Example #1
0
class SwiftConnection(object):
    order = 2

    def __init__(self):
        # Read configuration from environment variables (openstack.rc)
        auth_url = environ["OPENSTACK_AUTH_URL"]
        user_domain_name = environ["OPENSTACK_USER_DOMAIN_NAME"]
        user_name = environ["OPENSTACK_USERNAME"]
        password = environ["OPENSTACK_PASSWORD"]
        project_domain_name = environ["OPENSTACK_PROJECT_DOMAIN_NAME"]
        project_name = environ["OPENSTACK_PROJECT_NAME"]
        container_name = environ["OPENSTACK_CONTAINER_NAME"]
        ca_certificate = environ["OPENSTACK_CA_CERTIFICATE"]
        self.container_name = container_name
        options = {
            'user_domain_name': user_domain_name,
            'project_domain_name': project_domain_name,
            'project_name': project_name,
        }
        # Establish the connection with the object storage API cacert=ca_certificate,
        self.conn = Connection(user=user_name,
                               key=password,
                               authurl=auth_url,
                               auth_version=3,
                               os_options=options,
                               cacert=ca_certificate,
                               timeout=120)
        found = False
        for container in self.conn.get_account()[1]:
            cname = container['name']
            if cname == container_name:
                found = True
        if found is not True:
            # Create a new container
            container_name = container_name
            self.conn.put_container(container_name)

    def put(self, file_name, file_content):
        """Upload file object to swift bucket."""
        container_name = self.container_name
        self.conn.put_object(
            container_name,
            file_name,
            contents=file_content,
        )

    def get_file(self, file_name):
        """Download file object from swift bucket."""
        container_name = self.container_name
        self.conn.get_object(container_name, file_name)
Example #2
0
File: cdn.py Project: rygy/OpenFunc
class CdnCheck:

    """

    Functional test for CDN - basic workflow as follows

    Create a CDN enabled container
    List all the CDN containers
    Select a CDN enabled container
    Upload Metadata to the account
    Retrieve Metadata to the account
    Create and upload an object
    Access the object with the CDN http url
    Access the object with the CDN https url
    Delete the object created in the previous step
    Delete the CDN container we created in our first step

    """

    def __init__(self, logger, exec_time, **kwargs):
        self.keystone_client = keystone_client.Client(
            username=kwargs['os_username'],
            password=kwargs['os_password'],
            tenant_name=kwargs['os_tenant_name'],
            auth_url=kwargs['os_auth_url'])
        self.token = self.keystone_client.auth_ref['token']['id']
        self.tenant_id = self.keystone_client.auth_ref['token']['tenant']['id']
        self.end_points = self.keystone_client.service_catalog.get_endpoints()
        self.region1 = str(self.end_points['hpext:cdn'][0]['region'])
        self.region2 = str(self.end_points['hpext:cdn'][1]['region'])
        self.url1 = str(self.end_points['hpext:cdn'][0]['versionList'])
        self.url1 = self.url1[:-1]
        self.url2 = str(self.end_points['hpext:cdn'][1]['versionList'])
        self.url2 = self.url2[:-1]

        self.END_POINTS = {
            self.region1: self.url1,
            self.region2: self.url2
        }

        self.cdn_client = Connection(
            user=kwargs['os_username'],
            key=kwargs['os_password'],
            tenant_name=kwargs['os_tenant_name'],
            authurl=kwargs['os_auth_url'],
            auth_version="2.0",
            os_options={'region_name': kwargs['os_region'],
                        'service_type': 'hpext:cdn'})

        self.swift_client = Connection(
            user=kwargs['os_username'],
            key=kwargs['os_password'],
            tenant_name=kwargs['os_tenant_name'],
            authurl=kwargs['os_auth_url'],
            auth_version="2.0",
            os_options={'region_name': kwargs['os_region']})

        self.service = 'cdn'
        self.authurl = kwargs['os_auth_url']
        self.logger = logger
        self.exec_time = exec_time
        self.zone = kwargs['os_zone']
        self.failure = None
        self.overall_success = True
        self.region = kwargs['os_region']
        self.tenant_name = kwargs['os_tenant_name']

    @monitoring.timeit
    def list_containers(self):
        """

        List all the CDN containers

        """

        try:
            self.success = True
            self.cdn_containers = self.cdn_client.get_account()[1]
            self.logger.warning('Listing CDN Containers')

            for container in self.cdn_containers:
                self.logger.warning(
                    container['name'] + ' ' + container['x-cdn-uri'] +
                    ' ' + container['x-cdn-ssl-uri'])

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Listing CDN containers failed %s", sys.exc_info()[1])

    @monitoring.timeit
    def select_container(self):
        """

        Select a CDN enabled container. Usually this is the container we created.

        """

        try:
            self.success = True
            self.enabled_container = None
            self.container = None
            self.cdn_containers = self.cdn_client.get_account()[1]
            """
            Select the container that was created in the previous step.
            """
            for x in range(len(self.cdn_containers)):
                if self.cdn_containers[x]['name'] == self.container_name:
                    self.enabled_container = x
                    break

            if self.enabled_container is not None:
                self.container = self.cdn_containers[self.enabled_container]
            else:
                raise cdn_exceptions.ClientException("CDN container not found")

            self.logger.warning(
                "The following CDN-enabled container has been selected %s",
                self.container)

        except cdn_exceptions.ClientException:
            self.success, self.overall_success = False, False
            self.failure = "Not found"
            self.logger.error("CDN container not found")

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Selecting a CDN container failed %s", sys.exc_info()[1])

    @monitoring.timeit
    def upload_object(self):
        """

        Create and upload a small object to the container

        """

        try:
            self.success = True
            self.object = 'cdncheckob' + str(time.time())
            contents = 'yeah this is a pretty small object'
            self.swift_client.put_object(
                self.container['name'], self.object, contents)
            self.logger.warning("Created Object %s", self.object)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Uploading object to a CDN container failed %s",
                sys.exc_info()[1])

    @monitoring.timeit
    def check_http_url(self):
        """

        Access the object we created using the CDN http url

        """

        try:
            self.success = True
            uri = self.container['x-cdn-uri'] + '/' + self.object
            self.logger.warning("HTTP URL: %s", uri)

            for x in range(1, 51):
                sleep(10)

                http_client = httplib2.Http(
                    timeout=9, disable_ssl_certificate_validation=True)

                try:
                    response, content = http_client.request(uri, "GET")
                except:
                    continue

                if response['status'] == '200':
                    self.logger.warning("Checking HTTP CDN URL Succeeded")
                    return True

            self.logger.error("Checking HTTP CDN URL Timed Out")
            exit(1)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Checking HTTP CDN URL Failed %s", sys.exc_info()[1])

    @monitoring.timeit
    def check_https_url(self):
        """

        Access the object we created using the CDN https url

        """

        try:
            self.success = True
            uri = self.container['x-cdn-ssl-uri'] + self.object
            self.logger.warning("HTTPS URL: %s", uri)

            for x in range(1, 51):
                sleep(10)

                http_client = httplib2.Http(
                    timeout=9, disable_ssl_certificate_validation=True)
                response, content = http_client.request(uri, "GET")

                if response['status'] == '200':
                    self.logger.warning("Checking HTTPS CDN URL Succeeded")

                    return True

            self.logger.error("Checking HTTPS CDN URL Timed Out")
            exit(1)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Checking HTTPS CDN URL Failed %s", sys.exc_info()[1])

    def delete_object(self):
        """

        Delete the object we created

        """

        try:
            self.success = True
            self.swift_client.delete_object(
                self.container['name'], self.object)
            self.logger.warning("Object %s Deleted", self.object)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Object Deletion Failed  %s", sys.exc_info()[1])

    @monitoring.timeit
    def create_cdn_enabled_container(self):
        """

        Create a CDN enabled container. We use Swift client to do this except
        we use a CDN endpoint

        """

        try:
            self.success = True
            self.container_name = 'cdncheck' + str(time.time())
            self.cdn_client.put_container(self.container_name)
            self.logger.warning(
                "Created New Container %s", self.container_name)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Create CDN Container Failed  %s", sys.exc_info()[1])

    @monitoring.timeit
    def delete_container(self):
        """

        Delete the container we created

        """

        try:
            self.success = True
            self.cdn_containers[self.enabled_container]['cdn_enabled'] = False
            # This would take some time to be propagated
            # We will keep checking until it's disabled.
            self.timer = 0
            while self.cdn_containers[
                    self.enabled_container]['cdn_enabled'] is True:
                if self.timer > 90:
                    break
                sleep(1)
                self.timer = self.timer + 1
                continue

            self.logger.warning("Deleting Container: %s", self.container['name'])
            self.swift_client.delete_container(self.container_name)
            self.cdn_client.delete_container(self.container_name)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Delete CDN Container Failed  %s", sys.exc_info()[1])

    @monitoring.timeit
    def update_metadata(self):
        """

        Update the metadata of the account

        """

        try:
            self.success = True
            headers = {"X-Account-Meta-Temp-User": "******"}
            self.swift_client.post_account(headers)
            self.logger.warning(
                "Posting Metadata to Account succeeded: %s", headers)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Updating MetaData for CDN Container Failed  %s",
                sys.exc_info()[1])

    @monitoring.timeit
    def retrieve_metadata(self):
        """

        Retrieve the metadata of the account

        """

        try:
            self.success = True
            account_info = self.swift_client.head_account()
            self.logger.warning(
                "Getting Account Head succeeded: %s", account_info)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Retrieve MetaData from CDN Container Failed  %s",
                sys.exc_info()[1])

    def run(self):
        """

        This is a driver function that runs all the other methods in the Class

        """

        self.create_cdn_enabled_container()
        self.list_containers()
        self.select_container()

        # Uploading metadata and retrieving it

        self.update_metadata()
        self.retrieve_metadata()

        # First create a test object. Next, test the presence of it, using
        # bot a http and hppts url. Then delete the object.

        self.upload_object()
        self.check_http_url()
        self.check_https_url()

        if hasattr(self, 'object'):
            self.delete_object()

        self.delete_container()

        if self.overall_success is True:
            exit(0)
        else:
            exit(1)
Example #3
0
class SwiftCheck:

    """

    Functional test for Swift - basic workflow as follows:

    List containers
    List objects in those containers
    Update Metadata of the account
    Retrieve Metadata of the account
    Create a Container
    Select that container
    Update Metadata of the container
    Retrieve Metadata of the container
    Create an object in the container
    Retrieve the object in the container
    Update metadata of the object
    Retrieve metadata of the object
    Delete object
    Delete container.

    """

    def __init__(self, logger, exec_time, **kwargs):
        self.swift_client = Connection(
            user=kwargs['os_username'],
            key=kwargs['os_password'],
            tenant_name=kwargs['os_tenant_name'],
            authurl=kwargs['os_auth_url'],
            auth_version="2.0",
            os_options={'region_name': kwargs['os_region']}
        )

        self.service = 'Object Storage'
        self.logger = logger
        self.exec_time = exec_time
        self.zone = kwargs['os_zone']
        self.region = kwargs['os_region']
        self.failure = None
        self.overall_success = True
        self.tenant_name = kwargs['os_tenant_name']

    @monitoring.timeit
    def list_containers(self):
        """
        List all the existing containers
        """

        try:
            self.success = True
            self.containers = self.swift_client.get_account()[1]
            self.logger.warning("Listing Containers:")
            for self.container in self.containers:
                self.logger.warning(self.container['name'])

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Listing Swift containers failed %s", sys.exc_info()[1])

    @monitoring.timeit
    def list_objects(self):
        """
        List all the objects contained in each container
        """

        try:
            self.success = True
            self.containers = self.swift_client.get_account()[1]
            self.logger.warning("Listing Objects:")
            for self.container in self.containers:
                try:
                    for swift_container in self.swift_client.get_container(
                            self.container['name'])[1]:
                        self.logger.warning(
                            self.container['name'] + " " +
                            swift_container['name'])
                except:
                    pass

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Listing objects failed %s", sys.exc_info()[1])

    @monitoring.timeit
    def create_container(self):
        """
        Create a new container
        """

        try:
            self.success = True
            self.container = 'swiftcheck' + str(time.time())
            self.swift_client.put_container(self.container)

            self.logger.warning("Created Container %s", self.container)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Create Container failed %s", sys.exc_info()[1])

    @monitoring.timeit
    def create_object(self):
        """
        Create a new object in the newly created container
        """

        try:
            self.success = True
            self.object = 'swiftcheckob' + str(time.time())
            contents = 'yeah this is a pretty small object'
            self.swift_client.put_object(self.container, self.object, contents)
            self.logger.warning("Created Object %s", self.object)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Create Object Failed %s", sys.exc_info()[1])

    @monitoring.timeit
    def get_container(self):
        """
        Select the newly created container
        """

        try:
            self.success = True
            self.containers = self.swift_client.get_account()[1]
            self.flag = 0

            for container in self.containers:
                if container['name'] == self.container:
                    self.logger.warning(
                        "Getting Container Succeeded: %s", container['name'])
                    self.flag = self.flag + 1
            if self.flag == 0:
                raise cdn_exceptions.ClientException("Container not found")

        except cdn_exceptions.ClientException:
            self.success, self.overall_success = False, False
            self.failure = "Not found"
            self.logger.error("Container not found")

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Selecting a container failed %s", sys.exc_info()[1])

    @monitoring.timeit
    def get_object(self):
        """
        Get the newly created object from the newly created container
        """

        try:
            self.success = True
            object = self.swift_client.get_object(self.container, self.object)
            self.logger.warning("Getting Object Succeded: %s", object)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Getting object failed %s", sys.exc_info()[1])

    @monitoring.timeit
    def retrieve_metadata_object(self):
        """
        Retrieve the metadata of the selected object
        """

        try:
            self.success = True
            object_info = self.swift_client.head_object(
                self.container, self.object)
            self.logger.warning(
                "Getting Object Head succeeded: %s", object_info)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Retrieving Object Head failed %s", sys.exc_info()[1])

    @monitoring.timeit
    def retrieve_metadata_account(self):
        """
        Retrieve the metadata of the account
        """

        try:
            self.success = True
            account_info = self.swift_client.head_account()
            self.logger.warning(
                "Getting Account Head succeeded: %s", account_info)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Retrieving Account Head failed %s", sys.exc_info()[1])

    @monitoring.timeit
    def retrieve_metadata_container(self):
        """
        Retrieve the metadata of the container
        """

        try:
            self.success = True
            container_info = self.swift_client.head_container(self.container)
            self.logger.warning(
                "Getting Container Head succeeded: %s", container_info)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Getting Container Head failed: %s", sys.exc_info()[1])

    @monitoring.timeit
    def update_metadata_account(self):
        """
        Update the metadata of the account
        """

        try:
            self.success = True
            headers = {"X-Account-Meta-Temp-User": "******"}
            self.swift_client.post_account(headers)
            self.logger.warning(
                "Posting Metadata to Account succeeded: %s", headers)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Posting Metadata to Account failed %s", sys.exc_info()[1])

    @monitoring.timeit
    def update_metadata_container(self):
        """
        Update the metadata of the container
        """

        try:
            self.success = True
            headers = {"X-Container-Meta-Temp-User": "******"}
            self.swift_client.post_container(self.container, headers)
            self.logger.warning(
                "Posting Metadata to Container succeeded: %s", headers)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Posting Metadata to Container failed %s", sys.exc_info()[1])

    @monitoring.timeit
    def update_metadata_object(self):
        """
        Update the metadata of the object
        """

        try:
            self.success = True
            headers = {"X-Object-Meta-Temp-User": "******"}
            self.swift_client.post_object(self.container, self.object, headers)
            self.logger.warning(
                "Posting Metadata to Object succeeded: %s", headers)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Posting Metadata to Object failed %s", sys.exc_info()[1])

    @monitoring.timeit
    def delete_object(self):
        """
        Delete the object created earlier in the process flow
        """

        try:
            self.swift_client.delete_object(self.container, self.object)
            self.logger.warning("Object Deleted")

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Object Delete failed %s", sys.exc_info()[1])

    @monitoring.timeit
    def delete_container(self):
        """
        Delete the container that was created earlier in the process flow
        """

        try:
            self.swift_client.delete_container(self.container)
            self.logger.warning("Container %s Deleted", self.container)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error(
                "Container Delete Failed %s", sys.exc_info()[1])

    def run(self):
        """
        The driver method that runs all the steps in the process flow
        """

        self.list_containers()
        self.list_objects()

        self.update_metadata_account()
        self.retrieve_metadata_account()

        self.create_container()
        self.get_container()
        self.update_metadata_container()
        self.retrieve_metadata_container()

        self.create_object()
        self.get_object()
        self.update_metadata_object()
        self.retrieve_metadata_object()

        if hasattr(self, 'object'):
            self.delete_object()

        if hasattr(self, 'container'):
            self.delete_container()

        if self.overall_success is True:
            exit(0)
        else:
            exit(1)
Example #4
0
class Swift:

    def __init__(self, username, password, tenant, auth_url, region):
        self.swift_client = Connection(
            user=username,
            key=password,
            tenant_name=tenant,
            authurl=auth_url,
            auth_version="2.0",
            os_options={'region_name': region}
        )

        # Setup logging
        self.logger = logging.getLogger()
        self.logger.setLevel(logging.WARNING)
    
        # Allow the logger to write all output to stdout too
        self.logger.addHandler(logging.StreamHandler())
  
    def list_containers(self):
        try:
            self.containers = self.swift_client.get_account()[1]
      
            self.logger.warning("Listing Containers")
            for container in self.containers:
                self.logger.warning(container['name'])
    
        except Exception:
            self.logger.error("Listing Containers Failed")
            self.exit(1)

    def list_objects(self):
        try:
            self.logger.warning("Listing Objects")
            for container in self.containers:
                for swift_container in self.swift_client.get_container(container['name'])[1]:
                    self.logger.warning(container['name'] + " " + swift_container['name'])
    
        except Exception as e:
            self.logger.error('Listing Objects Failed, Got exception: %s' % e)
            self.exit(1)

    def create_container(self, name):
        try:
            self.container = name
            self.swift_client.put_container(self.container)
            self.logger.warning("Created Container %s", self.container)

        except Exception:
            self.logger.error("Creating Container Failed")
            self.exit(1)

    def create_object(self, name, contents):
        try:
            self.object = name
            self.swift_client.put_object(self.container, self.object, contents)
            self.logger.warning("Created Object %s", self.object)

        except Exception:
            self.logger.error("Creating Object Failed")
            self.exit(1)

    def get_container(self):
        try:
            self.containers = self.swift_client.get_account()[1]

            for container in self.containers:
                if container['name'] == self.container:
                    self.logger.warning("Getting Container Succeeded")

                    return True

            self.logger.error("Getting Container Failed")
            self.exit(1)

        except Exception as e:
            self.logger.error('Getting Container Failed: Got exception: ' % e)
            self.exit(1)

    def get_object(self):
        try:
            object = self.swift_client.get_object(self.container, self.object)
            self.logger.warning("Object Get: %s", object)

        except Exception as e:
            self.logger.error('Object Get Failed, Got exception: %s' % e)
            self.exit(1)

    def delete_object(self):
        try:
            self.swift_client.delete_object(self.container, self.object)
            self.logger.warning("Object Deleted")

        except Exception as e:
            self.logger.error('Object Deletion Failed: Got exception: ' % e)
      
    def delete_container(self):
        try:
            self.swift_client.delete_container(self.container)
            self.logger.warning("Container Deleted")

        except Exception as e:
            self.logger.error('Container Deletion Failed: Got exception: ' % e)

    def exit(self, value):
        if hasattr(self, 'object'):
            self.delete_object()

        if hasattr(self, 'container'):
            self.delete_container()
    
        exit(value)

    def run(self):
        self.list_containers()
        self.list_objects()

        self.create_container()
        self.create_object()

        self.get_container()
        self.get_object()
    
        self.exit(0)
Example #5
0
env = os.environ

loader = loading.get_plugin_loader('password')
auth = loader.load_from_options(auth_url=env['OS_AUTH_URL'],
                                username=env['OS_USERNAME'],
                                password=env['OS_PASSWORD'],
                                project_name=env['OS_PROJECT_NAME'],
                                project_domain_name=env['OS_USER_DOMAIN_NAME'],
                                project_id=env['OS_PROJECT_ID'],
                                user_domain_name=env['OS_USER_DOMAIN_NAME'])

sess = session.Session(auth=auth)

swift = Connection(session=sess)

resp_headers, containers = swift.get_account()

container_name = 'fabian_data'
container = swift.get_container(container_name)

files = os.listdir('data')
for filename in files:
    file_obj = os.path.join('data/', filename)
    with open(file_obj, 'r') as local:
        #print(local)
        swift.put_object(container_name,
                         file_obj,
                         contents=local,
                         content_type="plain/text")

#print(swift.get_container(container_name))
Example #6
0
class SwiftStore(MutableMapping):
    """Storage class using Openstack Swift Object Store.

    Parameters
    ----------
    container: string
        swift container to use. It is created if it does not already exists
    prefix: string
        sub-directory path with in the container to store data
    storage_options: dict
        authentication information to connect to the swift store.

    Examples
    --------

    >>> import os
    >>> from zarrswift import SwiftStore
    >>> getenv = os.environ.get
    >>> options = {'preauthurl': getenv('OS_STORAGE_URL'),
    ...            'preauthtoken': getenv('OS_AUTH_TOKEN')}
    >>> store = SwiftStore(container="demo", prefix="zarr_demo", storage_options=options)
    >>> root = zarr.group(store=store, overwrite=True)
    >>> z = root.zeros('foo/bar', shape=(10, 10), chunks=(5, 5), dtype='i4')
    >>> z[:] = 42
    """
    def __init__(self, container, prefix="", storage_options=None):
        self.container = container
        self.prefix = normalize_storage_path(prefix)
        self.storage_options = storage_options or {}
        self.conn = Connection(**self.storage_options)
        self._ensure_container()

    def __getstate__(self):
        state = self.__dict__.copy()
        del state["conn"]
        return state

    def __setstate__(self, state):
        self.__dict__.update(state)
        self.conn = Connection(**self.storage_options)

    def __getitem__(self, name):
        name = self._add_prefix(name)
        try:
            resp, content = self.conn.get_object(self.container, name)
        except ClientException:
            raise KeyError("Object {} not found".format(name))
        return content

    def __setitem__(self, name, value):
        name = self._add_prefix(name)
        value = ensure_bytes(value)
        self.conn.put_object(self.container, name, value)

    def __delitem__(self, name):
        name = self._add_prefix(name)
        try:
            self.conn.delete_object(self.container, name)
        except ClientException:
            raise KeyError("Object {} not found".format(name))

    def __eq__(self, other):
        return (isinstance(other, SwiftStore)
                and self.container == other.container
                and self.prefix == other.prefix)

    def __contains__(self, name):
        return name in self.keys()

    def __iter__(self):
        contents = self._list_container(strip_prefix=True)
        for entry in contents:
            yield entry["name"]

    def __len__(self):
        return len(self.keys())

    def _ensure_container(self):
        _, contents = self.conn.get_account()
        listings = [item["name"] for item in contents]
        if self.container not in listings:
            self.conn.put_container(self.container)

    def _add_prefix(self, path):
        path = normalize_storage_path(path)
        path = "/".join([self.prefix, path])
        return normalize_storage_path(path)

    def _list_container(self,
                        path=None,
                        delimiter=None,
                        strip_prefix=False,
                        treat_path_as_dir=True):
        path = self.prefix if path is None else self._add_prefix(path)
        if path and treat_path_as_dir:
            path += "/"
        _, contents = self.conn.get_container(self.container,
                                              prefix=path,
                                              delimiter=delimiter)
        if strip_prefix:
            prefix_size = len(path)
            for entry in contents:
                name = entry.get('name', entry.get('subdir', ''))
                entry["name"] = normalize_storage_path(name[prefix_size:])
        for entry in contents:
            entry["bytes"] = entry.get("bytes", 0)
        return contents

    def keys(self):
        return list(self.__iter__())

    def listdir(self, path=None):
        contents = self._list_container(path, delimiter="/", strip_prefix=True)
        listings = [entry["name"] for entry in contents]
        return sorted(listings)

    def getsize(self, path=None):
        contents = self._list_container(path,
                                        strip_prefix=True,
                                        treat_path_as_dir=False)
        contents = [entry for entry in contents if "/" not in entry["name"]]
        return sum([entry["bytes"] for entry in contents])

    def rmdir(self, path=None):
        contents = self._list_container(path)
        for entry in contents:
            self.conn.delete_object(self.container, entry["name"])

    def clear(self):
        self.rmdir()

    @property
    def url(self):
        _url = '/'.join([self.conn.url, self.container, self.prefix])
        if not self.prefix:
            _url = _url.rstrip('/')
        return _url
Example #7
0
class ConnStorage(object):
    '''
	classdocs
	'''
    def __init__(self, conf):
        '''
		根据配置文件初始化连接Swift云存储的客户端,包括认证系统和存储系统。
		'''
        self.conf = conf
        colon = conf['storuser'].find(":")
        if colon > 0:
            self.user = conf['storuser'][:colon]
            self.tenant = conf['storuser'][colon + 1:]
        else:
            self.user = self.tenant = conf['storuser']
        print self.user, self.tenant
        self.pawd = conf['storpass']
        self.authurl = "http://" + conf['storip'] + ":" + conf[
            'storport'] + "/v2.0/"

        #		self.keystone = client.Client(username="******", password="******",
        #									tenant_name="admin", auth_url=self.authurl)
        self.swift = Connection(authurl=self.authurl,
                                user=self.user,
                                key=self.pawd,
                                auth_version="2",
                                tenant_name=self.tenant,
                                insecure=True)


#	def getTenantList(self):
#		items = self.keystone.tenants.list()
#		tenantlist=[]
#		for item in items:
#			tenantlist.append(item.name)
#		return tenantlist
#
#	def getUserList(self):
#		items = self.keystone.users.list()
#		userlist = []
#		for item in items:
#			userlist.append(item.name)
#		return userlist

#	def addTenant(self):
#		tenantlist = self.getTenantList()
#		if self.tenant not in tenantlist:
#			self.keystone.tenants.create(tenant_name = self.tenant)
#		else:
#			print "The tenant \"%s\" already existed!" % self.tenant
#
#	def addUser(self):
#		tenantlist = self.keystone.tenants.list()
#		my_tenant = [x for x in tenantlist if x.name == self.tenant][0]
#
#		userlist = self.getUserList()
#		if self.user not in userlist:
#			self.keystone.users.create(name = self.tenant, password = self.pawd,
#									tenant_id = my_tenant.id)
#		else:
#			print "The user \"%s\" already existed under tenant \"%s\"!" % (self.tenant, self.user)

    def getContainerList(self):
        items = self.swift.get_account()[1]
        conlist = []
        for item in items:
            conlist.append(item.get('name', item.get('hjc')))

        print conlist
        return conlist

    def getObjectList(self, conName):
        items = self.swift.get_container(container=conName)[1]
        objlist = []
        for item in items:
            objlist.append(item.get('name', item.get('hjc')))

        return objlist

    def upload_file(self, container, objpath):
        conlist = self.getContainerList()
        if container not in conlist:
            try:
                self.swift.put_container(container)
            except ClientException, err:
                msg = ' '.join(
                    str(x) for x in (err.http_status, err.http_reason))
                if err.http_response_content:
                    if msg:
                        msg += ': '
                    msg += err.http_response_content[:60]
                print 'Error trying to create container %r: %s' % (container,
                                                                   msg)
            except Exception, err:
                print 'Error trying to create container %r: %s' % (container,
                                                                   err)
Example #8
0
class PurgeCheck:
    """
        Description - Purge left over elements created by each service.
                      Service is selected and then specific deletes for
                      that service are executed.
        Basic workflow

        if cdn
            delete_cdn_containers
        if cinder
            delete_snapshots
            delete_volume
        if domains
            delete_domains
        if keystone
            pass
        if libra
            delete_lb
        if neutron
            delete_floating
            delete_port
            delete_router
            delete_subnet
            delete_network
        if nova
            delete_instance
            delete_floating
            delete_keypair
        if swift
            delete_swift_containers
        if trove
            delete_db
    """

    def __init__(self, logger, exec_time, **kwargs):
        self.neutron_client = neutron_client.Client(
            username=kwargs['os_username'],
            password=kwargs['os_password'],
            tenant_name=kwargs['os_tenant_name'],
            auth_url=kwargs['os_auth_url'],
            region_name=kwargs['os_region']
        )
        self.nova_client = nova_client.Client(
            kwargs['os_username'],
            kwargs['os_password'],
            kwargs['os_tenant_name'],
            kwargs['os_auth_url'],
            region_name=kwargs['os_region']
        )
        self.cinder_client = cinder_client.Client(
            kwargs['os_username'],
            kwargs['os_password'],
            kwargs['os_tenant_name'],
            kwargs['os_auth_url'],
            region_name=kwargs['os_region'],
            service_type="volume"
        )
        self.client = client.Client(
            kwargs['os_username'],
            kwargs['os_password'],
            kwargs['os_tenant_name'],
            kwargs['os_auth_url'],
            region_name=kwargs['os_region'],
        )
        self.keystone_client = keystone_client.Client(
            username=kwargs['os_username'],
            password=kwargs['os_password'],
            tenant_name=kwargs['os_tenant_name'],
            auth_url=kwargs['os_auth_url']
        )

        self.designate_client = Designate(
            auth_url=kwargs['os_auth_url'],
            username=kwargs['os_username'],
            password=kwargs['os_password'],
            tenant_name=kwargs['os_tenant_name'],
            region_name=kwargs['os_region'],
            service_type='hpext:dns'
        )

        self.swift_cdn_client = Connection(
            user=kwargs['os_username'],
            key=kwargs['os_password'],
            tenant_name=kwargs['os_tenant_name'],
            authurl=kwargs['os_auth_url'],
            auth_version="2.0",
            os_options={'region_name': kwargs['os_region'],
                        'service_type': 'hpext:cdn'}
        )

        self.swift_client = Connection(
            user=kwargs['os_username'],
            key=kwargs['os_password'],
            tenant_name=kwargs['os_tenant_name'],
            authurl=kwargs['os_auth_url'],
            auth_version="2.0",
            os_options={'region_name': kwargs['os_region']}
        )

        #self.cdn_client = cdn.Client(
        #    self.token, self.tenant_id, kwargs['os_region'], self.END_POINTS
        #)

        self.region = str(kwargs['os_region'])
        self.container = None
        self.cdn_object = None

        self.logger = logger
        self.exec_time = exec_time
        self.success = True
        self.overall_success = True
        self.purge_service = kwargs['os_purge_service']
        self.service = 'Purge Service'
        self.failure = None
        self.tenant_name = kwargs['os_tenant_name']

    @monitoring.timeit
    def delete_keypair(self):
        """
        Description - Delete all keypairs where OSfunctest is part of the name
        """
        try:
            self.logger.warning('Delete Keypairs:')
            for kp in self.nova_client.keypairs.list():
                if 'OSfuncTest' in kp.name:
                    self.keypair = self.nova_client.keypairs.delete(kp.name)
                    self.success = True
        except nova_exceptions.NotFound as e:
            self.success, self.overall_success = False, True
            self.failure = e
            self.logger.error("<*>404 keypairs not found delete_keypair %s", e)
        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error("<*>delete_keypair Failed %s", e)

    @monitoring.timeit
    def delete_floating(self):
        """
        Description - Delete all floating IPs where floatingip['port_id'] is
                        none and floatingip['fixed_ip_address'] is none
        """
        try:
            floatingips = self.neutron_client.list_floatingips()['floatingips']
            self.success = True
            self.logger.warning('Delete Floating IP:')
            for floatingip in floatingips:
                if floatingip['port_id'] is None:
                    if floatingip['fixed_ip_address'] is None:
                        floating_ips = self.neutron_client.delete_floatingip(
                            floatingip['id'])
                        self.logger.warning(
                            'Delete ' + floatingip['id'])

        except Exception as e:
            self.logger.error("<*>delete_floating Failed %s", e)
            self.success, self.overall_success = False, False
            self.failure = e

    @monitoring.timeit
    def delete_network(self):
        """
        Description - Delete all networks where network['name'] is new_network
                        or contains 'neutroncheck'
        """
        try:
            networks = self.neutron_client.list_networks()['networks']
            self.success = True
            self.logger.warning('Deleting Networks:')
            for network in networks:
                try:
                    if network['name'] == 'new_network' or \
                            'neutroncheck' in network['name']:
                        self.neutron_client.delete_network(network['id'])
                        self.logger.warning(
                            'Delete ' + network['id'] + " " + network['name'])
                    else:
                        self.logger.warning("Did not delete %s", network['id'])
                except Exception as e:
                    self.logger.warning("Did not delete %s", network['id'])
        except Exception as e:
            self.logger.error("<*>delete_network Failed %s", e)
            self.success, self.overall_success = False, False
            self.failure = e

    @monitoring.timeit
    def delete_port(self):
        """
        Description - Delete all ports where port['name'] contains
                        'neutroncheck'
        """
        try:
            ports = self.neutron_client.list_ports()['ports']
            self.logger.warning('Deleting Ports:')
            self.success = True
            for port in ports:
                try:
                    if 'neutroncheck' in port['name']:
                        self.neutron_client.delete_port(port['id'])
                        self.logger.warning(
                            'Deleting ' + port['id'] + " " + port['name'])
                    else:
                        self.logger.warning("Did not delete " + port['id'])
                except:
                    self.logger.warning("Did not delete %s", port['id'])
        except Exception as e:
            self.logger.error("<*>delete_port Failed %s", e)
            self.success, self.overall_success = False, False
            self.failure = e

    @monitoring.timeit
    def delete_router(self):
        """
        Description - Delete all routers where router['name'] contains
                        'neutroncheck'
        """
        try:
            routers = self.neutron_client.list_routers()['routers']
            self.success = True
            self.logger.warning('Deleting Routers:')
            for router in routers:
                try:
                    if 'neutroncheck' in router['name']:
                        self.neutron_client.delete_router(router['id'])
                        self.logger.warning(
                            'Deleting ' + router['id'] + " " + router['name'])
                    else:
                        self.logger.warning("Did not delete %s", router['id'])
                except:
                    self.logger.warning("Did not delete %s", router['id'])
        except Exception as e:
            self.logger.error("<*>delete_router Failed %s", e)
            self.success, self.overall_success = False, False
            self.failure = e

    @monitoring.timeit
    def delete_subnet(self):
        """
        Description - Delete all subnets where subnet['name'] contains
                        'neutroncheck'
        """
        try:
            subnets = self.neutron_client.list_subnets()['subnets']
            self.success = True
            self.logger.warning('Deleting Subnets:')
            for subnet in subnets:
                try:
                    if 'neutroncheck' in subnet['name']:
                        self.neutron_client.delete_subnet(subnet['id'])
                        self.logger.warning(
                            'Delete ' + subnet['id'] + " " + subnet['name'])
                    else:
                        self.logger.warning("Did not delete %s", subnet['id'])
                except:
                    self.logger.warning("Did not delete %s", subnet['id'])
        except Exception as e:
            self.logger.error("<*>list_subnet Failed %s", e)
            self.success, self.overall_success = False, False
            self.failure = e

    @monitoring.timeit
    def delete_volume(self):
        """
        Description - Delete all volumes where volume.display_name contains
                        'cinder'
        """
        volumes = self.cinder_client.volumes.list()
        try:
            self.logger.warning('Deleting Volumes:')
            for volume in volumes:
                self.success = True
                if 'cinder' in volume.display_name:
                    if self.cinder_client.volumes.get(volume.id).status\
                            == 'available':
                        try:
                            volume.delete()
                            self.logger.warning('Deleting unused volume: %s' %
                                                volume.id)
                        except Exception as e:
                            self.logger.error('Unable to delete volume: {}'
                                .format(e))
                    else:
                        self.logger.warning('Did not delete ' + volume.id)
        except cinder_exceptions.NotFound:
            self.logger.error("No Volumes found to delete")
            self.success, self.overall_success = False, True
            self.failure = "Not Found"
        except Exception as e:
            self.logger.warning(
                'Caught exception trying to delete old volumes: %s' % e)
            self.success, self.overall_success = False, False
            self.failure = e

    @monitoring.timeit
    def delete_snapshots(self):
        """
        Description - Delete all snapshots
        """

        try:
            snapshots = self.cinder_client.volume_snapshots.list()
            self.success = True
            self.logger.warning("deleting snapshots")
            for snapshot in snapshots:
                try:
                    snapshot.delete()
                    self.logger.warning("Deleting snapshot %s", snapshot.id)
                except Exception as e:
                    self.logger.error("Delete snapshot failed %s", e)
        except cinder_exceptions.NotFound:
            self.logger.error("No Snapshots found")
            self.success, self.overall_success = False, True
            self.failure = "Not found"
        except Exception as e:
            self.logger.error("Deleting Snapshots Failed")
            self.success, self.overall_success = False, False
            self.failure = e

    @monitoring.timeit
    def delete_instance(self):
        """
        Description - Delete all instances where instance.name contains
                        'novacheck'
        """
        try:
            instances = self.nova_client.servers.list()
            self.success = True
            self.logger.warning("Deleting instances")
            for instance in instances:
                if 'novacheck' in instance.name:
                    instance.delete()
                    self.logger.warning("delete %s", instance.id)
                else:
                    self.logger.warning("did not delete " + instance.id)
        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error("<*>delete_instance %s", e)

    @monitoring.timeit
    def delete_db(self):
        """
        Description - Delete all databases where instance.name contains
                        'DBaas' and the instance.status is active
        """
        try:
            instances = self.client.instances.list()
            self.logger.warning('Delete db instances')
            self.success = True
            for instance in instances:
                if instance.status == "ACTIVE":
                    if 'DBaaS' in instance.name:
                        try:
                            instance.delete()
                            self.logger.warning(
                                'delete ' + instance.id + ' ' + str(instance.name))
                        except Exception as e:
                            self.logger.error('could not delete %s', instance.name)
                    else:
                        self.logger.warning('did not delete %s', instance.name)
                else:
                    self.logger.warning('Not active %s', instance.name)
        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.warning('Error Deleting Instance %s', e)

    @monitoring.timeit
    def delete_lb(self):
        """
        Description - Delete all loadbalancers where name equals TestLB
        """
        name = "TestLB"
        try:
            self.logger.warning('Delete Load Balancers:')
            self.success = True
            proc = subprocess.Popen(['libra',
                                     '--insecure',
                                     '--os-region-name',
                                     self.region,
                                     'list'], stdout=PIPE)
            proc.wait()
            outs, err = proc.communicate()
            sum_output = ''
            for lists in outs:
                sum_output = sum_output + lists
                if lists == '\n':
                    sum_output = ''
                if name in sum_output:
                    sum_split = sum_output.split()
                    proc = subprocess.Popen(['libra',
                                             '--insecure',
                                             '--os-region-name',
                                             self.region,
                                             'delete', sum_split[1]])
                    sum_output = ''
                    proc.wait()
                    if proc.returncode == 0:
                        self.logger.warning('deleting %s', sum_split[1])
                    else:
                        self.failure = "Return code " + str(proc.returncode)
                        self.logger.error("did not delete lb return code %s",
                                          proc.returncode)
        except Exception as e:
            self.success, self.overall_success = False, True
            self.failure = e
            self.logger.error("<*>delete_lb Failed %s", e)

    @monitoring.timeit
    def delete_cdn_containers(self):
        """
        Description - Delete all containers where name starts with
                        'cdncheck' and all objects in that container
        """
        try:
            self.success = True
            self.cdn_containers = self.cdn_client.get_account()[1]

            if len(self.cdn_containers) == 0:
                self.logger.warning(
                    'No CDN containers to clean up')
                return

            self.cdn_container_names = []
            for i in self.cdn_containers:
                if str(i['name']).startswith('cdncheck'):
                    self.cdn_container_names.append(str(i['name']))

            if len(self.cdn_container_names) == 0:
                self.logger.warning(
                    'No CDN containers (cdncheck string) to delete')
                return

            for self.container_name in self.cdn_container_names:

                try:
                    self.objects = self.swift_client.get_container(
                        self.container_name)[1]
                except Exception:
                    self.logger.warning(
                        "Couldn't retrieve objects for %s", self.container_name)
                    self.logger.warning("Deleting the container directly")
                    self.cdn_client.delete_container(self.container_name)
                    continue

                if len(self.objects) == 0:
                    self.logger.warning(
                        'No objects found for %s', self.container_name)
                    self.logger.warning(
                        'Deleting CDN container %s', self.container_name)
                    self.swift_client.delete_container(self.container_name)
                    self.cdn_client.delete_container(self.container_name)
                    continue

                self.object_names = []
                for i in self.swift_client.get_container(self.container_name)[1]:
                    self.object_names.append(str(i['name']))

                self.logger.warning(
                    'Deleting objects for %s', self.container_name)

                for i in self.object_names:
                    self.logger.warning('    Deleting object %s', i)
                    self.swift_client.delete_object(self.container_name, i)

                self.logger.warning(
                    'Deleting CDN container %s', self.container_name)
                self.swift_client.delete_container(self.container_name)
                self.cdn_client.delete_container(self.container_name)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error("<*>delete_cdn_containers Failed %s", e)

    @monitoring.timeit
    def delete_swift_containers(self):
        """
        Description - Delete all containers where name starts with
                        'swiftcheck' and all objects in that container
        """
        try:
            self.success = True
            self.swift_containers = self.swift_client.get_account()[1]
            if len(self.swift_containers) == 0:
                self.logger.warning('No Swift containers to delete')
                return

            self.swift_container_names = []
            for i in self.swift_containers:
                if i['name'].startswith('swiftcheck'):
                    self.swift_container_names.append(str(i['name']))

            for self.container_name in self.swift_container_names:
                self.logger.warning('Container: %s', self.container_name)
                self.objects = self.swift_client.get_container(
                    self.container_name)[1]
                if len(self.objects) == 0:
                    self.logger.warning(
                        'No objects found for %s', self.container_name)
                    self.logger.warning(
                        'Deleting container: %s', self.container_name)
                    self.swift_client.delete_container(self.container_name)
                    continue

                self.object_names = []
                for i in self.swift_client.get_container(self.container_name)[1]:
                    self.object_names.append(str(i['name']))

                self.logger.warning(
                    'Deleting objects for %s', self.container_name)

                for i in self.object_names:
                    self.logger.warning('   Deleting %s', i)
                    self.swift_client.delete_object(self.container_name, i)

                self.logger.warning(
                    'Deleting container: %s', self.container_name)
                self.swift_client.delete_container(self.container_name)

        except Exception as e:
            self.success, self.overall_success = False, False
            self.failure = e
            self.logger.error("<*>delete_swift_containers Failed %s", e)

    def delete_domains(self):
        """
        Description - Delete all domains where domain.name contains
                        'OSfunctional'
        """
        try:
            self.logger.warning("Delete Domains")
            for domain in self.designate_client.domains.list():
                if 'OSfunctional' in domain.name:
                    self.logger.warning('Deleting Domain {}'.format(domain.name))
                    self.designate_client.domains.delete(domain.id)
        except Exception as e:
            self.logger.error('<*>Domain Deletion Failed: {}'.format(e))

    def run(self):
        if self.purge_service == "cdn":
            self.delete_cdn_containers()
        elif self.purge_service == "cinder":
            self.delete_snapshots()
            self.delete_volume()
        elif self.purge_service == "domains":
            self.delete_domains()
        elif self.purge_service == "keystone":
            pass
        elif self.purge_service == "libra":
            self.delete_lb()
        elif self.purge_service == "neutron":
            self.delete_floating()
            self.delete_port()
            self.delete_router()
            self.delete_subnet()
            self.delete_network()
        elif self.purge_service == "nova":
            self.delete_instance()
            self.delete_floating()
            self.delete_keypair()
        elif self.purge_service == "swift":
            self.delete_swift_containers()
        elif self.purge_service == "trove":
            self.delete_db()
        else:
            self.logger.error("Invalid service entered")

        if self.overall_success is True:
            exit(0)
        else:
            exit(1)
Created on Tue Oct 21 13:50:28 2014

@author: Imperssonator
"""

from swiftclient import Connection

authURL = 'https://swift.storm.gatech.edu/auth/v1.0'
mainURL = 'https://[email protected]'
user = '******'
PW = 'SmallBowel=20ft'
container = 'img'

swift = Connection(authurl=authURL, user=user, key=PW, insecure=True)

(headers, containers) = swift.get_account()

print(headers)
print(containers)

cont1 = swift.get_container(container)
#print(cont1)

files = cont1[1]

for ii in files:
    filename = ii['name']
    print(filename)
    # now you can iterate any number of operations over your cloud-stored images
    # get the image, do analysis, then save the results of the analysis back on swiftstack
Example #10
0
## SwiftService interface

# SwiftService API will actually use your environment auth variables if they are not specified in the script,
# but here is how to specify them explicitly:

options = {
    "auth_version": '2.0',
    "os_username": username,
    "os_password": password,
    "os_tenant_name": project_name,
    "os_auth_url": auth_url,
}

swift_service = SwiftService(options=options)
result = swift_service.list()
for item in result:
    for container in item['listing']:
        print container

## Connection interface
swift_conn = Connection(authurl=auth_url,
                        user=username,
                        key=password,
                        tenant_name=project_name,
                        auth_version=2)

headers, containers = swift_conn.get_account()

for con in containers:
    print con
Example #11
0
class ConnStorage(object):
	'''
	classdocs
	'''

	def __init__(self, conf):
		'''
		根据配置文件初始化连接Swift云存储的客户端,包括认证系统和存储系统。
		'''
		self.conf = conf
		colon = conf['storuser'].find(":")
		if colon > 0 :
			self.user = conf['storuser'][:colon]
			self.tenant = conf['storuser'][colon+1:] 
		else:
			self.user = self.tenant = conf['storuser']
		print self.user, self.tenant
		self.pawd = conf['storpass']
		self.authurl = "http://" + conf['storip'] + ":" + conf['storport'] + "/v2.0/"
		
#		self.keystone = client.Client(username="******", password="******",
#									tenant_name="admin", auth_url=self.authurl)        
		self.swift = Connection(authurl=self.authurl, user=self.user, key=self.pawd, 
								auth_version="2", tenant_name=self.tenant, insecure = True)
		
#	def getTenantList(self):
#		items = self.keystone.tenants.list()
#		tenantlist=[]
#		for item in items:
#			tenantlist.append(item.name)            
#		return tenantlist
#	
#	def getUserList(self):
#		items = self.keystone.users.list()
#		userlist = []
#		for item in items:
#			userlist.append(item.name)
#		return userlist
	
#	def addTenant(self):
#		tenantlist = self.getTenantList()
#		if self.tenant not in tenantlist:
#			self.keystone.tenants.create(tenant_name = self.tenant)
#		else:
#			print "The tenant \"%s\" already existed!" % self.tenant
#	
#	def addUser(self):
#		tenantlist = self.keystone.tenants.list()
#		my_tenant = [x for x in tenantlist if x.name == self.tenant][0]
#		
#		userlist = self.getUserList()
#		if self.user not in userlist:
#			self.keystone.users.create(name = self.tenant, password = self.pawd, 
#									tenant_id = my_tenant.id)
#		else:
#			print "The user \"%s\" already existed under tenant \"%s\"!" % (self.tenant, self.user) 
	
	def getContainerList(self):
		items = self.swift.get_account()[1]
		conlist=[]
		for item in items:
			conlist.append(item.get('name', item.get('hjc')))
			
		print conlist
		return conlist
	
	def getObjectList(self, conName):
		items = self.swift.get_container(container=conName)[1]
		objlist = []
		for item in items:
			objlist.append(item.get('name', item.get('hjc')))
		
		return objlist
	
	def upload_file(self, container, objpath):
		conlist = self.getContainerList()
		if container not in conlist:
			try:
				self.swift.put_container(container)
			except ClientException, err:
				msg = ' '.join(str(x) for x in (err.http_status, err.http_reason))
				if err.http_response_content:
					if msg:
						msg += ': '
					msg += err.http_response_content[:60]
				print 'Error trying to create container %r: %s' % (container, msg)
			except Exception, err:
				print 'Error trying to create container %r: %s' % (container, err)