forest-net
an overlay networks for large-scale virtual worlds
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator
NetInfo.h
Go to the documentation of this file.
1 
9 #ifndef NETINFO_H
10 #define NETINFO_H
11 
12 #include <list>
13 #include <map>
14 #include <set>
15 #include <queue>
16 #include "Forest.h"
17 #include "HashMap.h"
18 #include "IdMap.h"
19 #include "UiSetPair.h"
20 #include "Wgraph.h"
21 #include "RateSpec.h"
22 
23 namespace forest {
24 
25 
41 class NetInfo {
42 public:
43  NetInfo(int,int,int,int);
44  ~NetInfo();
45 
46  // struct used by io routines
47  struct LinkDesc {
48  string nameL, nameR;
49  int numL, numR;
50  int length;
51  RateSpec rates;
52  };
53 
54  enum statusType { UP, DOWN, BOOTING };
55 
56  // methods for working with nodes
57  // predicates
58  bool validNode(int) const;
59  // iterating through nodes
60  int firstNode() const;
61  int nextNode(int) const;
62  // access node attributes
63  int getMaxNode() const;
64  string& getNodeName(int,string&)const ;
65  int getNodeNum(string&) const;
66  int getNodeNum(fAdr_t) const;
67  Forest::ntyp_t getNodeType(int) const;
68  fAdr_t getNodeAdr(int) const;
69  bool getNodeLocation(int, pair<double,double>&) const;
70  statusType getStatus(int) const;
71  // modify node attributes
72  bool setNodeName(int, string&);
73  bool setNodeAdr(int, fAdr_t);
74  bool setNodeLocation(int, pair<double,double>&);
75  void setStatus(int, statusType);
76 
77  // additional methods for leaf nodes
78  // predicates
79  bool isLeaf(int) const;
80  int firstLeaf() const;
81  int nextLeaf(int) const;
82  int firstController() const;
83  int nextController(int) const;
84  // access leaf attributes
85  ipa_t getLeafIpAdr(int) const;
86  // add/modify leaves
87  int addLeaf(const string&, Forest::ntyp_t);
88  bool setLeafType(int, Forest::ntyp_t);
89  bool setLeafIpAdr(int, ipa_t);
90 
91  // additional methods for routers
92  // predicates
93  bool isRouter(int) const;
94  bool validIf(int, int) const;
95  // iterating through routers
96  int firstRouter() const;
97  int nextRouter(int) const;
98  // access router attributes
99  int getMaxRouter() const;
100  int getNumRouters() const;
101  int getIface(int, int) const;
102  int getNumIf(int) const;
103  bool getLeafRange(int,pair<fAdr_t,fAdr_t>&) const;
104  ipa_t getIfIpAdr(int,int) const;
105  ipp_t getIfPort(int,int) const;
106  RateSpec& getIfRates(int,int) const;
107  bool getIfLinks(int,int,pair<int,int>&) const;
108  // add/modify routers
109  int addRouter(const string&);
110  bool addInterfaces(int, int);
111  bool setLeafRange(int,pair<int,int>&);
112  bool setIfIpAdr(int,int,ipa_t);
113  bool setIfPort(int,int,ipp_t);
114  bool setIfLinks(int,int,pair<int,int>&);
115 
116  // methods for working with links
117  // predicates
118  bool validLink(int) const;
119  // iterating through links
120  int firstLink() const;
121  int nextLink(int) const;
122  int firstLinkAt(int) const;
123  int nextLinkAt(int,int) const;
124  // access link attributes
125  int getMaxLink() const;
126  int getLeft(int) const;
127  int getRight(int) const;
128  int getPeer(int,int) const;
129  RateSpec& getLinkRates(int) const;
130  RateSpec& getAvailRates(int) const;
131  RateSpec& getDefLeafRates();
132  int getLinkLength(int) const;
133  int getLinkNum(int,int) const;
134  int getLLnum(int,int) const;
135  int getLeftLLnum(int) const;
136  int getRightLLnum(int) const;
137  uint64_t getNonce(int) const;
138  // add/modify links
139  int addLink(int,int,int,int);
140  bool setLeftLLnum(int,int);
141  bool setRightLLnum(int,int);
142  bool setLinkLength(int,int);
143  bool setNonce(int,uint64_t);
144 
145  // io routines
146  bool read(istream&);
147  string link2string(int) const;
148  string linkProps2string(int) const;
149  string linkState2string(int) const;
150  string toString() const;
151 
152  // locking methods for mutually exclusive access
153  void lock();
154  void unlock();
155 
156 private:
157  int maxRtr;
158  int maxNode;
160  int maxLink;
161  int maxLeaf;
162  int maxCtl;
163 
166  Wgraph *netTopo;
167 
168  struct IfInfo {
169  ipa_t ipAdr;
170  ipp_t port;
171  int firstLink;
172  int lastLink;
173  RateSpec rates;
174  };
175 
177  struct LeafNodeInfo {
178  string name;
179  Forest::ntyp_t nType;
180  ipa_t ipAdr;
181  fAdr_t fAdr;
182  int latitude;
183  int longitude;
184  statusType status;
185  };
186  LeafNodeInfo *leaf;
187  UiSetPair *leaves;
188  set<int> *controllers;
189 
190  static int const UNDEF_LAT = 91; // invalid latitude
191  static int const UNDEF_LONG = 361; // invalid longitude
192 
194  struct RtrNodeInfo {
195  string name;
196  Forest::ntyp_t nType;
197  fAdr_t fAdr;
198  int latitude;
199  int longitude;
200  fAdr_t firstLeafAdr;
201  fAdr_t lastLeafAdr;
202  statusType status;
203  int numIf;
204  IfInfo *iface;
205  };
206  RtrNodeInfo *rtr;
207  UiSetPair *routers;
208 
210  map<string, int> *nameNodeMap;
211 
213  map<fAdr_t, int> *adrNodeMap;
214 
215  HashMap *locLnk2lnk;
216  uint64_t ll2l_key(int,int) const;
217 
218  struct LinkInfo {
219  int leftLnum;
220  int rightLnum;
221  RateSpec rates;
222  RateSpec availRates;
223  uint64_t nonce;
224  };
225  LinkInfo *link;
226 
227  RateSpec defaultLeafRates;
228 
229  pthread_mutex_t glock;
230 
231  // helper methods for reading a NetInfo file
232  bool readRouter(istream&, RtrNodeInfo&, IfInfo*, string&);
233  bool readLocation(istream&, pair<double,double>&);
234  bool readAdrRange(istream&, pair<fAdr_t,fAdr_t>&);
235  bool readRateSpec(istream&, RateSpec&);
236  int readIface(istream&, IfInfo*, string&);
237  bool readLeaf(istream&, LeafNodeInfo&, string&);
238  bool readLink(istream&, LinkDesc&, string&);
239  bool readLinkEndpoint(istream&, string&, int&);
240 
241  // post-input setup and validity checking
242  bool check() const;
243  bool checkLocalLinks() const;
244  bool checkBackBone() const;
245  bool checkAddresses() const;
246  bool checkLeafRange() const;
247  bool checkLeafNodes() const;
248  bool checkLinkRates() const;
249  bool checkRtrRates() const;
250 
251  // toString helper methods
252  string& rtr2string(int,string&) const;
253  string& leaf2string(int,string&) const;
254 };
255 
256 
257 // Methods for working with nodes ///////////////////////////////////
258 
264 inline bool NetInfo::validNode(int n) const {
265  return (isLeaf(n) || isRouter(n));
266 }
267 
272 inline int NetInfo::firstNode() const {
273  return (firstRouter() != 0 ? firstRouter() : firstLeaf());
274 }
275 
282 inline int NetInfo::nextNode(int n) const {
283  return (isLeaf(n) ? nextLeaf(n) :
284  (isRouter(n) ?
285  (nextRouter(n) != 0 ? nextRouter(n) : firstLeaf())
286  : 0));
287 }
288 
294 inline int NetInfo::firstController() const {
295  set<int>::iterator p = controllers->begin();
296  return (p != controllers->end() ? (*p)+maxRtr : 0);
297 }
298 
305 inline int NetInfo::nextController(int n) const {
306  set<int>::iterator p = controllers->find(n-maxRtr);
307  if (p == controllers->end()) return 0;
308  p++;
309  return (p != controllers->end() ? (*p)+maxRtr : 0);
310 }
311 
315 inline int NetInfo::getMaxNode() const { return maxNode; }
316 
322 inline string& NetInfo::getNodeName(int n, string& s) const {
323  if (isLeaf(n)) s = leaf[n-maxRtr].name;
324  else if (isRouter(n)) s = rtr[n].name;
325  else s = "";
326  return s;
327 }
328 
334 inline int NetInfo::getNodeNum(string& s) const {
335  map<string,int>::iterator p = nameNodeMap->find(s);
336  return ((p != nameNodeMap->end()) ? p->second : 0);
337 }
338 
344 inline int NetInfo::getNodeNum(fAdr_t adr) const {
345  map<fAdr_t,int>::iterator p = adrNodeMap->find(adr);
346  return ((p != adrNodeMap->end()) ? p->second : 0);
347 }
348 
353 inline Forest::ntyp_t NetInfo::getNodeType(int n) const {
354  return (isLeaf(n) ? leaf[n-maxRtr].nType :
355  (isRouter(n) ? rtr[n].nType : Forest::UNDEF_NODE));
356 }
357 
363 inline bool NetInfo::setNodeName(int n, string& nam) {
364  if (!validNode(n)) return false;
365  if (isRouter(n)) rtr[n].name = nam;
366  else leaf[n-maxRtr].name = nam;
367  string s;
368  nameNodeMap->erase(getNodeName(n,s));
369  (*nameNodeMap)[nam] = n;
370  return true;
371 }
372 
378 inline bool NetInfo::setNodeAdr(int n, fAdr_t adr) {
379  if (isLeaf(n)) leaf[n-maxRtr].fAdr = adr;
380  else if (isRouter(n)) rtr[n].fAdr = adr;
381  else return false;
382  adrNodeMap->erase(getNodeAdr(n));
383  (*adrNodeMap)[adr] = n;
384  return true;
385 }
392 inline bool NetInfo::setNodeLocation(int n, pair<double,double>& loc) {
393  if (isLeaf(n)) {
394  leaf[n-maxRtr].latitude = (int) 1000000*loc.first;
395  leaf[n-maxRtr].longitude = (int) 1000000*loc.second;
396  } else if (isRouter(n)) {
397  rtr[n].latitude = (int) 1000000*loc.first;
398  rtr[n].longitude = (int) 1000000*loc.second;
399  } else return false;
400  return true;
401 }
402 
407 inline void NetInfo::setStatus(int n, statusType status) {
408  if (isLeaf(n)) leaf[n-maxRtr].status = status;
409  else rtr[n].status = status;
410 }
411 
412 // Additional methods for working with leaf nodes ///////////////////
413 
419 inline bool NetInfo::isLeaf(int n) const {
420  return (n <= maxRtr ? 0 : leaves->isIn(n - maxRtr));
421 }
422 
428 inline int NetInfo::firstLeaf() const {
429  return (leaves->firstIn() != 0 ? maxRtr + leaves->firstIn() : 0);
430 }
431 
438 inline int NetInfo::nextLeaf(int n) const {
439  int nxt = leaves->nextIn(n-maxRtr);
440  return (nxt != 0 ? maxRtr + nxt : 0);
441 }
442 
448 inline bool NetInfo::setLeafType(int n, Forest::ntyp_t typ) {
449  if (isLeaf(n)) leaf[n-maxRtr].nType = typ;
450  else return false;
451  return true;
452 }
453 
459 inline bool NetInfo::setLeafIpAdr(int n, ipa_t ip) {
460  if (isLeaf(n)) leaf[n-maxRtr].ipAdr = ip;
461  else return false;
462  return true;
463 }
464 
465 // Additional methods for working with routers //////////////////////
466 
472 inline bool NetInfo::isRouter(int n) const { return routers->isIn(n); }
473 
480 inline bool NetInfo::validIf(int r, int iface) const {
481  return isRouter(r) && (1 <= iface && iface <= rtr[r].numIf &&
482  rtr[r].iface[iface].ipAdr != 0);
483 }
484 
490 inline int NetInfo::firstRouter() const { return routers->firstIn(); }
491 
498 inline int NetInfo::nextRouter(int r) const { return routers->nextIn(r); }
499 
503 inline int NetInfo::getMaxRouter() const { return maxRtr; }
504 
508 inline int NetInfo::getNumRouters() const { return routers->getNumIn(); }
509 
510 
516 inline bool NetInfo::getLeafRange(int r, pair<fAdr_t,fAdr_t>& range) const {
517  if (!isRouter(r)) return false;
518  range.first = rtr[r].firstLeafAdr;
519  range.second = rtr[r].lastLeafAdr;
520  return true;
521 }
522 
528 inline int NetInfo::getNumIf(int r) const {
529  return (isRouter(r) ? rtr[r].numIf : 0);
530 }
531 
536 inline ipa_t NetInfo::getLeafIpAdr(int n) const {
537  return (isLeaf(n) ? leaf[n-maxRtr].ipAdr : 0);
538 }
539 
544 inline fAdr_t NetInfo::getNodeAdr(int n) const {
545  return (isLeaf(n) ? leaf[n-maxRtr].fAdr :
546  (isRouter(n) ? rtr[n].fAdr : 0));
547 }
548 
555 inline bool NetInfo::getNodeLocation(int n, pair<double,double>& loc) const {
556  if (isLeaf(n)) {
557  loc.first = leaf[n-maxRtr].latitude/1000000.0;
558  loc.second = leaf[n-maxRtr].longitude/1000000.0;
559  } else if (isRouter(n)) {
560  loc.first = rtr[n].latitude/1000000.0;
561  loc.second = rtr[n].longitude/1000000.0;
562  } else return false;
563  return true;
564 }
565 
570 inline NetInfo::statusType NetInfo::getStatus(int n) const {
571  if (isLeaf(n)) return leaf[n-maxRtr].status;
572  else return rtr[n].status;
573 }
574 
581 inline ipa_t NetInfo::getIfIpAdr(int n, int iface) const {
582  return (validIf(n,iface) ? rtr[n].iface[iface].ipAdr : 0);
583 }
584 
591 inline ipp_t NetInfo::getIfPort(int n, int iface) const {
592  return (validIf(n,iface) ? rtr[n].iface[iface].port : 0);
593 }
594 
600 inline RateSpec& NetInfo::getIfRates(int r, int iface) const {
601  return rtr[r].iface[iface].rates;
602 }
603 
610 inline bool NetInfo::getIfLinks(int r, int iface, pair<int,int>& links) const {
611  if (!validIf(r,iface)) return false;
612  links.first = rtr[r].iface[iface].firstLink;
613  links.second = rtr[r].iface[iface].lastLink;
614  return true;
615 }
616 
622 inline bool NetInfo::setLeafRange(int r, pair<fAdr_t,fAdr_t>& range) {
623  if (!isRouter(r)) return false;
624  rtr[r].firstLeafAdr = range.first;
625  rtr[r].lastLeafAdr = range.second;
626  return true;
627 }
628 
648 inline bool NetInfo::setIfLinks(int r, int iface, pair<int,int>& links) {
649  if (!validIf(r,iface)) return false;
650  rtr[r].iface[iface].firstLink = links.first;
651  rtr[r].iface[iface].lastLink = links.second;
652  return true;
653 }
654 
661 inline bool NetInfo::setIfIpAdr(int r, int iface, ipa_t ip) {
662  if (validIf(r,iface)) rtr[r].iface[iface].ipAdr = ip;
663  else return false;
664  return true;
665 }
666 
673 inline bool NetInfo::setIfPort(int r, int iface, ipp_t port) {
674  if (validIf(r,iface)) rtr[r].iface[iface].port = port;
675  else return false;
676  return true;
677 }
678 
679 // Methods for working with links ///////////////////////////////////
680 
686 inline bool NetInfo::validLink(int lnk) const {
687  return netTopo->validEdge(lnk);
688 }
689 
694 inline int NetInfo::firstLink() const { return netTopo->first(); }
695 
701 inline int NetInfo::nextLink(int lnk) const { return netTopo->next(lnk); }
702 
708 inline int NetInfo::firstLinkAt(int n) const {
709  return (validNode(n) ? netTopo->firstAt(n) : 0);
710 }
711 
718 inline int NetInfo::nextLinkAt(int n, int lnk) const {
719  return (validNode(n) ? netTopo->nextAt(n,lnk) : 0);
720 }
721 
725 inline int NetInfo::getMaxLink() const { return maxLink; }
726 
733 inline int NetInfo::getLeft(int lnk) const {
734  return (validLink(lnk) ? netTopo->left(lnk) : 0);
735 }
736 
743 inline int NetInfo::getRight(int lnk) const {
744  return (validLink(lnk) ? netTopo->right(lnk) : 0);
745 }
746 
753 inline int NetInfo::getPeer(int n, int lnk) const {
754  return (validLink(lnk) ? netTopo->mate(n,lnk) : 0);
755 }
756 
764 inline int NetInfo::getLLnum(int lnk, int r) const {
765  return (!(validLink(lnk) && isRouter(r)) ? 0 :
766  (r == netTopo->left(lnk) ? getLeftLLnum(lnk) :
767  (r == netTopo->right(lnk) ? getRightLLnum(lnk) : 0)));
768 }
769 
776 inline int NetInfo::getLeftLLnum(int lnk) const {
777  int r = getLeft(lnk);
778  return ((lnk != 0 && isRouter(r)) ? link[lnk].leftLnum : 0);
779 }
780 
787 inline int NetInfo::getRightLLnum(int lnk) const {
788  int r = getRight(lnk);
789  return ((lnk != 0 && isRouter(r)) ? link[lnk].rightLnum : 0);
790 }
791 
796 inline uint64_t NetInfo::getNonce(int lnk) const {
797  return (validLink(lnk) ? link[lnk].nonce : 0);
798 }
799 
804 inline RateSpec& NetInfo::getLinkRates(int lnk) const {
805  return link[lnk].rates;
806 }
807 
812 inline RateSpec& NetInfo::getAvailRates(int lnk) const {
813  return link[lnk].availRates;
814 }
815 
819 inline RateSpec& NetInfo::getDefLeafRates() {
820  return defaultLeafRates;
821 }
822 
828 inline int NetInfo::getLinkLength(int lnk) const {
829  return (validLink(lnk) ? netTopo->weight(lnk) : 0);
830 }
831 
838 inline int NetInfo::getLinkNum(int nn, int llnk) const {
839  if (!validNode(nn)) return 0;
840  if (isRouter(nn)) return locLnk2lnk->get(ll2l_key(nn,llnk))/2;
841  return firstLinkAt(nn);
842 }
843 
850 inline bool NetInfo::setLeftLLnum(int lnk, int loc) {
851  if (validLink(lnk)) link[lnk].leftLnum = loc;
852  else return false;
853  return true;
854 }
855 
862 inline bool NetInfo::setRightLLnum(int lnk, int loc) {
863  if (validLink(lnk)) link[lnk].rightLnum = loc;
864  else return false;
865  return true;
866 }
867 
873 inline bool NetInfo::setNonce(int lnk, uint64_t nonce) {
874  if (!validLink(lnk)) return false;
875  link[lnk].nonce = nonce;
876  return true;
877 }
878 
905 inline bool NetInfo::setLinkLength(int lnk, int len) {
906  if (validLink(lnk)) netTopo->setWeight(lnk,len);
907  else return false;
908  return true;
909 }
910 
916 inline uint64_t NetInfo::ll2l_key(int r, int llnk) const {
917  return (uint64_t(r) << 32) | (uint64_t(llnk) & 0xffffffff);
918 }
919 
924 inline void NetInfo::lock() { pthread_mutex_lock(&glock); }
925 
928 inline void NetInfo::unlock() { pthread_mutex_unlock(&glock); }
929 
930 } // ends namespace
931 
932 
933 #endif