示例#1
0
def launch_client(clients_threads, client_id, client_data, routers_data,
                  routers_threads):

    arp_table_mac = data.client_arp_table_generator(client_data["gateway_ip"],
                                                    routers_data)

    default_gateway = client_data["gateway_ip"]

    # find the id of the router to which the server will connect
    for router, router_data in routers_data.items():
        if (router_data["client_side"]["ip_address"] == default_gateway):
            router_id = router
            break

    router_thread = routers_threads[router_id]

    init_params = {
        "clients_threads": clients_threads,
        "arp_table_mac": arp_table_mac,
        "client_data": client_data,
        "client_id": client_id,
        "router_thread": router_thread,
        "router_id": router_id,
        "sync_event_message": sync_event_message,
        "sync_event_connection": sync_event_connection
    }

    client_thread = ClientThread(init_params)

    clients_threads[client_id] = client_thread

    client_thread.start()
示例#2
0
    def serve(self):
        worker_thread = Thread(target=self.tick)
        worker_thread.daemon = True
        worker_thread.start()

        while True:
            connection, address = self.socket_server.accept()
            connection.settimeout(const.SERVER_CONNECTION_TIMEOUT)
            log(f"Server - {address} connected")

            thread = ClientThread(connection, address, self)
            thread.daemon = True
            self.client_pool.append(thread)
            thread.start()
示例#3
0
 def wait_for_connect(self,client_args={}):
     (clientsocket, address) = self.serversocket.accept()
     self.logger.info("Starting client thread %s:%d" % address)
     commands = self._server_commands()
     args = dict(client_args)
     if args.has_key('commands'):
         args['commands'].update(commands)
     else:
         args['commands'] = commands
     ct = ClientThread(sock=clientsocket, address=address, logger=self.logger, args=args)
     ct.cleanup_func   = self._client_stopped
     ct.broadcast_func = self._broadcast
     with self.lock:
         self.clientthreads.append(ct)
     ct.start()
示例#4
0
        if not q.empty():
            r = q.get()
            if isinstance(r, MailDataFrame):
                print(r.data)
            else:
                for i in range(2):
                    if r[-i] in ["\r", "\n"]:
                        r = r[:-i]
                print(r)


HOST = '127.0.0.1'
SERVPORT = 42069
DESTPORT = 25
BACKLOG = 5
msg_q = Queue()
log_q = Queue()
client_thread = ClientThread((HOST, DESTPORT), msg_q, log_q, daemon=True)
client_thread.start()
log = Thread(target=logger, args=(log_q, ), daemon=True)
log.start()

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, SERVPORT))
    i = 0
    while True:
        s.listen(BACKLOG)
        cl_skt, addr = s.accept()
        t = ServerThread(cl_skt, msg_q, log_q, daemon=True)
        t.start()
        i = i + 1
示例#5
0
import sys

if __name__ == "__main__":

    if len(sys.argv) > 1:
        if sys.argv[1] == "-c" or sys.argv[1] == "--cliente":
            # Se entrou aqui é porque deve subir um cliente
            if len(sys.argv) == 3:
                # Pega argumentos ip:porta da linha de comando
                server = sys.argv[2]
                server = server.split(":")
                # Cria thread cliente para ip:porta informados
                # na linha de comando
                server = ClientThread(server[0],server[1])
                server.setName(THREAD_CLIENT)
                server.start()
            else:
                print "forneça ip:porta do servidor."
            
        elif sys.argv[1] == "-s" or sys.argv[1] == "--servidor":
            # Se entrou aqui é porque deve subir um servidor    
            if len(sys.argv) == 3:
                # Pega argumento porta da linha de comando
                porta = sys.argv[2]
                # Cria thread servidor para port
                server = ServerThread(porta)
                server.setName(THREAD_SERVER)
                server.start()
            else:
                print "forneça uma porta para escutar."
                
示例#6
0
class MainWindow(QMainWindow, Ui_MainWindow):
    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)
        self.setupUi(self)

        self.run = True
        self.mode = None        # signals 'server'/'client' mode
        self.input_values = []  # input values retrieve from UI
        self.io_handlers()      # initialize UI components

        # communication/network variables
        self.tcp_main_queue = Queue.Queue()
        self.tcp_sim_queue = Queue.Queue()
        self.thread_event = threading.Event()
        self.data = "meaningless"
        self.custom_data = ''

        self.cm = SceneManager(self.graphicsView)

        self.animations = []
        self.animator = QTimer()    # timer paired with main thread
        self.animator.timeout.connect(self.update)  # timeout callback
        self.update()   # initial call
        

    # links buttons to event handlers
    def io_handlers(self):
        self.btn_start_server.clicked.connect(self.startServer)
        self.btn_start_client.clicked.connect(self.startClient)
        self.btn_stop.clicked.connect(self.stopSimulation)
        self.btn_random_ball.clicked.connect(self.randomBall)
        self.btn_custom_ball.clicked.connect(self.customBall)


    # period callback used to animate 'graphicsView'
    def update(self):
        
        # moves item to location smoothly in one second
        def config_animate_to(t,item,x,y):
            # used to animate an item in specific ways
            animation = QGraphicsItemAnimation()

            # create a timeline (1 sec here)
            timeline = QTimeLine(100)
            timeline.setFrameRange(0,200)   # 200 steps

            #item should at 'x,y' by time 't's
            animation.setPosAt(t,QPointF(x,y))
            animation.setItem(item)             # animate this item
            animation.setTimeLine(timeline)     # with this duration/steps

            return animation

        if (self.run):   # still running

            # check for items received via tcp
            if (not self.tcp_sim_queue.empty()):
                self.cm.deleteItems()
                # item = self.tcp_sim_queue.get() # retrieve value
                msg = self.tcp_sim_queue.get()
                if (type(msg) == type('s')) :
                # self.cm.addItem(item)           # add new item
                    self.cm.addItem(msg)
                else:
                    self.cm.addItems(msg)
            elif (self.custom_data != ''):     # data received from GUI
                # print 'self.custom_data is %s' % self.custom_data     #DEBUG
                self.cm.addItem(self.custom_data)
                self.custom_data = ''


            if (str(self.mode) == 'SERVER'):
                del self.animations[:]  # empty list of prev animations

                # retrieve all items in the graphicsView
                scene_items = self.cm.getItems()

                for item in scene_items:

                    next_x, next_y = self.cm.next_move(item)    # determine next location
                    # create corresponding item animation (given displacement in local coordinates)
                    item_animation = config_animate_to(1,item,next_x,next_y)
                    self.animations.append(item_animation)      # store item animation

                    # update location values of item (global coordiantes)
                    item.set_location(next_x+item.x_start,next_y+item.y_start)

                # signal the start of all animations
                [ animation.timeLine().start() for animation in self.animations]

                # send all simulation items to server thread
                if (len(scene_items) > 0):
                    # retrieve items encoded for TCP
                    tcp_list = self.cm.getItemsForTCP()
                    # print ('Observed: ' + str(tcp_list))    #DEBUG
                    self.tcp_main_queue.put(tcp_list)

            self.animator.start(ANIMATOR_TIMEOUT)


    def startServer(self):
        self.btn_start_client.setEnabled(False)     # disable 'client' button
        # initiate server thread and pass GUI/simulation messgae queues
        self.mode = ServerThread(self.tcp_main_queue,self.thread_event)
        self.mode.daemon = True
        self.mode.start()


    def startClient(self):
        
        try:
            # initiate client thread and pass simulation GUI message queue
            self.mode = ClientThread(self.tcp_sim_queue,self.thread_event)
            self.mode.daemon = True     # thread to close when main thread closes
            self.mode.start()

            # disable all buttons except 'Stop'
            self.btn_start_server.setEnabled(False)
            self.btn_start_client.setEnabled(False)
            self.btn_random_ball.setEnabled(False)
            self.btn_custom_ball.setEnabled(False)
        except Exception:
            print "No server available."


    def stopSimulation(self):
        # disable all buttons
        self.btn_start_server.setEnabled(False)
        self.btn_start_client.setEnabled(False)
        self.btn_stop.setEnabled(False)
        self.btn_random_ball.setEnabled(False)
        self.btn_custom_ball.setEnabled(False)
        
        self.run = False
        self.thread_event.set()
        print 'Main thread stopped'


    def randomBall(self):

        # select random radius, mass, x/y velocities
        mass = random.randint(5, 20)
        radius = int(mass * 2)
        x_vel = random.randint(1,30)
        y_vel = random.randint(1,30)

        # select x/y positions within graphicsView
        x_pos = random.randint(0,SCENE_WIDTH-radius)
        y_pos = random.randint(0,SCENE_HEIGHT-radius)

        # encode data for TCP transport
        self.data = 'x' + str(x_pos) + 'y' + str(y_pos) + 'xv' + str(x_vel) + \
                    'yv' + str(y_vel) + 'm' + str(mass) + 'r' + str(radius)

        # self.tcp_main_queue.put(self.data)
        # self.tcp_sim_queue.put(self.data)
        self.custom_data = self.data

    def customBall(self):
        # create dialog for input
        dialog = CustomDialog()

        # retrieve input from dialog
        if (dialog.exec_()):
            self.input_values = dialog.results
        
        params = ['x','y','xv','yv','m','r']
        self.data = ''

        # encode data for TCP transmission
        for i in range(0,len(self.input_values)):
            self.data += params[i] + str(self.input_values[i])

        # # input in queue for tcp thread
        if (len(self.data) > 0):
            self.custom_data = self.data
示例#7
0
文件: main.py 项目: kNalj/yamb
 def join_server(self, ip):
     ip = self.sender().ip.text()
     client = ClientThread(ip)
     client.start()