def create_ofg_server(port, recv_callback):
"""Starts a server which listens for OFG clients on the specified port.
@param port the port to listen on
@param recv_callback the function to call with received message content
(takes two arguments: transport, msg)
@return returns the new LTTwistedServer
"""
from ltprotocol.ltprotocol import LTTwistedServer
server = LTTwistedServer(OFG_PROTOCOL, recv_callback)
server.listen(port)
return server
def create_vns_server(port, recv_callback, new_conn_callback, lost_conn_callback, verbose=True):
"""Starts a server which listens for VNS clients on the specified port.
@param port the port to listen on
@param recv_callback the function to call with received message content
(takes two arguments: transport, msg)
@param new_conn_callback called with one argument (a LTProtocol) when a connection is started
@param lost_conn_callback called with one argument (a LTProtocol) when a connection is lost
@param verbose whether to print messages when they are sent
@return returns the new LTTwistedServer
"""
server = LTTwistedServer(VNS_PROTOCOL, recv_callback, new_conn_callback, lost_conn_callback, verbose)
server.listen(port)
return server
if len(sys.argv) < 2:
print >> sys.stderr, "usage: ./test_ltprotocol.py TYPE"
sys.exit(-1)
what = sys.argv[1]
if what != "client" and what != "server":
print >> sys.stderr, "TYPE must be client or server"
sys.exit(-1)
# periodically sends some messages
def periodic_send(proto):
if proto.connected:
print 'sending ...'
proto.send(NumMsg(200))
proto.send(StrMsg("hello world!"))
proto.send(NumMsg(7))
reactor.callLater(1, lambda : periodic_send(proto))
if what == "client":
client = LTTwistedClient(TEST_PROTOCOL,
lambda p, m : print_ltm('client', p, m))
client.connect('127.0.0.1', 9999)
else:
server = LTTwistedServer(TEST_PROTOCOL,
lambda p, m : print_ltm('server', p, m),
periodic_send,
print_disconnect)
server.listen(9999)
reactor.run()
def test():
def ip_to_dpid(ip):
ip_re = re.compile("(\d+)\.(\d+)\.(\d+)\.(\d+)")
ip_group = ip_re.search(ip)
if ip_group is not None:
dpid = long(0)
for i in range(1,5):
dpid = long(dpid)*256 + long(ip_group.group(i))
return dpid
return 0
def get_port(name):
return int(name[-1:])
def get_nbr_iface(nbr, check_disabled=True):
for r in rtrs:
if(r.getRouterID() == nbr.getNeighborID()):
for i in r.interfaces:
if((i.ip == nbr.getNeighborIP())):
if((not check_disabled) or i.isLinkUp()):
return get_port(i.name)
return (-1)
def get_host_nbr(rtr_ip):
for r in rtrs:
for i in r.interfaces:
if(i.ip == rtr_ip):
return (ip_to_dpid(r.routerID), get_port(i.name),)
return (-1, -1,)
def get_host_of_rtr(iface):
for h in hosts:
if (h.nbr == iface.ip):
return (ip_to_dpid(h.ip), 0,)
return (-1, -1,)
# simply print out all received messages
def print_ltm(xport, ltm):
if ltm is not None:
print 'recv: %s' % str(ltm)
t = ltm.get_type()
if t==LinksAdd.get_type() or t==LinksDel.get_type():
# got request to add/del a link: tell the GUI we've done so
xport.write(MPFR_PROTOCOL.pack_with_header(ltm))
def receive_ltm(xport, ltm):
if ltm is not None:
print 'recv: %s' % str(ltm)
t = ltm.get_type()
if t==LinksAdd.get_type() or t==LinksDel.get_type():
# got request to add/del a link: tell the GUI we've done so
xport.write(MPFR_PROTOCOL.pack_with_header(ltm))
elif t == SetMPFR.get_type():
if(ltm.get_subtype() == SetMPFR.TYPE_MP):
for r in rtrs:
r.setMultipath(ltm.val)
elif(ltm.get_subtype() == SetMPFR.TYPE_FR):
for r in rtrs:
r.setFastReroute(ltm.val)
from ltprotocol.ltprotocol import LTTwistedServer
def close_conn_callback(conn):
print "close_conn_callback: Connection closed\n"
while len(rtrs) > 0:
rtr = rtrs.pop()
print "Deleting router " + rtr.routerID
print str(len(rtrs)) + " routers left"
del(rtr)
def update_rtrs(conn):
print "Calling update_rtrs"
if(len(rtrs) == 0):
print "No routers left in the list - I'm done with this session"
return
print str(time.time())+ "\tUpdating the status of all routers"
for r in rtrs:
r.checkLinkStatus()
r.updateNeighbors()
r.getStats()
for r in rtrs:
print "Router :" + r.routerID
src_node = Node(Node.TYPE_OPENFLOW_SWITCH, ip_to_dpid(r.routerID))
del_links = []
add_linkspecs = []
del_flows = []
add_flows = []
for i in r.interfaces:
src_port = get_port(i.name)
old_nbrs = i.getOldNeighbors()
new_nbrs = i.getNeighbors()
#if neighbors have changed or link status has changed
if(i.haveChangedNeighbors() or i.hasChangedLinkStatus()):
#if there was an old nbr and active link, delete link and flow
if((len(old_nbrs) > 0) and i.wasLinkUp()):
dst_node = Node(Node.TYPE_OPENFLOW_SWITCH, ip_to_dpid(old_nbrs[0].getNeighborID()))
dst_port = get_nbr_iface(old_nbrs[0], False)
if(dst_port >= 0):
del_links.append(Link(Link.TYPE_WIRE, src_node, src_port, dst_node, dst_port))
# if there was a flow delete it
if(i.getOldStatsOUTChange()):
xput = int(i.getStatsChangeOUT()*8/(1000*POLL_INTERVAL))
del_flows.append(Flow(Flow.TYPE_UNKNOWN, ip_to_dpid(i.ip), xput, src_node, src_port, dst_node, dst_port, list()))
# if there is a new nbr and the link is up, add link and flow
if((len(new_nbrs) > 0) and i.isLinkUp()):
dst_node = Node(Node.TYPE_OPENFLOW_SWITCH, ip_to_dpid(new_nbrs[0].getNeighborID()))
dst_port = get_nbr_iface(new_nbrs[0])
if(dst_port >= 0):
add_linkspecs.append(LinkSpec(Link.TYPE_WIRE, src_node, src_port, dst_node, dst_port, GIGABIT))
(host_id, host_port) = get_host_of_rtr(i)
# if there is a flow going out add it
if(i.haveChangedStatsOUT()):
# if there is a flow to a router add it
if(len(new_nbrs) > 0):
dst_node = Node(Node.TYPE_OPENFLOW_SWITCH, ip_to_dpid(new_nbrs[0].getNeighborID()))
dst_port = get_nbr_iface(new_nbrs[0])
if(dst_port >= 0):
xput = int(i.getStatsChangeOUT()*8/(1000*POLL_INTERVAL))
add_flows.append(Flow(Flow.TYPE_UNKNOWN, ip_to_dpid(i.ip), xput, src_node, src_port, dst_node, dst_port, list()))
# if there is a flow to a host add it
elif(host_id > 0):
dst_node = Node(Node.TYPE_HOST, host_id)
dst_port = host_port
xput = int(i.getStatsChangeOUT()*8/(1000*POLL_INTERVAL))
add_flows.append(Flow(Flow.TYPE_UNKNOWN, ip_to_dpid(i.ip), xput, src_node, src_port, dst_node, dst_port, list()))
# else delete it
else:
# if there is no flow to a router delete it
if(len(old_nbrs) > 0):
dst_node = Node(Node.TYPE_OPENFLOW_SWITCH, ip_to_dpid(old_nbrs[0].getNeighborID()))
dst_port = get_nbr_iface(old_nbrs[0], False)
if(dst_port >= 0):
del_flows.append(Flow(Flow.TYPE_UNKNOWN, ip_to_dpid(i.ip), 0, src_node, src_port, dst_node, dst_port, list()))
# if there is no flow to a host delete it
elif(host_id > 0):
dst_node = Node(Node.TYPE_HOST, host_id)
dst_port = host_port
del_flows.append(Flow(Flow.TYPE_UNKNOWN, ip_to_dpid(i.ip), 0, src_node, src_port, dst_node, dst_port, list()))
if(host_id > 0):
host_node = Node(Node.TYPE_HOST, host_id)
# if there is a flow from a host add it
if(i.haveChangedStatsIN()):
xput = int(i.getStatsChangeIN()*8/(1000*POLL_INTERVAL))
add_flows.append(Flow(Flow.TYPE_UNKNOWN, host_id, xput, host_node, host_port, src_node, src_port, list()))
# else delete it
else:
del_flows.append(Flow(Flow.TYPE_UNKNOWN, host_id, 0, host_node, host_port, src_node, src_port, list()))
if(len(del_links) > 0):
server.send_msg_to_client(conn, LinksDel(del_links))
for link in del_links:
print "Deleting link: " + str(link.src_node.id) + ":" + str(link.src_port) + " -> " + str(link.dst_node.id) + ":" + str(link.dst_port)
if(len(add_linkspecs) > 0):
server.send_msg_to_client(conn, LinksAdd(add_linkspecs))
for link in add_linkspecs:
print "Adding link: " + str(link.src_node.id) + ":" + str(link.src_port) + " -> " + str(link.dst_node.id) + ":" + str(link.dst_port)
if(len(del_flows) > 0):
server.send_msg_to_client(conn, FlowsDel(del_flows))
for flow in del_flows:
print "Deleting flow " + str(flow.flow_id) + ": " + str(flow.src_node.id) + ":" + str(flow.src_port) + " -> " + str(flow.dst_node.id) + ":" + str(flow.dst_port)
if(len(add_flows) > 0):
server.send_msg_to_client(conn, FlowsAdd(add_flows))
for flow in add_flows:
print "Adding flow " + str(flow.flow_id) + ": " + str(flow.src_node.id) + ":" + str(flow.src_port) + " -> " + str(flow.dst_node.id) + ":" + str(flow.dst_port)
reactor.callLater(POLL_INTERVAL, lambda: update_rtrs(conn))
return
# when the gui connects, tell it about the modules and nodes
def new_conn_callback(conn):
# read in router information
try:
f = open('routers.txt', 'r')
except IOError:
print "Could not open routers.txt for reading!"
return
lines = f.readlines()
f.close()
rtr_re = re.compile("(\S+)\s+(\d+)")
for line in lines:
res = rtr_re.search(line)
if res is not None:
rtr = Router(res.group(1), res.group(2))
print "Parsed router " + res.group(1) + ":" + res.group(2) + ", dpid " + str(ip_to_dpid(rtr.routerID))
if rtr is not None:
rtrs.append(rtr)
# Get updates the first time (do it 2 times! to get flow info)
for r in rtrs:
print "Updating router " + r.routerID
r.checkLinkStatus()
r.updateNeighbors()
r.getStats()
time.sleep(2)
for r in rtrs:
r.checkLinkStatus()
r.updateNeighbors()
r.getStats()
#draw the router nodes first
nodes = []
for r in rtrs:
print "Drawing router " + r.routerID
nodes.append(Node(Node.TYPE_OPENFLOW_SWITCH, ip_to_dpid(r.routerID)))
if(len(nodes) > 0):
server.send_msg_to_client(conn, NodesAdd(nodes))
# read in host information
# draw hosts and links
try:
f = open('hosts.txt', 'r')
except IOError:
print "Could not open hosts.txt for reading!"
return
lines = f.readlines()
f.close()
hosts_list = []
host_linkspecs = []
host_re = re.compile("(\d+\.\d+\.\d+\.\d+)\s+(\d+\.\d+\.\d+\.\d+)")
for line in lines:
res = host_re.search(line)
if res is not None:
host_ip = res.group(1)
src_node = Node(Node.TYPE_HOST, ip_to_dpid(host_ip))
src_port = 0
rtr_ip = res.group(2)
hosts.append(Host(host_ip, rtr_ip))
print "Drawing node and flows for host " + host_ip
(dst_dpid, dst_port) = get_host_nbr(rtr_ip)
if(dst_dpid > 0 and dst_port >= 0):
host_linkspecs.append(LinkSpec(Link.TYPE_WIRE, src_node, src_port, Node(Node.TYPE_OPENFLOW_SWITCH, dst_dpid), dst_port, GIGABIT))
host_linkspecs.append(LinkSpec(Link.TYPE_WIRE, Node(Node.TYPE_OPENFLOW_SWITCH, dst_dpid), dst_port, src_node, src_port, GIGABIT))
print host_ip + ":" + str(src_port) + " -> " + rtr_ip + ":" + str(dst_port)
print rtr_ip + ":" + str(dst_port) + " -> " + host_ip + ":" + str(src_port)
if(len(hosts) > 0):
for h in hosts:
hosts_list.append(Node(Node.TYPE_HOST, ip_to_dpid(h.ip)))
server.send_msg_to_client(conn, NodesAdd(hosts_list))
if(len(host_linkspecs) > 0):
server.send_msg_to_client(conn, LinksAdd(host_linkspecs))
#draw the router links
for r in rtrs:
print "Drawing links and flows for router " + r.routerID
linkspecs = []
flows = []
src_node = Node(Node.TYPE_OPENFLOW_SWITCH, ip_to_dpid(r.routerID))
for i in r.interfaces:
print "\tInterface : " + i.name
if(i.isLinkUp() and (len(i.neighbors) > 0)):
print "\t\tLink is up : neighbor " + i.neighbors[0].getNeighborID()
src_port = get_port(i.name)
dst_node = Node(Node.TYPE_OPENFLOW_SWITCH, ip_to_dpid(i.neighbors[0].getNeighborID()))
dst_port = get_nbr_iface(i.neighbors[0])
print "\t\tdst_port = " + str(dst_port)
if(dst_port >= 0):
print r.routerID + ":" + str(src_port) + " -> " + i.neighbors[0].getNeighborID() + ":" + str(dst_port)
linkspecs.append(LinkSpec(Link.TYPE_WIRE, src_node, src_port, dst_node, dst_port, GIGABIT))
if(i.haveChangedStatsOUT()):
xput = int(i.getStatsChangeOUT()*8/(1000*POLL_INTERVAL))
flow = Flow(Flow.TYPE_UNKNOWN, ip_to_dpid(i.ip), xput, src_node, src_port, dst_node, dst_port, list())
flows.append(flow)
print "Adding flow " + str(flow.flow_id) + ": " + str(flow.src_node.id) + ":" + str(flow.src_port) + " -> " + str(flow.dst_node.id) + ":" + str(flow.dst_port)
if(len(linkspecs) > 0):
server.send_msg_to_client(conn, LinksAdd(linkspecs))
if(len(flows) > 0):
server.send_msg_to_client(conn, FlowsAdd(flows))
#thread.start_new_thread(update_rtrs, (conn,))
reactor.callLater(0, lambda: update_rtrs(conn))
#server = LTTwistedServer(MPFR_PROTOCOL, print_ltm, new_conn_callback, close_conn_callback)
server = LTTwistedServer(MPFR_PROTOCOL, receive_ltm, new_conn_callback, close_conn_callback)
server.listen(OFG_DEFAULT_PORT)
reactor.run()
