def server(): s = WebsocketServer(0, loglevel=logging.DEBUG) server_thread = Thread(target=s.run_forever) server_thread.daemon = True server_thread.start() yield s s.server_close()
def server(): """ Returns the response of a server after""" s = WebsocketServer(0, loglevel=logging.DEBUG) server_thread = Thread(target=s.run_forever) server_thread.daemon = True server_thread.start() yield s s.server_close()
class WebsocketConnection(Thread): def __init__(self, port, message_received_callback): Thread.__init__(self) self.port = port self.num_clients_connected = 0 self.message_received_callback = message_received_callback def run(self): print "starting web socket..." self.websocket_server = WebsocketServer(self.port, "") self.websocket_server.set_fn_new_client(self._new_web_client) self.websocket_server.set_fn_client_left(self._web_client_left) self.websocket_server.set_fn_message_received(self._web_message_received) try: self.websocket_server.run_forever() except: print "Exception" def stop(self): # @TODO: okay, this is not super clean but seems to work for now with an exception popping up... print "Stopping web server..." self.websocket_server.server_close() def is_client_connected(self): return self.num_clients_connected > 0 def send(self, message): self.websocket_server.send_message_to_all(message) def _new_web_client(self, client, server): print "New client connected via web" self.num_clients_connected += 1 def _web_client_left(self, client, server): print "Web client disconnected" self.num_clients_connected -= 1 def _web_message_received(self, client, server, message): print "Message received from web client: " + message self.message_received_callback("web", message)
class WSServer: def __init__(self): self.serv = None self.clients = [] self.previous_messages = [] def start(self): port = 4001 self.serv = WebsocketServer(port, "0.0.0.0") self.serv.set_fn_new_client(self.client_joined) self.serv.set_fn_message_received(self.message_received) self.serv.set_fn_client_left(self.client_left) thr = Thread(target=lambda: self.serv.run_forever()) thr.start() def stop(self): self.serv.shutdown() self.serv.server_close() def send_ws_message(self, msg): if not self.is_enabled(): return self.previous_messages.append(msg) self.serv.send_message_to_all(msg) def is_enabled(self): return self.serv is not None def client_joined(self, client, server): if len(self.previous_messages) == 0: return server.send_message(client, "payload-start") for prev_msg in self.previous_messages: server.send_message(client, prev_msg) server.send_message(client, "payload-end") def message_received(self, client, server): pass def client_left(self, client, server): pass
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings) return ch def startServer(server): print("HMI signals listener was started\r") server.set_fn_new_client(new_client) server.set_fn_client_left(client_left) server.set_fn_message_received(message_received) server.run_forever() def keyBoardEvent(): global server char = ' ' while char != 'q': char = getch() server = WebsocketServer(8081) serverThread = Thread(target=startServer, args=(server, )) keyBoardThread = Thread(target=keyBoardEvent) keyBoardThread.start() serverThread.start() keyBoardThread.join() print("Closing server...") server.shutdown() server.server_close()
class WebsocketServerModule(ModuleProcess): def __init__(self, baseConfig, pInBoundQueue, pOutBoundQueue, loggingQueue): # super(WebsocketServerModule, self).__init__() ModuleProcess.__init__(self, baseConfig, pInBoundQueue, pOutBoundQueue, loggingQueue) self.alive = False self.config = baseConfig self.inQueue = pInBoundQueue # inQueue are messages from the main process to websocket clients self.outQueue = pOutBoundQueue # outQueue are messages from clients to main process self.websocketServer = None self.loggingQueue = loggingQueue self.threadProcessQueue = None # Configs self.moduleConfig = configLoader.load(self.loggingQueue, __name__) # Constants self._port = self.moduleConfig['WebsocketPort'] self._host = self.moduleConfig['WebsocketHost'] # logging setup self.logger = ThreadsafeLogger(loggingQueue, __name__) def run(self): if not self.check_ss_version(): #cant run with wrong version so we return early return False """ Main thread entry point. Sets up websocket server and event callbacks. Starts thread to monitor inbound message queue. """ self.logger.info("Starting websocket server") self.alive = True self.listen() self.websocketServer = WebsocketServer(self._port, host=self._host) self.websocketServer.set_fn_new_client(self.new_websocket_client) self.websocketServer.set_fn_message_received( self.websocket_message_received) self.websocketServer.run_forever() def check_ss_version(self): #check for min version met self.logger.info('Module version %s' % (__version__)) if LooseVersion(self.config['ss_version']) < LooseVersion( self.moduleConfig['MinSimpleSensorVersion']): self.logger.error( 'This module requires a min SimpleSensor %s version. This instance is running version %s' % (self.moduleConfig['MinSimpleSensorVersion'], self.config['ss_version'])) return False return True def new_websocket_client(self, client, server): """ Client joined callback - called whenever a new client joins. """ self.logger.debug("Client joined") def websocket_message_received(self, client, server, message): """ Message received callback - called whenever a new message is received. """ self.logger.debug('Message received: %s' % message) message = json.loads(message) self.logger.info("message jsond: %s" % message) _msg = Message(topic=message['topic'], sender_id=message['sender_id']) if 'sender_type' in message: _msg.sender_type = message['sender_type'] if 'recipients' in message: _msg.recipients = message['recipients'] if 'extended_data' in message: _msg.extended_data = message['extended_data'] self.put_message(_msg) def listen(self): self.threadProcessQueue = Thread(target=self.process_queue) self.threadProcessQueue.setDaemon(True) self.threadProcessQueue.start() def shutdown(self): """ Handle shutdown message. Close and shutdown websocket server. Join queue processing thread. """ self.logger.info("Shutting down websocket server") try: self.logger.info("Closing websocket") self.websocketServer.server_close() except Exception as e: self.logger.error("Websocket close error : %s " % e) try: self.logger.info("Shutdown websocket") self.websocketServer.shutdown() except Exception as e: self.logger.error("Websocket shutdown error : %s " % e) self.alive = False self.threadProcessQueue.join() time.sleep(1) self.exit = True def handle_message(self, message): """ Send message to listening clients. """ self.websocketServer.send_message_to_all(json.dumps(message.__dict__)) def process_queue(self): """ Monitor queue of messages from main process to this thread. """ while self.alive: if (self.inQueue.empty() == False): try: message = self.inQueue.get(block=False, timeout=1) if message is not None: if message.topic.upper() == "SHUTDOWN": self.logger.debug("SHUTDOWN handled") self.shutdown() else: self.handle_message(message) except Exception as e: self.logger.error("Websocket unable to read queue : %s " % e) else: time.sleep(.25)
def on_exit(self, client, server: WebsocketServer): server.server_close()
class WebSocket: def __init__(self): self.server = None self.S = None # Called for every client connecting (after handshake) def new_client(self, client, server): #print("New client connected and was given id %d" % client['id']) str = self.S.getUpdateInfo() server.send_message(client, str) # Called for every client disconnecting def client_left(self, client, server): #print("Client(%d) disconnected" % client['id']) pass def start(self): port = 3344 self.S = S() self.server = WebsocketServer(port, host='0.0.0.0', loglevel=logging.CRITICAL) self.server.set_fn_new_client(self.new_client) self.server.set_fn_client_left(self.client_left) server_thread = threading.Thread(target=self.server.run_forever) server_thread.start() def stop(self): self.server.server_close() def reset(self): self.S.players = [""] * 4 self.S.callsRecord = [""] * 4 self.S.callsRaw = [""] * 4 self.S.threeModeUsers = [""] * 4 self.S.playsRecord = [""] * 4 self.S.playsRaw = [""] * 4 self.S.boutsWinRecord = [] self.S.flowerCountRecord = [0] * 4 self.S.playsPokerHand = [[] for i in range(4)] self.S.threeModeIndex = [-1] * 4 self.S.trump = 'Waiting' self.S.trumpRaw = -1 self.S.attackIndex = [-1] * 2 self.S.attackWinNumber = 7 self.S.attackTeam = '' self.S.attackScore = 0 self.S.defenseTeam = '' self.S.defenseScore = 0 self.S.threeMode = False def setPlayers(self, str): self.S.players = str.split(',') self.server.send_message_to_all(self.S.getUpdateInfo()) def setThreeModePlayers(self, str): self.S.threeModeUsers = str.split(',') def setThreeModeIndex(self, list): self.S.threeModeIndex = list def setPlayersPoker(self, index, cards): cardArray = cards.split(',') for card in cardArray: self.S.playsPokerHand[index].append(int(card)) self.server.send_message_to_all(self.S.getUpdateInfo()) def updateContent(self, str): connectState = str[0:1] info = str[1:] # print connectState,info if connectState == "S": splitArray = info.split(',') trump = int(splitArray[1]) lastUser = int(splitArray[3]) self.S.trump = ("%d%s") % (trump / 7 + 1, Trumps[trump % 7]) self.S.trumpRaw = trump self.S.attackWinNumber = (trump / 7 + 7) if self.S.threeMode: self.S.attackIndex[0] = 0 self.S.attackIndex[1] = 2 else: self.S.attackIndex[0] = (lastUser + 1) % 4 self.S.attackIndex[1] = (lastUser + 3) % 4 attackTeam = '' defenseTeam = '' for i in range(0, 4): player = self.S.players[i] if self.S.threeMode: player = self.S.threeModeUsers[i] if i in self.S.attackIndex: attackTeam = attackTeam + player + ' , ' else: defenseTeam = defenseTeam + player + ' , ' self.S.attackTeam = attackTeam[0:len(attackTeam) - 3] self.S.defenseTeam = defenseTeam[0:len(defenseTeam) - 3] elif connectState == "T": self.S.threeMode = True elif connectState == "C": splitArray = info.split(',') lastUser = int(splitArray[0]) trump = int(splitArray[2]) updateRecord = self.S.callsRecord[lastUser] updateRaw = self.S.callsRaw[lastUser] if trump != -1: tempStr = ("%d%s,") % ((trump / 7) + 1, Trumps[trump % 7]) else: tempStr = "Pass," self.S.callsRecord[lastUser] = updateRecord + tempStr self.S.callsRaw[lastUser] = updateRaw + ("%d^") % trump elif connectState == "P": splitArray = info.split(',') nextUser = int(splitArray[2]) lastUser = (nextUser + 4 - 1) % 4 poker = int(splitArray[0]) playState = Type.PlayState(int(splitArray[1])) if poker != 0: removeIndex = lastUser updateRecord = self.S.playsRecord[lastUser] updateRaw = self.S.playsRaw[lastUser] tempStr = showPokerStr(poker) self.S.playsRecord[lastUser] = updateRecord + tempStr self.S.playsRaw[lastUser] = updateRaw + ("%d^") % poker flower = int((poker - 1) / 13) self.S.flowerCountRecord[flower] += 1 if self.S.threeMode: removeIndex = self.S.threeModeIndex[lastUser] self.S.playsPokerHand[removeIndex].remove(poker) else: if nextUser in self.S.attackIndex: self.S.attackScore += 1 else: self.S.defenseScore += 1 self.S.boutsWinRecord.append(nextUser) if poker != 0: flower = int((poker - 1) / 13) self.S.flowerCountRecord[flower] += 1 for index in range(4): tempStr = self.S.playsRecord[index] tempStr = tempStr[:-1] if index == nextUser: tempStr += "✓," else: tempStr += "✗," self.S.playsRecord[index] = tempStr if playState == Type.PlayState.GameOver: self.recordCSV() self.saveShowRecord() self.server.send_message_to_all(self.S.getUpdateInfo()) def recordCSV(self): #{time},{trump},{threeMode},{name},{call},{play},{threeName} file = open('record.csv', "a+") timeStr = time.strftime("%Y-%m-%d %H:%M", time.localtime()) trumpStr = self.S.trump nameStr = "" for player in self.S.players: nameStr += player + "|" nameStr = nameStr[:-1] callStr = "" for callRaw in self.S.callsRaw: callStr += callRaw[0:-1] + "|" callStr = callStr[:-1] playStr = "" for playRaw in self.S.playsRaw: playStr += playRaw[0:-1] + "|" playStr = playStr[:-1] threeStr = "" if self.S.threeModeUsers[0] != "": for player in self.S.threeModeUsers: threeStr += player + "|" threeStr = threeStr[:-1] file.write("%s,%s,%s,%s,%s,%s\n" % (timeStr, trumpStr, nameStr, callStr, playStr, threeStr)) file.close() def saveShowRecord(self): #{time},{trump},{name},{call},{threeName},{play} file = open('/var/www/html/data/showRecord.csv', "a+") local = pytz.timezone("Etc/GMT+8") naive = datetime.datetime.now() local_dt = local.localize(naive, is_dst=None) utc_dt = local_dt.astimezone(pytz.utc) timeStr = utc_dt.strftime('%Y-%m-%d %H:%M') winFlag = "✓" if (self.S.attackScore < self.S.attackWinNumber): winFlag = "✗" trumpStr = ("%s %s %d:%d") % (self.S.trump, winFlag, self.S.attackScore, self.S.defenseScore) nameStr = "" for player in self.S.players: nameStr += player + "|" nameStr = nameStr[:-1] callStr = "" subCalls = [[], [], [], []] for index in range(4): subCalls[index] = self.S.callsRecord[index].split(',') count = 0 index = 0 length = 0 while 1: subCall = subCalls[index] str = "" if length < len(subCall) and subCall[length] != "": str = subCall[length] elif (subCalls[index] != ""): count += 1 subCalls[index] = "" if count == 4: break callStr += str + " - " if index + 1 == 4: index = 0 length += 1 callStr = callStr[:-2] callStr += "|" else: index += 1 callStr = callStr[:-1] threeStr = "" if self.S.threeModeUsers[0] != "": for player in self.S.threeModeUsers: threeStr += player + "|" threeStr = threeStr[:-1] playStr = "" subPlays = [[], [], [], []] for index in range(4): subPlays[index] = self.S.playsRecord[index].split(',') for i in range(13): for j in range(4): subPlay = subPlays[j] str = subPlay[i] playStr += str + " | " playStr = playStr[:-2] playStr += "," playStr = playStr[:-1] file.write("%s,%s,%s,%s,%s,%s\n" % (timeStr, trumpStr, nameStr, callStr, threeStr, playStr)) file.close()
class WebSocket: def __init__(self): self.server = None self.rooms = None self.clientSelectedRoom = dict() self.debugMode = False # Called for every client connecting (after handshake) def new_client(self,client, server): print("New client connected and was given id %d" % client['id']) self.clientSelectedRoom[client['id']]=-1 if self.rooms == None or len(self.rooms) == 0: server.send_message(client,"0") else: messageStr = self.getRoomInfo(self.rooms) server.send_message(client,"R:"+messageStr) # Called for every client disconnecting def client_left(self,client, server): # print("Client(%d) disconnected" % client['id']) self.clientSelectedRoom.pop(client['id']) print("Client disconnected") pass # Called when a client sends a message def message_received(self,client, server, message): if len(message) > 200: message = message[:200]+'..' print("Client(%d) said: %s" % (client['id'], message)) if message == "debug": self.debugMode = True elif message == "normal": self.debugMode = False else: roomIndex=int(message) self.clientSelectedRoom[client['id']]=roomIndex if roomIndex < len(self.rooms): room = self.rooms[roomIndex] messageStr = self.getUpdateInfo(self.rooms[roomIndex]) server.send_message(client,messageStr) def start(self): port=3344 self.server = WebsocketServer(port,host='0.0.0.0') self.server.set_fn_new_client(self.new_client) self.server.set_fn_client_left(self.client_left) self.server.set_fn_message_received(self.message_received) server_thread = threading.Thread(target=self.server.run_forever) server_thread.daemon = True server_thread.start() def stop(self): self.server.server_close() def findClientFromId(self,clientId): for client in self.server.clients: if client['id'] == clientId: return client return None def updateRooms(self,Rooms,removeIndex): self.rooms=Rooms messageStr = "" if len(self.rooms) != 0: messageStr = self.getRoomInfo(self.rooms) self.server.send_message_to_all("R:"+messageStr) if removeIndex != -1: for key in self.clientSelectedRoom: if self.clientSelectedRoom[key] > removeIndex: self.clientSelectedRoom[key]-=1 elif self.clientSelectedRoom[key] == removeIndex: self.clientSelectedRoom[key]=-1 def updateContent(self,Rooms,roomIndex): self.rooms=Rooms for clientId,selectedIndex in self.clientSelectedRoom.iteritems(): client = self.findClientFromId(clientId) if client == None: continue if selectedIndex == roomIndex: messageStr = self.getUpdateInfo(Rooms[roomIndex]) self.server.send_message(client,messageStr) def getRoomInfo(self,rooms): content = "" for room in rooms: names = "" for index in range(4): name = room.users[index].name names += name if index != 3: names += "、" content += names + "|" content = content[:-1] return content def getUpdateInfo(self,room): # trump^{info}^{Name}^{call}^{three}^{play}^{card} info = "" if room.attackTeam!="": info = room.attackTeam + "|" + ("%d / %d")%(room.attackScore,room.attackWinNumber) + "|" + room.defenseTeam + "|" + ("%d / %d")%(room.defenseScore,14-room.attackWinNumber) name = "" for user in room.users: name += user.name + "|" name = name[:-1] call = "" subCalls = [[],[],[],[]] for index in range(4): subCalls[index] = room.callsRaw[index].split('^') count=0;index=0;length=0 while 1: subCall = subCalls[index] str = "" if length < len(subCall) and subCall[length]!="": str = subCall[length] elif(subCalls[index]!=""): count+=1 subCalls[index]="" if count == 4: break call += str + "," if index+1 == 4: index = 0 length += 1 call = call[:-1] call += "|" else: index += 1 call = call[:-1] three = "" for player in room.threeModeUsers: three += player + "|" three = three[:-1] play = "" subPlays = [[],[],[],[]] for index in range(4): subPlays[index] = room.playsRaw[index].split('^') count=0;index=0;length=0 while 1: subPlay = subPlays[index] str = "" if length < len(subPlay): str = subPlay[length] if count == 13: break play += str + "," if index+1 == 4: index = 0 length += 1 count += 1 play = play[:-1] play += "|" else: index += 1 play = play[:-1] winBount = room.boutsWinRecord[:-1] flower = "" for index in range(4): flower += ("%d|")%room.flowerCountRecord[index] flower = flower[:-1] card = "" if room.users[0].name!="": for index in range(4): str = "" for poker in room.playsPokerHand[index]: str += ("%d,")%poker card += str[:-1] + "|" card = card[:-1] return ("%d")%room.getTrump() + "^" + info + "^" + name + "^" + call + "^" + three + "^" + play + "^" + winBount + "^"+ flower + "^" +card
tty.setraw(sys.stdin.fileno()) ch = sys.stdin.read(1) finally: termios.tcsetattr(fd, termios.TCSADRAIN, old_settings) return ch def startServer(server): print("HMI signals listener was started\r") server.set_fn_new_client(new_client) server.set_fn_client_left(client_left) server.set_fn_message_received(message_received) server.run_forever() def keyBoardEvent(): global server char = ' ' while char != 'q': char = getch() server = WebsocketServer(8081) serverThread = Thread(target = startServer, args = (server, )) keyBoardThread = Thread(target = keyBoardEvent) keyBoardThread.start() serverThread.start() keyBoardThread.join() print("Closing server...") server.shutdown() server.server_close()
class CloudLink: def __init__(self): self.wss = None self.users = {} self.userlist = [] self.handlers = [] self.gdata = "" self.mode = 0 # 1=Host, 2=Client, 3=Plugin def host(self, port): if serverModeSupport: self.mode = 1 self.wss = WebsocketServer( int(port) ) # Instanciate WebsocketServer alongside CloudLink module # Define callbacks to functions self.wss.set_fn_new_client(self.newConnection) self.wss.set_fn_message_received(self.gotPacket) self.wss.set_fn_client_left(self.closedConnection) # Run the server print("Now running in host mode on port {0}...".format(port)) try: self.wss.serve_forever() except KeyboardInterrupt: if not len(self.users) == 0: print("Shutdown in progress, please wait...") # Tell all users to disconnect, and wait until all are disconnected self.wss.send_message_to_all(json.dumps({"cmd": "ds"})) while not len(self.users) == 0: pass print("All users disconnected, now exiting...") else: print("Now exiting...") self.wss.server_close() else: print( "Error! Couldn't initialize mode 1: Support for Server mode has been disabled since you don't have the required websocket_server.py!" ) sys.exit() def client(self): if clientOrPluginModeSupport: self.mode = 2 print("Oops. This is a WIP feature. Sorry...") sys.exit() else: print( "Error! Couldn't initialize mode 2: Support for Client mode has been disabled since you don't have the required library websocket-client!" ) sys.exit() def plugin(self): if clientOrPluginModeSupport: self.mode = 3 print("Oops. This is a WIP feature. Sorry...") sys.exit() else: print( "Error! Couldn't initialize mode 3: Support for Plugin mode has been disabled since you don't have the required library websocket-client!" ) sys.exit() def newConnection(self, client, server): if self.mode == 1: print("New connection: {0}".format(client['id'])) self.users[str(client)] = {"name": "", "id": str(client['id'])} self.relayUserList(server, True, client) self.sendPacket(server, True, { "cmd": "gmsg", "id": client, "val": str(self.gdata) }) def sendPacket(self, server, type, data): # False:Public, True:Private if self.mode == 1: if "id" in data: id = data["id"] del data["id"] if type == False: server.send_message_to_all(json.dumps(data)) elif type == True: server.send_message(id, json.dumps(data)) def relayUserList(self, server, type, id): if self.mode == 1: y = "" for x in range(len(self.userlist)): y = str(y + self.userlist[x] + ";") self.sendPacket(server, type, { "cmd": "ulist", "id": id, "val": str(y) }) def closedConnection(self, client, server): if self.mode == 1: if str(client) in self.users: if self.users[str(client)]['name'] in self.userlist: print("Connection closed: {0} ({1})".format( self.users[str(client)]['name'], client['id'])) else: print("Connection closed: {0}".format(client['id'])) if self.users[str(client)]['name'] in self.userlist: del self.userlist[self.userlist.index( self.users[str(client)]['name'])] if client in self.handlers: del self.handlers[self.handlers.index(client)] del self.users[str(client)] if not len(self.users) == 0: self.relayUserList(server, False, client) def gotPacket(self, client, server, message): if self.mode == 1: err = False try: packet = json.loads(message) except Exception as e: err = True finally: if not err: if "cmd" in packet: # Check if the cmd parameter is specified cmd = packet['cmd'] if "val" in packet: val = packet["val"] else: val = "" if "id" in packet: try: id = self.handlers[self.userlist.index( str(packet['id']))] except Exception as e: id = "" else: id = "" if "name" in packet: name = str(packet['name']) else: name = "" if cmd == "clear": # Clears comms self.sendPacket(server, False, { "cmd": "gmsg", "val": "" }) self.sendPacket(server, False, { "cmd": "pmsg", "val": "" }) if cmd == "setid": # Set username on server link if "val" in packet: if not client in self.handlers: self.userlist.append(val) self.handlers.append(client) else: if self.users[str( client)]['name'] in self.userlist: self.userlist[self.userlist.index( self.users[str( client)]['name'])] = val self.users[str(client)]['name'] = val print("User {0} declared username: {1}".format( client['id'], self.users[str(client)]['name'])) self.relayUserList(server, False, client) if cmd == "gmsg": # Set global stream data values self.gdata = str(val) self.sendPacket(server, False, { "cmd": "gmsg", "val": self.gdata }) if cmd == "pmsg": # Set private stream data values if not id == "": self.sendPacket(server, True, { "cmd": "pmsg", "id": id, "val": val }) if cmd == "gvar": # Set global variable data values self.sendPacket(server, False, { "cmd": "gvar", "name": name, "val": val }) if cmd == "pvar": # Set private variable data values if not id == "": self.sendPacket( server, True, { "cmd": "pvar", "name": name, "id": id, "val": val })
class ServerWs(threading.Thread): def __init__(self, bartender): threading.Thread.__init__(self) self.bartender = bartender self.bartender.log("ServerWs", "Initialisation...") self.server = None def run(self): self.bartender.log( "ServerWs", f"Démarrage du serveur websocket sur l'adresse {self.bartender.config['ws']['ip']}:{self.bartender.config['ws']['port']}..." ) try: self.server = WebsocketServer( self.bartender.config["ws"]["port"], host=self.bartender.config["ws"]["ip"], loglevel=logging.NOTSET) self.server.set_fn_new_client(self.new_client) self.server.set_fn_message_received(self.message_received) self.server.set_fn_client_left(self.client_left) self.bartender.log("ServerWs", "Serveur démarré") self.server.run_forever() except Exception as e: self.bartender.log( "ServerWs", "Erreur lors du démarrage du serveur : " + str(e)) def close(self): self.bartender.log("ServerWs", "Arrêt du serveur websocket...") try: self.server.server_close() self.server = None self.bartender.log("ServerWs", "Arrêté") except Exception as e: self.bartender.log("ServerWs", "Erreur lors de l'arrêt du serveur : " + str(e)) def send_message(self, client, msg): self.bartender.log("ServerWs", f"Envoie (id:{client['id']}) : {msg}") self.server.send_message(client, msg) def send_message_to_all(self, msg): # self.bartender.log("ServerWs", f"Envoie (all) : {msg}") for client in self.server.clients: if (client != self.bartender.ethylotest): self.server.send_message(client, msg) def message_received(self, client, server, msg): self.bartender.log("ServerWs", f"Reçu (id:{client['id']}) : {msg}") self.bartender.message_received(client, server, msg) def new_client(self, client, server): self.bartender.log("ServerWs", f"Nouvelle connexion (id:{client['id']})") self.bartender.newClient(client, server) def client_left(self, client, server): self.bartender.log("ServerWs", f"Déconnexion (id:{client['id']})") self.bartender.clientLeft(client, server) def getOtherClients(self, client): clients = [] for other in self.server.clients: if (other != client): clients.append(other) return clients def kickClient(self, client): client['handler'].send_text("", opcode=0x8)
class RTC_Spider2020_Info(OpenRTM_aist.DataFlowComponentBase): ## # @brief constructor # @param manager Maneger Object # def __init__(self, manager): OpenRTM_aist.DataFlowComponentBase.__init__(self, manager) self._d_GCCapacityRatio_In = OpenRTM_aist.instantiateDataType( RTC.TimedDouble) """ ゲームコントローラのバッテリ残容量比 - Unit: [%] """ self._GCCapacityRatio_InIn = OpenRTM_aist.InPort( "GCCapacityRatio_In", self._d_GCCapacityRatio_In) self._d_MainCapacityRatio_In = OpenRTM_aist.instantiateDataType( RTC.TimedDouble) """ メインバッテリのバッテリ残容量比 - Unit: [%] """ self._MainCapacityRatio_InIn = OpenRTM_aist.InPort( "MainCapacityRatio_In", self._d_MainCapacityRatio_In) self._d_Mode_In = OpenRTM_aist.instantiateDataType(RTC.TimedLongSeq) """ 動作指令の状態 - Number: 6 - Semantics: [0]: 操作モード [1]: 走行操作 速度レベル [2]: 走行操作 最大速度フラグ [3]: 走行モード フリッパーの選択状態 [4]: 走行モード フリッパーの動作状態 [5]: 走行モード 台車の位置姿勢のクリア """ self._Mode_InIn = OpenRTM_aist.InPort("Mode_In", self._d_Mode_In) self._d_Pose3D_In = OpenRTM_aist.instantiateDataType(RTC.TimedPose3D) """ 3次元の位置・姿勢 - Unit: 位置:[m], 姿勢:[rad] """ self._Pose3D_InIn = OpenRTM_aist.InPort("Pose3D_In", self._d_Pose3D_In) self._d_Velocity2D_In = OpenRTM_aist.instantiateDataType( RTC.TimedVelocity2D) """ メインクローラの速度 - Unit: [m/s] """ self._Velocity2D_InIn = OpenRTM_aist.InPort("Velocity2D_In", self._d_Velocity2D_In) self._d_FlipperAngle_In = OpenRTM_aist.instantiateDataType( RTC.TimedDoubleSeq) """ フリッパーの角度 - Number: 4 - Semantics: [0]: 右前方フリッパー [1]: 左前方フリッパー [2]: 右後方フリッパー [3]: 左後方フリッパー - Unit: [rad] """ self._FlipperAngle_InIn = OpenRTM_aist.InPort("FlipperAngle_In", self._d_FlipperAngle_In) self._d_MotorLoad_In = OpenRTM_aist.instantiateDataType( RTC.TimedDoubleSeq) """ モータの負荷 - Number: 6 - Semantics: [0]: 右メインモータ [1]: 左メインモータ [2]: 右前方サブモータ [3]: 左前方サブモータ [4]: 右後方サブモータ [5]: 左後方サブモータ - Unit: [A] """ self._MotorLoad_InIn = OpenRTM_aist.InPort("MotorLoad_In", self._d_MotorLoad_In) self._d_Arm1Pose3D_In = OpenRTM_aist.instantiateDataType( RTC.TimedPose3D) """ アーム1の3次元の位置・姿勢 (ロボット座標系) - Unit: 位置:[m], 姿勢:[rad] """ self._Arm1Pose3D_InIn = OpenRTM_aist.InPort("Arm1Pose3D_In", self._d_Arm1Pose3D_In) self._d_Arm1Angular_In = OpenRTM_aist.instantiateDataType( RTC.TimedDoubleSeq) """ アーム1の腕の角度 - Semantics: [0]: 1軸目 [1]: 2軸目 [2]: 3軸目 [3]: 4軸目 [4]: 5軸目 [5]: 6軸目 - Unit: [rad] """ self._Arm1Angular_InIn = OpenRTM_aist.InPort("Arm1Angular_In", self._d_Arm1Angular_In) self._d_Arm1Finger_In = OpenRTM_aist.instantiateDataType( RTC.TimedLongSeq) """ アーム1の指の開閉具合 - Semantics: [0]: 親指 [1]: 差指 [2]: 中指 - Unit: [u] (独自単位) """ self._Arm1Finger_InIn = OpenRTM_aist.InPort("Arm1Finger_In", self._d_Arm1Finger_In) self._d_Arm1Current_In = OpenRTM_aist.instantiateDataType( RTC.TimedDoubleSeq) """ アーム1のモータ負荷 - Semantics: [0]: 1軸目 [1]: 2軸目 [2]: 3軸目 [3]: 4軸目 [4]: 5軸目 [5]: 6軸目 [6]: 親指 [7]: 差指 [8]: 中指 - Unit: [A] """ self._Arm1Current_InIn = OpenRTM_aist.InPort("Arm1Current_In", self._d_Arm1Current_In) # initialize of configuration-data. # <rtc-template block="init_conf_param"> """ WebSocket 待受ポート番号 - Name: WEBSOCKET_PORT - DefaultValue: 8080 """ self._WEBSOCKET_PORT = [8080] """ WebSocket 待受アドレス - Name: WEBSOCKET_HOST - DefaultValue: 0.0.0.0 """ self._WEBSOCKET_HOST = ['0.0.0.0'] # </rtc-template> ## # # The initialize action (on CREATED->ALIVE transition) # formaer rtc_init_entry() # # @return RTC::ReturnCode_t # # def onInitialize(self): # Bind variables and configuration variable self.bindParameter("WEBSOCKET_PORT", self._WEBSOCKET_PORT, "8080") self.bindParameter("WEBSOCKET_HOST", self._WEBSOCKET_HOST, "0.0.0.0") # Set InPort buffers self.addInPort("GCCapacityRatio_In", self._GCCapacityRatio_InIn) self.addInPort("MainCapacityRatio_In", self._MainCapacityRatio_InIn) self.addInPort("Mode_In", self._Mode_InIn) self.addInPort("Pose3D_In", self._Pose3D_InIn) self.addInPort("Velocity2D_In", self._Velocity2D_InIn) self.addInPort("FlipperAngle_In", self._FlipperAngle_InIn) self.addInPort("MotorLoad_In", self._MotorLoad_InIn) self.addInPort("Arm1Pose3D_In", self._Arm1Pose3D_InIn) self.addInPort("Arm1Angular_In", self._Arm1Angular_InIn) self.addInPort("Arm1Finger_In", self._Arm1Finger_InIn) self.addInPort("Arm1Current_In", self._Arm1Current_InIn) # Set OutPort buffers # Set service provider to Ports # Set service consumers to Ports # Set CORBA Service Ports return RTC.RTC_OK ## # # The finalize action (on ALIVE->END transition) # formaer rtc_exiting_entry() # # @return RTC::ReturnCode_t # def onFinalize(self): return RTC.RTC_OK ### ## ## The startup action when ExecutionContext startup ## former rtc_starting_entry() ## ## @param ec_id target ExecutionContext Id ## ## @return RTC::ReturnCode_t ## ## #def onStartup(self, ec_id): # # return RTC.RTC_OK ### ## ## The shutdown action when ExecutionContext stop ## former rtc_stopping_entry() ## ## @param ec_id target ExecutionContext Id ## ## @return RTC::ReturnCode_t ## ## #def onShutdown(self, ec_id): # # return RTC.RTC_OK ## # # The activated action (Active state entry action) # former rtc_active_entry() # # @param ec_id target ExecutionContext Id # # @return RTC::ReturnCode_t # # def onActivated(self, ec_id): # ビューアーの設定ファイルを生成 config = { "WEBSOCKET_PORT": self._WEBSOCKET_PORT[0], } with open(VIEWER_CONFIG_FILE, mode="w") as f: json.dump(config, f, ensure_ascii=False, indent=2, separators=(",", ": ")) #def ws_on_message(client, server, message): # server.send_message_to_all(message) # return # WebSocket サーバーを起動 self.ws_server = WebsocketServer(self._WEBSOCKET_PORT[0], host=self._WEBSOCKET_HOST[0]) #self.ws_server.set_fn_message_received(ws_on_message) self.ws_thread = threading.Thread(target=self.ws_server.run_forever) self.ws_thread.start() return RTC.RTC_OK ## # # The deactivated action (Active state exit action) # former rtc_active_exit() # # @param ec_id target ExecutionContext Id # # @return RTC::ReturnCode_t # # def onDeactivated(self, ec_id): # WebSocket サーバーを終了 self.ws_server.shutdown() self.ws_server.server_close() return RTC.RTC_OK ## # # The execution action that is invoked periodically # former rtc_active_do() # # @param ec_id target ExecutionContext Id # # @return RTC::ReturnCode_t # # def onExecute(self, ec_id): # 入力ポートに入ってきたデータを WebSocket クライアントに転送する for port in self._inports: port_name = port._name port_type = port._value.__class__.__name__ if port.isNew(): port_in = port.read() time = port_in.tm.sec + port_in.tm.nsec * (10**-9) if port_type in [ "TimedDouble", "TimedLongSeq", "TimedDoubleSeq" ]: data = port_in.data elif port_type == "TimedPose3D": position = port_in.data.position orientation = port_in.data.orientation data = { "position": { "x": position.x, "y": position.y, "z": position.z }, "orientation": { "r": orientation.r, "p": orientation.p, "y": orientation.y }, } elif port_type == "TimedVelocity2D": velocity = port_in.data data = { "vx": velocity.vx, "vy": velocity.vy, "va": velocity.va } js_data = json.dumps({port_name: {"tm": time, "data": data}}) self.ws_server.send_message_to_all(js_data) #print(js_data) return RTC.RTC_OK
class SocConn(Communicator): def __init__(self): super().__init__() DEFAULT_SOC_PORT = 8765 self.host = '' self.port = DEFAULT_SOC_PORT self.bus = WebsocketServer(host=self.host, port=self.port) self.recv_q = Queue() self.send_q = Queue() self.close_event = False def open(self): Thread(target=self.__open, daemon=True).start() Thread(target=self.__send_handler, daemon=True).start() return self.host, self.port def close(self): self.bus.server_close() def recv(self): if self.recv_q.empty(): return None modi_message = self.recv_q.get() return modi_message def send(self, modi_message): self.send_q.put(modi_message) # # Helper Methods # def __open(self): def new_client(client, server): server.send_message_to_all( f'Hey all, a new client:{client} has joined us' ) def client_left(client, server): server.send_message_to_all( f'Hey all, a client:{client} has left us' ) # Set callback functions self.bus.set_fn_new_client(new_client) self.bus.set_fn_message_received(self.__recv_handler) self.bus.set_fn_client_left(client_left) # Run the server forever self.bus.run_forever() def __recv_handler(self, client, server, message): self.recv_q.put(message) def __send_handler(self): while not self.close_event: if self.send_q.empty(): time.sleep(0.001) continue try: message = self.send_q.get() self.bus.send_message_to_all(message) except Exception: self.close_event = True