node.py: refactor config-file getting and setting

src/allmydata/client.py

@@ -24,13 +24,7 @@ class Client(node.Node, Referenceable):
     PORTNUMFILE = "client.port"
     STOREDIR = 'storage'
     NODETYPE = "client"
-    WEBPORTFILE = "webport"
-    WEB_ALLOW_LOCAL_ACCESS_FILE = "webport_allow_localfile"
-    INTRODUCER_FURL_FILE = "introducer.furl"
-    MY_FURL_FILE = "myself.furl"
     SUICIDE_PREVENTION_HOTLINE_FILE = "suicide_prevention_hotline"
-    SIZELIMIT_FILE = "sizelimit"
-    PUSH_TO_OURSELVES_FILE = "push_to_ourselves"
 
     # we're pretty narrow-minded right now
     OLDEST_SUPPORTED_VERSION = allmydata.__version__
@@ -45,17 +39,11 @@ class Client(node.Node, Referenceable):
         self.add_service(Uploader())
         self.add_service(Downloader())
         self.add_service(VirtualDrive())
-        try:
+        webport = self.get_config("webport")
-            webport = open(os.path.join(self.basedir, self.WEBPORTFILE),
+        if webport:
-                           "r").read().strip() # strports string
+            self.init_web(webport) # strports string
-        except EnvironmentError:
-            pass # absent or unreadable webport file
-        else:
-            self.init_web(webport)
 
-        INTRODUCER_FURL_FILE = os.path.join(self.basedir,
+        self.introducer_furl = self.get_config("introducer.furl", required=True)
-                                            self.INTRODUCER_FURL_FILE)
-        self.introducer_furl = open(INTRODUCER_FURL_FILE, "r").read().strip()
 
         hotline_file = os.path.join(self.basedir,
                                     self.SUICIDE_PREVENTION_HOTLINE_FILE)
@@ -68,12 +56,8 @@ class Client(node.Node, Referenceable):
         storedir = os.path.join(self.basedir, self.STOREDIR)
         sizelimit = None
 
-        try:
+        data = self.get_config("sizelimit")
-            data = open(os.path.join(self.basedir, self.SIZELIMIT_FILE),
+        if data:
-                        "r").read().strip()
-        except EnvironmentError:
-            pass # absent or unreadable sizelimit file
-        else:
             m = re.match(r"^(\d+)([kKmMgG]?[bB]?)$", data)
             if not m:
                 log.msg("SIZELIMIT_FILE contains unparseable value %s" % data)
@@ -88,21 +72,19 @@ class Client(node.Node, Referenceable):
                               "G": 1000 * 1000 * 1000,
                               }[suffix]
                 sizelimit = int(number) * multiplier
-        NOSTORAGE_FILE = os.path.join(self.basedir, "debug_no_storage")
+        no_storage = self.get_config("debug_no_storage") is not None
-        no_storage = os.path.exists(NOSTORAGE_FILE)
         self.add_service(StorageServer(storedir, sizelimit, no_storage))
 
     def init_options(self):
         self.push_to_ourselves = None
-        filename = os.path.join(self.basedir, self.PUSH_TO_OURSELVES_FILE)
+        if self.get_config("push_to_ourselves") is not None:
-        if os.path.exists(filename):
             self.push_to_ourselves = True
 
     def init_web(self, webport):
         # this must be called after the VirtualDrive is attached
         ws = WebishServer(webport)
-        ws.allow_local_access(os.path.exists(os.path.join(self.basedir,
+        if self.get_config("webport_allow_localfile") is not None:
-                              self.WEB_ALLOW_LOCAL_ACCESS_FILE)))
+            ws.allow_local_access(True)
         self.add_service(ws)
         vd = self.getServiceNamed("vdrive")
         startfile = os.path.join(self.basedir, "start.html")
@@ -122,18 +104,13 @@ class Client(node.Node, Referenceable):
         self.log("tub_ready")
 
         my_old_name = None
-        try:
+        my_old_furl = self.get_config("myself.furl")
-            my_old_furl = open(os.path.join(self.basedir, self.MY_FURL_FILE),
+        if my_old_furl is not None:
-                               "r").read().strip()
-        except EnvironmentError:
-            pass # absent or unreadable myfurl file
-        else:
             sturdy = SturdyRef(my_old_furl)
             my_old_name = sturdy.name
 
         self.my_furl = self.tub.registerReference(self, my_old_name)
-        open(os.path.join(self.basedir, self.MY_FURL_FILE),
+        self.write_config("myself.furl", self.my_furl + "\n")
-             "w").write(self.my_furl + "\n")
 
         ic = IntroducerClient(self.tub, self.introducer_furl, self.my_furl)
         self.introducer_client = ic

src/allmydata/introducer_and_vdrive.py

@@ -22,9 +22,7 @@ class IntroducerAndVdrive(node.Node):
         r = self.add_service(i)
         self.urls["introducer"] = self.tub.registerReference(r, "introducer")
         self.log(" introducer is at %s" % self.urls["introducer"])
-        f = open(os.path.join(self.basedir, "introducer.furl"), "w")
+        self.write_config("introducer.furl", self.urls["introducer"] + "\n")
-        f.write(self.urls["introducer"] + "\n")
-        f.close()
 
         vdrive_dir = os.path.join(self.basedir, self.VDRIVEDIR)
         vds = self.add_service(VirtualDriveServer(vdrive_dir))
@@ -32,20 +30,15 @@ class IntroducerAndVdrive(node.Node):
         vds.set_furl(vds_furl)
         self.urls["vdrive"] = vds_furl
         self.log(" vdrive is at %s" % self.urls["vdrive"])
-        f = open(os.path.join(self.basedir, "vdrive.furl"), "w")
+        self.write_config("vdrive.furl", self.urls["vdrive"] + "\n")
-        f.write(self.urls["vdrive"] + "\n")
-        f.close()
 
         encoding_parameters = self.read_encoding_parameters()
         i.set_encoding_parameters(encoding_parameters)
 
     def read_encoding_parameters(self):
         k, desired, n = self.DEFAULT_K, self.DEFAULT_DESIRED, self.DEFAULT_N
-        PARAM_FILE = os.path.join(self.basedir, self.ENCODING_PARAMETERS_FILE)
+        data = self.get_config("encoding_parameters")
-        if os.path.exists(PARAM_FILE):
+        if data is not None:
-            f = open(PARAM_FILE, "r")
-            data = f.read().strip()
-            f.close()
             k,desired,n = data.split()
             k = int(k); desired = int(desired); n = int(n)
         return k, desired, n

src/allmydata/node.py

@@ -25,7 +25,6 @@ class Node(service.MultiService):
     PORTNUMFILE = None
     CERTFILE = "node.pem"
     LOCAL_IP_FILE = "advertised_ip_addresses"
-    NODEIDFILE = "my_nodeid"
 
     def __init__(self, basedir="."):
         service.MultiService.__init__(self)
@@ -36,9 +35,7 @@ class Node(service.MultiService):
         self.tub.setOption("logLocalFailures", True)
         self.tub.setOption("logRemoteFailures", True)
         self.nodeid = b32decode(self.tub.tubID.upper()) # binary format
-        f = open(os.path.join(self.basedir, self.NODEIDFILE), "w")
+        self.write_config("my_nodeid", b32encode(self.nodeid).lower() + "\n")
-        f.write(b32encode(self.nodeid).lower() + "\n")
-        f.close()
         self.short_nodeid = b32encode(self.nodeid).lower()[:8] # ready for printing
         assert self.PORTNUMFILE, "Your node.Node subclass must provide PORTNUMFILE"
         self._portnumfile = os.path.join(self.basedir, self.PORTNUMFILE)
@@ -68,6 +65,44 @@ class Node(service.MultiService):
                  % (allmydata.__version__, foolscap.__version__,
                     twisted.__version__, zfec.__version__,))
 
+    def get_config(self, name, mode="r", required=False):
+        """Get the (string) contents of a config file, or None if the file
+        did not exist. If required=True, raise an exception rather than
+        returning None. Any leading or trailing whitespace will be stripped
+        from the data."""
+        fn = os.path.join(self.basedir, name)
+        try:
+            return open(fn, mode).read().strip()
+        except EnvironmentError:
+            if not required:
+                return None
+            raise
+
+    def get_or_create_config(self, name, default, mode="w"):
+        """Try to get the (string) contents of a config file. If the file
+        does not exist, create it with the given default value, and return
+        the default value. Any leading or trailing whitespace will be
+        stripped from the data."""
+        value = self.get_config(name)
+        if value is None:
+            value = default
+            fn = os.path.join(self.basedir, name)
+            try:
+                open(fn, mode).write(value)
+            except EnvironmentError, e:
+                self.log("Unable to write config file '%s'" % fn)
+                self.log(e)
+        return value
+
+    def write_config(self, name, value, mode="w"):
+        """Write a string to a config file."""
+        fn = os.path.join(self.basedir, name)
+        try:
+            open(fn, mode).write(value)
+        except EnvironmentError, e:
+            self.log("Unable to write config file '%s'" % fn)
+            self.log(e)
+
     def get_versions(self):
         return {'allmydata': allmydata.__version__,
                 'foolscap': foolscap.__version__,