Merge remote-tracking branch 'upstream/python3.4' into python3.4

Author: Foxlet

cloudbot/__init__.py

@@ -2,7 +2,7 @@
 
 # check python version
 if sys.version_info < (3, 4, 0):
-    print("CloudBot3 requires Python 3.4 or newer.")
+    print("CloudBot requires Python 3.4 or newer.")
     sys.exit(1)
 
 import json
@@ -12,33 +12,22 @@
 
 __version__ = "0.1.1.dev0"
 
-__all__ = ["util", "bot", "connection", "config", "permissions", "plugin", "event", "hook", "dev_mode", "log_dir"]
+__all__ = ["util", "bot", "connection", "config", "permissions", "plugin", "event", "hook", "log_dir"]
 
 
 def _setup():
-    default_developer_mode = {"plugin_reloading": False, "config_reloading": True,
-                              "console_debug": False, "file_debug": True}
     if os.path.exists(os.path.abspath("config.json")):
         with open(os.path.abspath("config.json")) as config_file:
             json_conf = json.load(config_file)
-        developer_mode = json_conf.get("developer_mode", default_developer_mode)
+        logging_config = json_conf.get("logging", {})
     else:
-        developer_mode = default_developer_mode
+        logging_config = {}
 
-    if "config_reloading" not in developer_mode:
-        developer_mode["config_reloading"] = default_developer_mode["config_reloading"]
-    if "plugin_reloading" not in developer_mode:
-        developer_mode["plugin_reloading"] = default_developer_mode["plugin_reloading"]
-    if "console_debug" not in developer_mode:
-        developer_mode["console_debug"] = default_developer_mode["console_debug"]
-    if "file_debug" not in developer_mode:
-        developer_mode["file_debug"] = default_developer_mode["file_debug"]
+    global logging_dir
+    logging_dir = os.path.join(os.path.abspath(os.path.curdir), "logs")
 
-    global log_dir
-    log_dir = os.path.join(os.path.abspath(os.path.curdir), "logs")
-
-    if not os.path.exists(log_dir):
-        os.makedirs(log_dir)
+    if not os.path.exists(logging_dir):
+        os.makedirs(logging_dir)
 
     dict_config = {
         "version": 1,
@@ -66,7 +55,7 @@ def _setup():
                 "formatter": "full",
                 "level": "INFO",
                 "encoding": "utf-8",
-                "filename": os.path.join(log_dir, "bot.log")
+                "filename": os.path.join(logging_dir, "bot.log")
             }
         },
         "loggers": {
@@ -77,24 +66,21 @@ def _setup():
         }
     }
 
-    if developer_mode["console_debug"]:
+    if logging_config.get("console_debug", False):
         dict_config["handlers"]["console"]["level"] = "DEBUG"
 
-    if developer_mode["file_debug"]:
+    if logging_config.get("file_debug", True):
         dict_config["handlers"]["debug_file"] = {
             "class": "logging.handlers.RotatingFileHandler",
             "maxBytes": 1000000,
             "backupCount": 5,
             "formatter": "full",
             "encoding": "utf-8",
             "level": "DEBUG",
-            "filename": os.path.join(log_dir, "debug.log")
+            "filename": os.path.join(logging_dir, "debug.log")
         }
         dict_config["loggers"]["cloudbot"]["handlers"].append("debug_file")
 
     logging.config.dictConfig(dict_config)
 
-    return developer_mode
-
-
-dev_mode = _setup()
+_setup()

cloudbot/__main__.py

@@ -5,21 +5,16 @@
 import time
 import signal
 
-print('CloudBot3 <http://git.io/refresh>')
+# store the original working directory, for use when restarting
+original_wd = os.path.realpath(".")
 
-# set up environment
-
-# we need to make sure we are in the install directory
+# set up environment - we need to make sure we are in the install directory
 path0 = os.path.realpath(sys.path[0] or '.')
-cloudbot_dir = os.path.realpath(os.path.dirname(__file__))
-if path0 == cloudbot_dir:
-    sys.path[0] = path0 = os.path.dirname(cloudbot_dir)
+install_dir = os.path.realpath(os.path.dirname(__file__))
+if path0 == install_dir:
+    sys.path[0] = path0 = os.path.dirname(install_dir)
 os.chdir(path0)
 
-# add 'lib' to path for libraries (currently unused)
-if os.path.exists(os.path.abspath('lib')):
-    sys.path += ['lib']
-
 # import bot
 from cloudbot.bot import CloudBot
 
@@ -31,12 +26,10 @@ def main():
     logging.logProcesses = 0
 
     logger = logging.getLogger("cloudbot")
-
-    # store the original working directory, for use when restarting
-    original_wd = os.path.realpath(".")
+    logger.info("Starting CloudBot.")
 
     # create the bot
-    cloudbot = CloudBot()
+    bot = CloudBot()
 
     # whether we are killed while restarting
     stopped_while_restarting = False
@@ -47,11 +40,11 @@ def main():
     # define closure for signal handling
     def exit_gracefully(signum, frame):
         nonlocal stopped_while_restarting
-        if not cloudbot:
+        if not bot:
             # we are currently in the process of restarting
             stopped_while_restarting = True
         else:
-            cloudbot.loop.call_soon_threadsafe(lambda: asyncio.async(cloudbot.stop("Killed"), loop=cloudbot.loop))
+            bot.loop.call_soon_threadsafe(lambda: asyncio.async(bot.stop("Killed"), loop=bot.loop))
 
         # restore the original handler so if they do it again it triggers
         signal.signal(signal.SIGINT, original_sigint)
@@ -61,12 +54,12 @@ def exit_gracefully(signum, frame):
     # start the bot master
 
     # CloudBot.run() will return True if it should restart, False otherwise
-    restart = cloudbot.run()
+    restart = bot.run()
 
     # the bot has stopped, do we want to restart?
     if restart:
         # remove reference to cloudbot, so exit_gracefully won't try to stop it
-        cloudbot = None
+        bot = None
         # sleep one second for timeouts
         time.sleep(1)
         if stopped_while_restarting:
@@ -75,8 +68,8 @@ def exit_gracefully(signum, frame):
             # actually restart
             os.chdir(original_wd)
             args = sys.argv
-            logger.info("Restarting CloudBot")
-            logger.debug("Restarting - arguments {}".format(args))
+            logger.info("Restarting Bot")
+            logger.debug("Restart arguments: {}".format(args))
             for f in [sys.stdout, sys.stderr]:
                 f.flush()
             # close logging, and exit the program.

cloudbot/bot.py

@@ -16,7 +16,7 @@
 from cloudbot.plugin import PluginManager
 from cloudbot.event import Event, CommandEvent, RegexEvent, EventType
 from cloudbot.util import botvars, formatting
-from cloudbot.irc.client import IrcClient
+from cloudbot.clients.irc import IrcClient
 
 logger = logging.getLogger("cloudbot")
 
@@ -71,15 +71,9 @@ def __init__(self, loop=asyncio.get_event_loop()):
         self.config = Config(self)
         logger.debug("Config system initialised.")
 
-        # log developer mode
-        if cloudbot.dev_mode.get("plugin_reloading"):
-            logger.info("Enabling developer option: plugin reloading.")
-        if cloudbot.dev_mode.get("config_reloading"):
-            logger.info("Enabling developer option: config reloading.")
-        if cloudbot.dev_mode.get("console_debug"):
-            logger.info("Enabling developer option: console debug.")
-        if cloudbot.dev_mode.get("file_debug"):
-            logger.info("Enabling developer option: file debug")
+        # set values for reloading
+        self.plugin_reloading_enabled = self.config.get("reloading", {}).get("plugin_reloading", False)
+        self.config_reloading_enabled = self.config.get("reloading", {}).get("config_reloading", True)
 
         # this doesn't REALLY need to be here but it's nice
         self.user_agent = self.config.get('user_agent', 'CloudBot/3.0 - CloudBot Refresh '
@@ -91,6 +85,7 @@ def __init__(self, loop=asyncio.get_event_loop()):
         self.db_factory = sessionmaker(bind=self.db_engine)
         self.db_session = scoped_session(self.db_factory)
         self.db_metadata = MetaData()
+
         # set botvars.metadata so plugins can access when loading
         botvars.metadata = self.db_metadata
         logger.debug("Database system initialised.")
@@ -101,7 +96,7 @@ def __init__(self, loop=asyncio.get_event_loop()):
         # create bot connections
         self.create_connections()
 
-        if cloudbot.dev_mode.get("plugin_reloading"):
+        if self.plugin_reloading_enabled:
             self.reloader = PluginReloader(self)
 
         self.plugin_manager = PluginManager(self)
@@ -122,40 +117,39 @@ def run(self):
 
     def create_connections(self):
         """ Create a BotConnection for all the networks defined in the config """
-        for conf in self.config['connections']:
+        for config in self.config['connections']:
             # strip all spaces and capitalization from the connection name
-            readable_name = conf['name']
-            name = clean_name(readable_name)
-            nick = conf['nick']
-            server = conf['connection']['server']
-            port = conf['connection'].get('port', 6667)
-            local_bind = (conf['connection'].get('bind_addr', False), conf['connection'].get('bind_port', 0))
+            name = clean_name(config['name'])
+            nick = config['nick']
+            server = config['connection']['server']
+            port = config['connection'].get('port', 6667)
+            local_bind = (config['connection'].get('bind_addr', False), config['connection'].get('bind_port', 0))
             if local_bind[0] is False:
                 local_bind = False
 
-            self.connections.append(IrcClient(self, name, nick, config=conf, channels=conf['channels'],
-                                              readable_name=readable_name, server=server, port=port,
-                                              use_ssl=conf['connection'].get('ssl', False), local_bind=local_bind))
-            logger.debug("[{}] Created connection.".format(readable_name))
+            self.connections.append(IrcClient(self, name, nick, config=config, channels=config['channels'],
+                                              server=server, port=port, use_ssl=config['connection'].get('ssl', False),
+                                              local_bind=local_bind))
+            logger.debug("[{}] Created connection.".format(name))
 
     @asyncio.coroutine
     def stop(self, reason=None, *, restart=False):
         """quits all networks and shuts the bot down"""
         logger.info("Stopping bot.")
 
-        if cloudbot.dev_mode.get("config_reloading"):
+        if self.config_reloading_enabled:
             logger.debug("Stopping config reloader.")
             self.config.stop()
 
-        if cloudbot.dev_mode.get("plugin_reloading"):
+        if self.plugin_reloading_enabled:
             logger.debug("Stopping plugin reloader.")
             self.reloader.stop()
 
         for connection in self.connections:
             if not connection.connected:
                 # Don't quit a connection that hasn't connected
                 continue
-            logger.debug("[{}] Closing connection.".format(connection.readable_name))
+            logger.debug("[{}] Closing connection.".format(connection.name))
 
             connection.quit(reason)
 
@@ -186,7 +180,7 @@ def _init_routine(self):
             logger.info("Killed while loading, exiting")
             return
 
-        if cloudbot.dev_mode.get("plugin_reloading"):
+        if self.plugin_reloading_enabled:
             # start plugin reloader
             self.reloader.start(os.path.abspath("plugins"))
 

cloudbot/client.py

@@ -12,7 +12,6 @@ class Client:
     :type bot: cloudbot.bot.CloudBot
     :type loop: asyncio.events.AbstractEventLoop
     :type name: str
-    :type readable_name: str
     :type channels: list[str]
     :type config: dict[str, unknown]
     :type nick: str
@@ -21,11 +20,10 @@ class Client:
     :type permissions: PermissionManager
     """
 
-    def __init__(self, bot, name, nick, *, readable_name, channels=None, config=None):
+    def __init__(self, bot, name, nick, *, channels=None, config=None):
         """
         :type bot: cloudbot.bot.CloudBot
         :type name: str
-        :type readable_name: str
         :type nick: str
         :type channels: list[str]
         :type config: dict[str, unknown]
@@ -34,7 +32,6 @@ def __init__(self, bot, name, nick, *, readable_name, channels=None, config=None
         self.loop = bot.loop
         self.name = name
         self.nick = nick
-        self.readable_name = readable_name
 
         if channels is None:
             self.channels = []

cloudbot/irc/__init__.py cloudbot/clients/__init__.pycloudbot/irc/__init__.py renamed to cloudbot/clients/__init__.py

@@ -46,12 +46,11 @@ class IrcClient(Client):
     :type _ignore_cert_errors: bool
     """
 
-    def __init__(self, bot, name, nick, *, readable_name, channels=None, config=None,
+    def __init__(self, bot, name, nick, *, channels=None, config=None,
                  server, port=6667, use_ssl=False, ignore_cert_errors=True, timeout=300, local_bind=False):
         """
         :type bot: cloudbot.bot.CloudBot
         :type name: str
-        :type readable_name: str
         :type nick: str
         :type channels: list[str]
         :type config: dict[str, unknown]
@@ -61,7 +60,7 @@ def __init__(self, bot, name, nick, *, readable_name, channels=None, config=None
         :type ignore_cert_errors: bool
         :type timeout: int
         """
-        super().__init__(bot, name, nick, readable_name=readable_name, channels=channels, config=config)
+        super().__init__(bot, name, nick, channels=channels, config=config)
 
         self.use_ssl = use_ssl
         self._ignore_cert_errors = ignore_cert_errors
@@ -99,18 +98,18 @@ def connect(self):
         """
         Connects to the IRC server, or reconnects if already connected.
         """
-        # connect to the irc server
+        # connect to the clients server
         if self._quit:
             # we've quit, so close instead (because this has probably been called because of EOF received)
             self.close()
             return
 
         if self._connected:
-            logger.info("[{}] Reconnecting".format(self.readable_name))
+            logger.info("[{}] Reconnecting".format(self.name))
             self._transport.close()
         else:
             self._connected = True
-            logger.info("[{}] Connecting".format(self.readable_name))
+            logger.info("[{}] Connecting".format(self.name))
         optional_params = {}
         if self.local_bind:
             optional_params["local_addr"] = self.local_bind
@@ -208,7 +207,7 @@ def _send(self, line):
         Sends a raw IRC line unchecked. Doesn't do connected check, and is *not* threadsafe
         :type line: str
         """
-        logger.info("[{}] >> {}".format(self.readable_name, line))
+        logger.info("[{}] >> {}".format(self.name, line))
         asyncio.async(self._protocol.send(line), loop=self.loop)
 
 
@@ -262,14 +261,14 @@ def connection_lost(self, exc):
         if exc is None:
             # we've been closed intentionally, so don't reconnect
             return
-        logger.error("[{}] Connection lost: {}".format(self.conn.readable_name, exc))
+        logger.error("[{}] Connection lost: {}".format(self.conn.name, exc))
         asyncio.async(self.conn.connect(), loop=self.loop)
 
     def eof_received(self):
         self._connected = False
         # create a new connected_future for when we are connected.
         self._connected_future = asyncio.Future(loop=self.loop)
-        logger.info("[{}] EOF received.".format(self.conn.readable_name))
+        logger.info("[{}] EOF received.".format(self.conn.name))
         asyncio.async(self.conn.connect(), loop=self.loop)
         return True
 
@@ -294,7 +293,7 @@ def data_received(self, data):
                 prefix_line_match = irc_prefix_re.match(line)
                 if prefix_line_match is None:
                     logger.critical("[{}] Received invalid IRC line '{}' from {}".format(
-                        self.conn.readable_name, line, self.conn.describe_server()))
+                        self.conn.name, line, self.conn.describe_server()))
                     continue
 
                 netmask_prefix, command, params = prefix_line_match.groups()
@@ -316,7 +315,7 @@ def data_received(self, data):
                 noprefix_line_match = irc_noprefix_re.match(line)
                 if noprefix_line_match is None:
                     logger.critical("[{}] Received invalid IRC line '{}' from {}".format(
-                        self.conn.readable_name, line, self.conn.describe_server()))
+                        self.conn.name, line, self.conn.describe_server()))
                     continue
                 command = noprefix_line_match.group(1)
                 params = noprefix_line_match.group(2)