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 start_server(): """ Start the server in localhost with port 8000 :return: void """ server = SimpleWebSocketServer('', 8000, SimpleEcho) server.serveforever()
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_server(): global server server = SimpleWebSocketServer('', 9000, DetectorHandler, selectInterval=(1000.0 / 15) / 1000) server.serveforever()
def RunCNCServer(): try: server = SimpleWebSocketServer('', 8083, WS_Web) server.serveforever() except KeyboardInterrupt: raise print 'Stopping CNC server'
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()
def RunServer(): try: server = SimpleWebSocketServer('', 8080, WS_Collector) server.serveforever() except KeyboardInterrupt: raise print 'Stopping Client Socket server'
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
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)))
def run_server(): global server server = SimpleWebSocketServer('', 85, SimpleWSServer, selectInterval=(1000.0 / 30) / 1000) 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)
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 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 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()
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 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()
def run_server(): global server server = SimpleWebSocketServer('', 9000, SimpleWSServer, selectInterval=(1000.0 / 60) / 1000) print("run_server") server.serveforever()
def run_server(): global server global stop_thread server = SimpleWebSocketServer('', 9000, SimpleWSServer, selectInterval=(1000.0 / 15) / 1000) server.serveforever()
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 session_wsserver(): host = "localhost" port = WEBSOCK_PORT # cert = "./webclient/server.pem" # key = "./webclient/key.pem" # server = SimpleSSLWebSocketServer(host, port, socket_class, cert, key) server = SimpleWebSocketServer(host=host, port=port, websocketclass=ClientWSocket) print("WSServer ready to serve.") server.serveforever()
def main_websocket(): print('Running websockets server on port: ' + str(WEBSOCKETS_PORT)) thread = threading.Thread(target=generator, args=({ 'value': DEFAULT_COIN_PRICE }, clients)) thread.start() server = SimpleWebSocketServer('', WEBSOCKETS_PORT, FakeData) server.serveforever()
def run_server(): global server # empirically determined by measuring the webcam's output frame_rate = 30.0 server = SimpleWebSocketServer(host='', port=7777, websocketclass=MotionReporterSocket, selectInterval=1.0 / frame_rate) print('server is serving forever') server.serveforever()
class FacadeWsService: def __init__(self): self.server = None def register_command(self, command, name=''): WsHandler.register_command(command, name) def run(self): self.server = SimpleWebSocketServer('', 8000, WsHandler) 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 TMoohIWebsocketServer: def __init__(self, logger, host, port, defaultfilter=[]): global websocketServer if websocketServer != None: raise AlreadyDefinedError("Websocket server already created.") websocketServer = self self.logger = logger self.host = host self.port = port self.defaultfilter = defaultfilter self.killing = False self.clients = [] self.logger.info( MoohLog.eventmessage( "websocket", "WebSocketServer loading up on %s:%s!" % (self.host, self.port))) self.server = SimpleWebSocketServer(self.host, self.port, websocketlogger) self.serverthread = threading.Thread(target=self.runserver) self.serverthread.start() self.neweststatus = {} def quit(self): self.killing = True self.logger.info( MoohLog.eventmessage("websocket", "WebSocketServer shutting down!")) self.server.close() def runserver(self): while not self.killing: try: self.logger.info( MoohLog.eventmessage("websocket", "WebSocketServer starting!")) self.server.serveforever() except (KeyboardInterrupt): self.killing = True except OSError: if not self.killing: # swallow errors when closing self.logger.exception() except Exception: self.logger.exception() finally: self.logger.info( MoohLog.eventmessage("websocket", "WebSocketServer shut down!")) try: self.server.close() except OSError: pass # swallow "An operation was attempted on something that is not a socket" errors
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()
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 WSServer_thandler(lock): global ws_server, ws_port ws_server = SimpleWebSocketServer('', ws_port, SimpleEcho) with (lock): print "Listening at ws connetions at port", ws_port try: ws_server.serveforever() except UnboundLocalError: # prevent display call stack when shutdown thread pass
def run_server(): # checking running processes. # if the backplane is already running, just note that and move on. global bus, address bus = smbus.SMBus(1) address = 0x12 #arbitraire GPIO.setmode(GPIO.BOARD) GPIO.setup(11, GPIO.IN) #bouton rouge GPIO.setup(7, GPIO.IN) #plaque de pression os.system('scratch2&') server = SimpleWebSocketServer('', 9000, SAS_SERVER) server.serveforever()
def run(self): # server = SimpleWebSocketServer('', self.port, ElevWSHandler(self.dispatchCenter, self.logger), selectInterval = 1) server = SimpleWebSocketServer('', self.port, ElevWSHandler, selectInterval=1) self.logger.warn( "------------------------------------------------------") self.logger.warn("WebSocket Server listening on :{}".format(self.port)) self.logger.warn( "------------------------------------------------------") 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))
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))
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")
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 WSServer(Thread): def __init__(self, port): super().__init__() self.port = port self._server = SimpleWebSocketServer('', self.port, WebSocket) def run(self): print("Opening WS server on port %d..." % self.port) self._server.serveforever() def on_frame(self, frame): for c in self._server.connections: self._server.connections[c].sendMessage(frame)
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()
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()
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 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 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!")
def startServer(): server = SimpleWebSocketServer('', 12345, SimpleEcho) server.serveforever()
def init(): server = SimpleWebSocketServer('', PORT, WebsocketServer) server.serveforever()
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: Flag = 1 print 'Turn On' GPIO.output(RELAY, GPIO.HIGH) elif Flag == 1: Flag = 0 print 'Turn Off' GPIO.output(RELAY, GPIO.LOW)
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 start_server(): cls = SimpleServer server = SimpleWebSocketServer("192.168.0.10", 9001, cls) server.serveforever()
def doWebSocket(ip,port): server = SimpleWebSocketServer(ip, port, websocket) 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()
endTime = time.time() print "%s Experiment complete" % endTime saveResults() reset() def handleConnected(self): global numClientsData print self.address, "Connected Data" numClientsData += 1 def handleClose(self): global numClientsData global startTime print self.address, "closed Data" numClientsData -= 1 # deal with disconnect during experiment if startTime is not None: print "---ERROR---\nClient disconnected (data) mid-experiment\n-----------" startTime = None serverControl = SimpleWebSocketServer('', 9000, ControlSocket) serverData = SimpleWebSocketServer('', 9001, DataSocket) # create two threads as follows try: thread.start_new_thread( serverControl.serveforever, () ) except: print "Error: unable to start thread" serverData.serveforever()
def websocketThread(): global x server = SimpleWebSocketServer('', 65432, SimpleEcho) server.serveforever()
def startWebSocketServer(): socketServer = SimpleWebSocketServer('', websocket_port, TestWebSocket) socketServer.serveforever()
def createServer(): # Read config data config = readConfig() # Array clients clients = [] # Array sites sites = [] # Array history parsing history = [] # Coonect to Redis if 'socket' in config['redis']: # Socket connect redisClient = redis.Redis( db = config['redis']['db'], password = config['redis']['password'], unix_socket_path = config['redis']['socket'] ) else: # Host connect redisClient = redis.Redis( db = config['redis']['db'], host = config['redis']['host'], port = config['redis']['port'], password = config['redis']['password'] ) # Read sites in Redis redisSites = redisClient.get('sites') # Read parsing history in Redis redisHistory = redisClient.get('history') # If sites exists if redisSites != None: sites = json.loads(str(redisSites, encoding = 'utf-8')) # If history exists if redisHistory != None: history = json.loads(str(redisHistory, encoding = 'utf-8')) # Convert object to string def objToString(obj): # Create string return str(json.dumps(obj, ensure_ascii = False, sort_keys = True)) # Set processed site def setProcess(): # Count processed site count = 0 length = len(sites) # Calc site in process or success or error for site in sites: if site['status'] != "new": count += 1 # Processed all sites if length > 0: processed = int(count / length * 100) else: processed = 0 # Send redis redisClient.set('processed', processed) # Send message for all clients for client in clients: # Send client message client.sendMessage(objToString({"action": "setProcess", "data": processed})) # Set status for site def setStatus(val, status): # Replace status val['status'] = status # Replace site in sites for index, site in enumerate(sites): if site['url'] == val['url']: sites[index] = val # Set redis sites redisClient.set('sites', objToString(sites)) # Send message for all clients for client in clients: # Send client message client.sendMessage(objToString({"action": "setStatus", "data": val})) # Parsing site def parsing(val): # If status new site if val['status'] == "new": # Set status site setStatus(val, "parsing") # Create browser driver = webdriver.PhantomJS(executable_path=config['phantomjs']) # Set window size driver.set_window_size(int(config['windowWidth']), int(config['widnowHeight'])) # Set url site driver.get(val['url']) # Set processed setProcess() # Get title title = driver.title # Result object obj = False # If site exists if len(title) and val['status'] != "warning": # Get image img = driver.find_elements_by_tag_name("img") if(len(img)): img = img[0].get_attribute("src") else: img = None # Get h1 h1 = driver.find_elements_by_tag_name("h1") if len(h1): h1 = h1[0].text else: h1 = None # Set status site setStatus(val, "success") # Create object obj = {"title": title, "img": img, "h1": h1, "url": val['url']} # Add to history history.append(obj) # Set redis history redisClient.set('history', objToString(history)) # Set status site else: # If not status warning if val['status'] != "warning": setStatus(val, "error") # Send message for all clients for client in clients: # Send client message client.sendMessage(objToString({"action": "parsingResult", "data": obj})) # Close browser driver.close() # Timeout for timer def timeout(): # Get date time currentDateTime = int(time.time() * 1000) # Send message for all clients for client in clients: # Send client message client.sendMessage(objToString({"action": "serverTime", "data": currentDateTime})) # Run parsing site for site in sites: if int(site['date']) <= currentDateTime and site['status'] == "new": q.put(site) # Start timer Timer(30, timeout).start() # Create timer Timer(30, timeout).start() # Max queuing q = queue.Queue(int(config['max_queue'])) # Worker for parsing def worker(): while True: # Get object site for parsing site = q.get() # Parsing start parsing(site) # Close task q.task_done() # Create threads for i in range(int(config['threads'])): t = Thread(target = worker) t.setDaemon(True) t.start() # Set lock q.join() # WebSocket class class WsServer(WebSocket): # Action for download image def action_uploadedImage(self, obj): # Actual url address img = obj['data'] # If new image if img.find(config['urlImg']) < 0: # Get data query image url = urllib.request.urlopen(img) # Get image name name = basename(img) # Add to path config file filename = createPath('images', name) # New url address newImg = config['urlImg'] + "/" + name # Open file for write f = open(filename, 'wb') # Get total length image totalLength = float(url.headers['content-length']) # Download length dwnLength = 0 # Progress length progress = 0 # Read chank tmp = url.read(1024) # Load image while(progress < 100): # Write chank in file f.write(tmp) # Get download length dwnLength += len(tmp) # Get progress download image progress = dwnLength / totalLength * 100 # Send message for all clients for client in clients: # Send client status download image client.sendMessage(objToString({"action": "setProgressImage", "data": {"img": img, "progress": int(progress)}})) # Read chank tmp = url.read(1024) # Close write file f.close() # Send message for all clients for client in clients: # Send client status download image client.sendMessage(objToString({"action": "imageUploaded", "data": {"newUrl": newImg, "oldUrl": img}})) # Replace h in history for index, h in enumerate(history): if h['img'] == img: history[index]['img'] = newImg # Set redis history redisClient.set('history', objToString(history)) # Action for delete site def action_deleteSite(self, obj): # Remove site in array for site in sites: if site['url'] == obj['data']: sites.remove(site) # Remove site in history array for site in history: if site['url'] == obj['data']: history.remove(site) # Set redis sites redisClient.set('sites', objToString(sites)) # Set redis history redisClient.set('history', objToString(history)) # Set processed setProcess() # Send message for all clients for client in clients: client.sendMessage(objToString({"action": "getSites", "data": sites})) client.sendMessage(objToString({"action": "getHistory", "data": history})) # Action for stop parsing all sites def action_stopParsing(self, obj): # Stop parsing all sites for site in sites: # If status is not worked if site["status"] != "success": setStatus(site, "warning") # Action for start parsing all sites def action_startParsing(self, obj): # Start parsing all sites for site in sites: q.put(site) # Action remove all sites def action_clearSites(self, obj): # Remove all sites sites.clear() history.clear() # Del sites in redis redisClient.delete('sites') redisClient.delete('history') redisClient.delete('processed') # Send message for all clients for client in clients: # Send client message client.sendMessage(objToString({"action": "setProcess", "data": 0})) client.sendMessage(objToString({"action": "getSites", "data": sites})) client.sendMessage(objToString({"action": "getHistory", "data": history})) # Action add new site def action_newSite(self, obj): # Get data query val = obj['data'] # Append status val['status'] = "new" # Result check current url flagExists = False flagFilled = True # Check current url in arrey sites for site in sites: if site['url'] == val['url']: flagExists = True else: flagExists = False # If current url is not exist if not flagExists: # If count sites if len(sites) == int(config['threads']): # Search old site for site in sites: # If this old site if site['status'] != "new": flagFilled = False # Remove old site sites.remove(site) # Append new site else: flagFilled = False # If sites is not filled if not flagFilled: # Append new site sites.append(val) # Set redis new site redisClient.set('sites', objToString(sites)) # Send message for all clients for client in clients: obj['data'] = sites obj['action'] = "getSites" # Send client message client.sendMessage(objToString(obj)) # Set processed setProcess() # Send messaage for current client else: del obj['data'] obj['error'] = "Sites filled" # Send client message self.sendMessage(objToString(obj)) # Send messaage for current client else: del obj['data'] obj['error'] = "Site already exists" # Send client message self.sendMessage(objToString(obj)) # Get message from client def handleMessage(self): # Parse json data obj = json.loads(self.data) method_name = 'action_' + str(obj['action']) method = getattr(self, method_name) method(obj) # Connect client def handleConnected(self): clients.append(self) print(self.address, 'connected') # Create object answer obj = {"action": "getSites", "data": sites} # History parsing history = redisClient.get('history') # Processed site processed = redisClient.get('processed') # Set default value history if history == None: history = [] else: history = json.loads(str(history, encoding = 'utf-8')) # Set default value process if processed == None: processed = 0 # Send client message self.sendMessage(objToString(obj)) self.sendMessage(objToString({"action": "getHistory", "data": history})) self.sendMessage(objToString({"action": "setProcess", "data": int(processed)})) self.sendMessage(objToString({"action": "serverTime", "data": int(time.time() * 1000)})) # Disconnect client def handleClose(self): clients.remove(self) print(self.address, 'closed') # Create WebSocket server server = SimpleWebSocketServer(config['host'], int(config['port']), WsServer) # Start server 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()
class qiraplugin_t(idaapi.plugin_t): flags = 0 comment = "QEMU Interactive Runtime Analyser plugin" help = "Visit qira.me for more infos" wanted_name = "QIRA Plugin" wanted_hotkey = "Alt-F5" def __init__(self): self.max_comment_len = 100 self.qira_address = idc.BADADDR self.wsserver = None self.old_addr = None self.port = 3003 self.addr = None self.cmd = None def init(self): ret = self.start() idaapi.msg("[%s] Initialized: Ready to go!\n" % (self.comment,)) return ret def start(self): # if __name__ == '__main__': server = Thread(target=self.ws_server, args=(3003,)) try: server.start() return idaapi.PLUGIN_KEEP except AttributeError: return idaapi.PLUGIN_SKIP 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 ws_send(self, msg): if self.wsserver is not None: self.start() if msg is not None: if msg == 'connected': for conn in list(CLIENTS): conn.sendMessage(msg) time.sleep(1) CLIENTS.append(self) elif msg == 'closed': CLIENTS.remove(self) for conn in list(CLIENTS): conn.sendMessage(msg) time.sleep(1) else: # print "Tuple: %s" % (self.wsserver.connections.items(),) # This one still have errors in both items()/CLIENTS for conn in list(self.wsserver.connections.items()): if conn != self: # debugging if DEBUG: idaapi.msg("[%s] ws_send : %s\n" % (self.wanted_name, msg,)) conn.sendMessage(msg) time.sleep(0.1) else: idaapi.msg("[%s] ws_send : Cannot send null\n" % (self.comment,)) def set_qira_address(self, sea): # Check if there is a BreakPoint and delete is before processing. if (self.qira_address is not None) and ( self.qira_address != idc.BADADDR): qea = idaapi.toEA(0, self.qira_address) if idc.CheckBpt(qea) != -1: idaapi.del_bpt(qea) # Update qira_address and set BreakPont. self.qira_address = sea idaapi.add_bpt(self.qira_address, 0, idaapi.BPT_SOFT) idc.EnableBpt(self.qira_address, False) # debugging if DEBUG: idaapi.msg( "[%s] set_qira_address: 0x%x\n" % (self.wanted_name, self.qira_address,)) def send_names(self): qira_names = idaapi.get_nlist_size() for i in range(0, qira_names): self.cmd = "setname 0x%x %s" % ( idaapi.get_nlist_ea(i), idaapi.get_nlist_name(i)) # debugging if DEBUG: idaapi.msg( "[%s] send_names: EA [0x%x], Name [%s]\n" % (self.wanted_name, idaapi.get_nlist_ea(i), idaapi.get_nlist_name(i),)) self.ws_send(self.cmd) def send_comments(self): start = idaapi.get_segm_base(idaapi.get_first_seg()) cur = start while True: if cur != idc.BADADDR: cmt = idaapi.get_cmt(cur, 0) if (cmt is not None) and (cmt != idc.BADADDR): self.cmd = "setcmt 0x%x %s" % (cur, cmt) # debugging if DEBUG: idaapi.msg( "[%s] send_comments: EA [0x%x], Comment [%s]\n" % (self.wanted_name, cur, cmt,)) self.ws_send(self.cmd) else: break cur = idc.NextAddr(cur) return True def update_address(self, addr_type, addr): if (addr_type is not None) and (addr is not None): self.cmd = "set%s 0x%x" % (addr_type, addr) self.ws_send(self.cmd) else: idaapi.msg( "[%s] Cannot update address: 'None'\n" % (self.wanted_name,)) def jump_to(self, qea): if qea is not None: if (qea != self.qira_address) and (qea != idc.BADADDR): self.set_qira_address(qea) idaapi.jumpto(self.qira_address, -1, 0x0001) else: idaapi.jumpto(self.qira_address, -1, 0x0001) # debugging if DEBUG: idaapi.msg( "[%s] jump_to: qira_address [0x%x], ea [0x%x]\n" % (self.wanted_name, self.qira_address, qea,)) else: idaapi.msg("[%s] Cannot jump_to: None\n") def run(self, arg): idaapi.msg("[%s] Syncing with WS Server\n" % (self.wanted_name,)) self.addr = idaapi.get_screen_ea() if self.old_addr != self.addr: # check against idc.BADADDR and None before going if (self.addr is not None) and (self.addr != idc.BADADDR): # Code Address if idaapi.isCode(idaapi.getFlags(self.addr)): # don't set the address if it's already the qira_address if self.addr != self.qira_address: # debugging if DEBUG: idaapi.msg( "[%s] Qira Address 0x%x \n" % (self.wanted_name, self.addr,)) # Instruction Address self.set_qira_address(self.addr) self.update_address("iaddr", self.addr) # Data Address elif idaapi.isData(idaapi.getFlags(self.addr)): self.update_address("daddr", self.addr) # Tail Address elif idaapi.isTail(idaapi.getFlags(self.addr)): self.update_address("taddr", self.addr) # Unknown Address elif idaapi.isUnknown(idaapi.getFlags(self.addr)): self.update_address("uaddr", self.addr) # Head Address elif idaapi.isHead(idaapi.getFlags(self.addr)): self.update_address("haddr", self.addr) # Flow Address elif idaapi.isFlow(idaapi.getFlags(self.addr)): self.update_address("faddr", self.addr) # Var Address elif idaapi.isVar(idaapi.getFlags(self.addr)): self.update_address("vaddr", self.addr) # Data Address else: self.update_address("daddr", self.addr) self.old_addr = self.addr def stop(self): if self.wsserver is not None: self.wsserver.close() self.wsserver = None else: idaapi.msg("[%s] is not running.\n" % (self.wanted_name,)) def term(self): idaapi.msg("[%s] Terminating tasks...\n" % (self.wanted_name,)) try: self.stop() except AttributeError: pass idaapi.msg("[%s] Uninstalled!\n" % (self.wanted_name,))
def run(serverType, port=5167): print "Starting server (port %d)" % port server = SimpleWebSocketServer('', port, serverType) server.serveforever()
def startServer(): server = SimpleWebSocketServer('', 8080, SockClient) server.serveforever()