Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 | Suche | FAQ

Hauptmenü
myCSharp.de
» Startseite
» Forum
» Suche
» Regeln
» Wie poste ich richtig?

Mitglieder
» Liste / Suche
» Wer ist online?

Ressourcen
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Microsoft Docs

Team
» Kontakt
» Cookies
» Spenden
» Datenschutz
» Impressum

  • »
  • Portal
  • |
  • Mitglieder
Beiträge von MadMax.2006
Thema: FastCMD - Konsolenprogramme oder Befehle parallel auf verschiedenen Servern ausführen
Am im Forum: .NET-Komponenten und C#-Snippets

Hi,

danke für die konstruktiven Anmerkungen.

Was den Quellcode angeht bin ich für Verbesserungsvorschläge empfänglich.
Es können natürlich auch Änderungen/Verbesserungen an dem Code vorgenommen und dann neu gepostet werden, hoffentlich.

Alles und jeder ist fehlbar. Nichts und niemand ist unfehlbar.

Gruß
Andreas

Thema: FastCMD - Konsolenprogramme oder Befehle parallel auf verschiedenen Servern ausführen
Am im Forum: .NET-Komponenten und C#-Snippets

Beschreibung:

Mit diesem Programm können Konsolenprogramme (CMD), oder Befehle parallel auf verschiedenen Servern ausgeführt werden. Minderst Voraussetzung ist eine "server.txt", mit zeilenweise Namen der Server im gleichen Verzeichnis und die Übergabe von dem Dateinamen der Batch, oder eines Befehls, das mehrfach ausgeführt werden soll.

Die Namen der Server werden bei einem Befehl als %%1 und bei Batchdateien als %1 übergeben.

Wenn das Programm läuft, legt es ein "tmp" - Verzeichnis an, in dem die Ausgaben (StdOut, StdErr) in eine Datei (Servernamen) geschrieben werden. Am Ende wird eine Datei erzeugt, mit Datum und Zeit erweitert, in der die Information aus allen Servern zusammen gefasst wird.

Die Hilfe wird wie üblich mit dem Parameter /? oder ohne Angabe von Parametern ausgegeben.


Hier noch die Anzeige der Hilfe:

Startet mehrere Prozesse gleichzeitig mittels Übergabe einer Liste von Server
und der optionalen Vorgabe der maximal gleichzeitig laufenden Prozesse.

Zusätzlich besteht die Möglichkeit vor dem ausführen der Prozesse, die
Erreichbarkeit der Server mittels PING zu ermitteln.

Die Ausgaben (stdOut/stdErr) werden in separaten Protokolldateien erfaßt und
anschließend in einer Protokolldatei zusammengefügt. Fehlermeldungen werden
zusätzlich als Information auf der Konsole ausgegeben.

Die Reihenfolge in der die Server in der Protokolldatei ausgegeben werden,
ist abhängig von der Geschwindigkeit mit der die Server antworten.

Der Name der Protokolldatei hat folgenden Syntax:

FastCMD dd.mm.yyyy hh-mm-ss.txt


Copyright 2014 by Andreas Potsch - Mail an [email protected]


Syntax: FastCmd [Befehl|Programm] [Server.txt] [pTIMEOUT] [maxAnzahl]

Befehl/Programm Befehl|Programm, der|daß mehrfach ausgeführt werden soll.

server.txt Eine Textdatei, in der die Servername zeilenweise angegeben
sind, die bei einem Befehl als %%1 und bei einem
Batch-Programm als %1 übergeben werden.
Wichtig!!! Servernamen dürfen nur einmal in der server.txt
vorhanden sein!!!

pTIMEOUT Mit diesem Parameters ist es möglich, vor dem ausführen
der Befehle|Programme ein PING auf den entsprechenden
Server auszuführen. Ist der PING erfolglos, dann wird
dies in die Protokolldatei eingetragen und zusätzlich in
der Konsole ausgegeben. Die Zahl nach dem Buchstaben legt
die Wartezeit (timeout) bis zur Antwort fest. Ist keine
Zahl angegeben, wird der Wert auf 1000ms festgelegt.
Der Parameter ist optional.

maxAnzahl Legt die maximale Anzahl der gleichzeitig ausgeführten
Befehle/Programme fest. Wird dieser Parameter nicht
vorgegeben, starten soviel Befehle/Programme gleichzeitig,
wie Server in der Liste vorhanden sind (maximal 999).
ACHTUNG!! Die Anzahl der gleichzeitig gestarteten Programme,
ist abhängig von dem zur Verfügung stehenden Speicher.
Der Parameter ist optional.


Beispiele:
FastCmd dir \\%%1\c$\Daten server.txt

FastCMD batch.cmd server.txt p5000 50

In der batch.cmd wird %1 als Platzhalter für den jeweiligen
Name des Server aus der server.txt übergeben.


Programm.cs

 
/*********************************************************************************************************
 *
 * Mit diesem (Consolen/CMD) Programm können mehrere Tasks gleichzeitigt ausgeführt werden.
 * Das Programm ist hauptsächlich für die Arbeit von Systemadministratoren unter dem
 * Betriebssystem Windows gedacht.
 * 
 * Voraussetzungen für das ausführen des Programms ist die Installation von DotNetFramwork 2.0
 * 
 * Hilfe bzw. Syntax ist durch Eingabe von "/?" oder Eingabe keiner/falscher Parameter zu erreichen.
 * Am Ende im Quelltext ist die Ausgabe des Hilfetextes als Funktion zu finden.
 * 
 * Fragen bzw. Anregungen können unter [email protected] gestellt werden.
 *
**********************************************************************************************************/

using System;
using System.IO;
using System.Text;
using System.Threading;
using System.Diagnostics;
using System.Collections.Generic;


namespace FastCmd
{
    class Program
    {
        // Zähler die aktuell laufenden Prozesse
        static int prozessRunning = 0;
        
        // Zähler die abgeschlossenen Prozesse
        static int prozessComplete = 0;

        // Zähler die bisher gestarteten Prozesse
        static int prozessStarted = 0;

        // gesamt Anzahl der auszuführenden Prozesse
        static int prozessesExecuted = 0;

        // nimmt den Retunwert der Prozesse auf
        static StringBuilder returnString = null;

        // Hauptprogramm starten
        static int Main(string[] args)
        {
            try
            {
                // Array für die Aufnahme der Server
                List<string> server = new List<string>();

                // Flag, ist Übergabe eine Datei oder ein Befehl
                bool isFile = false;

                // Flag, ist Ping angefordert
                bool isPing = false;

                // Timeout für Ping-Abfrabe. Default 1000ms
                int timeout = 1000;

                // Objekt für den Returnwert der Prozesse erstellen
                returnString = new StringBuilder("");

                // Anzahl der Maximal gleichzeitig ausgeführten Prozesse.
                // Wird durch die Anzahl der Server bzw. der vorgegebenen
                // Anzahl der Max. Prozesse angepaßt
                int MaxProzessCount = 999;

                // Hilfe ausgeben
                if (args.Length == 0)
                {
                    // Hilfe anzeigen
                    Help();
                    return 0;

                }

                // Hilfe ausgeben
                if (args[0] == "/?")
                {
                    // Hilfe anzeigen
                    Help();
                    return 0;

                }

                // wenn wenige als zwei Argumente übergeben werden
                if (args.Length < 2)
                {
                    Console.WriteLine("");
                    Console.WriteLine("");
                    Console.WriteLine("");
                    Console.WriteLine("");
                    Console.WriteLine("");
                    Console.WriteLine("  Bitte mindestens zwei Parameter angeben!");
                    Console.WriteLine("");

                    Help();
                    return 1;

                }

                // Prüfen ob Server.txt-Datei vorhanden ist
                if (!File.Exists(args[1]))
                {
                    Console.WriteLine("");
                    Console.WriteLine("");
                    Console.WriteLine("");
                    Console.WriteLine("");
                    Console.WriteLine("");
                    Console.WriteLine("  Serverdatei ist nicht vorhanden!!!");
                    Console.WriteLine("");

                    Help();
                    return 1;
                }

                // prüfen, ob ein drittes Argument vorhanden und eine Zahl oder ein Buchstabe ist
                if (args.Length > 2)
                {
                    // Ist in dem 3. Argument der Buchstabe "p" enthalten
                    if (args[2].ToLower().ToString().Contains("p") == true)
                    {
                        // ist das 3. Argument länger als ein Zeichen
                        if (args[2].Length > 1)
                        {
                            // Prüfen ob nach dem Buchstaben eine Zahl folgt
                            int num;
                            bool test = int.TryParse(args[2].Substring(1), out num);
                            if (test == true)
                            {
                                // ist die Zahl größer als 0
                                if (num > 0)
                                {
                                    // dann die Zahl für Ping-Timeout übernehmen
                                    timeout = num;
                                }
                                else
                                {
                                    Console.WriteLine("");
                                    Console.WriteLine("");
                                    Console.WriteLine("");
                                    Console.WriteLine("");
                                    Console.WriteLine("");
                                    Console.WriteLine("  Die Zahl nach 'p' muß größer als null sein!!!");
                                    Console.WriteLine("");

                                    Help();
                                    return 1;
                                }

                            }
                            else
                            {
                                Console.WriteLine("");
                                Console.WriteLine("");
                                Console.WriteLine("");
                                Console.WriteLine("");
                                Console.WriteLine("");
                                Console.WriteLine("  Nach dem Buchstaben 'p' muß eine Zahl erfolgen!!!");
                                Console.WriteLine("");

                                Help();
                                return 1;
                            }


                        }
                        // Ping ist angefordert
                        isPing = true;

                    }
                    // Ist das 3. Argument nur eine Zahl
                    else
                    {
                        int num;
                        bool test = int.TryParse(args[2], out num);
                        if (test == false)
                        {
                            Console.WriteLine("");
                            Console.WriteLine("");
                            Console.WriteLine("");
                            Console.WriteLine("");
                            Console.WriteLine("");
                            Console.WriteLine("  Bitte eine Zahl als dritten Parameter eingeben,");
                            Console.WriteLine("  oder mit dem Buchstaben 'p' beginnen lassen!!!");
                            Console.WriteLine("");

                            Help();
                            return 1;

                        }

                        // Beträgt die Zahl maximal 999
                        if (num ≥ 999)
                        {
                            Console.WriteLine("");
                            Console.WriteLine("");
                            Console.WriteLine("");
                            Console.WriteLine("");
                            Console.WriteLine("");
                            Console.WriteLine("  Bitte keine Zahl über 999 eingeben!!!");
                            Console.WriteLine("");

                            Help();
                            return 1;

                        }

                        // maximale Anzahl der gleichzeitigen laufenden Prozesse übernehmen
                        MaxProzessCount = num;

                    }

                }
                    
                // prüfen, ob ein vierte Argument vorhanden und eine Zahl ist
                if (args.Length > 3)
                {
                    int num;
                    bool test = int.TryParse(args[3], out num);
                    if (test == false)
                    {
                        Console.WriteLine("");
                        Console.WriteLine("");
                        Console.WriteLine("");
                        Console.WriteLine("");
                        Console.WriteLine("");
                        Console.WriteLine("  Bitte eine Zahl als vierten Parameter eingeben!!!");
                        Console.WriteLine("");

                        Help();
                        return 1;

                    }

                    // Beträgt die Zahl maximal 999
                    if (num ≥ 999)
                    {
                        Console.WriteLine("");
                        Console.WriteLine("");
                        Console.WriteLine("");
                        Console.WriteLine("");
                        Console.WriteLine("");
                        Console.WriteLine("  Bitte keine Zahl über 999 eingeben!!!");
                        Console.WriteLine("");

                        Help();
                        return 1;

                    }

                    // maximale Anzahl der gleichzeitigen laufenden Prozesse übernehmen
                    MaxProzessCount = num;

                }

                
                // Prüfen ob Befehl oder Batchdatei übergeben wurde
                if (File.Exists(args[0]))
                    isFile = true;

                // Objekt Stopuhr erstellen
                Stopwatch stopWatch = new Stopwatch();

                // Stopuhr starten
                stopWatch.Start();

                // Wenn tmp-Verzeichnis vorhanden ist
                if (Directory.Exists(Environment.CurrentDirectory + "\\tmp"))

                    // dann tmp-Verzeichnis löschen
                    Directory.Delete(Environment.CurrentDirectory + "\\tmp", true);

                // Neues tmp-Verzeichnis anlegen
                Directory.CreateDirectory(Environment.CurrentDirectory + "\\tmp");

                // Server aus der Serverdatei einlesen
                string line;
                StreamReader file = new StreamReader(args[1]);

                // Erste Zeile auslesen und überprüfen, ob sie Text enhält
                line = file.ReadLine().ToLower().Trim();
                if ((line == null) || (line == ""))
                {
                    Console.WriteLine("");
                    Console.WriteLine("");
                    Console.WriteLine("");
                    Console.WriteLine("");
                    Console.WriteLine("");
                    Console.WriteLine("  Keine Server in der Serverdatei vorhanden,");
                    Console.WriteLine("  oder die erste Zeile ist leer!!!");
                    Console.WriteLine("");

                    Help();
                    return 1;
                }
                else
                    // Server dem Array hinzufügen
                    server.Add(line);

                // Solange bis alle Zeilen ausgelesen sind
                while ((line = file.ReadLine().ToLower().Trim()) != null)
                {
                    // nur wenn die Zeile Text (Server) enthält
                    if (line != String.Empty)
                    {
                        // Ist der Server vorhanden
                        if (!server.Contains(line))
                        {
                            // nein, Server einfügen
                            server.Add(line);
                        }
                        else
                        {
                            // ja, Meldung ausgeben
                            Console.WriteLine("");
                            Console.WriteLine("");
                            Console.WriteLine("");
                            Console.WriteLine("");
                            Console.WriteLine("");
                            Console.WriteLine("  Servername: " + line.ToUpper() + " ist doppelt vorhanden!!!");
                            Console.WriteLine("");

                            Help();
                            return 1;

                        }

                    }

                }

                // die Anzal aller Prozesse für die Anzeige in der Konsole festlegen (showAktiviti)
                prozessesExecuted = server.Count;

                // Array vom Objekt NewProzess erstellen
                NewProzess[] prozessList = new NewProzess[server.Count];
                
                // Alle Server aus der Datei mit Befehl|Programm in das Array eintragen
                // und die Prozedur für das "Prozesscompleted"-Ereignis zuweisen
                for (int i = 0; i < server.Count; i++)
                {
                    prozessList[i] = new NewProzess(args[0], server[i], isFile, isPing, timeout);
                    prozessList[i].prozessCompleted += 
                        new NewProzess.ProzessCompletedDelegat(newProzess_completeProzess);

                }
                
                // Ist die maximale Anzahl der Server kleiner als die Anzahl der Server in der txt,
                // dann Anzahl der max. Prozesse auf Anzahl der Server anpassen
                if (prozessList.Length < MaxProzessCount)
                    MaxProzessCount = prozessList.Length;

                // Task für die dynamische Anzeige über Taskstatus in der Konsole
                Thread showActiviti = new Thread(new ThreadStart(StartActiviti));

                // Starte Task
                showActiviti.Start();

                // solange nicht alle Server abgearbeitet sind
                while (prozessComplete < server.Count)
                {
                    // Begrenzung der Max. gleichzeitig laufenden Prozesse überprüfen
                    if (prozessRunning < MaxProzessCount)
                    {
                        // ist das Ende der Anzahl der Prozesse erreicht
                        if (prozessStarted < prozessList.Length)
                        {
                            // Prozesse starten
                            prozessList[prozessStarted].StartProzess();

                            // Zähler für die Anzahl laufender Prozesse erhöhen
                            prozessRunning++;

                            // Zähler für die Anzahl der bisher gestarteten Prozesse erhöhen
                            prozessStarted++;
                        }

                    }

                }

                // Format für das Datum in der Protokolldatei
                DateTime time = DateTime.Now;
                string format = "dd.MM.yyyy HH-mm-ss";

                // Name der gesamt Protokolldatei wird gebildet
                string writeFileName = string.Format("{0}\\{1}.txt",
                    Environment.CurrentDirectory,
                    Process.GetCurrentProcess().ProcessName +
                    " " + time.ToString(format));

                // erstellen der gesamt Protokolldatei
                StreamWriter proFile = new StreamWriter(writeFileName);

                // Wenn Puffer voll ist, dann automatisch schreiben
                proFile.AutoFlush = true;
                
                // Alle Textdateien aus dem tmp-Verzeichnis zusammenfügen
                for (int i = 0; i < server.Count; i++)
                {
                    // nimmt den Inhalt der einzelnen Protokolldatei auf und erweitert sie um den Servernamen
                    string allLine = "####### " + server[i] +
                        " ###########################################################################" +
                        Environment.NewLine;

                    // nimmt den Namen der einzelnen Protokolldateinamen auf
                    string readFileName = String.Empty;

                    // Der Name der Protokolldatei im tmp wird gebildet
                    readFileName = string.Format("{0}\\tmp\\{1}.txt",
                        Environment.CurrentDirectory, server[i]);

                    // Prüfen ob die Protokolldatei existiert
                    if (File.Exists(readFileName))
                    {
                        // Öffnen der Protokolldatei
                        StreamReader resfile = new StreamReader(readFileName);

                        // Alle Zeilen auslesen
                        allLine += resfile.ReadToEnd();

                        // In Datei Schreiben
                        proFile.Write(allLine);

                        // Protokolldatei schließen
                        resfile.Close();
                    }
                    // Wenn keine Datei vorhanden ist
                    else
                    {
                        // In Datei Schreiben
                        proFile.Write(allLine);

                        proFile.WriteLine("");
                        proFile.WriteLine("!!! Ausgabedatei nicht vorhanden, oder kein Ping möglich !!!");
                        proFile.WriteLine("");
                    }

                }

                // Reste aus dem Puffer schreiben
                proFile.Flush();

                // Warten bis alles geschrieben ist
                Thread.Sleep(50);

                // Protokolldatei schließen
                proFile.Close();

                // Wenn keine Dateien im Verzeichnis existieren
                if(!File.Exists(Environment.CurrentDirectory + "\\tmp"))

                // dann tmp-Verzeichnis löschen
                    Directory.Delete(Environment.CurrentDirectory + "\\tmp", true);

                // Stopuhr stoppen
                stopWatch.Stop();

                // Zeitdifferenz auslesen
                TimeSpan ts = stopWatch.Elapsed;

                // Ausgabeformat für die Laufzeit festlegen
                string elapsedTime = String.Format("{0:D2}:{1:D2}.{2:D3}",
                    ts.Minutes, ts.Seconds,
                    ts.Milliseconds);

                // Wenn ein Fehler aufgetreten ist
                if (returnString.ToString() != "")
                {
                    // Leerzeile ausgeben
                    Console.WriteLine("");

                    // Fehlermeldung ausgeben
                    Console.WriteLine(returnString);
                }

                // Leerzeilen ausgeben
                Console.WriteLine("");
                Console.WriteLine("");

                // Ausgabe auf der Laufzeit in der Konsole
                Console.WriteLine("Laufzeit: " + elapsedTime);

                // Leerzeilen ausgeben
                Console.WriteLine("");
                Console.WriteLine("");
                Console.WriteLine("");

                return 0;
            }

            // Ausführen im Fehlerfall
            catch (Exception ex)
            {
                Console.WriteLine("");
                Console.WriteLine(ex.Message);
                Console.WriteLine(ex.ToString());
                Console.WriteLine("");

                return 1;
            }

        }

        // Funktion die bei dem Ereignis "Prozesscompleted" aufgerufen wird
        static void newProzess_completeProzess(object sender, prozessReturnArgs e)
        {
            try
            {
                // Zähler für die Anzahl der laufende Prozesse negieren
                prozessRunning--;

                // Anzahl der fertigen Prozesse erhöhen
                prozessComplete++;

                // Prüfen ob ein Fehler aufgetreten ist
                if (e.server != String.Empty)
                {
                    // ist Text in e.ErrMsg vorhanden
                    if (e.ErrMsg != String.Empty)
                    {
                        // Fehlermeldung anhängen
                        returnString.Append(Environment.NewLine +
                            "kein Ping möglich  -> " + e.server);
                    }
                    // ist kein Text in e.ErrMsg vorhanden
                    else
                    {
                        // Fehlermeldung anhängen
                        returnString.Append(Environment.NewLine +
                            "Fehler in Logdatei -> " + e.server);
                    }

                }

            }

            // Ausführen im Fehlerfall
            catch (Exception ex)
            {
                Console.WriteLine("");
                Console.WriteLine(ex.Message);
                Console.WriteLine("");
            }

        }

        // Anzeige der Aktivitäten in der Konsole
        static void StartActiviti()
        {
            try
            {
                // Zähler für die activeSymbol (Array)
                int counter = 0;

                // Zähler für die Verzögerungsschleife
                int delay = 0;

                // Das Flag zeigt an ob alle Prozesse beendet sind
                bool notCompeled = true;

                // Textinhalt der Ausgabezeile aller Aktivitäten
                string line = "";
                Console.WriteLine("");

                // Die "activeSymbol" - Zeichen, die angezeigt werden
                string[] activSymbol = new string[] { "|", "/", "-", "\\" };

                // solange nicht alle Prozesse abgearbeitet sind
                while (notCompeled)
                {
                    // Wenn noch nicht alle Prozesse abgearbeitet sind
                    if (prozessComplete != prozessesExecuted)
                    {
                        // Den aktuellen Status anzeigen mit activeSymbols
                        line = string.Format("Prozesse aktiv: {0,3} -> {1,3} Prozesse beendet ({2,3}%) {3}     \r",
                            prozessRunning,
                            prozessComplete,
                            prozessComplete * 100 / prozessesExecuted,
                            activSymbol[counter]);

                    }
                    // Wenn alle Prozesse abgearbeitet sind
                    else
                    {
                        // Den aktuellen Status (bei 100%) ohne activeSymbol anzeigen
                        line = string.Format("Prozesse aktiv: {0,3} -> {1,3} Prozesse beendet ({2,3}%)         \r",
                            prozessRunning,
                            prozessComplete,
                            prozessComplete * 100 / prozessesExecuted);

                        // Alle Prozesse abgearbeitet
                        notCompeled = false;

                    }

                    // Ausgabe aktueller Status
                    Console.Write(line);

                    // 5 ms warten
                    Thread.Sleep(5);

                    // Verzögerungsschleife
                    if (++delay > 5)
                    {
                        // Zähler zurücksetzen
                        delay = 0;

                        // Hochzählen der "activeSymbol" (Array)
                        if (++counter > activSymbol.Length - 1)

                            // Zähler für "actveSymbol" zurücksetzen
                            counter = 0;
                    }

                }

            }

            // Ausführen im Fehlerfall
            catch (Exception ex)
            {
                Console.WriteLine("");
                Console.WriteLine(ex.Message);
                Console.WriteLine("");
            }

        }

        // Inhalt der Hilfe
        static void Help()
        {
            Console.WriteLine("");
            Console.WriteLine("Startet mehrere Prozesse gleichzeitig mittels Übergabe einer Liste von Server");
            Console.WriteLine("und der optionalen Vorgabe der maximal gleichzeitig laufenden Prozesse.");
            Console.WriteLine("");
            Console.WriteLine("Zusätzlich besteht die Möglichkeit vor dem ausführen der Prozesse, die");
            Console.WriteLine("Erreichbarkeit der Server mittels PING zu ermitteln.");
            Console.WriteLine("");
            Console.WriteLine("Die Ausgaben (stdOut/stdErr) werden in separaten Protokolldateien erfaßt und");
            Console.WriteLine("anschließend in einer Protokolldatei zusammengefügt. Fehlermeldungen werden");
            Console.WriteLine("zusätzlich als Information auf der Konsole ausgegeben.");
            Console.WriteLine("");
            Console.WriteLine("Die Reihenfolge in der die Server in der Protokolldatei ausgegeben werden,");
            Console.WriteLine("ist abhängig von der Geschwindigkeit mit der die Server antworten.");
            Console.WriteLine("");
            Console.WriteLine("Der Name der Protokolldatei hat folgenden Syntax:");
            Console.WriteLine("");
            Console.WriteLine("      " + Process.GetCurrentProcess().ProcessName +
                                " dd.mm.yyyy hh-mm-ss.txt");
            Console.WriteLine("");
            Console.WriteLine("");
            Console.WriteLine("Copyright 2014 by Andreas Potsch - Mail an [email protected]");
            Console.WriteLine("");
            Console.WriteLine("");
            Console.WriteLine("");
            Console.WriteLine("Syntax:   FastCmd [Befehl|Programm] [Server.txt] [pTIMEOUT] [maxAnzahl]");
            Console.WriteLine("");
            Console.WriteLine(" Befehl/Programm  Befehl|Programm, der|daß mehrfach ausgeführt werden soll.");
            Console.WriteLine("");
            Console.WriteLine(" server.txt       Eine Textdatei, in der die Servername zeilenweise angegeben");
            Console.WriteLine("                  sind, die bei einem Befehl als %%1 und bei einem");
            Console.WriteLine("                  Batch-Programm als %1 übergeben werden.");
            Console.WriteLine("                  Wichtig!!! Servernamen dürfen nur einmal in der server.txt");
            Console.WriteLine("                  vorhanden sein!!!");
            Console.WriteLine("");
            Console.WriteLine(" pTIMEOUT         Mit diesem Parameters ist es möglich, vor dem ausführen");
            Console.WriteLine("                  der Befehle|Programme ein PING auf den entsprechenden");
            Console.WriteLine("                  Server auszuführen. Ist der PING erfolglos, dann wird");
            Console.WriteLine("                  dies in die Protokolldatei eingetragen und zusätzlich in");
            Console.WriteLine("                  der Konsole ausgegeben. Die Zahl nach dem Buchstaben legt");
            Console.WriteLine("                  die Wartezeit (timeout) bis zur Antwort fest. Ist keine");
            Console.WriteLine("                  Zahl angegeben, wird der Wert auf 1000ms festgelegt.");
            Console.WriteLine("                  Der Parameter ist optional.");
            Console.WriteLine("");
            Console.WriteLine(" maxAnzahl        Legt die maximale Anzahl der gleichzeitig ausgeführten");
            Console.WriteLine("                  Befehle/Programme fest. Wird dieser Parameter nicht");
            Console.WriteLine("                  vorgegeben, starten soviel Befehle/Programme gleichzeitig,");
            Console.WriteLine("                  wie Server in der Liste vorhanden sind (maximal 999).");
            Console.WriteLine("                  ACHTUNG!! Die Anzahl der gleichzeitig gestarteten Programme,");
            Console.WriteLine("                  ist abhängig von dem zur Verfügung stehenden Speicher.");
            Console.WriteLine("                  Der Parameter ist optional.");
            Console.WriteLine("");
            Console.WriteLine("");
            Console.WriteLine(" Beispiele:       " + Process.GetCurrentProcess().ProcessName +
                                                    " \"dir \\\\%%1\\c$\\Daten\" server.txt");
            Console.WriteLine("");
            Console.WriteLine("");
            Console.WriteLine("                  " + Process.GetCurrentProcess().ProcessName +
                                                    " batch.cmd server.txt p5000 50");
            Console.WriteLine("");
            Console.WriteLine("                  In der batch.cmd wird %1 als Platzhalter für den jeweiligen");
            Console.WriteLine("                  Name des Server aus der server.txt übergeben.");
            Console.WriteLine("");
            Console.WriteLine("");

        }

    }

}


NewProzess


/*********************************************************************************************************
 *
 * Diese Klasse stellt den Prozess dar, der die Befehle für einen Server ausgeführt.
 * 
 * Von dieser Klasse werden soviele Objekte erstellt, wie Server in der server.txt vohanden sind.
 * Jedes Objekt dieser Klasse wird in einem eigenen Thread ausgeführt und läuft quasi parallel.
 * 
**********************************************************************************************************/
using System;
using System.IO;
using System.Text;
using System.Threading;
using System.Diagnostics;

namespace FastCmd
{
    class NewProzess
    {
        // Delegat für die Ereignisfunktion
        public delegate void ProzessCompletedDelegat(object sender, prozessReturnArgs e);
        
        // Funktion die das Ereignis darstellt
        public event ProzessCompletedDelegat prozessCompleted;

        // Ojekt zum ausführen eines Prozesses erstellen
        private Process myProzess = new Process();

        // nimmt die Variable "arguments" aus dem Konstruktor auf
        private string arguments = String.Empty;

        // nimmt die Variable "fileName" aus dem Konstruktor auf
        private string fileName = String.Empty;

        // nimmt die Variable "ping" aus dem Konstruktor auf
        private bool isPing = false;

        // nimmt die Variable "timeout" aus dem Konstruktor auf
        private int timeout = 0;

        // nimmt den Stream von stdOutput auf
        private StringBuilder stdOutput = null;

        // Anzahl der durch StdOutput empfangenden Zeilen
        private int numOutputLines = 0;

        // zeigt an ob der Prozess fehlerhaft beendet wurde
        private string taskError = String.Empty;

        // enthält die Fehlermeldung
        private string msgError = String.Empty;

        // Objekt zur Aufnahme der Rückgabewerte (taskError, msgError)
        prozessReturnArgs args = new prozessReturnArgs();

        // Konstruktor für die Klasse mit Übergabe der Parameter
        public NewProzess(string fileName, string arguments, bool isFile, bool isPing, int timeout)
        {
            try
            {
                // Argumente an die globale Variable übergeben
                this.arguments = arguments;

                // Argumente an die globale Variable übergeben
                this.fileName = fileName;

                // Argumente an die globale Variable übergeben
                this.isPing = isPing;

                // Argumente an die globale Variable übergeben
                this.timeout = timeout;
                
                // Ereignisfunktion für StdOutput festlegen
                myProzess.OutputDataReceived += new DataReceivedEventHandler(myProzess_OutputDataReceived);

                // Ereignisfunktion für StdError festlegen
                myProzess.ErrorDataReceived += new DataReceivedEventHandler(myProzess_ErrorDataReceived);

                // Ist der Parameter "arguments" eine Datei
                if (isFile == true)
                {
                    // Programmname
                    myProzess.StartInfo.FileName = fileName;

                    // Programmargumente
                    myProzess.StartInfo.Arguments = arguments;
                }
                // Ist der Parameter "arguments" ein Befehl
                else
                {
                    // Programmname
                    myProzess.StartInfo.FileName = "cmd.exe";

                    // ist %1 in arguments enthalten
                    if (arguments.Contains("%1"))
                    {
                        // Der Platzhalter wird durch den Servernamen ersetzt
                        fileName = fileName.Replace("%1", arguments);
                    }

                    // Damit das Programm an Ende automatisch beendet wird
                    fileName = string.Format(" /c {0}", fileName);

                    // Programmargumente
                    myProzess.StartInfo.Arguments = fileName;

                }

                // Prozess ist nicht sichtbar 
                myProzess.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;

                // StdOutput und StdError empfangen
                myProzess.StartInfo.UseShellExecute = false;

                // StdOutput zulassen
                myProzess.StartInfo.RedirectStandardOutput = true;

                // StdError zulassen
                myProzess.StartInfo.RedirectStandardError = true;

            }

            // Fehlerbehandlung
            catch (Exception ex)
            {
                Console.WriteLine("");
                Console.WriteLine("Prozess: " + fileName + " Argumente: " + arguments);
                Console.WriteLine("");
                Console.WriteLine(ex.Message);
                Console.WriteLine("");
            }

        }

        // Wird ausgelöst, wenn Daten über StdError eingehen
        void myProzess_ErrorDataReceived(object sendingProzess, DataReceivedEventArgs e)
        {
            try
            {
                // wenn Daten von StdError verfügbar sind
                if (!String.IsNullOrEmpty(e.Data))
                {
                    // Zeile hochzählen, wenn Daten verfügbar sind
                    numOutputLines++;

                    // Text dem StringBuilder hinzufügen
                    stdOutput.Append(Environment.NewLine + "ERROR: " + e.Data);

                    // Festlegen, das ein Fehler aufgetreten ist
                    taskError = arguments;
                }

            }

            // Fehlerbehandlung
            catch (Exception ex)
            {
                Console.WriteLine("");
                Console.WriteLine("Prozess: " + fileName + " Argumente: " + arguments);
                Console.WriteLine("");
                Console.WriteLine(ex.Message);
                Console.WriteLine("");
            }

        }

        // Wird ausgelöst, wenn Daten über StdOutput eingehen
        void myProzess_OutputDataReceived(object sendingProzess, DataReceivedEventArgs e)
        {
            try
            {
                // wenn Daten von StdOutput verfügbar sind
                if (!String.IsNullOrEmpty(e.Data))
                {
                    // Zeile hochzählen, wenn Daten verfügbar sind
                    numOutputLines++;

                    // Text dem StringBuilder hinzufügen
                    stdOutput.Append(Environment.NewLine + e.Data);
                }

            }

            // Fehlerbehandlung
            catch (Exception ex)
            {
                Console.WriteLine("");
                Console.WriteLine("Prozess: " + fileName + " Argumente: " + arguments);
                Console.WriteLine("");
                Console.WriteLine(ex.Message);
                Console.WriteLine("");
            }

        }

        // Funktion zum starten des Prozesses in dem Objekt
        public void StartProzess()
        {
            try
            {
                // Thread erstellen
                Thread myThread = new Thread(new ThreadStart(StartTask));

                // Thread starten
                myThread.Start();
            }

            // Die Ausnahme wird ausgelöst, wenn ein NULL-Verweis an die Methode übergeben wird.
            catch (System.ArgumentNullException ex)
            {
                Console.WriteLine("");
                Console.WriteLine("Prozess: " + fileName + " Argumente: " + arguments);
                Console.WriteLine("");
                Console.WriteLine(ex.Message);
                Console.WriteLine("");
            }

            // Die Ausnahme wird ausgelöst, wenn nicht genügend Arbeitsspeicher zur Verfügung steht.
            catch (System.OutOfMemoryException ex)
            {
                Console.WriteLine("");
                Console.WriteLine("Prozess: " + fileName + " Argumente: " + arguments);
                Console.WriteLine("");
                Console.WriteLine(ex.Message);
                Console.WriteLine("");
            }

            // Die Ausnahme wird bei allen anderen Fehlern ausgelöst.
            catch (Exception ex)
            {
                Console.WriteLine("");
                Console.WriteLine("Prozess: " + fileName + " Argumente: " + arguments);
                Console.WriteLine("");
                Console.WriteLine(ex.Message);
                Console.WriteLine("");
            }

        }

        // eigenen Task für den Prozess starten
        private void StartTask()
        {
            try
            {
                // Objekt erstellen
                stdOutput = new StringBuilder("");

                // wird ein Ping angefordert
                if (isPing == true)
                {
                    // Ping Objekt erstellen und ausführen
                    PingIP ping = new PingIP(arguments, timeout);

                    // Konnte ein Ping erfolgreich empfangen werden
                    if (ping.result == true)
                    {
                        // den Prozess starten
                        myProzess.Start();

                        // Startet asynchrones lesen des Outputstreams
                        myProzess.BeginOutputReadLine();

                        // Startet asynchrones lesen des Errorstreams
                        myProzess.BeginErrorReadLine();

                        // warten bis der Prozess beendet ist, maximal 10 Minuten
                        myProzess.WaitForExit(600000);

                        // Sind Daten von StdOutput vorhanden, dann in Textdatei schreiben
                        if (numOutputLines > 0)
                        {
                            // Dateiname für die StdOutput Rückmeldung festlegen
                            string place = string.Format("{0}\\tmp\\{1}.txt", Environment.CurrentDirectory, arguments);

                            // Objekt für den Stream von StdOutput erzeugen
                            StreamWriter file = new StreamWriter(place);

                            // Leerzeilen hinzufügen
                            stdOutput.Append(Environment.NewLine + Environment.NewLine);

                            // StdOutput in Textdatei schreiben
                            file.Write(stdOutput);

                            // Reste aus dem Puffer schreiben
                            file.Flush();

                            // Warten bis alles geschrieben ist
                            Thread.Sleep(50);

                            // StreamWriter schließen
                            file.Close();

                        }

                    }
                    // Ping nicht erfolgreich gewesen
                    else
                    {
                        taskError = arguments;
                        msgError = "Server nicht erreichbar !!!";
                    }

                }
                // Es wird kein Ping angefordert
                else
                {
                    // den Prozess starten
                    myProzess.Start();

                    // Startet asynchrones lesen des Outputstreams
                    myProzess.BeginOutputReadLine();

                    // Startet asynchrones lesen des Errorstreams
                    myProzess.BeginErrorReadLine();

                    // warten bis der Prozess beendet ist
                    myProzess.WaitForExit();

                    // Sind Daten von StdOutput vorhanden, dann in Textdatei schreiben
                    if (numOutputLines > 0)
                    {
                        // Dateiname für die StdOutput Rückmeldung festlegen
                        string place = string.Format("{0}\\tmp\\{1}.txt", Environment.CurrentDirectory, arguments);

                        // Objekt für den Stream von StdOutput erzeugen
                        StreamWriter file = new StreamWriter(place);

                        // Leerzeilen hinzufügen
                        stdOutput.Append(Environment.NewLine + Environment.NewLine);

                        // StdOutput in Textdatei schreiben
                        file.Write(stdOutput);

                        // Reste aus dem Puffer schreiben
                        file.Flush();

                        // Warten bis alles geschrieben ist
                        Thread.Sleep(50);

                        // StreamWriter schließen
                        file.Close();

                    }

                }

                // Status wird als Argument übergeben
                args.server = taskError;

                // Fehlermeldung wird als Argument übergeben
                args.ErrMsg = msgError;

                // Prozess beendet, Ereignis auslösen
                OnEvent(args);

            }

            // Fehlerbehandlung
            catch (Exception ex)
            {
                Console.WriteLine("");
                Console.WriteLine("Prozess: " + fileName + " Argumente: " + arguments);
                Console.WriteLine("");
                Console.WriteLine(ex.Message);
                Console.WriteLine("");
            }

        }

        // Funktion löst das Ereigis "prozessCompleted" aus
        protected virtual void OnEvent(prozessReturnArgs e)
        {
            try
            {
                // Ereignisfunktion für StdOutput lösen
                myProzess.OutputDataReceived -= new DataReceivedEventHandler(myProzess_OutputDataReceived);

                // Ereignisfunktion für StdError lösen
                myProzess.ErrorDataReceived -= new DataReceivedEventHandler(myProzess_ErrorDataReceived);

                // sind Empfänger für das Ereignis vorhanden
                if (prozessCompleted != null)

                    // Ereignis auslösen
                    prozessCompleted(this, e);
            }

            // Fehlerbehandlung
            catch (Exception ex)
            {
                Console.WriteLine("");
                Console.WriteLine("Prozess: " + fileName + " Argumente: " + arguments);
                Console.WriteLine("");
                Console.WriteLine(ex.Message);
                Console.WriteLine("");
            }

        }
        
    }

    // Klasse für die Rückgabeparameter
    public class prozessReturnArgs : EventArgs
    {
        public string server { get; set; }
        public string ErrMsg { get; set; }
    }

}


PingIP.cs


/*********************************************************************************************************
 *
 * Diese Klasse stellt ein Objekt dar, welches ein Ping auf den übergebenen Servernamen ausführt.
 * 
 * Quelle:
 * http://msdn.microsoft.com/en-us/library/system.net.networkinformation.ping%28v=vs.80%29.aspx
 * 
**********************************************************************************************************/
using System;
using System.Net;
using System.Text;
using System.Threading;
using System.Net.NetworkInformation;


namespace FastCmd
{
    class PingIP
    {
        // Ergebnis der Ping-Abfrage 
        bool status = false;

        // Eigenschaft der Klasse, enthält das Ergebnis aus der Ping-Abfrage
        public bool result
        {
            get { return status; }
        }

        // Konstruktor mit übergabe der Servers und timeout
        public PingIP(string hostName, int timeout)
        {
            try
            {
                IPHostEntry host;
                IPAddress Adresse = null;

                // Die IP-Adresse des Servers wird abgefragt
                host = Dns.GetHostEntry(hostName);

                // Liste aller IP-Adressen durchlaufen
                foreach (IPAddress ip in host.AddressList)
                    Adresse = ip;

                AutoResetEvent waiter = new AutoResetEvent(false);

                Ping pingSender = new Ping();

                // When the PingCompleted event is raised,
                // the PingCompletedCallback method is called.
                pingSender.PingCompleted += new PingCompletedEventHandler(PingCompletedCallback);

                // Create a buffer of 32 bytes of data to be transmitted.
                string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
                byte[] buffer = Encoding.ASCII.GetBytes(data);

                // Set options for transmission:
                // The data can go through 64 gateways or routers
                // before it is destroyed, and the data packet
                // cannot be fragmented.
                PingOptions options = new PingOptions(64, true);

                // Send the ping asynchronously.
                // Use the waiter as the user token.
                // When the callback completes, it can wake up this thread.
                pingSender.SendAsync(Adresse, timeout, buffer, options, waiter);

                // Prevent this example application from ending.
                // A real application should do something useful
                // when possible.
                waiter.WaitOne();
            }

            // Fehlerbehandlung
            catch (Exception)
            {
                // Ping nicht erfolgreich
                status = false;
            }

        }

        public void PingCompletedCallback(object sender, PingCompletedEventArgs e)
        {
            // If the operation was canceled or an error occurred, generate a message to the user.
            if ((e.Cancelled)||(e.Error != null))
            {
                // Ping nicht erfolgreich
                status = false;

                // Let the main thread resume. 
                // UserToken is the AutoResetEvent object that the main thread 
                // is waiting for.
                ((AutoResetEvent)e.UserState).Set();

                return;
            }

            // Ping erfolgreich
            status = true;

            // Let the main thread resume.
            ((AutoResetEvent)e.UserState).Set();

        }

    }

}


Anregungen und Fragen können unter [email protected] gestellt werden.


Schlagwörter: FastCMD Admin Betriebsführung Multi Thread Parallel