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 server():
""" Returns the response of a server after"""
s = WebsocketServer(0, loglevel=logging.DEBUG)
server_thread = Thread(target=s.run_forever)
server_thread.daemon = True
server_thread.start()
yield s
s.server_close()
def start_wss(port):
"start the websocket test server"
def reply_back(client, server, msg):
server.send_message(client, "You sent: %s" % msg)
server = WebsocketServer(port)
server.set_fn_message_received(reply_back)
server.run_forever()
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 WsServerLaunch(): global wsServer while 1: try: wsServer = WebsocketServer( port=PORT_NUMBER + 1, host='' ) wsServer.set_fn_message_received( message_received ) wsServer.run_forever() except Exception as e: wsServer = None time.sleep( 5 )
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 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 __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 __init__(self):
super(WebSocket, self).__init__()
self.target = self.identifier
self.server = WebsocketServer(5601, "0.0.0.0")
self.wsThread = threading.Thread(target=self.server.run_forever)
self.clients = self.server.clients
self.subscriptions = []
@self.server.set_fn_new_client
def new_client(client, server):
client["subscriptions"] = []
@self.server.set_fn_client_left
def client_left(client, server):
logging.info("Client(%d) disconnected" % client['id'])
@self.server.set_fn_message_received
def message_received(client, server, msg):
if msg:
try:
event = json.loads(msg)
event_type = event["type"]
event_data = event["data"]
if event_type == "subscribe":
self._subscribe(client, event_data)
elif event_type == "unsubscribe":
self._unsubscribe(client, msg)
else:
Dispatcher().put_event(Event(type=event_type, data=event_data))
except json.decoder.JSONDecodeError as e:
pass
def websocket_server():
global server
logging.debug('Running websocket server')
server = WebsocketServer(13254, host='127.0.0.1')
server.set_fn_client_left(websocket_client_left)
server.run_forever()
def main():
print('\033[94m' + "Server Started" + '\033[0m')
HTTP_PORT = 8000
WEBSOCKET_PORT = 9001
server = WebsocketServer(9001, host='0.0.0.0')
server.set_fn_message_received(message_received)
server.run_forever()
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 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()
class Game:
users = []
locations = []
def __init__(self, _port):
self.server = WebsocketServer(_port)
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()
# Called for every client connecting (after handshake)
def new_client(self, client, server):
print("New client connected and was given id %d" % client['id'])
server.send_message_to_all("Hey all, a new client has joined us")
server.send_message(client, 'Welcome')
pprint(client['headers'])
#clients_out = Game.json_encode(Game.get_clients(server.clients))
#server.send_message_to_all(clients_out)
# Called for every client disconnecting
def client_left(self, client, server):
print("Client(%d) disconnected" % client['id'])
# Called when a client sends a message
def message_received(self, client, server, message):
#print(type(message))
#pprint(message)
if len(message) > 200:
message = message[:200] + '..'
print("Client(%d) said: %s" % (client['id'], message))
def _add_user(self, client, key):
user = {'API_KEY': key, 'CLIENT': client}
data = self.preload_data('')
self.users.append(user)
def json_encode(arr):
return json.dumps(arr)
def get_clients(_clients):
clients = []
for _client in _clients:
id = _client['id']
addr = _client['address']
clients.append({'id': id, 'address': addr})
return clients
class Controller:
def __init__(self, topic=''):
self.server = WebsocketServer(9001)
self.t = threading.Thread(target=self.server.run_forever)
self.t.daemon = True
self.t.start()
self.subscriber = rospy.Subscriber(
topic,
NavSatFix,
self.callback,
)
def callback(self, msg):
lat = msg.latitude
lng = msg.longitude
self.server.send_message_to_all(json.dumps({
'lat': lat,
'lng': lng,
}))
def spin(self):
rospy.spin()
def face_capture():
import logging
from websocket_server import WebsocketServer
clients = {}
def client_left(client, server):
msg = "Client (%s) left" % client['id']
print msg
try:
clients.pop(client['id'])
except:
print "Error in removing client %s" % client['id']
for cl in clients.values():
server.send_message(cl, msg)
def new_client(client, server):
msg = "New client (%s) connected" % client['id']
print msg
for cl in clients.values():
server.send_message(cl, msg)
clients[client['id']] = client
def msg_received(client, server, msg):
# msg = "Client (%s) : %s" % (client['id'], msg)
# print msg
clientid = client['id']
for cl in clients:
if cl == clientid:
cl = clients[cl]
server.send_message(cl, msg)
server = WebsocketServer(9001, host='0.0.0.0')
server.set_fn_client_left(client_left)
server.set_fn_new_client(new_client)
"""Sets a callback function that will be called when a client sends a message """
server.set_fn_message_received(msg_received)
server.run_forever()
def main():
server = WebsocketServer(9090, host='127.0.0.1', loglevel=logging.INFO)
server.set_fn_new_client(new_client)
send_message_thread = threading.Thread(target=send_message_every, args=(server,))
send_message_thread.start()
try:
server.run_forever()
except:
print("Exception!")
class UnityWebSocket:
def __init__(self, port):
logging.info("Creating Unity socket")
self.server = WebsocketServer(port)
self.server.set_fn_new_client(self.new_client)
self.server.set_fn_message_received(self.on_message)
self.on_play_mode_state_changed = self.event_default
self.on_pause_mode_state_changed = self.event_default
self.on_set_title = self.event_default
self.on_set_image = self.event_default
self.on_set_state = self.event_default
def start(self):
self.server.run_forever()
def new_client(self, client, ws):
self.send("open-socket")
def on_message(self, client, ws, message):
logging.debug(message)
data = UnityResponseData(message)
{
"setState": self.on_set_state,
"playModeStateChanged": self.on_play_mode_state_changed,
"pauseModeStateChanged": self.on_pause_mode_state_changed,
"setTitle": self.on_set_title,
"setImage": self.on_set_image
}.get(data.event, self.event_default)(data)
def send(self, action, context=None, settings=None, state=0):
if len(self.server.clients) == 0:
return False
data = {
"action": action,
"context": context,
"settings": settings,
"state": state
}
self.server.send_message_to_all(json.dumps(data))
return True
def event_default(self, data):
pass
def onActivated(self, ec_id):
# ビューアーの設定ファイルを生成
config = {
"WEBSOCKET_PORT": self._WEBSOCKET_PORT[0],
}
with open(VIEWER_CONFIG_FILE, mode="w") as f:
json.dump(config,
f,
ensure_ascii=False,
indent=2,
separators=(",", ": "))
#def ws_on_message(client, server, message):
# server.send_message_to_all(message)
# return
# WebSocket サーバーを起動
self.ws_server = WebsocketServer(self._WEBSOCKET_PORT[0],
host=self._WEBSOCKET_HOST[0])
#self.ws_server.set_fn_message_received(ws_on_message)
self.ws_thread = threading.Thread(target=self.ws_server.run_forever)
self.ws_thread.start()
return RTC.RTC_OK
class OrderingHub():
def __init__(self, host='localhost', port=7777, isdebug=True):
self.server = WebsocketServer(port, host)
self.server.set_fn_new_client(self.new_client)
self.server.set_fn_client_left(self.client_left)
self.clients = {}
self.clientId = 0
self.orderId = 0;
return
def run(self):
self.server.run_forever()
return
def set_callback(self, callback):
# self.server.set_fn_message_received(lambda client, server,message: callback(json.loads(message), self.send_all))
self.server.set_fn_message_received(lambda client, server,message: callback(self, json.loads(message), self.send_all))
return
def send_all(self, message):
for c in self.clients.values():
self.server.send_message(c, json.dumps(message))
return
def new_client(self, client, server):
print('hello clinet')
client['id'] = self.clientId
self.clients[self.clientId] = client
print('add client(id={})'.format(self.clientId))
self.clientId = self.clientId+1
return
def client_left(self, client, server):
print('closing clientid={}'.format(client['id']))
del self.clients[client['id']]
return
class WebSocketInterface(SystemInterface):
""" Interface to a WebSocket Connection, runs a WebSocket Server """
def __init__(self, message_callback, port, IP='127.0.0.1'):
self.IP = IP
self.port = (port)
# init Websocket
self.server = WebsocketServer(self.port, self.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(message_callback)
varanus_logger.debug(self.server)
varanus_logger.info("+++ WebSocket Server Initialised +++")
def send(self, message):
varanus_logger.info("+++ Sending ", message, " +++")
self.ws.send(message)
def connect(self):
self.server.run_forever()
def new_client(self, client, server):
"""Called for every client connecting (after handshake)"""
varanus_logger.info(
"+++ New ROS monitor connected and was given id: " + client['id'] +
" +++")
# server.send_message_to_all("Hey all, a new client has joined us")
def client_left(self, client, server):
""" Called for every client disconnecting"""
varanus_logger.info("ROS monitor " + client['id'] +
" disconnected +++")
def close(self):
self.server.close()
def __init__(self, websocket_port, serial_port):
self.n_packet = 0
try:
self.ser = serial.Serial(serial_port)
except serial.SerialException as e:
logging.error("Can't find teensy: {}".format(e))
if USE_DUMMY:
logging.warning('Using serial dummy')
self.dummy = SerialDummy()
self.ser = self.dummy.ser
else:
exit()
self.serial_reader = ReaderThread(self.ser, PacketReceiver).__enter__()
self.serial_reader.commander = self
# Websocket server
self.websocket_server = WebsocketServer(websocket_port)
self.websocket_server.set_fn_message_received(self.ws_msg_rcv)
self.websocket_server.set_fn_new_client(self.ws_client_connect)
self.websocket_server.set_fn_client_left(self.ws_client_left)
self.websocket_thread = threading.Thread(
target=self.websocket_server.run_forever)
self.websocket_thread.daemon = True
self.websocket_thread.start()
def WsServerLaunch():
global wsServer
while 1:
try:
wsServer = WebsocketServer(port=PORT_NUMBER + 1, host='')
wsServer.set_fn_message_received(message_received)
wsServer.run_forever()
except Exception as e:
wsServer = None
time.sleep(5)
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 serve(mqtt_q, ws_q):
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_q))
t = Thread(target=server.run_forever)
t.daemon = True
t.start()
while True:
topic, msg = mqtt_q.get()
print("< %s, %s" % (topic, msg), flush=True)
state[topic] = msg
tstamp = datetime.datetime.now().strftime("%H:%M:%S")
state['timestamp'] = tstamp
server.send_message_to_all(
json.dumps({
topic: msg,
"timestamp": tstamp
}))
t.join()
def start_docker(cls, run_webui=True):
assert cls.compose_file, "compose_file class var must be set by subclass"
assert cls.testname, "testname class var must be set by subclass"
assert os.getenv(
'LOCAL_PATH'
), "You must set the env variable LOCAL_PATH which contains the project you are testing."
if cls._docker_started:
return
cls._docker_started = True
os.environ['TEST_NAME'] = cls.testname
for root, dirs, files in os.walk(os.getenv('LOCAL_PATH')):
if os.getenv('TEST_NAME') in root:
shutil.rmtree(root)
cls._run_launch('--clean')
cls._run_launch('--build_only')
cls._run_launch('&')
# Configure node map properties including the 'groups', 'nodemap', and 'nodes' attributes
cls._set_node_map()
if run_webui:
log.debug("Launching web UI")
cls.webui = Process(target=cls._run_webui)
cls.webui.start()
cls._webui_started = True
cls.server = WebsocketServer(WS_PORT, host='0.0.0.0')
cls.websocket = Process(target=cls._run_websocket,
args=(cls.server, ))
cls.websocket.start()
webbrowser.open('http://localhost:{}'.format(WEBUI_PORT),
new=2,
autoraise=True)
sys.stdout.flush()
log.info('Running test "{}" and waiting for {}s...'.format(
cls.testname, cls.setuptime))
time.sleep(cls.setuptime)
class SocketServer(object):
def __init__(self,
host: str = '0.0.0.0',
port: int = 10000,
callback: SocketServerCallback = None):
self.port = port
self.host = host
self.callback = callback
self.server = None # type: WebsocketServer
def run(self):
self.server = WebsocketServer(self.port, host=self.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)
self.server.run_forever()
@try_except('new client')
def new_client(self, client, server):
if not self.callback:
logger.debug(f'new client: {client}')
return
self.callback.new_client(client, server)
@try_except('new left')
def client_left(self, client, server):
if not self.callback:
logger.debug(f'client left: {client}')
return
self.callback.client_left(client, server)
@try_except('message received')
def message_received(self, client, server, message):
if not self.callback:
b_data = message.encode(encoding='raw_unicode_escape')
message = b_data.decode()
logger.debug(f'client id: {client["id"]} request: {message}')
handler = client['handler'] # type: WebSocketHandler
handler.send_message(message)
logger.debug(f'client id: {client["id"]} response: {message}')
return
self.callback.message_received(client, server, message)
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 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 main(OPERAT_TIME):
# WTF???
global OPERATING_TIME
OPERATING_TIME = OPERAT_TIME
ends = Request_currency_endings.main(underline=False)
list_paths = Paths_for_price_requests.launch(ends, only_pairs=False)
# Открываем параллельные потоки для запроса цен
prices = threading.Thread(target=requests_price, args=(list_paths, ))
# fast_price = threading.Thread(target=wb_price_BNBUSDT)
prices.start()
# fast_price.start()
server = WebsocketServer(13254, host='127.0.0.1')
server.set_fn_message_received(listening_to_messages)
server.run_forever()
class WS():
def __init__(self,Asseist):
self.ws = None #type: WebsocketServer
self.Asseist = Asseist
def Init_Websocket(self):
self.ws = WebsocketServer(7777, host='127.0.0.1')
self.ws.set_fn_new_client(self.new_client)
self.ws.set_fn_message_received(self.on_message)
self.ws.run_forever()
def new_client(self,ws,server):
print("有人加入了websocket")
def on_message(self,ws,client,data):
print(client)
print(data)
#通訊協定 json格式 {'order':自定指令 ,'detail':發送的內容}
try :
data = base64.b64decode(data).decode()
print(data)
cmd = json.loads(data)
if cmd['order'] == "push_msg":
self.Send_Order_To_All(order="notify",detail=cmd['detail'])
if cmd['order'] == "close_win":
self.Asseist.Helper_Win_Hind()
except Exception as e:
print("Websocket 接收訊息錯誤格式")
print(e)
def Send_Order_To_All(self,order,detail):
pack = {'order': order, 'detail': detail}
print("ReadySend:{}".format(pack))
pack = base64.b64encode(json.dumps(pack).encode())
self.ws.send_message_to_all(pack)
class WS:
def __init__(self, main):
# type : WebsocketServer
self.ws = None
self.main = main
def Init_Websocket(self):
self.ws = WebsocketServer(7777, host='127.0.0.1')
self.ws.set_fn_new_client(self.new_client)
self.ws.set_fn_message_received(self.on_message)
self.ws.run_forever()
def new_client(self, ws, server):
print("有人加入websocket")
def on_message(self, ws, client, data):
# 通訊協定 json格式 {'order': 自訂指令, 'detail': 發送內容}
try:
# 編碼方式
data = base64.b64decode(data).decode()
cmd = json.loads(data)
print(data)
if cmd['order'] == "push_msg":
self.send_order_to_all(order='notify', detail=cmd['detail'])
if cmd['order'] == "close_win":
self.main.helper_win_hide()
except Exception as e:
print("Websocket 接收訊息錯誤格式")
print(e)
def send_order_to_all(self, order, detail):
pack = {'order': order, 'detail': detail}
# print("Ready send{}".format(pack))
pack = base64.b64encode(json.dumps(pack).encode())
# sound.speak(detail) # 透過google 小姐說出訊息
self.ws.send_message_to_all(pack)
def socketserver():
def message_received(client, server, message):
function = message.split(",,,")[0]
atr = message.split(",,,")[1]
# ignoring states for buttons
if not function in ["bell", "servo", "tts"]:
device = atr.split("//")[2]
new_state = atr.split("//")[1]
states[device] = new_state
socketserver.send_message_to_all(function + "//" + atr)
try:
module = importlib.import_module("scripts." + function)
t = threading.Thread(target=lambda: getattr(module, "run")(atr))
t.start()
print("\n------------------------")
print(function, atr)
print(states)
print(">> Erfolreich ausgeführt.")
getattr(module, "run")(atr)
except ModuleNotFoundError:
print(">> Das Modul konnte nicht gefunden werden.")
pass
def initial_send(client, server):
for state in states:
message = functions[state] + "//" + states[state] + "//" + state
socketserver.send_message(client, message)
socketserver = WebsocketServer(2687, host="0.0.0.0")
socketserver.set_fn_message_received(message_received)
socketserver.set_fn_new_client(initial_send)
print(">> Socketserver listening (:2687).")
socketserver.run_forever()
def websocket_server():
global i
i = 0
def new_client(client, server):
global i
i = ((i + 1))
def start_data_stream():
while True:
try:
with open(image_path, "rb") as image_file:
thermal = base64.b64encode(image_file.read())
server.send_message_to_all(thermal)
time.sleep(.02)
except:
with open(image_path, "rb") as image_file:
thermal = base64.b64encode(image_file.read())
server.send_message_to_all(thermal)
time.sleep(.02)
if i == 1:
start_data_stream()
else:
pass
print("New client connected and was given id %d" % client['id'])
def client_left(client, server):
print("Client(%d) disconnected" % client['id'])
PORT = 9876
server = WebsocketServer(websocket_port, host=websocket_interface)
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.run_forever()
def websocket_server():
global i
i=0
def new_client(client, server):
global i
i=((i+1))
def start_data_stream():
data_limit = 2000
while True:
check = os.stat('thermal.jpg')
#Add a wait in, due to file access speed
time.sleep(.005)
try:
if check>=data_limit:
with open(image_path, "rb") as image_file:
thermal=base64.b64encode(image_file.read())
server.send_message_to_all(thermal)
else:
pass
except:
pass
if i == 1:
threading.Thread(target=start_data_stream).start()
else:
pass
print("New client connected and was given id %d" % client['id'])
def client_left(client, server):
print("Client(%d) disconnected" % client['id'])
PORT=9876
server = WebsocketServer(websocket_port,host=websocket_interface)
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.run_forever()
class WSServer():
def __init__(self, port, host):
self.server = WebsocketServer(port=port, host=host)
self.server.set_fn_new_client(self.new_client)
self.server.set_fn_client_left(self.close_connection)
def new_client(self, client, _server):
print("client connected", client)
def close_connection(self, client, _server):
print(client, "disconnected")
def broadcast(self, message):
self.server.send_message_to_all(message)
def run(self):
serverThread = threading.Thread(target=self.server.run_forever)
serverThread.start()
class IPCWebSocket(object):
def __init__(self, ipc):
self.ipc = ipc
self.server = WebsocketServer(9000)
self._set_callbacks(self.server)
self.clients = []
def start(self):
from threading import Thread
def run():
self.server.run_forever()
t = Thread(target=run)
t.daemon = True
t.start()
def _set_callbacks(self, server):
server.set_fn_new_client(self.on_connect)
server.set_fn_client_left(self.on_disconnect)
server.set_fn_message_received(self.on_message)
def on_connect(self, client, server):
print("New client connected")
self.clients.append(client)
def on_disconnect(self, client, server):
print("Client disconnected")
self.clients = [c for c in self.clients if c['id'] != client['id']]
def on_message(self, client, server, message):
message = json.loads(message)
self.ipc.on_message(client, message)
def broadcast(self, message):
message = json.dumps(message)
for c in self.clients:
self.server.send_message(c, message)
print("broadcasted message to {} clients".format(len(self.clients)))
def send(self, client, message):
self.server.send_message(client, json.dumps(message))
class IPCWebSocket(object):
def __init__(self, ipc, port):
self.ipc = ipc
self.server = WebsocketServer(port)
self._set_callbacks(self.server)
self.clients = []
def start(self):
from threading import Thread
def run():
self.server.run_forever()
t = Thread(target=run)
t.daemon = True
t.start()
def _set_callbacks(self, server):
server.set_fn_new_client(self.on_connect)
server.set_fn_client_left(self.on_disconnect)
server.set_fn_message_received(self.on_message)
def on_connect(self, client, server):
self.clients.append(client)
def on_disconnect(self, client, server):
self.clients = [c for c in self.clients if c['id'] != client['id']]
def on_message(self, client, server, message):
message = json.loads(message)
self.ipc.on_message(client, message)
def broadcast(self, message):
message = json.dumps(message)
for c in self.clients:
self.server.send_message(c, message)
def send(self, client, message):
self.server.send_message(client, json.dumps(message))
class DSSocketServer(threading.Thread):
def __init__(self, port=9876):
threading.Thread.__init__(self)
self.setDaemon = True
self.server = WebsocketServer(port)
self.server.set_fn_message_received(self.message_received)
self.stopped = 0
def message_received(self, client, server, message):
print 'Message received: %s' % (message)
if message == 'STOP':
self.stopped += 1
elif message == 'START':
self.stopped -= 1
def run(self):
self.server.run_forever()
def message(self, text):
self.server.send_message_to_all(text)
class observer(threading.Thread):
def __init__(self, value_name, host, port, interval=1):
super(observer, self).__init__()
self.interval = interval
self.server = WebsocketServer(port,host)
self.server.set_fn_new_client(self._on_new_client_appeared)
self.server.set_fn_client_left(self._on_new_client_appeared)
self.wsthread = threading.Thread(target=self.server.run_forever)
self.value_name = value_name
def _getvalue(self):
pass
def _on_new_client_appeared(self, client, server):
logging.info("new client[{0}:{1}] appear here.".format(client["address"]))
def _on_client_left(self, client, server):
logging.info("client[{0}:{1}] has vanished.".format(client["address"]))
def run(self):
self.wsthread.start()
try:
while True:
val = self._getvalue()
if(val!=None):
data = {
"name": self.value_name,
"value": val
}
data_json = json.dumps(data)
self.server.send_message_to_all(data_json)
logging.debug(json.dumps(data, indent=2))
time.sleep(self.interval)
except KeyboardInterrupt as e:
logging.info("Interrupted.")
except Exception as e:
logging.error(e)
class WebSocketServerThread(threading.Thread):
def __init__(self, name, port, address):
super(WebSocketServerThread, self).__init__()
#threading.Thread.__init__(self)
self.name = name
self.port = port
self.address = address
def run(self):
# broadcasts the received message to all websocket clients
def broadcast(client, server, message):
for client in server.clients:
if client["server_port"] == server.port:
server.send_message(client, message)
def new_client(client, server):
client["server_port"] = server.port
print(datetime.datetime.now(), "|Publisher |Thread | started",
self.name, " @", self.address, self.port)
self.server = WebsocketServer(int(self.port), host=self.address)
self.server.set_fn_new_client(new_client)
self.server.set_fn_message_received(broadcast)
self.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()
elif "songlist" in message:
r = {"action": "songlist", "data": get_song_list()}
server.send_message(client, json.dumps(r))
elif "delsong" in message:
try:
song = message[7:]
except Exception as e:
logging.error("Error in parsing raw message `delsong`. e: %s, trackback: %s" % (e, format_exc(e)))
else:
logging.info("Try del: %s" % song)
r = {"action": "songlist", "data": del_a_song(song)}
server.send_message_to_all(json.dumps(r))
if __name__ == "__main__":
server = WebsocketServer(8080, "haha5")
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.set_fn_message_received(message_received)
t = Thread(target=server.run_forever)
t.start()
mq = RedisMessageQueue()
while True:
msg = mq.accept_msg()
logging.info("Global message: %s" % msg)
response = {"action": "msg", "data": msg}
server.send_message_to_all(json.dumps(response))
def client_left(client, server):
msg = "Client (%s) left" % client['id']
print msg
try:
clients.pop(client['id'])
except:
print "Error in removing client %s" % client['id']
def new_client(client, server):
msg = "New client (%s) connected" % client['id']
print msg
clients[client['id']] = client
def msg_received(client, server, msg):
# msg = "Client (%s) : %s" % (client['id'], msg)
print msg
clientid = client['id']
for cl in clients:
if cl != clientid:
cl = clients[cl]
server.send_message(cl, msg)
server = WebsocketServer(9001, host="0.0.0.0")
server.set_fn_client_left(client_left)
server.set_fn_new_client(new_client)
server.set_fn_message_received(msg_received)
server.run_forever()
class WebSocket(Agent):
autostart = True
def __init__(self):
super(WebSocket, self).__init__()
self.target = self.identifier
self.server = WebsocketServer(5601, "0.0.0.0")
self.wsThread = threading.Thread(target=self.server.run_forever)
self.clients = self.server.clients
self.subscriptions = []
@self.server.set_fn_new_client
def new_client(client, server):
client["subscriptions"] = []
@self.server.set_fn_client_left
def client_left(client, server):
logging.info("Client(%d) disconnected" % client['id'])
@self.server.set_fn_message_received
def message_received(client, server, msg):
if msg:
try:
event = json.loads(msg)
event_type = event["type"]
event_data = event["data"]
if event_type == "subscribe":
self._subscribe(client, event_data)
elif event_type == "unsubscribe":
self._unsubscribe(client, msg)
else:
Dispatcher().put_event(Event(type=event_type, data=event_data))
except json.decoder.JSONDecodeError as e:
pass
def run(self):
self.wsThread.start()
self._listener()
def _listener(self):
while self.wsThread.isAlive():
event = self.next_event()
event_type = event["type"]
event_data = event["data"]
for client in self.clients:
if event_type in client["subscriptions"]:
self.server.send_message(client, json.dumps(event))
def _subscribe(self, client, event_data):
client["subscriptions"].append(str(event_data))
if not str(event_data) in self.subscriptions:
self.subscriptions.append(str(event_data))
Dispatcher().bind(self, event_data)
logging.info("Client subscribed to " + event_data)
def _unsubscribe(self, client, event_data):
if str(event_data) in client["subscriptions"]:
client["subscriptions"].remove(event_data)
othersubscriber = False
for otherclient in self.clients:
if str(event_data) in otherclient["subscriptions"]:
othersubscriber = True
if not othersubscriber:
self.subscriptions.remove(str(event_data))
logging.info("Client unsubscribed from " + event_data)
else:
# Client wasn't found in subscribers list
pass
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))
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)
tty.setraw(sys.stdin.fileno())
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
def startServer(server):
print("HMI signals listener was started\r")
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 keyBoardEvent():
global server
char = ' '
while char != 'q':
char = getch()
server = WebsocketServer(8081)
serverThread = Thread(target = startServer, args = (server, ))
keyBoardThread = Thread(target = keyBoardEvent)
keyBoardThread.start()
serverThread.start()
keyBoardThread.join()
print("Closing server...")
server.shutdown()
server.server_close()
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()
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()
inputSem.release()
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()
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()
# 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()
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 __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 __init__(self, ipc):
self.ipc = ipc
self.server = WebsocketServer(9000)
self._set_callbacks(self.server)
self.clients = []
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()
def serve(port, host):
from websocket_server import WebsocketServer
from threading import Thread, Event
import signal
def message_received(client, server, message):
print 'message_received:', message
cmds = message.split('|')
for cmd in cmds:
if cmd.startswith('addr='):
address = cmd[5:]
if server.watched_addresses.has_key(address):
server.watched_addresses[address].append(client)
else:
server.watched_addresses[address] = [client]
if cmd == 'blocks':
server.block_watchers.append(client)
def client_left(client, server):
print 'client_left:', client
addrs = []
for key in server.watched_addresses:
if client in server.watched_addresses[key]:
addrs.append(key)
for addr in addrs:
clients = server.watched_addresses[addr]
clients.remove(client)
if not clients:
del server.watched_addresses[addr]
if client in server.block_watchers:
server.block_watchers.remove(client)
def service_thread(ws_server, evt):
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
from bitrisk.bitcoind_config import read_default_config
import json
import decimal
config = read_default_config()
testnet = ''
if config.has_key('testnet'):
testnet = config['testnet']
rpc_user = config['rpcuser']
rpc_password = config['rpcpassword']
rpc_connection = AuthServiceProxy("http://%s:%s@%s:%s8332"%(rpc_user, rpc_password, host, testnet))
conn = sqlite3.connect(db_filename)
while not evt.wait(5):
txs = get_db_txs(conn)
for tx in txs:
print 'tx:', tx
tx = rpc_connection.gettransaction(tx)
for details in tx['details']:
addr = details['address']
if ws_server.watched_addresses.has_key(addr):
def decimal_default(obj):
if isinstance(obj, decimal.Decimal):
return float(obj)
raise TypeError
msg = json.dumps(tx, default=decimal_default)
for client in ws_server.watched_addresses[addr]:
ws_server.send_message(client, msg)
blocks = get_db_blocks(conn)
for block in blocks:
print 'block:', block
for client in ws_server.block_watchers:
ws_server.send_message(client, block)
server = WebsocketServer(port, host)
server.watched_addresses = {}
server.block_watchers = []
server.set_fn_message_received(message_received)
server.set_fn_client_left(client_left)
evt = Event()
thread = Thread(target=service_thread, args=(server, evt))
thread.start()
server.run_forever() # catches and exits on SIGINT
evt.set() # stop service_thread
thread.join()
def getDataFromNickName(server, name):
c = 0
for i in server.clients:
if i['name'] == name:
return c
c += 1
def getNickNameFromID(server, id):
for i in server.clients:
if i['id'] == id:
return i['name']
@route('/')
def hello():
print("hello")
return ""
# Main
if __name__ == "__main__":
server = WebsocketServer(port=12345,
host='127.0.0.1',
loglevel=logging.INFO)
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 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.")
