X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=lib%2Fsimple_config.py;h=0824c04e4d9d6d0f285da21c32df901f0ea068cc;hb=99a31b0c6a30bad2cb2b8c27a748a1f25a89c107;hp=014726de23e69a2e22fd1b0ff880fbab6a73ee50;hpb=d25724a621eeb0b4a92a0ffe67f08bce52a38071;p=electrum-nvc.git

diff --git a/lib/simple_config.py b/lib/simple_config.py
index 014726d..0824c04 100644
--- a/lib/simple_config.py
+++ b/lib/simple_config.py
@@ -1,163 +1,176 @@
-import json, ast
-import os, ast
-from util import user_dir
+import ast
+import threading
+import os
 
-from version import ELECTRUM_VERSION, SEED_VERSION
+from util import user_dir, print_error, print_msg
 
+SYSTEM_CONFIG_PATH = "/etc/electrum.conf"
 
-# old stuff.. should be removed at some point
-def replace_keys(obj, old_key, new_key):
-    if isinstance(obj, dict):
-        if old_key in obj:
-            obj[new_key] = obj[old_key]
-            del obj[old_key]
-        for elem in obj.itervalues():
-            replace_keys(elem, old_key, new_key)
-    elif isinstance(obj, list):
-        for elem in obj:
-            replace_keys(elem, old_key, new_key)
+config = None
 
-def old_to_new(d):
-    replace_keys(d, 'blk_hash', 'block_hash')
-    replace_keys(d, 'pos', 'index')
-    replace_keys(d, 'nTime', 'timestamp')
-    replace_keys(d, 'is_in', 'is_input')
-    replace_keys(d, 'raw_scriptPubKey', 'raw_output_script')
 
+def get_config():
+    global config
+    return config
 
 
-class SimpleConfig:
+def set_config(c):
+    global config
+    config = c
 
-    def __init__(self, options):
 
-        self.wallet_config = {}
-        self.read_wallet_config(options.wallet_path)
+class SimpleConfig(object):
+    """
+    The SimpleConfig class is responsible for handling operations involving
+    configuration files.
 
-        self.common_config = {}
-        self.read_common_config()
+    There are 3 different sources of possible configuration values:
+        1. Command line options.
+        2. User configuration (in the user's config directory)
+        3. System configuration (in /etc/)
+    They are taken in order (1. overrides config options set in 2., that
+    override config set in 3.)
+    """
+    def __init__(self, options=None, read_system_config_function=None,
+                 read_user_config_function=None, read_user_dir_function=None):
 
-        self.options_config = {}
+        # This is the holder of actual options for the current user.
+        self.read_only_options = {}
+        # This lock needs to be acquired for updating and reading the config in
+        # a thread-safe way.
+        self.lock = threading.RLock()
+        # The path for the config directory. This is set later by init_path()
+        self.path = None
 
-        if options.server: self.options_config['server'] = options.server
-        if options.proxy: self.options_config['proxy'] = options.proxy
-        if options.gui: self.options_config['gui'] = options.gui
-        
-        
-
-    def set_key(self, key, value, save = False):
-        # find where a setting comes from and save it there
-        if self.options_config.get(key):
-            return
-
-        elif self.wallet_config.get(key):
-            self.wallet_config[key] = value
-            if save: self.save_wallet_config()
-
-        elif self.common_config.get(key):
-            self.common_config[key] = value
-            if save: self.save_common_config()
+        if options is None:
+            options = {}  # Having a mutable as a default value is a bad idea.
 
+        # The following two functions are there for dependency injection when
+        # testing.
+        if read_system_config_function is None:
+            read_system_config_function = read_system_config
+        if read_user_config_function is None:
+            read_user_config_function = read_user_config
+        if read_user_dir_function is None:
+            self.user_dir = user_dir
         else:
-            # add key to wallet config
-            self.wallet_config[key] = value
-            if save: self.save_wallet_config()
+            self.user_dir = read_user_dir_function
 
+        # Save the command-line keys to make sure we don't override them.
+        self.command_line_keys = options.keys()
+        # Save the system config keys to make sure we don't override them.
+        self.system_config_keys = []
 
-    def get(self, key, default=None):
-        # 1. command-line options always override everything
-        if self.options_config.has_key(key):
-            # print "found", key, "in options"
-            out = self.options_config.get(key)
-
-        # 2. configuration file overrides wallet file
-        elif self.common_config.has_key(key):
-            out = self.common_config.get(key)
-            
-        else:
-            out = self.wallet_config.get(key)
+        if options.get('portable') is not True:
+            # system conf
+            system_config = read_system_config_function()
+            self.system_config_keys = system_config.keys()
+            self.read_only_options.update(system_config)
 
-        if out is None and default is not None:
-            out = default
-        return out
+        # update the current options with the command line options last (to
+        # override both others).
+        self.read_only_options.update(options)
 
+        # init path
+        self.init_path()
 
-    def is_modifiable(self, key):
-        if self.options_config.has_key(key) or self.common_config.has_key(key):
-            return False
-        else:
-            return True
+        # user config.
+        self.user_config = read_user_config_function(self.path)
 
+        set_config(self)  # Make a singleton instance of 'self'
 
-    def read_common_config(self):
-        for name in ['/etc/electrum.conf', os.path.join( user_dir(), 'electrum.conf')]:
-            if os.path.exists(name):
-                try:
-                    import ConfigParser
-                except:
-                    print "cannot parse electrum.conf. please install ConfigParser"
-                    return
-                
-                p = ConfigParser.ConfigParser()
-                p.read(name)
-                for k, v in p.items('client'):
-                    self.common_config[k] = v
+    def init_path(self):
+        # Read electrum path in the command line configuration
+        self.path = self.read_only_options.get('electrum_path')
 
+        # If not set, use the user's default data directory.
+        if self.path is None:
+            self.path = self.user_dir()
 
+        # Make directory if it does not yet exist.
+        if not os.path.exists(self.path):
+            os.mkdir(self.path)
 
+        print_error( "electrum directory", self.path)
 
-    def init_path(self, wallet_path):
-        """Set the path of the wallet."""
-        if wallet_path is not None:
-            self.path = wallet_path
+    def set_key(self, key, value, save = True):
+        if not self.is_modifiable(key):
+            print "Warning: not changing key '%s' because it is not modifiable" \
+                  " (passed as command line option or defined in /etc/electrum.conf)"%key
             return
 
-        # Look for wallet file in the default data directory.
-        # Keeps backwards compatibility.
-        wallet_dir = user_dir()
+        with self.lock:
+            self.user_config[key] = value
+            if save:
+                self.save_user_config()
 
-        # Make wallet directory if it does not yet exist.
-        if not os.path.exists(wallet_dir):
-            os.mkdir(wallet_dir)
-        self.path = os.path.join(wallet_dir, "electrum.dat")
+        return
 
+    def get(self, key, default=None):
+        out = None
+        with self.lock:
+            out = self.read_only_options.get(key)
+            if not out:
+                out = self.user_config.get(key, default)
+        return out
 
+    def is_modifiable(self, key):
+        if key in self.command_line_keys:
+            return False
+        if key in self.system_config_keys:
+            return False
+        return True
 
-    def save_common_config(self):
-        s = repr(self.common_config)
-        # todo: decide what to do 
-        print "not saving settings in common config:", s
-
-
+    def save_user_config(self):
+        if not self.path: return
 
-    def read_wallet_config(self, path):
-        """Read the contents of the wallet file."""
-        self.wallet_file_exists = False
-        self.init_path(path)
+        path = os.path.join(self.path, "config")
+        s = repr(self.user_config)
+        f = open(path,"w")
+        f.write( s )
+        f.close()
+        if self.get('gui') != 'android':
+            import stat
+            os.chmod(path, stat.S_IREAD | stat.S_IWRITE)
+
+def read_system_config(path=SYSTEM_CONFIG_PATH):
+    """Parse and return the system config settings in /etc/electrum.conf."""
+    result = {}
+    if os.path.exists(path):
         try:
-            with open(self.path, "r") as f:
-                data = f.read()
-        except IOError:
+            import ConfigParser
+        except ImportError:
+            print "cannot parse electrum.conf. please install ConfigParser"
             return
+
+        p = ConfigParser.ConfigParser()
         try:
-            d = ast.literal_eval( data )  #parse raw data from reading wallet file
-            old_to_new(d)
-        except:
-            raise IOError("Cannot read wallet file.")
+            p.read(path)
+            for k, v in p.items('client'):
+                result[k] = v
+        except (ConfigParser.NoSectionError, ConfigParser.MissingSectionHeaderError):
+            pass
 
-        self.wallet_config = d
-        self.wallet_file_exists = True
+    return result
 
+def read_user_config(path):
+    """Parse and store the user config settings in electrum.conf into user_config[]."""
+    if not path: return {}  # Return a dict, since we will call update() on it.
 
+    config_path = os.path.join(path, "config")
+    result = {}
+    if os.path.exists(config_path):
+        try:
 
-    def save(self):
-        self.save_wallet_config()
+            with open(config_path, "r") as f:
+                data = f.read()
+            result = ast.literal_eval( data )  #parse raw data from reading wallet file
 
+        except Exception:
+            print_msg("Error: Cannot read config file.")
+            result = {}
 
-    def save_wallet_config(self):
-        s = repr(self.wallet_config)
-        f = open(self.path,"w")
-        f.write( s )
-        f.close()
-        import stat
-        os.chmod(self.path,stat.S_IREAD | stat.S_IWRITE)
+        if not type(result) is dict:
+            return {}
 
+    return result