Source code for sesf.msgtransfer2.user_node

"""
Module **sesf.msgtransfer2.user_node** has class ``UserNode`` that
implements a user node that starts a given msgtransfer2 node.
If the peer user node is also started, the two user nodes exercise
the msgtransfer2 service provided by the two msgtransfer2 nodes.
For example:

- Run ``python user_node.py 2 0 --use imp_0.node 2 0`` to start a process
  that starts ``UserNode`` 0 which starts ``msgtransfer2.imp_0.Node`` 0.
- Run ``python user_node.py 2 1 --use imp_0.node 2 1`` to start a process
  that starts ``UserNode`` 1 which starts ``msgtransfer2.imp_0.Node`` 1.
- Or, instead of the above two commands, run
  ``python ../start_nodes.py 2 user_node.py --use imp_0.node``.)

The two user nodes use the service provided by the two msgtransfer2 nodes
to exchange a few messages, then end the msgtransfer2 service and the
two processes.

The user nodes can also make use of a running msgtransfer2 *servicemodel*,
instead of a msgtransfer2 implementation. Simply replace ``imp_0.node``
by ``service_node`` in the above commands.
"""

from threading import Thread
import importlib, random, time, argparse, sys

class UserNode():

  def __init__(self, argv):
    p = argparse.ArgumentParser(
      usage='python user_node.py [-h] num_nodes myid --use node_argv',
      description='create UserNode using msgtransfer2 node_argv')
    p.add_argument("num_nodes", type=int, help='number of nodes')
    p.add_argument("myid", type=int,
                   help='id of this node, in 0..num_nodes-1')
    p.add_argument("--use", nargs=argparse.REMAINDER,
                   help='zero or more "--use node_argv" strings')
    args = p.parse_args(argv[1:])
    print("create node from args:", args)
    if args.use == None:
      print("Using sesf.msgtransfer2.imp_0.node for msgtransfer2 node")
      nodemodule = importlib.import_module('sesf.msgtransfer2.imp_0.node')
      mtnode = nodemodule.Node(
        ['placeholder', str(args.num_nodes), str(args.myid)])
    else:
      nodemodule = importlib.import_module(args.use[0])
      print("creating_node_from_module", nodemodule)
      mtnode = nodemodule.Node(args.use)
    print("msgtransfer2 node", mtnode)

    self.num_nodes = 2
    self.myid = args.myid
    self.mtnode = mtnode
    self.recv_thread = Thread(target=self.do_recvs)
    self.recv_thread.start()
    print('starting user', self.num_nodes, self.myid, self.mtnode)


  def do_recvs(self):
    while True:
      rval = self.mtnode.recv()
      print("user rcvd", rval, flush=True)
      if rval == (False,):
        break

  def do_sends(self):
    for i in range(5):
      time.sleep(2*random.random())
      msg = random.randint(0, 1000)
      print("user send", msg, flush=True)
      rval = self.mtnode.send(msg)
      if not rval:
        break

##### END class UserNode in module msgtransfer2.user_node ################

if __name__ == '__main__':
  usernode = UserNode(sys.argv)
  usernode.do_sends()
  time.sleep(1)
  if usernode.myid == 0:
    print("mtnode.end called", flush=True)    
    usernode.mtnode.end()
  usernode.recv_thread.join()
  print("usernode ended", flush=True)
  time.sleep(2)