| #!/usr/bin/env python |
| """ |
| Copyright 2018 Open Networking Foundation (ONF) |
| |
| Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>, |
| the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>, |
| or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg> |
| |
| TestON 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. |
| |
| TestON 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 TestON. If not, see <http://www.gnu.org/licenses/>. |
| """ |
| |
| import pexpect |
| import re |
| import json |
| import types |
| import time |
| import os |
| from drivers.common.clidriver import CLI |
| from core import utilities |
| from shutil import copyfile |
| |
| class OFDPASwitchDriver( CLI ): |
| |
| def __init__( self ): |
| """ |
| Initialize client |
| """ |
| super( CLI, self ).__init__() |
| self.name = None |
| self.handle = None |
| self.prompt = "~#" |
| # Respect to bin folder |
| self.home = "../drivers/common/cli/ofdpa/" |
| # Local home for functions using scp |
| self.tempDirectory = "/tmp/" |
| self.conf = "ofagent.conf" |
| self.switchDirectory = "/etc/ofagent/" |
| |
| def connect( self, **connectargs ): |
| """ |
| Creates ssh handle for Accton cli. |
| """ |
| try: |
| # Parse keys in xml object |
| for key in connectargs: |
| vars( self )[ key ] = connectargs[ key ] |
| # Get the name |
| self.name = self.options['name'] |
| # Get the dpid |
| self.dpid = self.options[ 'dpid' ] |
| # Parse the IP address |
| try: |
| if os.getenv( str( self.ip_address ) ) is not None: |
| self.ip_address = os.getenv( str( self.ip_address ) ) |
| # Otherwise is an ip address |
| else: |
| main.log.info( self.name + ": Trying to connect to " + self.ip_address ) |
| # Error handling |
| except KeyError: |
| main.log.info( "Invalid host name," + " connecting to local host instead" ) |
| self.ip_address = 'localhost' |
| except Exception as inst: |
| main.log.error( "Uncaught exception: " + str( inst ) ) |
| # Build the handle using the above information |
| self.handle = super(OFDPASwitchDriver, self ).connect( |
| user_name=self.user_name, |
| ip_address=self.ip_address, |
| port=None, |
| pwd=self.pwd) |
| # Successful connection |
| if self.handle: |
| main.log.info( "Connection successful to the host " + self.user_name + "@" + self.ip_address ) |
| self.handle.sendline( "" ) |
| self.handle.expect( self.prompt ) |
| return main.TRUE |
| # Connection failed |
| else: |
| main.log.error( "Connection failed to the host " + self.user_name + "@" + self.ip_address ) |
| main.log.error( "Failed to connect to the OFDPA CLI" ) |
| return main.FALSE |
| # Error handling |
| except TypeError: |
| main.log.exception( self.name + ": Object not as expected" ) |
| return None |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except Exception: |
| main.log.exception( self.name + ": Uncaught exception!" ) |
| main.cleanup() |
| main.exit() |
| |
| def disconnect( self ): |
| """ |
| Called when Test is complete to disconnect the OFDPASwitchDriver handle. |
| """ |
| response = main.TRUE |
| try: |
| if self.handle: |
| # Stop the ofagent |
| self.stopOfAgent() |
| # Disconnect from the device |
| self.handle.sendline( "" ) |
| self.handle.expect( self.prompt ) |
| self.handle.sendline( "exit" ) |
| self.handle.expect( "closed" ) |
| # Errors handling |
| except pexpect.TIMEOUT: |
| main.log.error( self.name + ": pexpect.TIMEOUT found" ) |
| return main.FALSE |
| except TypeError: |
| main.log.exception( self.name + ": Object not as expected" ) |
| response = main.FALSE |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| except ValueError: |
| main.log.exception( "Exception in disconnect of " + self.name ) |
| response = main.TRUE |
| except Exception: |
| main.log.exception( self.name + ": Connection failed to the host" ) |
| response = main.FALSE |
| return response |
| |
| def assignSwController( self, ip, port="6653", ptcp=""): |
| """ |
| Description: |
| The assignment is realized properly creating the agent.conf |
| for each switch and then pushing it into the device. |
| Required: |
| ip - Ip addresses of controllers. This can be a list or a string. |
| Optional: |
| port - controller port is ignored |
| ptcp - ptcp information is ignored |
| Return: |
| Returns main.TRUE if the switch is correctly assigned to controllers, |
| otherwise it will return main.FALSE or an appropriate exception(s) |
| """ |
| assignResult = main.TRUE |
| # Initial arguments for OFDPA |
| opt_args = 'OPT_ARGS="-d 2 -c 2 -c 4 ' |
| onosIp = "" |
| # Parses the controller option |
| try: |
| if isinstance( ip, types.StringType ): |
| onosIp = "-t " + str( ip ) |
| elif isinstance( ip, types.ListType ): |
| for ipAddress in ip: |
| onosIp += "-t " + str( ipAddress ) + " " |
| else: |
| main.log.error( self.name + ": Invalid ip address" ) |
| return main.FALSE |
| # Complete the arguments adding the dpid |
| opt_args += onosIp + '-i %s' % self.dpid + '"' |
| # Create a copy of the cfg file using the template |
| self.createCfg() |
| # Load the cfg file and adds the missing option |
| self.updateCfg( opt_args ) |
| # Backup the cfg on the switch |
| self.backupCfg() |
| # Push the new cfg on the device |
| self.pushCfg() |
| # Start the ofagent on the device |
| self.startOfAgent() |
| # Enable all the ports |
| assignResult = utilities.retry( |
| self.enablePorts, |
| main.FALSE, |
| kwargs={}, |
| attempts=5, |
| sleep=10) |
| # Done return true |
| return assignResult |
| # Errors handling |
| except pexpect.TIMEOUT: |
| main.log.error( self.name + ": pexpect.TIMEOUT found" ) |
| return main.FALSE |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanAndExit() |
| except Exception: |
| main.log.exception( self.name + ": Uncaught exception!" ) |
| main.cleanAndExit() |
| |
| def createCfg( self ): |
| """ |
| Create in bench context a new config file starting from the template |
| """ |
| copyfile(self.home + self.conf + ".template", self.tempDirectory + self.conf) |
| |
| def updateCfg( self, opt_args): |
| """ |
| Add the arguments related to the current switch (self) |
| """ |
| with open(self.tempDirectory + self.conf, "a") as cfg: |
| cfg.write(opt_args + "\n") |
| cfg.close() |
| |
| def backupCfg( self ): |
| """ |
| Create a backup file of the old configuration on the switch |
| """ |
| self.handle.sendline( "" ) |
| self.handle.expect( self.prompt ) |
| self.handle.sendline( "cp %s%s %s%s.backup" % (self.switchDirectory, self.conf, self.switchDirectory, self.conf) ) |
| self.handle.expect( self.prompt ) |
| |
| def pushCfg( self ): |
| """ |
| Push the new configuration from the network bench |
| """ |
| # We use os.system to send the command from TestON cluster |
| # to the switches. This means that passwordless access is |
| # necessary in order to push the configuration file |
| os.system( "scp " + self.tempDirectory + self.conf + " " + |
| self.user_name + "@" + self.ip_address + ":" + self.switchDirectory) |
| |
| def startOfAgent( self ): |
| """ |
| Start the ofagent on the device |
| """ |
| self.handle.sendline( "" ) |
| self.handle.expect( self.prompt ) |
| self.handle.sendline( "service ofagentd start" ) |
| self.handle.expect( self.prompt ) |
| |
| def stopOfAgent( self ): |
| """ |
| Stop the ofagent on the device |
| """ |
| self.handle.sendline( "" ) |
| self.handle.expect( self.prompt ) |
| self.handle.sendline( "service ofagentd stop" ) |
| self.handle.expect( self.prompt ) |
| |
| def dumpFlows( self ): |
| """ |
| Dump the flows from the devices |
| FIXME need changes in the workflow in order to be used |
| """ |
| try: |
| self.handle.sendline( "" ) |
| self.handle.expect( self.prompt ) |
| # Create the dump of the flows locally on the switches |
| self.handle.sendline( "client_flowtable_dump" ) |
| self.handle.expect( self.prompt ) |
| response = self.handle.before |
| # Write back in the tmp folder - needs to be changed in future |
| with open(self.tempDirectory + "flows_%s.txt" % self.dpid, "w") as flows: |
| flows.write(response + "\n") |
| flows.close() |
| # Done return for further processing |
| return response |
| # Errors handling |
| except pexpect.TIMEOUT: |
| main.log.error( self.name + ": pexpect.TIMEOUT found" ) |
| return main.FALSE |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanAndExit() |
| except Exception: |
| main.log.exception( self.name + ": Uncaught exception!" ) |
| main.cleanAndExit() |
| |
| def dumpGroups( self ): |
| """ |
| Dump the groups from the devices |
| FIXME need changes in the workflow in order to be used |
| """ |
| try: |
| self.handle.sendline( "" ) |
| self.handle.expect( self.prompt ) |
| self.handle.sendline( "client_grouptable_dump > groups.txt" ) |
| self.handle.expect( self.prompt ) |
| response = self.handle.before |
| # Write back in the tmp folder - needs to be changed in future |
| with open(self.tempDirectory + "groups_%s.txt" % self.dpid, "w") as groups: |
| groups.write(response + "\n") |
| groups.close() |
| # Done return for further processing |
| return response |
| # Errors handling |
| except pexpect.TIMEOUT: |
| main.log.error( self.name + ": pexpect.TIMEOUT found" ) |
| return main.FALSE |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanAndExit() |
| except Exception: |
| main.log.exception( self.name + ": Uncaught exception!" ) |
| main.cleanAndExit() |
| |
| def enablePorts( self ): |
| """ |
| Enable all the ports on the devices |
| It needs to wait for the boot |
| """ |
| self.handle.sendline( "" ) |
| self.handle.expect( self.prompt ) |
| self.handle.sendline( "client_port_table_dump" ) |
| self.handle.expect( self.prompt ) |
| response = self.handle.before |
| if "Error from ofdpaClientInitialize()" in response: |
| main.log.warn( |
| self.name + |
| ": Not yet started" ) |
| return main.FALSE |
| main.log.info( self.name + ": started" ) |
| self.handle.sendline( "sh portspeed.sh" ) |
| self.handle.expect( self.prompt ) |
| return main.TRUE |