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 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 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():
"""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()
# 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()
print('Car connected')
def start_data_server():
server = WebsocketServer(WS_PORT, host='0.0.0.0', loglevel=logging.INFO)
server.set_fn_new_client(new_client)
server.set_fn_message_received(on_sensor_data_recv)
server.run_forever()
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 WBmessenger(object):
def __init__(self, viewerparent):
self.parent = viewerparent
self.ProcessMessage = self.parent.ProcessMessage
self.websockport = self.parent.websockport
self.sleeptime = self.parent.sleeptime
self.mprint = self.parent.mprint
self.parent.lastviewmtrx
self.browserisopen = False
self.msgqueue = []
self.msgdelim = ":\n"
self.ishandling = False
self.websockclient = None
self.isterminating = False
self.was_disconnected = None
self.mywebsock = None
self.websockeventloop = None
def Sleep(self, t):
time.sleep(t)
def OnWebsocketClientMessage(self, client, server, message):
self.ProcessMessage(message)
def StartWebsocket(self):
self.server = WebsocketServer(self.websockport, host='127.0.0.1')
if not self.server:
raise Sorry("Could not connect to web browser")
self.server.set_fn_new_client(self.OnConnectWebsocketClient)
self.server.set_fn_client_left(self.OnDisconnectWebsocketClient)
self.server.set_fn_message_received(self.OnWebsocketClientMessage)
self.wst = threading.Thread(target=self.server.run_forever)
self.wst.daemon = True
self.wst.start()
self.msgqueuethrd = threading.Thread(target=self.WebBrowserMsgQueue)
self.msgqueuethrd.daemon = True
self.msgqueuethrd.start()
def StopWebsocket(self):
try:
if self.websockclient: # might not have been created if program is closed before a data set is shown
self.websockclient['handler'].send_text(u"", opcode=0x8)
except Exception as e:
self.mprint(to_str(e) + "\n" + traceback.format_exc(limit=10),
verbose=0)
self.mprint("Shutting down Websocket listening thread", verbose=1)
self.server.shutdown()
self.parent.javascriptcleaned = True
self.msgqueuethrd.join()
self.mprint("Shutting down WebsocketServer", verbose=1)
self.wst.join()
self.isterminating = True
def AddToBrowserMsgQueue(self, msgtype, msg=""):
self.msgqueue.append((msgtype, msg))
def WebBrowserMsgQueue(self):
try:
while True:
nwait = 0.0
time.sleep(self.sleeptime)
if self.parent.javascriptcleaned:
self.mprint("Shutting down WebBrowser message queue",
verbose=1)
return
if len(self.msgqueue):
pendingmessagetype, pendingmessage = self.msgqueue[0]
gotsent = self.send_msg_to_browser(pendingmessagetype,
pendingmessage)
while not self.browserisopen: #self.websockclient:
time.sleep(self.sleeptime)
nwait += self.sleeptime
if nwait > self.parent.handshakewait or self.parent.javascriptcleaned or not self.viewerparams.scene_id is not None:
return
if gotsent:
self.msgqueue.remove(self.msgqueue[0])
#if self.was_disconnected:
# nwait2 = 0.0
# while nwait2 < self.parent.handshakewait:
# nwait2 += self.sleeptime
# self.ReloadNGL()
# if the html content is huge the browser will be unresponsive until it has finished
# reading the html content. This may crash this thread. So try restarting this thread until
# browser is ready
except Exception as e:
self.mprint( str(e) + ", Restarting WebBrowserMsgQueue\n" \
+ traceback.format_exc(limit=10), verbose=2)
self.websockclient = None
self.WebBrowserMsgQueue()
def OnConnectWebsocketClient(self, client, server):
self.websockclient = client
self.mprint("Browser connected:" + str(self.websockclient), verbose=1)
if self.was_disconnected:
self.was_disconnected = False
if self.parent.lastviewmtrx and self.parent.viewerparams.scene_id is not None:
self.parent.set_volatile_params()
self.mprint("Reorienting client after refresh:" +
str(self.websockclient),
verbose=2)
self.AddToBrowserMsgQueue("ReOrient", self.parent.lastviewmtrx)
else:
self.parent.SetAutoView()
def OnDisconnectWebsocketClient(self, client, server):
self.mprint("Browser disconnected:" + str(client), verbose=1)
self.was_disconnected = True
def send_msg_to_browser(self, msgtype, msg=""):
message = u"" + msgtype + self.msgdelim + str(msg)
if self.websockclient:
nwait = 0.0
while not ("Ready" in self.parent.lastmsg or "tooltip_id" in self.parent.lastmsg \
or "CurrentViewOrientation" in self.parent.lastmsg or "AutoViewSet" in self.parent.lastmsg \
or "ReOrient" in self.parent.lastmsg or self.websockclient is None):
time.sleep(self.sleeptime)
nwait += self.sleeptime
if nwait > 2.0 and self.browserisopen:
self.mprint("ERROR: No handshake from browser!", verbose=0)
self.mprint("failed sending " + msgtype, verbose=1)
self.mprint("Reopening webpage again", verbose=0)
break
if self.browserisopen and self.websockclient is not None:
try:
self.server.send_message(self.websockclient, message)
return True
except Exception as e:
self.mprint(str(e) + "\n" + traceback.format_exc(limit=10),
verbose=1)
self.websockclient = None
return False
else:
return self.parent.OpenBrowser()
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()
import json as j
from websocket_server import WebsocketServer
import datetime
def new_client(client, server):
print("Request")
message = "Joined new client"
dtime = datetime.datetime.now()
time = dtime.strftime('%Y年%m月%d日 %H:%M:%S')
msg = j.dumps({"res" : "join", "time" : time, "text" : message})
server.send_message_to_all(str(msg))
def rp(client, server, message):
dtime = datetime.datetime.now()
json = j.loads(message)
time = dtime.strftime('%Y年%m月%d日 %H:%M:%S')
msg = j.dumps({"res" : "msg", "time" : time, "text" : json["msg"], "name" : json["name"]})
server.send_message_to_all(str(msg))
server = WebsocketServer(80)
server.set_fn_new_client(new_client)
server.set_fn_message_received(rp)
server.run_forever()
elif bison_id=='cmd':
if client['power']!=0:
logging.debug("don't have the power %s %d!!!!" % (client['account'],client['power']))
return
if (check_exclude_cmd(client, bison_cmd)==False):
message_dispatch(client,bison_cmd,issingle)
else:
logging.debug("命令包含非法字符")
return
config=ConfigParser.ConfigParser();
config.read('config.cfg')
config_url=config.get("info","url")
s= get_config_data()
cmd_dic=s['servershell']
account_dic=s['account']
shell_dic=s['shell']
exclude_cmd=s['exclude_cmd']
PORT=8009
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()
# 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 MockSocket:
def __init__(self):
self.last_messages = {}
self.connected = False
self.disconnected = False
self.closed = False
self.ws = None
self.should_heartbeat = True
self.fake_workers = []
self.port = None
self.launch_socket()
self.handlers = {}
while self.ws is None:
time.sleep(0.05)
time.sleep(1)
def send(self, packet):
self.ws.send_message_to_all(packet)
def close(self):
if not self.closed:
self.ws.server_close()
self.ws.shutdown()
self.closed = True
def do_nothing(self, *args):
pass
def launch_socket(self):
def on_message(client, server, message):
if self.closed:
raise Exception('Socket is already closed...')
if message == '':
return
packet_dict = json.loads(message)
if packet_dict['content']['id'] == 'WORLD_ALIVE':
self.ws.send_message(client, json.dumps({'type': 'conn_success'}))
self.connected = True
elif packet_dict['content']['type'] == 'heartbeat':
pong = packet_dict['content'].copy()
pong['type'] = 'pong'
self.ws.send_message(
client,
json.dumps(
{'type': data_model.SOCKET_ROUTE_PACKET_STRING, 'content': pong}
),
)
if 'receiver_id' in packet_dict['content']:
receiver_id = packet_dict['content']['receiver_id']
use_func = self.handlers.get(receiver_id, self.do_nothing)
use_func(packet_dict['content'])
def on_connect(client, server):
pass
def on_disconnect(client, server):
self.disconnected = True
def run_socket(*args):
port = 3030
while self.port is None:
try:
self.ws = WebsocketServer(port, host='127.0.0.1')
self.port = port
except OSError:
port += 1
self.ws.set_fn_client_left(on_disconnect)
self.ws.set_fn_new_client(on_connect)
self.ws.set_fn_message_received(on_message)
self.ws.run_forever()
self.listen_thread = threading.Thread(
target=run_socket, name='Fake-Socket-Thread'
)
self.listen_thread.daemon = True
self.listen_thread.start()
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))
"main_coord",
"comparitor",
]
batch_size = 32
def exec_fn_test(datas):
print("exec")
def return_fn_test(datas):
print("returns")
model_queues = {
name: ExecQueue(batch_size, exec_fn_test, return_fn_test)
for name in valid_queue_names
}
def client_message_rec(client, server, message):
print(client, message)
pass
#server.send_message()
server = WebsocketServer(13254, host='127.0.0.1')
server.set_fn_message_received(client_message_rec)
server.run_forever()
class Scatter:
"""Interface for python."""
def __init__(self, x, y, labels, label_formatter=None):
"""Initialize the plot.
Parameters
----------
x : list of floats
x coordinates of each point you want to plot.
y : list of floats
y coordinates of each point you want to plot.
labels : type
'label' corresponding with the x and y coordinates.
Could be anything from the text of a word corresponding
with a word embedding to the id/path of an image url that
you want to call with your label formatter.
Returns
-------
Scatter
Scatter object constructor.
"""
# size of chunks to send to the visualization
# Start out with smaller chunks, progressively send larger chunks
self.CHUNK_SIZE = 500000
self.PORT = 54286 #find_free_port()
self.server = WebsocketServer(self.PORT)
print(self.PORT)
# todo: validate that the length of all passed lists are the same
assert len(x) == len(y) == len(labels)
def new_client(client, server):
print("New client connected and was given id %d" % client['id'])
# Check if we need to load the library
self.server.send_message(client, {'loaded_scatter'})
n = len(x)
for i in range(n):
if (i > 0 and i % self.CHUNK_SIZE == 0) or i == n - 1:
start_idx = max(0, i-self.CHUNK_SIZE)
x_chunk = x[start_idx:i + 1]
y_chunk = y[start_idx:i + 1]
label_chunk = labels[start_idx:i + 1]
self.server.send_message(client,
json.dumps({'x': x_chunk,
'y': y_chunk,
'labels': label_chunk
}))
# self.server.send_message_to_all("Finished")
self.server.set_fn_new_client(new_client)
# Called for every client disconnecting
def client_left(client, server):
print("Client(%d) disconnected" % client['id'])
self.server.set_fn_client_left(client_left)
# Called when a client sends a message
def message_received(client, server, message):
self.dispatcher(json.loads(message))
self.server.set_fn_message_received(message_received)
def begin():
self.server.run_forever()
self.server_thread = Thread(target=begin)
self.server_thread.start()
self._ids = []
def dispatcher(self, message):
if message['command'] == 'request_data':
pass
elif message['command'] == 'load_lib':
pass
def _repr_html_(self):
unique_id = str(uuid1())
anchor = '<div id="{unique_id}"/>'.format(unique_id=unique_id)
self._ids.append(unique_id)
return anchor
def _create_js(self, uid):
script = open('scatter-script.js').read()
script = script.replace('_UID_', uid)
return script
def _repr_javascript_(self):
js = []
while len(self._ids) > 0:
i = self._ids.pop(0)
# funcs = 'console.log("' + 'test' + '");'#self._filled_ctx(i, self._s)
funcs = self._create_js(i)
js.append(funcs)
print("\n".join(js))
return "\n".join(js)
def _ipython_display_(self):
display_html(self._repr_html_(), raw=True)
display_javascript(self._repr_javascript_(), raw=True)
def to_html(self, out_path):
"""Write an html file with the visualization.
You can open this in the browser
"""
with open(out_path) as out:
raise NotImplemented
out.write("NOT IMPL")
class websocketclass():
def __init__(self):
PORT=9014
self.callSingle = re.compile("call:([a-zA-Z]+)\.([a-zA-Z]+)\.([a-zA-Z_]+)[|]?(.*)")
self.callMultiple = re.compile("call:([a-zA-Z]+)\.\[([a-zA-Z,]+)\]\.([a-zA-Z_]+)[|]?(.*)")
self.callAll = re.compile("call:([a-zA-Z]+)\.\*\.([a-zA-Z_]+)[|]?(.*)")
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)
threading.Thread(target=self.run).start()
self.server.run_forever()
def analyzeMessage(self,strMessage):
# If the module wants to call a method, analyze the call (for tablet or nao)
# and dispached it accordingly
matchCallSingle = self.callSingle.match(strMessage)
if matchCallSingle:
strDestDevice = matchCallSingle.group(1)
strDestModule = matchCallSingle.group(2)
strCallMethod = matchCallSingle.group(3)
strCallParams = matchCallSingle.group(4)
self.handleCallSingle(strDestDevice,strDestModule,strCallMethod,strCallParams)
return
# If the module wants to call a method in multiple mudules, get the name of the
# modules and dispached it accordingly
matchCallMultiple = self.callMultiple.match(strMessage)
if matchCallMultiple:
strDestDevice = matchCallMultiple.group(1)
aDestModule = matchCallMultiple.group(2).split(",")
strCallMethod = matchCallMultiple.group(3)
strCallParams = matchCallMultiple.group(4)
for strDestModule in aDestModule:
self.handleCallSingle(strDestDevice,strDestModule,strCallMethod,strCallParams)
return
# If the module wants to call a method in all known mudules, go through all modules
# and send according message
matchCallAll = self.callAll.match(strMessage)
if matchCallAll:
strDestDevice = matchCallAll.group(1)
strCallMethod = matchCallAll.group(2)
strCallParams = matchCallAll.group(3)
for strDestModule in aRegistered:
self.handleCallSingle(strDestDevice,strDestModule,strCallMethod,strCallParams)
return
def handleCallSingle(self,strDestDevice,strDestModule,strCallMethod,strCallParams):
logging.debug("handle call: " + strDestDevice + " " + strDestModule + " " + strCallMethod + " " + strCallParams)
# If the called module is on tablet, store the call in aRegistered
if strDestDevice == "tablet":
if strDestModule in aRegistered:
registeredLock.acquire()
aRegistered[strDestModule].append(("TabletGame",strCallMethod,strCallParams))
registeredLock.release()
# If the called module is on Nao, call the method through ALProxy
if strDestDevice == "nao":
# If the called module is yet yet in aRegisteredNao creates and stores
# a new instantiation
try:
registeredLockNao.acquire()
if not strDestModule in aRegisteredNao:
aRegisteredNao[strDestModule] = ALProxy(strDestModule,robotIP,9559)
registeredLockNao.release()
except RuntimeError:
registeredLockNao.release()
logging.error("Could not obtain module " + strDestModule + " on Nao")
return
# Call the method of the instantiated called module
try:
t = None
if(strCallParams!=""):
t = threading.Thread(target=getattr(aRegisteredNao[strDestModule],strCallMethod),args=(strCallParams,))
else:
t = threading.Thread(target=getattr(aRegisteredNao[strDestModule],strCallMethod))
t.start()
except RuntimeError:
logging.error("Could not call method " + strCallMethod + " on Nao")
def new_client(self,client, server):
logging.info("New client connected and was given id %d" % client['id'])
registeredLock.acquire()
aRegistered["tabletgame"] = []
registeredLock.release()
#server.send_message_to_all("Hey all, a new client has joined us")
def message_received(self, client, server, message):
logging.info("Text message received:" + message)
self.analyzeMessage(message)
def run(self):
global msgsForWeb
while 1:
if not msgsForWeb.empty():
self.tosend=msgsForWeb.get()
logging.info("Message to send from Webscoket thread:" + self.tosend)
try:
self.server.send_message_to_all(self.tosend)
except:
logging.erro("Unexpected error:", sys.exc_info()[0])
time.sleep(0.1)
def client_left(self, client, server):
logging.info("Client(%d) disconnected" % client['id'])
registeredLock.acquire()
del aRegistered["tabletgame"]
registeredLock.release()
send_msg(json.dumps(dic))
threading.Timer(0.2, judgeNotes).start()
if __name__ == "__main__":
f = open('MusicScore.json', 'r') # Json読み込み
jsonData = json.load(f)
f.close()
notesJson = jsonData["Notes"]
FootNotesList.append([])
FootNotesList.append([])
FootNotesList.append([])
FootNotesList.append([])
NotesList.append([])
NotesList.append([])
NotesList.append([])
NotesList.append([])
server = WebsocketServer(3000, host='127.0.0.1') # WSserver初期化
server.set_fn_new_client(new_client)
server.set_fn_message_received(received_message)
thread_1 = threading.Thread(target=server_run,
args=([server])) # Serverと入力受付はサブスレッド
thread_2 = threading.Thread(target=input_char)
thread_3 = threading.Thread(target=judgeNotes)
thread_1.start()
thread_2.start()
thread_3.start()
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 __init__(self,ip,port):
server = WebsocketServer(port,ip)
server.set_fn_client_left(self.client_left)
server.set_fn_new_client(self.new_client)
server.set_fn_message_received(self.msg_received)
server.run_forever()
class hklview_3d:
def __init__(self, *args, **kwds):
self.settings = kwds.get("settings")
self.miller_array = None
self.d_min = None
self.scene = None
self.NGLscriptstr = ""
self.cameratype = "orthographic"
self.url = ""
self.binarray = "Resolution"
self.icolourcol = None
self.iradiicol = None
self.iarray = None
self.isnewfile = False
self.binvals = []
self.workingbinvals = []
self.proc_arrays = []
self.otherscenes = []
self.othermaxdata = []
self.othermindata = []
self.othermaxsigmas = []
self.otherminsigmas = []
self.sceneisdirty = False
self.matchingarrayinfo = []
self.match_valarrays = []
self.binstrs = []
self.mapcoef_fom_dict = {}
self.verbose = True
if kwds.has_key('verbose'):
self.verbose = kwds['verbose']
self.mprint = sys.stdout.write
if 'mprint' in kwds:
self.mprint = kwds['mprint']
self.nbin = 0
self.websockclient = None
self.lastmsg = ""
self.StartWebsocket()
tempdir = tempfile.gettempdir()
self.hklfname = os.path.join(tempdir, "hkl.htm")
if os.path.isfile(self.hklfname):
os.remove(self.hklfname)
if 'htmlfname' in kwds:
self.hklfname = kwds['htmlfname']
self.hklfname = os.path.abspath(self.hklfname)
self.jscriptfname = os.path.join(tempdir, "hkljstr.js")
if os.path.isfile(self.jscriptfname):
os.remove(self.jscriptfname)
if 'jscriptfname' in kwds:
self.jscriptfname = kwds['jscriptfname']
self.mprint('Output will be written to \"%s\"\n' \
'including reference to NGL JavaScript \"%s\"' %(self.hklfname, self.jscriptfname))
self.hklhtml = r"""
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<meta charset="utf-8" />
</head>
<body>
<script src="%s" type="text/javascript"></script>
<script src="%s" type="text/javascript"></script>
"""
self.htmldiv = """
<div id="viewport" style="width:100%; height:100%;"></div>
</body></html>
"""
self.colourgradientvalues = []
self.UseOSBrowser = True
if 'UseOSBrowser' in kwds:
self.UseOSBrowser = kwds['UseOSBrowser']
self.viewmtrxelms = None
self.pendingmessage = None
def __exit__(self, exc_type, exc_value, traceback):
# not called unless instantiated with a "with hklview_3d ... " statement
self.server.shutdown()
if os.path.isfile(self.hklfname):
os.remove(self.hklfname)
def set_miller_array(self, col, merge=None, details="", proc_arrays=[]):
self.iarray = col
if col:
self.miller_array = proc_arrays[col]
self.proc_arrays = proc_arrays
self.merge = merge
if (self.miller_array is None):
return
self.d_min = self.miller_array.d_min()
array_info = self.miller_array.info()
self.binvals = [
1.0 / self.miller_array.d_max_min()[0],
1.0 / self.miller_array.d_max_min()[1]
]
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
uc = "a=%g b=%g c=%g angles=%g,%g,%g" % self.miller_array.unit_cell(
).parameters()
self.mprint( "Data: %s %s, %d reflections in space group: %s, unit Cell: %s" \
% (array_info.label_string(), details, self.miller_array.indices().size(), \
self.miller_array.space_group_info(), uc) )
#self.construct_reciprocal_space(merge=merge)
def ExtendMillerArraysUnionHKLs(self):
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
self.match_valarrays = []
# loop over all miller arrays to find the subsets of hkls common between currently selected
# miler array and the other arrays. hkls found in the currently selected miller array but
# missing in the subsets are populated populated with NaN values
# create miller indices being a superset of available indices in all arrays
self.mprint("Gathering superset of miller indices")
superset_array = self.proc_arrays[0]
for i, validarray in enumerate(self.proc_arrays):
if i == 0:
continue
# first match indices in currently selected miller array with indices in the other miller arrays
matchindices = miller.match_indices(superset_array.indices(),
validarray.indices())
#print validarray.info().label_string()
valarray = validarray.select(matchindices.pairs().column(1))
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
if valarray.anomalous_flag(
) and not superset_array.anomalous_flag():
# valarray gets its anomalous_flag from validarray. But it cannot have more HKLs than self.miller_array
# so set its anomalous_flag to False if self.miller_array is not anomalous data
valarray._anomalous_flag = False
if not valarray.anomalous_flag() and superset_array.anomalous_flag(
):
# temporarily expand other arrays to anomalous if self.miller_array is anomalous
valarray = valarray.generate_bijvoet_mates()
missing = superset_array.lone_set(valarray)
# insert NAN values for reflections in self.miller_array not found in validarray
valarray = display.ExtendMillerArray(valarray, missing.size(),
missing.indices())
match_valindices = miller.match_indices(superset_array.indices(),
valarray.indices())
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
match_valarray = valarray.select(
match_valindices.pairs().column(1))
match_valarray.sort(by_value="packed_indices")
#match_valarray.set_info(validarray.info() )
superset_array = match_valarray
#print "supersetsize:", superset_array.size()
# now extend each miller array to contain any missing indices from the superset miller array
for i, validarray in enumerate(self.proc_arrays):
# first match indices in currently selected miller array with indices in the other miller arrays
matchindices = miller.match_indices(superset_array.indices(),
validarray.indices())
#print validarray.info().label_string()
valarray = validarray.select(matchindices.pairs().column(1))
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
if valarray.anomalous_flag(
) and not superset_array.anomalous_flag():
# valarray gets its anomalous_flag from validarray. But it cannot have more HKLs than self.miller_array
# so set its anomalous_flag to False if self.miller_array is not anomalous data
valarray._anomalous_flag = False
if not valarray.anomalous_flag() and superset_array.anomalous_flag(
):
# temporarily expand other arrays to anomalous if self.miller_array is anomalous
valarray = valarray.generate_bijvoet_mates()
missing = superset_array.lone_set(valarray)
# insert NAN values for reflections in self.miller_array not found in validarray
valarray = display.ExtendMillerArray(valarray, missing.size(),
missing.indices())
match_valindices = miller.match_indices(superset_array.indices(),
valarray.indices())
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
match_valarray = valarray.select(
match_valindices.pairs().column(1))
match_valarray.sort(by_value="packed_indices")
match_valarray.set_info(validarray.info())
self.match_valarrays.append(match_valarray)
def construct_reciprocal_space(self, merge=None):
self.mprint("Constructing HKL scenes")
#if len(self.match_valarrays)==0:
# self.ExtendMillerArraysUnionHKLs()
self.miller_array = self.match_valarrays[self.iarray]
if not self.sceneisdirty:
return
self.otherscenes = []
self.othermaxdata = []
self.othermindata = []
self.othermaxsigmas = []
self.otherminsigmas = []
self.matchingarrayinfo = []
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
foms_array = None
if self.miller_array.is_complex_array():
fomcolm = self.mapcoef_fom_dict.get(
self.miller_array.info().label_string())
if fomcolm:
foms_array = self.proc_arrays[fomcolm].deep_copy()
#self.scene = display.scene(miller_array=self.miller_array, merge=merge,
# settings=self.settings, foms_array=foms_array)
# compute scenes for each of the miller arrays
for i, match_valarray in enumerate(self.match_valarrays):
foms = None
if match_valarray.is_complex_array():
fomcolm = self.mapcoef_fom_dict.get(
match_valarray.info().label_string())
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
if fomcolm:
foms = self.match_valarrays[fomcolm]
#commonarray = match_valarray
commonarray = match_valarray.common_set(
self.proc_arrays[self.iarray])
commonarray.set_info(match_valarray.info())
if i == self.iradiicol or i == self.icolourcol or i == self.iarray:
bfullprocess = True
else:
bfullprocess = False
otherscene = display.scene(miller_array=commonarray,
merge=merge,
settings=self.settings,
foms_array=foms,
fullprocessarray=True)
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
if not otherscene.SceneCreated:
self.mprint("The " + commonarray.info().label_string() +
" array was not processed")
continue
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
# cast any NAN values to 1 of the colours and radii to 0.2 before writing javascript
b = flex.bool([
bool(math.isnan(e[0]) + math.isnan(e[1]) + math.isnan(e[2]))
for e in otherscene.colors
])
otherscene.colors = otherscene.colors.set_selected(
b, (1.0, 1.0, 1.0))
b = flex.bool([bool(math.isnan(e)) for e in otherscene.radii])
otherscene.radii = otherscene.radii.set_selected(b, 0.2)
self.otherscenes.append(otherscene)
ainf = ArrayInfo(otherscene.work_array, self.mprint)
self.othermaxdata.append(ainf.maxdata)
self.othermindata.append(ainf.mindata)
self.othermaxsigmas.append(ainf.maxsigmas)
self.otherminsigmas.append(ainf.minsigmas)
infostr = ainf.infostr
self.mprint("%d, %s" % (i, infostr))
self.matchingarrayinfo.append(infostr)
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
self.sceneisdirty = False
def update_settings(self, diffphil):
if hasattr(diffphil, "filename"):
self.ExtendMillerArraysUnionHKLs()
self.sceneisdirty = True
if hasattr(diffphil, "spacegroupchoice") or \
hasattr(diffphil, "mergedata") or \
hasattr(diffphil, "column") or \
hasattr(diffphil, "fomcolumn") or \
hasattr(diffphil, "viewer") and ( hasattr(diffphil.viewer, "show_anomalous_pairs") \
or hasattr(diffphil.viewer, "show_data_over_sigma") \
or hasattr(diffphil.viewer, "show_missing") \
or hasattr(diffphil.viewer, "show_only_missing") \
or hasattr(diffphil.viewer, "show_systematic_absences") \
or hasattr(diffphil.viewer, "slice_axis") \
or hasattr(diffphil.viewer, "slice_mode") \
or hasattr(diffphil.viewer, "scale") \
or hasattr(diffphil.viewer, "nth_power_scale_radii") \
or hasattr(diffphil.viewer, "expand_anomalous") \
or hasattr(diffphil.viewer, "expand_to_p1")
):
self.sceneisdirty = True
self.construct_reciprocal_space(merge=self.merge)
if self.miller_array is None or self.iarray < 0:
return
self.scene = self.otherscenes[self.iarray]
self.DrawNGLJavaScript()
msg = "Rendered %d reflections\n" % self.scene.points.size()
return msg
def UpdateBinValues(self, binvals=[]):
if binvals:
self.binvals = binvals
else:
self.binvals = [
1.0 / self.miller_array.d_max_min()[0],
1.0 / self.miller_array.d_max_min()[1]
]
def DrawNGLJavaScript(self):
if self.miller_array is None:
self.mprint("A miller array must be selected for drawing")
return
self.mprint("Composing NGL JavaScript...")
h_axis = self.scene.axes[0]
k_axis = self.scene.axes[1]
l_axis = self.scene.axes[2]
nrefls = self.scene.points.size()
Hstararrowstart = roundoff(
[-h_axis[0] * 100, -h_axis[1] * 100, -h_axis[2] * 100])
Hstararrowend = roundoff(
[h_axis[0] * 100, h_axis[1] * 100, h_axis[2] * 100])
Hstararrowtxt = roundoff(
[h_axis[0] * 102, h_axis[1] * 102, h_axis[2] * 102])
Kstararrowstart = roundoff(
[-k_axis[0] * 100, -k_axis[1] * 100, -k_axis[2] * 100])
Kstararrowend = roundoff(
[k_axis[0] * 100, k_axis[1] * 100, k_axis[2] * 100])
Kstararrowtxt = roundoff(
[k_axis[0] * 102, k_axis[1] * 102, k_axis[2] * 102])
Lstararrowstart = roundoff(
[-l_axis[0] * 100, -l_axis[1] * 100, -l_axis[2] * 100])
Lstararrowend = roundoff(
[l_axis[0] * 100, l_axis[1] * 100, l_axis[2] * 100])
Lstararrowtxt = roundoff(
[l_axis[0] * 102, l_axis[1] * 102, l_axis[2] * 102])
# make arrow font size roughly proportional to radius of highest resolution shell
fontsize = str(1.0 + roundoff(
math.pow(max(self.miller_array.index_span().max()), 1.0 / 3.0)))
arrowstr = """
// xyz arrows
shape.addSphere( [0,0,0] , [ 1, 1, 1 ], 0.3, 'Origo');
//blue-x
shape.addArrow( %s, %s , [ 0, 0, 1 ], 0.1);
//green-y
shape.addArrow( %s, %s , [ 0, 1, 0 ], 0.1);
//red-z
shape.addArrow( %s, %s , [ 1, 0, 0 ], 0.1);
shape.addText( %s, [ 0, 0, 1 ], %s, 'h');
shape.addText( %s, [ 0, 1, 0 ], %s, 'k');
shape.addText( %s, [ 1, 0, 0 ], %s, 'l');
""" % (str(Hstararrowstart), str(Hstararrowend), str(Kstararrowstart),
str(Kstararrowend), str(Lstararrowstart), str(Lstararrowend),
Hstararrowtxt, fontsize, Kstararrowtxt, fontsize, Lstararrowtxt,
fontsize)
# Make colour gradient array used for drawing a bar of colours next to associated values on the rendered html
mincolourscalar = self.othermindata[self.icolourcol]
maxcolourscalar = self.othermaxdata[self.icolourcol]
if self.settings.sigma_color:
mincolourscalar = self.otherminsigmas[self.icolourcol]
maxcolourscalar = self.othermaxsigmas[self.icolourcol]
span = maxcolourscalar - mincolourscalar
ln = 60
incr = span / ln
colourgradarrays = []
val = mincolourscalar
colourscalararray = flex.double()
colourscalararray.append(val)
for j, sc in enumerate(range(ln)):
val += incr
colourscalararray.append(val)
if self.otherscenes[self.icolourcol].miller_array.is_complex_array():
# When displaying phases from map coefficients together with fom values
# compute colour map chart as a function of fom and phase values (x,y axis)
incr = 360.0 / ln
val = 0.0
colourscalararray = flex.double()
colourscalararray.append(val)
for j in enumerate(range(ln)):
val += incr
colourscalararray.append(val)
fomarrays = []
if self.otherscenes[self.icolourcol].isUsingFOMs():
fomln = 50
fom = 1.0
fomdecr = 1.0 / (fomln - 1.0)
# make fomln fom arrays of size len(colourscalararray) when calling colour_by_phi_FOM
for j in range(fomln):
fomarrays.append(flex.double(len(colourscalararray), fom))
fom -= fomdecr
for j in range(fomln):
colourgradarrays.append(
graphics_utils.colour_by_phi_FOM(
colourscalararray *
(math.pi / 180.0), fomarrays[j]) * 255.0)
else:
fomln = 1
fomarrays = [1.0]
colourgradarrays.append(
graphics_utils.colour_by_phi_FOM(colourscalararray *
(math.pi / 180.0)) *
255.0)
else:
fomln = 1
fomarrays = [1.0]
colourgradarrays.append(
graphics_utils.color_by_property(
properties=flex.double(colourscalararray),
selection=flex.bool(len(colourscalararray), True),
color_all=False,
gradient_type=self.settings.color_scheme) * 255.0)
colors = self.otherscenes[self.icolourcol].colors
radii = self.otherscenes[self.iradiicol].radii
points = self.scene.points
hkls = self.scene.indices
dres = self.scene.dres
colstr = self.scene.miller_array.info().label_string()
data = self.scene.data
colourlabel = self.otherscenes[self.icolourcol].colourlabel
fomlabel = self.otherscenes[self.icolourcol].fomlabel
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
assert (colors.size() == radii.size() == nrefls)
colours = []
positions = []
radii2 = []
spbufttips = []
self.workingbinvals = []
if not self.binarray == "Resolution":
ibinarray = int(self.binarray)
self.workingbinvals = [
self.othermindata[ibinarray] - 0.1,
self.othermaxdata[ibinarray] + 0.1
]
self.workingbinvals.extend(self.binvals)
self.workingbinvals.sort()
if self.workingbinvals[0] < 0.0:
self.workingbinvals.append(0.0)
self.workingbinvals.sort()
bindata = self.otherscenes[ibinarray].data
if self.otherscenes[ibinarray].work_array.is_complex_array():
bindata = self.otherscenes[ibinarray].ampl
else:
self.workingbinvals = self.binvals
colstr = "dres"
bindata = 1.0 / dres
self.nbin = len(self.workingbinvals)
for ibin in range(self.nbin):
colours.append([]) # colours and positions are 3 x size of data()
positions.append([])
radii2.append([])
spbufttips.append([])
def data2bin(d):
for ibin, binval in enumerate(self.workingbinvals):
if (ibin + 1) == self.nbin:
return ibin
if d > binval and d <= self.workingbinvals[ibin + 1]:
return ibin
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
raise Sorry("Should never get here")
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
for i, hklstars in enumerate(points):
# bin currently displayed data according to the values of another miller array
ibin = data2bin(bindata[i])
spbufttip = 'H,K,L: %s, %s, %s' % (hkls[i][0], hkls[i][1],
hkls[i][2])
spbufttip += '\ndres: %s ' % str(roundoff(dres[i]))
spbufttip += '\' + AA + \''
for j, otherscene in enumerate(self.otherscenes):
ocolstr = self.proc_arrays[j].info().label_string()
odata = otherscene.data
od = ""
if self.proc_arrays[j].is_complex_array():
if not math.isnan(otherscene.foms[i]):
od = str(roundoff(otherscene.ampl[i])) + ", " + str(roundoff(otherscene.phases[i]) ) + \
"\' + DGR + \'" + ", " + str(roundoff(otherscene.foms[i]) )
else:
od = str(roundoff(otherscene.ampl[i])) + ", " + str(roundoff(otherscene.phases[i]) ) + \
"\' + DGR + \'"
elif self.proc_arrays[j].sigmas() is not None:
od = str(roundoff(odata[i])) + ", " + str(
roundoff(otherscene.sigmas[i]))
else:
od = str(roundoff(odata[i]))
if not (math.isnan(abs(odata[i]))
or odata[i] == display.inanval):
spbufttip += "\n%s: %s" % (ocolstr, od)
positions[ibin].extend(roundoff(list(hklstars)))
colours[ibin].extend(roundoff(list(colors[i]), 2))
radii2[ibin].append(roundoff(radii[i], 2))
spbufttips[ibin].append(spbufttip)
spherebufferstr = """
ttips = new Array(%d)
positions = new Array(%d)
colours = new Array(%d)
radii = new Array(%d)
spherebufs = new Array(%d)
""" % (self.nbin, self.nbin, self.nbin, self.nbin, self.nbin)
negativeradiistr = ""
cntbin = 0
self.binstrs = []
for ibin in range(self.nbin):
mstr = ""
nreflsinbin = len(radii2[ibin])
if (ibin + 1) < self.nbin and nreflsinbin > 0:
bin1 = self.workingbinvals[ibin]
bin2 = self.workingbinvals[ibin + 1]
if colstr == "dres":
bin1 = 1.0 / self.workingbinvals[ibin]
bin2 = 1.0 / self.workingbinvals[ibin + 1]
mstr= "bin:%d, %d reflections with %s in ]%2.2f; %2.2f]" %(cntbin, nreflsinbin, \
colstr, bin1, bin2)
self.binstrs.append(mstr)
self.mprint(mstr, verbose=True)
spherebufferstr += """
// %s
ttips[%d] = %s
positions[%d] = new Float32Array( %s )
colours[%d] = new Float32Array( %s )
radii[%d] = new Float32Array( %s )
spherebufs[%d] = new NGL.SphereBuffer({
position: positions[%d],
color: colours[%d],
radius: radii[%d],
picking: ttips[%d],
})
//}, { disableImpostor: true }) // if true allows wireframe spheres but does not allow resizing spheres
shape.addBuffer(spherebufs[%d])
""" %(mstr, cntbin, str(spbufttips[ibin]).replace('\"', '\''), \
cntbin, str(positions[ibin]), cntbin, str(colours[ibin]), \
cntbin, str(radii2[ibin]), cntbin, cntbin, cntbin, cntbin, cntbin, cntbin )
if self.workingbinvals[ibin] < 0.0:
negativeradiistr += "spherebufs[%d].setParameters({metalness: 1})\n" % cntbin
cntbin += 1
spherebufferstr += """
// create tooltip element and add to the viewer canvas
tooltip = document.createElement("div");
Object.assign(tooltip.style, {
display: "none",
position: "absolute",
zIndex: 10,
pointerEvents: "none",
backgroundColor: "rgba(255, 255, 255, 0.75)",
color: "black",
padding: "0.1em",
fontFamily: "sans-serif"
});
stage.viewer.container.appendChild(tooltip);
// listen to `hovered` signal to move tooltip around and change its text
stage.signals.hovered.add(function (pickingProxy) {
if (pickingProxy && (Object.prototype.toString.call(pickingProxy.picker) === '[object Array]' )){
var sphere = pickingProxy.sphere;
var cp = pickingProxy.canvasPosition;
tooltip.innerText = pickingProxy.picker[pickingProxy.pid];
tooltip.style.bottom = cp.y + 7 + "px";
tooltip.style.left = cp.x + 8 + "px";
tooltip.style.fontSize = "smaller";
tooltip.style.display = "block";
}else{
tooltip.style.display = "none";
}
});
stage.signals.clicked.add(function (pickingProxy) {
if (pickingProxy && (Object.prototype.toString.call(pickingProxy.picker) === '[object Array]' )){
var innerText = pickingProxy.picker[pickingProxy.pid];
mysocket.send( innerText);
}
});
"""
colourgradstrs = "colourgradvalarray = new Array(%s)\n" % fomln
# if displaying phases from map coefficients together with fom values then
for g, colourgradarray in enumerate(colourgradarrays):
self.colourgradientvalues = []
for j, e in enumerate(colourgradarray):
self.colourgradientvalues.append([colourscalararray[j], e])
self.colourgradientvalues = roundoff(self.colourgradientvalues)
fom = fomarrays[g]
colourgradstr = []
for j, val in enumerate(self.colourgradientvalues):
vstr = ""
alpha = 1.0
gradval = "rgba(%s, %s, %s, %s)" % (val[1][0], val[1][1],
val[1][2], alpha)
if j % 10 == 0 or j == len(self.colourgradientvalues) - 1:
vstr = str(roundoff(val[0], 2))
colourgradstr.append([vstr, gradval])
colourgradstrs += " colourgradvalarray[%s] = %s\n" % (
g, str(colourgradstr))
#negativeradiistr = ""
#for ibin in range(self.nbin):
# if self.workingbinvals[ibin] < 0.0:
# negativeradiistr += "spherebufs[%d].setParameters({metalness: 1})\n" %ibin
self.NGLscriptstr = """
// Microsoft Edge users follow instructions on
// https://stackoverflow.com/questions/31772564/websocket-to-localhost-not-working-on-microsoft-edge
// to enable websocket connection
var pagename = location.pathname.substring(1);
var mysocket = new WebSocket('ws://127.0.0.1:7894/');
mysocket.onopen = function (e) {
mysocket.send('%s now connected via websocket to ' + pagename + '\\n');
};
mysocket.onclose = function (e) {
mysocket.send('%s now disconnecting from websocket ' + pagename + '\\n');
};
// Log errors to debugger of your browser
mysocket.onerror = function (error) {
console.log('WebSocket Error ' + error);
};
window.addEventListener( 'resize', function( event ){
stage.handleResize();
}, false );
var stage;
var shape;
var shapeComp;
var repr;
var AA = String.fromCharCode(197); // short for angstrom
var DGR = String.fromCharCode(176); // short for degree symbol
function createElement (name, properties, style) {
// utility function used in for loop over colourgradvalarray
var el = document.createElement(name)
Object.assign(el, properties)
Object.assign(el.style, style)
Object.assign(el.style, {
display: "block",
position: "absolute",
color: "black",
fontFamily: "sans-serif",
fontSize: "smaller",
}
)
return el
}
function addElement (el) {
// utility function used in for loop over colourgradvalarray
Object.assign(el.style, {
position: "absolute",
zIndex: 10
})
stage.viewer.container.appendChild(el)
}
function addDivBox(txt, t, l, w, h, bgcolour='rgba(255.0, 255.0, 255.0, 0.0)') {
divbox = createElement("div",
{
innerText: txt
},
{
backgroundColor: bgcolour,
color: 'rgba(0.0, 0.0, 0.0, 1.0)',
top: t.toString() + "px",
left: l.toString() + "px",
width: w.toString() + "px",
height: h.toString() + "px",
}
);
addElement(divbox)
}
var hklscene = function () {
shape = new NGL.Shape('shape');
stage = new NGL.Stage('viewport', { backgroundColor: "grey", tooltip:false,
fogNear: 100, fogFar: 100 });
stage.setParameters( { cameraType: "%s" } );
%s
%s
shapeComp = stage.addComponentFromObject(shape);
repr = shapeComp.addRepresentation('buffer');
shapeComp.autoView();
repr.update()
// if some radii are negative draw them with wireframe
%s
//colourgradvalarrays
%s
var ih = 3;
var topr = 35
var topr2 = 10
var lp = 10
var wp = 40
var lp2 = lp + wp
var gl = 3
var wp2 = gl
var fomlabelheight = 25
if (colourgradvalarray.length === 1) {
wp2 = 15
fomlabelheight = 0
}
var wp3 = wp + colourgradvalarray.length * wp2 + 2
totalheight = ih*colourgradvalarray[0].length + 35 + fomlabelheight
// make a white box on top of which boxes with transparent background are placed
// containing the colour values at regular intervals as well as label legend of
// the displayed miller array
addDivBox("", topr2, lp, wp3, totalheight, 'rgba(255.0, 255.0, 255.0, 1.0)');
// print label of the miller array used for colouring
addDivBox("%s", topr2, lp, wp, 20);
if (colourgradvalarray.length > 1) {
// print FOM label, 1, 0.5 and 0.0 values below colour chart
fomtop = topr2 + totalheight - 18
fomlp = lp + wp
fomwp = wp3
fomtop2 = fomtop - 13
// print the 1 number
addDivBox("1", fomtop2, fomlp, fomwp, 20)
// print the 0.5 number
leftp = fomlp + 0.48 * gl * colourgradvalarray.length
addDivBox("0.5", fomtop2, leftp, fomwp, 20)
// print the FOM label
addDivBox("%s", fomtop, leftp, fomwp, 20);
// print the 0 number
leftp = fomlp + 0.96 * gl * colourgradvalarray.length
addDivBox("0", fomtop2, leftp, fomwp, 20)
}
for (j = 0; j < colourgradvalarray[0].length; j++) {
rgbcol = colourgradvalarray[0][j][1];
val = colourgradvalarray[0][j][0]
topv = j*ih + topr
toptxt = topv - 5
// print value of miller array if present in colourgradvalarray[0][j][0]
addDivBox(val, toptxt, lp, wp, ih);
}
// draw the colour gradient
for (g = 0; g < colourgradvalarray.length; g++) {
leftp = g*gl + lp + wp
// if FOM values are supplied draw colour gradients with decreasing
// saturation values as stored in the colourgradvalarray[g] arrays
for (j = 0; j < colourgradvalarray[g].length; j++) {
rgbcol = colourgradvalarray[g][j][1];
val = colourgradvalarray[g][j][0]
topv = j*ih + topr
addDivBox("", topv, leftp, wp2, ih, rgbcol);
}
}
}
document.addEventListener('DOMContentLoaded', function() { hklscene() }, false );
mysocket.onmessage = function (e) {
//alert('Server: ' + e.data);
var c
var alpha
var si
mysocket.send('got ' + e.data ); // tell server what it sent us
try {
val = e.data.split(",")
if (val[0] === "alpha") {
ibin = parseInt(val[1])
alpha = parseFloat(val[2])
spherebufs[ibin].setParameters({opacity: alpha})
stage.viewer.requestRender()
}
if (val[0] === "colour") {
ibin = parseInt(val[1])
si = parseInt(val[2])
colours[ibin][3*si] = parseFloat(val[3])
colours[ibin][3*si+1] = parseFloat(val[4])
colours[ibin][3*si+2] = parseFloat(val[5])
spherebufs[ibin].setAttributes({ color: colours[ibin] })
stage.viewer.requestRender()
}
if (val[0] === "Redraw") {
stage.viewer.requestRender()
}
if (val[0] === "ReOrient") {
mysocket.send( 'Reorienting ' + pagename );
sm = new Float32Array(16);
for (j=0; j<16; j++)
sm[j] = parseFloat(val[j + 2]) // first 2 are "ReOrient", "NGL\\n"
var m = new NGL.Matrix4();
m.fromArray(sm);
stage.viewerControls.orient(m);
stage.viewer.requestRender();
}
if (val[0] === "Reload") {
// refresh browser with the javascript file
cvorient = stage.viewerControls.getOrientation().elements
msg = String(cvorient)
mysocket.send('Current vieworientation:\\n, ' + msg );
mysocket.send( 'Refreshing ' + pagename );
window.location.reload(true);
}
if (val[0] === "Testing") {
// test something new
mysocket.send( 'Testing something new ' + pagename );
var newradii = radii[0].map(function(element) {
return element*1.5;
});
spherebufs[0].setAttributes({
radius: newradii
})
stage.viewer.requestRender()
}
}
catch(err) {
mysocket.send('error: ' + err );
}
};
""" % (self.__module__, self.__module__, self.cameratype, arrowstr, spherebufferstr, \
negativeradiistr, colourgradstrs, colourlabel, fomlabel)
if self.jscriptfname:
with open(self.jscriptfname, "w") as f:
f.write(self.NGLscriptstr)
self.ReloadNGL()
def OnConnectWebsocketClient(self, client, server):
#if not self.websockclient:
self.websockclient = client
self.mprint("Browser connected:" + str(self.websockclient),
self.verbose)
#else:
# self.mprint( "Unexpected browser connection was rejected" )
def OnWebsocketClientMessage(self, client, server, message):
if message != "":
self.mprint(message, verbose=False)
self.lastmsg = message
if "Current vieworientation:" in message:
# The NGL.Matrix4 with the orientation is a list of floats.
self.viewmtrxelms = message[message.find("\n"):]
sleep(0.2)
self.mprint("Reorienting client after refresh:" +
str(self.websockclient))
if not self.isnewfile:
self.pendingmessage = u"ReOrient, NGL" + self.viewmtrxelms
self.isnewfile = False
def WebBrowserMsgQueue(self):
while True:
sleep(1)
if hasattr(self, "pendingmessage") and self.pendingmessage:
self.SendWebSockMsg(self.pendingmessage)
self.pendingmessage = None
def StartWebsocket(self):
self.server = WebsocketServer(7894, host='127.0.0.1')
if not self.server:
raise Sorry("Could not connect socket to web browser")
self.server.set_fn_new_client(self.OnConnectWebsocketClient)
self.server.set_fn_message_received(self.OnWebsocketClientMessage)
self.wst = threading.Thread(target=self.server.run_forever)
self.wst.daemon = True
self.wst.start()
self.msgqueuethrd = threading.Thread(target=self.WebBrowserMsgQueue)
self.msgqueuethrd.daemon = True
self.msgqueuethrd.start()
def SendWebSockMsg(self, msg):
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
#print "self.server.clients: ", self.server.clients
#print "self.websockclient: ",
if self.websockclient:
while "Refreshing" in self.lastmsg:
sleep(0.5)
self.lastmsg = ""
self.server.send_message(self.websockclient, msg)
else:
self.OpenBrowser()
def SetOpacity(self, bin, alpha):
if bin > self.nbin:
self.mprint("There are only %d bins of data present" % self.nbin)
return
msg = u"alpha, %d, %f" % (bin, alpha)
self.SendWebSockMsg(msg)
def RedrawNGL(self):
self.SendWebSockMsg(u"Redraw, NGL\n")
def ReloadNGL(self): # expensive as javascript may be several Mbytes large
self.mprint("Rendering NGL JavaScript...")
self.SendWebSockMsg(u"Reload, NGL\n")
def OpenBrowser(self):
NGLlibpath = libtbx.env.under_root(
os.path.join("modules", "cctbx_project", "crys3d", "hklview",
"ngl.js"))
htmlstr = self.hklhtml % (NGLlibpath, os.path.abspath(
self.jscriptfname))
htmlstr += self.htmldiv
with open(self.hklfname, "w") as f:
f.write(htmlstr)
self.url = "file://" + os.path.abspath(self.hklfname)
self.mprint(
"Writing %s and connecting to its websocket client" %
self.hklfname, self.verbose)
if self.UseOSBrowser:
webbrowser.open(self.url, new=1)
self.isnewfile = False
def TestNewFunction(self):
self.SendWebSockMsg(u"Testing, NGL\n")
# print 'car position did not change'
pos_check = 0
idx0 = string_list[1].find("[")
car_orient_tmp = eval(string_list[1][idx0:])
orient_check = 1
if np.linalg.norm(np.array(car_orient_tmp) - np.array(car_orient)) < 0.05:
# print 'car orientation did not change'
pos_check = 0
if car_pos_tmp == [0, 0] and car_orient_tmp == [1, 0]:
return
car_pos = car_pos_tmp
car_orient = car_orient_tmp
new_car_param = pos_check + orient_check
if new_car_param < 2:
new_car_param = 0
else:
new_car_param = 1
server = WebsocketServer(9090, host='172.27.163.216')
server.set_fn_new_client(new_client)
server.set_fn_message_received(new_message)
server.set_fn_client_left(client_left)
path_pub = rospy.Publisher('web_socket/path', String, queue_size=1)
rospy.Subscriber('lane_driver/path', String, callback_path)
rospy.Subscriber("lane_driver/car", String, callback_car)
rospy.Subscriber("drive_param_fin", drive_param, callback_drive)
update_thread = Update()
server.run_forever()
def SocketServerStart():
server = WebsocketServer(SOCKET_PORT, HOST)
server.set_fn_new_client(NewClient)
server.set_fn_client_left(ClientLeft)
server.set_fn_message_received(MessageReceived)
server.run_forever()
class Template:
# Initialize class variables
# self.time_cycle to run an execution for atleast 1 second
# self.process for the current running process
def __init__(self):
self.thread = None
self.reload = False
# Time variables
self.time_cycle = 80
self.ideal_cycle = 80
self.iteration_counter = 0
self.frequency_message = {'brain': '', 'gui': ''}
self.server = None
self.client = None
self.host = sys.argv[1]
# Initialize the GUI and Console behind the scenes
self.hal = HAL()
self.gui = GUI(self.host, self.hal)
# Function for saving
def save_code(self, source_code):
with open('code/academy.py', 'w') as code_file:
code_file.write(source_code)
# Function for loading
def load_code(self):
with open('code/academy.py', 'r') as code_file:
source_code = code_file.read()
return source_code
# Function to parse the code
# A few assumptions:
# 1. The user always passes sequential and iterative codes
# 2. Only a single infinite loop
def parse_code(self, source_code):
# Check for save/load
if (source_code[:5] == "#save"):
source_code = source_code[5:]
self.save_code(source_code)
return "", "", 1
elif (source_code[:5] == "#load"):
source_code = source_code + self.load_code()
self.server.send_message(self.client, source_code)
return "", "", 1
elif (source_code[:5] == "#resu"):
restart_simulation = rospy.ServiceProxy('/gazebo/unpause_physics',
Empty)
restart_simulation()
return "", "", 1
elif (source_code[:5] == "#paus"):
pause_simulation = rospy.ServiceProxy('/gazebo/pause_physics',
Empty)
pause_simulation()
return "", "", 1
elif (source_code[:5] == "#rest"):
reset_simulation = rospy.ServiceProxy('/gazebo/reset_world', Empty)
reset_simulation()
self.gui.reset_gui()
return "", ""
else:
# Get the frequency of operation, convert to time_cycle and strip
sequential_code, iterative_code = self.seperate_seq_iter(
source_code)
return iterative_code, sequential_code
# Function to parse code according to the debugging level
def debug_parse(self, source_code, debug_level):
if (debug_level == 1):
# If debug level is 0, then all the GUI operations should not be called
source_code = re.sub(r'GUI\..*', '', source_code)
return source_code
# Function to seperate the iterative and sequential code
def seperate_seq_iter(self, source_code):
if source_code == "":
return "", ""
# Search for an instance of while True
infinite_loop = re.search(r'[^ \t]while\(True\):|[^ \t]while True:',
source_code)
# Seperate the content inside while True and the other
# (Seperating the sequential and iterative part!)
try:
start_index = infinite_loop.start()
iterative_code = source_code[start_index:]
sequential_code = source_code[:start_index]
# Remove while True: syntax from the code
# And remove the the 4 spaces indentation before each command
iterative_code = re.sub(r'[^ ]while\(True\):|[^ ]while True:', '',
iterative_code)
iterative_code = re.sub(r'^[ ]{4}', '', iterative_code, flags=re.M)
except:
sequential_code = source_code
iterative_code = ""
return sequential_code, iterative_code
# The process function
def process_code(self, source_code):
# Redirect the information to console
start_console()
# Reference Environment for the exec() function
iterative_code, sequential_code = self.parse_code(source_code)
# print("The debug level is " + str(debug_level)
# print(sequential_code)
# print(iterative_code)
# The Python exec function
# Run the sequential part
gui_module, hal_module = self.generate_modules()
reference_environment = {"GUI": gui_module, "HAL": hal_module}
exec(sequential_code, reference_environment)
# Run the iterative part inside template
# and keep the check for flag
while self.reload == False:
start_time = datetime.now()
# Execute the iterative portion
exec(iterative_code, reference_environment)
# Template specifics to run!
finish_time = datetime.now()
dt = finish_time - start_time
ms = (dt.days * 24 * 60 * 60 +
dt.seconds) * 1000 + dt.microseconds / 1000.0
# Keep updating the iteration counter
if (iterative_code == ""):
self.iteration_counter = 0
else:
self.iteration_counter = self.iteration_counter + 1
# The code should be run for atleast the target time step
# If it's less put to sleep
if (ms < self.time_cycle):
time.sleep((self.time_cycle - ms) / 1000.0)
close_console()
print("Current Thread Joined!")
# Function to generate the modules for use in ACE Editor
def generate_modules(self):
# Define HAL module
hal_module = imp.new_module("HAL")
hal_module.HAL = imp.new_module("HAL")
# Add HAL functions
hal_module.HAL.getImage = self.hal.getImage
hal_module.HAL.graficToOptical = self.hal.graficToOptical
hal_module.HAL.backproject = self.hal.backproject
hal_module.HAL.getCameraPosition = self.hal.getCameraPosition
hal_module.HAL.project = self.hal.project
hal_module.HAL.opticalToGrafic = self.hal.opticalToGrafic
hal_module.HAL.project3DScene = self.hal.project3DScene
# Define GUI module
gui_module = imp.new_module("GUI")
gui_module.GUI = imp.new_module("GUI")
# Add GUI functions
gui_module.GUI.showImages = self.gui.showImages
gui_module.GUI.ShowNewPoints = self.gui.ShowNewPoints
gui_module.GUI.ShowAllPoints = self.gui.ShowAllPoints
gui_module.GUI.showImageMatching = self.gui.showImageMatching
gui_module.GUI.ClearAllPoints = self.gui.ClearAllPoints
# Adding modules to system
# Protip: The names should be different from
# other modules, otherwise some errors
sys.modules["HAL"] = hal_module
sys.modules["GUI"] = gui_module
return gui_module, hal_module
# Function to measure the frequency of iterations
def measure_frequency(self):
previous_time = datetime.now()
# An infinite loop
while self.reload == False:
# Sleep for 2 seconds
time.sleep(2)
# Measure the current time and subtract from the previous time to get real time interval
current_time = datetime.now()
dt = current_time - previous_time
ms = (dt.days * 24 * 60 * 60 +
dt.seconds) * 1000 + dt.microseconds / 1000.0
previous_time = current_time
# Get the time period
try:
# Division by zero
self.ideal_cycle = ms / self.iteration_counter
except:
self.ideal_cycle = 0
# Reset the counter
self.iteration_counter = 0
# Function to generate and send frequency messages
def send_frequency_message(self):
# This function generates and sends frequency measures of the brain and gui
brain_frequency = 0
gui_frequency = 0
try:
brain_frequency = round(1000 / self.ideal_cycle, 1)
except ZeroDivisionError:
brain_frequency = 0
try:
gui_frequency = round(1000 / self.thread_gui.ideal_cycle, 1)
except ZeroDivisionError:
gui_frequency = 0
self.frequency_message["brain"] = brain_frequency
self.frequency_message["gui"] = gui_frequency
message = "#freq" + json.dumps(self.frequency_message)
self.server.send_message(self.client, message)
# Function to maintain thread execution
def execute_thread(self, source_code):
# Keep checking until the thread is alive
# The thread will die when the coming iteration reads the flag
if (self.thread != None):
while self.thread.is_alive() or self.measure_thread.is_alive():
pass
# Turn the flag down, the iteration has successfully stopped!
self.reload = False
# New thread execution
self.measure_thread = threading.Thread(target=self.measure_frequency)
self.thread = threading.Thread(target=self.process_code,
args=[source_code])
self.thread.start()
self.measure_thread.start()
print("New Thread Started!")
# Function to read and set frequency from incoming message
def read_frequency_message(self, message):
frequency_message = json.loads(message)
# Set brain frequency
frequency = float(frequency_message["brain"])
self.time_cycle = 1000.0 / frequency
# Set gui frequency
frequency = float(frequency_message["gui"])
self.thread_gui.time_cycle = 1000.0 / frequency
return
# The websocket function
# Gets called when there is an incoming message from the client
def handle(self, client, server, message):
if (message[:5] == "#freq"):
frequency_message = message[5:]
self.read_frequency_message(frequency_message)
self.send_frequency_message()
return
try:
# Once received turn the reload flag up and send it to execute_thread function
code = message
# print(repr(code))
self.reload = True
self.execute_thread(code)
except:
pass
# Function that gets called when the server is connected
def connected(self, client, server):
self.client = client
# Start the GUI update thread
self.thread_gui = ThreadGUI(self.gui)
self.thread_gui.start()
# Initialize the frequency message
self.send_frequency_message()
print(client, 'connected')
# Function that gets called when the connected closes
def handle_close(self, client, server):
print(client, 'closed')
def run_server(self):
self.server = WebsocketServer(port=1905, host=self.host)
self.server.set_fn_new_client(self.connected)
self.server.set_fn_client_left(self.handle_close)
self.server.set_fn_message_received(self.handle)
self.server.run_forever()
class Template:
# Initialize class variables
# self.time_cycle to run an execution for at least 1 second
# self.process for the current running process
def __init__(self):
self.thread = None
self.reload = False
# Time variables
self.time_cycle = 80
self.ideal_cycle = 80
self.iteration_counter = 0
self.real_time_factor = 0
self.frequency_message = {'brain': '', 'gui': '', 'rtf': ''}
self.server = None
self.client = None
self.host = sys.argv[1]
# Initialize the GUI, HAL and Console behind the scenes
self.hal = HAL()
self.gui = GUI(self.host, self.hal)
# Function for saving
def save_code(self, source_code):
with open('code/academy.py', 'w') as code_file:
code_file.write(source_code)
# Function for loading
def load_code(self):
with open('code/academy.py', 'r') as code_file:
source_code = code_file.read()
return source_code
# Function to parse the code
# A few assumptions:
# 1. The user always passes sequential and iterative codes
# 2. Only a single infinite loop
def parse_code(self, source_code):
# Check for save/load
if (source_code[:5] == "#save"):
source_code = source_code[5:]
self.save_code(source_code)
return "", ""
elif (source_code[:5] == "#load"):
source_code = source_code + self.load_code()
self.server.send_message(self.client, source_code)
return "", ""
elif (source_code[:5] == "#resu"):
restart_simulation = rospy.ServiceProxy('/gazebo/unpause_physics',
Empty)
restart_simulation()
return "", ""
elif (source_code[:5] == "#paus"):
pause_simulation = rospy.ServiceProxy('/gazebo/pause_physics',
Empty)
pause_simulation()
return "", ""
elif (source_code[:5] == "#rest"):
reset_simulation = rospy.ServiceProxy('/gazebo/reset_world', Empty)
reset_simulation()
self.gui.reset_gui()
return "", ""
else:
# Get the frequency of operation, convert to time_cycle and strip
try:
# Get the debug level and strip the debug part
debug_level = int(source_code[5])
source_code = source_code[12:]
except:
debug_level = 1
source_code = ""
source_code = self.debug_parse(source_code, debug_level)
# Pause and unpause
if (source_code == ""):
self.gui.lap.pause()
else:
self.gui.lap.unpause()
sequential_code, iterative_code = self.seperate_seq_iter(
source_code)
return iterative_code, sequential_code
# Function to parse code according to the debugging level
def debug_parse(self, source_code, debug_level):
if (debug_level == 1):
# If debug level is 0, then all the GUI operations should not be called
source_code = re.sub(r'GUI\..*', '', source_code)
return source_code
# Function to seperate the iterative and sequential code
def seperate_seq_iter(self, source_code):
if source_code == "":
return "", ""
# Search for an instance of while True
infinite_loop = re.search(r'[^ \t]while\(True\):|[^ \t]while True:',
source_code)
# Seperate the content inside while True and the other
# (Seperating the sequential and iterative part!)
try:
start_index = infinite_loop.start()
iterative_code = source_code[start_index:]
sequential_code = source_code[:start_index]
# Remove while True: syntax from the code
# And remove the the 4 spaces indentation before each command
iterative_code = re.sub(r'[^ ]while\(True\):|[^ ]while True:', '',
iterative_code)
iterative_code = re.sub(r'^[ ]{4}', '', iterative_code, flags=re.M)
except:
sequential_code = source_code
iterative_code = ""
return sequential_code, iterative_code
# The process function
def process_code(self, source_code):
# Redirect the information to console
start_console()
# Reference Environment for the exec() function
iterative_code, sequential_code = self.parse_code(source_code)
# Whatever the code is, first step is to just stop!
self.hal.motors.sendV(0)
self.hal.motors.sendW(0)
# print("The debug level is " + str(debug_level)
# print(sequential_code)
# print(iterative_code)
# The Python exec function
# Run the sequential part
gui_module, hal_module = self.generate_modules()
reference_environment = {"GUI": gui_module, "HAL": hal_module}
exec(sequential_code, reference_environment)
# Run the iterative part inside template
# and keep the check for flag
while self.reload == False:
start_time = datetime.now()
# Execute the iterative portion
exec(iterative_code, reference_environment)
# Template specifics to run!
finish_time = datetime.now()
dt = finish_time - start_time
ms = (dt.days * 24 * 60 * 60 +
dt.seconds) * 1000 + dt.microseconds / 1000.0
# Keep updating the iteration counter
if (iterative_code == ""):
self.iteration_counter = 0
else:
self.iteration_counter = self.iteration_counter + 1
# The code should be run for atleast the target time step
# If it's less put to sleep
if (ms < self.time_cycle):
time.sleep((self.time_cycle - ms) / 1000.0)
close_console()
print("Current Thread Joined!")
# Function to generate the modules for use in ACE Editor
def generate_modules(self):
# Define HAL module
hal_module = imp.new_module("HAL")
hal_module.HAL = imp.new_module("HAL")
hal_module.HAL.motors = imp.new_module("motors")
# Add HAL functions
hal_module.HAL.getPose3d = self.hal.pose3d.getPose3d
hal_module.HAL.getLaserData = self.hal.laser.getLaserData
hal_module.HAL.getImage = self.hal.getImage
hal_module.HAL.motors.sendV = self.hal.motors.sendV
hal_module.HAL.motors.sendW = self.hal.motors.sendW
# Define GUI module
gui_module = imp.new_module("GUI")
gui_module.GUI = imp.new_module("GUI")
# Add GUI functions
gui_module.GUI.showImage = self.gui.showImage
gui_module.GUI.map = self.gui.map
# Adding modules to system
# Protip: The names should be different from
# other modules, otherwise some errors
sys.modules["HAL"] = hal_module
sys.modules["GUI"] = gui_module
return gui_module, hal_module
# Function to measure the frequency of iterations
def measure_frequency(self):
previous_time = datetime.now()
# An infinite loop
while self.reload == False:
# Sleep for 2 seconds
time.sleep(2)
# Measure the current time and subtract from the previous time to get real time interval
current_time = datetime.now()
dt = current_time - previous_time
ms = (dt.days * 24 * 60 * 60 +
dt.seconds) * 1000 + dt.microseconds / 1000.0
previous_time = current_time
# Get the time period
try:
# Division by zero
self.ideal_cycle = ms / self.iteration_counter
except:
self.ideal_cycle = 0
# Reset the counter
self.iteration_counter = 0
self.send_frequency_message()
# Function to generate and send frequency messages
def send_frequency_message(self):
# This function generates and sends frequency measures of the brain and gui
brain_frequency = 0
gui_frequency = 0
try:
brain_frequency = round(1000 / self.ideal_cycle, 1)
except ZeroDivisionError:
brain_frequency = 0
try:
gui_frequency = round(1000 / self.thread_gui.ideal_cycle, 1)
except ZeroDivisionError:
gui_frequency = 0
self.frequency_message["brain"] = brain_frequency
self.frequency_message["gui"] = gui_frequency
self.frequency_message["rtf"] = self.real_time_factor
message = "#freq" + json.dumps(self.frequency_message)
self.server.send_message(self.client, message)
# Function to maintain thread execution
def execute_thread(self, source_code):
# Keep checking until the thread is alive
# The thread will die when the coming iteration reads the flag
if (self.thread != None):
while self.thread.is_alive() or self.measure_thread.is_alive():
pass
# Turn the flag down, the iteration has successfully stopped!
self.reload = False
# New thread execution
self.measure_thread = threading.Thread(target=self.measure_frequency)
self.thread = threading.Thread(target=self.process_code,
args=[source_code])
self.thread.start()
self.measure_thread.start()
print("New Thread Started!")
# Function to track the real time factor from Gazebo statistics
# https://stackoverflow.com/a/17698359
# (For reference, Python3 solution specified in the same answer)
def track_stats(self):
args = ["gz", "stats", "-p"]
# Prints gz statistics. "-p": Output comma-separated values containing-
# real-time factor (percent), simtime (sec), realtime (sec), paused (T or F)
stats_process = subprocess.Popen(args,
stdout=subprocess.PIPE,
bufsize=1)
# bufsize=1 enables line-bufferred mode (the input buffer is flushed
# automatically on newlines if you would write to process.stdin )
with stats_process.stdout:
for line in iter(stats_process.stdout.readline, b''):
stats_list = [x.strip() for x in line.split(',')]
self.real_time_factor = stats_list[0]
# Function to read and set frequency from incoming message
def read_frequency_message(self, message):
frequency_message = json.loads(message)
# Set brain frequency
frequency = float(frequency_message["brain"])
self.time_cycle = 1000.0 / frequency
# Set gui frequency
frequency = float(frequency_message["gui"])
self.thread_gui.time_cycle = 1000.0 / frequency
return
# The websocket function
# Gets called when there is an incoming message from the client
def handle(self, client, server, message):
if (message[:5] == "#freq"):
frequency_message = message[5:]
self.read_frequency_message(frequency_message)
time.sleep(1)
self.send_frequency_message()
return
try:
# Once received turn the reload flag up and send it to execute_thread function
code = message
# print(repr(code))
self.reload = True
self.execute_thread(code)
except:
pass
# Function that gets called when the server is connected
def connected(self, client, server):
self.client = client
# Start the GUI update thread
self.thread_gui = ThreadGUI(self.gui)
self.thread_gui.start()
# Start the real time factor tracker thread
self.stats_thread = threading.Thread(target=self.track_stats)
self.stats_thread.start()
# Initialize the ping message
self.send_frequency_message()
print(client, 'connected')
# Function that gets called when the connected closes
def handle_close(self, client, server):
print(client, 'closed')
def run_server(self):
self.server = WebsocketServer(port=1905, host=self.host)
self.server.set_fn_new_client(self.connected)
self.server.set_fn_client_left(self.handle_close)
self.server.set_fn_message_received(self.handle)
self.server.run_forever()
def __init__(self,PORT,HOST,LOGGING): server = WebsocketServer(PORT,HOST,LOGGING) 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()
close_and_clean_up(client, ws_server)
return
ws_key_browser = info["ws_key_browser"]
if ws_key_browser in msg_queue:
msg_queue[ws_key_browser]['finish'] = True
if msg_queue[ws_key_browser]['client'] is not None:
send_msg_safe(ws_server,
msg_queue[ws_key_browser]['client'],
{'operation': 'finish'})
# ws_server.send_message(msg_queue[ws_key_browser]['client'], json.dumps({"operation": "finish"}))
elif operation == 'close':
close_and_clean_up(client, ws_server)
else:
debug_logging("invalid operation from %s: %s" %
(client, operation))
print("invalid operation from %s: %s" % (client, operation))
close_and_clean_up(client, ws_server)
except Exception as e:
debug_logging("msg from %s parsing failed: %s" % (client, e))
print("msg from %s parsing failed: %s" % (client, e))
send_msg_safe(ws_server, client, {'operation': 'reconnect'})
# ws_server.send_message(client, json.dumps({'operation': 'reconnect'}))
close_and_clean_up(client, ws_server)
server = WebsocketServer(8080, host='127.0.0.1')
server.set_fn_new_client(new_client)
server.set_fn_message_received(handle_msg)
server.set_fn_client_left(close_and_clean_up)
server.run_forever()
json_data = json.dumps(clasificados)
server.send_message_to_all(json_data)
if obj['type'] == 'update':
id = clasificados[-1]["id"] + 1
clasificados.append({
'id':id,
'titulo':obj['titulo'],
'texto':obj['texto']
})
print("Clasificado agregado")
for clasificado in clasificados:
print(clasificado['id'])
print("\t"+clasificado['titulo'])
print("\t"+clasificado['texto'])
json_data = json.dumps(clasificados)
server.send_message_to_all(json_data)
#Configuración del servidor de web sockets
PORT=9001
server = WebsocketServer(PORT, host='127.0.0.1')
server.set_fn_new_client(entrada_cliente)
server.set_fn_client_left(salida_cliente)
server.set_fn_message_received(mensajeria)
server.run_forever()
class turnServer:
clientMap = {}
peerMap = {}
server = None
# 当新的客户端连接时会提示
def __init__(self):
print("new turne server")
def new_client(self, client, server):
print("当新的客户端连接时会提示:%s" % client['id'])
#self.server.send_message(client,"only for you")
server.send_message_to_all("Hey all, a new client has joined us")
#peerMap.put(peer.id,peer)
self.clientMap[client['id']] = client
print("ip:", client["address"])
#print("ip:",client["address"]["port"])
server.send_message(client, "only for you")
# 当旧的客户端离开
def client_left(self, client, server):
print("客户端%s断开" % client['id'])
#del self.clientMap[client['id']]
# 接收客户端的信息。
def message_received(self, client, server, message):
print("Client(%d) said: %s" % (client['id'], message))
server.send_message_to_all(message + "+server")
#这里要解析消息货到客户端信息
#JSONObject msg = new JSONObject(message);
#print("收到消息：" + message);
#int code = msg.optInt("code");
code = 0
return
if (0 == code): #login
#self.lgoin(client)
print("login")
elif (1 == code): #heartbeat
#self.heartbeat(peerId)
print("heartbeat")
elif (2 == code): #requst for hole
#self.sendForHole(peer)
print("requst for hole")
else:
print("unknow message")
def login(self, client):
peer = Peer(client, "ip", 8989)
self.peerMap.put(peer.id, peer)
def send(self, clientId, msg):
print("send message to client")
self.server.send_message(self.clientMap[clientId], msg)
'''
def sendForHole(peer):
#1.发送信息给B，让B给A发信息；
#2.B发送后，返回已经发送；
return server.send_message(peer,"")
def connect(peerA,peerB):
return sendForHole(peerB)
def heartbeat(peerId):
peer=peerMap.get(peerId)
peer.status=0;
peer.lastTime= date()
#1.收到clientA的请求
def requestConnetPeer(peerId):
peerB= peerMap.get(peerId)
if(null==peerB):
return false;
else:
#发起连接A和B
return connect(peerA,peerB)
return true
'''
def startWebsocket(self):
print("turnServer startWebsocket")
self.server = WebsocketServer(8131, "0.0.0.0")
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()
print("turnServer startWebsocket end")
class Template:
# Initialize class variables
# self.time_cycle to run an execution for atleast 1 second
# self.process for the current running process
def __init__(self):
self.thread = None
self.reload = False
# Time variables
self.time_cycle = 80
self.ideal_cycle = 80
self.iteration_counter = 0
self.server = None
self.client = None
self.host = sys.argv[1]
# Initialize the GUI, HAL and Console behind the scenes
self.console = console.Console()
self.gui = gui.GUI(self.host, self.console)
self.hal = hal.HAL()
# Function for saving
def save_code(self, source_code):
with open('code/academy.py', 'w') as code_file:
code_file.write(source_code)
# Function for loading
def load_code(self):
with open('code/academy.py', 'r') as code_file:
source_code = code_file.read()
return source_code
# Function to parse the code
# A few assumptions:
# 1. The user always passes sequential and iterative codes
# 2. Only a single infinite loop
def parse_code(self, source_code):
# Check for save/load
if (source_code[:5] == "#save"):
source_code = source_code[5:]
self.save_code(source_code)
return "", "", 1
elif (source_code[:5] == "#load"):
source_code = source_code + self.load_code()
self.server.send_message(self.client, source_code)
return "", "", 1
elif (source_code[:5] == "#rest"):
reset_simulation = rospy.ServiceProxy('/gazebo/reset_simulation',
Empty)
reset_simulation()
return "", "", 1
else:
# Get the frequency of operation, convert to time_cycle and strip
try:
partition = source_code[5:].partition("\n")
frequency = partition[0]
frequency = float(frequency)
self.time_cycle = 1000.0 / frequency
source_code = partition[2]
# Get the debug level and strip the debug part
debug_level = int(source_code[5])
source_code = source_code[5:]
except:
debug_level = 1
source_code = source_code[5]
source_code = self.debug_parse(source_code, debug_level)
sequential_code, iterative_code = self.seperate_seq_iter(
source_code)
return iterative_code, sequential_code, debug_level
# Function to parse code according to the debugging level
def debug_parse(self, source_code, debug_level):
if (debug_level == 1):
# If debug level is 0, then all the GUI operations should not be called
source_code = re.sub(r'GUI\..*', '', source_code)
return source_code
# Function to seperate the iterative and sequential code
def seperate_seq_iter(self, source_code):
if source_code == "":
return "", ""
# Search for an instance of while True
infinite_loop = re.search(r'[^ \t]while\(True\):|[^ \t]while True:',
source_code)
# Seperate the content inside while True and the other
# (Seperating the sequential and iterative part!)
try:
start_index = infinite_loop.start()
iterative_code = source_code[start_index:]
sequential_code = source_code[:start_index]
# Remove while True: syntax from the code
# And remove the the 4 spaces indentation before each command
iterative_code = re.sub(r'[^ ]while\(True\):|[^ ]while True:', '',
iterative_code)
iterative_code = re.sub(r'^[ ]{4}', '', iterative_code, flags=re.M)
except:
sequential_code = source_code
iterative_code = ""
return sequential_code, iterative_code
# The process function
def process_code(self, source_code):
# Reference Environment for the exec() function
reference_environment = {
'GUI': self.gui,
'HAL': self.hal,
'console': self.console,
'print': print_function
}
iterative_code, sequential_code, debug_level = self.parse_code(
source_code)
# print("The debug level is " + str(debug_level)
# print(sequential_code)
# print(iterative_code)
# Whatever the code is, first step is to just stop!
self.hal.motors.sendV(0)
try:
# The Python exec function
# Run the sequential part
exec(sequential_code, {
"gui": gui,
"hal": hal,
"time": time
}, reference_environment)
# Run the iterative part inside template
# and keep the check for flag
while self.reload == False:
self.server.send_message(self.client, "#pingRunning")
start_time = datetime.now()
# A few changes in the reference environment, to
# allow usage of the initialized API
reference_environment["GUI"] = self.gui
reference_environment["HAL"] = self.hal
# Execute the iterative portion
exec(iterative_code, reference_environment)
# Template specifics to run!
finish_time = datetime.now()
dt = finish_time - start_time
ms = (dt.days * 24 * 60 * 60 +
dt.seconds) * 1000 + dt.microseconds / 1000.0
# Keep updating the iteration counter
if (iterative_code == ""):
self.iteration_counter = 0
else:
self.iteration_counter = self.iteration_counter + 1
# The code should be run for atleast the target time step
# If it's less put to sleep
# If it's more no problem as such, but we can change it!
if (ms < self.time_cycle):
time.sleep((self.time_cycle - ms) / 1000.0)
print("Current Thread Joined!")
# To print the errors that the user submitted through the Javascript editor (ACE)
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
self.console.print(exc_value)
# Function to measure the frequency of iterations
def measure_frequency(self):
previous_time = datetime.now()
# An infinite loop
while self.reload == False:
# Sleep for 2 seconds
time.sleep(2)
# Measure the current time and subtract from the previous time to get real time interval
current_time = datetime.now()
dt = current_time - previous_time
ms = (dt.days * 24 * 60 * 60 +
dt.seconds) * 1000 + dt.microseconds / 1000.0
previous_time = current_time
# Get the time period
try:
# Division by zero
self.ideal_cycle = ms / self.iteration_counter
except:
self.ideal_cycle = 0
# Reset the counter
self.iteration_counter = 0
# Send to client
try:
self.server.send_message(
self.client,
"#freq" + str(round(1000 / self.ideal_cycle, 2)))
except ZeroDivisionError:
self.server.send_message(self.client, "#freq" + str(0))
# Function to maintain thread execution
def execute_thread(self, source_code):
# Keep checking until the thread is alive
# The thread will die when the coming iteration reads the flag
if (self.thread != None):
while self.thread.is_alive() or self.measure_thread.is_alive():
pass
# Turn the flag down, the iteration has successfully stopped!
self.reload = False
# New thread execution
self.measure_thread = threading.Thread(target=self.measure_frequency)
self.thread = threading.Thread(target=self.process_code,
args=[source_code])
self.thread.start()
self.measure_thread.start()
print("New Thread Started!")
# The websocket function
# Gets called when there is an incoming message from the client
def handle(self, client, server, message):
if (message == "#pong"):
return
try:
# Once received turn the reload flag up and send it to execute_thread function
code = message
# print(repr(code))
self.reload = True
self.execute_thread(code)
except:
pass
# Function that gets called when the server is connected
def connected(self, client, server):
self.client = client
# Start the GUI update thread
t = gui.ThreadGUI(self.gui)
t.daemon = True
t.start()
print(client, 'connected')
# Function that gets called when the connected closes
def handle_close(self, client, server):
print(client, 'closed')
def run_server(self):
self.server = WebsocketServer(port=1905, host=self.host)
self.server.set_fn_new_client(self.connected)
self.server.set_fn_client_left(self.handle_close)
self.server.set_fn_message_received(self.handle)
self.server.run_forever()
# 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()
print('Car connected')
class WebsocketServerModule(ModuleProcess):
def __init__(self, baseConfig, pInBoundQueue, pOutBoundQueue,
loggingQueue):
# super(WebsocketServerModule, self).__init__()
ModuleProcess.__init__(self, baseConfig, pInBoundQueue, pOutBoundQueue,
loggingQueue)
self.alive = False
self.config = baseConfig
self.inQueue = pInBoundQueue # inQueue are messages from the main process to websocket clients
self.outQueue = pOutBoundQueue # outQueue are messages from clients to main process
self.websocketServer = None
self.loggingQueue = loggingQueue
self.threadProcessQueue = None
# Configs
self.moduleConfig = configLoader.load(self.loggingQueue, __name__)
# Constants
self._port = self.moduleConfig['WebsocketPort']
self._host = self.moduleConfig['WebsocketHost']
# logging setup
self.logger = ThreadsafeLogger(loggingQueue, __name__)
def run(self):
""" Main thread entry point.
Sets up websocket server and event callbacks.
Starts thread to monitor inbound message queue.
"""
self.logger.info("Starting websocket server")
self.alive = True
self.listen()
self.websocketServer = WebsocketServer(self._port, host=self._host)
self.websocketServer.set_fn_new_client(self.new_websocket_client)
self.websocketServer.set_fn_message_received(
self.websocket_message_received)
self.websocketServer.run_forever()
def new_websocket_client(self, client, server):
""" Client joined callback - called whenever a new client joins. """
self.logger.debug("Client joined")
def websocket_message_received(self, client, server, message):
""" Message received callback - called whenever a new message is received. """
self.logger.debug('Message received: %s' % message)
message = json.loads(message)
self.logger.info("message jsond: %s" % message)
_msg = Message(topic=message['topic'], sender_id=message['sender_id'])
if 'sender_type' in message:
_msg.sender_type = message['sender_type']
if 'recipients' in message:
_msg.recipients = message['recipients']
if 'extended_data' in message:
_msg.extended_data = message['extended_data']
self.put_message(_msg)
def listen(self):
self.threadProcessQueue = Thread(target=self.process_queue)
self.threadProcessQueue.setDaemon(True)
self.threadProcessQueue.start()
def shutdown(self):
""" Handle shutdown message.
Close and shutdown websocket server.
Join queue processing thread.
"""
self.logger.info("Shutting down websocket server")
try:
self.logger.info("Closing websocket")
self.websocketServer.server_close()
except Exception as e:
self.logger.error("Websocket close error : %s " % e)
try:
self.logger.info("Shutdown websocket")
self.websocketServer.shutdown()
except Exception as e:
self.logger.error("Websocket shutdown error : %s " % e)
self.alive = False
self.threadProcessQueue.join()
time.sleep(1)
self.exit = True
def handle_message(self, message):
""" Send message to listening clients. """
self.websocketServer.send_message_to_all(json.dumps(message.__dict__))
def process_queue(self):
""" Monitor queue of messages from main process to this thread. """
while self.alive:
if (self.inQueue.empty() == False):
try:
message = self.inQueue.get(block=False, timeout=1)
if message is not None:
if (message.topic.upper() == "SHUTDOWN"
and message.sender_id.lower() == 'main'):
self.logger.debug("SHUTDOWN handled")
self.shutdown()
else:
self.handle_message(message)
except Exception as e:
self.logger.error("Websocket unable to read queue : %s " %
e)
else:
time.sleep(.25)
elif client2 is None:
print('connected client #2')
client2 = client
def handleClose(client):
global client1, client2
print('closed')
if client1 is client:
client1 = None
if client2 is client:
client2 = None
def new_client(client, server):
handleConnected(client)
def on_msg(client, server, msg):
handleMessage(client, server, msg)
def on_client_left(client, server):
handleClose(client)
server = WebsocketServer(8000, host='127.0.0.1', loglevel=logging.INFO)
server.set_fn_new_client(new_client)
server.set_fn_message_received(on_msg)
server.set_fn_client_left(on_client_left)
server.run_forever()
class GUI:
# Initialization function
# The actual initialization
def __init__(self, host, hal):
t = threading.Thread(target=self.run_server)
self.payload = {'map': ''}
self.server = None
self.client = None
self.host = host
self.acknowledge = False
self.acknowledge_lock = threading.Lock()
self.hal = hal
t.start()
# Create the lap object
pose3d_object = ListenerPose3d("/roombaROS/odom")
self.map = Map(pose3d_object)
# Explicit initialization function
# Class method, so user can call it without instantiation
@classmethod
def initGUI(cls, host, console):
# self.payload = {'image': '', 'shape': []}
new_instance = cls(host, console)
return new_instance
# Function to get the client
# Called when a new client is received
def get_client(self, client, server):
self.client = client
# Function to get value of Acknowledge
def get_acknowledge(self):
self.acknowledge_lock.acquire()
acknowledge = self.acknowledge
self.acknowledge_lock.release()
return acknowledge
# Function to get value of Acknowledge
def set_acknowledge(self, value):
self.acknowledge_lock.acquire()
self.acknowledge = value
self.acknowledge_lock.release()
# Update the gui
def update_gui(self):
# Payload Map Message
pos_message = self.map.getRobotCoordinates()
ang_message = self.map.getRobotAngle()
pos_message = str(pos_message + ang_message)
self.payload["map"] = pos_message
message = "#gui" + json.dumps(self.payload)
self.server.send_message(self.client, message)
# Function to read the message from websocket
# Gets called when there is an incoming message from the client
def get_message(self, client, server, message):
# Acknowledge Message for GUI Thread
if(message[:4] == "#ack"):
self.set_acknowledge(True)
# 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.get_message)
self.server.run_forever()
# Function to reset
def reset_gui(self):
self.map.reset()
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()
class GUI:
# Initialization function
# The actual initialization
def __init__(self, host, hal):
t = threading.Thread(target=self.run_server)
self.payload = {'image': '', 'map': '', 'array': ''}
self.server = None
self.client = None
self.host = host
self.image_to_be_shown = None
self.image_to_be_shown_updated = False
self.image_show_lock = threading.Lock()
self.array_lock = threading.Lock()
self.array = None
self.acknowledge = False
self.acknowledge_lock = threading.Lock()
self.mapXY = None
self.worldXY = None
# Take the console object to set the same websocket and client
self.hal = hal
t.start()
# Create the lap object
self.pose3d_object = ListenerPose3d("/taxi_holo/odom")
self.map = Map(self.pose3d_object)
# Function to get the client
# Called when a new client is received
def get_client(self, client, server):
self.client = client
# Function to get value of Acknowledge
def get_acknowledge(self):
self.acknowledge_lock.acquire()
acknowledge = self.acknowledge
self.acknowledge_lock.release()
return acknowledge
# Function to get value of Acknowledge
def set_acknowledge(self, value):
self.acknowledge_lock.acquire()
self.acknowledge = value
self.acknowledge_lock.release()
# encode the image data to be sent to websocket
def payloadImage(self):
self.image_show_lock.acquire()
image_to_be_shown_updated = self.image_to_be_shown_updated
image_to_be_shown = self.image_to_be_shown
self.image_show_lock.release()
image = image_to_be_shown
payload = {'image': '', 'shape': ''}
if (image_to_be_shown_updated == False):
return payload
shape = image.shape
frame = cv2.imencode('.PNG', image)[1]
encoded_image = base64.b64encode(frame)
payload['image'] = encoded_image.decode('utf-8')
payload['shape'] = shape
self.image_show_lock.acquire()
self.image_to_be_shown_updated = False
self.image_show_lock.release()
return payload
# load the image data
def showGPP(self, image):
self.image_show_lock.acquire()
self.image_to_be_shown = image
self.image_to_be_shown_updated = True
self.image_show_lock.release()
# Process the array(ideal path) to be sent to websocket
def showPath(self, array):
self.array_lock.acquire()
arr_shape = array.shape
three_dim = array.reshape(1, arr_shape[0], arr_shape[1])
strArray = np.array_str(three_dim)
# Remove unnecesary spaces in the array to avoid JSON syntax error in javascript
strArray = re.sub(r"\[[ ]+", "[", strArray)
strArray = re.sub(r"[ ]+", ", ", strArray)
strArray = re.sub(r",[ ]+]", "]", strArray)
self.array = strArray
self.array_lock.release()
# Update the gui
def update_gui(self):
# Payload Image Message
payload = self.payloadImage()
self.payload["image"] = json.dumps(payload)
self.payload["array"] = self.array
# Payload Map Message
pos_message1 = self.map.getTaxiCoordinates()
# print(self.pose3d_object.getPose3d())
ang_message = self.map.getTaxiAngle()
pos_message = str(pos_message1 + ang_message)
# print("pos2 : {} , ang : {}".format(pos_message,ang_message))
self.payload["map"] = pos_message
message = "#gui" + json.dumps(self.payload)
self.server.send_message(self.client, message)
return list(pos_message1)
# Function to read the message from websocket
# Gets called when there is an incoming message from the client
def get_message(self, client, server, message):
# Acknowledge Message for GUI Thread
if (message[:4] == "#ack"):
self.set_acknowledge(True)
# Check for mouse click data on the map
elif (message[:5] == "#pick"):
data = eval(message[5:])
self.mapXY = data["data"]
x, y = self.mapXY
worldx, worldy = self.map.gridToWorld(x, y)
self.worldXY = [worldx, worldy]
print("World : {}".format(self.worldXY))
# 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.get_message)
self.server.run_forever()
# Function to reset
def reset_gui(self):
self.map.reset()
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()
if mesaj == "pkliste":
#os.system("mps paketler --json")
subprocess.call(['mps', 'paketler', '--json'])
dosya_iletim("paket_liste", "/tmp/mps_paketler_listesi")
if mesaj == "pkgrupliste":
mps.gruplar()
mps.kos()
dosya_iletim("paket_grup_liste", "/tmp/mps_paket_grup_listesi")
if "grup_paketler=" in mesaj:
grup = mesaj.split("=")[1]
grup = tr_cevir(grup)
mps.grup_paketler(grup)
mps.kos()
dosya_iletim("grup_paketler_liste", "/tmp/mps_grup_paketler_listesi")
if mesaj == "sistem":
komut = "./sistem_bilgi.sh"
#genel_iletim(genel_kanal,komut)
#os.system('curl --request POST -H "Accept: text/json" http://127.0.0.1:36060 --data `./sistem_bilgi.sh`')
sunucu.send_message(istemci, "sistem bilgisi gönderildi")
if mesaj == "pingo":
os.system("killall borulama")
PORT = 36060
sunucu = WebsocketServer(PORT)
sunucu.set_fn_new_client(yeni_istemci)
sunucu.set_fn_client_left(istemci_cikis)
sunucu.set_fn_message_received(gelen_mesaj)
print("%s portunda mps websocket aracı sunucusu çalışıyor" % PORT)
sunucu.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)
sys.exit(0)
#================================================
#
# MAIN / INIT
#
#------------------------------------------------
signal.signal(signal.SIGINT, signal_handler)
print('Press Ctrl+C to exit')
server = WebsocketServer(12000, host="0.0.0.0")
server.set_fn_message_received(serv_recvParser)
serv_thread = Thread(target=server.run_forever, args=())
serv_thread.start()
strip = Adafruit_NeoPixel(300, 12, strip_type = ws.WS2811_STRIP_GRB)
strip.begin()
strip_order = range(strip.numPixels())
shuffle(strip_order)
while True:
looptime = time()
for idx in range(len(patterns)):
if patterns[idx][1].state > 0:
patterns[idx][1].step(strip)
if patterns[idx][0] >= 0:
if patterns[idx][0] == 1: # turn on
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))
from bootstrap_scrapers import bootstrap_scrapers
from provider_runner import run_movie_providers
from websocket_server import WebsocketServer
import json
providers = bootstrap_scrapers()
def get_movie(client, server, req):
tmdb_id = int(req)
existing_movies = []
def send_movies(movie_urls):
new_urls = filter(lambda url: url not in existing_movies, movie_urls)
existing_movies.extend(new_urls)
if len(movie_urls):
res = json.dumps({"type": "data", "data": movie_urls})
server.send_message(client, res)
def send_done():
res = json.dumps({"type": "done"})
server.send_message(client, res)
run_movie_providers(providers, tmdb_id, send_movies, send_done)
server = WebsocketServer(9996, host='0.0.0.0')
server.set_fn_message_received(get_movie)
server.run_forever()
#!/usr/bin/env python
from websocket_server import WebsocketServer
import hashlib
import os
def nuevo_cliente(client, server):
print("Cliente (%s) nuevo" % client['address'][0])
def mensaje_recibido(client, server, mensaje):
audio = hashlib.md5(client['address'][0]).hexdigest()
file = open("podcast/"+audio, "ab")
file.write(mensaje)
file.close()
def desconectado(client, server):
audio = hashlib.md5(client['address'][0]).hexdigest()
os.remove("podcast/"+audio)
print("Cliente (%s) desconectado" % client['address'][0])
PORT=9000
server = WebsocketServer(PORT,"192.168.1.2")
server.set_fn_new_client(nuevo_cliente)
server.set_fn_client_left(desconectado)
server.set_fn_message_received(mensaje_recibido)
server.run_forever()
class ConnectionManager:
def __init__(self,
host,
my_port,
callback,
sc_self=None,
cb=None,
cb2=None):
print('Initializing ConnectionManager...') #####
self.cb = cb #
self.cb2 = cb2
self.host = host
self.port = my_port
self.my_c_host = None
self.my_c_port = None
self.core_node_set = CoreNodeList()
self.edge_node_set = EdgeNodeList()
self.last_ping = {} ##
self.__add_peer((host, my_port))
self.mm = MessageManager()
self.callback = callback
self.my_host = self.__get_myip() ##
self.ws = WebsocketServer(port=my_port, host=self.my_host) ##
self.sc_self = sc_self ##
self.flag = 0 ##
# 待受を開始する際に呼び出される（ServerCore向け
def start(self):
# t = threading.Thread(target=self.__wait_for_access)
# t.start()
self.ping_timer_p = threading.Timer(PING_INTERVAL,
self.__check_peers_connection)
self.ping_timer_p.start()
self.ping_timer_e = threading.Timer(PING_INTERVAL,
self.__check_edges_connection)
self.ping_timer_e.start()
self.ws.set_fn_new_client(self.__new_client) ##
self.ws.set_fn_message_received(self.__ws_handle) ##
t = threading.Thread(target=self.ws.run_forever)
t.start()
def __ws_handle(self, client, server, message): ##
self.__handle_message((client, client['address'], message), server)
return
def __new_client(self, client, server): ##
print("%s is connected" % (client))
# ユーザが指定した既知のCoreノードへの接続（ServerCore向け
def join_network(self, host, port):
self.my_c_host = host
self.my_c_port = port
self.__connect_to_P2PNW(host, port)
def get_message_text(self, msg_type, payload=None):
"""
指定したメッセージ種別のプロトコルメッセージを作成して返却する
params:
msg_type : 作成したいメッセージの種別をMessageManagerの規定に従い指定
payload : メッセージにデータを格納したい場合に指定する
return:
msgtxt : MessageManagerのbuild_messageによって生成されたJSON形式のメッセージ
"""
msgtxt = self.mm.build(msg_type, self.port, payload)
print('generated_msg:', msgtxt + str("省略中"))
return msgtxt
# 指定されたノードに対してメッセージを送信する
def send_msg(self, peer, msg):
try:
ws4edge = create_connection("ws://" + str(peer[0]) + ":" +
str(peer[1]))
ws4edge.send(msg.encode())
ws4edge.close()
except OSError:
print('Connection failed for peer : ', peer)
self.__remove_peer(peer)
# Coreノードリストに登録されている全てのノードに対して同じメッセージをブロードキャストする
def send_msg_to_all_peer(self, msg):
print('send_msg_to_all_peer was called!')
current_list = self.core_node_set.get_list()
for peer in current_list:
if peer != (self.host, self.port):
print("message will be sent to ... ", peer)
self.send_msg(peer, msg)
# Edgeノードリストに登録されている全てのノードに対して同じメッセージをブロードキャストする
def send_msg_to_all_edge(self, msg):
print('send_msg_to_all_edge was called! ')
current_list = self.edge_node_set.get_list()
for edge in current_list:
print("message will be sent to ... ", edge)
self.send_msg(edge, msg)
# 終了前の処理としてソケットを閉じる
def connection_close(self):
pass
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((self.host, self.port))
self.socket.close()
s.close()
self.ping_timer_p.cancel()
self.ping_timer_e.cancel()
#離脱要求の送信
if self.my_c_host is not None:
msg = self.mm.build(MSG_REMOVE, self.port)
self.send_msg((self.my_c_host, self.my_c_port), msg)
def __connect_to_P2PNW(self, host, port):
msg = self.mm.build(MSG_ADD, self.port)
self.send_msg((host, port), msg)
def __wait_for_access(self):
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.bind((self.host, self.port))
self.socket.listen(0)
executor = ThreadPoolExecutor(max_workers=10)
while True:
print('Waiting for the connection ...')
soc, addr = self.socket.accept()
print('Connected by .. ', addr)
data_sum = ''
params = (soc, addr, data_sum)
executor.submit(self.__handle_message, params)
def __is_in_core_set(self, peer):
"""
与えられたnodeがCoreノードのリストに含まれているか？をチェックする
param:
peer : IPアドレスとポート番号のタプル
return:
True or False
"""
return self.core_node_set.has_this_peer(peer)
def __is_in_edge_set(self, peer):
return self.edge_node_set.has_this_edge(peer)
# 受信したメッセージを確認して、内容に応じた処理を行う。クラスの外からは利用しない想定
def __handle_message(self, params, server): #
soc, addr, data_sum = params
#Parse
result, reason, cmd, peer_port, payload = self.mm.parse(data_sum)
print("result, reason, cmd, peer_port, payload")
status = (result, reason)
if status == ('error', ERR_PROTOCOL_UNMATCH):
print('Error: Protocol name is not matched')
return
elif status == ('error', ERR_VERSION_UNMATCH):
print('Error: Protocol version is not matched')
return
elif status == ('ok', OK_WITHOUT_PAYLOAD):
if cmd == MSG_ADD:
print('ADD node request was received!!')
self.__add_peer((addr[0], peer_port))
if (addr[0], peer_port) == (self.host, self.port):
return
else:
cl = pickle.dumps(self.core_node_set.get_list(),
0).decode()
msg = self.mm.build(MSG_CORE_LIST, self.port, cl)
self.send_msg_to_all_peer(msg)
self.send_msg_to_all_edge(msg)
elif cmd == MSG_REMOVE:
print('REMOVE request was received!! from', addr[0], peer_port)
self.__remove_peer((addr[0], peer_port))
cl = pickle.dumps(self.core_node_set.get_list(), 0).decode()
msg = self.mm.build(MSG_CORE_LIST, self.port, cl)
self.send_msg_to_all_peer(msg)
self.send_msg_to_all_edge(msg)
##----PING
elif cmd == MSG_PING: ##
# 特にやること思いつかない
peer = (addr[0], peer_port)
if (self.__is_in_edge_set(peer)):
self.edge_node_set.ping_recv(peer)
print('----------------PING receive!!------------')
#print('List for Core nodes was requested!!')
cl = pickle.dumps(self.core_node_set.get_list(), 0).decode()
msg = self.mm.build(MSG_CORE_LIST, self.port, cl)
server.send_message(soc, msg.encode('utf-8'))
print("core node list sent")
return
elif cmd == MSG_REQUEST_CORE_LIST:
print('List for Core nodes was requested!!')
cl = pickle.dumps(self.core_node_set.get_list(), 0).decode()
msg = self.mm.build(MSG_CORE_LIST, self.port, cl)
self.send_msg((addr[0], peer_port), msg)
elif cmd == MSG_ADD_AS_EDGE:
edge = (addr[0], peer_port)
self.__add_edge_node(edge)
cl = pickle.dumps(self.core_node_set.get_list(), 0).decode()
msg = self.mm.build(MSG_CORE_LIST, self.port, cl)
self.send_msg((addr[0], peer_port), msg)
self.last_ping[edge] = time.time()
elif cmd == MSG_REMOVE_EDGE:
print('REMOVE_EDGE request was received!! from', addr[0],
peer_port)
self.__remove_edge_node((addr[0], peer_port))
elif cmd == Sync_DB3:
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■ Sync_DB3 handle ■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
cl = str(get_level_dir.get_late_dir_num(zip_p=ZIP_P))
msg = self.mm.build(Sync_DB4, self.port, cl)
self.send_msg((addr[0], peer_port), msg)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
elif cmd == Sync_DB4:
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■ Sync_DB4 handle ■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
new_node_dir = int(
get_level_dir.get_late_dir_num(zip_p=RE_ZIP_P))
latest_dir = int(json.loads(data_sum)["payload"])
if new_node_dir < latest_dir:
cl = new_node_dir + 1
self.flag = 0
msg = self.mm.build(Sync_DB5, self.port, cl)
self.send_msg((addr[0], peer_port), msg)
else:
if self.flag == 0:
get_level_dir.unfold_zip_dir(ldb_p=RE_LDB_P,
zip_p=RE_ZIP_P)
level_param.update_key(
RE_PARAM_P, level_param.latest_block_num(RE_LDB_P))
latest_db_bc = check_level_all.valid_all(RE_LDB_P)
else:
latest_db_bc = check_level_all.valid_all(RE_LDB_P)
if latest_db_bc:
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print("DB Valid Check OK !!!!")
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
if self.flag == 0:
print("■■■■■■■■ Start Sync ■■■■■■■■■")
self.sc_self.get_all_chains_for_resolve_conflict()
self.flag = 1
if "genesis_block" in self.sc_self.bm.chain[0]:
msg = self.mm.build(Sync_DB5, self.port,
str(latest_dir))
self.send_msg((addr[0], peer_port), msg)
elif not check_level_all.is_valid_chain(
[latest_db_bc[0], self.sc_self.bm.chain[0]]):
msg = self.mm.build(Sync_DB5, self.port,
str(latest_dir))
self.send_msg((addr[0], peer_port), msg)
else:
if check_level_all.is_valid_chain([
latest_db_bc[0],
self.sc_self.bm.chain[0]
]):
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print("DB2Memory Valid Check OK !!!!")
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
msg = self.mm.build(Sync_DB7, self.port)
self.send_msg((addr[0], peer_port), msg)
else:
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■ WARNING ■■■■■■■■■ WARNING ■■■■■■■■ WARNING ■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
elif cmd == Sync_DB5:
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■ Sync_DB5 handle ■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
receive_dir_num = str(json.loads(data_sum)["payload"])
re_dir = receive_dir_num.zfill(6)
p = ZIP_P + "block{}.zip".format(re_dir)
with open(p, mode="rb") as z:
z_file = z.read()
cl = z_file.hex()
msg = self.mm.build(Sync_DB6, self.port, cl)
self.send_msg((addr[0], peer_port), msg)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
elif cmd == Sync_DB6:
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■ Sync_DB6 handle ■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
payload = json.loads(data_sum)["payload"]
latest_dir = int(
get_level_dir.get_late_dir_num(zip_p=RE_ZIP_P)) + 1
p = RE_ZIP_P + "block{}.zip".format(str(latest_dir).zfill(6))
with open(p, mode="wb") as rz:
rz.write(binascii.unhexlify(payload))
msg = self.mm.build(Sync_DB3, self.port)
self.send_msg((addr[0], peer_port), msg)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
elif cmd == Sync_DB7:
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■ Sync_DB7 handle ■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
print(
"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■"
)
else:
is_core = self.__is_in_core_set((addr[0], peer_port))
self.callback((result, reason, cmd, peer_port, payload),
is_core, (addr[0], peer_port))
return
elif status == ('ok', OK_WITH_PAYLOAD):
if cmd == MSG_CORE_LIST:
# TODO: 受信したリストをただ上書きしてしまうのは本来セキュリティ的には宜しくない。
# 信頼できるノードの鍵とかをセットしとく必要があるかも
# このあたりの議論については６章にて補足予定
print('Refresh the core node list...')
new_core_set = pickle.loads(payload.encode('utf8'))
print('latest core node list: ', new_core_set)
self.core_node_set.overwrite(new_core_set)
else:
is_core = self.__is_in_core_set((addr[0], peer_port))
self.callback((result, reason, cmd, peer_port, payload),
is_core, None)
return
else:
print('Unexpected status', status)
def __add_peer(self, peer):
"""
Coreノードをリストに追加する。クラスの外からは利用しない想定
param:
peer : Coreノードとして格納されるノードの接続情報（IPアドレスとポート番号）
"""
self.core_node_set.add((peer))
try:
self.cb(self.core_node_set.get_list())
except:
pass
def __add_edge_node(self, edge):
"""
Edgeノードをリストに追加する。クラスの外からは利用しない想定
param:
edge : Edgeノードとして格納されるノードの接続情報（IPアドレスとポート番号）
"""
self.edge_node_set.add((edge))
try:
self.cb2(self.edge_node_set.get_list())
except:
pass
def __remove_peer(self, peer):
"""
離脱したと判断されるCoreノードをリストから削除する。クラスの外からは利用しない想定
param:
peer : 削除するノードの接続先情報（IPアドレスとポート番号）
"""
self.core_node_set.remove(peer)
def __remove_edge_node(self, edge):
"""
離脱したと判断されるEdgeノードをリストから削除する。クラスの外からは利用しない想定
param:
edge : 削除するノードの接続先情報（IPアドレスとポート番号）
"""
self.edge_node_set.remove(edge)
try:
self.cb2(self.edge_node_set.get_list())
except:
pass
def __check_peers_connection(self):
"""
接続されているCoreノード全ての生存確認を行う。クラスの外からは利用しない想定
この確認処理は定期的に実行される
"""
print('check_peers_connection was called')
current_core_list = self.core_node_set.get_list()
changed = False
dead_c_node_set = list(
filter(lambda p: not self.__is_alive(p), current_core_list))
if dead_c_node_set:
changed = True
print('Removing peer', dead_c_node_set)
current_core_list = current_core_list - set(dead_c_node_set)
current_core_list = self.core_node_set.get_list()
print('current core node list:', current_core_list)
# 変更があった時だけブロードキャストで通知する
if changed:
cl = pickle.dumps(current_core_list, 0).decode()
msg = self.mm.build(MSG_CORE_LIST, self.port, cl)
self.send_msg_to_all_peer(msg)
self.send_msg_to_all_edge(msg)
self.ping_timer_p = threading.Timer(PING_INTERVAL,
self.__check_peers_connection)
self.ping_timer_p.start()
def __check_edges_connection(self):
"""
接続されているEdgeノード全ての生存確認を行う。クラスの外からは利用しない想定
この確認処理は定期的に実行される
"""
print('check_edges_connection was called')
current_edge_list = self.edge_node_set.get_list()
for edge in current_edge_list:
if (time.time() - self.edge_node_set.last_ping(edge) >
TIME_OUT): ##
self.__remove_edge_node(edge)
print("--------edge node " + str(edge) +
"Time Out-------------") ##
current_edge_list = self.edge_node_set.get_list()
print('current edge node list:', current_edge_list)
self.ping_timer_e = threading.Timer(PING_INTERVAL,
self.__check_edges_connection)
self.ping_timer_e.start()
try:
self.cb2(self.edge_node_set.get_list())
except:
pass
def __is_alive(self, target):
"""
有効ノード確認メッセージの送信
param:
target : 有効ノード確認メッセージの送り先となるノードの接続情報（IPアドレスとポート番号）
"""
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((target))
msg_type = MSG_PING
msg = self.mm.build(msg_type)
s.sendall(msg.encode('utf-8'))
s.close()
return True
except OSError:
return False
def __get_myip(self):
##
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(('8.8.8.8', 80))
return s.getsockname()[0]
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()
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.")
