def start_server():
"""Starts the WebSocket server."""
server = WebsocketServer(9001, host='0.0.0.0')
server.set_fn_message_received(message_received)
server.set_fn_client_left(client_left)
print("Started")
server.run_forever()
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 main(origin_png_filename, open_html=False, open_svg=False):
global WS_SERVER
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
assert os.path.isfile(origin_png_filename), origin_png_filename
dst_png_filename = os.path.join(TMP_DIR, 'origin.png')
shutil.copyfile(origin_png_filename, dst_png_filename)
svg_filename = render_templates(origin_png_filename, open_svg)
on_observable_svg_changed(svg_filename, dst_png_filename, reload_view=False)
print("Set change observer")
event_handler = SVGModificationHandler(svg_filename, dst_png_filename)
observer = Observer()
observer.schedule(event_handler, WWW_DIR, recursive=True)
observer.start()
print("Start WebSocket server")
WS_SERVER = WebsocketServer(**WS_SERVER_CONFIG)
if open_html:
args = ['open'] if sys.platform == 'darwin' else ['cmd.exe', '/c', 'start']
args.append(HTML_URL)
subprocess.check_call(args)
WS_SERVER.run_forever()
#
observer.stop()
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 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 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
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 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 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 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 __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')
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 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()
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(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()
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()
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()
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 open(self):
nw = self.newClientCallBack
server = WebsocketServer(9001, "192.168.8.106")
#server.set_fn_new_client(new_client)
#server.set_fn_client_left(self.clientLeftCallBack)
server.set_fn_message_received(self.newMessage)
server.run_forever()
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 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()
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 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 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()
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 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 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_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(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()
class Server:
"""
A Websocket server that polls a GSP's waitforchange RPC interface and
pushes notifications to connected clients.
"""
def __init__ (self, host, port, gspRpcUrl):
self.srv = WebsocketServer (host=host, port=port, loglevel=logging.INFO)
self.rpc = jsonrpclib.ServerProxy (gspRpcUrl)
def run (self):
"""
Starts the server, GSP polling thread and blocks forever while
the server is running.
"""
with self.pollingWorker ():
self.srv.run_forever ()
@contextmanager
def pollingWorker (self):
"""
Runs a new polling worker task in a managed context. When the context
is exited, the worker is stopped.
"""
mut = threading.Lock ()
shouldStop = False
def loop ():
knownBlock = ""
while True:
newBlock = self.rpc.waitforchange (knownBlock)
if newBlock != knownBlock:
self.pushNewBlock (newBlock)
knownBlock = newBlock
with mut:
if shouldStop:
return
thread = threading.Thread (target=loop)
thread.start ()
try:
yield
finally:
with mut:
shouldStop = True
thread.join ()
def pushNewBlock (self, blockHash):
data = {
"jsonrpc": "2.0",
"method": "newblock",
"params": [blockHash],
}
msg = json.dumps (data, separators=(",", ":"))
self.srv.send_message_to_all (msg)
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 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()
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))
server = WebsocketServer(PORT)
manager = Manager(server)
# Called for every client connecting (after handshake)
def new_client(client, server):
print("New client connected and was given id %d" % client['id'])
# Called for every client disconnecting
# @manager.user_logout
def client_left(client, server):
manager.user_logout(client)
print("Client disconnected")
# Called when a client sends a message
# @status_check
@manager.check_message
def message_received(client, server, message):
print(message)
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.set_fn_message_received(message_received)
# clear all LoggedUsers
MenuUser.objects.all().delete()
# then run server
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.")
def signal_handler(signal, frame):
print('\nShutting down server..')
global carIsConnected
global runServer
carConnectionSem.acquire()
runServer = False
# If car is not connected: connect to self as car then close connection
# so thread will continue and check if it needs to stop
if(not carIsConnected):
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('127.0.0.1',carPort))
s.close()
carConnectionSem.release()
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
# Start car communication thread
t = threading.Thread(target=communicateWithCar)
threads.append(t)
t.start()
print 'Listening on port', carPort, 'for car'
# Start websocket to communicate with client
websocket.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()
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))
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 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()
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)
def disconnected(self, table):
if self._first_disconnect:
self._first_disconnect = False
return
print("NetworkTabes disconnected from", table)
shared_dict["robot_status"] = "disconnected"
ws_server.send_message_to_all(json.dumps(shared_dict))
networktable = networktables_client.setup(config["robot_ip"], config["networktable"], ConnectionListener)
ws_server.run_forever() # we could throw this off to a seperate thread too, but then the main thread would have nothing to do
print("Exiting")
