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()
