Пример #1
0
    def _run(self, client: OpenrCtrl.Client, node_name: str) -> None:
        area = self.get_area_id()
        key = Consts.STATIC_PREFIX_ALLOC_PARAM_KEY

        # Retrieve previous allocation
        resp = None
        if area is None:
            resp = client.getKvStoreKeyVals([key])
        else:
            resp = client.getKvStoreKeyValsArea([key], area)
        allocs = None
        if key in resp.keyVals:
            allocs = serializer.deserialize_thrift_object(
                resp.keyVals.get(key).value, alloc_types.StaticAllocation
            )
        else:
            allocs = alloc_types.StaticAllocation(nodePrefixes={node_name: ""})

        # Return if there need no change
        if node_name not in allocs.nodePrefixes:
            print("No changes needed. {}'s prefix is not set".format(node_name))
            return

        # Update value in KvStore
        del allocs.nodePrefixes[node_name]
        value = serializer.serialize_thrift_object(allocs)

        super(AllocationsUnsetCmd, self)._run(
            client, key, value, "breeze", None, Consts.CONST_TTL_INF
        )
Пример #2
0
    def toggle_link_overload_bit(
        self,
        client: OpenrCtrl.Client,
        overload: bool,
        interface: str,
        yes: bool = False,
    ) -> None:
        links = client.getInterfaces()
        print()

        if interface not in links.interfaceDetails:
            print("No such interface: {}".format(interface))
            return

        if overload and links.interfaceDetails[interface].isOverloaded:
            print("Interface is already overloaded.\n")
            sys.exit(0)

        if not overload and not links.interfaceDetails[interface].isOverloaded:
            print("Interface is not overloaded.\n")
            sys.exit(0)

        action = "set overload bit" if overload else "unset overload bit"
        question_str = "Are you sure to {} for interface {} ?"
        if not utils.yesno(question_str.format(action, interface), yes):
            print()
            return

        if overload:
            client.setInterfaceOverload(interface)
        else:
            client.unsetInterfaceOverload(interface)

        print("Successfully {} for the interface.\n".format(action))
Пример #3
0
    def toggle_node_overload_bit(
        self, client: OpenrCtrl.Client, overload: bool, yes: bool = False
    ) -> None:
        links = client.getInterfaces()
        host = links.thisNodeName
        print()

        if overload and links.isOverloaded:
            print("Node {} is already overloaded.\n".format(host))
            sys.exit(0)

        if not overload and not links.isOverloaded:
            print("Node {} is not overloaded.\n".format(host))
            sys.exit(0)

        action = "set overload bit" if overload else "unset overload bit"
        if not utils.yesno(
            "Are you sure to {} for node {} ?".format(action, host), yes
        ):
            print()
            return

        if overload:
            client.setNodeOverload()
        else:
            client.unsetNodeOverload()

        print("Successfully {}..\n".format(action))
Пример #4
0
    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
                )
Пример #5
0
    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)
Пример #6
0
    def _run(self, client: OpenrCtrl.Client, node_name: str, prefix_str: str) -> None:
        area = self.get_area_id()
        key = Consts.STATIC_PREFIX_ALLOC_PARAM_KEY

        # Retrieve previous allocation
        resp = None
        if area is None:
            resp = client.getKvStoreKeyVals([key])
        else:
            resp = client.getKvStoreKeyValsArea([key], area)
        allocs = None
        if key in resp.keyVals:
            allocs = serializer.deserialize_thrift_object(
                resp.keyVals.get(key).value, alloc_types.StaticAllocation
            )
        else:
            allocs = alloc_types.StaticAllocation(nodePrefixes={})

        # Return if there is no change
        prefix = ipnetwork.ip_str_to_prefix(prefix_str)
        if allocs.nodePrefixes.get(node_name) == prefix:
            print(
                "No changes needed. {}'s prefix is already set to {}".format(
                    node_name, prefix_str
                )
            )
            return

        # Update value in KvStore
        allocs.nodePrefixes[node_name] = prefix
        value = serializer.serialize_thrift_object(allocs)

        super(AllocationsSetCmd, self)._run(
            client, key, value, "breeze", None, Consts.CONST_TTL_INF
        )
Пример #7
0
 def _run(
     self, client: OpenrCtrl.Client, prefixes: List[str], prefix_type: str
 ) -> None:
     tprefixes = self.to_thrift_prefixes(
         prefixes, self.to_thrift_prefix_type(prefix_type)
     )
     client.withdrawPrefixes(tprefixes)
     print(f"Withdrew {len(prefixes)} prefixes")
Пример #8
0
    def _run(self, client: OpenrCtrl.Client, yes: bool = False) -> None:
        question_str = "Are you sure to force sending GR msg to neighbors?"
        if not utils.yesno(question_str, yes):
            print()
            return

        client.floodRestartingMsg()
        print("Successfully forcing to send GR msgs.\n")
Пример #9
0
 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)
Пример #10
0
 def _run(
     self,
     client: OpenrCtrl.Client,
     node: str,
     interface: str,
     metric: str,
     yes: bool,
 ) -> None:
     client.setAdjacencyMetric(interface, node, int(metric))
Пример #11
0
 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))
Пример #12
0
    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)
Пример #13
0
 def _run(
     self,
     client: OpenrCtrl.Client,
     node: str,
     interface: str,
     yes: bool,
     *args,
     **kwargs,
 ) -> None:
     client.unsetAdjacencyMetric(interface, node)
Пример #14
0
 def _run(
     self,
     client: OpenrCtrl.Client,
     prefixes: List[str],
     prefix_type: str,
     forwarding_type: str,
 ) -> None:
     tprefix_type = self.to_thrift_prefix_type(prefix_type)
     tprefixes = self.to_thrift_prefixes(
         prefixes, tprefix_type,
         self.to_thrift_forwarding_type(forwarding_type))
     client.syncPrefixesByType(tprefix_type, tprefixes)
     print(f"Synced {len(prefixes)} prefixes with type {prefix_type}")
Пример #15
0
    def _run(self, client: OpenrCtrl.Client, prefix: str) -> None:
        area = self.get_area_id()
        keyDumpParams = self.buildKvStoreKeyDumpParams(prefix)
        resp = None
        if area is None:
            resp = client.getKvStoreHashFiltered(keyDumpParams)
        else:
            resp = client.getKvStoreHashFilteredArea(keyDumpParams, area)

        signature = hashlib.sha256()
        for _, value in sorted(resp.keyVals.items(), key=lambda x: x[0]):
            signature.update(str(value.hash).encode("utf-8"))

        print("sha256: {}".format(signature.hexdigest()))
Пример #16
0
 def _run(
     self,
     client: OpenrCtrl.Client,
     prefixes: List[str],
     prefix_type: str,
     forwarding_type: str,
 ) -> None:
     tprefixes = self.to_thrift_prefixes(
         prefixes,
         self.to_thrift_prefix_type(prefix_type),
         self.to_thrift_forwarding_type(forwarding_type),
     )
     client.advertisePrefixes(tprefixes)
     print(f"Advertised {len(prefixes)} prefixes with type {prefix_type}")
Пример #17
0
    def _run(self, client: OpenrCtrl.Client, json: bool) -> None:
        openr_version = client.getOpenrVersion()
        build_info = client.getBuildInfo()

        if json:
            if build_info.buildPackageName:
                info = utils.thrift_to_dict(build_info)
                print(utils.json_dumps(info))
            version = utils.thrift_to_dict(openr_version)
            print(utils.json_dumps(version))
        else:
            if build_info.buildPackageName:
                print("Build Information")
                print("  Built by: {}".format(build_info.buildUser))
                print("  Built on: {}".format(build_info.buildTime))
                print("  Built at: {}".format(build_info.buildHost))
                print("  Build path: {}".format(build_info.buildPath))
                print("  Package Name: {}".format(build_info.buildPackageName))
                print("  Package Version: {}".format(build_info.buildPackageVersion))
                print("  Package Release: {}".format(build_info.buildPackageRelease))
                print("  Build Revision: {}".format(build_info.buildRevision))
                print(
                    "  Build Upstream Revision: {}".format(
                        build_info.buildUpstreamRevision
                    )
                )
                print("  Build Platform: {}".format(build_info.buildPlatform))
                print(
                    "  Build Rule: {} ({}, {}, {})".format(
                        build_info.buildRule,
                        build_info.buildType,
                        build_info.buildTool,
                        build_info.buildMode,
                    )
                )
            rows = []
            rows.append(["Open Source Version", ":", openr_version.version])
            rows.append(
                [
                    "Lowest Supported Open Source Version",
                    ":",
                    openr_version.lowestSupportedVersion,
                ]
            )
            print(
                printing.render_horizontal_table(
                    rows, column_labels=[], tablefmt="plain"
                )
            )
Пример #18
0
    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)
Пример #19
0
    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
            )
Пример #20
0
    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)
Пример #21
0
    def _run(
        self,
        client: OpenrCtrl.Client,
    ) -> None:

        # Get data
        self.render(client.getOriginatedPrefixes())
Пример #22
0
 def _run(self, client: OpenrCtrl.Client) -> None:
     key = Consts.STATIC_PREFIX_ALLOC_PARAM_KEY
     resp = client.getKvStoreKeyVals([key])
     if key not in resp.keyVals:
         print("Static allocation is not set in KvStore")
     else:
         utils.print_allocations_table(resp.keyVals.get(key).value)
Пример #23
0
 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)
Пример #24
0
 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)
Пример #25
0
 def _run(self, client: OpenrCtrl.Client, only_suppressed: bool, json: bool) -> None:
     links = client.getInterfaces()
     if only_suppressed:
         links.interfaceDetails = {
             k: v for k, v in links.interfaceDetails.items() if v.linkFlapBackOffMs
         }
     if json:
         self.print_links_json(links)
     else:
         if self.enable_color:
             overload_color = "red" if links.isOverloaded else "green"
             overload_status = click.style(
                 "{}".format("YES" if links.isOverloaded else "NO"),
                 fg=overload_color,
             )
             caption = "Node Overload: {}".format(overload_status)
             self.print_links_table(
                 links.interfaceDetails, caption, self.enable_color
             )
         else:
             caption = "Node Overload: {}".format(
                 "YES" if links.isOverloaded else "NO"
             )
             self.print_links_table(
                 links.interfaceDetails, caption, self.enable_color
             )
Пример #26
0
    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)
Пример #27
0
    def _run(self, client: OpenrCtrl.Client, file: str):
        running_conf = client.getRunningConfig()

        try:
            file_conf = client.dryrunConfig(file)
        except OpenrError as ex:
            click.echo(click.style("FAILED: {}".format(ex), fg="red"))
            return

        res = jsondiff.diff(running_conf, file_conf, load=True, syntax="explicit")
        if res:
            click.echo(click.style("DIFF FOUND!", fg="red"))
            print("== diff(running_conf, {}) ==".format(file))
            print(res)
        else:
            click.echo(click.style("SAME", fg="green"))
Пример #28
0
    def fetch(
        self,
        client: OpenrCtrl.Client,
        prefixes: List[str],
        node: Optional[str],
        area: Optional[str],
    ) -> List[ctrl_types.AdvertisedRouteDetail]:
        """
        Fetch the requested data
        """

        # Create filter
        route_filter = ctrl_types.ReceivedRouteFilter()
        if prefixes:
            route_filter.prefixes = [
                ipnetwork.ip_str_to_prefix(p) for p in prefixes
            ]
        if node:
            route_filter.nodeName = node
        if area:
            route_filter.areaName = area

        # Get routes
        # pyre-fixme[7]: Expected `List[ctrl_types.AdvertisedRouteDetail]` but got
        #  `List[ctrl_types.ReceivedRouteDetail]`.
        return client.getReceivedRoutesFiltered(route_filter)
Пример #29
0
    def _run(self, client: OpenrCtrl.Client):
        policy = None
        try:
            policy = client.getRibPolicy()
        except ctrl_types.OpenrError as e:
            print(f"Error: {e.message}", file=sys.stderr)
            return

        # Convert the prefixes to readable format
        assert policy is not None
        for stmt in policy.statements:
            if stmt.matcher.prefixes:
                stmt.matcher.prefixes = [
                    ipnetwork.sprint_prefix(p) for p in stmt.matcher.prefixes
                ]

        # NOTE: We don't do explicit effor to print policy in
        print("> RibPolicy")
        print(f"  Validity: {policy.ttl_secs}s")
        for stmt in policy.statements:
            prefixes = stmt.matcher.prefixes or []
            action = stmt.action.set_weight or ctrl_types.RibRouteActionWeight(
            )
            print(f"  Statement: {stmt.name}")
            print(f"    Prefix Match List: {', '.join(prefixes)}")
            print("    Action Set Weight:")
            print(f"      Default: {action.default_weight}")
            print("      Area:")
            for area, weight in action.area_to_weight.items():
                print(f"        {area}: {weight}")
            print("      Neighbor:")
            for neighbor, weight in action.neighbor_to_weight.items():
                print(f"        {neighbor}: {weight}")
Пример #30
0
 def _run(self, client: OpenrCtrl.Client, nodes: set, bidir: bool,
          json: bool) -> None:
     adj_dbs = client.getDecisionAdjacencyDbs()
     adjs_map = utils.adj_dbs_to_dict(adj_dbs, nodes, bidir, self.iter_dbs)
     if json:
         utils.print_json(adjs_map)
     else:
         utils.print_adjs_table(adjs_map, self.enable_color, None, None)