180 lines
6.0 KiB
Python
180 lines
6.0 KiB
Python
"""
|
|
BMConfigParser class definition and default configuration settings
|
|
"""
|
|
|
|
import os
|
|
import shutil
|
|
from threading import Event
|
|
from datetime import datetime
|
|
|
|
from six import string_types
|
|
from six.moves import configparser
|
|
|
|
try:
|
|
import state
|
|
except ImportError:
|
|
from pybitmessage import state
|
|
|
|
SafeConfigParser = configparser.SafeConfigParser
|
|
config_ready = Event()
|
|
|
|
|
|
class BMConfigParser(SafeConfigParser):
|
|
"""
|
|
Singleton class inherited from :class:`ConfigParser.SafeConfigParser`
|
|
with additional methods specific to bitmessage config.
|
|
"""
|
|
# pylint: disable=too-many-ancestors
|
|
_temp = {}
|
|
|
|
def set(self, section, option, value=None):
|
|
if self._optcre is self.OPTCRE or value:
|
|
if not isinstance(value, string_types):
|
|
raise TypeError("option values must be strings")
|
|
if not self.validate(section, option, value):
|
|
raise ValueError("Invalid value %s" % value)
|
|
return SafeConfigParser.set(self, section, option, value)
|
|
|
|
def get(self, section, option, **kwargs):
|
|
"""Try returning temporary value before using parent get()"""
|
|
try:
|
|
return self._temp[section][option]
|
|
except KeyError:
|
|
pass
|
|
return SafeConfigParser.get(
|
|
self, section, option, **kwargs)
|
|
|
|
def setTemp(self, section, option, value=None):
|
|
"""Temporary set option to value, not saving."""
|
|
try:
|
|
self._temp[section][option] = value
|
|
except KeyError:
|
|
self._temp[section] = {option: value}
|
|
|
|
def safeGetBoolean(self, section, option):
|
|
"""Return value as boolean, False on exceptions"""
|
|
try:
|
|
return self.getboolean(section, option)
|
|
except (configparser.NoSectionError, configparser.NoOptionError,
|
|
ValueError, AttributeError):
|
|
return False
|
|
|
|
def safeGetInt(self, section, option, default=0):
|
|
"""Return value as integer, default on exceptions,
|
|
0 if default missing"""
|
|
try:
|
|
return int(self.get(section, option))
|
|
except (configparser.NoSectionError, configparser.NoOptionError,
|
|
ValueError, AttributeError):
|
|
return default
|
|
|
|
def safeGetFloat(self, section, option, default=0.0):
|
|
"""Return value as float, default on exceptions,
|
|
0.0 if default missing"""
|
|
try:
|
|
return self.getfloat(section, option)
|
|
except (configparser.NoSectionError, configparser.NoOptionError,
|
|
ValueError, AttributeError):
|
|
return default
|
|
|
|
def safeGet(self, section, option, default=None):
|
|
"""
|
|
Return value as is, default on exceptions, None if default missing
|
|
"""
|
|
try:
|
|
return self.get(section, option)
|
|
except (configparser.NoSectionError, configparser.NoOptionError,
|
|
ValueError, AttributeError):
|
|
return default
|
|
|
|
def items(self, section, raw=False, variables=None):
|
|
# pylint: disable=signature-differs
|
|
"""Return section variables as parent,
|
|
but override the "raw" argument to always True"""
|
|
return SafeConfigParser.items(self, section, True, variables)
|
|
|
|
def _reset(self):
|
|
"""
|
|
Reset current config.
|
|
There doesn't appear to be a built in method for this.
|
|
"""
|
|
self._temp = {}
|
|
sections = self.sections()
|
|
for x in sections:
|
|
self.remove_section(x)
|
|
|
|
def read(self, filenames=None):
|
|
self._reset()
|
|
SafeConfigParser.read(
|
|
self, os.path.join(os.path.dirname(__file__), 'default.ini'))
|
|
if filenames:
|
|
SafeConfigParser.read(self, filenames)
|
|
|
|
def addresses(self, sort=False):
|
|
"""Return a list of local bitmessage addresses (from section labels)"""
|
|
sections = [x for x in self.sections() if x.startswith('BM-')]
|
|
if sort:
|
|
sections.sort(key=lambda item: self.get(item, 'label').lower())
|
|
return sections
|
|
|
|
def save(self):
|
|
"""Save the runtime config onto the filesystem"""
|
|
fileName = os.path.join(state.appdata, 'keys.dat')
|
|
fileNameBak = '.'.join([
|
|
fileName, datetime.now().strftime("%Y%j%H%M%S%f"), 'bak'])
|
|
# create a backup copy to prevent the accidental loss due to
|
|
# the disk write failure
|
|
try:
|
|
shutil.copyfile(fileName, fileNameBak)
|
|
# The backup succeeded.
|
|
fileNameExisted = True
|
|
except(IOError, Exception):
|
|
# The backup failed. This can happen if the file
|
|
# didn't exist before.
|
|
fileNameExisted = False
|
|
|
|
with open(fileName, 'w') as configfile:
|
|
self.write(configfile)
|
|
# delete the backup
|
|
if fileNameExisted:
|
|
os.remove(fileNameBak)
|
|
|
|
def validate(self, section, option, value):
|
|
"""Input validator interface (using factory pattern)"""
|
|
try:
|
|
return getattr(self, 'validate_%s_%s' % (section, option))(value)
|
|
except AttributeError:
|
|
return True
|
|
|
|
@staticmethod
|
|
def validate_bitmessagesettings_maxoutboundconnections(value):
|
|
"""Reject maxoutboundconnections that are too high or too low"""
|
|
try:
|
|
value = int(value)
|
|
except ValueError:
|
|
return False
|
|
if value < 0 or value > 8:
|
|
return False
|
|
return True
|
|
|
|
def search_addresses(self, address, searched_text):
|
|
"""Return the searched label of MyAddress"""
|
|
return [x for x in [self.get(address, 'label').lower(),
|
|
address.lower()] if searched_text in x]
|
|
|
|
def disable_address(self, address):
|
|
""""Disabling the specific Address"""
|
|
self.set(str(address), 'enabled', 'false')
|
|
self.save()
|
|
|
|
def enable_address(self, address):
|
|
""""Enabling the specific Address"""
|
|
self.set(address, 'enabled', 'true')
|
|
self.save()
|
|
|
|
|
|
if not getattr(BMConfigParser, 'read_file', False):
|
|
BMConfigParser.read_file = BMConfigParser.readfp
|
|
|
|
config = BMConfigParser() # TODO: remove this crutch
|