#!/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.shortName = 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/"
        self.ports = []
        self.isup = False

    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' ]
            self.shortName = self.options[ 'shortName' ]
            # Get the dpid
            self.dpid = self.options[ 'dpid' ]
            # Get ofagent patch
            for key, value in self.options.items():
                if re.match( 'link[\d]+', key ):
                    self.ports.append( { 'enabled': True,
                                         'ips': [ None ],
                                         'mac': None,
                                         'name': None,
                                         'node2': value[ 'node2' ],
                                         'port2': value[ 'port2' ],
                                         'of_port': value[ 'port1' ] } )
            if 'confDir' in self.options:
                self.switchDirectory = self.options[ 'confDir' ]
            # 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="", updateConf=False ):
        """
        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
            updateConf - create new ofagent conf file and push to the switch if
                         set to True; otherwise will use the existing conf file
                         on the switch.
        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 + '"'
            if updateConf:
                # 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=10,
                sleep=10)
            if not assignResult:
                self.isup = False
            else:
                self.isup = True
            # 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
        """
        try:
            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 )
        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 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 ofagentIsRunning( self ):
        """
        Return main.TRUE if service ofagentd is running on the
        switch; otherwise main.FALSE
        """
        try:
            self.handle.sendline( "" )
            self.handle.expect( self.prompt )
            self.handle.sendline( "service ofagentd status" )
            self.handle.expect( self.prompt )
            response = self.handle.before
            if "ofagentd is running" in response:
                return main.TRUE
            else:
                return main.FALSE
        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 startOfAgent( self ):
        """
        Start the ofagent on the device
        """
        try:
            if self.ofagentIsRunning():
                main.log.warn( self.name + ": ofagentd is already running" )
                return main.TRUE
            self.handle.sendline( "" )
            self.handle.expect( self.prompt )
            self.handle.sendline( "service ofagentd start" )
            self.handle.expect( self.prompt )
        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 stopOfAgent( self ):
        """
        Stop the ofagent on the device
        """
        try:
            self.handle.sendline( "" )
            self.handle.expect( self.prompt )
            self.handle.sendline( "service ofagentd stop" )
            self.handle.expect( self.prompt )
            self.isup = False
        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 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
        """
        try:
            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
            # Change port speed
            self.handle.sendline( "sh portspeed" )
            self.handle.expect( self.prompt )
            response = self.handle.before
            if "Failure calling" in response:
                main.log.warn( self.name + ": failed to change port speed" )
                return main.FALSE
            return main.TRUE
        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 setPortSpeed( self, index, speed=40000 ):
        """
        Run client_drivshell on the switch to set speed for a
        specific port
        index: port index, e.g. 1
        speed: port speed, e.g. 40000
        """
        try:
            self.handle.sendline( "" )
            self.handle.expect( self.prompt )
            cmd = "client_drivshell port {} sp={}".format( index, speed )
            self.handle.sendline( cmd )
            self.handle.expect( self.prompt )
            response = self.handle.before
            return main.TRUE
        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 updatePorts( self ):
        """
        Get latest port status on the switch by running
        client_port_table_dump commmand and parsing the output
        """
        try:
            self.handle.sendline( "" )
            self.handle.expect( self.prompt )
            self.handle.sendline( "client_port_table_dump" )
            self.handle.expect( self.prompt )
            ports = self.handle.before
            if "Error from ofdpaClientInitialize()" in ports:
                main.log.warn( self.name + ": Not yet started" )
                return main.FALSE
            ports = re.findall( r"0x[\d]+.*port[\d]+:\r\r\n.*\r\r\n.*PeerFeature:.*\r\r\n", ports )
            for port in ports:
                m = re.match( r".*port([\d]+):\r\r\n.*state = (.*), mac", port )
                index = m.group( 1 )
                enabled = True if m.group( 2 ) == '0x00000000' else False
                for p in self.ports:
                    if p[ 'of_port' ] == index:
                        p[ 'enabled' ] = enabled
        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()