def __init__(self, name, sw_path = None, json_path = None,
              thrift_port = None,
              pcap_dump = False,
              log_console = False,
              verbose = False,
              device_id = None,
              enable_debugger = False,
              **kwargs):
     Switch.__init__(self, name, **kwargs)
     assert(sw_path)
     assert(json_path)
     # make sure that the provided sw_path is valid
     pathCheck(sw_path)
     # make sure that the provided JSON file exists
     if not os.path.isfile(json_path):
         error("Invalid JSON file.\n")
         exit(1)
     self.sw_path = sw_path
     self.json_path = json_path
     self.verbose = verbose
     logfile = "/tmp/p4s.{}.log".format(self.name)
     self.output = open(logfile, 'w')
     self.thrift_port = thrift_port
     self.pcap_dump = pcap_dump
     self.enable_debugger = enable_debugger
     self.log_console = log_console
     if device_id is not None:
         self.device_id = device_id
         P4Switch.device_id = max(P4Switch.device_id, device_id)
     else:
         self.device_id = P4Switch.device_id
         P4Switch.device_id += 1
     self.nanomsg = "ipc:///tmp/bm-{}-log.ipc".format(self.device_id)

 def __init__( self, name, dpopts='--no-slicing', **kwargs ):
     """Init.
        name: name for the switch
        dpopts: additional arguments to ofdatapath (--no-slicing)"""
     Switch.__init__( self, name, **kwargs )
     pathCheck('switch', moduleName='the Fluid library example switch' +
                           '(CPqD)' )

 def __init__(self, name, **kwargs):
     """Init.
        name: name for the switch"""
     Switch.__init__(self, name, **kwargs)
     pathCheck("ofdatapath", "ofprotocol", moduleName="the OpenFlow reference user switch" + "(openflow.org)")
     if self.listenPort:
         self.opts += " --listen=ptcp:%i " % self.listenPort

 def start(self):
     """Start <controller> <args> on controller.
         Log to /tmp/cN.log"""
     pathCheck(self.command)
     cout = "/tmp/" + self.name + ".log"
     if self.cdir is not None:
         self.cmd("cd " + self.cdir)
     self.cmd(self.command, self.cargs % self.port, ">&", cout, "&")

 def __init__( self, name, **kwargs ):
     """Init.
        name: name for the switch"""
     Switch.__init__( self, name, **kwargs )
     pathCheck( 'ofdatapath', 'ofprotocol',
         moduleName='the OpenFlow reference user switch (openflow.org)' )
     self.cmd( 'kill %ofdatapath' )
     self.cmd( 'kill %ofprotocol' )

 def start( self ):
     """Start <controller> <args> on controller.
         Log to /tmp/cN.log"""
     pathCheck( self.command )
     cout = '/tmp/' + self.name + '.log'
     if self.cdir is not None:
         self.cmd( 'cd ' + self.cdir )
     self.cmd( self.command, self.cargs % self.port, '>&', cout, '&' )

 def start(self):
     pathCheck(self.command)
     cout = '/tmp/' + self.name + '.log'
     command = self.command + ' ' + (self.cargs % self.port)
     print command
     self.fout = open(cout, 'w')
     self.controller_popen = self.popen(command.split(' '),
                                        stdout=self.fout,
                                        stderr=self.fout)

 def setup( cls ):
     "Check dependencies and warn about firewalling"
     pathCheck( 'brctl', moduleName='bridge-utils' )
     # Disable Linux bridge firewalling so that traffic can flow!
     for table in 'arp', 'ip', 'ip6':
         cmd = 'sysctl net.bridge.bridge-nf-call-%stables' % table
         out = quietRun( cmd ).strip()
         if out.endswith( '1' ):
             warn( 'Warning: Linux bridge may not work with', out, '\n' )

 def setup():
     pathCheck('brctl')
     brlist = quietRun('brctl show')
     for line in brlist.split("\n"):
         line = line.rstrip()
         m = re.match('^lxbr-(\w+)', line)
         if (m):
             print "Cleaning old bridge lxbr-%s" % m.group(1)
             self.cmd ('brctl', 'delbr', 'lxbr-%s' % m.group(1))

 def start(self):
     """Start <controller> <args> on controller.
        Log to /tmp/cN.log"""
     pathCheck(self.command)
     cout = "/tmp/" + self.name + ".log"
     if self.cdir is not None:
         self.cmd("cd " + self.cdir)
     self.cmd(self.command + " " + self.cargs % self.port + " 1>" + cout + " 2>" + cout + "&")
     self.execed = False

 def setup(cls):
     "Check dependencies and warn about firewalling"
     pathCheck("brctl", moduleName="bridge-utils")
     # Disable Linux bridge firewalling so that traffic can flow!
     for table in "arp", "ip", "ip6":
         cmd = "sysctl net.bridge.bridge-nf-call-%stables" % table
         out = quietRun(cmd).strip()
         if out.endswith("1"):
             warn("Warning: Linux bridge may not work with", out, "\n")

 def __init__( self, name, **kwargs ):
     """Init.
        name: name for the switch"""
     Switch.__init__( self, name, **kwargs )
     pathCheck( 'ofdatapath', 'ofprotocol',
                moduleName='the OpenFlow reference user switch' +
                           '(openflow.org)' )
     if self.listenPort:
         self.opts += ' --listen=ptcp:%i ' % self.listenPort

 def start(self):
     """Start <controller> <args> on controller.
        Log to /tmp/cN.log"""
     log.info('Starting controller...\n')
     pathCheck(self.command)
     cout = '/tmp/' + self.name + '.log'
     chdir(self.fl_root_dir)
     self.cmd(self.command + ' ' + self.cargs +
              ' 1>' + cout + ' 2>' + cout + '&')
     self.execed = False

 def __init__( self, name, bw=100000000, **kwargs ): #100mbps
     """Init.
        name: name for the switch
        bw: interface maximum bandwidth"""
     
     Switch.__init__( self, name, **kwargs )
     self.bandwidth = bw
     pathCheck( 'ofdatapath', 'ofprotocol', moduleName='QoSFlow 0.1 datapath')
     if self.listenPort: # dpctl
         self.opts += ' --listen=ptcp:%i ' % self.listenPort

 def start( self ):
     """Start <controller> <args> on controller.
        Log to /tmp/cN.log"""
     pathCheck( self.command )
     cout = '/tmp/' + self.name + '.log'
     if self.cdir is not None:
         self.cmd( 'cd ' + self.cdir )
     self.cmd( self.command + ' ' + self.cargs % self.port +
               ' 1>' + cout + ' 2>' + cout + '&' )
     self.execed = False

 def setup( cls ):
     "Make sure IVS is installed"
     pathCheck( 'ivs-ctl', 'ivs',
                moduleName="Indigo Virtual Switch (projectfloodlight.org)" )
     out, err, exitcode = errRun( 'ivs-ctl show' )
     if exitcode:
         error( out + err +
                'ivs-ctl exited with code %d\n' % exitcode +
                '*** The openvswitch kernel module might '
                'not be loaded. Try modprobe openvswitch.\n' )
         exit( 1 )

 def __init__( self, name, dpopts='--no-slicing', **kwargs ):
     """Init.
        name: name for the switch
        dpopts: additional arguments to ofdatapath (--no-slicing)"""
     Switch.__init__( self, name, **kwargs )
     pathCheck( 'ofdatapath', 'ofprotocol',
                moduleName='the OpenFlow reference user switch' +
                           '(openflow.org)' )
     if self.listenPort:
         self.opts += ' --listen=ptcp:%i ' % self.listenPort
     self.dpopts = dpopts

    def setup():
        "Ensure any dependencies are loaded; if not, try to load them."
        moduleName='Open vSwitch (openvswitch.org)'
        pathCheck( 'ovs-vsctl', 'ovsdb-server', 'ovs-vswitchd', moduleName=moduleName )
        moduleDeps( subtract=OF_KMOD, add=OVS_KMOD, moduleName=moduleName )

        if not checkRunning('ovsdb-server', 'ovs-vswitchd'):
            ovsdb_server_cmd = ['ovsdb-server', 
                            '--remote=punix:/tmp/mn-openvswitch-db.sock', 
                            '--remote=db:Open_vSwitch,manager_options']

            # We need to specify the DB path for OVS before 1.2.0
            ovs_ver = quietRun('ovsdb-server -V').split('\n')[0]
            # Note the space in front of the version strings.
            # TODO: Maybe we should extract the version instead of 
            #       substr matching
            if ' 1.1.' in ovs_ver or ' 1.0.' in ovs_ver:
                ovsdb_server_cmd.insert(1, '/usr/local/etc/openvswitch/conf.db')
                
            # Every OVS command *except* ovsdb-server has a default path
            # to the database socket hardcoded. Problem is: if we need
            # to run ovsdb-server ourselves we cannot figure out what
            # this path is. Grr.
            ovsdb_instance = Popen(ovsdb_server_cmd, 
                         stderr = STDOUT, stdout = open('/tmp/mn-ovsdb-server.log', "w") )
            sleep(0.1)
            if ovsdb_instance.poll() is not None:
                error("ovsdb-server was not running and we could not start it - exiting\n")
                sys.exit(1)
            vswitchd_instance = Popen(['ovs-vswitchd', 'unix:/tmp/mn-openvswitch-db.sock'],
                          stderr = STDOUT, stdout = open('/tmp/mn-vswitchd.log', "w") )
            if vswitchd_instance.poll() is not None:
                error("ovs-vswitchd was not running and we could not start it - exiting\n")
                sys.exit(1)
            sleep(0.1)
            OVSKernelSwitchNew.vsctl_cmd = 'ovs-vsctl -t 2 --db=unix:/tmp/mn-openvswitch-db.sock '
        else:
            OVSKernelSwitchNew.vsctl_cmd = 'ovs-vsctl -t 2 '

        # Remove old mininet datapaths to make sure they don't interfere
        brlist = quietRun ( OVSKernelSwitchNew.vsctl_cmd + ' list-br' )
        for line in brlist.split("\n"):
            line = line.rstrip()
            if re.match('^mn-dp[0-9]+$', line):
                quietRun ( OVSKernelSwitchNew.vsctl_cmd + ' del-br ' + line )

 def setup( cls ):
     "Make sure Open vSwitch is installed and working"
     pathCheck( 'ovs-vsctl',
                moduleName='Open vSwitch (openvswitch.org)')
     # This should no longer be needed, and it breaks
     # with OVS 1.7 which has renamed the kernel module:
     #  moduleDeps( subtract=OF_KMOD, add=OVS_KMOD )
     out, err, exitcode = errRun( 'ovs-vsctl -t 1 show' )
     if exitcode:
         error( out + err +
                'ovs-vsctl exited with code %d\n' % exitcode +
                '*** Error connecting to ovs-db with ovs-vsctl\n'
                'Make sure that Open vSwitch is installed, '
                'that ovsdb-server is running, and that\n'
                '"ovs-vsctl show" works correctly.\n'
                'You may wish to try '
                '"service openvswitch-switch start".\n' )
         exit( 1 )

    def _build_cmd_args( self ):
        "Build command-line argument of POX."
        self.run_file = ""
        self.ctrl_args = ""
        self.cmd_args = ""
        self.cmd_log = ""
        self.cmd_tail = ""

        self.run_file = self.poxCoreDir + "/pox.py"
        pathCheck( self.run_file )

        if self.use_remote_controller:
            self.ctrl_args = "--no-openflow"
        elif self.controller_type:
            self.ctrl_args = self.controller_type + " openflow.of_01"
            self.ctrl_args += " --address="    + str(self.controller_ip)
            self.ctrl_args += " --port="       + str(self.controller_port)

        self.cmd_args = "datapaths.pcap_switch"
        self.cmd_args += " --address="         + str(self.controller_ip)
        self.cmd_args += " --port="            + str(self.controller_port)
        self.cmd_args += " --max_retry_delay=" + str(self.max_retry_delay)
        self.cmd_args += " --dpid="            + str(self.dpid)
        self.cmd_args += " --ports="           + ",".join(self.intf_ports)
        self.cmd_args += " --extra="           + ",".join(self.extra)

        self.cmd_log = "/tmp/" + self.name + ".log"
        self.cmd( 'echo "" > %s' % self.cmd_log )  # Clear previous
        self.cmd_tail = "1>> " + self.cmd_log + " 2>> " + self.cmd_log + " &"

        if self.print_personal_debug: print "WARN: self.listenPort is UNUSED"
        self.command = self.run_file
        self.command += " " + self.ctrl_args
        self.command += " " + self.cmd_args
        self.command += " " + self.cmd_tail
        if self.print_personal_debug: print "EVAL: " + self.command