Esempio n. 1
0
        public void ReadingFromSnAndRCsFile(string path)
        {
            string line;

            char[]              delimiterChars = { '#' };
            string[]            words;
            SubNetworkPointPool snpp;
            SNandRC             sNandRc;

            try
            {
                using (StreamReader file = new StreamReader(path))
                {
                    while ((line = file.ReadLine()) != null)
                    {
                        words   = line.Split(delimiterChars);
                        sNandRc = new SNandRC(words[1], words[0]);
                        this.SN_RCs.Add(sNandRc);
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Cannot read from file");
            }
        }
Esempio n. 2
0
        public bool resolveSNPPS(ref NetworkPath networkPath, short band, short frequency)
        {
            //topology.getNetworkPath();
            foreach (var snpp in networkPath.snpps)
            {
                //if (canIGoOnAtThisFrequency)
                //{
                SNandRC sNandRc = SN_RCs.Find(x => x.snpp.snps[0].ipaddress.ToString() == snpp.snps[0].ipaddress.ToString());

                if (sNandRc != null)
                {
                    //IP węzła modelującego podsieć
                    string oldNodeIP = sNandRc.snpp.snps[0].ipaddress.ToString();

                    //Łącze dochodzące do węzła modelującego podsieć
                    int previousLink = networkPath.path.KrawedzieSciezki.FindIndex(x =>
                                                                                   x.Wezel2.ip == oldNodeIP);

                    //Łącze wychodzące z węzła modelującego podsieć
                    int nextLink = networkPath.path.KrawedzieSciezki.FindIndex(x =>
                                                                               x.Wezel1.ip == oldNodeIP);

                    Wezel w1 = networkPath.path.zwroc_ListaKrawedziSciezki[previousLink].Wezel1;
                    Wezel w2 = networkPath.path.zwroc_ListaKrawedziSciezki[nextLink].Wezel2;

                    SubNetworkPointPool SNPPFrom = new SubNetworkPointPool(new SubNetworkPoint(IPAddress.Parse(w1.ip)));
                    SubNetworkPointPool SNPPTo   = new SubNetworkPointPool(new SubNetworkPoint(IPAddress.Parse(w2.ip)));

                    // writeLog("Resolving path from " + SNPPFrom.snps[0].ipaddress + " to " + SNPPTo.snps[0].ipaddress);

                    //Czesciowa sciezka, którą trzeba dodać do nadścieżki
                    var partOfThePath = this.getPathFromRC(sNandRc.RC_IP.ToString(), SNPPFrom, SNPPTo, band,
                                                           frequency);

                    //Sciezka jest pusta
                    if (partOfThePath == null || partOfThePath.snpps.Count == 0)
                    {
                        //canIGoOnAtThisFrequency = false;
                        return(false);
                    }
                    //Ścieżka jest niepusta
                    else
                    {
                        //insertSubPath(ref networkPath, partOfThePath, previousLink, nextLink);
                        return(true);
                    }
                }
            }
            //}

            return(true);
        }
Esempio n. 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);
                }
            }
        }