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))
