| #! /usr/bin/env python |
| # -*- Mode: python; py-indent-offset: 4; tab-width: 8; -*- |
| |
| """ |
| onoscli : ONOS-specific Command Line Interface |
| |
| Usage: |
| # Running the CLI in interactive mode: |
| $ ./onoscli |
| |
| # Running multiple CLI commands in batch mode |
| $ cat commands.txt | ./onoscli |
| |
| # Running a single command from the system command-line |
| $ ./onoscli -c show switch |
| |
| # Run the following command for additional help |
| $ ./onoscli -h |
| """ |
| |
| # |
| # INSTALLATION NOTES: MUST install Python cmd2 module. E.g., on Ubuntu: |
| # sudo apt-get install python-cmd2 |
| # On older Ubuntu installations (e.g., Ubuntu-12.04 or Ubuntu-13.04), install |
| # also: |
| # sudo apt-get install python-pyparsing |
| # |
| |
| # |
| # ADDING A NEW CLI COMMAND: |
| # 1. Add the appropriate Command entry (or entries) inside array |
| # OnosCli.init_commands. |
| # See the comments for init_commands for details. |
| # 2. Add the appropriate callback (inside class OnosCli) for the CLI command |
| # |
| # |
| |
| import sys |
| import argparse |
| import json |
| from optparse import make_option |
| import urllib2 |
| from urllib2 import URLError, HTTPError |
| import cmd2 |
| from cmd2 import Cmd |
| from cmd2 import options |
| |
| |
| class Command(): |
| "Command node. A hierarchy of nodes are organized in a command tree." |
| |
| def __init__(self, name, help, callback=None, add_parser_args=None): |
| """name: a string with the full command name |
| help: the help string for the command |
| callback: the method to be called if the command is executed |
| add_parser_args: the parser arguments to add to the command: a dictionary of argparse arguments""" |
| # Normalize the name by removing extra spaces |
| self.split_name = name.split() # List of the words in the name |
| self.name = ' '.join(self.split_name) # Normalized name |
| self.last_subname = self.split_name[-1] # Last word in the name |
| self.parent_name = ' '.join(self.split_name[:-1]) # Name of parent command |
| self.help = help # THe help string |
| self.callback = callback # The command callback |
| self.add_parser_args = add_parser_args # Parser arguments to add |
| self.parent = None # The parent Command |
| self.children = [] # The children Command entries |
| |
| |
| class OnosCli(Cmd): |
| "The main ONOS CLI class" |
| |
| # Setup generic CLI fields |
| intro = "Welcome to the ONOS CLI. Type help or ? to list commands.\n" |
| prompt = "(onos) " |
| settable = Cmd.settable + "prompt CLI prompt" |
| |
| # Setup ONOS-specific fields |
| onos_ip = "127.0.0.1" |
| settable = settable + "onos_ip ONOS IP address" |
| onos_port = 8080 |
| settable = settable + "onos_port ONOS REST port number" |
| output_format = "json" # Valid values: json, text |
| settable = settable + "output_format The output format: `text` or `json`" |
| |
| # Collection of commands sorted by the level in the CLI command hierarchy |
| commands = [] |
| # Commands, parsers and subparsers keyed by the command name |
| commands_dict = {} |
| parsers_dict = {} |
| subparsers_dict = {} |
| |
| def __init__(self): |
| Cmd.__init__(self) |
| |
| # |
| # An array of the ONOS-specific CLI commands. |
| # Each entry is a Command instance, and must have at least |
| # two arguments: |
| # * Command name as typed on the CLI. E.g.: |
| # "show intent" |
| # * Command help description. E.g.: |
| # "Show intents" |
| # |
| # Executable commands should have a third Command argument, which is |
| # the name of the method to be called when the command is executed. |
| # The method will be called with the (argparse) parsed arguments |
| # for that command. |
| # |
| # If an executable command takes arguments, those should be described |
| # in the Command's fourth argument. It is a list of pairs: |
| # [ |
| # ("--argument-name1", dict(...)), |
| # ("--argument-name2", dict(...)), |
| # ... |
| # ] |
| # where the first entry in the pair is the argument name, and the |
| # second entry in the pair is a dictionary with argparse-specific |
| # description of the argument. |
| # |
| init_commands = [ |
| Command("delete", "Delete command"), |
| # |
| Command("delete intent", |
| """Delete high-level intents |
| Usage: |
| delete intent --intent-id INTENT_ID Delete a high-level intent |
| delete intent --all Delete all high-level intents |
| Arguments: |
| --intent-id INTENT_ID The Intent ID (an integer) |
| --all Delete all high-level intents""", |
| self.delete_intent, |
| [ |
| ("--intent-id", dict(required=False, type=int)), |
| ("--all", dict(required=False, action='store_true')) |
| ] |
| ), |
| # |
| Command("set", "Set command"), |
| # |
| Command("set intent", |
| """Set a high-level intent |
| Usage: |
| set intent <ARGS> |
| Arguments: |
| --intent-id INTENT_ID The Intent ID (an integer) (REQUIRED) |
| --src-dpid SRC_DPID Source Switch DPID (REQUIRED) |
| --src-port SRC_PORT Source Switch Port (REQUIRED) |
| --dst-dpid DST_DPID Destination Switch DPID (REQUIRED) |
| --dst-port DST_PORT Destination Switch Port (REQUIRED) |
| --match-src-mac MATCH_SRC_MAC Matching Source MAC Address (REQUIRED) |
| --match-dst-mac MATCH_DST_MAC Matching Destination MAC Address (REQUIRED)""", |
| self.set_intent, |
| [ |
| ("--intent-id", dict(required=True, type=int)), |
| ("--src-dpid", dict(required=True)), |
| ("--src-port", dict(required=True, type=int)), |
| ("--dst-dpid", dict(required=True)), |
| ("--dst-port", dict(required=True, type=int)), |
| ("--match-src-mac", dict(required=True)), |
| ("--match-dst-mac", dict(required=True)) |
| ]), |
| # |
| Command("show", "Show command"), |
| # |
| Command("show host", "Show all hosts", self.show_host), |
| # |
| Command("show intent", "Show intents"), |
| # |
| Command("show intent high", |
| """Show all high-level intents |
| show intent high --intent-id INTENT_ID Show a high-level intent""", |
| self.show_intent_high, |
| [ |
| ("--intent-id", dict(required=False, type=int)) |
| ] |
| ), |
| # |
| Command("show intent low", |
| """Show all low-level intents |
| show intent low --intent-id INTENT_ID Show a low-level intent""", |
| self.show_intent_low, |
| [ |
| ("--intent-id", dict(required=False)) |
| ] |
| ), |
| # |
| Command("show link", "Show all links", self.show_link), |
| # |
| Command("show metrics", |
| """Show all metrics |
| show metrics --metric-id METRIC_ID Show a metric""", |
| self.show_metrics, |
| [ |
| ("--metric-id", dict(required=False, type=str)), |
| ] |
| ), |
| # |
| Command("show path", "Show a path"), |
| # |
| Command("show path shortest", |
| """Show a shortest path |
| Usage: |
| show path shortest --src-dpid SRC_DPID --dst-dpid DST_DPID |
| Arguments: |
| --src-dpid SRC_DPID Source Switch DPID |
| --dst-dpid DST_DPID Destination Switch DPID""", |
| self.show_path_shortest, |
| [ |
| ("--src-dpid", dict(required=True)), |
| ("--dst-dpid", dict(required=True)) |
| ]), |
| # |
| Command("show switch", "Show all switches", self.show_switch), |
| # |
| Command("show topology", "Show network topology", self.show_topology) |
| ] |
| |
| # Sort the commands by the level in the CLI command hierarchy |
| self.commands = sorted(init_commands, key = lambda c: len(c.name.split())) |
| |
| # Create a dictionary with all commands: name -> Command |
| for c in self.commands: |
| self.commands_dict[c.name] = c |
| |
| # Create a tree with all commands |
| for c in self.commands: |
| if c.parent_name: |
| pc = self.commands_dict[c.parent_name] |
| pc.children.append(c) |
| c.parent = pc |
| |
| # Create the parsers and the sub-parsers |
| for c in self.commands: |
| # Add a parser |
| parser = None |
| if c.parent is None: |
| # Add a top-level parser |
| parser = argparse.ArgumentParser(description=c.help, |
| prog=c.name, |
| add_help=False) |
| else: |
| # Add a parser from the parent's subparser |
| parent_subparser = self.subparsers_dict[c.parent_name] |
| parser = parent_subparser.add_parser(c.last_subname, |
| help=c.help, |
| add_help=False) |
| self.parsers_dict[c.name] = parser |
| # Add a sub-parser |
| if c.children: |
| subparser = parser.add_subparsers(help=c.help) |
| self.subparsers_dict[c.name] = subparser |
| # Setup the callback |
| if c.callback is not None: |
| parser.set_defaults(func=c.callback) |
| # Init the argument parser |
| if c.add_parser_args is not None: |
| for a in c.add_parser_args: |
| (p1, p2) = a |
| parser.add_argument(p1, **p2) |
| |
| def delete_intent(self, args): |
| "CLI command callback: delete intent" |
| |
| url = "" |
| if args.all: |
| # Delete all intents |
| url = "http://%s:%s/wm/onos/intent/high" % (self.onos_ip, self.onos_port) |
| else: |
| if args.intent_id is None: |
| print "*** Unknown syntax:" |
| self.help_delete() |
| return |
| # Delete an intent |
| url = "http://%s:%s/wm/onos/intent/high/%s" % (self.onos_ip, self.onos_port, args.intent_id) |
| |
| result = delete_json(url) |
| # NOTE: No need to print the response |
| # if len(result) != 0: |
| # self.print_json_result(result) |
| |
| def set_intent(self, args): |
| "CLI command callback: set intent" |
| |
| intents = [] |
| oper = {} |
| # Create the POST payload |
| oper['intentId'] = args.intent_id |
| oper['intentType'] = 'SHORTEST_PATH' # XXX: Hardcoded |
| oper['staticPath'] = False # XXX: Hardcoded |
| oper['srcSwitchDpid'] = args.src_dpid |
| oper['srcSwitchPort'] = args.src_port |
| oper['dstSwitchDpid'] = args.dst_dpid |
| oper['dstSwitchPort'] = args.dst_port |
| oper['matchSrcMac'] = args.match_src_mac |
| oper['matchDstMac'] = args.match_dst_mac |
| intents.append(oper) |
| |
| url = "http://%s:%s/wm/onos/intent/high" % (self.onos_ip, self.onos_port) |
| result = post_json(url, intents) |
| # NOTE: No need to print the response |
| # if len(result) != 0: |
| # self.print_json_result(result) |
| |
| def show_host(self, args): |
| "CLI command callback: show host" |
| |
| url = "http://%s:%s/wm/onos/topology/hosts" % (self.onos_ip, self.onos_port) |
| result = get_json(url) |
| self.print_json_result(result) |
| |
| def show_intent_high(self, args): |
| "CLI command callback: show intent high" |
| |
| if args.intent_id is None: |
| # Show all intents |
| url = "http://%s:%s/wm/onos/intent/high" % (self.onos_ip, self.onos_port) |
| else: |
| # Show a single intent |
| url = "http://%s:%s/wm/onos/intent/high/%s" % (self.onos_ip, self.onos_port, args.intent_id) |
| |
| result = get_json(url) |
| self.print_json_result(result) |
| |
| def show_intent_low(self, args): |
| "CLI command callback: show intent low" |
| |
| if args.intent_id is None: |
| # Show all intents |
| url = "http://%s:%s/wm/onos/intent/low" % (self.onos_ip, self.onos_port) |
| else: |
| # Show a single intent |
| url = "http://%s:%s/wm/onos/intent/low/%s" % (self.onos_ip, self.onos_port, args.intent_id) |
| |
| result = get_json(url) |
| self.print_json_result(result) |
| |
| def show_link(self, args): |
| "CLI command callback: show link" |
| |
| url = "http://%s:%s/wm/onos/topology/links" % (self.onos_ip, self.onos_port) |
| result = get_json(url) |
| # |
| if (self.output_format == "json"): |
| self.print_json_result(result) |
| else: |
| # NOTE: The code below is for demo purpose only how to |
| # decode and print the links in text format. It will be |
| # reimplemented in the future. |
| links = result |
| print "# src_dpid src_port -> dst_dpid dst_port" |
| for v in sorted(links, key=lambda x: x['src']['dpid']): |
| src_dpid = str(v['src']['dpid']) |
| src_port = str(v['src']['portNumber']) |
| dst_dpid = str(v['dst']['dpid']) |
| dst_port = str(v['dst']['portNumber']) |
| self.print_result("%s %s -> %s %s" % (src_dpid, src_port, dst_dpid, dst_port)) |
| |
| def show_metrics(self, args): |
| "CLI command callback: show metrics" |
| |
| if args.metric_id is None: |
| # Show all metrics |
| url = "http://%s:%s/wm/onos/metrics" % (self.onos_ip, self.onos_port) |
| else: |
| # Show a single metric |
| url = "http://%s:%s/wm/onos/metrics?ids=%s" % (self.onos_ip, self.onos_port, args.metric_id) |
| |
| result = get_json(url) |
| self.print_json_result(result) |
| |
| def show_path_shortest(self, args): |
| "CLI command callback: show path shortest" |
| |
| url = "http://%s:%s/wm/onos/intent/path/switch/%s/shortest-path/%s" % (self.onos_ip, self.onos_port, args.src_dpid, args.dst_dpid) |
| result = get_json(url) |
| # |
| self.print_json_result(result) |
| |
| def show_switch(self, args): |
| "CLI command callback: show switch" |
| |
| url = "http://%s:%s/wm/onos/topology/switches" % (self.onos_ip, self.onos_port) |
| result = get_json(url) |
| # |
| self.print_json_result(result) |
| |
| def show_topology(self, args): |
| "CLI command callback: show topology" |
| |
| url = "http://%s:%s/wm/onos/topology" % (self.onos_ip, self.onos_port) |
| result = get_json(url) |
| # |
| self.print_json_result(result) |
| |
| # |
| # Implement "delete" top-level command |
| # |
| def do_delete(self, arg): |
| "Top-level 'delete' command" |
| self.impl_do_command('delete', arg) |
| def complete_delete(self, text, line, begidx, endidx): |
| "Completion of top-level 'delete' command" |
| return self.impl_complete_command('delete', text, line, begidx, endidx) |
| def help_delete(self): |
| "Help for top-level 'delete' command" |
| self.impl_help_command('delete') |
| |
| # |
| # Implement "set" top-level command |
| # |
| def do_set(self, arg): |
| "Top-level 'set' command" |
| self.impl_do_command('set', arg) |
| def complete_set(self, text, line, begidx, endidx): |
| "Completion of top-level 'set' command" |
| return self.impl_complete_command('set', text, line, begidx, endidx) |
| def help_set(self): |
| "Help for top-level 'set' command" |
| self.impl_help_command('set') |
| |
| # |
| # Implement "show" top-level command |
| # |
| def do_show(self, arg): |
| "Top-level 'show' command" |
| self.impl_do_command('show', arg) |
| def complete_show(self, text, line, begidx, endidx): |
| "Completion of top-level 'show' command" |
| return self.impl_complete_command('show', text, line, begidx, endidx) |
| def help_show(self): |
| "Help for top-level 'show' command" |
| self.impl_help_command('show') |
| |
| # |
| # Implement the "do_something" top-level command execution |
| # |
| def impl_do_command(self, root_name, arg): |
| "Implementation of top-level 'do_something' command execution" |
| parser = self.parsers_dict[root_name] |
| parsed_args = parser.parse_args(arg.split()) |
| parsed_args.func(parsed_args) |
| |
| # |
| # Implement the "complete_something" top-level command completion |
| # |
| def impl_complete_command(self, root_name, text, line, begidx, endidx): |
| "Implementation of top-level 'complete_something' command completion" |
| root_command = self.commands_dict[root_name] |
| subtree_commands = self.collect_subtree_commands(root_command) |
| |
| # |
| # Loop through the commands and add their portion |
| # of the sub-name to the list of completions. |
| # |
| # NOTE: We add a command only if it has a callback. |
| # |
| completions = [] |
| for c in subtree_commands: |
| if c.callback is None: |
| continue |
| name = c.split_name[len(root_command.split_name):] |
| completions.append(' '.join(name)) |
| |
| mline = line.partition(" ")[2] |
| offs = len(mline) - len(text) |
| return [s[offs:] for s in completions if s.startswith(mline)] |
| |
| # |
| # Implement the "help_something" top-level command help |
| # |
| def impl_help_command(self, root_name): |
| "Implementation of top-level 'help_something' command help" |
| root_command = self.commands_dict[root_name] |
| subtree_commands = self.collect_subtree_commands(root_command) |
| |
| # |
| # Loop through the commands and print the help for each command. |
| # NOTE: We add a command only if it has a callback. |
| # |
| print "Help for the `%s` command:" % (root_name) |
| for c in subtree_commands: |
| if c.callback is None: |
| continue |
| print " {0:30}{1:30}".format(c.name, c.help) |
| # if c.init_arg_parser is not None: |
| # parser = self.parsers_dict[c.name] |
| # parser.print_help() |
| |
| # |
| # Traverse (depth-first) a subtree and return all nodes except the |
| # root node. |
| # |
| def collect_subtree_commands(self, root_command): |
| """Collect a subtree of commands. |
| Traverses (depth-first) a subtree of commands and returns |
| all nodes except the root node.""" |
| |
| commands = [] |
| subtree_commands = [] |
| # Use depth-first to traverse the subtree |
| for c in root_command.children: |
| commands.append(c) |
| subtree_commands = self.collect_subtree_commands(c) |
| if len(subtree_commands): |
| commands.extend(subtree_commands) |
| return commands |
| |
| def log_debug(self, msg): |
| """Log debug information. |
| msg: the message to log |
| Use the following CLI commands to enable/disable debugging: |
| paramset debug true |
| paramset debug false |
| """ |
| if self.debug: |
| print "%s" % (msg) |
| |
| def print_json_result(self, json_result): |
| """Print JSON result.""" |
| if len(json_result) == 0: |
| return |
| result = json.dumps(json_result, indent=4) |
| self.print_result(result) |
| |
| def print_result(self, result): |
| """Print parsed result.""" |
| print "%s" % (result) |
| |
| # |
| # Implementation of the "paramshow" CLI command. |
| # |
| # NOTE: The do_paramshow implementation below is copied from |
| # the cmd2.do_show() implementation |
| # |
| @options([make_option('-l', '--long', action="store_true", |
| help="describe function of parameter")]) |
| def do_paramshow(self, arg, opts): |
| '''Shows value of a parameter.''' |
| param = arg.strip().lower() |
| result = {} |
| maxlen = 0 |
| for p in self.settable: |
| if (not param) or p.startswith(param): |
| result[p] = '%s: %s' % (p, str(getattr(self, p))) |
| maxlen = max(maxlen, len(result[p])) |
| if result: |
| for p in sorted(result): |
| if opts.long: |
| self.poutput('%s # %s' % (result[p].ljust(maxlen), self.settable[p])) |
| else: |
| self.poutput(result[p]) |
| else: |
| raise NotImplementedError("Parameter '%s' not supported (type 'show' for list of parameters)." % param) |
| |
| # |
| # Implementation of the "paramset" CLI command. |
| # |
| # |
| # NOTE: The do_paramset implementation below is copied from |
| # the cmd2.do_set() implementation (with minor modifications). |
| # |
| def do_paramset(self, arg): |
| ''' |
| Sets a cmd2 parameter. Accepts abbreviated parameter names so long |
| as there is no ambiguity. Call without arguments for a list of |
| settable parameters with their values.''' |
| |
| class NotSettableError(Exception): |
| pass |
| |
| try: |
| statement, paramName, val = arg.parsed.raw.split(None, 2) |
| val = val.strip() |
| paramName = paramName.strip().lower() |
| if paramName not in self.settable: |
| hits = [p for p in self.settable if p.startswith(paramName)] |
| if len(hits) == 1: |
| paramName = hits[0] |
| else: |
| return self.do_paramshow(paramName) |
| currentVal = getattr(self, paramName) |
| if (val[0] == val[-1]) and val[0] in ("'", '"'): |
| val = val[1:-1] |
| else: |
| val = cmd2.cast(currentVal, val) |
| setattr(self, paramName, val) |
| self.stdout.write('%s - was: %s\nnow: %s\n' % (paramName, currentVal, val)) |
| if currentVal != val: |
| try: |
| onchange_hook = getattr(self, '_onchange_%s' % paramName) |
| onchange_hook(old=currentVal, new=val) |
| except AttributeError: |
| pass |
| except (ValueError, AttributeError, NotSettableError) as exc: |
| self.do_paramshow(arg) |
| |
| |
| def get_json(url): |
| """Make a REST GET call and return the JSON result |
| url: the URL to call""" |
| |
| parsed_result = [] |
| try: |
| response = urllib2.urlopen(url) |
| result = response.read() |
| response.close() |
| if len(result) != 0: |
| parsed_result = json.loads(result) |
| except HTTPError as exc: |
| print "ERROR:" |
| print " REST GET URL: %s" % url |
| # NOTE: exc.fp contains the object with the response payload |
| error_payload = json.loads(exc.fp.read()) |
| print " REST Error Code: %s" % (error_payload['code']) |
| print " REST Error Summary: %s" % (error_payload['summary']) |
| print " REST Error Description: %s" % (error_payload['formattedDescription']) |
| print " HTTP Error Code: %s" % exc.code |
| print " HTTP Error Reason: %s" % exc.reason |
| except URLError as exc: |
| print "ERROR:" |
| print " REST GET URL: %s" % url |
| print " URL Error Reason: %s" % exc.reason |
| return parsed_result |
| |
| def post_json(url, data): |
| """Make a REST POST call and return the JSON result |
| url: the URL to call |
| data: the data to POST""" |
| |
| parsed_result = [] |
| data_json = json.dumps(data) |
| try: |
| request = urllib2.Request(url, data_json) |
| request.add_header("Content-Type", "application/json") |
| response = urllib2.urlopen(request) |
| result = response.read() |
| response.close() |
| if len(result) != 0: |
| parsed_result = json.loads(result) |
| except HTTPError as exc: |
| print "ERROR:" |
| print " REST POST URL: %s" % url |
| # NOTE: exc.fp contains the object with the response payload |
| error_payload = json.loads(exc.fp.read()) |
| print " REST Error Code: %s" % (error_payload['code']) |
| print " REST Error Summary: %s" % (error_payload['summary']) |
| print " REST Error Description: %s" % (error_payload['formattedDescription']) |
| print " HTTP Error Code: %s" % exc.code |
| print " HTTP Error Reason: %s" % exc.reason |
| except URLError as exc: |
| print "ERROR:" |
| print " REST POST URL: %s" % url |
| print " URL Error Reason: %s" % exc.reason |
| return parsed_result |
| |
| def delete_json(url): |
| """Make a REST DELETE call and return the JSON result |
| url: the URL to call""" |
| |
| parsed_result = [] |
| try: |
| request = urllib2.Request(url) |
| request.get_method = lambda: 'DELETE' |
| response = urllib2.urlopen(request) |
| result = response.read() |
| response.close() |
| if len(result) != 0: |
| parsed_result = json.loads(result) |
| except HTTPError as exc: |
| print "ERROR:" |
| print " REST DELETE URL: %s" % url |
| # NOTE: exc.fp contains the object with the response payload |
| error_payload = json.loads(exc.fp.read()) |
| print " REST Error Code: %s" % (error_payload['code']) |
| print " REST Error Summary: %s" % (error_payload['summary']) |
| print " REST Error Description: %s" % (error_payload['formattedDescription']) |
| print " HTTP Error Code: %s" % exc.code |
| print " HTTP Error Reason: %s" % exc.reason |
| except URLError as exc: |
| print "ERROR:" |
| print " REST DELETE URL: %s" % url |
| print " URL Error Reason: %s" % exc.reason |
| return parsed_result |
| |
| if __name__ == '__main__': |
| onosCli = OnosCli() |
| |
| # Setup the parser |
| parser = argparse.ArgumentParser() |
| parser.add_argument('-c', '--command', nargs=argparse.REMAINDER, |
| help="Run arguments to the end of the line as a CLI command") |
| parser.add_argument('--onos-ip', |
| help="Set the ONOS IP address (for REST calls)") |
| parser.add_argument('--onos-port', |
| help="Set the ONOS port number (for REST calls)") |
| parser.add_argument('-t', '--test', nargs='+', |
| help="Test against transcript(s) in FILE (wildcards OK)") |
| |
| # Parse the arguments |
| parsed_args = parser.parse_args() |
| if parsed_args.onos_ip: |
| onosCli.onos_ip = parsed_args.onos_ip |
| if parsed_args.onos_port: |
| onosCli.onos_port = parsed_args.onos_port |
| # |
| # NOTE: We have to reset the command-line options so the Cmd2 parser |
| # doesn't process them again. |
| # |
| sys.argv = [sys.argv[0]] |
| |
| # Run the CLI as appropriate |
| if parsed_args.test: |
| # Run CLI Transcript Tests |
| onosCli.runTranscriptTests(parsed_args.test) |
| elif parsed_args.command: |
| # Run arguments as a CLI command |
| command_line = ' '.join(parsed_args.command) |
| onosCli.onecmd(command_line) |
| else: |
| # Run interactive CLI |
| onosCli.cmdloop() |