Esempio n. 1
0
        /* Die Hauptfunktion / Main  vom backend NOC Portal */
        public static void Main()
        {
            Debuger debuger = new Debuger();

            debuger.routeErmitteln();       /* Roue Ordner Ermitteln */

            string      version            = "1.0";
            Einstellung einstellung        = new Einstellung();
            bool        status_einstellung = einstellung.laden();

            Protokoll protokoll    = new Protokoll();
            string    proto_gruppe = "main";


            AsciiPic asciipic = new AsciiPic();

            protokoll.erstellen(debuger.block(), proto_gruppe, "Noc Portal Backend Version " + version + " wird gestartet.  Auf Rechner: " + Environment.MachineName, debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), false);                   /* Protokoll erstellen */
            Console.WriteLine("----------------------------------------------------- \n");
            Console.WriteLine("-- Willkommen im NOC Portal Backend Version " + version + " -- \n");
            Console.WriteLine("----------------------------------------------------- \n\n");

            if (status_einstellung == true)
            {
                Console.WriteLine(" Tastenkombination:  \n");
                Console.WriteLine(" -> AltGr + C = Clary Thread ausschalten zur DB. ( es erfolgt kein neuer Durchlauf Aktueller wird noch abgearbeitet. )  \n");
                Console.WriteLine(" -> AltGr + B = Programm beenden.  \n\n");

                main_run();
            }
            else
            {
                protokoll.erstellen(debuger.block(), proto_gruppe, "Config Datei vom Server war fehlerhaft. Programm wurde abgebrochen.", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), true); /* Protokoll erstellen */
                Console.BackgroundColor = ConsoleColor.Magenta;                                                                                                                                                                              /* Hintergrund Farbe zuweisen */
                Console.ForegroundColor = ConsoleColor.Black;                                                                                                                                                                                /* Text Frabe zuweisen */
                Console.WriteLine("\n\n Fehler in der Config datei! Programm wurde abgebrochen. \n");
                Console.ResetColor();                                                                                                                                                                                                        /* auf Standart Farbzuweisung gehen zurückgehen */
            }

            Console.WriteLine("\n\n  Bitte nicht Ausschalten sichere Daten! Danke. \n\n");

            protokoll.erstellen(debuger.block(), proto_gruppe, "Noc Portal Backend Version " + version + " wurde beendet.  Auf Rechner: " + Environment.MachineName, debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), false);                  /* Protokoll erstellen */
            Thread protokoll_speicherung = new Thread(protokoll.rennen);

            protokoll_speicherung.Name         = "Ende_vom_Protokoll_Schreiben"; /* Thread Namen geben */
            protokoll_speicherung.Priority     = ThreadPriority.Highest;         /* Höchste Priorität vergeben was Thread hat */
            protokoll_speicherung.IsBackground = true;
            protokoll_speicherung.Start();
            protokoll.stop();
            protokoll_speicherung.Join();       /* Warte bis Protokolle gespeichert wurden */
            Console.WriteLine("\n----------------------------------------------------- \n");
            Console.WriteLine("--------  Daten wurden gesichert.-------------------- \n");
            Console.WriteLine("-------- NOC Portal Backend wurde Beendet!  --------- \n");
            Console.WriteLine("----------------------------------------------------- \n\n");
            Console.WriteLine(asciipic.computer());
        }
Esempio n. 2
0
        /*  Der eigentliche Thread */
        public void rennen_client()
        {
            PortZahler portzahler          = new PortZahler();
            bool       verbindung_zulassen = portzahler.kontrolle(max_verbindung, port, true);

            Text     text     = new Text();
            AsciiPic asciipic = new AsciiPic();

            /* Speziele regelung bei CFY Rohdaten empfang */
            if (this.port_bezeichnung == "cfy_rohdaten" && Clary.cfy_port_status != "leer")        /* Datensatz wird gerade noch bearbeitet Verbindung sollange sperren bis dieser abgearbeitet wurde */
            {
                verbindung_zulassen = false;
            }
            else
            {
            }

            if (verbindung_zulassen == true)
            {
                try
                {
                    protokoll.erstellen(debuger.block(), this.proto_gruppe, "TCP Kommunikation wird aufgebaut um Daten vom Client zu empfangen.", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), false);                   /* Protokoll erstellen */

                    Benutzer benutzer = new Benutzer();
                    port_stream = new List <PortPuffer>();

                    client_eingang = new Byte[256];               /* Länge vom Stream defienieren ( 256 byte lang )  */

                    /* Daten für nächsten durchlauf wieder leeren */
                    anmeldung     = string.Empty;
                    puffer_string = string.Empty;

                    NetworkStream stream = this.clientInstanz.GetStream();            /* Datenstrom vom Clienten holen und im Stream legen */

                    byte_lange = 0;                                                   /* Stream Wie lang dieser gefühlt ist max 256 byte */
                    while ((byte_lange = stream.Read(client_eingang, 0, client_eingang.Length)) != 0)
                    {                                                                 /* Unendlich Schleife - Es wird erst hier durchgelaufen  wenn stream.Read byte daten hat
                                                                                       *  ( Liefert int zahlen für Byte stellen belegt sind  )  bis max 256 Bit wie oben defieniert */
                        puffer_string = text.text_stream(client_eingang, byte_lange); /* client_eingang Byte Array  mit angabe der länge was befühlt ist in  UTF8 string Übersetzten */
                        puffer_string = text.steuerzeichen(puffer_string, "alle");

                        /* nur zu testzwecken  alles durchlassen Start */
                        //anmeldung = "ok";
                        /* nur zu testzwecken  alles durchlassen ende */

                        if (text.klein(puffer_string) == "exit")
                        {
                            protokoll.erstellen(debuger.block(), this.proto_gruppe, "Verbindung wurde beendet. ( exit wurde empfangen )", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), false);                  /* Protokoll erstellen */
                            client_antwort = text.byte_stream("Die Verbindung wurde beendet. Have a Nice Day :-) \n");
                            /* Info an Client senden */
                            stream.Write(client_antwort, 0, client_antwort.Length);
                            break;
                        }
                        else if (text.klein(puffer_string) == "hallo" && anmeldung != "ok")                                                                                                                                            /* Verbindung wird mit "hallo" inisialiesiert  Vorher reagiert Port auf Datenstrom nicht */
                        {
                            protokoll.erstellen(debuger.block(), this.proto_gruppe, "Benutzer wird aufgefordert Name einzugeben.", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), false); /* Protokoll erstellen */
                            client_antwort = text.byte_stream("Hallo Benutzer Bitte gebe deinen Namen ein.\n");
                            anmeldung      = "name";
                            /* Info an Client senden */
                            stream.Write(client_antwort, 0, client_antwort.Length);
                        }
                        else if (anmeldung == "name")  /* Dann wird Benutzername geprüft */
                        {
                            if (benutzer.liste(text.klein(puffer_string), "", "name"))
                            {
                                benutzername = puffer_string;
                                protokoll.erstellen(debuger.block(), this.proto_gruppe, "Benutzer wird aufgefordert Name einzugeben.", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), false);                     /* Protokoll erstellen */
                                client_antwort = text.byte_stream("Bitte gebe dein Password ein.\n");
                                anmeldung      = "password";
                            }
                            else
                            {
                                protokoll.erstellen(debuger.block(), this.proto_gruppe, "Benutzer " + benutzername + " wurde nicht gefunden.", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), true);             /* Protokoll erstellen */
                                client_antwort = text.byte_stream("Benutzername wurde nicht gefunden Bitte Neu eingeben!\n");
                            }

                            /* Info an Client senden */
                            stream.Write(client_antwort, 0, client_antwort.Length);
                        }
                        else if (anmeldung == "password")  /* Wenn Benutzername OK ist Wird nach Password geprüft */
                        {
                            if (benutzer.liste(text.klein(benutzername), text.klein(puffer_string)))
                            {
                                protokoll.erstellen(debuger.block(), this.proto_gruppe, "Benutzer " + benutzername + " wurde erfolgreich angemeldet. Warte auf Datenempfang.", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), false);                   /* Protokoll erstellen */
                                client_antwort = text.byte_stream("Willkommen im NOC Portal Backend. Ich warte jetzt auf Daten.\n");
                                anmeldung      = "ok";
                            }
                            else
                            {
                                protokoll.erstellen(debuger.block(), this.proto_gruppe, "Benutzer " + benutzername + " hat Fehlerhaftes Password eingetragen.", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), true);             /* Protokoll erstellen */
                                client_antwort = text.byte_stream("Dein Password war Fehlerhaft. Bitte Neu eingeben!\n");
                            }

                            /* Info an Client senden */
                            stream.Write(client_antwort, 0, client_antwort.Length);
                        }
                        else if (anmeldung == "ok")  /* Anmeldung war OK Datenstrom empfangen und in MSStream legen als bitstrom */
                        {
                            if (this.port_bezeichnung == "cfy_rohdaten")
                            {                                       /* CFY status nur ändern wenn Mit Port für CFY_Rohdaten gesprochen wird */
                                Clary.cfy_port_status = "empfange"; /* Clary Status auf empfangn setzen und Sperren zur weiterverarbeitung */
                            }
                            else
                            {
                            }

                            /*  Empfangene byte aus Stream in List legen und Sammeln bis zum ende des Emfangs */
                            byte[] daten_wei = (byte[])client_eingang.Clone();      /* Byte Array Klonen für Speicherung im List Objekt */
                            port_stream.Add(new PortPuffer(daten_wei, byte_lange)); /*  geklontes Byte in List legen */
                        }
                        else
                        {
                        }
                    }

                    this.clientInstanz.Close();                                                                                                                                                                  /* Verbindung wurde getrennt */
                    protokoll.erstellen(debuger.block(), this.proto_gruppe, "TCP Verbindung wurde beendet.", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), false); /* Protokoll erstellen */


                    /*  Datenstrom Bauen und in einem String legen -- Start -- */
                    protokoll.erstellen(debuger.block(), this.proto_gruppe, "Baue Datenstrom zum weiter Verarbeiten.", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), false); /* Protokoll erstellen */
                    komplett_byte = 0;
                    foreach (PortPuffer byte_daten in port_stream)                                                                                                                                                         /* Byte stream Länge ermitteln */
                    {
                        komplett_byte += byte_daten.bitpuffer.Length;
                    }

                    memstream = new MemoryStream(new byte[komplett_byte], 0, komplett_byte, true, true);
                    foreach (PortPuffer byte_daten in port_stream)                      /* Byte Pakete aus List holen und im MemoryStream zusammenfügen */
                    {
                        memstream.Write(byte_daten.bitpuffer, 0, byte_daten.bytelange);
                    }

                    komplett_byte_stream = memstream.GetBuffer();  /* Byte vom stream zusammenfügen und  in ein Gesamtes Array Byte legen  */


                    protokoll.erstellen(debuger.block(), this.proto_gruppe, "Erstelle Daten String aus Datenstrom.", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), false);              /* Protokoll erstellen */

                    puffer_string = string.Empty;
                    puffer_string = text.text_stream(komplett_byte_stream, komplett_byte_stream.Length);      /* client_eingang Byte Array  mit angabe der länge was befühlt ist in  UTF8 string Übersetzten */
                    puffer_string = text.steuerzeichen(puffer_string, "alle");
                    /*  Datenstrom Bauen und in einem String legen -- Ende -- */

                    /* Protokoll vom Client aus dem Text Strem holen und in eigenes Protokoll Schreiben */
                    string[] proto_client = text.split("|Protokoll|", puffer_string);
                    if (proto_client.Length > 0)                                            /* Schutz das auch Protokolle da sind */
                    {
                        puffer_string = proto_client[0];                                    /* Eigentliche Daten zum Weiterverarbeiten in Variable wieder legen ( Liegen immer vor Protokoll )  */

                        string[] proto_client_zeilen = text.split("|tr|", proto_client[1]); /* Protokolle Zeilen ermitteln */
                        //bool fehler_client;
                        foreach (string proto_daten in proto_client_zeilen)
                        {   /* in dieser schleife werden die Protokolle übernohmen auf dem Server */
                            try
                            { string[] proto_inhalt = text.split("|td|", proto_daten);
                              //if(proto_inhalt[6] == "ja")fehler_client = true; else fehler_client = false;
                              //protokoll.erstellen( proto_inhalt[0] , proto_inhalt[1] , proto_inhalt[2] , proto_inhalt[3] ,proto_inhalt[4],proto_inhalt[5] , fehler_client , 0 );
                            }
                            catch (IndexOutOfRangeException e)
                            {
                                protokoll.erstellen(debuger.block(), this.proto_gruppe, "Client Protokoll Schreiben Fehler: " + e.Message, debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), true);                       /* Protokoll erstellen */
                            }
                        }
                    }
                    else
                    {
                    }


                    if (this.port_bezeichnung == "cfy_rohdaten")
                    {                                                                                                                                                                                                             /* CFY status nur ändern wenn Mit Port für CFY_Rohdaten gesprochen wird */
                        protokoll.erstellen(debuger.block(), this.proto_gruppe, "Daten werden an CFY Datenimport Übergeben.", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), false); /* Protokoll erstellen */
                        Clary clary = new Clary();
                        Clary.cfy_port_gruppe = this.proto_gruppe;
                        clary.rohdaten(puffer_string);
                    }
                    else
                    {
                    }
                }
                catch (ThreadAbortException)   /* Thread wird von der Main aus sofort abgebrochen - Programm wurde beendet */
                { protokoll.erstellen(debuger.block(), this.proto_gruppe, "Thread wurde von der Main sofort Beendet. ( .Abort() )", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), false); /* Protokoll erstellen */ }
                catch (System.IO.IOException e)
                { protokoll.erstellen(debuger.block(), this.proto_gruppe, "Client hat Verbindung beendet. Info: " + e.Message, debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), false); /* Protokoll erstellen */ }
                catch (SocketException e)
                { protokoll.erstellen(debuger.block(), this.proto_gruppe, "SocketException wurde gewurfen Verbindung wurde getrennt. Fehler: " + e.Message, debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), true); /* Protokoll erstellen */ }

                protokoll.erstellen(debuger.block(), this.proto_gruppe, "Gebe TCP Verbindung wieder frei.", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), false); /* Protokoll erstellen */
                portzahler.kontrolle(max_verbindung, port, false);                                                                                                                                              /* Verbindung wieder Frei geben */
            }
            else
            {                                                          /* Maximale Verbindung für Port wurden festgestellt oder CFY DatenImport wird noch bearbeitet im System */
                NetworkStream stream = this.clientInstanz.GetStream(); /* Datenstrom vom Clienten holen und im Stream legen */

                /* Speziele regelung für CFY Rohdaten empfangen */
                if (this.port_bezeichnung == "cfy_rohdaten" && Clary.cfy_port_status != "leer")
                {
                    protokoll.erstellen(debuger.block(), this.proto_gruppe, "CFY Rohdaten werden gerade im System Verarbeitet. Neue Verbindung wurde abgelehnt.", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), true);                        /* Protokoll erstellen */
                    client_antwort = text.byte_stream(" Achutung CFY Rohdaten Import wird gerade gerade im System verarbeitet. \n Neue Verbindung wurde abgebrochen. \n Bitte versuchen Sie es später noch einmal. \n");
                }
                else
                {
                    protokoll.erstellen(debuger.block(), this.proto_gruppe, "Verbindung wurde abgebrochen Maximale Verbindungen ist erreicht.", debuger.klasse(), debuger.path(), debuger.dateiName(), debuger.funktion(), debuger.zeile(), true);                    /* Protokoll erstellen */
                    client_antwort = text.byte_stream(" Achtung es sind keine Verbindungen mehr Frei! Es wurde abgebrochen! \n Bitte versuchen Sie es später noch einmal. \n");
                }

                /* Info an Client senden */
                stream.Write(client_antwort, 0, client_antwort.Length);

                Thread.Sleep(2000);         /* zwei Secunden warten und Verbindung dann  beenden */
                this.clientInstanz.Close(); /* Verbindung wurde getrennt */
            }
        }