def rci_1(a, b=1, coro=None):
logger.debug('running %s/%s with %s, %s', coro.name, id(coro), a, b)
msg = yield coro.receive()
if b % 2 == 0:
yield coro.sleep(b)
logger.debug('%s/%s done', coro.name, id(coro))
# (remote) monitor (if any) gets this exception (to be
# interpreted as normal termination)
raise StopIteration(msg)
else:
# (remote) monitor (if any) gets this exception, too
raise Exception('invalid invocation: %s' % b)
def monitor_proc(n, coro=None):
# this coro gets exceptions from (remote) coroutines created in coro1
done = 0
while True:
try:
yield coro.sleep()
except asyncoro.MonitorException as exc:
rcoro = exc.args[0]
value_type, value = exc.args[1]
if value_type == StopIteration:
logger.debug('RCI %s/%s finished with: %s', rcoro.name, rcoro._id,
value.args[0])
else:
logger.debug('RCI %s/%s failed with: %s', rcoro.name, rcoro._id,
value.args[0])
done += 1
if done == n:
break
def coro1(coro=None):
# if server is on remote network, automatic discovery won't work,
# so add it explicitly
# yield scheduler.peer('192.168.21.5')
# find where 'rci_1' is registered; alternately, location can be
# explicitly created with asyncoro.Location or obtained with
# 'locate_peer' etc.
rloc = yield scheduler.locate_RCI('rci_1', timeout=2)
if not rloc:
raise Exception('failed')
n = 5
monitor = Coro(monitor_proc, n)
for x in range(n):
rcoro = yield scheduler.run_RCI(rloc, 'rci_1', 'test%s' % x, b=x)
logger.debug('rcoro: %s/%s', rcoro.name, rcoro._id)
# set 'm' as monitor for this coroutine
yield monitor.monitor(rcoro)
# send credentials
rcoro.send('msg:%s' % x)
yield coro.sleep(random.uniform(0, 1))
def handle_message(self, msg):
if not msg.dest_service == self.service_id:
raise Exception("Mismatched service recipient for message.")
if msg.type == Message_Setup_Node.Type():
node = Node(self, msg.public_ip, msg.local_ip, msg.local_port)
if msg.seeded_peers:
for peer in msg.seeded_peers:
node.join(peer) # use callback to try next peer if join fails (join is async)
else:
node.join()
self.message_router.route(
Message_Start_Server(node.local_ip, node.local_port,
Message_Start_Server_Callback(self.service_id, node, True),
Message_Start_Server_Callback(self.service_id, node, False)))
elif msg.type == Message_Start_Server_Callback.Type():
if msg.result:
self.nodes[str(msg.node)] = msg.node
self.delay_enqueue(("NODE_STABILIZE", msg.node), 1000)
else:
msg.node.exit_network()
raise Exception( "Unable to successfully start server for node at " + str(msg.node.thisNode))
if msg.type == Message_Forward.Type( ):
ni = msg.origin_node
if self.nodes.has_key(str(ni)):
lnode = self.nodes[str(ni)] # get the Node class this message is addressed to (ip:port)
forward_node = lnode.find_ideal_forward(msg.forward_hash)
if msg.forward_msg.type == Database_Get_Message.Type() or msg.forward_msg.type == Database_Put_Message.Type():
msg.forward_msg.storage_node = forward_node
if forward_node != ni:
self.send_message(msg.forward_msg, forward_node)
else:
self.send_message(msg.forward_msg)
elif msg.type == Message_Recv_Peer_Data.Type(): # came off the wire
ni = Node_Info(msg.local_ip if len(msg.local_ip) > 0 else "127.0.0.1",msg.local_port)
if self.nodes.has_key(str(ni)):
lnode = self.nodes[str(ni)] # get the Node class this message is addressed to (ip:port)
msg = msg.network_msg
rnode = lnode.final_destination(msg)
if rnode != lnode.thisNode:
self.send_message(msg,rnode)
return
logger.debug(str(ni) + " received network msg: " + msg.type)
if msg.type == Message_Forward.Type( ):
lnode.find_ideal_forward(msg.forward_hash) #fix this...we need to do forward the message
elif msg.type == Find_Successor_Message.Type():
self.send_message(Update_Message(lnode.thisNode, msg.reply_to.key, msg.finger), msg.reply_to)
elif msg.type == Update_Message.Type( ):
lnode.update_finger(msg.reply_to, msg.finger)
elif msg.type == Check_Predecessor_Message.Type():
self.send_message(Update_Message(lnode.thisNode, msg.reply_to.key, 0), msg.reply_to)
elif msg.type == Stablize_Message.Type( ):
self.send_message(Stabilize_Reply_Message(lnode.thisNode, msg.reply_to.key, msg.reply_to))
elif msg.type == Stabilize_Reply_Message.Type():
lnode.stabilize(msg)
elif msg.type == Notify_Message.Type():
lnode.get_notified(msg)
elif msg.type == Exit_Message.Type():
lnode.peer_polite_exit(msg.reply_to)
elif msg.type == Database_Put_Message.Type() or msg.type == Database_Get_Message.Type():
msg.storage_node = lnode.thisNode
self.message_router.route(msg)
elif msg.type == Database_Put_Message_Response.Type() or msg.type == Database_Get_Message_Response.Type():
self.message_router.route(msg)
elif msg.type == Message_Console_Command.Type():
self.handle_command(msg.command,msg.args)
