def delete_container(self, name): if not self.http_conn: self.connect() swift.delete_container(url=self.swift_url, token=self.token, http_conn=self.http_conn, container=name) if self.debug: print("Container {0} deleted".format(name))
def delete(self, container): """Container must be empty for deletion to succeed.""" super(SwiftContainers, self).delete(container) swift_client.delete_container(self.endpoint, self.token, container, http_conn=self.http_conn)
def test_missing_container(self): # In this test, we need to put container at handoff devices, so we # need container devices more than replica count if len(self.container_ring.devs) <= self.container_ring.replica_count: raise SkipTest("Need devices more that replica count") container = 'container-%s' % uuid4() cpart, cnodes = self.container_ring.get_nodes(self.account, container) # Kill all primary container servers for cnode in cnodes: kill_server((cnode['ip'], cnode['port']), self.ipport2server) # Create container, and all of its replicas are placed at handoff # device try: client.put_container(self.url, self.token, container) except ClientException as err: # if the cluster doesn't have enough devices, swift may return # error (ex. When we only have 4 devices in 3-replica cluster). self.assertEqual(err.http_status, 503) # Assert handoff device has a container replica another_cnode = next(self.container_ring.get_more_nodes(cpart)) direct_client.direct_get_container( another_cnode, cpart, self.account, container) # Restart all primary container servers for cnode in cnodes: start_server((cnode['ip'], cnode['port']), self.ipport2server) # Create container/obj obj = 'object-%s' % uuid4() client.put_object(self.url, self.token, container, obj, '') # Run the object-updater Manager(['object-updater']).once() # Run the container-replicator, and now, container replicas # at handoff device get moved to primary servers Manager(['container-replicator']).once() # Assert container replicas in primary servers, just moved by # replicator don't know about the object for cnode in cnodes: self.assertFalse(direct_client.direct_get_container( cnode, cpart, self.account, container)[1]) # since the container is empty - we can delete it! client.delete_container(self.url, self.token, container) # Re-run the object-updaters and now container replicas in primary # container servers should get updated Manager(['object-updater']).once() # Assert all primary container servers know about container/obj for cnode in cnodes: objs = [o['name'] for o in direct_client.direct_get_container( cnode, cpart, self.account, container)[1]] self.assertIn(obj, objs)
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 delete_container(self, swift_url=None, swift_container=None): swift_connection = swift.HTTPConnection(url=swift_url, insecure=True) swift.delete_container(swift_url, self.keystone.get_token('id'), swift_container, http_conn=(swift_connection.parsed_url, swift_connection))
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_one_node_fails(self): # Create container1 # Kill container1 servers excepting two of the primaries # Delete container1 # Restart other container1 primary server # Create container1/object1 (allowed because at least server thinks the # container exists) # Get to a final state # Assert all container1 servers indicate container1 is alive and # well with object1 # Assert account level also indicates container1 is alive and # well with object1 container1 = 'container-%s' % uuid4() cpart, cnodes = self.container_ring.get_nodes(self.account, container1) client.put_container(self.url, self.token, container1) kill_nonprimary_server(cnodes, self.port2server, self.pids) kill_server(cnodes[0]['port'], self.port2server, self.pids) client.delete_container(self.url, self.token, container1) start_server(cnodes[0]['port'], self.port2server, self.pids) client.put_object(self.url, self.token, container1, 'object1', '123') get_to_final_state() for cnode in cnodes: self.assertEquals([ o['name'] for o in direct_client.direct_get_container( cnode, cpart, self.account, container1)[1] ], ['object1']) headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '1') self.assertEquals(headers['x-account-object-count'], '1') self.assertEquals(headers['x-account-bytes-used'], '3')
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 test_one_node_fails(self): # Create container1 # Kill container1 servers excepting two of the primaries # Delete container1 # Restart other container1 primary server # Create container1/object1 (allowed because at least server thinks the # container exists) # Get to a final state # Assert all container1 servers indicate container1 is alive and # well with object1 # Assert account level also indicates container1 is alive and # well with object1 container1 = 'container-%s' % uuid4() cpart, cnodes = self.container_ring.get_nodes(self.account, container1) client.put_container(self.url, self.token, container1) kill_nonprimary_server(cnodes, self.port2server, self.pids) kill_server(cnodes[0]['port'], self.port2server, self.pids) client.delete_container(self.url, self.token, container1) start_server(cnodes[0]['port'], self.port2server, self.pids) client.put_object(self.url, self.token, container1, 'object1', '123') get_to_final_state() for cnode in cnodes: self.assertEquals( [o['name'] for o in direct_client.direct_get_container( cnode, cpart, self.account, container1)[1]], ['object1']) headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '1') self.assertEquals(headers['x-account-object-count'], '1') self.assertEquals(headers['x-account-bytes-used'], '3')
def _tearDown(self): client.delete_object(self.url, self.token, self.container_name, 'eran_swapped_mov.avi') client.delete_object(self.url, self.token, self.container_name, 'model') client.delete_object(self.url, self.token, self.container_name, 'recognized_mov.avi') client.delete_container(self.url, self.token, self.container_name)
def delete(self): name = self.path.strip('/') try: client.delete_container(self.storage_url, self.auth_token, name, http_conn=self.http_connection) except client.ClientException: raise dav_error.DAVError(dav_error.HTTP_INTERNAL_ERROR)
def test_missing_container(self): # In this test, we need to put container at handoff devices, so we # need container devices more than replica count if len(self.container_ring.devs) <= self.container_ring.replica_count: raise SkipTest("Need devices more that replica count") container = "container-%s" % uuid4() cpart, cnodes = self.container_ring.get_nodes(self.account, container) # Kill all primary container servers for cnode in cnodes: kill_server((cnode["ip"], cnode["port"]), self.ipport2server) # Create container, and all of its replicas are placed at handoff # device try: client.put_container(self.url, self.token, container) except ClientException as err: # if the cluster doesn't have enough devices, swift may return # error (ex. When we only have 4 devices in 3-replica cluster). self.assertEqual(err.http_status, 503) # Assert handoff device has a container replica another_cnode = self.container_ring.get_more_nodes(cpart).next() direct_client.direct_get_container(another_cnode, cpart, self.account, container) # Restart all primary container servers for cnode in cnodes: start_server((cnode["ip"], cnode["port"]), self.ipport2server) # Create container/obj obj = "object-%s" % uuid4() client.put_object(self.url, self.token, container, obj, "") # Run the object-updater Manager(["object-updater"]).once() # Run the container-replicator, and now, container replicas # at handoff device get moved to primary servers Manager(["container-replicator"]).once() # Assert container replicas in primary servers, just moved by # replicator don't know about the object for cnode in cnodes: self.assertFalse(direct_client.direct_get_container(cnode, cpart, self.account, container)[1]) # since the container is empty - we can delete it! client.delete_container(self.url, self.token, container) # Re-run the object-updaters and now container replicas in primary # container servers should get updated Manager(["object-updater"]).once() # Assert all primary container servers know about container/obj for cnode in cnodes: objs = [o["name"] for o in direct_client.direct_get_container(cnode, cpart, self.account, container)[1]] self.assertIn(obj, objs)
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 delete(self): name = self.path.strip('/') try: client.delete_container( self.storage_url, self.auth_token, name, http_conn=self.http_connection) except client.ClientException: raise dav_error.DAVError(dav_error.HTTP_INTERNAL_ERROR)
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 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_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 run_test(num_locks, catch_503): container = 'container-%s' % uuid4() client.put_container(self.url, self.token, container) db_files = self._get_container_db_files(container) db_conns = [] for i in range(num_locks): db_conn = sqlite3.connect(db_files[i]) db_conn.execute('begin exclusive transaction') db_conns.append(db_conn) if catch_503: try: client.delete_container(self.url, self.token, container) except client.ClientException, e: self.assertEquals(e.http_status, 503)
def run_test(num_locks, catch_503): container = 'container-%s' % uuid4() client.put_container(self.url, self.token, container) db_files = self._get_container_db_files(container) db_conns = [] for i in range(num_locks): db_conn = connect(db_files[i]) db_conn.execute('begin exclusive transaction') db_conns.append(db_conn) if catch_503: exc = None try: client.delete_container(self.url, self.token, container) except client.ClientException, err: exc = err self.assertEquals(exc.http_status, 503)
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 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 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 del_container(container): headers, objs = container_info(container) if len(objs) != 0: for i in objs: del_object(container, i['name']) return client.delete_container(url=storageURL, token=authtoken, container=container)
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 run_test(num_locks, catch_503): container = "container-%s" % uuid4() client.put_container(self.url, self.token, container) db_files = self._get_container_db_files(container) db_conns = [] for i in range(num_locks): db_conn = connect(db_files[i]) db_conn.execute("begin exclusive transaction") db_conns.append(db_conn) if catch_503: try: client.delete_container(self.url, self.token, container) except client.ClientException as err: self.assertEquals(err.http_status, 503) else: self.fail("Expected ClientException but didn't get it") else: client.delete_container(self.url, self.token, container)
def del_container(container): headers, objs = container_info(container) if len(objs) != 0: for i in objs: del_object(container,i['name']) return client.delete_container(url = storageURL, token = authtoken, container = container )
def run_test(num_locks, catch_503): container = 'container-%s' % uuid4() client.put_container(self.url, self.token, container) db_files = self._get_container_db_files(container) db_conns = [] for i in range(num_locks): db_conn = connect(db_files[i]) db_conn.execute('begin exclusive transaction') db_conns.append(db_conn) if catch_503: try: client.delete_container(self.url, self.token, container) except client.ClientException as err: self.assertEqual(err.http_status, 503) else: self.fail("Expected ClientException but didn't get it") else: client.delete_container(self.url, self.token, container)
def delete_container(self, container_name): """ :param container_name: :return: """ ret = sc.delete_container(self.storage_location, self.ks.auth_token, container_name) if ret is None: print('Container: %s has been deleted.' % container_name)
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_swift_account(storage_url, auth_token): insecure = settings.SWIFT_INSECURE try: # Criar container vazio para garantir que o account existe no swift http_conn = client.http_connection(storage_url, insecure=insecure) client.put_container(storage_url, auth_token, 'dummy_container', http_conn=http_conn) client.delete_container(storage_url, auth_token, 'dummy_container', http_conn=http_conn) except client.ClientException as err: log.exception( 'Fail to create container "dummy_container": {0}'.format(err)) return False try: # Deletar o account url = urlparse(storage_url) domain = '{}://{}'.format(url.scheme, url.netloc) path = url.path http_conn = client.HTTPConnection(domain, insecure=insecure) headers = {'X-Auth-Token': auth_token} resp = http_conn.request('DELETE', path, headers=headers) if resp.status_code != 204: error_msg = resp.json().get('error') log.exception( 'Fail to delete account {}: {}, status code {}'.format( storage_url, error_msg, resp.status_code)) return False, error_msg except client.ClientException as err: log.exception(f'Exception: {err}') return False, str(err) return True, 'success'
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_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, })
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 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 test_one_node_fails(self): # Create container1 container1 = "container-%s" % uuid4() cpart, cnodes = self.container_ring.get_nodes(self.account, container1) client.put_container(self.url, self.token, container1) # Kill container1 servers excepting two of the primaries kill_nonprimary_server(cnodes, self.port2server, self.pids) kill_server(cnodes[0]["port"], self.port2server, self.pids) # Delete container1 client.delete_container(self.url, self.token, container1) # Restart other container1 primary server start_server(cnodes[0]["port"], self.port2server, self.pids) # Create container1/object1 (allowed because at least server thinks the # container exists) client.put_object(self.url, self.token, container1, "object1", "123") # Get to a final state self.get_to_final_state() # Assert all container1 servers indicate container1 is alive and # well with object1 for cnode in cnodes: self.assertEquals( [o["name"] for o in direct_client.direct_get_container(cnode, cpart, self.account, container1)[1]], ["object1"], ) # Assert account level also indicates container1 is alive and # well with object1 headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers["x-account-container-count"], "1") self.assertEquals(headers["x-account-object-count"], "1") self.assertEquals(headers["x-account-bytes-used"], "3")
def delete_container(self, swift_url=None, swift_container=None): swift.delete_container(swift_url, self.keystone.get_token('id'), swift_container)
def test_main(self): container1 = 'container1' client.put_container(self.url, self.token, container1) container2 = 'container2' client.put_container(self.url, self.token, container2) headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '2') self.assertEquals(headers['x-account-object-count'], '0') self.assertEquals(headers['x-account-bytes-used'], '0') found1 = False found2 = False for c in containers: if c['name'] == container1: found1 = True self.assertEquals(c['count'], 0) self.assertEquals(c['bytes'], 0) elif c['name'] == container2: found2 = True self.assertEquals(c['count'], 0) self.assertEquals(c['bytes'], 0) self.assert_(found1) self.assert_(found2) client.put_object(self.url, self.token, container2, 'object1', '1234') headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '2') self.assertEquals(headers['x-account-object-count'], '0') self.assertEquals(headers['x-account-bytes-used'], '0') found1 = False found2 = False for c in containers: if c['name'] == container1: found1 = True self.assertEquals(c['count'], 0) self.assertEquals(c['bytes'], 0) elif c['name'] == container2: found2 = True self.assertEquals(c['count'], 0) self.assertEquals(c['bytes'], 0) self.assert_(found1) self.assert_(found2) get_to_final_state() headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '2') self.assertEquals(headers['x-account-object-count'], '1') self.assertEquals(headers['x-account-bytes-used'], '4') found1 = False found2 = False for c in containers: if c['name'] == container1: found1 = True self.assertEquals(c['count'], 0) self.assertEquals(c['bytes'], 0) elif c['name'] == container2: found2 = True self.assertEquals(c['count'], 1) self.assertEquals(c['bytes'], 4) self.assert_(found1) self.assert_(found2) apart, anodes = self.account_ring.get_nodes(self.account) kill(self.pids[self.port2server[anodes[0]['port']]], SIGTERM) client.delete_container(self.url, self.token, container1) client.put_object(self.url, self.token, container2, 'object2', '12345') headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '1') self.assertEquals(headers['x-account-object-count'], '1') self.assertEquals(headers['x-account-bytes-used'], '4') found1 = False found2 = False for c in containers: if c['name'] == container1: found1 = True elif c['name'] == container2: found2 = True self.assertEquals(c['count'], 1) self.assertEquals(c['bytes'], 4) self.assert_(not found1) self.assert_(found2) ps = [] for n in xrange(1, 5): ps.append(Popen(['swift-container-updater', '/etc/swift/container-server/%d.conf' % n, 'once'])) for p in ps: p.wait() headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '1') self.assertEquals(headers['x-account-object-count'], '2') self.assertEquals(headers['x-account-bytes-used'], '9') found1 = False found2 = False for c in containers: if c['name'] == container1: found1 = True elif c['name'] == container2: found2 = True self.assertEquals(c['count'], 2) self.assertEquals(c['bytes'], 9) self.assert_(not found1) self.assert_(found2) self.pids[self.port2server[anodes[0]['port']]] = \ Popen(['swift-account-server', '/etc/swift/account-server/%d.conf' % ((anodes[0]['port'] - 6002) / 10)]).pid sleep(2) # This is the earlier counts and bytes because the first node doesn't # have the newest udpates yet. headers, containers = \ direct_client.direct_get_account(anodes[0], apart, self.account) self.assertEquals(headers['x-account-container-count'], '2') self.assertEquals(headers['x-account-object-count'], '1') self.assertEquals(headers['x-account-bytes-used'], '4') found1 = False found2 = False for c in containers: if c['name'] == container1: found1 = True elif c['name'] == container2: found2 = True # This is the earlier count and bytes because the first node # doesn't have the newest udpates yet. self.assertEquals(c['count'], 1) self.assertEquals(c['bytes'], 4) # This okay because the first node hasn't got the update that # container1 was deleted yet. self.assert_(found1) self.assert_(found2) get_to_final_state() headers, containers = \ direct_client.direct_get_account(anodes[0], apart, self.account) self.assertEquals(headers['x-account-container-count'], '1') self.assertEquals(headers['x-account-object-count'], '2') self.assertEquals(headers['x-account-bytes-used'], '9') found1 = False found2 = False for c in containers: if c['name'] == container1: found1 = True elif c['name'] == container2: found2 = True self.assertEquals(c['count'], 2) self.assertEquals(c['bytes'], 9) self.assert_(not found1) self.assert_(found2)
def test_main(self): # Create container1 and container2 container1 = 'container1' client.put_container(self.url, self.token, container1) container2 = 'container2' client.put_container(self.url, self.token, container2) # Assert account level sees them headers, containers = client.get_account(self.url, self.token) self.assertEqual(headers['x-account-container-count'], '2') self.assertEqual(headers['x-account-object-count'], '0') self.assertEqual(headers['x-account-bytes-used'], '0') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True self.assertEqual(container['count'], 0) self.assertEqual(container['bytes'], 0) elif container['name'] == container2: found2 = True self.assertEqual(container['count'], 0) self.assertEqual(container['bytes'], 0) self.assertTrue(found1) self.assertTrue(found2) # Create container2/object1 client.put_object(self.url, self.token, container2, 'object1', '1234') # Assert account level doesn't see it yet headers, containers = client.get_account(self.url, self.token) self.assertEqual(headers['x-account-container-count'], '2') self.assertEqual(headers['x-account-object-count'], '0') self.assertEqual(headers['x-account-bytes-used'], '0') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True self.assertEqual(container['count'], 0) self.assertEqual(container['bytes'], 0) elif container['name'] == container2: found2 = True self.assertEqual(container['count'], 0) self.assertEqual(container['bytes'], 0) self.assertTrue(found1) self.assertTrue(found2) # Get to final state self.get_to_final_state() # Assert account level now sees the container2/object1 headers, containers = client.get_account(self.url, self.token) self.assertEqual(headers['x-account-container-count'], '2') self.assertEqual(headers['x-account-object-count'], '1') self.assertEqual(headers['x-account-bytes-used'], '4') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True self.assertEqual(container['count'], 0) self.assertEqual(container['bytes'], 0) elif container['name'] == container2: found2 = True self.assertEqual(container['count'], 1) self.assertEqual(container['bytes'], 4) self.assertTrue(found1) self.assertTrue(found2) apart, anodes = self.account_ring.get_nodes(self.account) kill_nonprimary_server(anodes, self.ipport2server) kill_server((anodes[0]['ip'], anodes[0]['port']), self.ipport2server) # Kill account servers excepting two of the primaries # Delete container1 client.delete_container(self.url, self.token, container1) # Put container2/object2 client.put_object(self.url, self.token, container2, 'object2', '12345') # Assert account level knows container1 is gone but doesn't know about # container2/object2 yet headers, containers = client.get_account(self.url, self.token) self.assertEqual(headers['x-account-container-count'], '1') self.assertEqual(headers['x-account-object-count'], '1') self.assertEqual(headers['x-account-bytes-used'], '4') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True elif container['name'] == container2: found2 = True self.assertEqual(container['count'], 1) self.assertEqual(container['bytes'], 4) self.assertFalse(found1) self.assertTrue(found2) # Run container updaters Manager(['container-updater']).once() # Assert account level now knows about container2/object2 headers, containers = client.get_account(self.url, self.token) self.assertEqual(headers['x-account-container-count'], '1') self.assertEqual(headers['x-account-object-count'], '2') self.assertEqual(headers['x-account-bytes-used'], '9') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True elif container['name'] == container2: found2 = True self.assertEqual(container['count'], 2) self.assertEqual(container['bytes'], 9) self.assertFalse(found1) self.assertTrue(found2) # Restart other primary account server start_server((anodes[0]['ip'], anodes[0]['port']), self.ipport2server) # Assert that server doesn't know about container1's deletion or the # new container2/object2 yet headers, containers = \ direct_client.direct_get_account(anodes[0], apart, self.account) self.assertEqual(headers['x-account-container-count'], '2') self.assertEqual(headers['x-account-object-count'], '1') self.assertEqual(headers['x-account-bytes-used'], '4') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True elif container['name'] == container2: found2 = True self.assertEqual(container['count'], 1) self.assertEqual(container['bytes'], 4) self.assertTrue(found1) self.assertTrue(found2) # Get to final state self.get_to_final_state() # Assert that server is now up to date headers, containers = \ direct_client.direct_get_account(anodes[0], apart, self.account) self.assertEqual(headers['x-account-container-count'], '1') self.assertEqual(headers['x-account-object-count'], '2') self.assertEqual(headers['x-account-bytes-used'], '9') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True elif container['name'] == container2: found2 = True self.assertEqual(container['count'], 2) self.assertEqual(container['bytes'], 9) self.assertEqual(container['bytes'], 9) self.assertFalse(found1) self.assertTrue(found2)
def delete_container(self, container): return swift_client.delete_container(self.storage_url, self.token, container)
def projects(request, project_id=None): """ GET: List all projects ordered by name PUT: Save a project (enable) DELETE: Delete a project (disable) POST: Check if a project exist or is enabled """ try: r = get_redis_connection() except RedisError: return JSONResponse('Error connecting with DB', status=status.HTTP_500_INTERNAL_SERVER_ERROR) if request.method == 'GET': enabled_projects = r.lrange('projects_crystal_enabled', 0, -1) return JSONResponse(enabled_projects, status=status.HTTP_200_OK) if request.method == 'PUT': project_list = get_project_list() project_name = project_list[project_id] if project_name == settings.MANAGEMENT_ACCOUNT: return JSONResponse("Management project could not be set as Crystal project", status=status.HTTP_400_BAD_REQUEST) try: # Set Manager as admin of the Crystal Project keystone_client = get_keystone_admin_auth() admin_role_id, reseller_admin_role_id, admin_user_id = get_admin_role_user_ids(keystone_client) keystone_client.roles.grant(role=admin_role_id, user=admin_user_id, project=project_id) keystone_client.roles.grant(role=reseller_admin_role_id, user=admin_user_id, project=project_id) # Post Storlet and Dependency containers url, token = get_swift_url_and_token(project_name) swift_client.put_container(url, token, ".storlet") swift_client.put_container(url, token, ".dependency") headers = {'X-Account-Meta-Crystal-Enabled': True, 'X-Account-Meta-Storlet-Enabled': True} swift_client.post_account(url, token, headers) # Create project docker image create_docker_image(r, project_id) r.lpush('projects_crystal_enabled', project_id) return JSONResponse("Crystal Project correctly enabled", status=status.HTTP_201_CREATED) except: return JSONResponse("Error Enabling Crystal Project", status=status.HTTP_400_BAD_REQUEST) if request.method == 'DELETE': try: project_list = get_project_list() project_name = project_list[project_id] # Delete Storlet and Dependency containers try: url, token = get_swift_url_and_token(project_name) headers = {'X-Account-Meta-Crystal-Enabled': '', 'X-Account-Meta-Storlet-Enabled': ''} swift_client.post_account(url, token, headers) swift_client.delete_container(url, token, ".storlet") swift_client.delete_container(url, token, ".dependency") except: pass # Delete Manager as admin of the Crystal Project keystone_client = get_keystone_admin_auth() admin_role_id, reseller_admin_role_id, admin_user_id = get_admin_role_user_ids(keystone_client) try: keystone_client.roles.revoke(role=admin_role_id, user=admin_user_id, project=project_id) keystone_client.roles.revoke(role=reseller_admin_role_id, user=admin_user_id, project=project_id) except: pass # Delete project docker image delete_docker_image(r, project_id) r.lrem('projects_crystal_enabled', project_id) return JSONResponse("Crystal project correctly disabled.", status=status.HTTP_201_CREATED) except RedisError: return JSONResponse("Error inserting data", status=status.HTTP_400_BAD_REQUEST) if request.method == 'POST': enabled_projects = r.lrange('projects_crystal_enabled', 0, -1) if project_id in enabled_projects: return JSONResponse(project_id, status=status.HTTP_200_OK) return JSONResponse('The project with id: ' + str(project_id) + ' does not exist.', status=status.HTTP_404_NOT_FOUND) return JSONResponse('Method ' + str(request.method) + ' not allowed.', status=status.HTTP_405_METHOD_NOT_ALLOWED)
def test_main(self): # Create container1 and container2 # Assert account level sees them # Create container2/object1 # Assert account level doesn't see it yet # Get to final state # Assert account level now sees the container2/object1 # Kill account servers excepting two of the primaries # Delete container1 # Assert account level knows container1 is gone but doesn't know about # container2/object2 yet # Put container2/object2 # Run container updaters # Assert account level now knows about container2/object2 # Restart other primary account server # Assert that server doesn't know about container1's deletion or the # new container2/object2 yet # Get to final state # Assert that server is now up to date container1 = 'container1' client.put_container(self.url, self.token, container1) container2 = 'container2' client.put_container(self.url, self.token, container2) headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '2') self.assertEquals(headers['x-account-object-count'], '0') self.assertEquals(headers['x-account-bytes-used'], '0') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True self.assertEquals(container['count'], 0) self.assertEquals(container['bytes'], 0) elif container['name'] == container2: found2 = True self.assertEquals(container['count'], 0) self.assertEquals(container['bytes'], 0) self.assert_(found1) self.assert_(found2) client.put_object(self.url, self.token, container2, 'object1', '1234') headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '2') self.assertEquals(headers['x-account-object-count'], '0') self.assertEquals(headers['x-account-bytes-used'], '0') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True self.assertEquals(container['count'], 0) self.assertEquals(container['bytes'], 0) elif container['name'] == container2: found2 = True self.assertEquals(container['count'], 0) self.assertEquals(container['bytes'], 0) self.assert_(found1) self.assert_(found2) get_to_final_state() headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '2') self.assertEquals(headers['x-account-object-count'], '1') self.assertEquals(headers['x-account-bytes-used'], '4') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True self.assertEquals(container['count'], 0) self.assertEquals(container['bytes'], 0) elif container['name'] == container2: found2 = True self.assertEquals(container['count'], 1) self.assertEquals(container['bytes'], 4) self.assert_(found1) self.assert_(found2) apart, anodes = self.account_ring.get_nodes(self.account) kill_nonprimary_server(anodes, self.port2server, self.pids) kill_server(anodes[0]['port'], self.port2server, self.pids) client.delete_container(self.url, self.token, container1) client.put_object(self.url, self.token, container2, 'object2', '12345') headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '1') self.assertEquals(headers['x-account-object-count'], '1') self.assertEquals(headers['x-account-bytes-used'], '4') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True elif container['name'] == container2: found2 = True self.assertEquals(container['count'], 1) self.assertEquals(container['bytes'], 4) self.assert_(not found1) self.assert_(found2) processes = [] for node in xrange(1, 5): processes.append( Popen([ 'swift-container-updater', '/etc/swift/container-server/%d.conf' % node, 'once' ])) for process in processes: process.wait() headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '1') self.assertEquals(headers['x-account-object-count'], '2') self.assertEquals(headers['x-account-bytes-used'], '9') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True elif container['name'] == container2: found2 = True self.assertEquals(container['count'], 2) self.assertEquals(container['bytes'], 9) self.assert_(not found1) self.assert_(found2) start_server(anodes[0]['port'], self.port2server, self.pids) headers, containers = \ direct_client.direct_get_account(anodes[0], apart, self.account) self.assertEquals(headers['x-account-container-count'], '2') self.assertEquals(headers['x-account-object-count'], '1') self.assertEquals(headers['x-account-bytes-used'], '4') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True elif container['name'] == container2: found2 = True self.assertEquals(container['count'], 1) self.assertEquals(container['bytes'], 4) self.assert_(found1) self.assert_(found2) get_to_final_state() headers, containers = \ direct_client.direct_get_account(anodes[0], apart, self.account) self.assertEquals(headers['x-account-container-count'], '1') self.assertEquals(headers['x-account-object-count'], '2') self.assertEquals(headers['x-account-bytes-used'], '9') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True elif container['name'] == container2: found2 = True self.assertEquals(container['count'], 2) self.assertEquals(container['bytes'], 9) self.assert_(not found1) self.assert_(found2)
def test_main(self): # Create container1 and container2 container1 = 'container1' client.put_container(self.url, self.token, container1) container2 = 'container2' client.put_container(self.url, self.token, container2) # Assert account level sees them headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '2') self.assertEquals(headers['x-account-object-count'], '0') self.assertEquals(headers['x-account-bytes-used'], '0') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True self.assertEquals(container['count'], 0) self.assertEquals(container['bytes'], 0) elif container['name'] == container2: found2 = True self.assertEquals(container['count'], 0) self.assertEquals(container['bytes'], 0) self.assertTrue(found1) self.assertTrue(found2) # Create container2/object1 client.put_object(self.url, self.token, container2, 'object1', '1234') # Assert account level doesn't see it yet headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '2') self.assertEquals(headers['x-account-object-count'], '0') self.assertEquals(headers['x-account-bytes-used'], '0') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True self.assertEquals(container['count'], 0) self.assertEquals(container['bytes'], 0) elif container['name'] == container2: found2 = True self.assertEquals(container['count'], 0) self.assertEquals(container['bytes'], 0) self.assertTrue(found1) self.assertTrue(found2) # Get to final state self.get_to_final_state() # Assert account level now sees the container2/object1 headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '2') self.assertEquals(headers['x-account-object-count'], '1') self.assertEquals(headers['x-account-bytes-used'], '4') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True self.assertEquals(container['count'], 0) self.assertEquals(container['bytes'], 0) elif container['name'] == container2: found2 = True self.assertEquals(container['count'], 1) self.assertEquals(container['bytes'], 4) self.assertTrue(found1) self.assertTrue(found2) apart, anodes = self.account_ring.get_nodes(self.account) kill_nonprimary_server(anodes, self.ipport2server, self.pids) kill_server((anodes[0]['ip'], anodes[0]['port']), self.ipport2server, self.pids) # Kill account servers excepting two of the primaries # Delete container1 client.delete_container(self.url, self.token, container1) # Put container2/object2 client.put_object(self.url, self.token, container2, 'object2', '12345') # Assert account level knows container1 is gone but doesn't know about # container2/object2 yet headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '1') self.assertEquals(headers['x-account-object-count'], '1') self.assertEquals(headers['x-account-bytes-used'], '4') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True elif container['name'] == container2: found2 = True self.assertEquals(container['count'], 1) self.assertEquals(container['bytes'], 4) self.assertTrue(not found1) self.assertTrue(found2) # Run container updaters Manager(['container-updater']).once() # Assert account level now knows about container2/object2 headers, containers = client.get_account(self.url, self.token) self.assertEquals(headers['x-account-container-count'], '1') self.assertEquals(headers['x-account-object-count'], '2') self.assertEquals(headers['x-account-bytes-used'], '9') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True elif container['name'] == container2: found2 = True self.assertEquals(container['count'], 2) self.assertEquals(container['bytes'], 9) self.assertTrue(not found1) self.assertTrue(found2) # Restart other primary account server start_server((anodes[0]['ip'], anodes[0]['port']), self.ipport2server, self.pids) # Assert that server doesn't know about container1's deletion or the # new container2/object2 yet headers, containers = \ direct_client.direct_get_account(anodes[0], apart, self.account) self.assertEquals(headers['x-account-container-count'], '2') self.assertEquals(headers['x-account-object-count'], '1') self.assertEquals(headers['x-account-bytes-used'], '4') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True elif container['name'] == container2: found2 = True self.assertEquals(container['count'], 1) self.assertEquals(container['bytes'], 4) self.assertTrue(found1) self.assertTrue(found2) # Get to final state self.get_to_final_state() # Assert that server is now up to date headers, containers = \ direct_client.direct_get_account(anodes[0], apart, self.account) self.assertEquals(headers['x-account-container-count'], '1') self.assertEquals(headers['x-account-object-count'], '2') self.assertEquals(headers['x-account-bytes-used'], '9') found1 = False found2 = False for container in containers: if container['name'] == container1: found1 = True elif container['name'] == container2: found2 = True self.assertEquals(container['count'], 2) self.assertEquals(container['bytes'], 9) self.assertTrue(not found1) self.assertTrue(found2)
def test_ok(self): c.http_connection = self.fake_http_connection(200) value = c.delete_container('http://www.test.com', 'asdf', 'asdf') self.assertEqual(value, None)
def test_ok(self): c.http_connection = self.fake_http_connection(200) value = c.delete_container('http://www.test.com', 'asdf', 'asdf') self.assertEquals(value, None)
def delete_container(self, account_id, token, s_type, container): cnx = self.get_cnx(account_id, s_type) sclient.delete_container("", token, container, http_conn=cnx)
def delete_container(self, container_name): return client.delete_container(self.url, self.token, container_name)
def tearDown(self): swift_client.delete_container(self.url, self.token, self.container)
def test_ok(self): c.http_connection = self.fake_http_connection(200) value = c.delete_container("http://www.test.com", "asdf", "asdf") self.assertEquals(value, None)
client.put_container(self.url, self.token, container) db_files = self._get_container_db_files(container) db_conns = [] for i in range(num_locks): db_conn = connect(db_files[i]) db_conn.execute('begin exclusive transaction') db_conns.append(db_conn) if catch_503: exc = None try: client.delete_container(self.url, self.token, container) except client.ClientException, err: exc = err self.assertEquals(exc.http_status, 503) else: client.delete_container(self.url, self.token, container) pool = GreenPool() try: with Timeout(15): pool.spawn(run_test, 1, False) pool.spawn(run_test, 2, True) pool.spawn(run_test, 3, True) pool.waitall() except Timeout, err: raise Exception( "The server did not return a 503 on container db locks, " "it just hangs: %s" % err) if __name__ == '__main__':
def delete(self, container): """Container must be empty for deletion to succeed.""" super(SwiftContainers, self).delete(container) swift_client.delete_container(self.endpoint, self.token, container)
def projects(request, project_id=None): """ GET: List all projects ordered by name PUT: Save a project (enable) DELETE: Delete a project (disable) POST: Check if a project exist or is enabled """ try: r = get_redis_connection() except RedisError: return JSONResponse('Error connecting with DB', status=status.HTTP_500_INTERNAL_SERVER_ERROR) if request.method == 'GET': enabled_projects = r.lrange('projects_crystal_enabled', 0, -1) return JSONResponse(enabled_projects, status=status.HTTP_200_OK) if request.method == 'PUT': project_list = get_project_list() project_name = project_list[project_id] if project_name == settings.MANAGEMENT_ACCOUNT: return JSONResponse( "Management project could not be set as Crystal project", status=status.HTTP_400_BAD_REQUEST) try: # Set Manager as admin of the Crystal Project keystone_client = get_keystone_admin_auth() admin_role_id, reseller_admin_role_id, admin_user_id = get_admin_role_user_ids( keystone_client) keystone_client.roles.grant(role=admin_role_id, user=admin_user_id, project=project_id) keystone_client.roles.grant(role=reseller_admin_role_id, user=admin_user_id, project=project_id) # Post Storlet and Dependency containers url, token = get_swift_url_and_token(project_name) swift_client.put_container(url, token, ".storlet") swift_client.put_container(url, token, ".dependency") headers = { 'X-Account-Meta-Crystal-Enabled': True, 'X-Account-Meta-Storlet-Enabled': True } swift_client.post_account(url, token, headers) # Create project docker image create_docker_image(r, project_id) r.lpush('projects_crystal_enabled', project_id) return JSONResponse("Crystal Project correctly enabled", status=status.HTTP_201_CREATED) except: return JSONResponse("Error Enabling Crystal Project", status=status.HTTP_400_BAD_REQUEST) if request.method == 'DELETE': try: project_list = get_project_list() project_name = project_list[project_id] # Delete Storlet and Dependency containers try: url, token = get_swift_url_and_token(project_name) headers = { 'X-Account-Meta-Crystal-Enabled': '', 'X-Account-Meta-Storlet-Enabled': '' } swift_client.post_account(url, token, headers) swift_client.delete_container(url, token, ".storlet") swift_client.delete_container(url, token, ".dependency") except: pass # Delete Manager as admin of the Crystal Project keystone_client = get_keystone_admin_auth() admin_role_id, reseller_admin_role_id, admin_user_id = get_admin_role_user_ids( keystone_client) try: keystone_client.roles.revoke(role=admin_role_id, user=admin_user_id, project=project_id) keystone_client.roles.revoke(role=reseller_admin_role_id, user=admin_user_id, project=project_id) except: pass # Delete project docker image delete_docker_image(r, project_id) r.lrem('projects_crystal_enabled', project_id) return JSONResponse("Crystal project correctly disabled.", status=status.HTTP_201_CREATED) except RedisError: return JSONResponse("Error inserting data", status=status.HTTP_400_BAD_REQUEST) if request.method == 'POST': enabled_projects = r.lrange('projects_crystal_enabled', 0, -1) if project_id in enabled_projects: return JSONResponse(project_id, status=status.HTTP_200_OK) return JSONResponse('The project with id: ' + str(project_id) + ' does not exist.', status=status.HTTP_404_NOT_FOUND) return JSONResponse('Method ' + str(request.method) + ' not allowed.', status=status.HTTP_405_METHOD_NOT_ALLOWED)
def delete_container(self, container, *args): return swift_client.delete_container(self.storage_url, self.token, container)
def delete_container(self): """ delete container """ client.delete_container(self.url, self.token, self.container_name)