Ticket #137: 137.diff

foolscap/pb.py

@@ -26 +26 @@
 
 
 Listeners = []
-class Listener(protocol.ServerFactory):
+class Listener(protocol.ServerFactory, service.MultiService):
     """I am responsible for a single listening port, which may connect to
     multiple Tubs. I have a strports-based Service, which I will attach as a
     child of one of my Tubs. If that Tub disconnects, I will reparent the
@@ -39 +39 @@
 
     # this also serves as the ServerFactory
 
-    def __init__(self, port, options={},
+    def __init__(self, port=None, portFile=None, options={},
                  negotiationClass=negotiate.Negotiation):
         """
         @type port: string
         @param port: a L{twisted.application.strports} -style description.
         """
-        name, args, kw = strports.parse(port, None)
-        assert name in ("TCP", "UNIX") # TODO: IPv6
+        service.MultiService.__init__(self)
+        assert port or portFile
+        self.portFile = portFile
+        if not port:
+            # get it from the portfile (on second and later runs)
+            try:
+                port = open(self.portFile, "rb").read().strip()
+            except EnvironmentError:
+                # must be the first run. We'll use "0".
+                pass
+        if port:
+            name, args, kw = strports.parse(port, None)
+            assert name in ("TCP", "UNIX") # TODO: IPv6
         self.port = port
         self.options = options
         self.negotiationClass = negotiationClass
         self.parentTub = None
         self.tubs = {}
         self.redirects = {}
-        self.s = strports.service(port, self)
         Listeners.append(self)
 
     def getPortnum(self):
@@ -69 +79 @@
         """
 
         assert self.s.running
-        name, args, kw = strports.parse(self.port, None)
-        assert name in ("TCP",)
         return self.s._port.getHost().port
 
     def __repr__(self):
@@ -82 +90 @@
         return "<Listener at 0x%x on %s with no tubs>" % (abs(id(self)),
                                                           self.port)
 
+    def startService(self):
+        port = self.port
+        need_to_write_portfile = False
+        if not port:
+            # the portFile was empty
+            need_to_write_portfile = True
+            port = "0"
+        self.s = strports.service(port, self)
+        self.s.setServiceParent(self)
+        service.MultiService.startService(self)
+        # now the new port should be listening, so we can grab its portnum
+        if self.portFile:
+            open(self.portFile, "wb").write("%d\n" % self.getPortnum())
+
     def addTub(self, tub):
         if tub.tubID in self.tubs:
             if tub.tubID is None:
@@ -93 +115 @@
         self.tubs[tub.tubID] = tub
         if self.parentTub is None:
             self.parentTub = tub
-            self.s.setServiceParent(self.parentTub)
+            self.setServiceParent(self.parentTub)
 
     def removeTub(self, tub):
         # this might return a Deferred, since the removal might cause the
@@ -108 +130 @@
                 # disownServiceParent, so the port remains listening. Can we
                 # do this? It looks like setServiceParent does
                 # disownServiceParent first, so it may glitch.
-                self.s.setServiceParent(self.parentTub)
+                self.setServiceParent(self.parentTub)
             else:
                 # no more tubs, this Listener will go away now
-                d = self.s.disownServiceParent()
+                d = self.disownServiceParent()
                 Listeners.remove(self)
                 return d
         return None
 
-    def getService(self):
-        return self.s
-
     def addRedirect(self, tubID, location):
         assert tubID is not None # unauthenticated Tubs don't get redirects
         self.redirects[tubID] = location
@@ -529 +548 @@
         d.addCallback(_got_local_ip)
         return d
 
-    def listenOn(self, what, options={}):
+    def listenOn(self, what=None, portFile=None, options={}):
         """Start listening for connections.
 
-        @type  what: string or Listener instance
+        @type  what: string or Listener instance, or None to use portFile=
         @param what: a L{twisted.application.strports} -style description,
                      or a L{Listener} instance returned by a previous call to
                      listenOn.
+        @param portFile: a string, or None to use what=. If provided, the
+                         Listener will use this file to store the port on
+                         which it listens. If the file does not exist when
+                         the Listener is started, it will pick an arbitrary
+                         free port (on all interfaces) to use, and will store
+                         it in the file. If this file does exist, it will
+                         read the port number from this file.
         @param options: a dictionary of options that can influence connection
                         negotiation before the target Tub has been determined
 
+        You must provide either what= or portFile=, not both.
+
         @return: The Listener object that was created. This can be used to
         stop listening later on, to have another Tub listen on the same port,
         and to figure out which port was allocated when you used a strports
         specification of 'tcp:0'. """
 
-        if type(what) is str:
-            l = Listener(what, options, self.negotiationClass)
-        else:
+        assert what or portFile
+        if isinstance(what, Listener):
             assert not options
             l = what
+        else:
+            l = Listener(what, portFile, options, self.negotiationClass)
         assert l not in self.listeners
         l.addTub(self)
         self.listeners.append(l)

foolscap/test/test_tub.py

@@ -117 +117 @@
         d.addCallback(_check)
         return d
 
+class PortFile(unittest.TestCase):
+
+    def setUp(self):
+        self.s = service.MultiService()
+        self.s.startService()
+
+    def tearDown(self):
+        d = self.s.stopService()
+        d.addCallback(flushEventualQueue)
+        return d
+
+    def test_portfile(self):
+        basedir = "tub/PortFile/portfile"
+        os.makedirs(basedir)
+        fn = os.path.join(basedir, "port")
+        t = GoodEnoughTub()
+        l = t.listenOn(portFile=fn)
+        self.failIf(os.path.exists(fn))
+        t.setServiceParent(self.s)
+        self.failUnless(os.path.exists(fn))
+        p = int(open(fn, "rb").read().strip())
+        self.failUnlessEqual(p, l.getPortnum())
+        d = t.disownServiceParent()
+
+        def _next(ign):
+            t2 = GoodEnoughTub()
+            l2 = t2.listenOn(portFile=fn)
+            t2.setServiceParent(self.s)
+            self.failUnlessEqual(p, l2.getPortnum())
+            t2.disownServiceParent()
+        d.addCallback(_next)
+        return d
 
 
 class FurlFile(unittest.TestCase):