Exemplo n.º 1
0
 def initialize_ecmp_deps(self):
     """Initialize ECMP dependencies"""
     for n, node in map(
             lambda x: (x[0], self.node(x[0])),
             filter(lambda x: x[1] > 1, self.dag.out_degree_iter())):
         if node.has_any_fake_node():
             log.debug('%s does ECMP and has a fake node', n)
             self.ecmp[n].add(n)
         else:
             f = []
             paths = self._p.default_path(n, self.dest)
             for p in paths:
                 # Try to find the first fake node for each path
                 for h in p[:-1]:
                     if self.node(h).has_any_fake_node():
                         f.add(h)
                         break
             if len(f) > 0 and len(f) < len(paths):
                 log.warning(
                     '%s does ECMP and has less downstream fake '
                     'nodes than paths (%s < %s), forcing it to '
                     'have a fake node.', n, len(f), len(paths))
                 node.fake_type = Node.GLOBAL
             elif f:
                 log.debug('Registering ECMP depencies on %s: %s', n, f)
                 for fake in f:
                     self.ecmp[fake].add(f)
Exemplo n.º 2
0
 def __read_private_ips(self, filename):
     router_private_address = defaultdict(dict)
     ip_to_bd = defaultdict(list)
     try:
         with open(filename, 'r') as f:
             private_address_binding = json.load(f)
             for subnets in private_address_binding.itervalues():
                 # Log router id in broadcast domain
                 sub = subnets.keys()
                 for rid, ip in subnets.iteritems():
                     # Enable single private address as string
                     if not is_container(ip):
                         ip = [ip]
                     # Log private addresses adjacencies
                     other = sub[:]
                     other.remove(rid)
                     for s in other:
                         router_private_address[rid][s] = ip
                     for i in ip:
                         # Register the broadcast domain for each ip
                         ip_to_bd[i] = other
     except ValueError as e:
         log.error('Incorrect private IP addresses binding file')
         log.error(str(e))
         ip_to_bd.clear()
         router_private_address.clear()
     except IOError as e:
         log.warning('Cannot read private address file')
         ip_to_bd.clear()
         router_private_address.clear()
     return router_private_address, ip_to_bd
Exemplo n.º 3
0
 def initialize_ecmp_deps(self):
     """Initialize ECMP dependencies"""
     for n, node in map(lambda x: (x[0], self.node(x[0])),
                        filter(lambda x: x[1] > 1,
                               self.dag.out_degree_iter())):
         if node.has_any_fake_node():
             log.debug('%s does ECMP and has a fake node', n)
             self.ecmp[n].add(n)
         else:
             f = []
             paths = self._p.default_path(n, self.dest)
             for p in paths:
                 # Try to find the first fake node for each path
                 for h in p[:-1]:
                     if self.node(h).has_any_fake_node():
                         f.add(h)
                         break
             if len(f) > 0 and len(f) < len(paths):
                 log.warning('%s does ECMP and has less downstream fake '
                             'nodes than paths (%s < %s), forcing it to '
                             'have a fake node.', n, len(f), len(paths))
                 node.fake_type = Node.GLOBAL
             elif f:
                 log.debug('Registering ECMP depencies on %s: %s', n, f)
                 for fake in f:
                     self.ecmp[fake].add(f)
Exemplo n.º 4
0
 def _get_proxy_routes(self, points):
     for prefix, parts in groupby(sorted(points, key=itemgetter(3)),
                                  key=itemgetter(3)):
         route = []
         for p in parts:
             src, dst, cost = p[0], p[1], p[2]
             if cost >= 0:
                 src = None
             fwd_addr = self.root.get_fwd_address(src, dst)
             # Can have multiple private addresses per interface, handle
             # here the selection ...
             if isinstance(fwd_addr, list):
                 try:
                     fwd_addr = fwd_addr[cost]
                 except IndexError:
                     log.warning('Required private forwarding address index'
                                 ' is out of bounds. Wanted index %s '
                                 '- Have %s elements.',
                                 abs(cost), len(fwd_addr))
                     fwd_addr = fwd_addr[0]
                 cost = 1
             try:
                 fwd_addr = str(ip_interface(fwd_addr).ip)
             except ValueError:
                 log.debug('Forwarding address for %s-%s has no netmask: %s',
                           src, dst, fwd_addr)
             route.append((fwd_addr, str(cost)))
         yield prefix, route
Exemplo n.º 5
0
 def testWeird(self):
     log.warning('Testing Weird')
     self._test(self.gadgets.weird,
                {'3_8': nx.DiGraph([('D', 'C'),
                                    ('C', 'B'),
                                    ('B', 'A')])},
                2)
Exemplo n.º 6
0
 def testTrapezoid(self):
     log.warning('Testing Trapezoid')
     self._test(self.gadgets.trap,
                {'1_8': nx.DiGraph([('R1', 'R2'),
                                    ('R2', 'E2'),
                                    ('E2', 'D')])},
                1)
Exemplo n.º 7
0
 def testSquareWithThreeConsecutiveChanges(self):
     log.warning('Testing SquareWithThreeConsecutiveChanges')
     self._test(
         self.gadgets.square, {
             '3_8':
             IGPGraph([('D2', 'B1'), ('B1', 'T1'), ('T1', 'T2'),
                       ('T2', 'B2'), ('B2', 'D1')])
         }, 3)
Exemplo n.º 8
0
 def testDiamond(self):
     log.warning('Testing Diamond')
     self._test(
         self.gadgets.diamond, {
             '3_8':
             IGPGraph([('A', 'Y1'), ('A', 'Y2'), ('Y2', 'X'), ('Y1', 'X'),
                       ('X', 'D'), ('O', 'D')])
         }, 2)
Exemplo n.º 9
0
 def testPaperGadget(self):
     log.warning('Testing PaperGadget')
     self._test(
         self.gadgets.paper_gadget, {
             '3_8':
             IGPGraph([('H1', 'X'), ('H2', 'X'), ('H3', 'X'), ('X', 'Y'),
                       ('A1', 'Y'), ('A2', 'Y')])
         }, 1)
Exemplo n.º 10
0
 def remove_lsa(self, *lsas):
     """Instructs the southbound controller to remove LSAs"""
     lsas = list(lsas)
     if lsas:
         self.quagga_manager.remove(lsas)
         self.advertized_lsa.difference_update(lsas)
     else:
         log.warning('Tried to remove an empty list of LSA')
 def advertize_lsa(self, *lsas):
     """Instructs the southbound controller to announce LSAs"""
     lsas = list(lsas)
     if lsas:
         self.quagga_manager.add(lsas)
         self.advertized_lsa.update(lsas)
     else:
         log.warning('Tried to advertize an empty list of LSA')
 def remove_lsa(self, *lsas):
     """Instructs the southbound controller to remove LSAs"""
     lsas = list(lsas)
     if lsas:
         self.quagga_manager.remove(lsas)
         self.advertized_lsa.difference_update(lsas)
     else:
         log.warning('Tried to remove an empty list of LSA')
Exemplo n.º 13
0
 def advertize_lsa(self, *lsas):
     """Instructs the southbound controller to announce LSAs"""
     lsas = list(lsas)
     if lsas:
         self.quagga_manager.add(lsas)
         self.advertized_lsa.update(lsas)
     else:
         log.warning('Tried to advertize an empty list of LSA')
Exemplo n.º 14
0
 def testDoubleDiamond(self):
     log.warning('Testing DoubleDiamond')
     self._test(
         self.gadgets.ddiamond, {
             '1_8':
             IGPGraph([('H1', 'Y1'), ('H1', 'Y2'), ('Y1', 'X'), ('Y2', 'X'),
                       ('H2', 'X'), ('X', 'D')])
         }, 3)
Exemplo n.º 15
0
 def testParallel(self):
     log.warning('Testing Parallel')
     self._test(
         self.gadgets.parallel, {
             '3_8':
             IGPGraph([('A2', 'B2'), ('B2', 'C2'), ('C2', 'D2'),
                       ('D2', 'D1'), ('D1', 'C1'), ('C1', 'B1'),
                       ('B1', 'A1'), ('A1', 'D')])
         }, 4)
Exemplo n.º 16
0
 def testSquareWithThreeConsecutiveChanges(self):
     log.warning('Testing SquareWithThreeConsecutiveChanges')
     self._test(self.gadgets.square,
                {'3_8': nx.DiGraph([('D2', 'B1'),
                                    ('B1', 'T1'),
                                    ('T1', 'T2'),
                                    ('T2', 'B2'),
                                    ('B2', 'D1')])},
                3)
Exemplo n.º 17
0
 def testSquareWithThreeConsecutiveChangesAndMultipleRequirements(self):
     log.warning('Testing SquareWithThreeConsecutiveChanges'
                 'AndMultipleRequirements')
     dag = IGPGraph([('D2', 'B1'), ('B1', 'T1'), ('T1', 'T2'), ('T2', 'B2'),
                     ('B2', 'D1')])
     self._test(self.gadgets.square, {
         '3_8': dag,
         '8_3': dag.reverse(copy=True)
     }, 5)
Exemplo n.º 18
0
 def testDiamond(self):
     log.warning('Testing Diamond')
     self._test(self.gadgets.diamond,
                {'3_8': nx.DiGraph([('A', 'Y1'),
                                    ('A', 'Y2'),
                                    ('Y2', 'X'),
                                    ('Y1', 'X'),
                                    ('X', 'D'),
                                    ('O', 'D')])},
                2)
Exemplo n.º 19
0
 def testPaperGadget(self):
     log.warning('Testing PaperGadget')
     self._test(self.gadgets.paper_gadget,
                {'3_8': nx.DiGraph([('H1', 'X'),
                                    ('H2', 'X'),
                                    ('H3', 'X'),
                                    ('X', 'Y'),
                                    ('A1', 'Y'),
                                    ('A2', 'Y')])},
                1)
Exemplo n.º 20
0
 def testDoubleDiamond(self):
     log.warning('Testing DoubleDiamond')
     self._test(self.gadgets.ddiamond,
                {'1_8': nx.DiGraph([('H1', 'Y1'),
                                    ('H1', 'Y2'),
                                    ('Y1', 'X'),
                                    ('Y2', 'X'),
                                    ('H2', 'X'),
                                    ('X', 'D')])},
                3)
Exemplo n.º 21
0
 def testTrapezoidWithEcmp(self):
     log.warning('Testing TrapezoidWithEcmp')
     self._test(self.gadgets.trap,
                {'2_8': nx.DiGraph([('R1', 'R2'),
                                    ('R2', 'E2'),
                                    ('E2', 'D'),
                                    # ECMP on E1
                                    ('E1', 'D'),
                                    ('E1', 'R1')])},
                3)
Exemplo n.º 22
0
 def testSquareWithThreeConsecutiveChangesAndMultipleRequirements(self):
     log.warning('Testing SquareWithThreeConsecutiveChanges'
                 'AndMultipleRequirements')
     dag = nx.DiGraph([('D2', 'B1'),
                       ('B1', 'T1'),
                       ('T1', 'T2'),
                       ('T2', 'B2'),
                       ('B2', 'D1')])
     self._test(self.gadgets.square,
                {'3_8': dag, '8_3': dag.reverse(copy=True)},
                5)
Exemplo n.º 23
0
 def testParallel(self):
     log.warning('Testing Parallel')
     self._test(self.gadgets.parallel,
                {'3_8': nx.DiGraph([('A2', 'B2'),
                                    ('B2', 'C2'),
                                    ('C2', 'D2'),
                                    ('D2', 'D1'),
                                    ('D1', 'C1'),
                                    ('C1', 'B1'),
                                    ('B1', 'A1'),
                                    ('A1', 'D')])},
                4)
Exemplo n.º 24
0
 def solve(self, topo, requirement_dags):
     # a list of tuples with info on the node to be attracted,
     # the forwarding address, the cost to be set in the fake LSA,
     # and the respective destinations
     self.fake_ospf_lsas = []
     self.reqs = requirement_dags
     self.igp_graph = topo
     self.igp_paths = ShortestPath(self.igp_graph)
     # process input forwarding DAGs, one at the time
     for dest, dag in requirement_dags.iteritems():
         log.info('Solving DAG for dest %s', dest)
         self.dest, self.dag = dest, dag
         log.debug('Checking dest in dag')
         ssu.add_dest_to_graph(dest, dag)
         log.debug('Checking dest in igp graph')
         ssu.add_dest_to_graph(dest,
                               topo,
                               edges_src=dag.predecessors,
                               spt=self.igp_paths,
                               metric=self.new_edge_metric)
         ssu.complete_dag(dag,
                          topo,
                          dest,
                          self.igp_paths,
                          skip=self.reqs.keys())
         # Add temporarily the destination to the igp graph and/or req dags
         if not ssu.solvable(dag, topo):
             log.warning('Skipping requirement for dest: %s', dest)
             continue
         for node in dag:
             nhs = self.nhs_for(node, dest, dag)
             if not nhs:
                 continue
             for req_nh in nhs:
                 log.debug('Placing a fake node for %s->%s', node, req_nh)
                 for i in xrange(get_edge_multiplicity(dag, node, req_nh)):
                     self.fake_ospf_lsas.append(
                         ssu.LSA(node=node,
                                 nh=req_nh,
                                 cost=(-1 - i),
                                 dest=dest))
         # Check whether we need to include one more fake node to handle
         # the case where we create a new route from scratch.
         for p in dag.predecessors_iter(dest):
             if not is_fake(topo, p, dest):
                 continue
             log.debug(
                 '%s is a terminal node towards %s but had no prior '
                 'route to it! Adding a synthetic route', p, dest)
             self.fake_ospf_lsas.append(
                 ssu.GlobalLie(dest, self.new_edge_metric, p))
     return self.fake_ospf_lsas
Exemplo n.º 25
0
 def solve(self, graph, requirements):
     """Compute the augmented topology for a given graph and a set of
     requirements.
     :type graph: IGPGraph
     :type requirements: { dest: IGPGraph }
     :param requirements: the set of requirement DAG on a per dest. basis
     :return: list of fake LSAs"""
     self.reqs = requirements
     log.info('Preparing IGP graph')
     self.g = prepare_graph(graph, requirements)
     log.info('Computing SPT')
     self._p = ShortestPath(graph)
     lsa = []
     for dest, dag in requirements.iteritems():
         self.dest, self.dag = dest, dag
         self.ecmp.clear()
         log.info('Evaluating requirement %s', dest)
         log.info('Ensuring the consistency of the DAG')
         self.check_dest()
         ssu.complete_dag(self.dag,
                          self.g,
                          self.dest,
                          self._p,
                          skip=self.reqs.keys())
         log.info('Computing original and required next-hop sets')
         for n, node in self.nodes():
             node.forced_nhs = set(self.dag.successors(n))
             node.original_nhs = set(
                 [p[1] for p in self._p.default_path(n, self.dest)])
         if not ssu.solvable(self.dag, self.g):
             log.warning('Consistency check failed, skipping %s', dest)
             continue
         log.info('Placing initial fake nodes')
         self.place_fake_nodes()
         log.info('Initializing fake nodes')
         self.initialize_fake_nodes()
         log.info('Propagating initial lower bounds')
         self.propagate_lb()
         log.debug('Fake node bounds: %s',
                   [n for _, n in self.nodes() if n.has_any_fake_node()])
         log.info('Reducing the augmented topology')
         self.merge_fake_nodes()
         self.remove_redundant_fake_nodes()
         log.info('Generating LSAs')
         lsas = self.create_fake_lsa()
         log.info('Solved the DAG for destination %s with LSA set: %s',
                  self.dest, lsas)
         lsa.extend(lsas)
     return lsa
Exemplo n.º 26
0
 def testTrapezoidWithEcmp(self):
     log.warning('Testing TrapezoidWithEcmp')
     self._test(
         self.gadgets.trap,
         {
             '2_8':
             IGPGraph([
                 ('R1', 'R2'),
                 ('R2', 'E2'),
                 ('E2', 'D'),
                 # ECMP on E1
                 ('E1', 'D'),
                 ('E1', 'R1')
             ])
         },
         3)
Exemplo n.º 27
0
 def solve(self, graph, requirements):
     """Compute the augmented topology for a given graph and a set of
     requirements.
     :type graph: IGPGraph
     :type requirements: { dest: IGPGraph }
     :param requirements: the set of requirement DAG on a per dest. basis
     :return: list of fake LSAs"""
     self.reqs = requirements
     log.info('Preparing IGP graph')
     self.g = prepare_graph(graph, requirements)
     log.info('Computing SPT')
     self._p = ShortestPath(graph)
     lsa = []
     for dest, dag in requirements.iteritems():
         self.dest, self.dag = dest, dag
         self.ecmp.clear()
         log.info('Evaluating requirement %s', dest)
         log.info('Ensuring the consistency of the DAG')
         self.check_dest()
         ssu.complete_dag(self.dag, self.g, self.dest, self._p,
                          skip=self.reqs.keys())
         log.info('Computing original and required next-hop sets')
         for n, node in self.nodes():
             node.forced_nhs = set(self.dag.successors(n))
             node.original_nhs = set([p[1] for p in
                                      self._p.default_path(n, self.dest)])
         if not ssu.solvable(self.dag, self.g):
             log.warning('Consistency check failed, skipping %s', dest)
             continue
         log.info('Placing initial fake nodes')
         self.place_fake_nodes()
         log.info('Initializing fake nodes')
         self.initialize_fake_nodes()
         log.info('Propagating initial lower bounds')
         self.propagate_lb()
         log.debug('Fake node bounds: %s',
                   [n for _, n in self.nodes() if n.has_any_fake_node()])
         log.info('Reducing the augmented topology')
         self.merge_fake_nodes()
         self.remove_redundant_fake_nodes()
         log.info('Generating LSAs')
         lsas = self.create_fake_lsa()
         log.info('Solved the DAG for destination %s with LSA set: %s',
                  self.dest, lsas)
         lsa.extend(lsas)
     return lsa
Exemplo n.º 28
0
 def create_fake_lsa(self):
     lsa = []
     for n in self.dag:
         if n == self.dest:
             continue
         node = self.node(n)
         for nh in node.forced_nhs:
             if nh == self.dest:
                 log.warning('Ignoring LSA towards nh == dest ?!?')
                 continue
             log.debug('Creating LSA for %s -> %s', n, nh)
             lsa.append(ssu.LSA(node=n,
                                nh=nh,
                                cost=node.lb + 1
                                if node.fake == Node.GLOBAL else -1,
                                dest=self.dest))
     return lsa
Exemplo n.º 29
0
 def solve(self, topo, requirement_dags):
     # a list of tuples with info on the node to be attracted,
     # the forwarding address, the cost to be set in the fake LSA,
     # and the respective destinations
     self.fake_ospf_lsas = []
     self.reqs = requirement_dags
     self.igp_graph = topo
     self.igp_paths = ShortestPath(self.igp_graph)
     # process input forwarding DAGs, one at the time
     for dest, dag in requirement_dags.iteritems():
         log.info('Solving DAG for dest %s', dest)
         self.dest, self.dag = dest, dag
         log.debug('Checking dest in dag')
         ssu.add_dest_to_graph(dest, dag)
         log.debug('Checking dest in igp graph')
         ssu.add_dest_to_graph(dest, topo,
                               edges_src=dag.predecessors,
                               spt=self.igp_paths,
                               metric=self.new_edge_metric)
         ssu.complete_dag(dag, topo, dest, self.igp_paths,
                          skip=self.reqs.keys())
         # Add temporarily the destination to the igp graph and/or req dags
         if not ssu.solvable(dag, topo):
             log.warning('Skipping requirement for dest: %s', dest)
             continue
         for node in dag:
             nhs = self.nhs_for(node, dest, dag)
             if not nhs:
                 continue
             for req_nh in nhs:
                 log.debug('Placing a fake node for %s->%s', node, req_nh)
                 for i in xrange(get_edge_multiplicity(dag, node, req_nh)):
                     self.fake_ospf_lsas.append(ssu.LSA(node=node,
                                                        nh=req_nh,
                                                        cost=(-1 - i),
                                                        dest=dest))
         # Check whether we need to include one more fake node to handle
         # the case where we create a new route from scratch.
         for p in dag.predecessors_iter(dest):
             if not is_fake(topo, p, dest):
                 continue
             log.debug('%s is a terminal node towards %s but had no prior '
                       'route to it! Adding a synthetic route', p, dest)
             self.fake_ospf_lsas.append(
                     ssu.GlobalLie(dest, self.new_edge_metric, p))
     return self.fake_ospf_lsas
Exemplo n.º 30
0
 def create_fake_lsa(self):
     lsa = []
     for n in self.dag:
         if n == self.dest:
             continue
         node = self.node(n)
         for nh in node.forced_nhs:
             if nh == self.dest:
                 log.warning('Ignoring LSA towards nh == dest ?!?')
                 continue
             log.debug('Creating LSA for %s -> %s', n, nh)
             lsa.append(
                 ssu.LSA(node=n,
                         nh=nh,
                         cost=node.lb +
                         1 if node.fake == Node.GLOBAL else -1,
                         dest=self.dest))
     return lsa
Exemplo n.º 31
0
 def solve(self, topo, requirement_dags):
     # a list of tuples with info on the node to be attracted,
     # the forwarding address, the cost to be set in the fake LSA,
     # and the respective destinations
     self.fake_ospf_lsas = []
     self.reqs = requirement_dags
     self.igp_graph = topo
     self.igp_paths = ShortestPath(self.igp_graph)
     log.debug('Original SPT: %s', self.igp_paths)
     # process input forwarding DAGs, one at the time
     for dest, dag in requirement_dags.iteritems():
         log.debug('Solving DAG for dest %s', dest)
         self.dest, self.dag = dest, dag
         log.debug('Checking dest in dag')
         ssu.add_dest_to_graph(dest, dag)
         log.debug('Checking dest in igp graph')
         ssu.add_dest_to_graph(dest,
                               topo,
                               edges_src=dag.predecessors,
                               spt=self.igp_paths,
                               metric=self.new_edge_metric)
         ssu.complete_dag(dag,
                          topo,
                          dest,
                          self.igp_paths,
                          skip=self.reqs.keys())
         # Add temporarily the destination to the igp graph and/or req dags
         if not ssu.solvable(dag, topo):
             log.warning('Skipping requirement for dest: %s', dest)
             continue
         for node in nx.topological_sort(dag, reverse=True)[1:]:
             nhs, original_nhs = self.nhs_for(node, dag, dest)
             if not self.require_fake_node(nhs, original_nhs):
                 log.debug('%s does not require a fake node (%s - %s)',
                           node, nhs, original_nhs)
                 continue
             for req_nh in nhs:
                 log.debug('Placing a fake node for nh %s', req_nh)
                 self.fake_ospf_lsas.append(
                     ssu.LSA(node=node, nh=req_nh, cost=-1, dest=dest))
     return self.fake_ospf_lsas
Exemplo n.º 32
0
 def solve(self, topo, requirement_dags):
     # a list of tuples with info on the node to be attracted,
     # the forwarding address, the cost to be set in the fake LSA,
     # and the respective destinations
     self.fake_ospf_lsas = []
     self.reqs = requirement_dags
     self.igp_graph = topo
     self.igp_paths = ShortestPath(self.igp_graph)
     log.debug('Original SPT: %s', self.igp_paths)
     # process input forwarding DAGs, one at the time
     for dest, dag in requirement_dags.iteritems():
         log.debug('Solving DAG for dest %s', dest)
         self.dest, self.dag = dest, dag
         log.debug('Checking dest in dag')
         ssu.add_dest_to_graph(dest, dag)
         log.debug('Checking dest in igp graph')
         ssu.add_dest_to_graph(dest, topo,
                               edges_src=dag.predecessors,
                               spt=self.igp_paths,
                               metric=self.new_edge_metric)
         ssu.complete_dag(dag, topo, dest, self.igp_paths,
                          skip=self.reqs.keys())
         # Add temporarily the destination to the igp graph and/or req dags
         if not ssu.solvable(dag, topo):
             log.warning('Skipping requirement for dest: %s', dest)
             continue
         for node in nx.topological_sort(dag, reverse=True)[1:]:
             nhs, original_nhs = self.nhs_for(node, dag, dest)
             if not self.require_fake_node(nhs, original_nhs):
                 log.debug('%s does not require a fake node (%s - %s)',
                           node, nhs, original_nhs)
                 continue
             for req_nh in nhs:
                 log.debug('Placing a fake node for nh %s', req_nh)
                 self.fake_ospf_lsas.append(ssu.LSA(node=node,
                                                    nh=req_nh,
                                                    cost=-1,
                                                    dest=dest))
     return self.fake_ospf_lsas
Exemplo n.º 33
0
 def __init__(self):
     self.BASE_NET = ip_network(CFG.get(DEFAULTSECT, 'base_net'))
     self.private_address_network = ip_network(CFG.get(DEFAULTSECT,
                                               'private_net'))
     try:
         with open(CFG.get(DEFAULTSECT, 'private_ips'), 'r') as f:
             self.private_address_binding = json.load(f)
             self.router_private_address = {}
             for subnets in self.private_address_binding.itervalues():
                 for rid, ip in subnets.iteritems():
                     try:
                         iplist = self.router_private_address[rid]
                     except KeyError:
                         iplist = self.router_private_address[rid] = []
                     # Enable single private address as string
                     if isinstance(ip, str):
                         ip = [ip]
                     iplist.extend(ip)
     except Exception as e:
         log.warning('Incorrect private IP addresses binding file')
         log.warning(str(e))
         self.private_address_binding = {}
         self.router_private_address = {}
     self.last_line = ''
     self.leader_watchdog = None
     self.transaction = None
     self.graph = IGPGraph()
     self.routers = {}  # router-id : lsa
     self.networks = {}  # DR IP : lsa
     self.ext_networks = {}  # (router-id, dest) : lsa
     self.controllers = defaultdict(list)  # controller nr : ip_list
     self.listener = {}
     self.keep_running = True
     self.queue = Queue()
     self.processing_thread = Thread(target=self.process_lsa,
                                     name="lsa_processing_thread")
     self.processing_thread.setDaemon(True)
     self.processing_thread.start()
Exemplo n.º 34
0
"""This module provides a structure to represent an IGP topology"""
import os
import networkx as nx

from fibbingnode import log

# The draw_graph call will be remapped to 'nothing' if matplotlib (aka extra
# packages) is not available
try:
    import matplotlib.pyplot as plt
except ImportError:
    log.warning('Missing packages to draw the network, disabling the fonction')
    def draw_graph(*_): pass
else:
    def draw_graph(graph, output):
        """If matplotlib is available, draw the given graph to output file"""
        try:
            layout = spring_layout(graph)
            metrics = {
                (src, dst): data['metric']
                for src, dst, data in graph.edges_iter(data=True)
            }
            nx.draw_networkx_edge_labels(graph, layout, edge_labels=metrics)
            nx.draw(graph, layout, node_size=20)
            nx.draw_networkx_labels(graph, layout, labels={n: n for n in graph})
            if os.path.exists(output):
                os.unlink(output)
            plt.savefig(output)
            plt.close()
            log.debug('Graph of %d nodes saved in %s', len(graph), output)
        except:
Exemplo n.º 35
0
import heapq
import networkx as nx
from itertools import count

from fibbingnode import log
import fibbingnode.algorithms.utils as ssu
from fibbingnode.misc.utils import extend_paths_list, is_container

# The draw_graph call will be remapped to 'nothing' if matplotlib (aka extra
# packages) is not available
try:
    import matplotlib
    matplotlib.use('PDF')
    import matplotlib.pyplot as plt
except ImportError:
    log.warning('Missing packages to draw the network, disabling the fonction')
    def draw_graph(*_):
        """Can't draw without matplotlib"""
        pass
else:
    def draw_graph(graph, output):
        """If matplotlib is available, draw the given graph to output file"""
        try:
            layout = nx.spring_layout(graph)
            metrics = {
                (src, dst): data['metric']
                for src, dst, data in graph.edges_iter(data=True)
            }
            nx.draw_networkx_edge_labels(graph, layout, edge_labels=metrics)
            nx.draw(graph, layout, node_size=20)
            nx.draw_networkx_labels(graph, layout,
Exemplo n.º 36
0
 def log_test_name(self):
     # Get previous stack frame, 3rd part is func name
     test = inspect.stack()[1][3]
     log.warning('[%s] Testing %s with %s', self.__class__.__name__, test,
                 self.solver_provider.__name__)
Exemplo n.º 37
0
 def log_test_name(self):
     # Get previous stack frame, 3rd part is func name
     test = inspect.stack()[1][3]
     log.warning('[%s] Testing %s with %s', self.__class__.__name__, test,
                 self.solver_provider.__name__)
Exemplo n.º 38
0
 def testTrapezoid(self):
     log.warning('Testing Trapezoid')
     self._test(
         self.gadgets.trap,
         {'1_8': IGPGraph([('R1', 'R2'), ('R2', 'E2'), ('E2', 'D')])}, 1)
Exemplo n.º 39
0
 def testWeird(self):
     log.warning('Testing Weird')
     self._test(self.gadgets.weird,
                {'3_8': IGPGraph([('D', 'C'), ('C', 'B'), ('B', 'A')])}, 2)