class LogRecordSocketReceiver(SocketServer.ThreadingTCPServer): allow_reuse_address = 1 def __init__(self, host='localhost', port=logging.handlers.DEFAULT_TCP_LOGGING_PORT, handler=LogRecordStreamHandler): SocketServer.ThreadingTCPServer.__init__(self, (host, port), handler) self.abort = 0 self.timeout = 1 self.logname = None self.requstHandle = None self.wsserver = SimpleWebSocketServer('', BASE_WS_PORT, WebSocket) def finish_request(self, request, client_address): LogRecordStreamHandler(request, client_address, self, self.wsserver) def cleanup(self): self.wsserver.close() def serve_until_stopped(self): import select abort = 0 while not abort: self.wsserver.servconnman() rd, wr, ex = select.select([self.socket.fileno()], [], [], self.timeout) if rd: self.handle_request() abort = self.abort
def run_server(): global server server = SimpleWebSocketServer('', 9000, DetectorHandler, selectInterval=(1000.0 / 15) / 1000) server.serveforever()
def start_server(): """ Start the server in localhost with port 8000 :return: void """ server = SimpleWebSocketServer('', 8000, SimpleEcho) server.serveforever()
class WSServerThread( threading.Thread ): """ La clase cliente socket que se levanta como un hilo de proceso independiente. """ def __init__ ( self, sktServer): """ Inicializacion de la clase """ self.wshandlerclass = '' self.sktServer = sktServer self.wSktServer = SimpleWebSocketServer('', 9000, SimpleEcho) threading.Thread.__init__ ( self ) def setWSHandlerClass(self, instance): self.wshandlerclass = instance def run ( self ): """ Una vez inicializada la clase esta es ejecutada en este metodo """ self.wSktServer.setInvoker(self) self.sktServer.attach(self) self.wSktServer.serveforever() def sendMessage(self, data): if self.wshandlerclass != '': self.wshandlerclass.send_bytes(data)
def run(self): print "Starting server on localhost:%d" % self.port self.wss = SimpleWebSocketServer('', self.port, BuzzSocket) try: self.wss.serveforever() except: print "Buzzws server killed or crashed. Bye!"
def __init__(self, host='', port=9999, skipframes=0, **kwargs): self.host = host self.port = port self.skipframes = skipframes + 1 SimpleWebSocketServer.__init__(self, host, port, BotIOChromeExtensionSocket, selectInterval=0.1) Framework.Framework.__init__(self, **kwargs) self.serveforever()
def RunServer(): try: server = SimpleWebSocketServer('', 8080, WS_Collector) server.serveforever() except KeyboardInterrupt: raise print 'Stopping Client Socket server'
def __init__(self): self.__version__ = '3.1.3' logger_format = '%(asctime)s %(message)s' logging.basicConfig(format=logger_format, level=logging.INFO, datefmt="%H:%M:%S", filename='./logfile.log', filemode='w') logging.getLogger().addHandler(SysLogHandler(facility=SysLogHandler.LOG_DAEMON, address='/dev/log')) self._SIGKILL = False self.logging = logging self.config = DB('./config.json') self.network = Network(self) self.display = DisplayContent() self.detector = Detector() self.ultrasound = Ultrasound(self) self.temp = Temp() self.server = SimpleWebSocketServer('', 8069, WebSocketServer, self) self.cook = Cook(self) self.energy = Energy(self) self.history = History(self) self.audio = Audio(self) self.users = Users(self) self.automations = Automations(self) signal.signal(signal.SIGTERM, self.sig_handler) signal.signal(signal.SIGINT, self.sig_handler) self.log("Boot: v" + self.__version__)
class Websocket(object): def send_data(self, data): for nr, conn in self.server.connections.items(): conn.sendMessage(data) def run(self): self.server = SimpleWebSocketServer('', self.port, TestEcho) while not self.exit_event.is_set(): self.server.serveonce() def __init__(self, port): self.port = port self.exit_event = Event() self.thread = Thread(target=self.run) self.thread.start() def __enter__(self): return self def __exit__(self, exc_type, exc_value, traceback): self.exit_event.set() self.thread.join(10) if self.thread.is_alive(): Utility.console_log('Thread cannot be joined', 'orange')
def setUp(cls): parser = OptionParser(usage="usage: %prog [options]", version="%prog 1.0") parser.add_option("--host", default='', type='string', action="store", dest="host", help="hostname (localhost)") parser.add_option("--port", default=32768, type='int', action="store", dest="port", help="port (32768)") (options, args) = parser.parse_args() server = SimpleWebSocketServer(options.host, options.port, cls) def close_sig_handler(signal, frame): server.close() sys.exit() signal.signal(signal.SIGINT, close_sig_handler) server.serveforever()
def _runserver(self): self.server = SimpleWebSocketServer(self.superNodeIp, 4141, P2PClientConnectionHandler) try: print("node starting") self.server.serveforever() except Exception as e: print("websocket server exited: %s" % e)
def run_server(): # checking running processes. # if the backplane is already running, just note that and move on. found_pigpio = False found_gammu-smsd = False for pid in psutil.pids(): p = psutil.Process(pid) if p.name() == "pigpiod": found_pigpio = True print("pigpiod is running") else: continue if not found_pigpio: call(['sudo', 'pigpiod']) print('pigpiod has been started') # add gammu-smsd deamon check for pid in psutil.pids(): p = psutil.Process(pid) if p.name() == "gammu-smsd": found_ = True print("gammu-smsd is running") else: continue if not found_gammu-smsd: call(['sudo', 'systemctl start gammu-smsd.service']) print('gammu-smsd has been started') os.system('scratch2&') server = SimpleWebSocketServer('', 9000, S2Nadhat) server.serveforever()
class WsServer(object): def __init__(self, port): self.ws_clients = [] ws_server = self class DataPusher(WebSocket): def handleMessage(self): pass def handleConnected(self): logging.info('ws_server: client connected') ws_server.ws_clients.append(self) def handleClose(self): ws_server.ws_clients.remove(self) logging.info('ws_server: client closed') self.server = SimpleWebSocketServer('', port, DataPusher) def start_server(self): self.server.serveforever() logging.info("ws_server started") def broadcast(self, msg): msg.update({"ts": time.time()}) for client in self.ws_clients: client.sendMessage(unicode(json.dumps(msg)))
class WebSockectLCDSimulator: def __init__(self): self.server = SimpleWebSocketServer('', 8000, WebSocketServer) def on_start(self): thread = Thread(target=self.runServer) thread.start() def runServer(self): self.server.serveforever() def message(self, message): #TODO Find special characters and replace with others. For example Volume\x01 to u'Volume\u2600' data = unicode(json.dumps({'jsonrpc': '2.0', 'method': 'message', 'params': message })) global last_message last_message = data for client in clients: client.sendMessage(data) def create_char(self, location, pattern): data = unicode(json.dumps({'jsonrpc': '2.0', 'method': 'create_char', 'params': {location: location, pattern: pattern}})) for client in clients: client.sendMessage(data) def on_stop(self): self.server.close() def is_pressed(self, button): if button not in set((InputManager.SELECT, InputManager.RIGHT, InputManager.DOWN, InputManager.UP, InputManager.LEFT)): raise ValueError('Unknown button, must be SELECT, RIGHT, DOWN, UP, or LEFT.') return pressed_keys[button]
def __init__(self): self.running = False self.host_address = '' self.port = 8500 self.server = SimpleWebSocketServer(self.host_address, self.port, SimpleMessager) self.game = None
class Server: def __init__(self): self.server = SimpleWebSocketServer(config.host, config.port, Events) self.sockname = self.server.serversocket.getsockname() def __call__(self): self.server.serveforever()
def run(self): self._logger.info("Websocket Server started on port %s" % self.port) try: self.wsd = SimpleWebSocketServer('', self.port, FSWebSocket) self.wsd.serveforever() except: self._logger.error("Websocket not started")
class WebSocket(util.Threadbase): signals = 'message' def __init__(self, ip, port): global emitter super(WebSocket, self).__init__() emitter = self port = int(port) log.info('starting websocket on %s:%i' % (ip, port)) self.server = SimpleWebSocketServer(ip, port, WebsocketClient) self.start() def terminate(self): log.debug('terminating websocket') super().terminate() self.server.close() @staticmethod def send_message(client, message_dict): _json = json.dumps(message_dict) for _client in clients: if not client or _client.address[0] == client.address[0]: _client.sendMessage(_json) def run(self): while not self.terminated: self.server.serveonce() log.debug('websocket exits')
def run_server(): # checking running processes. # if the backplane is already running, just note that and move on. found_pigpio = False found_scratch = False print('Starting server') for pid in psutil.pids(): p = psutil.Process(pid) if p.name() == "pigpiod": found_pigpio = True print("pigpiod is running") else: continue if not found_pigpio: call(['sudo', 'pigpiod']) print('pigpiod has been started') for pid in psutil.pids(): p = psutil.Process(pid) if p.name() == "scratch2": found_scratch = True print("scratch2 is running") else: continue if not found_scratch: os.system('scratch2&') print('scratch2 has been started') server = SimpleWebSocketServer('', 9001, FelixServer) server.serveforever()
class LogRecordSocketReceiver(SocketServer.ThreadingTCPServer): allow_reuse_address = 1 def __init__(self, host='localhost', port=logging.handlers.DEFAULT_TCP_LOGGING_PORT, handler=LogRecordStreamHandler): SocketServer.ThreadingTCPServer.__init__(self, (host, port), handler) self.abort = 0 self.timeout = 1 self.logname = None self.requstHandle = None self.wsserver = SimpleWebSocketServer('', 8081, WebSocket) def finish_request(self, request, client_address): LogRecordStreamHandler(request, client_address, self, self.wsserver) def cleanup(self): self.wsserver.close() def serve_until_stopped(self): import select abort = 0 while not abort: self.wsserver.servconnman() rd, wr, ex = select.select([self.socket.fileno()], [], [], self.timeout) if rd: self.handle_request() abort = self.abort
def RunCNCServer(): try: server = SimpleWebSocketServer('', 8083, WS_Web) server.serveforever() except KeyboardInterrupt: raise print 'Stopping CNC server'
def run_server(): global server server = SimpleWebSocketServer('', 85, SimpleWSServer, selectInterval=(1000.0 / 30) / 1000) server.serveforever()
def train_loop(**tmgr_params): global train_manager train_manager = TrainManager(**tmgr_params) server = SimpleWebSocketServer(dist_train_config.WS_HTTP_HOST, dist_train_config.WS_HTTP_PORT, ClientConnection) server.serveforever()
class WebSocketServer(Thread): def __init__(self, receiver=None): Thread.__init__(self) self.name = deviceIP self.port = wsPort self.server = SimpleWebSocketServer(self.name, self.port, HandleServer) self._isClosed = False self.setDaemon(True) if receiver is not None: receivers.append(receiver) def start(self, name=deviceName): mDNSinit('mediadisplay', name) logging.info("[Server] starting tcp socket server") super(WebSocketServer, self).start() def run(self): self.server.serveforever() def stop(self): self.server.close() self._isClosed = True def broadcast(self, msg): if isinstance(msg, str): msg = msg.encode('utf-8').decode("utf-8") for client in clients: client.sendMessage(msg) while client.sendq: opcode, payload = client.sendq.popleft() remaining = client._sendBuffer(payload) if remaining is not None: client.sendq.appendleft((opcode, remaining)) break
def __init__(self, host, port, websocketclass, certfile, keyfile, version = ssl.PROTOCOL_TLSv1): SimpleWebSocketServer.__init__(self, host, port, websocketclass) self.cerfile = certfile self.keyfile = keyfile self.version = version
class WebSocketServer(Thread): def __init__(self, name, port): Thread.__init__(self) self.server = SimpleWebSocketServer(deviceIP, wsPort, HandleServer) self._isClosed = False mDNSinit() BLINKER_LOG('websocket Server init') BLINKER_LOG('ws://', deviceIP, ':', wsPort) self.setDaemon(True) def start(self): super(WebSocketServer, self).start() def run(self): self.server.serveforever() def stop(self): self.server.close() self._isClosed = True def broadcast(self, msg): if isinstance(msg, str): msg = unicode(msg, "utf-8") for client in clients: client.sendMessage(msg) while client.sendq: opcode, payload = client.sendq.popleft() remaining = client._sendBuffer(payload) if remaining is not None: client.sendq.appendleft((opcode, remaining)) break
def __init__(self, host, port, websocketclass, selectInterval=0.1): SimpleWebSocketServer.__init__(self, host, port, websocketclass, selectInterval) self._lock_clients = threading.Lock() self._clients = []
def main(argv): if len(argv) == 1 or len(argv) > 3: print("Usage:") #print(f" {argv[0]} dbfile [port]") print(" {} dbfile [port]".format(argv[0])) print(" default port: 8000") return dbfile = argv[1] if len(argv) >= 3: try: port = int(argv[2]) except ValueError: print("Invalid port") return else: port = 8000 print("Connecting to db") WotServer.pool = DBChunkPool(dbfile) WotServer.clients = [] server = SimpleWebSocketServer('', port, WotServer) try: server.serveforever() except KeyboardInterrupt: print("") print("Saving recent changes.") WotServer.pool.save_changes() print("Cleaning up empty chunks from db.") WotServer.pool.remove_empty() print("Stopped.")
def startServer(self): self.server = SimpleWebSocketServer( config['frontService']['host'], config['frontService']['listen'], WsHandler ) self.server.serveforever()
def __init__(self, ip, port): global emitter super(WebSocket, self).__init__() emitter = self port = int(port) log.info('starting websocket on %s:%i' % (ip, port)) self.server = SimpleWebSocketServer(ip, port, WebsocketClient) self.start()
def run_server(): global server server = SimpleWebSocketServer('', 9000, SimpleWSServer, selectInterval=(1000.0 / 60) / 1000) print("run_server") server.serveforever()
def __init__(self, type=BLINKER_DIY_WIFI): Thread.__init__(self) self.name = deviceIP self.port = wsPort self.type = type self.server = SimpleWebSocketServer(self.name, self.port, HandleServer) self._isClosed = False self.setDaemon(True)
class WebSocketServer(threading.Thread): def __init__(self): threading.Thread.__init__(self) self.server = SimpleWebSocketServer("", WEB_SOCKET_PORT_NUMBER, WebSocketHandler) def run(self): log.info("Starting WebSocketServer on port %d" % WEB_SOCKET_PORT_NUMBER) self.server.serveforever()
def runServer(): server = SimpleWebSocketServer("", 8532, VaticServer) def close_sig_handler(signal, frame): server.close() sys.exit() signal.signal(signal.SIGINT, close_sig_handler) server.serveforever()
class NetworkServerSocket(Thread): def __init__(self, lettre): Thread.__init__(self) self.server = SimpleWebSocketServer("", portWebSocket, ClientWebSocket) print "WEBSOCKET listenning ..." def run(self): self.server.serveforever() def broadcastAll(self, jsonMessage): for c in clients: c.sendMessage(json.dumps(jsonMessage, ensure_ascii=False))
def __init__(self, system): from . import skeleton SimpleWebSocketServer.__init__(self, '', 9121, _DlalWebSocket) self.root = _Root( weakref.proxy(system), skeleton, lambda: FREE, ) self.store = {} self.thread = threading.Thread(target=_serve, args=(weakref.ref(self),)) self.thread.daemon = True self.thread.start()
def serve(): ''' class InputServer(WebSocket): tilt = 0 def __init__(self, *args, **kwargs): super(InputServer, self).__init__(*args, **kwargs) self.runloop = None def handleConnected(self): print(self.address, 'connected') self.runloop = input.KinectLoop(self) self.runloop.start() def handleClose(self): self.runloop.kill() print(self.address, 'closed') def handleMessage(self): self.tilt = int(float(self.data)) ''' class InputServer(WebSocket): def __init__(self, *args, **kwargs): super(InputServer, self).__init__(*args, **kwargs) self.kinect = None self.oid = None def handleConnected(self): print self.address, 'connected' self.kinect = KinectFactory.create_kinect() self.oid = uuid.uuid1() self.kinect.add_observer(self.oid, self.send_depth) def handleClose(self): self.kinect.remove_observer(self.oid) print self.address, 'closed' def handleMessage(self): degs = int(float(self.data)) self.kinect.set_tilt(degs) def send_depth(self, depth): self.sendMessage(depth) def close_sig_handler(signum, frame): server.close() KinectFactory.kill() sys.exit() signal.signal(signal.SIGINT, close_sig_handler) server = SimpleWebSocketServer('0.0.0.0', 1337, InputServer) server.serveforever()
def main(): print("Starting WebSocket ...") server = SimpleWebSocketServer('localhost', 8000, DataServer) print("WebSocket Ready!") def close_sig_handler(signal, frame): print("\nClosing WebSocket ...") server.close() print("Bye!") sys.exit() signal.signal(signal.SIGINT, close_sig_handler) server.serveforever()
class FSWebSocketServer(FSWebSocketServerInterface): def __init__(self): super(FSWebSocketServerInterface, self).__init__(group=None) self.port = 8010 self._logger = logging.getLogger(__name__) def run(self): self._logger.info("Websocket Server started on port %s" % self.port) try: self.wsd = SimpleWebSocketServer('', self.port, FSWebSocket) self.wsd.serveforever() except: self._logger.error("Websocket not started")
class FSWebSocketServer(threading.Thread): def __init__(self): threading.Thread.__init__(self) self.port = 8010 self._logger = logging.getLogger(__name__) def run(self): #try: self._logger.info("Websocket Server started on port %s" % self.port) self.wsd = SimpleWebSocketServer('', self.port, FSWebSocket) self.wsd.serveforever() #except: # self._logger.error("WebSocket Crash!")
class socketServerThread(threading.Thread): def __init__(self, host, port, socketQueue): threading.Thread.__init__(self) self.cls = socketServer self.socketQueue = socketQueue self.server = SimpleWebSocketServer(host, port, self.socketQueue, self.cls) def run(self): print "starting Server" self.server.serveforever() def exit(self): print "stoping Server" self.server.close()
class Server(Thread): def run(self): """Starts the thread for the Web Socket Server""" host = "" port = 8008 self.server = SimpleWebSocketServer(host, port, Logger) print("serving") self.server.serveforever() def close_sig_handler(self, signal, frame): """Function called upon Ctrl+C that kills the program""" print("closing") self.server.close()
def run(self): #try: self._logger.info("Websocket Server started on port %s" % self.port) self.wsd = SimpleWebSocketServer('', self.port, FSWebSocket) self.wsd.serveforever() #except: # self._logger.error("WebSocket Crash!")
def run(self): """Starts the thread for the Web Socket Server""" host = "" port = 8008 self.server = SimpleWebSocketServer(host, port, Logger) print("serving") self.server.serveforever()
def __init__ ( self, sktServer): """ Inicializacion de la clase """ self.wshandlerclass = '' self.sktServer = sktServer self.wSktServer = SimpleWebSocketServer('', 9000, SimpleEcho) threading.Thread.__init__ ( self )
def __init__(self, app): SimpleWebSocketServer.__init__(self, '', 8080, SimpleEcho) QObject.__init__(self) th = threading.Thread(target=self.serveforever) th.daemon = True th.start() self.app = app for id, iesmas in app.stendas.iesmai.iteritems(): iesmas.stateChanged.connect(self.onSwitchChanged) for train in app.trains: train.signalChanged.connect(self.onTrainChanged) train.speedChanged.connect(self.onTrainChanged) for ruozas in app.stendas.ruozai: ruozas.stateChanged.connect(self.onRoadChanged)
def __init__(self, host='localhost', port=logging.handlers.DEFAULT_TCP_LOGGING_PORT, handler=LogRecordStreamHandler): SocketServer.ThreadingTCPServer.__init__(self, (host, port), handler) self.abort = 0 self.timeout = 1 self.logname = None self.requstHandle = None self.wsserver = SimpleWebSocketServer('', 8081, WebSocket)
def ws_server(self, port): if port is None: port = self.port host = '' self.wsserver = SimpleWebSocketServer(host, port, QiraServer, selectInterval=0.1) if self.wsserver is not None: idaapi.msg("[%s] Starting WS Server\n" % (self.comment,)) self.wsserver.serveforever() else: idaapi.msg("[%s] Cannot Start WS Server\n" % (self.comment,))
def __init__(self): self.server = SimpleWebSocketServer('0.0.0.0', 8000, self.WebSocket_GUI) signal.signal(signal.SIGINT, self.close_sig_handler) logging.basicConfig(format='%(asctime)s %(message)s', level=logging.DEBUG) thread.start_new_thread(self.thread_main,()) thread.start_new_thread(self.thread_change,()) print "Server open!"
def startServer(): server = SimpleWebSocketServer('', 12345, SimpleEcho) server.serveforever()
class Server_GUI: class WebSocket_GUI(WebSocket): def handleMessage(self): mode = self.data[:1] message = self.data[1:] if (mode == '0'): # PLAY obj_Music.play_pause() elif (mode == '1'): # STOP obj_Music.stop() elif (mode == '2'): # PREVIOUS obj_Playlist.prev() elif (mode == '3'): # NEXT obj_Playlist.button_next() elif (mode == '4'): # VOLUME obj_Music.set_volume(float(message)) elif (mode == '5'): # PLAY INDEX obj_Playlist.play_index(int(message)) elif (mode == '6'): # SEEK obj_Music.seek(float(message)) elif (mode == '7'): # MUTE obj_Music.mute_toggle() elif (mode == '8'): # PLAYLIST CYCLE MODE obj_Playlist.change_mode() def handleConnected(self): print self.address, 'connected' Server_GUI.update_all(self); def handleClose(self): print self.address, 'closed' def __init__(self): self.server = SimpleWebSocketServer('0.0.0.0', 8000, self.WebSocket_GUI) signal.signal(signal.SIGINT, self.close_sig_handler) logging.basicConfig(format='%(asctime)s %(message)s', level=logging.DEBUG) thread.start_new_thread(self.thread_main,()) thread.start_new_thread(self.thread_change,()) print "Server open!" @staticmethod def string_playing(): return '"playing":' + str(obj_Music.get_playing()).lower() + ',' @staticmethod def string_index(): return '"index":' + str(obj_Playlist.index).lower() + ',' @staticmethod def string_files(): string = '"files":[' for title in obj_Playlist.array_titles: string += '"' + title + '",' return string[:-1] + '],' @staticmethod def string_length(): string = '"lengths":[' for length in obj_Playlist.array_length: string += str(length) + ',' return string[:-1] + '],' @staticmethod def string_position(): return '"time":' + str(obj_Music.get_time()) + ',' @staticmethod def string_volume(): return '"volume":' + str(obj_Music.get_volume()) + ',' @staticmethod def string_mute(): return '"mute":' + str(obj_Music.mute).lower() + ',' @staticmethod def string_mode(): return '"mode":' + str(obj_Playlist.mode) + ',' @staticmethod def string_cycles(): string = '"cycles":["' for x in obj_Playlist.array_cycles: string += x + '","' return (string[:-2] + '],').replace("\r", "\n").replace("\n\n", "\n").replace("\n", "\\n") @staticmethod def string_cycles_index(): string = '"cycles_index":[' for x in obj_Playlist.array_cycles_index: string += str(x) + ',' return string[:-1] + '],' def send_to_all(self, string): for conn in self.server.connections.itervalues(): conn.sendMessage(string) def thread_main(self): self.server.serveforever() @staticmethod def update_all(client): client.sendMessage("0{" + Server_GUI.string_cycles_index() + Server_GUI.string_cycles() + Server_GUI.string_mode() + Server_GUI.string_mute() + Server_GUI.string_volume() + Server_GUI.string_position() + Server_GUI.string_length() + Server_GUI.string_index() + Server_GUI.string_files() + Server_GUI.string_playing()[:-1] + "}") def thread_change(self): global running array_prev = [None for x in range(6)] array_current = [ obj_Music.get_playing, (lambda: obj_Playlist.index), obj_Music.get_time, obj_Music.get_volume, (lambda: obj_Music.mute), (lambda: obj_Playlist.mode) ] array_id = [ '2', '3', '5', '6', '7', '8' ] array_function = [ self.string_playing, self.string_index, self.string_position, self.string_volume, self.string_mute, self.string_mode ] while running: for i in range(len(array_current)): if (array_prev[i] != array_current[i]()): self.send_to_all(array_id[i] + "{" + array_function[i]()[:-1] + "}") array_prev[i] = array_current[i]() time.sleep(1.0/15.0) def close_sig_handler(self, signal, frame): self.server.close()
def startWebSocketServer(): socketServer = SimpleWebSocketServer('', websocket_port, TestWebSocket) socketServer.serveforever()
def run(self): print('trying to initialize websocket server...') handler = make_handler_class(self.fcd, self.fcd_write_func) server = SimpleWebSocketServer('', 8926, handler) print('websocket server is running') server.serveforever()
def startServer(): server = SimpleWebSocketServer('', 8080, SockClient) server.serveforever()
import signal, sys, ssl from SimpleWebSocketServer import WebSocket, SimpleWebSocketServer, SimpleSSLWebSocketServer from optparse import OptionParser clients = [] class SimpleChat(WebSocket): def handleMessage(self): words = self.data.split("\r\n") print("\nCount={0}".format(len(words))) for w in words: print ''.join(' {:02x}'.format(x) for x in w) def handleConnected(self): print self.address, 'connected' for client in clients: client.sendMessage(self.address[0] + u' - connected') clients.append(self) def handleClose(self): clients.remove(self) print self.address, 'closed' for client in clients: client.sendMessage(self.address[0] + u' - disconnected') server = SimpleWebSocketServer('', 8000, SimpleChat) server.serveforever()
def handleConnected(self): print self.address, 'connected' def handleClose(self): #car.stop() print self.address, 'closed' if __name__ == '__main__': os.chdir(os.path.dirname(os.path.realpath(__file__)) + '/www') SocketServer.TCPServer.allow_reuse_address = True httpserver = SocketServer.TCPServer( ('', HTTP_PORT), SimpleHTTPRequestHandler) print('car http server port: %d' % HTTP_PORT) httpd = threading.Thread(target=httpserver.serve_forever) httpd.start() websocket = SimpleWebSocketServer('', WEBSOCKET_PORT, CommandWebsocket) def close_sig_handler(signal, frame): #car.quit() httpserver.shutdown() httpd.join() websocket.close() print('quit') sys.exit() signal.signal(signal.SIGINT, close_sig_handler) while True: websocket.serveforever() if grove_sound_sensor.read_sound_sensor_values() >= SoundLimen: if Flag == 0:
def __init__(self, host, port, socketQueue): threading.Thread.__init__(self) self.cls = socketServer self.socketQueue = socketQueue self.server = SimpleWebSocketServer(host, port, self.socketQueue, self.cls)
#!/usr/bin/python import sys from SimpleWebSocketServer import WebSocket, SimpleWebSocketServer class SimpleEcho(WebSocket): def handleMessage(self): if self.data is None: self.data = '' # echo message back to client self.sendMessage(str(self.data)) print str(self.data) sys.stdout.flush() def handleConnected(self): print self.address, 'connected' def handleClose(self): print self.address, 'closed' #START server = SimpleWebSocketServer('', 8000, SimpleEcho) while True: server.servenow()