Exemplo n.º 1
0
    def run(self):
        # parameters
        Sim.scheduler.reset()

        # setup network
        net = Network('experiment.txt')
        net.loss(self.loss)

        # setup routes
        n1 = net.get_node('n1')
        n2 = net.get_node('n2')
        n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
        n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])

        # setup transport
        t1 = Transport(n1)
        t2 = Transport(n2)

        # setup application
        a = AppHandler(self.filename)

        # setup connection
        c1 = TCP(t1,
                 n1.get_address('n2'),
                 1,
                 n2.get_address('n1'),
                 1,
                 a,
                 window=self.window,
                 fast_retransmit=self.fast_retransmit,
                 measure=True)
        TCP(t2,
            n2.get_address('n1'),
            1,
            n1.get_address('n2'),
            1,
            a,
            window=self.window,
            fast_retransmit=self.fast_retransmit,
            measure=True)

        # send a file
        with open(self.filename, 'rb') as f:
            while True:
                data = f.read()
                if not data:
                    break
                Sim.scheduler.add(delay=0, event=data, handler=c1.send)

        Sim.scheduler.run()
        result_file = open("results.txt", "r")
        results = result_file.read()
        result_file.close()
        f = open("experiment.csv", "a")
        f.write(str(self.window) + "," + results + "\n")
Exemplo n.º 2
0
    def run(self):
        # parameters
        Sim.scheduler.reset()
        Sim.set_debug('AppHandler')
        Sim.set_debug('TCP')

        # setup network
        net = Network('network.txt')
        net.loss(self.loss)

        # setup routes
        n1 = net.get_node('n1')
        n2 = net.get_node('n2')
        n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
        n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])

        # setup transport
        t1 = Transport(n1)
        t2 = Transport(n2)

        # setup application
        a = AppHandler(self.filename)

        # setup connection
        c1 = TCP(t1,
                 n1.get_address('n2'),
                 1,
                 n2.get_address('n1'),
                 1,
                 a,
                 window=self.window,
                 fast_retransmit=self.fast_retransmit)
        c2 = TCP(t2,
                 n2.get_address('n1'),
                 1,
                 n1.get_address('n2'),
                 1,
                 a,
                 window=self.window,
                 fast_retransmit=self.fast_retransmit)

        # send a file
        with open(self.filename, 'rb') as f:
            while True:
                data = f.read(10000)
                if not data:
                    break
                Sim.scheduler.add(delay=0, event=data, handler=c1.send)

        # run the simulation
        Sim.scheduler.run()
        if self.print_queueing_delay:
            print('average queueing delay: {}'.format(
                c2.total_queueing_delay / c2.total_packets_received))
Exemplo n.º 3
0
 def __init__(self, ipAddress):
     self.sq = Queue()
     self.rq = Queue()
     self.struct = Struct('BBbB')  #command, selector, value, checksum
     self.sender = TCP(isServer=False,
                       isSender=True,
                       host=ipAddress,
                       port=1234,
                       q=self.sq)
     self.receiver = TCP(isServer=False,
                         isSender=False,
                         host=ipAddress,
                         port=5678,
                         q=self.rq)
Exemplo n.º 4
0
    def run(self):
        # parameters
        Sim.scheduler.reset()
        Sim.set_debug('AppHandler')
        Sim.set_debug('TCP')
        Sim.set_debug('Plot')

        # setup network
        net = Network('basic.txt')
        net.loss(self.loss)

        # setup routes
        n1 = net.get_node('n1')
        n2 = net.get_node('n2')
        n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
        n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])

        # setup transport
        t1 = Transport(n1)
        t2 = Transport(n2)

        # setup application
        a = AppHandler(self.filename)

        # setup connection
        c1 = TCP(t1,
                 n1.get_address('n2'),
                 1,
                 n2.get_address('n1'),
                 1,
                 a,
                 window=self.window)
        TCP(t2,
            n2.get_address('n1'),
            1,
            n1.get_address('n2'),
            1,
            a,
            window=self.window)

        # send a file
        with open(self.filename, 'rb') as f:
            while True:
                data = f.read()
                if not data:
                    break
                Sim.scheduler.add(delay=0, event=data, handler=c1.send)

        Sim.scheduler.run()
Exemplo n.º 5
0
    def run(self):
        # parameters
        Sim.scheduler.reset()
        Sim.set_debug('AppHandler')
        Sim.set_debug('TCP')
        Sim.set_debug('Plot')

        # setup network
        net = Network('./networks/one-hop.txt')
        net.loss(self.loss)

        # setup routes
        n1 = net.get_node('n1')
        n2 = net.get_node('n2')
        n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
        n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])

        # setup transport
        t1 = Transport(n1)
        t2 = Transport(n2)

        # setup application
        a = AppHandler(self.filename)

        # setup connection
        c1 = TCP(t1,
                 n1.get_address('n2'),
                 1,
                 n2.get_address('n1'),
                 1,
                 a,
                 window=self.window,
                 drop=self.drops)
        c2 = TCP(t2,
                 n2.get_address('n1'),
                 1,
                 n1.get_address('n2'),
                 1,
                 a,
                 window=self.window,
                 drop=self.drops)

        # setup fast retransmit
        if self.fast_retransmit:
            c1.set_fast_retransmit_enabled(True)
            c2.set_fast_retransmit_enabled(True)

        # send a file
        with open(self.filename, 'rb') as f:
            while True:
                data = f.read(1000)
                if not data:
                    break
                Sim.scheduler.add(delay=0, event=data, handler=c1.send)

        # run the simulation
        Sim.scheduler.run()
Exemplo n.º 6
0
 def __init__(self, camera, pnts_pattern):
     self.rep = Representation()
     self.h = Homography(pnts_pattern)
     self.tcp = TCP()
     self.a = Angle()
     self.camera = camera
     self.hom = np.zeros((3, 3))
     self.inv_hom = np.zeros((3, 3))
     self.Frame = np.zeros((3, 3))
     self.inv_Frame = np.zeros((3, 3))
     self.hom_final_camera = np.zeros((3, 3))
def main(url):

    parsed = urlparse(url)
    # exit on unsupported application protocol
    if parsed.scheme.lower() != 'http':
        print '"' + parsed.scheme  + '"' + ' scheme address is not supported'
        sys.exit()
    host = parsed.netloc
    filename = getFilename(parsed.path)
    request = getRequest(parsed.path, host)
    print filename
    print request
    # Initiate the download
    startTime = time.time()
    sock = TCP()
    sock.connect(host)
    sock.sendGet(request)

    # Start the retrieve
    filedata = sock.transmission()
    	
    print filedata

    # if found it is a non-200 packet, exit
    if not filedata.startswith("HTTP/1.1 200"):
        print ('Non-200 HTTP status code is not supported')
    	sys.exit(0)

    # remove the HTTP header:
    pos = filedata.find("\r\n\r\n")
    if pos > -1:
        pos += 4
        filedata = filedata[pos:]

    endTime = time.time()

    # save file to disk
    saveFile(filename, filedata)
    print len(filedata),
    print 'Bytes received'
    #timecost = '%.2g' % (endTime - startTime)
    #print timecost,
    #print 'seconds passed. Average speed:',
    #throughput = '%f' % (len(filedata) / float(timecost) / 1000)
    #print throughput,
    #print 'KBps'
    sock.sock.close()
Exemplo n.º 8
0
    print('Ethernet Frame:')
    print(TAB_1 + 'Destination: {}, Source: {}, Protocol: {}'.format(
        eth.dest_mac, eth.src_mac, eth.proto))

    # IPv4
    if eth.proto == 8:
        ipv4 = IPv4(eth.data)
        print(TAB_1 + 'IPv4 Packet:')
        print(TAB_2 + 'Version: {}, Header Length: {}, TTL: {},'.format(
            ipv4.version, ipv4.header_length, ipv4.ttl))
        print(TAB_2 + 'Protocol: {}, Source: {}, Target: {}'.format(
            ipv4.proto, ipv4.src, ipv4.target))

        # TCP
        if ipv4.proto == 6:
            tcp = TCP(ipv4.data)
            print(TAB_1 + 'TCP Segment:')
            print(TAB_2 + 'Source Port: {}, Destination Port: {}'.format(
                tcp.src_port, tcp.dest_port))
            print(TAB_2 + 'Sequence: {}, Acknowledgment: {}'.format(
                tcp.sequence, tcp.acknowledgment))
            print(TAB_2 + 'Flags:')
            print(TAB_3 + 'URG: {}, ACK: {}, PSH: {}'.format(
                tcp.flag_urg, tcp.flag_ack, tcp.flag_psh))
            print(TAB_3 + 'RST: {}, SYN: {}, FIN:{}'.format(
                tcp.flag_rst, tcp.flag_syn, tcp.flag_fin))

            if len(tcp.data) > 0:
                # HTTP
                if tcp.src_port == 80 or tcp.dest_port == 80:
                    print(TAB_2 + 'HTTP Data:')
Exemplo n.º 9
0
    def run(self):
        # parameters
        Sim.scheduler.reset()
        Sim.set_debug('AppHandler')
        #Sim.set_debug('TCP')
        Sim.set_debug('Link')

        net = Network('networks/one-hop-queue.txt')
        net.loss(self.loss)

        # setup routes
        n1 = net.get_node('n1')
        n2 = net.get_node('n2')
        n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
        n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])

        # setup transport
        t1 = Transport(n1)
        t2 = Transport(n2)

        # setup application
        a = AppHandler(self.filename)

        # setup connection
        c1 = TCP(t1,
                 n1.get_address('n2'),
                 1,
                 n2.get_address('n1'),
                 1,
                 a,
                 window=self.window,
                 threshold=self.threshold,
                 fast_recovery=self.fast_recovery)
        c2 = TCP(t2,
                 n2.get_address('n1'),
                 1,
                 n1.get_address('n2'),
                 1,
                 a,
                 window=self.window,
                 threshold=self.threshold,
                 fast_recovery=self.fast_recovery)

        # send a file
        with open(self.filename, 'r') as f:
            while True:
                data = f.read(1000)
                if not data:
                    break
                Sim.scheduler.add(delay=0, event=data, handler=c1.send)

        # run the simulation
        Sim.scheduler.run()

        # print some results
        print
        print "========== Overall results =========="
        time = Sim.scheduler.current_time()
        print "Total time: %f seconds" % time
        avg = numpy.mean(c2.queueing_delay_list)
        print "Average queueing delay: %f" % avg
        max = numpy.max(c2.queueing_delay_list)
        print "Max queueing delay: %f" % max
        file_size = os.path.getsize(self.filename)
        print "File size: %i" % file_size
        throughput = file_size / time
        print "Throughput: %f" % throughput

        plotter = Plotter()
        #print "Saving the sequence plot"
        #plotter.create_sequence_plot(c1.x, c1.y, c1.dropX, c1.dropY, c1.ackX, c1.ackY)
        self.c2 = c2
        self.c1 = c1
        self.t1 = t1
        self.t2 = t2
        self.net = net
        plotter.rateTimePlot(c2.packets_received, Sim.scheduler.current_time(),
                             'one/rateTime.png')
Exemplo n.º 10
0
    def run(self):
        # parameters
        Sim.scheduler.reset()
        #Sim.set_debug('AppHandler')
        #Sim.set_debug('TCP')
        Sim.set_debug('Link')

        net = Network('networks/two.txt')
        net.loss(self.loss)

        # setup routes
        n1 = net.get_node('n1')
        n2 = net.get_node('n2')
        n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
        n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])

        # setup transport
        t1 = Transport(n1)
        t2 = Transport(n2)

        # setup application
        a1 = AppHandler('test1.txt')
        a2 = AppHandler('test2.txt')

        # setup connection
        c1 = TCP(t1,
                 n1.get_address('n2'),
                 1,
                 n2.get_address('n1'),
                 1,
                 a1,
                 window=self.window,
                 threshold=self.threshold,
                 fast_recovery=self.fast_recovery)
        c2 = TCP(t2,
                 n2.get_address('n1'),
                 1,
                 n1.get_address('n2'),
                 1,
                 a1,
                 window=self.window,
                 threshold=self.threshold,
                 fast_recovery=self.fast_recovery)

        c3 = TCP(t1,
                 n1.get_address('n2'),
                 2,
                 n2.get_address('n1'),
                 2,
                 a2,
                 window=self.window,
                 threshold=self.threshold,
                 fast_recovery=self.fast_recovery)
        c4 = TCP(t2,
                 n2.get_address('n1'),
                 2,
                 n1.get_address('n2'),
                 2,
                 a2,
                 window=self.window,
                 threshold=self.threshold,
                 fast_recovery=self.fast_recovery)

        # send a file
        with open('test1.txt', 'r') as f:
            while True:
                data = f.read(1000)
                if not data:
                    break
                Sim.scheduler.add(delay=0, event=data, handler=c1.send)
        with open('test2.txt', 'r') as f:
            while True:
                data = f.read(1000)
                if not data:
                    break
                Sim.scheduler.add(delay=0, event=data, handler=c3.send)

        # run the simulation
        Sim.scheduler.run()

        # print some results
        print
        print "========== Overall results =========="
        time = Sim.scheduler.current_time()
        print "Total time: %f seconds" % time
        avg = numpy.mean(c2.queueing_delay_list)
        print "Average queueing delay: %f" % avg
        max = numpy.max(c2.queueing_delay_list)
        print "Max queueing delay: %f" % max
        file_size = os.path.getsize(self.filename)
        print "File size: %i" % file_size
        throughput = file_size / time
        print "Throughput: %f" % throughput

        # Variables for debugging
        self.c3 = c3
        self.c4 = c4
        self.c2 = c2
        self.c1 = c1
        self.t1 = t1
        self.t2 = t2
        self.net = net
        linkab = n1.links[0]
        self.linkab = linkab
        l = linkab

        # Plotting
        plotter = Plotter()

        # Plot sequence charts
        plotter.clear()
        plotter.create_sequence_plot(c1.x,
                                     c1.y,
                                     c1.dropX,
                                     c1.dropY,
                                     c1.ackX,
                                     c1.ackY,
                                     chart_name='two/sequence1.png')
        plotter.clear()
        plotter.create_sequence_plot(c3.x,
                                     c3.y,
                                     c3.dropX,
                                     c3.dropY,
                                     c3.ackX,
                                     c3.ackY,
                                     chart_name='two/sequence2.png')

        # Plot receiver rate
        plotter.clear()
        plotter.rateTimePlot(c2.packets_received,
                             Sim.scheduler.current_time(),
                             chart_name=None)
        plotter.rateTimePlot(c4.packets_received,
                             Sim.scheduler.current_time(),
                             chart_name='two/rateTime.png')

        # Plot queue size
        plotter.clear()
        plotter.queueSizePlot(l.queue_log_x,
                              l.queue_log_y,
                              l.dropped_packets_x,
                              l.dropped_packets_y,
                              chart_name='two/queueSize.png')

        # Plot congestion window
        plotter.clear()
        plotter.windowSizePlot(c1.window_x,
                               c1.window_y,
                               chart_name="two/windowSize1.png")
        plotter.clear()
        plotter.windowSizePlot(c3.window_x,
                               c3.window_y,
                               chart_name="two/windowSize2.png")
Exemplo n.º 11
0
def fn(x, y):
    tcp = TCP([x, y], arms=2, armlengths=armlengths)
    tcp.computeTcp()
    return tcp.tcp  # should be list of length 3
Exemplo n.º 12
0
    def run(self, size):
        # parameters
        Sim.scheduler.reset()
        logging.getLogger('app').setLevel(logging.INFO)
        logging.getLogger('bene.link.queue').setLevel(logging.DEBUG)
        logging.getLogger('bene.tcp.sequence').setLevel(logging.DEBUG)
        logging.getLogger('bene.tcp.cwnd').setLevel(logging.DEBUG)
        if self.debug:
            logging.getLogger('bene.tcp').setLevel(logging.DEBUG)
            logging.getLogger('bene.tcp.sender').setLevel(logging.DEBUG)
            logging.getLogger('bene.tcp.receiver').setLevel(logging.DEBUG)

        # setup network
        net = Network('networks/one-hop-q10.txt')
        net.loss(self.loss)

        # setup routes
        n1 = net.get_node('n1')
        n2 = net.get_node('n2')
        n1.add_forwarding_entry(n2.get_address('n1'), n1.links[0])
        n2.add_forwarding_entry(n1.get_address('n2'), n2.links[0])

        # setup transport
        t1 = Transport(n1)
        t2 = Transport(n2)

        # setup application
        a = AppHandler(self.filename)

        window = size

        # setup connection
        drop = []
        filen = ("data/queue-%i.csv" % size)
        fd = open(filen, "w")
        fd.write("Time_stamp,qDelay\n")
        c1 = TCP(t1,
                 n1.get_address('n2'),
                 1,
                 n2.get_address('n1'),
                 1,
                 a,
                 window=window,
                 drop=drop,
                 retran=self.retran)
        c2 = TCP(t2,
                 n2.get_address('n1'),
                 1,
                 n1.get_address('n2'),
                 1,
                 a,
                 window=window,
                 fd=fd)
        # send a file
        time_before = Sim.scheduler.current_time()
        count = 0
        with open(self.filename, 'rb') as f:
            while True:
                data = f.read(1000)
                count += len(data)
                # print("0",count)
                if not data:
                    break
                Sim.scheduler.add(delay=0, event=data, handler=c1.send)
            Sim.scheduler.run()
        time_after = Sim.scheduler.current_time()
        Sim.scheduler.reset()
        fd.close()
        return (time_after - time_before), count
Exemplo n.º 13
0
    def run(self):
        # parameters
        Sim.scheduler.reset()
        #Sim.set_debug('AppHandler')
        #Sim.set_debug('TCP')
        Sim.set_debug('Link')

        net = Network('networks/one.txt')
        net.loss(self.loss)

        # setup routes
        n1 = net.get_node('n1')
        n2 = net.get_node('n2')
        n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
        n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])

        # setup transport
        t1 = Transport(n1)
        t2 = Transport(n2)

        # setup application
        a1 = AppHandler('test.txt')

        # setup connection
        c1 = TCP(t1,
                 n1.get_address('n2'),
                 1,
                 n2.get_address('n1'),
                 1,
                 a1,
                 window=self.window,
                 threshold=self.threshold,
                 fast_recovery=True,
                 aimdc=5.0 / 6.0)
        c2 = TCP(t2,
                 n2.get_address('n1'),
                 1,
                 n1.get_address('n2'),
                 1,
                 a1,
                 window=self.window,
                 threshold=self.threshold,
                 fast_recovery=True,
                 aimdc=5.0 / 6.0)

        # send a file
        with open('test.txt', 'r') as f:
            while True:
                data = f.read(1000)
                if not data:
                    break
                Sim.scheduler.add(delay=0, event=data, handler=c1.send)

        # run the simulation
        Sim.scheduler.run()

        # print some results
        print
        print "========== Overall results =========="
        time = Sim.scheduler.current_time()
        print "Total time: %f seconds" % time
        avg = numpy.mean(c2.queueing_delay_list)
        print "Average queueing delay: %f" % avg
        max = numpy.max(c2.queueing_delay_list)
        print "Max queueing delay: %f" % max
        file_size = os.path.getsize(self.filename)
        print "File size: %i" % file_size
        throughput = file_size / time
        print "Throughput: %f" % throughput

        plotter = Plotter()
        print "Saving the sequence plot"
        plotter.create_sequence_plot(c1.x,
                                     c1.y,
                                     c1.dropX,
                                     c1.dropY,
                                     c1.ackX,
                                     c1.ackY,
                                     chart_name='advanced/aimd/sequence.png')

        plotter.clear()
        plotter.rateTimePlot(c2.packets_received, Sim.scheduler.current_time(),
                             'advanced/aimd/rateTime1.png')

        linkab = n1.links[0]
        self.linkab = linkab
        plotter.clear()
        plotter.queueSizePlot(linkab.queue_log_x,
                              linkab.queue_log_y,
                              linkab.dropped_packets_x,
                              linkab.dropped_packets_y,
                              chart_name='advanced/aimd/queueSize.png')

        plotter.clear()
        plotter.windowSizePlot(c1.window_x,
                               c1.window_y,
                               chart_name="advanced/aimd/windowSize1.png")
Exemplo n.º 14
0
class Cal_camera():
    def __init__(self, camera, pnts_pattern):
        self.rep = Representation()
        self.h = Homography(pnts_pattern)
        self.tcp = TCP()
        self.a = Angle()
        self.camera = camera
        self.hom = np.zeros((3, 3))
        self.inv_hom = np.zeros((3, 3))
        self.Frame = np.zeros((3, 3))
        self.inv_Frame = np.zeros((3, 3))
        self.hom_final_camera = np.zeros((3, 3))

    def get_pxls_homography(self, image, scale=1):
        pts_image = self.h.read_image(image, scale)
        return pts_image

    def calculate_homography(self, pxls_pattern):
        self.hom = self.h.calculate(pxls_pattern)
        self.inv_hom = linalg.inv(self.hom)

    def get_pxl_origin(self, folder, scale=1):
        pxl_pnts = []
        for f in sorted(folder):
            im_uEye = cv2.imread(f)
            pxl_pnts.append(self.tcp.read_image(im_uEye, scale))
        return pxl_pnts

    def get_pxl_orientation(self, folder, scale=1):
        for f in sorted(folder):
            name = basename(f)
            if name == "move_x.jpg":
                im_uEye = cv2.imread(f)
                pxl_pnts_x = self.tcp.read_image(im_uEye, scale)
            elif name == "move_y.jpg":
                im_uEye = cv2.imread(f)
                pxl_pnts_y = self.tcp.read_image(im_uEye, scale)
            elif name == "move_o.jpg":
                im_uEye = cv2.imread(f)
                pxl_pnts_origin = self.tcp.read_image(im_uEye, scale)

        return pxl_pnts_origin, pxl_pnts_x, pxl_pnts_y

    def calculate_TCP_orientarion(self, pxl_pnts, pxl_pnts_origin, pxl_pnts_x, pxl_pnts_y, dx, dy):
        pxl_TCP = self.tcp.calculate_origin(pxl_pnts)
        print "TCP :", pxl_TCP
        factor, angle_y, angle_x = self.tcp.calculate_orientation(pxl_pnts_origin, pxl_pnts_x, pxl_pnts_y, dx, dy)
        return pxl_TCP, factor, angle_y, angle_x

    def calculate_angle_TCP(self, origin, axis_x, pattern):

        pnt_origin = self.rep.transform(self.hom, origin)
        pnt_x = self.rep.transform(self.hom, axis_x)
        pnt_pattern = self.rep.transform(self.hom, pattern)

        l_1 = np.float32([pnt_origin[0], pnt_x[0]])
        l_2 = pnt_pattern[0:2]
        vd1 = self.a.director_vector(l_1[0], l_1[1])
        vd2 = self.a.director_vector(l_2[0], l_2[1])
        angle = self.a.calculate_angle(vd1, vd2)
        return angle

    def calculate_frame(self, pxl_TCP, angle):
        pnts_TCP = self.rep.transform(self.hom, pxl_TCP)[0]

        a = np.deg2rad(angle)
        self.Frame = np.float32([[np.cos(a),  -np.sin(a), pnts_TCP[0]],
                                [np.sin(a),  np.cos(a), pnts_TCP[1]],
                                [0, 0, 1]])

        self.Orientation = np.float32([[np.cos(a),  -np.sin(a), 0],
                                       [np.sin(a),  np.cos(a), 0],
                                       [0, 0, 1]])
        self.inv_Orientation = linalg.inv(self.Orientation)
        self.inv_Frame = linalg.inv(self.Frame)

    def calculate_hom_final(self, img, pnts, corners, pnts_final):
        # pxls_camera = self.rep.transform(self.inv_hom, pnts)
        im_measures = self.rep.define_camera(img.copy(), self.hom)
        #------------------ Data in (c)mm
        image_axis = self.rep.draw_axis_camera(im_measures, pnts)
        #------------------
        pnts_Frame = pnts
        pnts_camera = self.rep.transform(self.Frame, pnts_Frame)

        image_axis_tcp = self.rep.draw_axis_camera(image_axis, pnts_camera)
        #------------------
        corners_Frame = corners
        corners_camera = self.rep.transform(self.Frame, corners_Frame)
        img = self.rep.draw_points(image_axis_tcp, corners_camera)
        #------------------
        pxls_corner = self.rep.transform(self.inv_hom, corners_camera)
        self.hom_final_camera, status = cv2.findHomography(pxls_corner.copy(), pnts_final)
        self.write_config_file()
        return self.hom_final_camera

    def write_config_file(self):
        hom_vis = self.hom_final_camera
        hom_TCP = np.dot(self.inv_hom, self.Frame)
        inv_hom_TCP = np.dot(self.inv_Frame, self.hom)
        data = dict(
            hom_vis=hom_vis.tolist(),
            hom=hom_TCP.tolist(),
            inv_hom=inv_hom_TCP.tolist(),
            )
        filename = '../../config/' + self.camera + '_config.yaml'
        with open(filename, 'w') as outfile:
            yaml.dump(data, outfile)
            print data

    def visualize_data(self):
        print "Homography: "
        print self.hom

        print "Frame: "
        print self.Frame

        print "Final homography: "
        print self.hom_final_camera

    def draw_pattern_axis(self, pnts, img):
        pnts_axis_pattern = pnts
        pxls_axis_pattern = self.rep.transform(self.inv_hom, pnts_axis_pattern)
        pnt_axis_pattern_final = self.rep.transform(self.hom_final_camera, pxls_axis_pattern)
        img_pattern_NIT = self.rep.draw_axis_camera(img, pnt_axis_pattern_final)
        return img_pattern_NIT

    def draw_TCP_axis(self, pnts, img):
        pnts_axis = pnts
        pnts_axis_TCP = self.rep.transform(self.Frame, pnts_axis)
        pxls_axis_TCP = self.rep.transform(self.inv_hom, pnts_axis_TCP)
        pnt_axis_TCP_final = self.rep.transform(self.hom_final_camera, pxls_axis_TCP)
        img_final_axis = self.rep.draw_axis_camera(img, pnt_axis_TCP_final)
        return img_final_axis

    def draw_axis(self, pnts, img):
        img_TCP = self.draw_pattern_axis(pnts, img)
        img_final = self.draw_TCP_axis(pnts, img_TCP)
        return img_final
Exemplo n.º 15
0
def test_format_message():
    test_body = "This is a test!"
    expected_message = "b'\\x00\\x00\\x00\\x0f'This is a test!"
    assert TCP.format_message(message=test_body) == expected_message
Exemplo n.º 16
0
def main(*args, **kwargs):
    start = time.time()
    global client, passphrase, host, port
    network = []
    chain = BlockChain(client, passphrase)
    files = Filemng(client, chain)
    encrypt = files.Load_Both_Keys()
    files.Load_Month()
    print("Loading Logs")
    sensors = Sensor()
    sensors.Config_Sensors()
    print("Configued Sensors")
    que = queue.Queue()
    send_que = queue.Queue()
    recv_que = queue.Queue()
    comm = TCP(encrypt, passphrase, host, port, que, send_que, recv_que)

    Showdown = False
    while not Showdown:
        print("Collecting Sensors data")
        Collect_Sensor(chain, sensors)
        print("Saving Log")
        files.Save_Log()
        error = 0
        transmit = False
        water_count = 0
        print("Checking Water level/Levels")
        if (float(chain.chain[-1].sensor.water_level) < MAX_WATER_LEVEL
                and float(chain.chain[-1].sensor.water_level) != 0.00
                or 0 < water_count <= 10):
            if (float(chain.chain[-1].sensor.water_level) < MAX_WATER_LEVEL):
                water_count = 0
            water_count += 1
            attenna_status = True  #sensors.boot_antenna()
            while (not attenna_status and not Showdown):
                attenna_status = sensors.boot_antenna()
                error += 1
                if (error >= 3):
                    chain.Set_Network_Error(112)
                    Shutdown(files)
                    Showdown = True
            if (not comm.State):
                Start_Comm(comm)
                time.sleep(1)
            print("Water level High")
            transmit = True
        print("Checking Unsent Object")
        if (Check_Unsent_Blocks(chain) > UNSENT_SEND and not transmit):
            attenna_status = True  #sensors.boot_antenna()
            while (not attenna_status and not Showdown):
                attenna_status = sensors.boot_antenna()
                error += 1
                if (error >= 3):
                    chain.Set_Network_Error(112)
                    Shutdown(files)
                    Showdown = True
            if (not comm.State):
                Start_Comm(comm)
                time.sleep(1)
            print("Unsent blocks High")
            transmit = True

        if (transmit):
            Send_Blocks(chain, send_que)
            time.sleep(5)
            Remove_blocks(chain, recv_que)
            print("Transmitting")
        else:
            print("Nothing to transmitt")
            files.Save_Log()
            Showdown = True

        if not que.empty():
            network.append(que.get())
        if (len(network) > 0):
            chain.Set_Network_Error(network[0][0])
            if (network[0][0] == 111):
                Showdown = True
        time.sleep(2)
        print("Cycling ")
    print("Shutting Down")
    Soft_Shutdown(files, comm)
Exemplo n.º 17
0
class PXI:
    """
    PXI Class. TODO: write docstring
    
    Attributes:
    
    """
    help_str = ("At any time, type... \n" +
                " - 'h' to see this message again \n" +
                " - 'r' to reset the connection to CsPy \n" +
                " - 'd' to toggle the server DEBUG level logging \n" +
                " - 'x' to print the most recently received xml to a file \n" +
                " - 'q' to stop the connection and close this server.")

    def __init__(self, address: Tuple[str, int]):
        self.root_logger = logging.getLogger() # root_logger
        self._root_logging_lvl_default = self.root_logger.level
        self.sh = self.root_logger.handlers[0] # stream_handler
        self._sh_lvl_default = self.sh.level

        self.logger = logging.getLogger(self.__class__.__name__)
        self.logger.setLevel(logging.DEBUG)
        fh = logging.FileHandler('spam.log')
        fh.setLevel(logging.DEBUG)
        self.logger.addHandler(fh)
        self._stop_connections = False
        self._reset_connection = False
        self._exit_measurement = False
        self.cycle_continuously = False
        self.return_data = b""
        self.return_data_queue = b""
        self.measurement_timeout = 0
        self.keylisten_thread = None
        self.command_queue = Queue(0)  # 0 indicates no maximum queue length enforced.
        self.element_tags = []  # for debugging
        self.devices = []

        # instantiate the device objects
        self.hsdio = HSDIO(self)
        self.tcp = TCP(self, address)
        self.analog_input = AnalogInput(self)
        self.analog_output = AnalogOutput(self)
        self.ttl = TTLInput(self)
        # self.daqmx_do = DAQmxDO(self)
        self.hamamatsu = Hamamatsu(self)
        self.counters = Counters(self)

    @property
    def stop_connections(self) -> bool:
        return self._stop_connections

    @stop_connections.setter
    def stop_connections(self, value):
        self._stop_connections = value

    @property
    def reset_connection(self) -> bool:
        return self._reset_connection

    @reset_connection.setter
    def reset_connection(self, value):
        self._reset_connection = value

    @property
    def exit_measurement(self) -> bool:
        return self._exit_measurement

    @exit_measurement.setter
    def exit_measurement(self, value):
        self._exit_measurement = value

    @property
    def active_devices(self):
        """
        Number of devices that were successfully initialized
        """
        return sum(dev.is_initialized for dev in self.devices)
        
    @property
    def root_logging_lvl_default(self):
        """
        The default root logging level for this server
        """
        return self._root_logging_lvl_default
        
    @property
    def sh_lvl_default(self):
        """
        The default stream handler level for this server
        """
        return self._sh_lvl_default

    def queue_command(self, command):
        self.command_queue.put(command)

    def launch_network_thread(self):
        self.tcp.launch_network_thread()

    def launch_experiment_thread(self):
        """
        Launch a thread for the main experiment loop

        Thread target method = self.command_loop
        """
        self.experiment_thread = threading.Thread(
            target=self.command_loop,
            name='Experiment Thread'
        )
        self.experiment_thread.setDaemon(False)
        self.experiment_thread.start()

    def command_loop(self):
        """
        Update devices with xml from CsPy, and get and return data from devices

        Pop a command from self.command_queue on each iteration, parse the xml
        in that command, and update the instruments accordingly. When the queue
        is empty, try to receive measurements from the data if cycling
        continuously.

        This function handles the switching between updating devices and
        getting data from them, while the bulk of the work is done in the
        hierarchy of methods in self.parse_xml and self.measurement.
        """

        while not (self.stop_connections or self.exit_measurement):
            try:
                # dequeue xml
                xml_str = self.command_queue.get(block=False, timeout=0)
                self.parse_xml(xml_str)

            except Empty:
                self.exit_measurement = False
                self.return_data = b""  # clear the return data

                if self.cycle_continuously and self.active_devices > 0:
                    self.logger.debug("Entering cycle continously...")
                    # This method returns the data
                    self.return_data_queue = self.measurement()
            
            sleep(0.001) # keep while loop from hogging resources
        
        self.shutdown()
        self.logger.info("Exiting Experiment Thread.")
        

    def launch_keylisten_thread(self):
        """
        Launch a KeyListener thread to get key presses in the command line
        """
        self.keylisten_thread = KeyListener(self.on_key_press)
        self.keylisten_thread.setDaemon(True)
        self.logger.info("starting keylistener")
        self.keylisten_thread.start()

    def parse_xml(self, xml_str: str):
        """
        Initialize the device instances and other settings from queued xml
        
        Loop over highest tier of xml tags with the root tag='LabView' in the 
        message received from CsPy, and call the appropriate device class accordingly. the xml is popped 
        from a queue, which updates in the network_loop whenever a valid 
        message from CsPy is received. 
        
        Args:
            'xml_str': (str) xml received from CsPy in the receive_message method
        """

        self.exit_measurement = False
        self.element_tags = []  # clear the list of received tags

        # get the xml root
        root = ET.fromstring(xml_str)
        if root.tag != "LabView":
            self.logger.warning("Not a valid msg for the pxi")

        else:
            # loop non-recursively over children in root to setup device
            # hardware and other server settings
            for child in root:

                self.element_tags.append(child)

                try:

                    if child.tag == "measure":
                        # if no data available, take one measurement. Otherwise,
                        # use the most recent data.
                        if self.return_data_queue == b"":
                            self.measurement()
                        else:
                            self.return_data = self.return_data_queue
                            pass

                    elif child.tag == "pause":
                        # TODO: set state of server to 'pause';
                        # i don't know if this a feature that currently gets used,
                        # so might be able to omit this.
                        pass

                    elif child.tag == "run":
                        # TODO: set state of server to 'run';
                        # i don't know if this a feature that currently gets used,
                        # so might be able to omit this.
                        pass

                    elif child.tag == "HSDIO":
                        # setup the HSDIO
                        self.hsdio.load_xml(child)
                        self.logger.info("HSDIO XML loaded")
                        self.hsdio.init()
                        self.logger.info("HSDIO hardware initialized")
                        self.hsdio.update()
                        self.logger.info("HSDIO hardware updated")

                    elif child.tag == "TTL":
                        self.ttl.load_xml(child)
                        self.logger.info("TTLInput XML loaded")
                        self.ttl.init()
                        self.logger.info("TTLInput hardware initialized")

                    elif child.tag == "DAQmxDO":
                        # self.daqmx_do.load_xml(child)
                        # self.daqmx_do.init()
                        pass

                    elif child.tag == "timeout":
                        try:
                            # get timeout in [ms]
                            self.measurement_timeout = 1000 * float(child.text)
                        except ValueError as e:
                            msg = f"{e} \n {child.text} is not valid" + \
                                  f"text for node {child.tag}"
                            raise XMLError(self, child, message=msg)

                    elif child.tag == "cycleContinuously":
                        cycle = False
                        if child.text.lower() == "true":
                            cycle = True
                        self.cycle_continuously = cycle

                    elif child.tag == "camera":
                        # set up the Hamamatsu camera
                        self.hamamatsu.load_xml(child)  # Raises ValueError
                        self.hamamatsu.init()  # Raises IMAQErrors

                    elif child.tag == "AnalogOutput":
                        # set up the analog_output
                        self.analog_output.load_xml(child)
                        self.logger.info("AnalogOutput XML loaded")
                        self.analog_output.init()
                        self.logger.info("AnalogOutput initialized")
                        self.analog_output.update()
                        self.logger.info("AnalogOutput hardware updated")
                    
                    elif child.tag == "AnalogInput":
                        # set up the analog_input
                        self.analog_input.load_xml(child)
                        self.analog_input.init()
                    
                    elif child.tag == "Counters":
                    #     # TODO: implement counters class
                    #     # set up the counters
                        self.counters.load_xml(child)
                        self.counters.init()
                        pass

                    # # might implement, or might move RF generator functionality to
                    # # CsPy based on code used by Hybrid.
                    elif child.tag == "RF_generators":
                        pass

                    else:
                        self.logger.warning(f"Node {child.tag} received is not a valid" +
                                            f"child tag under root <{root.tag}>")

                # I do not catch AssertionErrors. The one at the top of load_xml in every 
                # device class can only occur if the device is passed the wrong xml node, 
                # which can never occur in pxi.parse_xml, as we check the tag before 
                # instantiating a device. those assertions are there in case someone down the 
                # road does something more careless. 
                except (XMLError, HardwareError) as e:
                    self.handle_errors(e)

        # send a message back to CsPy
        self.tcp.send_message(self.return_data)

        # clear the return data
        self.return_data = b""
        self.return_data_queue = b""

    def data_to_xml(self) -> str:
        """
        Get xml-formatted data string from device measurements

        Return the data as an xml string by calling the device class is_out
        methods.

        Returns:
            'return_data': concatenated string of xml-formatted data
        """

        return_data = b""

        # the devices which have a method named 'data_out' which returns a str
        devices = [
            self.hamamatsu,
            self.counters,
            #self.ttl,
            # self.counters, #TODO: implement
            self.ttl,
            self.analog_input
            # self.demo # not implemented, and debatable whether it needs to be
        ]

        for dev in devices:
            if dev.is_initialized:
                try:
                    return_data += dev.data_out()
                except HardwareError as e:
                    self.handle_errors(e)

        self.return_data = return_data
        return return_data

    def measurement(self) -> str:
        """
        Return a queue of the acquired responses queried from device hardware

        Returns:
            'return_data': string of concatenated responses received from the
                device classes
        """

        if not (self.stop_connections or self.exit_measurement):
            
            # self.logger.info(f"measurement time lapse= {time()-self.trelative}")
            self.trelative = time()
            
            self.reset_data()
            self.system_checks()
            self.start_tasks()

            _is_done = False
            _is_error = False

            ## timed loop to frequently check if tasks are done
            tau = 10  # loop period in [ms]
            scl = 1e-6  # scale factor to convert ns to ms
            
            devtime = time()
            finished_devs = []
            while not (_is_done or _is_error or self.stop_connections
                       or self.exit_measurement):
                try:
                    _is_done = self.is_done()

                except HardwareError as e:
                    self.handle_errors(e)

                # sleep to reduce resource usage
                sleep(0.001)

            try:
                self.get_data()
                self.system_checks()
                self.stop_tasks()
                return_data = self.data_to_xml()
                return return_data

            except Exception as e:  # TODO: make less general
                self.logger.warning(f"Error encountered {e}\nNo data returned.")
                self.handle_errors(e)
                return ""

    def reset_data(self):
        """
        Resets data on devices which need to be reset.

        For now, only applies to TTL
        """
        try:
            self.ttl.reset_data()
        except HardwareError as e:
            self.handle_errors(e)

    def system_checks(self):
        """
        Check devices.

        For now, only applies to TTL
        """
        try:
            self.ttl.check()
        except HardwareError as e:
            self.handle_errors(e)

    # wrap batch_method_call calls in convenience functions

    def start_tasks(self, handle_error=True):
        """
        Start measurement and output tasks for relevant devices
        """

        # devices which have a method 'start'
        devices = [
            self.hsdio,
            # self.daqmx_do,
            # self.hamamatsu,
            self.analog_input,
            self.analog_output,
            #self.ttl
            self.counters
        ]

        self.batch_method_call(devices, 'start', handle_error)
        # self.reset_timeout()  # TODO : Implement or discard

    def stop_tasks(self, handle_error=True):
        """
        Stop measurement and output tasks for relevant devices
        """

        # devices which have a method 'stop'
        devices = [
            self.hsdio,
            # self.daqmx_do,
            self.analog_input,
            self.analog_output,
            #self.ttl
            self.counters # TODO: implement Counters.stop
        ]

        self.batch_method_call(devices, 'stop', handle_error)
        
    def close_tasks(self, handle_error=True):
        """
        Close references to tasks for relevant devices
        """

        # devices which have a method 'stop'
        devices = [
            self.hsdio,
            # self.daqmx_do,
            self.hamamatsu,
            self.analog_input,
            self.analog_output,
            self.ttl,
            self.counters # TODO: implement Counters.stop
        ]

        self.batch_method_call(devices, 'close', handle_error)

    def get_data(self, handle_error=True):
        """
        Get data from the devices
        """
        if not (self.stop_connections or self.exit_measurement):
            # devices which have a method 'get_data'
            devices = [
                self.hamamatsu,
                self.analog_input,
                self.counters  # TODO: implement Counters.get_data
            ]

            self.batch_method_call(devices, 'get_data', handle_error)

    def is_done(self) -> bool:
        """
        Check if devices running processes are done yet

        Loops over the device classes and calls the instance's is_done method
        for each device capable of running a process and breaks when a process
        is found to not be done.

        Returns:
            done
                'done': will return True iff all the device processes are done.
        """

        done = True
        if not (self.stop_connections or self.exit_measurement):

            # devices which have a method named 'is_done' that returns a bool
            devices = [
                self.hsdio,
                self.analog_output,
                self.analog_input,
                # self.daqmx_do
                #self.counters
            ]

            try:
                for dev in devices:
                    if dev.is_initialized:
                        if not dev.is_done():
                            done = False
                            break
            except HardwareError as e:
                self.handle_errors(e)
                return done

        return done
        
        
    def reset_timeout(self):
        """
        Seems to change a global variable 'Timeout Elapses at' to the current time + timeout
        Will that work here?
        Returns:

        """
        # TODO: Implement
        pass

    def on_key_press(self, key: str):
        """
        Determines what happens for key presses in the command prompt.

        This method to be passed into the KeyListener instance to be called
        when keys are pressed.

        Args:
            'key': the returned key from msvcrt.getwch(), e.g. 'h'
        """

        if key == 'h': # show the help str
            self.logger.info(self.help_str)

        if key == 'r': # reset the connection
            self.logger.info("Connection reset by user.")
            self.reset_connection = True

        if key == 'x': # print most recently received xml to file
            try:
                fname = self.tcp.xml_to_file()
                self.logger.info("wrote xml to file "+fname)
            except Exception as e:
                self.logger.error(f"oops. failed to write to file. + \n {e}")
            
        if key == 'd': # toggle debug/info level root logging
            if self.root_logger.level != logging.DEBUG:
                self.root_logger.setLevel(logging.DEBUG)
            else:
                self.root_logger.setLevel(self.root_logging_lvl_default)
                self.logger.info("set the root level logging to default")
                
            if self.sh.level != logging.DEBUG:
                self.sh.setLevel(logging.DEBUG)
            else:
                self.sh.setLevel(self.sh_lvl_default)
                self.logger.info("set the stream handler level logging to default")
                
            self.logger.debug("Logging level is now DEBUG")

            
        elif key == 'q':
            self.logger.info("Connection stopped by user. Closing server.")
            self.exit_measurement = True
            self.stop_connections = True
        else:
            self.logger.info("Not a valid keypress. Type \'h\' for help.")

    def handle_errors(self, error: Exception, traceback_str: str = ""):
        """
        Handle errors caught in the PXI instance

        Error handling philosophy:
            I. The class where the error originated should log a useful
                message detailing the source of the error
            II. If error should halt instrument activity, error should be raised
                to pxi class. Use logger.error(msg,exc_info=True) to log error
                with traceback.
            III. If error should not halt instrument activity, use
                logger.warning(msg,exc_info=t/f) (t/f = with/without traceback)
            IV. When error is raised to pxi class, this function should be
                called. A message will be logged to the terminal output as well
                as sent to CsPy, warning the user that an error has occurred
                and that the PXI settings should be updated.
            V. The current measurement cycle should be aborted, and restarted
                if self.cycle_continuously == True. Device where error occurred
                should be excluded from the measurement cycle until it has been
                reinitialized. I.e., devices which read/write signals (e.g.
                TTLInput, HSDIO, etc) should continue to cycle if they can
            VI. The errors raised in the device classes can should be classified
                coarsely, as many errors should result in the same handling
                behavior in this function (e.g. all error types pertaining to an XML
                initialization failure should result in a message urging the user to
                check the XML in CsPy and reinitialize the device). Specific
                error types handled here are HardwareError and XMLError, defined
                in pxierrors.py

        Args:
            error : The error that was raised. Maybe it's useful to keep it around
            traceback_str : string useful for traceback
        """

        # NOTE:
        # This code is not a janitor, your mother/father, etc. If your device soiled itself, it is your
        # responsibility to clean up the problem where it occurred. The code that follows is only
        # intended to change the state the of the server and/or log a report of what happened,
        # in response to whatever mess was made.

        if self.stop_connections:
            return
            
        self.logger.warning("PXIError encountered. Closing the problematic tasks.")
        
        if isinstance(error, XMLError):
            self.logger.error(traceback_str + "\n" + error.message + "\n" +
                              "Fix the pertinent XML in CsPy, then try again.")
            self.cycle_message(error.device)
            self.reset_exp_thread()

        elif isinstance(error, HardwareError):
            self.logger.error(traceback_str + "\n" + error.message)
            self.cycle_message(error.device)
            self.stop_tasks(handle_error=False)  # stop all current measurement tasks
            error.device.close() # close the reference to the problematic device
            self.reset_exp_thread() # this stalls the program currently

        # If not a type of error we anticipated, raise it.
        else:
            raise error

    def cycle_message(self, dev: XMLLoader):
        """
        Log a message about the status of the server cycling. 
        
        Args:
            dev: the device instance where the problem occurred
        """
        if self.cycle_continuously:
            self.logger.warning(f"The server will now cycle, but without {dev}")
        else:
            self.logger.info(f"The server is not taking data. Cycle continuously to resume, but without {dev}")

    def reset_exp_thread(self):
        """
        Restart experiment thread after current measurement ends
        """
        # self.logger.info("Waiting for the experiment thread to end...")
        # self.exit_measurement = True
        # while self.experiment_thread.is_alive():
            # pass
        # self.experiment_thread.join()
        self.logger.info("Restarting current experiment thread...")
        self.exit_measurement = False
        
        # overwrite the existing thread ref. might be a better way to do this.
        self.launch_experiment_thread() 
        self.logger.info("Experiment thread relaunched")

    def batch_method_call(
            self,
            device_list: List[Instrument],
            method: str,
            handle_error: bool = True
    ):
        """
        Call a method common to several device classes

        Given a list of device instances, assumed to have method 'method' as
        well as bool parameter 'is_initialized', 'method' will be called for
        each instance.

        For now, it is assumed that 'method' takes no arguments, and does
        does not return anything.

        Args:
            device_list: list of device instances
            method: name of the method to be called. make sure every device
                in device list has a method with this name.
            handle_error: Should self.handle_errors() be called to deal with
                errors during this operation?
        """

        # only iterate over initialized devices
        for dev in filter(lambda x: x.is_initialized, device_list):
            fun = getattr(dev, method, None)
            if fun is None or not callable(fun):
                self.logger.warning(f"{dev} does not have a method '{method}'")
                continue
            try:
                fun()  # call the method
                
                # self.logger.info("starting the {dev.__class__.__name__}")
                
            except HardwareError as he:
                self.logger.info(
                    f"Error {he} encountered while performing {dev}.{method}()"
                    f"handle_error = {handle_error}")
                if handle_error:
                    self.handle_errors(he)

    def shutdown(self):
        """
        Nicely shut down this server
        """
        if self.tcp.seeking_connection:
            self.tcp.abort()
        
        self.logger.info(f"Attempting to stop devices with stop method")
        self.stop_tasks()
        self.logger.info(f"Attempting to close devices with close method")
        self.close_tasks()
        self.logger.info(f"Disabling all devices")
        for device in self.devices:
            device.enable = False
Exemplo n.º 18
0
class Trainer:

    def __init__(self, agent):
        self.agent = agent
        self.name = "Trainer"

    def start_training_session(self, num_of_episodes):
        for episode_num in range(num_of_episodes):
            self.headline_print("start game of episode number {}".format(episode_num + 1))
            self.game_id = rest_api.create_game(self.name).content.decode("utf-8")
            print("Trainer created game with id: {}".format(self.game_id))
            self.tcp = TCP(self.game_id, self.name, self.on_recieved)
            self.start_game_with_agent(self.game_id)
            self.headline_print("end of episode number {}".format(episode_num + 1))

    def start_game_with_agent(self, game_id):
        env = QuoridorEnv(game_id, "Agent")

        cur_state = env.reset()
        done = False
        steps_num = 0

        while not done:
            steps_num += 1
            action = self.agent.act(cur_state, env)
            new_state, reward, done, _ = env.step(action)
            self.agent.remember(cur_state, action, reward, new_state, done)
            self.agent.replay(env)  # internally iterates default (prediction) model
            self.agent.target_train()  # iterates target model
            cur_state = new_state

        print("\n\nGAME FINISHED IN {} STEPS!\n\n".format(steps_num))

    def on_recieved(self, json_message):
        if json_message["type"] == "NewTurnEvent":
            if json_message["nextPlayerToPlay"] == self.name:
                myLoc = json_message["currentPosition"]
                actions = []
                for move in json_message["avialiableMoves"]:
                    if int(move["x"]) > int(myLoc["x"]):
                        actions.append(3)  # Move Right
                    elif int(move["x"]) < int(myLoc["x"]):
                        actions.append(2)  # Move Left
                    elif int(move["y"]) > int(myLoc["y"]):
                        actions.append(1)  # Move Down
                    elif int(move["y"]) < int(myLoc["y"]):
                        actions.append(0)  # Move Up

                actions_len = len(actions)
                random_i = np.random.randint(0, actions_len)
                act_json = utils.convert_action_to_server(actions[random_i])
                self.tcp.write(act_json)

        elif json_message["type"] == "GameOverEvent":
            pass
        elif json_message["type"] == "RoomStateResponse":
            if len(json_message["players"]) == 2:
                rest_api.start_game(self.game_id)

    def headline_print(self, text):
        print("====================================================")
        print(text)
        print("====================================================")
Exemplo n.º 19
0
class QuoridorEnv(gym.Env):
    """
    players: {
        index: number,
        start_location: number,
        name: string,
        targets: [number]
    }

    """

    def __init__(self, game_id, player_name, is_not_tcp):
        self.game_id = game_id
        self.player_name = player_name
        self.is_my_turn = False
        self.winner_status = GameWinnerStatus.NoWinner
        self.last_turn_illegal = False
        self.action_options = []
        self.winning_points_dim = np.zeros(shape=(9, 9), dtype=int)

        # join_game(self.game_id, self.player_name)

        if not is_not_tcp:
            self.tcp = TCP(game_id, player_name, self.on_recieved)
            self.wait_for_my_turn()

        self.action_space = spaces.Discrete(Global.num_of_actions)

        self.observation_space = spaces.Tuple((
            spaces.MultiBinary([9, 9]),
            spaces.MultiBinary([9, 9]),
            spaces.MultiBinary([9, 9]),
            spaces.MultiBinary([9, 9]),
            spaces.MultiBinary([9, 9])
        ))

        self.seed()

        # Start the first game
        #self.reset()

    def step(self, action):
        assert self.action_space.contains(action)

        action = int(action)
        self.update_board(action)
        self.wait_for_my_turn()
        reward, done = self.calculate_reward()
        self.is_my_turn = False

        # self.print_board()
        return self.board, reward, done, {}

    def wait_for_my_turn(self):
        while not self.is_my_turn:
            pass

    def reset(self):
        # self.board = self.init_board()
        return self.board

    def calculate_reward(self):
        reward = -1
        done = False

        if self.last_turn_illegal:
            reward = -10
            self.last_turn_illegal = False

        if self.winner_status != GameWinnerStatus.NoWinner:
            done = True
            if self.winner_status == GameWinnerStatus.EnvWinner:
                reward = 200
            elif self.winner_status == GameWinnerStatus.EnvLoser:
                reward = -200

        return reward, done

    def update_board(self, action):
        operation = utils.convert_action_to_server(action)
        self.send_to_server(operation)  # WAITING

    def print_board(self):
        os.system('cls')
        print('------- TEAM 600 --------')
        arrays = np.dsplit(self.board, 4)
        for y in range(9):
            for x in range(9):
                print('|', end='')
                if arrays[0][y][x] != 0:
                    print(1, end='')
                elif arrays[1][y][x] != 0:
                    print(2, end='')
                else:
                    print(' ', end='')
                if arrays[3][y][x] != 0:
                    print('|', end='')
                elif y != 0 & arrays[3][y - 1][x] != 0:
                    print('|', end='')
                else:
                    print(' ', end='')

            print('')
            for x_wall in range(9):
                if arrays[2][y][x_wall] != 0:
                    print(' ==', end='')
                elif x_wall != 0 & arrays[2][y][x_wall - 1] != 0:
                    print(' ==', end='')
                else:
                    print(' __', end='')
            print('')

    def get_and_convert_board(self):
        board = json.loads(get_board(self.game_id).content)
        return convert_board(board, self.winning_points_dim)

    def send_to_server(self, operation):
        self.tcp.write(operation)

    def on_recieved(self, json_message):
        if json_message["type"] == "IllegalMove":
            # self.is_my_turn = True
            self.last_turn_illegal = True
        elif json_message["type"] == "NewTurnEvent":
            if json_message["nextPlayerToPlay"] == self.player_name:
                self.board = self.get_and_convert_board()
                self.is_my_turn = True
                self.update_action_options(json_message)
        elif json_message["type"] == "GameOverEvent":
            self.is_my_turn = True
            if json_message["winnerName"] == self.player_name:
                self.winner_status = GameWinnerStatus.EnvWinner
            else:
                self.winner_status = GameWinnerStatus.EnvLoser
        elif json_message["type"] == "StartGameMessage":
            self.update_winning_locations(json_message["players"])

    def action_shape(self):
        return action_shape()

    def observation_shape(self):
        return observation_shape()

    def update_action_options(self, moves_json):
        self.action_options = []

        myLoc = moves_json["currentPosition"]
        for move in moves_json["avialiableMoves"]:
            if int(move["x"]) > int(myLoc["x"]):
                self.action_options.append(3)  # Move Right
            elif int(move["x"]) < int(myLoc["x"]):
                self.action_options.append(2)  # Move Left
            elif int(move["y"]) > int(myLoc["y"]):
                self.action_options.append(1)  # Move Down
            elif int(move["y"]) < int(myLoc["y"]):
                self.action_options.append(0)  # Move Up

        for wall in moves_json["availableWalls"]:
            wall_action = 4 + wall["position"]["x"] + (8 * wall["position"]["y"])
            if wall["wallDirection"] == "Down":
                wall_action += 64
            self.action_options.append(wall_action)

    def get_action_options(self):
        return self.action_options

    def update_winning_locations(self, players):
        for player in players:
            if player["name"] == self.player_name:
                for loc in player["endLine"]:
                    x = int(loc["x"])
                    y = int(loc["y"])
                    self.winning_points_dim[y, x] = 1
        print(self.winning_points_dim)
Exemplo n.º 20
0
class Robot(object):
    def __init__(self, ipAddress):
        self.sq = Queue()
        self.rq = Queue()
        self.struct = Struct('BBbB')  #command, selector, value, checksum
        self.sender = TCP(isServer=False,
                          isSender=True,
                          host=ipAddress,
                          port=1234,
                          q=self.sq)
        self.receiver = TCP(isServer=False,
                            isSender=False,
                            host=ipAddress,
                            port=5678,
                            q=self.rq)

    def motor(self, device, value):
        self.send(1, device, value)

    def send(self, command, device, value):
        self.sq.put(self.struct.pack(command, device, value))

    def connect(self):
        self.sender.start()
        self.receiver.start()

    def listen(self):
        pass

    def disconnect(self):
        while not self.sq.empty():
            sleep(0.01)
        self.sender.running = False
        self.receiver.running = False
        self.sender.disconnect()
        self.receiver.disconnect()
        self.sender.join()
        self.receiver.join()
Exemplo n.º 21
0
    def run(self):
        # parameters
        Sim.scheduler.reset()
        logging.getLogger('app').setLevel(logging.INFO)
        logging.getLogger('bene.link.queue').setLevel(logging.DEBUG)
        logging.getLogger('bene.tcp.sequence').setLevel(logging.DEBUG)
        logging.getLogger('bene.tcp.cwnd').setLevel(logging.DEBUG)
        if self.debug:
            logging.getLogger('bene.tcp').setLevel(logging.DEBUG)
            logging.getLogger('bene.tcp.sender').setLevel(logging.DEBUG)
            logging.getLogger('bene.tcp.receiver').setLevel(logging.DEBUG)

        # setup network
        net = Network('networks/one-hop-q10.txt')
        net.loss(self.loss)

        # setup routes
        n1 = net.get_node('n1')
        n2 = net.get_node('n2')
        n1.add_forwarding_entry(n2.get_address('n1'), n1.links[0])
        n2.add_forwarding_entry(n1.get_address('n2'), n2.links[0])

        # setup transport
        t1 = Transport(n1)
        t2 = Transport(n2)

        # setup application
        a = AppHandler(self.filename)

        window = self.wsize

        # setup connection
        drop = []
        c1 = TCP(t1,
                 n1.get_address('n2'),
                 1,
                 n2.get_address('n1'),
                 1,
                 a,
                 window=window,
                 drop=drop,
                 retran=self.retran)
        c2 = TCP(t2,
                 n2.get_address('n1'),
                 1,
                 n1.get_address('n2'),
                 1,
                 a,
                 window=window)
        # send a file
        strin = ""
        times = []
        for i in range(5):
            with open(self.filename, 'rb') as f:
                while True:
                    data = f.read(1000)
                    if not data:
                        break
                    Sim.scheduler.add(delay=0, event=data, handler=c1.send)
                # break
            Sim.scheduler.run()
            times.append(Sim.scheduler.current_time())
            Sim.scheduler.reset()
        times.append(sum(times) / len(times))
        with open("report/w10000_TESTING.txt", 'w') as f2:
            f2.writelines(["%s\n" % item for item in times])
Exemplo n.º 22
0
    def run(self):
        # parameters
        Sim.scheduler.reset()
        logging.getLogger('app').setLevel(logging.INFO)
        logging.getLogger('bene.link.queue').setLevel(logging.DEBUG)
        logging.getLogger('bene.tcp.sequence').setLevel(logging.DEBUG)
        logging.getLogger('bene.tcp.cwnd').setLevel(logging.DEBUG)
        if self.debug:
            logging.getLogger('bene.tcp').setLevel(logging.DEBUG)
            logging.getLogger('bene.tcp.sender').setLevel(logging.DEBUG)
            logging.getLogger('bene.tcp.receiver').setLevel(logging.DEBUG)

        # setup network
        net = Network('../networks/one-hop.txt')
        net.loss(self.loss)

        # setup routes
        n1 = net.get_node('n1')
        n2 = net.get_node('n2')
        n1.add_forwarding_entry(n2.get_address('n1'), n1.links[0])
        n2.add_forwarding_entry(n1.get_address('n2'), n2.links[0])

        # setup transport
        t1 = Transport(n1)
        t2 = Transport(n2)

        # setup application
        a = AppHandler(self.filename)

        window = self.window
        increment = 0

        # setup connection
        drop = []
        c1 = TCP(t1,
                 n1.get_address('n2'),
                 1,
                 n2.get_address('n1'),
                 1,
                 a,
                 window=window,
                 drop=drop,
                 fast=self.fast,
                 com_seq_num=self.com_seq_num,
                 increment=increment)
        c2 = TCP(t2,
                 n2.get_address('n1'),
                 1,
                 n1.get_address('n2'),
                 1,
                 a,
                 window=window)

        # send a file
        with open(self.filename, 'rb') as f:
            while True:
                data = f.read(1000)
                if not data:
                    break
                Sim.scheduler.add(delay=0, event=data, handler=c1.send)

        # run the simulation
        Sim.scheduler.run()
Exemplo n.º 23
0
 def checkServerMailTCP(payloadToBeChecked):
     patternT1 = re.compile("HELO", flags=2)  # --->124 same 1
     #$SMTP_SERVERS 25 destination ip and port msg:"SERVER-MAIL Exim gethostbyname heap buffer overflow attempt"
     patternT2 = re.compile("\\x0A", flags=2)  #-->124 NOT |0A| same 1
     # $SMTP_SERVERS 25 destination ip and port msg:"SERVER-MAIL Exim gethostbyname heap buffer overflow attempt"
     patternT3 = re.compile("EHLO", flags=2)  #--->125 not patternT2 same 1
     # $SMTP_SERVERS 25 destination ip and port msg:"SERVER-MAIL Exim gethostbyname heap buffer overflow attempt"
     patternT4 = re.compile("Content-Disposition\\x3A",
                            flags=2)  #same 2   --->145
     # $SMTP_SERVERS 25 msg "SERVER-MAIL Content-Disposition attachment"
     patternT5 = re.compile("attachment", flags=2)  #same 2 --->145
     # $SMTP_SERVERS 25 msg "SERVER-MAIL Content-Disposition attachment"
     patternT6 = re.compile("WorldMail IMAP4 Server", flags=2)  #--->148
     #$HOME_NET 143 source ip then source port msg:"SERVER-MAIL Qualcomm WorldMail Server Response"
     patternT7 = re.compile("BM", flags=2)  #-->181
     # $SMTP_SERVERS 25 destination msg:"SERVER-MAIL IBM Domino BMP color palette stack buffer overflow attempt"
     patternT8 = re.compile("\\x00 \\x00 \\x00 \\x00", flags=2)  # -->181
     # $SMTP_SERVERS 25 destination msg:"SERVER-MAIL IBM Domino BMP color palette stack buffer overflow attempt"
     patternT9 = re.compile("\\x28 \\x00 \\x00 \\x00|", flags=2)  # -->181
     # $SMTP_SERVERS 25 destination msg:"SERVER-MAIL IBM Domino BMP color palette stack buffer overflow attempt"
     patternT10 = re.compile(
         "GIF89a", flags=2)  # -->184,185 -->$FILE_DATA_PORTS source port
     #$SMTP_SERVERS 25 destination msg:"SERVER-MAIL IBM Lotus Domino Server nrouter.exe malformed GIF parsing remote exploit attempt"
     patternT11 = re.compile(
         "\\x21 \\xF9 \\x04",
         flags=2)  # -->184,185-->$FILE_DATA_PORTS source port
     # $SMTP_SERVERS 25 destination msg:"SERVER-MAIL IBM Lotus Domino Server nrouter.exe malformed GIF parsing remote exploit attempt"
     patternT12 = re.compile(
         "\\x00 \\x2C",
         flags=2)  # -->184 ,185--> $FILE_DATA_PORTS source port
     # $SMTP_SERVERS 25 destination msg:"SERVER-MAIL IBM Lotus Domino Server nrouter.exe malformed GIF parsing remote exploit attempt"
     if re.search(patternT1, payloadToBeChecked) and (not re.search(
             patternT2,
             payloadToBeChecked)) and TCP.getdestinationPort() == "25":
         print("Alert!!!\t", "SQL sa login failed")
     if re.search(patternT3,
                  payloadToBeChecked) and TCP.getdestinationPort() == "25":
         print(
             "Alert!!!\t",
             "SERVER-MAIL Exim gethostbyname heap buffer overflow attempt")
     if re.search(patternT4, payloadToBeChecked) and re.search(
             patternT5,
             payloadToBeChecked) and TCP.getdestinationPort() == "25":
         print("Alert!!!\t", "SERVER-MAIL Content-Disposition attachment")
     if re.search(patternT6,
                  payloadToBeChecked) and TCP.getsourcePort() == "143":
         print("Alert!!!\t",
               "SERVER-MAIL Qualcomm WorldMail Server Response")
     if re.search(patternT7, payloadToBeChecked) and re.search(
             patternT8, payloadToBeChecked) and re.search(
                 patternT9,
                 payloadToBeChecked) and TCP.getdestinationPort() == "25":
         print(
             "Alert!!!\t",
             "SERVER-MAIL IBM Domino BMP color palette stack buffer overflow attempt"
         )
     if re.search(patternT10, payloadToBeChecked) and re.search(
             patternT11, payloadToBeChecked) and re.search(
                 patternT12,
                 payloadToBeChecked) and TCP.getdestinationPort() == "25":
         print(
             "Alert!!!\t",
             "SERVER-MAIL IBM Lotus Domino Server nrouter.exe malformed GIF parsing remote exploit attempt"
         )
Exemplo n.º 24
0
    def run(self):
        # parameters
        Sim.scheduler.reset()
        Sim.set_debug('AppHandler')
        Sim.set_debug('TCP')

        # setup network
        if self.use_queue:
            net = Network('networks/one-hop-queue.txt')
        else:
            net = Network('networks/one-hop.txt')
        net.loss(self.loss)

        # setup routes
        n1 = net.get_node('n1')
        n2 = net.get_node('n2')
        n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0])
        n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0])

        # setup transport
        t1 = Transport(n1)
        t2 = Transport(n2)

        # setup application
        a = AppHandler(self.filename)

        # setup connection
        c1 = TCP(t1,
                 n1.get_address('n2'),
                 1,
                 n2.get_address('n1'),
                 1,
                 a,
                 window=self.window,
                 threshold=self.threshold,
                 fast_recovery=self.fast_recovery)
        c2 = TCP(t2,
                 n2.get_address('n1'),
                 1,
                 n1.get_address('n2'),
                 1,
                 a,
                 window=self.window,
                 threshold=self.threshold,
                 fast_recovery=self.fast_recovery)

        # send a file
        with open(self.filename, 'r') as f:
            while True:
                data = f.read(1000)
                if not data:
                    break
                Sim.scheduler.add(delay=0, event=data, handler=c1.send)

        # run the simulation
        Sim.scheduler.run()

        # print some results
        print
        print "========== Overall results =========="
        time = Sim.scheduler.current_time()
        print "Total time: %f seconds" % time
        avg = numpy.mean(c2.queueing_delay_list)
        print "Average queueing delay: %f" % avg
        max = numpy.max(c2.queueing_delay_list)
        print "Max queueing delay: %f" % max
        file_size = os.path.getsize(self.filename)
        print "File size: %i" % file_size
        throughput = file_size / time
        print "Throughput: %f" % throughput

        print "%i,%f,%f,%f,%i,%f\n" % (self.window, time, avg, max, file_size,
                                       throughput)
        if self.loss == 0.0:
            print "Outputing results to experiment.csv"
            output_fh = open('experiment.csv', 'a')
            output_fh.write(
                "%i,%f,%f,%f,%i,%f\n" %
                (self.window, time, avg, max, file_size, throughput))
            output_fh.close()

        print "Saving the sequence plot"
        self.create_sequence_plot(c1.x, c1.y, c1.dropX, c1.dropY, c1.ackX,
                                  c1.ackY)
Exemplo n.º 25
0
def test_format_data():
    test_name = "Test"
    test_data = "one, two, three, four"
    expected_message = "b'\\x00\\x00\\x00\\x04'Testb'\\x00\\x00\\x00\\x15'one, two, three, four"
    assert TCP.format_data(name=test_name, data=test_data) == expected_message
Exemplo n.º 26
0
 def __init__(self):
     TCP.__init__(self)
     self.cwnd = 1000
Exemplo n.º 27
0
# This file is part of openWNS (open Wireless Network Simulator)
# _____________________________________________________________________________
#
# Copyright (C) 2004-2007
# Chair of Communication Networks (ComNets)
# Kopernikusstr. 16, D-52074 Aachen, Germany
# phone: ++49-241-80-27910,
# fax: ++49-241-80-22242
# email: [email protected]
# www: http://www.openwns.org
# _____________________________________________________________________________
#
# openWNS is free software; you can redistribute it and/or modify it under the
# terms of the GNU Lesser General Public License version 2 as published by the
# Free Software Foundation;
#
# openWNS is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
# A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
# details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
###############################################################################

import openwns
import tcp.TCP

openwns.simulator.OpenWNS.modules.tcp = TCP.TCP()
Exemplo n.º 28
0
    def checkServerOtherTCP(payloadToBeChecked):
        patternT1 = re.compile('edit\.action\?', flags=2)  #72
        #$HOME_NET $HTTP_PORTS destination (msg:"SERVER-OTHER Apache Struts2 skillName remote code execution attempt"
        patternT2 = re.compile("skillName=\\x7B \\x28 \\x23", flags=2)  #72
        patternT3 = re.compile("SOAPAction\\x3A,flags=2")  #101
        #$HOME_NET [$HTTP_PORTS,5555] destination (msg:"SERVER-OTHER MiniUPnPd ExecuteSoapAction buffer overflow attempt"
        patternT4 = re.compile("\x75", flags=2)  #109
        #$HOME_NET 3000 (msg:"SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"
        patternT5 = re.compile("nsrmm", flags=2)  #109
        # $HOME_NET 3000 (msg:"SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"
        patternT6 = re.compile("mmpool", flags=2)  # 110
        # $HOME_NET 3000 (msg:"SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"
        patternT7 = re.compile("mmlocate", flags=2)  # 111
        # $HOME_NET 3000 (msg:"SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"
        patternT8 = re.compile("nsrjb", flags=2)  # 112
        # $HOME_NET 3000 (msg:"SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"
        patternT9 = re.compile("\\x18 \\x03 \\x03", flags=2)  # 645
        #$HOME_NET [21,25,443,465,636,992,993,995,2484] -> $EXTERNAL_NET any
        # (msg:"SERVER-OTHER OpenSSL TLSv1.2 large heartbeat response - possible ssl heartbleed attempt"
        patternT10 = re.compile("\\x18 \\x03 \\x02", flags=2)  # 646
        # $HOME_NET [21,25,443,465,636,992,993,995,2484] -> $EXTERNAL_NET any
        # (msg:"SERVER-OTHER OpenSSL TLSv1.1 large heartbeat response - possible ssl heartbleed attempt"
        patternT11 = re.compile("\\x18 \\x03 \\x00", flags=2)  # 647
        # $HOME_NET [21,25,443,465,636,992,993,995,2484] -> $EXTERNAL_NET any
        # (msg:"SERVER-OTHER OpenSSL TLSv1 large heartbeat response - possible ssl heartbleed attempt"
        patternT12 = re.compile("\\x18 \\x03 \\x01", flags=2)  # 648 --->652
        # $HOME_NET [21,25,443,465,636,992,993,995,2484] -> $EXTERNAL_NET any
        # (msg:"SERVER-OTHER OpenSSL TLSv3 large heartbeat response - possible ssl heartbleed attempt"
        patternT13 = re.compile("\\x18 \\x03 \\x03", flags=2)  #
        #$EXTERNAL_NETany -> $HOME_NET[21, 25, 443, 465, 636, 992, 993, 995, 2484](msg:"SERVER-OTHER OpenSSL TLSv1.2 heartbeat read overrun attempt"
        patternT14 = re.compile("\\x18 \\x03 \\x02", flags=2)  #
        # $HOME_NET 3000 (msg:"SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"
        patternT15 = re.compile("\\x18 \\x03 \\x00", flags=2)  # 112
        # $HOME_NET 3000 (msg:"SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"
        patternT16 = re.compile("\\x18 \\x03 \\x01", flags=2)  # 112
        # $HOME_NET 3000 (msg:"SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"
        patternT17 = re.compile("\\x18 \\x03 \\x01", flags=2)  # 112
        # $HOME_NET 3000 (msg:"SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"
        patternT18 = re.compile("\\x18 \\x03 \\x01", flags=2)  # 112
        # $HOME_NET 3000 (msg:"SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"
        patternT19 = re.compile("\\x18 \\x03 \\x01", flags=2)  # 112
        # $HOME_NET 3000 (msg:"SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"
        patternT20 = re.compile("\\x18 \\x03 \\x01", flags=2)  # 112
        # $HOME_NET 3000 (msg:"SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"

        if ((re.search(patternT1, payloadToBeChecked))
                and (re.search(patternT2, payloadToBeChecked))):
            print(
                "Alert!!!\t",
                "SERVER-OTHER Apache Struts2 skillName remote code execution attempt"
            )
        if (re.search(patternT3, payloadToBeChecked)):
            print(
                "Alert!!!\t",
                "SERVER-OTHER MiniUPnPd ExecuteSoapAction buffer overflow attempt"
            )
        if (re.search(patternT4, payloadToBeChecked)
                and (TCP.getdestinationPort() == "3000")
                and re.search(patternT5, payloadToBeChecked)):
            print(
                "Alert!!!\t",
                "SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"
            )
        if (re.search(patternT4, payloadToBeChecked)
                and (TCP.getdestinationPort() == "3000")
                and re.search(patternT6, payloadToBeChecked)):
            print(
                "Alert!!!\t",
                "SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"
            )
        if (re.search(patternT4, payloadToBeChecked)
                and (TCP.getdestinationPort() == "3000")
                and re.search(patternT7, payloadToBeChecked)):
            print(
                "Alert!!!\t",
                "SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"
            )
        if (re.search(patternT4, payloadToBeChecked)
                and (TCP.getdestinationPort() == "3000")
                and re.search(patternT8, payloadToBeChecked)):
            print(
                "Alert!!!\t",
                "SERVER-OTHER EMC AlphaStor Device Manager command injection attempt"
            )
        if (re.search(patternT9, payloadToBeChecked)) and (
                TCP.getsourcePort() == "21" or TCP.getsourcePort() == "443"
                or TCP.getsourcePort() == "25" or TCP.getsourcePort() == "993"
                or TCP.getsourcePort() == "992" or TCP.getsourcePort() == "636"
                or TCP.getsourcePort() == "465" or TCP.getsourcePort() == "995"
                or TCP.getsourcePort() == "2484"):
            print(
                "Alert!!!\t",
                "SERVER-OTHER OpenSSL TLSv1.2 large heartbeat response - possible ssl heartbleed attempt"
            )
        if (re.search(patternT10, payloadToBeChecked)) and (
                TCP.getsourcePort() == "21" or TCP.getsourcePort() == "443"
                or TCP.getsourcePort() == "25" or TCP.getsourcePort() == "993"
                or TCP.getsourcePort() == "992" or TCP.getsourcePort() == "636"
                or TCP.getsourcePort() == "465" or TCP.getsourcePort() == "995"
                or TCP.getsourcePort() == "2484"):
            print(
                "Alert!!!\t",
                "SERVER-OTHER OpenSSL TLSv1.1 large heartbeat response - possible ssl heartbleed attempt"
            )
        if (re.search(patternT11, payloadToBeChecked)) and (
                TCP.getsourcePort() == "21" or TCP.getsourcePort() == "443"
                or TCP.getsourcePort() == "25" or TCP.getsourcePort() == "993"
                or TCP.getsourcePort() == "992" or TCP.getsourcePort() == "636"
                or TCP.getsourcePort() == "465" or TCP.getsourcePort() == "995"
                or TCP.getsourcePort() == "2484"):
            print(
                "Alert!!!\t",
                "SERVER-OTHER OpenSSL TLSv1 large heartbeat response - possible ssl heartbleed attempt"
            )
        if (re.search(patternT12, payloadToBeChecked)) and (
                TCP.getsourcePort() == "21" or TCP.getsourcePort() == "443"
                or TCP.getsourcePort() == "25" or TCP.getsourcePort() == "993"
                or TCP.getsourcePort() == "992" or TCP.getsourcePort() == "636"
                or TCP.getsourcePort() == "465" or TCP.getsourcePort() == "995"
                or TCP.getsourcePort() == "2484"):
            print(
                "Alert!!!\t",
                "SERVER-OTHER OpenSSL TLSv3 large heartbeat response - possible ssl heartbleed attempt"
            )
        if (re.search(patternT9, payloadToBeChecked)) and (
                TCP.getdestinationPort() == "21" or TCP.getdestinationPort()
                == "443" or TCP.getdestinationPort() == "25"
                or TCP.getdestinationPort() == "993"
                or TCP.getdestinationPort() == "992"
                or TCP.getdestinationPort() == "636"
                or TCP.getdestinationPort() == "465"
                or TCP.getdestinationPort() == "995"
                or TCP.getdestinationPort() == "2484"):
            print(
                "Alert!!!\t",
                "SERVER-OTHER OpenSSL TLSv1.2 heartbeat read overrun attempt")
        if (re.search(patternT10, payloadToBeChecked)) and (
                TCP.getdestinationPort() == "21" or TCP.getdestinationPort()
                == "443" or TCP.getdestinationPort() == "25"
                or TCP.getdestinationPort() == "993"
                or TCP.getdestinationPort() == "992"
                or TCP.getdestinationPort() == "636"
                or TCP.getdestinationPort() == "465"
                or TCP.getdestinationPort() == "995"
                or TCP.getdestinationPort() == "2484"):
            print(
                "Alert!!!\t",
                "SERVER-OTHER OpenSSL TLSv1.1 heartbeat read overrun attempt")
        if (re.search(patternT11, payloadToBeChecked)) and (
                TCP.getdestinationPort() == "21" or TCP.getdestinationPort()
                == "443" or TCP.getdestinationPort() == "25"
                or TCP.getdestinationPort() == "993"
                or TCP.getdestinationPort() == "992"
                or TCP.getdestinationPort() == "636"
                or TCP.getdestinationPort() == "465"
                or TCP.getdestinationPort() == "995"
                or TCP.getdestinationPort() == "2484"):
            print("Alert!!!\t",
                  "SERVER-OTHER OpenSSL TLSv1 heartbeat read overrun attempt")
        if (re.search(patternT12, payloadToBeChecked)) and (
                TCP.getdestinationPort() == "21" or TCP.getdestinationPort()
                == "443" or TCP.getdestinationPort() == "25"
                or TCP.getdestinationPort() == "993"
                or TCP.getdestinationPort() == "992"
                or TCP.getdestinationPort() == "636"
                or TCP.getdestinationPort() == "465"
                or TCP.getdestinationPort() == "995"
                or TCP.getdestinationPort() == "2484"):
            print("Alert!!!\t",
                  "SERVER-OTHER OpenSSL TLSv3 heartbeat read overrun attempt")