Support interactive mode with charmrun on one host

Launching with charmrun on one host with ++interactive
command-line option will enter an interactive shell. For example:
$ python3 -m charmrun.start +p4 ++interactive

will start an interactive shell using 4 processes. In this mode,
new chare types can be defined and created at run time.

Similarly, interactive mode can also be entered from a python
script by doing:
charm.start(interactive=True)

Author: juanjgalvez

charmpy/charm.py

@@ -99,6 +99,9 @@ def __init__(self):
         # maps cond_str to condition object. the condition object stores the lambda function associated with cond_str
         # TODO: remove old/unused condition strings
         self.wait_conditions = {}
+        # store chare types defined after program start and other objects created
+        # in interactive mode
+        self.dynamic_register = {}
 
     def handleGeneralError(self):
         import traceback
@@ -413,7 +416,7 @@ def _registerInternalChares(self):
     def _createInternalChares(self):
         Group(CharmRemote)
 
-    def start(self, entry, classes=[], modules=[]):
+    def start(self, entry=None, classes=[], modules=[], interactive=False):
         """
         Start Charmpy program.
 
@@ -430,6 +433,13 @@ def start(self, entry, classes=[], modules=[]):
                      arguments are passed to this method.
         """
 
+        if interactive:
+            from .interactive import InteractiveConsole as entry
+            self.origStdinFd = os.dup(0)
+            self.origStoutFd = os.dup(1)
+            self.dynamic_register.update({'charm': charm, 'Chare': Chare, 'Group': Group,
+                                          'Array': Array, 'Reducer': self.reducers})
+
         if self.started:
             raise CharmPyError("charm.start() can only be called once")
         self.started = True
@@ -635,6 +645,12 @@ def exit(self, exit_code=0):
     def myPe(self):
         return charm.myPe()
 
+    def registerNewChareType(self, name, source):
+        exec(source, charm.dynamic_register)
+        chare_type = charm.dynamic_register[name]
+        charm.register(chare_type)
+        charm.registerInCharm(chare_type)
+
 
 def load_charm_library(charm):
     args = sys.argv

charmpy/interactive.py

@@ -0,0 +1,101 @@
+from . import charm, Chare, threaded
+import sys
+import time
+import re
+from code import InteractiveInterpreter
+import os
+
+
+class InteractiveConsole(Chare, InteractiveInterpreter):
+
+    def __init__(self, args):
+        # restore original tty stdin and stdout (else readline won't work correctly)
+        os.dup2(charm.origStdinFd, 0)
+        os.dup2(charm.origStoutFd, 1)
+        InteractiveInterpreter.__init__(self, locals=charm.dynamic_register)
+        self.filename = '<console>'
+        self.resetbuffer()
+        # regexp to detect when user defines a new chare type
+        self.regexpChareDefine = re.compile('class\s*(\S+)\s*\(.*Chare.*\)\s*:')
+
+        try:
+            import readline
+            import rlcompleter
+            readline.parse_and_bind('tab: complete')
+        except:
+            pass
+
+        try:
+            sys.ps1
+        except AttributeError:
+            sys.ps1 = '>>> '
+        try:
+            sys.ps2
+        except AttributeError:
+            sys.ps2 = '... '
+        self.thisProxy.start()
+
+    def resetbuffer(self):
+        self.buffer = []
+
+    def null(self):
+        return
+
+    def write(self, data):
+        # print(data)
+        sys.stdout.write(data)
+        sys.stdout.flush()
+        # go through charm scheduler to keep things moving
+        self.thisProxy.null(ret=True).get()
+
+    @threaded
+    def start(self):
+        self.write('CharmPy interactive shell\n')
+        more = 0
+        tick = time.time()
+        while 1:
+            # self.thisProxy.null(ret=True).get()
+            # time.sleep(0.001)
+            if time.time() - tick > 0.01:
+                try:
+                    if more:
+                        prompt = sys.ps2
+                    else:
+                        prompt = sys.ps1
+                    try:
+                        line = self.raw_input(prompt)
+                        tick = time.time()
+                    except EOFError:
+                        self.write('\n')
+                        break
+                    else:
+                        more = self.push(line)
+                except KeyboardInterrupt:
+                    self.write('\nKeyboardInterrupt\n')
+                    self.resetbuffer()
+                    more = 0
+
+    def push(self, line):
+        self.buffer.append(line)
+        source = '\n'.join(self.buffer)
+        more = self.runsource(source, self.filename)
+        if not more:
+            self.resetbuffer()
+            self.thisProxy.null(ret=True).get()
+        return more
+
+    def runcode(self, code):
+        chareTypeDefined = False
+        for line in self.buffer:
+            m = self.regexpChareDefine.search(line)
+            if m is not None:
+                newChareTypeName = m.group(1)
+                source = '\n'.join(self.buffer)
+                # print("Chare type '" + newChareTypeName + "' source:\n", source)
+                charm.thisProxy.registerNewChareType(newChareTypeName, source, ret=True).get()
+                chareTypeDefined = True
+        if not chareTypeDefined:
+            InteractiveInterpreter.runcode(self, code)
+
+    def raw_input(self, prompt=''):
+        return input(prompt)

charmrun/start.py

@@ -50,6 +50,17 @@ def start(args=[]):
     if '++local' not in args and '++mpiexec' not in args and checkNodeListLocal(args):
         args.append('++local')
 
+    try:
+        idx = args.index('++interactive')
+        args[idx] = '-c'
+        if os.name == 'nt':
+            # workaround for how windows charmrun executable passes argument
+            args.insert(idx + 1, '\"from charmpy import charm ; charm.start(interactive=True)\"')
+        else:
+            args.insert(idx + 1, 'from charmpy import charm ; charm.start(interactive=True)')
+    except ValueError:
+        pass
+
     cmd = [os.path.join(os.path.dirname(__file__), 'charmrun')]
     cmd.append(sys.executable)
     cmd.extend(args)