def __init__(self, config=None):
Thread.__init__(self)
# dict from port number to port object
self.ports = {}
# dict from port number to list of (timestamp, packet)
self.packet_queues = {}
# cvar serves double duty as a regular top level lock and
# as a condition variable
self.cvar = Condition()
# Used to wake up the event loop from another thread
self.waker = ofutils.EventDescriptor()
self.killed = False
self.logger = logging.getLogger("dataplane")
self.pcap_writer = None
if config is None:
self.config = {}
else:
self.config = config
############################################################
#
# The platform/config can provide a custom DataPlanePort class
# here if you have a custom implementation with different
# behavior.
#
# Set config.dataplane.portclass = MyDataPlanePortClass
# where MyDataPlanePortClass has the same interface as the class
# DataPlanePort defined here.
#
if "dataplane" in self.config and "portclass" in self.config[
"dataplane"]:
self.dppclass = self.config["dataplane"]["portclass"]
elif have_pypcap:
self.dppclass = DataPlanePortPcap
else:
self.logger.warning(
"Missing pypcap, VLAN tests may fail. See README for installation instructions."
)
self.dppclass = DataPlanePort
self.start()
def __init__(self, config=None):
Thread.__init__(self)
# dict from port number to port object
self.ports = {}
# dict from port number to list of (timestamp, packet)
self.packet_queues = {}
# cvar serves double duty as a regular top level lock and
# as a condition variable
self.cvar = Condition()
# Used to wake up the event loop from another thread
self.waker = ofutils.EventDescriptor()
self.killed = False
self.logger = logging.getLogger("ControlPlane")
self.pcap_writer = None
if config is None:
self.config = {}
else:
self.config = config;
############################################################
#
# The platform/config can provide a custom DataPlanePort class
# here if you have a custom implementation with different
# behavior.
#
# Set config.dataplane.portclass = MyDataPlanePortClass
# where MyDataPlanePortClass has the same interface as the class
# DataPlanePort defined here.
#
if "linux" in sys.platform:
self.dppclass = ControlPlanePortLinux
else:
self.dppclass = ControlPlanePortPcap
self.start()
def __init__(self,
switch=None,
host='127.0.0.1',
port=6653,
max_pkts=1024):
Thread.__init__(self)
# Socket related
self.rcv_size = RCV_SIZE_DEFAULT
self.listen_socket = None
self.switch_socket = None
self.switch_addr = None
self.connect_cv = Condition()
self.message_cv = Condition()
self.tx_lock = Lock()
# Used to wake up the event loop from another thread
self.waker = ofutils.EventDescriptor()
# Counters
self.socket_errors = 0
self.parse_errors = 0
self.packets_total = 0
self.packets_expired = 0
self.packets_handled = 0
self.poll_discards = 0
# State
self.sync = Lock()
self.handlers = {}
self.keep_alive = False
self.active = True
self.initial_hello = True
# OpenFlow message/packet queue
# Protected by the packets_cv lock / condition variable
self.packets = []
self.packets_cv = Condition()
self.packet_in_count = 0
# Settings
self.max_pkts = max_pkts
self.switch = switch
self.passive = not self.switch
self.host = host
self.port = port
self.dbg_state = "init"
self.logger = logging.getLogger("controller")
self.filter_packet_in = False # Drop "excessive" packet ins
self.pkt_in_run = 0 # Count on run of packet ins
self.pkt_in_filter_limit = 50 # Count on run of packet ins
self.pkt_in_dropped = 0 # Total dropped packet ins
self.transact_to = 15 # Transact timeout default value; add to config
# Transaction and message type waiting variables
# xid_cv: Condition variable (semaphore) for packet waiters
# xid: Transaction ID being waited on
# xid_response: Transaction response message
self.xid_cv = Condition()
self.xid = None
self.xid_response = None
self.buffered_input = ""
# Create listen socket
if self.passive:
self.logger.info("Create/listen at " + self.host + ":" +
str(self.port))
ai = socket.getaddrinfo(self.host, self.port, socket.AF_UNSPEC,
socket.SOCK_STREAM, 0, socket.AI_PASSIVE)
# Use first returned addrinfo
(family, socktype, proto, name, sockaddr) = ai[0]
self.listen_socket = socket.socket(family, socktype)
self.listen_socket.setsockopt(socket.SOL_SOCKET,
socket.SO_REUSEADDR, 1)
self.listen_socket.bind(sockaddr)
self.listen_socket.listen(LISTEN_QUEUE_SIZE)
def __init__(self, config=None):
Thread.__init__(self)
# dict from port number to port object
self.ports = {}
# dict from port number to list of (timestamp, packet)
self.packet_queues = {}
# cvar serves double duty as a regular top level lock and
# as a condition variable
self.cvar = Condition()
# Used to wake up the event loop from another thread
self.waker = ofutils.EventDescriptor()
self.killed = False
self.logger = logging.getLogger("dataplane")
self.pcap_writer = None
if config is None:
self.config = {}
else:
self.config = config;
############################################################
#
# The platform/config can provide a custom DataPlanePort class
# here if you have a custom implementation with different
# behavior.
#
# Set config.dataplane.portclass = MyDataPlanePortClass
# where MyDataPlanePortClass has the same interface as the class
# DataPlanePort defined here.
#
if "dataplane" in self.config and "portclass" in self.config["dataplane"]:
self.dppclass = self.config["dataplane"]["portclass"]
elif "tstc" in self.config["platform"]:
self.logger.info( "dataplane use stc adapter")
self.dppclass = DataPlanePortStc
elif "test" in self.config["platform"]:
self.logger.info( "dataplane use stc adapter")
self.dppclass = DataPlanePortTest
elif "linux" in sys.platform:
self.dppclass = DataPlanePortLinux
else:
self.dppclass = DataPlanePortPcap
if "tstc" in self.config["platform"]:
try:
self.stc = stc_proxy.STC(remoteRpcServerIp = self.config["stcSeriverIp"], port = self.config["stcServierPort"])
self.chassisIp = self.config["chassisIp"]
self.stc_version = self.stc.get("system1","-Version")
self.logger.info("Spirent test center version-%s" % self.stc_version)
log_filename_stc = time.strftime("remote_%Y_%m_%d_%H_%M_%S.log",time.localtime(time.time()))
cResult = self.stc.config("automationoptions -logTo \"" + "log/" + log_filename_stc + "\" -logLevel DEBUG")
self.logger.info("enable stc log to file . result %s ." % cResult)
cResult = self.stc.connect(self.chassisIp)
self.logger.info("connect to chassis . result %s ." % cResult)
self.project = []
self.ethPhy = []
prj = self.stc.create("project")
assert(prj != "")
self.project.append(prj)
except:
self.logger.error("Configure remote rpc server failed, Please check whether remote server is running")
raise
self.start()
def __init__(self,
switch_socket=None,
switch_addr=None,
dpid=None,
ip='127.0.0.1',
max_port=None,
max_pkts=1024):
Thread.__init__(self)
# feature related
if max_port == None:
self.max_port = 2
else:
self.max_port = max_port
self.dpid = dpid
self.ip = ip
self.port_desc = None
self.netconf = None
# Socket related
self.rcv_size = RCV_SIZE_DEFAULT
self.switch_socket = switch_socket
self.switch_addr = switch_addr
self.tx_lock = Lock()
# Used to wake up the event loop from another thread
self.waker = ofutils.EventDescriptor()
# Counters
self.socket_errors = 0
self.parse_errors = 0
self.packets_total = 0
self.packets_expired = 0
self.packets_handled = 0
self.poll_discards = 0
# State
self.sync = Lock()
self.handlers = {}
self.keep_alive = True
self.active = True
self.initial_hello = True
# OpenFlow message/packet queue
# Protected by the packets_cv lock / condition variable
self.packets = []
self.packets_cv = Condition()
self.packet_in_count = 0
# Settings
self.max_pkts = max_pkts
self.dbg_state = "init"
self.logger = logging.getLogger("device_agent")
# Transaction and message type waiting variables
# xid_cv: Condition variable (semaphore) for packet waiters
# xid: Transaction ID being waited on
# xid_response: Transaction response message
self.xid_cv = Condition()
self.xid = None
self.xid_response = None
self.buffered_input = ""
