# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""
Node driver for Aliyun.
"""

try:
    import simplejson as json
except ImportError:
    import json
import time

from libcloud.common.aliyun import AliyunXmlResponse, SignedAliyunConnection
from libcloud.common.types import LibcloudError
from libcloud.compute.base import Node, NodeDriver, NodeImage, NodeSize, \
    StorageVolume, VolumeSnapshot, NodeLocation
from libcloud.compute.types import NodeState, StorageVolumeState, \
    VolumeSnapshotState
from libcloud.utils.py3 import _real_unicode as u
from libcloud.utils.xml import findall, findattr, findtext

__all__ = [
    'DiskCategory',
    'InternetChargeType',
    'ECS_API_VERSION',
    'ECSDriver',
    'ECSSecurityGroup',
    'ECSZone'
]

ECS_API_VERSION = '2014-05-26'
ECS_API_ENDPOINT = 'ecs.aliyuncs.com'
DEFAULT_SIGNATURE_VERSION = '1.0'


def _parse_bool(value):
    if isinstance(value, bool):
        return value
    if u(value).lower() == 'true':
        return True
    return False


"""
Define the extra dictionary for specific resources
"""
RESOURCE_EXTRA_ATTRIBUTES_MAP = {
    'node': {
        'description': {
            'xpath': 'Description',
            'transform_func': u
        },
        'image_id': {
            'xpath': 'ImageId',
            'transform_func': u
        },
        'zone_id': {
            'xpath': 'ZoneId',
            'transform_func': u
        },
        'instance_type': {
            'xpath': 'InstanceType',
            'transform_func': u
        },
        'instance_type_family': {
            'xpath': 'InstanceTypeFamily',
            'transform_func': u
        },
        'hostname': {
            'xpath': 'HostName',
            'transform_func': u
        },
        'serial_number': {
            'xpath': 'SerialNumber',
            'transform_func': u
        },
        'internet_charge_type': {
            'xpath': 'InternetChargeType',
            'transform_func': u
        },
        'creation_time': {
            'xpath': 'CreationTime',
            'transform_func': u
        },
        'instance_network_type': {
            'xpath': 'InstanceNetworkType',
            'transform_func': u
        },
        'instance_charge_type': {
            'xpath': 'InstanceChargeType',
            'transform_func': u
        },
        'device_available': {
            'xpath': 'DeviceAvailable',
            'transform_func': u
        },
        'io_optimized': {
            'xpath': 'IoOptimized',
            'transform_func': u
        },
        'expired_time': {
            'xpath': 'ExpiredTime',
            'transform_func': u
        }
    },
    'vpc_attributes': {
        'vpc_id': {
            'xpath': 'VpcId',
            'transform_func': u
        },
        'vswitch_id': {
            'xpath': 'VSwitchId',
            'transform_func': u
        },
        'private_ip_address': {
            'xpath': 'PrivateIpAddress/IpAddress',
            'transform_func': u
        },
        'nat_ip_address': {
            'xpath': 'NatIpAddress',
            'transform_func': u
        }
    },
    'eip_address_associate': {
        'allocation_id': {
            'xpath': 'AllocationId',
            'transform_func': u
        },
        'ip_address': {
            'xpath': 'IpAddress',
            'transform_func': u
        },
        'bandwidth': {
            'xpath': 'Bandwidth',
            'transform_func': int
        },
        'internet_charge_type': {
            'xpath': 'InternetChargeType',
            'transform_func': u
        }
    },
    'operation_locks': {
        'lock_reason': {
            'xpath': 'LockReason',
            'transform_func': u
        }
    },
    'volume': {
        'region_id': {
            'xpath': 'RegionId',
            'transform_func': u
        },
        'zone_id': {
            'xpath': 'ZoneId',
            'transform_func': u
        },
        'description': {
            'xpath': 'Description',
            'transform_func': u
        },
        'type': {
            'xpath': 'Type',
            'transform_func': u
        },
        'category': {
            'xpath': 'Category',
            'transform_func': u
        },
        'image_id': {
            'xpath': 'ImageId',
            'transform_func': u
        },
        'source_snapshot_id': {
            'xpath': 'SourceSnapshotId',
            'transform_func': u
        },
        'product_code': {
            'xpath': 'ProductCode',
            'transform_func': u
        },
        'portable': {
            'xpath': 'Portable',
            'transform_func': _parse_bool
        },
        'instance_id': {
            'xpath': 'InstanceId',
            'transform_func': u
        },
        'device': {
            'xpath': 'Device',
            'transform_func': u
        },
        'delete_with_instance': {
            'xpath': 'DeleteWithInstance',
            'transform_func': _parse_bool
        },
        'enable_auto_snapshot': {
            'xpath': 'EnableAutoSnapshot',
            'transform_func': _parse_bool
        },
        'creation_time': {
            'xpath': 'CreationTime',
            'transform_func': u
        },
        'attached_time': {
            'xpath': 'AttachedTime',
            'transform_func': u
        },
        'detached_time': {
            'xpath': 'DetachedTime',
            'transform_func': u
        },
        'disk_charge_type': {
            'xpath': 'DiskChargeType',
            'transform_func': u
        }
    },
    'snapshot': {
        'snapshot_name': {
            'xpath': 'SnapshotName',
            'transform_func': u
        },
        'description': {
            'xpath': 'Description',
            'transform_func': u
        },
        'progress': {
            'xpath': 'Progress',
            'transform_func': u
        },
        'source_disk_id': {
            'xpath': 'SourceDiskId',
            'transform_func': u
        },
        'source_disk_size': {
            'xpath': 'SourceDiskSize',
            'transform_func': int
        },
        'source_disk_type': {
            'xpath': 'SourceDiskType',
            'transform_func': u
        },
        'product_code': {
            'xpath': 'ProductCode',
            'transform_func': u
        },
        'usage': {
            'xpath': 'Usage',
            'transform_func': u
        }
    },
    'image': {
        'image_version': {
            'xpath': 'ImageVersion',
            'transform_func': u
        },
        'os_type': {
            'xpath': 'OSType',
            'transform_func': u
        },
        'platform': {
            'xpath': 'Platform',
            'transform_func': u
        },
        'architecture': {
            'xpath': 'Architecture',
            'transform_func': u
        },
        'description': {
            'xpath': 'Description',
            'transform_func': u
        },
        'size': {
            'xpath': 'Size',
            'transform_func': int
        },
        'image_owner_alias': {
            'xpath': 'ImageOwnerAlias',
            'transform_func': u
        },
        'os_name': {
            'xpath': 'OSName',
            'transform_func': u
        },
        'product_code': {
            'xpath': 'ProductCode',
            'transform_func': u
        },
        'is_subscribed': {
            'xpath': 'IsSubscribed',
            'transform_func': _parse_bool
        },
        'progress': {
            'xpath': 'Progress',
            'transform_func': u
        },
        'creation_time': {
            'xpath': 'CreationTime',
            'transform_func': u
        },
        'usage': {
            'xpath': 'Usage',
            'transform_func': u
        },
        'is_copied': {
            'xpath': 'IsCopied',
            'transform_func': _parse_bool
        }
    },
    'disk_device_mapping': {
        'snapshot_id': {
            'xpath': 'SnapshotId',
            'transform_func': u
        },
        'size': {
            'xpath': 'Size',
            'transform_func': int
        },
        'device': {
            'xpath': 'Device',
            'transform_func': u
        },
        'format': {
            'xpath': 'Format',
            'transform_func': u
        },
        'import_oss_bucket': {
            'xpath': 'ImportOSSBucket',
            'transform_func': u
        },
        'import_oss_object': {
            'xpath': 'ImportOSSObject',
            'transform_func': u
        }
    }
}


class ECSConnection(SignedAliyunConnection):
    """
    Represents a single connection to the Aliyun ECS Endpoint.
    """

    api_version = ECS_API_VERSION
    host = ECS_API_ENDPOINT
    responseCls = AliyunXmlResponse
    service_name = 'ecs'


class ECSSecurityGroup(object):
    """
    Security group used to control nodes internet and intranet accessibility.
    """
    def __init__(self, id, name, description=None, driver=None, vpc_id=None,
                 creation_time=None):
        self.id = id
        self.name = name
        self.description = description
        self.driver = driver
        self.vpc_id = vpc_id
        self.creation_time = creation_time

    def __repr__(self):
        return ('<ECSSecurityGroup: id=%s, name=%s, driver=%s ...>' %
                (self.id, self.name, self.driver.name))


class ECSSecurityGroupAttribute(object):

    """
    Security group attribute.
    """
    def __init__(self, ip_protocol=None, port_range=None,
                 source_group_id=None, policy=None, nic_type=None):
        self.ip_protocol = ip_protocol
        self.port_range = port_range
        self.source_group_id = source_group_id
        self.policy = policy
        self.nic_type = nic_type

    def __repr__(self):
        return ('<ECSSecurityGroupAttribute: ip_protocol=%s ...>' %
                (self.ip_protocol))


class ECSZone(object):
    """
    ECSZone used to represent an availability zone in a region.
    """
    def __init__(self, id, name, driver=None,
                 available_resource_types=None,
                 available_instance_types=None,
                 available_disk_categories=None):
        self.id = id
        self.name = name
        self.driver = driver
        self.available_resource_types = available_resource_types
        self.available_instance_types = available_instance_types
        self.available_disk_categories = available_disk_categories

    def __repr__(self):
        return ('<ECSZone: id=%s, name=%s, driver=%s>' %
                (self.id, self.name, self.driver))


class InternetChargeType(object):
    """
    Internet connection billing types for Aliyun Nodes.
    """
    BY_BANDWIDTH = 'PayByBandwidth'
    BY_TRAFFIC = 'PayByTraffic'


class DiskCategory(object):
    """
    Enum defined disk types supported by Aliyun system and data disks.
    """
    CLOUD = 'cloud'
    CLOUD_EFFICIENCY = 'cloud_efficiency'
    CLOUD_SSD = 'cloud_ssd'
    EPHEMERAL_SSD = 'ephemeral_ssd'


class Pagination(object):
    """
    Pagination used to describe the multiple pages results.
    """
    def __init__(self, total, size, current):
        """
        Create a pagination.

        :param total: the total count of the results
        :param size: the page size of each page
        :param current: the current page number, 1-based
        """
        self.total = total
        self.size = size
        self.current = current

    def next(self):
        """
        Switch to the next page.
        :return: the new pagination or None when no more page
        :rtype: ``Pagination``
        """
        if self.total is None or (self.size * self.current >= self.total):
            return None
        self.current += 1
        return self

    def to_dict(self):
        return {'PageNumber': self.current,
                'PageSize': self.size}

    def __repr__(self):
        return ('<Pagination total=%d, size=%d, current page=%d>' %
                (self.total, self.size, self.current))


class ECSDriver(NodeDriver):
    """
    Aliyun ECS node driver.

    Used for Aliyun ECS service.

    TODO:
    Get guest OS root password
    Adjust internet bandwidth settings
    Manage security groups and rules
    """

    name = 'Aliyun ECS'
    website = 'https://www.aliyun.com/product/ecs'
    connectionCls = ECSConnection
    features = {'create_node': ['password']}
    namespace = None
    path = '/'

    internet_charge_types = InternetChargeType
    disk_categories = DiskCategory

    NODE_STATE_MAPPING = {
        'Starting': NodeState.PENDING,
        'Running': NodeState.RUNNING,
        'Stopping': NodeState.PENDING,
        'Stopped': NodeState.STOPPED
    }

    VOLUME_STATE_MAPPING = {
        'In_use': StorageVolumeState.INUSE,
        'Available': StorageVolumeState.AVAILABLE,
        'Attaching': StorageVolumeState.ATTACHING,
        'Detaching': StorageVolumeState.INUSE,
        'Creating': StorageVolumeState.CREATING,
        'ReIniting': StorageVolumeState.CREATING}

    SNAPSHOT_STATE_MAPPING = {
        'progressing': VolumeSnapshotState.CREATING,
        'accomplished': VolumeSnapshotState.AVAILABLE,
        'failed': VolumeSnapshotState.ERROR}

    def list_nodes(self, ex_node_ids=None, ex_filters=None):
        """
        List all nodes.

        @inherits: :class:`NodeDriver.create_node`

        :keyword  ex_node_ids: a list of node's ids used to filter nodes.
                               Only the nodes which's id in this list
                               will be returned.
        :type   ex_node_ids: ``list`` of ``str``
        :keyword  ex_filters: node attribute and value pairs to filter nodes.
                              Only the nodes which matchs all the pairs will
                              be returned.
                              If the filter attribute need a json array value,
                              use ``list`` object, the driver will convert it.
        :type   ex_filters: ``dict``
        """

        params = {'Action': 'DescribeInstances',
                  'RegionId': self.region}

        if ex_node_ids:
            if isinstance(ex_node_ids, list):
                params['InstanceIds'] = self._list_to_json_array(ex_node_ids)
            else:
                raise AttributeError('ex_node_ids should be a list of '
                                     'node ids.')

        if ex_filters:
            if isinstance(ex_filters, dict):
                params.update(ex_filters)
            else:
                raise AttributeError('ex_filters should be a dict of '
                                     'node attributes.')

        nodes = self._request_multiple_pages(self.path, params,
                                             self._to_nodes)
        return nodes

    def list_sizes(self, location=None):
        params = {'Action': 'DescribeInstanceTypes'}

        resp_body = self.connection.request(self.path, params).object
        size_elements = findall(resp_body, 'InstanceTypes/InstanceType',
                                namespace=self.namespace)
        sizes = [self._to_size(each) for each in size_elements]
        return sizes

    def list_locations(self):
        params = {'Action': 'DescribeRegions'}

        resp_body = self.connection.request(self.path, params).object
        location_elements = findall(resp_body, 'Regions/Region',
                                    namespace=self.namespace)
        locations = [self._to_location(each) for each in location_elements]
        return locations

    def create_node(self, name, size, image, auth=None,
                    ex_security_group_id=None, ex_description=None,
                    ex_internet_charge_type=None,
                    ex_internet_max_bandwidth_out=None,
                    ex_internet_max_bandwidth_in=None,
                    ex_hostname=None, ex_io_optimized=None,
                    ex_system_disk=None, ex_data_disks=None,
                    ex_vswitch_id=None, ex_private_ip_address=None,
                    ex_client_token=None, **kwargs):
        """
        @inherits: :class:`NodeDriver.create_node`

        :param name: The name for this new node (required)
        :type name: ``str``

        :param image: The image to use when creating this node (required)
        :type image: `NodeImage`

        :param size: The size of the node to create (required)
        :type size: `NodeSize`

        :keyword auth: Initial authentication information for the node
                       (optional)
        :type auth: :class:`NodeAuthSSHKey` or :class:`NodeAuthPassword`

        :keyword ex_security_group_id: The id of the security group the
                                       new created node is attached to.
                                       (required)
        :type ex_security_group_id: ``str``

        :keyword ex_description: A description string for this node (optional)
        :type ex_description: ``str``

        :keyword ex_internet_charge_type: The internet charge type (optional)
        :type ex_internet_charge_type: a ``str`` of 'PayByTraffic'
                                       or 'PayByBandwidth'

        :keyword ex_internet_max_bandwidth_out: The max output bandwidth,
                                                in Mbps (optional)
                                                Required for 'PayByTraffic'
                                                internet charge type
        :type ex_internet_max_bandwidth_out: a ``int`` in range [0, 100]
                                             a ``int`` in range [1, 100] for
                                             'PayByTraffic' internet charge
                                             type

        :keyword ex_internet_max_bandwidth_in: The max input bandwidth,
                                               in Mbps (optional)
        :type ex_internet_max_bandwidth_in: a ``int`` in range [1, 200]
                                            default to 200 in server side

        :keyword ex_hostname: The hostname for the node (optional)
        :type ex_hostname: ``str``

        :keyword ex_io_optimized: Whether the node is IO optimized (optional)
        :type ex_io_optimized: ``boll``

        :keyword ex_system_disk: The system disk for the node (optional)
        :type ex_system_disk: ``dict``

        :keyword ex_data_disks: The data disks for the node (optional)
        :type ex_data_disks: a `list` of `dict`

        :keyword ex_vswitch_id: The id of vswitch for a VPC type node
                                (optional)
        :type ex_vswitch_id: ``str``

        :keyword ex_private_ip_address: The IP address in private network
                                        (optional)
        :type ex_private_ip_address: ``str``

        :keyword ex_client_token: A token generated by client to keep
                                  requests idempotency (optional)
        :type keyword ex_client_token: ``str``
        """

        params = {'Action': 'CreateInstance',
                  'RegionId': self.region,
                  'ImageId': image.id,
                  'InstanceType': size.id,
                  'InstanceName': name}

        if not ex_security_group_id:
            raise AttributeError('ex_security_group_id is mandatory')
        params['SecurityGroupId'] = ex_security_group_id

        if ex_description:
            params['Description'] = ex_description

        inet_params = self._get_internet_related_params(
            ex_internet_charge_type,
            ex_internet_max_bandwidth_in,
            ex_internet_max_bandwidth_out)
        if inet_params:
            params.update(inet_params)

        if ex_hostname:
            params['HostName'] = ex_hostname

        if auth:
            auth = self._get_and_check_auth(auth)
            params['Password'] = auth.password

        if ex_io_optimized is not None:
            optimized = ex_io_optimized
            if isinstance(optimized, bool):
                optimized = 'optimized' if optimized else 'none'
            params['IoOptimized'] = optimized

        if ex_system_disk:
            system_disk = self._get_system_disk(ex_system_disk)
            if system_disk:
                params.update(system_disk)

        if ex_data_disks:
            data_disks = self._get_data_disks(ex_data_disks)
            if data_disks:
                params.update(data_disks)

        if ex_vswitch_id:
            params['VSwitchId'] = ex_vswitch_id

        if ex_private_ip_address:
            if not ex_vswitch_id:
                raise AttributeError('must provide ex_private_ip_address  '
                                     'and ex_vswitch_id at the same time')
            else:
                params['PrivateIpAddress'] = ex_private_ip_address

        if ex_client_token:
            params['ClientToken'] = ex_client_token

        resp = self.connection.request(self.path, params=params)
        node_id = findtext(resp.object, xpath='InstanceId',
                           namespace=self.namespace)
        nodes = self.list_nodes(ex_node_ids=[node_id])
        if len(nodes) != 1:
            raise LibcloudError('could not find the new created node '
                                'with id %s. ' % node_id,
                                driver=self)
        node = nodes[0]
        self.ex_start_node(node)
        self._wait_until_state(nodes, NodeState.RUNNING)
        return node

    def reboot_node(self, node, ex_force_stop=False):
        """
        Reboot the given node

        @inherits :class:`NodeDriver.reboot_node`

        :keyword ex_force_stop: if ``True``, stop node force (maybe lose data)
                                otherwise, stop node normally,
                                default to ``False``
        :type ex_force_stop: ``bool``
        """
        params = {'Action': 'RebootInstance',
                  'InstanceId': node.id,
                  'ForceStop': u(ex_force_stop).lower()}
        resp = self.connection.request(self.path, params=params)
        return resp.success() and \
            self._wait_until_state([node], NodeState.RUNNING)

    def destroy_node(self, node):
        nodes = self.list_nodes(ex_node_ids=[node.id])
        if len(nodes) != 1 and node.id != nodes[0].id:
            raise LibcloudError('could not find the node with id %s.'
                                % node.id)
        current = nodes[0]
        if current.state == NodeState.RUNNING:
            # stop node first
            self.ex_stop_node(node)
            self._wait_until_state(nodes, NodeState.STOPPED)
        params = {'Action': 'DeleteInstance',
                  'InstanceId': node.id}
        resp = self.connection.request(self.path, params)
        return resp.success()

    def start_node(self, node):
        """
        Start node to running state.

        :param node: the ``Node`` object to start
        :type node: ``Node``

        :return: starting operation result.
        :rtype: ``bool``
        """
        params = {'Action': 'StartInstance',
                  'InstanceId': node.id}
        resp = self.connection.request(self.path, params)
        return resp.success() and \
            self._wait_until_state([node], NodeState.RUNNING)

    def stop_node(self, node, ex_force_stop=False):
        """
        Stop a running node.

        :param node: The node to stop
        :type node: :class:`Node`

        :keyword ex_force_stop: if ``True``, stop node force (maybe lose data)
                                otherwise, stop node normally,
                                default to ``False``
        :type ex_force_stop: ``bool``

        :return: stopping operation result.
        :rtype: ``bool``
        """
        params = {'Action': 'StopInstance',
                  'InstanceId': node.id,
                  'ForceStop': u(ex_force_stop).lower()}
        resp = self.connection.request(self.path, params)
        return resp.success() and \
            self._wait_until_state([node], NodeState.STOPPED)

    def ex_start_node(self, node):
        # NOTE: This method is here for backward compatibility reasons after
        # this method was promoted to be part of the standard compute API in
        # Libcloud v2.7.0
        return self.start_node(node=node)

    def ex_stop_node(self, node, ex_force_stop=False):
        # NOTE: This method is here for backward compatibility reasons after
        # this method was promoted to be part of the standard compute API in
        # Libcloud v2.7.0
        return self.stop_node(node=node, ex_force_stop=ex_force_stop)

    def ex_create_security_group(self, description=None, client_token=None):
        """
        Create a new security group.

        :keyword description: security group description
        :type description: ``unicode``

        :keyword client_token: a token generated by client to identify
                                  each request.
        :type client_token: ``str``
        """
        params = {'Action': 'CreateSecurityGroup',
                  'RegionId': self.region}

        if description:
            params['Description'] = description
        if client_token:
            params['ClientToken'] = client_token
        resp = self.connection.request(self.path, params)
        return findtext(resp.object, 'SecurityGroupId',
                        namespace=self.namespace)

    def ex_delete_security_group_by_id(self, group_id=None):
        """
        Delete a new security group.

        :keyword group_id: security group id
        :type group_id: ``str``
        """
        params = {'Action': 'DeleteSecurityGroup',
                  'RegionId': self.region,
                  'SecurityGroupId': group_id}
        resp = self.connection.request(self.path, params)
        return resp.success()

    def ex_modify_security_group_by_id(
            self,
            group_id=None,
            name=None,
            description=None):
        """
        Modify a new security group.
        :keyword group_id: id of the security group
        :type group_id: ``str``
        :keyword name: new name of the security group
        :type name: ``unicode``
        :keyword description: new description of the security group
        :type description: ``unicode``
        """

        params = {'Action': 'ModifySecurityGroupAttribute',
                  'RegionId': self.region}
        if not group_id:
            raise AttributeError('group_id is required')
        params["SecurityGroupId"] = group_id

        if name:
            params["SecurityGroupName"] = name
        if description:
            params["Description"] = description

        resp = self.connection.request(self.path, params)
        return resp.success()

    def ex_list_security_groups(self, ex_filters=None):
        """
        List security groups in the current region.

        :keyword ex_filters: security group attributes to filter results.
        :type ex_filters: ``dict``

        :return: a list of defined security groups
        :rtype: ``list`` of ``ECSSecurityGroup``
        """
        params = {'Action': 'DescribeSecurityGroups',
                  'RegionId': self.region}

        if ex_filters and isinstance(ex_filters, dict):
            ex_filters.update(params)
            params = ex_filters

        def _parse_response(resp_object):
            sg_elements = findall(resp_object, 'SecurityGroups/SecurityGroup',
                                  namespace=self.namespace)
            sgs = [self._to_security_group(el) for el in sg_elements]
            return sgs
        return self._request_multiple_pages(self.path, params,
                                            _parse_response)

    def ex_list_security_group_attributes(self, group_id=None,
                                          nic_type='internet'):
        """
        List security group attributes in the current region.

        :keyword group_id: security group id.
        :type group_id: ``str``

        :keyword nic_type: internet|intranet.
        :type nic_type: ``str``

        :return: a list of defined security group Attributes
        :rtype: ``list`` of ``ECSSecurityGroupAttribute``
        """
        params = {'Action': 'DescribeSecurityGroupAttribute',
                  'RegionId': self.region,
                  'NicType': nic_type}

        if group_id is None:
            raise AttributeError('group_id is required')
        params['SecurityGroupId'] = group_id

        resp_object = self.connection.request(self.path, params).object
        sga_elements = findall(resp_object, 'Permissions/Permission',
                               namespace=self.namespace)
        return [self._to_security_group_attribute(el) for el in sga_elements]

    def ex_join_security_group(self, node, group_id=None):
        """
        Join a node into security group.

        :param node: The node to join security group
        :type node: :class:`Node`

        :param group_id: security group id.
        :type group_id: ``str``


        :return: join operation result.
        :rtype: ``bool``
        """
        if group_id is None:
            raise AttributeError('group_id is required')

        if node.state != NodeState.RUNNING and \
           node.state != NodeState.STOPPED:
            raise LibcloudError('The node state with id % s need\
                                be running or stopped .' % node.id)

        params = {'Action': 'JoinSecurityGroup',
                  'InstanceId': node.id,
                  'SecurityGroupId': group_id}
        resp = self.connection.request(self.path, params)
        return resp.success()

    def ex_leave_security_group(self, node, group_id=None):
        """
        Leave a node from security group.

        :param node: The node to leave security group
        :type node: :class:`Node`

        :param group_id: security group id.
        :type group_id: ``str``


        :return: leave operation result.
        :rtype: ``bool``
        """
        if group_id is None:
            raise AttributeError('group_id is required')

        if node.state != NodeState.RUNNING and \
           node.state != NodeState.STOPPED:
            raise LibcloudError('The node state with id % s need\
                                be running or stopped .' % node.id)

        params = {'Action': 'LeaveSecurityGroup',
                  'InstanceId': node.id,
                  'SecurityGroupId': group_id}
        resp = self.connection.request(self.path, params)
        return resp.success()

    def ex_list_zones(self, region_id=None):
        """
        List availability zones in the given region or the current region.

        :keyword region_id: the id of the region to query zones from
        :type region_id: ``str``

        :return: list of zones
        :rtype: ``list`` of ``ECSZone``
        """
        params = {'Action': 'DescribeZones'}
        if region_id:
            params['RegionId'] = region_id
        else:
            params['RegionId'] = self.region
        resp_body = self.connection.request(self.path, params).object
        zone_elements = findall(resp_body, 'Zones/Zone',
                                namespace=self.namespace)
        zones = [self._to_zone(el) for el in zone_elements]
        return zones
    ##
    # Volume and snapshot management methods
    ##

    def list_volumes(self, ex_volume_ids=None, ex_filters=None):
        """
        List all volumes.

        @inherits: :class:`NodeDriver.list_volumes`

        :keyword ex_volume_ids: a list of volume's ids used to filter volumes.
                                Only the volumes which's id in this list
                                will be returned.
        :type ex_volume_ids: ``list`` of ``str``

        :keyword ex_filters: volume attribute and value pairs to filter
                             volumes. Only the volumes which matchs all will
                             be returned.
                             If the filter attribute need a json array value,
                             use ``list`` object, the driver will convert it.
        :type ex_filters: ``dict``
        """
        params = {'Action': 'DescribeDisks',
                  'RegionId': self.region}

        if ex_volume_ids:
            if isinstance(ex_volume_ids, list):
                params['DiskIds'] = self._list_to_json_array(ex_volume_ids)
            else:
                raise AttributeError('ex_volume_ids should be a list of '
                                     'volume ids.')

        if ex_filters:
            if not isinstance(ex_filters, dict):
                raise AttributeError('ex_filters should be a dict of '
                                     'volume attributes.')
            else:
                for key in ex_filters.keys():
                    params[key] = ex_filters[key]

        def _parse_response(resp_object):
            disk_elements = findall(resp_object, 'Disks/Disk',
                                    namespace=self.namespace)
            volumes = [self._to_volume(each) for each in disk_elements]
            return volumes
        return self._request_multiple_pages(self.path, params,
                                            _parse_response)

    def list_volume_snapshots(self, volume, ex_snapshot_ids=[],
                              ex_filters=None):
        """
        List snapshots for a storage volume.

        @inherites :class:`NodeDriver.list_volume_snapshots`

        :keyword ex_snapshot_ids: a list of snapshot ids to filter the
                                  snapshots returned.
        :type ex_snapshot_ids: ``list`` of ``str``

        :keyword ex_filters: snapshot attribute and value pairs to filter
                             snapshots. Only the snapshot which matchs all
                             the pairs will be returned.
                             If the filter attribute need a json array value,
                             use ``list`` object, the driver will convert it.
        :type ex_filters: ``dict``
        """
        params = {'Action': 'DescribeSnapshots',
                  'RegionId': self.region}

        if volume:
            params['DiskId'] = volume.id
        if ex_snapshot_ids and isinstance(ex_snapshot_ids, list):
            params['SnapshotIds'] = self._list_to_json_array(ex_snapshot_ids)
        if ex_filters and isinstance(ex_filters, dict):
            for key in ex_filters.keys():
                params[key] = ex_filters[key]

        def _parse_response(resp_body):
            snapshot_elements = findall(resp_body, 'Snapshots/Snapshot',
                                        namespace=self.namespace)
            snapshots = [self._to_snapshot(each) for each in snapshot_elements]
            return snapshots

        return self._request_multiple_pages(self.path, params,
                                            _parse_response)

    def create_volume(self, size, name, location=None, snapshot=None,
                      ex_zone_id=None, ex_description=None,
                      ex_disk_category=None, ex_client_token=None):
        """
        Create a new volume.

        @inherites :class:`NodeDriver.create_volume`

        :keyword ex_zone_id: the availability zone id (required)
        :type ex_zone_id: ``str``

        :keyword ex_description: volume description
        :type ex_description: ``unicode``

        :keyword ex_disk_category: disk category for data disk
        :type ex_disk_category: ``str``

        :keyword ex_client_token: a token generated by client to identify
                                  each request.
        :type ex_client_token: ``str``
        """
        params = {'Action': 'CreateDisk',
                  'RegionId': self.region,
                  'DiskName': name,
                  'Size': size}
        if ex_zone_id is None:
            raise AttributeError('ex_zone_id is required')
        params['ZoneId'] = ex_zone_id

        if snapshot is not None and isinstance(snapshot, VolumeSnapshot):
            params['SnapshotId'] = snapshot.id
        if ex_description:
            params['Description'] = ex_description
        if ex_disk_category:
            params['DiskCategory'] = ex_disk_category
        if ex_client_token:
            params['ClientToken'] = ex_client_token
        resp = self.connection.request(self.path, params).object
        volume_id = findtext(resp, 'DiskId', namespace=self.namespace)
        volumes = self.list_volumes(ex_volume_ids=[volume_id])
        if len(volumes) != 1:
            raise LibcloudError('could not find the new create volume '
                                'with id %s.' % volume_id,
                                driver=self)
        return volumes[0]

    def create_volume_snapshot(self, volume, name=None, ex_description=None,
                               ex_client_token=None):
        """
        Creates a snapshot of the storage volume.

        @inherits :class:`NodeDriver.create_volume_snapshot`

        :keyword ex_description: description of the snapshot.
        :type ex_description: ``unicode``

        :keyword ex_client_token: a token generated by client to identify
                                  each request.
        :type ex_client_token: ``str``
        """
        params = {'Action': 'CreateSnapshot',
                  'DiskId': volume.id}
        if name:
            params['SnapshotName'] = name
        if ex_description:
            params['Description'] = ex_description
        if ex_client_token:
            params['ClientToken'] = ex_client_token

        snapshot_elements = self.connection.request(self.path, params).object
        snapshot_id = findtext(snapshot_elements, 'SnapshotId',
                               namespace=self.namespace)
        snapshots = self.list_volume_snapshots(volume=None,
                                               ex_snapshot_ids=[snapshot_id])
        if len(snapshots) != 1:
            raise LibcloudError('could not find new created snapshot with '
                                'id %s.' % snapshot_id, driver=self)
        return snapshots[0]

    def attach_volume(self, node, volume, device=None,
                      ex_delete_with_instance=None):
        """
        Attaches volume to node.

        @inherits :class:`NodeDriver.attach_volume`

        :keyword device: device path allocated for this attached volume
        :type device: ``str`` between /dev/xvdb to xvdz,
                      if empty, allocated by the system
        :keyword ex_delete_with_instance: if to delete this volume when the
                                          instance is deleted.
        :type ex_delete_with_instance: ``bool``
        """
        params = {'Action': 'AttachDisk',
                  'InstanceId': node.id,
                  'DiskId': volume.id}

        if device:
            params['Device'] = device
        if ex_delete_with_instance:
            params['DeleteWithInstance'] = \
                str(bool(ex_delete_with_instance)).lower()
        resp = self.connection.request(self.path, params)
        return resp.success()

    def detach_volume(self, volume, ex_instance_id=None):
        """
        Detaches a volume from a node.

        @inherits :class:`NodeDriver.detach_volume`

        :keyword ex_instance_id: the id of the instance from which the volume
                                 is detached.
        :type ex_instance_id: ``str``
        """
        params = {'Action': 'DetachDisk',
                  'DiskId': volume.id}

        if ex_instance_id:
            params['InstanceId'] = ex_instance_id
        else:
            volumes = self.list_volumes(ex_volume_ids=[volume.id])
            if len(volumes) != 1:
                raise AttributeError('could not find the instance id '
                                     'the volume %s attached to, '
                                     'ex_instance_id is required.' %
                                     volume.id)
            params['InstanceId'] = volumes[0].extra['instance_id']

        resp = self.connection.request(self.path, params)
        return resp.success()

    def destroy_volume(self, volume):
        params = {'Action': 'DeleteDisk',
                  'DiskId': volume.id}
        volumes = self.list_volumes(ex_volume_ids=[volume.id])
        if len(volumes) != 1:
            raise LibcloudError('could not find the volume with id %s.' %
                                volume.id,
                                driver=self)
        if volumes[0].state != StorageVolumeState.AVAILABLE:
            raise LibcloudError('only volume in AVAILABLE state could be '
                                'destroyed.', driver=self)
        resp = self.connection.request(self.path, params)
        return resp.success()

    def destroy_volume_snapshot(self, snapshot):
        params = {'Action': 'DeleteSnapshot'}

        if snapshot and isinstance(snapshot, VolumeSnapshot):
            params['SnapshotId'] = snapshot.id
        else:
            raise AttributeError('snapshot is required and must be a '
                                 'VolumeSnapshot')
        resp = self.connection.request(self.path, params)
        return resp.success()

    ##
    # Image management methods
    ##

    def list_images(self, location=None, ex_image_ids=None, ex_filters=None):
        """
        List images on a provider.

        @inherits :class:`NodeDriver.list_images`

        :keyword ex_image_ids: a list of image ids to filter the images to
                               be returned.
        :type ex_image_ids: ``list`` of ``str``

        :keyword ex_filters: image attribute and value pairs to filter
                             images. Only the image which matchs all
                             the pairs will be returned.
                             If the filter attribute need a json array value,
                             use ``list`` object, the driver will convert it.
        :type ex_filters: ``dict``
        """

        if location and isinstance(location, NodeLocation):
            region = location.id
        else:
            region = self.region
        params = {'Action': 'DescribeImages',
                  'RegionId': region}
        if ex_image_ids:
            if isinstance(ex_image_ids, list):
                params['ImageId'] = ','.join(ex_image_ids)
            else:
                raise AttributeError('ex_image_ids should be a list of '
                                     'image ids')
        if ex_filters and isinstance(ex_filters, dict):
            for key in ex_filters.keys():
                params[key] = ex_filters[key]

        def _parse_response(resp_body):
            image_elements = findall(resp_body, 'Images/Image',
                                     namespace=self.namespace)
            images = [self._to_image(each) for each in image_elements]
            return images
        return self._request_multiple_pages(self.path, params,
                                            _parse_response)

    def create_image(self, node, name, description=None, ex_snapshot_id=None,
                     ex_image_version=None, ex_client_token=None):
        """
        Creates an image from a system disk snapshot.

        @inherits :class:`NodeDriver.create_image`

        :keyword ex_snapshot_id: the id of the snapshot to create the image.
                                 (required)
        :type ex_snapshot_id: ``str``

        :keyword ex_image_version: the version number of the image
        :type ex_image_version: ``str``

        :keyword ex_client_token: a token generated by client to identify
                                  each request.
        :type ex_client_token: ``str``
        """
        params = {'Action': 'CreateImage',
                  'RegionId': self.region}
        if name:
            params['ImageName'] = name
        if description:
            params['Description'] = description
        if ex_snapshot_id:
            params['SnapshotId'] = ex_snapshot_id
        else:
            raise AttributeError('ex_snapshot_id is required')
        if ex_image_version:
            params['ImageVersion'] = ex_image_version
        if ex_client_token:
            params['ClientToken'] = ex_client_token

        resp = self.connection.request(self.path, params)
        image_id = findtext(resp.object, 'ImageId', namespace=self.namespace)
        return self.get_image(image_id=image_id)

    def delete_image(self, node_image):
        params = {'Action': 'DeleteImage',
                  'RegionId': self.region,
                  'ImageId': node_image.id}
        resp = self.connection.request(self.path, params)
        return resp.success()

    def get_image(self, image_id, ex_region_id=None):
        if ex_region_id:
            region = ex_region_id
        else:
            region = self.region
        location = NodeLocation(id=region, name=None, country=None,
                                driver=self)
        images = self.list_images(location, ex_image_ids=[image_id])
        if len(images) != 1:
            raise LibcloudError('could not find the image with id %s' %
                                image_id,
                                driver=self)
        return images[0]

    def copy_image(self, source_region, node_image, name, description=None,
                   ex_destination_region_id=None, ex_client_token=None):
        """
        Copies an image from a source region to the destination region.
        If not provide a destination region, default to the current region.

        @inherits :class:`NodeDriver.copy_image`

        :keyword ex_destination_region_id: id of the destination region
        :type ex_destination_region_id: ``str``

        :keyword ex_client_token: a token generated by client to identify
                                  each request.
        :type ex_client_token: ``str``
        """
        params = {'Action': 'CopyImage',
                  'RegionId': source_region,
                  'ImageId': node_image.id}
        if ex_destination_region_id is not None:
            params['DestinationRegionId'] = ex_destination_region_id
        else:
            params['DestinationRegionId'] = self.region
        if name:
            params['DestinationImageName'] = name
        if description:
            params['DestinationDescription'] = description
        if ex_client_token:
            params['ClientToken'] = ex_client_token
        resp = self.connection.request(self.path, params)
        image_id = findtext(resp.object, 'ImageId', namespace=self.namespace)
        return self.get_image(image_id=image_id)

    def create_public_ip(self, instance_id):
        """
        Create public ip.

        :keyword instance_id: instance id for allocating public ip.
        :type    instance_id: ``str``

        :return public ip
        :rtype ``str``
        """
        params = {'Action': 'AllocatePublicIpAddress',
                  'InstanceId': instance_id}

        resp = self.connection.request(self.path, params=params)
        return findtext(resp.object, 'IpAddress',
                        namespace=self.namespace)

    def _to_nodes(self, object):
        """
        Convert response to Node object list

        :param object: parsed response object
        :return: a list of ``Node``
        :rtype: ``list``
        """
        node_elements = findall(object, 'Instances/Instance', self.namespace)
        return [self._to_node(el) for el in node_elements]

    def _to_node(self, instance):
        """
        Convert an InstanceAttributesType object to ``Node`` object

        :param instance: a xml element represents an instance
        :return: a ``Node`` object
        :rtype: ``Node``
        """
        _id = findtext(element=instance, xpath='InstanceId',
                       namespace=self.namespace)
        name = findtext(element=instance, xpath='InstanceName',
                        namespace=self.namespace)
        instance_status = findtext(element=instance, xpath='Status',
                                   namespace=self.namespace)
        state = self.NODE_STATE_MAPPING.get(instance_status, NodeState.UNKNOWN)

        def _get_ips(ip_address_els):
            return [each.text for each in ip_address_els]

        public_ip_els = findall(element=instance,
                                xpath='PublicIpAddress/IpAddress',
                                namespace=self.namespace)
        public_ips = _get_ips(public_ip_els)
        private_ip_els = findall(element=instance,
                                 xpath='InnerIpAddress/IpAddress',
                                 namespace=self.namespace)
        private_ips = _get_ips(private_ip_els)

        # Extra properties
        extra = self._get_extra_dict(instance,
                                     RESOURCE_EXTRA_ATTRIBUTES_MAP['node'])
        extra['vpc_attributes'] = self._get_vpc_attributes(instance)
        extra['eip_address'] = self._get_eip_address(instance)
        extra['operation_locks'] = self._get_operation_locks(instance)

        node = Node(id=_id, name=name, state=state,
                    public_ips=public_ips, private_ips=private_ips,
                    driver=self.connection.driver, extra=extra)
        return node

    def _get_extra_dict(self, element, mapping):
        """
        Extract attributes from the element based on rules provided in the
        mapping dictionary.

        :param      element: Element to parse the values from.
        :type       element: xml.etree.ElementTree.Element.

        :param      mapping: Dictionary with the extra layout
        :type       node: :class:`Node`

        :rtype: ``dict``
        """
        extra = {}
        for attribute, values in mapping.items():
            transform_func = values['transform_func']
            value = findattr(element=element,
                             xpath=values['xpath'],
                             namespace=self.namespace)
            if value:
                try:
                    extra[attribute] = transform_func(value)
                except Exception:
                    extra[attribute] = None
            else:
                extra[attribute] = value

        return extra

    def _get_internet_related_params(self, ex_internet_charge_type,
                                     ex_internet_max_bandwidth_in,
                                     ex_internet_max_bandwidth_out):
        params = {}
        if ex_internet_charge_type:
            params['InternetChargeType'] = ex_internet_charge_type
            if ex_internet_charge_type.lower() == 'paybytraffic':
                if ex_internet_max_bandwidth_out:
                    params['InternetMaxBandwidthOut'] = \
                        ex_internet_max_bandwidth_out
                else:
                    raise AttributeError('ex_internet_max_bandwidth_out is '
                                         'mandatory for PayByTraffic internet'
                                         ' charge type.')
            elif ex_internet_max_bandwidth_out:
                params['InternetMaxBandwidthOut'] = \
                    ex_internet_max_bandwidth_out

        if ex_internet_max_bandwidth_in:
            params['InternetMaxBandwidthIn'] = \
                ex_internet_max_bandwidth_in
        return params

    def _get_system_disk(self, ex_system_disk):
        if not isinstance(ex_system_disk, dict):
            raise AttributeError('ex_system_disk is not a dict')
        sys_disk_dict = ex_system_disk
        key_base = 'SystemDisk.'
        # TODO(samsong8610): Use a type instead of dict
        mappings = {'category': 'Category',
                    'disk_name': 'DiskName',
                    'description': 'Description'}
        params = {}
        for attr in mappings.keys():
            if attr in sys_disk_dict:
                params[key_base + mappings[attr]] = sys_disk_dict[attr]
        return params

    def _get_data_disks(self, ex_data_disks):
        if isinstance(ex_data_disks, dict):
            data_disks = [ex_data_disks]
        elif isinstance(ex_data_disks, list):
            data_disks = ex_data_disks
        else:
            raise AttributeError('ex_data_disks should be a list of dict')
        # TODO(samsong8610): Use a type instead of dict
        mappings = {'size': 'Size',
                    'category': 'Category',
                    'snapshot_id': 'SnapshotId',
                    'disk_name': 'DiskName',
                    'description': 'Description',
                    'device': 'Device',
                    'delete_with_instance': 'DeleteWithInstance'}
        params = {}
        for idx, disk in enumerate(data_disks):
            key_base = 'DataDisk.{0}.'.format(idx + 1)
            for attr in mappings.keys():
                if attr in disk:
                    if attr == 'delete_with_instance':
                        # Convert bool value to str
                        value = str(disk[attr]).lower()
                    else:
                        value = disk[attr]
                    params[key_base + mappings[attr]] = value
        return params

    def _get_vpc_attributes(self, instance):
        vpcs = findall(instance, xpath='VpcAttributes',
                       namespace=self.namespace)
        if len(vpcs) <= 0:
            return None
        return self._get_extra_dict(
            vpcs[0], RESOURCE_EXTRA_ATTRIBUTES_MAP['vpc_attributes'])

    def _get_eip_address(self, instance):
        eips = findall(instance, xpath='EipAddress',
                       namespace=self.namespace)
        if len(eips) <= 0:
            return None
        return self._get_extra_dict(
            eips[0], RESOURCE_EXTRA_ATTRIBUTES_MAP['eip_address_associate'])

    def _get_operation_locks(self, instance):
        locks = findall(instance, xpath='OperationLocks',
                        namespace=self.namespace)
        if len(locks) <= 0:
            return None
        return self._get_extra_dict(
            locks[0], RESOURCE_EXTRA_ATTRIBUTES_MAP['operation_locks'])

    def _wait_until_state(self, nodes, state, wait_period=3, timeout=600):
        """
        Block until the provided nodes are in the desired state.
        :param nodes: List of nodes to wait for
        :type nodes: ``list`` of :class:`.Node`
        :param state: desired state
        :type state: ``NodeState``
        :param wait_period: How many seconds to wait between each loop
                            iteration. (default is 3)
        :type wait_period: ``int``
        :param timeout: How many seconds to wait before giving up.
                        (default is 600)
        :type timeout: ``int``
        :return: if the nodes are in the desired state.
        :rtype: ``bool``
        """
        start = time.time()
        end = start + timeout
        node_ids = [node.id for node in nodes]

        while(time.time() < end):
            matched_nodes = self.list_nodes(ex_node_ids=node_ids)
            if len(matched_nodes) > len(node_ids):
                found_ids = [node.id for node in matched_nodes]
                msg = ('found multiple nodes with same ids, '
                       'desired ids: %(ids)s, found ids: %(found_ids)s' %
                       {'ids': node_ids, 'found_ids': found_ids})
                raise LibcloudError(value=msg, driver=self)
            desired_nodes = [node for node in matched_nodes
                             if node.state == state]

            if len(desired_nodes) == len(node_ids):
                return True
            else:
                time.sleep(wait_period)
                continue

        raise LibcloudError(value='Timed out after %s seconds' % (timeout),
                            driver=self)

    def _to_volume(self, element):
        _id = findtext(element, 'DiskId', namespace=self.namespace)
        name = findtext(element, 'DiskName', namespace=self.namespace)
        size = int(findtext(element, 'Size', namespace=self.namespace))
        status_str = findtext(element, 'Status', namespace=self.namespace)
        status = self.VOLUME_STATE_MAPPING.get(status_str,
                                               StorageVolumeState.UNKNOWN)

        extra = self._get_extra_dict(element,
                                     RESOURCE_EXTRA_ATTRIBUTES_MAP['volume'])
        extra['operation_locks'] = self._get_operation_locks(element)
        return StorageVolume(_id, name, size, self, state=status, extra=extra)

    def _list_to_json_array(self, value):
        try:
            return json.dumps(value)
        except Exception:
            raise AttributeError('could not convert list to json array')

    def _to_snapshot(self, element):
        _id = findtext(element, 'SnapshotId', namespace=self.namespace)
        created = findtext(element, 'CreationTime', namespace=self.namespace)
        status_str = findtext(element, 'Status', namespace=self.namespace)
        state = self.SNAPSHOT_STATE_MAPPING.get(status_str,
                                                VolumeSnapshotState.UNKNOWN)
        extra = self._get_extra_dict(element,
                                     RESOURCE_EXTRA_ATTRIBUTES_MAP['snapshot'])
        return VolumeSnapshot(id=_id, driver=self, extra=extra,
                              created=created, state=state)

    def _to_size(self, element):
        _id = findtext(element, 'InstanceTypeId', namespace=self.namespace)
        ram = float(findtext(element, 'MemorySize', namespace=self.namespace))
        extra = {}
        extra['cpu_core_count'] = int(findtext(element, 'CpuCoreCount',
                                               namespace=self.namespace))
        extra['instance_type_family'] = findtext(element, 'InstanceTypeFamily',
                                                 namespace=self.namespace)
        return NodeSize(id=_id, name=_id, ram=ram, disk=None, bandwidth=None,
                        price=None, driver=self, extra=extra)

    def _to_location(self, element):
        _id = findtext(element, 'RegionId', namespace=self.namespace)
        localname = findtext(element, 'LocalName', namespace=self.namespace)
        return NodeLocation(id=_id, name=localname, country=None, driver=self)

    def _to_image(self, element):
        _id = findtext(element, 'ImageId', namespace=self.namespace)
        name = findtext(element, 'ImageName', namespace=self.namespace)
        extra = self._get_extra_dict(element,
                                     RESOURCE_EXTRA_ATTRIBUTES_MAP['image'])
        extra['disk_device_mappings'] = self._get_disk_device_mappings(
            element.find('DiskDeviceMappings'))
        return NodeImage(id=_id, name=name, driver=self, extra=extra)

    def _get_disk_device_mappings(self, element):
        if element is None:
            return None
        mapping_element = element.find('DiskDeviceMapping')
        if mapping_element is not None:
            return self._get_extra_dict(
                mapping_element,
                RESOURCE_EXTRA_ATTRIBUTES_MAP['disk_device_mapping'])
        return None

    def _to_security_group(self, element):
        _id = findtext(element, 'SecurityGroupId', namespace=self.namespace)
        name = findtext(element, 'SecurityGroupName',
                        namespace=self.namespace)
        description = findtext(element, 'Description',
                               namespace=self.namespace)
        vpc_id = findtext(element, 'VpcId', namespace=self.namespace)
        creation_time = findtext(element, 'CreationTime',
                                 namespace=self.namespace)
        return ECSSecurityGroup(_id, name, description=description,
                                driver=self, vpc_id=vpc_id,
                                creation_time=creation_time)

    def _to_security_group_attribute(self, element):
        ip_protocol = findtext(element, 'IpProtocol', namespace=self.namespace)
        port_range = findtext(element, 'PortRange', namespace=self.namespace)
        source_group_id = findtext(element, 'SourceGroupId',
                                   namespace=self.namespace)
        policy = findtext(element, 'Policy', namespace=self.namespace)
        nic_type = findtext(element, 'NicType', namespace=self.namespace)
        return ECSSecurityGroupAttribute(ip_protocol=ip_protocol,
                                         port_range=port_range,
                                         source_group_id=source_group_id,
                                         policy=policy, nic_type=nic_type)

    def _to_zone(self, element):
        _id = findtext(element, 'ZoneId', namespace=self.namespace)
        local_name = findtext(element, 'LocalName', namespace=self.namespace)
        resource_types = findall(element,
                                 'AvailableResourceCreation/ResourceTypes',
                                 namespace=self.namespace)
        instance_types = findall(element,
                                 'AvailableInstanceTypes/InstanceTypes',
                                 namespace=self.namespace)
        disk_categories = findall(element,
                                  'AvailableDiskCategories/DiskCategories',
                                  namespace=self.namespace)

        def _text(element):
            return element.text

        return ECSZone(id=_id, name=local_name, driver=self,
                       available_resource_types=list(
                           map(_text, resource_types)),
                       available_instance_types=list(
                           map(_text, instance_types)),
                       available_disk_categories=list(
                           map(_text, disk_categories)))

    def _get_pagination(self, element):
        page_number = int(findtext(element, 'PageNumber'))
        total_count = int(findtext(element, 'TotalCount'))
        page_size = int(findtext(element, 'PageSize'))
        return Pagination(total=total_count, size=page_size,
                          current=page_number)

    def _request_multiple_pages(self, path, params, parse_func):
        """
        Request all resources by multiple pages.
        :param path: the resource path
        :type path: ``str``
        :param params: the query parameters
        :type params: ``dict``
        :param parse_func: the function object to parse the response body
        :param type: ``function``
        :return: list of resource object, if not found any, return []
        :rtype: ``list``
        """
        results = []
        while True:
            one_page = self.connection.request(path, params).object
            resources = parse_func(one_page)
            results += resources
            pagination = self._get_pagination(one_page)
            if pagination.next() is None:
                break
            params.update(pagination.to_dict())
        return results