コード例 #1
0
        public static void ReserveRequest(int startSlot, int neededSlots)
        {
            int[] data = { startSlot, neededSlots };
            //  data = GetStartAndAmountOfSlots(message);
            SwitchingActions.pathToCount.ReserveWindow(data[1], data[0]);
            XMLeon xml = new XMLeon("path" + messageData[0] + messageData[1] + SwitchingActions.pathToCount.globalID + ".xml", XMLeon.Type.nodes);

            //  XMLeon xml = new XMLeon("path" + messageData[0] + messageData[1] + ".xml");
            SwitchingActions.pathToCount.xmlName = ("path" + messageData[0] + messageData[1] + SwitchingActions.pathToCount.globalID + ".xml");
            xml.CreatePathXML(SwitchingActions.pathToCount);

            if (Program.isTheBottonSub == true)
            {
                /* foreach (Manager nod in Program.managerNodes)
                 * {
                 *   Console.WriteLine(nod.number);
                 * }*/
                foreach (Node node in SwitchingActions.pathToCount.nodes)
                {
                    string message1 = xml.StringNode(node.number);
                    Console.WriteLine(message1);
                    try
                    {
                        Console.WriteLine(" Wezel: " + node.number);
                        Program.managerNodes.Find(x => x.number == node.number).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");
                    }
                }
            }
        }
コード例 #2
0
ファイル: CLI.cs プロジェクト: kirkosyn/MPLS-EON
        /// <summary>
        /// wysyla klijentom info na jaki port maja wysylac
        /// </summary>
        /// <param name="clientAmount"></param>
        /// <param name="managerClient"></param>
        public static void ConfigureClients(int clientAmount, List <Manager> managerClient)
        {
            CLI.RequestXML();
            string name;

            do
            {
                name = Console.ReadLine();

                if (name == "esc")
                {
                    break;
                }
                XML.SetName(name);
            } while (XML.Test() != true);
            if (name != "esc")
            {
                List <int> portOut = XMLeon.GetClientPortOut(name);
                for (int i = 0; i < clientAmount; i++)
                {
                    try
                    {
                        managerClient[i].Send("port_out:" + portOut[i]);
                        Console.WriteLine("Wysyłam info o porcie: " + portOut[i]);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Błąd wysyłania informacji o porcie");
                    }
                }
            }
        }
コード例 #3
0
ファイル: XMLeon.cs プロジェクト: kirkosyn/MPLS-EON
        /// <summary>
        /// zapis sciezki do pliku
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <param name="path"></param>
        public static void SavePathToFile(int start, int end, Path path)
        {
            XMLeon xml = new XMLeon("path" + start.ToString() + end.ToString() + ".xml", XMLeon.Type.nodes);

            path.xmlName = ("path" + start + end + ".xml");
            xml.CreatePathXML(path);
        }
コード例 #4
0
ファイル: CLI.cs プロジェクト: kirkosyn/MPLS-EON
        public static void ConfigureSubnetworks()
        {
            CLI.RequestXML();
            string name;

            do
            {
                name = Console.ReadLine();

                if (name == "esc")
                {
                    break;
                }
                XML.SetName(name);
            } while (XML.Test() != true);
            if (name != "esc")
            {
                Program.managerCloud.Send("clean_dictionary");
                XMLeonSubnetwork file = new XMLeonSubnetwork(name);


                CLI.PrintConfigFilesSent();

                lock (Program.subnetworksList)
                {
                    Program.subnetworksList = file.GetSubnetworks();
                    foreach (Subnetwork sub in Program.subnetworksList)
                    {
                        lock (Program.subnetworkManager)
                        {
                            try
                            {
                                Program.subnetworkManager.Find(x => x.number == sub.id).Send(sub.myContent);
                            }
                            catch (Exception ex)
                            {
                                Console.WriteLine("Nie udała się konfiguracja podsieci, ex:" + ex.ToString());
                            }
                        }
                    }
                }
                string client;
                client = file.GetClientFile();

                List <int> portOut = XMLeon.GetClientPortOut(client);
                for (int i = 0; i < Program.amountOfclients; i++)
                {
                    try
                    {
                        Program.managerClient[i].Send("port_out:" + portOut[i]);
                        Console.WriteLine("Wysyłam info o porcie: " + portOut[i]);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Błąd wysyłania informacji o porcie");
                    }
                }
                string    linksFile = file.GetLinkFile();
                XMLParser xml       = new XMLParser(linksFile);
                Program.links = xml.GetLinks();
                lock (Program.managerCloud)
                {
                    Program.managerCloud.Send(XML.StringCableLinks(linksFile));
                    //Console.WriteLine("aaaaaaaaaaaaaaaaaaaaaaaaaaa");
                }
            }
        }
コード例 #5
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();
        }
コード例 #6
0
ファイル: SwitchingActions.cs プロジェクト: kirkosyn/MPLS-EON
        /// <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();
            }
        }
コード例 #7
0
ファイル: SwitchingActions.cs プロジェクト: kirkosyn/MPLS-EON
        /// <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");
                        }
                    }
                }
            }
        }