Initial Mellanox switch driver
Adds support for the Mellanox MLNX-OS switch OS, as found on the
SN2100 switch in the LNG lab.
This *will* get confused if you change the port configuration and go
from single links to quad links or vice versa...
Change-Id: I6e095f8b433b3804ca22d6e5f275a6e6a39dae0b
diff --git a/drivers/Mellanox.py b/drivers/Mellanox.py
new file mode 100644
index 0000000..0bbf9f9
--- /dev/null
+++ b/drivers/Mellanox.py
@@ -0,0 +1,782 @@
+#! /usr/bin/python
+
+# Copyright 2018 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.
+
+import logging
+import sys
+import re
+import pexpect
+
+# Mellanox MLNX-OS driver
+# Developed and tested against the SN2100 in the Linaro LAVA lab
+
+if __name__ == '__main__':
+ import os
+ vlandpath = os.path.abspath(os.path.normpath(os.path.dirname(sys.argv[0])))
+ sys.path.insert(0, vlandpath)
+ sys.path.insert(0, "%s/.." % vlandpath)
+
+from errors import InputError, PExpectError
+from drivers.common import SwitchDriver, SwitchErrors
+
+class MlnxOS(SwitchDriver):
+
+ connection = None
+ _username = None
+ _password = None
+ _enable_password = None
+
+ _capabilities = [
+ 'TrunkWildCardVlans' # Trunk ports are on all VLANs by
+ # default, so we shouldn't need to
+ # bugger with them
+ ]
+
+ # Regexp of expected hardware information - fail if we don't see
+ # this
+ _expected_descr_re = re.compile(r'MLNX-OS')
+
+ def __init__(self, switch_hostname, switch_telnetport=23, debug = False):
+ SwitchDriver.__init__(self, switch_hostname, debug)
+ self._systemdata = []
+ self.exec_string = "/usr/bin/telnet %s %d" % (switch_hostname, switch_telnetport)
+ self.errors = SwitchErrors()
+
+ ################################
+ ### Switch-level API functions
+ ################################
+
+ # Save the current running config into flash - we want config to
+ # remain across reboots
+ def switch_save_running_config(self):
+ try:
+ self._configure()
+ self._cli("configuration write")
+ self._end_configure()
+ except (PExpectError, pexpect.EOF):
+ # recurse on error
+ self._switch_connect()
+ self.switch_save_running_config()
+
+ # Restart the switch - we need to reload config to do a
+ # roll-back. Do NOT save running-config first if the switch asks -
+ # we're trying to dump recent changes, not save them.
+ #
+ # This will also implicitly cause a connection to be closed
+ def switch_restart(self):
+ self._cli("reload noconfirm")
+
+ # List the capabilities of the switch (and driver) - some things
+ # make no sense to abstract. Returns a dict of strings, each one
+ # describing an extra feature that that higher levels may care
+ # about
+ def switch_get_capabilities(self):
+ return self._capabilities
+
+ ################################
+ ### VLAN API functions
+ ################################
+
+ # Create a VLAN with the specified tag
+ def vlan_create(self, tag):
+ logging.debug("Creating VLAN %d", tag)
+ try:
+ self._configure()
+ self._cli("vlan %d" % tag)
+ self._end_vlan()
+ self._end_configure()
+
+ # Validate it happened
+ vlans = self.vlan_get_list()
+ for vlan in vlans:
+ if vlan == tag:
+ return
+ raise IOError("Failed to create VLAN %d" % tag)
+
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ self.vlan_create(tag)
+
+ # Destroy a VLAN with the specified tag
+ def vlan_destroy(self, tag):
+ logging.debug("Destroying VLAN %d", tag)
+
+ try:
+ self._configure()
+ self._cli("no vlan %d" % tag)
+ self._end_configure()
+
+ # Validate it happened
+ vlans = self.vlan_get_list()
+ for vlan in vlans:
+ if vlan == tag:
+ raise IOError("Failed to destroy VLAN %d" % tag)
+
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ self.vlan_destroy(tag)
+
+ # Set the name of a VLAN
+ def vlan_set_name(self, tag, name):
+ logging.debug("Setting name of VLAN %d to %s", tag, name)
+
+ try:
+ self._configure()
+ self._cli("vlan %d name %s" % (tag, name))
+ self._end_configure()
+
+ # Validate it happened
+ read_name = self.vlan_get_name(tag)
+ if read_name != name:
+ raise IOError("Failed to set name for VLAN %d (name found is \"%s\", not \"%s\")"
+ % (tag, read_name, name))
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ self.vlan_set_name(tag, name)
+
+ # Get a list of the VLAN tags currently registered on the switch
+ def vlan_get_list(self):
+ logging.debug("Grabbing list of VLANs")
+
+ try:
+ vlans = []
+
+ regex = re.compile(r'^ *(\d+)')
+
+ self._cli("show vlan")
+ for line in self._read_long_output("show vlan"):
+ match = regex.match(line)
+ if match:
+ vlans.append(int(match.group(1)))
+ return vlans
+
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ return self.vlan_get_list()
+
+ # For a given VLAN tag, ask the switch what the associated name is
+ def vlan_get_name(self, tag):
+
+ try:
+ logging.debug("Grabbing the name of VLAN %d", tag)
+ name = None
+
+ # Ugh, the output here is messy. VLAN names can include spaces, and
+ # there are no delimiters in the output, e.g.:
+ # VLAN Name Ports
+ # ---- ----------- --------------------------------------
+ # 1 default Eth1/1/1, Eth1/1/2, Eth1/2, Eth1/3/1, Eth1/3/2,
+ # Eth1/4, Eth1/5, Eth1/6, Eth1/7, Eth1/8,
+ # Eth1/10, Eth1/12, Eth1/13, Eth1/14, Eth1/15,
+ # Eth1/16
+ # 102 mdev testing
+ # 103 vpp 1 performance testing Eth1/1/3, Eth1/9
+ # 104 vpp 2 performance testing Eth1/1/4, Eth1/11
+ #
+ # Simplest strategy:
+ # 1. Match on a leading number and grab all the text after it
+ # 2. Drop anything starting with "Eth" to EOL
+ # 3. Strip leading and trailing whitespace
+ #
+ # Not perfect, but it'll have to do. Anybody including "Eth" in a
+ # VLAN name deserves to lose...
+
+ regex = re.compile(r'^ *\d+\s+(.+)')
+ self._cli("show vlan id %d" % tag)
+ for line in self._read_long_output("show vlan id"):
+ match = regex.match(line)
+ if match:
+ name = re.sub(r'Eth.*$',"",match.group(1)).strip()
+ return name
+
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ return self.vlan_get_name(tag)
+
+
+ ################################
+ ### Port API functions
+ ################################
+
+ # Set the mode of a port: access or trunk
+ def port_set_mode(self, port, mode):
+ logging.debug("Setting port %s to %s", port, mode)
+ if not self._is_port_mode_valid(mode):
+ raise InputError("Port mode %s is not allowed" % mode)
+ if not self._is_port_name_valid(port):
+ raise InputError("Port name %s not recognised" % port)
+
+ try:
+ self._configure()
+ self._cli("interface ethernet %s" % port)
+ self._cli("switchport mode %s" % mode)
+ if mode == "trunk":
+ # Put the new trunk port on all VLANs
+ self._cli("switchport trunk allowed-vlan all")
+ self._end_interface()
+ self._end_configure()
+
+ # Validate it happened
+ read_mode = self._port_get_mode(port)
+ if read_mode != mode:
+ raise IOError("Failed to set mode for port %s" % port)
+
+ # And cache the result
+ self._port_modes[port] = mode
+
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ self.port_set_mode(port, mode)
+
+ # Set an access port to be in a specified VLAN (tag)
+ def port_set_access_vlan(self, port, tag):
+ logging.debug("Setting access port %s to VLAN %d", port, tag)
+ if not self._is_port_name_valid(port):
+ raise InputError("Port name %s not recognised" % port)
+ if not (self.port_get_mode(port) == "access"):
+ raise InputError("Port %s not in access mode" % port)
+
+ try:
+ self._configure()
+ self._cli("interface ethernet %s" % port)
+ self._cli("switchport access vlan %d" % tag)
+ self._end_interface()
+ self._end_configure()
+
+ # Validate things worked
+ read_vlan = int(self.port_get_access_vlan(port))
+ if read_vlan != tag:
+ raise IOError("Failed to move access port %s to VLAN %d - got VLAN %d instead"
+ % (port, tag, read_vlan))
+
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ self.port_set_access_vlan(port, tag)
+
+ # Add a trunk port to a specified VLAN (tag)
+ def port_add_trunk_to_vlan(self, port, tag):
+ logging.debug("Adding trunk port %s to VLAN %d", port, tag)
+ if not self._is_port_name_valid(port):
+ raise InputError("Port name %s not recognised" % port)
+ if not (self.port_get_mode(port) == "trunk"):
+ raise InputError("Port %s not in trunk mode" % port)
+
+ try:
+ self._configure()
+ self._cli("interface ethernet %s" % port)
+ self._cli("switchport trunk allowed-vlan add %d" % tag)
+ self._end_interface()
+ self._end_configure()
+
+ # Validate it happened
+ read_vlans = self.port_get_trunk_vlan_list(port)
+ for vlan in read_vlans:
+ if vlan == tag or vlan == "ALL":
+ return
+ raise IOError("Failed to add trunk port %s to VLAN %d" % (port, tag))
+
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ self.port_add_trunk_to_vlan(port, tag)
+
+ # Remove a trunk port from a specified VLAN (tag)
+ def port_remove_trunk_from_vlan(self, port, tag):
+ logging.debug("Removing trunk port %s from VLAN %d", port, tag)
+ if not self._is_port_name_valid(port):
+ raise InputError("Port name %s not recognised" % port)
+ if not (self.port_get_mode(port) == "trunk"):
+ raise InputError("Port %s not in trunk mode" % port)
+
+ try:
+ self._configure()
+ self._cli("interface ethernet %s" % port)
+ self._cli("switchport trunk allowed-vlan remove %d" % tag)
+ self._end_interface()
+ self._end_configure()
+
+ # Validate it happened
+ read_vlans = self.port_get_trunk_vlan_list(port)
+ for vlan in read_vlans:
+ if vlan == tag:
+ raise IOError("Failed to remove trunk port %s from VLAN %d" % (port, tag))
+
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ self.port_remove_trunk_from_vlan(port, tag)
+
+ # Get the configured VLAN tag for an access port (tag)
+ def port_get_access_vlan(self, port):
+ logging.debug("Getting VLAN for access port %s", port)
+ if not self._is_port_name_valid(port):
+ raise InputError("Port name %s not recognised" % port)
+ if not (self.port_get_mode(port) == "access"):
+ raise InputError("Port %s not in access mode" % port)
+
+ regex = re.compile(r'^Eth%s\s+access\s+(\d+)' % port)
+
+ try:
+ self._cli("show interfaces switchport")
+ for line in self._read_long_output("show interfaces switchport"):
+ match = regex.match(line)
+ if match:
+ vlan = match.group(1)
+ return int(vlan)
+
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ return self.port_get_access_vlan(port)
+
+ # Get the list of configured VLAN tags for a trunk port
+ def port_get_trunk_vlan_list(self, port):
+ logging.debug("Getting VLANs for trunk port %s", port)
+ vlans = []
+ if not self._is_port_name_valid(port):
+ raise InputError("Port name %s not recognised" % port)
+ if not (self.port_get_mode(port) == "trunk"):
+ raise InputError("Port %s not in trunk mode" % port)
+ regex_start = re.compile(r'^Eth%s\s+trunk\s+N/A\s+(.*)' % port)
+ regex_continue = re.compile(r'^(\d.*)')
+
+ try:
+ self._cli("show interfaces switchport")
+
+ # Complex parsing work - VLAN list may extend over several lines, e.g.:
+ #
+ # Eth1/16 trunk N/A 1, 102, 103, 104, 1000, 1001, 1002
+ # 1003, 1004
+ #
+ in_match = False
+ vlan_text = ''
+
+ for line in self._read_long_output("show interfaces switchport"):
+ if in_match:
+ match = regex_continue.match(line)
+ if match:
+ vlan_text += ', ' # Make a consistently-formed list
+ vlan_text += match.group(1)
+ else:
+ in_match = False
+ if not in_match:
+ match = regex_start.match(line)
+ if match:
+ vlan_text += match.group(1)
+ in_match = True
+
+ vlans = self._parse_vlan_list(vlan_text)
+ return vlans
+
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ return self.port_get_trunk_vlan_list(port)
+
+ ################################
+ ### Internal functions
+ ################################
+
+ # Connect to the switch and log in
+ def _switch_connect(self):
+
+ if not self.connection is None:
+ self.connection.close(True)
+ self.connection = None
+
+ logging.debug("Connecting to Switch with: %s", self.exec_string)
+ self.connection = pexpect.spawn(self.exec_string, logfile=self.logger)
+ self._login()
+
+ # Avoid paged output as much as possible
+ self._cli("terminal length 999")
+ # Don't do silly things with ANSI codes
+ self._cli("terminal type dumb")
+ # and disable auto-logout after delay
+ self._cli("no cli session auto-logout")
+
+ # And grab details about the switch. in case we need it
+ self._get_systemdata()
+
+ # And also validate them - make sure we're driving a switch of
+ # the correct model! Also store the serial number
+ descr_regex = re.compile(r'Product name:\s*(\S+)')
+ sn_regex = re.compile(r'System serial num:\s*(\S+)')
+ descr = ""
+
+ for line in self._systemdata:
+ match = descr_regex.match(line)
+ if match:
+ descr = match.group(1)
+ match = sn_regex.match(line)
+ if match:
+ self.serial_number = match.group(1)
+
+ logging.debug("serial number is %s", self.serial_number)
+ logging.debug("system description is %s", descr)
+
+ if not self._expected_descr_re.match(descr):
+ raise IOError("Switch %s not recognised by this driver: abort" % descr)
+
+ # Now build a list of our ports, for later sanity checking
+ self._ports = self._get_port_names()
+ if len(self._ports) < 4:
+ raise IOError("Not enough ports detected - problem!")
+
+ def _login(self):
+ logging.debug("attempting login with username %s, password %s", self._username, self._password)
+ if self._username is not None:
+ self.connection.expect("login:")
+ self._cli("%s" % self._username)
+ if self._password is not None:
+ self.connection.expect("Password:")
+ self._cli("%s" % self._password, False)
+ while True:
+ index = self.connection.expect(['User:', 'Password:', 'Login incorrect', 'authentication failed', r'(.*?)(#|>)'])
+ if index != 4: # Any other means: failed to log in!
+ logging.error("Login failure: index %d\n", index)
+ logging.error("Login failure: %s\n", self.connection.match.before)
+ raise IOError
+
+ # else
+
+ # Add a couple of newlines to get past the "last login" etc. junk
+ self._cli("")
+ self._cli("")
+ self.connection.expect(r'^(.*?) (#|>)')
+ self._prompt_name = re.escape(self.connection.match.group(1).strip())
+ logging.info("Got outer prompt \"%s\"", self._prompt_name)
+ if self.connection.match.group(2) == ">":
+ # Need to enter "enable" mode too
+ self._cli("enable")
+ if self._enable_password is not None:
+ self.connection.expect("Password:")
+ self._cli("%s" % self._enable_password, False)
+ index = self.connection.expect(['Password:', 'Login incorrect', 'authentication failed', r'(.*) *(#|>)'])
+ if index != 3: # Any other means: failed to log in!
+ logging.error("Enable password failure: %s\n", self.connection.match)
+ raise IOError
+ self._cli("")
+ self._cli("")
+ self.connection.expect(r'^(.*?) (#|>)')
+ self._prompt_name = re.escape(self.connection.match.group(1).strip())
+ logging.info("Got enable prompt \"%s\"", self._prompt_name)
+ return 0
+
+ def _logout(self):
+ logging.debug("Logging out")
+ self._cli("quit", False)
+ try:
+ self.connection.expect("Would you like to save them now")
+ self._cli("n")
+ except (pexpect.EOF):
+ pass
+ self.connection.close(True)
+
+ def _configure(self):
+ self._cli("configure terminal")
+
+ def _end_configure(self):
+ self._cli("exit")
+
+ def _end_interface(self):
+ self._cli("exit")
+
+ def _end_vlan(self):
+ self._cli("exit")
+
+ def _read_long_output(self, text):
+ longbuf = []
+ prompt = self._prompt_name + r'\s*#'
+ while True:
+ try:
+ index = self.connection.expect([r'lines \d+-\d+', prompt])
+ if index == 0: # "lines 45-50"
+ for line in self.connection.before.split('\r\n'):
+ longbuf.append(line.strip())
+ self._cli(' ', False)
+ elif index == 1: # Back to a prompt, says output is finished
+ break
+ except (pexpect.EOF, pexpect.TIMEOUT):
+ # Something went wrong; logout, log in and try again!
+ logging.error("PEXPECT FAILURE, RECONNECT")
+ self.errors.log_error_in(text)
+ raise PExpectError("_read_long_output failed")
+ except:
+ logging.error("prompt is \"%s\"", prompt)
+ raise
+
+ for line in self.connection.before.split('\r\n'):
+ longbuf.append(line.strip())
+ return longbuf
+
+ def _get_port_names(self):
+ logging.debug("Grabbing list of ports")
+ interfaces = []
+
+ # Look for "Eth1" at the beginning of the output lines to just
+ # match lines with interfaces - they have names like
+ # "Eth1/15". We do not care about Link Aggregation Groups (lag)
+ # here.
+ regex = re.compile(r'^Eth(\S+)')
+
+ try:
+ self._cli("show interfaces switchport")
+ for line in self._read_long_output("show interfaces switchport"):
+ match = regex.match(line)
+ if match:
+ interface = match.group(1)
+ interfaces.append(interface)
+ self._port_numbers[interface] = len(interfaces)
+ logging.debug(" found %d ports on the switch", len(interfaces))
+ return interfaces
+
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ return self._get_port_names()
+
+ # Get the mode of a port: access or trunk
+ def _port_get_mode(self, port):
+ logging.debug("Getting mode of port %s", port)
+ mode = ''
+ if not self._is_port_name_valid(port):
+ raise InputError("Port name %s not recognised" % port)
+ regex = re.compile('Switchport mode: (.*)')
+
+ try:
+ self._cli("show interfaces ethernet %s" % port)
+ for line in self._read_long_output("show interfaces ethernet"):
+ match = regex.match(line)
+ if match:
+ mode = match.group(1)
+ if mode == 'access':
+ return 'access'
+ if mode == 'trunk':
+ return 'trunk'
+ return mode
+
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ return self.port_get_mode(port)
+
+ def _show_config(self):
+ logging.debug("Grabbing config")
+ try:
+ self._cli("show running-config")
+ return self._read_long_output("show running-config")
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ return self._show_config()
+
+ def _show_clock(self):
+ logging.debug("Grabbing time")
+ try:
+ self._cli("show clock")
+ return self._read_long_output("show clock")
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ return self._show_clock()
+
+ def _get_systemdata(self):
+ logging.debug("Grabbing system sw and hw versions")
+
+ try:
+ self._systemdata = []
+ self._cli("show version")
+ for line in self._read_long_output("show version"):
+ self._systemdata.append(line)
+
+ except PExpectError:
+ # recurse on error
+ self._switch_connect()
+ return self._get_systemdata()
+
+ # Borrowed from the Catalyst driver. Over-complex for our needs here, but
+ # it's already tested and will do the job.
+ def _parse_vlan_list(self, inputdata):
+ vlans = []
+
+ if inputdata == "ALL":
+ return ["ALL"]
+ elif inputdata == "NONE":
+ return []
+ elif inputdata == "":
+ return []
+ else:
+ # Parse the complex list
+ groups = inputdata.split(',')
+ for group in groups:
+ subgroups = group.split('-')
+ if len(subgroups) == 1:
+ vlans.append(int(subgroups[0]))
+ elif len(subgroups) == 2:
+ for i in range (int(subgroups[0]), int(subgroups[1]) + 1):
+ vlans.append(i)
+ else:
+ logging.debug("Can't parse group \"" + group + "\"")
+
+ return vlans
+
+ # Wrapper around connection.send - by default, expect() the same
+ # text we've sent, to remove it from the output from the
+ # switch. For the few cases where we don't need that, override
+ # this using echo=False.
+ # Horrible, but seems to work.
+ def _cli(self, text, echo=True):
+ self.connection.send(text + '\r')
+ if echo:
+ try:
+ self.connection.expect(text)
+ except (pexpect.EOF, pexpect.TIMEOUT):
+ # Something went wrong; logout, log in and try again!
+ logging.error("PEXPECT FAILURE, RECONNECT")
+ self.errors.log_error_out(text)
+ raise PExpectError("_cli failed on %s" % text)
+ except:
+ logging.error("Unexpected error: %s", sys.exc_info()[0])
+ raise
+
+if __name__ == "__main__":
+
+ # Simple test harness - exercise the main working functions above to verify
+ # they work. This does *NOT* test really disruptive things like "save
+ # running-config" and "reload" - test those by hand.
+
+ import optparse
+
+ switch = '172.27.16.6'
+ parser = optparse.OptionParser()
+ parser.add_option("--switch",
+ dest = "switch",
+ action = "store",
+ nargs = 1,
+ type = "string",
+ help = "specify switch to connect to for testing",
+ metavar = "<switch>")
+ (opts, args) = parser.parse_args()
+ if opts.switch:
+ switch = opts.switch
+
+ logging.basicConfig(level = logging.DEBUG,
+ format = '%(asctime)s %(levelname)-8s %(message)s')
+ p = MlnxOS(switch, 23, debug=False)
+ p.switch_connect('admin', 'admin', None)
+
+ print "VLANs are:"
+ buf = p.vlan_get_list()
+ p.dump_list(buf)
+
+ buf = p.vlan_get_name(102)
+ print "VLAN 102 is named \"%s\"" % buf
+
+ print "Create VLAN 1003"
+ p.vlan_create(1003)
+
+ buf = p.vlan_get_name(1003)
+ print "VLAN 1003 is named \"%s\"" % buf
+
+ print "Set name of VLAN 1003 to test333"
+ p.vlan_set_name(1003, "test333")
+
+ buf = p.vlan_get_name(1003)
+ print "VLAN 1003 is named \"%s\"" % buf
+
+ print "VLANs are:"
+ buf = p.vlan_get_list()
+ p.dump_list(buf)
+
+ print "Destroy VLAN 1003"
+ p.vlan_destroy(1003)
+
+ print "VLANs are:"
+ buf = p.vlan_get_list()
+ p.dump_list(buf)
+
+ buf = p.port_get_mode("1/15")
+ print "Port 1/15 is in %s mode" % buf
+
+ buf = p.port_get_mode("1/16")
+ print "Port 1/16 is in %s mode" % buf
+
+ # Test access stuff
+ print "Set 1/15 to access mode"
+ p.port_set_mode("1/15", "access")
+
+ print "Move 1/15 to VLAN 4"
+ p.port_set_access_vlan("1/15", 4)
+
+ buf = p.port_get_access_vlan("1/15")
+ print "Read from switch: 1/15 is on VLAN %s" % buf
+
+ print "Move 1/15 back to VLAN 1"
+ p.port_set_access_vlan("1/15", 1)
+
+ print "Create VLAN 1002"
+ p.vlan_create(1002)
+
+ print "Create VLAN 1003"
+ p.vlan_create(1003)
+
+ print "Create VLAN 1004"
+ p.vlan_create(1004)
+
+ # Test access stuff
+ print "Set 1/15 to trunk mode"
+ p.port_set_mode("1/15", "trunk")
+ print "Read from switch: which VLANs is 1/15 on?"
+ buf = p.port_get_trunk_vlan_list("1/15")
+ p.dump_list(buf)
+
+ # The adds below are NOOPs in effect on this switch - no filtering
+ # for "trunk" ports
+ print "Add 1/15 to VLAN 1002"
+ p.port_add_trunk_to_vlan("1/15", 1002)
+ print "Add 1/15 to VLAN 1003"
+ p.port_add_trunk_to_vlan("1/15", 1003)
+ print "Add 1/15 to VLAN 1004"
+ p.port_add_trunk_to_vlan("1/15", 1004)
+ print "Read from switch: which VLANs is 1/15 on?"
+ buf = p.port_get_trunk_vlan_list("1/15")
+ p.dump_list(buf)
+
+ # And the same for removals here
+ p.port_remove_trunk_from_vlan("1/15", 1003)
+ p.port_remove_trunk_from_vlan("1/15", 1002)
+ p.port_remove_trunk_from_vlan("1/15", 1004)
+ print "Read from switch: which VLANs is 1/15 on?"
+ buf = p.port_get_trunk_vlan_list("1/15")
+ p.dump_list(buf)
+
+# print 'Restarting switch, to explicitly reset config'
+# p.switch_restart()
+
+# p.switch_save_running_config()
+
+# p.switch_disconnect()
+# p._show_config()