def __init__(self, controller='localhost', port=6633):
self.controller = controller
self.port = port
self.received_packet_count = 0
self.topology_real = StanfordTopo()
self.topology_discovered = StanfordTopo()
self.pinpointer = Pinpointer()
# Content: String!
self.queue_GUI_to_OF = Queue.Queue()
# Contnet: OF message!
self.queue_OF_to_GUI = Queue.Queue()
self.running = True
# Thread 1: OF thread
self.thread1 = threading.Thread(target=self.connectToController)
#self.thread1.start()
# Thread 2: Connect to run pinpointer
self.errors = []
self.test_packets = []
self.queue_pinpoint_to_GUI = Queue.Queue()
self.thread2 = None
# Thread 3: WebServer
DemoHTTPHandler.do_inject_external = self.do_inject
DemoHTTPHandler.do_reset_external = self.do_reset
DemoHTTPHandler.do_detect_external = self.do_detect
self.httpd = TCPServer(("", 8000), DemoHTTPHandler)
self.thread3 = threading.Thread(target=self.httpd.serve_forever)
self.thread3.start()
self.draw_callback(None)
def inject_errors(self, error_rules):
# error_rules is a set of error rule ids
p = Pinpointer()
for rule in error_rules:
tokens = rule.split("_")
if rule not in self.switch_name_to_errors["_".join(tokens[0:2])]:
self.switch_name_to_errors["_".join(tokens[0:2])].extend(p.get_config_lines(rule))
def __init__(self, controller='localhost', port=6633):
self.controller = controller
self.port = port
self.received_packet_count = 0
self.topology_real = StanfordTopo()
self.topology_discovered = StanfordTopo()
self.pinpointer = Pinpointer()
# Content: String!
self.queue_GUI_to_OF = Queue.Queue()
# Contnet: OF message!
self.queue_OF_to_GUI = Queue.Queue()
# Set up the thread to do asynchronous I/O
# For GTK,
# http://faq.pygtk.org/index.py?req=show&file=faq20.006.htp
gobject.threads_init()
self.running = True
self.thread1 = threading.Thread(target=self.connectToController)
self.thread1.start()
# Thread to run pinpointer
self.queue_pinpoint_to_GUI = Queue.Queue()
self.thread2 = None
# Show GUI
self.createWidgets()
# Start the periodic call in the GUI to check if the queue contains
# anything
gobject.timeout_add(100, self.processOF)
gobject.timeout_add(100, self.processError)
def inject_errors(self, error_rules):
# error_rules is a set of error rule ids
p = Pinpointer()
for rule in error_rules:
tokens = rule.split("_")
if rule not in self.switch_name_to_errors["_".join(tokens[0:2])]:
self.switch_name_to_errors["_".join(tokens[0:2])].extend(
p.get_config_lines(rule))
def remove_errors(self, error_rules):
p = Pinpointer()
for rule in error_rules:
tokens = rule.split("_")
lines = p.get_config_lines(rule)
for line in lines:
try:
self.switch_name_to_errors["_".join(tokens[0:2])].remove(line)
except:
pass
def remove_errors(self, error_rules):
p = Pinpointer()
for rule in error_rules:
tokens = rule.split("_")
lines = p.get_config_lines(rule)
for line in lines:
try:
self.switch_name_to_errors["_".join(
tokens[0:2])].remove(line)
except:
pass
def __init__(self, controller='localhost', port=6633):
self.controller = controller
self.port = port
self.received_packet_count = 0
self.topology_real = StanfordTopo()
self.topology_discovered = StanfordTopo()
self.pinpointer = Pinpointer()
# Content: String!
self.queue_GUI_to_OF = Queue.Queue()
# Contnet: OF message!
self.queue_OF_to_GUI = Queue.Queue()
# Set up the thread to do asynchronous I/O
# For GTK,
# http://faq.pygtk.org/index.py?req=show&file=faq20.006.htp
gobject.threads_init()
self.running = True
self.thread1 = threading.Thread(target=self.connectToController)
self.thread1.start()
# Thread to run pinpointer
self.queue_pinpoint_to_GUI = Queue.Queue()
self.thread2 = None
# Show GUI
self.createWidgets()
# Start the periodic call in the GUI to check if the queue contains
# anything
gobject.timeout_add(100, self.processOF)
gobject.timeout_add(100, self.processError)
def __init__(self, controller='localhost', port=6633):
self.controller = controller
self.port = port
self.received_packet_count = 0
self.topology_real = StanfordTopo()
self.topology_discovered = StanfordTopo()
self.pinpointer = Pinpointer()
# Content: String!
self.queue_GUI_to_OF = Queue.Queue()
# Contnet: OF message!
self.queue_OF_to_GUI = Queue.Queue()
self.running = True
# Thread 1: OF thread
self.thread1 = threading.Thread(target=self.connectToController)
#self.thread1.start()
# Thread 2: Connect to run pinpointer
self.errors = []
self.test_packets = []
self.queue_pinpoint_to_GUI = Queue.Queue()
self.thread2 = None
# Thread 3: WebServer
DemoHTTPHandler.do_inject_external = self.do_inject
DemoHTTPHandler.do_reset_external = self.do_reset
DemoHTTPHandler.do_detect_external = self.do_detect
self.httpd = TCPServer(("", 8000), DemoHTTPHandler)
self.thread3 = threading.Thread(target=self.httpd.serve_forever)
self.thread3.start()
self.draw_callback(None)
class Application:
CONTROLLER_DPID = 0xCAFECAFE
def main(self):
# Start the periodic call in the GUI to check if the queue contains
# anything
try:
while True:
self.processOF()
self.processError()
time.sleep(1)
except KeyboardInterrupt:
# Stop Thread 1
self.running = False
# Stop Thread 3
self.httpd.shutdown()
return -1
def __init__(self, controller='localhost', port=6633):
self.controller = controller
self.port = port
self.received_packet_count = 0
self.topology_real = StanfordTopo()
self.topology_discovered = StanfordTopo()
self.pinpointer = Pinpointer()
# Content: String!
self.queue_GUI_to_OF = Queue.Queue()
# Contnet: OF message!
self.queue_OF_to_GUI = Queue.Queue()
self.running = True
# Thread 1: OF thread
self.thread1 = threading.Thread(target=self.connectToController)
#self.thread1.start()
# Thread 2: Connect to run pinpointer
self.errors = []
self.test_packets = []
self.queue_pinpoint_to_GUI = Queue.Queue()
self.thread2 = None
# Thread 3: WebServer
DemoHTTPHandler.do_inject_external = self.do_inject
DemoHTTPHandler.do_reset_external = self.do_reset
DemoHTTPHandler.do_detect_external = self.do_detect
self.httpd = TCPServer(("", 8000), DemoHTTPHandler)
self.thread3 = threading.Thread(target=self.httpd.serve_forever)
self.thread3.start()
self.draw_callback(None)
def do_inject(self):
self.inject_callback(None)
def do_reset(self):
self.topology_real.clear_errors()
self.topology_discovered.clear_errors()
self.topology_real.dump_json("web/data/data.json")
self.topology_discovered.dump_json("web/data/dataDiscovered.json")
def do_detect(self):
if self.errors != []:
self.thread2 = threading.Thread(target=self.pinpoint,
args=(self.test_packets,
self.errors))
self.thread2.start()
self.errors = []
else:
# Touch!
self.topology_discovered.dump_json("web/data/dataDiscovered.json")
def submit_callback(self, widget, entry):
packet = entry.get_text()
self.send_packet(packet)
def draw_callback(self, widget):
self.topology_real.dump_json("web/data/data.json")
self.topology_discovered.dump_json("web/data/dataDiscovered.json")
def inject_callback(self, widget):
self.topology_real.clear_errors()
self.topology_discovered.clear_errors()
test_packets, errors = self.pinpointer.generate_test_case(1)
self.errors = errors
self.test_packets = test_packets
link_errors = []
device_errors = []
for error in errors:
if error.startswith("_"):
link_errors.append(error)
else:
device_errors.append(error)
self.topology_real.inject_errors(device_errors)
self.topology_real.inject_link_errors(link_errors)
self.topology_real.dump_json("web/data/data.json")
#self.thread2 = threading.Thread(target=self.pinpoint, args=(test_packets, errors))
#self.thread2.start()
def send_packet(self, packet="Hello, World!\n"):
self.queue_GUI_to_OF.put(packet)
def processOF(self):
while not self.queue_OF_to_GUI.empty():
msg = self.queue_OF_to_GUI.get()
self.msgCallback(msg)
if not self.running:
sys.exit(1)
return True
def processError(self):
if self.queue_pinpoint_to_GUI.empty():
return True
link_errors = []
device_errors = []
errors = self.queue_pinpoint_to_GUI.get()
for error in errors:
if error.startswith("_"):
link_errors.append(error)
else:
device_errors.append(error)
self.topology_discovered.inject_errors(device_errors)
self.topology_discovered.inject_link_errors(link_errors)
self.topology_discovered.dump_json("web/data/dataDiscovered.json")
return True
def connectToController(self):
#Connect to controller
ofmsg = openflow.messages()
ofparser = of_msg.parser(ofmsg)
ofsw = of_simu.switch(ofmsg,
self.controller,
self.port,
dpid=self.CONTROLLER_DPID,
parser=ofparser)
ofsw.send_hello()
while self.running:
msg = ofsw.connection.msgreceive(blocking=False)
# OF to GUI
if msg != None:
ofsw.receive_openflow(msg)
self.queue_OF_to_GUI.put(msg)
# GUI to OF
while not self.queue_GUI_to_OF.empty():
packet = self.queue_GUI_to_OF.get()
ofsw.send_packet(inport=0, packet=packet)
time.sleep(0.1)
def pinpoint(self, test_packets, errors):
errors = self.pinpointer.pin_point_test(test_packets, errors)
print "F**k!!"
self.queue_pinpoint_to_GUI.put(errors)
class Application:
CONTROLLER_DPID = 0xCAFECAFE
def main(self):
gtk.main()
def __init__(self, controller='localhost', port=6633):
self.controller = controller
self.port = port
self.received_packet_count = 0
self.topology_real = StanfordTopo()
self.topology_discovered = StanfordTopo()
self.pinpointer = Pinpointer()
# Content: String!
self.queue_GUI_to_OF = Queue.Queue()
# Contnet: OF message!
self.queue_OF_to_GUI = Queue.Queue()
# Set up the thread to do asynchronous I/O
# For GTK,
# http://faq.pygtk.org/index.py?req=show&file=faq20.006.htp
gobject.threads_init()
self.running = True
self.thread1 = threading.Thread(target=self.connectToController)
self.thread1.start()
# Thread to run pinpointer
self.queue_pinpoint_to_GUI = Queue.Queue()
self.thread2 = None
# Show GUI
self.createWidgets()
# Start the periodic call in the GUI to check if the queue contains
# anything
gobject.timeout_add(100, self.processOF)
gobject.timeout_add(100, self.processError)
def createWidgets(self):
#Set the Glade file
filename = "./gui/gui.glade"
builder = gtk.Builder()
builder.add_from_file(filename)
self.statusbar = builder.get_object("statusbar")
window = builder.get_object("mainWindow")
builder.connect_signals(self)
box = builder.get_object("topologyBox")
self.browser = webkit.WebView()
canvas = gtk.ScrolledWindow()
canvas.add(self.browser)
# Pack topology into the box
box.pack_start(canvas, True, True, 0)
box = builder.get_object("topologyBoxDiscovered")
builder.connect_signals(self)
self.browserDiscovered = webkit.WebView()
canvas = gtk.ScrolledWindow()
canvas.add(self.browserDiscovered)
# Pack topology into the box
box.pack_start(canvas, True, True, 0)
self.draw_callback(None)
button = builder.get_object("submit")
button.connect("clicked", self.submit_callback, builder.get_object("entry_input"))
button = builder.get_object("refresh")
button.connect("clicked", self.draw_callback)
button = builder.get_object("inject")
button.connect("clicked", self.inject_callback)
window.show_all()
def submit_callback(self, widget, entry):
packet = entry.get_text()
self.send_packet(packet)
def inject_callback(self, widget):
self.topology_real.clear_errors()
self.topology_discovered.clear_errors()
test_packets, errors = self.pinpointer.generate_test_case(1)
link_errors = []
device_errors = []
for error in errors:
if error.startswith("_"):
link_errors.append(error)
else:
device_errors.append(error)
self.topology_real.inject_errors(device_errors)
self.topology_real.inject_link_errors(link_errors)
self.topology_real.dump_json("web/data/data.json")
#self.browser.reload()
self.thread2 = threading.Thread(target=self.pinpoint, args=(test_packets, errors))
self.thread2.start()
def draw_callback(self, widget):
self.topology_real.dump_json("web/data/data.json")
self.browser.open("http://localhost:80/web/topology.html")
self.topology_discovered.dump_json("web/data/dataDiscovered.json")
self.browserDiscovered.open("http://localhost:80/web/topologyDiscovered.html")
def send_packet(self, packet="Hello, World!\n"):
self.queue_GUI_to_OF.put(packet)
def msgCallback(self, msg):
context_id = self.statusbar.get_context_id("Eastzone")
self.received_packet_count += 1
self.statusbar.pop(context_id)
self.statusbar.push(context_id, "%d packets received from the controller" % self.received_packet_count)
def destroy(self, widget):
self.running = False
def delete_event(self, widget, event, data=None):
self.running = False
gtk.main_quit()
return False
def processOF(self):
while not self.queue_OF_to_GUI.empty():
msg = self.queue_OF_to_GUI.get()
self.msgCallback(msg)
if not self.running:
sys.exit(1)
return True
def processError(self):
if self.queue_pinpoint_to_GUI.empty():
return True
link_errors = []
device_errors = []
errors = self.queue_pinpoint_to_GUI.get()
for error in errors:
if error.startswith("_"):
link_errors.append(error)
else:
device_errors.append(error)
self.topology_discovered.inject_errors(device_errors)
self.topology_discovered.inject_link_errors(link_errors)
self.topology_discovered.dump_json("web/data/dataDiscovered.json")
#self.browserDiscovered.reload()
return True
def connectToController(self):
#Connect to controller
ofmsg = openflow.messages()
ofparser = of_msg.parser(ofmsg)
ofsw = of_simu.switch(ofmsg, self.controller, self.port,
dpid=self.CONTROLLER_DPID,
parser=ofparser)
ofsw.send_hello()
while self.running:
msg = ofsw.connection.msgreceive(blocking=False)
# OF to GUI
if msg != None:
ofsw.receive_openflow(msg)
self.queue_OF_to_GUI.put(msg)
# GUI to OF
while not self.queue_GUI_to_OF.empty():
packet = self.queue_GUI_to_OF.get()
ofsw.send_packet(inport=0, packet=packet)
time.sleep(0.1)
def pinpoint(self, test_packets, errors):
errors = self.pinpointer.pin_point_test ( test_packets, errors )
self.queue_pinpoint_to_GUI.put(errors)
class Application:
CONTROLLER_DPID = 0xCAFECAFE
def main(self):
# Start the periodic call in the GUI to check if the queue contains
# anything
try:
while True:
self.processOF()
self.processError()
time.sleep(1)
except KeyboardInterrupt:
# Stop Thread 1
self.running = False
# Stop Thread 3
self.httpd.shutdown()
return -1
def __init__(self, controller='localhost', port=6633):
self.controller = controller
self.port = port
self.received_packet_count = 0
self.topology_real = StanfordTopo()
self.topology_discovered = StanfordTopo()
self.pinpointer = Pinpointer()
# Content: String!
self.queue_GUI_to_OF = Queue.Queue()
# Contnet: OF message!
self.queue_OF_to_GUI = Queue.Queue()
self.running = True
# Thread 1: OF thread
self.thread1 = threading.Thread(target=self.connectToController)
#self.thread1.start()
# Thread 2: Connect to run pinpointer
self.errors = []
self.test_packets = []
self.queue_pinpoint_to_GUI = Queue.Queue()
self.thread2 = None
# Thread 3: WebServer
DemoHTTPHandler.do_inject_external = self.do_inject
DemoHTTPHandler.do_reset_external = self.do_reset
DemoHTTPHandler.do_detect_external = self.do_detect
self.httpd = TCPServer(("", 8000), DemoHTTPHandler)
self.thread3 = threading.Thread(target=self.httpd.serve_forever)
self.thread3.start()
self.draw_callback(None)
def do_inject(self):
self.inject_callback(None)
def do_reset(self):
self.topology_real.clear_errors()
self.topology_discovered.clear_errors()
self.topology_real.dump_json("web/data/data.json")
self.topology_discovered.dump_json("web/data/dataDiscovered.json")
def do_detect(self):
if self.errors != []:
self.thread2 = threading.Thread(target=self.pinpoint, args=(self.test_packets, self.errors))
self.thread2.start()
self.errors = []
else:
# Touch!
self.topology_discovered.dump_json("web/data/dataDiscovered.json")
def submit_callback(self, widget, entry):
packet = entry.get_text()
self.send_packet(packet)
def draw_callback(self, widget):
self.topology_real.dump_json("web/data/data.json")
self.topology_discovered.dump_json("web/data/dataDiscovered.json")
def inject_callback(self, widget):
self.topology_real.clear_errors()
self.topology_discovered.clear_errors()
test_packets, errors = self.pinpointer.generate_test_case(1)
self.errors = errors
self.test_packets = test_packets
link_errors = []
device_errors = []
for error in errors:
if error.startswith("_"):
link_errors.append(error)
else:
device_errors.append(error)
self.topology_real.inject_errors(device_errors)
self.topology_real.inject_link_errors(link_errors)
self.topology_real.dump_json("web/data/data.json")
#self.thread2 = threading.Thread(target=self.pinpoint, args=(test_packets, errors))
#self.thread2.start()
def send_packet(self, packet="Hello, World!\n"):
self.queue_GUI_to_OF.put(packet)
def processOF(self):
while not self.queue_OF_to_GUI.empty():
msg = self.queue_OF_to_GUI.get()
self.msgCallback(msg)
if not self.running:
sys.exit(1)
return True
def processError(self):
if self.queue_pinpoint_to_GUI.empty():
return True
link_errors = []
device_errors = []
errors = self.queue_pinpoint_to_GUI.get()
for error in errors:
if error.startswith("_"):
link_errors.append(error)
else:
device_errors.append(error)
self.topology_discovered.inject_errors(device_errors)
self.topology_discovered.inject_link_errors(link_errors)
self.topology_discovered.dump_json("web/data/dataDiscovered.json")
return True
def connectToController(self):
#Connect to controller
ofmsg = openflow.messages()
ofparser = of_msg.parser(ofmsg)
ofsw = of_simu.switch(ofmsg, self.controller, self.port,
dpid=self.CONTROLLER_DPID,
parser=ofparser)
ofsw.send_hello()
while self.running:
msg = ofsw.connection.msgreceive(blocking=False)
# OF to GUI
if msg != None:
ofsw.receive_openflow(msg)
self.queue_OF_to_GUI.put(msg)
# GUI to OF
while not self.queue_GUI_to_OF.empty():
packet = self.queue_GUI_to_OF.get()
ofsw.send_packet(inport=0, packet=packet)
time.sleep(0.1)
def pinpoint(self, test_packets, errors):
errors = self.pinpointer.pin_point_test ( test_packets, errors )
print "F**k!!"
self.queue_pinpoint_to_GUI.put(errors)
class Application:
CONTROLLER_DPID = 0xCAFECAFE
def main(self):
gtk.main()
def __init__(self, controller='localhost', port=6633):
self.controller = controller
self.port = port
self.received_packet_count = 0
self.topology_real = StanfordTopo()
self.topology_discovered = StanfordTopo()
self.pinpointer = Pinpointer()
# Content: String!
self.queue_GUI_to_OF = Queue.Queue()
# Contnet: OF message!
self.queue_OF_to_GUI = Queue.Queue()
# Set up the thread to do asynchronous I/O
# For GTK,
# http://faq.pygtk.org/index.py?req=show&file=faq20.006.htp
gobject.threads_init()
self.running = True
self.thread1 = threading.Thread(target=self.connectToController)
self.thread1.start()
# Thread to run pinpointer
self.queue_pinpoint_to_GUI = Queue.Queue()
self.thread2 = None
# Show GUI
self.createWidgets()
# Start the periodic call in the GUI to check if the queue contains
# anything
gobject.timeout_add(100, self.processOF)
gobject.timeout_add(100, self.processError)
def createWidgets(self):
#Set the Glade file
filename = "./gui/gui.glade"
builder = gtk.Builder()
builder.add_from_file(filename)
self.statusbar = builder.get_object("statusbar")
window = builder.get_object("mainWindow")
builder.connect_signals(self)
box = builder.get_object("topologyBox")
self.browser = webkit.WebView()
canvas = gtk.ScrolledWindow()
canvas.add(self.browser)
# Pack topology into the box
box.pack_start(canvas, True, True, 0)
box = builder.get_object("topologyBoxDiscovered")
builder.connect_signals(self)
self.browserDiscovered = webkit.WebView()
canvas = gtk.ScrolledWindow()
canvas.add(self.browserDiscovered)
# Pack topology into the box
box.pack_start(canvas, True, True, 0)
self.draw_callback(None)
button = builder.get_object("submit")
button.connect("clicked", self.submit_callback,
builder.get_object("entry_input"))
button = builder.get_object("refresh")
button.connect("clicked", self.draw_callback)
button = builder.get_object("inject")
button.connect("clicked", self.inject_callback)
window.show_all()
def submit_callback(self, widget, entry):
packet = entry.get_text()
self.send_packet(packet)
def inject_callback(self, widget):
self.topology_real.clear_errors()
self.topology_discovered.clear_errors()
test_packets, errors = self.pinpointer.generate_test_case(1)
link_errors = []
device_errors = []
for error in errors:
if error.startswith("_"):
link_errors.append(error)
else:
device_errors.append(error)
self.topology_real.inject_errors(device_errors)
self.topology_real.inject_link_errors(link_errors)
self.topology_real.dump_json("web/data/data.json")
#self.browser.reload()
self.thread2 = threading.Thread(target=self.pinpoint,
args=(test_packets, errors))
self.thread2.start()
def draw_callback(self, widget):
self.topology_real.dump_json("web/data/data.json")
self.browser.open("http://localhost:80/web/topology.html")
self.topology_discovered.dump_json("web/data/dataDiscovered.json")
self.browserDiscovered.open(
"http://localhost:80/web/topologyDiscovered.html")
def send_packet(self, packet="Hello, World!\n"):
self.queue_GUI_to_OF.put(packet)
def msgCallback(self, msg):
context_id = self.statusbar.get_context_id("Eastzone")
self.received_packet_count += 1
self.statusbar.pop(context_id)
self.statusbar.push(
context_id, "%d packets received from the controller" %
self.received_packet_count)
def destroy(self, widget):
self.running = False
def delete_event(self, widget, event, data=None):
self.running = False
gtk.main_quit()
return False
def processOF(self):
while not self.queue_OF_to_GUI.empty():
msg = self.queue_OF_to_GUI.get()
self.msgCallback(msg)
if not self.running:
sys.exit(1)
return True
def processError(self):
if self.queue_pinpoint_to_GUI.empty():
return True
link_errors = []
device_errors = []
errors = self.queue_pinpoint_to_GUI.get()
for error in errors:
if error.startswith("_"):
link_errors.append(error)
else:
device_errors.append(error)
self.topology_discovered.inject_errors(device_errors)
self.topology_discovered.inject_link_errors(link_errors)
self.topology_discovered.dump_json("web/data/dataDiscovered.json")
#self.browserDiscovered.reload()
return True
def connectToController(self):
#Connect to controller
ofmsg = openflow.messages()
ofparser = of_msg.parser(ofmsg)
ofsw = of_simu.switch(ofmsg,
self.controller,
self.port,
dpid=self.CONTROLLER_DPID,
parser=ofparser)
ofsw.send_hello()
while self.running:
msg = ofsw.connection.msgreceive(blocking=False)
# OF to GUI
if msg != None:
ofsw.receive_openflow(msg)
self.queue_OF_to_GUI.put(msg)
# GUI to OF
while not self.queue_GUI_to_OF.empty():
packet = self.queue_GUI_to_OF.get()
ofsw.send_packet(inport=0, packet=packet)
time.sleep(0.1)
def pinpoint(self, test_packets, errors):
errors = self.pinpointer.pin_point_test(test_packets, errors)
self.queue_pinpoint_to_GUI.put(errors)
