"""

if hasattr(headers, 'items'):

headers = headers.items()

for name, value in headers:

if name.lower() == 'etag':

response.headers[name] = value.replace('"', '')

elif name.lower() not in (

'date', 'content-length', 'content-type',

'connection', 'x-put-timestamp', 'x-delete-after'):

"""

func.delay_denial = True

"""

meta = {}

sysmeta = {}

other = {}

for key, val in dict(headers).items():

lkey = wsgi_to_str(key).lower()

val = wsgi_to_str(val) if isinstance(val, str) else val

if is_user_meta(server_type, lkey):

meta[strip_user_meta_prefix(server_type, lkey)] = val

elif is_sys_meta(server_type, lkey):

sysmeta[strip_sys_meta_prefix(server_type, lkey)] = val

else:

other[lkey] = val

"""

headers, meta, sysmeta = _prep_headers_to_info(headers, 'account')

account_info = {

'status': status_int,

# 'container_count' anomaly:

# Previous code sometimes expects an int sometimes a string

# Current code aligns to str and None, yet translates to int in

# deprecated functions as needed

'container_count': headers.get('x-account-container-count'),

'total_object_count': headers.get('x-account-object-count'),

'bytes': headers.get('x-account-bytes-used'),

'storage_policies': {policy.idx: {

'container_count': int(headers.get(

'x-account-storage-policy-{}-container-count'.format(

policy.name), 0)),

'object_count': int(headers.get(

'x-account-storage-policy-{}-object-count'.format(

policy.name), 0)),

'bytes': int(headers.get(

'x-account-storage-policy-{}-bytes-used'.format(

policy.name), 0))}

for policy in POLICIES

},

'meta': meta,

'sysmeta': sysmeta,

}

if is_success(status_int):

account_info['account_really_exists'] = not config_true_value(

headers.get('x-backend-fake-account-listing'))

"""

headers, meta, sysmeta = _prep_headers_to_info(headers, 'container')

return {

'status': status_int,

'read_acl': headers.get('x-container-read'),

'write_acl': headers.get('x-container-write'),

'sync_to': headers.get('x-container-sync-to'),

'sync_key': headers.get('x-container-sync-key'),

'object_count': headers.get('x-container-object-count'),

'bytes': headers.get('x-container-bytes-used'),

'versions': headers.get('x-versions-location'),

'storage_policy': headers.get('x-backend-storage-policy-index', '0'),

'cors': {

'allow_origin': meta.get('access-control-allow-origin'),

'expose_headers': meta.get('access-control-expose-headers'),

'max_age': meta.get('access-control-max-age')

},

'meta': meta,

'sysmeta': sysmeta,

'sharding_state': headers.get('x-backend-sharding-state', 'unsharded'),

# the 'internal' format version of timestamps is cached since the

# normal format can be derived from this when required

'created_at': headers.get('x-backend-timestamp'),

'put_timestamp': headers.get('x-backend-put-timestamp'),

'delete_timestamp': headers.get('x-backend-delete-timestamp'),

'status_changed_at': headers.get('x-backend-status-changed-at'),

"""

if not info:

return None

required = (

('x-backend-timestamp', 'created_at'),

('x-backend-put-timestamp', 'put_timestamp'),

('x-backend-delete-timestamp', 'delete_timestamp'),

('x-backend-status-changed-at', 'status_changed_at'),

('x-backend-storage-policy-index', 'storage_policy'),

('x-container-object-count', 'object_count'),

('x-container-bytes-used', 'bytes'),

('x-backend-sharding-state', 'sharding_state'),

)

required_normal_format_timestamps = (

('x-timestamp', 'created_at'),

('x-put-timestamp', 'put_timestamp'),

)

optional = (

('x-container-read', 'read_acl'),

('x-container-write', 'write_acl'),

('x-container-sync-key', 'sync_key'),

('x-container-sync-to', 'sync_to'),

('x-versions-location', 'versions'),

)

cors_optional = (

('access-control-allow-origin', 'allow_origin'),

('access-control-expose-headers', 'expose_headers'),

('access-control-max-age', 'max_age')

)

def lookup(info, key):

# raises KeyError or ValueError

val = info[key]

if val is None:

raise ValueError

return val

# note: required headers may be missing from info for example during

# upgrade when stale info is still in cache

headers = HeaderKeyDict()

for hdr, key in required:

try:

headers[hdr] = lookup(info, key)

except (KeyError, ValueError):

return None

for hdr, key in required_normal_format_timestamps:

try:

headers[hdr] = Timestamp(lookup(info, key)).normal

except (KeyError, ValueError):

return None

for hdr, key in optional:

try:

headers[hdr] = lookup(info, key)

except (KeyError, ValueError):

pass

policy_index = info.get('storage_policy')

headers['x-storage-policy'] = POLICIES[int(policy_index)].name

prefix = get_user_meta_prefix('container')

headers.update(

(prefix + k, v)

for k, v in info.get('meta', {}).items())

for hdr, key in cors_optional:

try:

headers[prefix + hdr] = lookup(info.get('cors'), key)

except (KeyError, ValueError):

pass

prefix = get_sys_meta_prefix('container')

headers.update(

(prefix + k, v)

for k, v in info.get('sysmeta', {}).items())

"""

headers, meta, sysmeta = _prep_headers_to_info(headers, 'object')

transient_sysmeta = {}

for key, val in headers.items():

if is_object_transient_sysmeta(key):

key = strip_object_transient_sysmeta_prefix(key.lower())

transient_sysmeta[key] = val

info = {'status': status_int,

'length': headers.get('content-length'),

'type': headers.get('content-type'),

'etag': headers.get('etag'),

'meta': meta,

'sysmeta': sysmeta,

'transient_sysmeta': transient_sysmeta

}

"""

@functools.wraps(func)

def wrapped(*a, **kw):

controller = a[0]

req = a[1]

# The logic here was interpreted from

# http://www.w3.org/TR/cors/#resource-requests

# Is this a CORS request?

req_origin = req.headers.get('Origin', None)

if req_origin:

# Yes, this is a CORS request so test if the origin is allowed

container_info = \

controller.container_info(controller.account_name,

controller.container_name, req)

cors_info = container_info.get('cors', {})

# Call through to the decorated method

resp = func(*a, **kw)

if controller.app.strict_cors_mode and \

not controller.is_origin_allowed(cors_info, req_origin):

return resp

# Expose,

# - simple response headers,

# http://www.w3.org/TR/cors/#simple-response-header

# - swift specific: etag, x-timestamp, x-trans-id

# - headers provided by the operator in cors_expose_headers

# - user metadata headers

# - headers provided by the user in

# x-container-meta-access-control-expose-headers

if 'Access-Control-Expose-Headers' not in resp.headers:

expose_headers = set([

'cache-control', 'content-language', 'content-type',

'expires', 'last-modified', 'pragma', 'etag',

'x-timestamp', 'x-trans-id', 'x-openstack-request-id'])

expose_headers.update(controller.app.cors_expose_headers)

for header in resp.headers:

if header.startswith('X-Container-Meta') or \

header.startswith('X-Object-Meta'):

expose_headers.add(header.lower())

if cors_info.get('expose_headers'):

expose_headers = expose_headers.union(

[header_line.strip().lower()

for header_line in

cors_info['expose_headers'].split(' ')

if header_line.strip()])

resp.headers['Access-Control-Expose-Headers'] = \

', '.join(expose_headers)

# The user agent won't process the response if the Allow-Origin

# header isn't included

if 'Access-Control-Allow-Origin' not in resp.headers:

if cors_info['allow_origin'] and \

cors_info['allow_origin'].strip() == '*':

resp.headers['Access-Control-Allow-Origin'] = '*'

else:

resp.headers['Access-Control-Allow-Origin'] = req_origin

if 'Vary' in resp.headers:

resp.headers['Vary'] += ', Origin'

else:

resp.headers['Vary'] = 'Origin'

return resp

else:

# Not a CORS request so make the call as normal

return func(*a, **kw)

"""

(version, account, container, obj) = \

split_path(path or env['PATH_INFO'], 4, 4, True)

info = _get_object_info(app, env, account, container, obj,

swift_source=swift_source)

if info:

info = deepcopy(info)

else:

info = headers_to_object_info({}, 0)

for field in ('length',):

if info.get(field) is None:

info[field] = 0

else:

info[field] = int(info[field])

app, cache_state, container=None, resp=None):

"""

try:

proxy_app = app._pipeline_final_app

except AttributeError:

logger = None

else:

logger = proxy_app.logger

server_type = 'container' if container else 'account'

if logger:

"""

(version, wsgi_account, wsgi_container, unused) = \

split_path(env['PATH_INFO'], 3, 4, True)

if not constraints.valid_api_version(version):

# Not a valid Swift request; return 0 like we do

# if there's an account failure

return headers_to_container_info({}, 0)

account = wsgi_to_str(wsgi_account)

container = wsgi_to_str(wsgi_container)

# Try to cut through all the layers to the proxy app

# (while also preserving logging)

try:

logged_app = app._pipeline_request_logging_app

proxy_app = app._pipeline_final_app

except AttributeError:

logged_app = proxy_app = app

# Check in environment cache and in memcache (in that order)

info, cache_state = _get_info_from_caches(

proxy_app, env, account, container)

resp = None

if not info and not cache_only:

# Cache miss; go HEAD the container and populate the caches

env.setdefault('swift.infocache', {})

# Before checking the container, make sure the account exists.

#

# If it is an autocreateable account, just assume it exists; don't

# HEAD the account, as a GET or HEAD response for an autocreateable

# account is successful whether the account actually has .db files

# on disk or not.

is_autocreate_account = account.startswith(

constraints.AUTO_CREATE_ACCOUNT_PREFIX)

if not is_autocreate_account:

account_info = get_account_info(env, logged_app, swift_source)

if not account_info or not is_success(account_info['status']):

_record_ac_info_cache_metrics(

logged_app, cache_state, container)

return headers_to_container_info({}, 0)

req = _prepare_pre_auth_info_request(

env, ("/%s/%s/%s" % (version, wsgi_account, wsgi_container)),

(swift_source or 'GET_CONTAINER_INFO'))

# *Always* allow reserved names for get-info requests -- it's on the

# caller to keep the result private-ish

req.headers['X-Backend-Allow-Reserved-Names'] = 'true'

resp = req.get_response(logged_app)

drain_and_close(resp)

# Check in infocache to see if the proxy (or anyone else) already

# populated the cache for us. If they did, just use what's there.

#

# See similar comment in get_account_info() for justification.

info = _get_info_from_infocache(env, account, container)

if info is None:

info = set_info_cache(env, account, container, resp)

if info:

info = deepcopy(info) # avoid mutating what's in swift.infocache

else:

status_int = 0 if cache_only else 503

info = headers_to_container_info({}, status_int)

# Old data format in memcache immediately after a Swift upgrade; clean

# it up so consumers of get_container_info() aren't exposed to it.

if 'object_count' not in info and 'container_size' in info:

info['object_count'] = info.pop('container_size')

for field in ('storage_policy', 'bytes', 'object_count'):

if info.get(field) is None:

info[field] = 0

else:

info[field] = int(info[field])

if info.get('sharding_state') is None:

info['sharding_state'] = 'unsharded'

versions_cont = info.get('sysmeta', {}).get('versions-container', '')

if versions_cont:

versions_cont = wsgi_unquote(str_to_wsgi(

versions_cont)).split('/')[0]

versions_req = _prepare_pre_auth_info_request(

env, ("/%s/%s/%s" % (version, wsgi_account, versions_cont)),

(swift_source or 'GET_CONTAINER_INFO'))

versions_req.headers['X-Backend-Allow-Reserved-Names'] = 'true'

versions_info = get_container_info(versions_req.environ, app)

info['bytes'] = info['bytes'] + versions_info['bytes']

_record_ac_info_cache_metrics(logged_app, cache_state, container, resp)

"""

(version, wsgi_account, _junk) = split_path(env['PATH_INFO'], 2, 3, True)

if not constraints.valid_api_version(version):

return headers_to_account_info({}, 0)

account = wsgi_to_str(wsgi_account)

# Try to cut through all the layers to the proxy app

# (while also preserving logging)

try:

app = app._pipeline_request_logging_app

except AttributeError:

pass

# Check in environment cache and in memcache (in that order)

info, cache_state = _get_info_from_caches(app, env, account)

# Cache miss; go HEAD the account and populate the caches

if info:

resp = None

else:

env.setdefault('swift.infocache', {})

req = _prepare_pre_auth_info_request(

env, "/%s/%s" % (version, wsgi_account),

(swift_source or 'GET_ACCOUNT_INFO'))

# *Always* allow reserved names for get-info requests -- it's on the

# caller to keep the result private-ish

req.headers['X-Backend-Allow-Reserved-Names'] = 'true'

resp = req.get_response(app)

drain_and_close(resp)

# Check in infocache to see if the proxy (or anyone else) already

# populated the cache for us. If they did, just use what's there.

#

# The point of this is to avoid setting the value in memcached

# twice. Otherwise, we're needlessly sending requests across the

# network.

#

# If the info didn't make it into the cache, we'll compute it from

# the response and populate the cache ourselves.

#

# Note that this is taking "exists in infocache" to imply "exists in

# memcache". That's because we're trying to avoid superfluous

# network traffic, and checking in memcache prior to setting in

# memcache would defeat the purpose.

info = _get_info_from_infocache(env, account)

if info is None:

info = set_info_cache(env, account, None, resp)

if info:

info = info.copy() # avoid mutating what's in swift.infocache

else:

info = headers_to_account_info({}, 503)

for field in ('container_count', 'bytes', 'total_object_count'):

if info.get(field) is None:

info[field] = 0

else:

info[field] = int(info[field])

_record_ac_info_cache_metrics(app, cache_state, container=None, resp=resp)

"""

def to_native(s):

if s is None or isinstance(s, str):

return s

return s.decode('utf8', 'surrogateescape')

account = to_native(account)

container = to_native(container)

obj = to_native(obj)

if shard:

if not (account and container):

raise ValueError('Shard cache key requires account and container')

if obj:

raise ValueError('Shard cache key cannot have obj')

cache_key = 'shard-%s-v2/%s/%s' % (shard, account, container)

elif obj:

if not (account and container):

raise ValueError('Object cache key requires account and container')

cache_key = 'object/%s/%s/%s' % (account, container, obj)

elif container:

if not account:

raise ValueError('Container cache key requires account')

cache_key = 'container/%s/%s' % (account, container)

else:

cache_key = 'account/%s' % account

# Use a unique environment cache key per account and one container.

# This allows caching both account and container and ensures that when we

# copy this env to form a new request, it won't accidentally reuse the

# old container or account info

"""

cache_key = get_cache_key(account, container)

infocache = env.setdefault('swift.infocache', {})

memcache = cache_from_env(env, True)

if resp is None:

clear_info_cache(env, account, container)

return

if container:

cache_time = int(resp.headers.get(

'X-Backend-Recheck-Container-Existence',

DEFAULT_RECHECK_CONTAINER_EXISTENCE))

else:

cache_time = int(resp.headers.get(

'X-Backend-Recheck-Account-Existence',

DEFAULT_RECHECK_ACCOUNT_EXISTENCE))

if resp.status_int in (HTTP_NOT_FOUND, HTTP_GONE):

cache_time *= 0.1

elif not is_success(resp.status_int):

# If we got a response, it was unsuccessful, and it wasn't an

# "authoritative" failure, bail without touching caches.

return

if container:

info = headers_to_container_info(resp.headers, resp.status_int)

else:

info = headers_to_account_info(resp.headers, resp.status_int)

if memcache:

memcache.set(cache_key, info, time=cache_time)

infocache[cache_key] = info

"""

cache_key = get_cache_key(account, container, obj)

if 'swift.infocache' in env and not resp:

env['swift.infocache'].pop(cache_key, None)

return

info = headers_to_object_info(resp.headers, resp.status_int)

env.setdefault('swift.infocache', {})[cache_key] = info

"""

cache_key = get_cache_key(account, container, shard=shard)

infocache = env.setdefault('swift.infocache', {})

memcache = cache_from_env(env, True)

infocache.pop(cache_key, None)

if memcache:

"""

cache_key = get_cache_key(account, container)

if 'swift.infocache' in env and cache_key in env['swift.infocache']:

return env['swift.infocache'][cache_key]

logger, server_type, op_type, cache_state, resp=None):

"""

server_type = server_type.lower()

if cache_state == 'infocache_hit':

logger.increment('%s.%s.infocache.hit' % (server_type, op_type))

elif cache_state == 'hit':

# memcache hits.

logger.increment('%s.%s.cache.hit' % (server_type, op_type))

else:

# the cases of cache_state is memcache miss, error, skip, force_skip

# or disabled.

if resp:

logger.increment('%s.%s.cache.%s.%d' % (

server_type, op_type, cache_state, resp.status_int))

else:

# In some situation, we choose not to lookup backend after cache

# miss.

logger.increment('%s.%s.cache.%s' % (

"""

memcache = cache_from_env(env, True)

if not memcache:

return None, 'disabled'

try:

proxy_app = app._pipeline_final_app

except AttributeError:

# Only the middleware entry-points get a reference to the

# proxy-server app; if a middleware composes itself as multiple

# filters, we'll just have to choose a reasonable default

skip_chance = 0.0

else:

if container:

skip_chance = proxy_app.container_existence_skip_cache

else:

skip_chance = proxy_app.account_existence_skip_cache

cache_key = get_cache_key(account, container)

if skip_chance and random.random() < skip_chance:

info = None

cache_state = 'skip'

else:

info = memcache.get(cache_key)

cache_state = 'hit' if info else 'miss'

if info:

env.setdefault('swift.infocache', {})[cache_key] = info

"""

info = _get_info_from_infocache(env, account, container)

if info:

cache_state = 'infocache_hit'

else:

info, cache_state = _get_info_from_memcache(

app, env, account, container)

"""

ns_bound_list = None

if bounds:

ns_bound_list = NamespaceBoundList(bounds)

"""

bounds = None

if ns_bound_list:

bounds = ns_bound_list.bounds

"""

# try get namespaces from infocache first

infocache = req.environ.setdefault('swift.infocache', {})

ns_bound_list = infocache.get(cache_key)

if ns_bound_list:

return ns_bound_list, 'infocache_hit'

# then try get them from memcache

memcache = cache_from_env(req.environ, True)

if skip_chance and random.random() < skip_chance:

return None, 'skip'

try:

bounds = memcache.get(cache_key, raise_on_error=True)

cache_state = 'hit' if bounds else 'miss'

except MemcacheConnectionError:

bounds = None

cache_state = 'error'

ns_bound_list = namespace_bounds_to_list(bounds)

infocache[cache_key] = ns_bound_list

"""

if cache_key.startswith('shard-updating'):

raise ValueError('shard-updating cache should use '

'CooperativeNamespaceCachePopulator')

infocache = req.environ.setdefault('swift.infocache', {})

infocache[cache_key] = ns_bound_list

memcache = cache_from_env(req.environ, True)

if memcache:

bounds = namespace_list_to_bounds(ns_bound_list)

try:

memcache.set(cache_key, bounds, time=time, raise_on_error=True)

except MemcacheConnectionError:

cache_state = 'set_error'

else:

cache_state = 'set'

else:

# N.B. get_namespaces_from_cache is used for both types of namespace

# cache objects (updating and listing), and both code paths only call

# that helper if memcache is enabled. But this function is now only

# used to set cache *listing* namespace objects over in

# ContainerController, so if that code path learns to not call it when

# memcache is disabled this func could also drop cache_state=disabled

cache_state = 'disabled'

"""

# Set the env for the pre_authed call without a query string

newenv = make_pre_authed_env(env, 'HEAD', path, agent='Swift',

query_string='', swift_source=swift_source)

# This is a sub request for container metadata- drop the Origin header from

# the request so the it is not treated as a CORS request.

newenv.pop('HTTP_ORIGIN', None)

# ACLs are only shown to account owners, so let's make sure this request

# looks like it came from the account owner.

newenv['swift_owner'] = True

# Note that Request.blank expects quoted path

"""