Example #1
0
 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)
Example #2
0
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"
Example #3
0
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'
Example #4
0
 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)
Example #5
0
    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"])
Example #6
0
    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
Example #7
0
    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'], {})
Example #8
0
    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)
Example #9
0
 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'])
Example #10
0
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'
Example #11
0
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'
Example #12
0
 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))
Example #13
0
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);
Example #14
0
    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'], {})
Example #15
0
    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'], {})
Example #16
0
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)
Example #17
0
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)
Example #18
0
 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"])
Example #19
0
    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.')
Example #20
0
 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))
Example #21
0
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
Example #22
0
 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'])
Example #23
0
 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
Example #25
0
    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)
Example #26
0
 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)
Example #27
0
 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'])
Example #28
0
 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
Example #31
0
 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:])
Example #32
0
#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)
Example #33
0
    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();
Example #35
0
    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: