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");
}
}
}
}
/// <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");
}
}
}
}
/// <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);
}
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");
}
}
}
/// <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();
}
/// <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();
}
}
/// <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");
}
}
}
}
}