Major restructure and cleanup of the code.

This was badly needed!

We now have simple/sane objects to handle input
and display a menu.  And, they automatically
handle / don't allow themselves to be activated
when they are already activated.

The ProxyMenu code that detects how many instances
are running can be removed.

observer.py

@@ -0,0 +1,43 @@
+from twisted.internet import reactor
+
+
+class Observer(object):
+    def __init__(self):
+        self.dispatch = {}
+
+    def emit(self, signal, message):
+        """ emit a signal, return True if sent somewhere. """
+        if signal in self.dispatch:
+            # key exists, but is there anything in the list?
+            if self.dispatch[signal]:
+                # Yes there is.
+                for listener in self.dispatch[signal]:
+                    reactor.callLater(0, listener, message)
+                return True
+            return False
+        return False
+
+    def connect(self, signal, func):
+        """ Connect a signal to a given function. """
+        if not signal in self.dispatch:
+            self.dispatch[signal] = []
+
+        self.dispatch[signal].append(func)
+
+    def disconnect(self, signal, func):
+        """ Disconnect a signal with a certain function. """
+        if signal in self.dispatch:
+            self.dispatch[signal].remove(func)
+            if len(self.dispatch[signal]) == 0:
+                self.dispatch.pop(signal)
+
+    def save(self):
+        """ Save the current dispatch, and clears it. """
+        ret = dict(self.dispatch)
+        self.dispatch = {}
+        return ret
+
+    def load(self, dispatch):
+        """ Load/restore the dispatch. """
+        assert not dispatch is None
+        self.dispatch = dict(dispatch)

tcp-proxy.py

@@ -75,73 +75,181 @@ def cleanANSI(line):
 PORT_CLASSES = { 1: 'BBS', 2: 'BSB', 3: 'SBB', 4:'SSB', 5:'SBS', 6:'BSS', 7:'SSS', 8:'BBB'}
 CLASSES_PORT = { v: k for k,v in PORT_CLASSES.items() }
 
-class Observer(object):
-    def __init__(self):
-        self.dispatch = {}
-
-    def emit(self, signal, message):
-        """ emit a signal, return True if sent somewhere. """
-        if signal in self.dispatch:
-            # something to do
-            ret = False
-            for listener in self.dispatch[signal]:
-                ret = True
-                reactor.callLater(0, listener, message)
-            return ret
-        return False
-
-    def connect(self, signal, func):
-        """ Connect a signal to a given function. """
-        if not signal in self.dispatch:
-            self.dispatch[signal] = []
-
-        self.dispatch[signal].append(func)
-
-    def disconnect(self, signal, func):
-        """ Disconnect a signal with a certain function. """
-        if signal in self.dispatch:
-            self.dispatch[signal].remove(func)
-            if len(self.dispatch[signal]) == 0:
-                self.dispatch.pop(signal)
-
-    def save(self):
-        """ Save the current dispatch. """
-        ret = dict(self.dispatch)
-        self.dispath = {}
-        return ret
-
-    def load(self, dispatch):
-        """ Load/restore the dispatch. """
-        self.dispatch = dict(dispatch)
-
-    @deprecated("Use save/load instead.")
-    def set_funcs(self, dispatch):
-        """ Replaces the dispatch. """
-        self.dispatch = dict(dispatch)
-
-    @deprecated("Use save/load instead.")
-    def get_funcs(self):
-        """ Gives a copy of the dispatch. """
-        return dict(self.dispatch)
-
-    def get_funcs_(self, signal):
-        """ Gives a copy of the dispatch for a given signal. """
-        if signal in self.dispatch:
-            return list(self.dispatch[signal])
-        else:
-            return []
+from observer import Observer
 
-    def set_funcs_(self, signal, funcs):
-        """ Replaces the dispatch for a given signal. """
-        if signal in self.dispatch:
-            if len(funcs) == 0:
-                self.dispatch.pop(signal)
-            else:
-                self.dispatch = list(funcs)
-        else:
-            if len(funcs) != 0:
-                self.dispatch = list(funcs)
+class PlayerInput(object):
+    def __init__(self, game):
+        # I think game gives us access to everything we need
+        self.game = game
+        self.observer = self.game.observer
+        self.save = None
+        self.defer = None
+        self.game_queue = game.game_queue
+
+        # default colors, and useful consts
+        self.c = merge(Style.BRIGHT + Fore.WHITE + Back.BLUE)
+        self.r = Style.RESET_ALL
+        self.nl = "\n\r"
+        self.bsb = "\b \b"
+        self.keepalive = None
+
+    def color(self, c):
+        self.c = c
+
+    def awake(self):
+        log.msg("PlayerInput.awake()")
+        self.game.queue_player.put(" ")
+
+    def prompt(self, prompt, limit, default=''):
+        log.msg("PlayerInput({0}, {1}, {2}".format(prompt, limit, default))
+        self.prompt = prompt
+        self.limit = limit
+        self.default = default
+        self.input = ''
+        assert(self.save is None)
+        assert(self.keepalive is None)
+
+        # Note: This clears out the server "keep alive"
+        self.save = self.observer.save()
+        self.observer.connect('player', self.input)
+
+        self.keepalive = task.LoopingCall(self.awake)
+        self.keepalive.start(30)
+
+        # We need to "hide" the game output.
+        # Otherwise it WITH mess up the user input display.
+        self.to_player = self.game.to_player
+        self.game.to_player = False
+
+        # Display prompt
+        self.queue_game.put(self.r + self.nl + self.c + prompt)
+        # Set "Background of prompt"
+        self.queue_game.put( " " * limit + "\b" * limit)
+
+        assert(self.defer is None)
+        d = defer.Deferred()
+        self.defer = d
+        return d
+
+    def input(self, chunk):
+        """ Data from player (in bytes) """
+        chunk = chunk.decode('utf-8', 'ignore')
+
+        for ch in chunk:
+            if ch == "\b":
+                if len(self.input) > 0:
+                    self.queue_game.put(self.bsb)
+                    self.input = self.input[0:-1]
+                else:
+                    self.queue_game.put("\a")
+            if ch == "'\r":
+                self.queue_game.put(self.r + self.nl)
+                assert(not self.save is None)
+                self.observer.load(self.save)
+                self.save = None
+                self.keepalive.stop()
+                self.keepalive = None
+                line = self.input
+                self.input = ''
+                assert(not self.defer is None)
+                reactor.callLater(0, self.defer.callback, line)
+                self.defer = None
+            if ch.isprintable():
+                if len(self.input) + 1 <= self.limit:
+                    self.input += c
+                    self.queue_game.put(ch)
+                else:
+                    self.queue_game.put("\a")
+
+    def output(self, line):
+        """ A default display of what they just input. """
+        log.msg("PlayerInput.output({0})".format(line))
+        self.game.queue_game.put(self.r + self.nl + "[{0}]".format(line) + self.nl)
+        return line
+
+class ProxyMenu(object):
+    count = 0
+
+    def __init__(self, game):
+        ProxyMenu.count += 1
+        self.nl = "\n\r"
+        self.c = merge(Style.BRIGHT + Fore.YELLOW + Back.BLUE)
+        self.r = Style.RESET_ALL
+        self.c1 = merge(Style.BRIGHT + Fore.BLUE)
+        self.c2 = merge(Style.NORMAL + Fore.BLUE)
+
+        self.game = game
+        self.queue_game = game.queue_game
+        self.observer = game.observer
+        # Yes, at this point we would activate
+        self.prompt = game.buffer
+        self.save = self.observer.save()
+        self.observer.connect("player", self.player)
+        # If we want it, it's here.
+        self.defer = None
+
+        self.keepalive = task.LoopingCall(self.awake)
+        self.keepalive.start(30)
+        self.menu()
+
+    @classmethod
+    def total(cls):
+        return cls.count
 
+    def __del__(self):
+        log.msg("ProxyMenu {0} RIP".format(self))
+        ProxyMenu.count -= 1
+
+    def whenDone(self):
+        self.defer = defer.Deferred()
+        # Call this to chain something after we exit.
+        return self.defer
+
+    def menu(self):
+        self.queue_game.put(self.nl + self.c + "TradeWars Proxy active." + self.r + self.nl)
+        self.queue_game.put(" " + self.c1 + "D" + self.c2 + " - " + self.c1 + "Diagnostics" + self.nl)        
+        self.queue_game.put(
+            " " + self.c1 + "T" + self.c2 + " - " + self.c1 + "Display current Time" + self.nl
+        )
+        self.queue_game.put(" " + self.c1 + "P" + self.c2 + " - " + self.c1 + "Port CIM Report" + self.nl)
+        self.queue_game.put(" " + self.c1 + "S" + self.c2 + " - " + self.c1 + "Scripts" + self.nl)
+        self.queue_game.put(" " + self.c1 + "X" + self.c2 + " - " + self.c1 + "eXit" + self.nl)
+        self.queue_game.put("   " + self.c + "-=>" + self.r + " ")
+
+    def awake(self):
+        log.msg("ProxyMenu.awake()")
+        self.game.queue_player.put(" ")
+
+    def player(self, chunk):
+        """ Data from player (in bytes). """
+        chunk = chunk.decode("utf-8", 'ignore')
+        key = chunk.upper()
+        log.msg("ProxyMenu.player({0})".format(key))
+
+        # Weird / long running task / something odd happening here?
+        self.keepalive.stop()
+
+        if key == "T":
+            self.queue_game.put(self.c + key + self.r + self.nl)
+            # perform T option
+            now = pendulum.now()
+            self.queue_game.put(self.nl + self.c1 + "Current time " + now.to_datetime_string() + self.nl)
+        elif key == 'X':
+            self.queue_game.put(self.c + key + self.r + self.nl)
+            self.observer.load(self.save)
+            self.save = None
+            # It isn't running (NOW), so don't try to stop it.
+            # self.keepalive.stop()
+            self.keepalive = None
+            self.queue_game.put(self.prompt)
+            self.prompt = None
+            if self.defer:
+                self.defer.callback()
+                self.defer = None
+            return
+
+        self.keepalive.start(30, True)
+        self.menu()
 
 class MCP(object):
     def __init__(self, game):
@@ -162,6 +270,12 @@ class MCP(object):
         self.observer = self.game.observer
         self.observer.connect("hotkey", self.activate)
         self.observer.connect("notyet", self.notyet)
+        self.observer.connect('close', self.close)
+
+    def close(self, _):
+        if self.keepalive:
+            if self.keepalive.running:
+                self.keepalive.stop()
 
     def notyet(self, _):
         """ No, not yet! """
@@ -170,7 +284,7 @@ class MCP(object):
 
         log.msg("NNY!")
         prompt = self.game.buffer
-        self.queue_game.put(r + nl + "Proxy: I can't activate at this time." + nl)
+        self.queue_game.put(r + nl + Style.BRIGHT + "Proxy:" + Style.RESET_ALL + " I can't activate at this time." + nl)
         self.queue_game.put(prompt)
 
     def stayAwake(self):
@@ -179,6 +293,29 @@ class MCP(object):
         self.game.queue_player.put(" ")
 
     def startAwake(self):
+        """ Start the task that keeps the game server alive.
+
+        There is currently a bug in there somewhere, which causes it to
+        duplicate:
+
+        2019-11-25 21:19:03-0500 [-] Gameserver, stay awake.
+        2019-11-25 21:19:14-0500 [-] Gameserver, stay awake.
+        2019-11-25 21:19:24-0500 [-] Gameserver, stay awake.
+        2019-11-25 21:19:27-0500 [-] Gameserver, stay awake.
+        2019-11-25 21:19:31-0500 [-] Gameserver, stay awake.
+        2019-11-25 21:19:33-0500 [-] Gameserver, stay awake.
+        2019-11-25 21:19:44-0500 [-] Gameserver, stay awake.
+        2019-11-25 21:19:54-0500 [-] Gameserver, stay awake.
+        2019-11-25 21:19:57-0500 [-] Gameserver, stay awake.
+        2019-11-25 21:20:01-0500 [-] Gameserver, stay awake.
+        2019-11-25 21:20:03-0500 [-] Gameserver, stay awake.
+
+        ^ These aren't 30 seconds apart.
+
+        These are being sent, even when the MCP is not active!
+
+
+        """
         self.keepalive = task.LoopingCall(self.stayAwake)
         self.keepalive.start(30)
 
@@ -470,9 +607,10 @@ class MCP(object):
         self.player_input = d
         self.input_limit = limit
         self.input_input = ''
-        self.save = self.observer.get_funcs()
-        input_funcs = { 'player': [self.niceInput] }
-        self.observer.set_funcs(input_funcs)     
+        self.save = self.observer.save()
+        self.observer.connect('player', self.niceInput)
+        # input_funcs = { 'player': [self.niceInput] }
+        # self.observer.set_funcs(input_funcs)     
         return d
 
     def niceInput(self, chunk):
@@ -494,7 +632,7 @@ class MCP(object):
             if c == "\r":
                 # Ok, completed!
                 self.queue_game.put(r + "\n\r")
-                self.observer.set_funcs(self.save)
+                self.observer.load(self.save)
                 self.save = None
                 line = self.input_input
                 log.msg("finishing niceInput {0}".format(line))
@@ -632,6 +770,7 @@ class Game(protocol.Protocol):
 
     def connectionLost(self, why):
         log.msg("Game connectionLost because: %s" % why)
+        self.observer.emit('close', why)
         self.queue_game.put(False)
         self.transport.loseConnection()
 
@@ -737,21 +876,19 @@ class Player(protocol.Protocol):
         if not self.observer.emit("player", chunk):
             # Was not dispatched.  Send to game.
             self.queue_player.put(chunk)
+        
+        else:
+            # If there's an observer -- should I continue here?
+            log.msg("I'm being watched...")
+            # TIAS.
+            return
 
         if chunk == b"~":
             if self.game:
                 prompt = self.game.getPrompt()
-                if "Selection (? for menu)" in prompt:
-                    self.observer.emit("notyet", prompt)
-                elif "Enter your choice:" in prompt:
-                    self.observer.emit("notyet", prompt)
-                elif re.match(r"Computer command \[TL=.* \(\?=Help\)\? :", prompt):
-                    self.observer.emit("notyet", prompt)
-                elif re.match(r"Command \[TL=.* \(\?=Help\)\? :", prompt):
+                if re.match(r"Command \[TL=.* \(\?=Help\)\? :", prompt):
                     self.observer.emit("hotkey", prompt)
                 else:
-                    log.msg("Unsure about [{0}] prompt.".format(prompt))
-                    # but try anyway!  :P
                     self.observer.emit("notyet", prompt)
 
             # Selection (? for menu):   (the game server menu)
@@ -759,8 +896,22 @@ class Player(protocol.Protocol):
             # Command [TL=00:00:00]:[1800] (?=Help)? :  <- YES!
             # Computer command [TL=00:00:00]:[613] (?=Help)?
 
+        if chunk == b"|":
+            # how can I tell if this is active or not?
+            log.msg(pformat(self.observer.dispatch))
+
+            if ProxyMenu.total() == 0:
+                # prompt = self.game.getPrompt()
+                # if re.match(r"Command \[TL=.* \(\?=Help\)\? :", prompt):
+                menu = ProxyMenu(self.game)
+            else:
+                log.msg("The menu is already active!")
+
+
+
     def connectionLost(self, why):
         log.msg("lost connection %s" % why)
+        self.observer.emit('close', why)        
         self.queue_player.put(False)
 
     def connectionFailed(self, why):