def test_http_connection(self):
url = 'http://www.test.com'
_junk, conn = c.http_connection(url)
self.assertTrue(isinstance(conn, c.HTTPConnection))
url = 'https://www.test.com'
_junk, conn = c.http_connection(url)
self.assertTrue(isinstance(conn, c.HTTPSConnection))
url = 'ftp://www.test.com'
self.assertRaises(c.ClientException, c.http_connection, url)
def test_http_connection(self):
url = 'http://www.test.com'
_junk, conn = c.http_connection(url)
self.assertTrue(isinstance(conn, c.HTTPConnection))
url = 'https://www.test.com'
_junk, conn = c.http_connection(url)
self.assertTrue(isinstance(conn, c.HTTPConnection))
url = 'ftp://www.test.com'
self.assertRaises(c.ClientException, c.http_connection, url)
def connect(self, force=False):
if self.http_conn is not None and not force:
return
swift_url, self.token = swift.get_auth(
auth_url=self.auth_url,
user=self.username,
key=self.password,
auth_version=self.auth_ver,
tenant_name=self.tenant,
)
if self.debug:
print(self.auth_url)
print(self.token)
print(self.swift_url)
print(swift_url)
print
if not swift_url == self.swift_url:
print("Different swift_url returned from swift")
self.http_conn = swift.http_connection(self.swift_url)
if self.debug:
print(self.http_conn)
print
def create_container(request):
""" Creates a container (empty object of type application/directory) """
storage_url = get_endpoint(request, 'adminURL')
auth_token = get_token_id(request)
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
form = CreateContainerForm(request.POST or None)
if form.is_valid():
container = form.cleaned_data['containername']
try:
client.put_container(storage_url,
auth_token,
container,
http_conn=http_conn)
messages.add_message(request, messages.SUCCESS,
_("Container created."))
actionlog.log(request.user.username, "create", container)
except client.ClientException as err:
log.exception('{}{}'.format(_('Exception:').encode('UTF-8'), err))
messages.add_message(request, messages.ERROR, _('Access denied.'))
return redirect(containerview)
context = utils.update_default_context(request, {
'form': form,
})
return render_to_response('create_container.html',
context,
context_instance=RequestContext(request))
def test_raw_upload(self):
# Raw upload happens when content_length is passed to put_object
conn = c.http_connection(u'http://www.test.com/')
resp = MockHttpResponse(status=200)
conn[1].getresponse = resp.fake_response
conn[1]._request = resp._fake_request
astring = 'asdf'
astring_len = len(astring)
mock_file = six.StringIO(astring)
c.put_object(url='http://www.test.com', http_conn=conn,
contents=mock_file, content_length=astring_len)
self.assertTrue(isinstance(resp.requests_params['data'],
swiftclient.utils.LengthWrapper))
self.assertEqual(astring_len,
len(resp.requests_params['data'].read()))
mock_file = six.StringIO(astring)
c.put_object(url='http://www.test.com', http_conn=conn,
headers={'Content-Length': str(astring_len)},
contents=mock_file)
self.assertTrue(isinstance(resp.requests_params['data'],
swiftclient.utils.LengthWrapper))
self.assertEqual(astring_len,
len(resp.requests_params['data'].read()))
def test_raw_upload(self):
# Raw upload happens when content_length is passed to put_object
conn = c.http_connection(u'http://www.test.com/')
resp = MockHttpResponse(status=200)
conn[1].getresponse = resp.fake_response
conn[1]._request = resp._fake_request
astring = 'asdf'
astring_len = len(astring)
mock_file = six.StringIO(astring)
c.put_object(url='http://www.test.com',
http_conn=conn,
contents=mock_file,
content_length=astring_len)
self.assertTrue(
isinstance(resp.requests_params['data'],
swiftclient.utils.LengthWrapper))
self.assertEqual(astring_len, len(resp.requests_params['data'].read()))
mock_file = six.StringIO(astring)
c.put_object(url='http://www.test.com',
http_conn=conn,
headers={'Content-Length': str(astring_len)},
contents=mock_file)
self.assertTrue(
isinstance(resp.requests_params['data'],
swiftclient.utils.LengthWrapper))
self.assertEqual(astring_len, len(resp.requests_params['data'].read()))
def __init__(self, conn, container, name, content_type=None):
parsed, self.conn = http_connection(conn.url)
logging.debug("ChunkObject: new connection open (%r, %r)" % (parsed, self.conn))
path = '%s/%s/%s' % (parsed.path.rstrip('/'),
quote(smart_str(container)),
quote(smart_str(name)),
)
headers = { 'X-Auth-Token': conn.token,
'Content-Type': content_type or 'application/octet-stream',
'Transfer-Encoding': 'chunked',
'Connection': 'close',
# User-Agent ?
}
if conn.real_ip:
headers['X-Forwarded-For'] = conn.real_ip
# we can't use the generator interface offered by requests to do a
# chunked transfer encoded PUT, so we do this is to get control over the
# "real" http connection and do the HTTP request ourselves
self.raw_conn = self.conn.request_session.get_adapter(conn.url).get_connection(conn.url)._get_conn()
self.raw_conn.putrequest('PUT', path, skip_accept_encoding=True)
for key, value in headers.iteritems():
self.raw_conn.putheader(key, value)
self.raw_conn.endheaders()
logging.debug("ChunkedObject: path=%r, headers=%r" % (path, headers))
self.already_sent = 0
def test_unicode_ok(self):
conn = c.http_connection(u'http://www.test.com/')
args = (u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91',
u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91',
u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91',
u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91')
text = u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91'
headers = {'X-Header1': text,
b'X-Header2': 'value',
'X-2': '1', 'X-3': {'a': 'b'}, 'a-b': '.x:yz mn:kl:qr',
'X-Object-Meta-Header-not-encoded': text,
b'X-Object-Meta-Header-encoded': 'value'}
resp = MockHttpResponse()
conn[1].getresponse = resp.fake_response
conn[1]._request = resp._fake_request
c.post_object(*args, headers=headers, http_conn=conn)
# Test for RFC-2616 encoded symbols
self.assertIn(('a-b', b".x:yz mn:kl:qr"), resp.buffer)
# Test unicode header
self.assertIn(('x-header1', text.encode('utf8')),
resp.buffer)
self.assertIn((b'x-object-meta-header-not-encoded',
text.encode('utf8')), resp.buffer)
self.assertIn((b'x-object-meta-header-encoded', b'value'),
resp.buffer)
self.assertIn((b'x-header2', b'value'), resp.buffer)
def containerview(request):
""" Returns a list of all containers in current account. """
if not request.session.get('project_id'):
messages.add_message(request, messages.ERROR, _('Select a project'))
return HttpResponseRedirect(reverse('dashboard'))
storage_url = get_endpoint(request, 'adminURL')
auth_token = get_token_id(request)
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
page = request.GET.get('page', 1)
try:
account_stat, containers = client.get_account(storage_url, auth_token,
http_conn=http_conn)
except client.ClientException as err:
log.exception('{}{}'.format(_('Exception:').encode('UTF-8'), err))
messages.add_message(request, messages.ERROR,
_('Unable to list containers'))
account_stat = {}
containers = []
containers = _hide_containers_with_prefixes(containers)
account_stat = replace_hyphens(account_stat)
context = utils.update_default_context(request, {
'account_stat': account_stat,
'containers': utils.generic_pagination(containers, page),
})
return render_to_response('containerview.html', context,
context_instance=RequestContext(request))
def create_container(request):
""" Creates a container (empty object of type application/directory) """
storage_url = get_endpoint(request, 'adminURL')
auth_token = get_token_id(request)
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
form = CreateContainerForm(request.POST or None)
if form.is_valid():
container = form.cleaned_data['containername']
try:
client.put_container(storage_url,
auth_token,
container,
http_conn=http_conn)
messages.add_message(request, messages.SUCCESS,
_("Container created."))
actionlog.log(request.user.username, "create", container)
except client.ClientException as err:
log.exception('{}{}'.format(_('Exception:').encode('UTF-8'), err))
messages.add_message(request, messages.ERROR, _('Access denied.'))
return redirect(containerview)
context = utils.update_default_context(request, {
'form': form,
})
return render_to_response('create_container.html', context,
context_instance=RequestContext(request))
def __init__(self, conn, container, name, content_type=None, reuse_token = True):
self.raw_conn = None
if reuse_token:
self.url = conn.url
token = conn.token
else:
self.url, token = conn.get_auth()
self.parsed, self.conn = http_connection(self.url)
self.path = '%s/%s/%s' % (self.parsed.path.rstrip('/'),
quote(smart_str(container)),
quote(smart_str(name)),
)
self.headers = { 'X-Auth-Token': token,
'Content-Type': content_type or 'application/octet-stream',
'Transfer-Encoding': 'chunked',
'Connection': 'close',
# User-Agent ?
}
if conn.real_ip:
self.headers['X-Forwarded-For'] = conn.real_ip
logging.debug("ChunkedObject: path=%r, headers=%r" % (self.path, self.headers))
self.already_sent = 0
def test_unicode_ok(self):
conn = c.http_connection(u'http://www.test.com/')
args = (u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91',
u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91',
u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91',
u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91')
text = u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91'
headers = {
'X-Header1': text,
b'X-Header2': 'value',
'X-2': '1',
'X-3': {
'a': 'b'
},
'a-b': '.x:yz mn:kl:qr',
'X-Object-Meta-Header-not-encoded': text,
b'X-Object-Meta-Header-encoded': 'value'
}
resp = MockHttpResponse()
conn[1].getresponse = resp.fake_response
conn[1]._request = resp._fake_request
c.post_object(*args, headers=headers, http_conn=conn)
# Test for RFC-2616 encoded symbols
self.assertIn(('a-b', b".x:yz mn:kl:qr"), resp.buffer)
# Test unicode header
self.assertIn(('x-header1', text.encode('utf8')), resp.buffer)
self.assertIn(
(b'x-object-meta-header-not-encoded', text.encode('utf8')),
resp.buffer)
self.assertIn((b'x-object-meta-header-encoded', b'value'), resp.buffer)
self.assertIn((b'x-header2', b'value'), resp.buffer)
def delete_container(request, container, force=True):
"""
Deletes a container. If force is True, it will deletes all objects first.
"""
storage_url = get_endpoint(request, 'adminURL')
auth_token = get_token_id(request)
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
if force:
try:
_, objects = client.get_container(storage_url,
auth_token,
container,
http_conn=http_conn)
except client.ClientException as err:
log.exception('{}{}'.format(ugettext('Exception:').encode('UTF-8'), err))
return False
for obj in objects:
delete_object(request=request,
container=container,
objectname=obj['name'])
try:
client.delete_container(storage_url, auth_token,
container, http_conn=http_conn)
actionlog.log(request.user.username, "delete", container)
except client.ClientException as err:
log.exception('{}{}'.format(ugettext('Exception:').encode('UTF-8'), err))
return False
return True
def objectview(request, container, prefix=None):
""" Returns list of all objects in current container. """
storage_url = get_endpoint(request, 'adminURL')
public_url = get_endpoint(request, 'publicURL') + '/' + container
auth_token = get_token_id(request)
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
page = request.GET.get('page', 1)
try:
_, objects = client.get_container(storage_url, auth_token,
container, delimiter='/',
prefix=prefix,
http_conn=http_conn)
except client.ClientException as err:
log.exception('{}{}'.format(ugettext('Exception:').encode('UTF-8'), err))
messages.add_message(request, messages.ERROR, ugettext('Access denied.'))
return redirect(containerview)
prefixes = prefix_list(prefix)
object_list = pseudofolder_object_list(objects, prefix, public_url)
context = utils.update_default_context(request, {
'container': container,
'objects': utils.generic_pagination(object_list, page),
'prefix': prefix,
'prefixes': prefixes,
})
return render_to_response("objectview.html", context,
context_instance=RequestContext(request))
def __init__(self, conn, container, name, content_type=None):
# FIXME
# self._name_check()
parsed, self.chunkable_http = http_connection(conn.url)
logging.debug("ChunkObject: new connection open (%r, %r)" %
(parsed, self.chunkable_http))
path = '%s/%s/%s' % (
parsed.path.rstrip('/'),
quote(smart_str(container)),
quote(smart_str(name)),
)
headers = {
'X-Auth-Token': conn.token,
'Content-Type': content_type or 'application/octet-stream',
'Transfer-Encoding': 'chunked',
# User-Agent ?
}
if conn.real_ip:
headers['X-Forwarded-For'] = conn.real_ip
self.chunkable_http.putrequest('PUT', path)
for key, value in headers.iteritems():
self.chunkable_http.putheader(key, value)
self.chunkable_http.endheaders()
logging.debug("ChunkedObject: path=%r, headers=%r" % (path, headers))
def test_unicode_ok(self):
conn = c.http_connection(u'http://www.test.com/')
mock_file = six.StringIO(u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91')
args = (u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91',
'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91',
u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91',
u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91', mock_file)
text = u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91'
headers = {
'X-Header1': text,
'X-2': 1,
'X-3': {
'a': 'b'
},
'a-b': '.x:yz mn:fg:lp'
}
resp = MockHttpResponse()
conn[1].getresponse = resp.fake_response
conn[1]._request = resp._fake_request
value = c.put_object(*args, headers=headers, http_conn=conn)
self.assertTrue(isinstance(value, six.string_types))
# Test for RFC-2616 encoded symbols
self.assertIn((b"a-b", b".x:yz mn:fg:lp"), resp.buffer)
# Test unicode header
self.assertIn((b'x-header1', text.encode('utf8')), resp.buffer)
def accountview(request, project):
storage_url = get_storage_endpoint(request, 'adminURL')
if not storage_url:
return
auth_token = request.session.get('auth_token')
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
head_acc = {}
try:
head_acc = client.head_account(storage_url,
auth_token,
http_conn=http_conn)
except Exception as err:
log.exception(f'Exception: {err}')
context = {
'cloud': head_acc.get('x-account-meta-cloud'),
'total_containers': head_acc.get('x-account-container-count'),
'total_objects': head_acc.get('x-account-object-count'),
'total_bytes': head_acc.get('x-account-bytes-used'),
'account_domain_id': head_acc.get('x-account-project-domain-id'),
}
return render(request, 'storage/accountview.html',
update_default_context(request, context))
def __init__(self,
conn,
container,
name,
content_type=None,
reuse_token=True):
self.raw_conn = None
if reuse_token:
self.url = conn.url
token = conn.token
else:
self.url, token = conn.get_auth()
self.parsed, self.conn = http_connection(self.url)
self.path = '%s/%s/%s' % (
self.parsed.path.rstrip('/'),
quote(smart_str(container)),
quote(smart_str(name)),
)
self.headers = {
'X-Auth-Token': token,
'Content-Type': content_type or 'application/octet-stream',
'Transfer-Encoding': 'chunked',
'Connection': 'close',
# User-Agent ?
}
if conn.real_ip:
self.headers['X-Forwarded-For'] = conn.real_ip
logging.debug("ChunkedObject: path=%r, headers=%r" %
(self.path, self.headers))
self.already_sent = 0
def object_versioning(request, container, prefix=None):
storage_url = get_endpoint(request, 'adminURL')
auth_token = get_token_id(request)
public_url = get_endpoint(request, 'publicURL') + '/' + container
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
objects = []
page = request.GET.get('page', 1)
if request.method == 'GET':
headers = client.head_container(storage_url,
auth_token,
container,
http_conn=http_conn)
version_location = headers.get('x-versions-location', None)
if version_location:
try:
_, objects = client.get_container(storage_url,
auth_token,
version_location,
prefix=prefix,
delimiter='/',
http_conn=http_conn)
except client.ClientException:
pass
prefixes = prefix_list(prefix)
object_list = pseudofolder_object_list(objects, prefix, public_url)
context = utils.update_default_context(request, {
'container': container,
'objects': utils.generic_pagination(object_list, page),
'version_location': version_location,
'prefix': prefix,
'prefixes': prefixes,
})
return render_to_response('container_versioning.html',
dictionary=context,
context_instance=RequestContext(request))
if request.method == 'POST':
action = request.POST.get('action', None)
if action == 'enable':
enable_versioning(request, container)
actionlog.log(request.user.username, "enable", 'Versioning. Container: %s' % container)
elif action == 'disable':
disable_versioning(request, container)
actionlog.log(request.user.username, "disable", 'Versioning. Container: %s' % container)
else:
messages.add_message(request, messages.ERROR, ugettext('Action is required.'))
return redirect(object_versioning, container=container)
def get_info(url):
parts = urlparse(url)
url = parts.scheme + '://' + parts.netloc + '/info'
http_conn = client.http_connection(url)
try:
return client.get_capabilities(http_conn)
except client.ClientException:
raise unittest.SkipTest('Unable to retrieve cluster info')
def get_info(url):
parts = urlparse(url)
url = parts.scheme + '://' + parts.netloc + '/info'
http_conn = client.http_connection(url)
try:
return client.get_capabilities(http_conn)
except client.ClientException:
raise unittest.SkipTest('Unable to retrieve cluster info')
def __init__(self, environ, path):
dav_provider.DAVCollection.__init__(self, '/', environ)
self.path = path
self.auth_token = self.environ.get('swift_auth_token')
self.storage_url = self.environ.get('swift_storage_url')
self.http_connection = client.http_connection(
self.storage_url, insecure=self.environ.get('insecure'))
def delete_pseudofolder(request, container, pseudofolder):
""" Deletes an empty object, used as a pseudofolder """
storage_url = get_endpoint(request, 'adminURL')
auth_token = get_token_id(request)
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
objects = client.get_container(storage_url,
auth_token,
container,
prefix=pseudofolder,
http_conn=http_conn)[1]
count_deletes = 0
for obj in objects:
try:
client.delete_object(storage_url,
token=auth_token,
container=container,
name=obj['name'],
http_conn=http_conn)
count_deletes += 1
except client.ClientException as err:
log.exception('{}{}'.format(_('Exception:').encode('UTF-8'), err))
# Empty pseudofolder
if count_deletes == 1 and count_deletes == len(objects):
messages.add_message(request, messages.SUCCESS,
_('Pseudofolder deleted.'))
# Non empty pseudofolder
elif count_deletes > 1 and count_deletes == len(objects):
messages.add_message(
request, messages.SUCCESS,
_('Pseudofolder and {0} objects deleted.').format(count_deletes -
1))
elif count_deletes > 0 and count_deletes < len(objects):
messages.add_message(request, messages.SUCCESS,
_('It was not possible to delete all objects.'))
else:
messages.add_message(request, messages.ERROR,
_('Fail to delete pseudofolder.'))
if pseudofolder[-1] == '/': # deleting a pseudofolder, move one level up
pseudofolder = pseudofolder[:-1]
prefix = '/'.join(pseudofolder.split('/')[:-1])
if prefix:
prefix += '/'
actionlog.log(request.user.username, "delete", pseudofolder)
if prefix:
return redirect(objectview, container=container, prefix=prefix)
else:
return redirect(objectview, container=container)
def test_no_content_type(self):
conn = c.http_connection(u'http://www.test.com/')
resp = MockHttpResponse(status=200)
conn[1].getresponse = resp.fake_response
conn[1]._request = resp._fake_request
c.put_object(url='http://www.test.com', http_conn=conn)
request_header = resp.requests_params['headers']
self.assertEqual(request_header['content-type'], b'')
def connect(self):
auth = client.get_auth(self.authurl,
self.user_name,
self.user_pass,
tenant_name=self.tenant,
auth_version='2')
self.storage_url = auth[0]
self.http_conn = client.http_connection(self.storage_url)
self.token = auth[1]
def __init__(self, environ, path):
dav_provider.DAVCollection.__init__(self, '/', environ)
self.path = path
self.auth_token = self.environ.get('swift_auth_token')
self.storage_url = self.environ.get('swift_storage_url')
self.http_connection = client.http_connection(
self.storage_url,
insecure=self.environ.get('insecure'))
def test_no_content_type(self):
conn = c.http_connection(u'http://www.test.com/')
resp = MockHttpResponse(status=200)
conn[1].getresponse = resp.fake_response
conn[1]._request = resp._fake_request
c.put_object(url='http://www.test.com', http_conn=conn)
request_header = resp.requests_params['headers']
self.assertEqual(request_header['content-type'], b'')
def upload(request, container, prefix=None):
""" Display upload form using swift formpost """
storage_url = get_endpoint(request, 'adminURL')
auth_token = get_token_id(request)
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
redirect_url = 'http://{}'.format(request.get_host())
redirect_url += reverse('objectview', kwargs={
'container': container,
})
swift_url = storage_url + '/' + container + '/'
if prefix:
swift_url += prefix
redirect_url += prefix
redirect_url += '?p={}'.format(request.session.get('project_id'))
url_parts = urlparse(swift_url)
path = url_parts.path
max_file_size = 5 * 1024 * 1024 * 1024
max_file_count = 1
expires = int(time.time() + 15 * 60)
key = get_temp_key(storage_url, auth_token, http_conn)
if not key:
messages.add_message(request, messages.ERROR, _('Access denied.'))
if prefix:
return redirect(objectview, container=container, prefix=prefix)
else:
return redirect(objectview, container=container)
hmac_body = '%s\n%s\n%s\n%s\n%s' % (path, redirect_url, max_file_size,
max_file_count, expires)
signature = hmac.new(key, hmac_body, sha1).hexdigest()
prefixes = prefix_list(prefix)
context = utils.update_default_context(
request, {
'swift_url': swift_url,
'redirect_url': redirect_url,
'max_file_size': max_file_size,
'max_file_count': max_file_count,
'expires': expires,
'signature': signature,
'container': container,
'prefix': prefix if prefix is not None else '',
'prefixes': prefixes,
})
return render_to_response('upload_form.html',
context,
context_instance=RequestContext(request))
def close(self):
if not self.closed and hasattr(self, 'request_body'):
try:
self.request_body.write(self.CRLF)
self.request_body.write('--' + self.BOUNDARY + '--')
self.request_body.write(self.CRLF)
length = self.request_body.tell()
try:
parsed_url, connection = http_connection(self.url)
if parsed_url.query:
url_path = parsed_url.path + '?' + parsed_url.query
else:
url_path = parsed_url.path
connection.putrequest('POST', url_path)
connection.putheader('Content-Type', 'multipart/form-data; boundary=%s' % self.BOUNDARY)
connection.putheader('Content-Length', str(length))
if self.password:
credentials = base64.b64encode(b'%s:%s' % (self.username, self.password))
connection.putheader('Authorization', 'Basic %s' % credentials)
connection.endheaders()
self.request_body.seek(0)
connection.send(self.request_body)
response = connection.getresponse()
except Exception as error:
raise UnexpectedHTTPResponse('%s: %s' % (error.__class__, error))
if response.status // 100 != 2:
message = '%d: %s' % (response.status, response.reason)
if response.getheader('Content-Type') == 'text/plain':
try:
response_content = response.read(100).splitlines()[0]
message = '%s. %s' % (message, response_content)
except Exception:
pass
raise UnexpectedHTTPResponse(message)
finally:
self.closed = True
self.request_body.close()
def close(self):
if not self.closed and hasattr(self, 'request_body'):
try:
self.request_body.write(self.CRLF)
self.request_body.write('--' + self.BOUNDARY + '--')
self.request_body.write(self.CRLF)
length = self.request_body.tell()
try:
parsed_url, connection = http_connection(self.url)
if parsed_url.query:
url_path = parsed_url.path + '?' + parsed_url.query
else:
url_path = parsed_url.path
connection.putrequest('POST', url_path)
connection.putheader('Content-Type', 'multipart/form-data; boundary=%s' % self.BOUNDARY)
connection.putheader('Content-Length', str(length))
if self.password:
credentials = base64.b64encode(b'%s:%s' % (self.username, self.password))
connection.putheader('Authorization', 'Basic %s' % credentials)
connection.endheaders()
self.request_body.seek(0)
connection.send(self.request_body)
response = connection.getresponse()
except Exception as error:
raise UnexpectedHTTPResponse('%s: %s' % (error.__class__, error))
if response.status // 100 != 2:
message = '%d: %s' % (response.status, response.reason)
if response.getheader('Content-Type') == 'text/plain':
try:
response_content = response.read(100).splitlines()[0]
message = '%s. %s' % (message, response_content)
except Exception:
pass
raise UnexpectedHTTPResponse(message)
finally:
self.closed = True
self.request_body.close()
def test_params(self):
conn = c.http_connection(u"http://www.test.com/")
resp = MockHttpResponse(status=200)
conn[1].getresponse = resp.fake_response
conn[1]._request = resp._fake_request
c.put_object(url="http://www.test.com", http_conn=conn, etag="1234-5678", content_type="text/plain")
request_header = resp.requests_params["headers"]
self.assertTrue(request_header["etag"], "1234-5678")
self.assertTrue(request_header["content-type"], "text/plain")
def get_conn_and_storage_url(request, project_id):
service_catalog = request.session.get('service_catalog')
service = service_catalog.get('object_store')
endpoint = service.get('adminURL')
_, current_id = endpoint.split('AUTH_')
storage_url = endpoint.replace(current_id, project_id)
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
return http_conn, storage_url
def setUp(self):
# previous test may have left DatabaseBroker instances in garbage with
# open connections to db files which will prevent unmounting devices in
# resetswift, so collect garbage now
gc.collect()
resetswift()
kill_orphans()
self._load_rings_and_configs()
try:
self.servers_per_port = any(
int(
readconf(c, section_name='object-replicator').get(
'servers_per_port', '0'))
for c in self.configs['object-replicator'].values())
Manager(['main']).start(wait=True)
for ipport in self.ipport2server:
check_server(ipport, self.ipport2server)
proxy_conf = readconf(self.configs['proxy-server'],
section_name='app:proxy-server')
proxy_ipport = (proxy_conf.get('bind_ip', '127.0.0.1'),
int(proxy_conf.get('bind_port', 8080)))
self.ipport2server[proxy_ipport] = 'proxy'
self.url, self.token, self.account = check_server(
proxy_ipport, self.ipport2server)
self.account_1 = {
'url': self.url,
'token': self.token,
'account': self.account
}
rv = _retry_timeout(_check_proxy,
args=('test2:tester2', 'testing2'))
self.account_2 = {
k: v
for (k, v) in zip(('url', 'token', 'account'), rv)
}
self.replicators = Manager([
'account-replicator', 'container-replicator',
'object-replicator'
])
self.updaters = Manager(['container-updater', 'object-updater'])
except BaseException:
try:
raise
finally:
try:
Manager(['all']).kill()
except Exception:
pass
info_url = "%s://%s/info" % (urlparse(
self.url).scheme, urlparse(self.url).netloc)
proxy_conn = client.http_connection(info_url)
self.cluster_info = client.get_capabilities(proxy_conn)
def create_pseudofolder(request, container, prefix=None):
""" Creates a pseudofolder (empty object of type application/directory) """
storage_url = get_endpoint(request, 'adminURL')
auth_token = get_token_id(request)
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
form = PseudoFolderForm(request.POST or None)
if form.is_valid():
foldername = request.POST.get('foldername', None)
if prefix:
foldername = prefix + '/' + foldername
foldername = os.path.normpath(foldername)
foldername = foldername.strip('/')
foldername += '/'
content_type = 'application/directory'
obj = None
try:
client.put_object(storage_url,
auth_token,
container,
foldername,
obj,
content_type=content_type,
http_conn=http_conn)
messages.add_message(request, messages.SUCCESS,
_('Pseudofolder created.'))
except client.ClientException as err:
log.exception('{}{}'.format(_('Exception:').encode('UTF-8'), err))
messages.add_message(request, messages.ERROR, _('Access denied.'))
if prefix:
actionlog.log(request.user.username, "create", foldername)
return redirect(objectview, container=container, prefix=prefix)
actionlog.log(request.user.username, "create", foldername)
return redirect(objectview, container=container)
prefixes = prefix_list(prefix)
context = utils.update_default_context(
request, {
'container': container,
'prefix': prefix,
'prefixes': prefixes,
'form': form,
})
return render_to_response('create_pseudofolder.html',
context,
context_instance=RequestContext(request))
def test_params(self):
conn = c.http_connection(u'http://www.test.com/')
resp = MockHttpResponse(status=200)
conn[1].getresponse = resp.fake_response
conn[1]._request = resp._fake_request
c.put_object(url='http://www.test.com', http_conn=conn,
etag='1234-5678', content_type='text/plain')
request_header = resp.requests_params['headers']
self.assertTrue(request_header['etag'], '1234-5678')
self.assertTrue(request_header['content-type'], 'text/plain')
def test_params(self):
conn = c.http_connection(u'http://www.test.com/')
resp = MockHttpResponse(status=200)
conn[1].getresponse = resp.fake_response
conn[1]._request = resp._fake_request
c.put_object(url='http://www.test.com', http_conn=conn,
etag='1234-5678', content_type='text/plain')
request_header = resp.requests_params['headers']
self.assertEqual(request_header['etag'], b'1234-5678')
self.assertEqual(request_header['content-type'], b'text/plain')
def test_set_user_agent_per_request_override(self):
_junk, conn = c.http_connection('http://www.example.com')
req_headers = {}
def my_request_handler(*a, **kw):
req_headers.update(kw.get('headers', {}))
conn._request = my_request_handler
# test if it's actually set
conn.request('GET', '/', headers={'User-Agent': 'Me'})
ua = req_headers.get('user-agent', 'XXX-MISSING-XXX')
self.assertEqual(ua, b'Me', req_headers)
def test_set_user_agent_default(self):
_junk, conn = c.http_connection('http://www.example.com')
req_headers = {}
def my_request_handler(*a, **kw):
req_headers.update(kw.get('headers', {}))
conn._request = my_request_handler
# test the default
conn.request('GET', '/')
ua = req_headers.get('user-agent', 'XXX-MISSING-XXX')
self.assertTrue(ua.startswith('python-swiftclient-'))
def test_set_user_agent_per_request_override(self):
_junk, conn = c.http_connection('http://www.example.com')
req_headers = {}
def my_request_handler(*a, **kw):
req_headers.update(kw.get('headers', {}))
conn._request = my_request_handler
# test if it's actually set
conn.request('GET', '/', headers={'User-Agent': 'Me'})
ua = req_headers.get('user-agent', 'XXX-MISSING-XXX')
self.assertEqual(ua, b'Me', req_headers)
def test_set_user_agent_default(self):
_junk, conn = c.http_connection('http://www.example.com')
req_headers = {}
def my_request_handler(*a, **kw):
req_headers.update(kw.get('headers', {}))
conn._request = my_request_handler
# test the default
conn.request('GET', '/')
ua = req_headers.get('user-agent', 'XXX-MISSING-XXX')
self.assertTrue(ua.startswith('python-swiftclient-'))
def upload(request, container, prefix=None):
""" Display upload form using swift formpost """
storage_url = get_endpoint(request, 'adminURL')
auth_token = get_token_id(request)
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
redirect_url = 'http://{}'.format(request.get_host())
redirect_url += reverse('objectview', kwargs={'container': container, })
swift_url = storage_url + '/' + container + '/'
if prefix:
swift_url += prefix
redirect_url += prefix
redirect_url += '?p={}'.format(request.session.get('project_id'))
url_parts = urlparse(swift_url)
path = url_parts.path
max_file_size = 5 * 1024 * 1024 * 1024
max_file_count = 1
expires = int(time.time() + 15 * 60)
key = get_temp_key(storage_url, auth_token, http_conn)
if not key:
messages.add_message(request, messages.ERROR, _('Access denied.'))
if prefix:
return redirect(objectview, container=container, prefix=prefix)
else:
return redirect(objectview, container=container)
hmac_body = '%s\n%s\n%s\n%s\n%s' % (path, redirect_url, max_file_size,
max_file_count, expires)
signature = hmac.new(key, hmac_body, sha1).hexdigest()
prefixes = prefix_list(prefix)
context = utils.update_default_context(request, {
'swift_url': swift_url,
'redirect_url': redirect_url,
'max_file_size': max_file_size,
'max_file_count': max_file_count,
'expires': expires,
'signature': signature,
'container': container,
'prefix': prefix if prefix is not None else '',
'prefixes': prefixes,
})
return render_to_response('upload_form.html', context,
context_instance=RequestContext(request))
def delete_pseudofolder(request, container, pseudofolder):
""" Deletes an empty object, used as a pseudofolder """
storage_url = get_endpoint(request, 'adminURL')
auth_token = get_token_id(request)
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
objects = client.get_container(storage_url, auth_token,
container, prefix=pseudofolder,
http_conn=http_conn)[1]
count_deletes = 0
for obj in objects:
try:
client.delete_object(storage_url, token=auth_token,
container=container, name=obj['name'],
http_conn=http_conn)
count_deletes += 1
except client.ClientException as err:
log.exception('{}{}'.format(_('Exception:').encode('UTF-8'), err))
# Empty pseudofolder
if count_deletes == 1 and count_deletes == len(objects):
messages.add_message(request, messages.SUCCESS,
_('Pseudofolder deleted.'))
# Non empty pseudofolder
elif count_deletes > 1 and count_deletes == len(objects):
messages.add_message(request, messages.SUCCESS,
_('Pseudofolder and {0} objects deleted.').format(count_deletes - 1))
elif count_deletes > 0 and count_deletes < len(objects):
messages.add_message(request, messages.SUCCESS,
_('It was not possible to delete all objects.'))
else:
messages.add_message(request, messages.ERROR,
_('Fail to delete pseudofolder.'))
if pseudofolder[-1] == '/': # deleting a pseudofolder, move one level up
pseudofolder = pseudofolder[:-1]
prefix = '/'.join(pseudofolder.split('/')[:-1])
if prefix:
prefix += '/'
actionlog.log(request.user.username, "delete", pseudofolder)
if prefix:
return redirect(objectview, container=container, prefix=prefix)
else:
return redirect(objectview, container=container)
def get_account_containers(storage_url, auth_token):
""" List all containers in an account"""
container_list = []
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
_, containers = client.get_account(storage_url, auth_token,
http_conn=http_conn)
for container in containers:
container_list.append(container['name'])
return container_list
def delete_account_cont(self, account_url, token):
cnx = sclient.http_connection(account_url)
al = sclient.get_account(None, token, http_conn=cnx, full_listing=True)
for container in [c['name'] for c in al[1]]:
ci = sclient.get_container(None,
token,
container,
http_conn=cnx,
full_listing=True)
on = [od['name'] for od in ci[1]]
for obj in on:
sclient.delete_object('', token, container, obj, http_conn=cnx)
sclient.delete_container('', token, container, http_conn=cnx)
def get_container_objects(container, storage_url, auth_token):
object_list = []
http_conn = client.http_connection(storage_url, insecure=settings.SWIFT_INSECURE)
_, objects = client.get_container(storage_url,
auth_token,
container,
http_conn=http_conn)
for object in objects:
object_list.append(object['name'])
return object_list
def test_set_user_agent_per_request_override(self):
_junk, conn = c.http_connection("http://www.example.com")
req_headers = {}
def my_request_handler(*a, **kw):
req_headers.update(kw.get("headers", {}))
conn._request = my_request_handler
# test if it's actually set
conn.request("GET", "/", headers={"User-Agent": "Me"})
ua = req_headers.get("user-agent", "XXX-MISSING-XXX")
self.assertEqual(ua, "Me", req_headers)
def test_set_user_agent_default(self):
_junk, conn = c.http_connection("http://www.example.com")
req_headers = {}
def my_request_handler(*a, **kw):
req_headers.update(kw.get("headers", {}))
conn._request = my_request_handler
# test the default
conn.request("GET", "/")
ua = req_headers.get("user-agent", "XXX-MISSING-XXX")
self.assert_(ua.startswith("python-swiftclient-"))
def test_close_ok(self):
url = 'http://www.test.com'
c.http_connection = self.fake_http_connection(200)
conn = c.Connection(url, 'asdf', 'asdf')
self.assertEqual(conn.http_conn, None)
conn.http_conn = c.http_connection(url)
self.assertEqual(type(conn.http_conn), tuple)
self.assertEqual(len(conn.http_conn), 2)
http_conn_obj = conn.http_conn[1]
self.assertEqual(http_conn_obj.isclosed(), False)
conn.close()
self.assertEqual(http_conn_obj.isclosed(), True)
self.assertEqual(conn.http_conn, None)
def create_pseudofolder(request, container, prefix=None):
""" Creates a pseudofolder (empty object of type application/directory) """
storage_url = get_endpoint(request, 'adminURL')
auth_token = get_token_id(request)
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
form = PseudoFolderForm(request.POST or None)
if form.is_valid():
foldername = request.POST.get('foldername', None)
if prefix:
foldername = prefix + '/' + foldername
foldername = os.path.normpath(foldername)
foldername = foldername.strip('/')
foldername += '/'
content_type = 'application/directory'
obj = None
try:
client.put_object(storage_url, auth_token,
container, foldername, obj,
content_type=content_type,
http_conn=http_conn)
messages.add_message(request, messages.SUCCESS,
_('Pseudofolder created.'))
except client.ClientException as err:
log.exception('{}{}'.format(_('Exception:').encode('UTF-8'), err))
messages.add_message(request, messages.ERROR, _('Access denied.'))
if prefix:
actionlog.log(request.user.username, "create", foldername)
return redirect(objectview, container=container, prefix=prefix)
actionlog.log(request.user.username, "create", foldername)
return redirect(objectview, container=container)
prefixes = prefix_list(prefix)
context = utils.update_default_context(request, {
'container': container,
'prefix': prefix,
'prefixes': prefixes,
'form': form,
})
return render_to_response('create_pseudofolder.html', context,
context_instance=RequestContext(request))
def delete_account_cont(self, account_url, token):
cnx = sclient.http_connection(account_url)
al = sclient.get_account(None, token,
http_conn=cnx,
full_listing=True)
for container in [c['name'] for c in al[1]]:
ci = sclient.get_container(None, token,
container, http_conn=cnx,
full_listing=True)
on = [od['name'] for od in ci[1]]
for obj in on:
sclient.delete_object('', token, container,
obj, http_conn=cnx)
sclient.delete_container('', token, container, http_conn=cnx)
def test_close_ok(self):
url = 'http://www.test.com'
c.http_connection = self.fake_http_connection(200)
conn = c.Connection(url, 'asdf', 'asdf')
self.assertEqual(conn.http_conn, None)
conn.http_conn = c.http_connection(url)
self.assertEqual(type(conn.http_conn), tuple)
self.assertEqual(len(conn.http_conn), 2)
http_conn_obj = conn.http_conn[1]
self.assertEqual(http_conn_obj.isclosed(), False)
conn.close()
self.assertEqual(http_conn_obj.isclosed(), True)
self.assertEqual(conn.http_conn, None)
def test_set_user_agent_default_override(self):
_junk, conn = c.http_connection("http://www.example.com", default_user_agent="a-new-default")
req_headers = {}
def my_request_handler(*a, **kw):
req_headers.update(kw.get("headers", {}))
conn._request = my_request_handler
# test setting a default
conn._request = my_request_handler
conn.request("GET", "/")
ua = req_headers.get("user-agent", "XXX-MISSING-XXX")
self.assertEqual(ua, "a-new-default")
def _prepare_connection(self):
compute_nodes = self.compute_nodes.split(',')
compute_node = random.sample(compute_nodes, 1)
self.logger.info('Forwarding request to a compute node: ' +
compute_node[0])
url = os.path.join('http://', compute_node[0], self.api_version,
self.account)
parsed, conn = http_connection(url)
path = '%s/%s/%s' % (parsed.path, quote(self.container), quote(
self.obj))
return conn, path
def test_set_user_agent_default_override(self):
_junk, conn = c.http_connection('http://www.example.com',
default_user_agent='a-new-default')
req_headers = {}
def my_request_handler(*a, **kw):
req_headers.update(kw.get('headers', {}))
conn._request = my_request_handler
# test setting a default
conn._request = my_request_handler
conn.request('GET', '/')
ua = req_headers.get('user-agent', 'XXX-MISSING-XXX')
self.assertEqual(ua, 'a-new-default')
def __init__(self, container, objectname, environ, objects=None):
self.container = container
self.objectname = objectname
self.environ = environ
self.objects = objects
path = '/' + self.container + '/' + self.objectname
dav_provider.DAVNonCollection.__init__(self, path, environ)
self.auth_token = self.environ.get('swift_auth_token')
self.storage_url = self.environ.get('swift_storage_url')
self.headers = None
self.tmpfile = None
self.http_connection = client.http_connection(
self.storage_url, insecure=self.environ.get('insecure'))
def test_set_user_agent_default_override(self):
_junk, conn = c.http_connection(
'http://www.example.com',
default_user_agent='a-new-default')
req_headers = {}
def my_request_handler(*a, **kw):
req_headers.update(kw.get('headers', {}))
conn._request = my_request_handler
# test setting a default
conn._request = my_request_handler
conn.request('GET', '/')
ua = req_headers.get('user-agent', 'XXX-MISSING-XXX')
self.assertEqual(ua, 'a-new-default')
def test_unicode_ok(self):
conn = c.http_connection(u'http://www.test.com/')
args = (u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91',
'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91',
u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91',
u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91')
headers = {'X-Header1': u'\u5929\u7a7a\u4e2d\u7684\u4e4c\u4e91',
'X-2': '1', 'X-3': {'a': 'b'}, 'a-b': '.x:yz mn:kl:qr'}
resp = MockHttpResponse()
conn[1].getresponse = resp.fake_response
conn[1].send = resp.fake_send
c.post_object(*args, headers=headers, http_conn=conn)
# Test for RFC-2616 encoded symbols
self.assertTrue("a-b: .x:yz mn:kl:qr" in resp.buffer[0],
"[a-b: .x:yz mn:kl:qr] header is missing")
