Merge lp:~eday/burrow/backend-api-cleanup into lp:burrow

[Eric Day]

A number of cleanup tasks and client support.

=== modified file 'ChangeLog'
--- ChangeLog	2011-03-18 00:47:26 +0000
+++ ChangeLog	2011-04-06 05:49:23 +0000
@@ -1,3 +1,43 @@
[phone]  Eric Day  <[e-mail]>
+
+	Merged burrow and burrowd packages, the interfaces for backend/client can be shared, and this will also allow modular in-process queues.
+
[phone]  Eric Day  <[e-mail]>
+
+	Started SQLite backend cleanup.
+
[phone]  Eric Day  <[e-mail]>
+
+	More backend API cleanup.
+
[phone]  Eric Day  <[e-mail]>
+
+	Further backend API cleanup, started cleanup in memory backend.
+
[phone]  Eric Day  <[e-mail]>
+
+	Removed the need to 'queue_exists' decorator and backend methods.
+
[phone]  Eric Day  <[e-mail]>
+
+	Switched to pass attributes as a dict instead of positional arguments.
+
[phone]  Eric Day  <[e-mail]>
+
+	Switched to pass filters as a dict instead of positional arguments.
+
[phone]  Eric Day  <[e-mail]>
+
+	Started locale support.
+
[phone]  Eric Day  <[e-mail]>
+
+	Started locale support.
+
[phone]  Eric Day  <[e-mail]>
+
+	Python prototype conversion to get new trunk started.
+
 2011-03-17  Eric Day  <[e-mail]>
 
 	First chunk of code from prototype. Beyond the prototype, configuration, module loading, and log handling was added.
 
=== modified file 'bin/burrow'
--- bin/burrow	2011-03-17 23:42:41 +0000
+++ bin/burrow	2011-04-06 05:49:23 +0000
@@ -16,3 +16,157 @@
 '''
 Burrow command line client.
 '''
+
+import pwd
+import optparse
+import os
+import sys
+
+# If ../burrow/__init__.py exists, add ../ to the Python search path so
+# that it will override whatever may be installed in the default Python
+# search path.
+BASE_DIRECTORY = os.path.join(os.path.abspath(__file__), os.pardir, os.pardir)
+BASE_DIRECTORY = os.path.normpath(BASE_DIRECTORY)
+if os.path.exists(os.path.join(BASE_DIRECTORY, 'burrow', '__init__.py')):
+    sys.path.insert(0, BASE_DIRECTORY)
+
+import burrow
+
+
+class Burrow(object):
+
+    sections = [
+        dict(name='Global',
+            filters=True,
+            args=[],
+            commands=['delete_accounts', 'get_accounts']),
+        dict(name='Account',
+            account=True,
+            filters=True,
+            args=[],
+            commands=['delete_queues', 'get_queues']),
+        dict(name='Queue',
+            account=True,
+            filters=True,
+            args=['queue'],
+            commands=['delete_messages', 'get_messages', 'update_messages']),
+        dict(name='Message',
+            account=True,
+            args=['queue', 'message'],
+            commands=[
+                'create_message',
+                'delete_message',
+                'get_message',
+                'update_message'])]
+
+    attribute_commands = [
+        'update_messages',
+        'create_message',
+        'update_message']
+
+    stdin_commands = ['create_message']
+
+    def __init__(self):
+        self.parser = optparse.OptionParser(version=burrow.__version__)
+        self.parser.add_option('-c', '--commands', action='store_true',
+            help=_('Print help for the available commands'))
+        self.parser.add_option('-u', '--url', default='http://localhost:8080',
+            help=_('Backend URL to use'))
+        rcfile = os.path.expanduser('~')
+        rcfile = os.path.join(rcfile, '.burrowrc')
+        if not os.path.exists(rcfile):
+            rcfile = None
+        self.parser.add_option('-f', '--files', default=rcfile,
+            help=_('Configuration file(s) to use (comma separated)'))
+        user = pwd.getpwuid(os.getuid())[0]
+        self.parser.add_option('-a', '--account', default=user,
+            help=_('Account to use for queue and message commands'))
+        self.parser.add_option('-w', '--wait',
+            help=_('Number of seconds to wait if no messages match'))
+
+        attributes = optparse.OptionGroup(self.parser,
+            _('Messages attribute options'))
+        attributes.add_option('-t', '--ttl',
+            help=_('TTL attribute in seconds to set for message(s)'))
+        attributes.add_option('-H', '--hide',
+            help=_('Hidden time attribute in seconds to set for message(s)'))
+        self.parser.add_option_group(attributes)
+
+        filters = optparse.OptionGroup(self.parser, _('Filtering options'))
+        filters.add_option('-l', '--limit',
+            help=_('Limit the number of messages to match'))
+        filters.add_option('-m', '--marker',
+            help=_('Only match messages that were inserted after this id'))
+        filters.add_option('-A', '--all', action='store_true',
+            help=_('Match all messages, including those that are hidden'))
+        choices = ['none', 'id', 'attributes', 'all']
+        filters.add_option('-d', '--detail', type='choice', choices=choices,
+            help=_('What message information to return. Options are: %s') %
+            ', '.join(choices))
+        self.parser.add_option_group(filters)
+
+    def run(self):
+        (self.options, args) = self.parser.parse_args()
+        if self.options.commands:
+            self.print_help()
+        if len(args) == 0:
+            self.print_help(_('No command given'))
+        if self.options.files is None:
+            files = []
+        else:
+            files = self.options.files.split(', ')
+        self.client = burrow.Client(url=self.options.url, config_files=files)
+        for section in self.sections:
+            if args[0] in section['commands']:
+                self.run_command(section, args[0], args[1:])
+        self.print_help(_('Command not found'))
+
+    def run_command(self, section, command, args):
+        if len(args) != len(section['args']):
+            self.print_help(_('Wrong number of arguments'))
+        if section.get('account', None):
+            args.insert(0, self.options.account)
+        if command in self.stdin_commands:
+            args.append(sys.stdin.read())
+        if command in self.attribute_commands:
+            attributes = {}
+            if self.options.ttl is not None:
+                attributes['ttl'] = self.options.ttl
+            if self.options.hide is not None:
+                attributes['hide'] = self.options.hide
+            args.append(attributes)
+        if section.get('filters', None):
+            filters = {}
+            if self.options.limit is not None:
+                filters['limit'] = self.options.limit
+            if self.options.marker is not None:
+                filters['marker'] = self.options.marker
+            if self.options.all is not None:
+                filters['match_hidden'] = self.options.all
+            args.append(filters)
+        getattr(self.client.backend, command)(*args)
+        sys.exit(0)
+
+    def print_help(self, message=None):
+        if message:
+            print message
+            print
+        self.parser.print_help()
+        print
+        for section in self.sections:
+            print '%s commands:' % section['name']
+            for command in section['commands']:
+                help = ''
+                if section.get('filters', None):
+                    help += ' [filters]'
+                if command in self.attribute_commands:
+                    help += ' [attributes]'
+                for arg in section['args']:
+                    help += ' <%s>' % arg
+                print '    %s%s' % (command, help)
+            print
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    Burrow().run()
 
=== modified file 'bin/burrowd'
--- bin/burrowd	2011-03-17 23:42:41 +0000
+++ bin/burrowd	2011-04-06 05:49:23 +0000
@@ -20,15 +20,15 @@
 import os
 import sys
 
-# If ../burrowd/__init__.py exists, add ../ to the Python search path so
+# If ../burrow/__init__.py exists, add ../ to the Python search path so
 # that it will override whatever may be installed in the default Python
 # search path.
 BASE_DIRECTORY = os.path.join(os.path.abspath(__file__), os.pardir, os.pardir)
 BASE_DIRECTORY = os.path.normpath(BASE_DIRECTORY)
-if os.path.exists(os.path.join(BASE_DIRECTORY, 'burrowd', '__init__.py')):
+if os.path.exists(os.path.join(BASE_DIRECTORY, 'burrow', '__init__.py')):
     sys.path.insert(0, BASE_DIRECTORY)
 
-import burrowd
+import burrow
 
 if __name__ == '__main__':
-    burrowd.Burrowd(sys.argv[1:]).run()
+    burrow.Server(sys.argv[1:]).run()
 
=== removed directory 'burrow'
=== renamed directory 'burrowd' => 'burrow'
=== removed file 'burrow/__init__.py'
--- burrow/__init__.py	2011-03-17 23:42:41 +0000
+++ burrow/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,19 +0,0 @@
-# Copyright (C) 2011 OpenStack LLC.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-'''Main client module for burrow.'''
-
-
-class Burrow(object):
-    pass
 
=== modified file 'burrow/__init__.py'
--- burrowd/__init__.py	2011-03-18 00:47:26 +0000
+++ burrow/__init__.py	2011-04-06 05:49:23 +0000
@@ -12,99 +12,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-'''Main server module for burrow.'''
+'''Main module for burrow.'''
 
-import ConfigParser
 import gettext
 import logging
-import logging.config
 import sys
 
-import eventlet
+from burrow.client import Client
+from burrow.server import Server
+import burrow.config
 
-import burrowd.config
+__version__ = '0.1'
 
 # This installs the _(...) function as a built-in so all other modules
 # don't need to.
 gettext.install('burrow')
 
-# Default configuration values for this module.
-DEFAULT_BACKEND = 'burrowd.backend.sqlite'
-DEFAULT_FRONTENDS = 'burrowd.frontend.wsgi'
-DEFAULT_THREAD_POOL_SIZE = 1000
-
-
-class Burrowd(object):
-    '''Server class for burrow.'''
-
-    def __init__(self, config_files=[], add_default_log_handler=True):
-        '''Initialize a server using the config files from the given
-        list. This is passed directly to ConfigParser.read(), so
-        files should be in ConfigParser format. This will load all
-        frontend and backend classes from the configuration.'''
-        if len(config_files) > 0:
-            logging.config.fileConfig(config_files)
-        self._config = ConfigParser.ConfigParser()
-        self._config.read(config_files)
-        self.config = burrowd.config.Config(self._config, 'burrowd')
-        self.log = get_logger(self.config)
-        if add_default_log_handler:
-            self._add_default_log_handler()
-        self._import_backend()
-        self._import_frontends()
-
-    def _add_default_log_handler(self):
-        '''Add a default log handler it one has not been set.'''
-        root_log = logging.getLogger()
-        if len(root_log.handlers) > 0 or len(self.log.handlers) > 0:
-            return
-        handler = logging.StreamHandler()
-        handler.setLevel(logging.DEBUG)
-        log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-        handler.setFormatter(logging.Formatter(log_format))
-        root_log.addHandler(handler)
-
-    def _import_backend(self):
-        '''Load backend given in the 'backend' option.'''
-        backend = self.config.get('backend', DEFAULT_BACKEND)
-        config = (self._config, backend)
-        self.backend = import_class(backend, 'Backend')(config)
-
-    def _import_frontends(self):
-        '''Load frontends given in the 'frontends' option.'''
-        self.frontends = []
-        frontends = self.config.get('frontends', DEFAULT_FRONTENDS)
-        for frontend in frontends.split(','):
-            frontend = frontend.split(':')
-            if len(frontend) == 1:
-                frontend.append(None)
-            config = (self._config, frontend[0], frontend[1])
-            frontend = import_class(frontend[0], 'Frontend')
-            frontend = frontend(config, self.backend)
-            self.frontends.append(frontend)
-
-    def run(self):
-        '''Create the thread pool and start the main server loop. Wait
-        for the pool to complete, but possibly run forever if the
-        frontends and backend never remove threads.'''
-        thread_pool_size = self.config.getint('thread_pool_size',
-            DEFAULT_THREAD_POOL_SIZE)
-        thread_pool = eventlet.GreenPool(size=int(thread_pool_size))
-        self.backend.run(thread_pool)
-        for frontend in self.frontends:
-            frontend.run(thread_pool)
-        self.log.info(_('Waiting for all threads to exit'))
-        try:
-            thread_pool.waitall()
-        except KeyboardInterrupt:
-            pass
-
 
 class Module(object):
     '''Common module class for burrow.'''
 
     def __init__(self, config):
-        self.config = burrowd.config.Config(*config)
+        self.config = burrow.config.Config(*config)
         self.log = get_logger(self.config)
         self.log.debug(_('Module created'))
 
 
=== modified file 'burrow/backend/__init__.py'
--- burrowd/backend/__init__.py	2011-03-17 23:42:41 +0000
+++ burrow/backend/__init__.py	2011-04-06 05:49:23 +0000
@@ -12,14 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-'''Backends for the burrow server.'''
+'''Backends for burrow.'''
 
 import eventlet
 
-import burrowd
-
-
-class Backend(burrowd.Module):
+import burrow
+
+
+class Backend(burrow.Module):
     '''Interface that backend implementations must provide.'''
 
     def __init__(self, config):
@@ -27,62 +27,52 @@
         self.queues = {}
 
     def run(self, thread_pool):
+        '''Run the backend. This should start any periodic tasks in
+        separate threads and should never block.'''
         thread_pool.spawn_n(self._clean)
 
-    def _clean(self):
-        while True:
-            self.clean()
-            eventlet.sleep(1)
-
-    def delete_accounts(self):
-        pass
-
-    def get_accounts(self):
-        return []
-
-    def delete_account(self, account):
-        pass
-
-    def get_queues(self, account):
-        return []
-
-    def queue_exists(self, account, queue):
-        return False
-
-    def delete_messages(self, account, queue, limit, marker, match_hidden):
-        return []
-
-    def get_messages(self, account, queue, limit, marker, match_hidden):
-        return []
-
-    def update_messages(self, account, queue, limit, marker, match_hidden, ttl,
-                        hide):
-        return []
-
-    def delete_message(self, account, queue, message_id):
-        return None
-
-    def get_message(self, account, queue, message_id):
-        return None
-
-    def put_message(self, account, queue, message_id, ttl, hide, body):
+    def delete_accounts(self, filters={}):
+        pass
+
+    def get_accounts(self, filters={}):
+        return []
+
+    def delete_queues(self, account, filters={}):
+        pass
+
+    def get_queues(self, account, filters={}):
+        return []
+
+    def delete_messages(self, account, queue, filters={}):
+        return []
+
+    def get_messages(self, account, queue, filters={}):
+        return []
+
+    def update_messages(self, account, queue, attributes={}, filters={}):
+        return []
+
+    def create_message(self, account, queue, message, body, attributes={}):
         return True
 
-    def update_message(self, account, queue, message_id, ttl, hide):
-        return None
-
-    def clean(self):
-        '''This method should remove all messages with an expired
-        TTL and make hidden messages that have an expired hide time
-        visible again.'''
-        pass
+    def delete_message(self, account, queue, message):
+        return None
+
+    def get_message(self, account, queue, message):
+        return None
+
+    def update_message(self, account, queue, message, attributes={}):
+        return None
 
     def notify(self, account, queue):
+        '''Notify any waiting callers that the account/queue has
+        a visible message.'''
         queue = '%s/%s' % (account, queue)
         if queue in self.queues:
             self.queues[queue].put(0)
 
     def wait(self, account, queue, seconds):
+        '''Wait for a message to appear in the account/queue.'''
         queue = '%s/%s' % (account, queue)
         if queue not in self.queues:
             self.queues[queue] = eventlet.Queue()
@@ -92,3 +82,15 @@
             pass
         if self.queues[queue].getting() == 0:
             del self.queues[queue]
+
+    def clean(self):
+        '''This method should remove all messages with an expired
+        TTL and make hidden messages that have an expired hide time
+        visible again.'''
+        pass
+
+    def _clean(self):
+        '''Thread to run the clean method periodically.'''
+        while True:
+            self.clean()
+            eventlet.sleep(1)
 
=== added file 'burrow/backend/http.py'
--- burrow/backend/http.py	1970-01-01 00:00:00 +0000
+++ burrow/backend/http.py	2011-04-06 05:49:23 +0000
@@ -0,0 +1,103 @@
+# Copyright (C) 2011 OpenStack LLC.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+'''HTTP backend for burrow using httplib.'''
+
+import httplib
+
+import burrow.backend
+
+
+class Backend(burrow.backend.Backend):
+    '''This backend forwards all requests via HTTP using the httplib
+    module. It is used for clients and proxies.'''
+
+    def __init__(self, config):
+        super(Backend, self).__init__(config)
+        self.server = ('localhost', 8080)
+
+    def delete_accounts(self, filters={}):
+        url = self._add_parameters('/', filters=filters)
+        self._request('DELETE', url)
+
+    def get_accounts(self, filters={}):
+        url = self._add_parameters('/', filters=filters)
+        self._request('GET', url)
+
+    def delete_queues(self, account, filters={}):
+        url = self._add_parameters('/%s' % account, filters=filters)
+        self._request('DELETE', url)
+
+    def get_queues(self, account, filters={}):
+        url = self._add_parameters('/%s' % account, filters=filters)
+        self._request('GET', url)
+
+    def delete_messages(self, account, queue, filters={}):
+        url = '/%s/%s' % (account, queue)
+        url = self._add_parameters(url, filters=filters)
+        self._request('DELETE', url)
+
+    def get_messages(self, account, queue, filters={}):
+        url = '/%s/%s' % (account, queue)
+        url = self._add_parameters(url, filters=filters)
+        self._request('GET', url)
+
+    def update_messages(self, account, queue, attributes={}, filters={}):
+        url = '/%s/%s' % (account, queue)
+        url = self._add_parameters(url, attributes, filters)
+        self._request('POST', url)
+
+    def create_message(self, account, queue, message, body, attributes={}):
+        url = '/%s/%s/%s' % (account, queue, message)
+        url = self._add_parameters(url, attributes)
+        self._request('PUT', url, body=body)
+
+    def delete_message(self, account, queue, message):
+        url = '/%s/%s/%s' % (account, queue, message)
+        self._request('DELETE', url)
+
+    def get_message(self, account, queue, message):
+        url = '/%s/%s/%s' % (account, queue, message)
+        self._request('GET', url)
+
+    def update_message(self, account, queue, message, attributes={}):
+        url = '/%s/%s/%s' % (account, queue, message)
+        url = self._add_parameters(url, attributes)
+        self._request('POST', url)
+
+    def clean(self):
+        pass
+
+    def _add_parameters(self, url, attributes={}, filters={}):
+        separator = '?'
+        for attribute in ['ttl', 'hide']:
+            value = attributes.get(attribute, None)
+            if value is not None:
+                url += '%s%s=%s' % (separator, attribute, value)
+                separator = '&'
+        for filter in ['marker', 'limit', 'match_hidden', 'detail']:
+            value = filters.get(filter, None)
+            if value is not None:
+                url += '%s%s=%s' % (separator, filter, value)
+                separator = '&'
+        return url
+
+    def _request(self, *args, **kwargs):
+        connection = httplib.HTTPConnection(*self.server)
+        connection.request(*args, **kwargs)
+        response = connection.getresponse()
+        if response.status == 200:
+            print response.read()
+        if response.status >= 400:
+            print response.reason
 
=== modified file 'burrow/backend/memory.py'
--- burrowd/backend/memory.py	2011-03-17 23:42:41 +0000
+++ burrow/backend/memory.py	2011-04-06 05:49:23 +0000
@@ -12,115 +12,117 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-'''Memory backend for the burrow server.'''
+'''Memory backend for burrow.'''
 
 import time
 
-import burrowd.backend
-
-
-class Backend(burrowd.backend.Backend):
+import burrow.backend
+
+
+class Backend(burrow.backend.Backend):
+    '''This backend stores all data using native Python data
+    structures. It uses a linked list of tuples to store data
+    (accounts, queues, and messages) with a dict as a secondary index
+    into this list. This is required so we can have O(1) appends,
+    deletes, and lookups by name, along with easy traversal starting
+    anywhere in the list.'''
 
     def __init__(self, config):
         super(Backend, self).__init__(config)
-        self.accounts = {}
-
-    def delete_accounts(self):
-        self.accounts.clear()
-
-    def get_accounts(self):
-        return self.accounts.keys()
-
-    def delete_account(self, account):
-        del self.accounts[account]
-
-    def get_queues(self, account):
-        if account not in self.accounts:
-            return []
-        return self.accounts[account].keys()
-
-    def queue_exists(self, account, queue):
-        return account in self.accounts and queue in self.accounts[account]
-
-    def delete_messages(self, account, queue, limit, marker, match_hidden):
-        messages = self._scan_queue(account, queue, limit, marker,
-            match_hidden, delete=True)
-        if len(self.accounts[account][queue]) == 0:
-            del self.accounts[account][queue]
-        if len(self.accounts[account]) == 0:
-            del self.accounts[account]
-        return messages
-
-    def get_messages(self, account, queue, limit, marker, match_hidden):
-        return self._scan_queue(account, queue, limit, marker, match_hidden)
-
-    def update_messages(self, account, queue, limit, marker, match_hidden, ttl,
-                        hide):
-        return self._scan_queue(account, queue, limit, marker, match_hidden,
-                                ttl=ttl, hide=hide)
-
-    def delete_message(self, account, queue, message_id):
-        for index in range(0, len(self.accounts[account][queue])):
-            message = self.accounts[account][queue][index]
-            if message['id'] == message_id:
-                del self.accounts[account][queue][index]
-                if len(self.accounts[account][queue]) == 0:
-                    del self.accounts[account][queue]
-                if len(self.accounts[account]) == 0:
-                    del self.accounts[account]
-                return message
-        return None
-
-    def get_message(self, account, queue, message_id):
-        for index in range(0, len(self.accounts[account][queue])):
-            message = self.accounts[account][queue][index]
-            if message['id'] == message_id:
-                return message
-        return None
-
-    def put_message(self, account, queue, message_id, ttl, hide, body):
-        if account not in self.accounts:
-            self.accounts[account] = {}
-        if queue not in self.accounts[account]:
-            self.accounts[account][queue] = []
-        for index in range(0, len(self.accounts[account][queue])):
-            message = self.accounts[account][queue][index]
-            if message['id'] == message_id:
+        self.accounts = Accounts()
+
+    def delete_accounts(self, filters={}):
+        self.accounts.delete(filters)
+
+    def get_accounts(self, filters={}):
+        for account in self.accounts.iter(filters):
+            yield account[0]
+
+    def delete_queues(self, account, filters={}):
+        self.accounts.delete_queues(account, filters)
+
+    def get_queues(self, account, filters={}):
+        for queue in self.accounts.iter_queues(account, filters):
+            yield queue[0]
+
+    def delete_messages(self, account, queue, filters={}):
+        return self._scan_queue(account, queue, filters, delete=True)
+
+    def get_messages(self, account, queue, filters={}):
+        return self._scan_queue(account, queue, filters)
+
+    def update_messages(self, account, queue, attributes={}, filters={}):
+        return self._scan_queue(account, queue, filters, attributes)
+
+    def create_message(self, account, queue, message, body, attributes={}):
+        account, queue = self.accounts.get_queue(account, queue, True)
+        ttl = attributes.get('ttl', 0)
+        hide = attributes.get('hide', 0)
+        for index in xrange(0, len(queue[3])):
+            if queue[3][index]['id'] == message:
+                message = queue[3][index]
                 message['ttl'] = ttl
                 message['hide'] = hide
                 message['body'] = body
                 if hide == 0:
-                    self.notify(account, queue)
+                    self.notify(account[0], queue[0])
                 return False
-        message = dict(id=message_id, ttl=ttl, hide=hide, body=body)
-        self.accounts[account][queue].append(message)
-        self.notify(account, queue)
+        message = dict(id=message, ttl=ttl, hide=hide, body=body)
+        queue[3].append(message)
+        self.notify(account[0], queue[0])
         return True
 
-    def update_message(self, account, queue, message_id, ttl, hide):
-        for index in range(0, len(self.accounts[account][queue])):
-            message = self.accounts[account][queue][index]
-            if message['id'] == message_id:
+    def delete_message(self, account, queue, message):
+        account, queue = self.accounts.get_queue(account, queue)
+        if queue is None:
+            return None
+        for index in xrange(0, len(queue[3])):
+            if queue[3][index]['id'] == message:
+                message = queue[3][index]
+                del queue[3][index]
+                if len(queue[3]) == 0:
+                    self.accounts.delete_queue(account[0], queue[0])
+                return message
+        return None
+
+    def get_message(self, account, queue, message):
+        account, queue = self.accounts.get_queue(account, queue)
+        if queue is None:
+            return None
+        for index in xrange(0, len(queue[3])):
+            if queue[3][index]['id'] == message:
+                return queue[3][index]
+        return None
+
+    def update_message(self, account, queue, message, attributes={}):
+        account, queue = self.accounts.get_queue(account, queue)
+        if queue is None:
+            return None
+        ttl = attributes.get('ttl', None)
+        hide = attributes.get('hide', None)
+        for index in xrange(0, len(queue[3])):
+            if queue[3][index]['id'] == message:
+                message = queue[3][index]
                 if ttl is not None:
                     message['ttl'] = ttl
                 if hide is not None:
                     message['hide'] = hide
                     if hide == 0:
-                        self.notify(account, queue)
+                        self.notify(account[0], queue[0])
                 return message
         return None
 
     def clean(self):
         now = int(time.time())
-        for account in self.accounts.keys():
-            for queue in self.accounts[account].keys():
+        for account in self.accounts.iter():
+            for queue in account[3].iter():
                 index = 0
                 notify = False
-                total = len(self.accounts[account][queue])
+                total = len(queue[3])
                 while index < total:
-                    message = self.accounts[account][queue][index]
+                    message = queue[3][index]
                     if 0 < message['ttl'] <= now:
-                        del self.accounts[account][queue][index]
+                        del queue[3][index]
                         total -= 1
                     else:
                         if 0 < message['hide'] <= now:
@@ -128,30 +130,35 @@
                             notify = True
                         index += 1
                 if notify:
-                    self.notify(account, queue)
-                if len(self.accounts[account][queue]) == 0:
-                    del self.accounts[account][queue]
-            if len(self.accounts[account]) == 0:
-                del self.accounts[account]
+                    self.notify(account[0], queue[0])
+                if len(queue[3]) == 0:
+                    self.accounts.delete_queue(account[0], queue[0])
 
-    def _scan_queue(self, account, queue, limit, marker, match_hidden,
-                    ttl=None, hide=None, delete=False):
+    def _scan_queue(self, account, queue, filters, attributes={},
+        delete=False):
+        account, queue = self.accounts.get_queue(account, queue)
+        if queue is None:
+            return
         index = 0
         notify = False
-        if marker is not None:
+        if 'marker' in filters and filters['marker'] is not None:
             found = False
-            for index in range(0, len(self.accounts[account][queue])):
-                message = self.accounts[account][queue][index]
-                if message['id'] == marker:
+            for index in xrange(0, len(queue[3])):
+                message = queue[3][index]
+                if message['id'] == filters['marker']:
                     index += 1
                     found = True
                     break
             if not found:
                 index = 0
         messages = []
-        total = len(self.accounts[account][queue])
+        total = len(queue[3])
+        limit = filters.get('limit', None)
+        match_hidden = filters.get('match_hidden', False)
+        ttl = attributes.get('ttl', None)
+        hide = attributes.get('hide', None)
         while index < total:
-            message = self.accounts[account][queue][index]
+            message = queue[3][index]
             if not match_hidden and message['hide'] != 0:
                 index += 1
                 continue
@@ -162,15 +169,126 @@
                 if hide == 0:
                     notify = True
             if delete:
-                del self.accounts[account][queue][index]
+                del queue[3][index]
                 total -= 1
             else:
                 index += 1
-            messages.append(message)
+            yield message
             if limit:
                 limit -= 1
                 if limit == 0:
                     break
         if notify:
-            self.notify(account, queue)
-        return messages
+            self.notify(account[0], queue[0])
+        if len(queue[3]) == 0:
+            self.accounts.delete_queue(account[0], queue[0])
+
+
+class IndexedTupleList(object):
+    '''Class for managing an indexed tuple list. The tuple must be at
+    least three elements and must reserve the first three for (name,
+    next, previous).'''
+
+    def __init__(self):
+        self.first = None
+        self.last = None
+        self.index = {}
+
+    def add(self, item):
+        item = (item[0], None, self.last) + item[3:]
+        if self.first is None:
+            self.first = item
+        self.last = item
+        self.index[item[0]] = item
+        return item
+
+    def count(self):
+        return len(self.index)
+
+    def delete(self, filters):
+        if len(filters) == 0:
+            self.first = None
+            self.last = None
+            self.index.clear()
+            return
+        for item in self.iter(filters):
+            self.delete_item(item[0])
+
+    def delete_item(self, name):
+        if name not in self.index:
+            return
+        item = self.index[name][1]
+        if item is not None:
+            prev_item = self.index[name][2]
+            self.index[item[0]] = (item[0], item[1], prev_item) + item[3:]
+        item = self.index[name][2]
+        if item is not None:
+            next_item = self.index[name][1]
+            self.index[item[0]] = (item[0], next_item, item[2]) + item[3:]
+        if self.first == self.index[name]:
+            self.first = self.index[name][1]
+        if self.last == self.index[name]:
+            self.last = self.index[name][2]
+        del self.index[name]
+
+    def get(self, name):
+        if name in self.index:
+            return self.index[name]
+        return None
+
+    def iter(self, filters={}):
+        marker = filters.get('marker', None)
+        if marker is not None and marker in self.index:
+            item = self.index[marker]
+        else:
+            item = self.first
+        limit = filters.get('limit', None)
+        while item is not None:
+            yield item
+            if limit:
+                limit -= 1
+                if limit == 0:
+                    break
+            item = item[1]
+
+
+class Accounts(IndexedTupleList):
+
+    def delete_queue(self, account, queue):
+        account = self.get(account)
+        if account is not None:
+            account[3].delete_item(queue)
+            if account[3].count() == 0:
+                self.delete_item(account[0])
+
+    def delete_queues(self, account, filters):
+        account = self.get(account)
+        if account is not None:
+            account[3].delete(filters)
+            if account[3].count() == 0:
+                self.delete_item(account[0])
+
+    def get_queue(self, account, queue, create=False):
+        if account in self.index:
+            account = self.index[account]
+        elif create:
+            account = self.add((account, None, None, Queues()))
+        else:
+            return None, None
+        return account, account[3].get(queue, create)
+
+    def iter_queues(self, account, filters={}):
+        account = self.get(account)
+        if account is not None:
+            for queue in account[3].iter(filters):
+                yield queue
+
+
+class Queues(IndexedTupleList):
+
+    def get(self, queue, create=False):
+        if queue in self.index:
+            return self.index[queue]
+        elif create:
+            return self.add((queue, None, None, []))
+        return None
 
=== modified file 'burrow/backend/sqlite.py'
--- burrowd/backend/sqlite.py	2011-03-17 23:42:41 +0000
+++ burrow/backend/sqlite.py	2011-04-06 05:49:23 +0000
@@ -12,23 +12,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-'''Memory backend for the burrow server.'''
+'''SQLite backend for burrow.'''
 
 import sqlite3
 import time
 
-import burrowd.backend
+import burrow.backend
 
 # Default configuration values for this module.
 DEFAULT_DATABASE = ':memory:'
 
 
-class Backend(burrowd.backend.Backend):
+class Backend(burrow.backend.Backend):
 
     def __init__(self, config):
         super(Backend, self).__init__(config)
         database = self.config.get('database', DEFAULT_DATABASE)
         self.db = sqlite3.connect(database)
+        self.db.isolation_level = None
         queries = [
             'CREATE TABLE queues ('
                 'account VARCHAR(255) NOT NULL,'
@@ -44,129 +45,97 @@
         for query in queries:
             self.db.execute(query)
 
-    def delete_accounts(self):
-        self.db.execute("DELETE FROM queues")
-        self.db.execute("DELETE FROM messages")
-
-    def get_accounts(self):
-        result = self.db.execute("SELECT account FROM queues").fetchall()
-        return [row[0] for row in result]
-
-    def delete_account(self, account):
-        query = "SELECT rowid FROM queues WHERE account='%s'" % account
-        result = self.db.execute(query).fetchall()
-        if len(result) == 0:
+    def delete_accounts(self, filters={}):
+        if len(filters) == 0:
+            self.db.execute('DELETE FROM queues')
+            self.db.execute('DELETE FROM messages')
             return
-        queues = [str(queue[0]) for queue in result]
-        query = "DELETE FROM messages WHERE queue IN (%s)" % (','.join(queues))
-        self.db.execute(query)
-        self.db.execute("DELETE FROM queues WHERE account='%s'" % account)
-
-    def get_queues(self, account):
-        query = "SELECT queue FROM queues WHERE account='%s'" % account
-        result = self.db.execute(query).fetchall()
-        return [row[0] for row in result]
-
-    def queue_exists(self, account, queue):
-        query = "SELECT COUNT(*) FROM queues " \
-            "WHERE account='%s' AND queue='%s'" % \
-            (account, queue)
-        result = self.db.execute(query).fetchall()
-        if len(result) == 0:
-            return False
-        self.rowid = result[0][0]
-        return True
-
-    def delete_messages(self, account, queue, limit, marker, match_hidden):
-        messages = self.get_messages(account, queue, limit, marker,
-            match_hidden)
-        ids = [message['id'] for message in messages]
-        query = "DELETE FROM messages WHERE queue=%d AND name IN (%s)" % \
-            (self.rowid, ','.join(ids))
-        self.db.execute(query)
-        query = "SELECT rowid FROM messages WHERE queue=%d LIMIT 1" % \
-            self.rowid
-        if len(self.db.execute(query).fetchall()) == 0:
-            query = "DELETE FROM queues WHERE rowid=%d" % self.rowid
-            self.db.execute(query)
-        return messages
-
-    def get_messages(self, account, queue, limit, marker, match_hidden):
-        if marker is not None:
-            query = "SELECT rowid FROM messages " \
-                "WHERE queue=%d AND name='%s'" % \
-                (self.rowid, marker)
-            result = self.db.execute(query).fetchall()
-            if len(result) == 0:
-                marker = None
-            else:
-                marker = result[0][0]
-        query = "SELECT name,ttl,hide,body FROM messages WHERE queue=%d" % \
-            self.rowid
-        if match_hidden is False:
-            query += " AND hide == 0"
-        if marker is not None:
-            query += " AND rowid > %d" % marker
+
+    def get_accounts(self, filters={}):
+        query = 'SELECT DISTINCT account FROM queues'
+        values = tuple()
+        marker = filters.get('marker', None)
+        if marker is not None:
+            query += ' WHERE account > ?'
+            values += (marker,)
+        limit = filters.get('limit', None)
         if limit is not None:
-            query += " LIMIT %d" % limit
-        result = self.db.execute(query).fetchall()
-        messages = []
-        for row in result:
-            messages.append(dict(id=row[0], ttl=row[1], hide=row[2],
-                body=row[3]))
-        return messages
-
-    def update_messages(self, account, queue, limit, marker, match_hidden, ttl,
-                        hide):
-        messages = self.get_messages(account, queue, limit, marker,
-            match_hidden)
-        query = "UPDATE messages SET"
-        comma = ''
-        if ttl is not None:
-            query += "%s ttl=%d" % (comma, ttl)
-            comma = ','
-        if hide is not None:
-            query += "%s hide=%d" % (comma, hide)
-            comma = ','
-        if comma == '':
-            return (False, message)
-        ids = []
-        for message in messages:
+            query += ' LIMIT ?'
+            values += (limit,)
+        for row in self.db.execute(query, values):
+            yield row[0]
+
+    def delete_queues(self, account, filters={}):
+        query = 'SELECT rowid FROM queues WHERE account=?'
+        ids = []
+        for row in self.db.execute(query, (account,)):
+            ids.append(str(row[0]))
+        if len(ids) == 0:
+            return
+        query = 'DELETE FROM messages WHERE queue IN (%s)'
+        self.db.execute(query % ','.join(ids))
+        self.db.execute('DELETE FROM queues WHERE account=?', (account,))
+
+    def get_queues(self, account, filters={}):
+        query = 'SELECT queue FROM queues WHERE account=?'
+        for row in self.db.execute(query, (account,)):
+            yield row[0]
+
+    def delete_messages(self, account, queue, filters={}):
+        result = self._get_messages(account, queue, filters)
+        rowid = result.next()
+        ids = []
+        for message in result:
+            ids.append(message['id'])
+            yield message
+        if len(ids) == 0:
+            return
+        query = 'DELETE FROM messages WHERE queue=%d AND name IN (%s)'
+        self.db.execute(query % (rowid, ','.join(ids)))
+        query = 'SELECT rowid FROM messages WHERE queue=? LIMIT 1'
+        if len(self.db.execute(query, (rowid,)).fetchall()) == 0:
+            query = 'DELETE FROM queues WHERE rowid=?'
+            self.db.execute(query, (rowid,))
+
+    def get_messages(self, account, queue, filters={}):
+        result = self._get_messages(account, queue, filters)
+        rowid = result.next()
+        return result
+
+    def update_messages(self, account, queue, attributes={}, filters={}):
+        result = self._get_messages(account, queue, filters)
+        rowid = result.next()
+        ids = []
+        ttl = attributes.get('ttl', None)
+        hide = attributes.get('hide', None)
+        for message in result:
             ids.append(message['id'])
             if ttl is not None:
                 message['ttl'] = ttl
             if hide is not None:
                 message['hide'] = hide
-        query += " WHERE queue=%d AND name IN (%s)" % \
-            (self.rowid, ','.join(ids))
-        self.db.execute(query)
+            yield message
+        if len(ids) == 0:
+            return
+        query = 'UPDATE messages SET'
+        comma = ''
+        values = tuple()
+        if ttl is not None:
+            query += '%s ttl=?' % comma
+            values += (ttl,)
+            comma = ','
+        if hide is not None:
+            query += '%s hide=?' % comma
+            values += (hide,)
+            comma = ','
+        if comma == '':
+            return
+        values += (rowid,)
+        query += ' WHERE queue=? AND name IN (%s)'
+        self.db.execute(query % ','.join(ids), values)
         self.notify(account, queue)
-        return messages
-
-    def delete_message(self, account, queue, message_id):
-        message = self.get_message(account, queue, message_id)
-        if message is None:
-            return None
-        query = "DELETE FROM messages WHERE queue=%d AND name='%s'" % \
-            (self.rowid, message_id)
-        self.db.execute(query)
-        query = "SELECT rowid FROM messages WHERE queue=%d LIMIT 1" % \
-            self.rowid
-        if len(self.db.execute(query).fetchall()) == 0:
-            query = "DELETE FROM queues WHERE rowid=%d" % self.rowid
-            self.db.execute(query)
-        return message
-
-    def get_message(self, account, queue, message_id):
-        query = "SELECT name,ttl,hide,body FROM messages " \
-            "WHERE queue=%d AND name='%s'" % (self.rowid, message_id)
-        result = self.db.execute(query).fetchall()
-        if len(result) == 0:
-            return None
-        row = result[0]
-        return dict(id=row[0], ttl=row[1], hide=row[2], body=row[3])
-
-    def put_message(self, account, queue, message_id, ttl, hide, body):
+
+    def create_message(self, account, queue, message, body, attributes):
         query = "SELECT rowid FROM queues " \
             "WHERE account='%s' AND queue='%s'" % (account, queue)
         result = self.db.execute(query).fetchall()
@@ -176,11 +145,13 @@
         else:
             rowid = result[0][0]
         query = "SELECT rowid FROM messages WHERE queue=%d AND name='%s'" % \
-            (rowid, message_id)
+            (rowid, message)
         result = self.db.execute(query).fetchall()
+        ttl = attributes.get('ttl', 0)
+        hide = attributes.get('hide', 0)
         if len(result) == 0:
             query = "INSERT INTO messages VALUES (%d, '%s', %d, %d, '%s')" % \
-                (rowid, message_id, ttl, hide, body)
+                (rowid, message, ttl, hide, body)
             self.db.execute(query)
             self.notify(account, queue)
             return True
@@ -191,12 +162,45 @@
             self.notify(account, queue)
         return False
 
-    def update_message(self, account, queue, message_id, ttl, hide):
-        message = self.get_message(account, queue, message_id)
+    def delete_message(self, account, queue, message):
+        rowid = self._get_queue(account, queue)
+        if rowid is None:
+            return None
+        message = self.get_message(account, queue, message)
+        if message is None:
+            return None
+        query = "DELETE FROM messages WHERE queue=%d AND name='%s'" % \
+            (rowid, message['id'])
+        self.db.execute(query)
+        query = "SELECT rowid FROM messages WHERE queue=%d LIMIT 1" % rowid
+        if len(self.db.execute(query).fetchall()) == 0:
+            query = "DELETE FROM queues WHERE rowid=%d" % rowid
+            self.db.execute(query)
+        return message
+
+    def get_message(self, account, queue, message):
+        rowid = self._get_queue(account, queue)
+        if rowid is None:
+            return None
+        query = "SELECT name,ttl,hide,body FROM messages " \
+            "WHERE queue=%d AND name='%s'" % (rowid, message)
+        result = self.db.execute(query).fetchall()
+        if len(result) == 0:
+            return None
+        row = result[0]
+        return dict(id=row[0], ttl=row[1], hide=row[2], body=row[3])
+
+    def update_message(self, account, queue, message, attributes):
+        rowid = self._get_queue(account, queue)
+        if rowid is None:
+            return None
+        message = self.get_message(account, queue, message)
         if message is None:
             return None
         query = "UPDATE messages SET"
         comma = ''
+        ttl = attributes.get('ttl', None)
+        hide = attributes.get('hide', None)
         if ttl is not None:
             query += "%s ttl=%d" % (comma, ttl)
             comma = ','
@@ -205,7 +209,7 @@
             comma = ','
         if comma == '':
             return message
-        query += " WHERE queue=%d AND name='%s'" % (self.rowid, message_id)
+        query += " WHERE queue=%d AND name='%s'" % (rowid, message['id'])
         self.db.execute(query)
         if hide == 0:
             self.notify(account, queue)
@@ -248,3 +252,36 @@
                     queue
                 result = self.db.execute(query).fetchall()[0]
                 self.notify(result[0], result[1])
+
+    def _get_queue(self, account, queue):
+        query = "SELECT COUNT(*) FROM queues " \
+            "WHERE account='%s' AND queue='%s'" % \
+            (account, queue)
+        result = self.db.execute(query).fetchall()
+        if len(result) == 0:
+            return None
+        return result[0][0]
+
+    def _get_messages(self, account, queue, filters):
+        rowid = self._get_queue(account, queue)
+        yield rowid
+        if rowid is None:
+            return
+        marker = None
+        if 'marker' in filters and filters['marker'] is not None:
+            query = "SELECT rowid FROM messages " \
+                "WHERE queue=%d AND name='%s'" % (rowid, filters['marker'])
+            result = self.db.execute(query).fetchall()
+            if len(result) > 0:
+                marker = result[0][0]
+        query = "SELECT name,ttl,hide,body FROM messages WHERE queue=%d" % \
+            rowid
+        if marker is not None:
+            query += " AND rowid > %d" % marker
+        if 'match_hidden' not in filters or filters['match_hidden'] is False:
+            query += " AND hide == 0"
+        if 'limit' in filters and filters['limit'] is not None:
+            query += " LIMIT %d" % filters['limit']
+        result = self.db.execute(query).fetchall()
+        for row in result:
+            yield dict(id=row[0], ttl=row[1], hide=row[2], body=row[3])
 
=== added file 'burrow/client.py'
--- burrow/client.py	1970-01-01 00:00:00 +0000
+++ burrow/client.py	2011-04-06 05:49:23 +0000
@@ -0,0 +1,63 @@
+# Copyright (C) 2011 OpenStack LLC.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+'''Client module for burrow.'''
+
+import ConfigParser
+import logging
+import logging.config
+
+import burrow
+import burrow.config
+
+# Default configuration values for this module.
+DEFAULT_BACKEND = 'burrow.backend.http'
+
+
+class Client(object):
+    '''Client class for burrow.'''
+
+    def __init__(self, url=None, config_files=[],
+        add_default_log_handler=True):
+        '''Initialize a client using the URL and config files from the
+        given list. This is passed directly to ConfigParser.read(),
+        so files should be in ConfigParser format. This will load
+        all the backend class from the configuration.'''
+        if len(config_files) > 0:
+            logging.config.fileConfig(config_files)
+        self._config = ConfigParser.ConfigParser()
+        self._config.read(config_files)
+        # TODO: Parse URL if given and overwrite any values in self._config.
+        self.config = burrow.config.Config(self._config, 'burrow.client')
+        self.log = burrow.get_logger(self.config)
+        if add_default_log_handler:
+            self._add_default_log_handler()
+        self._import_backend()
+
+    def _add_default_log_handler(self):
+        '''Add a default log handler it one has not been set.'''
+        root_log = logging.getLogger()
+        if len(root_log.handlers) > 0 or len(self.log.handlers) > 0:
+            return
+        handler = logging.StreamHandler()
+        handler.setLevel(logging.ERROR)
+        log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        handler.setFormatter(logging.Formatter(log_format))
+        root_log.addHandler(handler)
+
+    def _import_backend(self):
+        '''Load backend given in the 'backend' option.'''
+        backend = self.config.get('backend', DEFAULT_BACKEND)
+        config = (self._config, backend)
+        self.backend = burrow.import_class(backend, 'Backend')(config)
 
=== modified file 'burrow/config.py'
--- burrowd/config.py	2011-03-17 23:42:41 +0000
+++ burrow/config.py	2011-04-06 05:49:23 +0000
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-'''Configuration module for the burrow server.'''
+'''Configuration module for burrow.'''
 
 import ConfigParser
 
 
=== modified file 'burrow/frontend/__init__.py'
--- burrowd/frontend/__init__.py	2011-03-17 23:42:41 +0000
+++ burrow/frontend/__init__.py	2011-04-06 05:49:23 +0000
@@ -12,12 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-'''Frontends for the burrow server.'''
-
-import burrowd
-
-
-class Frontend(burrowd.Module):
+'''Frontends for burrow.'''
+
+import burrow
+
+
+class Frontend(burrow.Module):
     '''Interface that frontend implementations must provide.'''
 
     def __init__(self, config, backend):
 
=== modified file 'burrow/frontend/wsgi.py'
--- burrowd/frontend/wsgi.py	2011-03-17 23:42:41 +0000
+++ burrow/frontend/wsgi.py	2011-04-06 05:49:23 +0000
@@ -24,7 +24,7 @@
 import webob.dec
 import webob.exc
 
-import burrowd.frontend
+import burrow.frontend
 
 # Default configuration values for this module.
 DEFAULT_HOST = '0.0.0.0'
@@ -38,20 +38,18 @@
 DEFAULT_HIDE = 0
 
 
-def queue_exists(method):
-    '''Decorator to ensure an account and queue exists. If the wait
-    option is given, this will block until a message in the queue is
-    ready or the timeout expires.'''
+def wait_on_queue(method):
+    '''Decorator to wait on an account/queue if the wait option is
+    given. This will block until a message in the queue is ready or
+    the timeout expires.'''
     def wrapper(self, req, account, queue, *args, **kwargs):
         wait = 0
         if 'wait' in req.params:
             wait = int(req.params['wait'])
             if wait > 0:
                 wait += time.time()
-        res = webob.exc.HTTPNotFound()
         while True:
-            if self.backend.queue_exists(account, queue):
-                res = method(self, req, account, queue, *args, **kwargs)
+            res = method(self, req, account, queue, *args, **kwargs)
             if wait == 0 or res.status_int != 404:
                 break
             now = time.time()
@@ -63,7 +61,7 @@
     return wrapper
 
 
-class Frontend(burrowd.frontend.Frontend):
+class Frontend(burrow.frontend.Frontend):
 
     def __init__(self, config, backend):
         super(Frontend, self).__init__(config, backend)
@@ -73,7 +71,7 @@
         mapper.connect('/', action='root')
         mapper.connect('/{account}', action='account')
         mapper.connect('/{account}/{queue}', action='queue')
-        mapper.connect('/{account}/{queue}/{message_id}', action='message')
+        mapper.connect('/{account}/{queue}/{message}', action='message')
         self._routes = routes.middleware.RoutesMiddleware(self._route, mapper)
 
     def run(self, thread_pool):
@@ -121,85 +119,86 @@
 
     @webob.dec.wsgify
     def _delete_root(self, req):
-        self.backend.delete_accounts()
+        filters = self._parse_filters(req)
+        self.backend.delete_accounts(filters)
         return webob.exc.HTTPNoContent()
 
     @webob.dec.wsgify
     def _get_root(self, req):
-        accounts = self.backend.get_accounts()
+        filters = self._parse_filters(req)
+        accounts = [account for account in self.backend.get_accounts(filters)]
         if len(accounts) == 0:
             return webob.exc.HTTPNotFound()
         return webob.exc.HTTPOk(body=json.dumps(accounts, indent=2))
 
     @webob.dec.wsgify
     def _delete_account(self, req, account):
-        self.backend.delete_account(account)
+        filters = self._parse_filters(req)
+        self.backend.delete_queues(account, filters)
         return webob.exc.HTTPNoContent()
 
     @webob.dec.wsgify
     def _get_account(self, req, account):
-        queues = self.backend.get_queues(account)
+        filters = self._parse_filters(req)
+        queues = [queue for queue in self.backend.get_queues(account, filters)]
         if len(queues) == 0:
             return webob.exc.HTTPNotFound()
         return webob.exc.HTTPOk(body=json.dumps(queues, indent=2))
 
     @webob.dec.wsgify
-    @queue_exists
+    @wait_on_queue
     def _delete_queue(self, req, account, queue):
-        limit, marker, match_hidden = self._parse_filters(req)
-        messages = self.backend.delete_messages(account, queue, limit, marker,
-            match_hidden)
+        filters = self._parse_filters(req)
+        messages = [message for message in
+            self.backend.delete_messages(account, queue, filters)]
         return self._return_messages(req, account, queue, messages, 'none')
 
     @webob.dec.wsgify
-    @queue_exists
+    @wait_on_queue
     def _get_queue(self, req, account, queue):
-        limit, marker, match_hidden = self._parse_filters(req)
-        messages = self.backend.get_messages(account, queue, limit, marker,
-            match_hidden)
+        filters = self._parse_filters(req)
+        messages = [message for message in
+            self.backend.get_messages(account, queue, filters)]
         return self._return_messages(req, account, queue, messages, 'all')
 
     @webob.dec.wsgify
-    @queue_exists
+    @wait_on_queue
     def _post_queue(self, req, account, queue):
-        limit, marker, match_hidden = self._parse_filters(req)
-        ttl, hide = self._parse_metadata(req)
-        messages = self.backend.update_messages(account, queue, limit, marker,
-            match_hidden, ttl, hide)
+        attributes = self._parse_attributes(req)
+        filters = self._parse_filters(req)
+        messages = [message for message in
+            self.backend.update_messages(account, queue, attributes, filters)]
         return self._return_messages(req, account, queue, messages, 'all')
 
     @webob.dec.wsgify
-    @queue_exists
-    def _delete_message(self, req, account, queue, message_id):
-        message = self.backend.delete_message(account, queue, message_id)
+    def _delete_message(self, req, account, queue, message):
+        message = self.backend.delete_message(account, queue, message)
         if message is None:
             return webob.exc.HTTPNotFound()
         return self._return_message(req, account, queue, message, 'none')
 
     @webob.dec.wsgify
-    @queue_exists
-    def _get_message(self, req, account, queue, message_id):
-        message = self.backend.get_message(account, queue, message_id)
+    def _get_message(self, req, account, queue, message):
+        message = self.backend.get_message(account, queue, message)
         if message is None:
             return webob.exc.HTTPNotFound()
         return self._return_message(req, account, queue, message, 'all')
 
     @webob.dec.wsgify
-    @queue_exists
-    def _post_message(self, req, account, queue, message_id):
-        ttl, hide = self._parse_metadata(req)
-        message = self.backend.update_message(account, queue, message_id, ttl,
-                                              hide)
+    def _post_message(self, req, account, queue, message):
+        attributes = self._parse_attributes(req)
+        message = self.backend.update_message(account, queue, message,
+            attributes)
         if message is None:
             return webob.exc.HTTPNotFound()
         return self._return_message(req, account, queue, message, 'id')
 
     @webob.dec.wsgify
-    def _put_message(self, req, account, queue, message_id):
-        (ttl, hide) = self._parse_metadata(req, self.default_ttl,
-                                           self.default_hide)
-        if self.backend.put_message(account, queue, message_id, ttl, hide, \
-                                    req.body):
+    def _put_message(self, req, account, queue, message):
+        attributes = self._parse_attributes(req, self.default_ttl,
+            self.default_hide)
+        if self.backend.create_message(account, queue, message, req.body,
+            attributes):
             return webob.exc.HTTPCreated()
         return webob.exc.HTTPNoContent()
 
@@ -239,31 +238,32 @@
         return webob.exc.HTTPOk(body=json.dumps(body, indent=2))
 
     def _parse_filters(self, req):
-        limit = None
+        filters = {}
         if 'limit' in req.params:
-            limit = int(req.params['limit'])
-        marker = None
+            filters['limit'] = int(req.params['limit'])
         if 'marker' in req.params:
-            marker = req.params['marker']
-        match_hidden = False
+            filters['marker'] = req.params['marker']
         if 'hidden' in req.params and req.params['hidden'].lower() == 'true':
-            match_hidden = True
-        return limit, marker, match_hidden
+            filters['match_hidden'] = True
+        return filters
 
-    def _parse_metadata(self, req, default_ttl=None, default_hide=None):
+    def _parse_attributes(self, req, default_ttl=None, default_hide=None):
+        attributes = {}
         if 'ttl' in req.params:
             ttl = int(req.params['ttl'])
         else:
             ttl = default_ttl
         if ttl is not None and ttl > 0:
             ttl += int(time.time())
+        attributes['ttl'] = ttl
         if 'hide' in req.params:
             hide = int(req.params['hide'])
         else:
             hide = default_hide
         if hide is not None and hide > 0:
             hide += int(time.time())
-        return ttl, hide
+        attributes['hide'] = hide
+        return attributes
 
 
 class WSGILog(object):
 
=== added file 'burrow/server.py'
--- burrow/server.py	1970-01-01 00:00:00 +0000
+++ burrow/server.py	2011-04-06 05:49:23 +0000
@@ -0,0 +1,95 @@
+# Copyright (C) 2011 OpenStack LLC.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+'''Server module for burrow.'''
+
+import ConfigParser
+import logging
+import logging.config
+
+import eventlet
+
+import burrow
+import burrow.config
+
+# Default configuration values for this module.
+DEFAULT_BACKEND = 'burrow.backend.sqlite'
+DEFAULT_FRONTENDS = 'burrow.frontend.wsgi'
+DEFAULT_THREAD_POOL_SIZE = 1000
+
+
+class Server(object):
+    '''Server class for burrow.'''
+
+    def __init__(self, config_files=[], add_default_log_handler=True):
+        '''Initialize a server using the config files from the given
+        list. This is passed directly to ConfigParser.read(), so
+        files should be in ConfigParser format. This will load all
+        frontend and backend classes from the configuration.'''
+        if len(config_files) > 0:
+            logging.config.fileConfig(config_files)
+        self._config = ConfigParser.ConfigParser()
+        self._config.read(config_files)
+        self.config = burrow.config.Config(self._config, 'burrow.server')
+        self.log = burrow.get_logger(self.config)
+        if add_default_log_handler:
+            self._add_default_log_handler()
+        self._import_backend()
+        self._import_frontends()
+
+    def _add_default_log_handler(self):
+        '''Add a default log handler it one has not been set.'''
+        root_log = logging.getLogger()
+        if len(root_log.handlers) > 0 or len(self.log.handlers) > 0:
+            return
+        handler = logging.StreamHandler()
+        handler.setLevel(logging.DEBUG)
+        log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        handler.setFormatter(logging.Formatter(log_format))
+        root_log.addHandler(handler)
+
+    def _import_backend(self):
+        '''Load backend given in the 'backend' option.'''
+        backend = self.config.get('backend', DEFAULT_BACKEND)
+        config = (self._config, backend)
+        self.backend = burrow.import_class(backend, 'Backend')(config)
+
+    def _import_frontends(self):
+        '''Load frontends given in the 'frontends' option.'''
+        self.frontends = []
+        frontends = self.config.get('frontends', DEFAULT_FRONTENDS)
+        for frontend in frontends.split(','):
+            frontend = frontend.split(':')
+            if len(frontend) == 1:
+                frontend.append(None)
+            config = (self._config, frontend[0], frontend[1])
+            frontend = burrow.import_class(frontend[0], 'Frontend')
+            frontend = frontend(config, self.backend)
+            self.frontends.append(frontend)
+
+    def run(self):
+        '''Create the thread pool and start the main server loop. Wait
+        for the pool to complete, but possibly run forever if the
+        frontends and backend never remove threads.'''
+        thread_pool_size = self.config.getint('thread_pool_size',
+            DEFAULT_THREAD_POOL_SIZE)
+        thread_pool = eventlet.GreenPool(size=int(thread_pool_size))
+        self.backend.run(thread_pool)
+        for frontend in self.frontends:
+            frontend.run(thread_pool)
+        self.log.info(_('Waiting for all threads to exit'))
+        try:
+            thread_pool.waitall()
+        except KeyboardInterrupt:
+            pass
 
=== modified file 'etc/burrowd.conf'
--- etc/burrowd.conf	2011-03-17 23:42:41 +0000
+++ etc/burrowd.conf	2011-04-06 05:49:23 +0000
@@ -1,6 +1,6 @@
 [DEFAULT]
 
-# Log level to use. All sections below prefixed with 'burrowd' can define
+# Log level to use. All sections below prefixed with 'burrow' can define
 # this to override this default.
 log_level = DEBUG
 
@@ -11,26 +11,26 @@
 default_hide = 0
 
 
-[burrowd]
+[burrow.server]
 
 # Backend to use for storing messages.
-backend = burrowd.backend.sqlite
+backend = burrow.backend.sqlite
 
 # Comma separated list of frontends to run.
-# frontends = burrowd.frontend.wsgi,burrowd.frontend.wsgi:ssl
-frontends = burrowd.frontend.wsgi
+# frontends = burrow.frontend.wsgi,burrow.frontend.wsgi:ssl
+frontends = burrow.frontend.wsgi
 
 # Size of the thread pool to use for the server.
 thread_pool_size = 1000
 
 
-[burrowd.backend.sqlite]
+[burrow.backend.sqlite]
 
 # Database file to use, passed to sqlite3.connect.
 database = :memory:
 
 
-[burrowd.frontend.wsgi]
+[burrow.frontend.wsgi]
 
 # Host to listen on.
 host = 0.0.0.0
@@ -51,7 +51,7 @@
 ssl_keyfile = example.key
 
 # Size of thread pool for the WSGI server. If the size is 0, use the main
-# burrowd thread pool.
+# burrow thread pool.
 thread_pool_size = 0
 
 # Default expiration time in seconds to set for messages. This overrides
@@ -63,7 +63,7 @@
 # default_hide = 0
 
 
-[burrowd.frontend.wsgi:ssl]
+[burrow.frontend.wsgi:ssl]
 
 # Port to listen on.
 port = 8443
 
=== modified file 'locale/burrow.pot'
--- locale/burrow.pot	2011-03-18 00:47:26 +0000
+++ locale/burrow.pot	2011-04-06 05:49:23 +0000
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: burrow 0.1\n"
 "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n"
-"POT-Creation-Date: 2011-03-17 17:43-0700\n"
+"POT-Creation-Date: 2011-04-05 19:00-0700\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
@@ -17,20 +17,20 @@
 "Content-Transfer-Encoding: 8bit\n"
 "Generated-By: Babel 0.9.4\n"
 
-#: burrowd/__init__.py:96
-msgid "Waiting for all threads to exit"
-msgstr ""
-
-#: burrowd/__init__.py:109
+#: burrow/__init__.py:38
 msgid "Module created"
 msgstr ""
 
-#: burrowd/__init__.py:130
+#: burrow/__init__.py:59
 #, python-format
 msgid "Class %s.%s cannot be found (%s)"
 msgstr ""
 
-#: burrowd/frontend/wsgi.py:87
+#: burrow/server.py:91
+msgid "Waiting for all threads to exit"
+msgstr ""
+
+#: burrow/frontend/wsgi.py:85
 #, python-format
 msgid "Listening on %s:%d"
 msgstr ""
 
=== modified file 'setup.py'
--- setup.py	2011-03-17 23:42:41 +0000
+++ setup.py	2011-04-06 05:49:23 +0000
@@ -17,11 +17,14 @@
 from setuptools.command.sdist import sdist
 import os
 import subprocess
+
 try:
     from babel.messages import frontend
 except ImportError:
     frontend = None
 
+import burrow
+
 
 class local_sdist(sdist):
     """Customized sdist hook - builds the ChangeLog file from VC first"""
@@ -54,7 +57,7 @@
 
 setup(
     name=name,
-    version='0.1',
+    version=burrow.__version__,
     description='Burrow',
     license='Apache License (2.0)',
     author='OpenStack, LLC.',
 
=== modified file 'test/frontend/test_wsgi.py'
--- test/frontend/test_wsgi.py	2011-03-17 23:42:41 +0000
+++ test/frontend/test_wsgi.py	2011-04-06 05:49:23 +0000
@@ -20,19 +20,19 @@
 import eventlet
 import webob
 
-import burrowd.backend.memory
-import burrowd.backend.sqlite
-import burrowd.frontend.wsgi
+import burrow.backend.memory
+import burrow.backend.sqlite
+import burrow.frontend.wsgi
 
 
 class TestWSGIMemory(unittest.TestCase):
     '''Unittests for the WSGI frontend to SQLite backend.'''
-    backend_class = burrowd.backend.memory.Backend
+    backend_class = burrow.backend.memory.Backend
 
     def setUp(self):
         config = (ConfigParser.ConfigParser(), 'test')
         self.backend = self.backend_class(config)
-        self.frontend = burrowd.frontend.wsgi.Frontend(config, self.backend)
+        self.frontend = burrow.frontend.wsgi.Frontend(config, self.backend)
         self.frontend.default_ttl = 0
         self._get_url('/', status=404)
         self._get_url('/a', status=404)
@@ -310,4 +310,4 @@
 
 class TestWSGISQLite(TestWSGIMemory):
     '''Unittests for the WSGI frontend to SQLite backend.'''
-    backend_class = burrowd.backend.sqlite.Backend
+    backend_class = burrow.backend.sqlite.Backend