def _run(self, client: OpenrCtrl.Client) -> None:
if not self.area_feature:
super()._run(client)
return
all_kv = kv_store_types.Publication()
all_kv.keyVals = {}
node_area = {}
nodes = set()
for area in self.areas:
prefix_keys = client.getKvStoreKeyValsFilteredArea(
self.buildKvStoreKeyDumpParams(Consts.PREFIX_DB_MARKER), area
)
all_kv.keyVals.update(prefix_keys.keyVals)
adj_keys = client.getKvStoreKeyValsFilteredArea(
self.buildKvStoreKeyDumpParams(Consts.ADJ_DB_MARKER), area
)
host_id = client.getMyNodeName()
node_set = self.get_connected_nodes(adj_keys, host_id)
# save area associated with each node
for node in node_set:
node_area[node] = area
nodes.update(node_set)
self.print_kvstore_nodes(nodes, all_kv, host_id, node_area)
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) -> 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) -> 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, json_opt: bool = False) -> None:
try:
resp = client.getEventLogs()
self.print_log_data(resp, json_opt)
except TypeError:
host_id = client.getMyNodeName()
print(
"Incompatible return type. Please upgrade Open/R binary on {}".
format(host_id))
def _run(self, client: OpenrCtrl.Client, prefix_or_ip: List[str],
json: bool) -> None:
unicast_route_list = client.getUnicastRoutesFiltered(prefix_or_ip)
host_name = client.getMyNodeName()
if json:
routes = {
"unicastRoutes":
[utils.unicast_route_to_dict(r) for r in unicast_route_list]
}
route_dict = {host_name: routes}
utils.print_routes_json(route_dict)
else:
utils.print_unicast_routes(
"Unicast Routes for {}".format(host_name), unicast_route_list)
def _run(self, client: OpenrCtrl.Client, labels: List[int], json: bool) -> None:
int_label_filters = [int(label) for label in labels]
mpls_route_list = client.getMplsRoutesFiltered(int_label_filters)
host_name = client.getMyNodeName()
if json:
routes = {
"mplsRoutes": [utils.mpls_route_to_dict(r) for r in mpls_route_list]
}
route_dict = {host_name: routes}
utils.print_routes_json(route_dict)
else:
utils.print_mpls_routes(
"MPLS Routes for {}".format(host_name), mpls_route_list
)
def print_peers(self, client: OpenrCtrl.Client, peers_list: Dict[str, Any]) -> None:
""" print the Kv Store peers """
host_id = client.getMyNodeName()
caption = "{}'s peers".format(host_id)
rows = []
for area, peers in peers_list.items():
area = area if area is not None else "N/A"
for (key, value) in sorted(peers.items(), key=lambda x: x[0]):
row = [f"{key}, area:{area}"]
row.append("cmd via {}".format(value.cmdUrl))
rows.append(row)
print(printing.render_vertical_table(rows, caption=caption))
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 print_peers(
self, client: OpenrCtrl.Client, peers: kv_store_types.PeersMap
) -> None:
""" print the Kv Store peers """
host_id = client.getMyNodeName()
caption = "{}'s peers".format(host_id)
rows = []
for (key, value) in sorted(peers.items(), key=lambda x: x[0]):
row = [key]
row.append("cmd via {}".format(value.cmdUrl))
row.append("pub via {}".format(value.pubUrl))
rows.append(row)
print(printing.render_vertical_table(rows, caption=caption))
def print_counters(self, client: OpenrCtrl.Client, resp: Dict, prefix: str,
json: bool) -> None:
""" print the Kv Store counters """
host_id = client.getMyNodeName()
caption = "{}'s counters".format(host_id)
rows = []
for key, counter in sorted(resp.items()):
if not key.startswith(prefix):
continue
rows.append([key, ":", counter])
if json:
json_data = {k: v for k, _, v in rows}
print(utils.json_dumps(json_data))
else:
print(
printing.render_horizontal_table(rows,
caption=caption,
tablefmt="plain"))
print()
