22

✏️ Editing: outscale.py

# 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.
"""
Outscale SDK
"""

import json
from typing import List
from datetime import datetime

import requests

from libcloud.common.osc import OSCRequestSignerAlgorithmV4
from libcloud.common.base import ConnectionUserAndKey
from libcloud.compute.base import (
    Node,
    KeyPair,
    NodeImage,
    NodeDriver,
    NodeLocation,
    StorageVolume,
    VolumeSnapshot,
)
from libcloud.compute.types import Provider, NodeState

class OutscaleNodeDriver(NodeDriver):
    """
    Outscale SDK node driver
    """

type = Provider.OUTSCALE
    name = "Outscale API"
    website = "http://www.outscale.com"

def __init__(
        self,
        key: str = None,
        secret: str = None,
        region: str = "eu-west-2",
        service: str = "api",
        version: str = "latest",
        base_uri: str = "outscale.com",
    ):
        self.key = key
        self.secret = secret
        self.region = region
        self.connection = ConnectionUserAndKey(self.key, self.secret)
        self.connection.region_name = region
        self.connection.service_name = service
        self.service_name = service
        self.base_uri = base_uri
        self.version = version
        self.signer = OSCRequestSignerAlgorithmV4(
            access_key=self.key,
            access_secret=self.secret,
            version=self.version,
            connection=self.connection,
        )
        self.NODE_STATE = {
            "pending": NodeState.PENDING,
            "running": NodeState.RUNNING,
            "shutting-down": NodeState.UNKNOWN,
            "terminated": NodeState.TERMINATED,
            "stopped": NodeState.STOPPED,
        }

def list_locations(self, ex_dry_run: bool = False):
        """
        Lists available locations details.

:param      ex_dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       ex_dry_run: ``bool``
        :return: locations details
        :rtype: ``dict``
        """
        action = "ReadLocations"
        data = json.dumps({"DryRun": ex_dry_run})
        response = self._call_api(action, data)
        if response.status_code == 200:
            return self._to_locations(response.json()["Locations"])
        return response.json()

def ex_list_regions(self, ex_dry_run: bool = False):
        """
        Lists available regions details.

:param      ex_dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       ex_dry_run: ``bool``
        :return: regions details
        :rtype: ``dict``
        """
        action = "ReadRegions"
        data = json.dumps({"DryRun": ex_dry_run})
        response = self._call_api(action, data)
        if response.status_code == 200:
            return response.json()["Regions"]
        return response.json()

def ex_list_subregions(self, ex_dry_run: bool = False):
        """
        Lists available subregions details.

:param      ex_dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       ex_dry_run: ``bool``
        :return: subregions details
        :rtype: ``dict``
        """
        action = "ReadSubregions"
        data = json.dumps({"DryRun": ex_dry_run})
        response = self._call_api(action, data)
        if response.status_code == 200:
            return response.json()["Subregions"]
        return response.json()

def ex_create_public_ip(self, dry_run: bool = False):
        """
        Create a new public ip.

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:return: the created public ip
        :rtype: ``dict``
        """
        action = "CreatePublicIp"
        data = json.dumps({"DryRun": dry_run})
        response = self._call_api(action, data)
        if response.status_code == 200:
            return response.json()["PublicIp"]
        return response.json()

def ex_delete_public_ip(
        self, dry_run: bool = False, public_ip: str = None, public_ip_id: str = None
    ):
        """
        Delete public ip.

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:param      public_ip: The EIP. In the public Cloud, this parameter is
        required.
        :type       public_ip: ``str``

:param      public_ip_id: The ID representing the association of the
        EIP with the VM or the NIC. In a Net,
        this parameter is required.
        :type       public_ip_id: ``str``

:return: request
        :rtype: ``dict``
        """
        action = "DeletePublicIp"
        data = {"DryRun": dry_run}
        if public_ip is not None:
            data.update({"PublicIp": public_ip})
        if public_ip_id is not None:
            data.update({"PublicIpId": public_ip_id})
        data = json.dumps(data)
        response = self._call_api(action, data)
        if response.status_code == 200:
            return True
        return response.json()

def ex_list_public_ips(self, data: str = "{}"):
        """
        List all public IPs.

:param      data: json stringify following the outscale api
        documentation for filter
        :type       data: ``string``

:return: nodes
        :rtype: ``dict``
        """
        action = "ReadPublicIps"
        response = self._call_api(action, data)
        if response.status_code == 200:
            return response.json()["PublicIps"]
        return response.json()

def ex_list_public_ip_ranges(self, dry_run: bool = False):
        """
        Lists available regions details.

:param      dry_run: If true, checks whether you have the
        required permissions to perform the action.
        :type       dry_run: ``bool``

:return: regions details
        :rtype: ``dict``
        """
        action = "ReadPublicIpRanges"
        data = json.dumps({"DryRun": dry_run})
        response = self._call_api(action, data)
        if response.status_code == 200:
            return response.json()["PublicIps"]
        return response.json()

def ex_attach_public_ip(
        self,
        allow_relink: bool = None,
        dry_run: bool = False,
        nic_id: str = None,
        vm_id: str = None,
        public_ip: str = None,
        public_ip_id: str = None,
    ):
        """
        Attach public ip to a node.

:param      allow_relink: If true, allows the EIP to be associated
        with the VM or NIC that you specify even if
        it is already associated with another VM or NIC.
        :type       allow_relink: ``bool``

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:param      nic_id:(Net only) The ID of the NIC. This parameter is
        required if the VM has more than one NIC attached. Otherwise,
        you need to specify the VmId parameter instead.
        You cannot specify both parameters
        at the same time.
        :type       nic_id: ``str``

:param      vm_id: the ID of the VM
        :type       nic_id: ``str``

:param      public_ip: The EIP. In the public Cloud, this parameter
        is required.
        :type       public_ip: ``str``

:param      public_ip_id: The allocation ID of the EIP. In a Net,
        this parameter is required.
        :type       public_ip_id: ``str``

:return: the attached volume
        :rtype: ``dict``
        """
        action = "LinkPublicIp"
        data = {"DryRun": dry_run}
        if public_ip is not None:
            data.update({"PublicIp": public_ip})
        if public_ip_id is not None:
            data.update({"PublicIpId": public_ip_id})
        if nic_id is not None:
            data.update({"NicId": nic_id})
        if vm_id is not None:
            data.update({"VmId": vm_id})
        if allow_relink is not None:
            data.update({"AllowRelink": allow_relink})
        data = json.dumps(data)
        response = self._call_api(action, data)
        if response.status_code == 200:
            return True
        return response.json()

def ex_detach_public_ip(
        self,
        public_ip: str = None,
        link_public_ip_id: str = None,
        dry_run: bool = False,
    ):
        """
        Detach public ip from a node.

:param      public_ip: (Required in a Net) The ID representing the
        association of the EIP with the VM or the NIC
        :type       public_ip: ``str``

:param      link_public_ip_id: (Required in a Net) The ID
        representing the association of the EIP with the
        VM or the NIC.
        :type       link_public_ip_id: ``str``

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:return: the attached volume
        :rtype: ``dict``
        """
        action = "UnlinkPublicIp"
        data = {"DryRun": dry_run}
        if public_ip is not None:
            data.update({"PublicIp": public_ip})
        if link_public_ip_id is not None:
            data.update({"LinkPublicIpId": link_public_ip_id})
        data = json.dumps(data)
        response = self._call_api(action, data)
        if response.status_code == 200:
            return True
        return response.json()

def create_node(
        self,
        image: NodeImage,
        name: str = None,
        ex_dry_run: bool = False,
        ex_block_device_mapping: dict = None,
        ex_boot_on_creation: bool = True,
        ex_bsu_optimized: bool = True,
        ex_client_token: str = None,
        ex_deletion_protection: bool = False,
        ex_keypair_name: str = None,
        ex_max_vms_count: int = None,
        ex_min_vms_count: int = None,
        ex_nics: List[dict] = None,
        ex_performance: str = None,
        ex_placement: dict = None,
        ex_private_ips: List[str] = None,
        ex_security_group_ids: List[str] = None,
        ex_security_groups: List[str] = None,
        ex_subnet_id: str = None,
        ex_user_data: str = None,
        ex_vm_initiated_shutdown_behavior: str = None,
        ex_vm_type: str = None,
    ):
        """
        Create a new instance.

:param      image: The image used to create the VM.
        :type       image: ``NodeImage``

:param      name: The name of the Node.
        :type       name: ``str``

:param      ex_dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       ex_dry_run: ``bool``

:param      ex_block_device_mapping: One or more block device mappings.
        :type       ex_block_device_mapping: ``dict``

:param      ex_boot_on_creation: By default or if true, the VM is
        started on creation. If false, the VM is
        stopped on creation.
        :type       ex_boot_on_creation: ``bool``

:param      ex_bsu_optimized: If true, the VM is created with optimized
        BSU I/O.
        :type       ex_bsu_optimized: ``bool``

:param      ex_client_token: A unique identifier which enables you to
        manage the idempotency.
        :type       ex_client_token: ``bool``

:param      ex_deletion_protection: If true, you cannot terminate the
        VM using Cockpit, the CLI or the API.
        If false, you can.
        :type       ex_deletion_protection: ``bool``

:param      ex_keypair_name: The name of the keypair.
        :type       ex_keypair_name: ``str``

:param      ex_max_vms_count: The maximum number of VMs you want to
        create. If all the VMs cannot be created, the
        largest possible number of VMs above MinVmsCount is created.
        :type       ex_max_vms_count: ``integer``

:param      ex_min_vms_count: The minimum number of VMs you want to
        create. If this number of VMs cannot be
        created, no VMs are created.
        :type       ex_min_vms_count: ``integer``

:param      ex_nics: One or more NICs. If you specify this parameter,
        you must define one NIC as the primary
        network interface of the VM with 0 as its device number.
        :type       ex_nics: ``list`` of ``dict``

:param      ex_performance: The performance of the VM (standard | high
        | highest).
        :type       ex_performance: ``str``

:param      ex_placement: Information about the placement of the VM.
        :type       ex_placement: ``dict``

:param      ex_private_ips: One or more private IP addresses of the VM.
        :type       ex_private_ips: ``list``

:param      ex_security_group_ids: One or more IDs of security group
        for the VMs.
        :type       ex_security_group_ids: ``list``

:param      ex_security_groups: One or more names of security groups
        for the VMs.
        :type       ex_security_groups: ``list``

:param      ex_subnet_id: The ID of the Subnet in which you want to
        create the VM.
        :type       ex_subnet_id: ``str``

:param      ex_user_data: Data or script used to add a specific
        configuration to the VM. It must be base64-encoded.
        :type       ex_user_data: ``str``

:param      ex_vm_initiated_shutdown_behavior: The VM behavior when
        you stop it. By default or if set to stop, the
        VM stops. If set to restart, the VM stops then automatically restarts.
        If set to terminate, the VM stops and is terminated.
        create the VM.
        :type       ex_vm_initiated_shutdown_behavior: ``str``

:param      ex_vm_type: The type of VM (t2.small by default).
        :type       ex_vm_type: ``str``

:return: the created instance
        :rtype: ``dict``
        """
        data = {
            "DryRun": ex_dry_run,
            "BootOnCreation": ex_boot_on_creation,
            "BsuOptimized": ex_bsu_optimized,
            "ImageId": image.id,
        }
        if ex_block_device_mapping is not None:
            data.update({"BlockDeviceMappings": ex_block_device_mapping})
        if ex_client_token is not None:
            data.update({"ClientToken": ex_client_token})
        if ex_deletion_protection is not None:
            data.update({"DeletionProtection": ex_deletion_protection})
        if ex_keypair_name is not None:
            data.update({"KeypairName": ex_keypair_name})
        if ex_max_vms_count is not None:
            data.update({"MaxVmsCount": ex_max_vms_count})
        if ex_min_vms_count is not None:
            data.update({"MinVmsCount": ex_min_vms_count})
        if ex_nics is not None:
            data.update({"Nics": ex_nics})
        if ex_performance is not None:
            data.update({"Performance": ex_performance})
        if ex_placement is not None:
            data.update({"Placement": ex_placement})
        if ex_private_ips is not None:
            data.update({"PrivateIps": ex_private_ips})
        if ex_security_group_ids is not None:
            data.update({"SecurityGroupIds": ex_security_group_ids})
        if ex_security_groups is not None:
            data.update({"SecurityGroups": ex_security_groups})
        if ex_user_data is not None:
            data.update({"UserData": ex_user_data})
        if ex_vm_initiated_shutdown_behavior is not None:
            data.update({"VmInstantiatedShutdownBehavior": ex_vm_initiated_shutdown_behavior})
        if ex_vm_type is not None:
            data.update({"VmType": ex_vm_type})
        if ex_subnet_id is not None:
            data.update({"SubnetId": ex_subnet_id})
        action = "CreateVms"
        data = json.dumps(data)
        node = self._to_node(self._call_api(action, data).json()["Vms"][0])
        if name is not None:
            action = "CreateTags"
            data = {
                "DryRun": ex_dry_run,
                "ResourceIds": [node.id],
                "Tags": {"Key": "Name", "Value": name},
            }
            data = json.dumps(data)
            response = self._call_api(action, data)
            if response.status_code != 200:
                return response.json()
            action = "ReadVms"
            data = {"DryRun": ex_dry_run, "Filters": {"VmIds": [node.id]}}
            return self._to_node(self._call_api(action, json.dumps(data)).json()["Vms"][0])
        return node

def reboot_node(self, node: Node):
        """
        Reboot instance.

:param      node: VM(s) you want to reboot (required)
        :type       node: ``list``

:return: the rebooted instances
        :rtype: ``dict``
        """
        action = "RebootVms"
        data = json.dumps({"VmIds": [node.id]})
        response = self._call_api(action, data)
        if response.status_code == 200:
            return True
        return response.json()

def start_node(self, node: Node):
        """
        Start a Vm.

:param      node: the  VM(s)
                    you want to start (required)
        :type       node: ``Node``

:return: the rebooted instances
        :rtype: ``bool``
        """
        action = "StartVms"
        data = json.dumps({"VmIds": [node.id]})
        response = self._call_api(action, data)
        if response.status_code == 200:
            return True
        return response.json()

def stop_node(self, node: Node):
        """
        Stop a Vm.

:param      node: the  VM(s)
                    you want to stop (required)
        :type       node: ``Node``

:return: the rebooted instances
        :rtype: ``bool``
        """
        action = "StopVms"
        data = json.dumps({"VmIds": [node.id]})
        response = self._call_api(action, data)
        if response.status_code == 200:
            return True
        return response.json()

def list_nodes(self, ex_data: str = "{}"):
        """
        List all nodes.

:return: nodes
        :rtype: ``dict``
        """
        action = "ReadVms"
        response = self._call_api(action, ex_data)
        if response.status_code == 200:
            return self._to_nodes(response.json()["Vms"])
        return response.json()

def destroy_node(self, node: Node):
        """
        Delete instance.

:param      node: one or more IDs of VMs (required)
        :type       node: ``Node``

:return: request
        :rtype: ``bool``
        """
        action = "DeleteVms"
        data = json.dumps({"VmIds": node.id})
        response = self._call_api(action, data)
        if response.status_code == 200:
            return True
        return response.json()

def ex_read_admin_password_node(self, node: Node, dry_run: bool = False):
        """
        Retrieves the administrator password for a Windows running virtual
        machine (VM).
        The administrator password is encrypted using the keypair you
        specified when launching the VM.

:param      node: the ID of the VM (required)
        :type       node: ``Node``

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:return: The Admin Password of the specified Node.
        :rtype: ``str``
        """
        action = "ReadAdminPassword"
        data = json.dumps({"DryRun": dry_run, "VmId": node.id})
        response = self._call_api(action, data)
        if response.status_code == 200:
            return response.json()["AdminPassword"]
        return response.json()

def ex_read_console_output_node(self, node: Node, dry_run: bool = False):
        """
        Gets the console output for a virtual machine (VM). This console
        provides the most recent 64 KiB output.

:param      node: the ID of the VM (required)
        :type       node: ``Node``

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:return: The Console Output of the specified Node.
        :rtype: ``str``
        """
        action = "ReadConsoleOutput"
        data = json.dumps({"DryRun": dry_run, "VmId": node.id})
        response = self._call_api(action, data)
        if response.status_code == 200:
            return response.json()["ConsoleOutput"]
        return response.json()

def ex_list_node_types(
        self,
        bsu_optimized: bool = None,
        memory_sizes: List[int] = None,
        vcore_counts: List[int] = None,
        vm_type_names: List[str] = None,
        volume_counts: List[int] = None,
        volume_sizes: List[int] = None,
        dry_run: bool = False,
    ):
        """
        Lists one or more predefined VM types.

:param      bsu_optimized: Indicates whether the VM is optimized for
        BSU I/O.
        :type       bsu_optimized: ``bool``

:param      memory_sizes: The amounts of memory, in gibibytes (GiB).
        :type       memory_sizes: ``list`` of ``int``

:param      vcore_counts: The numbers of vCores.
        :type       vcore_counts: ``list`` of ``int``

:param      vm_type_names: The names of the VM types. For more
        information, see Instance Types.
        :type       vm_type_names: ``list`` of ``str``

:param      volume_counts: The maximum number of ephemeral storage
        disks.
        :type       volume_counts: ``list`` of ``int``

:param      volume_sizes: The size of one ephemeral storage disk,
        in gibibytes (GiB).
        :type       volume_sizes: ``list`` of ``int``

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:return: list of vm types
        :rtype: ``list`` of ``dict``
        """
        action = "ReadVmTypes"
        data = {"Filters": {}, "DryRun": dry_run}
        if bsu_optimized is not None:
            data["Filters"].update({"BsuOptimized": bsu_optimized})
        if memory_sizes is not None:
            data["Filters"].update({"MemorySizes": memory_sizes})
        if vcore_counts is not None:
            data["Filters"].update({"VcoreCounts": vcore_counts})
        if vm_type_names is not None:
            data["Filters"].update({"VmTypeNames": vm_type_names})
        if volume_counts is not None:
            data["Filters"].update({"VolumeCounts": volume_counts})
        if volume_sizes is not None:
            data["Filters"].update({"VolumeSizes": volume_sizes})
        response = self._call_api(action, json.dumps(data))
        if response.status_code == 200:
            return response.json()["VmTypes"]
        return response.json()

def ex_list_nodes_states(
        self,
        all_vms: bool = None,
        subregion_names: List[str] = None,
        vm_ids: List[str] = None,
        vm_states: List[str] = None,
        dry_run: bool = False,
    ):
        """
        Lists the status of one or more virtual machines (VMs).

:param      all_vms: If true, includes the status of all VMs. By
        default or if set to false, only includes the status of running VMs.
        :type       all_vms: ``bool``

:param      subregion_names: The names of the Subregions of the VMs.
        :type       subregion_names: ``list`` of ``str``

:param      vm_ids: One or more IDs of VMs.
        :type       vm_ids: ``list`` of ``str``

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:return: list the status of one or more vms
        :rtype: ``list`` of ``dict``
        """
        action = "ReadVmsState"
        data = {"Filters": {}, "DryRun": dry_run}
        if all_vms is not None:
            data.update({"AllVms": all_vms})
        if subregion_names is not None:
            data["Filters"].update({"SubregionNames": subregion_names})
        if vm_ids is not None:
            data["Filters"].update({"VmIds": vm_ids})
        if vm_states is not None:
            data["Filters"].update({"VmStates": vm_states})
        response = self._call_api(action, json.dumps(data))
        if response.status_code == 200:
            return response.json()["VmStates"]
        return response.json()

def ex_update_node(
        self,
        block_device_mapping: List[dict],
        bsu_optimized: bool = None,
        deletion_protection: bool = False,
        is_source_dest_checked: bool = None,
        keypair_name: str = True,
        performance: str = True,
        security_group_ids: List[str] = None,
        user_data: str = False,
        vm_id: str = None,
        vm_initiated_shutown_behavior: str = None,
        vm_type: int = None,
        dry_run: bool = False,
    ):
        """
        Modifies a specific attribute of a Node (VM).
        You can modify only one attribute at a time. You can modify the
        IsSourceDestChecked attribute only if the VM is in a Net.
        You must stop the VM before modifying the following attributes:

- VmType
        - UserData
        - BsuOptimized

:param      block_device_mapping: One or more block device mappings
        of the VM.
        :type       block_device_mapping: ``dict``

:param      bsu_optimized: If true, the VM is optimized for BSU I/O.
        :type       bsu_optimized: ``bool``

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:param      deletion_protection: If true, you cannot terminate the VM
        using Cockpit, the CLI or the API. If false, you can.
        :type       deletion_protection: ``bool``

:param      is_source_dest_checked: (Net only) If true, the
        source/destination check is enabled. If false, it is disabled. This
        value must be false for a NAT VM to perform network address
        translation (NAT) in a Net.
        :type       is_source_dest_checked: ``bool``

:param      keypair_name: The name of the keypair.
        :type       keypair_name: ``str``

:param      performance: The performance of the VM
        (standard | high | highest).
        :type       performance: ``str``

:param      security_group_ids: One or more IDs of security groups for
        the VM.
        :type       security_group_ids: ``bool``

:param      user_data: The Base64-encoded MIME user data.
        :type       user_data: ``str``

:param      vm_id: The ID of the VM. (required)
        :type       vm_id: ``str``

:param      vm_initiated_shutown_behavior: The VM behavior when you
        stop it. By default or if set to stop, the VM stops. If set to
        restart, the VM stops then automatically restarts. If set to
        terminate, the VM stops and is terminated.
        :type       vm_initiated_shutown_behavior: ``str``

:param      vm_type: The type of VM. For more information,
        see Instance Types:
        https://wiki.outscale.net/display/EN/Instance+Types
        :type       vm_type: ``str``

:return: the updated Node
        :rtype: ``dict``
        """
        action = "UpdateVm"
        data = {
            "DryRun": dry_run,
        }
        if block_device_mapping is not None:
            data.update({"BlockDeviceMappings": block_device_mapping})
        if bsu_optimized is not None:
            data.update({"BsuOptimized": bsu_optimized})
        if deletion_protection is not None:
            data.update({"DeletionProtection": deletion_protection})
        if keypair_name is not None:
            data.update({"KeypairName": keypair_name})
        if is_source_dest_checked is not None:
            data.update({"IsSourceDestChecked": is_source_dest_checked})
        if performance is not None:
            data.update({"Performance": performance})
        if security_group_ids is not None:
            data.update({"SecurityGroupIds": security_group_ids})
        if user_data is not None:
            data.update({"UserDate": user_data})
        if vm_id is not None:
            data.update({"VmId": vm_id})
        if vm_initiated_shutown_behavior is not None:
            data.update({"VmInitiatedShutdownBehavior": vm_initiated_shutown_behavior})
        if vm_type is not None:
            data.update({"VmType": vm_type})
        response = self._call_api(action, json.dumps(data))
        if response.status_code == 200:
            return self._to_node(response.json()["Vm"])
        return response.json()

def create_image(
        self,
        ex_architecture: str = None,
        node: Node = None,
        name: str = None,
        description: str = None,
        ex_block_device_mapping: dict = None,
        ex_no_reboot: bool = False,
        ex_root_device_name: str = None,
        ex_dry_run: bool = False,
        ex_source_region_name: str = None,
        ex_file_location: str = None,
    ):
        """
        Create a new image.

:param      node: a valid Node object
        :type       node: ``str``

:param      ex_architecture: The architecture of the OMI (by default,
        i386).
        :type       ex_architecture: ``str``

:param      description: a description for the new OMI
        :type       description: ``str``

:param      name: A unique name for the new OMI.
        :type       name: ``str``

:param      ex_block_device_mapping: One or more block device mappings.
        :type       ex_block_device_mapping: ``dict``

:param      ex_no_reboot: If false, the VM shuts down before creating
        the OMI and then reboots.
        If true, the VM does not.
        :type       ex_no_reboot: ``bool``

:param      ex_root_device_name: The name of the root device.
        :type       ex_root_device_name: ``str``

:param      ex_source_region_name: The name of the source Region,
        which must be the same
        as the Region of your account.
        :type       ex_source_region_name: ``str``

:param      ex_file_location: The pre-signed URL of the OMI manifest
        file, or the full path to the OMI stored in
        an OSU bucket. If you specify this parameter, a copy of the OMI is
        created in your account.
        :type       ex_file_location: ``str``

:param      ex_dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       ex_dry_run: ``bool``

:return: the created image
        :rtype: ``dict``
        """
        data = {
            "DryRun": ex_dry_run,
            "NoReboot": ex_no_reboot,
        }
        if ex_block_device_mapping is not None:
            data.update({"BlockDeviceMappings": ex_block_device_mapping})
        if name is not None:
            data.update({"ImageName": name})
        if description is not None:
            data.update({"Description": description})
        if node.id is not None:
            data.update({"VmId": node.id})
        if ex_root_device_name is not None:
            data.update({"RootDeviceName": ex_root_device_name})
        if ex_source_region_name is not None:
            data.update({"SourceRegionName": ex_source_region_name})
        if ex_file_location is not None:
            data.update({"FileLocation": ex_file_location})
        data = json.dumps(data)
        action = "CreateImage"
        response = self._call_api(action, data)
        if response.status_code == 200:
            return self._to_node_image(response.json()["Image"])
        return response.json()

def ex_create_image_export_task(
        self,
        image: NodeImage = None,
        osu_export_disk_image_format: str = None,
        osu_export_api_key_id: str = None,
        osu_export_api_secret_key: str = None,
        osu_export_bucket: str = None,
        osu_export_manifest_url: str = None,
        osu_export_prefix: str = None,
        dry_run: bool = False,
    ):
        """
        Exports an Outscale machine image (OMI) to an Object Storage Unit
        (OSU) bucket.
        This action enables you to copy an OMI between accounts in different
        Regions. To copy an OMI in the same Region,
        you can also use the CreateImage method.
        The copy of the OMI belongs to you and is
        independent from the source OMI.

:param      image: The ID of the OMI to export. (required)
        :type       image: ``NodeImage``

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:param      osu_export_disk_image_format: The format of the
        export disk (qcow2 | vdi | vmdk). (required)
        :type       osu_export_disk_image_format: ``str``

:param      osu_export_api_key_id: The API key of the OSU
        account that enables you to access the bucket.
        :type       osu_export_api_key_id: ``str``

:param      osu_export_api_secret_key: The secret key of the
        OSU account that enables you to access the bucket.
        :type       osu_export_api_secret_key: ``str``

:param      osu_export_bucket: The name of the OSU bucket
        you want to export the object to. (required)
        :type       osu_export_bucket: ``str``

:param      osu_export_manifest_url: The URL of the manifest file.
        :type       osu_export_manifest_url: ``str``

:param      osu_export_prefix: The prefix for the key of
        the OSU object. This key follows this format:
        prefix + object_export_task_id + '.' + disk_image_format.
        :type       osu_export_prefix: ``str``

:return: the created image export task
        :rtype: ``dict``
        """
        action = "CreateImageExportTask"
        data = {"DryRun": dry_run, "OsuExport": {"OsuApiKey": {}}}
        if image is not None:
            data.update({"ImageId": image.id})
        if osu_export_disk_image_format is not None:
            data["OsuExport"].update({"DiskImageFormat": osu_export_disk_image_format})
        if osu_export_bucket is not None:
            data["OsuExport"].update({"OsuBucket": osu_export_bucket})
        if osu_export_manifest_url is not None:
            data["OsuExport"].update({"OsuManifestUrl": osu_export_manifest_url})
        if osu_export_prefix is not None:
            data["OsuExport"].update({"OsuPrefix": osu_export_prefix})
        if osu_export_api_key_id is not None:
            data["OsuExport"]["OsuApiKey"].update({"ApiKeyId": osu_export_api_key_id})
        if osu_export_api_secret_key is not None:
            data["OsuExport"]["OsuApiKey"].update({"SecretKey": osu_export_api_secret_key})
        response = self._call_api(action, json.dumps(data))
        if response.status_code == 200:
            return response.json()["ImageExportTask"]
        return response.json()

def list_images(
        self,
        account_aliases: List[str] = None,
        account_ids: List[str] = None,
        architectures: List[str] = None,
        block_device_mapping_delete_on_vm_deletion: bool = False,
        block_device_mapping_device_names: List[str] = None,
        block_device_mapping_snapshot_ids: List[str] = None,
        block_device_mapping_volume_sizes: List[int] = None,
        block_device_mapping_volume_types: List[str] = None,
        descriptions: List[str] = None,
        file_locations: List[str] = None,
        image_ids: List[str] = None,
        image_names: List[str] = None,
        permission_to_launch_account_ids: List[str] = None,
        permission_to_lauch_global_permission: bool = False,
        root_device_names: List[str] = None,
        root_device_types: List[str] = None,
        states: List[str] = None,
        tag_keys: List[str] = None,
        tag_values: List[str] = None,
        tags: List[str] = None,
        virtualization_types: List[str] = None,
        dry_run: bool = False,
    ):
        """
        Lists one or more Outscale machine images (OMIs) you can use.

:param      account_aliases: The account aliases of the
        owners of the OMIs.
        :type       account_aliases: ``list`` of ``str``

:param      account_ids: The account IDs of the owners of the
        OMIs. By default, all the OMIs for which you have launch
        permissions are described.
        :type       account_ids: ``list`` of ``str``

:param      architectures: The architectures of the
        OMIs (i386 | x86_64).
        :type       architectures: ``list`` of ``str``

:param      block_device_mapping_delete_on_vm_deletion: Indicates
        whether the block device mapping is deleted when terminating the VM.
        :type       block_device_mapping_delete_on_vm_deletion:
        ``bool``

:param      block_device_mapping_device_names: The device names for
        the volumes.
        :type       block_device_mapping_device_names: ``list`` of ``str``

:param      block_device_mapping_snapshot_ids: The IDs of the
        snapshots used to create the volumes.
        :type       block_device_mapping_snapshot_ids: ``list`` of ``str``

:param      block_device_mapping_volume_sizes: The sizes of the
        volumes, in gibibytes (GiB).
        :type       block_device_mapping_volume_sizes: ``list`` of ``int``

:param      block_device_mapping_volume_types: The types of
        volumes (standard | gp2 | io1).
        :type       block_device_mapping_volume_types: ``list`` of ``str``

:param      descriptions: The descriptions of the OMIs, provided
        when they were created.
        :type       descriptions: ``list`` of ``str``

:param      file_locations: The locations where the OMI files are
        stored on Object Storage Unit (OSU).
        :type       file_locations: ``list`` of ``str``

:param      image_ids: The IDs of the OMIs.
        :type       image_ids: ``list`` of ``str``

:param      image_names: The names of the OMIs, provided when
        they were created.
        :type       image_names: ``list`` of ``str``

:param      permission_to_launch_account_ids: The account IDs of the
        users who have launch permissions for the OMIs.
        :type       permission_to_launch_account_ids: ``list`` of ``str``

:param      permission_to_lauch_global_permission: If true, lists
        all public OMIs. If false, lists all private OMIs.
        :type       permission_to_lauch_global_permission: ``list`` of ``str``

:param      root_device_names: The device names of the root
        devices (for example, /dev/sda1).
        :type       root_device_names: ``list`` of ``str``

:param      root_device_types: The types of root device used by
        the OMIs (always bsu).
        :type       root_device_types: ``list`` of ``str``

:param      states: The states of the OMIs
        (pending | available | failed).
        :type       states: ``list`` of ``str``

:param      tag_keys: The keys of the tags associated with the OMIs.
        :type       tag_keys: ``list`` of ``str``

:param      tag_values: The values of the tags associated
        with the OMIs.
        :type       tag_values: ``list`` of ``str``

:param      tags: The key/value combination of the tags associated
        with the OMIs, in the following format:"Filters":
        {"Tags":["TAGKEY=TAGVALUE"]}.
        :type       tags: ``list`` of ``str``

:param      virtualization_types: The virtualization types
        (always hvm).
        :type       virtualization_types: ``list`` of ``str``

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:return: a list of image
        :rtype: ``list`` of ``dict``
        """
        action = "ReadImages"
        data = {"DryRun": dry_run, "Filters": {}}
        if account_aliases is not None:
            data["Filters"].update({"AccountAliases": account_aliases})
        if account_ids is not None:
            data["Filters"].update({"AccountIds": account_ids})
        if architectures is not None:
            data["Filters"].update({"Architectures": architectures})
        if block_device_mapping_delete_on_vm_deletion is not None:
            key = "BlockDeviceMappingDeleteOnVmDeletion"
            data["Filters"].update({key: block_device_mapping_delete_on_vm_deletion})
        if block_device_mapping_device_names is not None:
            key = "BlockDeviceMappingDeviceNames"
            data["Filters"].update({key: block_device_mapping_device_names})
        if block_device_mapping_snapshot_ids is not None:
            key = "BlockDeviceMappingSnapshotIds"
            data["Filters"].update({key: block_device_mapping_snapshot_ids})
        if block_device_mapping_volume_sizes is not None:
            key = "BlockDeviceMappingVolumeSizes"
            data["Filters"].update({key: block_device_mapping_volume_sizes})
        if block_device_mapping_volume_types is not None:
            key = "BlockDeviceMappingVolumeTypes"
            data["Filters"].update({key: block_device_mapping_volume_types})
        if descriptions is not None:
            data["Filters"].update({"Descriptions": descriptions})
        if file_locations is not None:
            data["Filters"].update({"FileLocations": file_locations})
        if image_ids is not None:
            data["Filters"].update({"ImageIds": image_ids})
        if image_names is not None:
            data["Filters"].update({"ImageNames": image_names})
        if permission_to_launch_account_ids is not None:
            key = "PermissionsToLaunchAccountIds"
            data["Filters"].update({key: permission_to_launch_account_ids})
        if permission_to_lauch_global_permission is not None:
            key = "PermissionsToLaunchGlobalPermission"
            data["Filters"].update({key: permission_to_lauch_global_permission})
        if root_device_names is not None:
            data["Filters"].update({"RootDeviceNames": root_device_names})
        if root_device_types is not None:
            data["Filters"].update({"RootDeviceTypes": root_device_types})
        if states is not None:
            data["Filters"].update({"States": states})
        if tag_keys is not None:
            data["Filters"].update({"TagKeys": tag_keys})
        if image_names is not None:
            data["Filters"].update({"TagValues": image_names})
        if tags is not None:
            data["Filters"].update({"Tags": tags})
        if virtualization_types is not None:
            data["Filters"].update({"VirtualizationTypes": virtualization_types})
        response = self._call_api(action, json.dumps(data))
        if response.status_code == 200:
            return response.json()["Images"]
        return response.json()

def ex_list_image_export_tasks(
        self,
        dry_run: bool = False,
        task_ids: List[str] = None,
    ):
        """
        Lists one or more image export tasks.

:param      task_ids: The IDs of the export tasks.
        :type       task_ids: ``list`` of ``str``

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:return: image export tasks
        :rtype: ``list`` of ``dict``
        """
        action = "ReadImageExportTasks"
        data = {"DryRun": dry_run, "Filters": {}}
        if task_ids is not None:
            data["Filters"].update({"TaskIds": task_ids})
        response = self._call_api(action, json.dumps(data))
        print(response.json())
        if response.status_code == 200:
            return response.json()["ImageExportTasks"]
        return response.json()

def get_image(self, image_id: str):
        """
        Get a specific image.

:param      image_id: the ID of the image you want to select (required)
        :type       image_id: ``str``

:return: the selected image
        :rtype: ``dict``
        """
        action = "ReadImages"
        data = '{"Filters": {"ImageIds": ["' + image_id + '"]}}'
        response = self._call_api(action, data)
        if response.status_code == 200:
            return self._to_node_image(response.json()["Images"][0])
        return response.json()

def delete_image(self, node_image: NodeImage):
        """
        Delete an image.

:param      node_image: the ID of the OMI you want to delete (required)
        :type       node_image: ``str``

:return: request
        :rtype: ``bool``
        """
        action = "DeleteImage"
        data = '{"ImageId": "' + node_image.id + '"}'
        response = self._call_api(action, data)
        if response.status_code == 200:
            return True
        return response.json()

def ex_update_image(
        self,
        dry_run: bool = False,
        image: NodeImage = None,
        perm_to_launch_addition_account_ids: List[str] = None,
        perm_to_launch_addition_global_permission: bool = None,
        perm_to_launch_removals_account_ids: List[str] = None,
        perm_to_launch_removals_global_permission: bool = None,
    ):
        """
        Modifies the specified attribute of an Outscale machine image (OMI).
        You can specify only one attribute at a time. You can modify
        the permissions to access the OMI by adding or removing account
        IDs or groups. You can share an OMI with a user that is in the
        same Region. The user can create a copy of the OMI you shared,
        obtaining all the rights for the copy of the OMI.
        For more information, see CreateImage.

:param      image: The ID of the OMI to export. (required)
        :type       image: ``NodeImage``

:param      perm_to_launch_addition_account_ids: The account
        ID of one or more users who have permissions for the resource.
        :type       perm_to_launch_addition_account_ids:
        ``list`` of ``dict``

:param      perm_to_launch_addition_global_permission:
        If true, the resource is public. If false, the resource is private.
        :type       perm_to_launch_addition_global_permission:
        ``boolean``

:param      perm_to_launch_removals_account_ids: The account
        ID of one or more users who have permissions for the resource.
        :type       perm_to_launch_removals_account_ids: ``list`` of ``dict``

:param      perm_to_launch_removals_global_permission: If true,
        the resource is public. If false, the resource is private.
        :type       perm_to_launch_removals_global_permission: ``boolean``

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:return: the new image
        :rtype: ``dict``
        """
        action = "UpdateImage"
        data = {
            "DryRun": dry_run,
            "PermissionsToLaunch": {"Additions": {}, "Removals": {}},
        }
        if image is not None:
            data.update({"ImageId": image.id})
        if perm_to_launch_addition_account_ids is not None:
            data["PermissionsToLaunch"]["Additions"].update(
                {"AccountIds": perm_to_launch_addition_account_ids}
            )
        if perm_to_launch_addition_global_permission is not None:
            data["PermissionsToLaunch"]["Additions"].update(
                {"GlobalPermission": perm_to_launch_addition_global_permission}
            )
        if perm_to_launch_removals_account_ids is not None:
            data["PermissionsToLaunch"]["Removals"].update(
                {"AccountIds": perm_to_launch_removals_account_ids}
            )
        if perm_to_launch_removals_global_permission is not None:
            data["PermissionsToLaunch"]["Removals"].update(
                {"GlobalPermission": perm_to_launch_removals_global_permission}
            )
        response = self._call_api(action, json.dumps(data))
        if response.status_code == 200:
            return response.json()["Image"]
        return response.json()

def create_key_pair(self, name: str, ex_dry_run: bool = False, ex_public_key: str = None):
        """
        Create a new key pair.

:param      name: A unique name for the keypair, with a maximum
        length of 255 ASCII printable characters.
        :type       name: ``str``

:param      ex_dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       ex_dry_run: ``bool``

:param      ex_public_key: The public key. It must be base64-encoded.
        :type       ex_public_key: ``str``

:return: the created key pair
        :rtype: ``dict``
        """
        data = {
            "KeypairName": name,
            "DryRun": ex_dry_run,
        }
        if ex_public_key is not None:
            data.update({"PublicKey": ex_public_key})
        data = json.dumps(data)
        action = "CreateKeypair"
        response = self._call_api(action, data)
        if response.status_code == 200:
            return self._to_key_pair(response.json()["Keypair"])
        return response.json()

def list_key_pairs(self, ex_data: str = "{}"):
        """
        List all key pairs.

:return: key pairs
        :rtype: ``dict``
        """
        action = "ReadKeypairs"
        response = self._call_api(action, ex_data)
        if response.status_code == 200:
            return self._to_key_pairs(response.json()["Keypairs"])
        return response.json()

def get_key_pair(self, name: str):
        """
        Get a specific key pair.

:param      name: the name of the key pair
                    you want to select (required)
        :type       name: ``str``

:return: the selected key pair
        :rtype: ``dict``
        """
        action = "ReadKeypairs"
        data = '{"Filters": {"KeypairNames" : ["' + name + '"]}}'
        response = self._call_api(action, data)
        if response.status_code == 200:
            return self._to_key_pair(response.json()["Keypairs"][0])
        return response.json()

def delete_key_pair(self, key_pair: KeyPair):
        """
        Delete a key pair.

:param      key_pair: the name of the keypair
        you want to delete (required)
        :type       key_pair: ``KeyPair``

:return: bool
        :rtype: ``bool``
        """
        action = "DeleteKeypair"
        data = '{"KeypairName": "' + key_pair.name + '"}'
        response = self._call_api(action, data)
        if response.status_code == 200:
            return True
        return response.json()

def create_volume_snapshot(
        self,
        ex_description: str = None,
        ex_dry_run: bool = False,
        ex_file_location: str = None,
        ex_snapshot_size: int = None,
        ex_source_region_name: str = None,
        ex_source_snapshot: VolumeSnapshot = None,
        volume: StorageVolume = None,
    ):
        """
        Create a new volume snapshot.

:param      ex_description: a description for the new OMI
        :type       ex_description: ``str``

:param      ex_snapshot_size: The size of the snapshot created in your
        account, in bytes. This size must be
        exactly the same as the source snapshot one.
        :type       ex_snapshot_size: ``integer``

:param      ex_source_snapshot: The ID of the snapshot you want to
        copy.
        :type       ex_source_snapshot: ``str``

:param      volume: The ID of the volume you want to create a
        snapshot of.
        :type       volume: ``str``

:param      ex_source_region_name: The name of the source Region,
        which must be the same as the Region of your account.
        :type       ex_source_region_name: ``str``

:param      ex_dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       ex_dry_run: ``bool``

:return: the created snapshot
        :rtype: ``dict``
        """
        data = {
            "DryRun": ex_dry_run,
        }
        if ex_description is not None:
            data.update({"Description": ex_description})
        if ex_file_location is not None:
            data.update({"FileLocation": ex_file_location})
        if ex_snapshot_size is not None:
            data.update({"SnapshotSize": ex_snapshot_size})
        if ex_source_region_name is not None:
            data.update({"SourceRegionName": ex_source_region_name})
        if ex_source_snapshot is not None:
            data.update({"SourceSnapshotId": ex_source_snapshot.id})
        if volume is not None:
            data.update({"VolumeId": volume.id})
        data = json.dumps(data)
        action = "CreateSnapshot"
        response = self._call_api(action, data)
        if response.status_code == 200:
            return self._to_snapshot(response.json()["Volume"])
        return response.json()

def list_snapshots(self, ex_data: str = "{}"):
        """
        List all volume snapshots.

:return: snapshots
        :rtype: ``dict``
        """
        action = "ReadSnapshots"
        response = self._call_api(action, ex_data)
        if response.status_code == 200:
            return self._to_snapshots(response.json()["Snapshots"])
        return response.json()

def list_volume_snapshots(self, volume):
        """
        List all snapshot for a given volume.

:param     volume: the volume from which to look for snapshots
        :type      volume: StorageVolume

:rtype: ``list`` of :class ``VolumeSnapshot``
        """
        action = "ReadSnapshots"
        data = {"Filters": {"VolumeIds": [volume.id]}}
        response = self._call_api(action, data)
        if response.status_code == 200:
            return self._to_snapshots(response.json()["Snapshots"])
        return response.json()

def destroy_volume_snapshot(self, snapshot: VolumeSnapshot):
        """
        Delete a volume snapshot.

:param      snapshot: the ID of the snapshot
                    you want to delete (required)
        :type       snapshot: ``VolumeSnapshot``

:return: request
        :rtype: ``bool``
        """
        action = "DeleteSnapshot"
        data = '{"SnapshotId": "' + snapshot.id + '"}'
        response = self._call_api(action, data)
        if response.status_code == 200:
            return True
        return response.json()

def ex_create_snapshot_export_task(
        self,
        osu_export_disk_image_format: str = None,
        osu_export_api_key_id: str = None,
        osu_export_api_secret_key: str = None,
        osu_export_bucket: str = None,
        osu_export_manifest_url: str = None,
        osu_export_prefix: str = None,
        snapshot: VolumeSnapshot = None,
        dry_run: bool = False,
    ):
        """
        Exports a snapshot to an Object Storage Unit (OSU) bucket.
        This action enables you to create a backup of your snapshot or to copy
        it to another account. You, or other users you send a pre-signed URL
        to, can then download this snapshot from the OSU bucket using
        the CreateSnapshot method.
        This procedure enables you to copy a snapshot between accounts within
        the same Region or in different Regions. To copy a snapshot within
        the same Region, you can also use the CreateSnapshot direct method.
        The copy of the source snapshot is independent and belongs to you.

:param      osu_export_disk_image_format: The format of the export
        disk (qcow2 | vdi | vmdk). (required)
        :type       osu_export_disk_image_format: ``str``

:param      osu_export_api_key_id: The API key of the OSU account
        that enables you to access the bucket.
        :type       osu_export_api_key_id   : ``str``

:param      osu_export_api_secret_key: The secret key of the OSU
        account that enables you to access the bucket.
        :type       osu_export_api_secret_key   : ``str``

:param      osu_export_bucket: The name of the OSU bucket you want
        to export the object to.  (required)
        :type       osu_export_bucket   : ``str``

:param      osu_export_manifest_url: The URL of the manifest file.
        :type       osu_export_manifest_url   : ``str``

:param      osu_export_prefix: The prefix for the key of the OSU
        object. This key follows this format: prefix +
        object_export_task_id + '.' + disk_image_format.
        :type       osu_export_prefix   : ``str``

:param      snapshot: The ID of the snapshot to export. (required)
        :type       snapshot   : ``VolumeSnapshot``

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run   : ``bool``

:return: the created snapshot export task
        :rtype: ``dict``
        """
        action = "CreateSnapshotExportTask"
        data = {"DryRun": dry_run, "OsuExport": {"OsuApiKey": {}}}
        if snapshot is not None:
            data.update({"SnapshotId": snapshot.id})
        if osu_export_disk_image_format is not None:
            data["OsuExport"].update({"DiskImageFormat": osu_export_disk_image_format})
        if osu_export_bucket is not None:
            data["OsuExport"].update({"OsuBucket": osu_export_bucket})
        if osu_export_manifest_url is not None:
            data["OsuExport"].update({"OsuManifestUrl": osu_export_manifest_url})
        if osu_export_prefix is not None:
            data["OsuExport"].update({"OsuPrefix": osu_export_prefix})
        if osu_export_api_key_id is not None:
            data["OsuExport"]["OsuApiKey"].update({"ApiKeyId": osu_export_api_key_id})
        if osu_export_api_secret_key is not None:
            data["OsuExport"]["OsuApiKey"].update({"SecretKey": osu_export_api_secret_key})
        response = self._call_api(action, json.dumps(data))
        if response.status_code == 200:
            return response.json()["SnapshotExportTask"]
        return response.json()

def ex_list_snapshot_export_tasks(
        self,
        dry_run: bool = False,
        task_ids: List[str] = None,
    ):
        """
        Lists one or more image export tasks.

:param      task_ids: The IDs of the export tasks.
        :type       task_ids: ``list`` of ``str``

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:return: snapshot export tasks
        :rtype: ``list`` of ``dict``
        """
        action = "ReadSnapshotExportTasks"
        data = {"DryRun": dry_run, "Filters": {}}
        if task_ids is not None:
            data["Filters"].update({"TaskIds": task_ids})
        response = self._call_api(action, json.dumps(data))
        if response.status_code == 200:
            return response.json()["SnapshotExportTasks"]
        return response.json()

def ex_update_snapshot(
        self,
        perm_to_create_volume_addition_account_id: List[str] = None,
        perm_to_create_volume_addition_global_perm: bool = None,
        perm_to_create_volume_removals_account_id: List[str] = None,
        perm_to_create_volume_removals_global_perm: bool = None,
        snapshot: VolumeSnapshot = None,
        dry_run: bool = False,
    ):
        """
        Modifies the permissions for a specified snapshot.
        You can add or remove permissions for specified account IDs or groups.
        You can share a snapshot with a user that is in the same Region.
        The user can create a copy of the snapshot you shared, obtaining all
        the rights for the copy of the snapshot.

:param      perm_to_create_volume_addition_account_id:
        The account ID of one or more users who have permissions
        for the resource.
        :type       perm_to_create_volume_addition_account_id:
        ``list`` of ``str``

:param      perm_to_create_volume_addition_global_perm: If true,
        the resource is public. If false, the resource is private.
        :type       perm_to_create_volume_addition_global_perm: ``bool``

:param      perm_to_create_volume_removals_account_id: The account ID
         of one or more users who have permissions for the resource.
        :type       perm_to_create_volume_removals_account_id:
        ``list`` of ``str``

:param      perm_to_create_volume_removals_global_perm: If true,
         the resource is public. If false, the resource is private.
        :type       perm_to_create_volume_removals_global_perm: ``bool``

:param      snapshot: The ID of the snapshot. (required)
        :type       snapshot: ``VolumeSnapshot``

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:return: snapshot export tasks
        :rtype: ``list`` of ``dict``
        """
        action = "UpdateSnapshot"
        data = {
            "DryRun: ": dry_run,
            "PermissionsToCreateVolume": {"Additions": {}, "Removals": {}},
        }
        if snapshot is not None:
            data.update({"ImageId": snapshot.id})
        if perm_to_create_volume_addition_account_id is not None:
            data["PermissionsToCreateVolume"]["Additions"].update(
                {"AccountIds": perm_to_create_volume_addition_account_id}
            )
        if perm_to_create_volume_addition_global_perm is not None:
            data["PermissionsToCreateVolume"]["Additions"].update(
                {"GlobalPermission": perm_to_create_volume_addition_global_perm}
            )
        if perm_to_create_volume_removals_account_id is not None:
            data["PermissionsToCreateVolume"]["Removals"].update(
                {"AccountIds": perm_to_create_volume_removals_account_id}
            )
        if perm_to_create_volume_removals_global_perm is not None:
            data["PermissionsToCreateVolume"]["Removals"].update(
                {"GlobalPermission": perm_to_create_volume_removals_global_perm}
            )
        response = self._call_api(action, json.dumps(data))
        if response.status_code == 200:
            return response.json()["Snapshot"]
        return response.json()

def create_volume(
        self,
        ex_subregion_name: str,
        ex_dry_run: bool = False,
        ex_iops: int = None,
        size: int = None,
        snapshot: VolumeSnapshot = None,
        ex_volume_type: str = None,
    ):
        """
        Create a new volume.

:param      snapshot: the ID of the snapshot from which
                    you want to create the volume (required)
        :type       snapshot: ``str``

:param      ex_dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       ex_dry_run: ``bool``

:param      size: the size of the volume, in gibibytes (GiB),
                    the maximum allowed size for a volume is 14,901 GiB
        :type       size: ``int``

:param      ex_subregion_name: The Subregion in which you want to
        create the volume.
        :type       ex_subregion_name: ``str``

:param      ex_volume_type: the type of volume you want to create (io1
        | gp2 | standard)
        :type       ex_volume_type: ``str``

:param      ex_iops: The number of I/O operations per second (IOPS).
        This parameter must be specified only if
        you create an io1 volume. The maximum number of IOPS allowed for io1
        volumes is 13000.
        :type       ex_iops: ``integer``

:return: the created volume
        :rtype: ``dict``
        """
        data = {"DryRun": ex_dry_run, "SubregionName": ex_subregion_name}
        if ex_iops is not None:
            data.update({"Iops": ex_iops})
        if size is not None:
            data.update({"Size": size})
        if snapshot is not None:
            data.update({"SnapshotId": snapshot.id})
        if ex_volume_type is not None:
            data.update({"VolumeType": ex_volume_type})
        data = json.dumps(data)
        action = "CreateVolume"
        response = self._call_api(action, data)
        if response.status_code == 200:
            return self._to_volume(response.json()["Volume"])
        return response.json()

def list_volumes(self, ex_data: str = "{}"):
        """
        List all volumes.
        :rtype: ``list`` of :class:`.StorageVolume`
        """
        action = "ReadVolumes"
        response = self._call_api(action, ex_data)
        if response.status_code == 200:
            return self._to_volumes(response.json()["Volumes"])
        return response.json()

def destroy_volume(self, volume: StorageVolume):
        """
        Delete a volume.

:param      volume: the ID of the volume
                    you want to delete (required)
        :type       volume: ``StorageVolume``

:return: request
        :rtype: ``bool``
        """
        action = "DeleteVolume"
        data = '{"VolumeId": "' + volume.id + '"}'
        response = self._call_api(action, data)
        if response.status_code == 200:
            return True
        return response.json()

def attach_volume(self, node: Node, volume: StorageVolume, device: str = None):
        """
        Attach a volume to a node.

:param      node: the ID of the VM you want
                    to attach the volume to (required)
        :type       node: ``Node``

:param      volume: the ID of the volume
                    you want to attach (required)
        :type       volume: ``StorageVolume``

:param      device: the name of the device (required)
        :type       device: ``str``

:return: the attached volume
        :rtype: ``dict``
        """
        action = "LinkVolume"
        data = json.dumps({"VmId": node.id, "VolumeId": volume.id, "DeviceName": device})
        response = self._call_api(action, data)
        if response.status_code == 200:
            return True
        return response.json()

def detach_volume(
        self,
        volume: StorageVolume,
        ex_dry_run: bool = False,
        ex_force_unlink: bool = False,
    ):
        """
        Detach a volume from a node.

:param      volume: the ID of the volume you want to detach
        (required)
        :type       volume: ``str``

:param      ex_force_unlink: Forces the detachment of the volume in
        case of previous failure.
        Important: This action may damage your data or file systems.
        :type       ex_force_unlink: ``bool``

:param      ex_dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       ex_dry_run: ``bool``

:return: the attached volume
        :rtype: ``dict``
        """
        action = "UnlinkVolume"
        data = {"DryRun": ex_dry_run, "VolumeId": volume.id}
        if ex_force_unlink is not None:
            data.update({"ForceUnlink": ex_force_unlink})
        data = json.dumps(data)
        response = self._call_api(action, data)
        if response.status_code == 200:
            return True
        return response.json()

def ex_check_account(
        self,
        login: str,
        password: str,
        dry_run: bool = False,
    ):
        """
        Validates the authenticity of the account.

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:param      login: the login of the account
        :type       login: ``str``

:param      password: the password of the account
        :type       password: ``str``

:param      dry_run: the password of the account
        :type       dry_run: ``bool``

:return: True if the action successful
        :rtype: ``bool``
        """
        action = "CheckAuthentication"
        data = {"DryRun": dry_run, "Login": login, "Password": password}
        response = self._call_api(action, json.dumps(data))
        if response.status_code == 200:
            return True
        return response.json()

def ex_read_account(self, dry_run: bool = False):
        """
        Gets information about the account that sent the request.

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:return: the account information
        :rtype: ``dict``
        """
        action = "ReadAccounts"
        data = json.dumps({"DryRun": dry_run})
        response = self._call_api(action, data)
        if response.status_code == 200:
            return response.json()["Accounts"][0]
        return response.json()

def ex_list_consumption_account(
        self, from_date: str = None, to_date: str = None, dry_run: bool = False
    ):
        """
        Displays information about the consumption of your account for
        each billable resource within the specified time period.

:param      from_date: The beginning of the time period, in
        ISO 8601 date-time format (for example, 2017-06-14 or
        2017-06-14T00:00:00Z). (required)
        :type       from_date: ``str``

:param      to_date: The end of the time period, in
        ISO 8601 date-time format (for example, 2017-06-30 or
        2017-06-30T00:00:00Z). (required)
        :type       to_date: ``str``

:param      dry_run: If true, checks whether you have the required
        permissions to perform the action.
        :type       dry_run: ``bool``

:return: a list of Consumption Entries
        :rtype: ``list`` of ``dict``
        """
        action = "ReadConsumptionAccount"
        data = {"DryRun": dry_run}
        if from_date is not None:
            data.update({"FromDate": from_date})
        if to_date is not None:
            data.update({"ToDate": to_date})
        response = self._call_api(action, json.dumps(data))
        print(response.status_code)
        if response.status_code == 200:
            return response.json()["ConsumptionEntries"]
        return response.json()

def ex_create_account(
        self,
        city: str = None,
        company_name: str = None,
        country: str = None,
        customer_id: str = None,
        email: str = None,
        first_name: str = None,
        last_name: str = None,
        zip_code: str = None,
        job_title: str = None,
        mobile_number: str = None,
        phone_number: str = None,
        state_province: str = None,
        vat_number: str = None,
        dry_run: bool = False,
    ):
        """
        Creates a new 3DS OUTSCALE account.

You need 3DS OUTSCALE credentials and the appropriate quotas to
        create a new account via API. To get quotas, you can send an email
        to sales@outscale.com.
        If you want to pass a numeral value as a string instead of an
        integer, you must wrap your string in additional quotes
        (for example, '"92000"').

:param      city: The city of the account owner.
        :type       city: ``str``

:param      company_name: The name of the company for the account.
        permissions to perform the action.
        :type       company_name: ``str``

:param      country: The country of the account owner.
        :type       country: ``str``

:param      customer_id: The ID of the customer. It must be 8 digits.
        :type       customer_id: ``str``

:param      email: The email address for the account.
        :type       email: ``str``

:param      first_name: The first name of the account owner.
        :type       first_name: ``str``

:param      last_name: The last name of the account owner.
        :type       last_name: ``str``

:param      zip_code: The ZIP code of the city.
        :type       zip_code: ``str``

:param      job_title: The job title of the account owner.
        :type       job_title: ``str``

:param      mobile_number: The mobile phone number of the account
        owner.
        :type       mobile_number: ``str``

:param      phone_number: The landline phone number of the account
        owner.
        :type       phone_number: ``str``

:param      state_province: The state/province of the account.
        :type       state_province: ``str``

:param      vat_number: The value added tax (VAT) number for
        the account.
        :type       vat_number: ``str``

:param      dry_run: the password of the account
        :type       dry_run: ``bool``

:return: True if the action is successful
        :rtype: ``bool``
        """
        action = "CreateAccount"
        data = {"DryRun": dry_run}
        if city is not None:
            data.update({"City": city})
        if company_name is not None:
            data.update({"CompanyName": company_name})
        if country is not None:
            data.update({"Country": country})
        if customer_id is not None:
            data.update({"CustomerId": customer_id})
        if email is not None:
            data.update({"Email": email})
        if first_name is not None:
            data.update({"FirstName": first_name})
        if last_name is not None:
            data.update({"LastName": last_name})
        if zip_code is not None:
            data.update({"ZipCode": zip_code})
        if job_title is not None:
            data.update({"JobTitle": job_title})
        if mobile_number is not None:
            data.update({"MobileNumber": mobile_number})
        if phone_number is not None:
            data.update({"PhoneNumber": phone_number})
        if state_province is not None:
            data.update({"StateProvince": state_province})
        if vat_number is not None:
            data.update({"VatNumber": vat_number})
        response = self._call_api(action, json.dumps(data))
        if response.status_code == 200:
            return True
        return response.json()

def ex_update_account(
        self,
        city: str = None,
        company_name: str = None,
        country: str = None,
        email: str = None,
        first_name: str = None,
        last_name: str = None,
        zip_code: str = None,
        job_title: str = None,
        mobile_number: str = None,
        phone_number: str = None,
        state_province: str = None,
        vat_number: str = None,
        dry_run: bool = False,
    ):
        """
        Updates the account information for the account that sends the request.