def start_server(port): server = WebsocketServer(port) ws_log.debug("Server listening on port: %d" % port) 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 start_wss(port): "start the websocket test server" def reply_back(client, server, msg): server.send_message(client, "You sent: %s" % msg) server = WebsocketServer(port) server.set_fn_message_received(reply_back) server.run_forever()
def WsServerLaunch(): global wsServer while 1: try: wsServer = WebsocketServer( port=PORT_NUMBER + 1, host='' ) wsServer.set_fn_message_received( message_received ) wsServer.run_forever() except Exception as e: wsServer = None time.sleep( 5 )
def start_server(): """Start both the Game Manager and the Web Server""" # Prepare the web server with above functions logger.info("Init Web Socket Server") server = WebsocketServer(PORT, HOST) server.set_fn_new_client(onconnect) server.set_fn_client_left(ondisconnect) server.set_fn_message_received(onmessage) # Create a game manager logger.info("Init Game Manager") global manager manager = Manager(server) # Start the web server logger.info("Starting Server") server.run_forever() manager.safe_stop()
# Receive data from client and put it in the input queue def communicateWithClient(client, server, msg): print('recv: ' + msg) carConnectionSem.acquire() if (carIsConnected and msg in validInput): inputSem.acquire() inputQueue.append(msg) inputSem.release() carConnectionSem.release() # Websocket to talk to client websocket = WebsocketServer(clientPort) websocket.set_fn_new_client(onClientConnection) websocket.set_fn_client_left(onClientDisconnection) websocket.set_fn_message_received(communicateWithClient) # Handle car communications def communicateWithCar(): while (runServer): # Wait for car to connect c, addr = carSock.accept() isConnected = True global carIsConnected carConnectionSem.acquire() carIsConnected = True carConnectionSem.release() print('Car connected')
def start_data_server(): server = WebsocketServer(WS_PORT, host='0.0.0.0', loglevel=logging.INFO) server.set_fn_new_client(new_client) server.set_fn_message_received(on_sensor_data_recv) server.run_forever()
def __init__(self, host='127.0.0.1'): server = WebsocketServer(self.port, host) server.set_fn_new_client(self.new_client_connection) server.set_fn_client_left(self.client_left) server.set_fn_message_received(self.message_received) server.run_forever()
class WBmessenger(object): def __init__(self, viewerparent): self.parent = viewerparent self.ProcessMessage = self.parent.ProcessMessage self.websockport = self.parent.websockport self.sleeptime = self.parent.sleeptime self.mprint = self.parent.mprint self.parent.lastviewmtrx self.browserisopen = False self.msgqueue = [] self.msgdelim = ":\n" self.ishandling = False self.websockclient = None self.isterminating = False self.was_disconnected = None self.mywebsock = None self.websockeventloop = None def Sleep(self, t): time.sleep(t) def OnWebsocketClientMessage(self, client, server, message): self.ProcessMessage(message) def StartWebsocket(self): self.server = WebsocketServer(self.websockport, host='127.0.0.1') if not self.server: raise Sorry("Could not connect to web browser") self.server.set_fn_new_client(self.OnConnectWebsocketClient) self.server.set_fn_client_left(self.OnDisconnectWebsocketClient) self.server.set_fn_message_received(self.OnWebsocketClientMessage) self.wst = threading.Thread(target=self.server.run_forever) self.wst.daemon = True self.wst.start() self.msgqueuethrd = threading.Thread(target=self.WebBrowserMsgQueue) self.msgqueuethrd.daemon = True self.msgqueuethrd.start() def StopWebsocket(self): try: if self.websockclient: # might not have been created if program is closed before a data set is shown self.websockclient['handler'].send_text(u"", opcode=0x8) except Exception as e: self.mprint(to_str(e) + "\n" + traceback.format_exc(limit=10), verbose=0) self.mprint("Shutting down Websocket listening thread", verbose=1) self.server.shutdown() self.parent.javascriptcleaned = True self.msgqueuethrd.join() self.mprint("Shutting down WebsocketServer", verbose=1) self.wst.join() self.isterminating = True def AddToBrowserMsgQueue(self, msgtype, msg=""): self.msgqueue.append((msgtype, msg)) def WebBrowserMsgQueue(self): try: while True: nwait = 0.0 time.sleep(self.sleeptime) if self.parent.javascriptcleaned: self.mprint("Shutting down WebBrowser message queue", verbose=1) return if len(self.msgqueue): pendingmessagetype, pendingmessage = self.msgqueue[0] gotsent = self.send_msg_to_browser(pendingmessagetype, pendingmessage) while not self.browserisopen: #self.websockclient: time.sleep(self.sleeptime) nwait += self.sleeptime if nwait > self.parent.handshakewait or self.parent.javascriptcleaned or not self.viewerparams.scene_id is not None: return if gotsent: self.msgqueue.remove(self.msgqueue[0]) #if self.was_disconnected: # nwait2 = 0.0 # while nwait2 < self.parent.handshakewait: # nwait2 += self.sleeptime # self.ReloadNGL() # if the html content is huge the browser will be unresponsive until it has finished # reading the html content. This may crash this thread. So try restarting this thread until # browser is ready except Exception as e: self.mprint( str(e) + ", Restarting WebBrowserMsgQueue\n" \ + traceback.format_exc(limit=10), verbose=2) self.websockclient = None self.WebBrowserMsgQueue() def OnConnectWebsocketClient(self, client, server): self.websockclient = client self.mprint("Browser connected:" + str(self.websockclient), verbose=1) if self.was_disconnected: self.was_disconnected = False if self.parent.lastviewmtrx and self.parent.viewerparams.scene_id is not None: self.parent.set_volatile_params() self.mprint("Reorienting client after refresh:" + str(self.websockclient), verbose=2) self.AddToBrowserMsgQueue("ReOrient", self.parent.lastviewmtrx) else: self.parent.SetAutoView() def OnDisconnectWebsocketClient(self, client, server): self.mprint("Browser disconnected:" + str(client), verbose=1) self.was_disconnected = True def send_msg_to_browser(self, msgtype, msg=""): message = u"" + msgtype + self.msgdelim + str(msg) if self.websockclient: nwait = 0.0 while not ("Ready" in self.parent.lastmsg or "tooltip_id" in self.parent.lastmsg \ or "CurrentViewOrientation" in self.parent.lastmsg or "AutoViewSet" in self.parent.lastmsg \ or "ReOrient" in self.parent.lastmsg or self.websockclient is None): time.sleep(self.sleeptime) nwait += self.sleeptime if nwait > 2.0 and self.browserisopen: self.mprint("ERROR: No handshake from browser!", verbose=0) self.mprint("failed sending " + msgtype, verbose=1) self.mprint("Reopening webpage again", verbose=0) break if self.browserisopen and self.websockclient is not None: try: self.server.send_message(self.websockclient, message) return True except Exception as e: self.mprint(str(e) + "\n" + traceback.format_exc(limit=10), verbose=1) self.websockclient = None return False else: return self.parent.OpenBrowser()
def serve(port, host): from websocket_server import WebsocketServer from threading import Thread, Event import signal def message_received(client, server, message): print 'message_received:', message cmds = message.split('|') for cmd in cmds: if cmd.startswith('addr='): address = cmd[5:] if server.watched_addresses.has_key(address): server.watched_addresses[address].append(client) else: server.watched_addresses[address] = [client] if cmd == 'blocks': server.block_watchers.append(client) def client_left(client, server): print 'client_left:', client addrs = [] for key in server.watched_addresses: if client in server.watched_addresses[key]: addrs.append(key) for addr in addrs: clients = server.watched_addresses[addr] clients.remove(client) if not clients: del server.watched_addresses[addr] if client in server.block_watchers: server.block_watchers.remove(client) def service_thread(ws_server, evt): from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException from bitrisk.bitcoind_config import read_default_config import json import decimal config = read_default_config() testnet = '' if config.has_key('testnet'): testnet = config['testnet'] rpc_user = config['rpcuser'] rpc_password = config['rpcpassword'] rpc_connection = AuthServiceProxy("http://%s:%s@%s:%s8332"%(rpc_user, rpc_password, host, testnet)) conn = sqlite3.connect(db_filename) while not evt.wait(5): txs = get_db_txs(conn) for tx in txs: print 'tx:', tx tx = rpc_connection.gettransaction(tx) for details in tx['details']: addr = details['address'] if ws_server.watched_addresses.has_key(addr): def decimal_default(obj): if isinstance(obj, decimal.Decimal): return float(obj) raise TypeError msg = json.dumps(tx, default=decimal_default) for client in ws_server.watched_addresses[addr]: ws_server.send_message(client, msg) blocks = get_db_blocks(conn) for block in blocks: print 'block:', block for client in ws_server.block_watchers: ws_server.send_message(client, block) server = WebsocketServer(port, host) server.watched_addresses = {} server.block_watchers = [] server.set_fn_message_received(message_received) server.set_fn_client_left(client_left) evt = Event() thread = Thread(target=service_thread, args=(server, evt)) thread.start() server.run_forever() # catches and exits on SIGINT evt.set() # stop service_thread thread.join()
import json as j from websocket_server import WebsocketServer import datetime def new_client(client, server): print("Request") message = "Joined new client" dtime = datetime.datetime.now() time = dtime.strftime('%Y年%m月%d日 %H:%M:%S') msg = j.dumps({"res" : "join", "time" : time, "text" : message}) server.send_message_to_all(str(msg)) def rp(client, server, message): dtime = datetime.datetime.now() json = j.loads(message) time = dtime.strftime('%Y年%m月%d日 %H:%M:%S') msg = j.dumps({"res" : "msg", "time" : time, "text" : json["msg"], "name" : json["name"]}) server.send_message_to_all(str(msg)) server = WebsocketServer(80) server.set_fn_new_client(new_client) server.set_fn_message_received(rp) server.run_forever()
elif bison_id=='cmd': if client['power']!=0: logging.debug("don't have the power %s %d!!!!" % (client['account'],client['power'])) return if (check_exclude_cmd(client, bison_cmd)==False): message_dispatch(client,bison_cmd,issingle) else: logging.debug("命令包含非法字符") return config=ConfigParser.ConfigParser(); config.read('config.cfg') config_url=config.get("info","url") s= get_config_data() cmd_dic=s['servershell'] account_dic=s['account'] shell_dic=s['shell'] exclude_cmd=s['exclude_cmd'] PORT=8009 server = WebsocketServer(PORT) server.set_fn_new_client(new_client) server.set_fn_client_left(client_left) server.set_fn_message_received(message_received) server.run_forever()
# 6. Send Khan user data to the client #server.send_message(client, login_data) def runWebsocketServer(): global server server.run_forever() def runAuthServer(): global callback_server callback_server.serve_forever() #PORT=9001 PORT=8080 SERVERHOST= "0.0.0.0" server = WebsocketServer(PORT, SERVERHOST) server.set_fn_new_client(new_client) server.set_fn_client_left(client_left) server.set_fn_message_received(message_received) #server.run_forever() #callback_server.serve_forever() t1 = threading.Thread(target=runWebsocketServer, args=[]) t2 = threading.Thread(target=runAuthServer, args=[]) t1.start() t2.start()
class MockSocket: def __init__(self): self.last_messages = {} self.connected = False self.disconnected = False self.closed = False self.ws = None self.should_heartbeat = True self.fake_workers = [] self.port = None self.launch_socket() self.handlers = {} while self.ws is None: time.sleep(0.05) time.sleep(1) def send(self, packet): self.ws.send_message_to_all(packet) def close(self): if not self.closed: self.ws.server_close() self.ws.shutdown() self.closed = True def do_nothing(self, *args): pass def launch_socket(self): def on_message(client, server, message): if self.closed: raise Exception('Socket is already closed...') if message == '': return packet_dict = json.loads(message) if packet_dict['content']['id'] == 'WORLD_ALIVE': self.ws.send_message(client, json.dumps({'type': 'conn_success'})) self.connected = True elif packet_dict['content']['type'] == 'heartbeat': pong = packet_dict['content'].copy() pong['type'] = 'pong' self.ws.send_message( client, json.dumps( {'type': data_model.SOCKET_ROUTE_PACKET_STRING, 'content': pong} ), ) if 'receiver_id' in packet_dict['content']: receiver_id = packet_dict['content']['receiver_id'] use_func = self.handlers.get(receiver_id, self.do_nothing) use_func(packet_dict['content']) def on_connect(client, server): pass def on_disconnect(client, server): self.disconnected = True def run_socket(*args): port = 3030 while self.port is None: try: self.ws = WebsocketServer(port, host='127.0.0.1') self.port = port except OSError: port += 1 self.ws.set_fn_client_left(on_disconnect) self.ws.set_fn_new_client(on_connect) self.ws.set_fn_message_received(on_message) self.ws.run_forever() self.listen_thread = threading.Thread( target=run_socket, name='Fake-Socket-Thread' ) self.listen_thread.daemon = True self.listen_thread.start()
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))
"main_coord", "comparitor", ] batch_size = 32 def exec_fn_test(datas): print("exec") def return_fn_test(datas): print("returns") model_queues = { name: ExecQueue(batch_size, exec_fn_test, return_fn_test) for name in valid_queue_names } def client_message_rec(client, server, message): print(client, message) pass #server.send_message() server = WebsocketServer(13254, host='127.0.0.1') server.set_fn_message_received(client_message_rec) server.run_forever()
class Scatter: """Interface for python.""" def __init__(self, x, y, labels, label_formatter=None): """Initialize the plot. Parameters ---------- x : list of floats x coordinates of each point you want to plot. y : list of floats y coordinates of each point you want to plot. labels : type 'label' corresponding with the x and y coordinates. Could be anything from the text of a word corresponding with a word embedding to the id/path of an image url that you want to call with your label formatter. Returns ------- Scatter Scatter object constructor. """ # size of chunks to send to the visualization # Start out with smaller chunks, progressively send larger chunks self.CHUNK_SIZE = 500000 self.PORT = 54286 #find_free_port() self.server = WebsocketServer(self.PORT) print(self.PORT) # todo: validate that the length of all passed lists are the same assert len(x) == len(y) == len(labels) def new_client(client, server): print("New client connected and was given id %d" % client['id']) # Check if we need to load the library self.server.send_message(client, {'loaded_scatter'}) n = len(x) for i in range(n): if (i > 0 and i % self.CHUNK_SIZE == 0) or i == n - 1: start_idx = max(0, i-self.CHUNK_SIZE) x_chunk = x[start_idx:i + 1] y_chunk = y[start_idx:i + 1] label_chunk = labels[start_idx:i + 1] self.server.send_message(client, json.dumps({'x': x_chunk, 'y': y_chunk, 'labels': label_chunk })) # self.server.send_message_to_all("Finished") self.server.set_fn_new_client(new_client) # Called for every client disconnecting def client_left(client, server): print("Client(%d) disconnected" % client['id']) self.server.set_fn_client_left(client_left) # Called when a client sends a message def message_received(client, server, message): self.dispatcher(json.loads(message)) self.server.set_fn_message_received(message_received) def begin(): self.server.run_forever() self.server_thread = Thread(target=begin) self.server_thread.start() self._ids = [] def dispatcher(self, message): if message['command'] == 'request_data': pass elif message['command'] == 'load_lib': pass def _repr_html_(self): unique_id = str(uuid1()) anchor = '<div id="{unique_id}"/>'.format(unique_id=unique_id) self._ids.append(unique_id) return anchor def _create_js(self, uid): script = open('scatter-script.js').read() script = script.replace('_UID_', uid) return script def _repr_javascript_(self): js = [] while len(self._ids) > 0: i = self._ids.pop(0) # funcs = 'console.log("' + 'test' + '");'#self._filled_ctx(i, self._s) funcs = self._create_js(i) js.append(funcs) print("\n".join(js)) return "\n".join(js) def _ipython_display_(self): display_html(self._repr_html_(), raw=True) display_javascript(self._repr_javascript_(), raw=True) def to_html(self, out_path): """Write an html file with the visualization. You can open this in the browser """ with open(out_path) as out: raise NotImplemented out.write("NOT IMPL")
class websocketclass(): def __init__(self): PORT=9014 self.callSingle = re.compile("call:([a-zA-Z]+)\.([a-zA-Z]+)\.([a-zA-Z_]+)[|]?(.*)") self.callMultiple = re.compile("call:([a-zA-Z]+)\.\[([a-zA-Z,]+)\]\.([a-zA-Z_]+)[|]?(.*)") self.callAll = re.compile("call:([a-zA-Z]+)\.\*\.([a-zA-Z_]+)[|]?(.*)") self.server = WebsocketServer(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) threading.Thread(target=self.run).start() self.server.run_forever() def analyzeMessage(self,strMessage): # If the module wants to call a method, analyze the call (for tablet or nao) # and dispached it accordingly matchCallSingle = self.callSingle.match(strMessage) if matchCallSingle: strDestDevice = matchCallSingle.group(1) strDestModule = matchCallSingle.group(2) strCallMethod = matchCallSingle.group(3) strCallParams = matchCallSingle.group(4) self.handleCallSingle(strDestDevice,strDestModule,strCallMethod,strCallParams) return # If the module wants to call a method in multiple mudules, get the name of the # modules and dispached it accordingly matchCallMultiple = self.callMultiple.match(strMessage) if matchCallMultiple: strDestDevice = matchCallMultiple.group(1) aDestModule = matchCallMultiple.group(2).split(",") strCallMethod = matchCallMultiple.group(3) strCallParams = matchCallMultiple.group(4) for strDestModule in aDestModule: self.handleCallSingle(strDestDevice,strDestModule,strCallMethod,strCallParams) return # If the module wants to call a method in all known mudules, go through all modules # and send according message matchCallAll = self.callAll.match(strMessage) if matchCallAll: strDestDevice = matchCallAll.group(1) strCallMethod = matchCallAll.group(2) strCallParams = matchCallAll.group(3) for strDestModule in aRegistered: self.handleCallSingle(strDestDevice,strDestModule,strCallMethod,strCallParams) return def handleCallSingle(self,strDestDevice,strDestModule,strCallMethod,strCallParams): logging.debug("handle call: " + strDestDevice + " " + strDestModule + " " + strCallMethod + " " + strCallParams) # If the called module is on tablet, store the call in aRegistered if strDestDevice == "tablet": if strDestModule in aRegistered: registeredLock.acquire() aRegistered[strDestModule].append(("TabletGame",strCallMethod,strCallParams)) registeredLock.release() # If the called module is on Nao, call the method through ALProxy if strDestDevice == "nao": # If the called module is yet yet in aRegisteredNao creates and stores # a new instantiation try: registeredLockNao.acquire() if not strDestModule in aRegisteredNao: aRegisteredNao[strDestModule] = ALProxy(strDestModule,robotIP,9559) registeredLockNao.release() except RuntimeError: registeredLockNao.release() logging.error("Could not obtain module " + strDestModule + " on Nao") return # Call the method of the instantiated called module try: t = None if(strCallParams!=""): t = threading.Thread(target=getattr(aRegisteredNao[strDestModule],strCallMethod),args=(strCallParams,)) else: t = threading.Thread(target=getattr(aRegisteredNao[strDestModule],strCallMethod)) t.start() except RuntimeError: logging.error("Could not call method " + strCallMethod + " on Nao") def new_client(self,client, server): logging.info("New client connected and was given id %d" % client['id']) registeredLock.acquire() aRegistered["tabletgame"] = [] registeredLock.release() #server.send_message_to_all("Hey all, a new client has joined us") def message_received(self, client, server, message): logging.info("Text message received:" + message) self.analyzeMessage(message) def run(self): global msgsForWeb while 1: if not msgsForWeb.empty(): self.tosend=msgsForWeb.get() logging.info("Message to send from Webscoket thread:" + self.tosend) try: self.server.send_message_to_all(self.tosend) except: logging.erro("Unexpected error:", sys.exc_info()[0]) time.sleep(0.1) def client_left(self, client, server): logging.info("Client(%d) disconnected" % client['id']) registeredLock.acquire() del aRegistered["tabletgame"] registeredLock.release()
send_msg(json.dumps(dic)) threading.Timer(0.2, judgeNotes).start() if __name__ == "__main__": f = open('MusicScore.json', 'r') # Json読み込み jsonData = json.load(f) f.close() notesJson = jsonData["Notes"] FootNotesList.append([]) FootNotesList.append([]) FootNotesList.append([]) FootNotesList.append([]) NotesList.append([]) NotesList.append([]) NotesList.append([]) NotesList.append([]) server = WebsocketServer(3000, host='127.0.0.1') # WSserver初期化 server.set_fn_new_client(new_client) server.set_fn_message_received(received_message) thread_1 = threading.Thread(target=server_run, args=([server])) # Serverと入力受付はサブスレッド thread_2 = threading.Thread(target=input_char) thread_3 = threading.Thread(target=judgeNotes) thread_1.start() thread_2.start() thread_3.start()
for mod in modlist: mname = GetModuleName(phandle,mod) if mname.endswith(game["moduleName"]): memory_address = mod + game["memoryOffset"] # read address def readTicker(): ReadProcessMemory(phandle, memory_address, ticker, ticker_s, byref(bytesRead)) def clientJoin(client,server): global client_num client_num += 1 if(client_num==1): initTicker() def clientLeave(client,server): global client_num client_num -= 1 if(client_num==0): CloseHandle(phandle) def clientMsg(client,server,message): readTicker() server.send_message(client,ticker.value.replace('m','.')) print "Starting server on " + str(socket.gethostbyname(socket.gethostname())) server = WebsocketServer(config["serverPort"],"0.0.0.0") server.set_fn_new_client(clientJoin) server.set_fn_client_left(clientLeave) server.set_fn_message_received(clientMsg) server.run_forever()
def __init__(self,ip,port): server = WebsocketServer(port,ip) server.set_fn_client_left(self.client_left) server.set_fn_new_client(self.new_client) server.set_fn_message_received(self.msg_received) server.run_forever()
class hklview_3d: def __init__(self, *args, **kwds): self.settings = kwds.get("settings") self.miller_array = None self.d_min = None self.scene = None self.NGLscriptstr = "" self.cameratype = "orthographic" self.url = "" self.binarray = "Resolution" self.icolourcol = None self.iradiicol = None self.iarray = None self.isnewfile = False self.binvals = [] self.workingbinvals = [] self.proc_arrays = [] self.otherscenes = [] self.othermaxdata = [] self.othermindata = [] self.othermaxsigmas = [] self.otherminsigmas = [] self.sceneisdirty = False self.matchingarrayinfo = [] self.match_valarrays = [] self.binstrs = [] self.mapcoef_fom_dict = {} self.verbose = True if kwds.has_key('verbose'): self.verbose = kwds['verbose'] self.mprint = sys.stdout.write if 'mprint' in kwds: self.mprint = kwds['mprint'] self.nbin = 0 self.websockclient = None self.lastmsg = "" self.StartWebsocket() tempdir = tempfile.gettempdir() self.hklfname = os.path.join(tempdir, "hkl.htm") if os.path.isfile(self.hklfname): os.remove(self.hklfname) if 'htmlfname' in kwds: self.hklfname = kwds['htmlfname'] self.hklfname = os.path.abspath(self.hklfname) self.jscriptfname = os.path.join(tempdir, "hkljstr.js") if os.path.isfile(self.jscriptfname): os.remove(self.jscriptfname) if 'jscriptfname' in kwds: self.jscriptfname = kwds['jscriptfname'] self.mprint('Output will be written to \"%s\"\n' \ 'including reference to NGL JavaScript \"%s\"' %(self.hklfname, self.jscriptfname)) self.hklhtml = r""" <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> <html> <head> <meta charset="utf-8" /> </head> <body> <script src="%s" type="text/javascript"></script> <script src="%s" type="text/javascript"></script> """ self.htmldiv = """ <div id="viewport" style="width:100%; height:100%;"></div> </body></html> """ self.colourgradientvalues = [] self.UseOSBrowser = True if 'UseOSBrowser' in kwds: self.UseOSBrowser = kwds['UseOSBrowser'] self.viewmtrxelms = None self.pendingmessage = None def __exit__(self, exc_type, exc_value, traceback): # not called unless instantiated with a "with hklview_3d ... " statement self.server.shutdown() if os.path.isfile(self.hklfname): os.remove(self.hklfname) def set_miller_array(self, col, merge=None, details="", proc_arrays=[]): self.iarray = col if col: self.miller_array = proc_arrays[col] self.proc_arrays = proc_arrays self.merge = merge if (self.miller_array is None): return self.d_min = self.miller_array.d_min() array_info = self.miller_array.info() self.binvals = [ 1.0 / self.miller_array.d_max_min()[0], 1.0 / self.miller_array.d_max_min()[1] ] #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) uc = "a=%g b=%g c=%g angles=%g,%g,%g" % self.miller_array.unit_cell( ).parameters() self.mprint( "Data: %s %s, %d reflections in space group: %s, unit Cell: %s" \ % (array_info.label_string(), details, self.miller_array.indices().size(), \ self.miller_array.space_group_info(), uc) ) #self.construct_reciprocal_space(merge=merge) def ExtendMillerArraysUnionHKLs(self): #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) self.match_valarrays = [] # loop over all miller arrays to find the subsets of hkls common between currently selected # miler array and the other arrays. hkls found in the currently selected miller array but # missing in the subsets are populated populated with NaN values # create miller indices being a superset of available indices in all arrays self.mprint("Gathering superset of miller indices") superset_array = self.proc_arrays[0] for i, validarray in enumerate(self.proc_arrays): if i == 0: continue # first match indices in currently selected miller array with indices in the other miller arrays matchindices = miller.match_indices(superset_array.indices(), validarray.indices()) #print validarray.info().label_string() valarray = validarray.select(matchindices.pairs().column(1)) #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) if valarray.anomalous_flag( ) and not superset_array.anomalous_flag(): # valarray gets its anomalous_flag from validarray. But it cannot have more HKLs than self.miller_array # so set its anomalous_flag to False if self.miller_array is not anomalous data valarray._anomalous_flag = False if not valarray.anomalous_flag() and superset_array.anomalous_flag( ): # temporarily expand other arrays to anomalous if self.miller_array is anomalous valarray = valarray.generate_bijvoet_mates() missing = superset_array.lone_set(valarray) # insert NAN values for reflections in self.miller_array not found in validarray valarray = display.ExtendMillerArray(valarray, missing.size(), missing.indices()) match_valindices = miller.match_indices(superset_array.indices(), valarray.indices()) #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) match_valarray = valarray.select( match_valindices.pairs().column(1)) match_valarray.sort(by_value="packed_indices") #match_valarray.set_info(validarray.info() ) superset_array = match_valarray #print "supersetsize:", superset_array.size() # now extend each miller array to contain any missing indices from the superset miller array for i, validarray in enumerate(self.proc_arrays): # first match indices in currently selected miller array with indices in the other miller arrays matchindices = miller.match_indices(superset_array.indices(), validarray.indices()) #print validarray.info().label_string() valarray = validarray.select(matchindices.pairs().column(1)) #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) if valarray.anomalous_flag( ) and not superset_array.anomalous_flag(): # valarray gets its anomalous_flag from validarray. But it cannot have more HKLs than self.miller_array # so set its anomalous_flag to False if self.miller_array is not anomalous data valarray._anomalous_flag = False if not valarray.anomalous_flag() and superset_array.anomalous_flag( ): # temporarily expand other arrays to anomalous if self.miller_array is anomalous valarray = valarray.generate_bijvoet_mates() missing = superset_array.lone_set(valarray) # insert NAN values for reflections in self.miller_array not found in validarray valarray = display.ExtendMillerArray(valarray, missing.size(), missing.indices()) match_valindices = miller.match_indices(superset_array.indices(), valarray.indices()) #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) match_valarray = valarray.select( match_valindices.pairs().column(1)) match_valarray.sort(by_value="packed_indices") match_valarray.set_info(validarray.info()) self.match_valarrays.append(match_valarray) def construct_reciprocal_space(self, merge=None): self.mprint("Constructing HKL scenes") #if len(self.match_valarrays)==0: # self.ExtendMillerArraysUnionHKLs() self.miller_array = self.match_valarrays[self.iarray] if not self.sceneisdirty: return self.otherscenes = [] self.othermaxdata = [] self.othermindata = [] self.othermaxsigmas = [] self.otherminsigmas = [] self.matchingarrayinfo = [] #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) foms_array = None if self.miller_array.is_complex_array(): fomcolm = self.mapcoef_fom_dict.get( self.miller_array.info().label_string()) if fomcolm: foms_array = self.proc_arrays[fomcolm].deep_copy() #self.scene = display.scene(miller_array=self.miller_array, merge=merge, # settings=self.settings, foms_array=foms_array) # compute scenes for each of the miller arrays for i, match_valarray in enumerate(self.match_valarrays): foms = None if match_valarray.is_complex_array(): fomcolm = self.mapcoef_fom_dict.get( match_valarray.info().label_string()) #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) if fomcolm: foms = self.match_valarrays[fomcolm] #commonarray = match_valarray commonarray = match_valarray.common_set( self.proc_arrays[self.iarray]) commonarray.set_info(match_valarray.info()) if i == self.iradiicol or i == self.icolourcol or i == self.iarray: bfullprocess = True else: bfullprocess = False otherscene = display.scene(miller_array=commonarray, merge=merge, settings=self.settings, foms_array=foms, fullprocessarray=True) #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) if not otherscene.SceneCreated: self.mprint("The " + commonarray.info().label_string() + " array was not processed") continue #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) # cast any NAN values to 1 of the colours and radii to 0.2 before writing javascript b = flex.bool([ bool(math.isnan(e[0]) + math.isnan(e[1]) + math.isnan(e[2])) for e in otherscene.colors ]) otherscene.colors = otherscene.colors.set_selected( b, (1.0, 1.0, 1.0)) b = flex.bool([bool(math.isnan(e)) for e in otherscene.radii]) otherscene.radii = otherscene.radii.set_selected(b, 0.2) self.otherscenes.append(otherscene) ainf = ArrayInfo(otherscene.work_array, self.mprint) self.othermaxdata.append(ainf.maxdata) self.othermindata.append(ainf.mindata) self.othermaxsigmas.append(ainf.maxsigmas) self.otherminsigmas.append(ainf.minsigmas) infostr = ainf.infostr self.mprint("%d, %s" % (i, infostr)) self.matchingarrayinfo.append(infostr) #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) self.sceneisdirty = False def update_settings(self, diffphil): if hasattr(diffphil, "filename"): self.ExtendMillerArraysUnionHKLs() self.sceneisdirty = True if hasattr(diffphil, "spacegroupchoice") or \ hasattr(diffphil, "mergedata") or \ hasattr(diffphil, "column") or \ hasattr(diffphil, "fomcolumn") or \ hasattr(diffphil, "viewer") and ( hasattr(diffphil.viewer, "show_anomalous_pairs") \ or hasattr(diffphil.viewer, "show_data_over_sigma") \ or hasattr(diffphil.viewer, "show_missing") \ or hasattr(diffphil.viewer, "show_only_missing") \ or hasattr(diffphil.viewer, "show_systematic_absences") \ or hasattr(diffphil.viewer, "slice_axis") \ or hasattr(diffphil.viewer, "slice_mode") \ or hasattr(diffphil.viewer, "scale") \ or hasattr(diffphil.viewer, "nth_power_scale_radii") \ or hasattr(diffphil.viewer, "expand_anomalous") \ or hasattr(diffphil.viewer, "expand_to_p1") ): self.sceneisdirty = True self.construct_reciprocal_space(merge=self.merge) if self.miller_array is None or self.iarray < 0: return self.scene = self.otherscenes[self.iarray] self.DrawNGLJavaScript() msg = "Rendered %d reflections\n" % self.scene.points.size() return msg def UpdateBinValues(self, binvals=[]): if binvals: self.binvals = binvals else: self.binvals = [ 1.0 / self.miller_array.d_max_min()[0], 1.0 / self.miller_array.d_max_min()[1] ] def DrawNGLJavaScript(self): if self.miller_array is None: self.mprint("A miller array must be selected for drawing") return self.mprint("Composing NGL JavaScript...") h_axis = self.scene.axes[0] k_axis = self.scene.axes[1] l_axis = self.scene.axes[2] nrefls = self.scene.points.size() Hstararrowstart = roundoff( [-h_axis[0] * 100, -h_axis[1] * 100, -h_axis[2] * 100]) Hstararrowend = roundoff( [h_axis[0] * 100, h_axis[1] * 100, h_axis[2] * 100]) Hstararrowtxt = roundoff( [h_axis[0] * 102, h_axis[1] * 102, h_axis[2] * 102]) Kstararrowstart = roundoff( [-k_axis[0] * 100, -k_axis[1] * 100, -k_axis[2] * 100]) Kstararrowend = roundoff( [k_axis[0] * 100, k_axis[1] * 100, k_axis[2] * 100]) Kstararrowtxt = roundoff( [k_axis[0] * 102, k_axis[1] * 102, k_axis[2] * 102]) Lstararrowstart = roundoff( [-l_axis[0] * 100, -l_axis[1] * 100, -l_axis[2] * 100]) Lstararrowend = roundoff( [l_axis[0] * 100, l_axis[1] * 100, l_axis[2] * 100]) Lstararrowtxt = roundoff( [l_axis[0] * 102, l_axis[1] * 102, l_axis[2] * 102]) # make arrow font size roughly proportional to radius of highest resolution shell fontsize = str(1.0 + roundoff( math.pow(max(self.miller_array.index_span().max()), 1.0 / 3.0))) arrowstr = """ // xyz arrows shape.addSphere( [0,0,0] , [ 1, 1, 1 ], 0.3, 'Origo'); //blue-x shape.addArrow( %s, %s , [ 0, 0, 1 ], 0.1); //green-y shape.addArrow( %s, %s , [ 0, 1, 0 ], 0.1); //red-z shape.addArrow( %s, %s , [ 1, 0, 0 ], 0.1); shape.addText( %s, [ 0, 0, 1 ], %s, 'h'); shape.addText( %s, [ 0, 1, 0 ], %s, 'k'); shape.addText( %s, [ 1, 0, 0 ], %s, 'l'); """ % (str(Hstararrowstart), str(Hstararrowend), str(Kstararrowstart), str(Kstararrowend), str(Lstararrowstart), str(Lstararrowend), Hstararrowtxt, fontsize, Kstararrowtxt, fontsize, Lstararrowtxt, fontsize) # Make colour gradient array used for drawing a bar of colours next to associated values on the rendered html mincolourscalar = self.othermindata[self.icolourcol] maxcolourscalar = self.othermaxdata[self.icolourcol] if self.settings.sigma_color: mincolourscalar = self.otherminsigmas[self.icolourcol] maxcolourscalar = self.othermaxsigmas[self.icolourcol] span = maxcolourscalar - mincolourscalar ln = 60 incr = span / ln colourgradarrays = [] val = mincolourscalar colourscalararray = flex.double() colourscalararray.append(val) for j, sc in enumerate(range(ln)): val += incr colourscalararray.append(val) if self.otherscenes[self.icolourcol].miller_array.is_complex_array(): # When displaying phases from map coefficients together with fom values # compute colour map chart as a function of fom and phase values (x,y axis) incr = 360.0 / ln val = 0.0 colourscalararray = flex.double() colourscalararray.append(val) for j in enumerate(range(ln)): val += incr colourscalararray.append(val) fomarrays = [] if self.otherscenes[self.icolourcol].isUsingFOMs(): fomln = 50 fom = 1.0 fomdecr = 1.0 / (fomln - 1.0) # make fomln fom arrays of size len(colourscalararray) when calling colour_by_phi_FOM for j in range(fomln): fomarrays.append(flex.double(len(colourscalararray), fom)) fom -= fomdecr for j in range(fomln): colourgradarrays.append( graphics_utils.colour_by_phi_FOM( colourscalararray * (math.pi / 180.0), fomarrays[j]) * 255.0) else: fomln = 1 fomarrays = [1.0] colourgradarrays.append( graphics_utils.colour_by_phi_FOM(colourscalararray * (math.pi / 180.0)) * 255.0) else: fomln = 1 fomarrays = [1.0] colourgradarrays.append( graphics_utils.color_by_property( properties=flex.double(colourscalararray), selection=flex.bool(len(colourscalararray), True), color_all=False, gradient_type=self.settings.color_scheme) * 255.0) colors = self.otherscenes[self.icolourcol].colors radii = self.otherscenes[self.iradiicol].radii points = self.scene.points hkls = self.scene.indices dres = self.scene.dres colstr = self.scene.miller_array.info().label_string() data = self.scene.data colourlabel = self.otherscenes[self.icolourcol].colourlabel fomlabel = self.otherscenes[self.icolourcol].fomlabel #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) assert (colors.size() == radii.size() == nrefls) colours = [] positions = [] radii2 = [] spbufttips = [] self.workingbinvals = [] if not self.binarray == "Resolution": ibinarray = int(self.binarray) self.workingbinvals = [ self.othermindata[ibinarray] - 0.1, self.othermaxdata[ibinarray] + 0.1 ] self.workingbinvals.extend(self.binvals) self.workingbinvals.sort() if self.workingbinvals[0] < 0.0: self.workingbinvals.append(0.0) self.workingbinvals.sort() bindata = self.otherscenes[ibinarray].data if self.otherscenes[ibinarray].work_array.is_complex_array(): bindata = self.otherscenes[ibinarray].ampl else: self.workingbinvals = self.binvals colstr = "dres" bindata = 1.0 / dres self.nbin = len(self.workingbinvals) for ibin in range(self.nbin): colours.append([]) # colours and positions are 3 x size of data() positions.append([]) radii2.append([]) spbufttips.append([]) def data2bin(d): for ibin, binval in enumerate(self.workingbinvals): if (ibin + 1) == self.nbin: return ibin if d > binval and d <= self.workingbinvals[ibin + 1]: return ibin #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) raise Sorry("Should never get here") #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) for i, hklstars in enumerate(points): # bin currently displayed data according to the values of another miller array ibin = data2bin(bindata[i]) spbufttip = 'H,K,L: %s, %s, %s' % (hkls[i][0], hkls[i][1], hkls[i][2]) spbufttip += '\ndres: %s ' % str(roundoff(dres[i])) spbufttip += '\' + AA + \'' for j, otherscene in enumerate(self.otherscenes): ocolstr = self.proc_arrays[j].info().label_string() odata = otherscene.data od = "" if self.proc_arrays[j].is_complex_array(): if not math.isnan(otherscene.foms[i]): od = str(roundoff(otherscene.ampl[i])) + ", " + str(roundoff(otherscene.phases[i]) ) + \ "\' + DGR + \'" + ", " + str(roundoff(otherscene.foms[i]) ) else: od = str(roundoff(otherscene.ampl[i])) + ", " + str(roundoff(otherscene.phases[i]) ) + \ "\' + DGR + \'" elif self.proc_arrays[j].sigmas() is not None: od = str(roundoff(odata[i])) + ", " + str( roundoff(otherscene.sigmas[i])) else: od = str(roundoff(odata[i])) if not (math.isnan(abs(odata[i])) or odata[i] == display.inanval): spbufttip += "\n%s: %s" % (ocolstr, od) positions[ibin].extend(roundoff(list(hklstars))) colours[ibin].extend(roundoff(list(colors[i]), 2)) radii2[ibin].append(roundoff(radii[i], 2)) spbufttips[ibin].append(spbufttip) spherebufferstr = """ ttips = new Array(%d) positions = new Array(%d) colours = new Array(%d) radii = new Array(%d) spherebufs = new Array(%d) """ % (self.nbin, self.nbin, self.nbin, self.nbin, self.nbin) negativeradiistr = "" cntbin = 0 self.binstrs = [] for ibin in range(self.nbin): mstr = "" nreflsinbin = len(radii2[ibin]) if (ibin + 1) < self.nbin and nreflsinbin > 0: bin1 = self.workingbinvals[ibin] bin2 = self.workingbinvals[ibin + 1] if colstr == "dres": bin1 = 1.0 / self.workingbinvals[ibin] bin2 = 1.0 / self.workingbinvals[ibin + 1] mstr= "bin:%d, %d reflections with %s in ]%2.2f; %2.2f]" %(cntbin, nreflsinbin, \ colstr, bin1, bin2) self.binstrs.append(mstr) self.mprint(mstr, verbose=True) spherebufferstr += """ // %s ttips[%d] = %s positions[%d] = new Float32Array( %s ) colours[%d] = new Float32Array( %s ) radii[%d] = new Float32Array( %s ) spherebufs[%d] = new NGL.SphereBuffer({ position: positions[%d], color: colours[%d], radius: radii[%d], picking: ttips[%d], }) //}, { disableImpostor: true }) // if true allows wireframe spheres but does not allow resizing spheres shape.addBuffer(spherebufs[%d]) """ %(mstr, cntbin, str(spbufttips[ibin]).replace('\"', '\''), \ cntbin, str(positions[ibin]), cntbin, str(colours[ibin]), \ cntbin, str(radii2[ibin]), cntbin, cntbin, cntbin, cntbin, cntbin, cntbin ) if self.workingbinvals[ibin] < 0.0: negativeradiistr += "spherebufs[%d].setParameters({metalness: 1})\n" % cntbin cntbin += 1 spherebufferstr += """ // create tooltip element and add to the viewer canvas tooltip = document.createElement("div"); Object.assign(tooltip.style, { display: "none", position: "absolute", zIndex: 10, pointerEvents: "none", backgroundColor: "rgba(255, 255, 255, 0.75)", color: "black", padding: "0.1em", fontFamily: "sans-serif" }); stage.viewer.container.appendChild(tooltip); // listen to `hovered` signal to move tooltip around and change its text stage.signals.hovered.add(function (pickingProxy) { if (pickingProxy && (Object.prototype.toString.call(pickingProxy.picker) === '[object Array]' )){ var sphere = pickingProxy.sphere; var cp = pickingProxy.canvasPosition; tooltip.innerText = pickingProxy.picker[pickingProxy.pid]; tooltip.style.bottom = cp.y + 7 + "px"; tooltip.style.left = cp.x + 8 + "px"; tooltip.style.fontSize = "smaller"; tooltip.style.display = "block"; }else{ tooltip.style.display = "none"; } }); stage.signals.clicked.add(function (pickingProxy) { if (pickingProxy && (Object.prototype.toString.call(pickingProxy.picker) === '[object Array]' )){ var innerText = pickingProxy.picker[pickingProxy.pid]; mysocket.send( innerText); } }); """ colourgradstrs = "colourgradvalarray = new Array(%s)\n" % fomln # if displaying phases from map coefficients together with fom values then for g, colourgradarray in enumerate(colourgradarrays): self.colourgradientvalues = [] for j, e in enumerate(colourgradarray): self.colourgradientvalues.append([colourscalararray[j], e]) self.colourgradientvalues = roundoff(self.colourgradientvalues) fom = fomarrays[g] colourgradstr = [] for j, val in enumerate(self.colourgradientvalues): vstr = "" alpha = 1.0 gradval = "rgba(%s, %s, %s, %s)" % (val[1][0], val[1][1], val[1][2], alpha) if j % 10 == 0 or j == len(self.colourgradientvalues) - 1: vstr = str(roundoff(val[0], 2)) colourgradstr.append([vstr, gradval]) colourgradstrs += " colourgradvalarray[%s] = %s\n" % ( g, str(colourgradstr)) #negativeradiistr = "" #for ibin in range(self.nbin): # if self.workingbinvals[ibin] < 0.0: # negativeradiistr += "spherebufs[%d].setParameters({metalness: 1})\n" %ibin self.NGLscriptstr = """ // Microsoft Edge users follow instructions on // https://stackoverflow.com/questions/31772564/websocket-to-localhost-not-working-on-microsoft-edge // to enable websocket connection var pagename = location.pathname.substring(1); var mysocket = new WebSocket('ws://127.0.0.1:7894/'); mysocket.onopen = function (e) { mysocket.send('%s now connected via websocket to ' + pagename + '\\n'); }; mysocket.onclose = function (e) { mysocket.send('%s now disconnecting from websocket ' + pagename + '\\n'); }; // Log errors to debugger of your browser mysocket.onerror = function (error) { console.log('WebSocket Error ' + error); }; window.addEventListener( 'resize', function( event ){ stage.handleResize(); }, false ); var stage; var shape; var shapeComp; var repr; var AA = String.fromCharCode(197); // short for angstrom var DGR = String.fromCharCode(176); // short for degree symbol function createElement (name, properties, style) { // utility function used in for loop over colourgradvalarray var el = document.createElement(name) Object.assign(el, properties) Object.assign(el.style, style) Object.assign(el.style, { display: "block", position: "absolute", color: "black", fontFamily: "sans-serif", fontSize: "smaller", } ) return el } function addElement (el) { // utility function used in for loop over colourgradvalarray Object.assign(el.style, { position: "absolute", zIndex: 10 }) stage.viewer.container.appendChild(el) } function addDivBox(txt, t, l, w, h, bgcolour='rgba(255.0, 255.0, 255.0, 0.0)') { divbox = createElement("div", { innerText: txt }, { backgroundColor: bgcolour, color: 'rgba(0.0, 0.0, 0.0, 1.0)', top: t.toString() + "px", left: l.toString() + "px", width: w.toString() + "px", height: h.toString() + "px", } ); addElement(divbox) } var hklscene = function () { shape = new NGL.Shape('shape'); stage = new NGL.Stage('viewport', { backgroundColor: "grey", tooltip:false, fogNear: 100, fogFar: 100 }); stage.setParameters( { cameraType: "%s" } ); %s %s shapeComp = stage.addComponentFromObject(shape); repr = shapeComp.addRepresentation('buffer'); shapeComp.autoView(); repr.update() // if some radii are negative draw them with wireframe %s //colourgradvalarrays %s var ih = 3; var topr = 35 var topr2 = 10 var lp = 10 var wp = 40 var lp2 = lp + wp var gl = 3 var wp2 = gl var fomlabelheight = 25 if (colourgradvalarray.length === 1) { wp2 = 15 fomlabelheight = 0 } var wp3 = wp + colourgradvalarray.length * wp2 + 2 totalheight = ih*colourgradvalarray[0].length + 35 + fomlabelheight // make a white box on top of which boxes with transparent background are placed // containing the colour values at regular intervals as well as label legend of // the displayed miller array addDivBox("", topr2, lp, wp3, totalheight, 'rgba(255.0, 255.0, 255.0, 1.0)'); // print label of the miller array used for colouring addDivBox("%s", topr2, lp, wp, 20); if (colourgradvalarray.length > 1) { // print FOM label, 1, 0.5 and 0.0 values below colour chart fomtop = topr2 + totalheight - 18 fomlp = lp + wp fomwp = wp3 fomtop2 = fomtop - 13 // print the 1 number addDivBox("1", fomtop2, fomlp, fomwp, 20) // print the 0.5 number leftp = fomlp + 0.48 * gl * colourgradvalarray.length addDivBox("0.5", fomtop2, leftp, fomwp, 20) // print the FOM label addDivBox("%s", fomtop, leftp, fomwp, 20); // print the 0 number leftp = fomlp + 0.96 * gl * colourgradvalarray.length addDivBox("0", fomtop2, leftp, fomwp, 20) } for (j = 0; j < colourgradvalarray[0].length; j++) { rgbcol = colourgradvalarray[0][j][1]; val = colourgradvalarray[0][j][0] topv = j*ih + topr toptxt = topv - 5 // print value of miller array if present in colourgradvalarray[0][j][0] addDivBox(val, toptxt, lp, wp, ih); } // draw the colour gradient for (g = 0; g < colourgradvalarray.length; g++) { leftp = g*gl + lp + wp // if FOM values are supplied draw colour gradients with decreasing // saturation values as stored in the colourgradvalarray[g] arrays for (j = 0; j < colourgradvalarray[g].length; j++) { rgbcol = colourgradvalarray[g][j][1]; val = colourgradvalarray[g][j][0] topv = j*ih + topr addDivBox("", topv, leftp, wp2, ih, rgbcol); } } } document.addEventListener('DOMContentLoaded', function() { hklscene() }, false ); mysocket.onmessage = function (e) { //alert('Server: ' + e.data); var c var alpha var si mysocket.send('got ' + e.data ); // tell server what it sent us try { val = e.data.split(",") if (val[0] === "alpha") { ibin = parseInt(val[1]) alpha = parseFloat(val[2]) spherebufs[ibin].setParameters({opacity: alpha}) stage.viewer.requestRender() } if (val[0] === "colour") { ibin = parseInt(val[1]) si = parseInt(val[2]) colours[ibin][3*si] = parseFloat(val[3]) colours[ibin][3*si+1] = parseFloat(val[4]) colours[ibin][3*si+2] = parseFloat(val[5]) spherebufs[ibin].setAttributes({ color: colours[ibin] }) stage.viewer.requestRender() } if (val[0] === "Redraw") { stage.viewer.requestRender() } if (val[0] === "ReOrient") { mysocket.send( 'Reorienting ' + pagename ); sm = new Float32Array(16); for (j=0; j<16; j++) sm[j] = parseFloat(val[j + 2]) // first 2 are "ReOrient", "NGL\\n" var m = new NGL.Matrix4(); m.fromArray(sm); stage.viewerControls.orient(m); stage.viewer.requestRender(); } if (val[0] === "Reload") { // refresh browser with the javascript file cvorient = stage.viewerControls.getOrientation().elements msg = String(cvorient) mysocket.send('Current vieworientation:\\n, ' + msg ); mysocket.send( 'Refreshing ' + pagename ); window.location.reload(true); } if (val[0] === "Testing") { // test something new mysocket.send( 'Testing something new ' + pagename ); var newradii = radii[0].map(function(element) { return element*1.5; }); spherebufs[0].setAttributes({ radius: newradii }) stage.viewer.requestRender() } } catch(err) { mysocket.send('error: ' + err ); } }; """ % (self.__module__, self.__module__, self.cameratype, arrowstr, spherebufferstr, \ negativeradiistr, colourgradstrs, colourlabel, fomlabel) if self.jscriptfname: with open(self.jscriptfname, "w") as f: f.write(self.NGLscriptstr) self.ReloadNGL() def OnConnectWebsocketClient(self, client, server): #if not self.websockclient: self.websockclient = client self.mprint("Browser connected:" + str(self.websockclient), self.verbose) #else: # self.mprint( "Unexpected browser connection was rejected" ) def OnWebsocketClientMessage(self, client, server, message): if message != "": self.mprint(message, verbose=False) self.lastmsg = message if "Current vieworientation:" in message: # The NGL.Matrix4 with the orientation is a list of floats. self.viewmtrxelms = message[message.find("\n"):] sleep(0.2) self.mprint("Reorienting client after refresh:" + str(self.websockclient)) if not self.isnewfile: self.pendingmessage = u"ReOrient, NGL" + self.viewmtrxelms self.isnewfile = False def WebBrowserMsgQueue(self): while True: sleep(1) if hasattr(self, "pendingmessage") and self.pendingmessage: self.SendWebSockMsg(self.pendingmessage) self.pendingmessage = None def StartWebsocket(self): self.server = WebsocketServer(7894, host='127.0.0.1') if not self.server: raise Sorry("Could not connect socket to web browser") self.server.set_fn_new_client(self.OnConnectWebsocketClient) self.server.set_fn_message_received(self.OnWebsocketClientMessage) self.wst = threading.Thread(target=self.server.run_forever) self.wst.daemon = True self.wst.start() self.msgqueuethrd = threading.Thread(target=self.WebBrowserMsgQueue) self.msgqueuethrd.daemon = True self.msgqueuethrd.start() def SendWebSockMsg(self, msg): #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) #print "self.server.clients: ", self.server.clients #print "self.websockclient: ", if self.websockclient: while "Refreshing" in self.lastmsg: sleep(0.5) self.lastmsg = "" self.server.send_message(self.websockclient, msg) else: self.OpenBrowser() def SetOpacity(self, bin, alpha): if bin > self.nbin: self.mprint("There are only %d bins of data present" % self.nbin) return msg = u"alpha, %d, %f" % (bin, alpha) self.SendWebSockMsg(msg) def RedrawNGL(self): self.SendWebSockMsg(u"Redraw, NGL\n") def ReloadNGL(self): # expensive as javascript may be several Mbytes large self.mprint("Rendering NGL JavaScript...") self.SendWebSockMsg(u"Reload, NGL\n") def OpenBrowser(self): NGLlibpath = libtbx.env.under_root( os.path.join("modules", "cctbx_project", "crys3d", "hklview", "ngl.js")) htmlstr = self.hklhtml % (NGLlibpath, os.path.abspath( self.jscriptfname)) htmlstr += self.htmldiv with open(self.hklfname, "w") as f: f.write(htmlstr) self.url = "file://" + os.path.abspath(self.hklfname) self.mprint( "Writing %s and connecting to its websocket client" % self.hklfname, self.verbose) if self.UseOSBrowser: webbrowser.open(self.url, new=1) self.isnewfile = False def TestNewFunction(self): self.SendWebSockMsg(u"Testing, NGL\n")
# print 'car position did not change' pos_check = 0 idx0 = string_list[1].find("[") car_orient_tmp = eval(string_list[1][idx0:]) orient_check = 1 if np.linalg.norm(np.array(car_orient_tmp) - np.array(car_orient)) < 0.05: # print 'car orientation did not change' pos_check = 0 if car_pos_tmp == [0, 0] and car_orient_tmp == [1, 0]: return car_pos = car_pos_tmp car_orient = car_orient_tmp new_car_param = pos_check + orient_check if new_car_param < 2: new_car_param = 0 else: new_car_param = 1 server = WebsocketServer(9090, host='172.27.163.216') server.set_fn_new_client(new_client) server.set_fn_message_received(new_message) server.set_fn_client_left(client_left) path_pub = rospy.Publisher('web_socket/path', String, queue_size=1) rospy.Subscriber('lane_driver/path', String, callback_path) rospy.Subscriber("lane_driver/car", String, callback_car) rospy.Subscriber("drive_param_fin", drive_param, callback_drive) update_thread = Update() server.run_forever()
def SocketServerStart(): server = WebsocketServer(SOCKET_PORT, HOST) server.set_fn_new_client(NewClient) server.set_fn_client_left(ClientLeft) server.set_fn_message_received(MessageReceived) server.run_forever()
class Template: # Initialize class variables # self.time_cycle to run an execution for atleast 1 second # self.process for the current running process def __init__(self): self.thread = None self.reload = False # Time variables self.time_cycle = 80 self.ideal_cycle = 80 self.iteration_counter = 0 self.frequency_message = {'brain': '', 'gui': ''} self.server = None self.client = None self.host = sys.argv[1] # Initialize the GUI and Console behind the scenes self.hal = HAL() self.gui = GUI(self.host, self.hal) # Function for saving def save_code(self, source_code): with open('code/academy.py', 'w') as code_file: code_file.write(source_code) # Function for loading def load_code(self): with open('code/academy.py', 'r') as code_file: source_code = code_file.read() return source_code # Function to parse the code # A few assumptions: # 1. The user always passes sequential and iterative codes # 2. Only a single infinite loop def parse_code(self, source_code): # Check for save/load if (source_code[:5] == "#save"): source_code = source_code[5:] self.save_code(source_code) return "", "", 1 elif (source_code[:5] == "#load"): source_code = source_code + self.load_code() self.server.send_message(self.client, source_code) return "", "", 1 elif (source_code[:5] == "#resu"): restart_simulation = rospy.ServiceProxy('/gazebo/unpause_physics', Empty) restart_simulation() return "", "", 1 elif (source_code[:5] == "#paus"): pause_simulation = rospy.ServiceProxy('/gazebo/pause_physics', Empty) pause_simulation() return "", "", 1 elif (source_code[:5] == "#rest"): reset_simulation = rospy.ServiceProxy('/gazebo/reset_world', Empty) reset_simulation() self.gui.reset_gui() return "", "" else: # Get the frequency of operation, convert to time_cycle and strip sequential_code, iterative_code = self.seperate_seq_iter( source_code) return iterative_code, sequential_code # Function to parse code according to the debugging level def debug_parse(self, source_code, debug_level): if (debug_level == 1): # If debug level is 0, then all the GUI operations should not be called source_code = re.sub(r'GUI\..*', '', source_code) return source_code # Function to seperate the iterative and sequential code def seperate_seq_iter(self, source_code): if source_code == "": return "", "" # Search for an instance of while True infinite_loop = re.search(r'[^ \t]while\(True\):|[^ \t]while True:', source_code) # Seperate the content inside while True and the other # (Seperating the sequential and iterative part!) try: start_index = infinite_loop.start() iterative_code = source_code[start_index:] sequential_code = source_code[:start_index] # Remove while True: syntax from the code # And remove the the 4 spaces indentation before each command iterative_code = re.sub(r'[^ ]while\(True\):|[^ ]while True:', '', iterative_code) iterative_code = re.sub(r'^[ ]{4}', '', iterative_code, flags=re.M) except: sequential_code = source_code iterative_code = "" return sequential_code, iterative_code # The process function def process_code(self, source_code): # Redirect the information to console start_console() # Reference Environment for the exec() function iterative_code, sequential_code = self.parse_code(source_code) # print("The debug level is " + str(debug_level) # print(sequential_code) # print(iterative_code) # The Python exec function # Run the sequential part gui_module, hal_module = self.generate_modules() reference_environment = {"GUI": gui_module, "HAL": hal_module} exec(sequential_code, reference_environment) # Run the iterative part inside template # and keep the check for flag while self.reload == False: start_time = datetime.now() # Execute the iterative portion exec(iterative_code, reference_environment) # Template specifics to run! finish_time = datetime.now() dt = finish_time - start_time ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0 # Keep updating the iteration counter if (iterative_code == ""): self.iteration_counter = 0 else: self.iteration_counter = self.iteration_counter + 1 # The code should be run for atleast the target time step # If it's less put to sleep if (ms < self.time_cycle): time.sleep((self.time_cycle - ms) / 1000.0) close_console() print("Current Thread Joined!") # Function to generate the modules for use in ACE Editor def generate_modules(self): # Define HAL module hal_module = imp.new_module("HAL") hal_module.HAL = imp.new_module("HAL") # Add HAL functions hal_module.HAL.getImage = self.hal.getImage hal_module.HAL.graficToOptical = self.hal.graficToOptical hal_module.HAL.backproject = self.hal.backproject hal_module.HAL.getCameraPosition = self.hal.getCameraPosition hal_module.HAL.project = self.hal.project hal_module.HAL.opticalToGrafic = self.hal.opticalToGrafic hal_module.HAL.project3DScene = self.hal.project3DScene # Define GUI module gui_module = imp.new_module("GUI") gui_module.GUI = imp.new_module("GUI") # Add GUI functions gui_module.GUI.showImages = self.gui.showImages gui_module.GUI.ShowNewPoints = self.gui.ShowNewPoints gui_module.GUI.ShowAllPoints = self.gui.ShowAllPoints gui_module.GUI.showImageMatching = self.gui.showImageMatching gui_module.GUI.ClearAllPoints = self.gui.ClearAllPoints # Adding modules to system # Protip: The names should be different from # other modules, otherwise some errors sys.modules["HAL"] = hal_module sys.modules["GUI"] = gui_module return gui_module, hal_module # Function to measure the frequency of iterations def measure_frequency(self): previous_time = datetime.now() # An infinite loop while self.reload == False: # Sleep for 2 seconds time.sleep(2) # Measure the current time and subtract from the previous time to get real time interval current_time = datetime.now() dt = current_time - previous_time ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0 previous_time = current_time # Get the time period try: # Division by zero self.ideal_cycle = ms / self.iteration_counter except: self.ideal_cycle = 0 # Reset the counter self.iteration_counter = 0 # Function to generate and send frequency messages def send_frequency_message(self): # This function generates and sends frequency measures of the brain and gui brain_frequency = 0 gui_frequency = 0 try: brain_frequency = round(1000 / self.ideal_cycle, 1) except ZeroDivisionError: brain_frequency = 0 try: gui_frequency = round(1000 / self.thread_gui.ideal_cycle, 1) except ZeroDivisionError: gui_frequency = 0 self.frequency_message["brain"] = brain_frequency self.frequency_message["gui"] = gui_frequency message = "#freq" + json.dumps(self.frequency_message) self.server.send_message(self.client, message) # Function to maintain thread execution def execute_thread(self, source_code): # Keep checking until the thread is alive # The thread will die when the coming iteration reads the flag if (self.thread != None): while self.thread.is_alive() or self.measure_thread.is_alive(): pass # Turn the flag down, the iteration has successfully stopped! self.reload = False # New thread execution self.measure_thread = threading.Thread(target=self.measure_frequency) self.thread = threading.Thread(target=self.process_code, args=[source_code]) self.thread.start() self.measure_thread.start() print("New Thread Started!") # Function to read and set frequency from incoming message def read_frequency_message(self, message): frequency_message = json.loads(message) # Set brain frequency frequency = float(frequency_message["brain"]) self.time_cycle = 1000.0 / frequency # Set gui frequency frequency = float(frequency_message["gui"]) self.thread_gui.time_cycle = 1000.0 / frequency return # The websocket function # Gets called when there is an incoming message from the client def handle(self, client, server, message): if (message[:5] == "#freq"): frequency_message = message[5:] self.read_frequency_message(frequency_message) self.send_frequency_message() return try: # Once received turn the reload flag up and send it to execute_thread function code = message # print(repr(code)) self.reload = True self.execute_thread(code) except: pass # Function that gets called when the server is connected def connected(self, client, server): self.client = client # Start the GUI update thread self.thread_gui = ThreadGUI(self.gui) self.thread_gui.start() # Initialize the frequency message self.send_frequency_message() print(client, 'connected') # Function that gets called when the connected closes def handle_close(self, client, server): print(client, 'closed') def run_server(self): self.server = WebsocketServer(port=1905, host=self.host) self.server.set_fn_new_client(self.connected) self.server.set_fn_client_left(self.handle_close) self.server.set_fn_message_received(self.handle) self.server.run_forever()
class Template: # Initialize class variables # self.time_cycle to run an execution for at least 1 second # self.process for the current running process def __init__(self): self.thread = None self.reload = False # Time variables self.time_cycle = 80 self.ideal_cycle = 80 self.iteration_counter = 0 self.real_time_factor = 0 self.frequency_message = {'brain': '', 'gui': '', 'rtf': ''} self.server = None self.client = None self.host = sys.argv[1] # Initialize the GUI, HAL and Console behind the scenes self.hal = HAL() self.gui = GUI(self.host, self.hal) # Function for saving def save_code(self, source_code): with open('code/academy.py', 'w') as code_file: code_file.write(source_code) # Function for loading def load_code(self): with open('code/academy.py', 'r') as code_file: source_code = code_file.read() return source_code # Function to parse the code # A few assumptions: # 1. The user always passes sequential and iterative codes # 2. Only a single infinite loop def parse_code(self, source_code): # Check for save/load if (source_code[:5] == "#save"): source_code = source_code[5:] self.save_code(source_code) return "", "" elif (source_code[:5] == "#load"): source_code = source_code + self.load_code() self.server.send_message(self.client, source_code) return "", "" elif (source_code[:5] == "#resu"): restart_simulation = rospy.ServiceProxy('/gazebo/unpause_physics', Empty) restart_simulation() return "", "" elif (source_code[:5] == "#paus"): pause_simulation = rospy.ServiceProxy('/gazebo/pause_physics', Empty) pause_simulation() return "", "" elif (source_code[:5] == "#rest"): reset_simulation = rospy.ServiceProxy('/gazebo/reset_world', Empty) reset_simulation() self.gui.reset_gui() return "", "" else: # Get the frequency of operation, convert to time_cycle and strip try: # Get the debug level and strip the debug part debug_level = int(source_code[5]) source_code = source_code[12:] except: debug_level = 1 source_code = "" source_code = self.debug_parse(source_code, debug_level) # Pause and unpause if (source_code == ""): self.gui.lap.pause() else: self.gui.lap.unpause() sequential_code, iterative_code = self.seperate_seq_iter( source_code) return iterative_code, sequential_code # Function to parse code according to the debugging level def debug_parse(self, source_code, debug_level): if (debug_level == 1): # If debug level is 0, then all the GUI operations should not be called source_code = re.sub(r'GUI\..*', '', source_code) return source_code # Function to seperate the iterative and sequential code def seperate_seq_iter(self, source_code): if source_code == "": return "", "" # Search for an instance of while True infinite_loop = re.search(r'[^ \t]while\(True\):|[^ \t]while True:', source_code) # Seperate the content inside while True and the other # (Seperating the sequential and iterative part!) try: start_index = infinite_loop.start() iterative_code = source_code[start_index:] sequential_code = source_code[:start_index] # Remove while True: syntax from the code # And remove the the 4 spaces indentation before each command iterative_code = re.sub(r'[^ ]while\(True\):|[^ ]while True:', '', iterative_code) iterative_code = re.sub(r'^[ ]{4}', '', iterative_code, flags=re.M) except: sequential_code = source_code iterative_code = "" return sequential_code, iterative_code # The process function def process_code(self, source_code): # Redirect the information to console start_console() # Reference Environment for the exec() function iterative_code, sequential_code = self.parse_code(source_code) # Whatever the code is, first step is to just stop! self.hal.motors.sendV(0) self.hal.motors.sendW(0) # print("The debug level is " + str(debug_level) # print(sequential_code) # print(iterative_code) # The Python exec function # Run the sequential part gui_module, hal_module = self.generate_modules() reference_environment = {"GUI": gui_module, "HAL": hal_module} exec(sequential_code, reference_environment) # Run the iterative part inside template # and keep the check for flag while self.reload == False: start_time = datetime.now() # Execute the iterative portion exec(iterative_code, reference_environment) # Template specifics to run! finish_time = datetime.now() dt = finish_time - start_time ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0 # Keep updating the iteration counter if (iterative_code == ""): self.iteration_counter = 0 else: self.iteration_counter = self.iteration_counter + 1 # The code should be run for atleast the target time step # If it's less put to sleep if (ms < self.time_cycle): time.sleep((self.time_cycle - ms) / 1000.0) close_console() print("Current Thread Joined!") # Function to generate the modules for use in ACE Editor def generate_modules(self): # Define HAL module hal_module = imp.new_module("HAL") hal_module.HAL = imp.new_module("HAL") hal_module.HAL.motors = imp.new_module("motors") # Add HAL functions hal_module.HAL.getPose3d = self.hal.pose3d.getPose3d hal_module.HAL.getLaserData = self.hal.laser.getLaserData hal_module.HAL.getImage = self.hal.getImage hal_module.HAL.motors.sendV = self.hal.motors.sendV hal_module.HAL.motors.sendW = self.hal.motors.sendW # Define GUI module gui_module = imp.new_module("GUI") gui_module.GUI = imp.new_module("GUI") # Add GUI functions gui_module.GUI.showImage = self.gui.showImage gui_module.GUI.map = self.gui.map # Adding modules to system # Protip: The names should be different from # other modules, otherwise some errors sys.modules["HAL"] = hal_module sys.modules["GUI"] = gui_module return gui_module, hal_module # Function to measure the frequency of iterations def measure_frequency(self): previous_time = datetime.now() # An infinite loop while self.reload == False: # Sleep for 2 seconds time.sleep(2) # Measure the current time and subtract from the previous time to get real time interval current_time = datetime.now() dt = current_time - previous_time ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0 previous_time = current_time # Get the time period try: # Division by zero self.ideal_cycle = ms / self.iteration_counter except: self.ideal_cycle = 0 # Reset the counter self.iteration_counter = 0 self.send_frequency_message() # Function to generate and send frequency messages def send_frequency_message(self): # This function generates and sends frequency measures of the brain and gui brain_frequency = 0 gui_frequency = 0 try: brain_frequency = round(1000 / self.ideal_cycle, 1) except ZeroDivisionError: brain_frequency = 0 try: gui_frequency = round(1000 / self.thread_gui.ideal_cycle, 1) except ZeroDivisionError: gui_frequency = 0 self.frequency_message["brain"] = brain_frequency self.frequency_message["gui"] = gui_frequency self.frequency_message["rtf"] = self.real_time_factor message = "#freq" + json.dumps(self.frequency_message) self.server.send_message(self.client, message) # Function to maintain thread execution def execute_thread(self, source_code): # Keep checking until the thread is alive # The thread will die when the coming iteration reads the flag if (self.thread != None): while self.thread.is_alive() or self.measure_thread.is_alive(): pass # Turn the flag down, the iteration has successfully stopped! self.reload = False # New thread execution self.measure_thread = threading.Thread(target=self.measure_frequency) self.thread = threading.Thread(target=self.process_code, args=[source_code]) self.thread.start() self.measure_thread.start() print("New Thread Started!") # Function to track the real time factor from Gazebo statistics # https://stackoverflow.com/a/17698359 # (For reference, Python3 solution specified in the same answer) def track_stats(self): args = ["gz", "stats", "-p"] # Prints gz statistics. "-p": Output comma-separated values containing- # real-time factor (percent), simtime (sec), realtime (sec), paused (T or F) stats_process = subprocess.Popen(args, stdout=subprocess.PIPE, bufsize=1) # bufsize=1 enables line-bufferred mode (the input buffer is flushed # automatically on newlines if you would write to process.stdin ) with stats_process.stdout: for line in iter(stats_process.stdout.readline, b''): stats_list = [x.strip() for x in line.split(',')] self.real_time_factor = stats_list[0] # Function to read and set frequency from incoming message def read_frequency_message(self, message): frequency_message = json.loads(message) # Set brain frequency frequency = float(frequency_message["brain"]) self.time_cycle = 1000.0 / frequency # Set gui frequency frequency = float(frequency_message["gui"]) self.thread_gui.time_cycle = 1000.0 / frequency return # The websocket function # Gets called when there is an incoming message from the client def handle(self, client, server, message): if (message[:5] == "#freq"): frequency_message = message[5:] self.read_frequency_message(frequency_message) time.sleep(1) self.send_frequency_message() return try: # Once received turn the reload flag up and send it to execute_thread function code = message # print(repr(code)) self.reload = True self.execute_thread(code) except: pass # Function that gets called when the server is connected def connected(self, client, server): self.client = client # Start the GUI update thread self.thread_gui = ThreadGUI(self.gui) self.thread_gui.start() # Start the real time factor tracker thread self.stats_thread = threading.Thread(target=self.track_stats) self.stats_thread.start() # Initialize the ping message self.send_frequency_message() print(client, 'connected') # Function that gets called when the connected closes def handle_close(self, client, server): print(client, 'closed') def run_server(self): self.server = WebsocketServer(port=1905, host=self.host) self.server.set_fn_new_client(self.connected) self.server.set_fn_client_left(self.handle_close) self.server.set_fn_message_received(self.handle) self.server.run_forever()
def __init__(self,PORT,HOST,LOGGING): server = WebsocketServer(PORT,HOST,LOGGING) server.set_fn_new_client(self.new_client) server.set_fn_client_left(self.client_left) server.set_fn_message_received(self.message_received) server.run_forever()
close_and_clean_up(client, ws_server) return ws_key_browser = info["ws_key_browser"] if ws_key_browser in msg_queue: msg_queue[ws_key_browser]['finish'] = True if msg_queue[ws_key_browser]['client'] is not None: send_msg_safe(ws_server, msg_queue[ws_key_browser]['client'], {'operation': 'finish'}) # ws_server.send_message(msg_queue[ws_key_browser]['client'], json.dumps({"operation": "finish"})) elif operation == 'close': close_and_clean_up(client, ws_server) else: debug_logging("invalid operation from %s: %s" % (client, operation)) print("invalid operation from %s: %s" % (client, operation)) close_and_clean_up(client, ws_server) except Exception as e: debug_logging("msg from %s parsing failed: %s" % (client, e)) print("msg from %s parsing failed: %s" % (client, e)) send_msg_safe(ws_server, client, {'operation': 'reconnect'}) # ws_server.send_message(client, json.dumps({'operation': 'reconnect'})) close_and_clean_up(client, ws_server) server = WebsocketServer(8080, host='127.0.0.1') server.set_fn_new_client(new_client) server.set_fn_message_received(handle_msg) server.set_fn_client_left(close_and_clean_up) server.run_forever()
json_data = json.dumps(clasificados) server.send_message_to_all(json_data) if obj['type'] == 'update': id = clasificados[-1]["id"] + 1 clasificados.append({ 'id':id, 'titulo':obj['titulo'], 'texto':obj['texto'] }) print("Clasificado agregado") for clasificado in clasificados: print(clasificado['id']) print("\t"+clasificado['titulo']) print("\t"+clasificado['texto']) json_data = json.dumps(clasificados) server.send_message_to_all(json_data) #Configuración del servidor de web sockets PORT=9001 server = WebsocketServer(PORT, host='127.0.0.1') server.set_fn_new_client(entrada_cliente) server.set_fn_client_left(salida_cliente) server.set_fn_message_received(mensajeria) server.run_forever()
class turnServer: clientMap = {} peerMap = {} server = None # 当新的客户端连接时会提示 def __init__(self): print("new turne server") def new_client(self, client, server): print("当新的客户端连接时会提示:%s" % client['id']) #self.server.send_message(client,"only for you") server.send_message_to_all("Hey all, a new client has joined us") #peerMap.put(peer.id,peer) self.clientMap[client['id']] = client print("ip:", client["address"]) #print("ip:",client["address"]["port"]) server.send_message(client, "only for you") # 当旧的客户端离开 def client_left(self, client, server): print("客户端%s断开" % client['id']) #del self.clientMap[client['id']] # 接收客户端的信息。 def message_received(self, client, server, message): print("Client(%d) said: %s" % (client['id'], message)) server.send_message_to_all(message + "+server") #这里要解析消息货到客户端信息 #JSONObject msg = new JSONObject(message); #print("收到消息:" + message); #int code = msg.optInt("code"); code = 0 return if (0 == code): #login #self.lgoin(client) print("login") elif (1 == code): #heartbeat #self.heartbeat(peerId) print("heartbeat") elif (2 == code): #requst for hole #self.sendForHole(peer) print("requst for hole") else: print("unknow message") def login(self, client): peer = Peer(client, "ip", 8989) self.peerMap.put(peer.id, peer) def send(self, clientId, msg): print("send message to client") self.server.send_message(self.clientMap[clientId], msg) ''' def sendForHole(peer): #1.发送信息给B,让B给A发信息; #2.B发送后,返回已经发送; return server.send_message(peer,"") def connect(peerA,peerB): return sendForHole(peerB) def heartbeat(peerId): peer=peerMap.get(peerId) peer.status=0; peer.lastTime= date() #1.收到clientA的请求 def requestConnetPeer(peerId): peerB= peerMap.get(peerId) if(null==peerB): return false; else: #发起连接A和B return connect(peerA,peerB) return true ''' def startWebsocket(self): print("turnServer startWebsocket") self.server = WebsocketServer(8131, "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) self.server.run_forever() print("turnServer startWebsocket end")
class Template: # Initialize class variables # self.time_cycle to run an execution for atleast 1 second # self.process for the current running process def __init__(self): self.thread = None self.reload = False # Time variables self.time_cycle = 80 self.ideal_cycle = 80 self.iteration_counter = 0 self.server = None self.client = None self.host = sys.argv[1] # Initialize the GUI, HAL and Console behind the scenes self.console = console.Console() self.gui = gui.GUI(self.host, self.console) self.hal = hal.HAL() # Function for saving def save_code(self, source_code): with open('code/academy.py', 'w') as code_file: code_file.write(source_code) # Function for loading def load_code(self): with open('code/academy.py', 'r') as code_file: source_code = code_file.read() return source_code # Function to parse the code # A few assumptions: # 1. The user always passes sequential and iterative codes # 2. Only a single infinite loop def parse_code(self, source_code): # Check for save/load if (source_code[:5] == "#save"): source_code = source_code[5:] self.save_code(source_code) return "", "", 1 elif (source_code[:5] == "#load"): source_code = source_code + self.load_code() self.server.send_message(self.client, source_code) return "", "", 1 elif (source_code[:5] == "#rest"): reset_simulation = rospy.ServiceProxy('/gazebo/reset_simulation', Empty) reset_simulation() return "", "", 1 else: # Get the frequency of operation, convert to time_cycle and strip try: partition = source_code[5:].partition("\n") frequency = partition[0] frequency = float(frequency) self.time_cycle = 1000.0 / frequency source_code = partition[2] # Get the debug level and strip the debug part debug_level = int(source_code[5]) source_code = source_code[5:] except: debug_level = 1 source_code = source_code[5] source_code = self.debug_parse(source_code, debug_level) sequential_code, iterative_code = self.seperate_seq_iter( source_code) return iterative_code, sequential_code, debug_level # Function to parse code according to the debugging level def debug_parse(self, source_code, debug_level): if (debug_level == 1): # If debug level is 0, then all the GUI operations should not be called source_code = re.sub(r'GUI\..*', '', source_code) return source_code # Function to seperate the iterative and sequential code def seperate_seq_iter(self, source_code): if source_code == "": return "", "" # Search for an instance of while True infinite_loop = re.search(r'[^ \t]while\(True\):|[^ \t]while True:', source_code) # Seperate the content inside while True and the other # (Seperating the sequential and iterative part!) try: start_index = infinite_loop.start() iterative_code = source_code[start_index:] sequential_code = source_code[:start_index] # Remove while True: syntax from the code # And remove the the 4 spaces indentation before each command iterative_code = re.sub(r'[^ ]while\(True\):|[^ ]while True:', '', iterative_code) iterative_code = re.sub(r'^[ ]{4}', '', iterative_code, flags=re.M) except: sequential_code = source_code iterative_code = "" return sequential_code, iterative_code # The process function def process_code(self, source_code): # Reference Environment for the exec() function reference_environment = { 'GUI': self.gui, 'HAL': self.hal, 'console': self.console, 'print': print_function } iterative_code, sequential_code, debug_level = self.parse_code( source_code) # print("The debug level is " + str(debug_level) # print(sequential_code) # print(iterative_code) # Whatever the code is, first step is to just stop! self.hal.motors.sendV(0) try: # The Python exec function # Run the sequential part exec(sequential_code, { "gui": gui, "hal": hal, "time": time }, reference_environment) # Run the iterative part inside template # and keep the check for flag while self.reload == False: self.server.send_message(self.client, "#pingRunning") start_time = datetime.now() # A few changes in the reference environment, to # allow usage of the initialized API reference_environment["GUI"] = self.gui reference_environment["HAL"] = self.hal # Execute the iterative portion exec(iterative_code, reference_environment) # Template specifics to run! finish_time = datetime.now() dt = finish_time - start_time ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0 # Keep updating the iteration counter if (iterative_code == ""): self.iteration_counter = 0 else: self.iteration_counter = self.iteration_counter + 1 # The code should be run for atleast the target time step # If it's less put to sleep # If it's more no problem as such, but we can change it! if (ms < self.time_cycle): time.sleep((self.time_cycle - ms) / 1000.0) print("Current Thread Joined!") # To print the errors that the user submitted through the Javascript editor (ACE) except Exception: exc_type, exc_value, exc_traceback = sys.exc_info() self.console.print(exc_value) # Function to measure the frequency of iterations def measure_frequency(self): previous_time = datetime.now() # An infinite loop while self.reload == False: # Sleep for 2 seconds time.sleep(2) # Measure the current time and subtract from the previous time to get real time interval current_time = datetime.now() dt = current_time - previous_time ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0 previous_time = current_time # Get the time period try: # Division by zero self.ideal_cycle = ms / self.iteration_counter except: self.ideal_cycle = 0 # Reset the counter self.iteration_counter = 0 # Send to client try: self.server.send_message( self.client, "#freq" + str(round(1000 / self.ideal_cycle, 2))) except ZeroDivisionError: self.server.send_message(self.client, "#freq" + str(0)) # Function to maintain thread execution def execute_thread(self, source_code): # Keep checking until the thread is alive # The thread will die when the coming iteration reads the flag if (self.thread != None): while self.thread.is_alive() or self.measure_thread.is_alive(): pass # Turn the flag down, the iteration has successfully stopped! self.reload = False # New thread execution self.measure_thread = threading.Thread(target=self.measure_frequency) self.thread = threading.Thread(target=self.process_code, args=[source_code]) self.thread.start() self.measure_thread.start() print("New Thread Started!") # The websocket function # Gets called when there is an incoming message from the client def handle(self, client, server, message): if (message == "#pong"): return try: # Once received turn the reload flag up and send it to execute_thread function code = message # print(repr(code)) self.reload = True self.execute_thread(code) except: pass # Function that gets called when the server is connected def connected(self, client, server): self.client = client # Start the GUI update thread t = gui.ThreadGUI(self.gui) t.daemon = True t.start() print(client, 'connected') # Function that gets called when the connected closes def handle_close(self, client, server): print(client, 'closed') def run_server(self): self.server = WebsocketServer(port=1905, host=self.host) self.server.set_fn_new_client(self.connected) self.server.set_fn_client_left(self.handle_close) self.server.set_fn_message_received(self.handle) self.server.run_forever()
# Receive data from client and put it in the input queue def communicateWithClient(client, server, msg): print('recv: ' + msg) carConnectionSem.acquire() if (carIsConnected and msg in validInput): inputSem.acquire() inputQueue.append(msg) inputSem.release() carConnectionSem.release() # Websocket to talk to client websocket = WebsocketServer(clientPort) websocket.set_fn_new_client(onClientConnection) websocket.set_fn_client_left(onClientDisconnection) websocket.set_fn_message_received(communicateWithClient) # Handle car communications def communicateWithCar(): while(runServer): # Wait for car to connect c, addr = carSock.accept() isConnected = True global carIsConnected carConnectionSem.acquire() carIsConnected = True carConnectionSem.release() print('Car connected')
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): """ 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 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" and message.sender_id.lower() == 'main'): 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 client2 is None: print('connected client #2') client2 = client def handleClose(client): global client1, client2 print('closed') if client1 is client: client1 = None if client2 is client: client2 = None def new_client(client, server): handleConnected(client) def on_msg(client, server, msg): handleMessage(client, server, msg) def on_client_left(client, server): handleClose(client) server = WebsocketServer(8000, host='127.0.0.1', loglevel=logging.INFO) server.set_fn_new_client(new_client) server.set_fn_message_received(on_msg) server.set_fn_client_left(on_client_left) server.run_forever()
class GUI: # Initialization function # The actual initialization def __init__(self, host, hal): t = threading.Thread(target=self.run_server) self.payload = {'map': ''} self.server = None self.client = None self.host = host self.acknowledge = False self.acknowledge_lock = threading.Lock() self.hal = hal t.start() # Create the lap object pose3d_object = ListenerPose3d("/roombaROS/odom") self.map = Map(pose3d_object) # Explicit initialization function # Class method, so user can call it without instantiation @classmethod def initGUI(cls, host, console): # self.payload = {'image': '', 'shape': []} new_instance = cls(host, console) return new_instance # Function to get the client # Called when a new client is received def get_client(self, client, server): self.client = client # Function to get value of Acknowledge def get_acknowledge(self): self.acknowledge_lock.acquire() acknowledge = self.acknowledge self.acknowledge_lock.release() return acknowledge # Function to get value of Acknowledge def set_acknowledge(self, value): self.acknowledge_lock.acquire() self.acknowledge = value self.acknowledge_lock.release() # Update the gui def update_gui(self): # Payload Map Message pos_message = self.map.getRobotCoordinates() ang_message = self.map.getRobotAngle() pos_message = str(pos_message + ang_message) self.payload["map"] = pos_message message = "#gui" + json.dumps(self.payload) self.server.send_message(self.client, message) # Function to read the message from websocket # Gets called when there is an incoming message from the client def get_message(self, client, server, message): # Acknowledge Message for GUI Thread if(message[:4] == "#ack"): self.set_acknowledge(True) # Activate the server def run_server(self): self.server = WebsocketServer(port=2303, host=self.host) self.server.set_fn_new_client(self.get_client) self.server.set_fn_message_received(self.get_message) self.server.run_forever() # Function to reset def reset_gui(self): self.map.reset()
def doLogin(message, server): global unModel # obj = ast.literal_eval(message) //pour compatibilité avec Android # print message //aucune idée pourquoi mais il faut mettre cela pour que ça fonctionne avec Android!!? obj = json.loads(message) objLogin = obj["object"] unModel.nom = objLogin["name"] unModel.prenom = objLogin["firstname"] #Ack client dict={} dict["messageType"]="ackLogin" objJson = json.dumps(dict) server.send_message(wsIHM, objJson) if __name__ == "__main__": # Fixation du point de lecture de fichier os.chdir('/')#Obligation de donner le chemin du fichier avec le QPython # routage des messages receptionnes switch={ "login":doLogin } # Initialisation des models unModel = UnModel() # Connexion au client web server = WebsocketServer(9999) server.set_fn_new_client(new_client) #définition de la fonction pour l arrivé d un nouveau client server.set_fn_message_received(rxMessage) #Définition de la fonction pour l arrivé d un nouveau message server.set_fn_client_left(clientLeft) #définition de la fonction pour la déconnexion d'un client server.run_forever()
class GUI: # Initialization function # The actual initialization def __init__(self, host, hal): t = threading.Thread(target=self.run_server) self.payload = {'image': '', 'map': '', 'array': ''} self.server = None self.client = None self.host = host self.image_to_be_shown = None self.image_to_be_shown_updated = False self.image_show_lock = threading.Lock() self.array_lock = threading.Lock() self.array = None self.acknowledge = False self.acknowledge_lock = threading.Lock() self.mapXY = None self.worldXY = None # Take the console object to set the same websocket and client self.hal = hal t.start() # Create the lap object self.pose3d_object = ListenerPose3d("/taxi_holo/odom") self.map = Map(self.pose3d_object) # Function to get the client # Called when a new client is received def get_client(self, client, server): self.client = client # Function to get value of Acknowledge def get_acknowledge(self): self.acknowledge_lock.acquire() acknowledge = self.acknowledge self.acknowledge_lock.release() return acknowledge # Function to get value of Acknowledge def set_acknowledge(self, value): self.acknowledge_lock.acquire() self.acknowledge = value self.acknowledge_lock.release() # encode the image data to be sent to websocket def payloadImage(self): self.image_show_lock.acquire() image_to_be_shown_updated = self.image_to_be_shown_updated image_to_be_shown = self.image_to_be_shown self.image_show_lock.release() image = image_to_be_shown payload = {'image': '', 'shape': ''} if (image_to_be_shown_updated == False): return payload shape = image.shape frame = cv2.imencode('.PNG', image)[1] encoded_image = base64.b64encode(frame) payload['image'] = encoded_image.decode('utf-8') payload['shape'] = shape self.image_show_lock.acquire() self.image_to_be_shown_updated = False self.image_show_lock.release() return payload # load the image data def showGPP(self, image): self.image_show_lock.acquire() self.image_to_be_shown = image self.image_to_be_shown_updated = True self.image_show_lock.release() # Process the array(ideal path) to be sent to websocket def showPath(self, array): self.array_lock.acquire() arr_shape = array.shape three_dim = array.reshape(1, arr_shape[0], arr_shape[1]) strArray = np.array_str(three_dim) # Remove unnecesary spaces in the array to avoid JSON syntax error in javascript strArray = re.sub(r"\[[ ]+", "[", strArray) strArray = re.sub(r"[ ]+", ", ", strArray) strArray = re.sub(r",[ ]+]", "]", strArray) self.array = strArray self.array_lock.release() # Update the gui def update_gui(self): # Payload Image Message payload = self.payloadImage() self.payload["image"] = json.dumps(payload) self.payload["array"] = self.array # Payload Map Message pos_message1 = self.map.getTaxiCoordinates() # print(self.pose3d_object.getPose3d()) ang_message = self.map.getTaxiAngle() pos_message = str(pos_message1 + ang_message) # print("pos2 : {} , ang : {}".format(pos_message,ang_message)) self.payload["map"] = pos_message message = "#gui" + json.dumps(self.payload) self.server.send_message(self.client, message) return list(pos_message1) # Function to read the message from websocket # Gets called when there is an incoming message from the client def get_message(self, client, server, message): # Acknowledge Message for GUI Thread if (message[:4] == "#ack"): self.set_acknowledge(True) # Check for mouse click data on the map elif (message[:5] == "#pick"): data = eval(message[5:]) self.mapXY = data["data"] x, y = self.mapXY worldx, worldy = self.map.gridToWorld(x, y) self.worldXY = [worldx, worldy] print("World : {}".format(self.worldXY)) # Activate the server def run_server(self): self.server = WebsocketServer(port=2303, host=self.host) self.server.set_fn_new_client(self.get_client) self.server.set_fn_message_received(self.get_message) self.server.run_forever() # Function to reset def reset_gui(self): self.map.reset()
query_string = """ SELECT value FROM "error_rate" WHERE "session_id" = '{session_id}' AND time >= now() - 10s AND time <= now() """.format(session_id=session_id) result = influx_client.query(query_string) if result: print("Sending messages...") else: print("No message found!") c = 1 if "counter" in client: c = int(client["counter"]) for items in result: for item in items: server.send_message_to_all("Batch Number => " + str(c)) server.send_message_to_all("Error Rate => " + str(item['value'])) c+=1 sleep(0.045) else: server.send_message_to_all("Session expired..!") def receive_messages(client,server, message): client['counter'] = message send_messages(client, server) server = WebsocketServer(8080, host='0.0.0.0') server.set_fn_new_client(send_messages) server.set_fn_message_received(receive_messages) server.run_forever()
if mesaj == "pkliste": #os.system("mps paketler --json") subprocess.call(['mps', 'paketler', '--json']) dosya_iletim("paket_liste", "/tmp/mps_paketler_listesi") if mesaj == "pkgrupliste": mps.gruplar() mps.kos() dosya_iletim("paket_grup_liste", "/tmp/mps_paket_grup_listesi") if "grup_paketler=" in mesaj: grup = mesaj.split("=")[1] grup = tr_cevir(grup) mps.grup_paketler(grup) mps.kos() dosya_iletim("grup_paketler_liste", "/tmp/mps_grup_paketler_listesi") if mesaj == "sistem": komut = "./sistem_bilgi.sh" #genel_iletim(genel_kanal,komut) #os.system('curl --request POST -H "Accept: text/json" http://127.0.0.1:36060 --data `./sistem_bilgi.sh`') sunucu.send_message(istemci, "sistem bilgisi gönderildi") if mesaj == "pingo": os.system("killall borulama") PORT = 36060 sunucu = WebsocketServer(PORT) sunucu.set_fn_new_client(yeni_istemci) sunucu.set_fn_client_left(istemci_cikis) sunucu.set_fn_message_received(gelen_mesaj) print("%s portunda mps websocket aracı sunucusu çalışıyor" % PORT) sunucu.run_forever()
class websocketserver: cameras = {} tags = {} users = {} calibration = {} port=8001 # Called for every client connecting (after handshake) def new_client_connection(self, client, server): print("New client connected and was given id %d" % client['id'] +" and address " + str(client['address'])) server.send_message(client, "Client connected succesfully") # Called for every client disconnecting def client_left(self, client, server): print("Client(%d) disconnected" % client['id']) #TODO : Remove from list # Called when a client sends a message def message_received(self, client, server, message): # print("Client(%d) said: %s" % (client['id'], message)) self.parseMessage(client, message) def __init__(self, host='127.0.0.1'): self.server = WebsocketServer(self.port, host) self.server.set_fn_new_client(self.new_client_connection) self.server.set_fn_client_left(self.client_left) self.server.set_fn_message_received(self.message_received) self.server.run_forever() def parseMessage(self, client, message): """ Check who is the message from to redirect it to User / Tag / Camera / Calibration or create a new instance of User / Tag / Camera / Calibration :param client: :param message: :return: """ if self.cameras.has_key(str(client['address'])): #print "Message from Camera" self.cameras[str(client['address'])].push(message) elif self.users.has_key(str(client['address'])): print "Message from User" elif self.tags.has_key(str(client['address'])): print "Message from Tag" elif self.calibration.has_key(str(client['address'])): self.calibration[str(client['address'])].push(message) print "Message from Calibration" # This message is coming from an unknown client else: if message.split("-")[0] == "camera": self.cameras[str(client['address'])] = Camera(client, message.split("-")[1]) # Add Observers linking every user to every camera's update for key in self.users: if isinstance(self.users[key], User): self.cameras[str(client['address'])].new2DPointNotifier.addObserver(self.users[key].position.newPoint2DObserver) self.cameras[str(client['address'])].point2DdeletedNotifier.addObserver(self.users[key].position.point2DDeletedObserver) elif message.split("-")[0] == "tag": print "Hello TAG" # TODO elif message.split("-")[0] == "user": user = User(client, self.server, message.split("-")[1]) self.users[str(client['address'])] = user # Add Observers linking every user to every camera's update for key in self.cameras: if isinstance(self.cameras[key], Camera): self.cameras[key].new2DPointNotifier.addObserver(user.position.newPoint2DObserver) self.cameras[key].point2DdeletedNotifier.addObserver(user.position.point2DDeletedObserver) elif message == "calibration": self.calibration[str(client['address'])] = Calibration(self.cameras, self.server, client)
sys.exit(0) #================================================ # # MAIN / INIT # #------------------------------------------------ signal.signal(signal.SIGINT, signal_handler) print('Press Ctrl+C to exit') server = WebsocketServer(12000, host="0.0.0.0") server.set_fn_message_received(serv_recvParser) serv_thread = Thread(target=server.run_forever, args=()) serv_thread.start() strip = Adafruit_NeoPixel(300, 12, strip_type = ws.WS2811_STRIP_GRB) strip.begin() strip_order = range(strip.numPixels()) shuffle(strip_order) while True: looptime = time() for idx in range(len(patterns)): if patterns[idx][1].state > 0: patterns[idx][1].step(strip) if patterns[idx][0] >= 0: if patterns[idx][0] == 1: # turn on
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))
from bootstrap_scrapers import bootstrap_scrapers from provider_runner import run_movie_providers from websocket_server import WebsocketServer import json providers = bootstrap_scrapers() def get_movie(client, server, req): tmdb_id = int(req) existing_movies = [] def send_movies(movie_urls): new_urls = filter(lambda url: url not in existing_movies, movie_urls) existing_movies.extend(new_urls) if len(movie_urls): res = json.dumps({"type": "data", "data": movie_urls}) server.send_message(client, res) def send_done(): res = json.dumps({"type": "done"}) server.send_message(client, res) run_movie_providers(providers, tmdb_id, send_movies, send_done) server = WebsocketServer(9996, host='0.0.0.0') server.set_fn_message_received(get_movie) server.run_forever()
#!/usr/bin/env python from websocket_server import WebsocketServer import hashlib import os def nuevo_cliente(client, server): print("Cliente (%s) nuevo" % client['address'][0]) def mensaje_recibido(client, server, mensaje): audio = hashlib.md5(client['address'][0]).hexdigest() file = open("podcast/"+audio, "ab") file.write(mensaje) file.close() def desconectado(client, server): audio = hashlib.md5(client['address'][0]).hexdigest() os.remove("podcast/"+audio) print("Cliente (%s) desconectado" % client['address'][0]) PORT=9000 server = WebsocketServer(PORT,"192.168.1.2") server.set_fn_new_client(nuevo_cliente) server.set_fn_client_left(desconectado) server.set_fn_message_received(mensaje_recibido) server.run_forever()
class ConnectionManager: def __init__(self, host, my_port, callback, sc_self=None, cb=None, cb2=None): print('Initializing ConnectionManager...') ##### self.cb = cb # self.cb2 = cb2 self.host = host self.port = my_port self.my_c_host = None self.my_c_port = None self.core_node_set = CoreNodeList() self.edge_node_set = EdgeNodeList() self.last_ping = {} ## self.__add_peer((host, my_port)) self.mm = MessageManager() self.callback = callback self.my_host = self.__get_myip() ## self.ws = WebsocketServer(port=my_port, host=self.my_host) ## self.sc_self = sc_self ## self.flag = 0 ## # 待受を開始する際に呼び出される(ServerCore向け def start(self): # t = threading.Thread(target=self.__wait_for_access) # t.start() self.ping_timer_p = threading.Timer(PING_INTERVAL, self.__check_peers_connection) self.ping_timer_p.start() self.ping_timer_e = threading.Timer(PING_INTERVAL, self.__check_edges_connection) self.ping_timer_e.start() self.ws.set_fn_new_client(self.__new_client) ## self.ws.set_fn_message_received(self.__ws_handle) ## t = threading.Thread(target=self.ws.run_forever) t.start() def __ws_handle(self, client, server, message): ## self.__handle_message((client, client['address'], message), server) return def __new_client(self, client, server): ## print("%s is connected" % (client)) # ユーザが指定した既知のCoreノードへの接続(ServerCore向け def join_network(self, host, port): self.my_c_host = host self.my_c_port = port self.__connect_to_P2PNW(host, port) def get_message_text(self, msg_type, payload=None): """ 指定したメッセージ種別のプロトコルメッセージを作成して返却する params: msg_type : 作成したいメッセージの種別をMessageManagerの規定に従い指定 payload : メッセージにデータを格納したい場合に指定する return: msgtxt : MessageManagerのbuild_messageによって生成されたJSON形式のメッセージ """ msgtxt = self.mm.build(msg_type, self.port, payload) print('generated_msg:', msgtxt + str("省略中")) return msgtxt # 指定されたノードに対してメッセージを送信する def send_msg(self, peer, msg): try: ws4edge = create_connection("ws://" + str(peer[0]) + ":" + str(peer[1])) ws4edge.send(msg.encode()) ws4edge.close() except OSError: print('Connection failed for peer : ', peer) self.__remove_peer(peer) # Coreノードリストに登録されている全てのノードに対して同じメッセージをブロードキャストする def send_msg_to_all_peer(self, msg): print('send_msg_to_all_peer was called!') current_list = self.core_node_set.get_list() for peer in current_list: if peer != (self.host, self.port): print("message will be sent to ... ", peer) self.send_msg(peer, msg) # Edgeノードリストに登録されている全てのノードに対して同じメッセージをブロードキャストする def send_msg_to_all_edge(self, msg): print('send_msg_to_all_edge was called! ') current_list = self.edge_node_set.get_list() for edge in current_list: print("message will be sent to ... ", edge) self.send_msg(edge, msg) # 終了前の処理としてソケットを閉じる def connection_close(self): pass s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((self.host, self.port)) self.socket.close() s.close() self.ping_timer_p.cancel() self.ping_timer_e.cancel() #離脱要求の送信 if self.my_c_host is not None: msg = self.mm.build(MSG_REMOVE, self.port) self.send_msg((self.my_c_host, self.my_c_port), msg) def __connect_to_P2PNW(self, host, port): msg = self.mm.build(MSG_ADD, self.port) self.send_msg((host, port), msg) def __wait_for_access(self): self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket.bind((self.host, self.port)) self.socket.listen(0) executor = ThreadPoolExecutor(max_workers=10) while True: print('Waiting for the connection ...') soc, addr = self.socket.accept() print('Connected by .. ', addr) data_sum = '' params = (soc, addr, data_sum) executor.submit(self.__handle_message, params) def __is_in_core_set(self, peer): """ 与えられたnodeがCoreノードのリストに含まれているか?をチェックする param: peer : IPアドレスとポート番号のタプル return: True or False """ return self.core_node_set.has_this_peer(peer) def __is_in_edge_set(self, peer): return self.edge_node_set.has_this_edge(peer) # 受信したメッセージを確認して、内容に応じた処理を行う。クラスの外からは利用しない想定 def __handle_message(self, params, server): # soc, addr, data_sum = params #Parse result, reason, cmd, peer_port, payload = self.mm.parse(data_sum) print("result, reason, cmd, peer_port, payload") status = (result, reason) if status == ('error', ERR_PROTOCOL_UNMATCH): print('Error: Protocol name is not matched') return elif status == ('error', ERR_VERSION_UNMATCH): print('Error: Protocol version is not matched') return elif status == ('ok', OK_WITHOUT_PAYLOAD): if cmd == MSG_ADD: print('ADD node request was received!!') self.__add_peer((addr[0], peer_port)) if (addr[0], peer_port) == (self.host, self.port): return else: cl = pickle.dumps(self.core_node_set.get_list(), 0).decode() msg = self.mm.build(MSG_CORE_LIST, self.port, cl) self.send_msg_to_all_peer(msg) self.send_msg_to_all_edge(msg) elif cmd == MSG_REMOVE: print('REMOVE request was received!! from', addr[0], peer_port) self.__remove_peer((addr[0], peer_port)) cl = pickle.dumps(self.core_node_set.get_list(), 0).decode() msg = self.mm.build(MSG_CORE_LIST, self.port, cl) self.send_msg_to_all_peer(msg) self.send_msg_to_all_edge(msg) ##----PING elif cmd == MSG_PING: ## # 特にやること思いつかない peer = (addr[0], peer_port) if (self.__is_in_edge_set(peer)): self.edge_node_set.ping_recv(peer) print('----------------PING receive!!------------') #print('List for Core nodes was requested!!') cl = pickle.dumps(self.core_node_set.get_list(), 0).decode() msg = self.mm.build(MSG_CORE_LIST, self.port, cl) server.send_message(soc, msg.encode('utf-8')) print("core node list sent") return elif cmd == MSG_REQUEST_CORE_LIST: print('List for Core nodes was requested!!') cl = pickle.dumps(self.core_node_set.get_list(), 0).decode() msg = self.mm.build(MSG_CORE_LIST, self.port, cl) self.send_msg((addr[0], peer_port), msg) elif cmd == MSG_ADD_AS_EDGE: edge = (addr[0], peer_port) self.__add_edge_node(edge) cl = pickle.dumps(self.core_node_set.get_list(), 0).decode() msg = self.mm.build(MSG_CORE_LIST, self.port, cl) self.send_msg((addr[0], peer_port), msg) self.last_ping[edge] = time.time() elif cmd == MSG_REMOVE_EDGE: print('REMOVE_EDGE request was received!! from', addr[0], peer_port) self.__remove_edge_node((addr[0], peer_port)) elif cmd == Sync_DB3: print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■ Sync_DB3 handle ■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) cl = str(get_level_dir.get_late_dir_num(zip_p=ZIP_P)) msg = self.mm.build(Sync_DB4, self.port, cl) self.send_msg((addr[0], peer_port), msg) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) elif cmd == Sync_DB4: print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■ Sync_DB4 handle ■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) new_node_dir = int( get_level_dir.get_late_dir_num(zip_p=RE_ZIP_P)) latest_dir = int(json.loads(data_sum)["payload"]) if new_node_dir < latest_dir: cl = new_node_dir + 1 self.flag = 0 msg = self.mm.build(Sync_DB5, self.port, cl) self.send_msg((addr[0], peer_port), msg) else: if self.flag == 0: get_level_dir.unfold_zip_dir(ldb_p=RE_LDB_P, zip_p=RE_ZIP_P) level_param.update_key( RE_PARAM_P, level_param.latest_block_num(RE_LDB_P)) latest_db_bc = check_level_all.valid_all(RE_LDB_P) else: latest_db_bc = check_level_all.valid_all(RE_LDB_P) if latest_db_bc: print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print("DB Valid Check OK !!!!") print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) if self.flag == 0: print("■■■■■■■■ Start Sync ■■■■■■■■■") self.sc_self.get_all_chains_for_resolve_conflict() self.flag = 1 if "genesis_block" in self.sc_self.bm.chain[0]: msg = self.mm.build(Sync_DB5, self.port, str(latest_dir)) self.send_msg((addr[0], peer_port), msg) elif not check_level_all.is_valid_chain( [latest_db_bc[0], self.sc_self.bm.chain[0]]): msg = self.mm.build(Sync_DB5, self.port, str(latest_dir)) self.send_msg((addr[0], peer_port), msg) else: if check_level_all.is_valid_chain([ latest_db_bc[0], self.sc_self.bm.chain[0] ]): print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print("DB2Memory Valid Check OK !!!!") print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) msg = self.mm.build(Sync_DB7, self.port) self.send_msg((addr[0], peer_port), msg) else: print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■ WARNING ■■■■■■■■■ WARNING ■■■■■■■■ WARNING ■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) elif cmd == Sync_DB5: print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■ Sync_DB5 handle ■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) receive_dir_num = str(json.loads(data_sum)["payload"]) re_dir = receive_dir_num.zfill(6) p = ZIP_P + "block{}.zip".format(re_dir) with open(p, mode="rb") as z: z_file = z.read() cl = z_file.hex() msg = self.mm.build(Sync_DB6, self.port, cl) self.send_msg((addr[0], peer_port), msg) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) elif cmd == Sync_DB6: print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■ Sync_DB6 handle ■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) payload = json.loads(data_sum)["payload"] latest_dir = int( get_level_dir.get_late_dir_num(zip_p=RE_ZIP_P)) + 1 p = RE_ZIP_P + "block{}.zip".format(str(latest_dir).zfill(6)) with open(p, mode="wb") as rz: rz.write(binascii.unhexlify(payload)) msg = self.mm.build(Sync_DB3, self.port) self.send_msg((addr[0], peer_port), msg) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) elif cmd == Sync_DB7: print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■ Sync_DB7 handle ■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) print( "■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■" ) else: is_core = self.__is_in_core_set((addr[0], peer_port)) self.callback((result, reason, cmd, peer_port, payload), is_core, (addr[0], peer_port)) return elif status == ('ok', OK_WITH_PAYLOAD): if cmd == MSG_CORE_LIST: # TODO: 受信したリストをただ上書きしてしまうのは本来セキュリティ的には宜しくない。 # 信頼できるノードの鍵とかをセットしとく必要があるかも # このあたりの議論については6章にて補足予定 print('Refresh the core node list...') new_core_set = pickle.loads(payload.encode('utf8')) print('latest core node list: ', new_core_set) self.core_node_set.overwrite(new_core_set) else: is_core = self.__is_in_core_set((addr[0], peer_port)) self.callback((result, reason, cmd, peer_port, payload), is_core, None) return else: print('Unexpected status', status) def __add_peer(self, peer): """ Coreノードをリストに追加する。クラスの外からは利用しない想定 param: peer : Coreノードとして格納されるノードの接続情報(IPアドレスとポート番号) """ self.core_node_set.add((peer)) try: self.cb(self.core_node_set.get_list()) except: pass def __add_edge_node(self, edge): """ Edgeノードをリストに追加する。クラスの外からは利用しない想定 param: edge : Edgeノードとして格納されるノードの接続情報(IPアドレスとポート番号) """ self.edge_node_set.add((edge)) try: self.cb2(self.edge_node_set.get_list()) except: pass def __remove_peer(self, peer): """ 離脱したと判断されるCoreノードをリストから削除する。クラスの外からは利用しない想定 param: peer : 削除するノードの接続先情報(IPアドレスとポート番号) """ self.core_node_set.remove(peer) def __remove_edge_node(self, edge): """ 離脱したと判断されるEdgeノードをリストから削除する。クラスの外からは利用しない想定 param: edge : 削除するノードの接続先情報(IPアドレスとポート番号) """ self.edge_node_set.remove(edge) try: self.cb2(self.edge_node_set.get_list()) except: pass def __check_peers_connection(self): """ 接続されているCoreノード全ての生存確認を行う。クラスの外からは利用しない想定 この確認処理は定期的に実行される """ print('check_peers_connection was called') current_core_list = self.core_node_set.get_list() changed = False dead_c_node_set = list( filter(lambda p: not self.__is_alive(p), current_core_list)) if dead_c_node_set: changed = True print('Removing peer', dead_c_node_set) current_core_list = current_core_list - set(dead_c_node_set) current_core_list = self.core_node_set.get_list() print('current core node list:', current_core_list) # 変更があった時だけブロードキャストで通知する if changed: cl = pickle.dumps(current_core_list, 0).decode() msg = self.mm.build(MSG_CORE_LIST, self.port, cl) self.send_msg_to_all_peer(msg) self.send_msg_to_all_edge(msg) self.ping_timer_p = threading.Timer(PING_INTERVAL, self.__check_peers_connection) self.ping_timer_p.start() def __check_edges_connection(self): """ 接続されているEdgeノード全ての生存確認を行う。クラスの外からは利用しない想定 この確認処理は定期的に実行される """ print('check_edges_connection was called') current_edge_list = self.edge_node_set.get_list() for edge in current_edge_list: if (time.time() - self.edge_node_set.last_ping(edge) > TIME_OUT): ## self.__remove_edge_node(edge) print("--------edge node " + str(edge) + "Time Out-------------") ## current_edge_list = self.edge_node_set.get_list() print('current edge node list:', current_edge_list) self.ping_timer_e = threading.Timer(PING_INTERVAL, self.__check_edges_connection) self.ping_timer_e.start() try: self.cb2(self.edge_node_set.get_list()) except: pass def __is_alive(self, target): """ 有効ノード確認メッセージの送信 param: target : 有効ノード確認メッセージの送り先となるノードの接続情報(IPアドレスとポート番号) """ try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((target)) msg_type = MSG_PING msg = self.mm.build(msg_type) s.sendall(msg.encode('utf-8')) s.close() return True except OSError: return False def __get_myip(self): ## s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(('8.8.8.8', 80)) return s.getsockname()[0]
def webServer(): usersfd = open("users.json", "r") users = json.load(usersfd) usersfd.close() def new_client(client, server): print("New client connected and was given id %d" % client['id']) def client_left(client, server): print("Client(%d) disconnected" % client['id']) def message_received(client, server, message): #print("received message from client id %d " % client['id']) #logging.info("received message from client id %d " % client['id']) msg = json.loads(message) if msg["action"] == AUTHENTICATE: print 'msg is AUTHENTICATE' resp = {"action": AUTHENTICATE, "data": None} username = msg["data"].get("username") if msg["data"].has_key("username") else None password = msg["data"].get("password") if msg["data"].has_key("password") else None if username and password and users.has_key(username) and password == users[username]: print "AUTHSUCCESS" resp["data"] = AUTHSUCCESS else: print "AUTHFAIL" resp["data"] = AUTHFAIL server.send_message(client, json.dumps(resp) ) elif msg["action"] == GETBANNEDIPs: #print 'msg is GETBANNEDIPs' #logging.info('msg is GETBANNEDIPs') resp = {"action": GETBANNEDIPs, "data": []} username = msg["data"].get("username") if msg["data"].has_key("username") else None password = msg["data"].get("password") if msg["data"].has_key("password") else None if username and password and users.has_key(username) and password == users[username]: for bannedIP in bannedIPs.values(): ip = {} ip["IP"] = bannedIP.IP ip["time"] = time.strftime("%b %d %H:%M:%S", time.localtime(bannedIP.time)) ip["timer"] = bannedIP.timer - (time.time() - bannedIP.time) ip["service"] = bannedIP.service resp["data"].append(ip) server.send_message(client, json.dumps(resp)) else: print "AUTHFAIL" resp["data"] = AUTHFAIL server.send_message(client, json.dumps(resp)) elif msg["action"] == GETFAILEDATTEMPTs: print 'msg is GETFAILEDATTEMPTs' resp = {"action": GETFAILEDATTEMPTs, "data": []} username = msg["data"].get("username") if msg["data"].has_key("username") else None password = msg["data"].get("password") if msg["data"].has_key("password") else None if username and password and users.has_key(username) and password == users[username]: for failedAttempt in failedAttempts: print "in FA" print "FA=" + str(failedAttempt) ip = {} ip["IP"] = failedAttempt[0] ip["attempts"] = [] ip["service"] = failedAttempt[1] for attempt in failedAttempts[failedAttempt]: ip["attempts"].append(time.strftime("%b %d %H:%M:%S", time.localtime(attempt.time))) resp["data"].append(ip) server.send_message(client, json.dumps(resp)) else: print "AUTHFAIL" resp["data"] = AUTHFAIL server.send_message(client, json.dumps(resp)) elif msg["action"] == UNBANIPs: print 'msg is UNBANIPs' resp = {"action": UNBANIPs, "data": {}} username = msg["data"].get("username") if msg["data"].has_key("username") else None password = msg["data"].get("password") if msg["data"].has_key("password") else None if username and password and users.has_key(username) and password == users[username]: unbanIP(msg["data"]["IP"], msg["data"]["service"]) resp["data"]["IP"] = msg["data"]["IP"] resp["data"]["service"] = msg["data"]["service"] server.send_message(client, json.dumps(resp)) else: print "AUTHFAIL" resp["data"] = AUTHFAIL server.send_message(client, json.dumps(resp)) elif msg["action"] == CHANGECONFIG: print 'msg is CHANGECONFIG' #changeconfig(bantimer,nofailedattempts,failinterval) data = msg["data"] for service in services.values(): if service.name.lower() == data.get("service").lower(): changeConfig(data.get("bantimer"), data.get("threshold"), data.get("interval"), service) #server.send_message(client, json.dumps(resp)) global server PORT=9001 server = WebsocketServer(PORT, host='0.0.0.0') server.set_fn_new_client(new_client) server.set_fn_client_left(client_left) server.set_fn_message_received(message_received) server.run_forever()
class websocketserver: cameras = {} tags = {} users = {} calibration = {} port=8001 # Called for every client connecting (after handshake) def new_client_connection(self, client, server): print("New client connected and was given id %d" % client['id'] +" and address " + str(client['address'])) server.send_message(client, "Client connected succesfully") # Called for every client disconnecting def client_left(self, client, server): print("Client(%d) disconnected" % client['id']) # Remove client from its list # TODO better delete (remove points etc...) if(str(client['address']) in self.cameras): print "Camera disconnected : " + str(client['address']) del self.cameras[str(client['address'])] elif(str(client['address']) in self.users): # Remove Tag assignement because User left print "User disconnected : " + str(client['address']) self.users[str(client['address'])].removeTag() del self.users[str(client['address'])] elif(str(client['address']) in self.calibration): print "Calibration disconnected : " + str(client['address']) del self.calibration[str(client['address'])] elif(str(client['address']) in self.tags): print "Tag disconnected : " + str(client['address']) # Remove Tag assignement to User because Tag left AND kill 3D point for key in self.users: if self.users[key].tag == self.tags[str(client['address'])]: self.users[key].removeTag() del self.tags[str(client['address'])] # Called when a client sends a message def message_received(self, client, server, message): self.parseMessage(client, message) def __init__(self, host='127.0.0.1'): self.server = WebsocketServer(self.port, host) self.server.set_fn_new_client(self.new_client_connection) self.server.set_fn_client_left(self.client_left) self.server.set_fn_message_received(self.message_received) self.server.run_forever() def parseMessage(self, client, message): """ Check who is the message from to redirect it to User / Tag / Camera / Calibration or create a new instance of User / Tag / Camera / Calibration :param client: :param message: :return: """ if self.cameras.has_key(str(client['address'])): #print "Message from Camera" self.cameras[str(client['address'])].push(message) # Update all cameras counters #Todo: Change this method for checking all cameras for lost point (auto check inside point2D ?) for key in self.cameras.keys(): self.cameras[key].update() elif self.users.has_key(str(client['address'])): print "Message from User" elif self.tags.has_key(str(client['address'])): print "Message from Tag" elif self.calibration.has_key(str(client['address'])): self.calibration[str(client['address'])].push(message) print "Message from Calibration" # This message is coming from an unknown client else: if message.split("-")[0] == "camera": self.cameras[str(client['address'])] = Camera(client, message.split("-")[1]) # Add Observers linking every user to every camera's update for key in self.users: if isinstance(self.users[key], User): self.cameras[str(client['address'])].new2DPointNotifier.addObserver(self.users[key].position.newPoint2DObserver) self.cameras[str(client['address'])].point2DdeletedNotifier.addObserver(self.users[key].position.point2DDeletedObserver) elif message.split("-")[0] == "tag": self.tags[str(client['address'])] = Tag(self.server, client, message.split("-")[1]) for key in self.users: if isinstance(self.users[key], User): # Assign a Tag to User with no Tag if self.users[key].tag == None: self.users[key].setTag(self.tags[str(client['address'])]) elif message.split("-")[0] == "user": user = User(self.server, client, message.split("-")[1]) self.users[str(client['address'])] = user # Add Observers linking every user to every camera's update for key in self.cameras: if isinstance(self.cameras[key], Camera): self.cameras[key].new2DPointNotifier.addObserver(user.position.newPoint2DObserver) self.cameras[key].point2DdeletedNotifier.addObserver(user.position.point2DDeletedObserver) for key in self.tags: if isinstance(self.tags[key], Tag): # Assign a Tag to new User if self.tags[key].isAssigned() == False: user.setTag(self.tags[key]) elif message == "calibration": if(len(self.tags)>0): self.calibration[str(client['address'])] = Calibration(self.server, client, self.cameras, self.tags.values()[0]) else: self.server.send_message(client, "Please connect a Tag first, and start Calibration again.")