class Websocket_Server():
def __init__(self, host, port):
self.server = WebsocketServer(port, host=host, loglevel=logging.DEBUG)
# クライアント接続時に呼ばれる関数
def new_client(self, client, server):
print("new client connected and was given id {}".format(client['id']))
# 全クライアントにメッセージを送信
self.server.send_message_to_all("hey all, a new client has joined us")
# クライアント切断時に呼ばれる関数
def client_left(self, client, server):
print("client({}) disconnected".format(client['id']))
# クライアントからメッセージを受信したときに呼ばれる関数
def message_received(self, client, server, message):
print(message + "これはテストです")
print("client({}) said: {}".format(client['id'], message + "これはテスト"))
file = open('InputText.txt', 'w')
file.write(message)
print(message + "これはテストです")
# 全クライアントにメッセージを送信
self.server.send_message_to_all(message)
# サーバーを起動する
def run(self):
# クライアント接続時のコールバック関数にself.new_client関数をセット
self.server.set_fn_new_client(self.new_client)
# クライアント切断時のコールバック関数にself.client_left関数をセット
self.server.set_fn_client_left(self.client_left)
# メッセージ受信時のコールバック関数にself.message_received関数をセット
self.server.set_fn_message_received(self.message_received)
self.server.run_forever()
def __init__(self, conf):
global server
super(WSService, self).__init__()
self.conf = conf
server = WebsocketServer(WSPORT, host='0.0.0.0')
server.set_fn_new_client(newClient)
server.set_fn_client_left(leftClient)
def run_server():
server = WebsocketServer(9288, host="0.0.0.0")
server.set_fn_new_client(on_join)
server.set_fn_client_left(on_leave)
server.set_fn_message_received(on_message)
print("Bridge server ready.")
server.run_forever()
def startWebSocketServer():
PORT = 8888
server = WebsocketServer(PORT)
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.set_fn_message_received(message_received)
server.run_forever()
def startup_ws_server(self):
WSPORT = 9001
server = WebsocketServer(port=WSPORT, host="0.0.0.0")
server.set_fn_new_client(self.new_client)
server.set_fn_client_left(self.client_left)
server.set_fn_message_received(self.message_received)
server.run_forever()
def main():
server = WebsocketServer(1236, '0.0.0.0')
server.set_fn_new_client(new_client_handler)
server.set_fn_client_left(client_left_handler)
server.set_fn_message_received(message_received_handler)
server.run_forever()
def main():
r_q = Queue()
ws_q = Queue()
server = WebsocketServer(8998, host='0.0.0.0') #, loglevel=logging.INFO)
server.set_fn_new_client(new_client)
server.set_fn_message_received(msg_received_ws(ws_q))
t = Thread(target=server.run_forever)
t.daemon = True
t.start()
r = redis.Redis(host='octopi.labs', port=6379, db=0)
p = r.pubsub()
p.subscribe(replies=handle_replies_redis(r_q))
while True:
if not ws_q.empty():
comm, data = ws_q.get()
print('from ws', comm, data)
if type(data) is list:
c = Command(comm, None, data)
else:
c = Command(comm, None, [data])
print(c, c.command)
r.publish('commands', bytes(c.command))
if not r_q.empty():
data = r_q.get()
print('from redis', data)
server.send_message_to_all(data)
p.get_message()
time.sleep(0.1)
class IrWsServer():
DEF_PORT = 9001
def __init__(self, port=DEF_PORT, host="0.0.0.0",
svrhost='localhost', svrport=51001,
debug=False):
self._dbg = debug
self._log = get_logger(__class__.__name__, self._dbg)
self._log.debug('host=%s, port=%s', host, port)
self._log.debug('svrhost=%s, svrport=%s', svrhost, svrport)
self.irsvr = IrSendCmdClient(svrhost, svrport, debug=self._dbg)
self.server = WebsocketServer(port, host=host)
def new_client(self, client, server):
self._log.debug('client=%s', client)
def client_left(self, client, server):
self._log.debug('client=%s', client)
self.irsvr.end()
def message_received(self, client, server, msg):
self._log.debug('client=%s, msg=%s', client, msg)
self.msg = msg.encode('utf-8')
self._log.info('msg=%s.', msg)
self.irsvr.send_recv(msg.split())
def run(self):
self._log.debug('')
self.server.set_fn_new_client(self.new_client)
self.server.set_fn_client_left(self.client_left)
self.server.set_fn_message_received(self.message_received)
self.server.run_forever()
class Websocket_Server():
def __init__(self, host, port):
self.client_id_username_map = {}
self.server = WebsocketServer(port, host = host, loglevel = logging.DEBUG)
def new_client(self, client, server):
print("new client connected and was given id {}".format(client['id']))
self.server.send_message(client,"make connection : success!!")
def client_left(self, client, server):
print("client({}) disconnected".format(client['id']))
def message_received(self, client, server, message):
if message.startswith("init:username:"******"init:username:"******"")
print(username)
self.client_id_username_map[client["id"]] = username
self.server.send_message_to_all(message)
else:
self.server.send_message_to_all(message)
def run(self):
self.server.set_fn_new_client(self.new_client)
self.server.set_fn_client_left(self.client_left)
self.server.set_fn_message_received(self.message_received)
self.server.run_forever()
def start_server(port):
server = WebsocketServer(port)
ws_log.debug("Server listening on port: %d" % port)
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.set_fn_message_received(message_received)
server.run_forever()
class WsSever:
def __init__(self, host,port,connectCall,leftCall,messageCall):
# day = time.strftime("%Y-%m-%d", time.localtime())
# self.logger = logging.getLogger(__name__)
# self.logger.setLevel(level = logging.DEBUG)
# handler = logging.FileHandler("{}-{}.txt".format(day,port),encoding="utf-8")
# handler.setLevel(logging.DEBUG)
# formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# handler.setFormatter(formatter)
# self.logger.addHandler(handler)
self.Server = WebsocketServer(host = host,port = port,loglevel=logging.INFO)
self.Server.set_fn_new_client(connectCall)
self.Server.set_fn_client_left(leftCall)
self.Server.set_fn_message_received(messageCall)
def startRun(self):
self.Server.run_forever()
def GetServer(self):
return self.Server
def loginfo(self,str):
# self.logger.info(str)
pass
class BaseWebSocketServer:
"""
WebSocketServerのベースクラス
"""
def __init__(self, IP, PORT):
# 接続
self.server = WebsocketServer(PORT, host=IP)
# 設定
self.server.set_fn_new_client(self._when_new_client)
self.server.set_fn_message_received(self._when_message_received)
# スレッド
self.thread = None
def _when_new_client(self, client, server):
"""
新規のclientが接続してきたときの処理
"""
print("{}:: New client connected.".format(self.__class__.__name__))
def _when_message_received(self, client, server, message):
"""
あるclientからmessageを受信したとき
"""
print("{}:: Received message \"{}\".".format(self.__class__.__name__, message))
def run_forever(self):
"""
サーバー起動
"""
print("{}:: Run forever.".format(self.__class__.__name__))
self.thread = Thread(target=self.server.run_forever)
self.thread.setDaemon(True)
self.thread.start()
def start_server(port):
server = WebsocketServer(port)
ws_log.debug("Server listening on port: %d" % port)
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.set_fn_message_received(message_received)
server.run_forever()
def run_server_classic(ip_address, port):
"""run_server"""
server = WebsocketServer(port, host=ip_address)
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_diconnected)
server.set_fn_message_received(std_message_received)
server.run_forever()
def run(self):
server = WebsocketServer(self.port, host="0.0.0.0")
server.set_fn_new_client(self.new_client)
server.set_fn_client_left(self.client_left)
server.set_fn_message_received(self.message_received)
self.servers.append(server)
server.run_forever()
def start_ws_server(args):
"""
"""
server = WebsocketServer(args.port, host=args.host)
def send(msg, client):
try:
message = json.dumps(msg)
server.send_message(client, message)
except:
logger.exception(('ws send error'))
def broadcast(msg):
try:
server.send_message_to_all(msg)
except:
#logger.exception(('ws send error'))
pass
def new_client(client, server):
logger.info(('connected', client['id']))
message = json.dumps({'message': 'connected', 'client': client['id']})
broadcast(message)
def client_left(client, server):
logger.info(('disconnected', client['id']))
message = json.dumps({
'message': 'disconnected',
'client': client['id']
})
broadcast(message)
def message_received(client, server, message):
logger.info(('message_received', len(message), message[:100]))
try:
msg = json.loads(message)
new_message = json.dumps({
'message': 'message',
'client': client['id'],
'content': msg
})
broadcast(new_message)
except:
logger.exception(('ws message handler error'))
resp_message = json.dumps({
'message': 'error',
'description': 'server error'
})
send(resp_message, client)
return
resp_message = json.dumps({'message': 'result', 'description': 'ok'})
send(resp_message, client)
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.set_fn_message_received(message_received)
server.run_forever()
class GUI:
# Initialization function
# The actual initialization
def __init__(self, host, console):
t = threading.Thread(target=self.run_server)
self.payload = {'canvas': None, 'image': '', 'shape': []}
self.server = None
self.client = None
self.host = host
self.payload_lock = threading.Lock()
# Take the console object to set the same websocket and client
self.console = console
t.start()
# Explicit initialization function
# Class method, so user can call it without instantiation
@classmethod
def initGUI(self):
# self.payload = {'image': '', 'shape': []}
pass
# Function for student to call
# Encodes the image as a JSON string and sends through the WS
def showImage(self, image):
shape = image.shape
frame = cv2.imencode('.JPEG', image)[1]
encoded_image = base64.b64encode(frame)
self.payload_lock.acquire()
self.payload['image'] = encoded_image.decode('utf-8')
self.payload['shape'] = shape
self.payload_lock.release()
# Function to get the client
# Called when a new client is received
def get_client(self, client, server):
self.client = client
self.console.set_websocket(self.server, self.client)
# Update the gui
def update_gui(self):
self.payload_lock.acquire()
message = "#img" + json.dumps(self.payload)
self.payload_lock.release()
try:
self.server.send_message(self.client, message)
except:
pass
# Activate the server
def run_server(self):
self.server = WebsocketServer(port=2303, host=self.host)
self.server.set_fn_new_client(self.get_client)
self.server.set_fn_message_received(self.console.prompt)
self.server.run_forever()
def main(argv):
host = ""
port = ""
try:
opts, args = getopt.getopt(argv, "hs:p:", ["host=", "port="])
except getopt.GetoptError:
print("server.py -s <host> -p <port>")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print("server.py -s <host> -p <port>")
sys.exit()
elif opt in ("-s", "--host"):
host = arg
elif opt in ("-p", "--port"):
port = arg
if host == "" or port == "":
print("server.py -s <host> -p <port>")
sys.exit(2)
server = WebsocketServer(host=host, port=int(port))
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.set_fn_message_received(message_received)
server.run_forever()
class RpiServerWS():
"""docstring for WebsocketServer"""
server = None
def __init__(self, parent):
self.parent = parent
self.server = WebsocketServer(8050,
host=hosthome,
loglevel=logging.INFO)
self.server.set_fn_new_client(self.new_client)
self.server.set_fn_message_received(self.message_received)
self.server.set_fn_client_left(self.client_left)
print('Websocket Server started, waiting for clients to connect')
self.server.run_forever()
def new_client(self, client, server):
#print('Connected by ', client)
self.parent.clientSockets.append(client)
greeting = '{"functionName":"connected", "args":{} }'
self.server.send_message(client, greeting)
def message_received(self, client, server, message):
item = (message, self.server, client)
#print('putting ', item, 'in the queue')
self.parent.callbackQueue.put(item)
#self.server.send_message(client, 'WS: Message put in queue')
def client_left(self, client, server):
self.parent.clientSockets.remove(client)
def __init__(self):
self.client = ''
self.server = ''
# Called for every client connecting (after handshake)
def new_client(client, server):
print("New client connected and was given id %d" % client['id'])
self.client = client
server.send_message_to_all("Hey all, a new client has joined us")
# Called for every client disconnecting
def client_left(client, server):
print("Client(%d) disconnected" % client['id'])
# Called when a client sends a message
def message_received(client, server, message):
if len(message) > 200:
message = message[:200] + '..'
print("Client(%d) said: %s" % (client['id'], message))
PORT = 9001
server = WebsocketServer(PORT)
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.set_fn_message_received(message_received)
server.run_forever()
self.server = server
make_template()
os.system('open index.html')
class WebSocketServer:
if DebugLog.Debug:
ip = '127.0.0.1'
local_ip = '127.0.0.1'
else:
ip = '188.134.82.95'
local_ip = '192.168.0.100'
port = 11001
def __init__(self):
self.server = WebsocketServer(WebSocketServer.port,
WebSocketServer.local_ip)
self.server.set_fn_new_client(self.new_client)
self.server.set_fn_client_left(self.client_left)
self.server.set_fn_message_received(self.message_received)
self.clients: Dict[int, VisualGithubClient] = {}
def run(self):
self.server.run_forever()
# Called for every client connecting (after handshake)
def new_client(self, client, _):
DebugLog.connected(f'New client connected '
f'and was given id {client["id"]}')
new_client = VisualGithubClient(client['id'], client['handler'])
client['client'] = new_client
self.clients[new_client.id] = new_client
# Called for every client disconnecting
def client_left(self, client, _):
if client is None:
return
DebugLog.client_left(f'Client {client["id"]} disconnected')
try:
client['client'].left(self)
except KeyError:
DebugLog.error(f'Key error possibly double deleting '
f'in client left id = {client["id"]}')
except ValueError:
DebugLog.error(f'Value error possibly double deleting '
f'in client left id = {client["id"]}')
# Called when a client sends a message
def message_received(self, client, _, message):
if client is None:
return
message = message.encode('ISO-8859-1').decode()
client['client'].receive(self, message, client)
def broadcast(self, message: dict):
for client in list(self.clients.values()):
if client.pass_filters(message):
client.send(message)
def start_server():
server = WebsocketServer(10001, host='0.0.0.0')
server.set_fn_new_client(accept_connection)
server.set_fn_message_received(handle_message)
server.set_fn_client_left(remove_connection)
thread = threading.Thread(target=server.run_forever)
thread.start()
class WsServer(threading.Thread):
def __init__(self, conf=None, controller=None):
threading.Thread.__init__(self)
if conf == None:
self.conf = dict(port=4000, host='127.0.0.1')
else:
self.conf = conf
self.server = WebsocketServer(self.conf["port"],
host=self.conf["host"])
self.server.set_fn_new_client(self.new_client)
self.server.set_fn_client_left(self.client_left)
self.server.set_fn_message_received(self.message_received)
def run(self):
self.server.run_forever()
def new_client(client, server):
logging.info("WS: New Client")
self.server.send_message_to_all("Hey all, a new client has joined us")
def client_left(client, server):
logging.info("WS: Client left")
self.server.send_message_to_all("Hey all, a new client has joined us")
def message_received(client, server, message):
logging.info("WS: New message " + message)
def disconnect(self):
logging.info("WS:Disconnect")
self.server.shutdown()
def start(self):
al.log('Launch a server on port %d...' % self.port)
server = WebsocketServer(self.port, host=self.host)
server.set_fn_new_client(self.newClient)
server.set_fn_client_left(self.clientLeft)
server.set_fn_message_received(self.msgReceived)
server.run_forever()
def _track_logs(test_name, project_path):
server = WebsocketServer(WS_PORT, host='0.0.0.0')
def new_client(cli, svr):
opened_files = {}
try:
while True:
for root, dirs, files in os.walk(project_path):
for f in files:
if f.endswith('_color') and test_name in root:
if not opened_files.get(f):
opened_files[f] = open(join(root, f))
log_lines = [
convert(l)
for l in opened_files[f].readlines()
]
if log_lines != []:
node = splitext(f)[0].split('_')
node_num = node[-1] if node[-1].isdigit(
) else None
node_type = node[:-1] if node[-1].isdigit(
) else node
svr.send_message_to_all(
json.dumps({
'node_type': '_'.join(node_type),
'node_num': node_num,
'log_lines': log_lines
}))
time.sleep(0.01)
except:
for f in opened_files:
opened_files[f].close()
server.set_fn_new_client(new_client)
server.run_forever()
def start_websocket():
PORT=8020
global server
server = WebsocketServer(PORT)
print('listenin websoket port:8020')
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.run_forever()
def start_server_task():
ws = WebsocketServer(api_server_port)
ws.set_fn_new_client(WebSoketAPIServerHandler.on_connected)
ws.set_fn_client_left(WebSoketAPIServerHandler.on_disconnected)
ws.set_fn_message_received(WebSoketAPIServerHandler.on_message)
WebSoketAPIServerHandler.api_server = ws
ws.run_forever()
def start(self):
logger.info("Starting WebSocket INDI server on %s:%s", self.address,
self.port)
server = WebsocketServer(self.port, host=self.address)
server.set_fn_new_client(self._new_client)
server.set_fn_client_left(self._client_left)
server.set_fn_message_received(self._message_received)
server.run_forever()
def run_server(i_ip_address, i_port, i_message_received, i_new_client,
i_client_diconnected):
"""run_server"""
server = WebsocketServer(i_port, host=i_ip_address)
server.set_fn_new_client(i_new_client)
server.set_fn_client_left(i_client_diconnected)
server.set_fn_message_received(i_message_received)
server.run_forever()
def __init__(self, port, fn_new_client, fn_client_left,
fn_message_received):
threading.Thread.__init__(self)
server = WebsocketServer(host='0.0.0.0', port=port)
server.set_fn_new_client(fn_new_client)
server.set_fn_client_left(fn_client_left)
server.set_fn_message_received(fn_message_received)
self.server = server
class StatusManager(object):
def __init__(self):
self._now = time.time()
self._datetime_now = datetime.now()
self._acc = Accelerometer()
self._motion = [0, 0]
self._server = WebsocketServer(host='127.0.0.1', port=6700)
self._server.set_fn_new_client(self.new_client)
self._server.set_fn_client_left(self.client_left)
self._server.set_fn_message_received(self.message_received)
# self._sensors = SerialSensorManager()
# self._sensors.search(["GY-521", "Papirs-01"])
def new_client(self, client, server):
print('New client {}:{} has joined.'.format(client['address'][0],
client['address'][1]))
def client_left(self, client, server):
print('Client {}:{} has left.'.format(client['address'][0],
client['address'][1]))
def message_received(self, client, server, message):
# print(message)
data = message.split(",")
if data[0] == 'motion':
motion_sensor_id = int(data[2])
status = data[3]
self._motion[motion_sensor_id] = 0 if status == 'stop' else 1
elif data[0] == 'acc':
self._acc.acc_x = float(data[3])
self._acc.acc_y = float(data[2])
self._acc.acc_z = float(data[4])
def update(self):
ws_thread = threading.Thread(target=self._server.run_forever)
ws_thread.daemon = True
ws_thread.start()
while True:
self._now = time.time()
self._datetime_now = datetime.now()
# TODO 天気情報
# TODO 強制実行アクション取得
# TODO ハッシュタグ取得
time.sleep(.1)
def get_data(self):
return {
"now": self._now,
"datetime": self._datetime_now,
"accelerometer": self._acc,
"motions": self._motion
}
def __init__(self):
self.client2slide = {}
self.slide2clients = {}
self.slide2presentationdata = {}
server = WebsocketServer(port=12345, host='127.0.0.1')
server.set_fn_new_client(self.new_client)
server.set_fn_client_left(self.client_left)
server.set_fn_message_received(self.message_received)
self.server = server
def WsLapCounterServerLaunch(): global wsLapCounterServer while 1: try: wsLapCounterServer = WebsocketServer( port=PORT_NUMBER + 2, host='' ) wsLapCounterServer.set_fn_new_client( lap_counter_new_client ) wsLapCounterServer.run_forever() except Exception as e: wsLapCounterServer = None time.sleep( 5 )
def listen(courier, host, port):
server = WebsocketServer(port)
server.set_fn_new_client(notify_client)
uthread = threading.Thread(target=updater, args=(courier, server))
tthread = threading.Thread(target=v_timer, args=(server,))
uthread.daemon = True
tthread.daemon = True
uthread.start()
tthread.start()
print("Starting WebSocket Server...")
server.run_forever()
def start_server():
"""Start both the Game Manager and the Web Server"""
# Prepare the web server with above functions
logger.info("Init Web Socket Server")
server = WebsocketServer(PORT, HOST)
server.set_fn_new_client(onconnect)
server.set_fn_client_left(ondisconnect)
server.set_fn_message_received(onmessage)
# Create a game manager
logger.info("Init Game Manager")
global manager
manager = Manager(server)
# Start the web server
logger.info("Starting Server")
server.run_forever()
manager.safe_stop()
def doLogin(message, server):
global unModel
# obj = ast.literal_eval(message) //pour compatibilité avec Android
# print message //aucune idée pourquoi mais il faut mettre cela pour que ça fonctionne avec Android!!?
obj = json.loads(message)
objLogin = obj["object"]
unModel.nom = objLogin["name"]
unModel.prenom = objLogin["firstname"]
#Ack client
dict={}
dict["messageType"]="ackLogin"
objJson = json.dumps(dict)
server.send_message(wsIHM, objJson)
if __name__ == "__main__":
# Fixation du point de lecture de fichier
os.chdir('/')#Obligation de donner le chemin du fichier avec le QPython
# routage des messages receptionnes
switch={
"login":doLogin
}
# Initialisation des models
unModel = UnModel()
# Connexion au client web
server = WebsocketServer(9999)
server.set_fn_new_client(new_client) #définition de la fonction pour l arrivé d un nouveau client
server.set_fn_message_received(rxMessage) #Définition de la fonction pour l arrivé d un nouveau message
server.set_fn_client_left(clientLeft) #définition de la fonction pour la déconnexion d'un client
server.run_forever()
#!/usr/bin/env python
from websocket_server import WebsocketServer
import hashlib
import os
def nuevo_cliente(client, server):
print("Cliente (%s) nuevo" % client['address'][0])
def mensaje_recibido(client, server, mensaje):
audio = hashlib.md5(client['address'][0]).hexdigest()
file = open("podcast/"+audio, "ab")
file.write(mensaje)
file.close()
def desconectado(client, server):
audio = hashlib.md5(client['address'][0]).hexdigest()
os.remove("podcast/"+audio)
print("Cliente (%s) desconectado" % client['address'][0])
PORT=9000
server = WebsocketServer(PORT,"192.168.1.2")
server.set_fn_new_client(nuevo_cliente)
server.set_fn_client_left(desconectado)
server.set_fn_message_received(mensaje_recibido)
server.run_forever()
class websocketserver:
cameras = {}
tags = {}
users = {}
calibration = {}
port=8001
# Called for every client connecting (after handshake)
def new_client_connection(self, client, server):
print("New client connected and was given id %d" % client['id'] +" and address " + str(client['address']))
server.send_message(client, "Client connected succesfully")
# Called for every client disconnecting
def client_left(self, client, server):
print("Client(%d) disconnected" % client['id'])
# Remove client from its list
# TODO better delete (remove points etc...)
if(str(client['address']) in self.cameras):
print "Camera disconnected : " + str(client['address'])
del self.cameras[str(client['address'])]
elif(str(client['address']) in self.users):
# Remove Tag assignement because User left
print "User disconnected : " + str(client['address'])
self.users[str(client['address'])].removeTag()
del self.users[str(client['address'])]
elif(str(client['address']) in self.calibration):
print "Calibration disconnected : " + str(client['address'])
del self.calibration[str(client['address'])]
elif(str(client['address']) in self.tags):
print "Tag disconnected : " + str(client['address'])
# Remove Tag assignement to User because Tag left AND kill 3D point
for key in self.users:
if self.users[key].tag == self.tags[str(client['address'])]:
self.users[key].removeTag()
del self.tags[str(client['address'])]
# Called when a client sends a message
def message_received(self, client, server, message):
self.parseMessage(client, message)
def __init__(self, host='127.0.0.1'):
self.server = WebsocketServer(self.port, host)
self.server.set_fn_new_client(self.new_client_connection)
self.server.set_fn_client_left(self.client_left)
self.server.set_fn_message_received(self.message_received)
self.server.run_forever()
def parseMessage(self, client, message):
"""
Check who is the message from to redirect it to User / Tag / Camera / Calibration
or create a new instance of User / Tag / Camera / Calibration
:param client:
:param message:
:return:
"""
if self.cameras.has_key(str(client['address'])):
#print "Message from Camera"
self.cameras[str(client['address'])].push(message)
# Update all cameras counters
#Todo: Change this method for checking all cameras for lost point (auto check inside point2D ?)
for key in self.cameras.keys():
self.cameras[key].update()
elif self.users.has_key(str(client['address'])):
print "Message from User"
elif self.tags.has_key(str(client['address'])):
print "Message from Tag"
elif self.calibration.has_key(str(client['address'])):
self.calibration[str(client['address'])].push(message)
print "Message from Calibration"
# This message is coming from an unknown client
else:
if message.split("-")[0] == "camera":
self.cameras[str(client['address'])] = Camera(client, message.split("-")[1])
# Add Observers linking every user to every camera's update
for key in self.users:
if isinstance(self.users[key], User):
self.cameras[str(client['address'])].new2DPointNotifier.addObserver(self.users[key].position.newPoint2DObserver)
self.cameras[str(client['address'])].point2DdeletedNotifier.addObserver(self.users[key].position.point2DDeletedObserver)
elif message.split("-")[0] == "tag":
self.tags[str(client['address'])] = Tag(self.server, client, message.split("-")[1])
for key in self.users:
if isinstance(self.users[key], User):
# Assign a Tag to User with no Tag
if self.users[key].tag == None:
self.users[key].setTag(self.tags[str(client['address'])])
elif message.split("-")[0] == "user":
user = User(self.server, client, message.split("-")[1])
self.users[str(client['address'])] = user
# Add Observers linking every user to every camera's update
for key in self.cameras:
if isinstance(self.cameras[key], Camera):
self.cameras[key].new2DPointNotifier.addObserver(user.position.newPoint2DObserver)
self.cameras[key].point2DdeletedNotifier.addObserver(user.position.point2DDeletedObserver)
for key in self.tags:
if isinstance(self.tags[key], Tag):
# Assign a Tag to new User
if self.tags[key].isAssigned() == False:
user.setTag(self.tags[key])
elif message == "calibration":
if(len(self.tags)>0):
self.calibration[str(client['address'])] = Calibration(self.server, client, self.cameras, self.tags.values()[0])
else:
self.server.send_message(client, "Please connect a Tag first, and start Calibration again.")
class WebsocketPublisher(object):
"""
Publish cluster state as JSON over a websocket.
Only sends CS state, and information on who is building on who.
This is enough information to draw a graph of the cluster.
Explicitly, does not send information on individual jobs.
"""
MIN_SEND_GAP_S = 0.1
"""Minimum gap in seconds between sending messages to connected clients."""
def __init__(self, host="0.0.0.0", port=9999):
self.frame = ""
self.nodes = ""
self.links = ""
self.last_sent_frame = ""
self.last_sent_nodes = ""
self.last_sent_links = ""
self.next_time_to_send = 0
self.lock = threading.RLock()
self.timer = None
self.ws_server = WebsocketServer(port, host)
def send_to_client(client, server):
with self.lock:
server.send_message(client, self.build_graph(True))
self.ws_server.set_fn_new_client(send_to_client)
t = threading.Thread(target=self.ws_server.run_forever)
t.daemon = True
t.start()
def build_nodes(self, mon):
"""Builds a JSON representation of the CS nodes in the cluster."""
nodes = []
for cs in mon.cs.values():
nodes.append({"id": cs.id,
"name": cs.name,
"ip": cs.ip,
"load": (100*cs.active_jobs())/cs.maxjobs})
return json.dumps(nodes)
def build_links(self, mon):
"""
Builds a JSON representation of the links in the cluster.
There is one link A->B if A has one or more jobs building on B.
"""
links = []
for job in mon.jobs.values():
if job.host_id not in mon.cs or job.client_id not in mon.cs:
continue
c, s = mon.cs[job.client_id], mon.cs[job.host_id]
# Don't double-add links.
add = True
for l in links:
if l["source"] == c.id and l["target"] == s.id:
add = False
if add:
links.append({"source": c.id, "target": s.id, "value": 10})
return json.dumps(links)
def build_graph(self, full=False):
"""Builds a full JSON representation of a graph of the cluster."""
frame = '{"timestamp": 0, "index": 0'
if full or self.nodes != self.last_sent_nodes:
frame += ', "nodes": ' + self.nodes
if full or self.links != self.last_sent_links:
frame += ', "links": ' + self.links
frame += '}'
return frame
def publish(self, mon):
"""
Called by the Monitor to indicate new cluster state.
Update our internal state, and notify clients if appropriate.
"""
with self.lock:
self.nodes = self.build_nodes(mon)
self.links = self.build_links(mon)
self.frame = self.build_graph()
self.notify()
def notify(self):
"""Send updates to clients if necessary."""
now = time.time()
with self.lock:
if self.frame == self.last_sent_frame:
# Frame hasn't changed, don't resend.
return
elif (now >= self.next_time_to_send and self.timer is None):
# We can send.
self.broadcast()
elif self.timer is None:
# We must reschedule.
self.timer = threading.Timer(self.next_time_to_send - now,
self.broadcast)
self.timer.start()
def broadcast(self):
"""Actually broadcast cluster state to all connected clients."""
with self.lock:
if self.timer is not None:
self.timer.cancel()
self.timer = None
self.next_time_to_send = time.time() + self.MIN_SEND_GAP_S
self.last_sent_frame = self.frame
self.last_sent_nodes = self.nodes
self.last_sent_links = self.links
self.ws_server.send_message_to_all(self.frame)
carConnectionSem.release()
print('Client disconnected')
# Receive data from client and put it in the input queue
def communicateWithClient(client, server, msg):
print('recv: ' + msg)
carConnectionSem.acquire()
if (carIsConnected and msg in validInput):
inputSem.acquire()
inputQueue.append(msg)
inputSem.release()
carConnectionSem.release()
# Websocket to talk to client
websocket = WebsocketServer(clientPort)
websocket.set_fn_new_client(onClientConnection)
websocket.set_fn_client_left(onClientDisconnection)
websocket.set_fn_message_received(communicateWithClient)
# Handle car communications
def communicateWithCar():
while(runServer):
# Wait for car to connect
c, addr = carSock.accept()
isConnected = True
global carIsConnected
carConnectionSem.acquire()
carIsConnected = True
carConnectionSem.release()
# 6. Send Khan user data to the client
#server.send_message(client, login_data)
def runWebsocketServer():
global server
server.run_forever()
def runAuthServer():
global callback_server
callback_server.serve_forever()
#PORT=9001
PORT=8080
SERVERHOST= "0.0.0.0"
server = WebsocketServer(PORT, SERVERHOST)
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.set_fn_message_received(message_received)
#server.run_forever()
#callback_server.serve_forever()
t1 = threading.Thread(target=runWebsocketServer, args=[])
t2 = threading.Thread(target=runAuthServer, args=[])
t1.start()
t2.start()
def __init__(self, host='127.0.0.1'):
server = WebsocketServer(self.port, host)
server.set_fn_new_client(self.new_client_connection)
server.set_fn_client_left(self.client_left)
server.set_fn_message_received(self.message_received)
server.run_forever()
class WSServer:
def __init__(self, port=9007):
self.port = port
self.server = WebsocketServer(self.port, host='0.0.0.0')
self.server.set_fn_new_client(self.on_connect)
self.server.set_fn_message_received(self.on_msg)
self.server.set_fn_client_left(self.on_disconnect)
self.msg_lock = Lock()
def ping(self):
self.server.send_message_to_all(json.dumps({'action': 'ping'}))
# pinging every 50 seconds to avoid disconnection
t = Timer(50, self.ping)
t.start()
def on_connect(self, client, server):
#server.send_message_to_all("Hey all, a new client has joined us")
pass
def on_disconnect(self, client, server):
#server.send_message_to_all("Hey all, a new client has joined us")
pass
def on_msg(self, client, server, message):
self.msg_lock.acquire()
try:
args = message.split(' ')
command = args[0]
args = args[1:]
internal = 'internal_ws_' + command
if hasattr(self, internal):
getattr(self, internal)(client, *args)
else:
data = {'action': 'cmd', 'msg': 'not found'}
self.server.send_message(client, json.dumps(data))
except Exception as e:
print("Error: ", e)
connection.close()
self.msg_lock.release()
def run(self):
self.ping()
self.server.run_forever()
def drop_seat(self, hold):
session = hold.session
layout = hold.layout
row, col = hold.seat.split('-')
data = {
'action': 'drop',
'session': session.id,
'layout': layout.id,
'row': row,
'col': col,
}
hold.delete()
confirmed = not session.is_seat_available(layout, row, col)
if confirmed:
data['action'] = 'confirm'
self.server.send_message_to_all(json.dumps(data))
def notify_confirmed(self):
d = timezone.now()
d = d - datetime.timedelta(seconds=80)
holds = TicketSeatHold.objects.filter(date__gt=d, type="R")
for h in holds:
row, col = h.seat.split('-')
data = {
'action': 'confirm',
'session': h.session.id,
'layout': h.layout.id,
'row': row,
'col': col,
}
self.server.send_message_to_all(json.dumps(data))
# Protocol definitions
def internal_ws_autoseats(self, client, session, amount, user):
session = Session.objects.get(id=session)
seats = search_seats(session, int(amount))
data = {
'action': 'autoseat',
'session': session.id,
'seats': seats,
}
for s in seats:
layout = SeatLayout.objects.get(id=s['layout'])
seat = '{}-{}'.format(s['row'], s['col'])
d2 = {
'action': 'hold',
'session': session.id,
'layout': layout.id,
'row': s['row'],
'col': s['col'],
}
sh = TicketSeatHold(client=user,
layout=layout,
seat=seat,
session=session)
sh.save()
self.server.send_message_to_all(json.dumps(d2))
if not seats:
data['error'] = _('Not found contiguous seats, please, select manually using the green button')
self.server.send_message(client, json.dumps(data))
def internal_ws_get_events(self, client):
events = serializers.serialize("json", Event.objects.all())
self.server.send_message(client, events)
def internal_ws_get_spaces(self, client, event):
event = Event.objects.get(slug=event)
spaces = serializers.serialize("json", event.spaces.all())
self.server.send_message(client, spaces)
def internal_ws_get_sessions(self, client, event, space):
event = Event.objects.get(slug=event)
space = event.spaces.get(slug=space)
sessions = serializers.serialize("json", space.sessions.all())
self.server.send_message(client, sessions)
def internal_ws_hold_seat(self, client, session, layout, row, col, user):
session = Session.objects.get(id=session)
layout = SeatLayout.objects.get(id=layout)
data = {
'action': 'hold',
'session': session.id,
'layout': layout.id,
'row': row,
'col': col,
}
if not session.is_seat_holded(layout, row, col):
seat = row + '-' + col
sh = TicketSeatHold(client=user, layout=layout, seat=seat,
session=session)
sh.save()
self.server.send_message_to_all(json.dumps(data))
else:
data['action'] = 'holded'
self.server.send_message(client, json.dumps(data))
def internal_ws_drop_seat(self, client, session, layout, row, col, user):
try:
seat = row + '-' + col
sh = TicketSeatHold.objects.get(client=user,
type='H',
layout=layout,
seat=seat,
session=session)
self.drop_seat(sh)
except:
pass
def internal_ws_add_ac(self, client, control, date, st):
data = {
'action': 'add_ac',
'control': control,
'date': date,
'st': st,
}
log = LogAccessControl(access_control=AccessControl.objects.get(slug=control), status=st)
log.save()
self.server.send_message_to_all(json.dumps(data))
def internal_ws_add_sale(self, client, window, date, payment, amount, price):
data = {
'action': 'add_sale',
'window': window,
'date': date,
'payment': payment,
'amount': amount,
'price': price
}
self.server.send_message_to_all(json.dumps(data))
def internal_ws_add_change(self, client, window, date, payment, amount, price):
data = {
'action': 'add_change',
'window': window,
'date': date,
'payment': payment,
'amount': amount,
'price': price
}
self.server.send_message_to_all(json.dumps(data))
query_string = """ SELECT value FROM "error_rate" WHERE "session_id" = '{session_id}' AND time >= now() - 10s AND time <= now() """.format(session_id=session_id)
result = influx_client.query(query_string)
if result:
print("Sending messages...")
else:
print("No message found!")
c = 1
if "counter" in client:
c = int(client["counter"])
for items in result:
for item in items:
server.send_message_to_all("Batch Number => " + str(c))
server.send_message_to_all("Error Rate => " + str(item['value']))
c+=1
sleep(0.045)
else:
server.send_message_to_all("Session expired..!")
def receive_messages(client,server, message):
client['counter'] = message
send_messages(client, server)
server = WebsocketServer(8080, host='0.0.0.0')
server.set_fn_new_client(send_messages)
server.set_fn_message_received(receive_messages)
server.run_forever()
for mod in modlist:
mname = GetModuleName(phandle,mod)
if mname.endswith(game["moduleName"]):
memory_address = mod + game["memoryOffset"]
# read address
def readTicker():
ReadProcessMemory(phandle, memory_address, ticker, ticker_s, byref(bytesRead))
def clientJoin(client,server):
global client_num
client_num += 1
if(client_num==1):
initTicker()
def clientLeave(client,server):
global client_num
client_num -= 1
if(client_num==0):
CloseHandle(phandle)
def clientMsg(client,server,message):
readTicker()
server.send_message(client,ticker.value.replace('m','.'))
print "Starting server on " + str(socket.gethostbyname(socket.gethostname()))
server = WebsocketServer(config["serverPort"],"0.0.0.0")
server.set_fn_new_client(clientJoin)
server.set_fn_client_left(clientLeave)
server.set_fn_message_received(clientMsg)
server.run_forever()
class websocketserver:
cameras = {}
tags = {}
users = {}
calibration = {}
port=8001
# Called for every client connecting (after handshake)
def new_client_connection(self, client, server):
print("New client connected and was given id %d" % client['id'] +" and address " + str(client['address']))
server.send_message(client, "Client connected succesfully")
# Called for every client disconnecting
def client_left(self, client, server):
print("Client(%d) disconnected" % client['id'])
#TODO : Remove from list
# Called when a client sends a message
def message_received(self, client, server, message):
# print("Client(%d) said: %s" % (client['id'], message))
self.parseMessage(client, message)
def __init__(self, host='127.0.0.1'):
self.server = WebsocketServer(self.port, host)
self.server.set_fn_new_client(self.new_client_connection)
self.server.set_fn_client_left(self.client_left)
self.server.set_fn_message_received(self.message_received)
self.server.run_forever()
def parseMessage(self, client, message):
"""
Check who is the message from to redirect it to User / Tag / Camera / Calibration
or create a new instance of User / Tag / Camera / Calibration
:param client:
:param message:
:return:
"""
if self.cameras.has_key(str(client['address'])):
#print "Message from Camera"
self.cameras[str(client['address'])].push(message)
elif self.users.has_key(str(client['address'])):
print "Message from User"
elif self.tags.has_key(str(client['address'])):
print "Message from Tag"
elif self.calibration.has_key(str(client['address'])):
self.calibration[str(client['address'])].push(message)
print "Message from Calibration"
# This message is coming from an unknown client
else:
if message.split("-")[0] == "camera":
self.cameras[str(client['address'])] = Camera(client, message.split("-")[1])
# Add Observers linking every user to every camera's update
for key in self.users:
if isinstance(self.users[key], User):
self.cameras[str(client['address'])].new2DPointNotifier.addObserver(self.users[key].position.newPoint2DObserver)
self.cameras[str(client['address'])].point2DdeletedNotifier.addObserver(self.users[key].position.point2DDeletedObserver)
elif message.split("-")[0] == "tag":
print "Hello TAG"
# TODO
elif message.split("-")[0] == "user":
user = User(client, self.server, message.split("-")[1])
self.users[str(client['address'])] = user
# Add Observers linking every user to every camera's update
for key in self.cameras:
if isinstance(self.cameras[key], Camera):
self.cameras[key].new2DPointNotifier.addObserver(user.position.newPoint2DObserver)
self.cameras[key].point2DdeletedNotifier.addObserver(user.position.point2DDeletedObserver)
elif message == "calibration":
self.calibration[str(client['address'])] = Calibration(self.cameras, self.server, client)
def webServer():
usersfd = open("users.json", "r")
users = json.load(usersfd)
usersfd.close()
def new_client(client, server):
print("New client connected and was given id %d" % client['id'])
def client_left(client, server):
print("Client(%d) disconnected" % client['id'])
def message_received(client, server, message):
#print("received message from client id %d " % client['id'])
#logging.info("received message from client id %d " % client['id'])
msg = json.loads(message)
if msg["action"] == AUTHENTICATE:
print 'msg is AUTHENTICATE'
resp = {"action": AUTHENTICATE, "data": None}
username = msg["data"].get("username") if msg["data"].has_key("username") else None
password = msg["data"].get("password") if msg["data"].has_key("password") else None
if username and password and users.has_key(username) and password == users[username]:
print "AUTHSUCCESS"
resp["data"] = AUTHSUCCESS
else:
print "AUTHFAIL"
resp["data"] = AUTHFAIL
server.send_message(client, json.dumps(resp) )
elif msg["action"] == GETBANNEDIPs:
#print 'msg is GETBANNEDIPs'
#logging.info('msg is GETBANNEDIPs')
resp = {"action": GETBANNEDIPs, "data": []}
username = msg["data"].get("username") if msg["data"].has_key("username") else None
password = msg["data"].get("password") if msg["data"].has_key("password") else None
if username and password and users.has_key(username) and password == users[username]:
for bannedIP in bannedIPs.values():
ip = {}
ip["IP"] = bannedIP.IP
ip["time"] = time.strftime("%b %d %H:%M:%S", time.localtime(bannedIP.time))
ip["timer"] = bannedIP.timer - (time.time() - bannedIP.time)
ip["service"] = bannedIP.service
resp["data"].append(ip)
server.send_message(client, json.dumps(resp))
else:
print "AUTHFAIL"
resp["data"] = AUTHFAIL
server.send_message(client, json.dumps(resp))
elif msg["action"] == GETFAILEDATTEMPTs:
print 'msg is GETFAILEDATTEMPTs'
resp = {"action": GETFAILEDATTEMPTs, "data": []}
username = msg["data"].get("username") if msg["data"].has_key("username") else None
password = msg["data"].get("password") if msg["data"].has_key("password") else None
if username and password and users.has_key(username) and password == users[username]:
for failedAttempt in failedAttempts:
print "in FA"
print "FA=" + str(failedAttempt)
ip = {}
ip["IP"] = failedAttempt[0]
ip["attempts"] = []
ip["service"] = failedAttempt[1]
for attempt in failedAttempts[failedAttempt]:
ip["attempts"].append(time.strftime("%b %d %H:%M:%S", time.localtime(attempt.time)))
resp["data"].append(ip)
server.send_message(client, json.dumps(resp))
else:
print "AUTHFAIL"
resp["data"] = AUTHFAIL
server.send_message(client, json.dumps(resp))
elif msg["action"] == UNBANIPs:
print 'msg is UNBANIPs'
resp = {"action": UNBANIPs, "data": {}}
username = msg["data"].get("username") if msg["data"].has_key("username") else None
password = msg["data"].get("password") if msg["data"].has_key("password") else None
if username and password and users.has_key(username) and password == users[username]:
unbanIP(msg["data"]["IP"], msg["data"]["service"])
resp["data"]["IP"] = msg["data"]["IP"]
resp["data"]["service"] = msg["data"]["service"]
server.send_message(client, json.dumps(resp))
else:
print "AUTHFAIL"
resp["data"] = AUTHFAIL
server.send_message(client, json.dumps(resp))
elif msg["action"] == CHANGECONFIG:
print 'msg is CHANGECONFIG'
#changeconfig(bantimer,nofailedattempts,failinterval)
data = msg["data"]
for service in services.values():
if service.name.lower() == data.get("service").lower():
changeConfig(data.get("bantimer"), data.get("threshold"), data.get("interval"), service)
#server.send_message(client, json.dumps(resp))
global server
PORT=9001
server = WebsocketServer(PORT, host='0.0.0.0')
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.set_fn_message_received(message_received)
server.run_forever()
def new_client(client, server):
print("New client connected and was given id %d" % client['id'])
server.send_message(client, json.dumps(shared_dict))
# Called when a client sends a message
def message_received(client, server, message):
if message != "PING":
print("Client(%d) said: %s" % (client['id'], message))
shared_dict["form"] = json.loads(message)
server.send_message_to_all(json.dumps(shared_dict))
for key, value in shared_dict["form"].items():
networktable.putValue(key, value)
ws_server = WebsocketServer(config['ws_port'])
ws_server.set_fn_new_client(new_client)
ws_server.set_fn_message_received(message_received)
class ConnectionListener:
def __init__(self):
self._first_disconnect = True # we want to ignore the first disconnect event as it's always disconnected at init
def connected(self, table):
print("NetworksTables connected to", table)
shared_dict["robot_status"] = "connected"
ws_server.send_message_to_all(json.dumps(shared_dict))
# we may have form data to send to the table while we were disconnected, so update it
for key, value in shared_dict["form"].items():
table.putValue(key, value)
