#!/usr/bin/env python
'''
Created on 26-Oct-2012

@author: Anil Kumar (anilkumar.s@paxterrasolutions.com)


    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/>.		


MininetCliDriver is the basic driver which will handle the Mininet functions
'''
import traceback
import pexpect
import struct
import fcntl
import os
import signal
import re
import sys
import core.teston
sys.path.append("../")
from drivers.common.cli.emulatordriver import Emulator
from drivers.common.clidriver import CLI
from time import time

class RemoteMininetDriver(Emulator):
    '''
    RemoteMininetCliDriver is the basic driver which will handle the Mininet functions
    The main different between this and the MininetCliDriver is that this one does not build the mininet. 
    It assumes that there is already a mininet running on the target. 
    '''
    def __init__(self):
        super(Emulator, self).__init__()
        self.handle = self
        self.wrapped = sys.modules[__name__]
        self.flag = 0

    def connect(self, **connectargs):
        #,user_name, ip_address, pwd,options):
        # Here the main is the TestON instance after creating all the log handles.
        for key in connectargs:
            vars(self)[key] = connectargs[key]       
        
        self.name = self.options['name']
        self.handle = super(RemoteMininetDriver, self).connect(user_name = self.user_name, ip_address = self.ip_address,port = None, pwd = self.pwd)
        
        self.ssh_handle = self.handle
        
        # Copying the readme file to process the 
        if self.handle :
            return main.TRUE

        else :
            main.log.error("Connection failed to the host "+self.user_name+"@"+self.ip_address) 
            main.log.error("Failed to connect to the Mininet")
            return main.FALSE

#*********************************************************************************************
#*********************************************************************************************
# checkForLoss will determine if any of the pings had any packets lost during the course of 
# the pingLong.
#*********************************************************************************************
#*********************************************************************************************

    def checkForLoss(self, pingList):
        '''
        Returns main.FALSE for 0% packet loss and
        Returns main.ERROR if "found multiple mininet" is found and
        Returns main.TRUE else
        '''
        import os
        self.handle.sendline("")
        self.handle.expect("\$")
        self.handle.sendline("cat " + pingList)
        self.handle.expect(pingList)
        self.handle.expect("\$")
        outputs = self.handle.before + self.handle.after
        if re.search(" 0% packet loss",outputs):
            return main.FALSE
        elif re.search("found multiple mininet",outputs):
            return main.ERROR
        else:
            print outputs
            return main.TRUE


    def pingLong(self,**pingParams):
        '''
        Starts a continuous ping on the mininet host outputing to a file in the /tmp dir. 
        '''
        self.handle.sendline("")
        self.handle.expect("\$")
        args = utilities.parse_args(["SRC","TARGET","PINGTIME"],**pingParams)
        precmd = "sudo rm /tmp/ping." + args["SRC"]
        self.execute(cmd=precmd,prompt="(.*)",timeout=10)
        command = "sudo mininet/util/m " + args["SRC"] + " ping "+args ["TARGET"]+" -i .2 -w " + str(args['PINGTIME']) + " > /tmp/ping." + args["SRC"] + " &"
        main.log.info( command ) 
        self.execute(cmd=command,prompt="(.*)",timeout=10)
        self.handle.sendline("")
        self.handle.expect("\$")
        return main.TRUE

    def pingstatus(self,**pingParams):
        '''
        Tails the respective ping output file and check that there is a moving "64 bytes"
        '''
        self.handle.sendline("")
        self.handle.expect("\$")
        args = utilities.parse_args(["SRC"],**pingParams)
        self.handle.sendline("tail /tmp/ping." + args["SRC"])
        self.handle.expect("tail")
        self.handle.expect("\$")
        result = self.handle.before + self.handle.after
        self.handle.sendline("")
        self.handle.expect("\$")
        if re.search('Unreachable', result ):
            main.log.info("Unreachable found in ping logs...") 
            return main.FALSE
        elif re.search('64\sbytes', result): 
            main.log.info("Pings look good") 
            return main.TRUE
        else: 
            main.log.info("No, or faulty ping data...") 
            return main.FALSE
         
    def pingKill(self, testONUser, testONIP):
        '''
        Kills all continuous ping processes.
        Then copies all the ping files to the TestStation.
        '''
        import time
        self.handle.sendline("")
        self.handle.expect("\$")
        command = "sudo kill -SIGINT `pgrep ping`" 
        main.log.info( command ) 
        self.execute(cmd=command,prompt="(.*)",timeout=10)
        #Commenting out in case TestON and MN are on the same machine. scp overrights the file anyways
        #main.log.info( "Removing old ping data" )
        #command = "rm /tmp/ping.*"
        #os.popen(command) 
        #time.sleep(2)      
        main.log.info( "Transferring ping files to TestStation" )
        command = "scp /tmp/ping.* "+ str(testONUser) + "@" + str(testONIP) + ":/tmp/" 
        self.execute(cmd=command,prompt="100%",timeout=20)
        self.handle.sendline("")
        self.handle.expect("\$")
        return main.TRUE
    
    def pingLongKill(self):
        import time
        self.handle.sendline("")
        self.handle.expect("\$")
        command = "sudo kill -SIGING `pgrep ping`"
        main.log.info(command)
        self.execute(cmd=command,prompt="(.*)",timeout=10)
        self.handle.sendline("")
        self.handle.expect("\$")
        return main.TRUE
       
    def pingHostOptical(self,**pingParams):
        '''
        This function is only for Packey Optical related ping
        Use the next pingHost() function for all normal scenarios)
        Ping from one mininet host to another
        Currently the only supported Params: SRC and TARGET
        '''
        args = utilities.parse_args(["SRC","TARGET"],**pingParams)
        #command = args["SRC"] + " ping -" + args["CONTROLLER"] + " " +args ["TARGET"]
        command = args["SRC"] + " ping "+args ["TARGET"]+" -c 1 -i 1 -W 8"
        try:
            main.log.warn("Sending: " + command)
            #response = self.execute(cmd=command,prompt="mininet",timeout=10 )
            self.handle.sendline(command)
            i = self.handle.expect([command,pexpect.TIMEOUT])
            if i == 1:
                main.log.error(self.name + ": timeout when waiting for response from mininet")
                main.log.error("response: " + str(self.handle.before))
            i = self.handle.expect(["mininet>",pexpect.TIMEOUT])
            if i == 1:
                main.log.error(self.name + ": timeout when waiting for response from mininet")
                main.log.error("response: " + str(self.handle.before))
            response = self.handle.before
        except pexpect.EOF:
            main.log.error(self.name + ": EOF exception found")
            main.log.error(self.name + ":     " + self.handle.before)
            main.cleanup()
            main.exit()
        main.log.info(self.name+": Ping Response: "+ response )
        #if utilities.assert_matches(expect=',\s0\%\spacket\sloss',actual=response,onpass="No Packet loss",onfail="Host is not reachable"):
        if re.search(',\s0\%\spacket\sloss',response):
            main.log.info(self.name+": no packets lost, host is reachable")
            main.last_result = main.TRUE
            return main.TRUE
        else :
            main.log.error(self.name+": PACKET LOST, HOST IS NOT REACHABLE")
            main.last_result = main.FALSE
            return main.FALSE


    def pingall(self):
        '''
        Verifies the reachability of the hosts using pingall command.
        This function is required by Packey Optical test
        '''
        if self.handle :
            main.log.info(self.name+": Checking reachabilty to the hosts using pingall")
            try:
                response = self.execute(cmd="pingall",prompt="mininet>",timeout=120)
                print "response: " + str(response)
            except pexpect.EOF:
                main.log.error(self.name + ": EOF exception found")
                main.log.error(self.name + ":     " + self.handle.before)
            pattern = 'Results\:\s0\%\sdropped\s'
            if re.search(pattern,response):
                main.log.info(self.name+": All hosts are reachable")
                return main.TRUE
            else:
                main.log.error(self.name+": Unable to reach all the hosts")
                return main.FALSE
        else :
            main.log.error(self.name+": Connection failed to the host")
            return main.FALSE


    def pingHost(self,**pingParams):
        ''' 
        Pings between two hosts on remote mininet  
        ''' 
        self.handle.sendline("")
        self.handle.expect("\$")
        args = utilities.parse_args(["SRC","TARGET"],**pingParams)
        #command = "mininet/util/m " + args["SRC"] + " ping "+args ["TARGET"]+" -c 4 -W 1 -i .2"
        command = "mininet/util/m " + args["SRC"] + " ping "+args ["TARGET"]+" -c 4 -W 1 -i .2"
        main.log.info ( command ) 
        response = self.execute(cmd=command,prompt="rtt",timeout=10 )
        #self.handle.sendline("")
        #self.handle.expect("\$")
        if utilities.assert_matches(expect=',\s0\%\spacket\sloss',actual=response,onpass="No Packet loss",onfail="Host is not reachable"):
            main.log.info("NO PACKET LOSS, HOST IS REACHABLE")
            main.last_result = main.TRUE 
            return main.TRUE
        else :
            main.log.error("PACKET LOST, HOST IS NOT REACHABLE")
            main.last_result = main.FALSE
            return main.FALSE
        
    
    def checknum(self,num):
        '''
        Verifies the correct number of switches are running 
        '''
        if self.handle :
            self.handle.sendline("")
            self.handle.expect("\$")
            self.handle.sendline('ifconfig -a | grep "sw.. " | wc -l')
            self.handle.expect("wc")
            self.handle.expect("\$")
            response = self.handle.before
            self.handle.sendline('ps -ef | grep "bash -ms mininet:sw" | grep -v color | wc -l') 
            self.handle.expect("color")
            self.handle.expect("\$")
            response2 = self.handle.before

            if re.search(num, response):
                if re.search(num, response2):
                    return main.TRUE
                else:
                    return main.FALSE
            else:
                return main.FALSE
        else :
            main.log.error("Connection failed to the host") 

    def ctrl_none(self):
        '''
        Sets all the switches to no controllers. 
        '''
        self.execute(cmd="~/ONOS/scripts/test-ctrl-none.sh", prompt="\$",timeout=10)

    def ctrl_one(self, ip):
        '''
        Sets all the switches to point to the supplied IP
        '''
        self.execute(cmd="~/ONOS/scripts/test-ctrl-one.sh "+ip, prompt="\$",timeout=10)
 
    def ctrl_local(self):
        '''
        Sets all the switches to point to the Controller on the same machine that they are running on. 
        '''
        self.execute(cmd="~/ONOS/scripts/test-ctrl-local.sh ", prompt="\$",timeout=10)

 #   def verifySSH(self,**connectargs):
 #       response = self.execute(cmd="h1 /usr/sbin/sshd -D&",prompt="mininet>",timeout=10)
 #       response = self.execute(cmd="h4 /usr/sbin/sshd -D&",prompt="mininet>",timeout=10)
 #       for key in connectargs:
 #           vars(self)[key] = connectargs[key]
 #       response = self.execute(cmd="xterm h1 h4 ",prompt="mininet>",timeout=10)
 #       import time
 #       time.sleep(20)
 #       if self.flag == 0:
 #           self.flag = 1
 #           return main.FALSE
 #       else :
 #           return main.TRUE
 #   
 #   def getMacAddress(self,host):
 #       '''
 #           Verifies the host's ip configured or not.
 #       '''
 #       if self.handle :
 #           response = self.execute(cmd=host+" ifconfig",prompt="mininet>",timeout=10)

 #           pattern = "HWaddr\s(((\d|\w)+:)+(\d|\w))"
 #           mac_address_search = re.search(pattern, response)
 #           main.log.info("Mac-Address of Host "+host +" is "+mac_address_search.group(1))
 #           return mac_address_search.group(1)
 #       else :
 #           main.log.error("Connection failed to the host") 
 #   def getIPAddress(self,host):
 #       '''
 #           Verifies the host's ip configured or not.
 #       '''
 #       if self.handle :
 #           response = self.execute(cmd=host+" ifconfig",prompt="mininet>",timeout=10)

 #           pattern = "inet\saddr:(\d+\.\d+\.\d+\.\d+)"
 #           ip_address_search = re.search(pattern, response)
 #           main.log.info("IP-Address of Host "+host +" is "+ip_address_search.group(1))
 #           return ip_address_search.group(1)
 #       else :
 #           main.log.error("Connection failed to the host") 
 #       
 #   def dump(self):
 #       main.log.info("Dump node info")
 #       self.execute(cmd = 'dump',prompt = 'mininet>',timeout = 10)
 #       return main.TRUE
 #           
 #   def intfs(self):
 #       main.log.info("List interfaces")
 #       self.execute(cmd = 'intfs',prompt = 'mininet>',timeout = 10)
 #       return main.TRUE
 #   
 #   def net(self):
 #       main.log.info("List network connections")
 #       self.execute(cmd = 'net',prompt = 'mininet>',timeout = 10)
 #       return main.TRUE
 #   
 #   def iperf(self):
 #       main.log.info("Simple iperf TCP test between two (optionally specified) hosts")
 #       self.execute(cmd = 'iperf',prompt = 'mininet>',timeout = 10)
 #       return main.TRUE
 #   
 #   def iperfudp(self):
 #       main.log.info("Simple iperf TCP test between two (optionally specified) hosts")
 #       self.execute(cmd = 'iperfudp',prompt = 'mininet>',timeout = 10)
 #       return main.TRUE
 #   
 #   def nodes(self):
 #       main.log.info("List all nodes.")
 #       self.execute(cmd = 'nodes',prompt = 'mininet>',timeout = 10)    
 #       return main.TRUE
 #   
 #   def pingpair(self):
 #       main.log.infoe("Ping between first two hosts")
 #       self.execute(cmd = 'pingpair',prompt = 'mininet>',timeout = 20)
 #       
 #       if utilities.assert_matches(expect='0% packet loss',actual=response,onpass="No Packet loss",onfail="Hosts not reachable"):
 #           main.log.info("Ping between two hosts SUCCESS")
 #           main.last_result = main.TRUE 
 #           return main.TRUE
 #       else :
 #           main.log.error("PACKET LOST, HOSTS NOT REACHABLE")
 #           main.last_result = main.FALSE
 #           return main.FALSE
 #   
 #   def link(self,**linkargs):
 #       '''
 #       Bring link(s) between two nodes up or down
 #       '''
 #       main.log.info('Bring link(s) between two nodes up or down')
 #       args = utilities.parse_args(["END1","END2","OPTION"],**linkargs)
 #       end1 = args["END1"] if args["END1"] != None else ""
 #       end2 = args["END2"] if args["END2"] != None else ""
 #       option = args["OPTION"] if args["OPTION"] != None else ""
 #       command = "link "+str(end1) + " " + str(end2)+ " " + str(option)
 #       response = self.execute(cmd=command,prompt="mininet>",timeout=10)
 #       return main.TRUE
 #       

 #   def dpctl(self,**dpctlargs):
 #       '''
 #        Run dpctl command on all switches.
 #       '''
 #       main.log.info('Run dpctl command on all switches')
 #       args = utilities.parse_args(["CMD","ARGS"],**dpctlargs)
 #       cmd = args["CMD"] if args["CMD"] != None else ""
 #       cmdargs = args["ARGS"] if args["ARGS"] != None else ""
 #       command = "dpctl "+cmd + " " + str(cmdargs)
 #       response = self.execute(cmd=command,prompt="mininet>",timeout=10)
 #       return main.TRUE
 #  
 #       
 #   def get_version(self):
 #       file_input = path+'/lib/Mininet/INSTALL'
 #       version = super(Mininet, self).get_version()
 #       pattern = 'Mininet\s\w\.\w\.\w\w*'
 #       for line in open(file_input,'r').readlines():
 #           result = re.match(pattern, line)
 #           if result:
 #               version = result.group(0)
 #               
 #           
 #       return version    
    def start_tcpdump(self, filename, intf = "eth0", port = "port 6633"):
        ''' 
        Runs tpdump on an intferface and saves the file
        intf can be specified, or the default eth0 is used
        '''
        try:
            self.handle.sendline("")
            self.handle.sendline("sudo tcpdump -n -i "+ intf + " " + port + " -w " + filename.strip() + "  &")
            self.handle.sendline("")
            self.handle.sendline("")
            i=self.handle.expect(['No\ssuch\device','listening\son',pexpect.TIMEOUT,"\$"],timeout=10)
            main.log.warn(self.handle.before + self.handle.after)
            if i == 0:
                main.log.error(self.name + ": tcpdump - No such device exists. tcpdump attempted on: " + intf)
                return main.FALSE
            elif i == 1:
                main.log.info(self.name + ": tcpdump started on " + intf)
                return main.TRUE
            elif i == 2:
                main.log.error(self.name + ": tcpdump command timed out! Check interface name, given interface was: " + intf)
                return main.FALSE
            elif i ==3: 
                main.log.info(self.name +": " +  self.handle.before)
                return main.TRUE
            else:
                main.log.error(self.name + ": tcpdump - unexpected response")
            return main.FALSE
        except pexpect.EOF:
            main.log.error(self.name + ": EOF exception found")
            main.log.error(self.name + ":     " + self.handle.before)
            main.cleanup()
            main.exit()
        except:
            main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
            main.log.error( traceback.print_exc() )
            main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
            main.cleanup()
            main.exit()

    def stop_tcpdump(self):
        "pkills tcpdump"
        try:
            self.handle.sendline("sudo pkill tcpdump")
            self.handle.sendline("")
            self.handle.sendline("")
            self.handle.expect("\$")
        except pexpect.EOF:
            main.log.error(self.name + ": EOF exception found")
            main.log.error(self.name + ":     " + self.handle.before)
            main.cleanup()
            main.exit()
        except:
            main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
            main.log.error( traceback.print_exc() )
            main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
            main.cleanup()
            main.exit()

    def run_optical_mn_script(self):
        '''
            This function is only meant for Packet Optical. 
            It runs the python script "optical.py" to create the packet layer(mn)
            topology
        '''
        try:
            self.handle.sendline("")
            self.handle.expect("\$")
            self.handle.sendline("cd ~")
            self.handle.expect("\$")
            self.handle.sendline("sudo python optical.py")
            self.handle.expect(">")
            return main.TRUE
        except pexpect.EOF:
            main.log.error(self.name + ": EOF exception found")
            main.log.error(self.name + ":     " + self.handle.before)
            return main.FALSE
    
    def del_switch(self,sw):
        self.handle.sendline("")
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl del-br "+sw)
        self.handle.expect("\$")
        return main.TRUE

    def add_switch(self,sw):
        #FIXME: Remove hardcoded number of ports
        self.handle.sendline("")
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl add-br "+sw)
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl add-port "+sw+" " + sw + "-eth1")
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl add-port "+sw+" " + sw + "-eth2")
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl add-port "+sw+" " + sw + "-eth3")
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl add-port "+sw+" " + sw + "-eth4")
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl add-port "+sw+" " + sw + "-eth5")
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl add-port "+sw+" " + sw + "-eth6")
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl add-port "+sw+" " + sw + "-eth7")
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl add-port "+sw+" " + sw + "-eth8")
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl add-port "+sw+" " + sw + "-eth9")
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl add-port "+sw+" " + sw + "-eth10")
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl add-port "+sw+" " + sw + "-eth11")
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl add-port "+sw+" " + sw + "-eth12")
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl add-port "+sw+" " + sw + "-eth13")
        self.handle.expect("\$")
        self.handle.sendline("sudo ovs-vsctl add-port "+sw+" " + sw + "-eth14")
        self.handle.expect("\$")


    def disconnect(self):
        '''    
        Called at the end of the test to disconnect the handle.    
        '''    
        response = ''
        #print "Disconnecting Mininet"
        if self.handle:
            self.handle.sendline("exit") 
            self.handle.expect("exit")
            self.handle.expect("(.*)")
            response = self.handle.before

        else :
            main.log.error("Connection failed to the host")
            response = main.FALSE
        return response  

    def get_flowTable(self, protoVersion, sw):
        self.handle.sendline("cd")
        #self.handle.expect(["\$",pexpect.EOF,pexpect.TIMEOUT])
        print "cd expect status: " 
        print self.handle.expect(["\$",pexpect.EOF,pexpect.TIMEOUT])
        #TODO: Write seperate versions of the function for this, possibly a string that tells it which switch is in use?
        #For 1.0 version of OVS
        #command = "sudo ovs-ofctl dump-flows " + sw + " | awk '{OFS=\",\" ; print $1 $6 $7 }' |sort -n -k1"
        #for 1.3 version of OVS
        #command = "sudo ovs-ofctl dump-flows " + sw + " | awk '{OFS=\",\" ; print $1 $3 $7 $8}' |sort -n -k1"
        #NOTE: Use format to force consistent flow table output across versions
        if protoVersion==1.0:
            command = "sudo ovs-ofctl dump-flows " + sw + " -F OpenFlow10-table_id | awk '{OFS=\",\" ; print $1  $3  $6  $7  $8}' |sort -n -k1"
            self.handle.sendline(command)
            self.handle.expect(["sort -n -k1",pexpect.EOF,pexpect.TIMEOUT])
            self.handle.expect(["OFPST_FLOW",pexpect.EOF,pexpect.TIMEOUT])
            response = self.handle.before
            #print "response=", response
            return response
        elif protoVersion==1.3:
            command = "sudo ovs-ofctl dump-flows " + sw + " -O OpenFlow13  | awk '{OFS=\",\" ; print $1  $3  $6  $7}' |sort -n -k1" 
            self.handle.sendline(command)
            #print "ovs-vsctl Command sent status."
            #self.handle.expect(["sort -n -k1",pexpect.EOF,pexpect.TIMEOUT])
            #print "sort return status: " 
            #print self.handle.expect(["sort -n -k1",pexpect.EOF,pexpect.TIMEOUT])
            #print self.handle.before
            self.handle.expect(["OFPST_FLOW",pexpect.EOF,pexpect.TIMEOUT])
            #print "OFPST_FLOW expected status: " 
            #print self.handle.expect(["OFPST_FLOW",pexpect.EOF,pexpect.TIMEOUT])
            #print self.handle.before
            response = self.handle.before
            #print "response=", response
            return response 
        

    def flow_comp(self,flow1,flow2):
        #print "Inside flow compare function"
        #print "Flow1 Table:"
        #for flow in flow1:
            #print flow1
        #print "Flow2 Table"
        #for flow in flow2:
            #print flow2

        if flow1==flow2:
            return main.TRUE
        else:
            main.log.info("Flow tables do not match, printing tables:")
            #main.log.info("Flow Table 1:")
            #main.log.info(flow1)
            #main.log.info("Flow Table 2:")
            #main.log.info(flow2)
            return main.FALSE

    def setIpTablesOUTPUT(self, dst_ip, dst_port, action='add', packet_type='tcp',rule='DROP'):
        '''
        Description:
            add or remove iptables rule to DROP (default)  packets from specific IP and PORT
        Usage:
        * specify action ('add' or 'remove')
          when removing, pass in the same argument as you would add. It will
          delete that specific rule. 
        * specify the destination ip to block with dst_ip 
        * specify destination port to block to dst_port
        * optional packet type to block (default tcp)
        * optional iptables rule (default DROP)
        WARNING:
        * This function uses root privilege iptables command which may result in
          unwanted network errors. USE WITH CAUTION
        '''
        import re
        import time

        #NOTE*********
        #   The strict checking methods of this driver function is intentional
        #   to discourage any misuse or error of iptables, which can cause
        #   severe network errors
        #*************

        #NOTE: Sleep needed to give some time for rule to be added and registered
        #      to the instance
        time.sleep(5)

        action_type = action.lower()
        if action_type != 'add' and action_type !='remove':
            main.log.error("Invalid action type. 'add' or 'remove' table rule")
            if rule != 'DROP' and rule != 'ACCEPT' and rule != 'LOG':
                #NOTE: Currently only supports rules DROP, ACCEPT, and LOG
                main.log.error("Invalid rule. 'DROP' or 'ACCEPT' or 'LOG' only.")
                return
            return
        else:

            #If there is no existing rule in the iptables, we will see an 
            #'iptables:'... message. We expect to see this message. 
            #Otherwise, if there IS an existing rule, we will get the prompt
            # back, hence why we expect $ for remove type. We want to remove
            # an already existing rule

            if action_type == 'add':
                #NOTE: "iptables:" expect is a result of return from the command
                #      iptables -C ...
                #      Any changes by the iptables command return string 
                #      will result in failure of the function. (deemed unlikely
                #      at the time of writing this function)
                #Check for existing rules on current input
                self.handle.sendline("")
                self.handle.expect("\$")
                self.handle.sendline("sudo iptables -C OUTPUT -p "+str(packet_type)+
                        " -d "+ str(dst_ip)+" --dport "+str(dst_port)+" -j "+str(rule))
                i = self.handle.expect(["iptables:", "\$"])
                print i
                print self.handle.before
                print "after: "
                print self.handle.after

            elif action_type == 'remove':
                #Check for existing rules on current input
                self.handle.sendline("")
                self.handle.expect("\$")
                self.handle.sendline("sudo iptables -C OUTPUT -p "+str(packet_type)+
                        " -d "+ str(dst_ip)+" --dport "+str(dst_port)+" -j "+str(rule))
                self.handle.expect("\$")
            print "before: "
            print self.handle.before
            actual_string = self.handle.after
            expect_string = "iptables:"
            print "Actual String:"
            print actual_string

            if re.search(expect_string, actual_string):
                match_result = main.TRUE
            else:
                match_result = main.FALSE
            #If match_result is main.TRUE, it means there is no matching rule. 

            #If tables does not exist and expected prompt is returned, go ahead and
            #add iptables rule
            if match_result == main.TRUE:
                #Ensure action type is add
                if action_type == 'add':
                    #-A is the 'append' action of iptables
                    action_add = '-A'
                    try:
                        self.handle.sendline("")
                        self.handle.sendline("sudo iptables "+action_add+" OUTPUT -p "+str(packet_type)+
                            " -d "+ str(dst_ip)+" --dport "+str(dst_port)+" -j "+str(rule))

                        info_string = "Rules added to "+str(self.name)
                        info_string += "iptable rule added to block IP: "+str(dst_ip)
                        info_string += "Port: "+str(dst_port)+" Rule: "+str(rule)

                        main.log.info(info_string)

                        self.handle.expect(["\$",pexpect.EOF,pexpect.TIMEOUT])
                    except pexpect.TIMEOUT:
                        main.log.error(self.name + ": Timeout exception in setIpTables function")
                    except:
                        main.log.error( traceback.print_exc())
                        main.cleanup()
                        main.exit()
                else:
                    main.log.error("Given rule already exists, but attempted to add it")
            #If match_result is 0, it means there IS a matching rule provided
            elif match_result == main.FALSE:
                #Ensure action type is remove
                if action_type == 'remove':
                    #-D is the 'delete' rule of iptables
                    action_remove = '-D'
                    try:
                        self.handle.sendline("")
                        #Delete a specific rule specified into the function
                        self.handle.sendline("sudo iptables "+action_remove+" OUTPUT -p "+str(packet_type)+
                            " -d "+ str(dst_ip)+" --dport "+str(dst_port)+" -j "+str(rule))

                        info_string = "Rules removed from "+str(self.name)
                        info_string += " iptables rule removed from blocking IP: "+str(dst_ip)
                        info_string += " Port: "+str(dst_port)+" Rule: "+str(rule)

                        main.log.info(info_string)

                        self.handle.expect(["\$",pexpect.EOF,pexpect.TIMEOUT])
                    except pexpect.TIMEOUT:
                        main.log.error(self.name + ": Timeout exception in setIpTables function")
                    except:
                        main.log.error( traceback.print_exc())
                        main.cleanup()
                        main.exit()
                else:
                    main.log.error("Given rule does not exist, but attempted to remove it")
            else:
                #NOTE: If a bad usage of this function occurs, exit the entire test
                main.log.error("Bad rule given for iptables. Exiting...")
                main.cleanup()
                main.exit()


if __name__ != "__main__":
    import sys
    sys.modules[__name__] = RemoteMininetDriver()