示例#1
0
 /// <summary>
 ///
 /// </summary>
 public string generateRouteTableQueryResponse(NetworkPath networkPath)
 {
     return(this.ip + "#" + MessageNames.ROUTE_TABLE_QUERY + "#"
            + networkPath.path.frequency + "#" + networkPath.path.band + "#" + PathToString(networkPath.path) + "#");
 }
示例#2
0
        /// <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);
        }
示例#3
0
        /// <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);
                }
            }
        }