Refactor client, add potential map widget.

diff --git a/client.py b/client.py
index 3e50b2ec43dfd7ef6427ca864e05b174fface59d..9092fe644bcd9618bb6b97e3e9f380a54dff972e 100755 (executable)
--- a/client.py
+++ b/client.py
@@ -6,88 +6,130 @@ import socket
 import threading
 
 
 import threading
 
 

-def recv_loop(socket, urwid_pipe_write_fd, server_output):
-    """Loop to receive messages from socket and deliver them to urwid.
-
-    The message transfer to urwid is a bit weird. The urwid developers warn
-    against sharing urwid resources among threads, and recommend using urwid's
-    watch_pipe mechanism: using a pipe from non-urwid threads into a single
-    urwid thread. We could pipe socket.recv output directly, but then we get
-    complicated buffering situations here as well as in the urwid code that
-    receives the pipe content. It's much easier to update a third resource
-    (server_output, which references an object that's also known to the urwid
-    code) to contain the new message, and then just use the urwid pipe
-    (urwid_pipe_write_fd) to trigger the urwid code to pull the message in from
-    that third resource. We send a single b' ' through the pipe to trigger it.
-    """
-    import os
-    for msg in plom_socket_io.recv(socket):
-        server_output[0] = msg
-        os.write(urwid_pipe_write_fd, b' ')
-
-
-class InputHandler:
-    """Helps delivering data from other thread to widget via message_container.
-
-    The whole class only exists to provide handle_input as a bound method, with
-    widget and message_container pre-set, as (bound) handle_input is used as a
-    callback in urwid's watch_pipe – which merely provides its callback target
-    with one parameter for a pipe to read data from an urwid-external thread.
-    """
-
-    def __init__(self, widget, message_container):
-        self.widget = widget
-        self.message_container = message_container
-
-    def handle_input(self, trigger):
-        """On input from other thread, either quit, or write to widget text.
-
-        Serves as a receiver to urwid's watch_pipe mechanism, with trigger the
-        data that a pipe defined by watch_pipe delivers. To avoid buffering
-        trouble, we don't care for that data beyond the fact that its receival
-        triggers this function: The sender is to write the data it wants to
-        deliver into the container referenced by self.message_container, and
-        just pipe the trigger to inform us about this.
-
-        If the message delivered is 'BYE', quits Urbit.
+class UrwidSetup():
+
+    def __init__(self, socket):
+        """Build client urwid interface around socket communication.
+
+        Sets up all widgets for writing to the socket and representing data
+        from it. Sending via a self.EditToSocket widget is straightforward;
+        polling the socket for input from the server in parallel to the urwid
+        main loop not so much:
+
+        The urwid developers warn against sharing urwid resources among
+        threads, so having a socket polling thread for writing to an urwid
+        widget while other widgets are handled in other threads would be
+        dangerous. Urwid developers recommend using urwid's watch_pipe
+        mechanism instead: using a pipe from non-urwid threads into a single
+        urwid thread. We use self.recv_loop_thread to poll the socket, therein
+        write socket.recv output to an object that is then linked to by
+        self.server_output (which is known the urwid thread), and then use the
+        pipe to urwid to trigger it pulling new data from self.server_output to
+        handle via self.InputHandler. (We *could* pipe socket.recv output
+        directly, but then we get complicated buffering situations here as well
+        as in the urwid code that receives the pipe output. It's much easier to
+        just tell the urwid code where it finds a full new server message to
+        handle.)

         """
         """

-        if self.message_container[0] == 'BYE':
-            raise urwid.ExitMainLoop()
-            return
-        self.widget.set_text('SERVER: ' + self.message_container[0])
-
-
-class SocketInputWidget(urwid.Filler):
-
-    def __init__(self, socket, *args, **kwargs):
-        super().__init__(*args, **kwargs)

         self.socket = socket
         self.socket = socket

+        self.main_loop = urwid.MainLoop(self.setup_widgets())
+        self.server_output = ['']
+        input_handler = getattr(self.InputHandler(self.reply_widget,
+                                                  self.map_widget,
+                                                  self.server_output),
+                                'handle_input')
+        self.urwid_pipe_write_fd = self.main_loop.watch_pipe(input_handler)
+        self.recv_loop_thread = threading.Thread(target=self.recv_loop)
+
+    def setup_widgets(self):
+        """Return container widget with all widgets we want on our screen.
+
+        Sets up an urwid.Pile inside a returned urwid.Filler; top to bottom:
+        - an EditToSocket widget, prefixing self.socket input with 'SEND: '
+        - self.reply_widget, a urwid.Text widget printing self.socket replies
+        - a 50-col wide urwid.Padding container for self.map_widget, which is
+          to print clipped map representations
+        """
+        edit_widget = self.EditToSocket(self.socket, 'SEND: ')
+        self.reply_widget = urwid.Text('')
+        self.map_widget = urwid.Text('', wrap='clip')
+        map_box = urwid.Padding(self.map_widget, width=50)
+        widget_pile = urwid.Pile([edit_widget, self.reply_widget, map_box])
+        return urwid.Filler(widget_pile)
+
+    class EditToSocket(urwid.Edit):
+        """Extends urwid.Edit with socket to send input on 'enter' to."""
+
+        def __init__(self, socket, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            self.socket = socket
+
+        def keypress(self, size, key):
+            """Extend super(): on Enter, send .edit_text, and empty it."""
+            if key != 'enter':
+                return super().keypress(size, key)
+            plom_socket_io.send(self.socket, self.edit_text)
+            self.edit_text = ''
+
+    class InputHandler:
+        """Delivers data from other thread to widget via message_container.
+
+        The class only exists to provide handle_input as a bound method, with
+        widget and message_container pre-set, as (bound) handle_input is used
+        as a callback in urwid's watch_pipe – which merely provides its
+        callback target with one parameter for a pipe to read data from an
+        urwid-external thread.
+        """

 
 

-    def keypress(self, size, key):
-        """Act like super(), except on Enter: send .edit_text, and empty it."""
-        if key != 'enter':
-            return super().keypress(size, key)
-        plom_socket_io.send(self.socket, edit.edit_text)
-        edit.edit_text = ''
-
-
-s = socket.create_connection(('127.0.0.1', 5000))
-
-edit = urwid.Edit('SEND: ')
-txt = urwid.Text('')
-pile = urwid.Pile([edit, txt])
-fill = SocketInputWidget(s, pile)
-loop = urwid.MainLoop(fill)
+        def __init__(self, widget1, widget2, message_container):
+            self.widget1 = widget1
+            self.widget2 = widget2
+            self.message_container = message_container
+
+        def handle_input(self, trigger):
+            """On input from other thread, either quit or write to widget text.
+
+            Serves as a receiver to urwid's watch_pipe mechanism, with trigger
+            the data that a pipe defined by watch_pipe delivers. To avoid
+            buffering trouble, we don't care for that data beyond the fact that
+            its receival triggers this function: The sender is to write the
+            data it wants to deliver into the container referenced by
+            self.message_container, and just pipe the trigger to inform us
+            about this.
+
+            If the message delivered is 'BYE', quits Urbit.
+            """
+            if self.message_container[0] == 'BYE':
+                raise urwid.ExitMainLoop()
+                return
+            self.widget1.set_text('SERVER: ' + self.message_container[0])
+            self.widget2.set_text('loremipsumdolorsitamet '
+                                  'loremipsumdolorsitamet'
+                                  'loremipsumdolorsitamet '
+                                  'loremipsumdolorsitamet\n'
+                                  'loremipsumdolorsitamet '
+                                  'loremipsumdolorsitamet')
+
+    def recv_loop(self):
+        """Loop to receive messages from socket and deliver them to urwid.
+
+        Writes finished messages from the socket to self.server_output[0],
+        then sends a single b' ' through self.urwid_pipe_write_fd to trigger
+        the urwid code to read from it.
+        """
+        import os
+        for msg in plom_socket_io.recv(self.socket):
+            self.server_output[0] = msg
+            os.write(self.urwid_pipe_write_fd, b' ')

 
 

-server_output = ['']
-write_fd = loop.watch_pipe(getattr(InputHandler(txt, server_output),
-                                   'handle_input'))
-thread = threading.Thread(target=recv_loop,
-                          kwargs={'socket': s, 'server_output': server_output,
-                                  'urwid_pipe_write_fd': write_fd})
-thread.start()
+    def run(self):
+        """Run in parallel main and recv_loop thread."""
+        self.recv_loop_thread.start()
+        self.main_loop.run()
+        self.recv_loop_thread.join()

 
 

-loop.run()

 
 

-thread.join()
+s = socket.create_connection(('127.0.0.1', 5000))
+u = UrwidSetup(s)
+u.run()

 s.close()
 s.close()

diff --git a/server.py b/server.py
index 82a10a65fa003b801403d747c278252c0d127539..6e3564b8cf59563fb15b30862e8a91f07dbdbfbb 100755 (executable)
--- a/server.py
+++ b/server.py
@@ -1,9 +1,7 @@
 #!/usr/bin/env python3
 
 import socketserver
 #!/usr/bin/env python3
 
 import socketserver

-import plom_socket_io

 import threading
 import threading

-import time

 import queue
 
 # Avoid "Address already in use" errors.
 import queue
 
 # Avoid "Address already in use" errors.


@@ -48,6 +46,8 @@ class IO_Handler(socketserver.BaseRequestHandler):
         to send replies back to), and optionally a third element for further
         instructions.
         """
         to send replies back to), and optionally a third element for further
         instructions.
         """

+        import plom_socket_io
+

         def caught_send(socket, message):
             """Send message by socket, catch broken socket connection error."""
             try:
         def caught_send(socket, message):
             """Send message by socket, catch broken socket connection error."""
             try: