def runserver(socket_port, websocket_port): SOCKET_PORT = socket_port WEBSOCKET_PORT = websocket_port server = WebSocketServer('', WEBSOCKET_PORT, Bridge) server.serve_forever()
class UnityServer: def __init__(self, host: str, port: int): self.logger = logging.getLogger("Unity Streamer") self.host = host self.port = port self.server = WebSocketServer(self.host, self.port, SimpleUnityWebsocketServer) self.thread = threading.Thread(target=self.start, args=()) self.logger.debug("Unity Server Initiated") def get_control(self): c = VehicleControl(throttle=throttle, steering=steering) return c def update_frame(self, new_frame): global frame frame = new_frame def start(self): self.logger.debug("Unity Server Started") self.server.serve_forever() def shutdown(self): self.server.close() self.thread.join() def startAsync(self): self.thread.start()
def init_project(): server = WebSocketServer('127.0.0.1', 8000, WafcamSocket, select_interval=None) launch(test_config, server) server.serve_forever()
def init_project(): db_config = database_utils.read_env() server = WebSocketServer('127.0.0.1', 8000, WafcamSocket, select_interval=None) launch(db_config, server) server.serve_forever()
class AnkiSocketServer(QThread): msgHandler = pyqtSignal(str) def run(self): global PORT self.server = WebSocketServer('', (PORT + 1), SimpleAnki) print("AnkiSocketServer run on port: " + str(PORT + 1)) self.server.serve_forever()
def __init__(self, host: str, port: int): self.logger = logging.getLogger("Unity Streamer") self.host = host self.port = port self.server = WebSocketServer(self.host, self.port, SimpleUnityWebsocketServer) self.thread = threading.Thread(target=self.start, args=()) self.logger.debug("Unity Server Initiated")
def main(): server_tool = WebSocketServer('192.168.43.238', 8000, WebSocketManagerBuzzer) thread_tool = Thread(target=server_tool.serve_forever) server_buzzer = WebSocketServer('192.168.43.238', 8001, WebSocketManagerBuzzer) thread_buzzer = Thread(target=server_buzzer.serve_forever) input() thread_tool.start() thread_buzzer.start()
def __init__(self) -> None: """Initialize the service.""" self._routes: Dict[str, Callable] = {} self._re_routes: Dict[Pattern[str], Callable] = {} self._lock = RLock() _stop_event = self._stop_event = threading.Event() class _WebsocketImpl(_WebsocketTemplate): _get_generator = WeakMethod(self._get_generator) # type: ignore server = self._server = WebSocketServer("0.0.0.0", 0, _WebsocketImpl) self.port = server.serversocket.getsockname()[1] # serve_forever() doesn't let you close the server without throwing # an exception >.< def loop() -> None: while not _stop_event.is_set(): server.handle_request() self._thread = threading.Thread(target=loop, daemon=True)
for client in self.clients: if client != self: client.send_message(self.data) def lightSeats() pass def doAnimation(animation, **params): pass def on(color,style=None): pass def off(color, style=None): pass def connected(self): #for client in self.clients: # client.send_message("new client Connected"); self.clients.append(self) def handle_close(self): self.clients.remove(self) #for client in self.clients: #client.send_message(self.address[0] + u" - disconnected") server = WebSocketServer("", 8000, SimpleChat) server.serve_forever()
#self.send_message(self.data) print(self.data) trama = self.data def connected(self): print(self.address, 'connected') clients.append(self) print(clients) def handle_close(self): print(self.address, 'closed') clients.remove(self) trama = "" server = WebSocketServer('192.168.0.230', 8000, MyWebSocket) def websocket_server(): while (1): server.handle_request() def read_text_input(): while (1): text = input() for client in list(clients): client.send_message(text) print("texto enviado", text)
from simple_websocket_server import WebSocketServer, WebSocket # import asyncio class SimpleEcho(WebSocket): def handle(self): # echo message back to client # self.send_message(self.data) print(self.data) def connected(self): print(self.address, 'connected') def handle_close(self): print(self.address, 'closed') server = WebSocketServer('', 8000, SimpleEcho) server.serve_forever()
from simple_websocket_server import WebSocketServer, WebSocket from ChatBot import get_response class ChatServer(WebSocket): def handleMessage(self): message = self.data response = get_response(message) self.sendMessage(response) def handleConnected(self): print(self.address, 'connected') def handleClose(self): print(self.address, 'closed') server = WebSocketServer('', 8000, ChatServer) server.serve_forever()
def ws_server(): print('Start Websocket server at ' + ip + ' 8001.') server = WebSocketServer(ip, 8001, WsServer) server.serve_forever()
def work(data): server = WebSocketServer('0.0.0.0', 5124, SimpleEcho, data) server.serve_forever()
def runServer(): print("Main:: Started backend WS server. Listening at port: 8765") server = WebSocketServer('192.168.0.122', 8765, WSServer) server.serve_forever()
self.ui.close() if __name__ == '__main__': parser = OptionParser(usage='usage: %prog [options]') parser.add_option('--host', default='', type='string', action='store', dest='host', help='hostname (localhost)') parser.add_option('--port', default=9503, type='int', action='store', dest='port', help='port (9503)') (options, args) = parser.parse_args() sslopts = {} server = WebSocketServer(options.host, options.port, WebKeyboard, **sslopts) def close_sig_handler(signal, frame): server.close() sys.exit() signal.signal(signal.SIGINT, close_sig_handler) server.serve_forever()
def server_thread(port): server = WebSocketServer('', port, ws_Server) print ("Starting Web socket server") server.serve_forever()
global duplicates global new_dupes print(new_dupes) duplicates = new_dupes new_dupes = [] class Server(WebSocket): def handle(self): print("MSG " + self.data) for ws in connections: ws.send_message("MSG " + self.data) def connected(self): print(self.address, 'connected') connections.append(self) def handle_close(self): print(self.address, 'closed') connections.remove(self) print("Listening on PORT " + os.getenv('PORT') + " ...") handler = Handler() handler.start() server = WebSocketServer("", os.getenv('PORT'), Server) server.serve_forever()
from simple_websocket_server import WebSocketServer, WebSocket class SimpleEcho(WebSocket): def handle(self): # echo message back to client self.send_message(self.data) def connected(self): print(self.address, 'connected') def handle_close(self): print(self.address, 'closed') server = WebSocketServer('127.0.0.1', 5678, SimpleEcho) server.serve_forever()
from simple_websocket_server import WebSocketServer, WebSocket import base64 from cv2 import cv2 import numpy as np import warnings warnings.simplefilter('ignore', DeprecationWarning) class SimpleEcho(WebSocket): def handle(self): msg = self.data img = cv2.imdecode( np.fromstring(base64.b64decode(msg.split(',')[1]), np.uint8), cv2.IMREAD_COLOR) cv2.imshow('image', img) cv2.waitKey(1) def connected(self): print(self.address, 'Connected') def handle_close(self): print(self.address, 'Closed') server = WebSocketServer('localhost', 3000, SimpleEcho) server.serve_forever()
else: master = process.stdout Thread(target=updater).start() http_port = 9000 socket_port = 9090 opts, args = getopt.getopt(sys.argv[1:], '', ['http_port=', 'socket_port=']) for opt, arg in opts: if opt == '--http_port': http_port = int(arg) elif opt == '--socket_port': socket_port = int(arg) http_thread = Thread( target=lambda: MyHTTPServer(('', http_port)).serve_forever()) http_thread.daemon = True http_thread.start() print('HTTP listening on {}'.format(http_port)) socket_thread = Thread(target=lambda: WebSocketServer( '0.0.0.0', socket_port, WebSocketHandler).serve_forever()) socket_thread.daemon = True socket_thread.start() print('WebSocket listening on {}'.format(socket_port)) while True: time.sleep(1)
def main(): server = WebSocketServer('127.0.0.1', 8009, SimpleEcho) server.serve_forever()
# -*- coding: utf-8 -*- """ Created on Wed Jun 26 08:52:19 2019 @author: janto """ from simple_websocket_server import WebSocketServer, WebSocket class ssbt_socket_face_id(WebSocket): def handle(self): # echo message back to client self.send_message(self.data) def connected(self): print(self.address, 'connected') def handle_close(self): print(self.address, 'closed') server = WebSocketServer('127.0.0.1', 61613, ssbt_socket_face_id) server.serve_forever()
print(self.address, 'closed') class SimpleChat(WebSocket): def handle(self): for client in clients: if client != self: client.send_message(self.data) def connected(self): print(self.address, 'connected') for client in clients: client.send_message(self.address[0] + u' - connected') clients.append(self) def handle_close(self): clients.remove(self) print(self.address, 'closed') for client in clients: client.send_message(self.address[0] + u' - disconnected') clients = [] sslopts = dict(certfile="/home/romain/cert.pem", keyfile="/home/romain/key.pem", ssl_version=ssl.PROTOCOL_TLSv1) server = WebSocketServer('172.25.28.5', 443, SimpleChat, **sslopts) server.serve_forever()
class ReRouter(WebSocket): def handle(self): # osc channel channel = self.data[0:5].decode("utf-8") # message type msg_type = self.data[9:10].decode("utf-8") # get message number = struct.unpack(">f", self.data[12:])[0] print( "msg from " + channel + ". type: " + msg_type + ", with value:>>", round(number, 2), ) # from p5 to weki print("Sending to weki ", channel) client.send_message(channel, round(float(number), 2)) def connected(self): print(self.address, "connected") def handle_close(self): print(self.address, "closed") while True: print(f"[*] I listen inputs from p5 in localhost:{p5_port}") print(f"[*] I reroute msgs to wekinator, in localhost:{weki_port}") server = WebSocketServer("", p5_port, ReRouter) server.serve_forever()
@app.route('/static/<path:path>') def send_js(path): return send_from_directory('static', path) connections = [] class SimpleEcho(WebSocket): def handle(self): # echo message back to client print("received data:" + self.data) for connection in connections: connection.send_message(self.data) def connected(self): connections.append(self) def handle_close(self): connections.remove(self) server = WebSocketServer('', 5001, SimpleEcho) # start websocket server threading.Thread(target=server.serve_forever).start() # start flask server threading.Thread(target=app.run, args=("0.0.0.0", )).start()
class SimpleEcho(WebSocket): def handle(self): # echo message back to client l[0] = self.data print l[0][2] def connected(self): print(self.address, 'connected') def handle_close(self): print(self.address, 'closed') server = WebSocketServer('', 8000, SimpleEcho) def srvr(): server.serve_forever() def engine(): while True: if l[0][2] == "R": tmp = l[0] tmp = tmp.encode('latin1') js = yaml.safe_load(tmp) a = list(js["Events"].keys()) NoE = len(js["Events"])
del server.clients[name] open_lobbies = {} address = socket.gethostbyname(socket.gethostname()) parser = OptionParser(usage='usage: %prog [options]', version='%prog 1.0.0') parser.add_option('--ssl', default=0, type='int', action='store', dest='ssl', help='ssl (1: on, 0: off (default))') parser.add_option('--cert', default='./cert.pem', type='string', action='store', dest='cert', help='cert (./cert.pem)') parser.add_option('--key', default='./key.pem', type='string', action='store', dest='key', help='key (./key.pem)') parser.add_option('--ver', default=ssl.PROTOCOL_TLSv1, type=int, action='store', dest='ver', help='ssl version') parser.add_option('--localhost', default=False, action='store_true', dest='localhost', help='whether to use localhost') parser.add_option('--port', default=11000, type=int, action='store', dest='port', help='server port') (options, args) = parser.parse_args() sslopts = {} if options.ssl == 1: sslopts = dict(certfile=options.cert, keyfile=options.key, ssl_version=options.ver) if options.localhost: address = "127.0.0.1" print(f"Running at {address}:{options.port} {'(using TLS/SSL)' if options.ssl == 1 else '(not using TLS/SSL)'}") server = WebSocketServer(address, options.port, MultiplayerServer, **sslopts) def keyboardInterruptHandler(signal, frame): print("KeyboardInterrupt (ID: {}) has been caught. Cleaning up...".format(signal)) server.close() print("Clean up complete, terminating...") sys.exit() signal.signal(signal.SIGINT, keyboardInterruptHandler) server.serve_forever()
if jsn['value'] is not None: self.__i = jsn['value'] self.send_message('{"success": True}') self.f() except Exception as e: print('???', e) def connected(self): print(self.address, 'connected') def handle_close(self): print(self.address, 'closed') def f(self): print('f', self.__i) self.__i += 1 self.send_message('{"value": ' + str(self.__i) + '}') t = threading.Timer(0.2, self.f) t.start() if __name__ == "__main__": server_address = '' server_port = 8000 server = WebSocketServer(server_address, server_port, SimpleEcho) print('serving at %s:%d' % (server_address, server_port)) server.serve_forever()
from simple_websocket_server import WebSocketServer, WebSocket import json import threading class BtcWebScoket(WebSocket): def handle(self): try: print(self.data) msg = json.loads(self.data) msgType = msg['MsgType'] if msgType == 'PEER_INFO': self.send_message('peer_info') # self.send_message(json.dumps({ # 'PEERS_IN':PEERS_IN, # 'PEERS_OUT':PEERS_OUT # })) except Exception as ex: print(ex) def connected(self): print(self.address, 'connected') def handle_close(self): print(self.address, 'closed') ws = WebSocketServer('', 9675, BtcWebScoket) wst = threading.Thread(target=ws.serve_forever) wst.start()