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