15 files changed, 265 insertions, 170 deletions

diff --git a/CHANGELOG.rst b/CHANGELOG.rst
new file mode 100644
index 0000000..4f961b9
--- /dev/null
+++ b/CHANGELOG.rst
@@ -0,0 +1,24 @@
+#########
+CHANGELOG
+#########
+
+0.4
+===
+* Update config file loading. Each device will load the ``global`` section followed by it's own section of the provided config (router for emq-router, jobmanager for emq-jobmanager, etc)
+
+Backwards incompatible changes
+------------------------------
+* Configuration: The name and section for the listening addresses has changed:
+   * Job Manager: ``WORKER_ADDR`` is now ``CONNECT_ADDR`` in the ``[jobmanager]`` section
+   * Job Manager: ``WORKER_ADDR_DEFAULT`` is now ``CONNECT_ADDR_DEFAULT`` in the ``[jobmanager]`` section
+   * Job Manager: ``WORKER_ADDR_FAILOVER`` is now ``CONNECT_ADDR_FAILOVER`` in the ``[jobmanager]`` section
+   * Publisher: ``PUBLISHER_FRONTEND_ADDR`` is not ``FRONTEND_LISTEN_ADDR`` in the ``[publisher]`` section
+   * Publisher: ``PUBLISHER_BACKEND_ADDR`` is not ``BACKEND_LISTEN_ADDR`` in the ``[publisher]`` section
+   * Router: ``FRONTEND_ADDR`` is now ``FRONTEND_LISTEN_ADDR`` in the ``[router]`` section
+   * Router: ``BACKEND_ADDR`` is now ``BACKEND_LISTEN_ADDR`` in the ``[router]`` section
+   * Scheduler: ``SCHEDULER_ADDR`` is now ``CONNECT_ADDR`` in the ``[scheduler]`` section
+   * ``RQ_HOST`` is now ``REDIS_HOST``
+   * ``RQ_PORT`` is now ``REDIS_PORT``
+   * ``RQ_DB`` is now ``REDIS_DB``
+   * ``RQ_PASSWORD`` is now ``REDIS_PASSWORD``
+   * ``ADMINISTRATIVE_ADDR`` is now ``ADMINISTRATIVE_LISTEN_ADDR`` in each respective section
diff --git a/docs/changelog_link.rst b/docs/changelog_link.rst
new file mode 100644
index 0000000..565b052
--- /dev/null
+++ b/docs/changelog_link.rst
@@ -0,0 +1 @@
+.. include:: ../CHANGELOG.rst
diff --git a/docs/index.rst b/docs/index.rst
index 25fc86f..af6a758 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -8,7 +8,7 @@ EventMQ Documentation
    using
    api
    contributing
-
+   changelog_link
 
 Indices and tables
 ==================
diff --git a/etc/eventmq.conf-dist b/etc/eventmq.conf-dist
index d492269..2d42285 100644
--- a/etc/eventmq.conf-dist
+++ b/etc/eventmq.conf-dist
@@ -1,27 +1,61 @@
+# -*- mode: conf; encoding: utf-8 -*-
 [global]
-# Enable message output at different stages in the app.
-super_debug = true
-
-# Hide the heartbeat logs when super_debug is enabled. Showing them will generate a lot of messages.
-hide_heartbeat_logs = True
-
-# Port to listen on for administrative commands sent via emq-cli
-administrative_addr=tcp://0.0.0.0:47293
-
-frontend_addr=tcp://0.0.0.0:47291
-backend_addr=tcp://0.0.0.0:47290
-worker_addr=tcp://eventmq:47290
-scheduler_addr=tcp://eventmq:47291
+# Don't bother with HEARTBEATS, both sending and paying attention to them
+disable_heartbeats=False
+# Assume the peer is dead after this many missed heartbeats
+heartbeat_liveness=3
+# Assume a missed heartbeat after this many seconds
+heartbeat_timeout=5
+# How often should a heartbeat be sent in seconds. This should be lower than
+# HEARTBEAT_TIMEOUT
+heartbeat_interval = 3
+# Enable raw message output at different stages in the app.
+super_debug=true
+# Hide the heartbeat logs when super_debug is enabled. Showing them will
+# generate a lot of messages.
+hide_heartbeat_logs=true
+# Default character encoding for strings in messages See these URLs for
+# supported encodings:
+# https://docs.python.org/2/library/codecs.html#standard-encodings
+# https://docs.python.org/3/library/codecs.html#standard-encodings
+default_encoding=utf-8
 
 [router]
+# Listen for clients and schedulers on this address
+frontend_listen_addr=tcp://127.0.0.1:47291
+# Listen for jobmanagers on this address
+backend_listen_addr=tcp://127.0.0.1:47290
+# Listen for administrative status and management commands on this address
+admnistrative_listen_addr=tcp://127.0.0.1:47293
 
 [scheduler]
+# The address of the router's frontend_listen_addr to connect to
+connect_addr=tcp://127.0.0.1:47291
+# Scheduled jobs are saved and loaded from Redis
+redis_host=localhost
+redis_port=6379
+redis_db=0
+# Leave password blank if there is no password
+redis_password=
 
 [jobmanager]
-worker_addr=tcp://127.0.0.1:47290
-queues=[[50,"google"], [40,"pushes"], [10,"default"]]
-concurrent_jobs=2
+# The address of the router's backend_listen_addr to connect to
+connect_addr=tcp://127.0.0.1:47290
+# When no named queue is specified for a job use this queue
+default_queue_name=default
+# JSON Array of weights and named queues. We recommend you keep the default
+# queue unless your 100% positive every job will specify a queue
+queues=[[10, "default"]]
+# Number of concurrent jobs to run
+concurrent_jobs=4
+# Number of messages to cache in RAM before discarding messages
+hwm=10000
+# Number of jobs to execute before restarting the Multiprocessing workers to
+# free up any leaked memory.
+max_job_count=1024
 
 [publisher]
-publisher_frontend_addr=tcp://0.0.0.0:47298
-publisher_backend_addr=tcp://0.0.0.0:47299
\ No newline at end of file
+# Listen for publish messages on this address
+frontend_listen_addr=tcp://127.0.0.1:47298
+# Listen for subscribers on this address
+backend_listen_addr=tcp://127.0.0.1:47299
\ No newline at end of file
diff --git a/eventmq/conf.py b/eventmq/conf.py
index 16b1f78..ef6cafb 100644
--- a/eventmq/conf.py
+++ b/eventmq/conf.py
@@ -17,6 +17,12 @@
 ===================================
 """
 
+# Settings that should not be honored if they are defined in the global
+# section. These must be lowercase.
+_AMBIGUOUS_SETTINGS = ('frontend_listen_addr', 'backend_listen_addr',
+                       'administrative_listen_addr', 'connect_addr',
+                       'reconnect_timeout')
+
 #: SUPER_DEBUG basically enables more debugging logs. Specifically the messages
 #: at different levels in the application.
 #: Default: False
@@ -30,11 +36,10 @@ HIDE_HEARTBEAT_LOGS = True
 # would be a good idea to have a handful of workers listening on this queue
 # unless you're positive that everything specifies a queue with workers.
 DEFAULT_QUEUE_NAME = 'default'
-DEFAULT_QUEUE_WEIGHT = 10
 
 # Default queues for the Job Manager to listen on. The values here should match
 # the values defined on the router.
-QUEUES = [(DEFAULT_QUEUE_WEIGHT, DEFAULT_QUEUE_NAME), ]
+QUEUES = [(10, DEFAULT_QUEUE_NAME), ]
 
 # {{{Job Manager
 # How long should we wait before retrying to connect to a broker?
@@ -59,32 +64,30 @@ CONFIG_FILE = '/etc/eventmq.conf'
 # https://docs.python.org/3/library/codecs.html#standard-encodings
 DEFAULT_ENCODING = 'utf-8'
 
+
 # Default addresses to localhost
-# Router:
-FRONTEND_ADDR = 'tcp://127.0.0.1:47291'
-BACKEND_ADDR = 'tcp://127.0.0.1:47290'
-# Where the Scheduler should connect.
-SCHEDULER_ADDR = 'tcp://127.0.0.1:47291'
-# Where the worker should connect
-WORKER_ADDR = 'tcp://127.0.0.1:47290'
-WORKER_ADDR_DEFAULT = 'tcp://127.0.0.1:47290'
-WORKER_ADDR_FAILOVER = 'tcp://127.0.0.1:47290'
+FRONTEND_LISTEN_ADDR = 'tcp://127.0.0.1:47291'
+BACKEND_LISTEN_ADDR = 'tcp://127.0.0.1:47290'
 # Used to monitor and manage the devices
-ADMINISTRATIVE_ADDR = 'tcp://127.0.0.1:47293'
+ADMINISTRATIVE_LISTEN_ADDR = 'tcp://127.0.0.1:47293'
+
+# Where the router is located
+CONNECT_ADDR = None
+
+# # Where the Scheduler should connect.
+CONNECT_ADDR_DEFAULT = 'tcp://127.0.0.1:47290'
+CONNECT_ADDR_FAILOVER = 'tcp://127.0.0.1:47290'
 
-# PubSub
-PUBLISHER_FRONTEND_ADDR = 'tcp://127.0.0.1:47298'
-PUBLISHER_BACKEND_ADDR = 'tcp://127.0.0.1:47299'
 
 # How many jobs should the job manager concurrently handle?
 CONCURRENT_JOBS = 4
 HWM = 10000
 
 # Redis settings
-RQ_HOST = 'localhost'
-RQ_PORT = 6379
-RQ_DB = 0
-RQ_PASSWORD = ''
+REDIS_HOST = 'localhost'
+REDIS_PORT = 6379
+REDIS_DB = 0
+REDIS_PASSWORD = ''
 
 MAX_JOB_COUNT = 1024
 
diff --git a/eventmq/jobmanager.py b/eventmq/jobmanager.py
index 831cee5..6433861 100644
--- a/eventmq/jobmanager.py
+++ b/eventmq/jobmanager.py
@@ -170,10 +170,10 @@ class JobManager(HeartbeatMixin, EMQPService):
             #       False, so it should stay at the bottom of the loop.
             if not self.maybe_send_heartbeat(events):
                 # Toggle default and failover worker_addr
-                if (conf.WORKER_ADDR == conf.WORKER_ADDR_DEFAULT):
-                    conf.WORKER_ADDR = conf.WORKER_ADDR_FAILOVER
+                if (conf.CONNECT_ADDR == conf.CONNECT_ADDR_DEFAULT):
+                    conf.CONNECT_ADDR = conf.CONNECT_ADDR_FAILOVER
                 else:
-                    conf.WORKER_ADDR = conf.WORKER_ADDR_DEFAULT
+                    conf.CONNECT_ADDR = conf.CONNECT_ADDR_DEFAULT
 
                 break
 
@@ -278,7 +278,7 @@ class JobManager(HeartbeatMixin, EMQPService):
 
     def on_disconnect(self, msgid, msg):
         sendmsg(self.frontend, KBYE)
-        self.frontend.unbind(conf.WORKER_ADDR)
+        self.frontend.unbind(conf.CONNECT_ADDR)
         super(JobManager, self).on_disconnect(msgid, msg)
 
     def on_kbye(self, msgid, msg):
@@ -287,7 +287,6 @@ class JobManager(HeartbeatMixin, EMQPService):
 
     def sighup_handler(self, signum, frame):
         logger.info('Caught signal %s' % signum)
-        import_settings()
         import_settings(section='jobmanager')
 
         self.should_reset = True
@@ -308,7 +307,6 @@ class JobManager(HeartbeatMixin, EMQPService):
             broker_addr (str): The address of the broker to connect to.
         """
         setup_logger('')
-        import_settings()
         import_settings(section='jobmanager')
 
         # If this manager was passed explicit options, favor those
@@ -316,9 +314,9 @@ class JobManager(HeartbeatMixin, EMQPService):
             conf.QUEUES = self.queues
 
         if broker_addr:
-            conf.WORKER_ADDR = broker_addr
+            conf.CONNECT_ADDR = broker_addr
 
-        self.start(addr=conf.WORKER_ADDR, queues=conf.QUEUES)
+        self.start(addr=conf.CONNECT_ADDR, queues=conf.QUEUES)
 
 
 def jobmanager_main():
diff --git a/eventmq/pub.py b/eventmq/pub.py
index 487e8c5..f668f05 100644
--- a/eventmq/pub.py
+++ b/eventmq/pub.py
@@ -41,8 +41,8 @@ class Pub(HeartbeatMixin):
         return
 
     def start(self,
-              frontend_addr=conf.PUBLISHER_FRONTEND_ADDR,
-              backend_addr=conf.PUBLISHER_BACKEND_ADDR):
+              frontend_addr=conf.FRONTEND_LISTEN_ADDR,
+              backend_addr=conf.BACKEND_LISTEN_ADDR):
 
         self.status = STATUS.starting
 
@@ -87,8 +87,8 @@ class Pub(HeartbeatMixin):
         """
         setup_logger('eventmq')
         import_settings(section='publisher')
-        self.start(frontend_addr=conf.PUBLISHER_FRONTEND_ADDR,
-                   backend_addr=conf.PUBLISHER_BACKEND_ADDR)
+        self.start(frontend_addr=conf.FRONTEND_LISTEN_ADDR,
+                   backend_addr=conf.BACKEND_LISTEN_ADDR)
 
 
 # Entry point for pip console scripts
diff --git a/eventmq/router.py b/eventmq/router.py
index 4ff3732..a455ece 100644
--- a/eventmq/router.py
+++ b/eventmq/router.py
@@ -136,9 +136,9 @@ class Router(HeartbeatMixin):
         pdb.Pdb().set_trace(frame)
 
     def start(self,
-              frontend_addr=conf.FRONTEND_ADDR,
-              backend_addr=conf.BACKEND_ADDR,
-              administrative_addr=conf.ADMINISTRATIVE_ADDR):
+              frontend_addr=conf.FRONTEND_LISTEN_ADDR,
+              backend_addr=conf.BACKEND_LISTEN_ADDR,
+              administrative_addr=conf.ADMINISTRATIVE_LISTEN_ADDR):
         """
         Begin listening for connections on the provided connection strings
 
@@ -359,7 +359,7 @@ class Router(HeartbeatMixin):
             self.send_kbye(self.frontend, scheduler)
 
         self.schedulers.clear()
-        self.frontend.unbind(conf.FRONTEND_ADDR)
+        self.frontend.unbind(conf.FRONTEND_LISTEN_ADDR)
 
         if len(self.waiting_messages) > 0:
             logger.info("Router processing messages in queue.")
@@ -372,7 +372,7 @@ class Router(HeartbeatMixin):
             self.send_kbye(self.backend, worker)
 
         self.workers.clear()
-        self.backend.unbind(conf.BACKEND_ADDR)
+        self.backend.unbind(conf.BACKEND_LISTEN_ADDR)
 
         # Loops event loops should check for this and break out
         self.received_disconnect = True
@@ -905,22 +905,22 @@ class Router(HeartbeatMixin):
         process receives a SIGHUP from the system.
         """
         logger.info('Caught signame %s' % signum)
-        self.frontend.unbind(conf.FRONTEND_ADDR)
-        self.backend.unbind(conf.BACKEND_ADDR)
-        import_settings()
-        self.start(frontend_addr=conf.FRONTEND_ADDR,
-                   backend_addr=conf.BACKEND_ADDR,
-                   administrative_addr=conf.ADMINISTRATIVE_ADDR)
+        self.frontend.unbind(conf.FRONTEND_LISTEN_ADDR)
+        self.backend.unbind(conf.BACKEND_LISTEN_ADDR)
+        import_settings('router')
+        self.start(frontend_addr=conf.FRONTEND_LISTEN_ADDR,
+                   backend_addr=conf.BACKEND_LISTEN_ADDR,
+                   administrative_addr=conf.ADMINISTRATIVE_LISTEN_ADDR)
 
     def router_main(self):
         """
         Kick off router with logging and settings import
         """
         setup_logger('eventmq')
-        import_settings()
-        self.start(frontend_addr=conf.FRONTEND_ADDR,
-                   backend_addr=conf.BACKEND_ADDR,
-                   administrative_addr=conf.ADMINISTRATIVE_ADDR)
+        import_settings('router')
+        self.start(frontend_addr=conf.FRONTEND_LISTEN_ADDR,
+                   backend_addr=conf.BACKEND_LISTEN_ADDR,
+                   administrative_addr=conf.ADMINISTRATIVE_LISTEN_ADDR)
 
 
 def router_on_full():
diff --git a/eventmq/scheduler.py b/eventmq/scheduler.py
index 0d953a6..e8188a0 100644
--- a/eventmq/scheduler.py
+++ b/eventmq/scheduler.py
@@ -52,9 +52,10 @@ class Scheduler(HeartbeatMixin, EMQPService):
 
     def __init__(self, *args, **kwargs):
         self.name = kwargs.get('name', None)
-
         logger.info('Initializing Scheduler...')
-        import_settings()
+
+        import_settings('scheduler')
+
         super(Scheduler, self).__init__(*args, **kwargs)
         self.frontend = Sender()
         self._redis_server = None
@@ -82,7 +83,6 @@ class Scheduler(HeartbeatMixin, EMQPService):
         self.interval_jobs = {}
 
         self.poller = Poller()
-
         self.load_jobs()
 
         self._setup()
@@ -189,10 +189,10 @@ class Scheduler(HeartbeatMixin, EMQPService):
         if self._redis_server is None:
             try:
                 self._redis_server = \
-                    redis.StrictRedis(host=conf.RQ_HOST,
-                                      port=conf.RQ_PORT,
-                                      db=conf.RQ_DB,
-                                      password=conf.RQ_PASSWORD)
+                    redis.StrictRedis(host=conf.REDIS_HOST,
+                                      port=conf.REDIS_PORT,
+                                      db=conf.REDIS_DB,
+                                      password=conf.REDIS_PASSWORD)
                 return self._redis_server
 
             except Exception as e:
@@ -222,7 +222,7 @@ class Scheduler(HeartbeatMixin, EMQPService):
         logger.info("Received DISCONNECT request: {}".format(message))
         self._redis_server.connection_pool.disconnect()
         sendmsg(self.frontend, KBYE)
-        self.frontend.unbind(conf.SCHEDULER_ADDR)
+        self.frontend.unbind(conf.CONNECT_ADDR)
         super(Scheduler, self).on_disconnect(msgid, message)
 
     def on_kbye(self, msgid, msg):
@@ -425,9 +425,9 @@ class Scheduler(HeartbeatMixin, EMQPService):
         Kick off scheduler with logging and settings import
         """
         setup_logger("eventmq")
-        import_settings()
+        import_settings('scheduler')
         self.__init__()
-        self.start(addr=conf.SCHEDULER_ADDR)
+        self.start(addr=conf.CONNECT_ADDR)
 
 
 # Entry point for pip console scripts
diff --git a/eventmq/subscriber.py b/eventmq/subscriber.py
deleted file mode 100644
index f585572..0000000
--- a/eventmq/subscriber.py
+++ /dev/null
@@ -1,21 +0,0 @@
-"""
-derp subscriber
-"""
-import zmq
-
-
-if __name__ == "__main__":
-    sockets = []
-    for i in xrange(100):
-        ctx = zmq.Context()
-        s = ctx.socket(zmq.SUB)
-        s.linger = 0
-        s.setsockopt(zmq.SUBSCRIBE, str(i))
-        s.connect('tcp://127.0.0.1:47299')
-        sockets.append(s)
-
-    while True:
-        # block until something comes in. normally you'd do something with
-        # this in another thread or something
-        for s in sockets:
-            print s.recv_multipart()  # noqa
diff --git a/eventmq/tests/test_jobmanager.py b/eventmq/tests/test_jobmanager.py
index 82fed3f..7b62eea 100644
--- a/eventmq/tests/test_jobmanager.py
+++ b/eventmq/tests/test_jobmanager.py
@@ -119,7 +119,7 @@ class TestCase(unittest.TestCase):
 
         # called once for the default settings, once for the jobmanager
         # settings
-        self.assertEqual(2, import_settings_mock.call_count)
+        self.assertEqual(1, import_settings_mock.call_count)
         # check to see if the last call was called with the jobmanager section
         import_settings_mock.assert_called_with(section='jobmanager')
 
@@ -140,18 +140,18 @@ class TestCase(unittest.TestCase):
 
         jm.jobmanager_main()
 
-        self.assertEqual(2, import_settings_mock.call_count)
+        self.assertEqual(1, import_settings_mock.call_count)
         # Assert that the last call to import settings was for the jobmanager
         # section
         import_settings_mock.assert_called_with(section='jobmanager')
 
-        start_mock.assert_called_with(addr=conf.WORKER_ADDR,
+        start_mock.assert_called_with(addr=conf.CONNECT_ADDR,
                                       queues=conf.QUEUES)
 
         jm.queues = ((10, 'derp'), (0, 'blurp'))
         jm.jobmanager_main()
 
-        start_mock.assert_called_with(addr=conf.WORKER_ADDR,
+        start_mock.assert_called_with(addr=conf.CONNECT_ADDR,
                                       queues=jm.queues)
 
     def cleanup(self):
diff --git a/eventmq/tests/test_router.py b/eventmq/tests/test_router.py
index 10441eb..95c5e74 100644
--- a/eventmq/tests/test_router.py
+++ b/eventmq/tests/test_router.py
@@ -37,8 +37,9 @@ class TestCase(unittest.TestCase):
     def test_start(self, event_loop_mock, zsocket_bind_mock):
         # Test default args
         self.router.start()
-        self.router.frontend.listen.assert_called_with(conf.FRONTEND_ADDR)
-        self.router.backend.listen.assert_called_with(conf.BACKEND_ADDR)
+        self.router.frontend.listen.assert_called_with(
+            conf.FRONTEND_LISTEN_ADDR)
+        self.router.backend.listen.assert_called_with(conf.BACKEND_LISTEN_ADDR)
         self.assertEqual(self.router.status, constants.STATUS.listening)
 
         # Test invalid args
diff --git a/eventmq/tests/test_scheduler.py b/eventmq/tests/test_scheduler.py
index ae7dd50..1d72146 100644
--- a/eventmq/tests/test_scheduler.py
+++ b/eventmq/tests/test_scheduler.py
@@ -18,8 +18,6 @@ import unittest
 
 from .. import constants, scheduler
 
-ADDR = 'inproc://pour_the_rice_in_the_thing'
-
 
 class TestCase(unittest.TestCase):
     def test__setup(self):
diff --git a/eventmq/tests/test_utils_settings.py b/eventmq/tests/test_utils_settings.py
index 2d94d4f..589d292 100644
--- a/eventmq/tests/test_utils_settings.py
+++ b/eventmq/tests/test_utils_settings.py
@@ -25,59 +25,73 @@ from ..utils import settings
 class TestCase(unittest.TestCase):
     settings_ini = "\n".join(
         ("[global]",
-         "super_debug=TRuE",
-         "frontend_addr=tcp://0.0.0.0:47291",
+         "super_debug=FaLsE",
+         "hide_heartbeat_logs=false",
+         "frontend_listen_addr=tcp://1.2.3.4:1234",
          "",
          "[jobmanager]",
-         "super_debug=FalSe",
+         "hide_heartbeat_logs=true",
+         "listen_addr=tcp://160.254.23.88:47290",
          'queues=[[50,"google"], [40,"pushes"], [10,"default"]]',
-         "worker_addr=tcp://160.254.23.88:47290",
-         "concurrent_jobs=9283",))
+         "concurrent_jobs=9283",
+         "",
+         "[router]",
+         "# Listen addresses",
+         "frontend_listen_addr=tcp://123.211.1.1:47291",
+         "backend_listen_addr=tcp://123.211.1.1:47290",
+         "# Log all messages",
+         "super_dEbug=TrUe",
+         ""))
 
     def test_import_settings_default(self):
-        # sometimes the tests step on each other with this module. reloading
-        # ensures fresh test data
-        reload(conf)
-
-        # Global section
-        # --------------
-        with utils.mock_config_file(self.settings_ini):
-            settings.import_settings()
-
-        # Changed. Default is 127.0.0.1:47291
-        self.assertEqual(conf.FRONTEND_ADDR, 'tcp://0.0.0.0:47291')
-
-        # Changed. Default is false
-        self.assertTrue(conf.SUPER_DEBUG, True)
+        # Test loading the global section only
+        with LogCapture() as log_checker:
+            with utils.mock_config_file(self.settings_ini):
+                settings.import_settings()
 
-        # Default True
-        self.assertTrue(conf.HIDE_HEARTBEAT_LOGS)
+            log_checker.check(
+                ('eventmq.utils.settings',
+                  'DEBUG',
+                  'Setting conf.SUPER_DEBUG to False'),
+                 ('eventmq.utils.settings',
+                  'DEBUG',
+                  'Setting conf.HIDE_HEARTBEAT_LOGS to False'),
+                 ('eventmq.utils.settings',
+                  'WARNING',
+                  'Ignoring ambiguous setting defined in global section: '
+                  'frontend_listen_addr=tcp://1.2.3.4:1234'))
+
+        # Defined in the global section
+        self.assertFalse(conf.SUPER_DEBUG)
+        self.assertFalse(conf.HIDE_HEARTBEAT_LOGS)
 
-        # Default is 4
+        # Defaults defefined in conf.py
         self.assertEqual(conf.CONCURRENT_JOBS, 4)
-
-        # Default is (10, 'default')
-        self.assertEqual(conf.QUEUES, [(10, conf.DEFAULT_QUEUE_NAME), ])
+        self.assertEqual(conf.QUEUES, [(10, 'default'), ])
 
     def test_read_section(self):
+        # Test reading the router section
         with utils.mock_config_file(self.settings_ini):
-            settings.import_settings('jobmanager')
+            settings.import_settings('router')
 
-        # Changed
-        self.assertFalse(conf.SUPER_DEBUG)
-        # Changed
-        self.assertEqual(conf.CONCURRENT_JOBS, 9283)
+        # Changed in global section
+        self.assertFalse(conf.HIDE_HEARTBEAT_LOGS)
 
-        # Changed
-        self.assertEqual(conf.QUEUES,
-                         [(50, 'google'), (40, 'pushes'), (10, 'default')])
+        # Changed in router section
+        self.assertEqual(conf.FRONTEND_LISTEN_ADDR, 'tcp://123.211.1.1:47291')
+        self.assertEqual(conf.BACKEND_LISTEN_ADDR, 'tcp://123.211.1.1:47290')
+        self.assertTrue(conf.SUPER_DEBUG)
+
+        # # Changed
+        # self.assertEqual(conf.QUEUES,
+        #                  [(50, 'google'), (40, 'pushes'), (10, 'default')])
 
-        self.assertEqual(conf.WORKER_ADDR, 'tcp://160.254.23.88:47290')
+        # self.assertEqual(conf.CONNECT_ADDR, 'tcp://160.254.23.88:47290')
 
     def test_invalid_section(self):
         conf.CONCURRENT_JOBS = 1234
         conf.QUEUES = [(50, 'google'), (40, 'pushes'), (10, 'default')]
-        conf.WORKER_ADDR = 'tcp://160.254.23.88:47290'
+        conf.CONNECT_ADDR = 'tcp://160.254.23.88:47290'
 
         # Invalid section
         with utils.mock_config_file(self.settings_ini):
@@ -87,7 +101,7 @@ class TestCase(unittest.TestCase):
         self.assertEqual(conf.CONCURRENT_JOBS, 1234)
         self.assertEqual(conf.QUEUES,
                          [(50, 'google'), (40, 'pushes'), (10, 'default')])
-        self.assertEqual(conf.WORKER_ADDR, 'tcp://160.254.23.88:47290')
+        self.assertEqual(conf.CONNECT_ADDR, 'tcp://160.254.23.88:47290')
         # Default value
         self.assertEqual(conf.DEFAULT_QUEUE_NAME, 'default')
 
@@ -109,7 +123,7 @@ class TestCase(unittest.TestCase):
             self.assertRaises(ValueError,
                               settings.import_settings, 'jobmanager')
 
-    def test_parse_array(self):
+    def test_parse_string_array(self):
         # Tests parsing a non-nested array (nested are tested via QUEUES
         # setting) via FAKE_VALUE
         settings_ini = "\n".join(
@@ -124,6 +138,20 @@ class TestCase(unittest.TestCase):
 
         self.assertEqual(conf.FAKE_VALUE, [u'asdf', u'asdf2'])
 
+    def test_parse_dict_array(self):
+        # Tests parsing an array of dictionaries
+        settings_ini = '\n'.join(
+            ("[jobmanager]",
+             'fake_value=[{"key1": "value1"}, {"key2": "value2"}]')
+        )
+        reload(conf)
+        conf.FAKE_VALUE = [{'default': 1}]
+        with utils.mock_config_file(settings_ini):
+            settings.import_settings('jobmanager')
+
+        self.assertEqual(conf.FAKE_VALUE,
+                         [{u"key1": u"value1"}, {u"key2": u"value2"}])
+
     def test_invalid_setting(self):
         settings_ini = "\n".join(
             ("[global]",
@@ -138,4 +166,5 @@ class TestCase(unittest.TestCase):
             log_checker.check(
                 ('eventmq.utils.settings',
                  'WARNING',
-                 'Tried to set invalid setting: nonexistent_setting'))
+                 'Tried to set invalid setting: nonexistent_setting=rabbit '
+                 'blood'))
diff --git a/eventmq/utils/settings.py b/eventmq/utils/settings.py
index 30c4dee..2e6fa5c 100644
--- a/eventmq/utils/settings.py
+++ b/eventmq/utils/settings.py
@@ -30,7 +30,8 @@ logger = logging.getLogger(__name__)
 
 def import_settings(section='global'):
     """
-    Import settings and apply to configuration globals
+    Import settings from the defined config file. This will import all the
+    settings from the `global` section followed by the requested section.
 
     Args:
        section (str): Name of the INI section to import
@@ -40,39 +41,66 @@ def import_settings(section='global'):
     if os.path.exists(conf.CONFIG_FILE):
         config.read(conf.CONFIG_FILE)
 
+        if config.has_section('global'):
+            _load_section(config, 'global')
+
+        if section == 'global':
+            # If the requested section is the default then there is nothing
+            # left to do
+            return
+
         if not config.has_section(section):
             logger.warning(
                 'Tried to read nonexistent section {}'.format(section))
             return
 
-        for name, value in config.items(section):
-            if hasattr(conf, name.upper()):
-                default_value = getattr(conf, name.upper())
-                t = type(default_value)
-                if isinstance(default_value, (list, tuple)):
-                    try:
-                        value = t(json.loads(value))
-                    except ValueError:
-                        raise ValueError(
-                            "Invalid JSON syntax for {} setting".format(name))
-                    # json.loads coverts all arrays to lists, but if the first
-                    # element in the default is a tuple (like in QUEUES) then
-                    # convert those elements, otherwise whatever it's type is
-                    # correct
-                    if isinstance(default_value[0], tuple):
-                        setattr(conf, name.upper(),
-                                t(map(tuplify, value)))
-                    else:
-                        setattr(conf, name.upper(), t(value))
-                elif isinstance(default_value, bool):
+        _load_section(config, section)
+    else:
+        logger.warning('Config file at {} not found. Continuing with '
+                       'defaults.'.format(conf.CONFIG_FILE))
+
+
+def _load_section(config, section):
+    """
+    Load the requested section into the configuration globals in
+    :mod:`eventmq.conf`
+
+    Args:
+        section (str): Name of the INI section to import
+    """
+    for name, value in config.items(section):
+        if hasattr(conf, name.upper()):
+
+            if section == 'global' and \
+               name.lower() in conf._AMBIGUOUS_SETTINGS:
+                logger.warning('Ignoring ambiguous setting defined in {} '
+                               'section: {}={}'.format(section, name, value))
+                continue
+
+            default_value = getattr(conf, name.upper())
+            t = type(default_value)
+            if isinstance(default_value, (list, tuple)):
+                try:
+                    value = t(json.loads(value))
+                except ValueError:
+                    raise ValueError(
+                        "Invalid JSON syntax for {} setting".format(name))
+                # json.loads coverts all arrays to lists, but if the first
+                # element in the default is a tuple (like in QUEUES) then
+                # convert those elements, otherwise whatever it's type is
+                # correct
+                if isinstance(default_value[0], tuple):
                     setattr(conf, name.upper(),
-                            True if 't' in value.lower() else False)
+                            t(map(tuplify, value)))
                 else:
                     setattr(conf, name.upper(), t(value))
-                logger.debug("Setting conf.{} to {}".format(
-                    name.upper(), getattr(conf, name.upper())))
+            elif isinstance(default_value, bool):
+                setattr(conf, name.upper(),
+                        True if 't' in value.lower() else False)
             else:
-                logger.warning('Tried to set invalid setting: %s' % name)
-    else:
-        logger.warning('Config file at {} not found. Continuing with '
-                       'defaults.'.format(conf.CONFIG_FILE))
+                setattr(conf, name.upper(), t(value))
+            logger.debug("Setting conf.{} to {}".format(
+                name.upper(), getattr(conf, name.upper())))
+        else:
+            logger.warning('Tried to set invalid setting: {}={}'.format(
+                name, value))