class Websocket_Server(): def __init__(self, host, port): self.server = WebsocketServer(port, host=host, loglevel=logging.DEBUG) # クライアント接続時に呼ばれる関数 def new_client(self, client, server): print("new client connected and was given id {}".format(client['id'])) # 全クライアントにメッセージを送信 self.server.send_message_to_all("hey all, a new client has joined us") # クライアント切断時に呼ばれる関数 def client_left(self, client, server): print("client({}) disconnected".format(client['id'])) # クライアントからメッセージを受信したときに呼ばれる関数 def message_received(self, client, server, message): print(message + "これはテストです") print("client({}) said: {}".format(client['id'], message + "これはテスト")) file = open('InputText.txt', 'w') file.write(message) print(message + "これはテストです") # 全クライアントにメッセージを送信 self.server.send_message_to_all(message) # サーバーを起動する def run(self): # クライアント接続時のコールバック関数にself.new_client関数をセット self.server.set_fn_new_client(self.new_client) # クライアント切断時のコールバック関数にself.client_left関数をセット self.server.set_fn_client_left(self.client_left) # メッセージ受信時のコールバック関数にself.message_received関数をセット self.server.set_fn_message_received(self.message_received) self.server.run_forever()
def __init__(self, conf): global server super(WSService, self).__init__() self.conf = conf server = WebsocketServer(WSPORT, host='0.0.0.0') server.set_fn_new_client(newClient) server.set_fn_client_left(leftClient)
def run_server(): server = WebsocketServer(9288, host="0.0.0.0") server.set_fn_new_client(on_join) server.set_fn_client_left(on_leave) server.set_fn_message_received(on_message) print("Bridge server ready.") server.run_forever()
def startWebSocketServer(): PORT = 8888 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()
def startup_ws_server(self): WSPORT = 9001 server = WebsocketServer(port=WSPORT, host="0.0.0.0") 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()
def main(): server = WebsocketServer(1236, '0.0.0.0') server.set_fn_new_client(new_client_handler) server.set_fn_client_left(client_left_handler) server.set_fn_message_received(message_received_handler) server.run_forever()
def main(): r_q = Queue() ws_q = Queue() server = WebsocketServer(8998, host='0.0.0.0') #, loglevel=logging.INFO) server.set_fn_new_client(new_client) server.set_fn_message_received(msg_received_ws(ws_q)) t = Thread(target=server.run_forever) t.daemon = True t.start() r = redis.Redis(host='octopi.labs', port=6379, db=0) p = r.pubsub() p.subscribe(replies=handle_replies_redis(r_q)) while True: if not ws_q.empty(): comm, data = ws_q.get() print('from ws', comm, data) if type(data) is list: c = Command(comm, None, data) else: c = Command(comm, None, [data]) print(c, c.command) r.publish('commands', bytes(c.command)) if not r_q.empty(): data = r_q.get() print('from redis', data) server.send_message_to_all(data) p.get_message() time.sleep(0.1)
class IrWsServer(): DEF_PORT = 9001 def __init__(self, port=DEF_PORT, host="0.0.0.0", svrhost='localhost', svrport=51001, debug=False): self._dbg = debug self._log = get_logger(__class__.__name__, self._dbg) self._log.debug('host=%s, port=%s', host, port) self._log.debug('svrhost=%s, svrport=%s', svrhost, svrport) self.irsvr = IrSendCmdClient(svrhost, svrport, debug=self._dbg) self.server = WebsocketServer(port, host=host) def new_client(self, client, server): self._log.debug('client=%s', client) def client_left(self, client, server): self._log.debug('client=%s', client) self.irsvr.end() def message_received(self, client, server, msg): self._log.debug('client=%s, msg=%s', client, msg) self.msg = msg.encode('utf-8') self._log.info('msg=%s.', msg) self.irsvr.send_recv(msg.split()) def run(self): self._log.debug('') self.server.set_fn_new_client(self.new_client) self.server.set_fn_client_left(self.client_left) self.server.set_fn_message_received(self.message_received) self.server.run_forever()
class Websocket_Server(): def __init__(self, host, port): self.client_id_username_map = {} self.server = WebsocketServer(port, host = host, loglevel = logging.DEBUG) def new_client(self, client, server): print("new client connected and was given id {}".format(client['id'])) self.server.send_message(client,"make connection : success!!") def client_left(self, client, server): print("client({}) disconnected".format(client['id'])) def message_received(self, client, server, message): if message.startswith("init:username:"******"init:username:"******"") print(username) self.client_id_username_map[client["id"]] = username self.server.send_message_to_all(message) else: self.server.send_message_to_all(message) def run(self): self.server.set_fn_new_client(self.new_client) self.server.set_fn_client_left(self.client_left) self.server.set_fn_message_received(self.message_received) self.server.run_forever()
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()
class WsSever: def __init__(self, host,port,connectCall,leftCall,messageCall): # day = time.strftime("%Y-%m-%d", time.localtime()) # self.logger = logging.getLogger(__name__) # self.logger.setLevel(level = logging.DEBUG) # handler = logging.FileHandler("{}-{}.txt".format(day,port),encoding="utf-8") # handler.setLevel(logging.DEBUG) # formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') # handler.setFormatter(formatter) # self.logger.addHandler(handler) self.Server = WebsocketServer(host = host,port = port,loglevel=logging.INFO) self.Server.set_fn_new_client(connectCall) self.Server.set_fn_client_left(leftCall) self.Server.set_fn_message_received(messageCall) def startRun(self): self.Server.run_forever() def GetServer(self): return self.Server def loginfo(self,str): # self.logger.info(str) pass
class BaseWebSocketServer: """ WebSocketServerのベースクラス """ def __init__(self, IP, PORT): # 接続 self.server = WebsocketServer(PORT, host=IP) # 設定 self.server.set_fn_new_client(self._when_new_client) self.server.set_fn_message_received(self._when_message_received) # スレッド self.thread = None def _when_new_client(self, client, server): """ 新規のclientが接続してきたときの処理 """ print("{}:: New client connected.".format(self.__class__.__name__)) def _when_message_received(self, client, server, message): """ あるclientからmessageを受信したとき """ print("{}:: Received message \"{}\".".format(self.__class__.__name__, message)) def run_forever(self): """ サーバー起動 """ print("{}:: Run forever.".format(self.__class__.__name__)) self.thread = Thread(target=self.server.run_forever) self.thread.setDaemon(True) self.thread.start()
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 run_server_classic(ip_address, port): """run_server""" server = WebsocketServer(port, host=ip_address) server.set_fn_new_client(new_client) server.set_fn_client_left(client_diconnected) server.set_fn_message_received(std_message_received) server.run_forever()
def run(self): server = WebsocketServer(self.port, host="0.0.0.0") server.set_fn_new_client(self.new_client) server.set_fn_client_left(self.client_left) server.set_fn_message_received(self.message_received) self.servers.append(server) server.run_forever()
def start_ws_server(args): """ """ server = WebsocketServer(args.port, host=args.host) def send(msg, client): try: message = json.dumps(msg) server.send_message(client, message) except: logger.exception(('ws send error')) def broadcast(msg): try: server.send_message_to_all(msg) except: #logger.exception(('ws send error')) pass def new_client(client, server): logger.info(('connected', client['id'])) message = json.dumps({'message': 'connected', 'client': client['id']}) broadcast(message) def client_left(client, server): logger.info(('disconnected', client['id'])) message = json.dumps({ 'message': 'disconnected', 'client': client['id'] }) broadcast(message) def message_received(client, server, message): logger.info(('message_received', len(message), message[:100])) try: msg = json.loads(message) new_message = json.dumps({ 'message': 'message', 'client': client['id'], 'content': msg }) broadcast(new_message) except: logger.exception(('ws message handler error')) resp_message = json.dumps({ 'message': 'error', 'description': 'server error' }) send(resp_message, client) return resp_message = json.dumps({'message': 'result', 'description': 'ok'}) send(resp_message, client) 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 GUI: # Initialization function # The actual initialization def __init__(self, host, console): t = threading.Thread(target=self.run_server) self.payload = {'canvas': None, 'image': '', 'shape': []} self.server = None self.client = None self.host = host self.payload_lock = threading.Lock() # Take the console object to set the same websocket and client self.console = console t.start() # Explicit initialization function # Class method, so user can call it without instantiation @classmethod def initGUI(self): # self.payload = {'image': '', 'shape': []} pass # Function for student to call # Encodes the image as a JSON string and sends through the WS def showImage(self, image): shape = image.shape frame = cv2.imencode('.JPEG', image)[1] encoded_image = base64.b64encode(frame) self.payload_lock.acquire() self.payload['image'] = encoded_image.decode('utf-8') self.payload['shape'] = shape self.payload_lock.release() # Function to get the client # Called when a new client is received def get_client(self, client, server): self.client = client self.console.set_websocket(self.server, self.client) # Update the gui def update_gui(self): self.payload_lock.acquire() message = "#img" + json.dumps(self.payload) self.payload_lock.release() try: self.server.send_message(self.client, message) except: pass # 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.console.prompt) self.server.run_forever()
def main(argv): host = "" port = "" try: opts, args = getopt.getopt(argv, "hs:p:", ["host=", "port="]) except getopt.GetoptError: print("server.py -s <host> -p <port>") sys.exit(2) for opt, arg in opts: if opt == '-h': print("server.py -s <host> -p <port>") sys.exit() elif opt in ("-s", "--host"): host = arg elif opt in ("-p", "--port"): port = arg if host == "" or port == "": print("server.py -s <host> -p <port>") sys.exit(2) server = WebsocketServer(host=host, port=int(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()
class RpiServerWS(): """docstring for WebsocketServer""" server = None def __init__(self, parent): self.parent = parent self.server = WebsocketServer(8050, host=hosthome, loglevel=logging.INFO) self.server.set_fn_new_client(self.new_client) self.server.set_fn_message_received(self.message_received) self.server.set_fn_client_left(self.client_left) print('Websocket Server started, waiting for clients to connect') self.server.run_forever() def new_client(self, client, server): #print('Connected by ', client) self.parent.clientSockets.append(client) greeting = '{"functionName":"connected", "args":{} }' self.server.send_message(client, greeting) def message_received(self, client, server, message): item = (message, self.server, client) #print('putting ', item, 'in the queue') self.parent.callbackQueue.put(item) #self.server.send_message(client, 'WS: Message put in queue') def client_left(self, client, server): self.parent.clientSockets.remove(client)
def __init__(self): self.client = '' self.server = '' # Called for every client connecting (after handshake) def new_client(client, server): print("New client connected and was given id %d" % client['id']) self.client = client server.send_message_to_all("Hey all, a new client has joined us") # Called for every client disconnecting def client_left(client, server): print("Client(%d) disconnected" % client['id']) # Called when a client sends a message def message_received(client, server, message): if len(message) > 200: message = message[:200] + '..' print("Client(%d) said: %s" % (client['id'], message)) PORT = 9001 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() self.server = server make_template() os.system('open index.html')
class WebSocketServer: if DebugLog.Debug: ip = '127.0.0.1' local_ip = '127.0.0.1' else: ip = '188.134.82.95' local_ip = '192.168.0.100' port = 11001 def __init__(self): self.server = WebsocketServer(WebSocketServer.port, WebSocketServer.local_ip) 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.clients: Dict[int, VisualGithubClient] = {} def run(self): self.server.run_forever() # Called for every client connecting (after handshake) def new_client(self, client, _): DebugLog.connected(f'New client connected ' f'and was given id {client["id"]}') new_client = VisualGithubClient(client['id'], client['handler']) client['client'] = new_client self.clients[new_client.id] = new_client # Called for every client disconnecting def client_left(self, client, _): if client is None: return DebugLog.client_left(f'Client {client["id"]} disconnected') try: client['client'].left(self) except KeyError: DebugLog.error(f'Key error possibly double deleting ' f'in client left id = {client["id"]}') except ValueError: DebugLog.error(f'Value error possibly double deleting ' f'in client left id = {client["id"]}') # Called when a client sends a message def message_received(self, client, _, message): if client is None: return message = message.encode('ISO-8859-1').decode() client['client'].receive(self, message, client) def broadcast(self, message: dict): for client in list(self.clients.values()): if client.pass_filters(message): client.send(message)
def start_server(): server = WebsocketServer(10001, host='0.0.0.0') server.set_fn_new_client(accept_connection) server.set_fn_message_received(handle_message) server.set_fn_client_left(remove_connection) thread = threading.Thread(target=server.run_forever) thread.start()
class WsServer(threading.Thread): def __init__(self, conf=None, controller=None): threading.Thread.__init__(self) if conf == None: self.conf = dict(port=4000, host='127.0.0.1') else: self.conf = conf self.server = WebsocketServer(self.conf["port"], host=self.conf["host"]) self.server.set_fn_new_client(self.new_client) self.server.set_fn_client_left(self.client_left) self.server.set_fn_message_received(self.message_received) def run(self): self.server.run_forever() def new_client(client, server): logging.info("WS: New Client") self.server.send_message_to_all("Hey all, a new client has joined us") def client_left(client, server): logging.info("WS: Client left") self.server.send_message_to_all("Hey all, a new client has joined us") def message_received(client, server, message): logging.info("WS: New message " + message) def disconnect(self): logging.info("WS:Disconnect") self.server.shutdown()
def start(self): al.log('Launch a server on port %d...' % self.port) server = WebsocketServer(self.port, host=self.host) server.set_fn_new_client(self.newClient) server.set_fn_client_left(self.clientLeft) server.set_fn_message_received(self.msgReceived) server.run_forever()
def _track_logs(test_name, project_path): server = WebsocketServer(WS_PORT, host='0.0.0.0') def new_client(cli, svr): opened_files = {} try: while True: for root, dirs, files in os.walk(project_path): for f in files: if f.endswith('_color') and test_name in root: if not opened_files.get(f): opened_files[f] = open(join(root, f)) log_lines = [ convert(l) for l in opened_files[f].readlines() ] if log_lines != []: node = splitext(f)[0].split('_') node_num = node[-1] if node[-1].isdigit( ) else None node_type = node[:-1] if node[-1].isdigit( ) else node svr.send_message_to_all( json.dumps({ 'node_type': '_'.join(node_type), 'node_num': node_num, 'log_lines': log_lines })) time.sleep(0.01) except: for f in opened_files: opened_files[f].close() server.set_fn_new_client(new_client) server.run_forever()
def start_websocket(): PORT=8020 global server server = WebsocketServer(PORT) print('listenin websoket port:8020') server.set_fn_new_client(new_client) server.set_fn_client_left(client_left) server.run_forever()
def start_server_task(): ws = WebsocketServer(api_server_port) ws.set_fn_new_client(WebSoketAPIServerHandler.on_connected) ws.set_fn_client_left(WebSoketAPIServerHandler.on_disconnected) ws.set_fn_message_received(WebSoketAPIServerHandler.on_message) WebSoketAPIServerHandler.api_server = ws ws.run_forever()
def start(self): logger.info("Starting WebSocket INDI server on %s:%s", self.address, self.port) server = WebsocketServer(self.port, host=self.address) 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()
def run_server(i_ip_address, i_port, i_message_received, i_new_client, i_client_diconnected): """run_server""" server = WebsocketServer(i_port, host=i_ip_address) server.set_fn_new_client(i_new_client) server.set_fn_client_left(i_client_diconnected) server.set_fn_message_received(i_message_received) server.run_forever()
def __init__(self, port, fn_new_client, fn_client_left, fn_message_received): threading.Thread.__init__(self) server = WebsocketServer(host='0.0.0.0', port=port) server.set_fn_new_client(fn_new_client) server.set_fn_client_left(fn_client_left) server.set_fn_message_received(fn_message_received) self.server = server
class StatusManager(object): def __init__(self): self._now = time.time() self._datetime_now = datetime.now() self._acc = Accelerometer() self._motion = [0, 0] self._server = WebsocketServer(host='127.0.0.1', port=6700) 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._sensors = SerialSensorManager() # self._sensors.search(["GY-521", "Papirs-01"]) def new_client(self, client, server): print('New client {}:{} has joined.'.format(client['address'][0], client['address'][1])) def client_left(self, client, server): print('Client {}:{} has left.'.format(client['address'][0], client['address'][1])) def message_received(self, client, server, message): # print(message) data = message.split(",") if data[0] == 'motion': motion_sensor_id = int(data[2]) status = data[3] self._motion[motion_sensor_id] = 0 if status == 'stop' else 1 elif data[0] == 'acc': self._acc.acc_x = float(data[3]) self._acc.acc_y = float(data[2]) self._acc.acc_z = float(data[4]) def update(self): ws_thread = threading.Thread(target=self._server.run_forever) ws_thread.daemon = True ws_thread.start() while True: self._now = time.time() self._datetime_now = datetime.now() # TODO 天気情報 # TODO 強制実行アクション取得 # TODO ハッシュタグ取得 time.sleep(.1) def get_data(self): return { "now": self._now, "datetime": self._datetime_now, "accelerometer": self._acc, "motions": self._motion }
def __init__(self): self.client2slide = {} self.slide2clients = {} self.slide2presentationdata = {} server = WebsocketServer(port=12345, host='127.0.0.1') server.set_fn_new_client(self.new_client) server.set_fn_client_left(self.client_left) server.set_fn_message_received(self.message_received) self.server = server
def WsLapCounterServerLaunch(): global wsLapCounterServer while 1: try: wsLapCounterServer = WebsocketServer( port=PORT_NUMBER + 2, host='' ) wsLapCounterServer.set_fn_new_client( lap_counter_new_client ) wsLapCounterServer.run_forever() except Exception as e: wsLapCounterServer = None time.sleep( 5 )
def listen(courier, host, port): server = WebsocketServer(port) server.set_fn_new_client(notify_client) uthread = threading.Thread(target=updater, args=(courier, server)) tthread = threading.Thread(target=v_timer, args=(server,)) uthread.daemon = True tthread.daemon = True uthread.start() tthread.start() print("Starting WebSocket Server...") server.run_forever()
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()
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()
#!/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 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.")
class WebsocketPublisher(object): """ Publish cluster state as JSON over a websocket. Only sends CS state, and information on who is building on who. This is enough information to draw a graph of the cluster. Explicitly, does not send information on individual jobs. """ MIN_SEND_GAP_S = 0.1 """Minimum gap in seconds between sending messages to connected clients.""" def __init__(self, host="0.0.0.0", port=9999): self.frame = "" self.nodes = "" self.links = "" self.last_sent_frame = "" self.last_sent_nodes = "" self.last_sent_links = "" self.next_time_to_send = 0 self.lock = threading.RLock() self.timer = None self.ws_server = WebsocketServer(port, host) def send_to_client(client, server): with self.lock: server.send_message(client, self.build_graph(True)) self.ws_server.set_fn_new_client(send_to_client) t = threading.Thread(target=self.ws_server.run_forever) t.daemon = True t.start() def build_nodes(self, mon): """Builds a JSON representation of the CS nodes in the cluster.""" nodes = [] for cs in mon.cs.values(): nodes.append({"id": cs.id, "name": cs.name, "ip": cs.ip, "load": (100*cs.active_jobs())/cs.maxjobs}) return json.dumps(nodes) def build_links(self, mon): """ Builds a JSON representation of the links in the cluster. There is one link A->B if A has one or more jobs building on B. """ links = [] for job in mon.jobs.values(): if job.host_id not in mon.cs or job.client_id not in mon.cs: continue c, s = mon.cs[job.client_id], mon.cs[job.host_id] # Don't double-add links. add = True for l in links: if l["source"] == c.id and l["target"] == s.id: add = False if add: links.append({"source": c.id, "target": s.id, "value": 10}) return json.dumps(links) def build_graph(self, full=False): """Builds a full JSON representation of a graph of the cluster.""" frame = '{"timestamp": 0, "index": 0' if full or self.nodes != self.last_sent_nodes: frame += ', "nodes": ' + self.nodes if full or self.links != self.last_sent_links: frame += ', "links": ' + self.links frame += '}' return frame def publish(self, mon): """ Called by the Monitor to indicate new cluster state. Update our internal state, and notify clients if appropriate. """ with self.lock: self.nodes = self.build_nodes(mon) self.links = self.build_links(mon) self.frame = self.build_graph() self.notify() def notify(self): """Send updates to clients if necessary.""" now = time.time() with self.lock: if self.frame == self.last_sent_frame: # Frame hasn't changed, don't resend. return elif (now >= self.next_time_to_send and self.timer is None): # We can send. self.broadcast() elif self.timer is None: # We must reschedule. self.timer = threading.Timer(self.next_time_to_send - now, self.broadcast) self.timer.start() def broadcast(self): """Actually broadcast cluster state to all connected clients.""" with self.lock: if self.timer is not None: self.timer.cancel() self.timer = None self.next_time_to_send = time.time() + self.MIN_SEND_GAP_S self.last_sent_frame = self.frame self.last_sent_nodes = self.nodes self.last_sent_links = self.links self.ws_server.send_message_to_all(self.frame)
carConnectionSem.release() print('Client disconnected') # 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()
# 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()
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 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))
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()
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()
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)
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()
def new_client(client, server): print("New client connected and was given id %d" % client['id']) server.send_message(client, json.dumps(shared_dict)) # Called when a client sends a message def message_received(client, server, message): if message != "PING": print("Client(%d) said: %s" % (client['id'], message)) shared_dict["form"] = json.loads(message) server.send_message_to_all(json.dumps(shared_dict)) for key, value in shared_dict["form"].items(): networktable.putValue(key, value) ws_server = WebsocketServer(config['ws_port']) ws_server.set_fn_new_client(new_client) ws_server.set_fn_message_received(message_received) class ConnectionListener: def __init__(self): self._first_disconnect = True # we want to ignore the first disconnect event as it's always disconnected at init def connected(self, table): print("NetworksTables connected to", table) shared_dict["robot_status"] = "connected" ws_server.send_message_to_all(json.dumps(shared_dict)) # we may have form data to send to the table while we were disconnected, so update it for key, value in shared_dict["form"].items(): table.putValue(key, value)