Merge lp:~ttx/swift/1.4.1-proposed into lp:~hudson-openstack/swift/milestone-proposed

[Thierry Carrez]

Merge 1.4.1 development from trunk (rev312)

Merge 1.4.1 development from trunk into milestone-proposed branch.

This was taken from rev312 in trunk (the last revision before 1.4.2 versioning)

=== modified file 'CHANGELOG'
--- CHANGELOG	2011-05-27 13:48:41 +0000
+++ CHANGELOG	2011-06-15 09:24:34 +0000
@@ -1,3 +1,19 @@
+swift (1.4.1)
+
+    * st renamed to swift
+
+    * swauth was separated froms swift. It is now its own project and can be
+      found at https://github.com/gholt/swauth.
+
+    * tempauth middleware added as an extremely limited auth system for dev
+      work.
+
+    * Account and container listings now properly labeled UTF-8 (previously the
+      label was "utf8").
+
+    * Accounts are auto-created if an auth token is valid when the
+      account_autocreate proxy config parameter is set to true.
+
 swift (1.4.0)
 
     * swift-bench now cleans up containers it creates.

=== removed file 'bin/st'
--- bin/st	2011-05-19 14:48:15 +0000
+++ bin/st	1970-01-01 00:00:00 +0000
@@ -1,1812 +0,0 @@
-#!/usr/bin/python -u
-# Copyright (c) 2010-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 errno import EEXIST, ENOENT
-from hashlib import md5
-from optparse import OptionParser
-from os import environ, listdir, makedirs, utime
-from os.path import basename, dirname, getmtime, getsize, isdir, join
-from Queue import Empty, Queue
-from sys import argv, exc_info, exit, stderr, stdout
-from threading import enumerate as threading_enumerate, Thread
-from time import sleep
-from traceback import format_exception
-
-
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
-# Inclusion of swift.common.client for convenience of single file distribution
-
-import socket
-from cStringIO import StringIO
-from re import compile, DOTALL
-from tokenize import generate_tokens, STRING, NAME, OP
-from urllib import quote as _quote, unquote
-from urlparse import urlparse, urlunparse
-
-try:
-    from eventlet.green.httplib import HTTPException, HTTPSConnection
-except ImportError:
-    from httplib import HTTPException, HTTPSConnection
-
-try:
-    from eventlet import sleep
-except ImportError:
-    from time import sleep
-
-try:
-    from swift.common.bufferedhttp \
-        import BufferedHTTPConnection as HTTPConnection
-except ImportError:
-    try:
-        from eventlet.green.httplib import HTTPConnection
-    except ImportError:
-        from httplib import HTTPConnection
-
-
-def quote(value, safe='/'):
-    """
-    Patched version of urllib.quote that encodes utf8 strings before quoting
-    """
-    if isinstance(value, unicode):
-        value = value.encode('utf8')
-    return _quote(value, safe)
-
-
-# look for a real json parser first
-try:
-    # simplejson is popular and pretty good
-    from simplejson import loads as json_loads
-except ImportError:
-    try:
-        # 2.6 will have a json module in the stdlib
-        from json import loads as json_loads
-    except ImportError:
-        # fall back on local parser otherwise
-        comments = compile(r'/\*.*\*/|//[^\r\n]*', DOTALL)
-
-        def json_loads(string):
-            '''
-            Fairly competent json parser exploiting the python tokenizer and
-            eval(). -- From python-cloudfiles
-
-            _loads(serialized_json) -> object
-            '''
-            try:
-                res = []
-                consts = {'true': True, 'false': False, 'null': None}
-                string = '(' + comments.sub('', string) + ')'
-                for type, val, _junk, _junk, _junk in \
-                        generate_tokens(StringIO(string).readline):
-                    if (type == OP and val not in '[]{}:,()-') or \
-                            (type == NAME and val not in consts):
-                        raise AttributeError()
-                    elif type == STRING:
-                        res.append('u')
-                        res.append(val.replace('\\/', '/'))
-                    else:
-                        res.append(val)
-                return eval(''.join(res), {}, consts)
-            except Exception:
-                raise AttributeError()
-
-
-class ClientException(Exception):
-
-    def __init__(self, msg, http_scheme='', http_host='', http_port='',
-                 http_path='', http_query='', http_status=0, http_reason='',
-                 http_device=''):
-        Exception.__init__(self, msg)
-        self.msg = msg
-        self.http_scheme = http_scheme
-        self.http_host = http_host
-        self.http_port = http_port
-        self.http_path = http_path
-        self.http_query = http_query
-        self.http_status = http_status
-        self.http_reason = http_reason
-        self.http_device = http_device
-
-    def __str__(self):
-        a = self.msg
-        b = ''
-        if self.http_scheme:
-            b += '%s://' % self.http_scheme
-        if self.http_host:
-            b += self.http_host
-        if self.http_port:
-            b += ':%s' % self.http_port
-        if self.http_path:
-            b += self.http_path
-        if self.http_query:
-            b += '?%s' % self.http_query
-        if self.http_status:
-            if b:
-                b = '%s %s' % (b, self.http_status)
-            else:
-                b = str(self.http_status)
-        if self.http_reason:
-            if b:
-                b = '%s %s' % (b, self.http_reason)
-            else:
-                b = '- %s' % self.http_reason
-        if self.http_device:
-            if b:
-                b = '%s: device %s' % (b, self.http_device)
-            else:
-                b = 'device %s' % self.http_device
-        return b and '%s: %s' % (a, b) or a
-
-
-def http_connection(url):
-    """
-    Make an HTTPConnection or HTTPSConnection
-
-    :param url: url to connect to
-    :returns: tuple of (parsed url, connection object)
-    :raises ClientException: Unable to handle protocol scheme
-    """
-    parsed = urlparse(url)
-    if parsed.scheme == 'http':
-        conn = HTTPConnection(parsed.netloc)
-    elif parsed.scheme == 'https':
-        conn = HTTPSConnection(parsed.netloc)
-    else:
-        raise ClientException('Cannot handle protocol scheme %s for url %s' %
-                              (parsed.scheme, repr(url)))
-    return parsed, conn
-
-
-def get_auth(url, user, key, snet=False):
-    """
-    Get authentication/authorization credentials.
-
-    The snet parameter is used for Rackspace's ServiceNet internal network
-    implementation. In this function, it simply adds *snet-* to the beginning
-    of the host name for the returned storage URL. With Rackspace Cloud Files,
-    use of this network path causes no bandwidth charges but requires the
-    client to be running on Rackspace's ServiceNet network.
-
-    :param url: authentication/authorization URL
-    :param user: user to authenticate as
-    :param key: key or password for authorization
-    :param snet: use SERVICENET internal network (see above), default is False
-    :returns: tuple of (storage URL, auth token)
-    :raises ClientException: HTTP GET request to auth URL failed
-    """
-    parsed, conn = http_connection(url)
-    conn.request('GET', parsed.path, '',
-                 {'X-Auth-User': user, 'X-Auth-Key': key})
-    resp = conn.getresponse()
-    resp.read()
-    if resp.status < 200 or resp.status >= 300:
-        raise ClientException('Auth GET failed', http_scheme=parsed.scheme,
-                http_host=conn.host, http_port=conn.port,
-                http_path=parsed.path, http_status=resp.status,
-                http_reason=resp.reason)
-    url = resp.getheader('x-storage-url')
-    if snet:
-        parsed = list(urlparse(url))
-        # Second item in the list is the netloc
-        parsed[1] = 'snet-' + parsed[1]
-        url = urlunparse(parsed)
-    return url, resp.getheader('x-storage-token',
-                                                resp.getheader('x-auth-token'))
-
-
-def get_account(url, token, marker=None, limit=None, prefix=None,
-                http_conn=None, full_listing=False):
-    """
-    Get a listing of containers for the account.
-
-    :param url: storage URL
-    :param token: auth token
-    :param marker: marker query
-    :param limit: limit query
-    :param prefix: prefix query
-    :param http_conn: HTTP connection object (If None, it will create the
-                      conn object)
-    :param full_listing: if True, return a full listing, else returns a max
-                         of 10000 listings
-    :returns: a tuple of (response headers, a list of containers) The response
-              headers will be a dict and all header names will be lowercase.
-    :raises ClientException: HTTP GET request failed
-    """
-    if not http_conn:
-        http_conn = http_connection(url)
-    if full_listing:
-        rv = get_account(url, token, marker, limit, prefix, http_conn)
-        listing = rv[1]
-        while listing:
-            marker = listing[-1]['name']
-            listing = \
-                get_account(url, token, marker, limit, prefix, http_conn)[1]
-            if listing:
-                rv[1].extend(listing)
-        return rv
-    parsed, conn = http_conn
-    qs = 'format=json'
-    if marker:
-        qs += '&marker=%s' % quote(marker)
-    if limit:
-        qs += '&limit=%d' % limit
-    if prefix:
-        qs += '&prefix=%s' % quote(prefix)
-    conn.request('GET', '%s?%s' % (parsed.path, qs), '',
-                 {'X-Auth-Token': token})
-    resp = conn.getresponse()
-    resp_headers = {}
-    for header, value in resp.getheaders():
-        resp_headers[header.lower()] = value
-    if resp.status < 200 or resp.status >= 300:
-        resp.read()
-        raise ClientException('Account GET failed', http_scheme=parsed.scheme,
-                http_host=conn.host, http_port=conn.port,
-                http_path=parsed.path, http_query=qs, http_status=resp.status,
-                http_reason=resp.reason)
-    if resp.status == 204:
-        resp.read()
-        return resp_headers, []
-    return resp_headers, json_loads(resp.read())
-
-
-def head_account(url, token, http_conn=None):
-    """
-    Get account stats.
-
-    :param url: storage URL
-    :param token: auth token
-    :param http_conn: HTTP connection object (If None, it will create the
-                      conn object)
-    :returns: a dict containing the response's headers (all header names will
-              be lowercase)
-    :raises ClientException: HTTP HEAD request failed
-    """
-    if http_conn:
-        parsed, conn = http_conn
-    else:
-        parsed, conn = http_connection(url)
-    conn.request('HEAD', parsed.path, '', {'X-Auth-Token': token})
-    resp = conn.getresponse()
-    resp.read()
-    if resp.status < 200 or resp.status >= 300:
-        raise ClientException('Account HEAD failed', http_scheme=parsed.scheme,
-                http_host=conn.host, http_port=conn.port,
-                http_path=parsed.path, http_status=resp.status,
-                http_reason=resp.reason)
-    resp_headers = {}
-    for header, value in resp.getheaders():
-        resp_headers[header.lower()] = value
-    return resp_headers
-
-
-def post_account(url, token, headers, http_conn=None):
-    """
-    Update an account's metadata.
-
-    :param url: storage URL
-    :param token: auth token
-    :param headers: additional headers to include in the request
-    :param http_conn: HTTP connection object (If None, it will create the
-                      conn object)
-    :raises ClientException: HTTP POST request failed
-    """
-    if http_conn:
-        parsed, conn = http_conn
-    else:
-        parsed, conn = http_connection(url)
-    headers['X-Auth-Token'] = token
-    conn.request('POST', parsed.path, '', headers)
-    resp = conn.getresponse()
-    resp.read()
-    if resp.status < 200 or resp.status >= 300:
-        raise ClientException('Account POST failed',
-                http_scheme=parsed.scheme, http_host=conn.host,
-                http_port=conn.port, http_path=path, http_status=resp.status,
-                http_reason=resp.reason)
-
-
-def get_container(url, token, container, marker=None, limit=None,
-                  prefix=None, delimiter=None, http_conn=None,
-                  full_listing=False):
-    """
-    Get a listing of objects for the container.
-
-    :param url: storage URL
-    :param token: auth token
-    :param container: container name to get a listing for
-    :param marker: marker query
-    :param limit: limit query
-    :param prefix: prefix query
-    :param delimeter: string to delimit the queries on
-    :param http_conn: HTTP connection object (If None, it will create the
-                      conn object)
-    :param full_listing: if True, return a full listing, else returns a max
-                         of 10000 listings
-    :returns: a tuple of (response headers, a list of objects) The response
-              headers will be a dict and all header names will be lowercase.
-    :raises ClientException: HTTP GET request failed
-    """
-    if not http_conn:
-        http_conn = http_connection(url)
-    if full_listing:
-        rv = get_container(url, token, container, marker, limit, prefix,
-                           delimiter, http_conn)
-        listing = rv[1]
-        while listing:
-            if not delimiter:
-                marker = listing[-1]['name']
-            else:
-                marker = listing[-1].get('name', listing[-1].get('subdir'))
-            listing = get_container(url, token, container, marker, limit,
-                                    prefix, delimiter, http_conn)[1]
-            if listing:
-                rv[1].extend(listing)
-        return rv
-    parsed, conn = http_conn
-    path = '%s/%s' % (parsed.path, quote(container))
-    qs = 'format=json'
-    if marker:
-        qs += '&marker=%s' % quote(marker)
-    if limit:
-        qs += '&limit=%d' % limit
-    if prefix:
-        qs += '&prefix=%s' % quote(prefix)
-    if delimiter:
-        qs += '&delimiter=%s' % quote(delimiter)
-    conn.request('GET', '%s?%s' % (path, qs), '', {'X-Auth-Token': token})
-    resp = conn.getresponse()
-    if resp.status < 200 or resp.status >= 300:
-        resp.read()
-        raise ClientException('Container GET failed',
-                http_scheme=parsed.scheme, http_host=conn.host,
-                http_port=conn.port, http_path=path, http_query=qs,
-                http_status=resp.status, http_reason=resp.reason)
-    resp_headers = {}
-    for header, value in resp.getheaders():
-        resp_headers[header.lower()] = value
-    if resp.status == 204:
-        resp.read()
-        return resp_headers, []
-    return resp_headers, json_loads(resp.read())
-
-
-def head_container(url, token, container, http_conn=None):
-    """
-    Get container stats.
-
-    :param url: storage URL
-    :param token: auth token
-    :param container: container name to get stats for
-    :param http_conn: HTTP connection object (If None, it will create the
-                      conn object)
-    :returns: a dict containing the response's headers (all header names will
-              be lowercase)
-    :raises ClientException: HTTP HEAD request failed
-    """
-    if http_conn:
-        parsed, conn = http_conn
-    else:
-        parsed, conn = http_connection(url)
-    path = '%s/%s' % (parsed.path, quote(container))
-    conn.request('HEAD', path, '', {'X-Auth-Token': token})
-    resp = conn.getresponse()
-    resp.read()
-    if resp.status < 200 or resp.status >= 300:
-        raise ClientException('Container HEAD failed',
-                http_scheme=parsed.scheme, http_host=conn.host,
-                http_port=conn.port, http_path=path, http_status=resp.status,
-                http_reason=resp.reason)
-    resp_headers = {}
-    for header, value in resp.getheaders():
-        resp_headers[header.lower()] = value
-    return resp_headers
-
-
-def put_container(url, token, container, headers=None, http_conn=None):
-    """
-    Create a container
-
-    :param url: storage URL
-    :param token: auth token
-    :param container: container name to create
-    :param headers: additional headers to include in the request
-    :param http_conn: HTTP connection object (If None, it will create the
-                      conn object)
-    :raises ClientException: HTTP PUT request failed
-    """
-    if http_conn:
-        parsed, conn = http_conn
-    else:
-        parsed, conn = http_connection(url)
-    path = '%s/%s' % (parsed.path, quote(container))
-    if not headers:
-        headers = {}
-    headers['X-Auth-Token'] = token
-    conn.request('PUT', path, '', headers)
-    resp = conn.getresponse()
-    resp.read()
-    if resp.status < 200 or resp.status >= 300:
-        raise ClientException('Container PUT failed',
-                http_scheme=parsed.scheme, http_host=conn.host,
-                http_port=conn.port, http_path=path, http_status=resp.status,
-                http_reason=resp.reason)
-
-
-def post_container(url, token, container, headers, http_conn=None):
-    """
-    Update a container's metadata.
-
-    :param url: storage URL
-    :param token: auth token
-    :param container: container name to update
-    :param headers: additional headers to include in the request
-    :param http_conn: HTTP connection object (If None, it will create the
-                      conn object)
-    :raises ClientException: HTTP POST request failed
-    """
-    if http_conn:
-        parsed, conn = http_conn
-    else:
-        parsed, conn = http_connection(url)
-    path = '%s/%s' % (parsed.path, quote(container))
-    headers['X-Auth-Token'] = token
-    conn.request('POST', path, '', headers)
-    resp = conn.getresponse()
-    resp.read()
-    if resp.status < 200 or resp.status >= 300:
-        raise ClientException('Container POST failed',
-                http_scheme=parsed.scheme, http_host=conn.host,
-                http_port=conn.port, http_path=path, http_status=resp.status,
-                http_reason=resp.reason)
-
-
-def delete_container(url, token, container, http_conn=None):
-    """
-    Delete a container
-
-    :param url: storage URL
-    :param token: auth token
-    :param container: container name to delete
-    :param http_conn: HTTP connection object (If None, it will create the
-                      conn object)
-    :raises ClientException: HTTP DELETE request failed
-    """
-    if http_conn:
-        parsed, conn = http_conn
-    else:
-        parsed, conn = http_connection(url)
-    path = '%s/%s' % (parsed.path, quote(container))
-    conn.request('DELETE', path, '', {'X-Auth-Token': token})
-    resp = conn.getresponse()
-    resp.read()
-    if resp.status < 200 or resp.status >= 300:
-        raise ClientException('Container DELETE failed',
-                http_scheme=parsed.scheme, http_host=conn.host,
-                http_port=conn.port, http_path=path, http_status=resp.status,
-                http_reason=resp.reason)
-
-
-def get_object(url, token, container, name, http_conn=None,
-               resp_chunk_size=None):
-    """
-    Get an object
-
-    :param url: storage URL
-    :param token: auth token
-    :param container: container name that the object is in
-    :param name: object name to get
-    :param http_conn: HTTP connection object (If None, it will create the
-                      conn object)
-    :param resp_chunk_size: if defined, chunk size of data to read. NOTE: If
-                            you specify a resp_chunk_size you must fully read
-                            the object's contents before making another
-                            request.
-    :returns: a tuple of (response headers, the object's contents) The response
-              headers will be a dict and all header names will be lowercase.
-    :raises ClientException: HTTP GET request failed
-    """
-    if http_conn:
-        parsed, conn = http_conn
-    else:
-        parsed, conn = http_connection(url)
-    path = '%s/%s/%s' % (parsed.path, quote(container), quote(name))
-    conn.request('GET', path, '', {'X-Auth-Token': token})
-    resp = conn.getresponse()
-    if resp.status < 200 or resp.status >= 300:
-        resp.read()
-        raise ClientException('Object GET failed', http_scheme=parsed.scheme,
-                http_host=conn.host, http_port=conn.port, http_path=path,
-                http_status=resp.status, http_reason=resp.reason)
-    if resp_chunk_size:
-
-        def _object_body():
-            buf = resp.read(resp_chunk_size)
-            while buf:
-                yield buf
-                buf = resp.read(resp_chunk_size)
-        object_body = _object_body()
-    else:
-        object_body = resp.read()
-    resp_headers = {}
-    for header, value in resp.getheaders():
-        resp_headers[header.lower()] = value
-    return resp_headers, object_body
-
-
-def head_object(url, token, container, name, http_conn=None):
-    """
-    Get object info
-
-    :param url: storage URL
-    :param token: auth token
-    :param container: container name that the object is in
-    :param name: object name to get info for
-    :param http_conn: HTTP connection object (If None, it will create the
-                      conn object)
-    :returns: a dict containing the response's headers (all header names will
-              be lowercase)
-    :raises ClientException: HTTP HEAD request failed
-    """
-    if http_conn:
-        parsed, conn = http_conn
-    else:
-        parsed, conn = http_connection(url)
-    path = '%s/%s/%s' % (parsed.path, quote(container), quote(name))
-    conn.request('HEAD', path, '', {'X-Auth-Token': token})
-    resp = conn.getresponse()
-    resp.read()
-    if resp.status < 200 or resp.status >= 300:
-        raise ClientException('Object HEAD failed', http_scheme=parsed.scheme,
-                http_host=conn.host, http_port=conn.port, http_path=path,
-                http_status=resp.status, http_reason=resp.reason)
-    resp_headers = {}
-    for header, value in resp.getheaders():
-        resp_headers[header.lower()] = value
-    return resp_headers
-
-
-def put_object(url, token, container, name, contents, content_length=None,
-               etag=None, chunk_size=65536, content_type=None, headers=None,
-               http_conn=None):
-    """
-    Put an object
-
-    :param url: storage URL
-    :param token: auth token
-    :param container: container name that the object is in
-    :param name: object name to put
-    :param contents: a string or a file like object to read object data from
-    :param content_length: value to send as content-length header; also limits
-                           the amount read from contents
-    :param etag: etag of contents
-    :param chunk_size: chunk size of data to write
-    :param content_type: value to send as content-type header
-    :param headers: additional headers to include in the request
-    :param http_conn: HTTP connection object (If None, it will create the
-                      conn object)
-    :returns: etag from server response
-    :raises ClientException: HTTP PUT request failed
-    """
-    if http_conn:
-        parsed, conn = http_conn
-    else:
-        parsed, conn = http_connection(url)
-    path = '%s/%s/%s' % (parsed.path, quote(container), quote(name))
-    if not headers:
-        headers = {}
-    headers['X-Auth-Token'] = token
-    if etag:
-        headers['ETag'] = etag.strip('"')
-    if content_length is not None:
-        headers['Content-Length'] = str(content_length)
-    if content_type is not None:
-        headers['Content-Type'] = content_type
-    if not contents:
-        headers['Content-Length'] = '0'
-    if hasattr(contents, 'read'):
-        conn.putrequest('PUT', path)
-        for header, value in headers.iteritems():
-            conn.putheader(header, value)
-        if content_length is None:
-            conn.putheader('Transfer-Encoding', 'chunked')
-            conn.endheaders()
-            chunk = contents.read(chunk_size)
-            while chunk:
-                conn.send('%x\r\n%s\r\n' % (len(chunk), chunk))
-                chunk = contents.read(chunk_size)
-            conn.send('0\r\n\r\n')
-        else:
-            conn.endheaders()
-            left = content_length
-            while left > 0:
-                size = chunk_size
-                if size > left:
-                    size = left
-                chunk = contents.read(size)
-                conn.send(chunk)
-                left -= len(chunk)
-    else:
-        conn.request('PUT', path, contents, headers)
-    resp = conn.getresponse()
-    resp.read()
-    if resp.status < 200 or resp.status >= 300:
-        raise ClientException('Object PUT failed', http_scheme=parsed.scheme,
-                http_host=conn.host, http_port=conn.port, http_path=path,
-                http_status=resp.status, http_reason=resp.reason)
-    return resp.getheader('etag').strip('"')
-
-
-def post_object(url, token, container, name, headers, http_conn=None):
-    """
-    Update object metadata
-
-    :param url: storage URL
-    :param token: auth token
-    :param container: container name that the object is in
-    :param name: name of the object to update
-    :param headers: additional headers to include in the request
-    :param http_conn: HTTP connection object (If None, it will create the
-                      conn object)
-    :raises ClientException: HTTP POST request failed
-    """
-    if http_conn:
-        parsed, conn = http_conn
-    else:
-        parsed, conn = http_connection(url)
-    path = '%s/%s/%s' % (parsed.path, quote(container), quote(name))
-    headers['X-Auth-Token'] = token
-    conn.request('POST', path, '', headers)
-    resp = conn.getresponse()
-    resp.read()
-    if resp.status < 200 or resp.status >= 300:
-        raise ClientException('Object POST failed', http_scheme=parsed.scheme,
-                http_host=conn.host, http_port=conn.port, http_path=path,
-                http_status=resp.status, http_reason=resp.reason)
-
-
-def delete_object(url, token, container, name, http_conn=None):
-    """
-    Delete object
-
-    :param url: storage URL
-    :param token: auth token
-    :param container: container name that the object is in
-    :param name: object name to delete
-    :param http_conn: HTTP connection object (If None, it will create the
-                      conn object)
-    :raises ClientException: HTTP DELETE request failed
-    """
-    if http_conn:
-        parsed, conn = http_conn
-    else:
-        parsed, conn = http_connection(url)
-    path = '%s/%s/%s' % (parsed.path, quote(container), quote(name))
-    conn.request('DELETE', path, '', {'X-Auth-Token': token})
-    resp = conn.getresponse()
-    resp.read()
-    if resp.status < 200 or resp.status >= 300:
-        raise ClientException('Object DELETE failed',
-                http_scheme=parsed.scheme, http_host=conn.host,
-                http_port=conn.port, http_path=path, http_status=resp.status,
-                http_reason=resp.reason)
-
-
-class Connection(object):
-    """Convenience class to make requests that will also retry the request"""
-
-    def __init__(self, authurl, user, key, retries=5, preauthurl=None,
-                 preauthtoken=None, snet=False, starting_backoff=1):
-        """
-        :param authurl: authenitcation URL
-        :param user: user name to authenticate as
-        :param key: key/password to authenticate with
-        :param retries: Number of times to retry the request before failing
-        :param preauthurl: storage URL (if you have already authenticated)
-        :param preauthtoken: authentication token (if you have already
-                             authenticated)
-        :param snet: use SERVICENET internal network default is False
-        """
-        self.authurl = authurl
-        self.user = user
-        self.key = key
-        self.retries = retries
-        self.http_conn = None
-        self.url = preauthurl
-        self.token = preauthtoken
-        self.attempts = 0
-        self.snet = snet
-        self.starting_backoff = starting_backoff
-
-    def get_auth(self):
-        return get_auth(self.authurl, self.user, self.key, snet=self.snet)
-
-    def http_connection(self):
-        return http_connection(self.url)
-
-    def _retry(self, reset_func, func, *args, **kwargs):
-        self.attempts = 0
-        backoff = self.starting_backoff
-        while self.attempts <= self.retries:
-            self.attempts += 1
-            try:
-                if not self.url or not self.token:
-                    self.url, self.token = self.get_auth()
-                    self.http_conn = None
-                if not self.http_conn:
-                    self.http_conn = self.http_connection()
-                kwargs['http_conn'] = self.http_conn
-                rv = func(self.url, self.token, *args, **kwargs)
-                return rv
-            except (socket.error, HTTPException):
-                if self.attempts > self.retries:
-                    raise
-                self.http_conn = None
-            except ClientException, err:
-                if self.attempts > self.retries:
-                    raise
-                if err.http_status == 401:
-                    self.url = self.token = None
-                    if self.attempts > 1:
-                        raise
-                elif err.http_status == 408:
-                    self.http_conn = None
-                elif 500 <= err.http_status <= 599:
-                    pass
-                else:
-                    raise
-            sleep(backoff)
-            backoff *= 2
-            if reset_func:
-                reset_func(func, *args, **kwargs)
-
-    def head_account(self):
-        """Wrapper for :func:`head_account`"""
-        return self._retry(None, head_account)
-
-    def get_account(self, marker=None, limit=None, prefix=None,
-                    full_listing=False):
-        """Wrapper for :func:`get_account`"""
-        # TODO(unknown): With full_listing=True this will restart the entire
-        # listing with each retry. Need to make a better version that just
-        # retries where it left off.
-        return self._retry(None, get_account, marker=marker, limit=limit,
-                           prefix=prefix, full_listing=full_listing)
-
-    def post_account(self, headers):
-        """Wrapper for :func:`post_account`"""
-        return self._retry(None, post_account, headers)
-
-    def head_container(self, container):
-        """Wrapper for :func:`head_container`"""
-        return self._retry(None, head_container, container)
-
-    def get_container(self, container, marker=None, limit=None, prefix=None,
-                      delimiter=None, full_listing=False):
-        """Wrapper for :func:`get_container`"""
-        # TODO(unknown): With full_listing=True this will restart the entire
-        # listing with each retry. Need to make a better version that just
-        # retries where it left off.
-        return self._retry(None, get_container, container, marker=marker,
-                           limit=limit, prefix=prefix, delimiter=delimiter,
-                           full_listing=full_listing)
-
-    def put_container(self, container, headers=None):
-        """Wrapper for :func:`put_container`"""
-        return self._retry(None, put_container, container, headers=headers)
-
-    def post_container(self, container, headers):
-        """Wrapper for :func:`post_container`"""
-        return self._retry(None, post_container, container, headers)
-
-    def delete_container(self, container):
-        """Wrapper for :func:`delete_container`"""
-        return self._retry(None, delete_container, container)
-
-    def head_object(self, container, obj):
-        """Wrapper for :func:`head_object`"""
-        return self._retry(None, head_object, container, obj)
-
-    def get_object(self, container, obj, resp_chunk_size=None):
-        """Wrapper for :func:`get_object`"""
-        return self._retry(None, get_object, container, obj,
-                           resp_chunk_size=resp_chunk_size)
-
-    def put_object(self, container, obj, contents, content_length=None,
-                   etag=None, chunk_size=65536, content_type=None,
-                   headers=None):
-        """Wrapper for :func:`put_object`"""
-
-        def _default_reset(*args, **kwargs):
-            raise ClientException('put_object(%r, %r, ...) failure and no '
-                'ability to reset contents for reupload.' % (container, obj))
-
-        reset_func = _default_reset
-        tell = getattr(contents, 'tell', None)
-        seek = getattr(contents, 'seek', None)
-        if tell and seek:
-            orig_pos = tell()
-            reset_func = lambda *a, **k: seek(orig_pos)
-        elif not contents:
-            reset_func = lambda *a, **k: None
-
-        return self._retry(reset_func, put_object, container, obj, contents,
-            content_length=content_length, etag=etag, chunk_size=chunk_size,
-            content_type=content_type, headers=headers)
-
-    def post_object(self, container, obj, headers):
-        """Wrapper for :func:`post_object`"""
-        return self._retry(None, post_object, container, obj, headers)
-
-    def delete_object(self, container, obj):
-        """Wrapper for :func:`delete_object`"""
-        return self._retry(None, delete_object, container, obj)
-
-# End inclusion of swift.common.client
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
-
-
-def mkdirs(path):
-    try:
-        makedirs(path)
-    except OSError, err:
-        if err.errno != EEXIST:
-            raise
-
-
-def put_errors_from_threads(threads, error_queue):
-    """
-    Places any errors from the threads into error_queue.
-    :param threads: A list of QueueFunctionThread instances.
-    :param error_queue: A queue to put error strings into.
-    :returns: True if any errors were found.
-    """
-    was_error = False
-    for thread in threads:
-        for info in thread.exc_infos:
-            was_error = True
-            if isinstance(info[1], ClientException):
-                error_queue.put(str(info[1]))
-            else:
-                error_queue.put(''.join(format_exception(*info)))
-    return was_error
-
-
-class QueueFunctionThread(Thread):
-
-    def __init__(self, queue, func, *args, **kwargs):
-        """ Calls func for each item in queue; func is called with a queued
-            item as the first arg followed by *args and **kwargs. Use the abort
-            attribute to have the thread empty the queue (without processing)
-            and exit. """
-        Thread.__init__(self)
-        self.abort = False
-        self.queue = queue
-        self.func = func
-        self.args = args
-        self.kwargs = kwargs
-        self.exc_infos = []
-
-    def run(self):
-        try:
-            while True:
-                try:
-                    item = self.queue.get_nowait()
-                    if not self.abort:
-                        self.func(item, *self.args, **self.kwargs)
-                    self.queue.task_done()
-                except Empty:
-                    if self.abort:
-                        break
-                    sleep(0.01)
-        except Exception:
-            self.exc_infos.append(exc_info())
-
-
-st_delete_help = '''
-delete --all OR delete container [--leave-segments] [object] [object] ...
-    Deletes everything in the account (with --all), or everything in a
-    container, or a list of objects depending on the args given. Segments of
-    manifest objects will be deleted as well, unless you specify the
-    --leave-segments option.'''.strip('\n')
-
-
-def st_delete(parser, args, print_queue, error_queue):
-    parser.add_option('-a', '--all', action='store_true', dest='yes_all',
-        default=False, help='Indicates that you really want to delete '
-        'everything in the account')
-    parser.add_option('', '--leave-segments', action='store_true',
-        dest='leave_segments', default=False, help='Indicates that you want '
-        'the segments of manifest objects left alone')
-    (options, args) = parse_args(parser, args)
-    args = args[1:]
-    if (not args and not options.yes_all) or (args and options.yes_all):
-        error_queue.put('Usage: %s [options] %s' %
-                        (basename(argv[0]), st_delete_help))
-        return
-
-    def _delete_segment((container, obj), conn):
-        conn.delete_object(container, obj)
-        if options.verbose:
-            if conn.attempts > 2:
-                print_queue.put('%s/%s [after %d attempts]' %
-                                (container, obj, conn.attempts))
-            else:
-                print_queue.put('%s/%s' % (container, obj))
-
-    object_queue = Queue(10000)
-
-    def _delete_object((container, obj), conn):
-        try:
-            old_manifest = None
-            if not options.leave_segments:
-                try:
-                    old_manifest = conn.head_object(container, obj).get(
-                        'x-object-manifest')
-                except ClientException, err:
-                    if err.http_status != 404:
-                        raise
-            conn.delete_object(container, obj)
-            if old_manifest:
-                segment_queue = Queue(10000)
-                scontainer, sprefix = old_manifest.split('/', 1)
-                for delobj in conn.get_container(scontainer,
-                                                 prefix=sprefix)[1]:
-                    segment_queue.put((scontainer, delobj['name']))
-                if not segment_queue.empty():
-                    segment_threads = [QueueFunctionThread(segment_queue,
-                        _delete_segment, create_connection()) for _junk in
-                        xrange(10)]
-                    for thread in segment_threads:
-                        thread.start()
-                    while not segment_queue.empty():
-                        sleep(0.01)
-                    for thread in segment_threads:
-                        thread.abort = True
-                        while thread.isAlive():
-                            thread.join(0.01)
-                    put_errors_from_threads(segment_threads, error_queue)
-            if options.verbose:
-                path = options.yes_all and join(container, obj) or obj
-                if path[:1] in ('/', '\\'):
-                    path = path[1:]
-                if conn.attempts > 1:
-                    print_queue.put('%s [after %d attempts]' %
-                                    (path, conn.attempts))
-                else:
-                    print_queue.put(path)
-        except ClientException, err:
-            if err.http_status != 404:
-                raise
-            error_queue.put('Object %s not found' %
-                            repr('%s/%s' % (container, obj)))
-
-    container_queue = Queue(10000)
-
-    def _delete_container(container, conn):
-        try:
-            marker = ''
-            while True:
-                objects = [o['name'] for o in
-                           conn.get_container(container, marker=marker)[1]]
-                if not objects:
-                    break
-                for obj in objects:
-                    object_queue.put((container, obj))
-                marker = objects[-1]
-            while not object_queue.empty():
-                sleep(0.01)
-            attempts = 1
-            while True:
-                try:
-                    conn.delete_container(container)
-                    break
-                except ClientException, err:
-                    if err.http_status != 409:
-                        raise
-                    if attempts > 10:
-                        raise
-                    attempts += 1
-                    sleep(1)
-        except ClientException, err:
-            if err.http_status != 404:
-                raise
-            error_queue.put('Container %s not found' % repr(container))
-
-    url, token = get_auth(options.auth, options.user, options.key,
-        snet=options.snet)
-    create_connection = lambda: Connection(options.auth, options.user,
-        options.key, preauthurl=url, preauthtoken=token, snet=options.snet)
-    object_threads = [QueueFunctionThread(object_queue, _delete_object,
-        create_connection()) for _junk in xrange(10)]
-    for thread in object_threads:
-        thread.start()
-    container_threads = [QueueFunctionThread(container_queue,
-        _delete_container, create_connection()) for _junk in xrange(10)]
-    for thread in container_threads:
-        thread.start()
-    if not args:
-        conn = create_connection()
-        try:
-            marker = ''
-            while True:
-                containers = \
-                    [c['name'] for c in conn.get_account(marker=marker)[1]]
-                if not containers:
-                    break
-                for container in containers:
-                    container_queue.put(container)
-                marker = containers[-1]
-            while not container_queue.empty():
-                sleep(0.01)
-            while not object_queue.empty():
-                sleep(0.01)
-        except ClientException, err:
-            if err.http_status != 404:
-                raise
-            error_queue.put('Account not found')
-    elif len(args) == 1:
-        if '/' in args[0]:
-            print >> stderr, 'WARNING: / in container name; you might have ' \
-                             'meant %r instead of %r.' % \
-                             (args[0].replace('/', ' ', 1), args[0])
-        conn = create_connection()
-        _delete_container(args[0], conn)
-    else:
-        for obj in args[1:]:
-            object_queue.put((args[0], obj))
-    while not container_queue.empty():
-        sleep(0.01)
-    for thread in container_threads:
-        thread.abort = True
-        while thread.isAlive():
-            thread.join(0.01)
-    put_errors_from_threads(container_threads, error_queue)
-    while not object_queue.empty():
-        sleep(0.01)
-    for thread in object_threads:
-        thread.abort = True
-        while thread.isAlive():
-            thread.join(0.01)
-    put_errors_from_threads(object_threads, error_queue)
-
-
-st_download_help = '''
-download --all OR download container [options] [object] [object] ...
-    Downloads everything in the account (with --all), or everything in a
-    container, or a list of objects depending on the args given. For a single
-    object download, you may use the -o [--output] <filename> option to
-    redirect the output to a specific file or if "-" then just redirect to
-    stdout.'''.strip('\n')
-
-
-def st_download(options, args, print_queue, error_queue):
-    parser.add_option('-a', '--all', action='store_true', dest='yes_all',
-        default=False, help='Indicates that you really want to download '
-        'everything in the account')
-    parser.add_option('-o', '--output', dest='out_file', help='For a single '
-        'file download, stream the output to an alternate location ')
-    (options, args) = parse_args(parser, args)
-    args = args[1:]
-    if options.out_file == '-':
-        options.verbose = 0
-    if options.out_file and len(args) != 2:
-        exit('-o option only allowed for single file downloads')
-    if (not args and not options.yes_all) or (args and options.yes_all):
-        error_queue.put('Usage: %s [options] %s' %
-                        (basename(argv[0]), st_download_help))
-        return
-
-    object_queue = Queue(10000)
-
-    def _download_object(queue_arg, conn):
-        if len(queue_arg) == 2:
-            container, obj = queue_arg
-            out_file = None
-        elif len(queue_arg) == 3:
-            container, obj, out_file = queue_arg
-        else:
-            raise Exception("Invalid queue_arg length of %s" % len(queue_arg))
-        try:
-            headers, body = \
-                conn.get_object(container, obj, resp_chunk_size=65536)
-            content_type = headers.get('content-type')
-            if 'content-length' in headers:
-                content_length = int(headers.get('content-length'))
-            else:
-                content_length = None
-            etag = headers.get('etag')
-            path = options.yes_all and join(container, obj) or obj
-            if path[:1] in ('/', '\\'):
-                path = path[1:]
-            md5sum = None
-            make_dir = out_file != "-"
-            if content_type.split(';', 1)[0] == 'text/directory':
-                if make_dir and not isdir(path):
-                    mkdirs(path)
-                read_length = 0
-                if 'x-object-manifest' not in headers:
-                    md5sum = md5()
-                for chunk in body:
-                    read_length += len(chunk)
-                    if md5sum:
-                        md5sum.update(chunk)
-            else:
-                dirpath = dirname(path)
-                if make_dir and dirpath and not isdir(dirpath):
-                    mkdirs(dirpath)
-                if out_file == "-":
-                    fp = stdout
-                elif out_file:
-                    fp = open(out_file, 'wb')
-                else:
-                    fp = open(path, 'wb')
-                read_length = 0
-                if 'x-object-manifest' not in headers:
-                    md5sum = md5()
-                for chunk in body:
-                    fp.write(chunk)
-                    read_length += len(chunk)
-                    if md5sum:
-                        md5sum.update(chunk)
-                fp.close()
-            if md5sum and md5sum.hexdigest() != etag:
-                error_queue.put('%s: md5sum != etag, %s != %s' %
-                                (path, md5sum.hexdigest(), etag))
-            if content_length is not None and read_length != content_length:
-                error_queue.put('%s: read_length != content_length, %d != %d' %
-                                (path, read_length, content_length))
-            if 'x-object-meta-mtime' in headers and not options.out_file:
-                mtime = float(headers['x-object-meta-mtime'])
-                utime(path, (mtime, mtime))
-            if options.verbose:
-                if conn.attempts > 1:
-                    print_queue.put('%s [after %d attempts' %
-                                    (path, conn.attempts))
-                else:
-                    print_queue.put(path)
-        except ClientException, err:
-            if err.http_status != 404:
-                raise
-            error_queue.put('Object %s not found' %
-                            repr('%s/%s' % (container, obj)))
-
-    container_queue = Queue(10000)
-
-    def _download_container(container, conn):
-        try:
-            marker = ''
-            while True:
-                objects = [o['name'] for o in
-                           conn.get_container(container, marker=marker)[1]]
-                if not objects:
-                    break
-                for obj in objects:
-                    object_queue.put((container, obj))
-                marker = objects[-1]
-        except ClientException, err:
-            if err.http_status != 404:
-                raise
-            error_queue.put('Container %s not found' % repr(container))
-
-    url, token = get_auth(options.auth, options.user, options.key,
-        snet=options.snet)
-    create_connection = lambda: Connection(options.auth, options.user,
-        options.key, preauthurl=url, preauthtoken=token, snet=options.snet)
-    object_threads = [QueueFunctionThread(object_queue, _download_object,
-        create_connection()) for _junk in xrange(10)]
-    for thread in object_threads:
-        thread.start()
-    container_threads = [QueueFunctionThread(container_queue,
-        _download_container, create_connection()) for _junk in xrange(10)]
-    for thread in container_threads:
-        thread.start()
-    if not args:
-        conn = create_connection()
-        try:
-            marker = ''
-            while True:
-                containers = [c['name']
-                              for c in conn.get_account(marker=marker)[1]]
-                if not containers:
-                    break
-                for container in containers:
-                    container_queue.put(container)
-                marker = containers[-1]
-        except ClientException, err:
-            if err.http_status != 404:
-                raise
-            error_queue.put('Account not found')
-    elif len(args) == 1:
-        if '/' in args[0]:
-            print >> stderr, 'WARNING: / in container name; you might have ' \
-                             'meant %r instead of %r.' % \
-                             (args[0].replace('/', ' ', 1), args[0])
-        _download_container(args[0], create_connection())
-    else:
-        if len(args) == 2:
-            obj = args[1]
-            object_queue.put((args[0], obj, options.out_file))
-        else:
-            for obj in args[1:]:
-                object_queue.put((args[0], obj))
-    while not container_queue.empty():
-        sleep(0.01)
-    for thread in container_threads:
-        thread.abort = True
-        while thread.isAlive():
-            thread.join(0.01)
-    put_errors_from_threads(container_threads, error_queue)
-    while not object_queue.empty():
-        sleep(0.01)
-    for thread in object_threads:
-        thread.abort = True
-        while thread.isAlive():
-            thread.join(0.01)
-    put_errors_from_threads(object_threads, error_queue)
-
-
-st_list_help = '''
-list [options] [container]
-    Lists the containers for the account or the objects for a container. -p or
-    --prefix is an option that will only list items beginning with that prefix.
-    -d or --delimiter is option (for container listings only) that will roll up
-    items with the given delimiter (see Cloud Files general documentation for
-    what this means).
-'''.strip('\n')
-
-
-def st_list(options, args, print_queue, error_queue):
-    parser.add_option('-p', '--prefix', dest='prefix', help='Will only list '
-        'items beginning with the prefix')
-    parser.add_option('-d', '--delimiter', dest='delimiter', help='Will roll '
-        'up items with the given delimiter (see Cloud Files general '
-        'documentation for what this means)')
-    (options, args) = parse_args(parser, args)
-    args = args[1:]
-    if options.delimiter and not args:
-        exit('-d option only allowed for container listings')
-    if len(args) > 1:
-        error_queue.put('Usage: %s [options] %s' %
-                        (basename(argv[0]), st_list_help))
-        return
-    conn = Connection(options.auth, options.user, options.key,
-        snet=options.snet)
-    try:
-        marker = ''
-        while True:
-            if not args:
-                items = \
-                    conn.get_account(marker=marker, prefix=options.prefix)[1]
-            else:
-                items = conn.get_container(args[0], marker=marker,
-                    prefix=options.prefix, delimiter=options.delimiter)[1]
-            if not items:
-                break
-            for item in items:
-                print_queue.put(item.get('name', item.get('subdir')))
-            marker = items[-1].get('name', items[-1].get('subdir'))
-    except ClientException, err:
-        if err.http_status != 404:
-            raise
-        if not args:
-            error_queue.put('Account not found')
-        else:
-            error_queue.put('Container %s not found' % repr(args[0]))
-
-
-st_stat_help = '''
-stat [container] [object]
-    Displays information for the account, container, or object depending on the
-    args given (if any).'''.strip('\n')
-
-
-def st_stat(options, args, print_queue, error_queue):
-    (options, args) = parse_args(parser, args)
-    args = args[1:]
-    conn = Connection(options.auth, options.user, options.key)
-    if not args:
-        try:
-            headers = conn.head_account()
-            if options.verbose > 1:
-                print_queue.put('''
-StorageURL: %s
-Auth Token: %s
-'''.strip('\n') % (conn.url, conn.token))
-            container_count = int(headers.get('x-account-container-count', 0))
-            object_count = int(headers.get('x-account-object-count', 0))
-            bytes_used = int(headers.get('x-account-bytes-used', 0))
-            print_queue.put('''
-   Account: %s
-Containers: %d
-   Objects: %d
-     Bytes: %d'''.strip('\n') % (conn.url.rsplit('/', 1)[-1], container_count,
-                                 object_count, bytes_used))
-            for key, value in headers.items():
-                if key.startswith('x-account-meta-'):
-                    print_queue.put('%10s: %s' % ('Meta %s' %
-                        key[len('x-account-meta-'):].title(), value))
-            for key, value in headers.items():
-                if not key.startswith('x-account-meta-') and key not in (
-                        'content-length', 'date', 'x-account-container-count',
-                        'x-account-object-count', 'x-account-bytes-used'):
-                    print_queue.put(
-                        '%10s: %s' % (key.title(), value))
-        except ClientException, err:
-            if err.http_status != 404:
-                raise
-            error_queue.put('Account not found')
-    elif len(args) == 1:
-        if '/' in args[0]:
-            print >> stderr, 'WARNING: / in container name; you might have ' \
-                             'meant %r instead of %r.' % \
-                             (args[0].replace('/', ' ', 1), args[0])
-        try:
-            headers = conn.head_container(args[0])
-            object_count = int(headers.get('x-container-object-count', 0))
-            bytes_used = int(headers.get('x-container-bytes-used', 0))
-            print_queue.put('''
-  Account: %s
-Container: %s
-  Objects: %d
-    Bytes: %d
- Read ACL: %s
-Write ACL: %s'''.strip('\n') % (conn.url.rsplit('/', 1)[-1], args[0],
-                                object_count, bytes_used,
-                                headers.get('x-container-read', ''),
-                                headers.get('x-container-write', '')))
-            for key, value in headers.items():
-                if key.startswith('x-container-meta-'):
-                    print_queue.put('%9s: %s' % ('Meta %s' %
-                        key[len('x-container-meta-'):].title(), value))
-            for key, value in headers.items():
-                if not key.startswith('x-container-meta-') and key not in (
-                        'content-length', 'date', 'x-container-object-count',
-                        'x-container-bytes-used', 'x-container-read',
-                        'x-container-write'):
-                    print_queue.put(
-                        '%9s: %s' % (key.title(), value))
-        except ClientException, err:
-            if err.http_status != 404:
-                raise
-            error_queue.put('Container %s not found' % repr(args[0]))
-    elif len(args) == 2:
-        try:
-            headers = conn.head_object(args[0], args[1])
-            print_queue.put('''
-       Account: %s
-     Container: %s
-        Object: %s
-  Content Type: %s'''.strip('\n') % (conn.url.rsplit('/', 1)[-1], args[0],
-                                     args[1], headers.get('content-type')))
-            if 'content-length' in headers:
-                print_queue.put('Content Length: %s' %
-                                headers['content-length'])
-            if 'last-modified' in headers:
-                print_queue.put(' Last Modified: %s' %
-                                headers['last-modified'])
-            if 'etag' in headers:
-                print_queue.put('          ETag: %s' % headers['etag'])
-            if 'x-object-manifest' in headers:
-                print_queue.put('      Manifest: %s' %
-                                headers['x-object-manifest'])
-            for key, value in headers.items():
-                if key.startswith('x-object-meta-'):
-                    print_queue.put('%14s: %s' % ('Meta %s' %
-                        key[len('x-object-meta-'):].title(), value))
-            for key, value in headers.items():
-                if not key.startswith('x-object-meta-') and key not in (
-                        'content-type', 'content-length', 'last-modified',
-                        'etag', 'date', 'x-object-manifest'):
-                    print_queue.put(
-                        '%14s: %s' % (key.title(), value))
-        except ClientException, err:
-            if err.http_status != 404:
-                raise
-            error_queue.put('Object %s not found' %
-                            repr('%s/%s' % (args[0], args[1])))
-    else:
-        error_queue.put('Usage: %s [options] %s' %
-                        (basename(argv[0]), st_stat_help))
-
-
-st_post_help = '''
-post [options] [container] [object]
-    Updates meta information for the account, container, or object depending on
-    the args given. If the container is not found, it will be created
-    automatically; but this is not true for accounts and objects. Containers
-    also allow the -r (or --read-acl) and -w (or --write-acl) options. The -m
-    or --meta option is allowed on all and used to define the user meta data
-    items to set in the form Name:Value. This option can be repeated. Example:
-    post -m Color:Blue -m Size:Large'''.strip('\n')
-
-
-def st_post(options, args, print_queue, error_queue):
-    parser.add_option('-r', '--read-acl', dest='read_acl', help='Sets the '
-        'Read ACL for containers. Quick summary of ACL syntax: .r:*, '
-        '.r:-.example.com, .r:www.example.com, account1, account2:user2')
-    parser.add_option('-w', '--write-acl', dest='write_acl', help='Sets the '
-        'Write ACL for containers. Quick summary of ACL syntax: account1, '
-        'account2:user2')
-    parser.add_option('-m', '--meta', action='append', dest='meta', default=[],
-        help='Sets a meta data item with the syntax name:value. This option '
-        'may be repeated. Example: -m Color:Blue -m Size:Large')
-    (options, args) = parse_args(parser, args)
-    args = args[1:]
-    if (options.read_acl or options.write_acl) and not args:
-        exit('-r and -w options only allowed for containers')
-    conn = Connection(options.auth, options.user, options.key)
-    if not args:
-        headers = {}
-        for item in options.meta:
-            split_item = item.split(':')
-            headers['X-Account-Meta-' + split_item[0]] = \
-                len(split_item) > 1 and split_item[1]
-        try:
-            conn.post_account(headers=headers)
-        except ClientException, err:
-            if err.http_status != 404:
-                raise
-            error_queue.put('Account not found')
-    elif len(args) == 1:
-        if '/' in args[0]:
-            print >> stderr, 'WARNING: / in container name; you might have ' \
-                             'meant %r instead of %r.' % \
-                             (args[0].replace('/', ' ', 1), args[0])
-        headers = {}
-        for item in options.meta:
-            split_item = item.split(':')
-            headers['X-Container-Meta-' + split_item[0]] = \
-                len(split_item) > 1 and split_item[1]
-        if options.read_acl is not None:
-            headers['X-Container-Read'] = options.read_acl
-        if options.write_acl is not None:
-            headers['X-Container-Write'] = options.write_acl
-        try:
-            conn.post_container(args[0], headers=headers)
-        except ClientException, err:
-            if err.http_status != 404:
-                raise
-            conn.put_container(args[0], headers=headers)
-    elif len(args) == 2:
-        headers = {}
-        for item in options.meta:
-            split_item = item.split(':')
-            headers['X-Object-Meta-' + split_item[0]] = \
-                len(split_item) > 1 and split_item[1]
-        try:
-            conn.post_object(args[0], args[1], headers=headers)
-        except ClientException, err:
-            if err.http_status != 404:
-                raise
-            error_queue.put('Object %s not found' %
-                            repr('%s/%s' % (args[0], args[1])))
-    else:
-        error_queue.put('Usage: %s [options] %s' %
-                        (basename(argv[0]), st_post_help))
-
-
-st_upload_help = '''
-upload [options] container file_or_directory [file_or_directory] [...]
-    Uploads to the given container the files and directories specified by the
-    remaining args. -c or --changed is an option that will only upload files
-    that have changed since the last upload. -S <size> or --segment-size <size>
-    and --leave-segments are options as well (see --help for more).
-'''.strip('\n')
-
-
-def st_upload(options, args, print_queue, error_queue):
-    parser.add_option('-c', '--changed', action='store_true', dest='changed',
-        default=False, help='Will only upload files that have changed since '
-        'the last upload')
-    parser.add_option('-S', '--segment-size', dest='segment_size', help='Will '
-        'upload files in segments no larger than <size> and then create a '
-        '"manifest" file that will download all the segments as if it were '
-        'the original file. The segments will be uploaded to a '
-        '<container>_segments container so as to not pollute the main '
-        '<container> listings.')
-    parser.add_option('', '--leave-segments', action='store_true',
-        dest='leave_segments', default=False, help='Indicates that you want '
-        'the older segments of manifest objects left alone (in the case of '
-        'overwrites)')
-    (options, args) = parse_args(parser, args)
-    args = args[1:]
-    if len(args) < 2:
-        error_queue.put('Usage: %s [options] %s' %
-                        (basename(argv[0]), st_upload_help))
-        return
-    object_queue = Queue(10000)
-
-    def _segment_job(job, conn):
-        if job.get('delete', False):
-            conn.delete_object(job['container'], job['obj'])
-        else:
-            fp = open(job['path'], 'rb')
-            fp.seek(job['segment_start'])
-            conn.put_object(job.get('container', args[0] + '_segments'),
-                job['obj'], fp, content_length=job['segment_size'])
-        if options.verbose and 'log_line' in job:
-            if conn.attempts > 1:
-                print_queue.put('%s [after %d attempts]' %
-                                (job['log_line'], conn.attempts))
-            else:
-                print_queue.put(job['log_line'])
-
-    def _object_job(job, conn):
-        path = job['path']
-        container = job.get('container', args[0])
-        dir_marker = job.get('dir_marker', False)
-        try:
-            obj = path
-            if obj.startswith('./') or obj.startswith('.\\'):
-                obj = obj[2:]
-            put_headers = {'x-object-meta-mtime': str(getmtime(path))}
-            if dir_marker:
-                if options.changed:
-                    try:
-                        headers = conn.head_object(container, obj)
-                        ct = headers.get('content-type')
-                        cl = int(headers.get('content-length'))
-                        et = headers.get('etag')
-                        mt = headers.get('x-object-meta-mtime')
-                        if ct.split(';', 1)[0] == 'text/directory' and \
-                                cl == 0 and \
-                                et == 'd41d8cd98f00b204e9800998ecf8427e' and \
-                                mt == put_headers['x-object-meta-mtime']:
-                            return
-                    except ClientException, err:
-                        if err.http_status != 404:
-                            raise
-                conn.put_object(container, obj, '', content_length=0,
-                                content_type='text/directory',
-                                headers=put_headers)
-            else:
-                # We need to HEAD all objects now in case we're overwriting a
-                # manifest object and need to delete the old segments
-                # ourselves.
-                old_manifest = None
-                if options.changed or not options.leave_segments:
-                    try:
-                        headers = conn.head_object(container, obj)
-                        cl = int(headers.get('content-length'))
-                        mt = headers.get('x-object-meta-mtime')
-                        if options.changed and cl == getsize(path) and \
-                                mt == put_headers['x-object-meta-mtime']:
-                            return
-                        if not options.leave_segments:
-                            old_manifest = headers.get('x-object-manifest')
-                    except ClientException, err:
-                        if err.http_status != 404:
-                            raise
-                if options.segment_size and \
-                        getsize(path) < options.segment_size:
-                    full_size = getsize(path)
-                    segment_queue = Queue(10000)
-                    segment_threads = [QueueFunctionThread(segment_queue,
-                        _segment_job, create_connection()) for _junk in
-                        xrange(10)]
-                    for thread in segment_threads:
-                        thread.start()
-                    segment = 0
-                    segment_start = 0
-                    while segment_start < full_size:
-                        segment_size = int(options.segment_size)
-                        if segment_start + segment_size > full_size:
-                            segment_size = full_size - segment_start
-                        segment_queue.put({'path': path,
-                            'obj': '%s/%s/%s/%08d' % (obj,
-                                put_headers['x-object-meta-mtime'], full_size,
-                                segment),
-                            'segment_start': segment_start,
-                            'segment_size': segment_size,
-                            'log_line': '%s segment %s' % (obj, segment)})
-                        segment += 1
-                        segment_start += segment_size
-                    while not segment_queue.empty():
-                        sleep(0.01)
-                    for thread in segment_threads:
-                        thread.abort = True
-                        while thread.isAlive():
-                            thread.join(0.01)
-                    if put_errors_from_threads(segment_threads, error_queue):
-                        raise ClientException('Aborting manifest creation '
-                            'because not all segments could be uploaded. %s/%s'
-                            % (container, obj))
-                    new_object_manifest = '%s_segments/%s/%s/%s/' % (
-                        container, obj, put_headers['x-object-meta-mtime'],
-                        full_size)
-                    if old_manifest == new_object_manifest:
-                        old_manifest = None
-                    put_headers['x-object-manifest'] = new_object_manifest
-                    conn.put_object(container, obj, '', content_length=0,
-                                    headers=put_headers)
-                else:
-                    conn.put_object(container, obj, open(path, 'rb'),
-                        content_length=getsize(path), headers=put_headers)
-                if old_manifest:
-                    segment_queue = Queue(10000)
-                    scontainer, sprefix = old_manifest.split('/', 1)
-                    for delobj in conn.get_container(scontainer,
-                                                     prefix=sprefix)[1]:
-                        segment_queue.put({'delete': True,
-                            'container': scontainer, 'obj': delobj['name']})
-                    if not segment_queue.empty():
-                        segment_threads = [QueueFunctionThread(segment_queue,
-                            _segment_job, create_connection()) for _junk in
-                            xrange(10)]
-                        for thread in segment_threads:
-                            thread.start()
-                        while not segment_queue.empty():
-                            sleep(0.01)
-                        for thread in segment_threads:
-                            thread.abort = True
-                            while thread.isAlive():
-                                thread.join(0.01)
-                        put_errors_from_threads(segment_threads, error_queue)
-            if options.verbose:
-                if conn.attempts > 1:
-                    print_queue.put(
-                        '%s [after %d attempts]' % (obj, conn.attempts))
-                else:
-                    print_queue.put(obj)
-        except OSError, err:
-            if err.errno != ENOENT:
-                raise
-            error_queue.put('Local file %s not found' % repr(path))
-
-    def _upload_dir(path):
-        names = listdir(path)
-        if not names:
-            object_queue.put({'path': path, 'dir_marker': True})
-        else:
-            for name in listdir(path):
-                subpath = join(path, name)
-                if isdir(subpath):
-                    _upload_dir(subpath)
-                else:
-                    object_queue.put({'path': subpath})
-
-    url, token = get_auth(options.auth, options.user, options.key,
-        snet=options.snet)
-    create_connection = lambda: Connection(options.auth, options.user,
-        options.key, preauthurl=url, preauthtoken=token, snet=options.snet)
-    object_threads = [QueueFunctionThread(object_queue, _object_job,
-        create_connection()) for _junk in xrange(10)]
-    for thread in object_threads:
-        thread.start()
-    conn = create_connection()
-    # Try to create the container, just in case it doesn't exist. If this
-    # fails, it might just be because the user doesn't have container PUT
-    # permissions, so we'll ignore any error. If there's really a problem,
-    # it'll surface on the first object PUT.
-    try:
-        conn.put_container(args[0])
-        if options.segment_size is not None:
-            conn.put_container(args[0] + '_segments')
-    except Exception:
-        pass
-    try:
-        for arg in args[1:]:
-            if isdir(arg):
-                _upload_dir(arg)
-            else:
-                object_queue.put({'path': arg})
-        while not object_queue.empty():
-            sleep(0.01)
-        for thread in object_threads:
-            thread.abort = True
-            while thread.isAlive():
-                thread.join(0.01)
-        put_errors_from_threads(object_threads, error_queue)
-    except ClientException, err:
-        if err.http_status != 404:
-            raise
-        error_queue.put('Account not found')
-
-
-def parse_args(parser, args, enforce_requires=True):
-    if not args:
-        args = ['-h']
-    (options, args) = parser.parse_args(args)
-    if enforce_requires and \
-            not (options.auth and options.user and options.key):
-        exit('''
-Requires ST_AUTH, ST_USER, and ST_KEY environment variables be set or
-overridden with -A, -U, or -K.'''.strip('\n'))
-    return options, args
-
-
-if __name__ == '__main__':
-    parser = OptionParser(version='%prog 1.0', usage='''
-Usage: %%prog <command> [options] [args]
-
-Commands:
-  %(st_stat_help)s
-  %(st_list_help)s
-  %(st_upload_help)s
-  %(st_post_help)s
-  %(st_download_help)s
-  %(st_delete_help)s
-
-Example:
-  %%prog -A https://auth.api.rackspacecloud.com/v1.0 -U user -K key stat
-'''.strip('\n') % globals())
-    parser.add_option('-s', '--snet', action='store_true', dest='snet',
-                      default=False, help='Use SERVICENET internal network')
-    parser.add_option('-v', '--verbose', action='count', dest='verbose',
-                      default=1, help='Print more info')
-    parser.add_option('-q', '--quiet', action='store_const', dest='verbose',
-                      const=0, default=1, help='Suppress status output')
-    parser.add_option('-A', '--auth', dest='auth',
-                      default=environ.get('ST_AUTH'),
-                      help='URL for obtaining an auth token')
-    parser.add_option('-U', '--user', dest='user',
-                      default=environ.get('ST_USER'),
-                      help='User name for obtaining an auth token')
-    parser.add_option('-K', '--key', dest='key',
-                      default=environ.get('ST_KEY'),
-                      help='Key for obtaining an auth token')
-    parser.disable_interspersed_args()
-    (options, args) = parse_args(parser, argv[1:], enforce_requires=False)
-    parser.enable_interspersed_args()
-
-    commands = ('delete', 'download', 'list', 'post', 'stat', 'upload')
-    if not args or args[0] not in commands:
-        parser.print_usage()
-        if args:
-            exit('no such command: %s' % args[0])
-        exit()
-
-    print_queue = Queue(10000)
-
-    def _print(item):
-        if isinstance(item, unicode):
-            item = item.encode('utf8')
-        print item
-
-    print_thread = QueueFunctionThread(print_queue, _print)
-    print_thread.start()
-
-    error_queue = Queue(10000)
-
-    def _error(item):
-        if isinstance(item, unicode):
-            item = item.encode('utf8')
-        print >> stderr, item
-
-    error_thread = QueueFunctionThread(error_queue, _error)
-    error_thread.start()
-
-    try:
-        parser.usage = globals()['st_%s_help' % args[0]]
-        try:
-            globals()['st_%s' % args[0]](parser, argv[1:], print_queue,
-                                         error_queue)
-        except (ClientException, HTTPException, socket.error), err:
-            error_queue.put(str(err))
-        while not print_queue.empty():
-            sleep(0.01)
-        print_thread.abort = True
-        while print_thread.isAlive():
-            print_thread.join(0.01)
-        while not error_queue.empty():
-            sleep(0.01)
-        error_thread.abort = True
-        while error_thread.isAlive():
-            error_thread.join(0.01)
-    except (SystemExit, Exception):
-        for thread in threading_enumerate():
-            thread.abort = True
-        raise

=== removed file 'bin/swauth-add-account'
--- bin/swauth-add-account	2011-04-18 16:08:48 +0000
+++ bin/swauth-add-account	1970-01-01 00:00:00 +0000
@@ -1,68 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2010 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 gettext
-from optparse import OptionParser
-from os.path import basename
-from sys import argv, exit
-
-from swift.common.bufferedhttp import http_connect_raw as http_connect
-from swift.common.utils import urlparse
-
-
-if __name__ == '__main__':
-    gettext.install('swift', unicode=1)
-    parser = OptionParser(usage='Usage: %prog [options] <account>')
-    parser.add_option('-s', '--suffix', dest='suffix',
-        default='', help='The suffix to use with the reseller prefix as the '
-        'storage account name (default: <randomly-generated-uuid4>) Note: If '
-        'the account already exists, this will have no effect on existing '
-        'service URLs. Those will need to be updated with '
-        'swauth-set-account-service')
-    parser.add_option('-A', '--admin-url', dest='admin_url',
-        default='http://127.0.0.1:8080/auth/', help='The URL to the auth '
-        'subsystem (default: http://127.0.0.1:8080/auth/)')
-    parser.add_option('-U', '--admin-user', dest='admin_user',
-        default='.super_admin', help='The user with admin rights to add users '
-        '(default: .super_admin).')
-    parser.add_option('-K', '--admin-key', dest='admin_key',
-        help='The key for the user with admin rights to add users.')
-    args = argv[1:]
-    if not args:
-        args.append('-h')
-    (options, args) = parser.parse_args(args)
-    if len(args) != 1:
-        parser.parse_args(['-h'])
-    account = args[0]
-    parsed = urlparse(options.admin_url)
-    if parsed.scheme not in ('http', 'https'):
-        raise Exception('Cannot handle protocol scheme %s for url %s' %
-                        (parsed.scheme, repr(options.admin_url)))
-    parsed_path = parsed.path
-    if not parsed_path:
-        parsed_path = '/'
-    elif parsed_path[-1] != '/':
-        parsed_path += '/'
-    path = '%sv2/%s' % (parsed_path, account)
-    headers = {'X-Auth-Admin-User': options.admin_user,
-               'X-Auth-Admin-Key': options.admin_key}
-    if options.suffix:
-        headers['X-Account-Suffix'] = options.suffix
-    conn = http_connect(parsed.hostname, parsed.port, 'PUT', path, headers,
-                        ssl=(parsed.scheme == 'https'))
-    resp = conn.getresponse()
-    if resp.status // 100 != 2:
-        exit('Account creation failed: %s %s' % (resp.status, resp.reason))

=== removed file 'bin/swauth-add-user'
--- bin/swauth-add-user	2011-04-18 16:08:48 +0000
+++ bin/swauth-add-user	1970-01-01 00:00:00 +0000
@@ -1,93 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2010 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 gettext
-from optparse import OptionParser
-from os.path import basename
-from sys import argv, exit
-
-from swift.common.bufferedhttp import http_connect_raw as http_connect
-from swift.common.utils import urlparse
-
-
-if __name__ == '__main__':
-    gettext.install('swift', unicode=1)
-    parser = OptionParser(
-        usage='Usage: %prog [options] <account> <user> <password>')
-    parser.add_option('-a', '--admin', dest='admin', action='store_true',
-        default=False, help='Give the user administrator access; otherwise '
-        'the user will only have access to containers specifically allowed '
-        'with ACLs.')
-    parser.add_option('-r', '--reseller-admin', dest='reseller_admin',
-        action='store_true', default=False, help='Give the user full reseller '
-        'administrator access, giving them full access to all accounts within '
-        'the reseller, including the ability to create new accounts. Creating '
-        'a new reseller admin requires super_admin rights.')
-    parser.add_option('-s', '--suffix', dest='suffix',
-        default='', help='The suffix to use with the reseller prefix as the '
-        'storage account name (default: <randomly-generated-uuid4>) Note: If '
-        'the account already exists, this will have no effect on existing '
-        'service URLs. Those will need to be updated with '
-        'swauth-set-account-service')
-    parser.add_option('-A', '--admin-url', dest='admin_url',
-        default='http://127.0.0.1:8080/auth/', help='The URL to the auth '
-        'subsystem (default: http://127.0.0.1:8080/auth/')
-    parser.add_option('-U', '--admin-user', dest='admin_user',
-        default='.super_admin', help='The user with admin rights to add users '
-        '(default: .super_admin).')
-    parser.add_option('-K', '--admin-key', dest='admin_key',
-        help='The key for the user with admin rights to add users.')
-    args = argv[1:]
-    if not args:
-        args.append('-h')
-    (options, args) = parser.parse_args(args)
-    if len(args) != 3:
-        parser.parse_args(['-h'])
-    account, user, password = args
-    parsed = urlparse(options.admin_url)
-    if parsed.scheme not in ('http', 'https'):
-        raise Exception('Cannot handle protocol scheme %s for url %s' %
-                        (parsed.scheme, repr(options.admin_url)))
-    parsed_path = parsed.path
-    if not parsed_path:
-        parsed_path = '/'
-    elif parsed_path[-1] != '/':
-        parsed_path += '/'
-    # Ensure the account exists
-    path = '%sv2/%s' % (parsed_path, account)
-    headers = {'X-Auth-Admin-User': options.admin_user,
-               'X-Auth-Admin-Key': options.admin_key}
-    if options.suffix:
-        headers['X-Account-Suffix'] = options.suffix
-    conn = http_connect(parsed.hostname, parsed.port, 'PUT', path, headers,
-                        ssl=(parsed.scheme == 'https'))
-    resp = conn.getresponse()
-    if resp.status // 100 != 2:
-        print 'Account creation failed: %s %s' % (resp.status, resp.reason)
-    # Add the user
-    path = '%sv2/%s/%s' % (parsed_path, account, user)
-    headers = {'X-Auth-Admin-User': options.admin_user,
-               'X-Auth-Admin-Key': options.admin_key,
-               'X-Auth-User-Key': password}
-    if options.admin:
-        headers['X-Auth-User-Admin'] = 'true'
-    if options.reseller_admin:
-        headers['X-Auth-User-Reseller-Admin'] = 'true'
-    conn = http_connect(parsed.hostname, parsed.port, 'PUT', path, headers,
-                        ssl=(parsed.scheme == 'https'))
-    resp = conn.getresponse()
-    if resp.status // 100 != 2:
-        exit('User creation failed: %s %s' % (resp.status, resp.reason))

=== removed file 'bin/swauth-cleanup-tokens'
--- bin/swauth-cleanup-tokens	2011-04-18 16:08:48 +0000
+++ bin/swauth-cleanup-tokens	1970-01-01 00:00:00 +0000
@@ -1,118 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2010 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.
-
-try:
-    import simplejson as json
-except ImportError:
-    import json
-import gettext
-import re
-from datetime import datetime, timedelta
-from optparse import OptionParser
-from sys import argv, exit
-from time import sleep, time
-
-from swift.common.client import Connection, ClientException
-
-
-if __name__ == '__main__':
-    gettext.install('swift', unicode=1)
-    parser = OptionParser(usage='Usage: %prog [options]')
-    parser.add_option('-t', '--token-life', dest='token_life',
-        default='86400', help='The expected life of tokens; token objects '
-        'modified more than this number of seconds ago will be checked for '
-        'expiration (default: 86400).')
-    parser.add_option('-s', '--sleep', dest='sleep',
-        default='0.1', help='The number of seconds to sleep between token '
-        'checks (default: 0.1)')
-    parser.add_option('-v', '--verbose', dest='verbose', action='store_true',
-        default=False, help='Outputs everything done instead of just the '
-        'deletions.')
-    parser.add_option('-A', '--admin-url', dest='admin_url',
-        default='http://127.0.0.1:8080/auth/', help='The URL to the auth '
-        'subsystem (default: http://127.0.0.1:8080/auth/)')
-    parser.add_option('-K', '--admin-key', dest='admin_key',
-        help='The key for .super_admin.')
-    args = argv[1:]
-    if not args:
-        args.append('-h')
-    (options, args) = parser.parse_args(args)
-    if len(args) != 0:
-        parser.parse_args(['-h'])
-    options.admin_url = options.admin_url.rstrip('/')
-    if not options.admin_url.endswith('/v1.0'):
-        options.admin_url += '/v1.0'
-    options.admin_user = '.super_admin:.super_admin'
-    options.token_life = timedelta(0, float(options.token_life))
-    options.sleep = float(options.sleep)
-    conn = Connection(options.admin_url, options.admin_user, options.admin_key)
-    for x in xrange(16):
-        container = '.token_%x' % x
-        marker = None
-        while True:
-            if options.verbose:
-                print 'GET %s?marker=%s' % (container, marker)
-            try:
-                objs = conn.get_container(container, marker=marker)[1]
-            except ClientException, e:
-                if e.http_status == 404:
-                    exit('Container %s not found. swauth-prep needs to be '
-                        'rerun' % (container))
-                else:
-                    exit('Object listing on container %s failed with status '
-                        'code %d' % (container, e.http_status))
-            if objs:
-                marker = objs[-1]['name']
-            else:
-                if options.verbose:
-                    print 'No more objects in %s' % container
-                break
-            for obj in objs:
-                last_modified = datetime(*map(int, re.split('[^\d]',
-                                              obj['last_modified'])[:-1]))
-                ago = datetime.utcnow() - last_modified
-                if ago > options.token_life:
-                    if options.verbose:
-                        print '%s/%s last modified %ss ago; investigating' % \
-                              (container, obj['name'],
-                               ago.days * 86400 + ago.seconds)
-                        print 'GET %s/%s' % (container, obj['name'])
-                    detail = conn.get_object(container, obj['name'])[1]
-                    detail = json.loads(detail)
-                    if detail['expires'] < time():
-                        if options.verbose:
-                            print '%s/%s expired %ds ago; deleting' % \
-                                  (container, obj['name'],
-                                   time() - detail['expires'])
-                        print 'DELETE %s/%s' % (container, obj['name'])
-                        try:
-                            conn.delete_object(container, obj['name'])
-                        except ClientException, e:
-                            if e.http_status != 404:
-                                print 'DELETE of %s/%s failed with status ' \
-                                    'code %d' % (container, obj['name'],
-                                    e.http_status)
-                    elif options.verbose:
-                        print "%s/%s won't expire for %ds; skipping" % \
-                              (container, obj['name'],
-                               detail['expires'] - time())
-                elif options.verbose:
-                    print '%s/%s last modified %ss ago; skipping' % \
-                          (container, obj['name'],
-                           ago.days * 86400 + ago.seconds)
-                sleep(options.sleep)
-    if options.verbose:
-        print 'Done.'

=== removed file 'bin/swauth-delete-account'
--- bin/swauth-delete-account	2011-04-18 16:08:48 +0000
+++ bin/swauth-delete-account	1970-01-01 00:00:00 +0000
@@ -1,60 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2010 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 gettext
-from optparse import OptionParser
-from os.path import basename
-from sys import argv, exit
-
-from swift.common.bufferedhttp import http_connect_raw as http_connect
-from swift.common.utils import urlparse
-
-
-if __name__ == '__main__':
-    gettext.install('swift', unicode=1)
-    parser = OptionParser(usage='Usage: %prog [options] <account>')
-    parser.add_option('-A', '--admin-url', dest='admin_url',
-        default='http://127.0.0.1:8080/auth/', help='The URL to the auth '
-        'subsystem (default: http://127.0.0.1:8080/auth/')
-    parser.add_option('-U', '--admin-user', dest='admin_user',
-        default='.super_admin', help='The user with admin rights to add users '
-        '(default: .super_admin).')
-    parser.add_option('-K', '--admin-key', dest='admin_key',
-        help='The key for the user with admin rights to add users.')
-    args = argv[1:]
-    if not args:
-        args.append('-h')
-    (options, args) = parser.parse_args(args)
-    if len(args) != 1:
-        parser.parse_args(['-h'])
-    account = args[0]
-    parsed = urlparse(options.admin_url)
-    if parsed.scheme not in ('http', 'https'):
-        raise Exception('Cannot handle protocol scheme %s for url %s' %
-                        (parsed.scheme, repr(options.admin_url)))
-    parsed_path = parsed.path
-    if not parsed_path:
-        parsed_path = '/'
-    elif parsed_path[-1] != '/':
-        parsed_path += '/'
-    path = '%sv2/%s' % (parsed_path, account)
-    headers = {'X-Auth-Admin-User': options.admin_user,
-               'X-Auth-Admin-Key': options.admin_key}
-    conn = http_connect(parsed.hostname, parsed.port, 'DELETE', path, headers,
-                        ssl=(parsed.scheme == 'https'))
-    resp = conn.getresponse()
-    if resp.status // 100 != 2:
-        exit('Account deletion failed: %s %s' % (resp.status, resp.reason))

=== removed file 'bin/swauth-delete-user'
--- bin/swauth-delete-user	2011-04-18 16:08:48 +0000
+++ bin/swauth-delete-user	1970-01-01 00:00:00 +0000
@@ -1,60 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2010 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 gettext
-from optparse import OptionParser
-from os.path import basename
-from sys import argv, exit
-
-from swift.common.bufferedhttp import http_connect_raw as http_connect
-from swift.common.utils import urlparse
-
-
-if __name__ == '__main__':
-    gettext.install('swift', unicode=1)
-    parser = OptionParser(usage='Usage: %prog [options] <account> <user>')
-    parser.add_option('-A', '--admin-url', dest='admin_url',
-        default='http://127.0.0.1:8080/auth/', help='The URL to the auth '
-        'subsystem (default: http://127.0.0.1:8080/auth/')
-    parser.add_option('-U', '--admin-user', dest='admin_user',
-        default='.super_admin', help='The user with admin rights to add users '
-        '(default: .super_admin).')
-    parser.add_option('-K', '--admin-key', dest='admin_key',
-        help='The key for the user with admin rights to add users.')
-    args = argv[1:]
-    if not args:
-        args.append('-h')
-    (options, args) = parser.parse_args(args)
-    if len(args) != 2:
-        parser.parse_args(['-h'])
-    account, user = args
-    parsed = urlparse(options.admin_url)
-    if parsed.scheme not in ('http', 'https'):
-        raise Exception('Cannot handle protocol scheme %s for url %s' %
-                        (parsed.scheme, repr(options.admin_url)))
-    parsed_path = parsed.path
-    if not parsed_path:
-        parsed_path = '/'
-    elif parsed_path[-1] != '/':
-        parsed_path += '/'
-    path = '%sv2/%s/%s' % (parsed_path, account, user)
-    headers = {'X-Auth-Admin-User': options.admin_user,
-               'X-Auth-Admin-Key': options.admin_key}
-    conn = http_connect(parsed.hostname, parsed.port, 'DELETE', path, headers,
-                        ssl=(parsed.scheme == 'https'))
-    resp = conn.getresponse()
-    if resp.status // 100 != 2:
-        exit('User deletion failed: %s %s' % (resp.status, resp.reason))

=== removed file 'bin/swauth-list'
--- bin/swauth-list	2011-04-18 16:08:48 +0000
+++ bin/swauth-list	1970-01-01 00:00:00 +0000
@@ -1,86 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2010 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.
-
-try:
-    import simplejson as json
-except ImportError:
-    import json
-import gettext
-from optparse import OptionParser
-from os.path import basename
-from sys import argv, exit
-
-from swift.common.bufferedhttp import http_connect_raw as http_connect
-from swift.common.utils import urlparse
-
-
-if __name__ == '__main__':
-    gettext.install('swift', unicode=1)
-    parser = OptionParser(usage='''
-Usage: %prog [options] [account] [user]
-
-If [account] and [user] are omitted, a list of accounts will be output.
-
-If [account] is included but not [user], an account's information will be
-output, including a list of users within the account.
-
-If [account] and [user] are included, the user's information will be output,
-including a list of groups the user belongs to.
-
-If the [user] is '.groups', the active groups for the account will be listed.
-'''.strip())
-    parser.add_option('-p', '--plain-text', dest='plain_text',
-        action='store_true', default=False, help='Changes the output from '
-        'JSON to plain text. This will cause an account to list only the '
-        'users and a user to list only the groups.')
-    parser.add_option('-A', '--admin-url', dest='admin_url',
-        default='http://127.0.0.1:8080/auth/', help='The URL to the auth '
-        'subsystem (default: http://127.0.0.1:8080/auth/')
-    parser.add_option('-U', '--admin-user', dest='admin_user',
-        default='.super_admin', help='The user with admin rights to add users '
-        '(default: .super_admin).')
-    parser.add_option('-K', '--admin-key', dest='admin_key',
-        help='The key for the user with admin rights to add users.')
-    args = argv[1:]
-    if not args:
-        args.append('-h')
-    (options, args) = parser.parse_args(args)
-    if len(args) > 2:
-        parser.parse_args(['-h'])
-    parsed = urlparse(options.admin_url)
-    if parsed.scheme not in ('http', 'https'):
-        raise Exception('Cannot handle protocol scheme %s for url %s' %
-                        (parsed.scheme, repr(options.admin_url)))
-    parsed_path = parsed.path
-    if not parsed_path:
-        parsed_path = '/'
-    elif parsed_path[-1] != '/':
-        parsed_path += '/'
-    path = '%sv2/%s' % (parsed_path, '/'.join(args))
-    headers = {'X-Auth-Admin-User': options.admin_user,
-               'X-Auth-Admin-Key': options.admin_key}
-    conn = http_connect(parsed.hostname, parsed.port, 'GET', path, headers,
-                        ssl=(parsed.scheme == 'https'))
-    resp = conn.getresponse()
-    body = resp.read()
-    if resp.status // 100 != 2:
-        exit('List failed: %s %s' % (resp.status, resp.reason))
-    if options.plain_text:
-        info = json.loads(body)
-        for group in info[['accounts', 'users', 'groups'][len(args)]]:
-            print group['name']
-    else:
-        print body

=== removed file 'bin/swauth-prep'
--- bin/swauth-prep	2011-04-18 16:08:48 +0000
+++ bin/swauth-prep	1970-01-01 00:00:00 +0000
@@ -1,59 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2010 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 gettext
-from optparse import OptionParser
-from os.path import basename
-from sys import argv, exit
-
-from swift.common.bufferedhttp import http_connect_raw as http_connect
-from swift.common.utils import urlparse
-
-
-if __name__ == '__main__':
-    gettext.install('swift', unicode=1)
-    parser = OptionParser(usage='Usage: %prog [options]')
-    parser.add_option('-A', '--admin-url', dest='admin_url',
-        default='http://127.0.0.1:8080/auth/', help='The URL to the auth '
-        'subsystem (default: http://127.0.0.1:8080/auth/')
-    parser.add_option('-U', '--admin-user', dest='admin_user',
-        default='.super_admin', help='The user with admin rights to add users '
-        '(default: .super_admin).')
-    parser.add_option('-K', '--admin-key', dest='admin_key',
-        help='The key for the user with admin rights to add users.')
-    args = argv[1:]
-    if not args:
-        args.append('-h')
-    (options, args) = parser.parse_args(args)
-    if args:
-        parser.parse_args(['-h'])
-    parsed = urlparse(options.admin_url)
-    if parsed.scheme not in ('http', 'https'):
-        raise Exception('Cannot handle protocol scheme %s for url %s' %
-                        (parsed.scheme, repr(options.admin_url)))
-    parsed_path = parsed.path
-    if not parsed_path:
-        parsed_path = '/'
-    elif parsed_path[-1] != '/':
-        parsed_path += '/'
-    path = '%sv2/.prep' % parsed_path
-    headers = {'X-Auth-Admin-User': options.admin_user,
-               'X-Auth-Admin-Key': options.admin_key}
-    conn = http_connect(parsed.hostname, parsed.port, 'POST', path, headers,
-                        ssl=(parsed.scheme == 'https'))
-    resp = conn.getresponse()
-    if resp.status // 100 != 2:
-        exit('Auth subsystem prep failed: %s %s' % (resp.status, resp.reason))

=== removed file 'bin/swauth-set-account-service'
--- bin/swauth-set-account-service	2011-04-18 16:08:48 +0000
+++ bin/swauth-set-account-service	1970-01-01 00:00:00 +0000
@@ -1,73 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2010 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.
-
-try:
-    import simplejson as json
-except ImportError:
-    import json
-import gettext
-from optparse import OptionParser
-from os.path import basename
-from sys import argv, exit
-
-from swift.common.bufferedhttp import http_connect_raw as http_connect
-from swift.common.utils import urlparse
-
-
-if __name__ == '__main__':
-    gettext.install('swift', unicode=1)
-    parser = OptionParser(usage='''
-Usage: %prog [options] <account> <service> <name> <value>
-
-Sets a service URL for an account. Can only be set by a reseller admin.
-
-Example: %prog -K swauthkey test storage local http://127.0.0.1:8080/v1/AUTH_018c3946-23f8-4efb-a8fb-b67aae8e4162
-'''.strip())
-    parser.add_option('-A', '--admin-url', dest='admin_url',
-        default='http://127.0.0.1:8080/auth/', help='The URL to the auth '
-        'subsystem (default: http://127.0.0.1:8080/auth/)')
-    parser.add_option('-U', '--admin-user', dest='admin_user',
-        default='.super_admin', help='The user with admin rights to add users '
-        '(default: .super_admin).')
-    parser.add_option('-K', '--admin-key', dest='admin_key',
-        help='The key for the user with admin rights to add users.')
-    args = argv[1:]
-    if not args:
-        args.append('-h')
-    (options, args) = parser.parse_args(args)
-    if len(args) != 4:
-        parser.parse_args(['-h'])
-    account, service, name, url = args
-    parsed = urlparse(options.admin_url)
-    if parsed.scheme not in ('http', 'https'):
-        raise Exception('Cannot handle protocol scheme %s for url %s' %
-                        (parsed.scheme, repr(options.admin_url)))
-    parsed_path = parsed.path
-    if not parsed_path:
-        parsed_path = '/'
-    elif parsed_path[-1] != '/':
-        parsed_path += '/'
-    path = '%sv2/%s/.services' % (parsed_path, account)
-    body = json.dumps({service: {name: url}})
-    headers = {'Content-Length': str(len(body)),
-               'X-Auth-Admin-User': options.admin_user,
-               'X-Auth-Admin-Key': options.admin_key}
-    conn = http_connect(parsed.hostname, parsed.port, 'POST', path, headers,
-                        ssl=(parsed.scheme == 'https'))
-    conn.send(body)
-    resp = conn.getresponse()
-    if resp.status // 100 != 2:
-        exit('Service set failed: %s %s' % (resp.status, resp.reason))

=== added file 'bin/swift'
--- bin/swift	1970-01-01 00:00:00 +0000
+++ bin/swift	2011-06-15 09:24:34 +0000
@@ -0,0 +1,1812 @@
+#!/usr/bin/python -u
+# Copyright (c) 2010-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 errno import EEXIST, ENOENT
+from hashlib import md5
+from optparse import OptionParser
+from os import environ, listdir, makedirs, utime
+from os.path import basename, dirname, getmtime, getsize, isdir, join
+from Queue import Empty, Queue
+from sys import argv, exc_info, exit, stderr, stdout
+from threading import enumerate as threading_enumerate, Thread
+from time import sleep
+from traceback import format_exception
+
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# Inclusion of swift.common.client for convenience of single file distribution
+
+import socket
+from cStringIO import StringIO
+from re import compile, DOTALL
+from tokenize import generate_tokens, STRING, NAME, OP
+from urllib import quote as _quote, unquote
+from urlparse import urlparse, urlunparse
+
+try:
+    from eventlet.green.httplib import HTTPException, HTTPSConnection
+except ImportError:
+    from httplib import HTTPException, HTTPSConnection
+
+try:
+    from eventlet import sleep
+except ImportError:
+    from time import sleep
+
+try:
+    from swift.common.bufferedhttp \
+        import BufferedHTTPConnection as HTTPConnection
+except ImportError:
+    try:
+        from eventlet.green.httplib import HTTPConnection
+    except ImportError:
+        from httplib import HTTPConnection
+
+
+def quote(value, safe='/'):
+    """
+    Patched version of urllib.quote that encodes utf8 strings before quoting
+    """
+    if isinstance(value, unicode):
+        value = value.encode('utf8')
+    return _quote(value, safe)
+
+
+# look for a real json parser first
+try:
+    # simplejson is popular and pretty good
+    from simplejson import loads as json_loads
+except ImportError:
+    try:
+        # 2.6 will have a json module in the stdlib
+        from json import loads as json_loads
+    except ImportError:
+        # fall back on local parser otherwise
+        comments = compile(r'/\*.*\*/|//[^\r\n]*', DOTALL)
+
+        def json_loads(string):
+            '''
+            Fairly competent json parser exploiting the python tokenizer and
+            eval(). -- From python-cloudfiles
+
+            _loads(serialized_json) -> object
+            '''
+            try:
+                res = []
+                consts = {'true': True, 'false': False, 'null': None}
+                string = '(' + comments.sub('', string) + ')'
+                for type, val, _junk, _junk, _junk in \
+                        generate_tokens(StringIO(string).readline):
+                    if (type == OP and val not in '[]{}:,()-') or \
+                            (type == NAME and val not in consts):
+                        raise AttributeError()
+                    elif type == STRING:
+                        res.append('u')
+                        res.append(val.replace('\\/', '/'))
+                    else:
+                        res.append(val)
+                return eval(''.join(res), {}, consts)
+            except Exception:
+                raise AttributeError()
+
+
+class ClientException(Exception):
+
+    def __init__(self, msg, http_scheme='', http_host='', http_port='',
+                 http_path='', http_query='', http_status=0, http_reason='',
+                 http_device=''):
+        Exception.__init__(self, msg)
+        self.msg = msg
+        self.http_scheme = http_scheme
+        self.http_host = http_host
+        self.http_port = http_port
+        self.http_path = http_path
+        self.http_query = http_query
+        self.http_status = http_status
+        self.http_reason = http_reason
+        self.http_device = http_device
+
+    def __str__(self):
+        a = self.msg
+        b = ''
+        if self.http_scheme:
+            b += '%s://' % self.http_scheme
+        if self.http_host:
+            b += self.http_host
+        if self.http_port:
+            b += ':%s' % self.http_port
+        if self.http_path:
+            b += self.http_path
+        if self.http_query:
+            b += '?%s' % self.http_query
+        if self.http_status:
+            if b:
+                b = '%s %s' % (b, self.http_status)
+            else:
+                b = str(self.http_status)
+        if self.http_reason:
+            if b:
+                b = '%s %s' % (b, self.http_reason)
+            else:
+                b = '- %s' % self.http_reason
+        if self.http_device:
+            if b:
+                b = '%s: device %s' % (b, self.http_device)
+            else:
+                b = 'device %s' % self.http_device
+        return b and '%s: %s' % (a, b) or a
+
+
+def http_connection(url):
+    """
+    Make an HTTPConnection or HTTPSConnection
+
+    :param url: url to connect to
+    :returns: tuple of (parsed url, connection object)
+    :raises ClientException: Unable to handle protocol scheme
+    """
+    parsed = urlparse(url)
+    if parsed.scheme == 'http':
+        conn = HTTPConnection(parsed.netloc)
+    elif parsed.scheme == 'https':
+        conn = HTTPSConnection(parsed.netloc)
+    else:
+        raise ClientException('Cannot handle protocol scheme %s for url %s' %
+                              (parsed.scheme, repr(url)))
+    return parsed, conn
+
+
+def get_auth(url, user, key, snet=False):
+    """
+    Get authentication/authorization credentials.
+
+    The snet parameter is used for Rackspace's ServiceNet internal network
+    implementation. In this function, it simply adds *snet-* to the beginning
+    of the host name for the returned storage URL. With Rackspace Cloud Files,
+    use of this network path causes no bandwidth charges but requires the
+    client to be running on Rackspace's ServiceNet network.
+
+    :param url: authentication/authorization URL
+    :param user: user to authenticate as
+    :param key: key or password for authorization
+    :param snet: use SERVICENET internal network (see above), default is False
+    :returns: tuple of (storage URL, auth token)
+    :raises ClientException: HTTP GET request to auth URL failed
+    """
+    parsed, conn = http_connection(url)
+    conn.request('GET', parsed.path, '',
+                 {'X-Auth-User': user, 'X-Auth-Key': key})
+    resp = conn.getresponse()
+    resp.read()
+    if resp.status < 200 or resp.status >= 300:
+        raise ClientException('Auth GET failed', http_scheme=parsed.scheme,
+                http_host=conn.host, http_port=conn.port,
+                http_path=parsed.path, http_status=resp.status,
+                http_reason=resp.reason)
+    url = resp.getheader('x-storage-url')
+    if snet:
+        parsed = list(urlparse(url))
+        # Second item in the list is the netloc
+        parsed[1] = 'snet-' + parsed[1]
+        url = urlunparse(parsed)
+    return url, resp.getheader('x-storage-token',
+                                                resp.getheader('x-auth-token'))
+
+
+def get_account(url, token, marker=None, limit=None, prefix=None,
+                http_conn=None, full_listing=False):
+    """
+    Get a listing of containers for the account.
+
+    :param url: storage URL
+    :param token: auth token
+    :param marker: marker query
+    :param limit: limit query
+    :param prefix: prefix query
+    :param http_conn: HTTP connection object (If None, it will create the
+                      conn object)
+    :param full_listing: if True, return a full listing, else returns a max
+                         of 10000 listings
+    :returns: a tuple of (response headers, a list of containers) The response
+              headers will be a dict and all header names will be lowercase.
+    :raises ClientException: HTTP GET request failed
+    """
+    if not http_conn:
+        http_conn = http_connection(url)
+    if full_listing:
+        rv = get_account(url, token, marker, limit, prefix, http_conn)
+        listing = rv[1]
+        while listing:
+            marker = listing[-1]['name']
+            listing = \
+                get_account(url, token, marker, limit, prefix, http_conn)[1]
+            if listing:
+                rv[1].extend(listing)
+        return rv
+    parsed, conn = http_conn
+    qs = 'format=json'
+    if marker:
+        qs += '&marker=%s' % quote(marker)
+    if limit:
+        qs += '&limit=%d' % limit
+    if prefix:
+        qs += '&prefix=%s' % quote(prefix)
+    conn.request('GET', '%s?%s' % (parsed.path, qs), '',
+                 {'X-Auth-Token': token})
+    resp = conn.getresponse()
+    resp_headers = {}
+    for header, value in resp.getheaders():
+        resp_headers[header.lower()] = value
+    if resp.status < 200 or resp.status >= 300:
+        resp.read()
+        raise ClientException('Account GET failed', http_scheme=parsed.scheme,
+                http_host=conn.host, http_port=conn.port,
+                http_path=parsed.path, http_query=qs, http_status=resp.status,
+                http_reason=resp.reason)
+    if resp.status == 204:
+        resp.read()
+        return resp_headers, []
+    return resp_headers, json_loads(resp.read())
+
+
+def head_account(url, token, http_conn=None):
+    """
+    Get account stats.
+
+    :param url: storage URL
+    :param token: auth token
+    :param http_conn: HTTP connection object (If None, it will create the
+                      conn object)
+    :returns: a dict containing the response's headers (all header names will
+              be lowercase)
+    :raises ClientException: HTTP HEAD request failed
+    """
+    if http_conn:
+        parsed, conn = http_conn
+    else:
+        parsed, conn = http_connection(url)
+    conn.request('HEAD', parsed.path, '', {'X-Auth-Token': token})
+    resp = conn.getresponse()
+    resp.read()
+    if resp.status < 200 or resp.status >= 300:
+        raise ClientException('Account HEAD failed', http_scheme=parsed.scheme,
+                http_host=conn.host, http_port=conn.port,
+                http_path=parsed.path, http_status=resp.status,
+                http_reason=resp.reason)
+    resp_headers = {}
+    for header, value in resp.getheaders():
+        resp_headers[header.lower()] = value
+    return resp_headers
+
+
+def post_account(url, token, headers, http_conn=None):
+    """
+    Update an account's metadata.
+
+    :param url: storage URL
+    :param token: auth token
+    :param headers: additional headers to include in the request
+    :param http_conn: HTTP connection object (If None, it will create the
+                      conn object)
+    :raises ClientException: HTTP POST request failed
+    """
+    if http_conn:
+        parsed, conn = http_conn
+    else:
+        parsed, conn = http_connection(url)
+    headers['X-Auth-Token'] = token
+    conn.request('POST', parsed.path, '', headers)
+    resp = conn.getresponse()
+    resp.read()
+    if resp.status < 200 or resp.status >= 300:
+        raise ClientException('Account POST failed',
+                http_scheme=parsed.scheme, http_host=conn.host,
+                http_port=conn.port, http_path=path, http_status=resp.status,
+                http_reason=resp.reason)
+
+
+def get_container(url, token, container, marker=None, limit=None,
+                  prefix=None, delimiter=None, http_conn=None,
+                  full_listing=False):
+    """
+    Get a listing of objects for the container.
+
+    :param url: storage URL
+    :param token: auth token
+    :param container: container name to get a listing for
+    :param marker: marker query
+    :param limit: limit query
+    :param prefix: prefix query
+    :param delimeter: string to delimit the queries on
+    :param http_conn: HTTP connection object (If None, it will create the
+                      conn object)
+    :param full_listing: if True, return a full listing, else returns a max
+                         of 10000 listings
+    :returns: a tuple of (response headers, a list of objects) The response
+              headers will be a dict and all header names will be lowercase.
+    :raises ClientException: HTTP GET request failed
+    """
+    if not http_conn:
+        http_conn = http_connection(url)
+    if full_listing:
+        rv = get_container(url, token, container, marker, limit, prefix,
+                           delimiter, http_conn)
+        listing = rv[1]
+        while listing:
+            if not delimiter:
+                marker = listing[-1]['name']
+            else:
+                marker = listing[-1].get('name', listing[-1].get('subdir'))
+            listing = get_container(url, token, container, marker, limit,
+                                    prefix, delimiter, http_conn)[1]
+            if listing:
+                rv[1].extend(listing)
+        return rv
+    parsed, conn = http_conn
+    path = '%s/%s' % (parsed.path, quote(container))
+    qs = 'format=json'
+    if marker:
+        qs += '&marker=%s' % quote(marker)
+    if limit:
+        qs += '&limit=%d' % limit
+    if prefix:
+        qs += '&prefix=%s' % quote(prefix)
+    if delimiter:
+        qs += '&delimiter=%s' % quote(delimiter)
+    conn.request('GET', '%s?%s' % (path, qs), '', {'X-Auth-Token': token})
+    resp = conn.getresponse()
+    if resp.status < 200 or resp.status >= 300:
+        resp.read()
+        raise ClientException('Container GET failed',
+                http_scheme=parsed.scheme, http_host=conn.host,
+                http_port=conn.port, http_path=path, http_query=qs,
+                http_status=resp.status, http_reason=resp.reason)
+    resp_headers = {}
+    for header, value in resp.getheaders():
+        resp_headers[header.lower()] = value
+    if resp.status == 204:
+        resp.read()
+        return resp_headers, []
+    return resp_headers, json_loads(resp.read())
+
+
+def head_container(url, token, container, http_conn=None):
+    """
+    Get container stats.
+
+    :param url: storage URL
+    :param token: auth token
+    :param container: container name to get stats for
+    :param http_conn: HTTP connection object (If None, it will create the
+                      conn object)
+    :returns: a dict containing the response's headers (all header names will
+              be lowercase)
+    :raises ClientException: HTTP HEAD request failed
+    """
+    if http_conn:
+        parsed, conn = http_conn
+    else:
+        parsed, conn = http_connection(url)
+    path = '%s/%s' % (parsed.path, quote(container))
+    conn.request('HEAD', path, '', {'X-Auth-Token': token})
+    resp = conn.getresponse()
+    resp.read()
+    if resp.status < 200 or resp.status >= 300:
+        raise ClientException('Container HEAD failed',
+                http_scheme=parsed.scheme, http_host=conn.host,
+                http_port=conn.port, http_path=path, http_status=resp.status,
+                http_reason=resp.reason)
+    resp_headers = {}
+    for header, value in resp.getheaders():
+        resp_headers[header.lower()] = value
+    return resp_headers
+
+
+def put_container(url, token, container, headers=None, http_conn=None):
+    """
+    Create a container
+
+    :param url: storage URL
+    :param token: auth token
+    :param container: container name to create
+    :param headers: additional headers to include in the request
+    :param http_conn: HTTP connection object (If None, it will create the
+                      conn object)
+    :raises ClientException: HTTP PUT request failed
+    """
+    if http_conn:
+        parsed, conn = http_conn
+    else:
+        parsed, conn = http_connection(url)
+    path = '%s/%s' % (parsed.path, quote(container))
+    if not headers:
+        headers = {}
+    headers['X-Auth-Token'] = token
+    conn.request('PUT', path, '', headers)
+    resp = conn.getresponse()
+    resp.read()
+    if resp.status < 200 or resp.status >= 300:
+        raise ClientException('Container PUT failed',
+                http_scheme=parsed.scheme, http_host=conn.host,
+                http_port=conn.port, http_path=path, http_status=resp.status,
+                http_reason=resp.reason)
+
+
+def post_container(url, token, container, headers, http_conn=None):
+    """
+    Update a container's metadata.
+
+    :param url: storage URL
+    :param token: auth token
+    :param container: container name to update
+    :param headers: additional headers to include in the request
+    :param http_conn: HTTP connection object (If None, it will create the
+                      conn object)
+    :raises ClientException: HTTP POST request failed
+    """
+    if http_conn:
+        parsed, conn = http_conn
+    else:
+        parsed, conn = http_connection(url)
+    path = '%s/%s' % (parsed.path, quote(container))
+    headers['X-Auth-Token'] = token
+    conn.request('POST', path, '', headers)
+    resp = conn.getresponse()
+    resp.read()
+    if resp.status < 200 or resp.status >= 300:
+        raise ClientException('Container POST failed',
+                http_scheme=parsed.scheme, http_host=conn.host,
+                http_port=conn.port, http_path=path, http_status=resp.status,
+                http_reason=resp.reason)
+
+
+def delete_container(url, token, container, http_conn=None):
+    """
+    Delete a container
+
+    :param url: storage URL
+    :param token: auth token
+    :param container: container name to delete
+    :param http_conn: HTTP connection object (If None, it will create the
+                      conn object)
+    :raises ClientException: HTTP DELETE request failed
+    """
+    if http_conn:
+        parsed, conn = http_conn
+    else:
+        parsed, conn = http_connection(url)
+    path = '%s/%s' % (parsed.path, quote(container))
+    conn.request('DELETE', path, '', {'X-Auth-Token': token})
+    resp = conn.getresponse()
+    resp.read()
+    if resp.status < 200 or resp.status >= 300:
+        raise ClientException('Container DELETE failed',
+                http_scheme=parsed.scheme, http_host=conn.host,
+                http_port=conn.port, http_path=path, http_status=resp.status,
+                http_reason=resp.reason)
+
+
+def get_object(url, token, container, name, http_conn=None,
+               resp_chunk_size=None):
+    """
+    Get an object
+
+    :param url: storage URL
+    :param token: auth token
+    :param container: container name that the object is in
+    :param name: object name to get
+    :param http_conn: HTTP connection object (If None, it will create the
+                      conn object)
+    :param resp_chunk_size: if defined, chunk size of data to read. NOTE: If
+                            you specify a resp_chunk_size you must fully read
+                            the object's contents before making another
+                            request.
+    :returns: a tuple of (response headers, the object's contents) The response
+              headers will be a dict and all header names will be lowercase.
+    :raises ClientException: HTTP GET request failed
+    """
+    if http_conn:
+        parsed, conn = http_conn
+    else:
+        parsed, conn = http_connection(url)
+    path = '%s/%s/%s' % (parsed.path, quote(container), quote(name))
+    conn.request('GET', path, '', {'X-Auth-Token': token})
+    resp = conn.getresponse()
+    if resp.status < 200 or resp.status >= 300:
+        resp.read()
+        raise ClientException('Object GET failed', http_scheme=parsed.scheme,
+                http_host=conn.host, http_port=conn.port, http_path=path,
+                http_status=resp.status, http_reason=resp.reason)
+    if resp_chunk_size:
+
+        def _object_body():
+            buf = resp.read(resp_chunk_size)
+            while buf:
+                yield buf
+                buf = resp.read(resp_chunk_size)
+        object_body = _object_body()
+    else:
+        object_body = resp.read()
+    resp_headers = {}
+    for header, value in resp.getheaders():
+        resp_headers[header.lower()] = value
+    return resp_headers, object_body
+
+
+def head_object(url, token, container, name, http_conn=None):
+    """
+    Get object info
+
+    :param url: storage URL
+    :param token: auth token
+    :param container: container name that the object is in
+    :param name: object name to get info for
+    :param http_conn: HTTP connection object (If None, it will create the
+                      conn object)
+    :returns: a dict containing the response's headers (all header names will
+              be lowercase)
+    :raises ClientException: HTTP HEAD request failed
+    """
+    if http_conn:
+        parsed, conn = http_conn
+    else:
+        parsed, conn = http_connection(url)
+    path = '%s/%s/%s' % (parsed.path, quote(container), quote(name))
+    conn.request('HEAD', path, '', {'X-Auth-Token': token})
+    resp = conn.getresponse()
+    resp.read()
+    if resp.status < 200 or resp.status >= 300:
+        raise ClientException('Object HEAD failed', http_scheme=parsed.scheme,
+                http_host=conn.host, http_port=conn.port, http_path=path,
+                http_status=resp.status, http_reason=resp.reason)
+    resp_headers = {}
+    for header, value in resp.getheaders():
+        resp_headers[header.lower()] = value
+    return resp_headers
+
+
+def put_object(url, token, container, name, contents, content_length=None,
+               etag=None, chunk_size=65536, content_type=None, headers=None,
+               http_conn=None):
+    """
+    Put an object
+
+    :param url: storage URL
+    :param token: auth token
+    :param container: container name that the object is in
+    :param name: object name to put
+    :param contents: a string or a file like object to read object data from
+    :param content_length: value to send as content-length header; also limits
+                           the amount read from contents
+    :param etag: etag of contents
+    :param chunk_size: chunk size of data to write
+    :param content_type: value to send as content-type header
+    :param headers: additional headers to include in the request
+    :param http_conn: HTTP connection object (If None, it will create the
+                      conn object)
+    :returns: etag from server response
+    :raises ClientException: HTTP PUT request failed
+    """
+    if http_conn:
+        parsed, conn = http_conn
+    else:
+        parsed, conn = http_connection(url)
+    path = '%s/%s/%s' % (parsed.path, quote(container), quote(name))
+    if not headers:
+        headers = {}
+    headers['X-Auth-Token'] = token
+    if etag:
+        headers['ETag'] = etag.strip('"')
+    if content_length is not None:
+        headers['Content-Length'] = str(content_length)
+    if content_type is not None:
+        headers['Content-Type'] = content_type
+    if not contents:
+        headers['Content-Length'] = '0'
+    if hasattr(contents, 'read'):
+        conn.putrequest('PUT', path)
+        for header, value in headers.iteritems():
+            conn.putheader(header, value)
+        if content_length is None:
+            conn.putheader('Transfer-Encoding', 'chunked')
+            conn.endheaders()
+            chunk = contents.read(chunk_size)
+            while chunk:
+                conn.send('%x\r\n%s\r\n' % (len(chunk), chunk))
+                chunk = contents.read(chunk_size)
+            conn.send('0\r\n\r\n')
+        else:
+            conn.endheaders()
+            left = content_length
+            while left > 0:
+                size = chunk_size
+                if size > left:
+                    size = left
+                chunk = contents.read(size)
+                conn.send(chunk)
+                left -= len(chunk)
+    else:
+        conn.request('PUT', path, contents, headers)
+    resp = conn.getresponse()
+    resp.read()
+    if resp.status < 200 or resp.status >= 300:
+        raise ClientException('Object PUT failed', http_scheme=parsed.scheme,
+                http_host=conn.host, http_port=conn.port, http_path=path,
+                http_status=resp.status, http_reason=resp.reason)
+    return resp.getheader('etag').strip('"')
+
+
+def post_object(url, token, container, name, headers, http_conn=None):
+    """
+    Update object metadata
+
+    :param url: storage URL
+    :param token: auth token
+    :param container: container name that the object is in
+    :param name: name of the object to update
+    :param headers: additional headers to include in the request
+    :param http_conn: HTTP connection object (If None, it will create the
+                      conn object)
+    :raises ClientException: HTTP POST request failed
+    """
+    if http_conn:
+        parsed, conn = http_conn
+    else:
+        parsed, conn = http_connection(url)
+    path = '%s/%s/%s' % (parsed.path, quote(container), quote(name))
+    headers['X-Auth-Token'] = token
+    conn.request('POST', path, '', headers)
+    resp = conn.getresponse()
+    resp.read()
+    if resp.status < 200 or resp.status >= 300:
+        raise ClientException('Object POST failed', http_scheme=parsed.scheme,
+                http_host=conn.host, http_port=conn.port, http_path=path,
+                http_status=resp.status, http_reason=resp.reason)
+
+
+def delete_object(url, token, container, name, http_conn=None):
+    """
+    Delete object
+
+    :param url: storage URL
+    :param token: auth token
+    :param container: container name that the object is in
+    :param name: object name to delete
+    :param http_conn: HTTP connection object (If None, it will create the
+                      conn object)
+    :raises ClientException: HTTP DELETE request failed
+    """
+    if http_conn:
+        parsed, conn = http_conn
+    else:
+        parsed, conn = http_connection(url)
+    path = '%s/%s/%s' % (parsed.path, quote(container), quote(name))
+    conn.request('DELETE', path, '', {'X-Auth-Token': token})
+    resp = conn.getresponse()
+    resp.read()
+    if resp.status < 200 or resp.status >= 300:
+        raise ClientException('Object DELETE failed',
+                http_scheme=parsed.scheme, http_host=conn.host,
+                http_port=conn.port, http_path=path, http_status=resp.status,
+                http_reason=resp.reason)
+
+
+class Connection(object):
+    """Convenience class to make requests that will also retry the request"""
+
+    def __init__(self, authurl, user, key, retries=5, preauthurl=None,
+                 preauthtoken=None, snet=False, starting_backoff=1):
+        """
+        :param authurl: authenitcation URL
+        :param user: user name to authenticate as
+        :param key: key/password to authenticate with
+        :param retries: Number of times to retry the request before failing
+        :param preauthurl: storage URL (if you have already authenticated)
+        :param preauthtoken: authentication token (if you have already
+                             authenticated)
+        :param snet: use SERVICENET internal network default is False
+        """
+        self.authurl = authurl
+        self.user = user
+        self.key = key
+        self.retries = retries
+        self.http_conn = None
+        self.url = preauthurl
+        self.token = preauthtoken
+        self.attempts = 0
+        self.snet = snet
+        self.starting_backoff = starting_backoff
+
+    def get_auth(self):
+        return get_auth(self.authurl, self.user, self.key, snet=self.snet)
+
+    def http_connection(self):
+        return http_connection(self.url)
+
+    def _retry(self, reset_func, func, *args, **kwargs):
+        self.attempts = 0
+        backoff = self.starting_backoff
+        while self.attempts <= self.retries:
+            self.attempts += 1
+            try:
+                if not self.url or not self.token:
+                    self.url, self.token = self.get_auth()
+                    self.http_conn = None
+                if not self.http_conn:
+                    self.http_conn = self.http_connection()
+                kwargs['http_conn'] = self.http_conn
+                rv = func(self.url, self.token, *args, **kwargs)
+                return rv
+            except (socket.error, HTTPException):
+                if self.attempts > self.retries:
+                    raise
+                self.http_conn = None
+            except ClientException, err:
+                if self.attempts > self.retries:
+                    raise
+                if err.http_status == 401:
+                    self.url = self.token = None
+                    if self.attempts > 1:
+                        raise
+                elif err.http_status == 408:
+                    self.http_conn = None
+                elif 500 <= err.http_status <= 599:
+                    pass
+                else:
+                    raise
+            sleep(backoff)
+            backoff *= 2
+            if reset_func:
+                reset_func(func, *args, **kwargs)
+
+    def head_account(self):
+        """Wrapper for :func:`head_account`"""
+        return self._retry(None, head_account)
+
+    def get_account(self, marker=None, limit=None, prefix=None,
+                    full_listing=False):
+        """Wrapper for :func:`get_account`"""
+        # TODO(unknown): With full_listing=True this will restart the entire
+        # listing with each retry. Need to make a better version that just
+        # retries where it left off.
+        return self._retry(None, get_account, marker=marker, limit=limit,
+                           prefix=prefix, full_listing=full_listing)
+
+    def post_account(self, headers):
+        """Wrapper for :func:`post_account`"""
+        return self._retry(None, post_account, headers)
+
+    def head_container(self, container):
+        """Wrapper for :func:`head_container`"""
+        return self._retry(None, head_container, container)
+
+    def get_container(self, container, marker=None, limit=None, prefix=None,
+                      delimiter=None, full_listing=False):
+        """Wrapper for :func:`get_container`"""
+        # TODO(unknown): With full_listing=True this will restart the entire
+        # listing with each retry. Need to make a better version that just
+        # retries where it left off.
+        return self._retry(None, get_container, container, marker=marker,
+                           limit=limit, prefix=prefix, delimiter=delimiter,
+                           full_listing=full_listing)
+
+    def put_container(self, container, headers=None):
+        """Wrapper for :func:`put_container`"""
+        return self._retry(None, put_container, container, headers=headers)
+
+    def post_container(self, container, headers):
+        """Wrapper for :func:`post_container`"""
+        return self._retry(None, post_container, container, headers)
+
+    def delete_container(self, container):
+        """Wrapper for :func:`delete_container`"""
+        return self._retry(None, delete_container, container)
+
+    def head_object(self, container, obj):
+        """Wrapper for :func:`head_object`"""
+        return self._retry(None, head_object, container, obj)
+
+    def get_object(self, container, obj, resp_chunk_size=None):
+        """Wrapper for :func:`get_object`"""
+        return self._retry(None, get_object, container, obj,
+                           resp_chunk_size=resp_chunk_size)
+
+    def put_object(self, container, obj, contents, content_length=None,
+                   etag=None, chunk_size=65536, content_type=None,
+                   headers=None):
+        """Wrapper for :func:`put_object`"""
+
+        def _default_reset(*args, **kwargs):
+            raise ClientException('put_object(%r, %r, ...) failure and no '
+                'ability to reset contents for reupload.' % (container, obj))
+
+        reset_func = _default_reset
+        tell = getattr(contents, 'tell', None)
+        seek = getattr(contents, 'seek', None)
+        if tell and seek:
+            orig_pos = tell()
+            reset_func = lambda *a, **k: seek(orig_pos)
+        elif not contents:
+            reset_func = lambda *a, **k: None
+
+        return self._retry(reset_func, put_object, container, obj, contents,
+            content_length=content_length, etag=etag, chunk_size=chunk_size,
+            content_type=content_type, headers=headers)
+
+    def post_object(self, container, obj, headers):
+        """Wrapper for :func:`post_object`"""
+        return self._retry(None, post_object, container, obj, headers)
+
+    def delete_object(self, container, obj):
+        """Wrapper for :func:`delete_object`"""
+        return self._retry(None, delete_object, container, obj)
+
+# End inclusion of swift.common.client
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+
+def mkdirs(path):
+    try:
+        makedirs(path)
+    except OSError, err:
+        if err.errno != EEXIST:
+            raise
+
+
+def put_errors_from_threads(threads, error_queue):
+    """
+    Places any errors from the threads into error_queue.
+    :param threads: A list of QueueFunctionThread instances.
+    :param error_queue: A queue to put error strings into.
+    :returns: True if any errors were found.
+    """
+    was_error = False
+    for thread in threads:
+        for info in thread.exc_infos:
+            was_error = True
+            if isinstance(info[1], ClientException):
+                error_queue.put(str(info[1]))
+            else:
+                error_queue.put(''.join(format_exception(*info)))
+    return was_error
+
+
+class QueueFunctionThread(Thread):
+
+    def __init__(self, queue, func, *args, **kwargs):
+        """ Calls func for each item in queue; func is called with a queued
+            item as the first arg followed by *args and **kwargs. Use the abort
+            attribute to have the thread empty the queue (without processing)
+            and exit. """
+        Thread.__init__(self)
+        self.abort = False
+        self.queue = queue
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+        self.exc_infos = []
+
+    def run(self):
+        try:
+            while True:
+                try:
+                    item = self.queue.get_nowait()
+                    if not self.abort:
+                        self.func(item, *self.args, **self.kwargs)
+                    self.queue.task_done()
+                except Empty:
+                    if self.abort:
+                        break
+                    sleep(0.01)
+        except Exception:
+            self.exc_infos.append(exc_info())
+
+
+st_delete_help = '''
+delete --all OR delete container [--leave-segments] [object] [object] ...
+    Deletes everything in the account (with --all), or everything in a
+    container, or a list of objects depending on the args given. Segments of
+    manifest objects will be deleted as well, unless you specify the
+    --leave-segments option.'''.strip('\n')
+
+
+def st_delete(parser, args, print_queue, error_queue):
+    parser.add_option('-a', '--all', action='store_true', dest='yes_all',
+        default=False, help='Indicates that you really want to delete '
+        'everything in the account')
+    parser.add_option('', '--leave-segments', action='store_true',
+        dest='leave_segments', default=False, help='Indicates that you want '
+        'the segments of manifest objects left alone')
+    (options, args) = parse_args(parser, args)
+    args = args[1:]
+    if (not args and not options.yes_all) or (args and options.yes_all):
+        error_queue.put('Usage: %s [options] %s' %
+                        (basename(argv[0]), st_delete_help))
+        return
+
+    def _delete_segment((container, obj), conn):
+        conn.delete_object(container, obj)
+        if options.verbose:
+            if conn.attempts > 2:
+                print_queue.put('%s/%s [after %d attempts]' %
+                                (container, obj, conn.attempts))
+            else:
+                print_queue.put('%s/%s' % (container, obj))
+
+    object_queue = Queue(10000)
+
+    def _delete_object((container, obj), conn):
+        try:
+            old_manifest = None
+            if not options.leave_segments:
+                try:
+                    old_manifest = conn.head_object(container, obj).get(
+                        'x-object-manifest')
+                except ClientException, err:
+                    if err.http_status != 404:
+                        raise
+            conn.delete_object(container, obj)
+            if old_manifest:
+                segment_queue = Queue(10000)
+                scontainer, sprefix = old_manifest.split('/', 1)
+                for delobj in conn.get_container(scontainer,
+                                                 prefix=sprefix)[1]:
+                    segment_queue.put((scontainer, delobj['name']))
+                if not segment_queue.empty():
+                    segment_threads = [QueueFunctionThread(segment_queue,
+                        _delete_segment, create_connection()) for _junk in
+                        xrange(10)]
+                    for thread in segment_threads:
+                        thread.start()
+                    while not segment_queue.empty():
+                        sleep(0.01)
+                    for thread in segment_threads:
+                        thread.abort = True
+                        while thread.isAlive():
+                            thread.join(0.01)
+                    put_errors_from_threads(segment_threads, error_queue)
+            if options.verbose:
+                path = options.yes_all and join(container, obj) or obj
+                if path[:1] in ('/', '\\'):
+                    path = path[1:]
+                if conn.attempts > 1:
+                    print_queue.put('%s [after %d attempts]' %
+                                    (path, conn.attempts))
+                else:
+                    print_queue.put(path)
+        except ClientException, err:
+            if err.http_status != 404:
+                raise
+            error_queue.put('Object %s not found' %
+                            repr('%s/%s' % (container, obj)))
+
+    container_queue = Queue(10000)
+
+    def _delete_container(container, conn):
+        try:
+            marker = ''
+            while True:
+                objects = [o['name'] for o in
+                           conn.get_container(container, marker=marker)[1]]
+                if not objects:
+                    break
+                for obj in objects:
+                    object_queue.put((container, obj))
+                marker = objects[-1]
+            while not object_queue.empty():
+                sleep(0.01)
+            attempts = 1
+            while True:
+                try:
+                    conn.delete_container(container)
+                    break
+                except ClientException, err:
+                    if err.http_status != 409:
+                        raise
+                    if attempts > 10:
+                        raise
+                    attempts += 1
+                    sleep(1)
+        except ClientException, err:
+            if err.http_status != 404:
+                raise
+            error_queue.put('Container %s not found' % repr(container))
+
+    url, token = get_auth(options.auth, options.user, options.key,
+        snet=options.snet)
+    create_connection = lambda: Connection(options.auth, options.user,
+        options.key, preauthurl=url, preauthtoken=token, snet=options.snet)
+    object_threads = [QueueFunctionThread(object_queue, _delete_object,
+        create_connection()) for _junk in xrange(10)]
+    for thread in object_threads:
+        thread.start()
+    container_threads = [QueueFunctionThread(container_queue,
+        _delete_container, create_connection()) for _junk in xrange(10)]
+    for thread in container_threads:
+        thread.start()
+    if not args:
+        conn = create_connection()
+        try:
+            marker = ''
+            while True:
+                containers = \
+                    [c['name'] for c in conn.get_account(marker=marker)[1]]
+                if not containers:
+                    break
+                for container in containers:
+                    container_queue.put(container)
+                marker = containers[-1]
+            while not container_queue.empty():
+                sleep(0.01)
+            while not object_queue.empty():
+                sleep(0.01)
+        except ClientException, err:
+            if err.http_status != 404:
+                raise
+            error_queue.put('Account not found')
+    elif len(args) == 1:
+        if '/' in args[0]:
+            print >> stderr, 'WARNING: / in container name; you might have ' \
+                             'meant %r instead of %r.' % \
+                             (args[0].replace('/', ' ', 1), args[0])
+        conn = create_connection()
+        _delete_container(args[0], conn)
+    else:
+        for obj in args[1:]:
+            object_queue.put((args[0], obj))
+    while not container_queue.empty():
+        sleep(0.01)
+    for thread in container_threads:
+        thread.abort = True
+        while thread.isAlive():
+            thread.join(0.01)
+    put_errors_from_threads(container_threads, error_queue)
+    while not object_queue.empty():
+        sleep(0.01)
+    for thread in object_threads:
+        thread.abort = True
+        while thread.isAlive():
+            thread.join(0.01)
+    put_errors_from_threads(object_threads, error_queue)
+
+
+st_download_help = '''
+download --all OR download container [options] [object] [object] ...
+    Downloads everything in the account (with --all), or everything in a
+    container, or a list of objects depending on the args given. For a single
+    object download, you may use the -o [--output] <filename> option to
+    redirect the output to a specific file or if "-" then just redirect to
+    stdout.'''.strip('\n')
+
+
+def st_download(options, args, print_queue, error_queue):
+    parser.add_option('-a', '--all', action='store_true', dest='yes_all',
+        default=False, help='Indicates that you really want to download '
+        'everything in the account')
+    parser.add_option('-o', '--output', dest='out_file', help='For a single '
+        'file download, stream the output to an alternate location ')
+    (options, args) = parse_args(parser, args)
+    args = args[1:]
+    if options.out_file == '-':
+        options.verbose = 0
+    if options.out_file and len(args) != 2:
+        exit('-o option only allowed for single file downloads')
+    if (not args and not options.yes_all) or (args and options.yes_all):
+        error_queue.put('Usage: %s [options] %s' %
+                        (basename(argv[0]), st_download_help))
+        return
+
+    object_queue = Queue(10000)
+
+    def _download_object(queue_arg, conn):
+        if len(queue_arg) == 2:
+            container, obj = queue_arg
+            out_file = None
+        elif len(queue_arg) == 3:
+            container, obj, out_file = queue_arg
+        else:
+            raise Exception("Invalid queue_arg length of %s" % len(queue_arg))
+        try:
+            headers, body = \
+                conn.get_object(container, obj, resp_chunk_size=65536)
+            content_type = headers.get('content-type')
+            if 'content-length' in headers:
+                content_length = int(headers.get('content-length'))
+            else:
+                content_length = None
+            etag = headers.get('etag')
+            path = options.yes_all and join(container, obj) or obj
+            if path[:1] in ('/', '\\'):
+                path = path[1:]
+            md5sum = None
+            make_dir = out_file != "-"
+            if content_type.split(';', 1)[0] == 'text/directory':
+                if make_dir and not isdir(path):
+                    mkdirs(path)
+                read_length = 0
+                if 'x-object-manifest' not in headers:
+                    md5sum = md5()
+                for chunk in body:
+                    read_length += len(chunk)
+                    if md5sum:
+                        md5sum.update(chunk)
+            else:
+                dirpath = dirname(path)
+                if make_dir and dirpath and not isdir(dirpath):
+                    mkdirs(dirpath)
+                if out_file == "-":
+                    fp = stdout
+                elif out_file:
+                    fp = open(out_file, 'wb')
+                else:
+                    fp = open(path, 'wb')
+                read_length = 0
+                if 'x-object-manifest' not in headers:
+                    md5sum = md5()
+                for chunk in body:
+                    fp.write(chunk)
+                    read_length += len(chunk)
+                    if md5sum:
+                        md5sum.update(chunk)
+                fp.close()
+            if md5sum and md5sum.hexdigest() != etag:
+                error_queue.put('%s: md5sum != etag, %s != %s' %
+                                (path, md5sum.hexdigest(), etag))
+            if content_length is not None and read_length != content_length:
+                error_queue.put('%s: read_length != content_length, %d != %d' %
+                                (path, read_length, content_length))
+            if 'x-object-meta-mtime' in headers and not options.out_file:
+                mtime = float(headers['x-object-meta-mtime'])
+                utime(path, (mtime, mtime))
+            if options.verbose:
+                if conn.attempts > 1:
+                    print_queue.put('%s [after %d attempts' %
+                                    (path, conn.attempts))
+                else:
+                    print_queue.put(path)
+        except ClientException, err:
+            if err.http_status != 404:
+                raise
+            error_queue.put('Object %s not found' %
+                            repr('%s/%s' % (container, obj)))
+
+    container_queue = Queue(10000)
+
+    def _download_container(container, conn):
+        try:
+            marker = ''
+            while True:
+                objects = [o['name'] for o in
+                           conn.get_container(container, marker=marker)[1]]
+                if not objects:
+                    break
+                for obj in objects:
+                    object_queue.put((container, obj))
+                marker = objects[-1]
+        except ClientException, err:
+            if err.http_status != 404:
+                raise
+            error_queue.put('Container %s not found' % repr(container))
+
+    url, token = get_auth(options.auth, options.user, options.key,
+        snet=options.snet)
+    create_connection = lambda: Connection(options.auth, options.user,
+        options.key, preauthurl=url, preauthtoken=token, snet=options.snet)
+    object_threads = [QueueFunctionThread(object_queue, _download_object,
+        create_connection()) for _junk in xrange(10)]
+    for thread in object_threads:
+        thread.start()
+    container_threads = [QueueFunctionThread(container_queue,
+        _download_container, create_connection()) for _junk in xrange(10)]
+    for thread in container_threads:
+        thread.start()
+    if not args:
+        conn = create_connection()
+        try:
+            marker = ''
+            while True:
+                containers = [c['name']
+                              for c in conn.get_account(marker=marker)[1]]
+                if not containers:
+                    break
+                for container in containers:
+                    container_queue.put(container)
+                marker = containers[-1]
+        except ClientException, err:
+            if err.http_status != 404:
+                raise
+            error_queue.put('Account not found')
+    elif len(args) == 1:
+        if '/' in args[0]:
+            print >> stderr, 'WARNING: / in container name; you might have ' \
+                             'meant %r instead of %r.' % \
+                             (args[0].replace('/', ' ', 1), args[0])
+        _download_container(args[0], create_connection())
+    else:
+        if len(args) == 2:
+            obj = args[1]
+            object_queue.put((args[0], obj, options.out_file))
+        else:
+            for obj in args[1:]:
+                object_queue.put((args[0], obj))
+    while not container_queue.empty():
+        sleep(0.01)
+    for thread in container_threads:
+        thread.abort = True
+        while thread.isAlive():
+            thread.join(0.01)
+    put_errors_from_threads(container_threads, error_queue)
+    while not object_queue.empty():
+        sleep(0.01)
+    for thread in object_threads:
+        thread.abort = True
+        while thread.isAlive():
+            thread.join(0.01)
+    put_errors_from_threads(object_threads, error_queue)
+
+
+st_list_help = '''
+list [options] [container]
+    Lists the containers for the account or the objects for a container. -p or
+    --prefix is an option that will only list items beginning with that prefix.
+    -d or --delimiter is option (for container listings only) that will roll up
+    items with the given delimiter (see Cloud Files general documentation for
+    what this means).
+'''.strip('\n')
+
+
+def st_list(options, args, print_queue, error_queue):
+    parser.add_option('-p', '--prefix', dest='prefix', help='Will only list '
+        'items beginning with the prefix')
+    parser.add_option('-d', '--delimiter', dest='delimiter', help='Will roll '
+        'up items with the given delimiter (see Cloud Files general '
+        'documentation for what this means)')
+    (options, args) = parse_args(parser, args)
+    args = args[1:]
+    if options.delimiter and not args:
+        exit('-d option only allowed for container listings')
+    if len(args) > 1:
+        error_queue.put('Usage: %s [options] %s' %
+                        (basename(argv[0]), st_list_help))
+        return
+    conn = Connection(options.auth, options.user, options.key,
+        snet=options.snet)
+    try:
+        marker = ''
+        while True:
+            if not args:
+                items = \
+                    conn.get_account(marker=marker, prefix=options.prefix)[1]
+            else:
+                items = conn.get_container(args[0], marker=marker,
+                    prefix=options.prefix, delimiter=options.delimiter)[1]
+            if not items:
+                break
+            for item in items:
+                print_queue.put(item.get('name', item.get('subdir')))
+            marker = items[-1].get('name', items[-1].get('subdir'))
+    except ClientException, err:
+        if err.http_status != 404:
+            raise
+        if not args:
+            error_queue.put('Account not found')
+        else:
+            error_queue.put('Container %s not found' % repr(args[0]))
+
+
+st_stat_help = '''
+stat [container] [object]
+    Displays information for the account, container, or object depending on the
+    args given (if any).'''.strip('\n')
+
+
+def st_stat(options, args, print_queue, error_queue):
+    (options, args) = parse_args(parser, args)
+    args = args[1:]
+    conn = Connection(options.auth, options.user, options.key)
+    if not args:
+        try:
+            headers = conn.head_account()
+            if options.verbose > 1:
+                print_queue.put('''
+StorageURL: %s
+Auth Token: %s
+'''.strip('\n') % (conn.url, conn.token))
+            container_count = int(headers.get('x-account-container-count', 0))
+            object_count = int(headers.get('x-account-object-count', 0))
+            bytes_used = int(headers.get('x-account-bytes-used', 0))
+            print_queue.put('''
+   Account: %s
+Containers: %d
+   Objects: %d
+     Bytes: %d'''.strip('\n') % (conn.url.rsplit('/', 1)[-1], container_count,
+                                 object_count, bytes_used))
+            for key, value in headers.items():
+                if key.startswith('x-account-meta-'):
+                    print_queue.put('%10s: %s' % ('Meta %s' %
+                        key[len('x-account-meta-'):].title(), value))
+            for key, value in headers.items():
+                if not key.startswith('x-account-meta-') and key not in (
+                        'content-length', 'date', 'x-account-container-count',
+                        'x-account-object-count', 'x-account-bytes-used'):
+                    print_queue.put(
+                        '%10s: %s' % (key.title(), value))
+        except ClientException, err:
+            if err.http_status != 404:
+                raise
+            error_queue.put('Account not found')
+    elif len(args) == 1:
+        if '/' in args[0]:
+            print >> stderr, 'WARNING: / in container name; you might have ' \
+                             'meant %r instead of %r.' % \
+                             (args[0].replace('/', ' ', 1), args[0])
+        try:
+            headers = conn.head_container(args[0])
+            object_count = int(headers.get('x-container-object-count', 0))
+            bytes_used = int(headers.get('x-container-bytes-used', 0))
+            print_queue.put('''
+  Account: %s
+Container: %s
+  Objects: %d
+    Bytes: %d
+ Read ACL: %s
+Write ACL: %s'''.strip('\n') % (conn.url.rsplit('/', 1)[-1], args[0],
+                                object_count, bytes_used,
+                                headers.get('x-container-read', ''),
+                                headers.get('x-container-write', '')))
+            for key, value in headers.items():
+                if key.startswith('x-container-meta-'):
+                    print_queue.put('%9s: %s' % ('Meta %s' %
+                        key[len('x-container-meta-'):].title(), value))
+            for key, value in headers.items():
+                if not key.startswith('x-container-meta-') and key not in (
+                        'content-length', 'date', 'x-container-object-count',
+                        'x-container-bytes-used', 'x-container-read',
+                        'x-container-write'):
+                    print_queue.put(
+                        '%9s: %s' % (key.title(), value))
+        except ClientException, err:
+            if err.http_status != 404:
+                raise
+            error_queue.put('Container %s not found' % repr(args[0]))
+    elif len(args) == 2:
+        try:
+            headers = conn.head_object(args[0], args[1])
+            print_queue.put('''
+       Account: %s
+     Container: %s
+        Object: %s
+  Content Type: %s'''.strip('\n') % (conn.url.rsplit('/', 1)[-1], args[0],
+                                     args[1], headers.get('content-type')))
+            if 'content-length' in headers:
+                print_queue.put('Content Length: %s' %
+                                headers['content-length'])
+            if 'last-modified' in headers:
+                print_queue.put(' Last Modified: %s' %
+                                headers['last-modified'])
+            if 'etag' in headers:
+                print_queue.put('          ETag: %s' % headers['etag'])
+            if 'x-object-manifest' in headers:
+                print_queue.put('      Manifest: %s' %
+                                headers['x-object-manifest'])
+            for key, value in headers.items():
+                if key.startswith('x-object-meta-'):
+                    print_queue.put('%14s: %s' % ('Meta %s' %
+                        key[len('x-object-meta-'):].title(), value))
+            for key, value in headers.items():
+                if not key.startswith('x-object-meta-') and key not in (
+                        'content-type', 'content-length', 'last-modified',
+                        'etag', 'date', 'x-object-manifest'):
+                    print_queue.put(
+                        '%14s: %s' % (key.title(), value))
+        except ClientException, err:
+            if err.http_status != 404:
+                raise
+            error_queue.put('Object %s not found' %
+                            repr('%s/%s' % (args[0], args[1])))
+    else:
+        error_queue.put('Usage: %s [options] %s' %
+                        (basename(argv[0]), st_stat_help))
+
+
+st_post_help = '''
+post [options] [container] [object]
+    Updates meta information for the account, container, or object depending on
+    the args given. If the container is not found, it will be created
+    automatically; but this is not true for accounts and objects. Containers
+    also allow the -r (or --read-acl) and -w (or --write-acl) options. The -m
+    or --meta option is allowed on all and used to define the user meta data
+    items to set in the form Name:Value. This option can be repeated. Example:
+    post -m Color:Blue -m Size:Large'''.strip('\n')
+
+
+def st_post(options, args, print_queue, error_queue):
+    parser.add_option('-r', '--read-acl', dest='read_acl', help='Sets the '
+        'Read ACL for containers. Quick summary of ACL syntax: .r:*, '
+        '.r:-.example.com, .r:www.example.com, account1, account2:user2')
+    parser.add_option('-w', '--write-acl', dest='write_acl', help='Sets the '
+        'Write ACL for containers. Quick summary of ACL syntax: account1, '
+        'account2:user2')
+    parser.add_option('-m', '--meta', action='append', dest='meta', default=[],
+        help='Sets a meta data item with the syntax name:value. This option '
+        'may be repeated. Example: -m Color:Blue -m Size:Large')
+    (options, args) = parse_args(parser, args)
+    args = args[1:]
+    if (options.read_acl or options.write_acl) and not args:
+        exit('-r and -w options only allowed for containers')
+    conn = Connection(options.auth, options.user, options.key)
+    if not args:
+        headers = {}
+        for item in options.meta:
+            split_item = item.split(':')
+            headers['X-Account-Meta-' + split_item[0]] = \
+                len(split_item) > 1 and split_item[1]
+        try:
+            conn.post_account(headers=headers)
+        except ClientException, err:
+            if err.http_status != 404:
+                raise
+            error_queue.put('Account not found')
+    elif len(args) == 1:
+        if '/' in args[0]:
+            print >> stderr, 'WARNING: / in container name; you might have ' \
+                             'meant %r instead of %r.' % \
+                             (args[0].replace('/', ' ', 1), args[0])
+        headers = {}
+        for item in options.meta:
+            split_item = item.split(':')
+            headers['X-Container-Meta-' + split_item[0]] = \
+                len(split_item) > 1 and split_item[1]
+        if options.read_acl is not None:
+            headers['X-Container-Read'] = options.read_acl
+        if options.write_acl is not None:
+            headers['X-Container-Write'] = options.write_acl
+        try:
+            conn.post_container(args[0], headers=headers)
+        except ClientException, err:
+            if err.http_status != 404:
+                raise
+            conn.put_container(args[0], headers=headers)
+    elif len(args) == 2:
+        headers = {}
+        for item in options.meta:
+            split_item = item.split(':')
+            headers['X-Object-Meta-' + split_item[0]] = \
+                len(split_item) > 1 and split_item[1]
+        try:
+            conn.post_object(args[0], args[1], headers=headers)
+        except ClientException, err:
+            if err.http_status != 404:
+                raise
+            error_queue.put('Object %s not found' %
+                            repr('%s/%s' % (args[0], args[1])))
+    else:
+        error_queue.put('Usage: %s [options] %s' %
+                        (basename(argv[0]), st_post_help))
+
+
+st_upload_help = '''
+upload [options] container file_or_directory [file_or_directory] [...]
+    Uploads to the given container the files and directories specified by the
+    remaining args. -c or --changed is an option that will only upload files
+    that have changed since the last upload. -S <size> or --segment-size <size>
+    and --leave-segments are options as well (see --help for more).
+'''.strip('\n')
+
+
+def st_upload(options, args, print_queue, error_queue):
+    parser.add_option('-c', '--changed', action='store_true', dest='changed',
+        default=False, help='Will only upload files that have changed since '
+        'the last upload')
+    parser.add_option('-S', '--segment-size', dest='segment_size', help='Will '
+        'upload files in segments no larger than <size> and then create a '
+        '"manifest" file that will download all the segments as if it were '
+        'the original file. The segments will be uploaded to a '
+        '<container>_segments container so as to not pollute the main '
+        '<container> listings.')
+    parser.add_option('', '--leave-segments', action='store_true',
+        dest='leave_segments', default=False, help='Indicates that you want '
+        'the older segments of manifest objects left alone (in the case of '
+        'overwrites)')
+    (options, args) = parse_args(parser, args)
+    args = args[1:]
+    if len(args) < 2:
+        error_queue.put('Usage: %s [options] %s' %
+                        (basename(argv[0]), st_upload_help))
+        return
+    object_queue = Queue(10000)
+
+    def _segment_job(job, conn):
+        if job.get('delete', False):
+            conn.delete_object(job['container'], job['obj'])
+        else:
+            fp = open(job['path'], 'rb')
+            fp.seek(job['segment_start'])
+            conn.put_object(job.get('container', args[0] + '_segments'),
+                job['obj'], fp, content_length=job['segment_size'])
+        if options.verbose and 'log_line' in job:
+            if conn.attempts > 1:
+                print_queue.put('%s [after %d attempts]' %
+                                (job['log_line'], conn.attempts))
+            else:
+                print_queue.put(job['log_line'])
+
+    def _object_job(job, conn):
+        path = job['path']
+        container = job.get('container', args[0])
+        dir_marker = job.get('dir_marker', False)
+        try:
+            obj = path
+            if obj.startswith('./') or obj.startswith('.\\'):
+                obj = obj[2:]
+            put_headers = {'x-object-meta-mtime': str(getmtime(path))}
+            if dir_marker:
+                if options.changed:
+                    try:
+                        headers = conn.head_object(container, obj)
+                        ct = headers.get('content-type')
+                        cl = int(headers.get('content-length'))
+                        et = headers.get('etag')
+                        mt = headers.get('x-object-meta-mtime')
+                        if ct.split(';', 1)[0] == 'text/directory' and \
+                                cl == 0 and \
+                                et == 'd41d8cd98f00b204e9800998ecf8427e' and \
+                                mt == put_headers['x-object-meta-mtime']:
+                            return
+                    except ClientException, err:
+                        if err.http_status != 404:
+                            raise
+                conn.put_object(container, obj, '', content_length=0,
+                                content_type='text/directory',
+                                headers=put_headers)
+            else:
+                # We need to HEAD all objects now in case we're overwriting a
+                # manifest object and need to delete the old segments
+                # ourselves.
+                old_manifest = None
+                if options.changed or not options.leave_segments:
+                    try:
+                        headers = conn.head_object(container, obj)
+                        cl = int(headers.get('content-length'))
+                        mt = headers.get('x-object-meta-mtime')
+                        if options.changed and cl == getsize(path) and \
+                                mt == put_headers['x-object-meta-mtime']:
+                            return
+                        if not options.leave_segments:
+                            old_manifest = headers.get('x-object-manifest')
+                    except ClientException, err:
+                        if err.http_status != 404:
+                            raise
+                if options.segment_size and \
+                        getsize(path) < options.segment_size:
+                    full_size = getsize(path)
+                    segment_queue = Queue(10000)
+                    segment_threads = [QueueFunctionThread(segment_queue,
+                        _segment_job, create_connection()) for _junk in
+                        xrange(10)]
+                    for thread in segment_threads:
+                        thread.start()
+                    segment = 0
+                    segment_start = 0
+                    while segment_start < full_size:
+                        segment_size = int(options.segment_size)
+                        if segment_start + segment_size > full_size:
+                            segment_size = full_size - segment_start
+                        segment_queue.put({'path': path,
+                            'obj': '%s/%s/%s/%08d' % (obj,
+                                put_headers['x-object-meta-mtime'], full_size,
+                                segment),
+                            'segment_start': segment_start,
+                            'segment_size': segment_size,
+                            'log_line': '%s segment %s' % (obj, segment)})
+                        segment += 1
+                        segment_start += segment_size
+                    while not segment_queue.empty():
+                        sleep(0.01)
+                    for thread in segment_threads:
+                        thread.abort = True
+                        while thread.isAlive():
+                            thread.join(0.01)
+                    if put_errors_from_threads(segment_threads, error_queue):
+                        raise ClientException('Aborting manifest creation '
+                            'because not all segments could be uploaded. %s/%s'
+                            % (container, obj))
+                    new_object_manifest = '%s_segments/%s/%s/%s/' % (
+                        container, obj, put_headers['x-object-meta-mtime'],
+                        full_size)
+                    if old_manifest == new_object_manifest:
+                        old_manifest = None
+                    put_headers['x-object-manifest'] = new_object_manifest
+                    conn.put_object(container, obj, '', content_length=0,
+                                    headers=put_headers)
+                else:
+                    conn.put_object(container, obj, open(path, 'rb'),
+                        content_length=getsize(path), headers=put_headers)
+                if old_manifest:
+                    segment_queue = Queue(10000)
+                    scontainer, sprefix = old_manifest.split('/', 1)
+                    for delobj in conn.get_container(scontainer,
+                                                     prefix=sprefix)[1]:
+                        segment_queue.put({'delete': True,
+                            'container': scontainer, 'obj': delobj['name']})
+                    if not segment_queue.empty():
+                        segment_threads = [QueueFunctionThread(segment_queue,
+                            _segment_job, create_connection()) for _junk in
+                            xrange(10)]
+                        for thread in segment_threads:
+                            thread.start()
+                        while not segment_queue.empty():
+                            sleep(0.01)
+                        for thread in segment_threads:
+                            thread.abort = True
+                            while thread.isAlive():
+                                thread.join(0.01)
+                        put_errors_from_threads(segment_threads, error_queue)
+            if options.verbose:
+                if conn.attempts > 1:
+                    print_queue.put(
+                        '%s [after %d attempts]' % (obj, conn.attempts))
+                else:
+                    print_queue.put(obj)
+        except OSError, err:
+            if err.errno != ENOENT:
+                raise
+            error_queue.put('Local file %s not found' % repr(path))
+
+    def _upload_dir(path):
+        names = listdir(path)
+        if not names:
+            object_queue.put({'path': path, 'dir_marker': True})
+        else:
+            for name in listdir(path):
+                subpath = join(path, name)
+                if isdir(subpath):
+                    _upload_dir(subpath)
+                else:
+                    object_queue.put({'path': subpath})
+
+    url, token = get_auth(options.auth, options.user, options.key,
+        snet=options.snet)
+    create_connection = lambda: Connection(options.auth, options.user,
+        options.key, preauthurl=url, preauthtoken=token, snet=options.snet)
+    object_threads = [QueueFunctionThread(object_queue, _object_job,
+        create_connection()) for _junk in xrange(10)]
+    for thread in object_threads:
+        thread.start()
+    conn = create_connection()
+    # Try to create the container, just in case it doesn't exist. If this
+    # fails, it might just be because the user doesn't have container PUT
+    # permissions, so we'll ignore any error. If there's really a problem,
+    # it'll surface on the first object PUT.
+    try:
+        conn.put_container(args[0])
+        if options.segment_size is not None:
+            conn.put_container(args[0] + '_segments')
+    except Exception:
+        pass
+    try:
+        for arg in args[1:]:
+            if isdir(arg):
+                _upload_dir(arg)
+            else:
+                object_queue.put({'path': arg})
+        while not object_queue.empty():
+            sleep(0.01)
+        for thread in object_threads:
+            thread.abort = True
+            while thread.isAlive():
+                thread.join(0.01)
+        put_errors_from_threads(object_threads, error_queue)
+    except ClientException, err:
+        if err.http_status != 404:
+            raise
+        error_queue.put('Account not found')
+
+
+def parse_args(parser, args, enforce_requires=True):
+    if not args:
+        args = ['-h']
+    (options, args) = parser.parse_args(args)
+    if enforce_requires and \
+            not (options.auth and options.user and options.key):
+        exit('''
+Requires ST_AUTH, ST_USER, and ST_KEY environment variables be set or
+overridden with -A, -U, or -K.'''.strip('\n'))
+    return options, args
+
+
+if __name__ == '__main__':
+    parser = OptionParser(version='%prog 1.0', usage='''
+Usage: %%prog <command> [options] [args]
+
+Commands:
+  %(st_stat_help)s
+  %(st_list_help)s
+  %(st_upload_help)s
+  %(st_post_help)s
+  %(st_download_help)s
+  %(st_delete_help)s
+
+Example:
+  %%prog -A https://auth.api.rackspacecloud.com/v1.0 -U user -K key stat
+'''.strip('\n') % globals())
+    parser.add_option('-s', '--snet', action='store_true', dest='snet',
+                      default=False, help='Use SERVICENET internal network')
+    parser.add_option('-v', '--verbose', action='count', dest='verbose',
+                      default=1, help='Print more info')
+    parser.add_option('-q', '--quiet', action='store_const', dest='verbose',
+                      const=0, default=1, help='Suppress status output')
+    parser.add_option('-A', '--auth', dest='auth',
+                      default=environ.get('ST_AUTH'),
+                      help='URL for obtaining an auth token')
+    parser.add_option('-U', '--user', dest='user',
+                      default=environ.get('ST_USER'),
+                      help='User name for obtaining an auth token')
+    parser.add_option('-K', '--key', dest='key',
+                      default=environ.get('ST_KEY'),
+                      help='Key for obtaining an auth token')
+    parser.disable_interspersed_args()
+    (options, args) = parse_args(parser, argv[1:], enforce_requires=False)
+    parser.enable_interspersed_args()
+
+    commands = ('delete', 'download', 'list', 'post', 'stat', 'upload')
+    if not args or args[0] not in commands:
+        parser.print_usage()
+        if args:
+            exit('no such command: %s' % args[0])
+        exit()
+
+    print_queue = Queue(10000)
+
+    def _print(item):
+        if isinstance(item, unicode):
+            item = item.encode('utf8')
+        print item
+
+    print_thread = QueueFunctionThread(print_queue, _print)
+    print_thread.start()
+
+    error_queue = Queue(10000)
+
+    def _error(item):
+        if isinstance(item, unicode):
+            item = item.encode('utf8')
+        print >> stderr, item
+
+    error_thread = QueueFunctionThread(error_queue, _error)
+    error_thread.start()
+
+    try:
+        parser.usage = globals()['st_%s_help' % args[0]]
+        try:
+            globals()['st_%s' % args[0]](parser, argv[1:], print_queue,
+                                         error_queue)
+        except (ClientException, HTTPException, socket.error), err:
+            error_queue.put(str(err))
+        while not print_queue.empty():
+            sleep(0.01)
+        print_thread.abort = True
+        while print_thread.isAlive():
+            print_thread.join(0.01)
+        while not error_queue.empty():
+            sleep(0.01)
+        error_thread.abort = True
+        while error_thread.isAlive():
+            error_thread.join(0.01)
+    except (SystemExit, Exception):
+        for thread in threading_enumerate():
+            thread.abort = True
+        raise

=== modified file 'doc/source/admin_guide.rst'
--- doc/source/admin_guide.rst	2011-03-31 22:32:41 +0000
+++ doc/source/admin_guide.rst	2011-06-15 09:24:34 +0000
@@ -222,22 +222,6 @@
     Sample represents 1.00% of the object partition space
 
 
-------------------------------------
-Additional Cleanup Script for Swauth
-------------------------------------
-
-With Swauth, you'll want to install a cronjob to clean up any
-orphaned expired tokens. These orphaned tokens can occur when a "stampede"
-occurs where a single user authenticates several times concurrently. Generally,
-these orphaned tokens don't pose much of an issue, but it's good to clean them
-up once a "token life" period (default: 1 day or 86400 seconds).
-
-This should be as simple as adding `swauth-cleanup-tokens -A
-https://<PROXY_HOSTNAME>:8080/auth/ -K swauthkey > /dev/null` to a crontab
-entry on one of the proxies that is running Swauth; but run
-`swauth-cleanup-tokens` with no arguments for detailed help on the options
-available.
-
 ------------------------
 Debugging Tips and Tools
 ------------------------

=== modified file 'doc/source/deployment_guide.rst'
--- doc/source/deployment_guide.rst	2011-01-25 00:28:22 +0000
+++ doc/source/deployment_guide.rst	2011-06-15 09:24:34 +0000
@@ -547,37 +547,23 @@
                                                node error limited
 allow_account_management      false            Whether account PUTs and DELETEs
                                                are even callable
+account_autocreate            false            If set to 'true' authorized
+                                               accounts that do not yet exist
+                                               within the Swift cluster will
+                                               be automatically created.
 ============================  ===============  =============================
 
-[auth]
-
-============  ===================================  ========================
-Option        Default                              Description
-------------  -----------------------------------  ------------------------
-use                                                Entry point for paste.deploy 
-                                                   to use for auth.  To
-                                                   use the swift dev auth,
-                                                   set to:
-                                                   `egg:swift#auth`
-ip            127.0.0.1                            IP address of auth
-                                                   server
-port          11000                                Port of auth server
-ssl           False                                If True, use SSL to
-                                                   connect to auth
-node_timeout  10                                   Request timeout
-============  ===================================  ========================
-
-[swauth]
+[tempauth]
 
 =====================  =============================== =======================
 Option                 Default                         Description
 ---------------------  ------------------------------- -----------------------
 use                                                    Entry point for
                                                        paste.deploy to use for
-                                                       auth. To use the swauth
+                                                       auth. To use tempauth
                                                        set to:
-                                                       `egg:swift#swauth`
-set log_name           auth-server                     Label used when logging
+                                                       `egg:swift#tempauth`
+set log_name           tempauth                        Label used when logging
 set log_facility       LOG_LOCAL0                      Syslog log facility
 set log_level          INFO                            Log level
 set log_headers        True                            If True, log headers in
@@ -593,16 +579,39 @@
                                                        reserves anything
                                                        beginning with the
                                                        letter `v`.
-default_swift_cluster  local#http://127.0.0.1:8080/v1  The default Swift
-                                                       cluster to place newly
-                                                       created accounts on.
 token_life             86400                           The number of seconds a
                                                        token is valid.
-node_timeout           10                              Request timeout
-super_admin_key        None                            The key for the
-                                                       .super_admin account.
 =====================  =============================== =======================
 
+Additionally, you need to list all the accounts/users you want here. The format
+is::
+
+    user_<account>_<user> = <key> [group] [group] [...] [storage_url]
+
+There are special groups of::
+
+    .reseller_admin = can do anything to any account for this auth
+    .admin = can do anything within the account
+
+If neither of these groups are specified, the user can only access containers
+that have been explicitly allowed for them by a .admin or .reseller_admin.
+
+The trailing optional storage_url allows you to specify an alternate url to
+hand back to the user upon authentication. If not specified, this defaults to::
+
+    http[s]://<ip>:<port>/v1/<reseller_prefix>_<account>
+
+Where http or https depends on whether cert_file is specified in the [DEFAULT]
+section, <ip> and <port> are based on the [DEFAULT] section's bind_ip and
+bind_port (falling back to 127.0.0.1 and 8080), <reseller_prefix> is from this
+section, and <account> is from the user_<account>_<user> name.
+
+Here are example entries, required for running the tests::
+
+    user_admin_admin = admin .admin .reseller_admin
+    user_test_tester = testing .admin
+    user_test2_tester2 = testing2 .admin
+    user_test_tester3 = testing3
 
 ------------------------
 Memcached Considerations

=== modified file 'doc/source/development_auth.rst'
--- doc/source/development_auth.rst	2011-03-14 02:56:37 +0000
+++ doc/source/development_auth.rst	2011-06-15 09:24:34 +0000
@@ -6,7 +6,7 @@
 Creating Your Own Auth Server and Middleware
 --------------------------------------------
 
-The included swift/common/middleware/swauth.py is a good example of how to
+The included swift/common/middleware/tempauth.py is a good example of how to
 create an auth subsystem with proxy server auth middleware. The main points are
 that the auth middleware can reject requests up front, before they ever get to
 the Swift Proxy application, and afterwards when the proxy issues callbacks to
@@ -27,7 +27,7 @@
 environ['REMOTE_USER'] set to the authenticated user string but often more
 information is needed than just that.
 
-The included Swauth will set the REMOTE_USER to a comma separated list of
+The included TempAuth will set the REMOTE_USER to a comma separated list of
 groups the user belongs to. The first group will be the "user's group", a group
 that only the user belongs to. The second group will be the "account's group",
 a group that includes all users for that auth account (different than the
@@ -37,7 +37,7 @@
 
 It is highly recommended that authentication server implementers prefix their
 tokens and Swift storage accounts they create with a configurable reseller
-prefix (`AUTH_` by default with the included Swauth). This prefix will avoid
+prefix (`AUTH_` by default with the included TempAuth). This prefix will avoid
 conflicts with other authentication servers that might be using the same
 Swift cluster. Otherwise, the Swift cluster will have to try all the resellers
 until one validates a token or all fail.
@@ -46,14 +46,14 @@
 '.' as that is reserved for internal Swift use (such as the .r for referrer
 designations as you'll see later).
 
-Example Authentication with Swauth:
+Example Authentication with TempAuth:
 
-    * Token AUTH_tkabcd is given to the Swauth middleware in a request's
+    * Token AUTH_tkabcd is given to the TempAuth middleware in a request's
       X-Auth-Token header.
-    * The Swauth middleware validates the token AUTH_tkabcd and discovers
+    * The TempAuth middleware validates the token AUTH_tkabcd and discovers
       it matches the "tester" user within the "test" account for the storage
       account "AUTH_storage_xyz".
-    * The Swauth server sets the REMOTE_USER to
+    * The TempAuth middleware sets the REMOTE_USER to
       "test:tester,test,AUTH_storage_xyz"
     * Now this user will have full access (via authorization procedures later)
       to the AUTH_storage_xyz Swift storage account and access to containers in

=== modified file 'doc/source/development_saio.rst'
--- doc/source/development_saio.rst	2011-05-18 15:26:52 +0000
+++ doc/source/development_saio.rst	2011-06-15 09:24:34 +0000
@@ -265,16 +265,18 @@
         log_facility = LOG_LOCAL1
 
         [pipeline:main]
-        pipeline = healthcheck cache swauth proxy-server
+        pipeline = healthcheck cache tempauth proxy-server
         
         [app:proxy-server]
         use = egg:swift#proxy
         allow_account_management = true
 
-        [filter:swauth]
-        use = egg:swift#swauth
-        # Highly recommended to change this.
-        super_admin_key = swauthkey
+        [filter:tempauth]
+        use = egg:swift#tempauth
+        user_admin_admin = admin .admin .reseller_admin
+        user_test_tester = testing .admin
+        user_test2_tester2 = testing2 .admin
+        user_test_tester3 = testing3
 
         [filter:healthcheck]
         use = egg:swift#healthcheck
@@ -558,8 +560,10 @@
 ------------------------------------
 
   #. Create `~/bin/resetswift.` 
-  If you are using a loopback device substitute `/dev/sdb1` with `/srv/swift-disk`.
-  If you did not set up rsyslog for individual logging, remove the `find /var/log/swift...` line::
+
+     If you are using a loopback device substitute `/dev/sdb1` with `/srv/swift-disk`.
+
+     If you did not set up rsyslog for individual logging, remove the `find /var/log/swift...` line::
   
         #!/bin/bash
 
@@ -608,18 +612,6 @@
 
         swift-init main start
 
-  #. Create `~/bin/recreateaccounts`::
-  
-        #!/bin/bash
-
-        # Replace swauthkey with whatever your super_admin key is (recorded in
-        # /etc/swift/proxy-server.conf).
-        swauth-prep -K swauthkey
-        swauth-add-user -K swauthkey -a test tester testing
-        swauth-add-user -K swauthkey -a test2 tester2 testing2
-        swauth-add-user -K swauthkey test tester3 testing3
-        swauth-add-user -K swauthkey -a -r reseller reseller reseller
-
   #. Create `~/bin/startrest`::
 
         #!/bin/bash
@@ -633,7 +625,7 @@
   #. `recreateaccounts`
   #. Get an `X-Storage-Url` and `X-Auth-Token`: ``curl -v -H 'X-Storage-User: test:tester' -H 'X-Storage-Pass: testing' http://127.0.0.1:8080/auth/v1.0``
   #. Check that you can GET account: ``curl -v -H 'X-Auth-Token: <token-from-x-auth-token-above>' <url-from-x-storage-url-above>``
-  #. Check that `st` works: `st -A http://127.0.0.1:8080/auth/v1.0 -U test:tester -K testing stat`
+  #. Check that `swift` works: `swift -A http://127.0.0.1:8080/auth/v1.0 -U test:tester -K testing stat`
   #. `cp ~/swift/trunk/test/functional/sample.conf /etc/swift/func_test.conf`
   #. `cd ~/swift/trunk; ./.functests` (Note: functional tests will first delete
      everything in the configured accounts.)

=== modified file 'doc/source/howto_installmultinode.rst'
--- doc/source/howto_installmultinode.rst	2011-05-17 03:59:57 +0000
+++ doc/source/howto_installmultinode.rst	2011-06-15 09:24:34 +0000
@@ -13,7 +13,7 @@
 Basic architecture and terms
 ----------------------------
 - *node* - a host machine running one or more Swift services
-- *Proxy node* - node that runs Proxy services; also runs Swauth
+- *Proxy node* - node that runs Proxy services; also runs TempAuth
 - *Storage node* - node that runs Account, Container, and Object services
 - *ring* - a set of mappings of Swift data to physical devices
 
@@ -23,7 +23,7 @@
 
   - Runs the swift-proxy-server processes which proxy requests to the
     appropriate Storage nodes. The proxy server will also contain
-    the Swauth service as WSGI middleware.
+    the TempAuth service as WSGI middleware.
 
 - five Storage nodes
 
@@ -130,17 +130,15 @@
         user = swift
         
         [pipeline:main]
-        pipeline = healthcheck cache swauth proxy-server
+        pipeline = healthcheck cache tempauth proxy-server
         
         [app:proxy-server]
         use = egg:swift#proxy
         allow_account_management = true
         
-        [filter:swauth]
-        use = egg:swift#swauth
-        default_swift_cluster = local#https://$PROXY_LOCAL_NET_IP:8080/v1
-        # Highly recommended to change this key to something else!
-        super_admin_key = swauthkey
+        [filter:tempauth]
+        use = egg:swift#tempauth
+        user_system_root = testpass .admin https://$PROXY_LOCAL_NET_IP:8080/v1/AUTH_system
         
         [filter:healthcheck]
         use = egg:swift#healthcheck
@@ -366,16 +364,6 @@
 
 You run these commands from the Proxy node.
 
-#. Create a user with administrative privileges (account = system,
-   username = root, password = testpass).  Make sure to replace 
-   ``swauthkey`` with whatever super_admin key you assigned in
-   the proxy-server.conf file
-   above.  *Note: None of the values of 
-   account, username, or password are special - they can be anything.*::
-
-        swauth-prep -A https://$PROXY_LOCAL_NET_IP:8080/auth/ -K swauthkey
-        swauth-add-user -A https://$PROXY_LOCAL_NET_IP:8080/auth/ -K swauthkey -a system root testpass
-
 #. Get an X-Storage-Url and X-Auth-Token::
 
         curl -k -v -H 'X-Storage-User: system:root' -H 'X-Storage-Pass: testpass' https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0
@@ -384,34 +372,34 @@
 
         curl -k -v -H 'X-Auth-Token: <token-from-x-auth-token-above>' <url-from-x-storage-url-above>
 
-#. Check that ``st`` works  (at this point, expect zero containers, zero objects, and zero bytes)::
-
-        st -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass stat
-
-#. Use ``st`` to upload a few files named 'bigfile[1-2].tgz' to a container named 'myfiles'::
-
-        st -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass upload myfiles bigfile1.tgz
-        st -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass upload myfiles bigfile2.tgz
-
-#. Use ``st`` to download all files from the 'myfiles' container::
-
-        st -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass download myfiles
-
-#. Use ``st`` to save a backup of your builder files to a container named 'builders'. Very important not to lose your builders!::
-
-        st -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass upload builders /etc/swift/*.builder
-
-#. Use ``st`` to list your containers::
-
-        st -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass list
-
-#. Use ``st`` to list the contents of your 'builders' container::
-
-        st -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass list builders
-
-#. Use ``st`` to download all files from the 'builders' container::
-
-        st -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass download builders
+#. Check that ``swift`` works  (at this point, expect zero containers, zero objects, and zero bytes)::
+
+        swift -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass stat
+
+#. Use ``swift`` to upload a few files named 'bigfile[1-2].tgz' to a container named 'myfiles'::
+
+        swift -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass upload myfiles bigfile1.tgz
+        swift -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass upload myfiles bigfile2.tgz
+
+#. Use ``swift`` to download all files from the 'myfiles' container::
+
+        swift -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass download myfiles
+
+#. Use ``swift`` to save a backup of your builder files to a container named 'builders'. Very important not to lose your builders!::
+
+        swift -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass upload builders /etc/swift/*.builder
+
+#. Use ``swift`` to list your containers::
+
+        swift -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass list
+
+#. Use ``swift`` to list the contents of your 'builders' container::
+
+        swift -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass list builders
+
+#. Use ``swift`` to download all files from the 'builders' container::
+
+        swift -A https://$PROXY_LOCAL_NET_IP:8080/auth/v1.0 -U system:root -K testpass download builders
 
 .. _add-proxy-server:
 
@@ -430,45 +418,16 @@
         use = egg:swift#memcache
         memcache_servers = $PROXY_LOCAL_NET_IP:11211
 
-#. Change the default_cluster_url to point to the load balanced url, rather than the first proxy server you created in /etc/swift/proxy-server.conf::
-
-        [filter:swauth]
-        use = egg:swift#swauth
-        default_swift_cluster = local#http://<LOAD_BALANCER_HOSTNAME>/v1
-        # Highly recommended to change this key to something else!
-        super_admin_key = swauthkey
-
-#. The above will make new accounts with the new default_swift_cluster URL, however it won't change any existing accounts. You can change a service URL for existing accounts with::
-
-    First retreve what the URL was::
-
-         swauth-list -A https://$PROXY_LOCAL_NET_IP:8080/auth/ -K swauthkey <account>
-
-     And then update it with::
-
-         swauth-set-account-service -A https://$PROXY_LOCAL_NET_IP:8080/auth/ -K swauthkey <account> storage local <new_url_for_the_account>
-
-    Make the <new_url_for_the_account> look just like it's original URL but with the host:port update you want.
+#. Change the storage url for any users to point to the load balanced url, rather than the first proxy server you created in /etc/swift/proxy-server.conf::
+
+        [filter:tempauth]
+        use = egg:swift#tempauth
+        user_system_root = testpass .admin http[s]://<LOAD_BALANCER_HOSTNAME>:<PORT>/v1/AUTH_system
 
 #. Next, copy all the ring information to all the nodes, including your new proxy nodes, and ensure the ring info gets to all the storage nodes as well. 
 
 #. After you sync all the nodes, make sure the admin has the keys in /etc/swift and the ownership for the ring file is correct. 
 
-Additional Cleanup Script for Swauth
-------------------------------------
-
-With Swauth, you'll want to install a cronjob to clean up any
-orphaned expired tokens. These orphaned tokens can occur when a "stampede"
-occurs where a single user authenticates several times concurrently. Generally,
-these orphaned tokens don't pose much of an issue, but it's good to clean them
-up once a "token life" period (default: 1 day or 86400 seconds).
-
-This should be as simple as adding `swauth-cleanup-tokens -A
-https://<PROXY_HOSTNAME>:8080/auth/ -K swauthkey > /dev/null` to a crontab
-entry on one of the proxies that is running Swauth; but run
-`swauth-cleanup-tokens` with no arguments for detailed help on the options
-available.
-
 Troubleshooting Notes
 ---------------------
 If you see problems, look in var/log/syslog (or messages on some distros). 

=== modified file 'doc/source/misc.rst'
--- doc/source/misc.rst	2011-03-24 03:37:07 +0000
+++ doc/source/misc.rst	2011-06-15 09:24:34 +0000
@@ -33,12 +33,12 @@
     :members:
     :show-inheritance:
 
-.. _common_swauth:
-
-Swauth
-======
-
-.. automodule:: swift.common.middleware.swauth
+.. _common_tempauth:
+
+TempAuth
+========
+
+.. automodule:: swift.common.middleware.tempauth
     :members:
     :show-inheritance:
 

=== modified file 'doc/source/overview_auth.rst'
--- doc/source/overview_auth.rst	2011-03-14 02:56:37 +0000
+++ doc/source/overview_auth.rst	2011-06-15 09:24:34 +0000
@@ -2,9 +2,9 @@
 The Auth System
 ===============
 
-------
-Swauth
-------
+--------
+TempAuth
+--------
 
 The auth system for Swift is loosely based on the auth system from the existing
 Rackspace architecture -- actually from a few existing auth systems -- and is
@@ -27,7 +27,7 @@
 Swift will make calls to the auth system, giving the auth token to be
 validated. For a valid token, the auth system responds with an overall
 expiration in seconds from now. Swift will cache the token up to the expiration
-time. The included Swauth also has the concept of admin and non-admin users
+time. The included TempAuth also has the concept of admin and non-admin users
 within an account. Admin users can do anything within the account. Non-admin
 users can only perform operations per container based on the container's
 X-Container-Read and X-Container-Write ACLs. For more information on ACLs, see
@@ -40,152 +40,9 @@
 Extending Auth
 --------------
 
-Swauth is written as wsgi middleware, so implementing your own auth is as easy
-as writing new wsgi middleware, and plugging it in to the proxy server.
+TempAuth is written as wsgi middleware, so implementing your own auth is as
+easy as writing new wsgi middleware, and plugging it in to the proxy server.
+The KeyStone project and the Swauth project are examples of additional auth
+services.
 
 Also, see :doc:`development_auth`.
-
-
---------------
-Swauth Details
---------------
-
-The Swauth system is included at swift/common/middleware/swauth.py; a scalable
-authentication and authorization system that uses Swift itself as its backing
-store. This section will describe how it stores its data.
-
-At the topmost level, the auth system has its own Swift account it stores its
-own account information within. This Swift account is known as
-self.auth_account in the code and its name is in the format
-self.reseller_prefix + ".auth". In this text, we'll refer to this account as
-<auth_account>.
-
-The containers whose names do not begin with a period represent the accounts
-within the auth service. For example, the <auth_account>/test container would
-represent the "test" account.
-
-The objects within each container represent the users for that auth service
-account. For example, the <auth_account>/test/bob object would represent the
-user "bob" within the auth service account of "test". Each of these user
-objects contain a JSON dictionary of the format::
-
-    {"auth": "<auth_type>:<auth_value>", "groups": <groups_array>}
-
-The `<auth_type>` can only be `plaintext` at this time, and the `<auth_value>`
-is the plain text password itself.
-
-The `<groups_array>` contains at least two groups. The first is a unique group
-identifying that user and it's name is of the format `<user>:<account>`. The
-second group is the `<account>` itself. Additional groups of `.admin` for
-account administrators and `.reseller_admin` for reseller administrators may
-exist. Here's an example user JSON dictionary::
-
-    {"auth": "plaintext:testing",
-     "groups": ["name": "test:tester", "name": "test", "name": ".admin"]}
-
-To map an auth service account to a Swift storage account, the Service Account
-Id string is stored in the `X-Container-Meta-Account-Id` header for the
-<auth_account>/<account> container. To map back the other way, an
-<auth_account>/.account_id/<account_id> object is created with the contents of
-the corresponding auth service's account name.
-
-Also, to support a future where the auth service will support multiple Swift
-clusters or even multiple services for the same auth service account, an
-<auth_account>/<account>/.services object is created with its contents having a
-JSON dictionary of the format::
-
-    {"storage": {"default": "local", "local": <url>}}
-
-The "default" is always "local" right now, and "local" is always the single
-Swift cluster URL; but in the future there can be more than one cluster with
-various names instead of just "local", and the "default" key's value will
-contain the primary cluster to use for that account. Also, there may be more
-services in addition to the current "storage" service right now.
-
-Here's an example .services dictionary at the moment::
-
-    {"storage":
-        {"default": "local",
-         "local": "http://127.0.0.1:8080/v1/AUTH_8980f74b1cda41e483cbe0a925f448a9"}}
-
-But, here's an example of what the dictionary may look like in the future::
-
-    {"storage":
-        {"default": "dfw",
-         "dfw": "http://dfw.storage.com:8080/v1/AUTH_8980f74b1cda41e483cbe0a925f448a9",
-         "ord": "http://ord.storage.com:8080/v1/AUTH_8980f74b1cda41e483cbe0a925f448a9",
-         "sat": "http://ord.storage.com:8080/v1/AUTH_8980f74b1cda41e483cbe0a925f448a9"},
-     "servers":
-        {"default": "dfw",
-         "dfw": "http://dfw.servers.com:8080/v1/AUTH_8980f74b1cda41e483cbe0a925f448a9",
-         "ord": "http://ord.servers.com:8080/v1/AUTH_8980f74b1cda41e483cbe0a925f448a9",
-         "sat": "http://ord.servers.com:8080/v1/AUTH_8980f74b1cda41e483cbe0a925f448a9"}}
-
-Lastly, the tokens themselves are stored as objects in the
-`<auth_account>/.token_[0-f]` containers. The names of the objects are the
-token strings themselves, such as `AUTH_tked86bbd01864458aa2bd746879438d5a`.
-The exact `.token_[0-f]` container chosen is based on the final digit of the
-token name, such as `.token_a` for the token
-`AUTH_tked86bbd01864458aa2bd746879438d5a`. The contents of the token objects
-are JSON dictionaries of the format::
-
-    {"account": <account>,
-     "user": <user>,
-     "account_id": <account_id>,
-     "groups": <groups_array>,
-     "expires": <time.time() value>}
-
-The `<account>` is the auth service account's name for that token. The `<user>`
-is the user within the account for that token. The `<account_id>` is the
-same as the `X-Container-Meta-Account-Id` for the auth service's account,
-as described above. The `<groups_array>` is the user's groups, as described
-above with the user object. The "expires" value indicates when the token is no
-longer valid, as compared to Python's time.time() value.
-
-Here's an example token object's JSON dictionary::
-
-    {"account": "test",
-     "user": "tester",
-     "account_id": "AUTH_8980f74b1cda41e483cbe0a925f448a9",
-     "groups": ["name": "test:tester", "name": "test", "name": ".admin"],
-     "expires": 1291273147.1624689}
-
-To easily map a user to an already issued token, the token name is stored in
-the user object's `X-Object-Meta-Auth-Token` header.
-
-Here is an example full listing of an <auth_account>::
-
-    .account_id
-        AUTH_2282f516-559f-4966-b239-b5c88829e927
-        AUTH_f6f57a3c-33b5-4e85-95a5-a801e67505c8
-        AUTH_fea96a36-c177-4ca4-8c7e-b8c715d9d37b
-    .token_0
-    .token_1
-    .token_2
-    .token_3
-    .token_4
-    .token_5
-    .token_6
-        AUTH_tk9d2941b13d524b268367116ef956dee6
-    .token_7
-    .token_8
-        AUTH_tk93627c6324c64f78be746f1e6a4e3f98
-    .token_9
-    .token_a
-    .token_b
-    .token_c
-    .token_d
-    .token_e
-        AUTH_tk0d37d286af2c43ffad06e99112b3ec4e
-    .token_f
-        AUTH_tk766bbde93771489982d8dc76979d11cf
-    reseller
-        .services
-        reseller
-    test
-        .services
-        tester
-        tester3
-    test2
-        .services
-        tester2

=== modified file 'doc/source/overview_large_objects.rst'
--- doc/source/overview_large_objects.rst	2010-12-06 20:01:19 +0000
+++ doc/source/overview_large_objects.rst	2011-06-15 09:24:34 +0000
@@ -14,24 +14,24 @@
 with the possibility of parallel uploads of the segments.
 
 ----------------------------------
-Using ``st`` for Segmented Objects
+Using ``swift`` for Segmented Objects
 ----------------------------------
 
-The quickest way to try out this feature is use the included ``st`` Swift Tool.
+The quickest way to try out this feature is use the included ``swift`` Swift Tool.
 You can use the ``-S`` option to specify the segment size to use when splitting
 a large file. For example::
 
-    st upload test_container -S 1073741824 large_file
+    swift upload test_container -S 1073741824 large_file
 
 This would split the large_file into 1G segments and begin uploading those
-segments in parallel. Once all the segments have been uploaded, ``st`` will
+segments in parallel. Once all the segments have been uploaded, ``swift`` will
 then create the manifest file so the segments can be downloaded as one.
 
-So now, the following ``st`` command would download the entire large object::
-
-    st download test_container large_file
-
-``st`` uses a strict convention for its segmented object support. In the above
+So now, the following ``swift`` command would download the entire large object::
+
+    swift download test_container large_file
+
+``swift`` uses a strict convention for its segmented object support. In the above
 example it will upload all the segments into a second container named
 test_container_segments. These segments will have names like
 large_file/1290206778.25/21474836480/00000000,
@@ -43,7 +43,7 @@
 upload of a new file with the same name won't overwrite the contents of the
 first until the last moment when the manifest file is updated.
 
-``st`` will manage these segment files for you, deleting old segments on
+``swift`` will manage these segment files for you, deleting old segments on
 deletes and overwrites, etc. You can override this behavior with the
 ``--leave-segments`` option if desired; this is useful if you want to have
 multiple versions of the same large object available.
@@ -53,14 +53,14 @@
 ----------
 
 You can also work with the segments and manifests directly with HTTP requests
-instead of having ``st`` do that for you. You can just upload the segments like
+instead of having ``swift`` do that for you. You can just upload the segments like
 you would any other object and the manifest is just a zero-byte file with an
 extra ``X-Object-Manifest`` header.
 
 All the object segments need to be in the same container, have a common object
 name prefix, and their names sort in the order they should be concatenated.
 They don't have to be in the same container as the manifest file will be, which
-is useful to keep container listings clean as explained above with ``st``.
+is useful to keep container listings clean as explained above with ``swift``.
 
 The manifest file is simply a zero-byte file with the extra