def _run(self, client: OpenrCtrl.Client) -> None:
prefix_keys = client.getKvStoreKeyValsFiltered(
self.buildKvStoreKeyDumpParams(Consts.PREFIX_DB_MARKER))
adj_keys = client.getKvStoreKeyValsFiltered(
self.buildKvStoreKeyDumpParams(Consts.ADJ_DB_MARKER))
host_id = client.getMyNodeName()
self.print_kvstore_nodes(self.get_connected_nodes(adj_keys, host_id),
prefix_keys, host_id)
def _run(self, client: OpenrCtrl.Client, nodes: Any, json: bool) -> None:
keyDumpParams = self.buildKvStoreKeyDumpParams(Consts.PREFIX_DB_MARKER)
resp = client.getKvStoreKeyValsFiltered(keyDumpParams)
if json:
utils.print_prefixes_json(resp, nodes, self.iter_publication)
else:
utils.print_prefixes_table(resp, nodes, self.iter_publication)
def _run(self, client: OpenrCtrl.Client, nodes: set) -> None:
area = self.get_area_id()
all_nodes_to_ips = self.get_node_to_ips(client, area)
if nodes:
nodes = set(nodes.strip().split(","))
if "all" in nodes:
nodes = list(all_nodes_to_ips.keys())
host_id = client.getMyNodeName()
if host_id in nodes:
nodes.remove(host_id)
keyDumpParams = self.buildKvStoreKeyDumpParams(
Consts.ALL_DB_MARKER)
pub = None
if not self.area_feature:
pub = client.getKvStoreKeyValsFiltered(keyDumpParams)
else:
pub = client.getKvStoreKeyValsFilteredArea(keyDumpParams, area)
kv_dict = self.dump_nodes_kvs(nodes, all_nodes_to_ips, area)
for node in kv_dict:
self.compare(pub.keyVals, kv_dict[node], host_id, node)
else:
nodes = list(all_nodes_to_ips.keys())
kv_dict = self.dump_nodes_kvs(nodes, all_nodes_to_ips, area)
for our_node, other_node in combinations(kv_dict.keys(), 2):
self.compare(kv_dict[our_node], kv_dict[other_node], our_node,
other_node)
def _run(self, client: OpenrCtrl.Client, nodes: set, node: Any,
interface: Any) -> None:
keyDumpParams = self.buildKvStoreKeyDumpParams(Consts.ADJ_DB_MARKER)
publication = client.getKvStoreKeyValsFiltered(keyDumpParams)
adjs_map = utils.adj_dbs_to_dict(publication, nodes, True,
self.iter_publication)
utils.print_adjs_table(adjs_map, self.enable_color, node, interface)
def _run(
self,
client: OpenrCtrl.Client,
src: str,
dst: str,
max_hop: int,
area: str,
*args,
**kwargs,
) -> None:
if not src or not dst:
host_id = client.getMyNodeName()
src = src or host_id
dst = dst or host_id
# pyre-fixme[16]: `PathCmd` has no attribute `prefix_dbs`.
self.prefix_dbs: Dict[str, openr_types.PrefixDatabase] = {}
area = utils.get_area_id(client, area)
# Get prefix_dbs from KvStore
params = openr_types.KeyDumpParams(Consts.PREFIX_DB_MARKER)
params.keys = [Consts.PREFIX_DB_MARKER]
if area is None:
pub = client.getKvStoreKeyValsFiltered(params)
else:
pub = client.getKvStoreKeyValsFilteredArea(params, area)
for value in pub.keyVals.values():
utils.parse_prefix_database("", "", self.prefix_dbs, value)
paths = self.get_paths(client, src, dst, max_hop)
self.print_paths(paths)
def _run(self, client: OpenrCtrl.Client, nodes: set, bidir: bool,
json: bool) -> None:
keyDumpParams = self.buildKvStoreKeyDumpParams(Consts.ADJ_DB_MARKER)
publication = client.getKvStoreKeyValsFiltered(keyDumpParams)
adjs_map = utils.adj_dbs_to_dict(publication, nodes, bidir,
self.iter_publication)
if json:
utils.print_json(adjs_map)
else:
utils.print_adjs_table(adjs_map, self.enable_color)
def get_dbs(self, client: OpenrCtrl.Client) -> Tuple[Dict, Dict, Dict]:
# get LSDB from Decision
decision_adj_dbs = client.getDecisionAdjacencyDbs()
decision_prefix_dbs = client.getDecisionPrefixDbs()
# get LSDB from KvStore
kvstore_keyvals = client.getKvStoreKeyValsFiltered(
kv_store_types.KeyDumpParams(Consts.ALL_DB_MARKER)).keyVals
return (decision_adj_dbs, decision_prefix_dbs, kvstore_keyvals)
def _run(
self,
client: OpenrCtrl.Client,
json: bool,
prefix: Any,
originator: Any = None,
ttl: bool = False,
) -> None:
keyDumpParams = self.buildKvStoreKeyDumpParams(prefix)
resp = client.getKvStoreKeyValsFiltered(keyDumpParams)
self.print_kvstore_keys(resp, ttl, json)
def _run(
self,
client: OpenrCtrl.Client,
nodes: set,
json: bool,
prefix: str,
client_type: str,
) -> None:
keyDumpParams = self.buildKvStoreKeyDumpParams(Consts.PREFIX_DB_MARKER)
resp = client.getKvStoreKeyValsFiltered(keyDumpParams)
self.print_prefix({None: resp}, nodes, json, prefix, client_type)
def get_node_to_ips(self, client: OpenrCtrl.Client) -> Dict:
""" get the dict of all nodes to their IP in the network """
node_dict = {}
keyDumpParams = self.buildKvStoreKeyDumpParams(Consts.PREFIX_DB_MARKER)
resp = client.getKvStoreKeyValsFiltered(keyDumpParams)
prefix_maps = utils.collate_prefix_keys(resp.keyVals)
for node, prefix_db in prefix_maps.items():
node_dict[node] = self.get_node_ip(prefix_db)
return node_dict
def get_node_to_ips(self, client: OpenrCtrl.Client) -> Dict:
""" get the dict of all nodes to their IP in the network """
def _parse_nodes(node_dict, value):
prefix_db = serializer.deserialize_thrift_object(
value.value, lsdb_types.PrefixDatabase)
node_dict[prefix_db.thisNodeName] = self.get_node_ip(prefix_db)
node_dict = {}
keyDumpParams = self.buildKvStoreKeyDumpParams(Consts.PREFIX_DB_MARKER)
resp = client.getKvStoreKeyValsFiltered(keyDumpParams)
self.iter_publication(node_dict, resp, ["all"], _parse_nodes)
return node_dict
def get_dbs(self, client: OpenrCtrl.Client, area: str) -> Tuple[Dict, Dict, Dict]:
# get LSDB from Decision
decision_adj_dbs = client.getDecisionAdjacencyDbs()
decision_prefix_dbs = client.getDecisionPrefixDbs()
area = utils.get_area_id(client, area)
# get LSDB from KvStore
params = openr_types.KeyDumpParams(Consts.ALL_DB_MARKER)
params.keys = [Consts.ALL_DB_MARKER]
if area is None:
kvstore_keyvals = client.getKvStoreKeyValsFiltered(params).keyVals
else:
kvstore_keyvals = client.getKvStoreKeyValsFilteredArea(params, area).keyVals
return (decision_adj_dbs, decision_prefix_dbs, kvstore_keyvals)
def _run(self, client: OpenrCtrl.Client, src: str, dst: str, max_hop: int) -> None:
if not src or not dst:
host_id = client.getMyNodeName()
src = src or host_id
dst = dst or host_id
# Get prefix_dbs from KvStore
self.prefix_dbs: Dict[str, lsdb_types.PrefixDatabase] = {}
pub = client.getKvStoreKeyValsFiltered(
kv_store_types.KeyDumpParams(Consts.PREFIX_DB_MARKER)
)
for value in pub.keyVals.values():
utils.parse_prefix_database("", "", self.prefix_dbs, value)
paths = self.get_paths(client, src, dst, max_hop)
self.print_paths(paths)
def _run(self, client: OpenrCtrl.Client, src: str, dst: str,
max_hop: int) -> None:
if not src or not dst:
host_id = utils.get_connected_node_name(self.cli_opts)
src = src or host_id
dst = dst or host_id
# Get prefix_dbs from KvStore
self.prefix_dbs = {}
pub = client.getKvStoreKeyValsFiltered(
kv_store_types.KeyDumpParams(Consts.PREFIX_DB_MARKER))
for v in pub.keyVals.values():
prefix_db = deserialize_thrift_object(v.value,
lsdb_types.PrefixDatabase)
self.prefix_dbs[prefix_db.thisNodeName] = prefix_db
paths = self.get_paths(client, src, dst, max_hop)
self.print_paths(paths)
def get_node_to_ips(self, client: OpenrCtrl.Client, area: str = None) -> Dict:
""" get the dict of all nodes to their IP in the network """
node_dict = {}
keyDumpParams = self.buildKvStoreKeyDumpParams(Consts.PREFIX_DB_MARKER)
resp = kv_store_types.Publication()
if not self.area_feature:
resp = client.getKvStoreKeyValsFiltered(keyDumpParams)
else:
if area is None:
print(f"Error: Must specify one of the areas: {self.areas}")
sys.exit(1)
resp = client.getKvStoreKeyValsFilteredArea(keyDumpParams, area)
prefix_maps = utils.collate_prefix_keys(resp.keyVals)
for node, prefix_db in prefix_maps.items():
node_dict[node] = self.get_node_ip(prefix_db)
return node_dict
def _run(self, client: OpenrCtrl.Client, nodes: set) -> None:
all_nodes_to_ips = self.get_node_to_ips(client)
if nodes:
nodes = set(nodes.strip().split(","))
if "all" in nodes:
nodes = list(all_nodes_to_ips.keys())
host_id = utils.get_connected_node_name(self.cli_opts)
if host_id in nodes:
nodes.remove(host_id)
keyDumpParams = self.buildKvStoreKeyDumpParams(
Consts.ALL_DB_MARKER)
pub = client.getKvStoreKeyValsFiltered(keyDumpParams)
kv_dict = self.dump_nodes_kvs(nodes, all_nodes_to_ips)
for node in kv_dict:
self.compare(pub.keyVals, kv_dict[node], host_id, node)
else:
nodes = list(all_nodes_to_ips.keys())
kv_dict = self.dump_nodes_kvs(nodes, all_nodes_to_ips)
for our_node, other_node in combinations(kv_dict.keys(), 2):
self.compare(kv_dict[our_node], kv_dict[other_node], our_node,
other_node)
def get_snapshot(self, client: OpenrCtrl.Client, delta: Any) -> Dict:
# get the active network snapshot first, so we can compute deltas
global_dbs = bunch.Bunch(
{
"prefixes": {},
"adjs": {},
"publications": {}, # map(key -> (version, originatorId))
}
)
if delta:
print("Retrieving KvStore snapshot ... ")
keyDumpParams = self.buildKvStoreKeyDumpParams(Consts.ALL_DB_MARKER)
resp = client.getKvStoreKeyValsFiltered(keyDumpParams)
global_dbs.prefixes = utils.build_global_prefix_db(resp)
global_dbs.adjs = utils.build_global_adj_db(resp)
for key, value in resp.keyVals.items():
global_dbs.publications[key] = (value.version, value.originatorId)
print("Done. Loaded {} initial key-values".format(len(resp.keyVals)))
else:
print("Skipping retrieval of KvStore snapshot")
return global_dbs
def _run(
self,
client: OpenrCtrl.Client,
node: str,
bidir: bool,
output_file: str,
edge_label: Any,
json: bool,
) -> None:
try:
import matplotlib.pyplot as plt
import networkx as nx
except ImportError:
print("Drawing topology requires `matplotlib` and `networkx` "
"libraries. You can install them with following command and "
"retry. \n"
" pip install matplotlib\n"
" pip install networkx")
sys.exit(1)
rem_str = {".facebook.com": "", ".tfbnw.net": ""}
rem_str = dict((re.escape(k), v) for k, v in rem_str.items())
rem_pattern = re.compile("|".join(rem_str.keys()))
keyDumpParams = self.buildKvStoreKeyDumpParams(Consts.ADJ_DB_MARKER)
publication = client.getKvStoreKeyValsFiltered(keyDumpParams)
nodes = list(
self.get_node_to_ips(client).keys()) if not node else [node]
adjs_map = utils.adj_dbs_to_dict(publication, nodes, bidir,
self.iter_publication)
if json:
return self.topology_json_dump(adjs_map.items())
G = nx.Graph()
adj_metric_map = {}
node_overloaded = {}
for this_node_name, db in adjs_map.items():
node_overloaded[rem_pattern.sub(
lambda m: rem_str[re.escape(m.group(0))],
this_node_name)] = db["overloaded"]
for adj in db["adjacencies"]:
adj_metric_map[(this_node_name, adj["ifName"])] = adj["metric"]
for this_node_name, db in adjs_map.items():
for adj in db["adjacencies"]:
adj["color"] = "r" if adj["isOverloaded"] else "b"
adj["adjOtherIfMetric"] = adj_metric_map[(adj["otherNodeName"],
adj["otherIfName"])]
G.add_edge(
rem_pattern.sub(lambda m: rem_str[re.escape(m.group(0))],
this_node_name),
rem_pattern.sub(lambda m: rem_str[re.escape(m.group(0))],
adj["otherNodeName"]),
**adj,
)
# hack to get nice fabric
# XXX: FB Specific
pos = {}
eswx = 0
sswx = 0
fswx = 0
rswx = 0
blue_nodes = []
red_nodes = []
for node in G.nodes():
if node_overloaded[node]:
red_nodes.append(node)
else:
blue_nodes.append(node)
if "esw" in node:
pos[node] = [eswx, 3]
eswx += 10
elif "ssw" in node:
pos[node] = [sswx, 2]
sswx += 10
elif "fsw" in node:
pos[node] = [fswx, 1]
fswx += 10
elif "rsw" in node:
pos[node] = [rswx, 0]
rswx += 10
maxswx = max(eswx, sswx, fswx, rswx)
if maxswx > 0:
# aesthetically pleasing multiplier (empirically determined)
plt.figure(figsize=(maxswx * 0.5, 8))
else:
plt.figure(figsize=(min(len(G.nodes()) * 2, 150),
min(len(G.nodes()) * 2, 150)))
pos = nx.spring_layout(G)
plt.axis("off")
edge_colors = []
for _, _, d in G.edges(data=True):
edge_colors.append(d["color"])
nx.draw_networkx_nodes(G,
pos,
ax=None,
alpha=0.5,
node_color="b",
nodelist=blue_nodes)
nx.draw_networkx_nodes(G,
pos,
ax=None,
alpha=0.5,
node_color="r",
nodelist=red_nodes)
nx.draw_networkx_labels(G, pos, ax=None, alpha=0.5, font_size=8)
nx.draw_networkx_edges(G,
pos,
ax=None,
alpha=0.5,
font_size=8,
edge_color=edge_colors)
edge_labels = {}
if node:
if edge_label:
edge_labels = {
(u, v): "<" + str(d["otherIfName"]) + ", " +
str(d["metric"]) + " > <" + str(d["ifName"]) + ", " +
str(d["adjOtherIfMetric"]) + ">"
for u, v, d in G.edges(data=True)
}
nx.draw_networkx_edge_labels(G,
pos,
edge_labels=edge_labels,
font_size=6)
print("Saving topology to file => {}".format(output_file))
plt.savefig(output_file)
def _run(self, client: OpenrCtrl.Client, nodes: set, bidir: bool,
json: bool) -> None:
keyDumpParams = self.buildKvStoreKeyDumpParams(Consts.ADJ_DB_MARKER)
publication = client.getKvStoreKeyValsFiltered(keyDumpParams)
self.print_adj({None: publication}, nodes, bidir, json)
def _run(self, client: OpenrCtrl.Client) -> None:
keyDumpParams = self.buildKvStoreKeyDumpParams(Consts.PREFIX_DB_MARKER)
resp = client.getKvStoreKeyValsFiltered(keyDumpParams)
host_id = utils.get_connected_node_name(self.cli_opts)
self.print_kvstore_nodes(resp, host_id)
def _run(self, client: OpenrCtrl.Client, nodes: set, node: Any,
interface: Any) -> None:
keyDumpParams = self.buildKvStoreKeyDumpParams(Consts.ADJ_DB_MARKER)
publication = client.getKvStoreKeyValsFiltered(keyDumpParams)
self.printAdjNode(publication, nodes)
