public static bool SendPeerCoordination(SNP SNPpathBegin, string AddressPathEnd, bool val)
{
Tuple <SNP, string> peerTuple = new Tuple <SNP, string>(SNPpathBegin, AddressPathEnd);
CSocket otherDomainSocket = GetSocketToDomain(AddressPathEnd);
if (val)
{
otherDomainSocket.SendObject(null, new Dictionary <string, string>());
otherDomainSocket.SendObject(PEER_COORDINATION, peerTuple);
}
else
{
otherDomainSocket.SendObject(null, new Dictionary <string, string>());
otherDomainSocket.SendObject(DELETE_PEER_COORDINATION, peerTuple);
}
string response = otherDomainSocket.ReceiveObject().Item1;
//otherDomainSocket.Close();
if (response.Equals(CSocket.ACK_FUNCTION))
{
return(true);
}
else
{
return(false);
}
}
public void LocalTopologyIn(bool delete, SNP localTopologyUpdate)
{
Link link = links.Find(x => x.FirstSNPP.Address == localTopologyUpdate.Address || x.SecondSNPP.Address == localTopologyUpdate.Address);
SNPP snpp = null;
if (link.FirstSNPP.Address == localTopologyUpdate.Address)
{
snpp = link.FirstSNPP;
}
else
{
snpp = link.SecondSNPP;
}
if (delete)
{
snpp.Capacity += localTopologyUpdate.OccupiedCapacity;
LogClass.GreenLog("[RC]Received Topology: Added " + localTopologyUpdate.OccupiedCapacity + "Mbit/s to SNPP " + localTopologyUpdate.Address + ".");
}
else
{
snpp.Capacity -= localTopologyUpdate.OccupiedCapacity;
LogClass.MagentaLog("[RC]Received Topology: Removed " + localTopologyUpdate.OccupiedCapacity + "Mbit/s from SNPP " + localTopologyUpdate.Address + ".");
}
LogClass.WhiteLog("[RC] " + snpp.Capacity + "Mbit/s left on " + snpp.Address);
}
public static bool SendConnectionRequest(SNP pathBegin, SNP pathEnd, SubnetworkAddress subnetworkAddress)
{
Tuple <SNP, SNP> connTuple = new Tuple <SNP, SNP>(pathBegin, pathEnd);
bool hasValue = SocketsByAddress.TryGetValue(subnetworkAddress, out childSubSocket);
if (hasValue)
{
if (pathBegin.Deleting)
{
childSubSocket.SendObject(DELETE_CONNECTION_REQUEST, connTuple);
}
else
{
childSubSocket.SendObject(CONNECTION_REQUEST_FROM_CC, connTuple);
}
while (!(acked || nacked))
{
Thread.Sleep(30);
}
if (acked)
{
if (pathBegin.Deleting)
{
LogClass.MagentaLog("Subnetwork " + subnetworkAddress.subnetAddress + " deleted connection between: " + pathBegin.Address + " and " + pathEnd.Address);
}
else
{
LogClass.GreenLog("Subnetwork " + subnetworkAddress.subnetAddress + " set connection between: " + pathBegin.Address + " and " + pathEnd.Address);
}
acked = false;
return(true);
}
else if (nacked)
{
if (pathBegin.Deleting)
{
LogClass.Log("Subnetwork " + subnetworkAddress.subnetAddress + " can't delete the connection between: " + pathBegin.Address + " and " + pathEnd.Address);
}
else
{
LogClass.Log("Subnetwork " + subnetworkAddress.subnetAddress + " can't set up the connection between: " + pathBegin.Address + " and " + pathEnd.Address);
}
nacked = false;
return(false);
}
}
else
{
LogClass.Log("Can't find subnetwork: " + subnetworkAddress.ToString());
}
return(false);
}
private bool BelongsToSubnetwork(SNP SNPstart, SNP SNPend)
{
//sprawdza, czy ma taka pare na liscie
foreach (SubnetworkAddress subAddress in ContainedSubnetworksAddresses)
{
if (IPAddressExtensions.IsInSameSubnet(IPAddress.Parse(SNPstart.Address), IPAddress.Parse(SNPend.Address), subAddress.subnetMask))
{
return(true);
}
}
return(false);
}
public bool DeletePeerCoordinationIn(SNP pathBegin, string pathEnd)
{
LogClass.Log("[DEBUG] incoming deletepeercoordination from" + pathBegin.Address + " to " + pathEnd);
List <SNP> SNPList = null;
foreach (string[] key in existingConnections.Keys)
{
if ((key[0] == pathBegin.Address && key[1] == pathEnd) || (key[1] == pathBegin.Address && key[0] == pathEnd))
{
SNPList = existingConnections[key];
}
}
//w kazdym SNP ustaw "deleting" na true
SNPList.ForEach(x => x.Deleting = true);
//usuniecie alokacji w LRM
for (int index = 0; index < SNPList.Count; index += 2)
{
SNP SNPpathBegin = SNPList[index];
SNP SNPpathEnd = SNPList[index + 1];
DeleteLinkConnectionRequest(SNPpathBegin, SNPpathEnd);
}
//Wysłanie DeleteConnectionRequesta do podsieci, jeżeli na liscie SNP znajdą się 2 adresy brzegowe tej podsieci
for (int index = 0; index < SNPList.Count - 1; index++)
{
SNP SNPpathBegin = SNPList[index];
for (int jndex = index + 1; jndex < SNPList.Count; jndex++)
{
SNP SNPpathEnd = SNPList[jndex];
if (BelongsToSubnetwork(SNPpathBegin, SNPpathEnd))
{
if (DeleteConnectionRequestOut(SNPpathBegin, SNPpathEnd))
{
LogClass.Log("Deleting " + SNPpathBegin.Address + " - " + SNPpathEnd.Address + " successful.");
}
else
{
LogClass.Log("Epic fail xD");
return(false);
}
}
}
}
return(true); //Jesli polaczenie zestawiono poprawnie
}
// % % % % % % % % % % % % % % % % % % % % % % % % % //
// %%%%%%%%%%%%%%%%% GŁOWNA METODA %%%%%%%%%%%%%%%%% //
// % % % % % % % % % % % % % % % % % % % % % % % % % //
public Tuple <SNP, SNP> SNPLinkConnectionRequest(Object pathBegin, Object pathEnd, int capacity)
{
Tuple <SNP, SNP> SNPpair = null;
//LRM dostaje od CC dwa SNPP do stworzenia SNP lub dwa SNP do usuniecia
if (pathBegin.GetType() == typeof(SNPP) && pathEnd.GetType() == typeof(SNPP))
{
SNPP SNPPpathBegin = (SNPP)pathBegin;
SNPP SNPPpathEnd = (SNPP)pathEnd;
SNPpair = AllocateLink(SNPPpathBegin, SNPPpathEnd, capacity);
}
//jesli SNPPki są równe to znaczy ze są fejkowe i trzeba znaleźć SNPP o tym adresie
else if (pathBegin == pathEnd)
{
SNPP fakeSNPP = (SNPP)pathBegin;
string address = fakeSNPP.Address;
SNPP realSNPP = myEdgeSNPPs.Find(i => i.Address == address);
if (realSNPP.Capacity > capacity)
{
realSNPP.Capacity -= capacity;
//generuje nowy label
int potentiallyNewLabel = GimmeNewLabel();
//sprawdz, czy wygenerowany label nie wystapil w SNPs - jesli tak, wygeneruj inny label
if (!SNPsbySNPPaddress.ContainsKey(realSNPP.Address))
{
SNPsbySNPPaddress.Add(realSNPP.Address, new List <SNP>());
}
//tworzenie SNP poczatkowego SNPP
SNP createdSNP = new SNP(potentiallyNewLabel, fakeSNPP.Address, capacity); //uses remembered label
SNPsbySNPPaddress[fakeSNPP.Address].Add(createdSNP);
Topology(createdSNP);
SNPpair = new Tuple <SNP, SNP>(createdSNP, createdSNP);
return(SNPpair);
}
}
else if (pathBegin.GetType() == typeof(SNP) && pathEnd.GetType() == typeof(SNP))
{
SNP SNPpathBegin = (SNP)pathBegin;
SNP SNPpathEnd = (SNP)pathEnd;
RemoveLink(SNPpathBegin, SNPpathEnd);
}
return(SNPpair);
}
private Tuple <SNP, SNP> AllocateLink(SNPP pathBegin, SNPP pathEnd, int capacity)
{
List <SNP> existingSNPs = new List <SNP>();
Tuple <SNP, SNP> SNPpair;
SNP SNPpathBegin, SNPpathEnd;
if (!SNPsbySNPPaddress.ContainsKey(pathBegin.Address))
{
SNPsbySNPPaddress.Add(pathBegin.Address, new List <SNP>());
if (pathBegin != pathEnd)
{
SNPsbySNPPaddress.Add(pathEnd.Address, new List <SNP>());
}
}
//generuje nowy label
int potentiallyNewLabel = GimmeNewLabel();
//sprawdz, czy wygenerowany label nie wystapil w SNPs - jesli tak, wygeneruj inny label
existingSNPs = SNPsbySNPPaddress[pathBegin.Address];
while (existingSNPs.Find(x => x.Label == potentiallyNewLabel) != null)
{
potentiallyNewLabel = GimmeNewLabel();
}
//tworzenie SNP poczatkowego SNPP
SNPpathBegin = new SNP(potentiallyNewLabel, pathBegin.Address, capacity); //uses remembered label
SNPsbySNPPaddress[pathBegin.Address].Add(SNPpathBegin);
CustomSocket.LogClass.WhiteLog("[LRM] Sending topology update: allocate " + SNPpathBegin.OccupiedCapacity + "Mbit/s on " + SNPpathBegin.Address);
Topology(SNPpathBegin);
if (pathBegin.Address != pathEnd.Address)
{
//tworzenie SNP koncowego SNPP
SNPpathEnd = new SNP(potentiallyNewLabel, pathEnd.Address, capacity); //uses generated label
SNPsbySNPPaddress[pathEnd.Address].Add(SNPpathEnd);
CustomSocket.LogClass.WhiteLog("[LRM] Sending topology update: allocate " + SNPpathEnd.OccupiedCapacity + "Mbit/s on " + SNPpathEnd.Address);
Topology(SNPpathEnd);
SNPpair = new Tuple <SNP, SNP>(SNPpathBegin, SNPpathEnd);
}
else
{
SNPpair = new Tuple <SNP, SNP>(SNPpathBegin, SNPpathBegin);
}
return(SNPpair);
}
private bool ConnectionRequestOut(SNP pathBegin, SNP pathEnd)
{
LogClass.WhiteLog("[CC] Sending ConnectionRequestOut between ports: " + pathBegin.Address + " and " + pathEnd.Address);
//wysyla do cc poziom niżej wiadomosc connection request
IPAddress subnetworkAddress = null;
IPAddress subnetworkAddressMask = null;
foreach (SubnetworkAddress sub in ContainedSubnetworksAddresses)
{
if (IPAddressExtensions.IsInSameSubnet(sub.subnetAddress, IPAddress.Parse(pathBegin.Address), sub.subnetMask))
{
subnetworkAddress = sub.subnetAddress;
subnetworkAddressMask = sub.subnetMask;
}
}
SubnetworkAddress subnetAddress = new SubnetworkAddress(subnetworkAddress.ToString(), subnetworkAddressMask.ToString());
return(SubnetworkServer.SendConnectionRequest(pathBegin, pathEnd, subnetAddress));
}
private void RemoveLink(SNP SNPpathBegin, SNP SNPpathEnd)
{
List <SNP> existingSNPs = new List <SNP>();
if (SNPsbySNPPaddress.ContainsKey(SNPpathBegin.Address))
{
SNP BeginToBeDeleted = SNPsbySNPPaddress[SNPpathBegin.Address].Find(x => x.Address == SNPpathBegin.Address);
SNPsbySNPPaddress[SNPpathBegin.Address].Remove(BeginToBeDeleted);
Topology(SNPpathBegin);
CustomSocket.LogClass.WhiteLog("[LRM] Sending topology update: deallocate " + SNPpathBegin.OccupiedCapacity + "Mbit/s on " + SNPpathBegin.Address);
}
if (SNPsbySNPPaddress.ContainsKey(SNPpathEnd.Address))
{
SNP EndToBeDeleted = SNPsbySNPPaddress[SNPpathEnd.Address].Find(x => x.Address == SNPpathEnd.Address);
SNPsbySNPPaddress[SNPpathEnd.Address].Remove(EndToBeDeleted);
Topology(SNPpathEnd);
CustomSocket.LogClass.WhiteLog("[LRM] Sending topology update: deallocate " + SNPpathEnd.OccupiedCapacity + "Mbit/s on " + SNPpathEnd.Address);
}
}
public bool DeleteConnectionRequestOut(SNP pathBegin, SNP pathEnd)
{
LogClass.Log("[DEBUG] sending delete connection request out between " + pathBegin.Address + " and " + pathEnd.Address);
//wysyla do cc poziom niżej wiadomosc usuwaj jak szalony konik
IPAddress subnetworkAddress = null;
IPAddress subnetworkAddressMask = null;
foreach (SubnetworkAddress sub in ContainedSubnetworksAddresses)
{
if (IPAddressExtensions.IsInSameSubnet(sub.subnetAddress, IPAddress.Parse(pathBegin.Address), sub.subnetMask))
{
subnetworkAddress = sub.subnetAddress;
subnetworkAddressMask = sub.subnetMask;
}
}
SubnetworkAddress subnetAddress = new SubnetworkAddress(subnetworkAddress.ToString(), subnetworkAddressMask.ToString());
SubnetworkServer.SendConnectionRequest(pathBegin, pathEnd, subnetAddress);
return(true);
}
public bool DeleteConnection(string pathBegin, string pathEnd)
{
List <SNP> SNPList = null;
LogClass.Log("[DEBUG] deleting connection between" + pathBegin + " to " + pathEnd);
//new string[] { pathBegin, pathEnd }
foreach (string[] key in existingConnections.Keys)
{
if ((key[0] == pathBegin && key[1] == pathEnd) || (key[1] == pathBegin && key[0] == pathEnd))
{
SNPList = existingConnections[key];
}
}
//w kazdym SNP ustaw "deleting" na true
SNPList.ForEach(x => x.Deleting = true);
string PathEndAddressFromDifferentDomain = null;
//usuniecie alokacji w LRM
for (int index = 0; index < SNPList.Count; index += 2)
{
SNP SNPpathBegin = SNPList[index];
SNP SNPpathEnd = SNPList[index + 1];
DeleteLinkConnectionRequest(SNPpathBegin, SNPpathEnd);
}
//Wysłanie DeleteConnectionRequesta do podsieci, jeżeli na liscie SNP znajdą się 2 adresy brzegowe tej podsieci
for (int index = 0; index < SNPList.Count - 1; index++)
{
SNP SNPpathBegin = SNPList[index];
for (int jndex = index + 1; jndex < SNPList.Count; jndex++)
{
SNP SNPpathEnd = SNPList[jndex];
if (BelongsToSubnetwork(SNPpathBegin, SNPpathEnd))
{
if (ConnectionRequestOut(SNPpathBegin, SNPpathEnd))
{
LogClass.Log("Deleting " + SNPpathBegin.Address + " - " + SNPpathEnd.Address + " successful.");
}
else
{
LogClass.Log("Epic fail xD");
return(false);
}
}
}
}
//sprawdzamy, czy adres koncowy jest w naszej domenie
if (!IPAddressExtensions.IsInSameSubnet(IPAddress.Parse(pathEnd), IPAddress.Parse(SubnetworkAddress), IPAddress.Parse(SubnetworkMask)))
{
PathEndAddressFromDifferentDomain = pathEnd;
//TODO: sprawdz, czy ktorys z SNP ma adres SNPP brzegowego tej domeny
SNP lastSNPinThisDomain = null;
foreach (SNP snp in SNPList)
{
foreach (List <Tuple <IPAddress, IPAddress> > list in OtherDomainSNPPAddressTranslation.Values)
{
foreach (Tuple <IPAddress, IPAddress> tuple in list)
{
if (tuple.Item1.ToString() == snp.Address)
{
lastSNPinThisDomain = snp;
}
}
}
}
if (DeletePeerCoordinationOut(lastSNPinThisDomain, PathEndAddressFromDifferentDomain))
{
LogClass.Log("DeletePeerCoordination OK.");
}
else
{
LogClass.Log("PeerCoordination FAIL.");
};
}
return(true); //Jesli polaczenie zestawiono poprawnie
}
internal static void callIgnoreLinkInRC(SNP snpPathBegin)
{
routingController.IgnoreLink(snpPathBegin);
}
public static void SendTopologyUpdateToRC(bool delete, SNP localTopologyUpdate)
{
routingController.LocalTopologyIn(delete, localTopologyUpdate);
}
private static void WaitForInput(CSocket connected)
{
if (!connected.Equals(toParentSocket))
{
ProcessConnectInformation(connected);
}
while (true)
{
Tuple <String, Object> received = connected.ReceiveObject();
String parameter = received.Item1;
Object receivedObject = received.Item2;
if (parameter.Equals(SNPP_SUBNETWORK_INFORMATION))
{
InsertSNPPSToRC((List <SNPP>)receivedObject);
}
else if (parameter.Equals(CONNECTION_REQUEST_FROM_NCC))
{
MessageParameters parameters = (MessageParameters)receivedObject;
String sourceIP = parameters.getFirstParameter();
String destinationIP = parameters.getSecondParameter();
int capacity = parameters.getCapacity();
LogClass.CyanLog("Received CONNECTION REQUEST from NCC.");
bool success = connectionController.ConnectionRequestFromNCC(sourceIP, destinationIP, capacity);
String parentSubnetworkAddress = "127.0.0.1";
CSocket c = new CSocket(IPAddress.Parse(parentSubnetworkAddress), 40000, CSocket.CONNECT_FUNCTION);
SendACKorNACK(success, c);
}
else if (parameter.Equals(PEER_COORDINATION))
{
Tuple <SNP, string> receivedPair = (Tuple <SNP, string>)receivedObject;
LogClass.CyanLog("Received PEER COORDINATION from AS 1");
bool success = connectionController.PeerCoordinationIn(receivedPair.Item1, receivedPair.Item2);
SendACKorNACK(success, connected);
}
else if (parameter.Equals(DELETE_PEER_COORDINATION))
{
Tuple <SNP, string> receivedPair = (Tuple <SNP, string>)receivedObject;
LogClass.CyanLog("Received DELETE PEER COORDINATION from AS 1");
bool success = connectionController.DeletePeerCoordinationIn(receivedPair.Item1, receivedPair.Item2);
SendACKorNACK(success, connected);
}
else if (parameter.Equals(NETWORK_TOPOLOGY))
{
}
else if (parameter.Equals(CONNECTION_REQUEST_FROM_CC))
{
Tuple <SNP, SNP> pathToAssign = (Tuple <SNP, SNP>)received.Item2;
SNP first = pathToAssign.Item1;
SNP second = pathToAssign.Item2;
LogClass.CyanLog("Received CONNECTION REQUEST to set connection between " + first.Address + " and " + second.Address);
bool response = callConnectionRequest(pathToAssign.Item1, pathToAssign.Item2);
SendACKorNACK(response, connected);
}
else if (parameter.Equals(CALL_TEARDOWN))
{
MessageParameters parameters = (MessageParameters)receivedObject;
String sourceIP = parameters.getFirstParameter();
String destinationIP = parameters.getSecondParameter();
LogClass.CyanLog("Received TEARDOWN to deallocate connection between " + sourceIP + " and " + destinationIP);
bool success = connectionController.DeleteConnection(sourceIP, destinationIP);
String parentSubnetworkAddress = "127.0.0.1";
CSocket c = new CSocket(IPAddress.Parse(parentSubnetworkAddress), 40000, CSocket.CONNECT_FUNCTION);
SendACKorNACK(success, c);
}
else if (parameter.Equals(DELETE_CONNECTION_REQUEST))
{
Tuple <SNP, SNP> pathToDelete = (Tuple <SNP, SNP>)received.Item2;
string pathBegin = pathToDelete.Item1.Address;
string pathEnd = pathToDelete.Item2.Address;
LogClass.CyanLog("Received DELETE CONNECTION REQUEST to delete connection between " + pathBegin + " and " + pathEnd);
bool success = connectionController.DeleteConnection(pathBegin, pathEnd);
SendACKorNACK(success, connected);
}
else if (parameter.Equals(CSocket.ACK_FUNCTION))
{
LogClass.CyanLog("Received ACK");
acked = true;
}
else if (parameter.Equals(CSocket.NACK_FUNCTION))
{
LogClass.CyanLog("Received NACK");
nacked = true;
}
}
}
public bool ConnectionRequestFromCC(SNP pathBegin, SNP pathEnd)
{
List <SNPP> SNPPList = RouteTableQuery(pathBegin.Address, pathEnd.Address, pathBegin.OccupiedCapacity);
//Lista SNP dla tworzonego aktualnie polaczenia
List <SNP> SNPList = new List <SNP>();
SNPList.Add(pathBegin);
SNPList.Add(pathEnd);
for (int index = 0; index < SNPPList.Count; index += 2)
{
SNPP SNPPpathBegin = SNPPList[index];
SNPP SNPPpathEnd = SNPPList[index + 1];
Tuple <SNP, SNP> SNPpair = LinkConnectionRequest(SNPPpathBegin, SNPPpathEnd, pathBegin.OccupiedCapacity);
SNPList.Add(SNPpair.Item1);
SNPList.Add(SNPpair.Item2);
}
//Zapamietaj SNPlist z polaczeniem mdzy takimi adresami
existingConnections.Add(new string[] { pathBegin.Address, pathEnd.Address }, SNPList);
//Wysłanie ConnectionRequesta do podsieci, jeżeli na liscie SNP zajdą się 2 adresy brzegowe tej podsieci
List <SNP> connected = new List <SNP>();
for (int index = 0; index < SNPList.Count - 1; index++)
{
SNP SNPpathBegin = SNPList[index];
for (int jndex = index + 1; jndex < SNPList.Count; jndex++)
{
SNP SNPpathEnd = SNPList[jndex];
if (BelongsToSubnetwork(SNPpathBegin, SNPpathEnd))
{
if (ConnectionRequestOut(SNPpathBegin, SNPpathEnd))
{
connected.Add(SNPpathBegin);
connected.Add(SNPpathEnd);
LogClass.Log("Subnetwork Connection set properly.");
}
else
{
connected.ForEach(x => x.Deleting = true);
for (int i = 0; i < connected.Count; i += 2)
{
DeleteLinkConnectionRequest(connected.ElementAt(i), connected.ElementAt(i + 1));
}
for (int i = 0; i < connected.Count; i += 2)
{
ConnectionRequestOut(connected.ElementAt(i), connected.ElementAt(i + 1));
}
SubnetworkServer.callIgnoreLinkInRC(SNPpathBegin);
SubnetworkServer.callIgnoreLinkInRC(SNPpathEnd);
LogClass.Log("Epic fail.");
return(false);
}
}
}
}
return(true); //Jesli polaczenie zestawiono poprawnie
}
public static void CallDeleteLinkConnectionRequestInLRM(SNP SNPpathBegin, SNP SNPpathEnd, int capacity)
{
linkResourceManager.SNPLinkConnectionRequest(SNPpathBegin, SNPpathEnd, capacity);
}
// % % % % % % % % % % % % % % % % % % % % % % % % % //
// %%%%%%%%%%%%%%%%% GŁOWNA METODA %%%%%%%%%%%%%%%%% //
// % % % % % % % % % % % % % % % % % % % % % % % % % //
public bool ConnectionRequestFromNCC(string pathBegin, string pathEnd, int capacity)
{
string PathEndAddressFromDifferentDomain = null;
string[] existingConnKey = new string[] { pathBegin, pathEnd };
//Lista SNP dla tworzonego aktualnie polaczenia
List <SNP> SNPList = new List <SNP>();
//zakladamy, ze adres poczatkowy zawsze jest w naszej domenie, jezeli dostalismy requesta od NCC
//dodaj SNP z labelem 0 dla poczatku sciezki
SNPList.Add(new SNP(0, pathBegin, capacity, pathBegin, pathEnd));
//sprawdzamy, czy adres koncowy jest w naszej domenie
if (!IPAddressExtensions.IsInSameSubnet(IPAddress.Parse(pathEnd), IPAddress.Parse(SubnetworkAddress), IPAddress.Parse(SubnetworkMask)))
{
PathEndAddressFromDifferentDomain = pathEnd;
//sprawdza, czy adres docelowy jest w innej podsieci i podmienia
foreach (SubnetworkAddress domainAddress in OtherDomainSNPPAddressTranslation.Keys)
{
if (!IPAddressExtensions.IsInSameSubnet(IPAddress.Parse(pathEnd), domainAddress.subnetAddress, domainAddress.subnetMask))
{
Random random = new Random();
List <Tuple <IPAddress, IPAddress> > translationsList = OtherDomainSNPPAddressTranslation[domainAddress];
Tuple <IPAddress, IPAddress> foundTranslation = translationsList[random.Next(translationsList.Count)];
IPAddress translatedAddress = foundTranslation.Item1;
pathEnd = translatedAddress.ToString();
}
}
}
LogClass.WhiteLog("[CC] RouteTableQuery called between: " + pathBegin + " and: " + pathEnd);
List <SNPP> SNPPList = RouteTableQuery(pathBegin, pathEnd, capacity);
if (SNPPList.Count > 0)
{
//dodaj SNP z labelem 0 dla konca sciezki
if (PathEndAddressFromDifferentDomain == null)
{
SNPList.Add(new SNP(0, pathEnd, capacity, pathBegin, pathEnd));
}
else
{
SNPP fakeSNPP = new SNPP(pathEnd, 0);
SNPPList.Add(fakeSNPP);
SNPPList.Add(fakeSNPP);
}
for (int index = 0; index < SNPPList.Count; index += 2)
{
SNPP SNPPpathBegin = SNPPList[index];
SNPP SNPPpathEnd = SNPPList[index + 1];
Tuple <SNP, SNP> SNPpair = LinkConnectionRequest(SNPPpathBegin, SNPPpathEnd, capacity);
if (SNPpair.Item1 != SNPpair.Item2)
{
SNPList.Add(SNPpair.Item1);
SNPList.Add(SNPpair.Item2);
}
else
{
SNPList.Add(SNPpair.Item1);
}
}
//Zapamietaj SNPlist z polaczeniem mdzy takimi adresami
existingConnections.Add(existingConnKey, SNPList);
//Wysłanie ConnectionRequesta do podsieci, jeżeli na liscie SNP zajdą się 2 adresy brzegowe tej podsieci
for (int index = 0; index < SNPList.Count - 1; index++)
{
SNP SNPpathBegin = SNPList[index];
for (int jndex = index + 1; jndex < SNPList.Count; jndex++)
{
SNP SNPpathEnd = SNPList[jndex];
if (BelongsToSubnetwork(SNPpathBegin, SNPpathEnd))
{
if (ConnectionRequestOut(SNPpathBegin, SNPpathEnd))
{
LogClass.Log("Subnetwork Connection set properly.");
}
else
{
LogClass.Log("Epic fail.");
return(false);
}
}
}
}
//Wyslanie PeerCoordination jezeli zestawiane polaczenie przebiega przez 2 domeny
if (PathEndAddressFromDifferentDomain != null)
{
//TODO: sprawdz, czy ktorys z SNP ma adres SNPP brzegowego tej domeny
SNP lastSNPinThisDomain = null;
foreach (SNP snp in SNPList)
{
foreach (List <Tuple <IPAddress, IPAddress> > list in OtherDomainSNPPAddressTranslation.Values)
{
foreach (Tuple <IPAddress, IPAddress> tuple in list)
{
if (tuple.Item1.ToString() == snp.Address)
{
lastSNPinThisDomain = snp;
lastSNPinThisDomain.PathBegin = pathBegin;
lastSNPinThisDomain.PathEnd = PathEndAddressFromDifferentDomain;
}
}
}
}
if (PeerCoordinationOut(lastSNPinThisDomain, PathEndAddressFromDifferentDomain))
{
LogClass.Log("PeerCoordination OK.");
}
else
{
LogClass.Log("PeerCoordination FAIL.");
};
}
}
if (SNPPList.Count > 0)
{
return(true); //Jesli polaczenie zestawiono poprawnie
}
else
{
return(false);
}
}
internal void IgnoreLink(SNP snp)
{
Link link = links.Find(x => (x.FirstSNPP.Address.Equals(snp.Address) || x.SecondSNPP.Address.Equals(snp.Address)));
link.ignore = true;
}
private bool DeletePeerCoordinationOut(SNP lastSNPinThisDomain, string pathEndAddressFromDifferentDomain)
{
LogClass.WhiteLog("[CC] Sending deletePeerCoordination: " + lastSNPinThisDomain.Address + " to " + pathEndAddressFromDifferentDomain);
return(SubnetworkServer.SendPeerCoordination(lastSNPinThisDomain, pathEndAddressFromDifferentDomain, false));
}
private bool PeerCoordinationOut(SNP SNPpathBegin, string AddressPathEnd)
{
LogClass.WhiteLog("[CC] Sending peerCoordination: " + SNPpathBegin.Address + " to " + AddressPathEnd);
return(SubnetworkServer.SendPeerCoordination(SNPpathBegin, AddressPathEnd, true));
}
public bool PeerCoordinationIn(SNP pathBegin, string pathEnd)
{
LogClass.Log("[DEBUG] incoming peercoordination from" + pathBegin.Address + " to " + pathEnd);
string[] existingConnKey = new string[] { pathBegin.Address, pathEnd };
string beginAddressForDict = pathBegin.Address;
//Lista SNP dla tworzonego aktualnie polaczenia
List <SNP> SNPList = new List <SNP>();
//sprawdza, z ktorej domeny przyszedl SNP i podmienia jego adres na adres swojego SNPP brzegowego
foreach (SubnetworkAddress domainAddress in OtherDomainSNPPAddressTranslation.Keys)
{
if (IPAddressExtensions.IsInSameSubnet(IPAddress.Parse(pathBegin.Address), domainAddress.subnetAddress, domainAddress.subnetMask))
{
Tuple <IPAddress, IPAddress> foundTranslation = OtherDomainSNPPAddressTranslation[domainAddress].Find(x => x.Item1.ToString() == pathBegin.Address);
IPAddress translatedAddress = foundTranslation.Item2;
Console.WriteLine("TRANSALATED FROM" + pathBegin.Address + " TO " + translatedAddress.ToString());
pathBegin.Address = translatedAddress.ToString();
}
}
Console.WriteLine("DEFENITELY TRANSALATED TO " + pathBegin.Address);
//przepustowosc bierzemy z przekazanego SNP
SNPList.Add(new SNP(pathBegin.Label, pathBegin.Address, pathBegin.OccupiedCapacity, null, null));
SNPList.Add(new SNP(0, pathEnd, pathBegin.OccupiedCapacity, pathBegin.PathBegin, pathBegin.PathEnd));
//Zapamietaj SNPlist z polaczeniem mdzy takimi adresami
existingConnections.Add(existingConnKey, SNPList);
List <SNPP> SNPPList = RouteTableQuery(pathBegin.Address, pathEnd, pathBegin.OccupiedCapacity);
for (int index = 0; index < SNPPList.Count; index += 2)
{
SNPP SNPPpathBegin = SNPPList[index];
SNPP SNPPpathEnd = SNPPList[index + 1];
Tuple <SNP, SNP> SNPpair = LinkConnectionRequest(SNPPpathBegin, SNPPpathEnd, pathBegin.OccupiedCapacity);
SNPList.Add(SNPpair.Item1);
SNPList.Add(SNPpair.Item2);
}
//Wysłanie ConnectionRequesta do podsieci, jeżeli na liscie SNP zajdą się 2 adresy brzegowe tej podsieci
List <SNP> connected = new List <SNP>();
for (int index = 0; index < SNPList.Count - 1; index++)
{
SNP SNPpathBegin = SNPList[index];
for (int jndex = index + 1; jndex < SNPList.Count; jndex++)
{
SNP SNPpathEnd = SNPList[jndex];
if (BelongsToSubnetwork(SNPpathBegin, SNPpathEnd))
{
LogClass.WhiteLog("[DEBUG] Sending ConnectionRequest between" + SNPpathBegin.Address + SNPpathEnd.Deleting + "and" + SNPpathEnd.Address + SNPpathBegin.Deleting);
if (ConnectionRequestOut(SNPpathBegin, SNPpathEnd))
{
connected.Add(SNPpathBegin);
connected.Add(SNPpathEnd);
LogClass.Log("Subnetwork Connection set properly.");
}
else
{
connected.ForEach(x => x.Deleting = true);
for (int i = 0; i < connected.Count; i += 2)
{
DeleteLinkConnectionRequest(connected.ElementAt(i), connected.ElementAt(i + 1));
}
for (int i = 0; i < connected.Count; i += 2)
{
ConnectionRequestOut(connected.ElementAt(i), connected.ElementAt(i + 1));
LogClass.WhiteLog("[DEBUG] Sending DeleteConnectionRequest between" + SNPpathBegin.Address + SNPpathEnd.Deleting + "and" + SNPpathEnd.Address + SNPpathBegin.Deleting);
}
SubnetworkServer.callIgnoreLinkInRC(SNPpathBegin);
SubnetworkServer.callIgnoreLinkInRC(SNPpathEnd);
LogClass.Log("Epic fail.");
return(false);
}
}
}
}
return(true); //Jesli polaczenie zestawiono poprawnie
}
private void Topology(SNP localTopologyUpdate)
{
//wysyła SNP, które zostało uaktualnione do RC
//Wywołanie metody serwera, która jeszcze nie jest zrobiona
SubnetworkServer.SendTopologyUpdateToRC(localTopologyUpdate.Deleting, localTopologyUpdate);
}
private void DeleteLinkConnectionRequest(SNP SNPpathBegin, SNP SNPpathEnd)
{
SubnetworkServer.CallDeleteLinkConnectionRequestInLRM(SNPpathBegin, SNPpathEnd, 0);
}
private static bool callConnectionRequest(SNP pathBegin, SNP pathEnd)
{
return(connectionController.ConnectionRequestFromCC(pathBegin, pathEnd));
}
