def send(self, segment): ''' This send method is for TCP. It will pack a TCP datagram into a IP datagram and send it to router. :param segment: transport layer datagram :return: None ''' datagram = pack(self.src_ip, self.dst_ip, self.protocol, segment) Router.send(datagram, self.dst_ip)
def test_show_cdp(): r1,r2 = create_router() r3 = Router("Amazon", "RX9898", "R3") r1.add_interface("G0/1") r3.add_interface("G0/0") r1.connect_to("G0/0", r2, "G0/1") r1.connect_to("G0/1", r3, "G0/0") assert r1.show_cdp() == "R1 interface G0/0 connect to R2 on interface G0/1\nR1 interface G0/1 connect to R3 on interface G0/0\n"
def test_connect_interface(): router1 = Router.Router('Test name 1', 'Test Model 1', 'Test vendor 1') router2 = Router.Router('Test name 2', 'Test Model 2', 'Test vendor 2') router1.add_interface('Gigabit Ethernet', '0/0') router2.add_interface('Gigabit Ethernet', '0/1') router1.connect_interface('G0/0', router2.interfaces.get('G0/1')) assert router1.interfaces.get( 'G0/0').connected_interface.attached_router == router2, 'test failed' assert router2.interfaces.get( 'G0/1').connected_interface.attached_router == router1, 'test failed'
def sendto(self, dst_ip, segment): ''' This sendto method is for UDP. By using the given dst_ip, it will pack a UDP datagram into a IP datagram and send it to router. :param dst_ip: The given dst_ip for UDP transmission :param segment: transport layer datagram :return: None ''' datagram = pack(self.src_ip, dst_ip, self.protocol, segment) Router.send(datagram, dst_ip)
def testDirectlyConnect(self): """test connent to neighbor interface of neighbor router""" router = Router('Cisco', '3745', 'R1') router.addInterface('GigabitEthernet0/1') router2 = Router('Cisco', '2600', 'R2') router2.addInterface('GigabitEthernet0/2') router.connect('GigabitEthernet0/1', router2, 'GigabitEthernet0/2') #check the next interface between routers is bonded. self.assertTrue('GigabitEthernet0/2' in router.interfaces['GigabitEthernet0/1']["n_interface"]) self.assertTrue('GigabitEthernet0/1' in router2.interfaces['GigabitEthernet0/2']["n_interface"]) #check next hostname is exist self.assertTrue('R2' in router.interfaces['GigabitEthernet0/1']["n_hostname"]) self.assertTrue('R1' in router2.interfaces['GigabitEthernet0/2']["n_hostname"])
def testRouterATR(self): rt1 = Router("Cisco", "c7200", "IOS", "R1") self.assertEqual(rt1.getBrand(), "Cisco") self.assertEqual(rt1.getModel(), "c7200") self.assertEqual(rt1.getHostname(), "R1") self.assertEqual(rt1.getOS(), "IOS") # Change the router's name rt1.setHostname("RT1") self.assertEqual(rt1.getHostname(), "RT1") del rt1
def test_lambda_PlayerStatus(self): input = self.loadEvent("./test/resources/test-Router-Player-Status.json") event_output = Router.handler(input['input'], None) self.assertEqual(event_output['data']['command']['type'], 'player') self.assertEqual(event_output['data']['command']['operation'], 'status') self.assertEqual(event_output['data']['errors'], {})
def runOSPF(self): for i in range(4): p = Router() List.append(p) for i in range(4): List[i].id = i + 1 List[i].port = Port[i] List[i].Graph[List[i].port] = {} List[0].Graph[List[0].port][List[1].port] = Cost[0] List[1].Graph[List[1].port][List[0].port] = Cost[0] List[1].Graph[List[1].port][List[2].port] = Cost[1] List[2].Graph[List[2].port][List[1].port] = Cost[1] List[2].Graph[List[2].port][List[3].port] = Cost[2] List[3].Graph[List[3].port][List[2].port] = Cost[2] List[0].Dijkstra() List[1].Dijkstra() List[2].Dijkstra() List[3].Dijkstra() #四个线程同时运行 for i in range(4): t = threading.Thread(target=List[i].run) t.start() #定时显示路由表 self.timer.start(60)
def testDuplicateIP(self): router = Router('Cisco', '3745', 'R1') router.addInterface('GigabitEthernet0/1') router.addInterface('GigabitEthernet0/3') router.assignIpaddr('GigabitEthernet0/1', '192.168.1.1/24') #validate by checking ip into interface that already assign or not. #Duplicated ip on exist interface, should be False router.assignIpaddr('GigabitEthernet0/3', '192.168.1.1/24') self.assertFalse('192.168.1.1' == router.interfaces['GigabitEthernet0/3']['ip_address'])
def test_assign_ip_int(): router1 = Router.Router('Test name 1', 'Test Model 1', 'Test vendor 1') router1.add_interface('Gigabit Ethernet', '0/0') router1.assign_ip_int('G0/0', '172.168.1.1', '255.255.255.0') assert router1.interfaces.get( 'G0/0').ip_address == '172.168.1.1', 'test failed' assert router1.interfaces.get( 'G0/0').subnet_mask == '255.255.255.0', 'test failed'
def test_fullinfo_router(): name = "Test Name" model = "Test Model" vendor = "Test Vendor" router1 = Router.Router(name, model, vendor) assert router1.name == name, 'test failed' assert router1.model == model, 'test failed' assert router1.vendor == vendor, 'test failed'
def test_success(self): storage = DummyStorage() testRouter = Router.Router(storage) weatherPlug = Weather.Weather() weatherPlug.storage = storage weatherPlug.sender_id = 1 self.assertEqual(testRouter.get_plugin('weather', 1), (weatherPlug, False))
def runTest(cases): for case in cases: params = case['params']; result = Router.route(params); Logger.v('William result', result); # fn.show(result); filename = 'william_py_result'; fn.writeTestFile(filename, result, minified=False);
def test_lambda_PlayerGuessLetter(self): input = self.loadEvent("./test/resources/test-Router-Player-GuessLetter.json") event_output = Router.handler(input['input'], None) self.assertEqual(event_output['data']['command']['type'], 'player') self.assertEqual(event_output['data']['command']['operation'], 'guess') self.assertEqual(event_output['data']['command']['arguments'], 'a') self.assertEqual(event_output['data']['errors'], {})
def test_lambda_AdminStatus(self): input = self.loadEvent("./test/resources/test-Router-Admin-Status.json") event_output = Router.handler(input['input'], None) self.assertEqual(event_output['data']['command']['type'], 'admin') self.assertEqual(event_output['data']['command']['operation'], 'game') self.assertEqual(event_output['data']['command']['arguments'][0], 'status') self.assertEqual(event_output['data']['errors'], {})
def runTest(cases): for case in cases: params = case['params'] result = Router.route(params) Logger.v('Daniel result', result) # fn.show(result); filename = 'daniel_py_result' fn.writeTestFile(filename, result, minified=False)
def main(): # make router, register entities during instantiation router = Router('alice', 1026, 'bob', 1027) # python run_router 1025 listenport = int(sys.argv[1]) listenaddr = '127.0.0.1' run_router(listenaddr, listenport, router)
def testConnectNotExistInt(self): """connection will not occur if next interface doesn't exist""" router = Router('Cisco', '3745', 'R1') router.addInterface('GigabitEthernet0/1') router2 = Router('Cisco', '2600', 'R2') router.connect('GigabitEthernet0/1', router2, 'GigabitEthernet0/99') self.assertFalse('GigabitEthernet0/99' in router.interfaces['GigabitEthernet0/1']["n_interface"])
def test_handler_AdminNoAccess(self): input = self.loadEvent("./test/resources/test-Router-Admin-Fail.json") event_output = Router.handler(input['input'], None) self.assertEqual(event_output['data']['command']['type'], 'admin') self.assertEqual(event_output['data']['command']['operation'], 'game') self.assertEqual(event_output['data']['command']['arguments'][0], 'stop') self.assertIsInstance(event_output['data']['errors'], SystemError) self.assertEqual(event_output['data']['response']['sms'], 'You do not have permission to execute this command.')
def test_success_initialised_plugin(self): storage = DummyStorage() storage.to_return = b'weather' testRouter = Router.Router(storage) weatherPlug = Weather.Weather() weatherPlug.storage = storage weatherPlug.sender_id = 1 self.assertEqual(testRouter.get_plugin('trash', 1), (weatherPlug, True))
def lambda_handler(event, context): try: logger.debug('router start') result = Router.route(event, self_=router) logger.debug('router end') except BaseException: logger.warning('Exception was raised on Router.') raise return result
def testAssignIpOverlap(self): router = Router('Cisco', '3745', 'R1') router.addInterface('GigabitEthernet0/1') router.addInterface('GigabitEthernet0/2') #validate by checking ip into interface that already assign or not. #IP currectly assign, will be true router.assignIpaddr('GigabitEthernet0/1', '192.168.1.1/24') self.assertTrue('192.168.1.1' == router.interfaces['GigabitEthernet0/1']['ip_address']) #IP overlapped to another network, should be False router.assignIpaddr('GigabitEthernet0/2', '192.168.37.24/16') self.assertFalse('192.168.37.24' == router.interfaces['GigabitEthernet0/2']['ip_address'])
def setup(self, cktIdx, dirName): ckt = self.dDB.subCkt(cktIdx) Router.Router(self.mDB).readBackDumbFile( dirName + 'stdcell/' + ckt.name + '.route.gds.dumb', cktIdx) #cmd = "cp " + dirName+'stdcell/'+cirname+'.route.gds ' + dirName+cirname+'.route.gds' #subprocess.call(cmd, shell=True) self.dDB.subCkt(cktIdx).isImpl = True # Read standard cell. ckt.setTechDB(self.tDB) ckt.parseGDS(dirName + 'stdcell/' + ckt.name + '.route.gds')
def initiate_distance_map(Map): ''' :param Map: two-dimensional list object :return: ''' distance_map = Router.makeWorkMap(Map) to_travel = Router.makeWorkMap(Map) for i in range(len(Map)): for j in range(len(Map[0])): if Map[i][j] == '-': distance_map[i][j] = float("inf") to_travel[i][j] = float("inf") else: distance_map[i][j] = float("inf") to_travel[i][j] = float("inf") return distance_map, to_travel
def __init__(self): #config self.config = configparser.ConfigParser() self.config_dir = 'config.INI' self.config.read(self.config_dir) self.interface_mode = self.config['DEFAULT']['interface_mode'] self.app_name = self.config['DEFAULT']['app_name'] self.head = self.config['DEFAULT']['header_en'] #init self.route = Router.Router(self.app_name, self.interface_mode, self.head)
def testRemoveInterface(self): """ Test Failed if removed interface is still exist after remove process""" router = Router('Cisco', '3745', 'R1') router.addInterface('GigabitEthernet0/1') router.addInterface('GigabitEthernet0/2') router.removeInt('GigabitEthernet0/1') #remove process self.assertFalse('GigabitEthernet0/1' in router.interfaces)
def testFaultAssignIP(self): #assign IP Address 888.888.445.134/24 to an interface #script will go to error (unable to assign wrong format IP Address). router = Router('Cisco', '3745', 'R1') router.addInterface('GigabitEthernet0/1') router.assignIpaddr('GigabitEthernet0/1', '888.888.445.134/24') self.assertTrue('888.888.445.134' != router.interfaces['GigabitEthernet0/1']['ip_address'])
def testIPAssign(self): router = Router('Cisco', '3745', 'R1') router.addInterface('GigabitEthernet0/1') router.addInterface('GigabitEthernet0/2') #validate by checking ip into interface that already assign or not. #IP currectly assign, will be true router.assignIpaddr('GigabitEthernet0/1', '192.168.1.1/24') self.assertTrue('192.168.1.1' == router.interfaces['GigabitEthernet0/1']['ip_address'])
def initiate_map(Map): ''' :param Map: two-dimensional list object :return: ''' node_map = Router.makeWorkMap(Map) for i in range(len(Map)): for j in range(len(Map[0])): if Map[i][j] == '-': node_map[i][j] = 1 return node_map
def initiate_parent_map(Map): ''' :param Map: two-dimensional list object :return: ''' cost_map = Router.makeWorkMap(Map) for i in range(len(Map)): for j in range(len(Map[0])): if Map[i][j] == '-': cost_map[i][j] = 7 return cost_map
def run(self): waypoints=None dist=-1 while True: preds=self.learnAndPredict() cv2.waitKey(0) (dist,waypoints)=Router.getRouteWP(preds.tolist(),(dist,waypoints),(self.sensors.getPos()[1],self.sensors.getPos()[0]),(self.sensors.getTargetPos()[1],self.sensors.getTargetPos()[0]),self.radius,1.5) self.sensors.showBot(waypoints) cv2.waitKey(0) print "Cur Pos"+str(self.sensors.getPos()) print "Waypoints: "+str(waypoints) distMoved=0 prev=(self.sensors.getPos()[1],self.sensors.getPos()[0]) count=0 for wp in waypoints: count+=1 distMoved+=Sensors.SimSensors.euclid(prev,wp) prev=wp self.sensors.move([wp[1],wp[0]]) if distMoved>Robot.moveDistance: break self.sensors.showBot(waypoints[count:])
#Phillips, King #Calls all of the other methods. Note, this will have to be replaced once we start using ROS, but this allows us to get started on the individual parts much more easily from PIL import Image; from freenect import sync_get_depth as get_depth, sync_get_video as get_video; import numpy as np; import Locator,Classifier,Router,Kinect; img=Image.open("Finder1.jpg")#Images will eventually draw from webcam robotPos=Locator.locateRobot(img) targetPos=Locator.locateTarget(img) #(depths,_)=get_depth() #need Kinect hooked up for this to work. Moore, can you create some simulations of the output of this? depths=[[0]*img.size[0] for i in range(img.size[1])] knownHeights=Kinect.getHeights(img,depths,robotPos) drivable=Classifier.getDriveable(img, knownHeights) (dist,waypoints)=Router.getRoute(drivable,robotPos,targetPos)
cv2.waitKey(0) o=newOverlay.Overlay(gmap,overheadPic,gpos,overheadPos,gres) one2one=o.overlay() one2onepic=np.zeros((np.shape(one2one)[0],np.shape(one2one)[1],3)) one2onepic[one2one==-1]=(0,0,0)#unknown one2onepic[one2one==0]=(0,255,0)#Driveable one2onepic[one2one==1]=(255,0,0)#wall cv2.imshow("Known 3d Data overlayed on overhead",one2onepic) cv2.waitKey(0) model=LRModel.LRModel(overheadPic,one2one) preds=model.predictAndShow(selfPos=overheadPos) print np.shape(one2one) print np.shape(preds) retVal=Router.getRouteWP(preds.tolist(),(-1,None),(overheadPos[1],overheadPos[0]),(targetPos[1],targetPos[0]),radius,.5,one2one.tolist()) if retVal==None: print "No path from here to target" os.system('say "No path"') (dist,waypoints)=(prevDist, prevWaypoints) else: (dist,waypoints)=retVal print waypoints showData(overheadPic,overheadPos,targetPos,waypoints) startTime=time.time() index=0 #Actually moving along the waypoints for a set amount of time for waypoint in waypoints[0]: if startTime+timeBetweenRelearn<time.time():#Exceeded allotted time break junk,overheadPic=cap.read()
#!/usr/bin/env python import sys from Router import * args=[]; for arg in sys.argv: args.append(arg); print arg rtrObj = Router(args); rtrObj.createRouter();
tfactory = TTransport.TBufferedTransportFactory() pfactory = TBinaryProtocol.TBinaryProtocolFactory() server = TServer.TThreadedServer(processor, transport, tfactory, pfactory) server.serve() if __name__ == '__main__': logging_format = '%(asctime)s %(process)04d %(levelname)5s %(message)s' logging.basicConfig(filename = 'log', format = logging_format, level=logging.DEBUG) logging.info("------------------------STARTING RUN-----------------------------------") if not len(sys.argv) in (4, 6): print "Usage: ./server node_id ip port [existing_ip existing_port]" sys.exit(-1) logging.info("Initializing ...") node_id = Router.hash(sys.argv[1]) host = sys.argv[2] port = int(sys.argv[3]) node = NodeID(node_id, host, port) logging.info("Node: %x (%s:%d)", node.int_id, host, port) handler = WDHTHandler(node) if len(sys.argv) == 6: existing_host = sys.argv[4] existing_port = int(sys.argv[5]) logging.info("Joining (%s:%d)", existing_host, existing_port) delayed_thread(lambda:handler.prv_init(existing_host, existing_port)) else: