def test_reauth(self):
c.http_connection = self.fake_http_connection(401)
def get_auth(*args, **kwargs):
return 'http://www.new.com', 'new'
def swap_sleep(*args):
self.swap_sleep_called = True
c.get_auth = get_auth
c.http_connection = self.fake_http_connection(200)
c.sleep = swap_sleep
self.swap_sleep_called = False
conn = c.Connection(
'http://www.test.com',
'asdf',
'asdf',
preauthurl='http://www.old.com',
preauthtoken='old',
)
self.assertEquals(conn.attempts, 0)
self.assertEquals(conn.url, 'http://www.old.com')
self.assertEquals(conn.token, 'old')
value = conn.head_account()
self.assertTrue(self.swap_sleep_called)
self.assertEquals(conn.attempts, 2)
self.assertEquals(conn.url, 'http://www.new.com')
self.assertEquals(conn.token, 'new')
def _make_swift_connection(self, auth_url, user, key):
"""
Creates a connection using the Swift client library.
"""
snet = self.snet
auth_version = self.auth_version
full_auth_url = (auth_url if not auth_url or auth_url.endswith('/')
else auth_url + '/')
logger.debug(
_("Creating Swift connection with "
"(auth_address=%(full_auth_url)s, user=%(user)s, "
"snet=%(snet)s, auth_version=%(auth_version)s)") % locals())
tenant_name = None
if self.auth_version == '2':
tenant_user = user.split(':')
if len(tenant_user) != 2:
reason = (_("Badly formed tenant:user '%(tenant_user)s' in "
"Swift URI") % locals())
raise exception.BadStoreUri(auth_url, reason)
(tenant_name, user) = tenant_user
return swift_client.Connection(authurl=full_auth_url,
user=user,
key=key,
snet=snet,
tenant_name=tenant_name,
auth_version=auth_version)
def test_resp_read_on_server_error(self):
c.http_connection = self.fake_http_connection(500)
conn = c.Connection('http://www.test.com', 'asdf', 'asdf', retries=0)
def get_auth(*args, **kwargs):
return 'http://www.new.com', 'new'
conn.get_auth = get_auth
self.url, self.token = conn.get_auth()
method_signatures = (
(conn.head_account, []),
(conn.get_account, []),
(conn.head_container, ('asdf', )),
(conn.get_container, ('asdf', )),
(conn.put_container, ('asdf', )),
(conn.delete_container, ('asdf', )),
(conn.head_object, ('asdf', 'asdf')),
(conn.get_object, ('asdf', 'asdf')),
(conn.put_object, ('asdf', 'asdf', 'asdf')),
(conn.post_object, ('asdf', 'asdf', {})),
(conn.delete_object, ('asdf', 'asdf')),
)
for method, args in method_signatures:
self.assertRaises(c.ClientException, method, *args)
try:
self.assertTrue(conn.http_conn[1].has_been_read)
except AssertionError:
msg = '%s did not read resp on server error' % method.__name__
self.fail(msg)
except Exception, e:
raise e.__class__("%s - %s" % (method.__name__, e))
def login(request):
"""登入页面"""
if request.user.is_authenticated():
return HttpResponseRedirect('/already-logged')
if request.method == 'POST':
form = Login_Form(request.POST)
if not form.is_valid():
return render_to_response('login.html', {'form': form})
username = request.POST.get('username', '')
password = request.POST.get('password', '')
con = client.Connection(utils.URL, username, password)
try:
auth_url, auth_token = con.get_auth()
utils.auth_url = auth_url
utils.auth_token = auth_token
except Exception, e:
if e[0] == 111:
form = Login_Form()
return render_to_response('login.html', {
'form': form,
'swift_no_start': True
})
user = auth.authenticate(username=username, password=password)
if user is not None and user.is_active:
auth.login(request, user)
return HttpResponseRedirect('/control-panel')
else:
return render_to_response('login.html', {
'form': Login_Form(),
'incorrect': True
})
def test_retry(self):
c.http_connection = self.fake_http_connection(500)
def quick_sleep(*args):
pass
c.sleep = quick_sleep
conn = c.Connection('http://www.test.com', 'asdf', 'asdf')
self.assertRaises(c.ClientException, conn.head_account)
self.assertEquals(conn.attempts, conn.retries + 1)
def _make_swift_connection(self, auth_url, user, key):
"""
Creates a connection using the Swift client library.
"""
snet = self.snet
logger.debug(_("Creating Swift connection with "
"(auth_address=%(auth_url)s, user=%(user)s, "
"snet=%(snet)s)") % locals())
return swift_client.Connection(
authurl=auth_url, user=user, key=key, snet=snet)
def test_large_objects(self):
"""
We test the large object manifest code path in the Swift driver.
In the case where an image file is bigger than the config variable
swift_store_large_object_size, then we chunk the image into
Swift, and add a manifest put_object at the end.
We test that the delete of the large object cleans up all the
chunks in Swift, in addition to the manifest file (LP Bug# 833285)
"""
self.cleanup()
self.swift_store_large_object_size = 2 # In MB
self.swift_store_large_object_chunk_size = 1 # In MB
self.start_servers(**self.__dict__.copy())
api_port = self.api_port
registry_port = self.registry_port
# GET /images
# Verify no public images
path = "http://%s:%d/v1/images" % ("0.0.0.0", self.api_port)
http = httplib2.Http()
response, content = http.request(path, 'GET')
self.assertEqual(response.status, 200)
self.assertEqual(content, '{"images": []}')
# POST /images with public image named Image1
# attribute and no custom properties. Verify a 200 OK is returned
image_data = "*" * FIVE_MB
headers = {
'Content-Type': 'application/octet-stream',
'X-Image-Meta-Name': 'Image1',
'X-Image-Meta-Is-Public': 'True'
}
path = "http://%s:%d/v1/images" % ("0.0.0.0", self.api_port)
http = httplib2.Http()
response, content = http.request(path,
'POST',
headers=headers,
body=image_data)
self.assertEqual(response.status, 201, content)
data = json.loads(content)
self.assertEqual(data['image']['checksum'],
hashlib.md5(image_data).hexdigest())
self.assertEqual(data['image']['size'], FIVE_MB)
self.assertEqual(data['image']['name'], "Image1")
self.assertEqual(data['image']['is_public'], True)
image_id = data['image']['id']
# HEAD image
# Verify image found now
path = "http://%s:%d/v1/images/%s" % ("0.0.0.0", self.api_port,
image_id)
http = httplib2.Http()
response, content = http.request(path, 'HEAD')
self.assertEqual(response.status, 200)
self.assertEqual(response['x-image-meta-name'], "Image1")
# GET image
# Verify all information on image we just added is correct
path = "http://%s:%d/v1/images/%s" % ("0.0.0.0", self.api_port,
image_id)
http = httplib2.Http()
response, content = http.request(path, 'GET')
self.assertEqual(response.status, 200)
expected_image_headers = {
'x-image-meta-id': image_id,
'x-image-meta-name': 'Image1',
'x-image-meta-is_public': 'True',
'x-image-meta-status': 'active',
'x-image-meta-disk_format': '',
'x-image-meta-container_format': '',
'x-image-meta-size': str(FIVE_MB)
}
expected_std_headers = {
'content-length': str(FIVE_MB),
'content-type': 'application/octet-stream'
}
for expected_key, expected_value in expected_image_headers.items():
self.assertEqual(
response[expected_key], expected_value,
"For key '%s' expected header value '%s'. Got '%s'" %
(expected_key, expected_value, response[expected_key]))
for expected_key, expected_value in expected_std_headers.items():
self.assertEqual(
response[expected_key], expected_value,
"For key '%s' expected header value '%s'. Got '%s'" %
(expected_key, expected_value, response[expected_key]))
self.assertEqual(content, "*" * FIVE_MB)
self.assertEqual(
hashlib.md5(content).hexdigest(),
hashlib.md5("*" * FIVE_MB).hexdigest())
# We test that the delete of the large object cleans up all the
# chunks in Swift, in addition to the manifest file (LP Bug# 833285)
# Grab the actual Swift location and query the object manifest for
# the chunks/segments. We will check that the segments don't exist
# after we delete the object through Glance...
path = "http://%s:%d/images/%s" % ("0.0.0.0", self.registry_port,
image_id)
http = httplib2.Http()
response, content = http.request(path, 'GET')
self.assertEqual(response.status, 200)
data = json.loads(content)
image_loc = data['image']['location']
if hasattr(self, 'metadata_encryption_key'):
key = self.metadata_encryption_key
else:
key = self.api_server.metadata_encryption_key
image_loc = crypt.urlsafe_decrypt(key, image_loc)
image_loc = get_location_from_uri(image_loc)
swift_loc = image_loc.store_location
from swift.common import client as swift_client
swift_conn = swift_client.Connection(authurl=swift_loc.swift_auth_url,
user=swift_loc.user,
key=swift_loc.key)
# Verify the object manifest exists
headers = swift_conn.head_object(swift_loc.container, swift_loc.obj)
manifest = headers.get('x-object-manifest')
self.assertTrue(manifest is not None, "Manifest could not be found!")
# Grab the segment identifiers
obj_container, obj_prefix = manifest.split('/', 1)
segments = [
segment['name']
for segment in swift_conn.get_container(obj_container,
prefix=obj_prefix)[1]
]
# Verify the segments exist
for segment in segments:
headers = swift_conn.head_object(obj_container, segment)
self.assertTrue(headers.get('content-length') is not None, headers)
# DELETE image
# Verify image and all chunks are gone...
path = "http://%s:%d/v1/images/%s" % ("0.0.0.0", self.api_port,
image_id)
http = httplib2.Http()
response, content = http.request(path, 'DELETE')
self.assertEqual(response.status, 200)
# Verify the segments no longer exist
for segment in segments:
self.assertRaises(swift_client.ClientException,
swift_conn.head_object, obj_container, segment)
self.stop_servers()
try:
swift_host = self.swift_store_auth_address
if not swift_host.startswith('http'):
swift_host = 'https://' + swift_host
user = self.swift_store_user
key = self.swift_store_key
container_name = self.swift_store_container
except AttributeError, e:
self.disabled_message = ("Failed to find required configuration "
"options for Swift store. "
"Got error: %s" % e)
self.inited = True
return
self.swift_conn = swift_conn = swift_client.Connection(
authurl=swift_host, user=user, key=key, snet=False, retries=1)
try:
_resp_headers, containers = swift_conn.get_account()
except Exception, e:
self.disabled_message = ("Failed to get_account from Swift "
"Got error: %s" % e)
self.inited = True
return
try:
for container in containers:
if container == container_name:
swift_conn.delete_container(container)
except swift_client.ClientException, e:
self.disabled_message = ("Failed to delete container from Swift "
def test_reset_stream(self):
class LocalContents(object):
def __init__(self, tell_value=0):
self.already_read = False
self.seeks = []
self.tell_value = tell_value
def tell(self):
return self.tell_value
def seek(self, position):
self.seeks.append(position)
self.already_read = False
def read(self, size=-1):
if self.already_read:
return ''
else:
self.already_read = True
return 'abcdef'
class LocalConnection(object):
def putrequest(self, *args, **kwargs):
return
def putheader(self, *args, **kwargs):
return
def endheaders(self, *args, **kwargs):
return
def send(self, *args, **kwargs):
raise socket.error('oops')
def request(self, *args, **kwargs):
return
def getresponse(self, *args, **kwargs):
self.status = 200
return self
def getheader(self, *args, **kwargs):
return ''
def read(self, *args, **kwargs):
return ''
def local_http_connection(url, proxy=None):
parsed = urlparse(url)
return parsed, LocalConnection()
orig_conn = c.http_connection
try:
c.http_connection = local_http_connection
conn = c.Connection('http://www.example.com',
'asdf',
'asdf',
retries=1,
starting_backoff=.0001)
contents = LocalContents()
exc = None
try:
conn.put_object('c', 'o', contents)
except socket.error, err:
exc = err
self.assertEquals(contents.seeks, [0])
self.assertEquals(str(exc), 'oops')
contents = LocalContents(tell_value=123)
exc = None
try:
conn.put_object('c', 'o', contents)
except socket.error, err:
exc = err
def test_instance(self):
conn = c.Connection('http://www.test.com', 'asdf', 'asdf')
self.assertEquals(conn.retries, 5)
def __init__(self, authurl, user, key):
''' Connect to swift server and create root directory '''
self.con = scc.Connection(authurl, user, key)
self.dirs = {}
# try :
self.mkdir('/')
