Esempio n. 1
0
        /// <summary>
        /// tworzenie xml i takie tam ich testowanie
        ///
        /// </summary>
        public static void TestXML()
        {
            //subnetowork content

            //klijenci
            XMLeon client1 = new XMLeon("subclient.xml", XMLeon.Type.clients);

            client1.AddClient(1, "127.0.0.1", 9111);
            client1.AddClient(2, "127.0.0.2", 9211);
            client1.AddClient(3, "127.0.0.3", 9326);
            client1.AddClient(4, "127.0.0.4", 9426);

            //linki
            XMLeon linksgen = new XMLeon("sub1links.xml", XMLeon.Type.cable_cloud);

            linksgen.AddLink(9111, 81, 2, 9111, 1191, "on", 1, 14);
            linksgen.AddLink(9211, 82, 2, 9211, 1191, "on", 1, 14);
            linksgen.AddLink(2693, 5, 83, 2693, 9326, "on", 1, 14);
            linksgen.AddLink(2694, 5, 84, 2694, 9426, "on", 1, 14);

            linksgen.AddLink(1415, 2, 3, 1415, 1514, "on", 1, 14);
            linksgen.AddLink(1419, 2, 4, 1419, 1914, "on", 1, 14);
            linksgen.AddLink(1823, 3, 5, 1823, 2318, "on", 1, 14);
            linksgen.AddLink(2223, 4, 5, 2223, 2322, "on", 1, 14);

            linksgen = new XMLeon("sub2links.xml", XMLeon.Type.cable_cloud);
            linksgen.AddLink(1112, 1, 2, "on", 1, 14);
            linksgen.AddLink(1113, 1, 3, "on", 1, 14);
            linksgen.AddLink(1214, 2, 4, "on", 1, 14);
            linksgen.AddLink(1314, 3, 4, "on", 1, 14);

            linksgen = new XMLeon("sub3links.xml", XMLeon.Type.cable_cloud);
            linksgen.AddLink(1516, 5, 6, "on", 1, 14);
            linksgen.AddLink(1517, 5, 7, "on", 1, 14);
            linksgen.AddLink(1618, 6, 8, "on", 1, 14);
            linksgen.AddLink(1718, 7, 8, "on", 1, 14);

            linksgen = new XMLeon("sub4links.xml", XMLeon.Type.cable_cloud);
            linksgen.AddLink(1920, 9, 10, "on", 1, 14);
            linksgen.AddLink(1921, 9, 11, "on", 1, 14);
            linksgen.AddLink(2022, 10, 12, "on", 1, 14);
            linksgen.AddLink(2122, 11, 12, "on", 1, 14);

            linksgen = new XMLeon("sub5links.xml", XMLeon.Type.cable_cloud);
            linksgen.AddLink(2324, 13, 14, "on", 1, 14);
            linksgen.AddLink(2325, 13, 15, "on", 1, 14);
            linksgen.AddLink(2426, 14, 16, "on", 1, 14);
            linksgen.AddLink(2526, 15, 16, "on", 1, 14);

            XMLeonSubnetwork sub = new XMLeonSubnetwork("subnetwork1.xml", "subclient.xml", "sub1links.xml");

            sub.AddSubnetwork(2, "", "sub2links.xml");
            sub.AddSubnetwork(3, "", "sub3links.xml");
            sub.AddSubnetwork(4, "", "sub4links.xml");
            sub.AddSubnetwork(5, "", "sub5links.xml");
            //end of subnetwork content


            XMLeon client = new XMLeon("client.xml", XMLeon.Type.clients);

            client.AddClient(1, "127.0.0.1", 9111);
            client.AddClient(2, "127.0.0.2", 9211);
            client.AddClient(3, "127.0.0.3", 9321);
            client.AddClient(4, "127.0.0.4", 9421);
            client.AddClient(5, "127.0.0.1", 11);
            client.AddClient(6, "111", 33);
            // client.RemoveClient(3);



            XMLeon nodes = new XMLeon("nodes.xml", XMLeon.Type.nodes);

            nodes.AddNode(1, "111", "3333");
            nodes.AddNode(2, "111", "3333");
            nodes.AddNode(3, "111", "3333");

            nodes.AddNode(4, "111", "3333");
            nodes.AddNode(5, "111e", "3333");
            nodes.AddNode(6, "11q1", "3333");
            nodes.AddNode(7, "11p1", "3333");
            nodes.RemoveNode(3);

            nodes.AddMatrix(3, 2);
            nodes.AddMatrix(3, 4);
            nodes.AddMatrix(11, 1);
            nodes.AddMatrix(13, 2);
            nodes.AddMatrix(23, 2);
            nodes.AddMatrix(3, 5);
            nodes.AddMatrix(23, 6);
            nodes.AddMatrix(93, 2);
            nodes.AddMatrix(31, 1);
            nodes.AddMatrix(3, 1);


            nodes.RemoveConnection(2, 13, 2);
            nodes.RemoveConnection(1, 11, 2);

            XMLeon links = new XMLeon("links.xml", XMLeon.Type.cable_cloud);

            links.AddLink(9111, 81, 1, "on", 1, 14);
            links.AddLink(9211, 82, 1, "on", 1, 14);

            links.AddLink(1112, 1, 2, "on", 1, 14);
            links.AddLink(1114, 1, 4, "on", 22, 14);

            links.AddLink(1215, 2, 5, "on", 22, 14);
            links.AddLink(1213, 2, 3, "on", 1, 14);

            links.AddLink(1316, 3, 6, "on", 1, 14);
            links.AddLink(1314, 3, 4, "on", 19, 14);

            links.AddLink(1417, 4, 7, "on", 22, 14);
            links.AddLink(1411, 4, 1, "on", 1, 14);

            links.AddLink(1516, 5, 6, "on", 22, 14);
            links.AddLink(1518, 5, 8, "on", 1, 14);

            links.AddLink(1617, 6, 7, "on", 22, 14);
            links.AddLink(1615, 6, 5, "on", 1, 14);

            links.AddLink(1719, 7, 9, "on", 22, 14);

            links.AddLink(1819, 8, 9, "on", 22, 14);

            links.AddLink(1920, 9, 10, "on", 22, 14);

            links.AddLink(2093, 10, 83, "on", 22, 14);
            links.AddLink(2094, 10, 84, "on", 22, 14);


            // links.AddLink(9111, 81, 1, "on", 22, 14);
            //links.AddLink(1112, 1, 2, "on", 22, 14);
            // links.AddLink(1213, 2, 3, "on", 22, 14);
            // links.AddLink(1392, 2, 82, "on", 22, 14);

            /* links.AddLink(1191, 1, 81, "on", 22, 14);
             * links.AddLink(1211, 2, 1, "on", 22, 14);
             * links.AddLink(1312, 3, 2, "on", 22, 14);
             * links.AddLink(9213, 82, 3, "on", 22, 14);*/
            // links.RemoveLink(1115);
            //  links.ChangeLinkStatus(1112, "off");

            XMLParser test = new XMLParser("nodes.xml");
            //test.GetNodePorts(2);

            XMLParser test1 = new XMLParser("links.xml");
            //  test1.GetLinks();



            List <Link> linksList = test1.GetLinks();
            List <Node> nodesList = new List <Node>();

            nodesList.Add(new Node(81));
            nodesList.Add(new Node(82));
            nodesList.Add(new Node(83));
            nodesList.Add(new Node(84));
            nodesList.Add(new Node(1));
            nodesList.Add(new Node(2));
            nodesList.Add(new Node(3));
            nodesList.Add(new Node(4));
            nodesList.Add(new Node(5));
            nodesList.Add(new Node(6));
            nodesList.Add(new Node(7));
            nodesList.Add(new Node(8));
            nodesList.Add(new Node(9));
            nodesList.Add(new Node(10));
            nodesList.Add(new Node(11));

            // PathAlgorithm.dijkstra(nodesList, linksList, 81, 83, false);
            Console.WriteLine("qqqqqqqqqqqqqqq");
            PathAlgorithm.dijkstra(nodesList, linksList, 81, 84, false);
            Console.WriteLine("qqqqqqqqqqqqqqq");

            PathAlgorithm.dijkstra(nodesList, linksList, 82, 83, false);


            for (int i = 0; i < 14; i++)
            {
                Console.WriteLine(linksList[2].usedSlots[i]);
            }

            Console.Read();
        }
Esempio n. 2
0
        /// <summary>
        /// funkcja uruchamiana wtedy gdy padnie jakis wezel
        /// </summary>
        /// <param name="id">numer noda ktory padl</param>
        internal static void NodeIsDead(int id)
        {
            var toReconfigure = Program.paths.FindAll(x => x.nodes.Contains(x.nodes.Find(y => y.number == id)));

            //czyszczenie zajetych zasobow
            foreach (Path path in toReconfigure)
            {
                path.ResetSlotReservation();
                SendNodesToDeleteConnection(path);
                //   Console.WriteLine("FIRST TRYInput port " + path.nodes.Last().inputLink.portIn + " Output port " + path.nodes.First().outputLink.portOut);
                // Console.WriteLine(path.xmlName);
            }

            Console.Write(DateTime.Now.ToString("HH:mm:ss") + " : ");
            Console.WriteLine("Posprzątane po awarii");

            foreach (Path path in toReconfigure)
            {
                lock (Program.nodes)
                {
                    lock (Program.links)
                    {
                        SwitchingActions.pathToCount = PathAlgorithm.dijkstra(Program.nodes, Program.links, path.nodes.Last().number, path.nodes.First().number, false);
                    }
                }
                if (!SwitchingActions.pathToCount.endToEnd)
                {
                    lock (agentCollection)
                    {
                        agentCollection.Add("<error>" + path.globalID + "</error>");
                    }
                    Console.WriteLine("Nie mozna ustawić innej ścieżki zapasowej w tej podsieci");
                }

                else
                {
                    //tu dodajemy do sciezki port na ktorej mamy z niej wyjechac i na ktory mamy wjechac
                    Link inPort  = path.nodes.Last().inputLink;
                    Link outPort = path.nodes.First().outputLink;
                    SwitchingActions.pathToCount.nodes.First().outputLink = outPort;
                    SwitchingActions.pathToCount.nodes.Last().inputLink   = inPort;

                    SwitchingActions.pathToCount.globalID = path.globalID;

                    Console.WriteLine("Input port " + inPort.portIn + " Output port  " + outPort.portOut);

                    Console.WriteLine("Start SLot: " + path.startSlot + " endSlot:" + path.endSlot);

                    //sprawdzamy czy mamy takie okno na tej sciezce jakie potrzebowalismy na starej
                    //tu moze cos byc namieszane ze slotami
                    //plus jeden proba bo np od 1 do 2 znajduja sie 2 liczby, a nie 2-1=1
                    if (SwitchingActions.pathToCount.IsReservingWindowPossible(path.endSlot - path.startSlot + 1, path.startSlot))
                    {
                        //tu plus jeden bo ta walona indeksacja
                        ReserveRequest(path.startSlot, path.endSlot - path.startSlot + 1);
                        Program.paths.Remove(Program.paths.Find(x => x == path));
                        Program.paths.Add(SwitchingActions.pathToCount);
                    }
                    else
                    {
                        Console.Write(DateTime.Now.ToString("HH:mm:ss") + " : ");
                        Console.WriteLine("Brakuje szczelin, by zestawić połączenie");

                        //wysylanie do agenta wiadomosci ze sie nie udalo
                        lock (agentCollection)
                        {
                            agentCollection.Add("<error>" + path.globalID + "</error>");
                        }

                        lock (Program.paths)
                        {
                            try
                            {
                                //jezeli nie udalo sie zestawic polaczenia to jest ono wywalane z listy polaczen
                                Program.paths.Remove(Program.paths.Find(x => x == path));
                            }
                            catch
                            {
                                Console.Write(DateTime.Now.ToString("HH:mm:ss") + " : ");
                                Console.WriteLine("Nie udało się usunąć ścieżki");
                            }
                        }
                    }
                }
            }
        }
Esempio n. 3
0
        /// <summary>
        /// przelaczanie tego co ma zrobic manager
        /// w zaleznosci co do niego doszlo
        /// </summary>
        /// <param name="message"></param>
        /// <param name="manager"></param>
        internal static void Action(string message, Manager manager)
        {
            //jezeli ma zostac polaczenie w podsieci czyl
            if (message.Contains("subconection"))
            {
                Console.Write(DateTime.Now.ToString("HH:mm:ss") + " : ");
                Console.WriteLine("Prośba o zestawienie połączenia w podsieci");
            }
            //ta wiadomosc moze przyjsc tylko do glownego managera
            //poniewaz do tych mniejszych zakladamy ze nie moga byc podlaczeni klijenci
            else if (message.Contains("connection:"))
            {
                //zerujemy licznik
                messageCounterPossibleWindow      = 0;
                messageCounterPossibleReservation = 0;

                //data[0] = askingClient;
                //data[1] = targetClient;
                data = GetStartAndEndNode(message);

                lock (Program.nodes)
                {
                    lock (Program.links)
                    {
                        pathToCount = PathAlgorithm.dijkstra(Program.nodes, Program.links, data[0] + 80, data[1] + 80, false);
                    }
                }
                SendToSubnetworks(pathToCount);
            }
            //klijent prosi o usuniecie podsieci
            else if (message.Contains("delete"))
            {
                data = GetStartAndEndNode(message);
                string pathId = (data[0] + 80).ToString() + (data[1] + 80).ToString();
                pathToCount = Program.paths.Find(x => x.id == pathId);
                SendSubToDeleteConnection(pathToCount);
                pathToCount.ResetSlotReservation();
                lock (Program.paths)
                {
                    Program.paths.Remove(pathToCount);
                }
            }
            //gdy dostaje z podesieci wiadomosc jak dluga jest droga w podsieci
            //info jest potrzebne do wyliczenia ile slotow potrzebujemy
            else if (message.Contains("lenght"))
            {
                int lenght = GetLenght(message);
                pathToCount.lenght += lenght;
            }
            else if (message.Contains("possible_window"))
            {
                pathToCount.ChangeWindow(possibleWindow);
                messageCounterPossibleWindow++;

                //jezeli jest to najwyza sciezka i doszly juz wszystkie wiadomosci
                //minus 2 jest, bo na samej gorze sa jeszcze klijenci ich nie uwzgledniamy
                if (Program.isTheTopSub && messageCounterPossibleWindow == pathToCount.nodes.Count - 2)
                {
                    amountOfSlots = PathAlgorithm.AmountNeededSlots(pathToCount.lenght);
                    //returnWindow= new int[2] {startSlot,maxWindow };
                    window = pathToCount.FindMaxWindow();

                    bool isReservationPossible = pathToCount.IsReservingWindowPossible(amountOfSlots, window[0]);

                    if (isReservationPossible)
                    {
                        SendAskIfReservationIsPossible(window[0], amountOfSlots);
                    }
                    //to trzeba zrobic jakies inne polecania na zestawianie sciezko na okolo
                    else
                    {
                        //znaczy to ze w tym miejscu sie nie udalo zrobic rekonfiguracji
                        reconfigured = true;
                        Console.Write(DateTime.Now.ToString("HH:mm:ss") + " : ");
                        Console.WriteLine("Nie można zestawić ścieżki");
                    }
                }
            }

            else if (message.Contains("possible_path"))
            {
                messageCounterPossibleReservation++;
                //jezeli jest na samym szczycie by wyslal nizej zadnia
                //minus dwa bo nie uwzgledniamu klientow
                //jezeli licznik wybil ze u wszystkich mozliwa jest rezerwacja okna to rozsylane jest prosba, by zarezerwowali to okno
                if (messageCounterPossibleReservation == pathToCount.nodes.Count - 2 && Program.isTheTopSub == true)
                {
                    pathToCount.ReserveWindow(amountOfSlots, window[0]);

                    SendSubToReserveWindow(window[0], amountOfSlots);
                    //data[1] target client
                    if (reconfigured == true)
                    {
                        SendClientsToReserveWindow(window[0], data[1]);
                    }

                    XMLeon xml = new XMLeon("path" + data[0] + data[1] + ".xml", XMLeon.Type.nodes);
                    pathToCount.xmlName = "path" + data[0] + data[1] + ".xml";
                    xml.CreatePathXML(pathToCount);

                    //dodawania sciezki do listy sciezek
                    lock (Program.paths)
                    {
                        Program.paths.Add(pathToCount);
                    }

                    //jak jest przypadek z rekonfiguracja, gdy sie uda
                    if (reconfigured == false)
                    {
                        reconfigured = true;
                        //zmniejszanie liczby sciezek jakie pozostaly jeszcze do zrekonfigurowania
                        toReconfigure--;
                        //rozeslanie informacji do klijenta wysylajacego o zmianie sciezki
                        var targetClient = SwitchingActions.pathToCount.nodes.First().number - 80;
                        var message1     = "replace:<start_slot>" + SwitchingActions.pathToCount.startSlot + "</start_slot><target_client>" + targetClient + "</target_client>";

                        try
                        {
                            Program.managerClient[SwitchingActions.pathToCount.nodes.Last().number - 80 - 1].Send(message1);
                        }
                        catch (Exception ex)
                        {
                            Console.Write(DateTime.Now.ToString("HH:mm:ss") + " : ");
                            Console.WriteLine("Nie udało się wysłać ścieżki do klienta, ex: " + ex.ToString());
                        }
                    }

                    Console.Write(DateTime.Now.ToString("HH:mm:ss") + " : ");
                    Console.WriteLine("Zestawianie ścieżki się powiodło");
                }
            }
            //jezeli zepsula sie podsiec, by naprawic to na wyzszym poziomie

            else if (message.Contains("error"))
            {
                Console.WriteLine("Do naprawy: " + toReconfigure);
                Thread.Sleep(3000 * toReconfigure);
                toReconfigure++;


                //tu jest maly cheat- taki ze numery podsieci sa takie same jak ich managerow
                //by nie parsowac ich wiadomosci ze wzgledu na numer
                //TODO zrobic ze podsiec wysyla tylko te scezki ktorych nie moze naprawic
                int deadSub = manager.number;
                Console.Write(DateTime.Now.ToString("HH:mm:ss") + " : ");
                Console.WriteLine("Zepsuła się podsieć: " + manager.number);

                //ustawienie ze jak nie mozna w niej usunac sciezki to sie ustawia ze jest ona martwa, by algorytm dijxtry do niej
                //nie wchodzil
                Program.nodes.Find(x => x.number == deadSub).isAlive = false;

                string errorPathId = GetIdOfErrorPath(message);



                var path = Program.paths.Find(x => x.globalID == errorPathId);

                path.ResetSlotReservation();
                SendSubToDeleteConnection(path);



                //a tu zestawiamy od nowa
                //musza byc dwie petle, bo robimy sycnhronicznie zestawianie
                lock (Program.nodes)
                {
                    lock (Program.links)
                    {
                        SwitchingActions.pathToCount = PathAlgorithm.dijkstra(Program.nodes, Program.links, path.nodes.Last().number, path.nodes.First().number, false);
                    }

                    try
                    {
                        lock (Program.paths)
                        {
                            Program.paths.Remove(Program.paths.Find(x => x.globalID == errorPathId));
                        }
                    }
                    catch
                    {
                    }
                    if (SwitchingActions.pathToCount.endToEnd == false)
                    {
                        //jak nie udalo sie zrekonfigurwac zmniejszamy licznik
                        toReconfigure--;

                        Console.Write(DateTime.Now.ToString("HH:mm:ss") + " : ");
                        Console.WriteLine("Naprawa ścieżki jest niemożliwa");
                    }
                    else
                    {
                        //zerujemy licznik
                        messageCounterPossibleWindow      = 0;
                        messageCounterPossibleReservation = 0;

                        reconfigured = false;
                        SendToSubnetworks(SwitchingActions.pathToCount);

                        //TODO potem do wodotryskow, ze jak sie jedna sciezka zepsuje to nie wylacza podsieci forever

                        /*
                         * while(reconfigured==false)
                         * {
                         *  Thread.Sleep(100);
                         * }
                         * Program.nodes.Find(x => x.number == deadSub).isAlive = true;*/
                    }
                }
            }
            //jezeli nie mozliwe jest zestawienie polaczenia w podsieci
            //TODO jak zestawienie polaczenia nie jest mozliwe przez jakas podscie to by poszlo inaczej
            else if (message.Contains("connection_impossible"))
            {
                //jak nie mozna w jakiejs podsieci zestawic to wtedy pomijamy to polaczenie
                //TODO zrobic ze jak nies niemozliwe to by szukac innego rozwiazania
                if (reconfigured == false)
                {
                    reconfigured = true;
                }
                Console.WriteLine();
            }
        }
Esempio n. 4
0
        /// <summary>
        /// do obslugi zlecenia polaczenia
        /// ma na celu stwierdzenie czy jest mozliwe zestawienie sciezki EndToEnd
        /// </summary>
        /// <param name="message"></param>
        /// <param name="agent"></param>
        private static void ConnectionRequest(string message, Agent agent)
        {
            //jezeli jest to juz najnizsza podsiec to na jej poziomie juz konfigurujemy
            if (Program.isTheBottonSub == true)
            {
                //format wiadomosci
                //connection:<port_in>port</port_in><port_out>port<port_out>

                messageData = GetStartAndEndNode(message);


                var path = PathAlgorithm.dijkstra(Program.nodes, Program.links, messageData[0], messageData[1], false);
                //4 indeks to numer globalID
                path.globalID = messageData[4].ToString();
                if (path.endToEnd)
                {
                    //by byla tylko jedna sciezka ta globalna na ktorej pracujemy


                    //  Console.WriteLine("Istnieje połączenie EndToEnd");

                    //tu dodajemy do sciezki port na ktorej mamy z niej wyjechac i na ktory mamy wjechac
                    Link inPort  = new Link(messageData[2]);
                    Link outPort = new Link(messageData[3]);

                    path.nodes.First().outputLink = outPort;
                    path.nodes.Last().inputLink   = inPort;

                    /*   foreach (Path p in Program.paths)
                     * {
                     *     Console.WriteLine("four TRYInput port " + p.nodes.Last().inputLink.portIn + "Output port  " + p.nodes.First().outputLink.portOut);
                     *     Console.WriteLine(p.xmlName);
                     *     Console.WriteLine("Start Slot:" + p.startSlot);
                     *
                     * }
                     */
                    SwitchingActions.pathToCount = path;



                    string message1 = "<lenght>" + path.lenght + "</lenght>";

                    // string message1="<order>"+message+"</order><lenght>"+path.lenght+"</lenght>";
                    agent.Send(message1);

                    MemoryStream stream    = new MemoryStream();
                    IFormatter   formatter = new BinaryFormatter();
                    formatter.Serialize(stream, path.possibleWindow);



                    agent.Send(stream);
                }
                //
                else
                {
                }
            }
            //TODO
            // w przeciwnym razie slemy nizej, czyli jak sa podspodem jeszcze inne polaczenia bedziemy musieli slac nizej
            else
            {
            }
        }
Esempio n. 5
0
        /// <summary>
        /// gdy zdechnie wezel by od nowa zrekonfigurowac polaczenia i
        /// rozsyla info wezlom co byly na poprzedniej sciezce by wywlaily co maja na nia
        /// potem wysyla klijentowi nowe info jak ma wysylac
        /// i wezlom co sa na tej nowej sciezce
        /// </summary>
        /// <param name="id"></param>
        internal static void NodeIsDead(int id)
        {
            string message1;
            var    toReconfigure = Program.paths.FindAll(x => x.nodes.Contains(x.nodes.Find(y => y.number == id)));

            foreach (Path path in toReconfigure)
            {
                path.ResetSlotReservation();
            }
            foreach (Path path in toReconfigure)
            {
                System.Threading.Thread.Sleep(100);
                path.ResetSlotReservation();
                message1 = "remove:" + path.nodes.Last().number + path.nodes[0].number;
                foreach (Node node in path.nodes)
                {
                    if (node.number <= 80 && node.number != id)
                    {
                        lock (Program.managerNodes)
                        {
                            try
                            {
                                Program.managerNodes[node.number - 1].Send(message1);
                            }
                            catch
                            {
                                Console.Write(DateTime.Now.ToString("HH:mm:ss") + " : ");
                                Console.WriteLine("Nie udało się automatycznie usunąć wpisów");
                            }
                        }
                    }
                }

                Path pathForFunction;
                lock (Program.nodes)
                {
                    lock (Program.links)
                    {
                        pathForFunction = PathAlgorithm.dijkstra(Program.nodes, Program.links, path.nodes.Last().number, path.nodes.First().number, false);
                    }
                }

                if (pathForFunction.pathIsSet == true)
                {
                    lock (Program.paths)
                    {
                        try
                        {
                            //jezeli udalo sie zestawic nowe polaczenie to jest podmieniane
                            Program.paths[Program.paths.FindIndex(x => x == path)] = pathForFunction;
                            Console.Write(DateTime.Now.ToString("HH:mm:ss") + " : ");
                            Console.WriteLine("Zamieniłem ścieżkę");
                        }
                        catch
                        {
                            Console.Write(DateTime.Now.ToString("HH:mm:ss") + " : ");
                            Console.WriteLine("Nie udało się zamienić ścieżki");
                        }
                    }



                    var xml = new XMLeon(path.xmlName);

                    //rozeslanie informacji do klijenta wysylajacego o zmianie sciezki
                    var targetClient = pathForFunction.nodes.First().number - 80;
                    message1 = "replace:<start_slot>" + pathForFunction.startSlot + "</start_slot><target_client>" + targetClient + "</target_client>";

                    try
                    {
                        Program.managerClient[path.nodes.Last().number - 80 - 1].Send(message1);
                    }
                    catch (Exception ex)
                    {
                        Console.Write(DateTime.Now.ToString("HH:mm:ss") + " : ");
                        Console.WriteLine("Nie udało się wysłać ścieżki do klienta, ex: " + ex.ToString());
                    }
                    //koniec rozsylo do klijenta

                    //taka indkesacja, bo bierzemy od konca i nie potrzebujemy do odbiorcy niczego wysylac
                    for (int i = pathForFunction.nodes.Count - 1; i >= 1; i--)
                    {
                        if (pathForFunction.nodes[i].number < 80)

                        {
                            message1 = xml.StringNode(pathForFunction.nodes[i].number);
                            Console.WriteLine(message1);
                            try
                            {
                                Program.managerNodes[pathForFunction.nodes[i].number - 1].Send(message1);
                            }
                            catch
                            {
                                Console.Write(DateTime.Now.ToString("HH:mm:ss") + " : ");
                                Console.WriteLine("Nie udało się wysłać ścieżki do węzła");
                            }
                        }
                    }
                }
                else
                {
                    lock (Program.paths)
                    {
                        try
                        {
                            //jezeli nie udalo sie zestawic polaczenia to jest ono wywalane z listy polaczen
                            Program.paths.Remove(Program.paths.Find(x => x == path));
                        }
                        catch
                        {
                            Console.Write(DateTime.Now.ToString("HH:mm:ss") + " : ");
                            Console.WriteLine("Nie udało się wywalić ścieżki");
                        }
                    }
                }
            }
        }