def chat_task(ctx, pipe):
n = Pyre(ctx)
n.join("CHAT")
n.start()
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
poller.register(n.inbox, zmq.POLLIN)
while(True):
items = dict(poller.poll())
if pipe in items and items[pipe] == zmq.POLLIN:
message = pipe.recv()
# message to quit
if message.decode('utf-8') == "$$STOP":
break
print("CHAT_TASK: %s" % message)
n.shout("CHAT", message)
if n.inbox in items and items[n.inbox] == zmq.POLLIN:
cmds = n.recv()
type = cmds.pop(0)
print("NODE_MSG TYPE: %s" % type)
print("NODE_MSG PEER: %s" % uuid.UUID(bytes=cmds.pop(0)))
print("NODE_MSG NAME: %s" % cmds.pop(0))
if type.decode('utf-8') == "SHOUT":
print("NODE_MSG GROUP: %s" % cmds.pop(0))
print("NODE_MSG CONT: %s" % cmds)
n.stop()
def chat_task(ctx, pipe, ncmds):
n = Pyre(ctx)
n.join("CHAT")
n.start()
# wait for someone else to join the chat
while not n.get_peer_groups():
pass
pipe.send('ready'.encode('utf-8'))
cmds = 0
t0 = time.time()
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
poller.register(n.inbox, zmq.POLLIN)
while(True):
items = dict(poller.poll())
if pipe in items and items[pipe] == zmq.POLLIN:
message = pipe.recv()
# message to quit
if message.decode('utf-8') == "$$STOP":
break
n.shout("CHAT", message)
if n.inbox in items and items[n.inbox] == zmq.POLLIN:
n.recv()
cmds += 1
if cmds == ncmds:
msg = 'Got %s msgs in %0.2f sec' % (cmds, time.time() - t0)
pipe.send(msg.encode('utf-8'))
n.stop()
def chat_task(ctx, pipe, ncmds):
n = Pyre(ctx=ctx)
n.join("CHAT")
n.start()
# wait for someone else to join the chat
while not n.peer_groups():
pass
pipe.send('ready'.encode('utf-8'))
cmds = 0
t0 = time.time()
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
poller.register(n.inbox, zmq.POLLIN)
while (True):
items = dict(poller.poll())
if pipe in items and items[pipe] == zmq.POLLIN:
message = pipe.recv()
# message to quit
if message.decode('utf-8') == "$$STOP":
break
n.shout("CHAT", message)
if n.inbox in items and items[n.inbox] == zmq.POLLIN:
n.recv()
cmds += 1
if cmds == ncmds:
msg = 'Got %s msgs in %0.2f sec' % (cmds, time.time() - t0)
pipe.send(msg.encode('utf-8'))
n.stop()
def discovery_task(self, ctx, pipe):
self.log.debug("Pyre on iface : {}".format(self.iface))
n = Pyre(self.groupName, sel_iface=self.iface)
n.set_header("DISCOVERY_Header1","DISCOVERY_HEADER")
n.join(self.groupName)
n.start()
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
while(True):
items = dict(poller.poll())
if pipe in items and items[pipe] == zmq.POLLIN:
message = pipe.recv()
# message to quit
if message.decode('utf-8') == "$$STOP":
break
n.shout(self.groupName, message)
n.stop()
def discovery_task(self, ctx, pipe):
self.log.debug("Pyre on iface : {}".format(self.iface))
n = Pyre(self.groupName, sel_iface=self.iface)
n.set_header("DISCOVERY_Header1", "DISCOVERY_HEADER")
n.join(self.groupName)
n.start()
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
while (True):
items = dict(poller.poll())
if pipe in items and items[pipe] == zmq.POLLIN:
message = pipe.recv()
# message to quit
if message.decode('utf-8') == "$$STOP":
break
n.shout(self.groupName, message)
n.stop()
answers = {"command": "ANSWER", "information": "MOBIDIK"}
msg_broadcast_name = str(n.name())
wsp_msg = 'whisper sample message'
while True:
have_command = False
rec_msg = n.recv()
msg_type = rec_msg[0].decode('utf-8')
sender_uuid = uuid.UUID(bytes=rec_msg[1])
sender_name = rec_msg[2].decode('utf-8')
data = rec_msg[-1]
data = data.decode('utf-8')
if str(data) == 'NameRequest':
n.shout("CHAT", msg_broadcast_name.encode('utf-8'))
if str(msg_type) == 'SHOUT' or str(msg_type) == 'WHISPER':
try:
jdata = json.loads(data)
have_command = True
except Exception as e:
print('Exception: ', e)
if have_command:
for item in jdata['payload']['commandList']:
if item['command'] == "GOTO":
answers['information'] = item['location']
elif item['command'] == "POSE":
answers['information'] = "0, 10, 20"
elif item['command'] == "RESUME":
class Bridge(object):
"""docstring for Bridge"""
def __init__(self, uvc_id):
super(Bridge, self).__init__()
self.data_seq = 0
self.note_seq = 0
# init capture
self.cap = uvc.Capture(uvc_id)
logger.info('Initialised uvc device %s'%self.cap.name)
# init pyre
self.network = Pyre(socket.gethostname()+self.cap.name[-4:])
self.network.start()
logger.info('Bridging under "%s"'%self.network.name())
# init sensor sockets
ctx = zmq.Context()
generic_url = 'tcp://*:*'
public_ep = self.network.endpoint()
self.note, self.note_url = self.bind(ctx, zmq.PUB , generic_url, public_ep)
self.data, self.data_url = self.bind(ctx, zmq.PUB , generic_url, public_ep,set_hwm=1)
self.cmd , self.cmd_url = self.bind(ctx, zmq.PULL, generic_url, public_ep)
def loop(self):
logger.info('Entering bridging loop...')
self.network.shout('pupil-mobile', self.sensor_attach_json())
try:
while True:
self.poll_network()
self.poll_cmd_socket()
self.publish_frame()
except KeyboardInterrupt:
pass
except Exception:
import traceback
traceback.print_exc()
finally:
self.network.shout('pupil-mobile', json.dumps({
'subject' : 'detach',
'sensor_uuid': self.network.uuid().hex
}))
logger.info('Leaving bridging loop...')
def publish_frame(self):
frame = self.cap.get_frame_robust()
now = int(time.time()*1000000)
index = self.data_seq
self.data_seq += 1
self.data_seq %= sequence_limit
jpeg_buffer = frame.jpeg_buffer
meta_data = struct.pack('<LLLLQLL', 0x10, frame.width, frame.height, index, now, jpeg_buffer.size, 0)
self.data.send_multipart([self.network.uuid().hex, meta_data, jpeg_buffer])
def poll_network(self):
while has_data(self.network.socket()):
event = PyreEvent(self.network)
if event.type == 'JOIN' and event.group == 'pupil-mobile':
self.network.whisper(event.peer_uuid, self.sensor_attach_json())
def poll_cmd_socket(self):
while has_data(self.cmd):
sensor, cmd_str = self.cmd.recv_multipart()
try:
cmd = json.loads(cmd_str)
except Exception as e:
logger.debug('Could not parse received cmd: %s'%cmd_str)
else:
logger.debug('Received cmd: %s'%cmd)
if cmd.get('action') == 'refresh_controls':
self.publish_controls()
elif cmd.get('action') == 'set_control_value':
val = cmd.get('value', 0)
if cmd.get('control_id') == 'CAM_RATE':
self.cap.frame_rate = self.cap.frame_rates[val]
elif cmd.get('control_id') == 'CAM_RES':
self.cap.frame_size = self.cap.frame_sizes[val]
self.publish_controls()
def __del__(self):
self.note.close()
self.data.close()
self.cmd.close()
self.network.stop()
def publish_controls(self):
self.note.send_multipart([
self.network.uuid().hex,
self.frame_size_control_json()])
self.note.send_multipart([
self.network.uuid().hex,
self.frame_rate_control_json()])
def sensor_attach_json(self):
sensor = {
"subject" : "attach",
"sensor_name" : self.cap.name,
"sensor_uuid" : self.network.uuid().hex,
"sensor_type" : 'video',
"notify_endpoint" : self.note_url,
"command_endpoint": self.cmd_url,
"data_endpoint" : self.data_url
}
return json.dumps(sensor)
def frame_size_control_json(self):
index = self.note_seq
self.note_seq += 1
self.note_seq %= sequence_limit
curr_fs = self.cap.frame_sizes.index(self.cap.frame_size)
return json.dumps({
"subject" : "update",
"control_id" : "CAM_RES",
"seq" : index,
"changes" : {
"value" : curr_fs,
"dtype" : 'intmapping',
"min" : None,
"max" : None,
"res" : None,
"def" : 0,
"caption" : 'Resolution',
"readonly" : False,
"map" : [{
'value' : idx,
'caption': '%ix%i'%fs
} for idx,fs in enumerate(self.cap.frame_sizes)]
}
})
def frame_rate_control_json(self):
index = self.note_seq
self.note_seq += 1
self.note_seq %= sequence_limit
curr_fr = self.cap.frame_rates.index(self.cap.frame_rate)
return json.dumps({
"subject" : "update",
"control_id" : "CAM_RATE",
"seq" : index,
"changes" : {
"value" : curr_fr,
"dtype" : 'intmapping',
"min" : None,
"max" : None,
"res" : None,
"def" : 0,
"caption" : 'Frame Rate',
"readonly" : False,
"map" : [{
'value' : idx,
'caption': '%.1f Hz'%fr
} for idx,fr in enumerate(self.cap.frame_rates)]
}
})
def bind(self, ctx, sock_type, url, public_ep, set_hwm=None):
sock = ctx.socket(sock_type)
if set_hwm: sock.set_hwm(set_hwm)
sock.bind(url)
ep = sock.last_endpoint
port = ep.split(':')[-1]
public_ep.split(':')[-1]
public_addr = public_ep.split(':')[:-1]
return sock, ':'.join(public_addr+[port])
# "features": features_list
# }]
msg_name_request = 'NameRequest'
dest_name = "receiver_node"
get_info = True
get_queries = True
send_next_query = False
k = 0
q = 0
print('press enter to start the program')
k = input()
# send an order to all nodes(shout) to send their names
n.shout("CHAT", msg_name_request.encode('utf-8'))
while get_queries:
rec_msg = n.recv()
msg_type = rec_msg[0].decode('utf-8')
# get all the nodes in the group
sender_uuid = uuid.UUID(bytes=rec_msg[1])
sender_name = rec_msg[2].decode('utf-8')
nodes_list[sender_name] = sender_uuid
data = rec_msg[-1]
data = data.decode('utf-8')
if str(msg_type) == 'SHOUT' or str(msg_type) == 'WHISPER':
try:
jdata = json.loads(data)
class ZyreToZMQModule:
""" The ZyreToZMQModule Base Class """
def __init__(self,
ctx=None,
name="Default",
headers=None,
groups=None,
config_file=None,
polling_timeout=1,
sim_time=2):
self.logger = logging.getLogger(name)
self.logger.setLevel(logging.DEBUG)
# create the console output logging
sh = logging.StreamHandler()
sh.setLevel(logging.INFO)
# create a logger writing into a log file
fh = logging.FileHandler(name + ".log")
fh.setLevel(logging.DEBUG)
# create formatter and add it to the handlers
# see https://docs.python.org/2/library/logging.html#logrecord-attributes for what can be logged
fh.setFormatter(
logging.Formatter(
'Name: %(name)s, ProcessName: %(processName)s, ThreadName: %(threadName)s, Module: %(module)s, FunctionName: %(funcName)s, LineNo: %(lineno)d, Level: %(levelname)s, Msg: %(message)s'
))
#sh.setFormatter(logging.Formatter('Module: %(module)s, FunctionName: %(funcName)s, LineNo: %(lineno)d, Level: %(levelname)s, Msg: %(message)s'))
sh.setFormatter(
logging.Formatter(
'Name: %(name)s, %(module)s/%(funcName)s[%(levelname)s]: %(message)s (lineno:%(lineno)d)'
))
# add the handlers to logger
self.logger.addHandler(sh)
self.logger.addHandler(fh)
self.logger.propagate = False # don't pass messages to parent loggers
if not type(ctx) == zmq.sugar.context.Context:
self.logger.warn(
"Created ZMQ context. Please supply a ZMQ context next time.")
ctx = zmq.Context()
self.ctx = ctx
if not type(name) == str:
name = "Default"
self.logger.warn(
"Please provide a the name as a string. Setting name to default: %s."
% name)
self.name = name
if not headers:
self.logger.warn(
"Please provide a model and other header information.")
headers = {}
self.headers = headers
if not groups:
groups = ["SHERPA"]
self.logger.warn(
"Please provide a list with group names to which it will listen. Will set it to default: %s"
% groups)
self.groups = groups
if not config_file:
# will be opened during configuration
self.logger.error(
"No config file provided for initial configuration")
exit()
self.config_file = config_file
self.config = None
self.alive = True # used for exiting once the node is stopped
self.line_controller = None # stores uid of line controller this module is listening to (to avoid several line controllers)
self.com_timeout = polling_timeout # time_out in msec after which poller returns
self.sim_time = sim_time # time in msec
self.inbox = []
self.outbox = []
# Node setup
self.node = Pyre(self.name)
for key in self.headers:
self.node.set_header(key, self.headers[key])
for group in self.groups:
self.node.join(group)
#self.node.set_verbose()
self.node.start()
# Socket setup
self.poller = zmq.Poller()
self.poller.register(self.node.socket(), zmq.POLLIN)
port = "12911"
self.zmq_socket = self.ctx.socket(zmq.PUB)
self.zmq_socket.bind("tcp://*:%s" % port)
self.run()
def run(self):
""" Running loop of this process:
[COMMUNICATION] Check communication channels and parse all messages.
"""
while self.alive:
try:
#[COMMUNICATION]
self.communication()
#[LOGGING]
#self.logging()
time.sleep(1)
except (KeyboardInterrupt, SystemExit):
break
self.node.stop()
def communication(self):
""" This function handles the communication """
# Check if communication is ready
if not self.poller:
self.logger.warn("No communication channels yet.")
# Process input
items = dict(self.poller.poll(self.com_timeout))
# Get input from Pyre socket and put it in inbox which is processed in the following steps
#logger.debug("Start processing incoming messages")
if self.node.socket() in items and items[
self.node.socket()] == zmq.POLLIN:
self.logger.info("Received %d msgs." % len(items))
#print "msg arrived. inbox len %d" % len(self.inbox)
msg_frame = self.node.recv()
msg_type = msg_frame.pop(0)
peer_uid = uuid.UUID(bytes=msg_frame.pop(0))
peer_name = msg_frame.pop(0)
self.logger.info("Msg type: %s" % msg_type)
self.logger.info("Sender: %s" % peer_name)
# For shout and whisper take message payload and put it into inbox assuming it is correct
# For the other zyre msgs create a JSON obj and put that into inbox
# TODO: add validation
if msg_type == "SHOUT":
group = msg_frame.pop(0)
msg = json.loads(msg_frame.pop(0))
msg["sender_UUID"] = peer_uid
msg["sender_name"] = peer_name
# self.inbox.append(msg)
self.outbox.append(msg)
elif msg_type == "WHISPER":
msg = json.loads(msg_frame.pop(0))
msg["sender_UUID"] = peer_uid
msg["sender_name"] = peer_name
self.inbox.append(msg)
# don't care about join and leave messages; if necessary, split to have separate events
# elif msg_type == "LEAVE" or msg_type == "JOIN":
# group = msg_frame.pop(0)
# event = json.dumps({"metamodel": "http://www.sherpa-project.eu/examples/sherpa_msgs",
# "model": "http://www.sherpa-project.eu/examples/sherpa_msgs/zyre_events",
# "type": "leave/join",
# "sender_UUID": peer_uid,
# "sender_name": peer_name,
# "payload": {}
# })
# self.inbox.append(event)
elif msg_type == "ENTER":
headers = json.loads(msg_frame.pop(0))
event = {
"metamodel":
"http://www.sherpa-project.eu/examples/sherpa_msgs",
"model":
"http://www.sherpa-project.eu/examples/sherpa_msgs/zyre_events",
"type": "enter",
"sender_UUID": peer_uid,
"sender_name": peer_name,
"payload": {
"header": headers
}
}
self.inbox.append(event)
elif msg_type == "EXIT":
event = {
"metamodel":
"http://www.sherpa-project.eu/examples/sherpa_msgs",
"model":
"http://www.sherpa-project.eu/examples/sherpa_msgs/zyre_events",
"type": "exit",
"sender_UUID": peer_uid,
"sender_name": peer_name,
"payload": {}
}
self.inbox.append(event)
# Process output and send all msgs there until it is empty, but only if a line controller is connected.
if self.outbox: #only do if there really is something in the outbox
#if self.lcsm.sm.curr_state._name == "Idle" or self.lcsm.sm.curr_state._name == "Busy":
if true:
self.logger.info(
"Start processing messages in outbox. Number of msgs in outbox: %d"
% len(self.outbox))
while self.outbox:
# since we assume all msgs conform to the sherpa_msgs JSON model, simply shout them out
# TODO: add validation
msg = self.outbox.pop()
if type(msg) == dict:
self.logger.info("outbox msg type: " + msg["type"])
self.node.shout("SHERPA", json.dumps(msg))
#WM message
msg_wm_update = {
"@worldmodeltype": "RSGUpdate",
"operation": "CREATE",
"node": {
"@graphtype":
"Group",
"id":
"ff483c43-4a36-4197-be49-de829cdd66c8",
"attributes": [
{
"key": "name",
"value": "Task Specification Tree"
},
{
"key": "tst:envtst",
"value": msg
},
],
},
"parentId": "e379121f-06c6-4e21-ae9d-ae78ec1986a1",
}
print("===")
print(json.dumps(msg_wm_update))
self.zmq_socket.send_string(json.dumps(msg_wm_update))
else:
self.logger.warn(
"Message is not a dict! Serialization is done here! Msg: \n"
+ str(msg))
else:
self.logger.info(
"Can't send messages in outbox. Module not ready.")
def chat_task(ctx,pipe):
print("communication started")
GROUPNAME = "Quizzzzz"
StopCmnd = "$$quit"
OPPONENT = "opponent"
print("name: %s" %NAME)
connected_players = 1
# set up node for the user
n = Pyre(GROUPNAME)
n.set_header('Name', NAME)
# join the groupchat
n.join(GROUPNAME)
#print("UUID %s" %n.uuid())
# start broadcasting signal
n.start()
# set up poller
poller = zmq.Poller()
poller.register(pipe,zmq.POLLIN)
poller.register(n.socket(),zmq.POLLIN)
# looping constantly to recieve messages
while True:
items = dict(poller.poll())
if pipe in items:
message = pipe.recv()
if message.decode('utf-8') == StopCmnd:
break
# uppercase letters for question to whole group
elif message.decode('utf-8').isupper() == True:
print("Question is: %s" %message)
n.shouts(GROUPNAME,"Question to group is: %s" %message.decode('utf-8'))
answer = 0
# lowercase to last person who asked question in the group
elif message.decode('utf-8').islower() == True:
message = NAME + "'s answer is=" + message
n.whisper(PEER,message)
else:
print("please don't mix up or lowercase or use not only numbers")
else:
msgrecv = n.recv()
#print(msgrecv)
msg_type = msgrecv.pop(0)
msg_sender = uuid.UUID(bytes=msgrecv.pop(0))
PEER = msg_sender
msg_name = msgrecv.pop(0)
if msg_type.decode('utf-8') == "ENTER":
headers = json.loads(msgrecv.pop(0).decode('utf-8'))
print("New player discovered in network")
print("New player = %s " %headers.get("Name"))
elif msg_type.decode('utf-8') == "JOIN":
print("New player has joined the group")
print("New player = %s" %headers.get("Name"))
connected_players += 1
print("#players = %s" %connected_players)
elif msg_type.decode('utf-8') == "SHOUT":
print(msgrecv.pop(1))
elif msg_type.decode('utf-8') == "WHISPER":
if msgrecv[0] == "You have to ask next question":
print("You have to ask next question")
n.shout(GROUPNAME, "%s is new quizmaster" %NAME)
answer = 0
else:
print(msgrecv.pop(0))
answer +=1
if answer == connected_players -1: #choosing new quizmaster randomly
players = n.peers()
next_master = players.pop(random.randint(0,connected_players-2))
n.whisper(next_master,"You have to ask next question")
print("Left current game")
n.stop()
class Bridge(object):
"""docstring for Bridge"""
def __init__(self, uvc_id):
super(Bridge, self).__init__()
self.data_seq = 0
self.note_seq = 0
# init capture
self.cap = uvc.Capture(uvc_id)
logger.info('Initialised uvc device {}'.format(self.cap.name))
# init pyre
self.network = Pyre(socket.gethostname()+self.cap.name[-4:])
self.network.join(GROUP)
self.network.start()
logger.info('Bridging under "{}"'.format(self.network.name()))
# init sensor sockets
ctx = zmq.Context()
generic_url = 'tcp://*:*'
public_ep = self.network.endpoint()
self.note, self.note_url = self.bind(ctx, zmq.PUB, generic_url, public_ep)
self.data, self.data_url = self.bind(ctx, zmq.PUB, generic_url, public_ep, set_hwm=1)
self.cmd, self.cmd_url = self.bind(ctx, zmq.PULL, generic_url, public_ep)
def loop(self):
logger.info('Entering bridging loop...')
self.network.shout(GROUP, self.sensor_attach_json().encode())
try:
while True:
self.poll_network()
self.poll_cmd_socket()
self.publish_frame()
except KeyboardInterrupt:
pass
except Exception:
import traceback
traceback.print_exc()
finally:
self.network.shout(GROUP, json.dumps({
'subject': 'detach',
'sensor_uuid': self.network.uuid().hex
}).encode())
logger.info('Leaving bridging loop...')
def publish_frame(self):
frame = self.cap.get_frame_robust()
now = time.time()
index = self.data_seq
self.data_seq += 1
self.data_seq %= sequence_limit
jpeg_buffer = frame.jpeg_buffer
m = hashlib.md5(jpeg_buffer)
lower_end = int(m.hexdigest(), 16) % 0x100000000
meta_data = struct.pack('<LLLLdLL', 0x10, frame.width, frame.height, index, now, jpeg_buffer.size, lower_end)
self.data.send_multipart([self.network.uuid().hex.encode(), meta_data, jpeg_buffer])
def poll_network(self):
for event in self.network.recent_events():
if event.type == 'JOIN' and event.group == GROUP:
self.network.whisper(event.peer_uuid, self.sensor_attach_json().encode())
def poll_cmd_socket(self):
while has_data(self.cmd):
sensor, cmd_str = self.cmd.recv_multipart()
try:
cmd = json.loads(cmd_str.decode())
except Exception as e:
logger.debug('Could not parse received cmd: {}'.format(cmd_str))
else:
logger.debug('Received cmd: {}'.format(cmd))
if cmd.get('action') == 'refresh_controls':
self.publish_controls()
elif cmd.get('action') == 'set_control_value':
val = cmd.get('value', 0)
if cmd.get('control_id') == 'CAM_RATE':
self.cap.frame_rate = self.cap.frame_rates[val]
elif cmd.get('control_id') == 'CAM_RES':
self.cap.frame_size = self.cap.frame_sizes[val]
self.publish_controls()
def __del__(self):
self.note.close()
self.data.close()
self.cmd.close()
self.network.stop()
def publish_controls(self):
self.note.send_multipart([
self.network.uuid().hex.encode(),
self.frame_size_control_json().encode()])
self.note.send_multipart([
self.network.uuid().hex.encode(),
self.frame_rate_control_json().encode()])
def sensor_attach_json(self):
sensor = {
"subject": "attach",
"sensor_name": self.cap.name,
"sensor_uuid": self.network.uuid().hex,
"sensor_type": 'video',
"notify_endpoint": self.note_url,
"command_endpoint": self.cmd_url,
"data_endpoint": self.data_url
}
return json.dumps(sensor)
def frame_size_control_json(self):
index = self.note_seq
self.note_seq += 1
self.note_seq %= sequence_limit
curr_fs = self.cap.frame_sizes.index(self.cap.frame_size)
return json.dumps({
"subject": "update",
"control_id": "CAM_RES",
"seq": index,
"changes": {
"value": curr_fs,
"dtype": 'intmapping',
"min": None,
"max": None,
"res": None,
"def": 0,
"caption": 'Resolution',
"readonly": False,
"map": [{
'value': idx,
'caption': '{:d}x{:d}'.format(*fs)
} for idx, fs in enumerate(self.cap.frame_sizes)]
}
})
def frame_rate_control_json(self):
index = self.note_seq
self.note_seq += 1
self.note_seq %= sequence_limit
curr_fr = self.cap.frame_rates.index(self.cap.frame_rate)
return json.dumps({
"subject": "update",
"control_id": "CAM_RATE",
"seq": index,
"changes": {
"value": curr_fr,
"dtype": 'intmapping',
"min": None,
"max": None,
"res": None,
"def": 0,
"caption": 'Frame Rate',
"readonly": False,
"map": [{
'value': idx,
'caption': '{:.1f} Hz'.format(fr)
} for idx, fr in enumerate(self.cap.frame_rates)]
}
})
def bind(self, ctx, sock_type, url, public_ep, set_hwm=None):
sock = ctx.socket(sock_type)
if set_hwm:
sock.set_hwm(set_hwm)
sock.bind(url)
ep = sock.last_endpoint.decode()
port = ep.split(':')[-1]
public_ep.split(':')[-1]
public_addr = public_ep.split(':')[:-1]
return sock, ':'.join(public_addr+[port])
class Network:
hosting: bool = False
def __init__(self):
self.open()
def get_all_groups(self) -> List[str]:
"""Get the names of groups that can be joined."""
groups = []
for peer in self.node.peers():
group = self.node.peer_header_value(peer, 'hosting')
if group != None and len(group) > 0:
groups.append(group)
return groups
def get_our_group(self) -> Union[str, None]:
"""What is the name of the group we're in or hosting?"""
our_groups = self.node.own_groups()
our_groups.remove('untangled2018')
if len(our_groups) == 0:
return None
return our_groups[0]
def is_in_group(self) -> bool:
"""Are we in or hosting a group?"""
return self.get_our_group() != None
def is_hosting(self) -> bool:
"""Are we hosting?"""
return self.hosting
def join_group(self, group: str) -> None:
"""Join a group of given name (assumes you are not in a group already)."""
if group not in self.get_all_groups():
raise ValueError('Group named "%s" does not exist'.format(group))
if self.is_in_group():
raise ValueError(
'You must leave the previous group before you join another')
self.node.join(group)
def leave_group(self) -> None:
"""Leave any joined group or stop hosting."""
self.hosting = False
if not self.is_in_group():
raise ValueError('You are not in a group')
for group in self.node.own_groups():
self.node.leave(group)
def host_group(self, name: str) -> None:
"""Host a group of given name."""
if name in self.get_all_groups():
raise ValueError('A group of the given name already exists')
if self.is_in_group():
raise ValueError('Cannot host whilst in a group')
self.node.set_header('hosting', name)
self.hosting = True
self.node.join(name)
def open(self) -> None:
"""Create a new pyre instance and join untangled."""
self.node = Pyre()
self.node.start()
self.node.join('untangled2018')
# used to get our messages
self.poller = zmq.Poller()
self.poller.register(self.node.socket(), zmq.POLLIN)
def get_id(self) -> str:
"""Get our id, as a unique node on the network."""
return self.node.uuid()
def is_me(self, player_id) -> bool:
"""See if a given id is ours."""
return self.get_id() == player_id
def close(self) -> None:
"""Disconnect from everything"""
self.node.stop()
def get_messages(self):
"""See what has been sent to us: who has joined, what have people said, etc"""
# what has changed
changes = dict(self.poller.poll(0))
# are these the changes we subscribed for
if self.node.socket() in changes and changes[
self.node.socket()] == zmq.POLLIN:
msgs = self.node.recent_events()
return msgs
# nothing to return
return []
def pull_game(self, game):
"""Update our game state based on what other people tell us."""
for msg in self.get_messages():
# is it relevant to us?
if msg.group != self.get_our_group():
continue
if msg.type == 'SHOUT':
entities = bson.loads(msg.msg[0])
if 'ids' in entities:
keys = entities['ids']
cur_keys = list(game.entities.keys())
diff = list(set(cur_keys) - set(keys))
for key in diff:
del game.entities[key]
entities = entities['components']
for key, changed_comps in entities.items():
key = uuid.UUID(key)
if key not in game.entities:
game.entities[key] = {}
entity = game.entities[key]
for compname, component in changed_comps.items():
try:
clas = components.__dict__[compname]
if clas in entity:
entity[clas] = entity[clas].replace(
**component)
else:
entity[clas] = clas(**component)
entity[clas].observed_changes()
except Exception:
print(
'Error updating component, is everyone in the group on the same version?',
file=sys.stdout)
elif self.is_hosting():
if msg.type == 'JOIN':
game.on_player_join(msg.peer_uuid)
self.push_game(game, initial=True)
elif msg.type == 'EXIT' or msg.type == "LEAVE":
game.on_player_quit(msg.peer_uuid)
def push_game(self, game, initial=False):
"""Tell others how we've changed the game state."""
if len(self.node.peers_by_group(self.get_our_group())) == 0:
# Nobody else to talk to
return
entities = {'components': {}}
if self.is_hosting():
entities = {'ids': [], 'components': {}}
for key, entity in game.entities.items():
changed_comps = {}
for component in entity.values():
if component.is_networked() and (initial
or component.has_changed()):
changed_comps[component.get_name()] = component.as_dict()
component.observed_changes()
if 'ids' in entities:
entities['ids'].append(key)
entities['components'][str(key)] = changed_comps
self.node.shout(self.get_our_group(), bson.dumps(entities))
class Bridge(object):
"""docstring for Bridge"""
def __init__(self, uvc_id):
super(Bridge, self).__init__()
self.data_seq = 0
self.note_seq = 0
# init capture
self.cap = uvc.Capture(uvc_id)
logger.info("Initialised uvc device {}".format(self.cap.name))
# init pyre
self.network = Pyre(socket.gethostname() + self.cap.name[-4:])
self.network.join(GROUP)
self.network.start()
logger.info('Bridging under "{}"'.format(self.network.name()))
# init sensor sockets
ctx = zmq.Context()
generic_url = "tcp://*:*"
public_ep = self.network.endpoint()
self.note, self.note_url = self.bind(ctx, zmq.PUB, generic_url,
public_ep)
self.data, self.data_url = self.bind(ctx,
zmq.PUB,
generic_url,
public_ep,
set_hwm=1)
self.cmd, self.cmd_url = self.bind(ctx, zmq.PULL, generic_url,
public_ep)
def loop(self):
logger.info("Entering bridging loop...")
self.network.shout(GROUP, self.sensor_attach_json().encode())
try:
while True:
self.poll_network()
self.poll_cmd_socket()
self.publish_frame()
except KeyboardInterrupt:
pass
except Exception:
import traceback
traceback.print_exc()
finally:
self.network.shout(
GROUP,
json.dumps({
"subject": "detach",
"sensor_uuid": self.network.uuid().hex
}).encode(),
)
logger.info("Leaving bridging loop...")
def publish_frame(self):
frame = self.cap.get_frame_robust()
now = time.time()
index = self.data_seq
self.data_seq += 1
self.data_seq %= sequence_limit
jpeg_buffer = frame.jpeg_buffer
m = hashlib.md5(jpeg_buffer)
lower_end = int(m.hexdigest(), 16) % 0x100000000
meta_data = struct.pack(
"<LLLLdLL",
0x10,
frame.width,
frame.height,
index,
now,
jpeg_buffer.size,
lower_end,
)
self.data.send_multipart(
[self.network.uuid().hex.encode(), meta_data, jpeg_buffer])
def poll_network(self):
for event in self.network.recent_events():
if event.type == "JOIN" and event.group == GROUP:
self.network.whisper(event.peer_uuid,
self.sensor_attach_json().encode())
def poll_cmd_socket(self):
while has_data(self.cmd):
sensor, cmd_str = self.cmd.recv_multipart()
try:
cmd = json.loads(cmd_str.decode())
except Exception as e:
logger.debug(
"Could not parse received cmd: {}".format(cmd_str))
else:
logger.debug("Received cmd: {}".format(cmd))
if cmd.get("action") == "refresh_controls":
self.publish_controls()
elif cmd.get("action") == "set_control_value":
val = cmd.get("value", 0)
if cmd.get("control_id") == "CAM_RATE":
self.cap.frame_rate = self.cap.frame_rates[val]
elif cmd.get("control_id") == "CAM_RES":
self.cap.frame_size = self.cap.frame_sizes[val]
self.publish_controls()
def __del__(self):
self.note.close()
self.data.close()
self.cmd.close()
self.network.stop()
def publish_controls(self):
self.note.send_multipart([
self.network.uuid().hex.encode(),
self.frame_size_control_json().encode()
])
self.note.send_multipart([
self.network.uuid().hex.encode(),
self.frame_rate_control_json().encode()
])
def sensor_attach_json(self):
sensor = {
"subject": "attach",
"sensor_name": self.cap.name,
"sensor_uuid": self.network.uuid().hex,
"sensor_type": "video",
"notify_endpoint": self.note_url,
"command_endpoint": self.cmd_url,
"data_endpoint": self.data_url,
}
return json.dumps(sensor)
def frame_size_control_json(self):
index = self.note_seq
self.note_seq += 1
self.note_seq %= sequence_limit
curr_fs = self.cap.frame_sizes.index(self.cap.frame_size)
return json.dumps({
"subject": "update",
"control_id": "CAM_RES",
"seq": index,
"changes": {
"value":
curr_fs,
"dtype":
"intmapping",
"min":
None,
"max":
None,
"res":
None,
"def":
0,
"caption":
"Resolution",
"readonly":
False,
"map": [{
"value": idx,
"caption": "{:d}x{:d}".format(*fs)
} for idx, fs in enumerate(self.cap.frame_sizes)],
},
})
def frame_rate_control_json(self):
index = self.note_seq
self.note_seq += 1
self.note_seq %= sequence_limit
curr_fr = self.cap.frame_rates.index(self.cap.frame_rate)
return json.dumps({
"subject": "update",
"control_id": "CAM_RATE",
"seq": index,
"changes": {
"value":
curr_fr,
"dtype":
"intmapping",
"min":
None,
"max":
None,
"res":
None,
"def":
0,
"caption":
"Frame Rate",
"readonly":
False,
"map": [{
"value": idx,
"caption": "{:.1f} Hz".format(fr)
} for idx, fr in enumerate(self.cap.frame_rates)],
},
})
def bind(self, ctx, sock_type, url, public_ep, set_hwm=None):
sock = ctx.socket(sock_type)
if set_hwm:
sock.set_hwm(set_hwm)
sock.bind(url)
ep = sock.last_endpoint.decode()
port = ep.split(":")[-1]
public_ep.split(":")[-1]
public_addr = public_ep.split(":")[:-1]
return sock, ":".join(public_addr + [port])
def network_manager(self, ctx, write_pipe, node_name, overlay_network_name,
read_pipe):
# create the poller to wait for messages from pipes and network
poller = zmq.Poller()
poller.register(write_pipe, zmq.POLLIN)
# create the Pyre node object
node = Pyre(node_name + str(uuid.uuid4()))
# register node to the network, start it and register for events with
# the poller.
node.join(overlay_network_name)
node.start()
poller.register(node.socket(), zmq.POLLIN)
while (True):
# do stuff, aka wait and decode messages
items = dict(poller.poll())
if write_pipe in items and items[write_pipe] == zmq.POLLIN:
# here is where the thread receives internal data
# check if we have to send something outside
# or eventually die gracefully
message = write_pipe.recv()
# here I have a Command + a FardNetworkData object
decoded_message = pickle.loads(message)
command = decoded_message[0]
network_data = decoded_message[1]
if command == "$$STOP":
# message to quit here
break
elif command == "$$GET_PEERS":
# only synchronous command, retrieves the peers inside the
# network of tasks.
group = network_data.group
peers = node.peers_by_group(group)
list_of_peers = []
for peer in peers:
list_of_peers.append(str(peer))
write_pipe.send(pickle.dumps(str(";".join(list_of_peers))))
elif command == "$$SEND_MESSAGE" in decoded_message:
# send message to a single peer using Pyre
# if requested, send back the message to the same node that
# sent it.
peer = network_data.peer
network_data.sender_peer = str(node.uuid())
network_data.message_type = "peer"
node.whisper(uuid.UUID(peer), pickle.dumps(network_data))
if network_data.auto_send and peer == network_data.sender_peer:
read_pipe.send(pickle.dumps(network_data))
elif command == "$$SEND_TASK_MESSAGE":
# send message to a group of identical tasks using Pyre.
# Currently implemented with a shout that is ignored by a
# receiver if the task name is different from his.
# if requested, send back the message to the same node that
# sent it.
network_data.sender_peer = str(node.uuid())
network_data.message_type = "task"
node.shout(group, pickle.dumps(network_data))
if network_data.auto_send:
read_pipe.send(pickle.dumps(network_data))
elif command == "$$SEND_GROUP_MESSAGE":
# send message to the whole application using Pyre
# if requested, send back the message to the same node that
# sent it.
group = network_data.group
network_data.sender_peer = str(node.uuid())
network_data.message_type = "group"
node.shout(group, pickle.dumps(network_data))
if network_data.auto_send:
read_pipe.send(pickle.dumps(network_data))
else:
# here is where the thread receives data from the outside
# decode messages and reroute them accordingly
cmds = node.recv()
msg_type = cmds.pop(0).decode('utf-8')
peer_uuid = uuid.UUID(bytes=cmds.pop(0))
sender_node_name = cmds.pop(0).decode('utf-8')
if msg_type == "SHOUT":
group = cmds.pop(0).decode('utf-8')
read_pipe.send(cmds.pop(0))
elif msg_type == "WHISPER":
read_pipe.send(cmds.pop(0))
# elif msg_type == "ENTER":
# headers = json.loads(cmds.pop(0).decode('utf-8'))
# print("NODE_MSG HEADERS: %s" % headers)
# for key in headers:
# print("key = {0}, value = {1}".format(key, headers[key]))
# print("NODE_MSG CONT: %s" % cmds)
node.stop()
class Authority():
def __init__(self):
self.node = Pyre("GAME_AUTH")
self.node.set_header("AUTHORITY", "TRUE")
self.node.start()
self.node.join("world:position")
self.node.join("ctf:teams")
self.node.join("ctf:dropflag")
self.node.join("ctf:gotflag")
self.poller = zmq.Poller()
self.poller.register(self.node.socket(), zmq.POLLIN)
self.players = AuthorityPlayerManager()
self.teams = {"blue": [], "red": []}
self.level = SaveLevel('./assets/maps/CAPFLAG MAP NAT')
red_spawn_pos = self.level.get_place(Place.RED_SPAWN)
blue_spawn_pos = self.level.get_place(Place.BLUE_SPAWN)
self.flags = {
"blue": {
"x": blue_spawn_pos[0],
"y": blue_spawn_pos[1],
"owner": '',
"timer": 0
},
"red": {
"x": red_spawn_pos[0],
"y": red_spawn_pos[1],
"owner": '',
"timer": 0
}
}
self.serve()
def set_teams(self):
blue_players = self.teams["blue"]
red_players = self.teams["red"]
# Check for removed players in RED
for i, playerUUID in enumerate(red_players):
if playerUUID not in self.players.players.keys():
red_players.pop(i)
# Check for removed players in BLUE
for i, playerUUID in enumerate(blue_players):
if playerUUID not in self.players.players.keys():
blue_players.pop(i)
# Add new players
for playerUUID, player in self.players.players.items():
if not (playerUUID in blue_players or playerUUID in red_players):
if len(blue_players) > len(red_players):
red_players.append(playerUUID)
else:
blue_players.append(playerUUID)
print("Teams: " + "RED: " + ','.join(red_players) + " | BLUE: " +
','.join(blue_players))
self.node.shout("ctf:teams", bson.dumps(self.teams))
def set_flags(self, flag_info):
return
def update_flags(self):
self.node.shout("ctf:flags", bson.dumps(self.flags))
def get_team_from_uuid(self, uuid):
place = None
if str(uuid) in self.teams['red']:
place = Place.RED_SPAWN
elif str(uuid) in self.teams['blue']:
place = Place.BLUE_SPAWN
return place
def serve(self):
clock = Clock()
while True:
clock.tick(60)
# check network
events = self.get_events()
if events:
try:
for event in events:
# Update the teams on JOIN and EXIT
if event.type == 'JOIN':
if event.group == 'ctf:dropflag':
for team, flag in self.flags.items():
if flag['owner'] == '':
self.node.shout(
'ctf:dropflag',
bson.dumps({
'x': flag['x'],
'y': flag['y'],
'team': team
}))
elif event.group == 'ctf:gotflag':
for team, flag in self.flags.items():
if flag['owner'] != '':
self.node.shout(
'ctf:gotflag',
bson.dumps({
'uuid': flag['owner'],
'team': team
}))
elif event.group == 'ctf:teams':
self.players.set(self.node.peers())
self.set_teams()
place = self.get_team_from_uuid(
event.peer_uuid)
pos = self.level.get_place(place)
self.node.whisper(
event.peer_uuid,
bson.dumps({
'type': 'teleport',
'x': pos[0],
'y': pos[1]
}))
elif event.type == 'EXIT':
for team, flag in self.flags.items():
if flag['owner'] == str(event.peer_uuid):
# flag owner is leaving, drop
player = self.players.get(event.peer_uuid)
flag['x'] = player.x
flag['y'] = player.y
flag['owner'] = ''
self.node.shout(
'ctf:dropflag',
bson.dumps({
'x': flag['x'],
'y': flag['y'],
'team': team
}))
self.players.set(self.node.peers())
self.set_teams()
elif event.type == 'SHOUT':
if event.group == "world:position":
new_position = bson.loads(event.msg[0])
network_player = self.players.get(
event.peer_uuid)
network_player.set_position(new_position)
# check if flag has been captured
for team, flag in self.flags.items():
if flag['owner'] != str(event.peer_uuid):
continue
tile = self.level.get_tile(
new_position['x'], new_position['y'])
if tile == TileType.RED_BLOCK and team == 'blue':
# TODO: blue's flag has been captured
spawn = Place.BLUE_SPAWN
elif tile == TileType.BLUE_BLOCK and team == 'red':
# TODO: red's flag has been captured
spawn = Place.RED_SPAWN
else:
continue
position = self.level.get_place(spawn)
flag['x'] = position[0]
flag['y'] = position[1]
flag['owner'] = ''
self.node.shout(
'ctf:dropflag',
bson.dumps({
'x': flag['x'],
'y': flag['y'],
'team': team
}))
if event.group == 'ctf:gotflags':
flag_info = bson.loads(event.msg[0])
self.set_flags(flag_info)
elif event.type == 'WHISPER':
msg = bson.loads(event.msg[0])
network_player = self.players.get(event.peer_uuid)
if msg['type'] == 'death_report':
player = self.players.get(event.peer_uuid)
previously_owned_flag = None
if self.flags['blue']['owner'] == str(
event.peer_uuid):
previously_owned_flag = 'blue'
elif self.flags['red']['owner'] == str(
event.peer_uuid):
previously_owned_flag = 'red'
if previously_owned_flag:
flag = self.flags[previously_owned_flag]
flag['owner'] = ''
self.node.shout(
'ctf:dropflag',
bson.dumps({
'x':
player.x,
'y':
player.y,
'team':
previously_owned_flag
}))
place = self.get_team_from_uuid(
event.peer_uuid)
pos = self.level.get_place(place)
self.node.whisper(
event.peer_uuid,
bson.dumps({
'type': 'teleport',
'x': pos[0],
'y': pos[1]
}))
player.x = pos[0]
player.y = pos[1]
except Exception as e:
print(e)
import traceback
print(traceback.format_exc())
pass
for team, flag in self.flags.items():
if flag["owner"] != '': continue
for uuid, player in self.players.players.items():
if flag['x'] == player.x and flag['y'] == player.y:
team_place = self.get_team_from_uuid(uuid)
pos = self.level.get_place(team_place)
if team == 'red' and team_place == Place.RED_SPAWN or team == 'blue' and team_place == Place.BLUE_SPAWN:
if player.x == pos[0] and player.y == pos[1]:
continue
self.node.shout(
'ctf:dropflag',
bson.dumps({
'x': pos[0],
'y': pos[1],
'team': team
}))
else:
flag["owner"] = uuid
self.node.shout(
'ctf:gotflag',
bson.dumps({
'uuid': uuid,
'team': team
}))
break
def poll(self):
return dict(self.poller.poll(0))
def peers(self):
return self.node.peers()
def stop(self):
self.node.stop()
def get_events(self):
changes = self.poll()
if self.node.socket() in changes and changes[
self.node.socket()] == zmq.POLLIN:
events = self.node.recent_events()
return events
class ZyreToZMQModule:
""" The ZyreToZMQModule Base Class """
def __init__(self,ctx = None,name = "Default",headers=None,groups=None,config_file=None,polling_timeout = 1,sim_time=2):
self.logger = logging.getLogger(name)
self.logger.setLevel(logging.DEBUG)
# create the console output logging
sh = logging.StreamHandler()
sh.setLevel(logging.INFO)
# create a logger writing into a log file
fh = logging.FileHandler(name + ".log")
fh.setLevel(logging.DEBUG)
# create formatter and add it to the handlers
# see https://docs.python.org/2/library/logging.html#logrecord-attributes for what can be logged
fh.setFormatter(logging.Formatter('Name: %(name)s, ProcessName: %(processName)s, ThreadName: %(threadName)s, Module: %(module)s, FunctionName: %(funcName)s, LineNo: %(lineno)d, Level: %(levelname)s, Msg: %(message)s'))
#sh.setFormatter(logging.Formatter('Module: %(module)s, FunctionName: %(funcName)s, LineNo: %(lineno)d, Level: %(levelname)s, Msg: %(message)s'))
sh.setFormatter(logging.Formatter('Name: %(name)s, %(module)s/%(funcName)s[%(levelname)s]: %(message)s (lineno:%(lineno)d)'))
# add the handlers to logger
self.logger.addHandler(sh)
self.logger.addHandler(fh)
self.logger.propagate = False # don't pass messages to parent loggers
if not type(ctx) == zmq.sugar.context.Context:
self.logger.warn("Created ZMQ context. Please supply a ZMQ context next time.")
ctx = zmq.Context()
self.ctx = ctx
if not type(name) == str:
name = "Default"
self.logger.warn("Please provide a the name as a string. Setting name to default: %s." % name)
self.name = name
if not headers:
self.logger.warn("Please provide a model and other header information.")
headers = {}
self.headers = headers
if not groups:
groups = ["SHERPA"]
self.logger.warn("Please provide a list with group names to which it will listen. Will set it to default: %s" %groups)
self.groups = groups
if not config_file:
# will be opened during configuration
self.logger.error("No config file provided for initial configuration")
exit()
self.config_file = config_file
self.config = None
self.alive = True # used for exiting once the node is stopped
self.line_controller = None # stores uid of line controller this module is listening to (to avoid several line controllers)
self.com_timeout = polling_timeout # time_out in msec after which poller returns
self.sim_time = sim_time # time in msec
self.inbox = []
self.outbox = []
# Node setup
self.node = Pyre(self.name)
for key in self.headers:
self.node.set_header(key,self.headers[key])
for group in self.groups:
self.node.join(group)
#self.node.set_verbose()
self.node.start()
# Socket setup
self.poller = zmq.Poller()
self.poller.register(self.node.socket(), zmq.POLLIN)
port = "12911"
self.zmq_socket = self.ctx.socket(zmq.PUB)
self.zmq_socket.bind("tcp://*:%s" % port)
self.run()
def run(self):
""" Running loop of this process:
[COMMUNICATION] Check communication channels and parse all messages.
"""
while self.alive:
try:
#[COMMUNICATION]
self.communication()
#[LOGGING]
#self.logging()
time.sleep(1)
except (KeyboardInterrupt, SystemExit):
break
self.node.stop()
def communication(self):
""" This function handles the communication """
# Check if communication is ready
if not self.poller:
self.logger.warn("No communication channels yet.")
# Process input
items = dict(self.poller.poll(self.com_timeout))
# Get input from Pyre socket and put it in inbox which is processed in the following steps
#logger.debug("Start processing incoming messages")
if self.node.socket() in items and items[self.node.socket()] == zmq.POLLIN:
self.logger.info("Received %d msgs." % len(items))
#print "msg arrived. inbox len %d" % len(self.inbox)
msg_frame = self.node.recv()
msg_type = msg_frame.pop(0)
peer_uid = uuid.UUID(bytes=msg_frame.pop(0))
peer_name = msg_frame.pop(0)
self.logger.info("Msg type: %s" % msg_type)
self.logger.info("Sender: %s" % peer_name)
# For shout and whisper take message payload and put it into inbox assuming it is correct
# For the other zyre msgs create a JSON obj and put that into inbox
# TODO: add validation
if msg_type == "SHOUT":
group = msg_frame.pop(0)
msg = json.loads(msg_frame.pop(0))
msg["sender_UUID"] = peer_uid
msg["sender_name"] = peer_name
# self.inbox.append(msg)
self.outbox.append(msg)
elif msg_type == "WHISPER":
msg = json.loads(msg_frame.pop(0))
msg["sender_UUID"] = peer_uid
msg["sender_name"] = peer_name
self.inbox.append(msg)
# don't care about join and leave messages; if necessary, split to have separate events
# elif msg_type == "LEAVE" or msg_type == "JOIN":
# group = msg_frame.pop(0)
# event = json.dumps({"metamodel": "http://www.sherpa-project.eu/examples/sherpa_msgs",
# "model": "http://www.sherpa-project.eu/examples/sherpa_msgs/zyre_events",
# "type": "leave/join",
# "sender_UUID": peer_uid,
# "sender_name": peer_name,
# "payload": {}
# })
# self.inbox.append(event)
elif msg_type == "ENTER":
headers = json.loads(msg_frame.pop(0))
event = {"metamodel": "http://www.sherpa-project.eu/examples/sherpa_msgs",
"model": "http://www.sherpa-project.eu/examples/sherpa_msgs/zyre_events",
"type": "enter",
"sender_UUID": peer_uid,
"sender_name": peer_name,
"payload": {"header": headers}
}
self.inbox.append(event)
elif msg_type == "EXIT":
event = {"metamodel": "http://www.sherpa-project.eu/examples/sherpa_msgs",
"model": "http://www.sherpa-project.eu/examples/sherpa_msgs/zyre_events",
"type": "exit",
"sender_UUID": peer_uid,
"sender_name": peer_name,
"payload": {}
}
self.inbox.append(event)
# Process output and send all msgs there until it is empty, but only if a line controller is connected.
if self.outbox: #only do if there really is something in the outbox
#if self.lcsm.sm.curr_state._name == "Idle" or self.lcsm.sm.curr_state._name == "Busy":
if true:
self.logger.info("Start processing messages in outbox. Number of msgs in outbox: %d" % len(self.outbox))
while self.outbox:
# since we assume all msgs conform to the sherpa_msgs JSON model, simply shout them out
# TODO: add validation
msg = self.outbox.pop()
if type(msg) == dict:
self.logger.info("outbox msg type: " + msg["type"])
self.node.shout("SHERPA", json.dumps(msg))
#WM message
msg_wm_update = {
"@worldmodeltype": "RSGUpdate",
"operation": "CREATE",
"node": {
"@graphtype": "Group",
"id": "ff483c43-4a36-4197-be49-de829cdd66c8",
"attributes": [
{"key": "name", "value": "Task Specification Tree"},
{"key": "tst:envtst", "value": msg },
],
},
"parentId": "e379121f-06c6-4e21-ae9d-ae78ec1986a1",
}
print ("===")
print (json.dumps(msg_wm_update))
self.zmq_socket.send_string(json.dumps(msg_wm_update))
else:
self.logger.warn("Message is not a dict! Serialization is done here! Msg: \n" + str(msg))
else:
self.logger.info("Can't send messages in outbox. Module not ready.")
def rethinkdb_writer(ctx, pipe):
# Database setup
with open('../configuration.json') as data_file:
configuration = json.load(data_file)
group_name = configuration['zyreMediator']['group']
n = Pyre(configuration['zyreMediator']['name'])
n.set_interface('usb0')
n.set_header('TYPE', configuration['zyreMediator']['type'])
n.join(group_name)
n.start()
# Zyre setup
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
poller.register(n.inbox, zmq.POLLIN)
database_configuration = configuration['database']['mongoDB']
mongo_connection = MongoClient(database_configuration['host'], database_configuration['port'])
meteor = mongo_connection['meteor']
# Add this module to the database
meteor['modules'].insert([{
'_id': str(n.uuid()),
'name': n.name(),
'type': configuration['zyreMediator']['type'],
'parent': None
}])
ready_message = {
'type': 'state',
'senderId': str(n.uuid()),
'payload': 2
}
def logMessage(message_to_log):
message_to_log['timestamp'] = datetime.datetime.utcnow()
meteor['events'].insert_one(message_to_log)
del message_to_log['timestamp']
del message_to_log['_id']
n.shout(group_name, json.dumps(ready_message))
logMessage(ready_message)
module_name_to_uid_map = {}
while True:
items = dict(poller.poll(10))
if pipe in items and items[pipe] == zmq.POLLIN:
message = pipe.recv()
# message to quit
if message.decode('utf-8') == '$$STOP':
break
if n.inbox in items and items[n.inbox] == zmq.POLLIN:
msg_frame = n.recv()
msg_type = msg_frame.pop(0)
peer_uid = uuid.UUID(bytes=msg_frame.pop(0))
peer_name = msg_frame.pop(0)
print('NODE_MSG TYPE: %s' % msg_type)
print('NODE_MSG PEER: %s' % str(peer_uid))
print('NODE_MSG NAME: %s' % peer_name)
if msg_type.decode('utf-8') == 'ENTER':
headers = json.loads(msg_frame.pop(0))
try:
module_type = headers['type']
except KeyError:
print("Your header doesn't contain your type of module")
module_type = 'unknown'
try:
parent_module_id = headers['parentId']
except KeyError:
print("The header doesn't contain the module's parent id")
parent_module_id = None
# creates an entry with all known information about the robot
# in the database if the robot is not in the database
meteor['modules'].insert_one({
'_id': str(peer_uid),
'name': peer_name,
'type': module_type,
'parent': parent_module_id
})
module_name_to_uid_map[peer_name] = str(peer_uid)
elif msg_type.decode('utf-8') == 'EXIT':
meteor['modules'].remove({'_id': str(peer_uid)})
elif msg_type.decode('utf-8') == 'SHOUT':
# write message to database
group = msg_frame.pop(0)
try:
data = json.loads(msg_frame[0])
except:
data = {}
print 'Invalid JSON string'
# print data
data['senderId'] = str(peer_uid)
logMessage(data)
elif msg_type.decode('utf-8') == 'WHISPER':
# write message to database
try:
data = json.loads(msg_frame[0])
except:
print 'Invalid JSON string'
logMessage(data)
meteor['modules'].remove({'_id': str(n.uuid())})
n.stop()
lst_msg = ['physics', 'Biology', 'chemistry', 'maths']
lst_msg = [x.encode('utf-8') for x in lst_msg]
stp_msg = 'stop'
k = 0
while True:
print('insert command: ')
k = input()
print(k)
if str(k) == 'q':
print('break')
n.stop()
break
elif str(k) == 'm':
print('send message')
# n.shout("CHAT", msg.encode('ascii'))
n.shout("CHAT", msg.encode('utf-8'))
# n.shout("CHAT", msg.decode('ascii'))
elif str(k) == 's':
print('stop message sent')
n.shout("CHAT", stp_msg.encode('utf-8'))
elif str(k) == 'l':
print('LIST message sent')
# n.shout("CHAT", lst_msg.encode('utf-8'))
n.shout("CHAT", lst_msg)
# n.shout("CHAT", [x.encode('utf-8') for x in lst_msg])
elif str(k) == 'dic':
n.shout("CHAT", dic_msg.encode('utf-8'))
elif str(k) == 'js':
n.shout("CHAT", jmsg)
else:
print('nodes list')
