def __init__(self, bot, root_dir, level): self._bot = bot self._root_dir = root_dir self._logging_level = level self._config_path = path.join(self.root_dir, "config.yml") self._log_dir = path.join(self.root_dir, "logs") perms_file = path.join(self.root_dir, "permissions.db") self._permissions = PermissionsDB(perms_file) self._decryption_cipher = None self._data = None self._components = ConfigNode() self._wiki = ConfigNode() self._irc = ConfigNode() self._commands = ConfigNode() self._tasks = ConfigNode() self._metadata = ConfigNode() self._nodes = [self._components, self._wiki, self._irc, self._commands, self._tasks, self._metadata] self._decryptable_nodes = [ # Default nodes to decrypt (self._wiki, ("password",)), (self._wiki, ("search", "credentials", "key")), (self._wiki, ("search", "credentials", "secret")), (self._irc, ("frontend", "nickservPassword")), (self._irc, ("watcher", "nickservPassword")), ]
class BotConfig(object): """ **EarwigBot: YAML Config File Manager** This handles all tasks involving reading and writing to our config file, including encrypting and decrypting passwords and making a new config file from scratch at the inital bot run. BotConfig has a few attributes and methods, including the following: - :py:attr:`root_dir`: bot's working directory; contains :file:`config.yml`, :file:`logs/` - :py:attr:`path`: path to the bot's config file - :py:attr:`components`: enabled components - :py:attr:`wiki`: information about wiki-editing - :py:attr:`irc`: information about IRC - :py:attr:`commands`: information about IRC commands - :py:attr:`tasks`: information for bot tasks - :py:attr:`metadata`: miscellaneous information - :py:meth:`schedule`: tasks scheduled to run at a given time BotConfig also has some methods used in config loading: - :py:meth:`load`: loads (or reloads) and parses our config file - :py:meth:`decrypt`: decrypts an object in the config tree """ def __init__(self, bot, root_dir, level): self._bot = bot self._root_dir = root_dir self._logging_level = level self._config_path = path.join(self.root_dir, "config.yml") self._log_dir = path.join(self.root_dir, "logs") perms_file = path.join(self.root_dir, "permissions.db") self._permissions = PermissionsDB(perms_file) self._decryption_cipher = None self._data = None self._components = ConfigNode() self._wiki = ConfigNode() self._irc = ConfigNode() self._commands = ConfigNode() self._tasks = ConfigNode() self._metadata = ConfigNode() self._nodes = [self._components, self._wiki, self._irc, self._commands, self._tasks, self._metadata] self._decryptable_nodes = [ # Default nodes to decrypt (self._wiki, ("password",)), (self._wiki, ("search", "credentials", "key")), (self._wiki, ("search", "credentials", "secret")), (self._irc, ("frontend", "nickservPassword")), (self._irc, ("watcher", "nickservPassword")), ] def __repr__(self): """Return the canonical string representation of the BotConfig.""" res = "BotConfig(root_dir={0!r}, level={1!r})" return res.format(self.root_dir, self.logging_level) def __str__(self): """Return a nice string representation of the BotConfig.""" return "<BotConfig at {0}>".format(self.root_dir) def _handle_missing_config(self): print "Config file missing or empty:", self._config_path msg = "Would you like to create a config file now? [Y/n] " choice = raw_input(msg) if choice.lower().startswith("n"): raise NoConfigError() else: try: ConfigScript(self).make_new() except KeyboardInterrupt: raise NoConfigError() def _load(self): """Load data from our JSON config file (config.yml) into self._data.""" filename = self._config_path with open(filename, 'r') as fp: try: self._data = yaml.load(fp, OrderedLoader) except yaml.YAMLError: print "Error parsing config file {0}:".format(filename) raise def _setup_logging(self): """Configures the logging module so it works the way we want it to.""" log_dir = self._log_dir logger = logging.getLogger("earwigbot") logger.handlers = [] # Remove any handlers already attached to us logger.setLevel(logging.DEBUG) color_formatter = BotFormatter(color=True) formatter = BotFormatter() if self.metadata.get("enableLogging"): hand = logging.handlers.TimedRotatingFileHandler logfile = lambda f: path.join(log_dir, f) if not path.isdir(log_dir): if not path.exists(log_dir): mkdir(log_dir, stat.S_IWUSR|stat.S_IRUSR|stat.S_IXUSR) else: msg = "log_dir ({0}) exists but is not a directory!" print msg.format(log_dir) return main_handler = hand(logfile("bot.log"), "midnight", 1, 7) error_handler = hand(logfile("error.log"), "W6", 1, 4) debug_handler = hand(logfile("debug.log"), "H", 1, 6) main_handler.setLevel(logging.INFO) error_handler.setLevel(logging.WARNING) debug_handler.setLevel(logging.DEBUG) for h in (main_handler, error_handler, debug_handler): h.setFormatter(formatter) logger.addHandler(h) self._stream_handler = stream = logging.StreamHandler() stream.setLevel(self._logging_level) stream.setFormatter(color_formatter) logger.addHandler(stream) def _decrypt(self, node, nodes): """Try to decrypt the contents of a config node. Use self.decrypt().""" try: node._decrypt(self._decryption_cipher, nodes[:-1], nodes[-1]) except ValueError: print "Error decrypting passwords:" raise @property def bot(self): """The config's Bot object.""" return self._bot @property def root_dir(self): """The bot's root directory containing its config file and more.""" return self._root_dir @property def logging_level(self): """The minimum logging level for messages logged via stdout.""" return self._logging_level @logging_level.setter def logging_level(self, level): self._logging_level = level self._stream_handler.setLevel(level) @property def path(self): """The path to the bot's config file.""" return self._config_path @property def log_dir(self): """The directory containing the bot's logs.""" return self._log_dir @property def data(self): """The entire config file as a decoded JSON object.""" return self._data @property def components(self): """A dict of enabled components.""" return self._components @property def wiki(self): """A dict of information about wiki-editing.""" return self._wiki @property def irc(self): """A dict of information about IRC.""" return self._irc @property def commands(self): """A dict of information for IRC commands.""" return self._commands @property def tasks(self): """A dict of information for bot tasks.""" return self._tasks @property def metadata(self): """A dict of miscellaneous information.""" return self._metadata def is_loaded(self): """Return ``True`` if our config file has been loaded, or ``False``.""" return self._data is not None def is_encrypted(self): """Return ``True`` if passwords are encrypted, otherwise ``False``.""" return self.metadata.get("encryptPasswords", False) def load(self): """Load, or reload, our config file. First, check if we have a valid config file, and if not, notify the user. If there is no config file at all, offer to make one, otherwise exit. Data from the config file is stored in six :py:class:`~earwigbot.config.ConfigNode`\ s (:py:attr:`components`, :py:attr:`wiki`, :py:attr:`irc`, :py:attr:`commands`, :py:attr:`tasks`, :py:attr:`metadata`) for easy access (as well as the lower-level :py:attr:`data` attribute). If passwords are encrypted, we'll use :py:func:`~getpass.getpass` for the key and then decrypt them. If the config is being reloaded, encrypted items will be automatically decrypted if they were decrypted earlier. """ if not path.exists(self._config_path): self._handle_missing_config() self._load() if not self._data: self._handle_missing_config() self._load() self.components._load(self._data.get("components", OrderedDict())) self.wiki._load(self._data.get("wiki", OrderedDict())) self.irc._load(self._data.get("irc", OrderedDict())) self.commands._load(self._data.get("commands", OrderedDict())) self.tasks._load(self._data.get("tasks", OrderedDict())) self.metadata._load(self._data.get("metadata", OrderedDict())) self._setup_logging() if self.is_encrypted(): if not self._decryption_cipher: try: blowfish_new = Blowfish.new hashpw = bcrypt.hashpw except ImportError: url1 = "http://www.mindrot.org/projects/py-bcrypt" url2 = "https://www.dlitz.net/software/pycrypto/" e = "Encryption requires the 'py-bcrypt' and 'pycrypto' packages: {0}, {1}" raise NoConfigError(e.format(url1, url2)) key = getpass("Enter key to decrypt bot passwords: ") self._decryption_cipher = blowfish_new(sha256(key).digest()) signature = self.metadata["signature"] if hashpw(key, signature) != signature: raise RuntimeError("Incorrect password.") for node, nodes in self._decryptable_nodes: self._decrypt(node, nodes) if self.irc: self.irc["permissions"] = self._permissions self._permissions.load() def decrypt(self, node, *nodes): """Decrypt an object in our config tree. :py:attr:`_decryption_cipher` is used as our key, retrieved using :py:func:`~getpass.getpass` in :py:meth:`load` if it wasn't already specified. If this is called when passwords are not encrypted (check with :py:meth:`is_encrypted`), nothing will happen. We'll also keep track of this node if :py:meth:`load` is called again (i.e. to reload) and automatically decrypt it. Example usage:: >>> config.decrypt(config.irc, "frontend", "nickservPassword") # decrypts config.irc["frontend"]["nickservPassword"] """ signature = (node, nodes) if signature in self._decryptable_nodes: return # Already decrypted self._decryptable_nodes.append(signature) if self.is_encrypted(): self._decrypt(node, nodes) def schedule(self, minute, hour, month_day, month, week_day): """Return a list of tasks scheduled to run at the specified time. The schedule data comes from our config file's ``schedule`` field, which is stored as :py:attr:`self.data["schedule"] <data>`. """ # Tasks to run this turn, each as a list of either [task_name, kwargs], # or just the task_name: tasks = [] now = {"minute": minute, "hour": hour, "month_day": month_day, "month": month, "week_day": week_day} data = self._data.get("schedule", []) for event in data: do = True for key, value in now.items(): try: requirement = event[key] except KeyError: continue if requirement != value: do = False break if do: try: tasks.extend(event["tasks"]) except KeyError: pass return tasks