def main(): r_q = Queue() ws_q = Queue() server = WebsocketServer(8998, host='0.0.0.0') #, loglevel=logging.INFO) server.set_fn_new_client(new_client) server.set_fn_message_received(msg_received_ws(ws_q)) t = Thread(target=server.run_forever) t.daemon = True t.start() r = redis.Redis(host='octopi.labs', port=6379, db=0) p = r.pubsub() p.subscribe(replies=handle_replies_redis(r_q)) while True: if not ws_q.empty(): comm, data = ws_q.get() print('from ws', comm, data) if type(data) is list: c = Command(comm, None, data) else: c = Command(comm, None, [data]) print(c, c.command) r.publish('commands', bytes(c.command)) if not r_q.empty(): data = r_q.get() print('from redis', data) server.send_message_to_all(data) p.get_message() time.sleep(0.1)
class WsServer(threading.Thread): def __init__(self, conf=None, controller=None): threading.Thread.__init__(self) if conf == None: self.conf = dict(port=4000, host='127.0.0.1') else: self.conf = conf self.server = WebsocketServer(self.conf["port"], host=self.conf["host"]) 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) def run(self): self.server.run_forever() def new_client(client, server): logging.info("WS: New Client") self.server.send_message_to_all("Hey all, a new client has joined us") def client_left(client, server): logging.info("WS: Client left") self.server.send_message_to_all("Hey all, a new client has joined us") def message_received(client, server, message): logging.info("WS: New message " + message) def disconnect(self): logging.info("WS:Disconnect") self.server.shutdown()
class Websocket_Server(): def __init__(self, host, port): self.server = WebsocketServer(port, host=host, loglevel=logging.DEBUG) # クライアント接続時に呼ばれる関数 def new_client(self, client, server): print("new client connected and was given id {}".format(client['id'])) # 全クライアントにメッセージを送信 self.server.send_message_to_all("hey all, a new client has joined us") # クライアント切断時に呼ばれる関数 def client_left(self, client, server): print("client({}) disconnected".format(client['id'])) # クライアントからメッセージを受信したときに呼ばれる関数 def message_received(self, client, server, message): print(message + "これはテストです") print("client({}) said: {}".format(client['id'], message + "これはテスト")) file = open('InputText.txt', 'w') file.write(message) print(message + "これはテストです") # 全クライアントにメッセージを送信 self.server.send_message_to_all(message) # サーバーを起動する def run(self): # クライアント接続時のコールバック関数にself.new_client関数をセット self.server.set_fn_new_client(self.new_client) # クライアント切断時のコールバック関数にself.client_left関数をセット self.server.set_fn_client_left(self.client_left) # メッセージ受信時のコールバック関数にself.message_received関数をセット self.server.set_fn_message_received(self.message_received) self.server.run_forever()
class Websocket_Server(): def __init__(self, host, port): self.client_id_username_map = {} self.server = WebsocketServer(port, host = host, loglevel = logging.DEBUG) def new_client(self, client, server): print("new client connected and was given id {}".format(client['id'])) self.server.send_message(client,"make connection : success!!") def client_left(self, client, server): print("client({}) disconnected".format(client['id'])) def message_received(self, client, server, message): if message.startswith("init:username:"******"init:username:"******"") print(username) self.client_id_username_map[client["id"]] = username self.server.send_message_to_all(message) else: self.server.send_message_to_all(message) def run(self): 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) self.server.run_forever()
class WebsocketSidecamServer(): def __init__(self): self.server = WebsocketServer(port=443, host='127.0.0.1') thread = threading.Thread(target=lambda: self.server.run_forever()) thread.start() def send_message(self, message): self.server.send_message_to_all(message)
class Server: """ A Websocket server that polls a GSP's waitforchange RPC interface and pushes notifications to connected clients. """ def __init__ (self, host, port, gspRpcUrl): self.srv = WebsocketServer (host=host, port=port, loglevel=logging.INFO) self.rpc = jsonrpclib.ServerProxy (gspRpcUrl) def run (self): """ Starts the server, GSP polling thread and blocks forever while the server is running. """ with self.pollingWorker (): self.srv.run_forever () @contextmanager def pollingWorker (self): """ Runs a new polling worker task in a managed context. When the context is exited, the worker is stopped. """ mut = threading.Lock () shouldStop = False def loop (): knownBlock = "" while True: newBlock = self.rpc.waitforchange (knownBlock) if newBlock != knownBlock: self.pushNewBlock (newBlock) knownBlock = newBlock with mut: if shouldStop: return thread = threading.Thread (target=loop) thread.start () try: yield finally: with mut: shouldStop = True thread.join () def pushNewBlock (self, blockHash): data = { "jsonrpc": "2.0", "method": "newblock", "params": [blockHash], } msg = json.dumps (data, separators=(",", ":")) self.srv.send_message_to_all (msg)
class Publisher(Thread): def __init__(self, host, port): super().__init__(daemon=True) self._server = WebsocketServer(port, host) self.start() def run(self): self._server.run_forever() def send(self, message): self._server.send_message_to_all(json.dumps(message))
class wsServer(threading.Thread): def __init__(self): threading.Thread.__init__(self) self.server = WebsocketServer(c.ws_port,"0.0.0.0") self.server.set_fn_new_client(new_client) self.server.set_fn_client_left(client_left) self.server.set_fn_message_received(message_received) def run(self): self.server.run_forever() def send_message_to_all(self, msg): self.server.send_message_to_all(msg)
class SenseHat(): temperature = 20.4 server = None block = True def new_client(self, client, server): print("New client connected and was given id %d" % client['id']) self.block = False def client_left(self, client, server): print("Client(%d) disconnected" % client['id']) def message_received(self, client, server, message): if message[0] == "Y": # Sample message: "Y29.2,80,1000" temp = message[1:].split(",")[0] print("Setting temperature:", temp) self.temperature = temp def __init__(self): t = threading.Thread(target=self.__startServer) t.daemon = True t.start() while self.block: print('.', end="") sys.stdout.flush() time.sleep(1) def __startServer(self): self.server = WebsocketServer(9000) 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) self.server.run_forever() def set_pixels(self, pixelMap): message = "P" first = True pixelMapNp = np.array(pixelMap) pixelMapNp.shape = (192) for x in range(0, 64): if (not first): message = message + "," message = message + str((x % 8)) + "," + str(int(math.floor( x / 8))) + "," + str(pixelMapNp[x * 3]) + "," + str( pixelMapNp[x * 3 + 1]) + "," + str(pixelMapNp[x * 3 + 2]) first = False self.server.send_message_to_all(message) def get_temperature(self): return float(self.temperature)
class WebSocketServer(Thread): def __init__(self, host="172.16.18.220", port=8081): self.host = host self.port = port self.server = WebsocketServer(self.port, host=self.host) Thread.__init__(self) def run(self): self.server.run_forever() def send_all(self, msg): try: self.server.send_message_to_all(msg) except Exception as e: print(e)
class Websocket_Server(): def __init__(self, host, port): # self.server = WebsocketServer(port, host=host, loglevel=logging.DEBUG) self.server = WebsocketServer(port, host=host) # クライアント接続時に呼ばれる関数 def new_client(self, client, server): print("new client connected and was given id {}".format(client['id'])) # 全クライアントにメッセージを送信 # self.server.send_message_to_all("hey all, a new client has joined us") # クライアント切断時に呼ばれる関数 def client_left(self, client, server): print("client({}) disconnected".format(client['id'])) # クライアントからメッセージを受信したときに呼ばれる関数 def message_received(self, client, server, message): send_message = "" if "mylive2d" in message: # message_dict = json.loads(str("\"" + message + "\"")) message_dict = literal_eval(message) # print(type(message_dict), type(message)) # print(message_dict) if message_dict["id"] == "mylive2d": if random.randrange(10) > 5: print("smile") send_message = json.dumps({ "id": "mylive2d", "text": "smile" }) else: print("idle") send_message = json.dumps({ "id": "mylive2d", "text": "normal" }) self.server.send_message_to_all(send_message) # サーバーを起動する def run(self): # クライアント接続時のコールバック関数にself.new_client関数をセット self.server.set_fn_new_client(self.new_client) # クライアント切断時のコールバック関数にself.client_left関数をセット self.server.set_fn_client_left(self.client_left) # メッセージ受信時のコールバック関数にself.message_received関数をセット self.server.set_fn_message_received(self.message_received) self.server.run_forever()
class UnityWebSocket: def __init__(self, port): logging.info("Creating Unity socket") self.server = WebsocketServer(port) self.server.set_fn_new_client(self.new_client) self.server.set_fn_message_received(self.on_message) self.on_play_mode_state_changed = self.event_default self.on_pause_mode_state_changed = self.event_default self.on_set_title = self.event_default self.on_set_image = self.event_default self.on_set_state = self.event_default def start(self): self.server.run_forever() def new_client(self, client, ws): self.send("open-socket") def on_message(self, client, ws, message): logging.debug(message) data = UnityResponseData(message) { "setState": self.on_set_state, "playModeStateChanged": self.on_play_mode_state_changed, "pauseModeStateChanged": self.on_pause_mode_state_changed, "setTitle": self.on_set_title, "setImage": self.on_set_image }.get(data.event, self.event_default)(data) def send(self, action, context=None, settings=None, state=0): if len(self.server.clients) == 0: return False data = { "action": action, "context": context, "settings": settings, "state": state } self.server.send_message_to_all(json.dumps(data)) return True def event_default(self, data): pass
class Websocket_Server(): def __init__(self, host, port): self.server = WebsocketServer(port, host=host, loglevel=logging.DEBUG) # クライアント接続時に呼ばれる関数 def new_client(self, client, server): print("new client connected and was given id {}".format(client['id'])) # 全クライアントにメッセージを送信 self.server.send_message_to_all("hey all, a new client has joined us") # クライアント切断時に呼ばれる関数 def client_left(self, client, server): print("client({}) disconnected".format(client['id'])) # クライアントからメッセージを受信したときに呼ばれる関数 def message_received(self, client, server, message): # message = message[1:] # message = message[:-1] file = open('result.json', 'w') file.write(message) # print(message) # print(type(message)) # #message=open(message) # json_data = json.load(message) # fw = open('myu_s.json', 'w') # json.dump(json_data, fw, indent=4) # #message = json.dumps(message) # with open('result.json', 'w') as fp: # json.dump(message, fp, ensure_ascii=False) # #print("client({}) said: {}".format(client['id'], message + "これはテスト")) # file = open('result.json', 'w') # file.write(message) # # print(message+"これはテストです") # # 全クライアントにメッセージを送信 # self.server.send_message_to_all(message) # サーバーを起動する def run(self): # クライアント接続時のコールバック関数にself.new_client関数をセット self.server.set_fn_new_client(self.new_client) # クライアント切断時のコールバック関数にself.client_left関数をセット self.server.set_fn_client_left(self.client_left) # メッセージ受信時のコールバック関数にself.message_received関数をセット self.server.set_fn_message_received(self.message_received) self.server.run_forever()
class Server(object): def __init__(self, ip, port): self.__ip = ip self.__port = port self.__server = None def __new_client(self, client, server): logging.info(client) logging.info(server.clients) def __client_left(self, client, server): logging.info(client) logging.info(server.clients) def __recv_ping(self, client, data=''): self.__send_msg_client(client, str({'timestamp' : int(1000 * time.time())})) def __message_received(self, client, server, message): if not message: self.__recv_ping(client, message) logging.info(client) logging.info(message) self.__send_msg(message) def __run(self): try: self.__server = WebsocketServer(self.__ip, self.__port) 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) self.__server.run_forever() except Exception as e: logging.exception(e) self.__server = None def __send_msg_client(self, client, message): if self.__server: self.__server.send_message(client, message) def __send_msg(self, message): if self.__server: self.__server.send_message_to_all(message) def start(self): #while True: self.__run()
class WSServer(): def __init__(self, port, host): self.server = WebsocketServer(port=port, host=host) self.server.set_fn_new_client(self.new_client) self.server.set_fn_client_left(self.close_connection) def new_client(self, client, _server): print("client connected", client) def close_connection(self, client, _server): print(client, "disconnected") def broadcast(self, message): self.server.send_message_to_all(message) def run(self): serverThread = threading.Thread(target=self.server.run_forever) serverThread.start()
class ParentMain(Parent): def new_client(self, client, server): values["clients"] = server.clients def client_left(self, client, server): values["clients"] = server.clients def message_received(self, client, server, message): values["messages"].append({client["id"]: message}) values["newest"][client["id"]] = message def __init__(self, config: dict): super().__init__(config) __port = config['port'] self.__server = WebsocketServer(port=__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) th = threading.Thread(target=self.__server.run_forever) th.setDaemon(True) th.start() def read(self, params): super().read(params) __tag = params["tag"] if __tag in values: return values[__tag] else: return None def write(self, value, params): super().write(value, params) __tag = params["tag"] __client = params["client"] if __tag == "send_to_client": if "client" in params: __client = params["client"] self.__server.send_message(__client, value) elif __tag == "send_to_all": self.__server.send_message_to_all(value) def __del__(self): super().__del__() del self.__server
def serve(mqtt_q, ws_q): server = WebsocketServer(8998, host='0.0.0.0') #, loglevel=logging.INFO) server.set_fn_new_client(new_client) server.set_fn_message_received(msg_received(ws_q)) t = Thread(target=server.run_forever) t.daemon = True t.start() while True: topic, msg = mqtt_q.get() print("< %s, %s" % (topic, msg), flush=True) state[topic] = msg tstamp = datetime.datetime.now().strftime("%H:%M:%S") state['timestamp'] = tstamp server.send_message_to_all( json.dumps({ topic: msg, "timestamp": tstamp })) t.join()
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
class DSSocketServer(threading.Thread): def __init__(self, port=9876): threading.Thread.__init__(self) self.setDaemon = True self.server = WebsocketServer(port) self.server.set_fn_message_received(self.message_received) self.stopped = 0 def message_received(self, client, server, message): print 'Message received: %s' % (message) if message == 'STOP': self.stopped += 1 elif message == 'START': self.stopped -= 1 def run(self): self.server.run_forever() def message(self, text): self.server.send_message_to_all(text)
class Controller: def __init__(self, topic=''): self.server = WebsocketServer(9001) self.t = threading.Thread(target=self.server.run_forever) self.t.daemon = True self.t.start() self.subscriber = rospy.Subscriber( topic, NavSatFix, self.callback, ) def callback(self, msg): lat = msg.latitude lng = msg.longitude self.server.send_message_to_all(json.dumps({ 'lat': lat, 'lng': lng, })) def spin(self): rospy.spin()
class observer(threading.Thread): def __init__(self, value_name, host, port, interval=1): super(observer, self).__init__() self.interval = interval self.server = WebsocketServer(port,host) self.server.set_fn_new_client(self._on_new_client_appeared) self.server.set_fn_client_left(self._on_new_client_appeared) self.wsthread = threading.Thread(target=self.server.run_forever) self.value_name = value_name def _getvalue(self): pass def _on_new_client_appeared(self, client, server): logging.info("new client[{0}:{1}] appear here.".format(client["address"])) def _on_client_left(self, client, server): logging.info("client[{0}:{1}] has vanished.".format(client["address"])) def run(self): self.wsthread.start() try: while True: val = self._getvalue() if(val!=None): data = { "name": self.value_name, "value": val } data_json = json.dumps(data) self.server.send_message_to_all(data_json) logging.debug(json.dumps(data, indent=2)) time.sleep(self.interval) except KeyboardInterrupt as e: logging.info("Interrupted.") except Exception as e: logging.error(e)
class WS(): def __init__(self,Asseist): self.ws = None #type: WebsocketServer self.Asseist = Asseist def Init_Websocket(self): self.ws = WebsocketServer(7777, host='127.0.0.1') self.ws.set_fn_new_client(self.new_client) self.ws.set_fn_message_received(self.on_message) self.ws.run_forever() def new_client(self,ws,server): print("有人加入了websocket") def on_message(self,ws,client,data): print(client) print(data) #通訊協定 json格式 {'order':自定指令 ,'detail':發送的內容} try : data = base64.b64decode(data).decode() print(data) cmd = json.loads(data) if cmd['order'] == "push_msg": self.Send_Order_To_All(order="notify",detail=cmd['detail']) if cmd['order'] == "close_win": self.Asseist.Helper_Win_Hind() except Exception as e: print("Websocket 接收訊息錯誤格式") print(e) def Send_Order_To_All(self,order,detail): pack = {'order': order, 'detail': detail} print("ReadySend:{}".format(pack)) pack = base64.b64encode(json.dumps(pack).encode()) self.ws.send_message_to_all(pack)
class WS: def __init__(self, main): # type : WebsocketServer self.ws = None self.main = main def Init_Websocket(self): self.ws = WebsocketServer(7777, host='127.0.0.1') self.ws.set_fn_new_client(self.new_client) self.ws.set_fn_message_received(self.on_message) self.ws.run_forever() def new_client(self, ws, server): print("有人加入websocket") def on_message(self, ws, client, data): # 通訊協定 json格式 {'order': 自訂指令, 'detail': 發送內容} try: # 編碼方式 data = base64.b64decode(data).decode() cmd = json.loads(data) print(data) if cmd['order'] == "push_msg": self.send_order_to_all(order='notify', detail=cmd['detail']) if cmd['order'] == "close_win": self.main.helper_win_hide() except Exception as e: print("Websocket 接收訊息錯誤格式") print(e) def send_order_to_all(self, order, detail): pack = {'order': order, 'detail': detail} # print("Ready send{}".format(pack)) pack = base64.b64encode(json.dumps(pack).encode()) # sound.speak(detail) # 透過google 小姐說出訊息 self.ws.send_message_to_all(pack)
class WebSockServer: def __init__(self, handler): PORT = 8807 self.server = WebsocketServer(PORT, host='0.0.0.0', loglevel=logging.DEBUG) 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) self.handler = handler # Called for every client connecting (after handshake) def new_client(self, client, server): print("New client connected. id=%d" % client['id']) msg = '{{"msg":1,"data":{{"id":{0}}}}}'.format(client['id']) print("-> " + msg) self.server.send_message_to_all(msg) # Called for every client disconnecting def client_left(self, client, server): print("Client(%d) disconnected" % client['id']) msg = '{{"msg":2,"data":{{"id":{0}}}}}'.format(client['id']) print("-> " + msg) self.server.send_message_to_all(msg) # Called when a client sends a message def message_received(self, client, server, message): if len(message) > 200: message = message[:200] + '..' print("id #%d <- %s" % (client['id'], message)) # TODO: Handle invalid messages incoming = json.loads(message) if 'data' in incoming: self.handler(incoming["msg"], incoming["data"]) else: self.handler(incoming["msg"], None) def send(self, msg): self.server.send_message_to_all(msg) def run(self): self.server.run_forever()
class WebsocketServer(): def __init__(self, host='0.0.0.0', PORT=8000): self.websocket = WSServer(PORT, host=host) self.websocket.set_fn_new_client(self.new_client) self.websocket.set_fn_client_left(self.client_left) self.websocket.set_fn_message_received(self.message_received) def start(self): try: self.websocket.run_forever() except KeyboardInterrupt: pass # 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.websocket.send_message_to_all( "Hey all, a new client has joined us") # Called for every client disconnecting def client_left(self, client, server): print("Client(%d) disconnected" % client['id']) # Called when a client sends a message def message_received(self, client, server, message): array_message = message.split(',') command = array_message[0] if command == 'calibrate': if self.calibrate: self.calibrate(array_message[1]) elif command == 'right': if self.rightMotor: self.rightMotor(array_message[1], array_message[2]) elif command == 'left': if self.leftMotor: self.leftMotor(array_message[1], array_message[2]) elif command == 'stand-by': if self.turnOffVehicle: self.turnOffVehicle() else: print('error: callback not setted for ' + command) elif command == 'turn-on': if self.turnOn: self.turnOn() else: print('error: callback not setted for ' + command) elif command == 'turn-off-mat': if self.turnOffMat: self.turnOffMat() else: print('error: callback not setted for ' + command) elif command == 'turn-on-mat': if self.turnOnMat: self.turnOnMat() else: print('error: callback not setted for ' + command) def rightMotorCallback(self, callback): self.rightMotor = callback def leftMotorCallback(self, callback): self.leftMotor = callback def turnOffVehicleCallback(self, callback): self.turnOffVehicle = callback def turnOnMatCallback(self, callback): self.turnOnMat = callback def turnOffMatCallback(self, callback): self.turnOffMat = callback def turnOnCallback(self, callback): self.turnOn = callback def calibrateCallback(self, callback): self.calibrate = callback
class GameServer(object): def __init__(self, d=36, y=6, r=6, m=250, L=4, p=2, gui=False): self.d = d self.y = y self.r = r self.m = m self.L = L self.p = p self.trench_cost = 0 self.trench_condition_achieved = True self.red_alert = [i % 100 for i in range(d, d + 6)] self.submarine_time_left = self.trench_time_left = 120 self.submarine_location = randint(0, 99) self.is_submarine_in_red = self.submarine_location in self.red_alert self.web_server = None print('Waiting on port %s for players...' % PORT) if gui: self.web_server = WebsocketServer(WEB_PORT, host=WEB_HOST) self.web_server.new_client = self.accept_player_connections self.web_server.run_forever() else: self.accept_player_connections() def accept_player_connections(self, front_end=None, web_server=None): if front_end: print('~~ WE GOT A FRONT END ~~') self.server = SocketServer(HOST, PORT, 2) self.server.establish_client_connections() self.player_attributes = [ json.loads(info) for info in self.server.receive_from_all() ] self.trench_idx = 0 if self.player_attributes[0][ 'is_trench_manager'] else 1 self.submarine_idx = 1 if self.player_attributes[0][ 'is_trench_manager'] else 0 self.play_game() def timed_request(self, request_data, client_idx): self.server.send_to(json.dumps(request_data), client_idx) start = time() move = json.loads(self.server.receive_from(client_idx)) stop = time() return move, (stop - start) def decrement_time(self, submarine_time_spent, trench_time_spent): self.submarine_time_left -= submarine_time_spent self.trench_time_left -= trench_time_spent def check_time_left(self): if self.submarine_time_left < 0: raise Exception('Submarine Captain ran out of time') if self.trench_time_left < 0: raise Exception('Trench Manager ran out of time') def complete_submarine_move(self, submarine_move): if type(submarine_move ) != int or submarine_move > 1 or submarine_move < -1: raise ValueError('Submarine Captain made an illegal move') self.submarine_location = (self.submarine_location + submarine_move) % 100 self.is_submarine_in_red = self.submarine_location in self.red_alert def trench_region_check(self, region): if region not in ('red', 'yellow'): raise ValueError('Trench Manager chose an illegal region') if self.is_submarine_in_red and region != 'red': self.trench_condition_achieved = False self.trench_cost += self.r if region == 'red' else self.y def deploy_probes(self, probes): probe_results = [] times_submarine_probed = 0 for probe in probes: if type(probe) != int or probe < 0 or probe > 99: raise ValueError( 'Trench Manager placed a probe at an illegal position') range_start = (probe - self.L) if (probe - self.L) > 0 else ( 100 + (probe - self.L)) probe_range = [ i % 100 for i in range(range_start, range_start + (self.L * 2) + 1) ] probe_results.append(self.submarine_location in probe_range) if probe_results[-1]: times_submarine_probed += 1 self.trench_cost += self.p return probe_results, times_submarine_probed def play_game(self): submarine_move, submarine_time_spent = self.timed_request( { 'm': self.m, 'L': self.L, 'pos': self.submarine_location }, self.submarine_idx) trench_probe_move, trench_time_spent = self.timed_request( { 'd': self.d, 'y': self.y, 'r': self.r, 'm': self.m, 'L': self.L, 'p': self.p }, self.trench_idx) self.decrement_time(submarine_time_spent, trench_time_spent) m = self.m while m > 0: self.check_time_left() self.complete_submarine_move(submarine_move['move']) probe_results, times_submarine_probed = self.deploy_probes( trench_probe_move['probes']) trench_move, trench_time_spent = self.timed_request( {'probe_results': probe_results}, self.trench_idx) self.trench_region_check(trench_move['region']) if self.web_server: self.web_server.send_message_to_all( json.dumps({ 'red_region': self.d, 'position': self.submarine_location, 'is_safety_condition_achieved': self.trench_condition_achieved, 'submarine_region': 'red' if self.is_submarine_in_red else 'yellow', 'trench_alert': trench_move['region'], 'probes': trench_probe_move['probes'] })) print("**********************************************") print( f"Submarine moved by {submarine_move['move']} (current position: {self.submarine_location})" ) print( f"Submarine is {'not' if not self.is_submarine_in_red else ''} in red region" ) print(f"Probes were placed at {trench_probe_move['probes']}") print(f"The results were: {probe_results}") print(f"Trench manager sent {trench_move['region']} alert") print( f"Safety condition {'not' if not self.trench_condition_achieved else ''} achieved" ) print("**********************************************") if m > 1: submarine_move, submarine_time_spent = self.timed_request( {'times_probed': times_submarine_probed}, self.submarine_idx) trench_probe_move, trench_time_spent = self.timed_request( {}, self.trench_idx) self.decrement_time(submarine_time_spent, trench_time_spent) m -= 1 if not self.trench_condition_achieved: self.trench_cost = (self.m * self.r) + (self.m * 5 * self.p) self.server.send_to_all( json.dumps({ 'game_over': True, 'trench_cost': self.trench_cost, 'was_condition_achieved': self.trench_condition_achieved }))
gray_face = gray_image[y1:y2, x1:x2] try: gray_face = cv2.resize(gray_face, (emotion_target_size)) except: continue gray_face = preprocess_input(gray_face, True) gray_face = np.expand_dims(gray_face, 0) gray_face = np.expand_dims(gray_face, -1) emotion_prediction = emotion_classifier.predict(gray_face) emotion_probability = np.max(emotion_prediction) emotion_label_arg = np.argmax(emotion_prediction) #如果是angry则跳转 if emotion_label_arg == 0: server.send_message_to_all('1') #显示端 emotion_text = emotion_labels[emotion_label_arg] emotion_window.append(emotion_text) if len(emotion_window) > frame_window: emotion_window.pop(0) try: emotion_mode = mode(emotion_window) except: continue if emotion_text == 'angry': color = emotion_probability * np.asarray((255, 0, 0))
class WSServer: def __init__(self, port=9007): self.port = port self.server = WebsocketServer(self.port, host='0.0.0.0') self.server.set_fn_new_client(self.on_connect) self.server.set_fn_message_received(self.on_msg) self.server.set_fn_client_left(self.on_disconnect) self.msg_lock = Lock() def ping(self): self.server.send_message_to_all(json.dumps({'action': 'ping'})) # pinging every 50 seconds to avoid disconnection t = Timer(50, self.ping) t.start() def on_connect(self, client, server): #server.send_message_to_all("Hey all, a new client has joined us") pass def on_disconnect(self, client, server): #server.send_message_to_all("Hey all, a new client has joined us") pass def on_msg(self, client, server, message): self.msg_lock.acquire() try: args = message.split(' ') command = args[0] args = args[1:] internal = 'internal_ws_' + command if hasattr(self, internal): getattr(self, internal)(client, *args) else: data = {'action': 'cmd', 'msg': 'not found'} self.server.send_message(client, json.dumps(data)) except Exception as e: print("Error: ", e) connection.close() self.msg_lock.release() def run(self): self.ping() self.server.run_forever() def drop_seat(self, hold): session = hold.session layout = hold.layout row, col = hold.seat.split('-') data = { 'action': 'drop', 'session': session.id, 'layout': layout.id, 'row': row, 'col': col, } hold.delete() confirmed = not session.is_seat_available(layout, row, col) if confirmed: data['action'] = 'confirm' self.server.send_message_to_all(json.dumps(data)) def notify_confirmed(self): d = timezone.now() d = d - datetime.timedelta(seconds=80) holds = TicketSeatHold.objects.filter(date__gt=d, type="R") for h in holds: row, col = h.seat.split('-') data = { 'action': 'confirm', 'session': h.session.id, 'layout': h.layout.id, 'row': row, 'col': col, } self.server.send_message_to_all(json.dumps(data)) # Protocol definitions def internal_ws_autoseats(self, client, session, amount, user): session = Session.objects.get(id=session) seats = search_seats(session, int(amount)) data = { 'action': 'autoseat', 'session': session.id, 'seats': seats, } for s in seats: layout = SeatLayout.objects.get(id=s['layout']) seat = '{}-{}'.format(s['row'], s['col']) d2 = { 'action': 'hold', 'session': session.id, 'layout': layout.id, 'row': s['row'], 'col': s['col'], } sh = TicketSeatHold(client=user, layout=layout, seat=seat, session=session) sh.save() self.server.send_message_to_all(json.dumps(d2)) if not seats: data['error'] = _('Not found contiguous seats, please, select manually using the green button') self.server.send_message(client, json.dumps(data)) def internal_ws_get_events(self, client): events = serializers.serialize("json", Event.objects.all()) self.server.send_message(client, events) def internal_ws_get_spaces(self, client, event): event = Event.objects.get(slug=event) spaces = serializers.serialize("json", event.spaces.all()) self.server.send_message(client, spaces) def internal_ws_get_sessions(self, client, event, space): event = Event.objects.get(slug=event) space = event.spaces.get(slug=space) sessions = serializers.serialize("json", space.sessions.all()) self.server.send_message(client, sessions) def internal_ws_hold_seat(self, client, session, layout, row, col, user): session = Session.objects.get(id=session) layout = SeatLayout.objects.get(id=layout) data = { 'action': 'hold', 'session': session.id, 'layout': layout.id, 'row': row, 'col': col, } if not session.is_seat_holded(layout, row, col): seat = row + '-' + col sh = TicketSeatHold(client=user, layout=layout, seat=seat, session=session) sh.save() self.server.send_message_to_all(json.dumps(data)) else: data['action'] = 'holded' self.server.send_message(client, json.dumps(data)) def internal_ws_drop_seat(self, client, session, layout, row, col, user): try: seat = row + '-' + col sh = TicketSeatHold.objects.get(client=user, type='H', layout=layout, seat=seat, session=session) self.drop_seat(sh) except: pass def internal_ws_add_ac(self, client, control, date, st): data = { 'action': 'add_ac', 'control': control, 'date': date, 'st': st, } log = LogAccessControl(access_control=AccessControl.objects.get(slug=control), status=st) log.save() self.server.send_message_to_all(json.dumps(data)) def internal_ws_add_sale(self, client, window, date, payment, amount, price): data = { 'action': 'add_sale', 'window': window, 'date': date, 'payment': payment, 'amount': amount, 'price': price } self.server.send_message_to_all(json.dumps(data)) def internal_ws_add_change(self, client, window, date, payment, amount, price): data = { 'action': 'add_change', 'window': window, 'date': date, 'payment': payment, 'amount': amount, 'price': price } self.server.send_message_to_all(json.dumps(data))
class WebsocketPublisher(object): """ Publish cluster state as JSON over a websocket. Only sends CS state, and information on who is building on who. This is enough information to draw a graph of the cluster. Explicitly, does not send information on individual jobs. """ MIN_SEND_GAP_S = 0.1 """Minimum gap in seconds between sending messages to connected clients.""" def __init__(self, host="0.0.0.0", port=9999): self.frame = "" self.nodes = "" self.links = "" self.last_sent_frame = "" self.last_sent_nodes = "" self.last_sent_links = "" self.next_time_to_send = 0 self.lock = threading.RLock() self.timer = None self.ws_server = WebsocketServer(port, host) def send_to_client(client, server): with self.lock: server.send_message(client, self.build_graph(True)) self.ws_server.set_fn_new_client(send_to_client) t = threading.Thread(target=self.ws_server.run_forever) t.daemon = True t.start() def build_nodes(self, mon): """Builds a JSON representation of the CS nodes in the cluster.""" nodes = [] for cs in mon.cs.values(): nodes.append({"id": cs.id, "name": cs.name, "ip": cs.ip, "load": (100*cs.active_jobs())/cs.maxjobs}) return json.dumps(nodes) def build_links(self, mon): """ Builds a JSON representation of the links in the cluster. There is one link A->B if A has one or more jobs building on B. """ links = [] for job in mon.jobs.values(): if job.host_id not in mon.cs or job.client_id not in mon.cs: continue c, s = mon.cs[job.client_id], mon.cs[job.host_id] # Don't double-add links. add = True for l in links: if l["source"] == c.id and l["target"] == s.id: add = False if add: links.append({"source": c.id, "target": s.id, "value": 10}) return json.dumps(links) def build_graph(self, full=False): """Builds a full JSON representation of a graph of the cluster.""" frame = '{"timestamp": 0, "index": 0' if full or self.nodes != self.last_sent_nodes: frame += ', "nodes": ' + self.nodes if full or self.links != self.last_sent_links: frame += ', "links": ' + self.links frame += '}' return frame def publish(self, mon): """ Called by the Monitor to indicate new cluster state. Update our internal state, and notify clients if appropriate. """ with self.lock: self.nodes = self.build_nodes(mon) self.links = self.build_links(mon) self.frame = self.build_graph() self.notify() def notify(self): """Send updates to clients if necessary.""" now = time.time() with self.lock: if self.frame == self.last_sent_frame: # Frame hasn't changed, don't resend. return elif (now >= self.next_time_to_send and self.timer is None): # We can send. self.broadcast() elif self.timer is None: # We must reschedule. self.timer = threading.Timer(self.next_time_to_send - now, self.broadcast) self.timer.start() def broadcast(self): """Actually broadcast cluster state to all connected clients.""" with self.lock: if self.timer is not None: self.timer.cancel() self.timer = None self.next_time_to_send = time.time() + self.MIN_SEND_GAP_S self.last_sent_frame = self.frame self.last_sent_nodes = self.nodes self.last_sent_links = self.links self.ws_server.send_message_to_all(self.frame)
if not circles is None: circles = np.uint16(np.around(circles)) max_r, max_i = 0, 0 for i in range(len(circles[:, :, 2][0])): if circles[:, :, 2][0][i] > 50 and circles[:, :, 2][0][i] > max_r: max_i = i max_r = circles[:, :, 2][0][i] x, y, r = circles[:, :, :][0][max_i] if y > r and x > r: square = frame[y - r:y + r, x - r:x + r] dominant_color = get_dominant_color(square, 2) if dominant_color[2] > 100: print("STOP") server.send_message_to_all("stop.png") # Send to browser elif dominant_color[0] > 80: zone_0 = square[square.shape[0] * 3 // 8:square.shape[0] * 5 // 8, square.shape[1] * 1 // 8:square.shape[1] * 3 // 8] cv2.imshow('Zone0', zone_0) zone_0_color = get_dominant_color(zone_0, 1) zone_1 = square[square.shape[0] * 1 // 8:square.shape[0] * 3 // 8, square.shape[1] * 3 // 8:square.shape[1] * 5 // 8] cv2.imshow('Zone1', zone_1) zone_1_color = get_dominant_color(zone_1, 1) zone_2 = square[square.shape[0] * 3 // 8:square.shape[0] * 5 // 8, square.shape[1] * 5 // 8:square.shape[1] *
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)
elif "songlist" in message: r = {"action": "songlist", "data": get_song_list()} server.send_message(client, json.dumps(r)) elif "delsong" in message: try: song = message[7:] except Exception as e: logging.error("Error in parsing raw message `delsong`. e: %s, trackback: %s" % (e, format_exc(e))) else: logging.info("Try del: %s" % song) r = {"action": "songlist", "data": del_a_song(song)} server.send_message_to_all(json.dumps(r)) if __name__ == "__main__": server = WebsocketServer(8080, "haha5") server.set_fn_new_client(new_client) server.set_fn_client_left(client_left) server.set_fn_message_received(message_received) t = Thread(target=server.run_forever) t.start() mq = RedisMessageQueue() while True: msg = mq.accept_msg() logging.info("Global message: %s" % msg) response = {"action": "msg", "data": msg} server.send_message_to_all(json.dumps(response))