/// <summary>
///
/// </summary>
public string generateRouteTableQueryResponse(NetworkPath networkPath)
{
return(this.ip + "#" + MessageNames.ROUTE_TABLE_QUERY + "#"
+ networkPath.path.frequency + "#" + networkPath.path.band + "#" + PathToString(networkPath.path) + "#");
}
/// <summary>
/// Wyznacza ścieżkę i wolną częstotliwość w ścieżce. W razie niepowodzenia zwraca pustą ścieżkę.
/// </summary>
/// <param name="rc_ip">IP RC, do którego RC zwraca się o wyznaczenie ścieżki.</param>
/// <param name="Source">Węzeł przed węzłem modelującym podsieć.</param>
/// <param name="Destnation">Węzeł po węźle modelującym podsieć.</param>
/// <param name="band">Ilość szczelin.</param>
/// <returns></returns>
/*[Obsolete]
* public NetworkPath TryGetPathFromSNMPAtFrequencies(string rc_ip, Wezel nodeFrom,
* Wezel nodeTo, short band, ref NetworkPath upperNetworkPath)
* {
* SubNetworkPointPool SNPPFrom = new SubNetworkPointPool(new SubNetworkPoint(IPAddress.Parse(nodeFrom.ip)));
* SubNetworkPointPool SNPPTo = new SubNetworkPointPool(new SubNetworkPoint(IPAddress.Parse(nodeTo.ip)));
*
* //RC po kolei próbuje otrzymać jakaś ścieżkę
* for (short i = 0; i < EONTable.capacity; i++)
* {
* if (nodeFrom.eonTable.OutFrequencies[i] == -1 && nodeTo.eonTable.InFrequencies[i] == -1)
* {
* upperNetworkPath = this.topology.getNetworkPath(SNPPFrom, SNPPTo, band, this.topology.network, i);
*
* if (upperNetworkPath != null || upperNetworkPath.snpps.Count != 0)
* {
* //Próba wyznaczenia i-tej ścieżki
* var path = this.getPathFromRC(rc_ip, SNPPFrom, SNPPTo, band, i);
*
* if (path != null || path.snpps.Count != 0)
* return path;
* }
* }
* else
* {
* continue;
* }
* }
* //Zwracanie pustej sciezki
* return new NetworkPath();
*
* }*/
/// <summary>
/// Generuje sciezke od jednego RC do drugiego RC
/// </summary>
/// <param name="rc_ip"></param>
/// <param name="Source"></param>
/// <param name="Destnation"></param>
/// <param name="band"></param>
/// <param name="frequency"></param>
/// <returns></returns>
public NetworkPath getPathFromRC(string rc_ip, SubNetworkPointPool Source,
SubNetworkPointPool Destnation, short band, short frequency)
{
try
{
//Generowanie wiadomosci
string message = generateGetPathFromRCMessage(Source, Destnation, band, frequency);
//Zamiana jej na tablice bajtow
byte[] data = Encoding.ASCII.GetBytes(message);
//Tworzenie IPEndPointa z rc, do którego wysyłamy prośbę o wyznaczenie ścieżki. Nasluchiwanie na porcie 11001
IPEndPoint rcEndPoint = new IPEndPoint(this.ip, 11001);
IPEndPoint myEndpoint = new IPEndPoint(IPAddress.Any, 0);
UdpClient client = new UdpClient(rcEndPoint);
//Polaczenie z endpointem
//if (!this.sender.IsBound)
//this.sender.Bind(rcEndPoint);
//TODO: Wyskakuje blad, ze tylko jedno uzycie gniazda sieciowego jest dozwolone
//Wyslanie zapytania do RC o IP okreslonym przez rc_ip
SendMessage(rc_ip, message);
//this.sender.SendTo(data, rcEndPoint);
//alokacja bajtow do odbierania
byte[] receivedBytes = new byte[0];
//if (!this.receiver.IsBound)
//this.receiver.Bind(rcEndPoint);
receivedBytes = client.Receive(ref myEndpoint);
client.Close();
//Odebranie wiadomości od tamtego RC
// UdpClient udpClient = new UdpClient(rcEndPoint);
//receivedBytes = udpClient.Receive(ref rcEndPoint);
//this.receiver.ReceiveFrom(receivedBytes, SocketFlags.None, ref rcendPoint);
//this.receiver.ReceiveFrom(receivedBytes, ref rcEndPoint);
//Zmiana jej na stringa
string receivedMesage = Encoding.ASCII.GetString(receivedBytes);
//Tworzenie obiektu klasy NetworkPath ze sciezka wpisana
NetworkPath networkPath = readGetPathFromRCResponse(receivedMesage, rc_ip);
//Przypisanie wartosci pasma i czestotliwosci do sciezki
networkPath.path.band = band;
networkPath.path.frequency = frequency;
return(networkPath);
}
catch (Exception E)
{
Console.WriteLine(E.Message);
return(null);
}
return(null);
}
/// <summary>
/// Próbuje wyznaczyć ścieżkę od częstotliwości początkowej do końcowej.
/// </summary>
/// <param name="pathFrom"></param>
/// <param name="pathTo"></param>
/// <param name="bitRate"></param>
/// <param name="hopsNumber"></param>
/// <param name="startFrequency"></param>
/// <param name="endFrequency"></param>
public void determineAndSendPath(string ccIP, string pathFrom, string pathTo, short bitRate, short hopsNumber, short startFrequency,
short endFrequency)
{
short modulationPerformance = BorderNodeCommutationTable.determineModulationPerformance(hopsNumber);
short band = BorderNodeCommutationTable.determineBand(bitRate, modulationPerformance);
//Odnalezienie wezlow poczatkowych i koncowych. Indeksy tez sie przydadza
int wFromIndex = this.topology.network.wezly.FindIndex(x => x.ip.ToString() == pathFrom);
int wToIndex = this.topology.network.wezly.FindIndex(x => x.ip.ToString() == pathTo);
Wezel wFrom = this.topology.network.wezly[wFromIndex];
Wezel wTo = this.topology.network.wezly[wToIndex];
//Lista strukturek reprezentujących podsieci, do których trzeba się zgłosić
List <SNandRC> sNandRcs = new List <SNandRC>();
//Czy lista jest kompletna?
bool sNandRcsComplete = false;
NetworkPath networkPath = new NetworkPath();
//Zapuszczenie algorytmu najkrotszej sciezki
this.topology.runShortestPathAlgorithm();
if (wFrom != null && wTo != null)
{
for (short i = startFrequency; i < endFrequency; i++)
{
//Wyznaczenie nadścieżki
networkPath = topology.getNetworkPath(wFrom.SNPP,
wTo.SNPP, band, topology.network, i);
if (networkPath == null || networkPath.snpps.Count == 0)
{
continue;
}
//Uzupełnienie listy z wyszukanymi węzłami
if (!sNandRcsComplete)
{
foreach (var snpp in networkPath.snpps)
{
//Wyszukiwanie węzłów, które reprezentują podsieci i do których RC trzeba się zwrócić.
SNandRC sNandRc = SN_RCs.Find(x => x.snpp.snps[0].ipaddress.ToString() == snpp.snps[0].ipaddress.ToString());
if (sNandRc != null)
{
sNandRcs.Add(sNandRc);
}
}
sNandRcsComplete = true;
}
if (resolveSNPPS(ref networkPath, band, i))
{
SendMessage(ccIP, generateRouteTableQueryResponse(networkPath));
break;
}
}
//Dodanie do listy potencjalnych sciezek, o ile nie jest pusta
if (networkPath.snpps.Count != 0)
{
this.topology.pathsCopy.Add(networkPath);
}
}
}
