def _update(interface_info_dict, interface_info):
interface_info_dict.update({
'v4Addrs': [utils.sprint_addr(v4Addr.addr)
for v4Addr in interface_info.v4Addrs],
'v6LinkLocalAddrs': [utils.sprint_addr(v6Addr.addr)
for v6Addr in interface_info.v6LinkLocalAddrs]
})
def _parse(if2node, adj_db):
nexthop_dict = if2node[adj_db.thisNodeName]
for adj in adj_db.adjacencies:
nh6_addr = utils.sprint_addr(adj.nextHopV6.addr)
nh4_addr = utils.sprint_addr(adj.nextHopV4.addr)
nexthop_dict[(adj.ifName, nh6_addr)] = adj.otherNodeName
nexthop_dict[(adj.ifName, nh4_addr)] = adj.otherNodeName
def _backtracking(cur, path, hop, visited, in_fib):
if hop > max_hop:
return
cur_lpm_len = self.get_lpm_len_from_node(cur, dst_addr, prefix_dbs)
next_hop_nodes = self.get_nexthop_nodes(client.get_route_db(cur),
dst_addr, cur_lpm_len,
if2node, fib_routes,
in_fib)
if len(next_hop_nodes) == 0:
if hop != 1:
paths.append((in_fib, path[:]))
return
for next_hop_node in next_hop_nodes:
next_hop_node_name = next_hop_node[0]
# prevent loops
if next_hop_node_name in visited:
return
path.append([hop] + next_hop_node)
visited.add(next_hop_node_name)
# check if next hop node is in fib path
is_nexthop_in_fib_path = False
for nexthop in fib_routes[cur]:
if next_hop_node[3] == utils.sprint_addr(nexthop.addr) and\
next_hop_node[1] == nexthop.ifName:
is_nexthop_in_fib_path = True
_backtracking(next_hop_node_name, path, hop + 1, visited,
is_nexthop_in_fib_path and in_fib)
visited.remove(next_hop_node_name)
path.pop()
def get_nexthop_nodes(self, route_db, dst_addr, cur_lpm_len, if2node,
fib_routes, in_fib):
''' get the next hop nodes.
if the longest prefix is coming from the current node,
return an empty list to terminate the path searching. '''
next_hop_nodes = []
is_initialized = fib_routes[route_db.thisNodeName]
for lpm_route in self.get_lpm_routes(route_db, dst_addr):
if lpm_route.prefix.prefixLength <= cur_lpm_len:
continue
if in_fib and not is_initialized:
fib_routes[route_db.thisNodeName].extend(
self.get_fib_path(route_db.thisNodeName,
utils.sprint_prefix(lpm_route.prefix),
self.fib_agent_port, self.timeout))
for path in lpm_route.paths:
if len(path.nextHop.addr) == 16:
next_hop_node_name = if2node[route_db.thisNodeName][
path.ifName]
next_hop_nodes.append([
next_hop_node_name, path.ifName, path.metric,
utils.sprint_addr(path.nextHop.addr)
])
return next_hop_nodes
def get_nexthop_nodes(self, route_db, dst_addr, cur_lpm_len,
if2node, fib_routes, in_fib):
''' get the next hop nodes.
if the longest prefix is coming from the current node,
return an empty list to terminate the path searching. '''
next_hop_nodes = []
is_initialized = fib_routes[route_db.thisNodeName]
lpm_route = self.get_lpm_route(route_db, dst_addr)
if lpm_route and lpm_route.prefix.prefixLength >= cur_lpm_len:
if in_fib and not is_initialized:
fib_routes[route_db.thisNodeName].extend(
self.get_fib_path(
route_db.thisNodeName,
utils.sprint_prefix(lpm_route.prefix),
self.fib_agent_port,
self.timeout))
min_cost = min([p.metric for p in lpm_route.paths])
for path in [p for p in lpm_route.paths if p.metric == min_cost]:
if len(path.nextHop.addr) == 16:
nh_addr = utils.sprint_addr(path.nextHop.addr)
next_hop_node_name = \
if2node[route_db.thisNodeName][(path.ifName, nh_addr)]
next_hop_nodes.append([
next_hop_node_name,
path.ifName,
path.metric,
nh_addr,
])
return next_hop_nodes
def ip_nexthop_to_str(nh):
'''
Convert ttypes.BinaryAddress to string representation of a nexthop
'''
return "{}{}{}".format(utils.sprint_addr(nh.addr),
'@' if nh.ifName else '', nh.ifName)
def print_links_table(interfaces, caption=None):
'''
@param interfaces: dict<interface-name, InterfaceDetail>
@param caption: Caption to show on table name
'''
rows = []
columns = [
'Interface', 'Status', 'Overloaded', 'Metric Override', 'ifIndex',
'Addresses'
]
for (k, v) in sorted(interfaces.items()):
state = 'Up' if v.info.isUp else 'Down'
overloaded = 'True' if v.isOverloaded else ''
metric_override = v.metricOverride if v.metricOverride else ''
index = v.info.ifIndex
rows.append([k, state, overloaded, metric_override, index, ''])
firstAddr = True
for a in (v.info.v4Addrs + v.info.v6LinkLocalAddrs):
addrStr = utils.sprint_addr(a.addr)
if firstAddr:
rows[-1][5] = addrStr
firstAddr = False
else:
rows.append(['', '', '', '', '', addrStr])
print(printing.render_horizontal_table(rows, columns, caption))
print()
def print_config(self, prefix_alloc):
seed_prefix = prefix_alloc.seedPrefix
seed_prefix_addr = utils.sprint_addr(seed_prefix.prefixAddress.addr)
caption = 'Prefix Allocator parameters stored'
rows = []
rows.append(['Seed prefix: {}/{}'.format(seed_prefix_addr,
seed_prefix.prefixLength)])
rows.append(['Allocated prefix length: {}'.format(
prefix_alloc.allocPrefixLen)])
rows.append(['Allocated prefix index: {}'.format(
prefix_alloc.allocPrefixIndex)])
print(printing.render_vertical_table(rows, caption=caption))
def run(self):
resp = self.client.peek()
headers = [
'Node', 'IP Address', 'Last Value Sent', 'Last Ack From Node',
'Last Ack To Node'
]
rows = []
for name, node in resp.nodeInfo.items():
rows.append([
name,
utils.sprint_addr(node.ipAddress), node.lastValSent,
node.lastAckFromNode, node.lastAckToNode
])
print()
print(tabulate.tabulate(rows, headers=headers))
print()
def get_node_ip(self, prefix_db):
'''
get routable IP address of node from it's prefix database
:return: string representation of Node's IP addresss. Returns None if
no IP found.
'''
# First look for LOOPBACK prefix
for prefix_entry in prefix_db.prefixEntries:
if prefix_entry.type == lsdb_types.PrefixType.LOOPBACK:
return utils.sprint_addr(prefix_entry.prefix.prefixAddress.addr)
# Next look for PREFIX_ALLOCATOR prefix if any
for prefix_entry in prefix_db.prefixEntries:
if prefix_entry.type == lsdb_types.PrefixType.PREFIX_ALLOCATOR:
return utils.alloc_prefix_to_loopback_ip_str(
prefix_entry.prefix)
# Else return None
return None
