TestON/drivers/common/cli/ofdpa/ofdpaswitchdriver.py

#!/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