| #! /usr/bin/python |
| |
| # Copyright 2014-2016 Linaro Limited |
| # |
| # This program is free software; you can redistribute it and/or modify |
| # it under the terms of the GNU General Public License as published by |
| # the Free Software Foundation; either version 2 of the License, or |
| # (at your option) any later version. |
| # |
| # This program is distributed in the hope that it will be useful, |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| # GNU General Public License for more details. |
| # |
| # You should have received a copy of the GNU General Public License |
| # along with this program; if not, write to the Free Software |
| # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
| # MA 02110-1301, USA. |
| # |
| # VLANd admin interface |
| # |
| |
| import os, sys |
| import argparse |
| import datetime, time |
| |
| vlandpath = os.path.abspath(os.path.normpath(os.path.dirname(sys.argv[0]))) |
| sys.path.insert(0, vlandpath) |
| |
| from errors import InputError, SocketError, NotFoundError, Error |
| from config.config import VlanConfig |
| from ipc.ipc import VlanIpc |
| |
| prog = "admin" |
| version = "0.6" |
| banner = "Linaro VLANd admin interface, version %s" % version |
| exitcode = Error.OK |
| TRUNK_ID_NONE = -1 |
| |
| def is_positive(text): |
| if text in ('1', 'y', 'Y', 't', 'T', 'True', 'true'): |
| return True |
| elif text in ('0', 'n', 'N', 'f', 'F', 'False', 'false'): |
| return False |
| else: |
| raise InputError("Cannot parse \"%s\" as True or False" % text) |
| |
| def dump_switch(switch): |
| print "switch_id:%d name:%s" % ( |
| int(switch[0]), |
| switch[1]) |
| |
| def dump_port(port): |
| print "port_id:%d name:%s switch_id:%d locked:%s mode:%s base_vlan_id:%d current_vlan_id:%d number:%d trunk_id:%s" % ( |
| int(port[0]), |
| port[1], |
| int(port[2]), |
| ("yes" if port[3] is True else "no"), |
| ("trunk" if port[4] is True else "access"), |
| int(port[5]), |
| int(port[6]), |
| int(port[7]), |
| 'None' if (TRUNK_ID_NONE == port[8]) else port[8]) |
| |
| def dump_vlan(vlan): |
| print "vlan_id:%d name:%s tag:%d is_base_vlan:%s, creation_time:%s" % ( |
| int(vlan[0]), |
| vlan[1], |
| int(vlan[2]), |
| ("yes" if vlan[3] is True else "no"), |
| vlan[4]) |
| |
| def dump_trunk(trunk): |
| print "trunk_id:%d creation_time:%s" % ( |
| int(trunk[0]), |
| trunk[1]) |
| |
| def call_vland(msgtype, msg): |
| ipc = VlanIpc() |
| ipc.client_connect('localhost', config.vland.port) |
| msg['client_name'] = 'admin.py' |
| msg['type'] = msgtype |
| ipc.client_send(msg) |
| ret = ipc.client_recv_and_close() |
| if 'response' not in ret: |
| raise SocketError("Badly-formed response from VLANd server") |
| if ret['response'] == "ERROR": |
| raise InputError("VLANd server said \"%s\"" % ret['error']) |
| if ret['response'] == "NOTFOUND": |
| raise NotFoundError("VLANd server said \"%s\"" % ret['error']) |
| return ret['data'] |
| |
| config = VlanConfig(filenames=('./vland.cfg',)) |
| |
| parser = argparse.ArgumentParser() |
| |
| #################### |
| # System commands |
| #################### |
| sp = parser.add_subparsers(title='Sub-commands', |
| help="Commands", |
| dest='subparser_name') |
| p_status = sp.add_parser("status", |
| help="Describe current system status") |
| p_status.set_defaults(which = "status") |
| p_statistics = sp.add_parser("statistics", |
| help="Print some system statistics") |
| p_statistics.set_defaults(which = "statistics") |
| p_version = sp.add_parser("version", |
| help="Describe the version of this admin interface") |
| p_version.set_defaults(which = "version") |
| p_vland_version = sp.add_parser("vland_version", |
| help="Describe the version of the running VLANd") |
| p_vland_version.set_defaults(which = "vland_version") |
| p_probe_switches = sp.add_parser("probe_switches", |
| help="Probe all the configured switches") |
| p_probe_switches.set_defaults(which = "probe_switches") |
| p_auto_import = sp.add_parser("auto_import_switch", |
| help="Attempt to import a switch's configuration into the VLANd system") |
| p_auto_import.add_argument('--name', |
| required = True, |
| help="Import the switch named SWITCH_NAME in vland.cfg") |
| p_auto_import.set_defaults(which = "auto_import_switch") |
| p_shutdown = sp.add_parser("shutdown", |
| help="Shut down a running VLANd") |
| p_shutdown.set_defaults(which = "shutdown") |
| |
| #################### |
| # Switch commands |
| #################### |
| p_list_all_switches = sp.add_parser("list_all_switches", |
| help="List all the existing switches in the system") |
| p_list_all_switches.set_defaults(which = "list_all_switches") |
| p_create_switch = sp.add_parser("create_switch", |
| help = "Add a new switch to the system") |
| p_create_switch.set_defaults(which = "create_switch") |
| p_create_switch.add_argument('--name', |
| required = True, |
| help="The name of the new switch, as described in vland.cfg") |
| p_delete_switch = sp.add_parser("delete_switch", |
| help = "Remove an existing switch from the system") |
| p_delete_switch.set_defaults(which = "delete_switch") |
| p_delete_switch.add_argument('--switch_id', |
| required = True, |
| help = "The ID of the switch to remove") |
| p_show_switch = sp.add_parser("show_switch", |
| help = "Show the details of an existing switch in the system") |
| p_show_switch.set_defaults(which = "show_switch") |
| p_show_switch.add_argument('--switch_id', |
| required = True, |
| help = "The ID of the switch to show") |
| p_lookup_switch_by_name = sp.add_parser("lookup_switch_by_name", |
| help = "Lookup a switch ID by name") |
| p_lookup_switch_by_name.set_defaults(which = "lookup_switch_by_name") |
| p_lookup_switch_by_name.add_argument('--name', |
| required = True, |
| help = "The switch name to search for") |
| |
| #################### |
| # Ports commands |
| #################### |
| p_list_all_ports = sp.add_parser("list_all_ports", |
| help="List all the existing ports in the system") |
| p_list_all_ports.set_defaults(which = "list_all_ports") |
| p_create_port = sp.add_parser("create_port", |
| help = "Add a new port to the system") |
| p_create_port.set_defaults(which = "create_port") |
| p_create_port.add_argument('--switch_id', |
| required = True, |
| help="The ID of the switch containing the new port") |
| p_create_port.add_argument('--name', |
| required = True, |
| help="The name of the new port") |
| p_create_port.add_argument('--number', |
| required = True, |
| help="The human-friendly number for the new port") |
| p_delete_port = sp.add_parser("delete_port", |
| help = "Remove an existing port from the system") |
| p_delete_port.set_defaults(which = "delete_port") |
| p_delete_port.add_argument('--port_id', |
| required = True, |
| help = "The ID of the port to remove") |
| p_show_port = sp.add_parser("show_port", |
| help = "Show the details of an existing port in the system") |
| p_show_port.set_defaults(which = "show_port") |
| p_show_port.add_argument('--port_id', |
| required = True, |
| help = "The ID of the port to show") |
| p_lookup_port_by_switch_and_name = sp.add_parser("lookup_port_by_switch_and_name", |
| help = "Lookup a port ID by switch ID and port name") |
| p_lookup_port_by_switch_and_name.set_defaults(which = "lookup_port_by_switch_and_name") |
| p_lookup_port_by_switch_and_name.add_argument('--switch_id', |
| required = True, |
| help = "The switch ID to search for") |
| p_lookup_port_by_switch_and_name.add_argument('--name', |
| required = True, |
| help = "The port name to search for") |
| p_lookup_port_by_switch_and_number = sp.add_parser("lookup_port_by_switch_and_number", |
| help = "Lookup a port ID by switch ID and port number") |
| p_lookup_port_by_switch_and_number.set_defaults(which = "lookup_port_by_switch_and_number") |
| p_lookup_port_by_switch_and_number.add_argument('--switch_id', |
| required = True, |
| help = "The switch ID to search for") |
| p_lookup_port_by_switch_and_number.add_argument('--number', |
| required = True, |
| help = "The port number to search for") |
| p_lookup_ports_by_switch = sp.add_parser("lookup_ports_by_switch", |
| help = "Lookup port ID(s) by switch ID") |
| p_lookup_ports_by_switch.set_defaults(which = "lookup_ports_by_switch") |
| p_lookup_ports_by_switch.add_argument('--switch_id', |
| required = True, |
| help = "The switch ID to search for") |
| p_lookup_ports_by_current_vlan = sp.add_parser("lookup_ports_by_current_vlan", |
| help = "Lookup port ID(s) by current VLAN ID") |
| p_lookup_ports_by_current_vlan.set_defaults(which = "lookup_ports_by_current_vlan") |
| p_lookup_ports_by_current_vlan.add_argument('--vlan_id', |
| required = True, |
| help = "The VLAN ID to search for") |
| p_lookup_ports_by_base_vlan = sp.add_parser("lookup_ports_by_base_vlan", |
| help = "Lookup port ID(s) by base vlan ID") |
| p_lookup_ports_by_base_vlan.set_defaults(which = "lookup_ports_by_base_vlan") |
| p_lookup_ports_by_base_vlan.add_argument('--vlan_id', |
| required = True, |
| help = "The VLAN ID to search for") |
| p_lookup_ports_by_trunk = sp.add_parser("lookup_ports_by_trunk", |
| help = "Lookup port ID(s) by trunk ID") |
| p_lookup_ports_by_trunk.set_defaults(which = "lookup_ports_by_trunk") |
| p_lookup_ports_by_trunk.add_argument('--trunk_id', |
| required = True, |
| help = "The trunk ID to search for") |
| p_set_port_mode = sp.add_parser("set_port_mode", |
| help = "Set the mode of a port to 'trunk' or 'access'") |
| p_set_port_mode.set_defaults(which = "set_port_mode") |
| p_set_port_mode.add_argument('--port_id', |
| required = True, |
| help = "The ID of the port to modify") |
| p_set_port_mode.add_argument('--mode', |
| required = True, |
| help = "The mode to select ('trunk' or 'access')") |
| p_get_port_mode = sp.add_parser("get_port_mode", |
| help = "Get the mode of a port ('trunk' or 'access')") |
| p_get_port_mode.set_defaults(which = "get_port_mode") |
| p_get_port_mode.add_argument('--port_id', |
| required = True, |
| help = "The ID of the port to query") |
| p_lock_port = sp.add_parser("lock_port", |
| help = "Lock the settings on a port") |
| p_lock_port.set_defaults(which = "lock_port") |
| p_lock_port.add_argument('--port_id', |
| required = True, |
| help = "The ID of the port to lock") |
| p_unlock_port = sp.add_parser("unlock_port", |
| help = "Unlock the settings on a port") |
| p_unlock_port.set_defaults(which = "unlock_port") |
| p_unlock_port.add_argument('--port_id', |
| required = True, |
| help = "The ID of the port to unlock") |
| p_set_port_current_vlan = sp.add_parser("set_port_current_vlan", |
| help = "Set the current VLAN assignment for a port") |
| p_set_port_current_vlan.set_defaults(which = "set_port_current_vlan") |
| p_set_port_current_vlan.add_argument('--port_id', |
| required = True, |
| help = "The ID of the port to modify") |
| p_set_port_current_vlan.add_argument('--vlan_id', |
| required = True, |
| help = "The VLAN ID to be used") |
| p_get_port_current_vlan = sp.add_parser("get_port_current_vlan", |
| help = "Get the current VLAN assignment for a port") |
| p_get_port_current_vlan.set_defaults(which = "get_port_current_vlan") |
| p_get_port_current_vlan.add_argument('--port_id', |
| required = True, |
| help = "The ID of the port to query") |
| p_set_port_base_vlan = sp.add_parser("set_port_base_vlan", |
| help = "Set the base VLAN assignment for a port") |
| p_set_port_base_vlan.set_defaults(which = "set_port_base_vlan") |
| p_set_port_base_vlan.add_argument('--port_id', |
| required = True, |
| help = "The ID of the port to modify") |
| p_set_port_base_vlan.add_argument('--vlan_id', |
| required = True, |
| help = "The VLAN ID to be used") |
| p_get_port_base_vlan = sp.add_parser("get_port_base_vlan", |
| help = "Get the base VLAN assignment for a port") |
| p_get_port_base_vlan.set_defaults(which = "get_port_base_vlan") |
| p_get_port_base_vlan.add_argument('--port_id', |
| required = True, |
| help = "The ID of the port to query") |
| p_restore_port_to_base_vlan = sp.add_parser("restore_port_to_base_vlan", |
| help = "Reset a port back to its base VLAN") |
| p_restore_port_to_base_vlan.set_defaults(which = "restore_port_to_base_vlan") |
| p_restore_port_to_base_vlan.add_argument('--port_id', |
| required = True, |
| help = "The ID of the port to modify") |
| |
| #################### |
| # VLAN commands |
| #################### |
| p_list_all_vlans = sp.add_parser("list_all_vlans", |
| help="List all the existing VLANs in the system") |
| p_list_all_vlans.set_defaults(which = "list_all_vlans") |
| p_create_vlan = sp.add_parser("create_vlan", |
| help = "Add a new VLAN to the system") |
| p_create_vlan.set_defaults(which = "create_vlan") |
| p_create_vlan.add_argument('--name', |
| required = True, |
| help="The name of the new VLAN") |
| p_create_vlan.add_argument('--tag', |
| required = True, |
| help="The tag for the new VLAN (-1 to automatically select)") |
| p_create_vlan.add_argument('--is_base_vlan', |
| required = True, |
| help="Is the new VLAN a base VLAN (true/false)") |
| p_delete_vlan = sp.add_parser("delete_vlan", |
| help = "Remove an existing VLAN from the system") |
| p_delete_vlan.set_defaults(which = "delete_vlan") |
| p_delete_vlan.add_argument('--vlan_id', |
| required = True, |
| help = "The ID of the VLAN to remove") |
| p_show_vlan = sp.add_parser("show_vlan", |
| help = "Show the details of an existing VLAN in the system") |
| p_show_vlan.set_defaults(which = "show_vlan") |
| p_show_vlan.add_argument('--vlan_id', |
| required = True, |
| help = "The ID of the VLAN to show") |
| p_lookup_vlan_by_tag = sp.add_parser("lookup_vlan_by_tag", |
| help = "Find the VLAN ID of an existing VLAN in the system") |
| p_lookup_vlan_by_tag.set_defaults(which = "lookup_vlan_by_tag") |
| p_lookup_vlan_by_tag.add_argument('--tag', |
| required = True, |
| help = "The VLAN tag to search for") |
| p_show_vlan_tag = sp.add_parser("show_vlan_tag", |
| help = "Print the VLAN tag of an existing VLAN in the system") |
| p_show_vlan_tag.set_defaults(which = "show_vlan_tag") |
| p_show_vlan_tag.add_argument('--vlan_id', |
| required = True, |
| help = "The VLAN ID to search for") |
| |
| #################### |
| # Trunk commands |
| #################### |
| p_list_all_trunks = sp.add_parser("list_all_trunks", |
| help="List all the existing trunks in the system") |
| p_list_all_trunks.set_defaults(which = "list_all_trunks") |
| p_create_trunk = sp.add_parser("create_trunk", |
| help = "Add a new trunk to the system, linking two ports") |
| p_create_trunk.set_defaults(which = "create_trunk") |
| p_create_trunk.add_argument('--port_id1', |
| required = True, |
| help="The ID of the first port to be used") |
| p_create_trunk.add_argument('--port_id2', |
| required = True, |
| help="The ID of the second port to be used") |
| p_delete_trunk = sp.add_parser("delete_trunk", |
| help = "Remove an existing trunk from the system") |
| p_delete_trunk.set_defaults(which = "delete_trunk") |
| p_delete_trunk.add_argument('--trunk_id', |
| required = True, |
| help = "The ID of the trunk to remove") |
| p_show_trunk = sp.add_parser("show_trunk", |
| help = "Show the details of an existing trunk in the system") |
| p_show_trunk.set_defaults(which = "show_trunk") |
| p_show_trunk.add_argument('--trunk_id', |
| required = True, |
| help = "The ID of the trunk to show") |
| |
| args = parser.parse_args() |
| |
| # Now work out what to do |
| if args.which == 'status': |
| try: |
| print 'Config:' |
| print ' knows about %d switch(es)' % len(config.switches) |
| default_vlan_id = call_vland('db_query', |
| {'command':'db.get_vlan_id_by_tag', |
| 'data': |
| {'tag': config.vland.default_vlan_tag}}) |
| print 'The default vlan tag (%d) is vlan ID %d' % (config.vland.default_vlan_tag, default_vlan_id) |
| stat = call_vland('daemon_query', {'command':'daemon.status', 'data': None}) |
| print 'VLANd is running %s' % stat['running'] |
| lastmod = datetime.datetime.strptime(stat['last_modified'], '%Y-%m-%dT%H:%M:%S.%f') |
| print 'DB Last modified %s' % lastmod.strftime('%Y-%m-%d %H:%M:%S %Z') |
| print 'DB via VLANd:' |
| switches = call_vland('db_query', {'command':'db.all_switches', 'data':None}) |
| print ' knows about %d switch(es)' % len(switches) |
| ports = call_vland('db_query', {'command':'db.all_ports', 'data':None}) |
| print ' knows about %d port(s)' % len(ports) |
| vlans = call_vland('db_query', {'command':'db.all_vlans', 'data':None}) |
| print ' DB knows about %d vlan(s)' % len(vlans) |
| except (InputError, NotFoundError): |
| exitcode = Error.FAILED |
| elif args.which == 'shutdown': |
| try: |
| print 'Asking VLANd to shutdown' |
| shutdown = call_vland('daemon_query', |
| {'command':'daemon.shutdown', |
| 'data': None}) |
| for field in shutdown: |
| print '%s: %s' % (field, shutdown[field]) |
| except (InputError, NotFoundError): |
| exitcode = Error.FAILED |
| elif args.which == 'vland_version': |
| try: |
| ver = call_vland('daemon_query', {'command':'daemon.version', 'data': None}) |
| print 'VLANd version %s' % ver['version'] |
| except (InputError, NotFoundError): |
| exitcode = Error.FAILED |
| elif args.which == 'statistics': |
| try: |
| stats = call_vland('daemon_query', {'command':'daemon.statistics', 'data': None}) |
| print 'VLANd uptime: %d seconds' % stats['uptime'] |
| except (InputError, NotFoundError): |
| exitcode = Error.FAILED |
| elif args.which == 'version': |
| print 'VLANd admin interface version %s' % version |
| elif args.which == 'auto_import_switch': |
| print 'Attempting to import switch %s' % args.name |
| if args.name not in config.switches: |
| raise InputError("Can't find switch %s in config" % args.name) |
| try: |
| imp = call_vland('vlan_update', |
| {'command':'api.auto_import_switch', |
| 'data': |
| {'switch': args.name}}) |
| print 'VLANd imported switch %s successfully: new switch_id %d, %d new ports, %d new VLANs' % (args.name, imp['switch_id'], imp['num_ports_added'], imp['num_vlans_added']) |
| except (InputError, NotFoundError): |
| print 'Import failed - see log for details' |
| exitcode = Error.FAILED |
| elif args.which == 'probe_switches': |
| print 'Asking VLANd to probe all the configured switches' |
| try: |
| probe = call_vland('daemon_query', |
| {'command':'daemon.probe_switches', |
| 'data': None}) |
| for field in probe: |
| print '%s: %s' % (field, probe[field]) |
| except (InputError, NotFoundError): |
| print 'Probe failed - see log for details' |
| exitcode = Error.FAILED |
| elif args.which == 'list_all_switches': |
| try: |
| result = call_vland('db_query', {'command':'db.all_switches', 'data':None}) |
| for line in result: |
| dump_switch(line) |
| except (InputError, NotFoundError): |
| exitcode = Error.FAILED |
| elif args.which == 'list_all_ports': |
| try: |
| result = call_vland('db_query', {'command':'db.all_ports', 'data':None}) |
| for line in result: |
| dump_port(line) |
| except (InputError, NotFoundError): |
| exitcode = Error.FAILED |
| elif args.which == 'list_all_vlans': |
| try: |
| result = call_vland('db_query', {'command':'db.all_vlans', 'data':None}) |
| for line in result: |
| dump_vlan(line) |
| except (InputError, NotFoundError): |
| exitcode = Error.FAILED |
| elif args.which == 'list_all_trunks': |
| try: |
| result = call_vland('db_query', {'command':'db.all_trunks', 'data':None}) |
| for line in result: |
| dump_trunk(line) |
| except (InputError, NotFoundError): |
| exitcode = Error.FAILED |
| elif args.which == 'create_switch': |
| try: |
| switch_id = call_vland('db_update', |
| {'command':'db.create_switch', |
| 'data': |
| {'name':args.name}}) |
| print 'Created switch_id %d' % switch_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| elif args.which == 'create_port': |
| try: |
| port_id = call_vland('db_update', |
| {'command':'db.create_port', |
| 'data': |
| {'switch_id': args.switch_id, |
| 'name': args.name, |
| 'number': args.number}}) |
| print 'Created port_id %d' % port_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'create_vlan': |
| try: |
| (vlan_id, vlan_tag) = call_vland('vlan_update', |
| {'command':'api.create_vlan', |
| 'data': |
| {'name': args.name, |
| 'tag': args.tag, |
| 'is_base_vlan': is_positive(args.is_base_vlan)}}) |
| print 'Created VLAN tag %d as vlan_id %d' % (vlan_tag, vlan_id) |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'create_trunk': |
| try: |
| trunk_id = call_vland('db_update', |
| {'command':'db.create_trunk', |
| 'data': |
| {'port_id1': args.port_id1, |
| 'port_id2': args.port_id2}}) |
| print 'Created trunk_id %d' % trunk_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'delete_switch': |
| try: |
| switch_id = call_vland('db_update', |
| {'command':'db.delete_switch', |
| 'data': {'switch_id': args.switch_id}}) |
| print 'Deleted switch_id %s' % switch_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'delete_port': |
| try: |
| port_id = call_vland('db_update', |
| {'command':'db.delete_port', |
| 'data': {'port_id': args.port_id}}) |
| print 'Deleted port_id %s' % port_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'delete_vlan': |
| try: |
| vlan_id = call_vland('vlan_update', |
| {'command':'api.delete_vlan', |
| 'data': {'vlan_id': args.vlan_id}}) |
| print 'Deleted vlan_id %d' % vlan_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'delete_trunk': |
| try: |
| port_id = call_vland('db_update', |
| {'command':'db.delete_trunk', |
| 'data': {'trunk_id': args.trunk_id}}) |
| print 'Deleted trunk_id %s' % trunk_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'lookup_switch_by_name': |
| try: |
| switch_id = call_vland('db_query', |
| {'command':'db.get_switch_id_by_name', |
| 'data':{'name':args.name}}) |
| if switch_id is not None: |
| print '%d' % switch_id |
| else: |
| print 'No switch found for name %s' % args.name |
| exitcode = Error.NOTFOUND |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| elif args.which == 'show_switch': |
| try: |
| this_switch = call_vland('db_query', |
| {'command':'db.get_switch_by_id', |
| 'data': |
| {'switch_id': args.switch_id}}) |
| if this_switch is not None: |
| dump_switch(this_switch) |
| else: |
| print 'No switch found for switch_id %s' % args.switch_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| elif args.which == 'show_port': |
| try: |
| this_port = call_vland('db_query', |
| {'command':'db.get_port_by_id', |
| 'data': |
| {'port_id': args.port_id}}) |
| if this_port is not None: |
| dump_port(this_port) |
| else: |
| print 'No port found for port_id %s' % args.port_id |
| exitcode = Error.NOTFOUND |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| elif args.which == 'lookup_port_by_switch_and_name': |
| try: |
| p = call_vland('db_query', |
| {'command':'db.get_port_by_switch_and_name', |
| 'data': |
| {'switch_id': args.switch_id, |
| 'name': args.name}}) |
| if p is not None: |
| print p |
| else: |
| print 'No port found for switch_id %s, name %s' % (args.switch_id, args.name) |
| exitcode = Error.NOTFOUND |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| elif args.which == 'lookup_port_by_switch_and_number': |
| try: |
| p = call_vland('db_query', |
| {'command':'db.get_port_by_switch_and_number', |
| 'data': |
| {'switch_id': args.switch_id, |
| 'number': args.number}}) |
| if p is not None: |
| print p |
| else: |
| print 'No port found for switch_id %s, port number %s' % (args.switch_id, args.number) |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| elif args.which == 'lookup_ports_by_switch': |
| try: |
| p = call_vland('db_query', |
| {'command':'db.get_ports_by_switch', |
| 'data': |
| {'switch_id': args.switch_id}}) |
| if p is not None: |
| for port_id in p: |
| print port_id |
| else: |
| print 'No ports found for switch_id %s' % args.switch_id |
| exitcode = Error.NOTFOUND |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| elif args.which == 'lookup_ports_by_current_vlan': |
| try: |
| p = call_vland('db_query', |
| {'command':'db.get_ports_by_current_vlan', |
| 'data': |
| {'vlan_id': args.vlan_id}}) |
| if p is not None: |
| for port_id in p: |
| print port_id |
| else: |
| print 'No ports found for current vlan_id %s' % args.vlan_id |
| exitcode = Error.NOTFOUND |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| elif args.which == 'lookup_ports_by_base_vlan': |
| try: |
| p = call_vland('db_query', |
| {'command':'db.get_ports_by_base_vlan', |
| 'data': |
| {'vlan_id': args.vlan_id}}) |
| if p is not None: |
| for port_id in p: |
| print port_id |
| else: |
| print 'No ports found for base vlan_id %s' % args.vlan_id |
| exitcode = Error.NOTFOUND |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| elif args.which == 'lookup_ports_by_trunk': |
| try: |
| p = call_vland('db_query', |
| {'command':'db.get_ports_by_trunk', |
| 'data': |
| {'trunk_id': args.trunk_id}}) |
| if p is not None: |
| for port_id in p: |
| print port_id |
| else: |
| print 'No ports found for trunk_id %s' % args.trunk_id |
| exitcode = Error.NOTFOUND |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| elif args.which == 'set_port_mode': |
| try: |
| port_id = call_vland('vlan_update', |
| {'command':'api.set_port_mode', |
| 'data': |
| {'port_id': args.port_id, |
| 'mode': args.mode}}) |
| print "Updated mode for port_id %d" % port_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'lock_port': |
| try: |
| port_id = call_vland('db_update', |
| {'command':'db.set_port_is_locked', |
| 'data': |
| {'port_id': args.port_id, |
| 'is_locked': True}}) |
| print "Locked port_id %d" % port_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'unlock_port': |
| try: |
| port_id = call_vland('db_update', |
| {'command':'db.set_port_is_locked', |
| 'data': |
| {'port_id': args.port_id, |
| 'is_locked': False}}) |
| print "Unlocked port_id %d" % port_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'set_port_current_vlan': |
| try: |
| port_id = call_vland('vlan_update', |
| {'command':'api.set_current_vlan', |
| 'data': |
| {'port_id': args.port_id, |
| 'vlan_id': args.vlan_id}}) |
| print "Set current VLAN on port_id %d" % port_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'get_port_current_vlan': |
| try: |
| vlan_id = call_vland('db_query', |
| {'command':'db.get_current_vlan_id_by_port', |
| 'data': |
| {'port_id': args.port_id}}) |
| if vlan_id is not None: |
| print vlan_id |
| else: |
| print "No current_vlan_id found for port_id %s" % args.port_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'set_port_base_vlan': |
| try: |
| port_id = call_vland('db_update', |
| {'command':'db.set_base_vlan', |
| 'data': |
| {'port_id': args.port_id, |
| 'base_vlan_id': args.vlan_id}}) |
| print "Set base VLAN on port_id %d" % port_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'get_port_base_vlan': |
| try: |
| vlan_id = call_vland('db_query', |
| {'command':'db.get_base_vlan_id_by_port', |
| 'data': |
| {'port_id': args.port_id}}) |
| if vlan_id is not None: |
| print vlan_id |
| else: |
| print "No base_vlan_id found for port_id %d" % port_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'restore_port_to_base_vlan': |
| try: |
| port_id = call_vland('vlan_update', |
| {'command': 'api.restore_base_vlan', |
| 'data': |
| {'port_id': args.port_id}}) |
| print "Restored port_id %d back to base VLAN" % port_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'show_vlan': |
| try: |
| v = call_vland('db_query', |
| {'command':'db.get_vlan_by_id', |
| 'data': |
| {'vlan_id': args.vlan_id}}) |
| if v is not None: |
| dump_vlan(v) |
| else: |
| print 'No VLAN found for vlan_id %s' % args.vlan_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| elif args.which == 'lookup_vlan_by_tag': |
| try: |
| vlan_id = call_vland('db_query', |
| {'command':'db.get_vlan_id_by_tag', |
| 'data': |
| {'tag': args.tag}}) |
| if vlan_id is not None: |
| print vlan_id |
| else: |
| print 'No VLAN found for vlan tag %s' % args.tag |
| exitcode = Error.NOTFOUND |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| elif args.which == 'show_vlan_tag': |
| try: |
| vlan_tag = call_vland('db_query', |
| {'command':'db.get_vlan_tag_by_id', |
| 'data': |
| {'vlan_id': args.vlan_id}}) |
| if vlan_tag is not None: |
| print vlan_tag |
| else: |
| print 'No VLAN found for vlan id %s' % args.vlan_id |
| exitcode = Error.NOTFOUND |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| elif args.which == 'show_trunk': |
| try: |
| this_trunk = call_vland('db_query', |
| {'command':'db.get_trunk_by_id', |
| 'data': |
| {'trunk_id': args.trunk_id}}) |
| if this_trunk is not None: |
| dump_trunk(this_trunk) |
| else: |
| print 'No port found for port_id %s' % args.trunk_id |
| except InputError as inst: |
| print 'Failed: %s' % inst |
| print 'Failed: %s' % inst |
| exitcode = Error.FAILED |
| except NotFoundError as inst: |
| print 'Failed: %s' % inst |
| exitcode = Error.NOTFOUND |
| else: |
| print 'No recognised command given. Try -h for help' |
| |
| sys.exit(exitcode) |