def _configure_manager(self):
     """
     Creates the Manager instances to handle monitoring.
     """
     self._entity_manager = CloudMonitorEntityManager(self,
             uri_base="entities", resource_class=CloudMonitorEntity,
             response_key=None, plural_response_key=None)
     self._check_type_manager = BaseManager(self,
             uri_base="check_types", resource_class=CloudMonitorCheckType,
             response_key=None, plural_response_key=None)
     self._monitoring_zone_manager = BaseManager(self,
             uri_base="monitoring_zones", resource_class=CloudMonitorZone,
             response_key=None, plural_response_key=None)
     self._notification_manager = CloudMonitorNotificationManager(self,
             uri_base="notifications",
             resource_class=CloudMonitorNotification,
             response_key=None, plural_response_key=None)
     self._notification_plan_manager = CloudMonitorNotificationPlanManager(
             self, uri_base="notification_plans",
             resource_class=CloudMonitorNotificationPlan,
             response_key=None, plural_response_key=None)
     self._changelog_manager = CloudMonitorChangelogManager(self,
             uri_base="changelogs/alarms", resource_class=None,
             response_key=None, plural_response_key=None)
     self._overview_manager = CloudMonitorOverviewManager(self,
             uri_base="views/overview", resource_class=None,
             response_key="value", plural_response_key=None)

 def __init__(self, *args, **kwargs):
     super(CloudDatabaseInstance, self).__init__(*args, **kwargs)
     self._database_manager = BaseManager(self.manager.api,
             resource_class=CloudDatabaseDatabase, response_key="database",
             uri_base="instances/%s/databases" % self.id)
     self._user_manager = BaseManager(self.manager.api,
             resource_class=CloudDatabaseUser, response_key="user",
             uri_base="instances/%s/users" % self.id)

 def _configure_manager(self):
     """
     Create the manager to handle the instances, and also another
     to handle flavors.
     """
     self._manager = BaseManager(self, resource_class=CloudBlockStorageVolume,
            response_key="volume", uri_base="volumes")
     self._types_manager = BaseManager(self, resource_class=CloudBlockStorageVolumeType,
            response_key="volume_type", uri_base="types")
     self._snaps_manager = BaseManager(self, resource_class=CloudBlockStorageSnapshot,
            response_key="snapshot", uri_base="snapshots")

 def __init__(self, *args, **kwargs):
     super(CloudDatabaseInstance, self).__init__(*args, **kwargs)
     self._database_manager = BaseManager(self.manager.api,
             resource_class=CloudDatabaseDatabase, response_key="database",
             uri_base="instances/%s/databases" % self.id)
     self._user_manager = BaseManager(self.manager.api,
             resource_class=CloudDatabaseUser, response_key="user",
             uri_base="instances/%s/users" % self.id)
     # Remove the lazy load
     if not self.loaded:
         self.get()
         # Make the volume into an accessible object instead of a dict
         self.volume = CloudDatabaseVolume(self, self.volume)

 def _configure_manager(self):
     """
     Creates a manager to handle the instances, and another
     to handle flavors.
     """
     self._manager = BaseManager(self, resource_class=CloudDatabaseInstance,
            response_key="instance", uri_base="instances")
     self._flavor_manager = BaseManager(self,
             resource_class=CloudDatabaseFlavor, response_key="flavor",
             uri_base="flavors")

 def _configure_manager(self):
     """
     Creates the Manager instance to handle networks.
     """
     self._entity_manager = CloudMonitorEntityManager(self,
             uri_base="entities", resource_class=CloudMonitorEntity,
             response_key=None, plural_response_key=None)
     self._check_type_manager = BaseManager(self,
             uri_base="check_types", resource_class=CloudMonitorCheckType,
             response_key=None, plural_response_key=None)
     self._monitoring_zone_manager = BaseManager(self,
             uri_base="monitoring_zones", resource_class=CloudMonitorZone,
             response_key=None, plural_response_key=None)
     self._notification_manager = CloudMonitorNotificationManager(self,
             uri_base="notifications",
             resource_class=CloudMonitorNotification,
             response_key=None, plural_response_key=None)
     self._notification_plan_manager = CloudMonitorNotificationPlanManager(
             self, uri_base="notification_plans",
             resource_class=CloudMonitorNotificationPlan,
             response_key=None, plural_response_key=None)

 def _configure_manager(self):
     """Create a manager to handle RackConnect operations."""
     self._network_manager = BaseManager(
         self, resource_class=Network, uri_base="cloud_networks",
     )
     self._load_balancer_pool_manager = LoadBalancerPoolManager(
         self, resource_class=LoadBalancerPool,
         uri_base="load_balancer_pools"
     )
     self._public_ip_manager = PublicIPManager(
         self, resource_class=PublicIP, uri_base="public_ips",
     )

 def __init__(self, *args, **kwargs):
     super(CloudBlockStorageVolume, self).__init__(*args, **kwargs)
     try:
         self._nova_volumes = pyrax.cloudservers.volumes
     except AttributeError:
         # This will happen in unit testing, where the full pyrax
         # namespace is not exposed. In that situation, there is
         # no need for the reference anyway
         pass
     self._snapshot_manager = BaseManager(self.manager.api,
             resource_class=CloudBlockStorageSnapshot,
             response_key="snapshot", uri_base="snapshots")

class CloudBlockStorageVolume(BaseResource):
    """
    This class represents a Block Storage volume.
    """
    def __init__(self, *args, **kwargs):
        super(CloudBlockStorageVolume, self).__init__(*args, **kwargs)
        try:
            self._nova_volumes = pyrax.cloudservers.volumes
        except AttributeError:
            # This will happen in unit testing, where the full pyrax
            # namespace is not exposed. In that situation, there is
            # no need for the reference anyway
            pass
        self._snapshot_manager = BaseManager(self.manager.api,
                resource_class=CloudBlockStorageSnapshot,
                response_key="snapshot", uri_base="snapshots")


    def attach_to_instance(self, instance, mountpoint):
        """
        Attaches this volume to the cloud server instance at the
        specified mountpoint. This requires a call to the cloud servers
        API; it cannot be done directly.
        """
        instance_id = _resolve_id(instance)
        resp = self._nova_volumes.create_server_volume(instance_id,
                self.id, mountpoint)
        # The response should be a volume reference to this volume.
        return resp.id == self.id


    def detach(self):
        """
        Detaches this volume from any device it may be attached to. If it
        is not attached, nothing happens.
        """
        attachments = self.attachments
        if not attachments:
            # Not attached; no error needed, just return
            return
        # A volume can only be attached to one device at a time, but for some
        # reason this is a list instead of a singular value
        att = attachments[0]
        instance_id = att["server_id"]
        attachment_id = att["id"]
        self._nova_volumes.delete_server_volume(instance_id, attachment_id)


    def delete(self, force=False):
        """
        Volumes cannot be deleted if either a) they are attached to a device, or
        b) they have any snapshots. This method overrides the base delete()
        method to both better handle these failures, and also to offer a 'force'
        option. When 'force' is True, the volume is detached, and any dependent
        snapshots are deleted before calling the volume's delete.
        """
        if force:
            self.detach()
            self.delete_all_snapshots()
        try:
            super(CloudBlockStorageVolume, self).delete()
        except exc.VolumeNotAvailable:
            # Notify the user? Record it somewhere?
            # For now, just re-raise
            raise


    def create_snapshot(self, name=None, description=None, force=False):
        """
        Creates a snapshot of this volume, with an optional name and
        description.

        Normally snapshots will not happen if the volume is attached. To
        override this default behavior, pass force=True.
        """
        name = name or ""
        description = description or ""
        # Note that passing in non-None values is required for the _create_body
        # method to distinguish between this and the request to create and
        # instance.
        try:
            snap = self._snapshot_manager.create(volume=self, name=name,
                    description=description, force=force)
        except exc.BadRequest as e:
            msg = str(e)
            if "Invalid volume: must be available" in msg:
                # The volume for the snapshot was attached.
                raise exc.VolumeNotAvailable("Cannot create a snapshot from an "
                        "attached volume. Detach the volume before trying again, "
                        "or pass 'force=True' to the create_snapshot() call.")
            else:
                # Some other error
                raise
        except exc.ClientException as e:
            if e.code == 409:
                if "Request conflicts with in-progress" in str(e):
                    raise exc.VolumeNotAvailable("The volume is current "
                            "creating a snapshot. You must wait until that "
                            "completes before attempting to create an "
                            "additional snapshot.")
#.........这里部分代码省略.........

class CloudDatabaseInstance(BaseResource):
    """
    This class represents a MySQL instance in the cloud. 
    """
    def __init__(self, *args, **kwargs):
        super(CloudDatabaseInstance, self).__init__(*args, **kwargs)
        self._database_manager = BaseManager(self.manager.api,
                resource_class=CloudDatabaseDatabase, response_key="database",
                uri_base="instances/%s/databases" % self.id)
        self._user_manager = BaseManager(self.manager.api,
                resource_class=CloudDatabaseUser, response_key="user",
                uri_base="instances/%s/users" % self.id)


    def list_databases(self):
        """Returns a list of the names of all databases for this instance."""
        return self._database_manager.list()


    def list_users(self):
        """Returns a list of the names of all users for this instance."""
        return self._user_manager.list()


    def get_database(self, name):
        """
        Finds the database in this instance with the specified name, and
        returns a CloudDatabaseDatabase object. If no match is found, a
        NoSuchDatabase exception is raised.
        """
        try:
            return [db for db in self.list_databases()
                    if db.name == name][0]
        except IndexError:
            raise exc.NoSuchDatabase("No database by the name '%s' exists." % name)


    def get_user(self, name):
        """
        Finds the user in this instance with the specified name, and
        returns a CloudDatabaseUser object. If no match is found, a
        NoSuchDatabaseUser exception is raised.
        """
        try:
            return [user for user in self.list_users()
                    if user.name == name][0]
        except IndexError:
            raise exc.NoSuchDatabaseUser("No user by the name '%s' exists." % name)


    def create_database(self, name, character_set=None, collate=None):
        """
        Creates a database with the specified name. If a database with
        that name already exists, a BadRequest (400) exception will
        be raised.
        """
        if character_set is None:
            character_set = "utf8"
        if collate is None:
            collate = "utf8_general_ci"
        # Note that passing in non-None values is required for the _create_body
        # method to distinguish between this and the request to create and instance.
        self._database_manager.create(name=name, character_set=character_set,
                collate=collate, return_none=True)
        # Since the API doesn't return the info for creating the database object, we
        # have to do it manually.
        return self._database_manager.find(name=name)


    def create_user(self, name, password, database_names):
        """
        Creates a user with the specified name and password, and gives that
        user access to the specified database(s).

        If a user with
        that name already exists, a BadRequest (400) exception will
        be raised.
        """
        if not isinstance(database_names, list):
            database_names = [database_names]
        # The API only accepts names, not DB objects
        database_names = [db if isinstance(db, basestring) else db.name
                for db in database_names]
        # Note that passing in non-None values is required for the create_body
        # method to distinguish between this and the request to create and instance.
        self._user_manager.create(name=name, password=password,
                database_names=database_names, return_none=True)
        # Since the API doesn't return the info for creating the user object, we
        # have to do it manually.
        return self._user_manager.find(name=name)


    def _get_name(self, name_or_obj):
        """
        For convenience, many methods accept either an object or the name
        of the object as a parameter, but need the name to send to the
        API. This method handles that conversion.
        """
        if isinstance(name_or_obj, basestring):
            return name_or_obj
#.........这里部分代码省略.........

class CloudDatabaseClient(BaseClient):
    """
    This is the primary class for interacting with Cloud Databases.
    """
    def _configure_manager(self):
        """
        Creates a manager to handle the instances, and another
        to handle flavors.
        """
        self._manager = BaseManager(self, resource_class=CloudDatabaseInstance,
               response_key="instance", uri_base="instances")
        self._flavor_manager = BaseManager(self,
                resource_class=CloudDatabaseFlavor, response_key="flavor",
                uri_base="flavors")


    @assure_instance
    def list_databases(self, instance):
        """Returns all databases for the specified instance."""
        return instance.list_databases()


    @assure_instance
    def create_database(self, instance, name, character_set=None,
            collate=None):
        """Creates a database with the specified name on the given instance."""
        return instance.create_database(name, character_set=character_set,
                collate=collate)


    @assure_instance
    def get_database(self, instance, name):
        """
        Finds the database in the given instance with the specified name, and
        returns a CloudDatabaseDatabase object. If no match is found, a
        NoSuchDatabase exception is raised.
        """
        return instance.get_database(name)


    @assure_instance
    def delete_database(self, instance, name):
        """Deletes the database by name on the given instance."""
        return instance.delete_database(name)


    @assure_instance
    def list_users(self, instance):
        """Returns all users for the specified instance."""
        return instance.list_users()


    @assure_instance
    def create_user(self, instance, name, password, database_names):
        """
        Creates a user with the specified name and password, and gives that
        user access to the specified database(s).
        """
        return instance.create_user(name=name, password=password,
                database_names=database_names)


    @assure_instance
    def get_user(self, instance, name):
        """
        Finds the user in the given instance with the specified name, and
        returns a CloudDatabaseUser object. If no match is found, a
        NoSuchUser exception is raised.
        """
        return instance.get_user(name)


    @assure_instance
    def delete_user(self, instance, name):
        """Deletes the user by name on the given instance."""
        return instance.delete_user(name)


    @assure_instance
    def enable_root_user(self, instance):
        """
        This enables login from any host for the root user and provides
        the user with a generated root password.
        """
        return instance.enable_root_user()


    @assure_instance
    def root_user_status(self, instance):
        """Returns True if the given instance is root-enabled."""
        return instance.root_user_status()


    @assure_instance
    def restart(self, instance):
        """Restarts the instance."""
        return instance.restart()


    @assure_instance
#.........这里部分代码省略.........

class CloudDatabaseClient(BaseClient):
    """
    This is the primary class for interacting with Cloud Databases.
    """
    name = "Cloud Databases"

    def _configure_manager(self):
        """
        Creates a manager to handle the instances, and another
        to handle flavors.
        """
        self._manager = CloudDatabaseManager(self,
                resource_class=CloudDatabaseInstance, response_key="instance",
                uri_base="instances")
        self._flavor_manager = BaseManager(self,
                resource_class=CloudDatabaseFlavor, response_key="flavor",
                uri_base="flavors")
        self._backup_manager = CloudDatabaseBackupManager(self,
                resource_class=CloudDatabaseBackup, response_key="backup",
                uri_base="backups")


    @assure_instance
    def list_databases(self, instance, limit=None, marker=None):
        """Returns all databases for the specified instance."""
        return instance.list_databases(limit=limit, marker=marker)


    @assure_instance
    def create_database(self, instance, name, character_set=None,
            collate=None):
        """Creates a database with the specified name on the given instance."""
        return instance.create_database(name, character_set=character_set,
                collate=collate)


    @assure_instance
    def get_database(self, instance, name):
        """
        Finds the database in the given instance with the specified name, and
        returns a CloudDatabaseDatabase object. If no match is found, a
        NoSuchDatabase exception is raised.
        """
        return instance.get_database(name)


    @assure_instance
    def delete_database(self, instance, name):
        """Deletes the database by name on the given instance."""
        return instance.delete_database(name)


    @assure_instance
    def list_users(self, instance, limit=None, marker=None):
        """Returns all users for the specified instance."""
        return instance.list_users(limit=limit, marker=marker)


    @assure_instance
    def create_user(self, instance, name, password, database_names, host=None):
        """
        Creates a user with the specified name and password, and gives that
        user access to the specified database(s).
        """
        return instance.create_user(name=name, password=password,
                database_names=database_names, host=host)


    @assure_instance
    def get_user(self, instance, name):
        """
        Finds the user in the given instance with the specified name, and
        returns a CloudDatabaseUser object. If no match is found, a
        NoSuchUser exception is raised.
        """
        return instance.get_user(name)


    @assure_instance
    def delete_user(self, instance, name):
        """Deletes the user by name on the given instance."""
        return instance.delete_user(name)


    @assure_instance
    def change_user_password(self, instance, user, new_pass):
        """
        Changes the password for the user of the specified instance to the
        supplied value.

        Returns None upon success; raises PasswordChangeFailed if the call
        does not complete successfully.
        """
        return instance.change_user_password(user, new_pass)


    @assure_instance
    def update_user(self, instance, user, name=None, password=None, host=None):
        """
        Allows you to change one or more of the user's username, password, or
#.........这里部分代码省略.........

class CloudBlockStorageClient(BaseClient):
    """
    This is the primary class for interacting with Cloud Block Storage.
    """
    name = "Cloud Block Storage"

    def _configure_manager(self):
        """
        Create the manager to handle the instances, and also another
        to handle flavors.
        """
        self._manager = CloudBlockStorageManager(self,
                resource_class=CloudBlockStorageVolume, response_key="volume",
                uri_base="volumes")
        self._types_manager = BaseManager(self,
                resource_class=CloudBlockStorageVolumeType,
                response_key="volume_type", uri_base="types")
        self._snapshot_manager = CloudBlockStorageSnapshotManager(self,
                resource_class=CloudBlockStorageSnapshot,
                response_key="snapshot", uri_base="snapshots")


    def list_types(self):
        """Returns a list of all available volume types."""
        return self._types_manager.list()


    def list_snapshots(self):
        """Returns a list of all snapshots."""
        return self._snapshot_manager.list()


    @assure_volume
    def attach_to_instance(self, volume, instance, mountpoint):
        """Attaches the volume to the specified instance at the mountpoint."""
        return volume.attach_to_instance(instance, mountpoint)


    @assure_volume
    def detach(self, volume):
        """Detaches the volume from whatever device it is attached to."""
        return volume.detach()


    @assure_volume
    def delete_volume(self, volume, force=False):
        """Deletes the volume."""
        return volume.delete(force=force)


    @assure_volume
    def create_snapshot(self, volume, name=None, description=None, force=False):
        """
        Creates a snapshot of the volume, with an optional name and description.

        Normally snapshots will not happen if the volume is attached. To
        override this default behavior, pass force=True.
        """
        return self._snapshot_manager.create(volume=volume, name=name,
                description=description, force=force)


    @assure_snapshot
    def delete_snapshot(self, snapshot):
        """Deletes the snapshot."""
        return snapshot.delete()

class RackConnectClient(BaseClient):
    """A client to interact with RackConnected resources."""

    name = "RackConnect"

    def _configure_manager(self):
        """Create a manager to handle RackConnect operations."""
        self._network_manager = BaseManager(
            self, resource_class=Network, uri_base="cloud_networks",
        )
        self._load_balancer_pool_manager = LoadBalancerPoolManager(
            self, resource_class=LoadBalancerPool,
            uri_base="load_balancer_pools"
        )
        self._public_ip_manager = PublicIPManager(
            self, resource_class=PublicIP, uri_base="public_ips",
        )

    def get_network(self, network):
        return self._network_manager.get(network)

    def list_networks(self):
        return self._network_manager.list()

    def list_load_balancer_pools(self):
        return self._load_balancer_pool_manager.list()

    def get_load_balancer_pool(self, pool):
        return self._load_balancer_pool_manager.get(pool)

    def list_pool_nodes(self, pool):
        return self._load_balancer_pool_manager.get_pool_nodes(pool)

    def create_pool_node(self, pool, server):
        return self._load_balancer_pool_manager.add_pool_node(pool, server)

    def get_pool_node(self, pool, node):
        return self._load_balancer_pool_manager.get_pool_node(pool, node)

    def delete_pool_node(self, pool, node):
        return self._load_balancer_pool_manager.delete_pool_node(pool, node)

    def create_public_ip(self, public_ip):
        return self._public_ip_manager.add_public_ip(public_ip)

    def list_public_ips(self):
        return self._public_ip_manager.list()

    def get_public_ip(self, public_ip):
        return self._public_ip_manager.get(public_ip)

    def get_public_ips_for_server(self, server):
        return self._public_ip_manager.get_ip_for_server(server)

    def delete_public_ip(self, public_ip):
        return self._public_ip_manager.delete_public_ip(public_ip)

    #################################################################
    # The following methods are defined in the generic client class,
    # but don't have meaning in RackConnect, as there is not a single
    # resource that defines this module.
    #################################################################
    def list(self, limit=None, marker=None):
        """Not applicable in RackConnect."""
        raise NotImplementedError

    def get(self, item):
        """Not applicable in RackConnect."""
        raise NotImplementedError

    def create(self, *args, **kwargs):
        """Not applicable in RackConnect."""
        raise NotImplementedError

    def delete(self, item):
        """Not applicable in RackConnect."""
        raise NotImplementedError

    def find(self, **kwargs):
        """Not applicable in RackConnect."""
        raise NotImplementedError

    def findall(self, **kwargs):
        """Not applicable in RackConnect."""
        raise NotImplementedError

class CloudMonitorClient(BaseClient):
    """
    This is the base client for creating and managing Cloud Monitoring.
    """

    def __init__(self, *args, **kwargs):
        super(CloudMonitorClient, self).__init__(*args, **kwargs)
        self.name = "Cloud Monitoring"


    def _configure_manager(self):
        """
        Creates the Manager instances to handle monitoring.
        """
        self._entity_manager = CloudMonitorEntityManager(self,
                uri_base="entities", resource_class=CloudMonitorEntity,
                response_key=None, plural_response_key=None)
        self._check_type_manager = BaseManager(self,
                uri_base="check_types", resource_class=CloudMonitorCheckType,
                response_key=None, plural_response_key=None)
        self._monitoring_zone_manager = BaseManager(self,
                uri_base="monitoring_zones", resource_class=CloudMonitorZone,
                response_key=None, plural_response_key=None)
        self._notification_manager = CloudMonitorNotificationManager(self,
                uri_base="notifications",
                resource_class=CloudMonitorNotification,
                response_key=None, plural_response_key=None)
        self._notification_plan_manager = CloudMonitorNotificationPlanManager(
                self, uri_base="notification_plans",
                resource_class=CloudMonitorNotificationPlan,
                response_key=None, plural_response_key=None)
        self._changelog_manager = CloudMonitorChangelogManager(self,
                uri_base="changelogs/alarms", resource_class=None,
                response_key=None, plural_response_key=None)
        self._overview_manager = CloudMonitorOverviewManager(self,
                uri_base="views/overview", resource_class=None,
                response_key="value", plural_response_key=None)


    def get_account(self):
        """
        Returns a dict with the following keys: id, webhook_token, and metadata.
        """
        resp, resp_body = self.method_get("/account")
        return resp_body


    def get_audits(self):
        """
        Every write operation performed against the API (PUT, POST or DELETE)
        generates an audit record that is stored for 30 days. Audits record a
        variety of information about the request including the method, URL,
        headers, query string, transaction ID, the request body and the
        response code. They also store information about the action performed
        including a JSON list of the previous state of any modified objects.
        For example, if you perform an update on an entity, this will record
        the state of the entity before modification.
        """
        resp, resp_body = self.method_get("/audits")
        return resp_body["values"]


    def list_entities(self):
        return self._entity_manager.list()


    def get_entity(self, entity):
        return self._entity_manager.get(entity)


    def create_entity(self, label=None, name=None, agent=None,
            ip_addresses=None, metadata=None):
        # NOTE: passing a non-None value for ip_addresses is required so that
        # the _create_body() method can distinguish this as a request for a
        # body dict for entities.
        ip_addresses = ip_addresses or {}
        resp = self._entity_manager.create(label=label, name=name, agent=agent,
                ip_addresses=ip_addresses, metadata=metadata,
                return_response=True)
        if resp.status_code == 201:
            ent_id = resp.headers["x-object-id"]
            return self.get_entity(ent_id)


    def update_entity(self, entity, agent=None, metadata=None):
        """
        Only the agent_id and metadata are able to be updated via the API.
        """
        self._entity_manager.update_entity(entity, agent=agent,
                metadata=metadata)


    def delete_entity(self, entity):
        """Deletes the specified entity."""
        self._entity_manager.delete(entity)


    def list_check_types(self):
        return self._check_type_manager.list()

#.........这里部分代码省略.........

class CloudBlockStorageClient(BaseClient):
    """
    This is the primary class for interacting with Cloud Block Storage.
    """
    def _configure_manager(self):
        """
        Create the manager to handle the instances, and also another
        to handle flavors.
        """
        self._manager = BaseManager(self,
                resource_class=CloudBlockStorageVolume, response_key="volume",
                uri_base="volumes")
        self._types_manager = BaseManager(self,
                resource_class=CloudBlockStorageVolumeType,
                response_key="volume_type", uri_base="types")
        self._snaps_manager = BaseManager(self,
                resource_class=CloudBlockStorageSnapshot,
                response_key="snapshot", uri_base="snapshots")


    def create(self, name="", size=None, volume_type=None, description=None,
             metadata=None, snapshot_id=None, availability_zone=None):
        """
        Makes sure that the size is passed and is within allowed values.
        """
        if not isinstance(size, (int, long)) or not (
                MIN_SIZE <= size <= MAX_SIZE):
            raise exc.InvalidSize("Volume sizes must be integers between "
                    "%s and %s." % (MIN_SIZE, MAX_SIZE))
        return super(CloudBlockStorageClient, self).create(name, size=size,
                volume_type=volume_type, description=description,
                metadata=metadata, snapshot_id=snapshot_id,
                availability_zone=availability_zone)


    def list_types(self):
        """Returns a list of all available volume types."""
        return self._types_manager.list()


    def list_snapshots(self):
        """Returns a list of all snapshots."""
        return self._snaps_manager.list()


    def _create_body(self, name, size=None, volume_type=None, description=None,
             metadata=None, snapshot_id=None, availability_zone=None,
             volume=None, force=False):
        """
        Used to create the dict required to create any of the following:
            A new volume
            A new snapshot
        """
        if size is not None:
            # Creating a volume
            if not isinstance(size, (int, long)) or not (
                    MIN_SIZE <= size <= MAX_SIZE):
                raise exc.InvalidSize("Volume sizes must be integers between "
                        "%s and %s." % (MIN_SIZE, MAX_SIZE))
            if volume_type is None:
                volume_type = "SATA"
            if description is None:
                description = ""
            if metadata is None:
                metadata = {}
            body = {"volume": {
                    "size": size,
                    "snapshot_id": snapshot_id,
                    "display_name": name,
                    "display_description": description,
                    "volume_type": volume_type,
                    "metadata": metadata,
                    "availability_zone": availability_zone,
                    }}
        else:
            # Creating a snapshot
            body = {"snapshot": {
                    "display_name": name,
                    "display_description": description,
                    "volume_id": volume.id,
                    "force": str(force).lower(),
                 }}
        return body


    @assure_volume
    def attach_to_instance(self, volume, instance, mountpoint):
        """Attaches the volume to the specified instance at the mountpoint."""
        return volume.attach_to_instance(instance, mountpoint)


    @assure_volume
    def detach(self, volume):
        """Detaches the volume from whatever device it is attached to."""
        return volume.detach()


    @assure_volume
    def delete_volume(self, volume, force=False):
        """Deletes the volume."""
#.........这里部分代码省略.........

class CloudBlockStorageClient(BaseClient):
    """
    This is the primary class for interacting with Cloud Block Storage.
    """
    name = "Cloud Block Storage"

    def _configure_manager(self):
        """
        Create the manager to handle the instances, and also another
        to handle flavors.
        """
        self._manager = CloudBlockStorageManager(self,
                resource_class=CloudBlockStorageVolume, response_key="volume",
                uri_base="volumes")
        self._types_manager = BaseManager(self,
                resource_class=CloudBlockStorageVolumeType,
                response_key="volume_type", uri_base="types")
        self._snapshot_manager = CloudBlockStorageSnapshotManager(self,
                resource_class=CloudBlockStorageSnapshot,
                response_key="snapshot", uri_base="snapshots")


    def list_types(self):
        """Returns a list of all available volume types."""
        return self._types_manager.list()


    def list_snapshots(self):
        """Returns a list of all snapshots."""
        return self._snapshot_manager.list()


    @assure_volume
    def attach_to_instance(self, volume, instance, mountpoint):
        """Attaches the volume to the specified instance at the mountpoint."""
        return volume.attach_to_instance(instance, mountpoint)


    @assure_volume
    def detach(self, volume):
        """Detaches the volume from whatever device it is attached to."""
        return volume.detach()


    @assure_volume
    def delete_volume(self, volume, force=False):
        """Deletes the volume."""
        return volume.delete(force=force)


    @assure_volume
    def update(self, volume, display_name=None, display_description=None):
        """
        Update the specified values on the specified volume. You may specify
        one or more values to update. If no values are specified as non-None,
        the call is a no-op; no exception will be raised.
        """
        return volume.update(display_name=display_name,
                display_description=display_description)


    def rename(self, volume, name):
        """
        Allows for direct renaming of an existing volume.
        """
        return self.update(volume, display_name=name)


    @assure_volume
    def create_snapshot(self, volume, name=None, description=None, force=False):
        """
        Creates a snapshot of the volume, with an optional name and description.

        Normally snapshots will not happen if the volume is attached. To
        override this default behavior, pass force=True.
        """
        return self._snapshot_manager.create(volume=volume, name=name,
                description=description, force=force)


    def get_snaps