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, json=STRATUM_INIT_PIPELINE, loglevel="warn", cpuport=DEFAULT_CPU_PORT, pipeconf=DEFAULT_PIPECONF, onosdevid=None, adminstate=True, **kwargs): Switch.__init__(self, name, **kwargs) self.grpcPort = StratumBmv2Switch.nextGrpcPort StratumBmv2Switch.nextGrpcPort += 1 self.cpuPort = cpuport self.json = json self.loglevel = loglevel self.tmpDir = '/tmp/%s' % self.name self.logfile = '%s/stratum_bmv2.log' % self.tmpDir self.netcfgFile = '%s/onos-netcfg.json' % self.tmpDir self.chassisConfigFile = '%s/chassis-config.txt' % self.tmpDir self.pipeconfId = pipeconf self.longitude = kwargs['longitude'] if 'longitude' in kwargs else None self.latitude = kwargs['latitude'] if 'latitude' in kwargs else None if onosdevid is not None and len(onosdevid) > 0: self.onosDeviceId = onosdevid else: # The "device:" prefix is required by ONOS. self.onosDeviceId = "device:%s" % self.name self.nodeId = DEFAULT_NODE_ID self.logfd = None self.bmv2popen = None self.stopped = True # In case of exceptions, mininet removes *.out files from /tmp. We use # this as a signal to terminate the switch instance (if active). self.keepaliveFile = '/tmp/%s-watchdog.out' % self.name self.adminState = "ENABLED" if adminstate else "DISABLED" # Remove files from previous executions self.cleanupTmpFiles() os.mkdir(self.tmpDir)
def __init__(self, name, config=None, sw_path="simple_switch", device_id=0, log_file=None, log_level="info", thrift_port=9090, debugger=False, **kwargs): """ :param config: Path to the JSON configuration file. Starting without a configuration will drop all traffic. :param sw_path: Switch executeable. :param device_id: Device ID of the switch. (--device-id) :param log_file: Path to a log file. `None` disabled logging. (--log-file) :param log_level: One of 'trace', 'debug', 'info', 'warn', 'error', 'off'. (--log-level) :param thrift_port: TCP port the thrift server will listen on. (--thrift-port) :param debugger: Enable the debugger. (--debugger) """ Switch.__init__(self, name, **kwargs) self.config = config self.sw_path = sw_path self.device_id = device_id self.log_file = log_file self.log_level = log_level self.thrift_port = thrift_port self.debugger = debugger
def __init__(self, name, thriftPort=None, deviceId=None, debugger=False, loglevel="warn", elogger=False, persistent=True, **kwargs): Switch.__init__(self, name, **kwargs) self.swPath = environ['BMV2_EXE'] self.jsonPath = environ['BMV2_JSON'] if thriftPort: self.thriftPort = thriftPort else: self.thriftPort = ONOSBmv2Switch.pickUnusedPort() if not deviceId: if self.dpid: self.deviceId = int(self.dpid, 0 if 'x' in self.dpid else 16) else: self.deviceId = ONOSBmv2Switch.deviceId ONOSBmv2Switch.deviceId += 1 else: self.deviceId = deviceId ONOSBmv2Switch.deviceId = max(deviceId, ONOSBmv2Switch.deviceId) self.debugger = debugger self.loglevel = loglevel self.logfile = '/tmp/bmv2-%d.log' % self.deviceId self.output = open(self.logfile, 'w') self.elogger = elogger self.persistent = persistent if persistent: self.exectoken = "/tmp/bmv2-%d-exec-token" % self.deviceId self.cmd("touch %s" % self.exectoken) # Store thrift port for future uses. self.cmd("echo %d > /tmp/bmv2-%d-thrift-port" % (self.thriftPort, self.deviceId))
def __init__(self, name, json=None, debugger=False, loglevel="warn", elogger=False, grpcport=None, cpuport=255, notifications=False, thriftport=None, netcfg=True, dryrun=False, pipeconf=DEFAULT_PIPECONF, pktdump=False, valgrind=False, gnmi=False, portcfg=True, onosdevid=None, stratum=False, **kwargs): Switch.__init__(self, name, **kwargs) self.grpcPort = grpcport self.thriftPort = thriftport self.cpuPort = cpuport self.json = json self.useStratum = parseBoolean(stratum) self.debugger = parseBoolean(debugger) self.notifications = parseBoolean(notifications) self.loglevel = loglevel # Important: Mininet removes all /tmp/*.log files in case of exceptions. # We want to be able to see the bmv2 log if anything goes wrong, hence # avoid the .log extension. self.logfile = '/tmp/bmv2-%s-log' % self.name self.elogger = parseBoolean(elogger) self.pktdump = parseBoolean(pktdump) self.netcfg = parseBoolean(netcfg) self.dryrun = parseBoolean(dryrun) self.valgrind = parseBoolean(valgrind) self.netcfgfile = '/tmp/bmv2-%s-netcfg.json' % self.name self.chassisConfigFile = '/tmp/bmv2-%s-chassis-config.txt' % self.name self.pipeconfId = pipeconf self.injectPorts = parseBoolean(portcfg) self.withGnmi = parseBoolean(gnmi) self.longitude = kwargs['longitude'] if 'longitude' in kwargs else None self.latitude = kwargs['latitude'] if 'latitude' in kwargs else None if onosdevid is not None and len(onosdevid) > 0: self.onosDeviceId = onosdevid else: self.onosDeviceId = "device:bmv2:%s" % self.name self.p4DeviceId = BMV2_DEFAULT_DEVICE_ID self.logfd = None self.bmv2popen = None self.stopped = True # In case of exceptions, mininet removes *.out files from /tmp. We use # this as a signal to terminate the switch instance (if active). self.keepaliveFile = '/tmp/bmv2-%s-watchdog.out' % self.name self.targetName = STRATUM_BMV2 if self.useStratum else SIMPLE_SWITCH_GRPC # Remove files from previous executions self.cleanupTmpFiles()
def __init__( self, name, sw_path="dc_full", json_path=None, thrift_port=None, pcap_dump=True, verbose=True, device_id=None, enable_debugger=True, **kwargs ): Switch.__init__(self, name, **kwargs) assert(sw_path) assert(json_path) self.sw_path = sw_path self.json_path = json_path self.verbose = verbose self.logfile = '/tmp/p4s.%s.log' % self.name self.thrift_port = thrift_port self.pcap_dump = pcap_dump self.enable_debugger = enable_debugger self.nanomsg = "ipc:///bm-%d-log.ipc" % self.device_id 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
def __init__(self, name, target_name='p4dockerswitch', thrift_port=None, target_dir='switch', sai_port=None, swapi_port=None, pcap_dump=False, verbose=False, start_program='/p4factory/tools/start.sh', config_fs=None, pps=0, qdepth=0, **kwargs): self.verbose = verbose self.pcap_dump = pcap_dump self.start_program = start_program self.config_fs = config_fs self.target_name = target_name self.target_dir = target_dir self.thrift_port = thrift_port self.sai_port = sai_port self.swapi_port = swapi_port self.pps = pps self.qdepth = qdepth Switch.__init__(self, name, **kwargs) self.inNamespace = True
def __init__(self, name, sw_path=None, json_path=None, thrift_port=None, pcap_dump=False, verbose=False, device_id=None, enable_debugger=False, cpu_port=None, **kwargs): Switch.__init__(self, name, **kwargs) assert (sw_path) self.sw_path = sw_path self.json_path = json_path self.verbose = verbose logfile = '/tmp/p4s.%s.log' % self.name self.output = open(logfile, 'w') self.thrift_port = thrift_port self.pcap_dump = pcap_dump self.enable_debugger = enable_debugger self.cpu_port = cpu_port 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-%d-log.ipc" % self.device_id
def __init__(self, name, thriftPort=None, deviceId=None, debugger=False, loglevel="warn", elogger=False, persistent=True, **kwargs): Switch.__init__(self, name, **kwargs) self.swPath = environ['BMV2_EXE'] self.jsonPath = environ['BMV2_JSON'] if not thriftPort: self.thriftPort = ONOSBmv2Switch.thriftPort ONOSBmv2Switch.thriftPort += 1 else: self.thriftPort = thriftPort ONOSBmv2Switch.thriftPort = max(thriftPort, ONOSBmv2Switch.thriftPort) if not deviceId: if self.dpid: self.deviceId = int(self.dpid, 0 if 'x' in self.dpid else 16) else: self.deviceId = ONOSBmv2Switch.deviceId ONOSBmv2Switch.deviceId += 1 else: self.deviceId = deviceId ONOSBmv2Switch.deviceId = max(deviceId, ONOSBmv2Switch.deviceId) self.debugger = debugger self.loglevel = loglevel self.logfile = '/tmp/bmv2-%d.log' % self.deviceId self.output = open(self.logfile, 'w') self.elogger = elogger self.persistent = persistent if persistent: self.exectoken = "/tmp/bmv2-%d-exec-token" % self.deviceId self.cmd("touch %s" % self.exectoken)
def __init__( self, name, target_name = 'p4dockerswitch', thrift_port = None, target_dir = 'single_device', sai_port = None, swapi_port = None, pcap_dump = False, verbose = False, start_program = '/p4factory/tools/start.sh', config_fs = None, pps = 0, qdepth = 0, **kwargs ): self.verbose = verbose self.pcap_dump = pcap_dump self.start_program = start_program self.config_fs = config_fs self.target_name = target_name self.target_dir = target_dir self.thrift_port = thrift_port self.sai_port = sai_port self.swapi_port = swapi_port self.pps = pps self.qdepth = qdepth Switch.__init__( self, name, **kwargs ) self.inNamespace = True
def __init__(self, name, inNamespace=True, sdeInstall="/root/sde/install", bfSwitchdConfig="/etc/stratum/tofino_skip_p4.conf", **kwargs): Switch.__init__(self, name, inNamespace=True, **kwargs) self.sdeInstall = sdeInstall self.bfSwitchdConfig = bfSwitchdConfig self.nodeId = StratumTofinoModel.nextNodeId * 64 StratumTofinoModel.nextNodeId += 1 self.tmpDir = '/tmp/%s' % self.name self.chassisConfigFile = '%s/chassis-config.txt' % self.tmpDir self.portVethFile = '%s/ports.json' % self.tmpDir # process handles for tofino model and stratum self.modelProcHandle = None self.stratumProcHandle = None # !(run) or run ? boolean bit self.stopped = True # In case of exceptions, mininet removes *.out files from /tmp. We use # this as a signal to terminate the switch instance (if active). self.keepalive = '/tmp/%s-watchdog.out' % self.name # Remove files from previous executions self.cmd("rm -rf %s" % self.tmpDir) os.mkdir(self.tmpDir)
def __init__(self, name, sw_path=None, json_path=None, thrift_port=None, pcap_dump=True, log_console=True, verbose=True, 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, sw_path=None, json_path=None, thrift_port=None, grpc_port=None, pcap_dump=False, verbose=False, device_id=None, enable_debugger=False, cpu_port=None, **kwargs): Switch.__init__(self, name, **kwargs) assert (sw_path) self.sw_path = sw_path self.json_path = json_path self.verbose = verbose self.thrift_port = thrift_port self.grpc_port = grpc_port # self.pcap_dump = pcap_dump self.enable_debugger = enable_debugger self.cpu_port = cpu_port if device_id is not None: self.device_id = device_id P4Switch.device_id = max(P4Switch.device_id, device_id) # self.thrift_port = 9090 + device_id else: self.device_id = P4Switch.device_id P4Switch.device_id += 1
def __init__(self, name, json=None, debugger=False, loglevel="warn", elogger=False, persistent=False, grpcPort=None, netcfg=True, **kwargs): Switch.__init__(self, name, **kwargs) self.grpcPort = ONOSBmv2Switch.pickUnusedPort( ) if not grpcPort else grpcPort if self.dpid: self.deviceId = int(self.dpid, 0 if 'x' in self.dpid else 16) else: self.deviceId = ONOSBmv2Switch.deviceId ONOSBmv2Switch.deviceId += 1 self.json = json self.debugger = debugger self.loglevel = loglevel self.logfile = '/tmp/bmv2-%d.log' % self.deviceId self.elogger = elogger self.persistent = persistent self.netcfg = netcfg self.netcfgfile = '/tmp/bmv2-%d-netcfg.json' % self.deviceId if persistent: self.exectoken = "/tmp/bmv2-%d-exec-token" % self.deviceId self.cmd("touch %s" % self.exectoken) # Store thrift port for future uses. self.cmd("echo %d > /tmp/bmv2-%d-grpc-port" % (self.grpcPort, self.deviceId))
def __init__(self, name, **kwargs): kwargs['inNamespace'] = True Switch.__init__(self, name, **kwargs) Router.ID += 1 self.switch_id = Router.ID
def __init__(self, name, **kwargs): if 'notInNamespace' not in kwargs: kwargs['inNamespace'] = True else: kwargs.pop('notInNamespace') Switch.__init__(self, name, **kwargs) Router.ID += 1 self.switch_id = Router.ID
def stop(self, deleteIntfs=True): """Terminate switch.""" self.stopped = True if self.anyProcHandleLive(): self.tryTerminate() self.modelProcHandle = None self.stratumProcHandle = None Switch.stop(self, deleteIntfs)
def __init__(self, name, sw_path = None, json_path = None, grpc_port = None, thrift_port = None, pcap_dump = False, log_console = False, verbose = False, device_id = None, enable_debugger = False, log_file = None, **kwargs): Switch.__init__(self, name, **kwargs) assert (sw_path) self.sw_path = sw_path # make sure that the provided sw_path is valid pathCheck(sw_path) if json_path is not None: # make sure that the provided JSON file exists if not os.path.isfile(json_path): error("Invalid JSON file: {}\n".format(json_path)) exit(1) self.json_path = json_path else: self.json_path = None if grpc_port is not None: self.grpc_port = grpc_port else: self.grpc_port = P4RuntimeSwitch.next_grpc_port P4RuntimeSwitch.next_grpc_port += 1 if thrift_port is not None: self.thrift_port = thrift_port else: self.thrift_port = P4RuntimeSwitch.next_thrift_port P4RuntimeSwitch.next_thrift_port += 1 if check_listening_on_port(self.grpc_port): error('%s cannot bind port %d because it is bound by another process\n' % (self.name, self.grpc_port)) exit(1) self.verbose = verbose logfile = "/tmp/p4s.{}.log".format(self.name) self.output = open(logfile, 'w') self.pcap_dump = pcap_dump self.enable_debugger = enable_debugger self.log_console = log_console if log_file is not None: self.log_file = log_file else: self.log_file = "/tmp/p4s.{}.log".format(self.name) 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, json=None, debugger=False, loglevel="info", elogger=False, grpcport=None, cpuport=255, notifications=False, thriftport=None, netcfg=True, dryrun=False, pipeconf="", pktdump=False, valgrind=False, gnmi=False, portcfg=True, onosdevid=None, switch_config=None, **kwargs): Switch.__init__(self, name, **kwargs) self.wintfs = {} # dict of wireless port numbers self.wports = {} # dict of interfaces to port numbers self.grpcPort = grpcport self.thriftPort = thriftport self.cpuPort = cpuport self.json = json self.debugger = parseBoolean(debugger) self.notifications = parseBoolean(notifications) self.loglevel = loglevel # Important: Mininet removes all /tmp/*.log files in case of exceptions. # We want to be able to see the bmv2 log if anything goes wrong, hence # avoid the .log extension. self.logfile = '/tmp/bmv2-%s-log' % self.name self.elogger = parseBoolean(elogger) self.pktdump = parseBoolean(pktdump) self.netcfg = parseBoolean(netcfg) self.dryrun = parseBoolean(dryrun) self.valgrind = parseBoolean(valgrind) self.netcfgfile = '/tmp/bmv2-%s-netcfg.json' % self.name self.pipeconfId = pipeconf self.injectPorts = parseBoolean(portcfg) self.withGnmi = parseBoolean(gnmi) self.longitude = kwargs['longitude'] if 'longitude' in kwargs else None self.latitude = kwargs['latitude'] if 'latitude' in kwargs else None if onosdevid is not None and len(onosdevid) > 0: self.onosDeviceId = onosdevid else: self.onosDeviceId = "device:bmv2:%s" % self.name nums = re.findall(r'\d+', name) self.p4DeviceId = nums[0] self.logfd = None self.bmv2popen = None self.stopped = False self.switch_config = switch_config # Remove files from previous executions self.cleanupTmpFiles()
def __init__(self, name, json=None, debugger=False, loglevel="warn", elogger=False, persistent=False, grpcPort=None, thriftPort=None, netcfg=True, dryrun=False, pipeconfId="", pktdump=False, valgrind=False, netcfgDelay=0, **kwargs): Switch.__init__(self, name, **kwargs) self.grpcPort = ONOSBmv2Switch.pickUnusedPort( ) if not grpcPort else grpcPort self.thriftPort = ONOSBmv2Switch.pickUnusedPort( ) if not thriftPort else thriftPort if self.dpid: self.deviceId = int(self.dpid, 0 if 'x' in self.dpid else 16) else: self.deviceId = ONOSBmv2Switch.deviceId ONOSBmv2Switch.deviceId += 1 self.json = json self.debugger = parseBoolean(debugger) self.loglevel = loglevel self.logfile = '/tmp/bmv2-%d.log' % self.deviceId self.elogger = parseBoolean(elogger) self.pktdump = parseBoolean(pktdump) self.persistent = parseBoolean(persistent) self.netcfg = parseBoolean(netcfg) self.dryrun = parseBoolean(dryrun) self.valgrind = parseBoolean(valgrind) self.netcfgDelay = netcfgDelay self.netcfgfile = '/tmp/bmv2-%d-netcfg.json' % self.deviceId self.pipeconfId = pipeconfId if persistent: self.exectoken = "/tmp/bmv2-%d-exec-token" % self.deviceId self.cmd("touch %s" % self.exectoken) # Store thrift port for future uses. self.cmd("echo %d > /tmp/bmv2-%d-grpc-port" % (self.grpcPort, self.deviceId)) if 'longitude' in kwargs: self.longitude = kwargs['longitude'] else: self.longitude = None if 'latitude' in kwargs: self.latitude = kwargs['latitude'] else: self.latitude = None self.onosDeviceId = "device:bmv2:%d" % self.deviceId
def __init__( self, name, dpid=None, allowed=True, switchType='ROADM', annotations={}, **params ): params[ 'inNamespace' ] = False Switch.__init__( self, name, dpid=dpid, **params ) self.name = name self.annotations = annotations self.allowed = allowed self.switchType = switchType self.configDict = {} # dictionary that holds all of the JSON configuration data
def __init__(self, name, logFile="/dev/null", inNamespace=True, parameters=[], **params): Switch.__init__(self, name, inNamespace=inNamespace, **params) self._logFile = logFile self._params = parameters
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 __init__( self, name, stp=False, prio=None, **kwargs ): """stp: use spanning tree protocol? (default False) prio: optional explicit bridge priority for STP""" self.stp = stp if prio: self.prio = prio else: self.prio = LinuxBridge.nextPrio LinuxBridge.nextPrio += 1 Switch.__init__( self, name, **kwargs )
def __init__(self, name, stp=False, prio=None, **kwargs): """stp: use spanning tree protocol? (default False) prio: optional explicit bridge priority for STP""" self.stp = stp if prio: self.prio = prio else: self.prio = LinuxBridge.nextPrio LinuxBridge.nextPrio += 1 Switch.__init__(self, name, **kwargs)
def __init__(self, name, switch_type="router", log_file=None, **params): Switch.__init__(self, name, **params) self.log_file = log_file if log_file else "log/{}.log".format( self.name) if switch_type == "simple_switch": self.make_config = self.simple_switch elif switch_type == "router": self.make_config = self.router else: raise NotImplementedError(switch_type)
def __init__(self, name, json=None, debugger=False, loglevel="info", elogger=False, grpcport=None, cpuport=255, notifications=False, thriftport=None, netcfg=False, dryrun=False, inNamespace=False, inband=False, pipeconf=DEFAULT_PIPECONF, pktdump=False, valgrind=False, gnmi=False, portcfg=True, onosdevid=None, stratum=False, switch_config=None, **kwargs): Switch.__init__(self, name, inNamespace=inNamespace, **kwargs) self.grpcPort = grpcport self.grpcPortInternal = None # Needed for Stratum (local_hercules_url) self.thriftPort = thriftport self.cpuPort = cpuport self.inNamespace = inNamespace self.inband = inband self.useStratum = parseBoolean(stratum) self.debugger = parseBoolean(debugger) self.notifications = parseBoolean(notifications) self.loglevel = loglevel # Important: Mininet removes all /tmp/*.log files in case of exceptions. # We want to be able to see the bmv2 log if anything goes wrong, hence # avoid the .log extension. self.logfile = '/tmp/bmv2-%s-log' % self.name self.elogger = parseBoolean(elogger) self.pktdump = parseBoolean(pktdump) self.netcfg = parseBoolean(netcfg) self.dryrun = parseBoolean(dryrun) self.valgrind = parseBoolean(valgrind) self.netcfgfile = '/tmp/bmv2-%s-netcfg.json' % self.name self.chassisConfigFile = '/tmp/bmv2-%s-chassis-config.txt' % self.name self.pipeconfId = pipeconf self.injectPorts = parseBoolean(portcfg) self.withGnmi = parseBoolean(gnmi) self.longitude = kwargs['longitude'] if 'longitude' in kwargs else None self.latitude = kwargs['latitude'] if 'latitude' in kwargs else None if onosdevid is not None and len(onosdevid) > 0: self.onosDeviceId = onosdevid else: self.onosDeviceId = "device:bmv2:%s" % self.name nums = re.findall(r'\d+', name) self.p4DeviceId = int(nums[0]) self.logfd = None self.bmv2popen = None self.stopped = True self.sip = None # In case of exceptions, mininet removes *.out files from /tmp. We use # this as a signal to terminate the switch instance (if active). self.keepaliveFile = '/tmp/bmv2-%s-watchdog.out' % self.name self.targetName = STRATUM_BMV2 if self.useStratum else SIMPLE_SWITCH_GRPC self.controllers = None self.switch_config = switch_config path = os.path.dirname(os.path.abspath(__file__)) + '/examples/p4/ap-runtime.json' self.json = path if not json else json # Remove files from previous executions self.cleanupTmpFiles()
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 = "/log/p4s.{}.log".format(self.name) self.output = open(logfile, 'w') self.thrift_port = thrift_port if check_listening_on_port(self.thrift_port): error( '%s cannot bind port %d because it is bound by another process\n' % (self.name, self.grpc_port)) exit(1) self.pcap_dump = pcap_dump self.enable_debugger = enable_debugger self.log_console = log_console self.device_id = P4Switch.device_id P4Switch.device_id += 1 self.nanomsg = "ipc:///log/bm-{}-log.ipc".format(self.device_id) if "operating_mode" in kwargs: self.operating_mode = kwargs["operating_mode"] else: self.operating_mode = "NORMAL" if "switch_rel_cpu_speed" in kwargs: self.switch_rel_cpu_speed = kwargs["switch_rel_cpu_speed"] else: self.switch_rel_cpu_speed = 1.0 if "n_round_insns" in kwargs: self.n_round_insns = kwargs["n_round_insns"] else: self.n_round_insns = 1000000 self.tracer_path = "/usr/bin/tracer" self.switch_pid = None
def __init__(self, name, config_file, log_file='/dev/null', inNamespace=True, parameters={}, **params): Switch.__init__(self, name, inNamespace=inNamespace, **params) self.config_file = config_file self.log_file = log_file self.params = parameters
def __init__(self, name, switch_path='softswitch', dpid=None, **kwargs): Switch.__init__(self, name, **kwargs) self.switch_path = switch_path if dpid: self.dpid = dpid eBPFSwitch.dpid = max(eBPFSwitch.dpid, dpid) else: self.dpid = eBPFSwitch.dpid eBPFSwitch.dpid += 1
def __init__(self, name, **kwargs): kwargs['inNamespace'] = True Switch.__init__(self, name, **kwargs) print "Switch %s %s" % (name, self.inNamespace) Routed.ID += 1 self.switch_id = Routed.ID self.kind = kwargs.get('kind') self.num_leafs = kwargs.get('num_leafs') self.num_spines = kwargs.get('num_spines') self.hosts_per_leaf = kwargs.get('hosts_per_leaf')
def __init__( self, name, sw_path = "dc_full", thrift_port = None, pcap_dump = False, verbose = False, **kwargs ): Switch.__init__( self, name, **kwargs ) self.sw_path = sw_path self.verbose = verbose logfile = '/tmp/p4ns.%s.log' % self.name self.output = open(logfile, 'w') self.thrift_port = thrift_port self.pcap_dump = pcap_dump
def __init__(self, name, json=None, debugger=False, loglevel="warn", elogger=False, grpcport=None, cpuport=255, thriftport=None, netcfg=True, dryrun=False, pipeconf="", pktdump=False, valgrind=False, gnmi=False, portcfg=True, onosdevid=None, **kwargs): Switch.__init__(self, name, **kwargs) self.grpcPort = pickUnusedPort() if not grpcport else grpcport self.thriftPort = pickUnusedPort() if not thriftport else thriftport self.cpuPort = cpuport self.json = json self.debugger = parseBoolean(debugger) self.loglevel = loglevel # Important: Mininet removes all /tmp/*.log files in case of exceptions. # We want to be able to see the bmv2 log if anything goes wrong, hence # avoid the .log extension. self.logfile = '/tmp/bmv2-%s-log' % self.name self.elogger = parseBoolean(elogger) self.pktdump = parseBoolean(pktdump) self.netcfg = parseBoolean(netcfg) self.dryrun = parseBoolean(dryrun) self.valgrind = parseBoolean(valgrind) self.netcfgfile = '/tmp/bmv2-%s-netcfg.json' % self.name self.pipeconfId = pipeconf self.injectPorts = parseBoolean(portcfg) self.withGnmi = parseBoolean(gnmi) self.longitude = kwargs['longitude'] if 'longitude' in kwargs else None self.latitude = kwargs['latitude'] if 'latitude' in kwargs else None if onosdevid is not None and len(onosdevid) > 0: self.onosDeviceId = onosdevid else: self.onosDeviceId = "device:bmv2:%s" % self.name self.logfd = None self.bmv2popen = None self.stopped = False # Remove files from previous executions self.cleanupTmpFiles() writeToFile("/tmp/bmv2-%s-grpc-port" % self.name, self.grpcPort) writeToFile("/tmp/bmv2-%s-thrift-port" % self.name, self.thriftPort)
def __init__(self, name, dpid=None, config_path=None, controller=None, **params): """Initialize this LINC-Switch. Most of the parameters will be passed on to the standard Mininet Link constructor, except for the LINC-specific attributes, such as config filepath. """ params['inNamespace'] = False Switch.__init__(self, name, dpid=dpid, **params) self.config_path = LINC_CONFIG if config_path is None else config_path self.controller = controller
def __init__(self, name, sw_path=None, json_path=None, log_file=None, thrift_port=None, pcap_dump=False, pcap_dir="", log_console=False, verbose=False, device_id=None, enable_debugger=False, sw_ip="10.0.1.254", **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.pcap_dir = pcap_dir self.verbose = verbose self.pcap_dump = pcap_dump self.enable_debugger = enable_debugger self.log_console = log_console self.log_file = log_file if self.log_file is None: self.log_file = "/tmp/p4s.{}.log".format(self.name) if self.log_console: self.output = open(self.log_file, 'w') self.thrift_port = thrift_port if check_listening_on_port(self.thrift_port): error( '%s cannot bind port %d because it is bound by another process\n' % (self.name, self.thrift_port)) exit(1) 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) self.simple_switch_pid = None self.sw_ip = sw_ip
def stop(self, deleteIntfs=True): """Terminate switch.""" self.stopped = True if self.bmv2popen is not None: if self.bmv2popen.poll() is None: self.bmv2popen.terminate() self.bmv2popen.wait() self.bmv2popen = None if self.logfd is not None: self.logfd.close() self.logfd = None Switch.stop(self, deleteIntfs)
def __init__( self, name, configPath=None, dp=None, **kwargs ): """Init. name: name for switch dp: netlink id (0, 1, 2, ...) defaultMAC: default MAC as unsigned int; random value if None""" Switch.__init__( self, name, **kwargs ) self.dp = 'dp%i' % dp self.intf = self.dp # Create a copy of the config for renaming if not configPath: configPath = os.path.join(os.getcwd(), "test.click") self.configPath = configPath + ".intf" shutil.copy(configPath, self.configPath)
def __init__(self, name, dpid=None, allowed=True, switchType='ROADM', topo=None, annotations={}, controller=None, **params): params[ 'inNamespace' ] = False Switch.__init__(self, name, dpid=dpid, **params) self.name = name self.annotations = annotations self.allowed = allowed self.switchType = switchType self.configDict = {} # dictionary that holds all of the JSON configuration data self.crossConnects = [] self.deletedCrossConnects = [] self.controller = controller self.lincId = self._get_linc_id() # use to communicate with LINC self.lincStarted = False
def __init__( self, name, sw_path = None, json_path = None, thrift_port = None, pcap_dump = False, verbose = False, **kwargs ): Switch.__init__( self, name, **kwargs ) assert(sw_path) assert(json_path) self.sw_path = sw_path self.json_path = json_path self.verbose = verbose logfile = '/tmp/bfns.%s.log' % self.name self.output = open(logfile, 'w') self.thrift_port = thrift_port self.pcap_dump = pcap_dump
def __init__(self, name, sw_path="dc_full", thrift_port=None, pcap_dump=False, verbose=False, **kwargs): Switch.__init__(self, name, **kwargs) self.sw_path = sw_path self.verbose = verbose logfile = '/tmp/p4ns.%s.log' % self.name self.output = open(logfile, 'w') self.thrift_port = thrift_port self.pcap_dump = pcap_dump
def __init__(self, name, **kwargs): """ :param name: :param kwargs: :return: """ Switch.__init__(self, name, **kwargs) # Check if 'pydatapath' is running. try: output = subprocess.check_output('netstat -lnp | grep ' + str(ProgSwitch.CTL_PORT), shell=True).strip() except: error( "*** error: 'pydatapath' is not running at " + ProgSwitch.CTL_ADDRESS + "::" + str(ProgSwitch.CTL_PORT) + "\n") exit(1)
def __init__( self, name, target_name = 'p4dockerswitch', thrift_port = None, sai_port = None, pcap_dump = False, verbose = False, start_program = '/p4factory/tools/start.sh', config_fs = None, **kwargs ): self.verbose = verbose self.pcap_dump = pcap_dump self.start_program = start_program self.config_fs = config_fs self.target_name = target_name self.thrift_port = thrift_port self.sai_port = sai_port Switch.__init__( self, name, **kwargs ) self.inNamespace = True
def __init__( self, name, config_path = None, # json_path = None, # thrift_port = None, # pcap_dump = False, # verbose = False, device_id = None, **kwargs ): Switch.__init__( self, name, **kwargs ) #self.parseConfig( config_path ) logfile = '/tmp/p4s.%s.log' % self.name self.output = open(logfile, 'w') 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-%d-log.ipc" % self.device_id
def __init__(self, name, json=None, debugger=False, loglevel="warn", elogger=False, grpcport=None, cpuport=255, notifications=False, thriftport=None, netcfg=True, dryrun=False, pipeconf="", pktdump=False, valgrind=False, gnmi=False, portcfg=True, onosdevid=None, **kwargs): Switch.__init__(self, name, **kwargs) self.grpcPort = grpcport self.thriftPort = thriftport self.cpuPort = cpuport self.json = json self.debugger = parseBoolean(debugger) self.notifications = parseBoolean(notifications) self.loglevel = loglevel # Important: Mininet removes all /tmp/*.log files in case of exceptions. # We want to be able to see the bmv2 log if anything goes wrong, hence # avoid the .log extension. self.logfile = '/tmp/bmv2-%s-log' % self.name self.elogger = parseBoolean(elogger) self.pktdump = parseBoolean(pktdump) self.netcfg = parseBoolean(netcfg) self.dryrun = parseBoolean(dryrun) self.valgrind = parseBoolean(valgrind) self.netcfgfile = '/tmp/bmv2-%s-netcfg.json' % self.name self.pipeconfId = pipeconf self.injectPorts = parseBoolean(portcfg) self.withGnmi = parseBoolean(gnmi) self.longitude = kwargs['longitude'] if 'longitude' in kwargs else None self.latitude = kwargs['latitude'] if 'latitude' in kwargs else None if onosdevid is not None and len(onosdevid) > 0: self.onosDeviceId = onosdevid else: self.onosDeviceId = "device:bmv2:%s" % self.name self.logfd = None self.bmv2popen = None self.stopped = False # Remove files from previous executions self.cleanupTmpFiles()
def __init__( self, name, sw_path = None, json_path = None, thrift_port = None, pcap_dump = False, verbose = False, device_id = None, **kwargs ): Switch.__init__( self, name, **kwargs ) assert(sw_path) assert(json_path) self.sw_path = sw_path self.json_path = json_path self.verbose = verbose logfile = '/tmp/p4s.%s.log' % self.name self.output = open(logfile, 'w') self.thrift_port = thrift_port self.pcap_dump = pcap_dump 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-%d-log.ipc" % self.device_id
def __init__(self, name, **kwargs): Switch.__init__(self, name, **kwargs) self.policy = ''
def __init__( self, name, dataPathOptions='--no-slicing', **kwargs ): Switch.__init__( self, name, **kwargs ) self.packetQueue = Queue() self.CustomSwitchLogger = self.get_logger("CustomSwitch")
def __init__(self, name, **kwargs): Switch.__init__(self, name, **kwargs)
def __init__(self, name, blocking=False, **params): Switch.__init__(self, name, **params) self.block = blocking
def __init__( self, name, control_flag=False, control_type="", address="127.0.0.1", port=6633, ports="", dpid=None, max_retry_delay=16, extra="", listenPort=None, **params): """Init. name: name for switch control_flag: spawn personal controller? control_type: personal controller type address: IP address to listen to (and personal controller address) port: TCP port to listen to (and personal controller port) ports: network interfaces to connect dpid: dpid for switch (or None to derive from name, e.g. s1 -> 1) max_retry_delay: max time between retries to connect to controller extra: extra parameters listenPort: port to listen on for dpctl connections params: Node parameters (see config() for details)""" Switch.__init__(self, name, dpid, listenPort=listenPort, **params) self.print_personal_debug = False print "iiiiiiiiiiiiiiiiiiii" ps = "Args: " ps += "\n name \t" + str(name) ps += "\n control_flag \t" + str(control_flag) ps += "\n control_type \t" + str(control_type) ps += "\n address \t" + str(address) ps += "\n port \t" + str(port) ps += "\n ports \t" + str(ports) ps += "\n dpid \t" + str(dpid) ps += "\n max_retry_delay\t" + str(max_retry_delay) ps += "\n extra \t" + str(extra) ps += "\n listenPort \t" + str(listenPort) ps += "\n params \t" + str(params) if self.print_personal_debug: print ps if 'POX_CORE_DIR' not in os.environ: #exit( 'exiting; please set missing POX_CORE_DIR env var' ) self.poxCoreDir = "/home/mininet/pox" else: self.poxCoreDir = os.environ[ 'POX_CORE_DIR' ] self.use_remote_controller = (not control_flag) self.controller_type = control_type self.controller_ip = address if address else "127.0.0.1" self.controller_port = int(port) if port else 6633 self.input_intf_ports = ports.split(";") if ports else [] self.max_retry_delay = max_retry_delay if max_retry_delay else 16 self.extra = format_pox_extra(extra).split(";") if extra else [] # NOTE: In case these are needed elsewhere... self.run_file = "" self.ctrl_args = "" self.cmd_args = "" self.cmd_log = "" self.cmd_tail = "" self.command = "" self.intf_ports = [] self.pox_pid = None # @GLY self.lastPid = None self.started_switch = False ps = "Input to POXSwitch.__init__(): " ps += "\n poxCoreDir \t" + str(self.poxCoreDir) ps += "\n switch_name \t" + str(self.name) ps += "\n use_remote_controller\t" + str(self.use_remote_controller) ps += "\n controller_type \t" + str(self.controller_type) ps += "\n controller_ip \t" + str(self.controller_ip) ps += "\n controller_port \t" + str(self.controller_port) ps += "\n input_intf_ports\t" + str(self.input_intf_ports) ps += "\n switch_dpid \t" + str(self.dpid) ps += "\n max_retry_delay \t" + str(self.max_retry_delay) ps += "\n extra_parameters\t" + str(self.extra) ps += "\n listenPort \t" + str(self.listenPort) if self.print_personal_debug: print ps
def popen( self, *args, **kwargs ): mncmd = [ 'docker', 'exec', "mininet-"+self.name ] return Switch.popen( self, *args, mncmd=mncmd, **kwargs )
def stop(self, deleteIntfs=True): """Terminate switch.""" self.stopped = True self.killBmv2(log=True) Switch.stop(self, deleteIntfs)