def test_copy_dest(self):
# No COPY in swiftclient. Using urllib instead...
url = os.path.join(self.url, self.container, self.storlet_file)
objname = self.storlet_file + '-copy-ex'
headers = {
'X-Auth-Token': self.token,
'X-Run-Storlet': self.storlet_name,
'Destination': '%s/%s' % (self.container, objname)
}
headers.update(self.additional_headers)
req = urllib2.Request(url, headers=headers)
req.get_method = lambda: 'COPY'
conn = urllib2.urlopen(req, timeout=10)
self.assertEqual(201, conn.getcode())
self.assertEqual('%s/%s' % (self.container, self.storlet_file),
conn.info()['x-storlet-generated-from'])
self.assertEqual(self.acct,
conn.info()['x-storlet-generated-from-account'])
self.assertIn('x-storlet-generated-from-last-modified', conn.info())
headers = client.head_object(self.url, self.token, self.container,
objname)
self.assertEqual(str(len(self.content)), headers['content-length'])
resp = dict()
client.delete_object(self.url,
self.token,
self.container,
objname,
response_dict=resp)
self.assertEqual(204, resp['status'])
def delete_container(request):
auth_token = request.session['auth_token']
storage_url = request.session['storage_url']
container = ''
if 'container' in request.GET.keys():
container = request.GET['container']
else:
return redirect(containers)
try:
http_conn = (urlparse(storage_url),
client.HTTPConnection(storage_url, insecure=settings.SWIFT_SSL_INSECURE))
_m, objects = client.get_container(storage_url, auth_token, container, http_conn=http_conn)
for obj in objects:
logger.info("Deleting object %s in container %s" % (obj['name'], container))
client.delete_object(storage_url, auth_token,
container, obj['name'], http_conn=http_conn)
logger.info("Deleting container %s" % (container))
client.delete_container(storage_url, auth_token, container, http_conn=http_conn)
messages.add_message(request, messages.INFO, "Container deleted.")
except client.ClientException:
messages.add_message(request, messages.ERROR, "Access denied.")
return redirect(containers)
def test_put(self):
objname = self.storlet_file + '-put'
resp = dict()
req_headers = {'X-Run-Storlet': self.storlet_name}
client.put_object(self.url,
self.token,
self.container,
objname,
self.content,
response_dict=resp,
headers=req_headers)
self.assertEqual(201, resp['status'])
resp = dict()
headers, content = client.get_object(self.url,
self.token,
self.container,
objname,
response_dict=resp)
self.assertEqual(200, resp['status'])
self.assertEqual('simple', headers['x-object-meta-test'])
self.assertEqual(self.content, content)
resp = dict()
client.delete_object(self.url,
self.token,
self.container,
objname,
response_dict=resp)
self.assertEqual(204, resp['status'])
def test_delete_propogate(self):
# create EC container
headers = {'X-Storage-Policy': self.policy.name}
client.put_container(self.url, self.token, self.container_name,
headers=headers)
# get our node lists
opart, onodes = self.object_ring.get_nodes(
self.account, self.container_name, self.object_name)
hnodes = self.object_ring.get_more_nodes(opart)
p_dev2 = self.device_dir('object', onodes[1])
# PUT object
contents = Body()
client.put_object(self.url, self.token, self.container_name,
self.object_name, contents=contents)
# now lets shut one down
self.kill_drive(p_dev2)
# delete on the ones that are left
client.delete_object(self.url, self.token,
self.container_name,
self.object_name)
# spot check a node
try:
self.direct_get(onodes[0], opart)
except direct_client.DirectClientException as err:
self.assertEqual(err.http_status, 404)
else:
self.fail('Node data on %r was not fully destoryed!' %
(onodes[0],))
# enable the first node again
self.revive_drive(p_dev2)
# propagate the delete...
# fire up reconstructor on handoff nodes only
for hnode in hnodes:
hnode_id = (hnode['port'] - 6000) / 10
self.reconstructor.once(number=hnode_id)
# check the first node to make sure its gone
try:
self.direct_get(onodes[1], opart)
except direct_client.DirectClientException as err:
self.assertEqual(err.http_status, 404)
else:
self.fail('Node data on %r was not fully destoryed!' %
(onodes[0]))
# make sure proxy get can't find it
try:
self.proxy_get()
except Exception as err:
self.assertEqual(err.http_status, 404)
else:
self.fail('Node data on %r was not fully destoryed!' %
(onodes[0]))
def copyMoveSingle(self, destPath, isMove):
src = '/'.join(self.path.split('/')[2:])
dst = '/'.join(destPath.split('/')[2:])
src_cont = self.path.split('/')[1]
dst_cont = destPath.split('/')[1]
if self.is_subdir(src):
client.put_object(self.storage_url,
self.auth_token,
dst_cont,
dst.rstrip('/') + '/',
content_type='application/directory',
http_conn=self.http_connection)
return
headers = {'X-Copy-From': self.path}
try:
client.put_object(self.storage_url,
self.auth_token,
dst_cont,
dst,
headers=headers,
http_conn=self.http_connection)
if isMove:
client.delete_object(self.storage_url,
self.auth_token,
src_cont,
src,
http_conn=self.http_connection)
except client.ClientException:
pass
def delete_object(request):
auth_token = request.session['auth_token']
storage_url = request.session['storage_url']
container = ''
subdir = ''
object_name = ''
if 'container' in request.GET.keys():
container = request.GET['container']
else:
return redirect(containers)
if 'subdir' in request.GET.keys():
subdir = request.GET['subdir']
else:
return redirect(reverse('container') + '?container=%s' % (container))
if 'object_name' in request.GET.keys():
object_name = request.GET['object_name']
else:
return redirect(reverse('container') + '?container=%s&subdir=%s' % (container, subdir))
logger.info("Delete File /%s/%s%s" % (container, subdir, object_name))
try:
http_conn = (urlparse(storage_url),
client.HTTPConnection(storage_url, insecure=settings.SWIFT_SSL_INSECURE))
client.delete_object(storage_url, auth_token,
container, object_name,
http_conn=http_conn)
messages.add_message(request, messages.INFO, "File deleted.")
except client.ClientException:
messages.add_message(request, messages.ERROR, "Access denied.")
return redirect(reverse('container') + '?container=%s&subdir=%s' % (container, subdir))
def test_copy_from(self):
resp = dict()
objname = self.storlet_file + '-copy'
req_headers = {
'X-Run-Storlet': self.storlet_name,
'X-Copy-From': '%s/%s' % (self.container, self.storlet_file)
}
client.put_object(self.url,
self.token,
self.container,
objname,
self.content,
response_dict=resp,
headers=req_headers)
self.assertEqual(201, resp['status'])
resp_header = resp['headers']
self.assertEqual('%s/%s' % (self.container, self.storlet_file),
resp_header['x-storlet-generated-from'])
self.assertEqual(self.acct,
resp_header['x-storlet-generated-from-account'])
self.assertIn('x-storlet-generated-from-last-modified', resp_header)
headers = client.head_object(self.url, self.token, self.container,
objname)
self.assertEqual(str(len(self.content)), headers['content-length'])
resp = dict()
client.delete_object(self.url,
self.token,
self.container,
objname,
response_dict=resp)
self.assertEqual(204, resp['status'])
def copyMoveSingle(self, destPath, isMove):
src = '/'.join(self.path.split('/')[2:])
dst = '/'.join(destPath.split('/')[2:])
src_cont = self.path.split('/')[1]
dst_cont = destPath.split('/')[1]
if self.is_subdir(src):
client.put_object(self.storage_url,
self.auth_token,
dst_cont,
dst.rstrip('/') + '/',
content_type='application/directory',
http_conn=self.http_connection)
return
headers = {'X-Copy-From': self.path}
try:
client.put_object(self.storage_url,
self.auth_token,
dst_cont,
dst,
headers=headers,
http_conn=self.http_connection)
if isMove:
client.delete_object(self.storage_url,
self.auth_token,
src_cont,
src,
http_conn=self.http_connection)
except client.ClientException:
pass
def delete_object(self, container, prefix, name):
try:
object_name = prefix + name
client.delete_object(self.storage_url, self.token, container, object_name)
return True
except:
return False
def delete(self, obj):
super(SwiftObjects, self).delete(obj)
swift_client.delete_object(self.endpoint,
token=self.token,
http_conn=self.http_conn,
container=obj['container'],
name=obj['name'])
def test_delete_propogate(self):
# create EC container
headers = {'X-Storage-Policy': self.policy.name}
client.put_container(self.url, self.token, self.container_name,
headers=headers)
# get our node lists
opart, onodes = self.object_ring.get_nodes(
self.account, self.container_name, self.object_name)
hnodes = self.object_ring.get_more_nodes(opart)
p_dev2 = self.device_dir('object', onodes[1])
# PUT object
contents = Body()
client.put_object(self.url, self.token, self.container_name,
self.object_name, contents=contents)
# now lets shut one down
self.kill_drive(p_dev2)
# delete on the ones that are left
client.delete_object(self.url, self.token,
self.container_name,
self.object_name)
# spot check a node
try:
self.direct_get(onodes[0], opart)
except direct_client.DirectClientException as err:
self.assertEqual(err.http_status, 404)
else:
self.fail('Node data on %r was not fully destoryed!' %
(onodes[0],))
# enable the first node again
self.revive_drive(p_dev2)
# propogate the delete...
# fire up reconstructor on handoff nodes only
for hnode in hnodes:
hnode_id = (hnode['port'] - 6000) / 10
self.reconstructor.once(number=hnode_id)
# check the first node to make sure its gone
try:
self.direct_get(onodes[1], opart)
except direct_client.DirectClientException as err:
self.assertEqual(err.http_status, 404)
else:
self.fail('Node data on %r was not fully destoryed!' %
(onodes[0]))
# make sure proxy get can't find it
try:
self.proxy_get()
except Exception as err:
self.assertEqual(err.http_status, 404)
else:
self.fail('Node data on %r was not fully destoryed!' %
(onodes[0]))
def dependency_undeploy(request, dependency_id, project_id):
if request.method == 'PUT':
try:
r = get_redis_connection()
except RedisError:
return JSONResponse('Problems to connect with the DB', status=500)
dependency = r.hgetall("dependency:" + str(dependency_id))
if not dependency:
return JSONResponse('Dependency does not exist', status=404)
if not r.exists(str(project_id) + ":dependency:" + str(dependency["name"])):
return JSONResponse('Dependency ' + str(dependency["name"]) + ' has not been deployed already', status=404)
try:
token = get_token_connection(request)
url = settings.SWIFT_URL + "/AUTH_" + project_id
swift_response = dict()
swift_client.delete_object(url, token, 'dependency', dependency["name"], None, None, None, None, swift_response)
except ClientException:
return JSONResponse(swift_response.get("reason"), status=swift_response.get('status'))
swift_status = swift_response.get('status')
if 200 <= swift_status < 300:
r.delete(str(project_id) + ":dependency:" + str(dependency["name"]))
r.lrem(str(project_id) + ":dependencies", str(dependency["name"]), 1)
return JSONResponse('The dependency has been deleted', status=swift_status)
return JSONResponse(swift_response.get("reason"), status=swift_status)
return JSONResponse('Method ' + str(request.method) + ' not allowed.', status=405)
def delete_given_object(request, container, objectname):
'''Delete the given object. '''
storage_url = request.session.get('storage_url', '')
auth_token = request.session.get('auth_token', '')
client.delete_object(storage_url, auth_token, container, objectname)
def delete_data(self, context, container_name):
url = self._get_endpoint_url(context)
token = context.auth_token
try:
headers, info = swift_client.get_container(
url, token, container_name
)
for obj in info:
try:
swift_client.delete_object(
url, token, container_name, obj['name']
)
except swift_exceptions.ClientException as e:
LOG.error(e)
if e.http_status != 404:
raise
swift_client.delete_container(url, token, container_name)
except swift_exceptions.ClientException as e:
LOG.error(e)
if e.http_status == 404:
raise exception.ContainerNotExists(
container_name=container_name
)
else:
raise exception.ContainerDeletionError(
container_name=container_name
)
def dependency_undeploy(request, id, account):
try:
r = get_redis_connection()
except:
return JSONResponse('Problems to connect with the DB', status=500)
dependency = r.hgetall("dependency:"+str(id))
if not dependency:
return JSONResponse('Dependency does not exists', status=404)
if not r.exists("AUTH_"+str(account)+":dependency:"+str(dependency["name"])):
return JSONResponse('Dependency '+str(dependency["name"])+' has not been deployed already', status=404)
if request.method == 'PUT':
headers = is_valid_request(request)
if not headers:
return JSONResponse('You must be authenticated. You can authenticate yourself with the header X-Auth-Token ', status=401)
response = dict()
try:
c.delete_object(settings.SWIFT_URL+settings.SWIFT_API_VERSION+"/"+"AUTH_"+str(account),headers["X-Auth-Token"],
'dependency', dependency["name"], None, None, None, None, response)
except:
return JSONResponse(response.get("reason"), status=response.get('status'))
status = response.get('status')
if 200 <= status < 300:
r.delete("AUTH_"+str(account)+":dependency:"+str(dependency["name"]))
r.lrem("AUTH_"+str(account)+":dependencies", str(dependency["name"]), 1)
return JSONResponse('The dependency has been deleted', status=status)
return JSONResponse(response.get("reason"), status=status)
return JSONResponse('Method '+str(request.method)+' not allowed.', status=405)
def test_symlink_target(self):
if 'symlink' not in self.cluster_info:
raise unittest.SkipTest("Symlink not enabled in proxy; can't test "
"symlink to reserved name")
int_client = self.make_internal_client()
# create link container first, ensure account gets created too
client.put_container(self.url, self.token, 'c1')
# Create reserve named container
tgt_cont = get_reserved_name('container-%s' % uuid4())
int_client.create_container(self.account, tgt_cont)
# sanity, user can't get to reserved name
with self.assertRaises(ClientException) as cm:
client.head_container(self.url, self.token, tgt_cont)
self.assertEqual(412, cm.exception.http_status)
tgt_obj = get_reserved_name('obj-%s' % uuid4())
int_client.upload_object(BytesIO(b'target object'), self.account,
tgt_cont, tgt_obj)
metadata = int_client.get_object_metadata(self.account, tgt_cont,
tgt_obj)
etag = metadata['etag']
# users can write a dynamic symlink that targets a reserved
# name object
client.put_object(self.url,
self.token,
'c1',
'symlink',
headers={
'X-Symlink-Target':
'%s/%s' % (tgt_cont, tgt_obj),
'Content-Type': 'application/symlink',
})
# but can't read the symlink
with self.assertRaises(ClientException) as cm:
client.get_object(self.url, self.token, 'c1', 'symlink')
self.assertEqual(412, cm.exception.http_status)
# user's can't create static symlink to reserved name
with self.assertRaises(ClientException) as cm:
client.put_object(self.url,
self.token,
'c1',
'static-symlink',
headers={
'X-Symlink-Target':
'%s/%s' % (tgt_cont, tgt_obj),
'X-Symlink-Target-Etag': etag,
'Content-Type': 'application/symlink',
})
self.assertEqual(412, cm.exception.http_status)
# clean-up
client.delete_object(self.url, self.token, 'c1', 'symlink')
int_client.delete_object(self.account, tgt_cont, tgt_obj)
int_client.delete_container(self.account, tgt_cont)
def _test_sync(self, object_post_as_copy):
source_container, dest_container = self._setup_synced_containers()
# upload to source
object_name = 'object-%s' % uuid.uuid4()
put_headers = {'X-Object-Meta-Test': 'put_value'}
client.put_object(self.url, self.token, source_container, object_name,
'test-body', headers=put_headers)
# cycle container-sync
Manager(['container-sync']).once()
resp_headers, body = client.get_object(self.url, self.token,
dest_container, object_name)
self.assertEqual(body, 'test-body')
self.assertIn('x-object-meta-test', resp_headers)
self.assertEqual('put_value', resp_headers['x-object-meta-test'])
# update metadata with a POST, using an internal client so we can
# vary the object_post_as_copy setting - first use post-as-copy
post_headers = {'Content-Type': 'image/jpeg',
'X-Object-Meta-Test': 'post_value'}
int_client = self.make_internal_client(
object_post_as_copy=object_post_as_copy)
int_client.set_object_metadata(self.account, source_container,
object_name, post_headers)
# sanity checks...
resp_headers = client.head_object(
self.url, self.token, source_container, object_name)
self.assertIn('x-object-meta-test', resp_headers)
self.assertEqual('post_value', resp_headers['x-object-meta-test'])
self.assertEqual('image/jpeg', resp_headers['content-type'])
# cycle container-sync
Manager(['container-sync']).once()
# verify that metadata changes were sync'd
resp_headers, body = client.get_object(self.url, self.token,
dest_container, object_name)
self.assertEqual(body, 'test-body')
self.assertIn('x-object-meta-test', resp_headers)
self.assertEqual('post_value', resp_headers['x-object-meta-test'])
self.assertEqual('image/jpeg', resp_headers['content-type'])
# delete the object
client.delete_object(
self.url, self.token, source_container, object_name)
with self.assertRaises(ClientException) as cm:
client.get_object(
self.url, self.token, source_container, object_name)
self.assertEqual(404, cm.exception.http_status) # sanity check
# cycle container-sync
Manager(['container-sync']).once()
# verify delete has been sync'd
with self.assertRaises(ClientException) as cm:
client.get_object(
self.url, self.token, dest_container, object_name)
self.assertEqual(404, cm.exception.http_status) # sanity check
def delete_object(self, container_name, object_name):
try:
client.delete_object(self.url, self.token,
container_name, object_name)
except ClientException as err:
if err.http_status != HTTP_NOT_FOUND:
raise
def delmByID(request, me_id, uname, id):
"""
:param request:
:param me_id: the parent_secl_id of Tmeta database,we can return the page after we delete the id of meta.
:param uname: the user's name
:param id: the meta object_id
:return: return to the page of before we execute delete.
"""
name_token = '_'.join([uname, 'token'])
name_url = '_'.join([uname, 'url'])
try:
auth_token = cache.get(name_token).split(':')[-1]
storage_url = cache.get(name_url)
except Exception as e:
return HttpResponse("<h1>You have no token!</h1></ br><p>Please Press 获取token Button!</p>")
bb = Tmeta.objects.get(object_id=id)
container = 'ytf'
objectname = bb.path
print "DELETE============"
print storage_url
print objectname.split('/')[-1]
try:
client.delete_object(storage_url, auth_token, container, objectname.split('/')[-1])
#values=(path, name, secfiled, seclevel, stype, token, str(url)+'/%s' % path)
#print values
#content = popen("curl -X DELETE -D- -H 'object_name:%s' -H 'parent_secl_id:%s' -H 'obj_seclevel:%s' -H 'Content-Type:%s' -H '%s' %s" % values).readlines()
bb.delete()
print "DELETE SUCESS"
messages.add_message(request, messages.INFO, _("Object deleted."))
except client.ClientException as e:
print "DELETE fail",e
messages.add_message(request, messages.ERROR, _("Access denied."))
return HttpResponse(e)
return HttpResponseRedirect("/meta/id=%s/name=%s" % (me_id, uname))
def cache_delete(self, context, plan_name, key):
swift_client = self.get_object_client(context)
try:
swift_client.delete_object(constants.TRIPLEO_CACHE_CONTAINER,
self._cache_key(plan_name, key))
except swiftexceptions.ClientException:
# cache or container does not exist. Ignore
pass
def delete_object(dest_cnx, dest_token, container_name, object_name):
parsed = dest_cnx[0]
url = '%s://%s/%s' % (parsed.scheme, parsed.netloc, parsed.path)
swiftclient.delete_object(url=url,
token=dest_token,
container=container_name,
http_conn=dest_cnx,
name=object_name)
def delete(self, credentials):
if credentials is None:
raise BadRequest('Swift backend requires credentials in x-auth-token headers')
log.debug('Deleting Swift object %s' % self.context.value)
protocol, schema, host, path = parse_uri(self.context.value)
uri = "%s:%s%s" % (schema, host, path)
client.delete_object(uri, credentials, path)
def test_query_string(self):
c.http_connection = self.fake_http_connection(200,
query_string="hello=20")
c.delete_object('http://www.test.com',
'asdf',
'asdf',
'asdf',
query_string="hello=20")
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 delete(self):
try:
client.delete_object(self.storage_url,
self.auth_token,
self.container,
self.objectname,
http_conn=self.http_connection)
except client.ClientException:
pass
def delete(self):
try:
client.delete_object(self.storage_url,
self.auth_token,
self.container,
self.objectname,
http_conn=self.http_connection)
except client.ClientException:
pass
def delete_given_object(request, container, objectname):
"""Delete the given object. """
storage_url = request.session.get('storage_url', '')
auth_token = request.session.get('auth_token', '')
client.delete_object(
storage_url, auth_token, container, objectname,
headers={"X-Forwarded-For": request.META.get('REMOTE_ADDR')})
def test_missing_primaries(self):
# Create container
container = 'container-%s' % uuid4()
client.put_container(self.url,
self.token,
container,
headers={'X-Storage-Policy': self.policy.name})
# Create container/obj (goes to all three primaries)
obj = 'object-%s' % uuid4()
client.put_object(self.url, self.token, container, obj, b'VERIFY')
odata = client.get_object(self.url, self.token, container, obj)[-1]
if odata != b'VERIFY':
raise Exception('Object GET did not return VERIFY, instead it '
'returned: %s' % repr(odata))
# Kill all primaries obj server
obj = 'object-%s' % uuid4()
opart, onodes = self.object_ring.get_nodes(self.account, container,
obj)
for onode in onodes:
kill_server((onode['ip'], onode['port']), self.ipport2server)
# Indirectly (i.e., through proxy) try to GET object, it should return
# a 503, since all primaries will Timeout and handoffs return a 404.
try:
client.get_object(self.url, self.token, container, obj)
except client.ClientException as err:
self.assertEqual(err.http_status, 503)
else:
self.fail("Expected ClientException but didn't get it")
# Restart the first container/obj primary server again
onode = onodes[0]
start_server((onode['ip'], onode['port']), self.ipport2server)
# Send a delete that will reach first primary and handoff.
# Sure, the DELETE will return a 404 since the handoff doesn't
# have a .data file, but object server will still write a
# Tombstone in the handoff node!
try:
client.delete_object(self.url, self.token, container, obj)
except client.ClientException as err:
self.assertEqual(err.http_status, 404)
# kill the first container/obj primary server again
kill_server((onode['ip'], onode['port']), self.ipport2server)
# a new GET should return a 404, since all primaries will Timeout
# and the handoff will return a 404 but this time with a tombstone
try:
client.get_object(self.url, self.token, container, obj)
except client.ClientException as err:
self.assertEqual(err.http_status, 404)
else:
self.fail("Expected ClientException but didn't get it")
def delete_object(self):
"""
issue delete for test object
"""
try:
client.delete_object(self.url, self.token, self.container_name,
self.object_name)
except ClientException as err:
if err.http_status != HTTP_NOT_FOUND:
raise
def delete_object(self):
"""
issue delete for test object
"""
try:
client.delete_object(self.url, self.token, self.container_name,
self.object_name)
except ClientException as err:
if err.http_status != HTTP_NOT_FOUND:
raise
def cache_delete(self, context, plan_name, key):
swift_client = self.get_object_client(context)
try:
swift_client.delete_object(
constants.TRIPLEO_CACHE_CONTAINER,
self._cache_key(plan_name, key)
)
except swiftexceptions.ClientException:
# cache or container does not exist. Ignore
pass
def moveRecursive(self, newname):
""" Move/rename a container.
This is only working for empty containers and objects with a size of 0.
Required by some clients because they create a folder "New folder" first.
For all other requests this will simply return HTTP_FORBIDDEN. """
oldname = self.path.lstrip('/')
newname = newname.lstrip('/')
if '/' not in oldname:
try:
# Container deletion will fail if not empty
client.delete_container(self.storage_url,
self.auth_token,
oldname)
client.put_container(self.storage_url,
self.auth_token,
newname)
except client.ClientException:
raise dav_error.DAVError(dav_error.HTTP_FORBIDDEN)
else:
old_container, _, old_object = oldname.partition('/')
new_container, _, new_object = newname.partition('/')
if old_container != new_container:
raise dav_error.DAVError(dav_error.HTTP_FORBIDDEN)
# If it is a pseudofolder, check that it is empty
_, objects = client.get_container(
self.storage_url,
self.auth_token,
container=self.container,
delimiter='/',
prefix=sanitize(old_object).rstrip('/') + '/',
http_conn=self.http_connection)
if len(objects) != 1: # first object is the pseudofolder entry
raise dav_error.DAVError(dav_error.HTTP_FORBIDDEN)
# also check if the object is empty
if objects[0].get('bytes') != 0:
raise dav_error.DAVError(dav_error.HTTP_FORBIDDEN)
# Do a COPY to preserve existing metadata and content-type
client.put_object(self.storage_url,
self.auth_token,
self.container,
sanitize(new_object),
headers = {'X-Copy-From': '/' + oldname + '/'},
http_conn=self.http_connection)
client.delete_object(self.storage_url,
self.auth_token,
self.container,
old_object + '/',
http_conn=self.http_connection)
def delete_object(dest_cnx,
dest_token,
container_name,
object_name):
parsed = dest_cnx[0]
url = '%s://%s/%s' % (parsed.scheme, parsed.netloc, parsed.path)
swiftclient.delete_object(url=url,
token=dest_token,
container=container_name,
http_conn=dest_cnx,
name=object_name)
def copyMoveSingle(self, destPath, isMove):
src = '/'.join(self.path.split('/')[2:])
dst = '/'.join(destPath.split('/')[2:])
src_cont = self.path.split('/')[1]
dst_cont = destPath.split('/')[1]
# Make sure target container exists
try:
client.put_container(self.storage_url,
self.auth_token,
dst_cont,
http_conn=self.http_connection)
except:
pass
_, objects = client.get_container(self.storage_url,
self.auth_token,
container=src_cont,
delimiter='/',
prefix=src,
http_conn=self.http_connection)
for obj in objects:
objname = obj.get('name', obj.get('subdir'))
headers = {'X-Copy-From': '%s/%s' % (self.container, objname)}
newname = objname.replace(src, dst)
if newname[-1] == '/':
newname = newname.rstrip('/') + '/'
try:
client.put_object(self.storage_url,
self.auth_token,
dst_cont,
newname,
headers=headers,
http_conn=self.http_connection)
if isMove:
client.delete_object(self.storage_url,
self.auth_token,
src_cont,
objname,
http_conn=self.http_connection)
except client.ClientException:
pass
# will only succeed if container is empty
if isMove:
try:
client.delete_container(self.storage_url,
self.auth_token,
self.container,
http_conn=self.http_connection)
except client.ClientException:
pass
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_ec_primary_timeout(self):
container_name = 'container-%s' % uuid4()
object_name = 'object-%s' % uuid4()
# create EC container
headers = {'X-Storage-Policy': self.policy.name}
client.put_container(self.url,
self.token,
container_name,
headers=headers)
# PUT object, should go to primary nodes
old_contents = Body()
client.put_object(self.url,
self.token,
container_name,
object_name,
contents=old_contents)
# get our node lists
opart, onodes = self.object_ring.get_nodes(self.account,
container_name, object_name)
# shutdown three of the primary data nodes
for i in range(3):
failed_primary = onodes[i]
failed_primary_device_path = self.device_dir(
'object', failed_primary)
self.kill_drive(failed_primary_device_path)
# Indirectly (i.e., through proxy) try to GET object, it should return
# a 503, since all primaries will Timeout and handoffs return a 404.
try:
client.get_object(self.url, self.token, container_name,
object_name)
except client.ClientException as err:
self.assertEqual(err.http_status, 503)
else:
self.fail("Expected ClientException but didn't get it")
# Send a delete to write down tombstones in the handoff nodes
client.delete_object(self.url, self.token, container_name, object_name)
# Now a new GET should return 404 because the handoff nodes
# return a 404 with a Tombstone.
try:
client.get_object(self.url, self.token, container_name,
object_name)
except client.ClientException as err:
self.assertEqual(err.http_status, 404)
else:
self.fail("Expected ClientException but didn't get it")
def deleteall(request):
try:
storage_url, auth_token = _get_auth_data(request.session)
auth_data_dict = request.data
for filename in auth_data_dict:
try:
client.delete_object(storage_url, auth_token, 'Image', filename)
except Exception as e:
print(filename.encode('utf-8') + '\n')
except Exception as e:
print e
raise e
return 'SUCCESS'
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 undeploy(r, storlet, account, headers):
response = dict()
try:
c.delete_object(settings.SWIFT_URL+settings.SWIFT_API_VERSION+"/"+"AUTH_"+str(account),headers["X-Auth-Token"],
'storlet', storlet["name"], None, None, None, None, response)
print 'response, ', response
except:
return JSONResponse(response.get("reason"), status=response.get('status'))
status = response.get('status')
if 200 <= status < 300:
r.delete("AUTH_"+str(account)+":"+str(storlet["name"]))
r.lrem("AUTH_"+str(account), str(storlet["name"]), 1)
return JSONResponse('The object has been deleted', status=status)
return JSONResponse(response.get("reason"), status=status)
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 delete_object(request, container, objectname):
""" Deletes an object """
storage_url = request.session.get('storage_url', '')
auth_token = request.session.get('auth_token', '')
try:
client.delete_object(storage_url, auth_token, container, objectname)
messages.add_message(request, messages.INFO, _("Object deleted."))
except client.ClientException:
messages.add_message(request, messages.ERROR, _("Access denied."))
prefix = '/'.join(objectname.split('/')[:-1])
if prefix:
prefix += '/'
return redirect(objectview, container=container, prefix=prefix)
def delete_object(self, container, name):
try:
print client.delete_object(self.storage_url, self.token, container, name)
return True
except:
return False
#def get_new_file_path(container,object):
#swift = Swift('swift.strawberrycode.com','demo','admin','secrete','5000')
#swift.connect();
#print swift.list_container('xiaohe-container');
#print swift.put_container('ThuCloudDisk-container');
#swift.put_object_from_file('ThuCloudDisk-container',prefix='',filepath='/home/chengls10/Desktop/2')
#print swift.get_object_to_file('ThuCloudDisk-container','1.py')
#print swift.delete_object('ThuCloudDisk-container','1.py')
def delete_object(request, container, objectname):
""" Deletes an object """
storage_url = request.session.get('storage_url', '')
auth_token = request.session.get('auth_token', '')
try:
client.delete_object(storage_url, auth_token, container, objectname)
messages.add_message(request, messages.INFO, _("Object deleted."))
except client.ClientException:
messages.add_message(request, messages.ERROR, _("Access denied."))
if objectname[-1] == '/': # deleting a pseudofolder, move one level up
objectname = objectname[:-1]
prefix = '/'.join(objectname.split('/')[:-1])
if prefix:
prefix += '/'
return redirect(objectview, container=container, prefix=prefix)
def delete_container(request, container):
""" Deletes a container """
storage_url = request.session.get("storage_url", "")
auth_token = request.session.get("auth_token", "")
try:
_m, objects = client.get_container(storage_url, auth_token, container)
for obj in objects:
client.delete_object(storage_url, auth_token, container, obj["name"])
client.delete_container(storage_url, auth_token, container)
messages.add_message(request, messages.INFO, _("Container deleted."))
except client.ClientException:
messages.add_message(request, messages.ERROR, _("Access denied."))
return redirect(containerview)
def clean_container(self, container_name):
_, objects = client.get_container(
self.url, self.token, container_name,
full_listing=True)
# delete all objects inside the container
# N.B. this cleanup could run in parallel but currently we have a few
# objects in the user testing container so that, currently this does
# as sequential simply
for obj_dict in objects:
client.delete_object(
self.url, self.token,
container_name, obj_dict['name'])
client.get_container(self.url, self.token, container_name)
# delete the container
client.delete_container(self.url, self.token, container_name)
def delete_object(self, container, name):
try:
print client.delete_object(self.storage_url, self.token, container,
name)
return True
except:
return False
#def get_new_file_path(container,object):
#swift = Swift('swift.strawberrycode.com','demo','admin','secrete','5000')
#swift.connect();
#print swift.list_container('xiaohe-container');
#print swift.put_container('ThuCloudDisk-container');
#swift.put_object_from_file('ThuCloudDisk-container',prefix='',filepath='/home/chengls10/Desktop/2')
#print swift.get_object_to_file('ThuCloudDisk-container','1.py')
#print swift.delete_object('ThuCloudDisk-container','1.py')
def test_first_two_nodes_fail(self):
container = 'container-%s' % uuid4()
client.put_container(self.url, self.token, container)
self.assert_(container in [c['name'] for c in
client.get_account(self.url, self.token)[1]])
object1 = 'object1'
client.put_object(self.url, self.token, container, object1, 'test')
self.assert_(container in [c['name'] for c in
client.get_account(self.url, self.token)[1]])
self.assert_(object1 in [o['name'] for o in
client.get_container(self.url, self.token, container)[1]])
cpart, cnodes = self.container_ring.get_nodes(self.account, container)
for x in xrange(2):
kill(self.pids[self.port2server[cnodes[x]['port']]], SIGTERM)
client.delete_object(self.url, self.token, container, object1)
self.assert_(container in [c['name'] for c in
client.get_account(self.url, self.token)[1]])
self.assert_(object1 not in [o['name'] for o in
client.get_container(self.url, self.token, container)[1]])
for x in xrange(2):
self.pids[self.port2server[cnodes[x]['port']]] = \
Popen(['swift-container-server',
'/etc/swift/container-server/%d.conf' %
((cnodes[x]['port'] - 6001) / 10)]).pid
sleep(2)
self.assert_(container in [c['name'] for c in
client.get_account(self.url, self.token)[1]])
# This okay because the first node hasn't got the update that the
# object was deleted yet.
self.assert_(object1 in [o['name'] for o in
direct_client.direct_get_container(cnodes[0], cpart,
self.account, container)[1]])
# This fails because all three nodes have to indicate deletion before
# we tell the user it worked. Since the first node 409s (it hasn't got
# the update that the object was deleted yet), the whole must 503
# (until every is synced up, then the delete would work).
exc = None
try:
client.delete_container(self.url, self.token, container)
except client.ClientException, err:
exc = err
def unset_filter(r, target, filter_data, token):
if filter_data['filter_type'] == 'storlet':
try:
project_id = target.split('/', 3)[0]
swift_response = dict()
url = settings.SWIFT_URL + "/AUTH_" + project_id
swift_client.delete_object(url, token, ".storlet", filter_data["filter_name"], None, None, None, None, swift_response)
except ClientException as e:
print swift_response + str(e)
return swift_response.get("status")
target = target.replace('/', ':')
keys = r.hgetall("pipeline:" + str(target))
for key, value in keys.items():
json_value = json.loads(value)
if json_value["filter_name"] == filter_data["filter_name"]:
r.hdel("pipeline:" + str(target), key)
def delete_object(request, container, objectname):
""" Deletes an object """
storage_url = request.session.get('storage_url', '')
auth_token = request.session.get('auth_token', '')
try:
client.delete_object(storage_url, auth_token, container, objectname)
messages.add_message(request, messages.INFO, _("Object deleted."))
except client.ClientException:
traceback.print_exc()
messages.add_message(request, messages.ERROR, _("Access denied."))
if objectname[-1] == '/': # deleting a pseudofolder, move one level up
objectname = objectname[:-1]
prefix = '/'.join(objectname.split('/')[:-1])
if prefix:
prefix += '/'
return redirect(objectview, container=container, prefix=prefix)
def delete_container(request, container):
""" Deletes a container """
storage_url = request.session.get('storage_url', '')
auth_token = request.session.get('auth_token', '')
try:
_m, objects = client.get_container(storage_url, auth_token, container)
for obj in objects:
client.delete_object(storage_url, auth_token, container,
obj['name'])
client.delete_container(storage_url, auth_token, container)
messages.add_message(request, messages.INFO, _("Container deleted."))
except client.ClientException:
messages.add_message(request, messages.ERROR, _("Access denied."))
return redirect(containerview)
def tearDown(self):
client.delete_object(self.url, self.token, self.container_name,
'small_eran.jpeg')
client.delete_object(self.url, self.token, self.container_name,
'small_eran_2.jpeg')
client.delete_object(self.url, self.token, self.container_name,
'small_eran_3.jpeg')
client.delete_object(self.url, self.token, self.container_name,
'model')
client.delete_container(self.url, self.token, self.container_name)
def update_container(request, project_id, container_name):
if request.method == 'PUT':
sp = JSONParser().parse(request)
token = get_token_connection(request)
url = settings.SWIFT_URL + "/AUTH_" + project_id
headers, obj_list = swift_client.get_container(url, token,
container_name)
headers['X-Storage-Policy'] = sp
path_container = settings.SWIFT_CFG_TMP_DIR + "/" + container_name
os.mkdir(path_container)
for obj in obj_list:
file = open(path_container + "/" + obj["name"], "w")
obj_headers, obj_body = swift_client.get_object(
url, token, container_name, obj["name"])
file.write(obj_body)
file.close()
obj["headers"] = obj_headers
swift_client.delete_object(url, token, container_name, obj["name"])
swift_client.delete_container(url, token, container_name)
swift_client.put_container(url, token, container_name, headers)
for obj in obj_list:
obj_path = os.path.join(path_container, obj["name"])
obj_body = open(obj_path, "r")
content_length = os.stat(obj_path).st_size
swift_response = {}
swift_client.put_object(url, token, container_name, obj["name"],
obj_body, content_length, None, None,
obj['content_type'], obj["headers"], None,
None, None, swift_response)
obj_body.close()
os.remove(obj_path)
os.rmdir(path_container)
return JSONResponse("Container Policy updated correctly",
status=status.HTTP_201_CREATED)
return JSONResponse('Method ' + str(request.method) + ' not allowed.',
status=status.HTTP_405_METHOD_NOT_ALLOWED)
def delete_container(request, container):
""" Deletes a container """
storage_url = request.session.get('storage_url', '')
auth_token = request.session.get('auth_token', '')
try:
_m, objects = client.get_container(storage_url, auth_token, container)
for obj in objects:
client.delete_object(storage_url, auth_token,
container, obj['name'])
client.delete_container(storage_url, auth_token, container)
messages.add_message(request, messages.INFO, _("Container deleted."))
except client.ClientException:
traceback.print_exc()
messages.add_message(request, messages.ERROR, _("Access denied."))
return redirect(containerview)
def delete(self):
prefix = '/'.join(self.path.split('/')[2:])
if '/' + self.container == self.path:
try:
client.delete_container(self.storage_url,
self.auth_token,
self.container,
http_conn=self.http_connection)
except client.ClientException:
pass
else:
try:
client.delete_object(self.storage_url,
self.auth_token,
self.container,
prefix + '/',
http_conn=self.http_connection)
except client.ClientException:
pass
def delete(self):
prefix = '/'.join(self.path.split('/')[2:])
if '/' + self.container == self.path:
try:
client.delete_container(self.storage_url,
self.auth_token,
self.container,
http_conn=self.http_connection)
except client.ClientException:
pass
else:
try:
client.delete_object(self.storage_url,
self.auth_token,
self.container,
prefix + '/',
http_conn=self.http_connection)
except client.ClientException:
pass
def update_container(request, project_id, container_name):
if request.method == 'PUT':
sp = JSONParser().parse(request)
token = get_token_connection(request)
url = settings.SWIFT_URL + "/AUTH_" + project_id
headers, obj_list = swift_client.get_container(url, token, container_name)
headers['X-Storage-Policy'] = sp
path_container = settings.SWIFT_CFG_TMP_DIR + "/" + container_name
os.mkdir(path_container)
for obj in obj_list:
fle = open(path_container + "/" + obj["name"], "w")
obj_headers, obj_body = swift_client.get_object(url, token, container_name, obj["name"])
fle.write(obj_body)
fle.close()
obj["headers"] = obj_headers
swift_client.delete_object(url, token, container_name, obj["name"])
swift_client.delete_container(url, token, container_name)
swift_client.put_container(url, token, container_name, headers)
for obj in obj_list:
obj_path = os.path.join(path_container, obj["name"])
obj_body = open(obj_path, "r")
content_length = os.stat(obj_path).st_size
swift_response = {}
swift_client.put_object(url, token, container_name, obj["name"],
obj_body, content_length,
None, None, obj['content_type'],
obj["headers"], None, None, None, swift_response)
obj_body.close()
os.remove(obj_path)
os.rmdir(path_container)
return JSONResponse("Container Policy updated correctly", status=status.HTTP_201_CREATED)
return JSONResponse('Method ' + str(request.method) + ' not allowed.', status=status.HTTP_405_METHOD_NOT_ALLOWED)
def delete_demo_data(self):
self.clean_container('train')
self.clean_container('test')
self.clean_container('extracted')
self.clean_container('video')
self.clean_container('trained')
client.delete_object(self.url, self.token, 'storlet',
'extract_face.py')
client.delete_object(self.url, self.token, 'storlet',
'train_model.py')
client.delete_object(self.url, self.token, 'storlet',
'video_swap_face.py')
client.delete_object(self.url, self.token, 'storlet',
'video_recognize_face.py')
def delete_object(request, container, objectname):
"""
Deletes an object from swift.
"""
storage_url = get_endpoint(request, 'adminURL')
auth_token = get_token_id(request)
http_conn = client.http_connection(storage_url,
insecure=settings.SWIFT_INSECURE)
try:
client.delete_object(storage_url,
token=auth_token,
container=container,
name=objectname,
http_conn=http_conn)
actionlog.log(request.user.username, "delete", objectname)
except client.ClientException as err:
log.exception('{}{}'.format(_('Exception:').encode('UTF-8'), err))
return False
return True
def delete_container(request, container):
""" Delete all the objects in the given container and delete the container
itself. Return a JsonResponse if successful or 500 error. """
storage_url = request.session.get('storage_url', '')
auth_token = request.session.get('auth_token', '')
try:
_m, objects = client.get_container(
storage_url, auth_token, container,
headers={"X-Forwarded-For": request.META.get('REMOTE_ADDR')})
for obj in objects:
client.delete_object(
storage_url, auth_token, container, obj['name'],
headers={"X-Forwarded-For": request.META.get('REMOTE_ADDR')})
client.delete_container(storage_url, auth_token, container,)
except client.ClientException:
return HttpResponse(e, status=500)
return JsonResponse({
'success': True,
})
