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)