Merge lp:~eday/burrow/prototype-conversion into lp:burrow

[Eric Day]

Python prototype conversion to get new trunk started.

=== added file 'Authors'
--- Authors	1970-01-01 00:00:00 +0000
+++ Authors	2011-03-17 23:47:24 +0000
@@ -0,0 +1,1 @@
+Eric Day <[e-mail]>

=== added file 'ChangeLog'
--- ChangeLog	1970-01-01 00:00:00 +0000
+++ ChangeLog	2011-03-17 23:47:24 +0000
@@ -0,0 +1,4 @@
[phone]  Eric Day  <[e-mail]>
+
+	Created new burrow trunk.
+

=== added file 'LICENSE'
--- LICENSE	1970-01-01 00:00:00 +0000
+++ LICENSE	2011-03-17 23:47:24 +0000
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

=== added file 'MANIFEST.in'
--- MANIFEST.in	1970-01-01 00:00:00 +0000
+++ MANIFEST.in	2011-03-17 23:47:24 +0000
@@ -0,0 +1,4 @@
+graft etc
+include Authors
+include ChangeLog
+include LICENSE

=== added directory 'bin'
=== added file 'bin/burrow'
--- bin/burrow	1970-01-01 00:00:00 +0000
+++ bin/burrow	2011-03-17 23:47:24 +0000
@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+# 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.
+
+'''
+Burrow command line client.
+'''

=== added file 'bin/burrowd'
--- bin/burrowd	1970-01-01 00:00:00 +0000
+++ bin/burrowd	2011-03-17 23:47:24 +0000
@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+# 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.
+
+'''
+Burrow server.
+'''
+
+import os
+import sys
+
+# If ../burrowd/__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')):
+    sys.path.insert(0, BASE_DIRECTORY)
+
+import burrowd
+
+if __name__ == '__main__':
+    burrowd.Burrowd(sys.argv[1:]).run()

=== added directory 'burrow'
=== added file 'burrow/__init__.py'
--- burrow/__init__.py	1970-01-01 00:00:00 +0000
+++ burrow/__init__.py	2011-03-17 23:47:24 +0000
@@ -0,0 +1,19 @@
+# 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

=== added directory 'burrowd'
=== added file 'burrowd/__init__.py'
--- burrowd/__init__.py	1970-01-01 00:00:00 +0000
+++ burrowd/__init__.py	2011-03-17 23:47:24 +0000
@@ -0,0 +1,131 @@
+# 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 server module for burrow.'''
+
+import ConfigParser
+import gettext
+import logging
+import logging.config
+import sys
+
+import eventlet
+
+import burrowd.config
+
+# This installs the _(...) function as a built-in so all other modules
+# don't need to.
+gettext.install('burrowd')
+
+# 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.log = get_logger(self.config)
+        self.log.debug(_('Module created'))
+
+
+def get_logger(config):
+    '''Create a logger from the given config.'''
+    log = logging.getLogger(config.section)
+    log_level = config.get('log_level', 'DEBUG')
+    log_level = logging.getLevelName(log_level)
+    if isinstance(log_level, int):
+        log.setLevel(log_level)
+    return log
+
+
+def import_class(module_name, class_name=None):
+    '''Import a class given a full module.class name.'''
+    if class_name is None:
+        module_name, _separator, class_name = module_name.rpartition('.')
+    try:
+        __import__(module_name)
+        return getattr(sys.modules[module_name], class_name)
+    except (ImportError, ValueError, AttributeError), exception:
+        raise ImportError(_('Class %s.%s cannot be found (%s)') %
+            (module_name, class_name, exception))

=== added directory 'burrowd/backend'
=== added file 'burrowd/backend/__init__.py'
--- burrowd/backend/__init__.py	1970-01-01 00:00:00 +0000
+++ burrowd/backend/__init__.py	2011-03-17 23:47:24 +0000
@@ -0,0 +1,94 @@
+# 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.
+
+'''Backends for the burrow server.'''
+
+import eventlet
+
+import burrowd
+
+
+class Backend(burrowd.Module):
+    '''Interface that backend implementations must provide.'''
+
+    def __init__(self, config):
+        super(Backend, self).__init__(config)
+        self.queues = {}
+
+    def run(self, thread_pool):
+        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):
+        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 notify(self, account, queue):
+        queue = '%s/%s' % (account, queue)
+        if queue in self.queues:
+            self.queues[queue].put(0)
+
+    def wait(self, account, queue, seconds):
+        queue = '%s/%s' % (account, queue)
+        if queue not in self.queues:
+            self.queues[queue] = eventlet.Queue()
+        try:
+            self.queues[queue].get(timeout=seconds)
+        except Exception:
+            pass
+        if self.queues[queue].getting() == 0:
+            del self.queues[queue]

=== added file 'burrowd/backend/memory.py'
--- burrowd/backend/memory.py	1970-01-01 00:00:00 +0000
+++ burrowd/backend/memory.py	2011-03-17 23:47:24 +0000
@@ -0,0 +1,176 @@
+# 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.
+
+'''Memory backend for the burrow server.'''
+
+import time
+
+import burrowd.backend
+
+
+class Backend(burrowd.backend.Backend):
+
+    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:
+                message['ttl'] = ttl
+                message['hide'] = hide
+                message['body'] = body
+                if hide == 0:
+                    self.notify(account, queue)
+                return False
+        message = dict(id=message_id, ttl=ttl, hide=hide, body=body)
+        self.accounts[account][queue].append(message)
+        self.notify(account, queue)
+        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:
+                if ttl is not None:
+                    message['ttl'] = ttl
+                if hide is not None:
+                    message['hide'] = hide
+                    if hide == 0:
+                        self.notify(account, queue)
+                return message
+        return None
+
+    def clean(self):
+        now = int(time.time())
+        for account in self.accounts.keys():
+            for queue in self.accounts[account].keys():
+                index = 0
+                notify = False
+                total = len(self.accounts[account][queue])
+                while index < total:
+                    message = self.accounts[account][queue][index]
+                    if 0 < message['ttl'] <= now:
+                        del self.accounts[account][queue][index]
+                        total -= 1
+                    else:
+                        if 0 < message['hide'] <= now:
+                            message['hide'] = 0
+                            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]
+
+    def _scan_queue(self, account, queue, limit, marker, match_hidden,
+                    ttl=None, hide=None, delete=False):
+        index = 0
+        notify = False
+        if 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:
+                    index += 1
+                    found = True
+                    break
+            if not found:
+                index = 0
+        messages = []
+        total = len(self.accounts[account][queue])
+        while index < total:
+            message = self.accounts[account][queue][index]
+            if not match_hidden and message['hide'] != 0:
+                index += 1
+                continue
+            if ttl is not None:
+                message['ttl'] = ttl
+            if hide is not None:
+                message['hide'] = hide
+                if hide == 0:
+                    notify = True
+            if delete:
+                del self.accounts[account][queue][index]
+                total -= 1
+            else:
+                index += 1
+            messages.append(message)
+            if limit:
+                limit -= 1
+                if limit == 0:
+                    break
+        if notify:
+            self.notify(account, queue)
+        return messages

=== added file 'burrowd/backend/sqlite.py'
--- burrowd/backend/sqlite.py	1970-01-01 00:00:00 +0000
+++ burrowd/backend/sqlite.py	2011-03-17 23:47:24 +0000
@@ -0,0 +1,250 @@
+# 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.
+
+'''Memory backend for the burrow server.'''
+
+import sqlite3
+import time
+
+import burrowd.backend
+
+# Default configuration values for this module.
+DEFAULT_DATABASE = ':memory:'
+
+
+class Backend(burrowd.backend.Backend):
+
+    def __init__(self, config):
+        super(Backend, self).__init__(config)
+        database = self.config.get('database', DEFAULT_DATABASE)
+        self.db = sqlite3.connect(database)
+        queries = [
+            'CREATE TABLE queues ('
+                'account VARCHAR(255) NOT NULL,'
+                'queue VARCHAR(255) NOT NULL,'
+                'PRIMARY KEY (account, queue))',
+            'CREATE TABLE messages ('
+                'queue INT UNSIGNED NOT NULL,'
+                'name VARCHAR(255) NOT NULL,'
+                'ttl INT UNSIGNED NOT NULL,'
+                'hide INT UNSIGNED NOT NULL,'
+                'body BLOB NOT NULL,'
+                'PRIMARY KEY (queue, name))']
+        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:
+            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
+        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:
+            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)
+        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):
+        query = "SELECT rowid FROM queues " \
+            "WHERE account='%s' AND queue='%s'" % (account, queue)
+        result = self.db.execute(query).fetchall()
+        if len(result) == 0:
+            query = "INSERT INTO queues VALUES ('%s', '%s')" % (account, queue)
+            rowid = self.db.execute(query).lastrowid
+        else:
+            rowid = result[0][0]
+        query = "SELECT rowid FROM messages WHERE queue=%d AND name='%s'" % \
+            (rowid, message_id)
+        result = self.db.execute(query).fetchall()
+        if len(result) == 0:
+            query = "INSERT INTO messages VALUES (%d, '%s', %d, %d, '%s')" % \
+                (rowid, message_id, ttl, hide, body)
+            self.db.execute(query)
+            self.notify(account, queue)
+            return True
+        query = "UPDATE messages SET ttl=%d, hide=%d, body='%s'" \
+            "WHERE rowid=%d" % (ttl, hide, body, result[0][0])
+        self.db.execute(query)
+        if hide == 0:
+            self.notify(account, queue)
+        return False
+
+    def update_message(self, account, queue, message_id, ttl, hide):
+        message = self.get_message(account, queue, message_id)
+        if message is None:
+            return None
+        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 message
+        query += " WHERE queue=%d AND name='%s'" % (self.rowid, message_id)
+        self.db.execute(query)
+        if hide == 0:
+            self.notify(account, queue)
+        return message
+
+    def clean(self):
+        now = int(time.time())
+        query = "SELECT rowid,queue FROM messages " \
+            "WHERE ttl > 0 AND ttl <= %d" % now
+        result = self.db.execute(query).fetchall()
+        if len(result) > 0:
+            messages = []
+            queues = []
+            for row in result:
+                messages.append(str(row[0]))
+                queues.append(row[1])
+            query = 'DELETE FROM messages WHERE rowid in (%s)' % \
+                ','.join(messages)
+            self.db.execute(query)
+            for queue in queues:
+                query = "SELECT rowid FROM messages WHERE queue=%d LIMIT 1" % \
+                    queue
+                if len(self.db.execute(query).fetchall()) == 0:
+                    query = "DELETE FROM queues WHERE rowid=%d" % queue
+                    self.db.execute(query)
+        query = "SELECT rowid,queue FROM messages WHERE " \
+            "hide > 0 AND hide <= %d" % now
+        result = self.db.execute(query).fetchall()
+        if len(result) > 0:
+            messages = []
+            queues = []
+            for row in result:
+                messages.append(str(row[0]))
+                queues.append(row[1])
+            query = 'UPDATE messages SET hide=0 WHERE rowid in (%s)' % \
+                ','.join(messages)
+            self.db.execute(query)
+            for queue in queues:
+                query = "SELECT account,queue FROM queues WHERE rowid=%d" % \
+                    queue
+                result = self.db.execute(query).fetchall()[0]
+                self.notify(result[0], result[1])

=== added file 'burrowd/config.py'
--- burrowd/config.py	1970-01-01 00:00:00 +0000
+++ burrowd/config.py	2011-03-17 23:47:24 +0000
@@ -0,0 +1,55 @@
+# 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.
+
+'''Configuration module for the burrow server.'''
+
+import ConfigParser
+
+
+class Config(object):
+    '''Configuration class that wraps the ConfigParser get*
+    methods. These wrappers automatically check for options in
+    a specific instance section first before the regular section
+    (section:instance and then section). They will also return a
+    default value if given instead of throwing an exception.'''
+
+    def __init__(self, config, section, instance=None):
+        self.config = config
+        self.section = section
+        if instance is None:
+            self.instance = None
+        else:
+            self.instance = '%s:%s' % (section, instance)
+
+    def get(self, option, default=None):
+        return self._get(self.config.get, option, default)
+
+    def getboolean(self, option, default=None):
+        return self._get(self.config.getboolean, option, default)
+
+    def getfloat(self, option, default=None):
+        return self._get(self.config.getfloat, option, default)
+
+    def getint(self, option, default=None):
+        return self._get(self.config.getint, option, default)
+
+    def _get(self, method, option, default):
+        if self.instance is not None:
+            if self.config.has_option(self.instance, option):
+                return method(self.instance, option)
+        if self.config.has_option(self.section, option):
+            return method(self.section, option)
+        if self.config.has_option(ConfigParser.DEFAULTSECT, option):
+            return method(ConfigParser.DEFAULTSECT, option)
+        return default

=== added directory 'burrowd/frontend'
=== added file 'burrowd/frontend/__init__.py'
--- burrowd/frontend/__init__.py	1970-01-01 00:00:00 +0000
+++ burrowd/frontend/__init__.py	2011-03-17 23:47:24 +0000
@@ -0,0 +1,30 @@
+# 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.
+
+'''Frontends for the burrow server.'''
+
+import burrowd
+
+
+class Frontend(burrowd.Module):
+    '''Interface that frontend implementations must provide.'''
+
+    def __init__(self, config, backend):
+        super(Frontend, self).__init__(config)
+        self.backend = backend
+
+    def run(self, thread_pool):
+        '''Run the frontend instance, adding any threads to the
+        thread_pool if needed.'''
+        pass

=== added file 'burrowd/frontend/wsgi.py'
--- burrowd/frontend/wsgi.py	1970-01-01 00:00:00 +0000
+++ burrowd/frontend/wsgi.py	2011-03-17 23:47:24 +0000
@@ -0,0 +1,276 @@
+# 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.
+
+'''WSGI frontend for the burrow server.'''
+
+import json
+import time
+
+import eventlet
+import eventlet.wsgi
+import routes
+import routes.middleware
+import webob.dec
+import webob.exc
+
+import burrowd.frontend
+
+# Default configuration values for this module.
+DEFAULT_HOST = '0.0.0.0'
+DEFAULT_PORT = 8080
+DEFAULT_BACKLOG = 64
+DEFAULT_SSL = False
+DEFAULT_SSL_CERTFILE = 'example.pem'
+DEFAULT_SSL_KEYFILE = 'example.key'
+DEFAULT_THREAD_POOL_SIZE = 0
+DEFAULT_TTL = 600
+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 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)
+            if wait == 0 or res.status_int != 404:
+                break
+            now = time.time()
+            if wait - now > 0:
+                self.backend.wait(account, queue, wait - now)
+            if wait < time.time():
+                break
+        return res
+    return wrapper
+
+
+class Frontend(burrowd.frontend.Frontend):
+
+    def __init__(self, config, backend):
+        super(Frontend, self).__init__(config, backend)
+        self.default_ttl = self.config.get('default_ttl', DEFAULT_TTL)
+        self.default_hide = self.config.get('default_hide', DEFAULT_HIDE)
+        mapper = routes.Mapper()
+        mapper.connect('/', action='root')
+        mapper.connect('/{account}', action='account')
+        mapper.connect('/{account}/{queue}', action='queue')
+        mapper.connect('/{account}/{queue}/{message_id}', action='message')
+        self._routes = routes.middleware.RoutesMiddleware(self._route, mapper)
+
+    def run(self, thread_pool):
+        '''Create the listening socket and start the thread that runs
+        the WSGI server. This extra thread is needed since the WSGI
+        server function blocks.'''
+        host = self.config.get('host', DEFAULT_HOST)
+        port = self.config.getint('port', DEFAULT_PORT)
+        backlog = self.config.getint('backlog', DEFAULT_BACKLOG)
+        socket = eventlet.listen((host, port), backlog=backlog)
+        self.log.info(_('Listening on %s:%d') % (host, port))
+        if self.config.getboolean('ssl', DEFAULT_SSL):
+            certfile = self.config.get('ssl_certfile', DEFAULT_SSL_CERTFILE)
+            keyfile = self.config.get('ssl_keyfile', DEFAULT_SSL_KEYFILE)
+            socket = eventlet.green.ssl.wrap_socket(socket, certfile=certfile,
+                keyfile=keyfile)
+        thread_pool.spawn_n(self._run, socket, thread_pool)
+
+    def _run(self, socket, thread_pool):
+        '''Thread to run the WSGI server.'''
+        thread_pool_size = self.config.getint('thread_pool_size',
+            DEFAULT_THREAD_POOL_SIZE)
+        log_format = '%(client_ip)s "%(request_line)s" %(status_code)s ' \
+                     '%(body_length)s %(wall_seconds).6f'
+        if thread_pool_size == 0:
+            eventlet.wsgi.server(socket, self, log=WSGILog(self.log),
+                log_format=log_format, custom_pool=thread_pool)
+        else:
+            eventlet.wsgi.server(socket, self, log=WSGILog(self.log),
+                log_format=log_format, max_size=thread_pool_size)
+
+    def __call__(self, *args, **kwargs):
+        return self._routes(*args, **kwargs)
+
+    @webob.dec.wsgify
+    def _route(self, req):
+        args = req.environ['wsgiorg.routing_args'][1]
+        if not args:
+            return webob.exc.HTTPNotFound()
+        action = args.pop('action')
+        method = getattr(self, '_%s_%s' % (req.method.lower(), action), False)
+        if not method:
+            return webob.exc.HTTPBadRequest()
+        return method(req, **args)
+
+    @webob.dec.wsgify
+    def _delete_root(self, req):
+        self.backend.delete_accounts()
+        return webob.exc.HTTPNoContent()
+
+    @webob.dec.wsgify
+    def _get_root(self, req):
+        accounts = self.backend.get_accounts()
+        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)
+        return webob.exc.HTTPNoContent()
+
+    @webob.dec.wsgify
+    def _get_account(self, req, account):
+        queues = self.backend.get_queues(account)
+        if len(queues) == 0:
+            return webob.exc.HTTPNotFound()
+        return webob.exc.HTTPOk(body=json.dumps(queues, indent=2))
+
+    @webob.dec.wsgify
+    @queue_exists
+    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)
+        return self._return_messages(req, account, queue, messages, 'none')
+
+    @webob.dec.wsgify
+    @queue_exists
+    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)
+        return self._return_messages(req, account, queue, messages, 'all')
+
+    @webob.dec.wsgify
+    @queue_exists
+    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)
+        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)
+        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)
+        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)
+        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):
+            return webob.exc.HTTPCreated()
+        return webob.exc.HTTPNoContent()
+
+    def _filter_message(self, detail, message):
+        if detail == 'id':
+            return dict(id=message['id'])
+        elif detail == 'metadata':
+            message = message.copy()
+            del message['body']
+            return message
+        elif detail == 'all':
+            return message
+        return None
+
+    def _return_message(self, req, account, queue, message, detail):
+        if 'detail' in req.params:
+            detail = req.params['detail']
+        message = self._filter_message(detail, message)
+        if message is not None:
+            body = {account: {queue: [message]}}
+            return webob.exc.HTTPOk(body=json.dumps(body, indent=2))
+        return webob.exc.HTTPNoContent()
+
+    def _return_messages(self, req, account, queue, messages, detail):
+        if len(messages) == 0:
+            return webob.exc.HTTPNotFound()
+        if 'detail' in req.params:
+            detail = req.params['detail']
+        filtered_messages = []
+        for message in messages:
+            message = self._filter_message(detail, message)
+            if message is not None:
+                filtered_messages.append(message)
+        if len(filtered_messages) == 0:
+            return webob.exc.HTTPNoContent()
+        body = {account: {queue: filtered_messages}}
+        return webob.exc.HTTPOk(body=json.dumps(body, indent=2))
+
+    def _parse_filters(self, req):
+        limit = None
+        if 'limit' in req.params:
+            limit = int(req.params['limit'])
+        marker = None
+        if 'marker' in req.params:
+            marker = req.params['marker']
+        match_hidden = False
+        if 'hidden' in req.params and req.params['hidden'].lower() == 'true':
+            match_hidden = True
+        return limit, marker, match_hidden
+
+    def _parse_metadata(self, req, default_ttl=None, default_hide=None):
+        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())
+        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
+
+
+class WSGILog(object):
+    '''Class for eventlet.wsgi.server to forward logging messages.'''
+
+    def __init__(self, log):
+        self.log = log
+
+    def write(self, message):
+        self.log.debug(message.rstrip())

=== added directory 'etc'
=== added file 'etc/burrowd.conf'
--- etc/burrowd.conf	1970-01-01 00:00:00 +0000
+++ etc/burrowd.conf	2011-03-17 23:47:24 +0000
@@ -0,0 +1,99 @@
+[DEFAULT]
+
+# Log level to use. All sections below prefixed with 'burrowd' can define
+# this to override this default.
+log_level = DEBUG
+
+# Default expiration time in seconds to set for messages.
+default_ttl = 600
+
+# Default hide time in seconds to set for messages.
+default_hide = 0
+
+
+[burrowd]
+
+# Backend to use for storing messages.
+backend = burrowd.backend.sqlite
+
+# Comma separated list of frontends to run.
+# frontends = burrowd.frontend.wsgi,burrowd.frontend.wsgi:ssl
+frontends = burrowd.frontend.wsgi
+
+# Size of the thread pool to use for the server.
+thread_pool_size = 1000
+
+
+[burrowd.backend.sqlite]
+
+# Database file to use, passed to sqlite3.connect.
+database = :memory:
+
+
+[burrowd.frontend.wsgi]
+
+# Host to listen on.
+host = 0.0.0.0
+
+# Port to listen on.
+port = 8080
+
+# Size of backlog for listener socket.
+backlog = 64
+
+# Whether to enable SSL.
+ssl = False
+
+# If SSL is enabled, which certfile to use.
+ssl_certfile = example.pem
+
+# If SSL is enabled, which keyfile to use.
+ssl_keyfile = example.key
+
+# Size of thread pool for the WSGI server. If the size is 0, use the main
+# burrowd thread pool.
+thread_pool_size = 0
+
+# Default expiration time in seconds to set for messages. This overrides
+# the value in the DEFAULT section.
+# default_ttl = 600
+
+# Default hide time in seconds to set for messages. This overrides the
+# value in the DEFAULT section.
+# default_hide = 0
+
+
+[burrowd.frontend.wsgi:ssl]
+
+# Port to listen on.
+port = 8443
+
+# Whether to enable SSL.
+ssl = True
+
+
+# Logging configuration following the logging.config format.
+
+[loggers]
+keys=root
+
+[logger_root]
+qualname=root
+level=WARNING
+handlers=console
+
+[handlers]
+keys=console
+
+[handler_console]
+class=StreamHandler
+level=DEBUG
+formatter=simple
+args=(sys.stdout,)
+
+[formatters]
+keys=simple
+
+[formatter_simple]
+format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
+datefmt=

=== added file 'setup.py'
--- setup.py	1970-01-01 00:00:00 +0000
+++ setup.py	2011-03-17 23:47:24 +0000
@@ -0,0 +1,74 @@
+#!/usr/bin/python
+# 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.
+
+from setuptools import setup, find_packages
+from setuptools.command.sdist import sdist
+import os
+import subprocess
+try:
+    from babel.messages import frontend
+except ImportError:
+    frontend = None
+
+
+class local_sdist(sdist):
+    """Customized sdist hook - builds the ChangeLog file from VC first"""
+
+    def run(self):
+        if os.path.isdir('.bzr'):
+            # We're in a bzr branch
+
+            log_cmd = subprocess.Popen(["bzr", "log", "--gnu"],
+                                       stdout=subprocess.PIPE)
+            changelog = log_cmd.communicate()[0]
+            with open("ChangeLog", "w") as changelog_file:
+                changelog_file.write(changelog)
+        sdist.run(self)
+
+
+name = 'burrow'
+
+
+cmdclass = {'sdist': local_sdist}
+
+
+if frontend:
+    cmdclass.update({
+        'compile_catalog': frontend.compile_catalog,
+        'extract_messages': frontend.extract_messages,
+        'init_catalog': frontend.init_catalog,
+        'update_catalog': frontend.update_catalog})
+
+
+setup(
+    name=name,
+    version='0.1',
+    description='Burrow',
+    license='Apache License (2.0)',
+    author='OpenStack, LLC.',
+    author_email='[e-mail]',
+    url='https://launchpad.net/burrow',
+    packages=find_packages(exclude=['test', 'bin']),
+    test_suite='nose.collector',
+    cmdclass=cmdclass,
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+        'License :: OSI Approved :: Apache Software License',
+        'Operating System :: POSIX :: Linux',
+        'Programming Language :: Python :: 2.6',
+        'Environment :: No Input/Output (Daemon)'],
+    scripts=[
+        'bin/burrow',
+        'bin/burrowd'])

=== added directory 'test'
=== added file 'test/__init__.py'
=== added directory 'test/frontend'
=== added file 'test/frontend/__init__.py'
=== added file 'test/frontend/test_wsgi.py'
--- test/frontend/test_wsgi.py	1970-01-01 00:00:00 +0000
+++ test/frontend/test_wsgi.py	2011-03-17 23:47:24 +0000
@@ -0,0 +1,313 @@
+# 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.
+
+import ConfigParser
+import json
+import time
+import unittest
+
+import eventlet
+import webob
+
+import burrowd.backend.memory
+import burrowd.backend.sqlite
+import burrowd.frontend.wsgi
+
+
+class TestWSGIMemory(unittest.TestCase):
+    '''Unittests for the WSGI frontend to SQLite backend.'''
+    backend_class = burrowd.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.default_ttl = 0
+        self._get_url('/', status=404)
+        self._get_url('/a', status=404)
+        self._get_url('/a/q', status=404)
+
+    def tearDown(self):
+        self._get_url('/a/q', status=404)
+        self._get_url('/a', status=404)
+        self._get_url('/', status=404)
+
+    def test_account(self):
+        self._put_url('/a/q/1')
+        accounts = self._get_url('/')
+        self.assertEquals(accounts, ['a'])
+        self._delete_url('/a')
+
+    def test_queue(self):
+        self._put_url('/a/q/1')
+        accounts = self._get_url('/a')
+        self.assertEquals(accounts, ['q'])
+        self._delete_url('/a/q')
+
+    def test_message(self):
+        self._put_url('/a/q/1', body='b')
+        accounts = self._get_url('/a/q')
+        self.assertMessages(accounts, 'a', 'q', [self.message('1', body='b')])
+        self._delete_url('/a/q/1')
+
+    def test_message_post(self):
+        self._put_url('/a/q/1', body='b')
+        for x in range(0, 3):
+            accounts = self._post_url('/a/q/1?ttl=%d&hide=%d' % (x, x))
+            self.assertEquals(accounts, {'a': {'q': [{'id': '1'}]}})
+            accounts = self._get_url('/a/q?hidden=true')
+            message = self.message('1', x, x, body='b')
+            self.assertMessages(accounts, 'a', 'q', [message])
+        self._delete_url('/a/q/1')
+
+    def test_message_put(self):
+        for x in range(0, 3):
+            url = '/a/q/1?ttl=%d&hide=%d' % (x, x)
+            status = 201 if x == 0 else 204
+            self._put_url(url, body=str(x), status=status)
+            accounts = self._get_url('/a/q?hidden=true')
+            message = self.message('1', x, x, body=str(x))
+            self.assertMessages(accounts, 'a', 'q', [message])
+        self._delete_url('/a/q/1')
+
+    def test_message_delete_limit(self):
+        [self._put_url('/a/q/%d' % x) for x in range(1, 5)]
+        accounts = self._delete_url('/a/q?limit=3&detail=all', status=200)
+        messages = []
+        messages.append(self.message('1'))
+        messages.append(self.message('2'))
+        messages.append(self.message('3'))
+        self.assertMessages(accounts, 'a', 'q', messages)
+        accounts = self._delete_url('/a/q?limit=3&detail=all', status=200)
+        message = self.message('4')
+        self.assertMessages(accounts, 'a', 'q', [message])
+
+    def test_message_get_limit(self):
+        [self._put_url('/a/q/%d' % x) for x in range(1, 5)]
+        for x in range(0, 4):
+            accounts = self._get_url('/a/q?limit=3')
+            messages = []
+            for y in range(x, 4)[:3]:
+                messages.append(self.message(str(y + 1)))
+            self.assertMessages(accounts, 'a', 'q', messages)
+            self._delete_url('/a/q/%d' % (x + 1))
+
+    def test_message_post_limit(self):
+        [self._put_url('/a/q/%d' % x) for x in range(1, 5)]
+        for x in range(0, 4):
+            accounts = self._post_url('/a/q?limit=3&ttl=%d&detail=all' % x)
+            messages = []
+            for y in range(x, 4)[:3]:
+                messages.append(self.message(str(y + 1), x))
+            self.assertMessages(accounts, 'a', 'q', messages)
+            self._delete_url('/a/q/%d' % (x + 1))
+
+    def test_message_delete_marker(self):
+        [self._put_url('/a/q/%d' % x) for x in range(1, 5)]
+        accounts = self._delete_url('/a/q?marker=2&detail=all', status=200)
+        messages = []
+        messages.append(self.message('3'))
+        messages.append(self.message('4'))
+        self.assertMessages(accounts, 'a', 'q', messages)
+        accounts = self._delete_url('/a/q?marker=5&detail=all', status=200)
+        messages = []
+        messages.append(self.message('1'))
+        messages.append(self.message('2'))
+        self.assertMessages(accounts, 'a', 'q', messages)
+
+    def test_message_get_marker(self):
+        [self._put_url('/a/q/%d' % x) for x in range(1, 5)]
+        for x in range(0, 4):
+            accounts = self._get_url('/a/q?marker=%d' % x)
+            messages = []
+            for y in range(x, 4):
+                messages.append(self.message(str(y + 1)))
+            self.assertMessages(accounts, 'a', 'q', messages)
+            self._delete_url('/a/q/%d' % (x + 1))
+
+    def test_message_post_marker(self):
+        [self._put_url('/a/q/%d' % x) for x in range(1, 5)]
+        for x in range(0, 4):
+            url = '/a/q?marker=%d&ttl=%d&detail=all' % (x, x)
+            accounts = self._post_url(url)
+            messages = []
+            for y in range(x, 4):
+                messages.append(self.message(str(y + 1), x))
+            self.assertMessages(accounts, 'a', 'q', messages)
+            self._delete_url('/a/q/%d' % (x + 1))
+
+    def test_message_delete_limit_marker(self):
+        [self._put_url('/a/q/%d' % x) for x in range(1, 5)]
+        url = '/a/q?limit=2&marker=1&detail=all'
+        accounts = self._delete_url(url, status=200)
+        messages = []
+        messages.append(self.message('2'))
+        messages.append(self.message('3'))
+        self.assertMessages(accounts, 'a', 'q', messages)
+        url = '/a/q?limit=2&marker=5&detail=all'
+        accounts = self._delete_url(url, status=200)
+        messages = []
+        messages.append(self.message('1'))
+        messages.append(self.message('4'))
+        self.assertMessages(accounts, 'a', 'q', messages)
+
+    def test_message_get_limit_marker(self):
+        [self._put_url('/a/q/%d' % x) for x in range(1, 5)]
+        for x in range(0, 4):
+            accounts = self._get_url('/a/q?limit=2&marker=%d' % x)
+            messages = []
+            for y in range(x, 4)[:2]:
+                messages.append(self.message(str(y + 1)))
+            self.assertMessages(accounts, 'a', 'q', messages)
+            self._delete_url('/a/q/%d' % (x + 1))
+
+    def test_message_post_limit_marker(self):
+        [self._put_url('/a/q/%d' % x) for x in range(1, 5)]
+        for x in range(0, 4):
+            url = '/a/q?limit=2&marker=%d&ttl=%d&detail=all' % (x, x)
+            accounts = self._post_url(url)
+            messages = []
+            for y in range(x, 4)[:2]:
+                messages.append(self.message(str(y + 1), x))
+            self.assertMessages(accounts, 'a', 'q', messages)
+            self._delete_url('/a/q/%d' % (x + 1))
+
+    def test_message_ttl(self):
+        self._put_url('/a/q/1?ttl=1')
+        accounts = self._get_url('/a/q/1')
+        message = self.message('1', 1)
+        self.assertMessages(accounts, 'a', 'q', [self.message('1', 1)])
+        time.sleep(1)
+        self.backend.clean()
+        self._get_url('/a/q/1', status=404)
+        self._put_url('/a/q/1')
+        accounts = self._get_url('/a/q/1')
+        self.assertMessages(accounts, 'a', 'q', [self.message('1')])
+        self._post_url('/a/q/1?ttl=1')
+        accounts = self._get_url('/a/q/1')
+        self.assertMessages(accounts, 'a', 'q', [self.message('1', 1)])
+        time.sleep(1)
+        self.backend.clean()
+        self._get_url('/a/q/1', status=404)
+
+    def test_message_hide(self):
+        self._put_url('/a/q/1?hide=1')
+        accounts = self._get_url('/a/q/1')
+        self.assertMessages(accounts, 'a', 'q', [self.message('1', hide=1)])
+        time.sleep(1)
+        self.backend.clean()
+        accounts = self._get_url('/a/q/1')
+        self.assertMessages(accounts, 'a', 'q', [self.message('1')])
+        self._post_url('/a/q/1?hide=1')
+        accounts = self._get_url('/a/q/1')
+        self.assertMessages(accounts, 'a', 'q', [self.message('1', hide=1)])
+        time.sleep(1)
+        self.backend.clean()
+        accounts = self._get_url('/a/q/1')
+        self.assertMessages(accounts, 'a', 'q', [self.message('1')])
+        self._delete_url('/a/q/1')
+
+    def _message_wait(self):
+        accounts = self._get_url('/a/q?wait=2')
+        self.assertMessages(accounts, 'a', 'q', [self.message('1')])
+        self.success = True
+
+    def test_message_put_wait(self):
+        self.success = False
+        thread = eventlet.spawn(self._message_wait)
+        eventlet.spawn_after(0.2, self._put_url, '/a/q/1')
+        thread.wait()
+        self.assertTrue(self.success)
+        self._delete_url('/a/q/1')
+
+    def test_message_put_wait_overwrite(self):
+        self.success = False
+        self._put_url('/a/q/1?hide=10')
+        thread = eventlet.spawn(self._message_wait)
+        eventlet.spawn_after(0.2, self._put_url, '/a/q/1?hide=0', status=204)
+        thread.wait()
+        self.assertTrue(self.success)
+        self._delete_url('/a/q/1')
+
+    def test_message_put_wait_cleanup(self):
+        self.success = False
+        self._put_url('/a/q/1?hide=1')
+        thread = eventlet.spawn(self._message_wait)
+        eventlet.spawn_after(1, self.backend.clean)
+        thread.wait()
+        self.assertTrue(self.success)
+        self._delete_url('/a/q/1')
+
+    def test_message_post_wait(self):
+        self.success = False
+        self._put_url('/a/q/1?hide=10')
+        thread = eventlet.spawn(self._message_wait)
+        eventlet.spawn_after(0.2, self._post_url, '/a/q/1?hide=0')
+        thread.wait()
+        self.assertTrue(self.success)
+        self._delete_url('/a/q/1')
+
+    def test_message_post_wait_queue(self):
+        self.success = False
+        self._put_url('/a/q/1?hide=10')
+        thread = eventlet.spawn(self._message_wait)
+        eventlet.spawn_after(0.2, self._post_url, '/a/q?hide=0&hidden=true')
+        thread.wait()
+        self.assertTrue(self.success)
+        self._delete_url('/a/q/1')
+
+    def message(self, id, ttl=0, hide=0, body=''):
+        return dict(id=id, ttl=ttl, hide=hide, body=body)
+
+    def assertMessages(self, accounts, account, queue, messages):
+        self.assertEquals(len(accounts), 1)
+        self.assertEquals(len(accounts['a']), 1)
+        self.assertEquals(len(accounts['a']['q']), len(messages))
+        for x in range(0, len(messages)):
+            self.assertEquals(accounts['a']['q'][x]['id'], messages[x]['id'])
+            ttl = messages[x]['ttl']
+            if ttl > 0:
+                ttl += int(time.time())
+            self.assertAlmostEquals(accounts['a']['q'][0]['ttl'], ttl)
+            hide = messages[x]['hide']
+            if hide > 0:
+                hide += int(time.time())
+            self.assertAlmostEquals(accounts['a']['q'][0]['hide'], hide)
+            body = messages[x]['body']
+            self.assertEquals(accounts['a']['q'][x]['body'], body)
+
+    def _delete_url(self, url, status=204, **kwargs):
+        return self._url('DELETE', url, status=status, **kwargs)
+
+    def _get_url(self, url, **kwargs):
+        return self._url('GET', url, **kwargs)
+
+    def _post_url(self, url, **kwargs):
+        return self._url('POST', url, **kwargs)
+
+    def _put_url(self, url, status=201, **kwargs):
+        return self._url('PUT', url, status=status, **kwargs)
+
+    def _url(self, method, url, body='', status=200):
+        req = webob.Request.blank(url, method=method, body=body)
+        res = req.get_response(self.frontend)
+        self.assertEquals(res.status_int, status)
+        if status == 200:
+            return json.loads(res.body)
+        return None
+
+
+class TestWSGISQLite(TestWSGIMemory):
+    '''Unittests for the WSGI frontend to SQLite backend.'''
+    backend_class = burrowd.backend.sqlite.Backend