def network_thread(self, ctx, pipe):
print("Network thread started..")
n = Pyre(self.name)
n.join("Car2X")
n.start()
node_socket = n.socket()
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
poller.register(node_socket, zmq.POLLIN)
while not self.stopped:
items = dict(poller.poll(1000))
if pipe in items and items[pipe] == zmq.POLLIN:
# handle outgoing messages
message = pipe.recv()
n.shouts("Car2X", message.decode('utf-8'))
elif node_socket in items:
cmds = n.recv()
msg_type = cmds.pop(0)
msg_uuid = cmds.pop(0)
msg_name = cmds.pop(0)
if msg_type == "JOIN":
print("{} joined!".format(msg_name))
elif msg_type == "EXIT":
print("{} left!".format(msg_name))
elif msg_type == "SHOUT":
# handling incoming information
msg_channel = cmds.pop(0)
msg_str = cmds.pop(0)
self.process_data(msg_str)
n.stop()
class Client(object):
def __exit__(self, exc_type, exc_val, exc_tb):
self.engine.stop()
def __init__(self, channel=ZYRE_CHANNEL, *args, **kvargs):
self.logger = logging.getLogger('pyre')
self.channel = channel
self.engine = Pyre(self.channel)
self.id = self.engine.uuid()
def start(self, ctx, pipe):
self.logger.info('joining channel')
self.engine.join(self.channel)
self.logger.info('starting engine...')
self.engine.start()
self.logger.info('id is: {}'.format(self.id))
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
poller.register(self.engine.socket(), 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
self.logger.info("CHAT_TASK: %s" % message)
self.engine.shouts(self.channel, message.decode('utf-8'))
else:
cmds = self.engine.recv()
self.logger.info('HMMM {}'.format(cmds))
msg_type = cmds.pop(0)
self.logger.info("NODE_MSG TYPE: %s" % msg_type)
self.logger.info("NODE_MSG PEER: %s" %
uuid.UUID(bytes=cmds.pop(0)))
self.logger.info("NODE_MSG NAME: %s" % cmds.pop(0))
if msg_type.decode('utf-8') == "SHOUT":
self.logger.info("NODE_MSG GROUP: %s" % cmds.pop(0))
elif msg_type.decode('utf-8') == "ENTER":
headers = json.loads(cmds.pop(0).decode('utf-8'))
self.logger.info("NODE_MSG HEADERS: %s" % headers)
for key in headers:
self.logger.info("key = {0}, value = {1}".format(
key, headers[key]))
self.logger.info("NODE_MSG CONT: %s" % cmds)
self.engine.stop()
class Client(object):
def __exit__(self, exc_type, exc_val, exc_tb):
self.engine.stop()
def __init__(self, channel=ZYRE_CHANNEL, *args, **kvargs):
self.logger = logging.getLogger('pyre')
self.channel = channel
self.engine = Pyre(self.channel)
self.id = self.engine.uuid()
def start(self, ctx, pipe):
self.logger.info('joining channel')
self.engine.join(self.channel)
self.logger.info('starting engine...')
self.engine.start()
self.logger.info('id is: {}'.format(self.id))
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
poller.register(self.engine.socket(), 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
self.logger.info("CHAT_TASK: %s" % message)
self.engine.shouts(self.channel, message.decode('utf-8'))
else:
cmds = self.engine.recv()
self.logger.info('HMMM {}'.format(cmds))
msg_type = cmds.pop(0)
self.logger.info("NODE_MSG TYPE: %s" % msg_type)
self.logger.info("NODE_MSG PEER: %s" % uuid.UUID(bytes=cmds.pop(0)))
self.logger.info("NODE_MSG NAME: %s" % cmds.pop(0))
if msg_type.decode('utf-8') == "SHOUT":
self.logger.info("NODE_MSG GROUP: %s" % cmds.pop(0))
elif msg_type.decode('utf-8') == "ENTER":
headers = json.loads(cmds.pop(0).decode('utf-8'))
self.logger.info("NODE_MSG HEADERS: %s" % headers)
for key in headers:
self.logger.info("key = {0}, value = {1}".format(key, headers[key]))
self.logger.info("NODE_MSG CONT: %s" % cmds)
self.engine.stop()
def network_thread(self, ctx, pipe):
print("Network thread started..")
n = Pyre(self.name)
n.join("Car2X")
n.start()
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
poller.register(n.inbox, zmq.POLLIN)
# wait for others
while not n.peer_groups():
time.sleep(0.0001)
pass
pipe.send('$$ready'.encode('utf-8'))
while not self.stopped:
items = dict(poller.poll())
if pipe in items and items[pipe] == zmq.POLLIN:
# handle outgoing messages
try:
message = pipe.recv()
if message.decode('utf-8') == "$$STOP":
break
n.shouts("Car2X", message.decode('utf-8'))
except zmq.error.Again:
print("ERROR! Again #1")
if n.inbox in items and items[n.inbox] == zmq.POLLIN:
try:
cmds = n.recv()
msg_type = cmds.pop(0)
msg_uuid = cmds.pop(0)
msg_name = cmds.pop(0)
if msg_type == "JOIN":
print("{} joined!".format(msg_name))
# ADD CAR IF NOT CONTROL
if msg_name[0:1] != "$":
self.window.hosts.append(msg_name)
elif msg_type == "EXIT":
print("{} left!".format(msg_name))
# REMOVE CAR
if msg_name in self.window.hosts:
self.window.hosts.remove(msg_name)
elif msg_type == "SHOUT":
# handling incoming information
msg_channel = cmds.pop(0)
msg_str = cmds.pop(0)
self.process_data(msg_str, msg_name)
except zmq.error.Again:
print("ERROR! Again #2")
n.stop()
def gaze_exchange_task(self, ctx, pipe):
"""
Task for exchanging messages
Args:
ctx(zmq.Context): the zmq context
pipe(zmq.PAIR pipe): the pipe for exchanging messages
Returns: (zmq.PAIR pipe) the pipe
"""
n = Pyre("GAZE_EXCHANGE")
self.publisher_id = n.uuid()
n.join(GROUP_GAZE_EXCHANGE)
n.start()
poller = zmq.Poller()
# noinspection PyUnresolvedReferences
poller.register(pipe, zmq.POLLIN)
# noinspection PyUnresolvedReferences
poller.register(n.socket(), zmq.POLLIN)
while not self.stopped:
items = dict(poller.poll())
print(n.socket(), items)
# noinspection PyUnresolvedReferences
if pipe in items and items[pipe] == zmq.POLLIN:
message = pipe.recv()
# message to quit
message = message.decode('utf-8')
if message == STOP_MESSAGE:
break
print("GAZE_EXCHANGE_TASK: {}".format(message))
self.save_gaze_from_message(message)
n.shouts(GROUP_GAZE_EXCHANGE, message)
else:
cmds = n.recv()
msg_type = cmds.pop(0)
print("NODE_MSG TYPE: %s" % msg_type)
print("NODE_MSG PEER: %s" % uuid.UUID(bytes=cmds.pop(0)))
print("NODE_MSG NAME: %s" % cmds.pop(0))
if msg_type.decode('utf-8') == "SHOUT":
print("NODE_MSG GROUP: %s" % cmds.pop(0))
message = cmds.pop(0).decode("utf-8")
self.save_gaze_from_message(message)
elif msg_type.decode('utf-8') == "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)
n.stop()
def indicators_create(self, data, **kwargs):
if isinstance(data, dict):
data = Indicator(**data)
if isinstance(data, Indicator):
data = [data]
n = Pyre()
n.join(CHAN)
n.start()
sleep(1)
for i in data:
n.shouts(CHAN, str(i))
n.stop()
def thread_loop(self, context, pipe):
n = Pyre(self.name)
n.join(self.group)
n.start()
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
poller.register(n.socket(), zmq.POLLIN)
front, back = zhelper.zcreate_pipe(context)
poller.register(back, zmq.POLLIN)
def wake_up():
#on app close this timer calls a closed socket. We simply catch it here.
try:
front.send('wake_up')
except Exception as e:
logger.debug('Orphaned timer thread raised error: %s' % e)
t = Timer(self.time_sync_announce_interval, wake_up)
t.daemon = True
t.start()
while (True):
try:
#this should not fail but it does sometimes. We need to clean this out.
# I think we are not treating sockets correclty as they are not thread-save.
items = dict(poller.poll())
except zmq.ZMQError:
logger.warning('Socket fail.')
continue
if back in items and items[back] == zmq.POLLIN:
back.recv()
#timeout events are used for pupil sync.
#annouce masterhood every interval time:
if isinstance(self.time_sync_node, Clock_Sync_Master):
n.shouts(
self.group, SYNC_TIME_MASTER_ANNOUNCE +
"%s" % self.clock_master_worthiness() + msg_delimeter +
'%s' % self.time_sync_node.port)
# synced slave: see if we should become master if we dont hear annoncement within time.
elif isinstance(self.time_sync_node, Clock_Sync_Follower
) and not self.time_sync_node.offset_remains:
if self.get_unadjusted_time(
) - self.last_master_announce > self.time_sync_wait_interval_short:
self.time_sync_node.terminate()
self.time_sync_node = Clock_Sync_Master(
time_fn=self.get_time)
n.shouts(
self.group, SYNC_TIME_MASTER_ANNOUNCE +
"%s" % self.clock_master_worthiness() +
msg_delimeter + '%s' % self.time_sync_node.port)
# unsynced slave or none should wait longer but eventually take over
elif self.get_unadjusted_time(
) - self.last_master_announce > self.time_sync_wait_interval_long:
if self.time_sync_node:
self.time_sync_node.terminate()
self.time_sync_node = Clock_Sync_Master(
time_fn=self.get_time)
n.shouts(
self.group, SYNC_TIME_MASTER_ANNOUNCE +
"%s" % self.clock_master_worthiness() + msg_delimeter +
'%s' % self.time_sync_node.port)
t = Timer(self.time_sync_announce_interval, wake_up)
t.daemon = True
t.start()
if pipe in items and items[pipe] == zmq.POLLIN:
message = pipe.recv()
# message to quit
if message.decode('utf-8') == exit_thread:
break
else:
logger.debug("Shout '%s' to '%s' " % (message, self.group))
n.shouts(self.group, message)
if n.socket() in items and items[n.socket()] == zmq.POLLIN:
cmds = n.recv()
msg_type = cmds.pop(0)
msg_type = msg_type.decode('utf-8')
if msg_type == "SHOUT":
uuid, name, group, msg = cmds
logger.debug("'%s' shouts '%s'." % (name, msg))
self._handle_msg(uuid, name, msg, n)
elif msg_type == "WHISPER":
uuid, name, msg = cmds
logger.debug("'%s/' whispers '%s'." % (name, msg))
self._handle_msg_whisper(uuid, name, msg, n)
elif msg_type == "JOIN":
uuid, name, group = cmds
if group == self.group:
self.group_members[uuid] = name
self.update_gui()
elif msg_type == "EXIT":
uuid, name = cmds
try:
del self.group_members[uuid]
except KeyError:
pass
else:
self.update_gui()
# elif msg_type == "LEAVE":
# uuid,name,group = cmds
# elif msg_type == "ENTER":
# uuid,name,headers,ip = cmds
# logger.warning((uuid,'name',headers,ip))
else:
pass
logger.debug('thread_loop closing.')
self.thread_pipe = None
n.stop()
def thread_loop(self,context,pipe):
n = Pyre(self.name)
n.join(self.group)
n.start()
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
poller.register(n.socket(), zmq.POLLIN)
front,back = zhelper.zcreate_pipe(context)
poller.register(back, zmq.POLLIN)
def wake_up():
#on app close this timer calls a closed socket. We simply catch it here.
try:
front.send('wake_up')
except Exception as e:
logger.debug('Orphaned timer thread raised error: %s'%e)
t = Timer(self.time_sync_announce_interval, wake_up)
t.daemon = True
t.start()
while(True):
try:
#this should not fail but it does sometimes. We need to clean this out.
# I think we are not treating sockets correclty as they are not thread-save.
items = dict(poller.poll())
except zmq.ZMQError:
logger.warning('Socket fail.')
continue
if back in items and items[back] == zmq.POLLIN:
back.recv()
#timeout events are used for pupil sync.
#annouce masterhood every interval time:
if isinstance(self.sync_node,Clock_Sync_Master):
n.shouts(self.group, SYNC_TIME_MASTER_ANNOUNCE+"%s"%self.clock_master_worthiness()+msg_delimeter+'%s'%self.sync_node.port)
# synced slave: see if we should become master if we dont hear annoncement within time.
elif isinstance(self.sync_node,Clock_Sync_Follower) and not self.sync_node.offset_remains:
if self.get_monotonic_time()-self.last_master_announce > self.time_sync_wait_interval_short:
self.sync_node.terminate()
self.sync_node = Clock_Sync_Master(time_fn=self.get_time)
n.shouts(self.group, SYNC_TIME_MASTER_ANNOUNCE+"%s"%self.clock_master_worthiness()+msg_delimeter+'%s'%self.sync_node.port)
# unsynced slave or none should wait longer but eventually take over
elif self.get_monotonic_time()-self.last_master_announce > self.time_sync_wait_interval_long:
if self.sync_node:
self.sync_node.terminate()
self.sync_node = Clock_Sync_Master(time_fn=self.get_time)
n.shouts(self.group, SYNC_TIME_MASTER_ANNOUNCE+"%s"%self.clock_master_worthiness()+msg_delimeter+'%s'%self.sync_node.port)
t = Timer(self.time_sync_announce_interval, wake_up)
t.daemon = True
t.start()
if pipe in items and items[pipe] == zmq.POLLIN:
message = pipe.recv()
# message to quit
if message.decode('utf-8') == exit_thread:
break
else:
logger.debug("Shout '%s' to '%s' " %(message,self.group))
n.shouts(self.group, message)
if n.socket() in items and items[n.socket()] == zmq.POLLIN:
cmds = n.recv()
msg_type = cmds.pop(0)
msg_type = msg_type.decode('utf-8')
if msg_type == "SHOUT":
uuid,name,group,msg = cmds
logger.debug("'%s' shouts '%s'."%(name,msg))
self.handle_msg(uuid,name,msg,n)
elif msg_type == "WHISPER":
uuid,name,msg = cmds
logger.debug("'%s/' whispers '%s'."%(name,msg))
self.handle_msg_whisper(uuid,name,msg,n)
elif msg_type == "JOIN":
uuid,name,group = cmds
if group == self.group:
self.group_members[uuid] = name
self.update_gui()
elif msg_type == "EXIT":
uuid,name = cmds
try:
del self.group_members[uuid]
except KeyError:
pass
else:
self.update_gui()
# elif msg_type == "LEAVE":
# uuid,name,group = cmds
# elif msg_type == "ENTER":
# uuid,name,headers,ip = cmds
# logger.warning((uuid,'name',headers,ip))
else:
pass
logger.debug('thread_loop closing.')
self.thread_pipe = None
n.stop()
def thread_loop(self,context,pipe):
n = Pyre(self.name)
n.join(self.group)
n.start()
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
logger.debug(n.socket())
poller.register(n.socket(), zmq.POLLIN)
while(True):
try:
#this should not fail but it does sometimes. We need to clean this out.
# I think we are not treating sockets correclty as they are not thread-save.
items = dict(poller.poll(self.timeout))
except zmq.ZMQError:
logger.warning('Socket fail.')
# print(n.socket(), items)
if pipe in items and items[pipe] == zmq.POLLIN:
message = pipe.recv()
# message to quit
if message.decode('utf-8') == exit_thread:
break
elif message.decode('utf-8') == init_master_sync:
self.timeout = 3000
else:
logger.debug("Emitting to '%s' to '%s' " %(message,self.group))
n.shouts(self.group, message)
if n.socket() in items and items[n.socket()] == zmq.POLLIN:
cmds = n.recv()
msg_type = cmds.pop(0)
msg_type = msg_type.decode('utf-8')
if msg_type == "SHOUT":
uid,name,group,msg = cmds
logger.debug("'%s' shouts '%s'."%(name,msg))
self.handle_msg(name,msg)
elif msg_type == "WHISPER":
uid,name,msg = cmds
logger.debug("'%s/' whispers '%s'."%(name,msg))
self.handle_msg_whisper(uid,name,msg,n)
elif msg_type == "JOIN":
uid,name,group = cmds
if group == self.group:
self.group_members[uid] = name
self.update_gui()
elif msg_type == "EXIT":
uid,name = cmds
try:
del self.group_members[uid]
except KeyError:
pass
else:
self.update_gui()
# elif msg_type == "LEAVE":
# uid,name,group = cmds
# elif msg_type == "ENTER":
# uid,name,headers,ip = cmds
# logger.warning((uid,'name',headers,ip))
elif not items:
#timeout events are used for pupil sync.
if self.sync_master is self:
if self.sync_nodes:
node_uid = self.sync_nodes.pop(0)
logger.info("Synchonizing node %s"%self.group_members[node_uid])
n.whispers(uuid.UUID(bytes=node_uid),sync_time_init)
else:
self.timeout = None
self.sync_master = None
logger.info("All other Pupil nodes are sycronized.")
elif self.sync_master:
t0 = self.g_pool.capture.get_timestamp()
n.whispers(uuid.UUID(bytes=self.sync_master),sync_time_request+'%s'%t0)
else:
pass
logger.debug('thread_loop closing.')
self.thread_pipe = None
n.stop()
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()
def thread_loop(self, context, pipe):
n = Pyre(self.name)
n.join(self.group)
n.start()
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
logger.debug(n.socket())
poller.register(n.socket(), zmq.POLLIN)
while (True):
try:
#this should not fail but it does sometimes. We need to clean this out.
# I think we are not treating sockets correclty as they are not thread-save.
items = dict(poller.poll())
except zmq.ZMQError:
logger.warning('Socket fail.')
# print(n.socket(), items)
if pipe in items and items[pipe] == zmq.POLLIN:
message = pipe.recv()
# message to quit
if message.decode('utf-8') == "EXIT_THREAD":
break
logger.debug("Emitting to '%s' to '%s' " %
(message, self.group))
n.shouts(self.group, message)
if n.socket() in items and items[n.socket()] == zmq.POLLIN:
cmds = n.recv()
msg_type = cmds.pop(0)
msg_type = msg_type.decode('utf-8')
if msg_type == "SHOUT":
uid, name, group, msg = cmds
logger.debug("'%s' shouts '%s'." % (name, msg))
self.handle_msg(name, msg)
elif msg_type == "WHISPER":
pass
# uid,name,group,msg = cmds
# logger.debug("'%s' whispers '%s'."%(name,msg))
# self.handle_msg(name,msg)
elif msg_type == "JOIN":
uid, name, group = cmds
if group == self.group:
self.group_members[uid] = name
self.update_gui()
elif msg_type == "EXIT":
uid, name = cmds
try:
del self.group_members[uid]
except KeyError:
pass
else:
self.update_gui()
# elif msg_type == "LEAVE":
# uid,name,group = cmds
# elif msg_type == "ENTER":
# uid,name,headers,ip = cmds
logger.debug('thread_loop closing.')
self.thread_pipe = None
n.stop()
def chat_task(ctx, pipe):
print("-----CAR PEER COMMUNICATION STARTED-----")
print("Manufacturer: ", MANUFACTURER, " - Model: ", MODEL)
connected_cars = 0
#Set up node for the car
n = Pyre("")
n.set_header("manufacturer", MANUFACTURER)
n.set_header("model", MODEL)
#Join the group 'chat'
n.join(GROUPNAME)
#Start broadcasting node
n.start()
# Set up poller
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN) #Local pipe (contains commands/messages we send through terminal)
poller.register(n.socket(), zmq.POLLIN)
# A while loop constantly polls for new items = PULL system
while True:
#Wait for new message to be polled. This function blocks until there is a new message
items = dict(poller.poll())
#This are messages from ourselves, that we want to shout on the network
if pipe in items:
message = pipe.recv()
# User stopped car
if message.decode('utf-8') == STOP_COMMAND:
break
print(">>>>>> Sending out shout: %s" % message)
n.shouts(GROUPNAME, message.decode('utf-8'))
# Received messages from system or messages from other peers
else:
cmds = n.recv()
print("--------------------------------------------------------------------------------")
#print(">>>>>>>RECEIVED MESSAGE: ", cmds)
msg_type = cmds.pop(0)
car_uuid = uuid.UUID(bytes=cmds.pop(0))
msg_name = cmds.pop(0)
if msg_type.decode('utf-8') == "ENTER":
headers = json.loads(cmds.pop(0).decode('utf-8'))
print(">>>> NEW CAR DISCOVERED IN NETWORK")
print("---Manufacturer:", headers.get("manufacturer"), "--- Model:", headers.get("model"))
elif msg_type.decode('utf-8') == "JOIN":
print(">>>> NEW CAR JOINED GROUP <<", cmds.pop(0).decode('utf-8'),">>")
connected_cars += 1
elif msg_type.decode('utf-8') == "SHOUT":
print(">>>> RECEIVED SHOUT IN %s" % cmds.pop(0))
print("---Msg: %s" % cmds.pop(0))
elif msg_type.decode('utf-8') == "EXIT":
print(">>>> CAR LEFT NETWORK")
connected_cars -= 1
print("---Total connected cars: ", connected_cars)
print("---Car_UUID: ", car_uuid)
#print("---NODE_MSG REMAINING: %s" % cmds)
print("-----CAR COMMUNICATION STOPPED-----")
n.stop()
def thread_loop(self,context,pipe):
n = Pyre(self.name)
n.join(self.group)
n.start()
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
logger.debug(n.socket())
poller.register(n.socket(), zmq.POLLIN)
while(True):
try:
#this should not fail but it does sometimes. We need to clean this out.
# I think we are not treating sockets correclty as they are not thread-save.
items = dict(poller.poll())
except zmq.ZMQError:
logger.warning('Socket fail.')
# print(n.socket(), items)
if pipe in items and items[pipe] == zmq.POLLIN:
message = pipe.recv()
# message to quit
if message.decode('utf-8') == "EXIT_THREAD":
break
logger.debug("Emitting to '%s' to '%s' " %(message,self.group))
n.shouts(self.group, message)
if n.socket() in items and items[n.socket()] == zmq.POLLIN:
cmds = n.recv()
msg_type = cmds.pop(0)
msg_type = msg_type.decode('utf-8')
if msg_type == "SHOUT":
uid,name,group,msg = cmds
logger.debug("'%s' shouts '%s'."%(name,msg))
self.handle_msg(name,msg)
elif msg_type == "WHISPER":
pass
# uid,name,group,msg = cmds
# logger.debug("'%s' whispers '%s'."%(name,msg))
# self.handle_msg(name,msg)
elif msg_type == "JOIN":
uid,name,group = cmds
if group == self.group:
self.group_members[uid] = name
self.update_gui()
elif msg_type == "EXIT":
uid,name = cmds
try:
del self.group_members[uid]
except KeyError:
pass
else:
self.update_gui()
# elif msg_type == "LEAVE":
# uid,name,group = cmds
# elif msg_type == "ENTER":
# uid,name,headers,ip = cmds
logger.debug('thread_loop closing.')
self.thread_pipe = None
n.stop()
def thread_loop(self,context,pipe):
n = Pyre(self.name)
n.join(self.group)
n.start()
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
logger.debug(n.socket())
poller.register(n.socket(), zmq.POLLIN)
while(True):
try:
#this should not fail but it does sometimes. We need to clean this out.
# I think we are not treating sockets correclty as they are not thread-save.
items = dict(poller.poll())
except zmq.ZMQError:
logger.warning('Socket fail.')
# print(n.socket(), items)
if pipe in items and items[pipe] == zmq.POLLIN:
message = pipe.recv()
# message to quit
if message.decode('utf-8') == "EXIT_THREAD":
break
logger.debug("Emitting to '%s' to '%s' " %(message,self.group))
n.shouts(self.group, message)
if n.socket() in items and items[n.socket()] == zmq.POLLIN:
cmds = n.recv()
msg_type = cmds.pop(0)
msg_type = msg_type.decode('utf-8')
if msg_type == "SHOUT":
uid,name,group,msg = cmds
logger.debug("'%s' shouts '%s'."%(name,msg))
if start_rec in msg :
session_name = msg.replace(start_rec,'')
self.notify_all({'name':'rec_should_start','session_name':session_name,'network_propagate':False})
elif stop_rec in msg:
self.notify_all({'name':'rec_should_stop','network_propagate':False})
elif sync_time in msg:
offset = float(msg.replace(sync_time,''))
if self.ok_to_set_timebase():
self.adjust_timebase(offset)
elif msg_type == "ENTER":
uid,name,headers,ip = cmds
elif msg_type == "JOIN":
uid,name,group = cmds
if group == self.group:
self.group_members[uid] = name
self.update_gui()
elif msg_type == "EXIT":
uid,name = cmds
try:
del self.group_members[uid]
except KeyError:
pass
else:
self.update_gui()
elif msg_type == "LEAVE":
uid,name,group = cmds
elif msg_tpye == "WHISPER":
pass
logger.debug('thread_loop closing.')
self.thread_pipe = None
n.stop()
def thread_loop(self, context, pipe):
n = Pyre(self.name)
n.join(self.group)
n.start()
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
logger.debug(n.socket())
poller.register(n.socket(), zmq.POLLIN)
while (True):
try:
#this should not fail but it does sometimes. We need to clean this out.
# I think we are not treating sockets correclty as they are not thread-save.
items = dict(poller.poll())
except zmq.ZMQError:
logger.warning('Socket fail.')
# print(n.socket(), items)
if pipe in items and items[pipe] == zmq.POLLIN:
message = pipe.recv()
# message to quit
if message.decode('utf-8') == "EXIT_THREAD":
break
logger.debug("Emitting to '%s' to '%s' " %
(message, self.group))
n.shouts(self.group, message)
if n.socket() in items and items[n.socket()] == zmq.POLLIN:
cmds = n.recv()
msg_type = cmds.pop(0)
msg_type = msg_type.decode('utf-8')
if msg_type == "SHOUT":
uid, name, group, msg = cmds
logger.debug("'%s' shouts '%s'." % (name, msg))
if start_rec in msg:
session_name = msg.replace(start_rec, '')
self.notify_all({
'name': 'rec_should_start',
'session_name': session_name,
'network_propagate': False
})
elif stop_rec in msg:
self.notify_all({
'name': 'rec_should_stop',
'network_propagate': False
})
elif sync_time in msg:
offset = float(msg.replace(sync_time, ''))
if self.ok_to_set_timebase():
self.adjust_timebase(offset)
elif msg_type == "ENTER":
uid, name, headers, ip = cmds
elif msg_type == "JOIN":
uid, name, group = cmds
if group == self.group:
self.group_members[uid] = name
self.update_gui()
elif msg_type == "EXIT":
uid, name = cmds
try:
del self.group_members[uid]
except KeyError:
pass
else:
self.update_gui()
elif msg_type == "LEAVE":
uid, name, group = cmds
elif msg_tpye == "WHISPER":
pass
logger.debug('thread_loop closing.')
self.thread_pipe = None
n.stop()
def thread_loop(self, context, pipe):
n = Pyre(self.name)
n.join(self.group)
n.start()
poller = zmq.Poller()
poller.register(pipe, zmq.POLLIN)
logger.debug(n.socket())
poller.register(n.socket(), zmq.POLLIN)
while (True):
try:
#this should not fail but it does sometimes. We need to clean this out.
# I think we are not treating sockets correclty as they are not thread-save.
items = dict(poller.poll(self.timeout))
except zmq.ZMQError:
logger.warning('Socket fail.')
# print(n.socket(), items)
if pipe in items and items[pipe] == zmq.POLLIN:
message = pipe.recv()
# message to quit
if message.decode('utf-8') == exit_thread:
break
elif message.decode('utf-8') == init_master_sync:
self.timeout = 3000
else:
logger.debug("Emitting to '%s' to '%s' " %
(message, self.group))
n.shouts(self.group, message)
if n.socket() in items and items[n.socket()] == zmq.POLLIN:
cmds = n.recv()
msg_type = cmds.pop(0)
msg_type = msg_type.decode('utf-8')
if msg_type == "SHOUT":
uid, name, group, msg = cmds
logger.debug("'%s' shouts '%s'." % (name, msg))
self.handle_msg(name, msg)
elif msg_type == "WHISPER":
uid, name, msg = cmds
logger.debug("'%s/' whispers '%s'." % (name, msg))
self.handle_msg_whisper(uid, name, msg, n)
elif msg_type == "JOIN":
uid, name, group = cmds
if group == self.group:
self.group_members[uid] = name
self.update_gui()
elif msg_type == "EXIT":
uid, name = cmds
try:
del self.group_members[uid]
except KeyError:
pass
else:
self.update_gui()
# elif msg_type == "LEAVE":
# uid,name,group = cmds
# elif msg_type == "ENTER":
# uid,name,headers,ip = cmds
# logger.warning((uid,'name',headers,ip))
elif not items:
#timeout events are used for pupil sync.
if self.sync_master is self:
if self.sync_nodes:
node_uid = self.sync_nodes.pop(0)
logger.info("Synchonizing node %s" %
self.group_members[node_uid])
n.whispers(uuid.UUID(bytes=node_uid), sync_time_init)
else:
self.timeout = None
self.sync_master = None
logger.info("All other Pupil nodes are sycronized.")
elif self.sync_master:
t0 = self.g_pool.capture.get_timestamp()
n.whispers(uuid.UUID(bytes=self.sync_master),
sync_time_request + '%s' % t0)
else:
pass
logger.debug('thread_loop closing.')
self.thread_pipe = None
n.stop()
