cmd_send: turn into a self-contained class

This will make it easier to maintain state.

src/wormhole/cli/cmd_send.py

@@ -11,7 +11,6 @@ from ..transit import TransitSender
 
 APPID = u"lothar.com/wormhole/text-or-file-xfer"
 
-@inlineCallbacks
 def send(args, reactor=reactor):
     """I implement 'wormhole send'. I return a Deferred that fires with None
     (for success), or signals one of the following errors:
@@ -21,30 +20,43 @@ def send(args, reactor=reactor):
                      permission not granted, ack not successful.
     * any other error: something unexpected happened
     """
-    assert isinstance(args.relay_url, type(u""))
+    return Sender(args, reactor).go()
 
-    tor_manager = None
+class Sender:
-    if args.tor:
+    def __init__(self, args, reactor):
-        with args.timing.add("import", which="tor_manager"):
+        self._args = args
+        self._reactor = reactor
+        self._tor_manager = None
+        self._timing = args.timing
+        self._fd_to_send = None
+        self._transit_sender = None
+
+    @inlineCallbacks
+    def go(self):
+        assert isinstance(self._args.relay_url, type(u""))
+        if self._args.tor:
+            with self._timing.add("import", which="tor_manager"):
                 from ..tor_manager import TorManager
-        tor_manager = TorManager(reactor, timing=args.timing)
+            self._tor_manager = TorManager(reactor, timing=self._timing)
-        # For now, block everything until Tor has started. Soon: launch tor
+            # For now, block everything until Tor has started. Soon: launch
-        # in parallel with everything else, make sure the TorManager can
+            # tor in parallel with everything else, make sure the TorManager
-        # lazy-provide an endpoint, and overlap the startup process with the
+            # can lazy-provide an endpoint, and overlap the startup process
-        # user handing off the wormhole code
+            # with the user handing off the wormhole code
-        yield tor_manager.start()
+            yield self._tor_manager.start()
 
-    w = wormhole(APPID, args.relay_url, reactor, tor_manager,
+        w = wormhole(APPID, self._args.relay_url,
-                 timing=args.timing)
+                     self._reactor, self._tor_manager,
-    d = _send(reactor, w, args, tor_manager)
+                     timing=self._timing)
+        d = self._go(w)
         d.addBoth(w.close)
         yield d
 
     @inlineCallbacks
-def _send(reactor, w, args, tor_manager):
+    def _go(self, w):
         # TODO: run the blocking zip-the-directory IO in a thread, let the
         # wormhole exchange happen in parallel
-    offer, fd_to_send = build_offer(args)
+        offer, self._fd_to_send = self._build_offer()
+        args = self._args
 
         other_cmd = "wormhole receive"
         if args.verify:
@@ -81,22 +93,22 @@ def _send(reactor, w, args, tor_manager):
                     w.send(reject_data)
                     raise TransferError(err)
 
-    transit_sender = None
+        if self._fd_to_send:
-    if fd_to_send:
+            ts = TransitSender(args.transit_helper,
-        transit_sender = TransitSender(args.transit_helper,
                                no_listen=args.no_listen,
-                                       tor_manager=tor_manager,
+                               tor_manager=self._tor_manager,
-                                       reactor=reactor,
+                               reactor=self._reactor,
-                                       timing=args.timing)
+                               timing=self._timing)
+            self._transit_sender = ts
             offer["transit"] = transit_data = {}
-        transit_data["relay_connection_hints"] = transit_sender.get_relay_hints()
+            transit_data["relay_connection_hints"] = ts.get_relay_hints()
-        direct_hints = yield transit_sender.get_direct_hints()
+            direct_hints = yield ts.get_direct_hints()
             transit_data["direct_connection_hints"] = direct_hints
 
             # TODO: move this down below w.get()
             transit_key = w.derive_key(APPID+"/transit-key",
-                                   transit_sender.TRANSIT_KEY_LENGTH)
+                                       ts.TRANSIT_KEY_LENGTH)
-        transit_sender.set_transit_key(transit_key)
+            ts.set_transit_key(transit_key)
 
         my_offer_bytes = json.dumps({"offer": offer}).encode("utf-8")
         w.send(my_offer_bytes)
@@ -117,14 +129,15 @@ def _send(reactor, w, args, tor_manager):
                 if not want_answer:
                     raise TransferError("duplicate answer")
                 them_answer = them_d[u"answer"]
-            yield handle_answer(them_answer, args, fd_to_send, transit_sender)
+                yield self._handle_answer(them_answer)
                 done = True
                 returnValue(None)
             log.msg("unrecognized message %r" % (them_d,))
 
-def build_offer(args):
+    def _build_offer(self):
         offer = {}
 
+        args = self._args
         text = args.text
         if text == "-":
             print(u"Reading text message from stdin..", file=args.stdout)
@@ -133,7 +146,8 @@ def build_offer(args):
             text = six.moves.input("Text to send: ")
 
         if text is not None:
-        print(u"Sending text message (%d bytes)" % len(text), file=args.stdout)
+            print(u"Sending text message (%d bytes)" % len(text),
+                  file=args.stdout)
             offer = { "message": text }
             fd_to_send = None
             return offer, fd_to_send
@@ -195,10 +209,10 @@ def build_offer(args):
         raise TypeError("'%s' is neither file nor directory" % args.what)
 
     @inlineCallbacks
-def handle_answer(them_answer, args, fd_to_send, transit_sender):
+    def _handle_answer(self, them_answer):
-    if fd_to_send is None:
+        if self._fd_to_send is None:
             if them_answer["message_ack"] == "ok":
-            print(u"text message sent", file=args.stdout)
+                print(u"text message sent", file=self._args.stdout)
                 returnValue(None) # terminates this function
             raise TransferError("error sending text: %r" % (them_answer,))
 
@@ -210,27 +224,26 @@ def handle_answer(them_answer, args, fd_to_send, transit_sender):
                                 "transfer abandoned: %s" % (them_answer,))
 
         tdata = them_answer["transit"]
-    yield _send_file_twisted(tdata, transit_sender, fd_to_send,
+        yield self._send_file_twisted(tdata)
-                             args.stdout, args.hide_progress,
-                             args.timing)
 
 
     @inlineCallbacks
-def _send_file_twisted(tdata, transit_sender, fd_to_send,
+    def _send_file_twisted(self, tdata):
-                       stdout, hide_progress, timing):
+        ts = self._transit_sender
-    transit_sender.add_their_direct_hints(tdata["direct_connection_hints"])
+        ts.add_their_direct_hints(tdata["direct_connection_hints"])
-    transit_sender.add_their_relay_hints(tdata["relay_connection_hints"])
+        ts.add_their_relay_hints(tdata["relay_connection_hints"])
 
-    fd_to_send.seek(0,2)
+        self._fd_to_send.seek(0,2)
-    filesize = fd_to_send.tell()
+        filesize = self._fd_to_send.tell()
-    fd_to_send.seek(0,0)
+        self._fd_to_send.seek(0,0)
 
-    record_pipe = yield transit_sender.connect()
+        record_pipe = yield ts.connect()
-    timing.add("transit connected")
+        self._timing.add("transit connected")
         # record_pipe should implement IConsumer, chunks are just records
+        stdout = self._args.stdout
         print(u"Sending (%s).." % record_pipe.describe(), file=stdout)
 
-    progress = tqdm(file=stdout, disable=hide_progress,
+        progress = tqdm(file=stdout, disable=self._args.hide_progress,
                         unit="B", unit_scale=True,
                         total=filesize)
         def _count(data):
@@ -238,13 +251,13 @@ def _send_file_twisted(tdata, transit_sender, fd_to_send,
             return data
         fs = basic.FileSender()
 
-    with timing.add("tx file"):
+        with self._timing.add("tx file"):
             with progress:
-            yield fs.beginFileTransfer(fd_to_send, record_pipe,
+                yield fs.beginFileTransfer(self._fd_to_send, record_pipe,
                                            transform=_count)
 
         print(u"File sent.. waiting for confirmation", file=stdout)
-    with timing.add("get ack") as t:
+        with self._timing.add("get ack") as t:
             ack = yield record_pipe.receive_record()
             record_pipe.close()
             if ack != b"ok\n":

src/wormhole/test/test_scripts.py

@@ -7,10 +7,13 @@ from twisted.internet.defer import gatherResults, inlineCallbacks
 from .. import __version__
 from .common import ServerBase
 from ..cli import runner, cmd_send, cmd_receive
-from ..cli.cmd_send import build_offer
 from ..errors import TransferError, WrongPasswordError
 from ..timing import DebugTiming
 
+def build_offer(args):
+    s = cmd_send.Sender(args, None)
+    return s._build_offer()
+
 class OfferData(unittest.TestCase):
     def setUp(self):
         self._things_to_delete = []