def __route_check(self, o):
"""Check route
@param o route check object (dictionary)
"""
gw = self.get_if_route(mif=o["mif"])
if gw == None:
o["tried"] += 1
if o["tried"] < MAX_RETRY:
rc = yapc.priv_callback(self, o)
self.server.post_event(rc, 1)
else:
no = self.switch.if_name2dpid_port_mac(o["if"])[1]
mc.set(nat.get_gw_key(no), gw)
output.info("Gateway of " + o["if"] + " is " + gw, self.__class__.__name__)
# Check for route
self.check_default_route()
# Register ip range
ipv4addr = self.ifmgr.ipv4_addr_n_mask(o["mif"])
if ipv4addr == None:
return
ipr = (
pu.ip_string2val(ipv4addr["addr"]),
pu.ip_string2val(ipv4addr["netmask"]),
pu.hex_str2array(self.ifmgr.ethernet_addr(o["mif"])),
)
mc.set(nat.get_ip_range_key(no), ipr)
output.info(
o["if"] + "(" + str(no) + ") has IP address %x and netmask %x" % (ipr[0], ipr[1]),
self.__class__.__name__,
)
# Call for ARP
rc = yapc.priv_callback(self, {"type": "arp", "tried": 0, "ip": gw, "if": o["mif"]})
self.server.post_event(rc, 0)
def dohandshake(self, msg):
"""Function to carry out handshake
Switch (hello) => hello + feature request
Switch (feature reply) => DONE
"""
if (msg.header.type == pyopenflow.OFPT_HELLO):
sendmsg = pyopenflow.ofp_hello()
self.send(sendmsg.pack())
sendmsg = pyopenflow.ofp_header()
sendmsg.type = pyopenflow.OFPT_FEATURES_REQUEST
self.send(sendmsg.pack())
elif (msg.header.type == pyopenflow.OFPT_FEATURES_REPLY):
switch_feature = pyopenflow.ofp_switch_features()
switch_feature.unpack(msg.message)
self.dpid = switch_feature.datapath_id
output.info("Connected to switch %x" % self.dpid,
self.__class__.__name__)
self.handshake = True
else:
output.warn("Handshake should not handle message type "+\
pyopenflow.ofp_type[msg.header.type],
self.__class__.__name__)
def __init__(self, server,
port=6633, host='', backlog=10, ofservermgr=None,
nagle=False):
"""Initialize
Bind core scheduler and receive thread
Install server connection into receive thread
"""
#Create server connection
self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server.bind((host, port))
output.info("Binding OpenFlow to "+str(host)+":"+str(port),
self.__class__.__name__)
self.server.listen(backlog)
#Create server manager
self.ofservermgr = ofservermgr
if (self.ofservermgr == None):
self.ofservermgr = ofserversocket(server, nagle)
#Bind
server.recv.addconnection(self.server, self.ofservermgr)
##Cleanup
server.register_cleanup(self)
##OpenFlow connections
self.connections = connections()
server.register_event_handler(message.name,
self)
server.register_event_handler(comm.event.name,
self)
def signalhandler(self, signal, frame):
"""Handle signal
"""
self.cleanup()
output.info("Exiting yapc...", self.__class__.__name__)
sys.exit(0)
def processevent(self, event):
output.info(event.message,
self.__class__.__name__)
output.info(str(event.address),
self.__class__.__name__)
if (event.message != "Acked"):
event.reply("Acked")
return True
def processevent(self, event):
"""Process OpenFlow message for switch status
@param event OpenFlow message event to process
@return True
"""
if isinstance(event, ofevents.features_reply):
# Maintain list of datapath socket
key = self.get_key(event.sock)
dpidsl = mc.get(dp_features.DP_SOCK_LIST)
if dpidsl == None:
dpidsl = []
if key not in dpidsl:
dpidsl.append(key)
mc.set(dp_features.DP_SOCK_LIST, dpidsl)
# Maintain dp features in memcache
mc.set(key, event.features)
elif isinstance(event, ofevents.port_status):
# Port status
if event.header.type == pyof.OFPT_PORT_STATUS:
key = self.get_key(event.sock)
sw = mc.get(key)
if sw == None:
output.warn("Port status from unknown datapath", self.__class__.__name__)
else:
output.dbg("Received port status:\n" + event.port.show("\t"), self.__class__.__name__)
if event.port.reason == pyof.OFPPR_DELETE or event.port.reason == pyof.OFPPR_MODIFY:
for p in sw.ports:
if p.port_no == event.port.desc.port_no:
sw.ports.remove(p)
if event.port.reason == pyof.OFPPR_ADD or event.port.reason == pyof.OFPPR_MODIFY:
sw.ports.append(event.port.desc)
output.dbg("Updated switch features:\n" + sw.show("\t"), self.__class__.__name__)
mc.set(key, sw)
elif isinstance(event, comm.event):
# Socket close
if event.event == comm.event.SOCK_CLOSE:
key = self.get_key(event.sock)
sw = mc.get(key)
if sw != None:
output.info("Datapath %x leaves" % sw.datapath_id, self.__class__.__name__)
# Maintain list of datapath socket
dpidsl = mc.get(dp_features.DP_SOCK_LIST)
if dpidsl != None:
if key in dpidsl:
dpidsl.remove(key)
mc.set(dp_features.DP_SOCK_LIST, dpidsl)
# Remove features
mc.delete(key)
return True
def processevent(self, event):
"""Event handler
@param event event to handle
@return false if flow can be installed, else true
"""
if (isinstance(event, ofevents.flow_removed)):
output.info("Received flow removed:\n"+event.flowrm.show("\t"),
self.__class__.__name__);
return True
def __arp_check(self, o):
"""Check ARP
@param o arp check object (dictionary)
"""
mac = self.get_ip_mac(o["ip"], self.loif.client_intf)
if mac == None:
o["tried"] += 1
if o["tried"] < MAX_RETRY:
rc = yapc.priv_callback(self, o)
self.server.post_event(rc, 1)
else:
mc.set(nat.get_gw_mac_key(o["ip"]), mac.mac)
output.info("ARP of " + o["ip"] + " is " + str(mac.mac), self.__class__.__name__)
def processevent(self, event):
"""Handle event
"""
if (isinstance(event, yapc.priv_callback)):
#Timer up
self.server.post_event(yapc.priv_callback(self, None),
self.period)
output.info("yapc sees "+str(self.count)+" OpenFlow messages in the last "+\
str(self.period)+" seconds",
self.__class__.__name__)
self.count = 0
elif (isinstance(event, ofcomm.message)):
self.count += 1
return True
def __init__(self, server, intf, extintf, ip):
"""Initialize
@param server reference to yapc core
@param intf name of interface to attach bump in the wire
@param extintf name of external interface to attach bump in the wire
@param ip list of destination IP to use (first being the primary one)
"""
pp.bitw.__init__(self, server, intf, extintf)
self.extintf = extintf
self.ip = []
for i in ip:
self.ip.append(pu.ip_string2binary(i))
self.__index = 0
output.info(
"Setting up flow splitter from " + extintf + " to " + intf + " for splitting flow among " + str(self.ip),
self.__class__.__name__,
)
def __init__(self, server, port,
host='', udpservermgr=None):
"""Initialize
Bind core scheduler and receive thread
Install server connection into receive thread
"""
#Create server connection
self.server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.server.bind((host, port))
output.info("Binding UDP to "+str(host)+":"+str(port),
self.__class__.__name__)
#Create server manager
self.udpservermgr = udpservermgr
if (self.udpservermgr == None):
self.udpservermgr = udpsocket(server)
server.recv.addconnection(self.server, self.udpservermgr)
##Cleanup
server.register_cleanup(self)
def __init__(self, server, file=SOCK_NAME, backlog=10, jsonservermgr=None, forcebind=True):
"""Initialize
* Install server connection into receive thread
* Register scheduler for processing message events
"""
# Reference to socket file
self.__file = file
# Create server connection
self.server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
try:
self.server.bind(file)
output.info("Binding to " + file, self.__class__.__name__)
except socket.error:
if forcebind:
os.remove(file)
self.server.bind(file)
output.warn("Force binding to " + file, self.__class__.__name__)
else:
raise
self.server.listen(backlog)
os.chmod(file, stat.S_IRWXO | stat.S_IRWXG | stat.S_IRWXU)
# Create server manager
self.jsonservermgr = jsonservermgr
if self.jsonservermgr == None:
self.jsonservermgr = jsonserversocket()
# Bind to scheduler
self.jsonservermgr.scheduler = server
server.recv.addconnection(self.server, self.jsonservermgr)
server.register_cleanup(self)
##OpenFlow connections
self.connections = connections()
server.register_event_handler(message.name, self)
server.register_event_handler(comm.event.name, self)
def set_ifconfig(self, msg):
"""Does manual ifconfig
"""
intf = msg["name"]
ip = msg["ipaddr"]
mask = msg["netmask"]
gw = msg["gwaddr"]
gwmac = msg["gwmac"]
no = self.switch.if_name2dpid_port_mac(intf)[1]
# Register gateway
mc.set(nat.get_gw_key(no), gw)
output.info("Gateway of " + intf + " is " + gw, self.__class__.__name__)
# Register ip range
ipr = (pu.ip_string2val(ip), pu.ip_string2val(mask), pu.hex_str2array(self.ifmgr.ethernet_addr(intf)))
mc.set(nat.get_ip_range_key(no), ipr)
output.info(
intf + "(" + str(no) + ") has IP address %x and netmask %x" % (ipr[0], ipr[1]), self.__class__.__name__
)
# Regsiter mac address
mc.set(nat.get_gw_mac_key(gw), gwmac)
output.info("ARP of " + gw + " is " + str(gwmac), self.__class__.__name__)
sock = jsoncomm.SOCK_NAME
for opt,arg in opts:
if (opt in ("-h","--help")):
usage()
sys.exit(0)
elif (opt in ("-v","--verbose")):
debug=True
elif (opt in ("-s","--sock")):
sock = arg
else:
print "Unhandled option :"+opt
sys.exit(2)
#Set output mode
if (debug):
output.set_mode("DBG")
else:
output.set_mode("INFO")
msg = {}
msg["type"] = "sqlite"
msg["command"] = "flush"
sock = jsoncomm.client(sock)
output.dbg("Sending "+simplejson.dumps(msg),"coin-client")
sock.sock.send(simplejson.dumps(msg))
output.info("Received "+simplejson.dumps(simplejson.loads(sock.recv(2048)),
indent=4))
sys.exit(0)