INVITE DE COMMANDES DOS

package fr.julien.invite.execution;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import fr.julien.invite.ihm.OutPut;

/**
 * <b>Cette classe définis les fonctions d'exécution de commandes en dos</b>
 * 
 * <p>
 * Cette classe est définie par les informations suivantes
 * <ul>
 * <li>Une sortie standard</li>
 * <li>Une sortie en erreur</li>
 * </ul>
 * </p>
 * 
 * <p>
 * Cette classe dispose également de méthodes permettant d'exécuter
 * des commandes dos et de erdiriger les flux de sorties
 * </p>
 * 
 * @see fr.julien.invite.execution.IExecuteur
 * @see fr.julien.invite.ihm.OutPut
 * 
 * @author julien
 * @version 1.0
 *
 */
public class ExecuteurDos implements IExecuteur {

	/**
	 * L'unique instance du singleton
	 */
	private static final IExecuteur instance = new ExecuteurDos();

	/**
	 * La sortie standard, l'écran dans lequel seront affichés les
	 * résultats de la commande
	 * 
	 * @see fr.julien.invite.ihm.OutPut
	 */
	private OutPut sortieStandard;
	
	/**
	 * La sortie d'erreur, l'écran dans lequel seront affichées les
	 * erreurs générées par la commande
	 * 
	 * @see fr.julien.invite.ihm.OutPut
	 */
	private OutPut sortieErreur;


	/**
	 * Constructeur privé du singleton
	 */
	private ExecuteurDos() {
		super();
	}

	/**
	 * Cette procédure permet d'exécuter un ensemble de commandes séparés par des sauts de lignes
	 * @param commande
	 * 	Les commandes à exécuter
	 */
	public void executer(String commande){
		try {
			Runtime runtime = Runtime.getRuntime();
			for(String instruction : commande.split("\n")){
				final Process process = runtime.exec("cmd /c "+instruction);
				lancerRecuperationSortie(process.getInputStream(), sortieStandard);
				lancerRecuperationSortie(process.getErrorStream(), sortieErreur);
			}
		} 
		catch (IOException e) {
			e.printStackTrace();
		} 
	}
	
	/**
	 * Cette procédure permet de lancer la récupération des flux dans un thread distinct
	 * @param stream
	 * 	Le flux à récupérer
	 * @param destination
	 * 	La destination du flux
	 */
	private void lancerRecuperationSortie(final InputStream stream, final OutPut destination){
		new Thread() {
			public void run() {
				try {
					BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
					String line = "";
					try {
						while((line = reader.readLine()) != null) {
							destination.ajouter(line);
						}
					} finally {
						reader.close();
					}
				} catch(IOException ioe) {
					ioe.printStackTrace();
				}
			}
		}.start();
	}

	/**
	 * Accesseur à l'instance de l'exécuteur
	 * @return l'instance d'exécuteurDos
	 */
	public static IExecuteur getInstance() {
		return instance;
	}

	/**
	 * @param sortieStandard the sortieStandard to set
	 */
	public void setSortieStandard(OutPut sortieStandard) {
		this.sortieStandard = sortieStandard;
	}

	/**
	 * @param sortieErreur the sortieErreur to set
	 */
	public void setSortieErreur(OutPut sortieErreur) {
		this.sortieErreur = sortieErreur;
	}


}