def wrapper(*args, **kw):

        storage_url = args[0].session.get('storage_url', '')
        auth_token = args[0].session.get('auth_token', '')
        username = args[0].session.get('username', '')
        password = args[0].session.get('password', '')

        try:
            client.head_account(storage_url, auth_token)
            return fn(*args, **kw)
        except:

            #Attempt to get a new auth token
            try:
                auth_version = settings.SWIFT_AUTH_VERSION or 1
                (storage_url, auth_token) = client.get_auth(
                    settings.SWIFT_AUTH_URL, username, password,
                    auth_version=auth_version)
                args[0].session['auth_token'] = auth_token
                args[0].session['storage_url'] = storage_url

                return fn(*args, **kw)
            except:
                messages.error(args[0], _("Session expired."))
        return {'errors': 'true'}

 def test_server_error(self):
     body = "c" * 65
     c.http_connection = self.fake_http_connection(500, body=body)
     self.assertRaises(c.ClientException, c.head_account, "http://www.tests.com", "asdf")
     try:
         c.head_account("http://www.tests.com", "asdf")
     except c.ClientException as e:
         new_body = "[first 60 chars of response] " + body[0:60]
         self.assertEqual(e.__str__()[-89:], new_body)

    def wrapper(*args, **kw):

        storage_url = args[0].session.get('storage_url', '')
        auth_token = args[0].session.get('auth_token', '')
        username = args[0].session.get('username', '')
        password = args[0].session.get('password', '')

        # If the following variables are available, attempt to get an
        # auth token
        if (storage_url and auth_token and username and password):

             # If the user has no role, head the container to valid the token
            if args[0].session.get('norole'):

                storage_url = args[0].session.get('default_storage_url', '')
                auth_token = args[0].session.get('default_auth_token', '')

                #Attempt to get a new auth token
                try:
                    client.head_container(
                        storage_url, auth_token, args[0].session.get('user'))
                    return fn(*args, **kw)
                except:
                    # Failure to get an auth token, tell the user the session
                    # has expiredself.
                    messages.error(args[0], _("Session expired."))

            # A regular user's token is validated by heading the account.
            else:
                try:
                    client.head_account(storage_url, auth_token)
                    return fn(*args, **kw)
                except:

                    #Attempt to get a new auth token
                    try:
                        auth_version = settings.SWIFT_AUTH_VERSION or 1
                        (storage_url, auth_token) = client.get_auth(
                            settings.SWIFT_AUTH_URL, username, password,
                            auth_version=auth_version)
                        args[0].session['auth_token'] = auth_token
                        args[0].session['storage_url'] = storage_url
                        return fn(*args, **kw)
                    except:
                        # Failure to get an auth token, tell the user the
                        # session has expired.
                        messages.error(args[0], _("Session expired."))
        return redirect(swiftbrowser.views.login)

    def setUp(self):
        super(TestAccountReaper, self).setUp()
        self.all_objects = []
        # upload some containers
        body = 'test-body'
        for policy in ENABLED_POLICIES:
            container = 'container-%s-%s' % (policy.name, uuid.uuid4())
            client.put_container(self.url, self.token, container,
                                 headers={'X-Storage-Policy': policy.name})
            obj = 'object-%s' % uuid.uuid4()
            client.put_object(self.url, self.token, container, obj, body)
            self.all_objects.append((policy, container, obj))
            policy.load_ring('/etc/swift')

        Manager(['container-updater']).once()

        headers = client.head_account(self.url, self.token)

        self.assertEqual(int(headers['x-account-container-count']),
                         len(ENABLED_POLICIES))
        self.assertEqual(int(headers['x-account-object-count']),
                         len(ENABLED_POLICIES))
        self.assertEqual(int(headers['x-account-bytes-used']),
                         len(ENABLED_POLICIES) * len(body))

        part, nodes = self.account_ring.get_nodes(self.account)

        for node in nodes:
            direct_delete_account(node, part, self.account)

def get_temp_key(storage_url, auth_token):
    """ Tries to get meta-temp-url key from account.
    If not set, generate tempurl and save it to acocunt.
    This requires at least account owner rights. """

    logging.debug('  in get_temp_key:  '  )

    try:
        account = client.head_account(storage_url, auth_token)
    except client.ClientException:
        return None
    logging.debug(' account in get_temp_key: %s ' % account)

    key = account.get('x-account-meta-temp-url-key')
    logging.debug(' key in get_temp_key: %s ' % key)

    if not key:
        chars = string.ascii_lowercase + string.digits
        key = ''.join(random.choice(chars) for x in range(32))
        headers = {'x-account-meta-temp-url-key': key}
        try:
            client.post_account(storage_url, auth_token, headers)
        except client.ClientException:
            return None
    return key

 def test_ok(self):
     c.http_connection = self.fake_http_connection(200)
     value = c.head_account('http://www.tests.com', 'asdf')
     # TODO: Hmm. This doesn't really test too much as it uses a fake that
     # always returns the same dict. I guess it "exercises" the code, so
     # I'll leave it for now.
     self.assertEqual(type(value), dict)

 def iter_accounts(ksclient):
     endpoint = ksclient.service_catalog.url_for(
         service_type='object-store',
         endpoint_type='adminURL')
     base_url = '%s/v1/%s' % (endpoint, cfg.CONF.reseller_prefix)
     for t in ksclient.tenants.list():
         yield (t.id, swift.head_account('%s%s' % (base_url, t.id),
                                         ksclient.auth_token))

def get_swift_used(sc, tenant_id):
    tenant_url, token = get_swift_tenant_connection(sc, tenant_id)
    try:
        swift_account = swiftclient.head_account(url=tenant_url, token=token)
    except sc_exception:
        print 'Project %s has no swift quota' % tenant_id
        return
    return swift_account.get(SWIFT_USED_KEY, -1)

def get_default_temp_time(storage_url, auth_token):
    """Return in seconds the header Default-Temp-Time for the given tenant.
    If an exception is caught, return 0."""

    try:
        cont = client.head_account(storage_url, auth_token)
        return cont.get('x-account-meta-default-temp-time', '')
    except:
        return 0

    def iter_accounts(ksclient):
        try:
            endpoint = ksclient.service_catalog.url_for(service_type="object-store", endpoint_type="adminURL")
        except exceptions.EndpointNotFound:
            LOG.debug(_("Swift endpoint not found"))
            return

        for t in ksclient.tenants.list():
            yield (t.id, swift.head_account(SwiftPollster._neaten_url(endpoint, t.id), ksclient.auth_token))

def login(request):
    """ Tries to login user and sets session data """
    request.session.flush()

    #Process the form if there is a POST request.
    if (request.POST):
        form = LoginForm(request.POST)
        if form.is_valid():
            username = form.cleaned_data['username']
            password = form.cleaned_data['password']
            try:
                auth_version = settings.SWIFT_AUTH_VERSION or 1
                (storage_url, auth_token) = client.get_auth(
                    settings.SWIFT_AUTH_URL, username, password,
                    auth_version=auth_version)
                request.session['auth_token'] = auth_token
                request.session['storage_url'] = storage_url
                request.session['username'] = username
                request.session['password'] = password

                tenant_name, user = split_tenant_user_names(username)
                request.session['user'] = user
                request.session['tenant_name'] = tenant_name

                # Upon successful retrieval of a token, if we're unable to
                # head the account, then the user is not an admin or
                # swiftoperator and has access to only a container.
                try:
                    client.head_account(storage_url, auth_token)
                except:
                    request.session['norole'] = True

                return redirect(containerview)

            # Specify why the login failed.
            except client.ClientException, e:
                messages.error(request, _("Login failed: {0}".format(
                    e)))

            # Generic login failure message.
            except Exception, e:
                print(e)
                messages.error(request, _("Login failed."))

    def test_sync(self):
        all_objects = []
        # upload some containers
        for policy in ENABLED_POLICIES:
            container = 'container-%s-%s' % (policy.name, uuid.uuid4())
            client.put_container(self.url, self.token, container,
                                 headers={'X-Storage-Policy': policy.name})
            obj = 'object-%s' % uuid.uuid4()
            body = 'test-body'
            client.put_object(self.url, self.token, container, obj, body)
            all_objects.append((policy, container, obj))

        Manager(['container-updater']).once()

        headers = client.head_account(self.url, self.token)

        self.assertEqual(int(headers['x-account-container-count']),
                         len(ENABLED_POLICIES))
        self.assertEqual(int(headers['x-account-object-count']),
                         len(ENABLED_POLICIES))
        self.assertEqual(int(headers['x-account-bytes-used']),
                         len(ENABLED_POLICIES) * len(body))

        part, nodes = self.account_ring.get_nodes(self.account)
        for node in nodes:
            direct_delete_account(node, part, self.account)

        Manager(['account-reaper']).once()

        get_to_final_state()

        for policy, container, obj in all_objects:
            cpart, cnodes = self.container_ring.get_nodes(
                self.account, container)
            for cnode in cnodes:
                try:
                    direct_head_container(cnode, cpart, self.account,
                                          container)
                except ClientException as err:
                    self.assertEquals(err.http_status, 404)
                else:
                    self.fail('Found un-reaped /%s/%s on %r' %
                              (self.account, container, node))
            object_ring = POLICIES.get_object_ring(policy.idx, '/etc/swift/')
            part, nodes = object_ring.get_nodes(self.account, container, obj)
            for node in nodes:
                try:
                    direct_get_object(node, part, self.account,
                                      container, obj)
                except ClientException as err:
                    self.assertEquals(err.http_status, 404)
                else:
                    self.fail('Found un-reaped /%s/%s/%s on %r in %s!' %
                              (self.account, container, obj, node, policy))

 def iter_accounts():
     ks = ksclient.Client(username=cfg.CONF.os_username,
                          password=cfg.CONF.os_password,
                          tenant_name=cfg.CONF.os_tenant_name,
                          auth_url=cfg.CONF.os_auth_url)
     endpoint = ks.service_catalog.url_for(service_type='object-store',
                                           endpoint_type='adminURL')
     base_url = '%s/v1/%s' % (endpoint, cfg.CONF.reseller_prefix)
     for t in ks.tenants.list():
         yield (t.id, swift.head_account('%s%s' % (base_url, t.id),
                                         ks.auth_token))

def get_tempurl_key():
    (storage_url, auth_token) = client.get_auth(settings.SWIFT_AUTH_URL, settings.SWIFT_USER, settings.SWIFT_PASSWORD)

    meta = client.head_account(storage_url, auth_token)
    key = meta.get("x-account-meta-temp-url-key")
    if not key:
        key = random_key()
        headers = {"x-account-meta-temp-url-key": key}
        client.post_account(storage_url, auth_token, headers)

    return storage_url, key

    def _get_account_info(self, ksclient, cache):
        try:
            endpoint = ksclient.service_catalog.url_for(
                service_type='object-store',
                endpoint_type='adminURL')
        except exceptions.EndpointNotFound:
            LOG.debug(_("Swift endpoint not found"))
            raise StopIteration()

        for t in cache['tenants']:
            yield (t.id, swift.head_account(self._neaten_url(endpoint, t.id),
                                            ksclient.auth_token))

    def _get_account_info(self, ksclient, cache):
        try:
            endpoint = ksclient.service_catalog.url_for(
                service_type='object-store',
                endpoint_type=cfg.CONF.service_credentials.os_endpoint_type)
        except exceptions.EndpointNotFound:
            LOG.debug(_("Swift endpoint not found"))
            raise StopIteration()

        for t in cache[self.CACHE_KEY_TENANT]:
            yield (t.id, swift.head_account(self._neaten_url(endpoint, t.id),
                                            ksclient.auth_token))

    def iter_accounts(ksclient):
        try:
            endpoint = ksclient.service_catalog.url_for(
                service_type='object-store',
                endpoint_type='adminURL')
        except exceptions.EndpointNotFound:
            LOG.debug(_("Swift endpoint not found"))
            return

        base_url = '%s/v1/%s' % (endpoint, cfg.CONF.reseller_prefix)
        for t in ksclient.tenants.list():
            yield (t.id, swift.head_account('%s%s' % (base_url, t.id),
                                            ksclient.auth_token))

def get_swift_usage(tenant_url, token):
    usage = {}
    usage['gb_allocated'] = usage['gb_used'] = 0

    try:
        swift_account = swiftclient.head_account(url=tenant_url, token=token)

        if SWIFT_QUOTA_KEY in swift_account:
            usage['gb_allocated'] = b_to_gb(swift_account[SWIFT_QUOTA_KEY])
        usage['gb_used'] = b_to_gb(swift_account['x-account-bytes-used'])
    except ClientException:
        pass

    return usage

def get_fine_grained_temp_key(storage_url, auth_token, container_name=None):
    """ 
    Tries to get meta-temp-url key from account or container.
    If not set, generate tempurl and save it.
    """

    logging.debug('  in get_fine_grained_temp_key: container_name:%s, \
        storage_url:%s ' % 
        (container_name, storage_url) )

    try:
        if container_name:
            container = client.head_container(storage_url, auth_token, 
                container_name)
            key = container.get('x-container-meta-temp-url-key')
            logging.debug(' key in get_fine_grained_temp_key container: %s ' % key)
        else:
            account = client.head_account(storage_url, auth_token)
            key = account.get('x-account-meta-temp-url-key')
            logging.debug(' key in get_fine_grained_temp_key account: %s ' % key)
    except client.ClientException:
        return None
    # logging.debug(' account or container in get_temp_key: %s ' 
    #     % account or container)

    if not key:
        chars = string.ascii_lowercase + string.digits
        key = ''.join(random.choice(chars) for x in range(32))
        if container_name:
            headers = {'x-container-meta-temp-url-key': key}
            try:
                client.post_container(storage_url, auth_token, container_name, 
                    headers)
                logging.debug(' post_container')

            except client.ClientException:
                return None
            raise ValueError('cannot get key, have no account rights to \
                get account key!')
        else:
            
            headers = {'x-account-meta-temp-url-key': key}
            try:
                client.post_account(storage_url, auth_token, headers)
                logging.debug(' post_account')

            except client.ClientException:
                return None
    return key

    def get_account(self, deep=True):
        if not self.http_conn:
            self.connect()

        account_info = swift.head_account(url=self.swift_url, token=self.token, http_conn=self.http_conn)
        account_head, containers = swift.get_account(url=self.swift_url, token=self.token, http_conn=self.http_conn)
        if self.debug:
            print(account_info)
            print(account_head)
            for container in containers:
                print(container)
            print

        if deep:
            self.get_containers(containers)