cutemeli/server
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2adfbd9ea73fc04955d459a3e37101263067ebdb
server/usr/lib/python3/dist-packages/libcloud/compute/drivers/outscale.py
cutemeli 2adfbd9ea7 .gitignore angepasst
2026-01-07 20:52:11 +01:00

8151 lines
297 KiB
Python
Raw Blame History

# 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
import requests
from datetime import datetime
from typing import List
from libcloud.compute.base import NodeDriver
from libcloud.compute.types import Provider
from libcloud.common.osc import OSCRequestSignerAlgorithmV4
from libcloud.common.base import ConnectionUserAndKey
from libcloud.compute.base import \
Node,\
NodeImage, \
KeyPair, \
StorageVolume, \
VolumeSnapshot, \
NodeLocation
from libcloud.compute.types import 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 vm_states: The states of the VMs
(pending | running | stopping | stopped | shutting-down | terminated
| quarantine)
:type vm_states: ``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 ore 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_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 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.
: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 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: The new account information
:rtype: ``dict``
"""
action = "UpdateAccount"
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 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 response.json()["Account"]
return response.json()
def ex_reset_account_password(
self,
password: str = "",
token: str = "",
dry_run: bool = False,
):
"""
Sends an email to the email address provided for the account with a
token to reset your password.
:param password: The new password for the account.
:type password: ``str``
:param token: The token you received at the email address
provided for the account.
:type token: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "ResetAccountPassword"
data = json.dumps({
"DryRun": dry_run, "Password": password, "Token": token
})
response = self._call_api(action, data)
if response.status_code == 200:
return True
return response.json()
def ex_send_reset_password_email(
self,
email: str,
dry_run: bool = False,
):
"""
Replaces the account password with the new one you provide.
You must also provide the token you received by email when asking for
a password reset using the SendResetPasswordEmail method.
:param email: The email address provided for the account.
:type email: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "SendResetPasswordEmail"
data = json.dumps({
"DryRun": dry_run, "Email": email
})
response = self._call_api(action, data)
if response.status_code == 200:
return True
return response.json()
def ex_create_tag(
self,
resource_ids: list,
tag_key: str = None,
tag_value: str = None,
dry_run: bool = False,
):
"""
Adds one tag to the specified resources.
If a tag with the same key already exists for the resource,
the tag value is replaced.
You can tag the following resources using their IDs:
:param resource_ids: One or more resource IDs. (required)
:type resource_ids: ``list``
:param tag_key: The key of the tag, with a minimum of 1 character.
(required)
:type tag_key: ``str``
:param tag_value: The value of the tag, between
0 and 255 characters. (required)
:type tag_value: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action. (required)
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "CreateTags"
data = {"DryRun": dry_run, "ResourceIds": resource_ids, "Tags": []}
if tag_key is not None and tag_value is not None:
data["Tags"].append({"Key": tag_key, "Value": tag_value})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_create_tags(
self,
resource_ids: list,
tags: list = None,
dry_run: bool = False,
):
"""
Adds one or more tags to the specified resources.
If a tag with the same key already exists for the resource,
the tag value is replaced.
You can tag the following resources using their IDs:
:param resource_ids: One or more resource IDs. (required)
:type resource_ids: ``list``
:param tags: The key of the tag, with a minimum of 1 character.
(required)
:type tags: ``list`` of ``dict``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "CreateTags"
data = {"DryRun": dry_run, "ResourceIds": resource_ids, "Tags": tags}
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_delete_tags(
self,
resource_ids: list,
tags: list = None,
dry_run: bool = False,
):
"""
Deletes one or more tags from the specified resources.
:param resource_ids: One or more resource IDs. (required)
:type resource_ids: ``list``
:param tags: The key of the tag, with a minimum of 1 character.
(required)
:type tags: ``list`` of ``dict``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteTags"
data = {"DryRun": dry_run, "ResourceIds": resource_ids, "Tags": tags}
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_tags(
self,
resource_ids: list = None,
resource_types: list = None,
keys: list = None,
values: list = None,
dry_run: bool = False
):
"""
Lists one or more tags for your resources.
:param resource_ids: One or more resource IDs.
:type resource_ids: ``list``
:param resource_types: One or more resource IDs.
:type resource_types: ``list``
:param keys: One or more resource IDs.
:type keys: ``list``
:param values: One or more resource IDs.
:type values: ``list``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: list of tags
:rtype: ``list`` of ``dict``
"""
action = "ReadTags"
data = {"Filters": {}, "DryRun": dry_run}
if resource_ids is not None:
data["Filters"].update({"ResourceIds": resource_ids})
if resource_types is not None:
data["Filters"].update({"ResourceTypes": resource_types})
if keys is not None:
data["Filters"].update({"Keys": keys})
if values is not None:
data["Filters"].update({"Values": values})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["Tags"]
return response.json()
def ex_create_access_key(
self,
expiration_date: datetime = None,
dry_run: bool = False,
):
"""
Creates a new secret access key and the corresponding access key ID
for a specified user. The created key is automatically set to ACTIVE.
:param expiration_date: The date and time at which you want the
access key to expire, in ISO 8601 format (for example,
2017-06-14 or 2017-06-14T00:00:00Z). If not specified, the access key
has no expiration date.
:type expiration_date: ``datetime``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: access key if action is successful
:rtype: ``dict``
"""
action = "CreateAccessKey"
data = {"DryRun": dry_run}
if expiration_date is not None:
data.update({"ExpirationDate": expiration_date})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["AccessKey"]
return response.json()
def ex_delete_access_key(
self,
access_key_id: str,
dry_run: bool = False,
):
"""
Deletes the specified access key associated with the account
that sends the request.
:param access_key_id: The ID of the access key you want to
delete. (required)
:type access_key_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteAccessKey"
data = {"DryRun": dry_run}
if access_key_id is not None:
data.update({"AccessKeyId": access_key_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_access_keys(
self,
access_key_ids: list = None,
states: list = None,
dry_run: bool = False,
):
"""
Returns information about the access key IDs of a specified user.
If the user does not have any access key ID, this action returns
an empty list.
:param access_key_ids: The IDs of the access keys.
:type access_key_ids: ``list`` of ``str``
:param states: The states of the access keys (ACTIVE | INACTIVE).
:type states: ``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`` of Access Keys
:rtype: ``list`` of ``dict``
"""
action = "ReadAccessKeys"
data = {"DryRun": dry_run, "Filters": {}}
if access_key_ids is not None:
data["Filters"].update({"AccessKeyIds": access_key_ids})
if states is not None:
data["Filters"].update({"States": states})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["AccessKeys"]
return response.json()
def ex_list_secret_access_key(
self,
access_key_id: str = None,
dry_run: bool = False,
):
"""
Gets information about the secret access key associated with
the account that sends the request.
:param access_key_id: The ID of the access key. (required)
:type access_key_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: Access Key
:rtype: ``dict``
"""
action = "ReadSecretAccessKey"
data = {"DryRun": dry_run}
if access_key_id is not None:
data.update({"AccessKeyId": access_key_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["AccessKey"]
return response.json()
def ex_update_access_key(
self,
access_key_id: str = None,
state: str = None,
dry_run: bool = False,
):
"""
Modifies the status of the specified access key associated with
the account that sends the request.
When set to ACTIVE, the access key is enabled and can be used to
send requests. When set to INACTIVE, the access key is disabled.
:param access_key_id: The ID of the access key. (required)
:type access_key_id: ``str``
:param state: The new state of the access key
(ACTIVE | INACTIVE). (required)
:type state: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: Access Key
:rtype: ``dict``
"""
action = "UpdateAccessKey"
data = {"DryRun": dry_run}
if access_key_id is not None:
data.update({"AccessKeyId": access_key_id})
if state is not None:
data.update({"State": state})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["AccessKey"]
return response.json()
def ex_create_client_gateway(
self,
bgp_asn: int = None,
connection_type: str = None,
public_ip: str = None,
dry_run: bool = False,
):
"""
Provides information about your client gateway.
This action registers information to identify the client gateway that
you deployed in your network.
To open a tunnel to the client gateway, you must provide
the communication protocol type, the valid fixed public IP address
of the gateway, and an Autonomous System Number (ASN).
:param bgp_asn: An Autonomous System Number (ASN) used by
the Border Gateway Protocol (BGP) to find the path to your
client gateway through the Internet. (required)
:type bgp_asn: ``int`` (required)
:param connection_type: The communication protocol used to
establish tunnel with your client gateway (only ipsec.1 is supported).
(required)
:type connection_type: ``str``
:param public_ip: The public fixed IPv4 address of your
client gateway. (required)
:type public_ip: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: Client Gateway as ``dict``
:rtype: ``dict``
"""
action = "CreateClientGateway"
data = {"DryRun": dry_run}
if bgp_asn is not None:
data.update({"BgpAsn": bgp_asn})
if connection_type is not None:
data.update({"ConnectionType": connection_type})
if public_ip is not None:
data.update({"PublicIp": public_ip})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["ClientGateway"]
return response.json()
def ex_list_client_gateways(
self,
client_gateway_ids: list = None,
bgp_asns: list = None,
connection_types: list = None,
public_ips: list = None,
states: list = None,
tag_keys: list = None,
tag_values: list = None,
tags: list = None,
dry_run: bool = False,
):
"""
Deletes a client gateway.
You must delete the VPN connection before deleting the client gateway.
:param client_gateway_ids: The IDs of the client gateways.
you want to delete. (required)
:type client_gateway_ids: ``list`` of ``str`
:param bgp_asns: The Border Gateway Protocol (BGP) Autonomous
System Numbers (ASNs) of the connections.
:type bgp_asns: ``list`` of ``int``
:param connection_types: The types of communication tunnels
used by the client gateways (only ipsec.1 is supported).
(required)
:type connection_types: ``list```of ``str``
:param public_ips: The public IPv4 addresses of the
client gateways.
:type public_ips: ``list`` of ``str``
:param states: The states of the client gateways
(pending | available | deleting | deleted).
:type states: ``list`` of ``str``
:param tag_keys: The keys of the tags associated with
the client gateways.
:type tag_keys: ``list`` of ``str``
:param tag_values: The values of the tags associated with the
client gateways.
:type tag_values: ``list`` of ``str``
:param tags: TThe key/value combination of the tags
associated with the client gateways, in the following
format: "Filters":{"Tags":["TAGKEY=TAGVALUE"]}.
:type tags: ``list`` of ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: Returns ``list`` of Client Gateway
:rtype: ``list`` of ``dict``
"""
action = "ReadClientGateways"
data = {"DryRun": dry_run, "Filters": {}}
if client_gateway_ids is not None:
data["Filters"].update({"ClientGatewayIds": client_gateway_ids})
if bgp_asns is not None:
data["Filters"].update({"BgpAsns": bgp_asns})
if connection_types is not None:
data["Filters"].update({"ConnectionTypes": connection_types})
if public_ips is not None:
data["Filters"].update({"PublicIps": public_ips})
if client_gateway_ids is not None:
data["Filters"].update({"ClientGatewayIds": client_gateway_ids})
if states is not None:
data["Filters"].update({"States": states})
if tag_keys is not None:
data["Filters"].update({"TagKeys": tag_keys})
if tag_values is not None:
data["Filters"].update({"TagValues": tag_values})
if tags is not None:
data["Filters"].update({"Tags": tags})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["ClientGateways"]
return response.json()
def ex_delete_client_gateway(
self,
client_gateway_id: str = None,
dry_run: bool = False,
):
"""
Deletes a client gateway.
You must delete the VPN connection before deleting the client gateway.
:param client_gateway_id: The ID of the client gateway
you want to delete. (required)
:type client_gateway_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: Returns True if action is successful
:rtype: ``bool``
"""
action = "DeleteClientGateway"
data = {"DryRun": dry_run}
if client_gateway_id is not None:
data.update({"ClientGatewayId": client_gateway_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_create_dhcp_options(
self,
domaine_name: str = None,
domaine_name_servers: list = None,
ntp_servers: list = None,
dry_run: bool = False,
):
"""
Creates a new set of DHCP options, that you can then associate
with a Net using the UpdateNet method.
:param domaine_name: Specify a domain name
(for example, MyCompany.com). You can specify only one domain name.
:type domaine_name: ``str``
:param domaine_name_servers: The IP addresses of domain name
servers. If no IP addresses are specified, the OutscaleProvidedDNS
value is set by default.
:type domaine_name_servers: ``list`` of ``str``
:param ntp_servers: The IP addresses of the Network Time
Protocol (NTP) servers.
:type ntp_servers: ``list`` of ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The created Dhcp Options
:rtype: ``dict``
"""
action = "CreateDhcpOptions"
data = {"DryRun": dry_run}
if domaine_name is not None:
data.update({"DomaineName": domaine_name})
if domaine_name_servers is not None:
data.update({"DomaineNameServers": domaine_name_servers})
if ntp_servers is not None:
data.update({"NtpServers": ntp_servers})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["DhcpOptionsSet"]
return response.json()
def ex_delete_dhcp_options(
self,
dhcp_options_set_id: str = None,
dry_run: bool = False,
):
"""
Deletes a specified DHCP options set.
Before deleting a DHCP options set, you must disassociate it from the
Nets you associated it with. To do so, you need to associate with each
Net a new set of DHCP options, or the default one if you do not want
to associate any DHCP options with the Net.
:param dhcp_options_set_id: The ID of the DHCP options set
you want to delete. (required)
:type dhcp_options_set_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteDhcpOptions"
data = {"DryRun": dry_run}
if dhcp_options_set_id is not None:
data.update({"DhcpOptionsSetId": dhcp_options_set_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_dhcp_options(
self,
default: bool = None,
dhcp_options_set_id: list = None,
domaine_names: list = None,
domaine_name_servers: list = None,
ntp_servers: list = None,
tag_keys: list = None,
tag_values: list = None,
tags: list = None,
dry_run: bool = False,
):
"""
Retrieves information about the content of one or more
DHCP options sets.
:param default: SIf true, lists all default DHCP options set.
If false, lists all non-default DHCP options set.
:type default: ``list`` of ``bool``
:param dhcp_options_set_id: The IDs of the DHCP options sets.
:type dhcp_options_set_id: ``list`` of ``str``
:param domaine_names: The domain names used for the DHCP
options sets.
:type domaine_names: ``list`` of ``str``
:param domaine_name_servers: The domain name servers used for
the DHCP options sets.
:type domaine_name_servers: ``list`` of ``str``
:param ntp_servers: The Network Time Protocol (NTP) servers used
for the DHCP options sets.
:type ntp_servers: ``list`` of ``str``
:param tag_keys: The keys of the tags associated with the DHCP
options sets.
:type ntp_servers: ``list`` of ``str``
:param tag_values: The values of the tags associated with the
DHCP options sets.
:type tag_values: ``list`` of ``str``
:param tags: The key/value combination of the tags associated
with the DHCP options sets, in the following format:
"Filters":{"Tags":["TAGKEY=TAGVALUE"]}.
:type tags: ``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 Dhcp Options
:rtype: ``list`` of ``dict``
"""
action = "ReadDhcpOptions"
data = {"DryRun": dry_run, "Filters": {}}
if default is not None:
data["Filters"].update({"Default": default})
if dhcp_options_set_id is not None:
data["Filters"].update({"DhcpOptionsSetIds": dhcp_options_set_id})
if domaine_names is not None:
data["Filters"].update({"DomaineNames": domaine_names})
if domaine_name_servers is not None:
data["Filters"].update({
"DomaineNameServers": domaine_name_servers
})
if ntp_servers is not None:
data["Filters"].update({"NtpServers": ntp_servers})
if tag_keys is not None:
data["Filters"].update({"TagKeys": tag_keys})
if tag_values is not None:
data["Filters"].update({"TagValues": tag_values})
if tags is not None:
data["Filters"].update({"Tags": tags})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["DhcpOptionsSets"]
return response.json()
def ex_create_direct_link(
self,
bandwidth: str = None,
direct_link_name: str = None,
location: str = None,
dry_run: bool = False,
):
"""
Creates a new DirectLink between a customer network and a
specified DirectLink location.
:param bandwidth: The bandwidth of the DirectLink
(1Gbps | 10Gbps). (required)
:type bandwidth: ``str``
:param direct_link_name: The name of the DirectLink. (required)
:type direct_link_name: ``str``
:param location: The code of the requested location for
the DirectLink, returned by the list_locations method.
Protocol (NTP) servers.
:type location: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Direct Link
:rtype: ``dict``
"""
action = "CreateDirectLink"
data = {"DryRun": dry_run}
if bandwidth is not None:
data.update({"Bandwidth": bandwidth})
if direct_link_name is not None:
data.update({"DirectLinkName": direct_link_name})
if location is not None:
data.update({"Location": location})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["DirectLink"]
return response.json()
def ex_delete_direct_link(
self,
direct_link_id: str = None,
dry_run: bool = False,
):
"""
Deletes a specified DirectLink.
Before deleting a DirectLink, ensure that all your DirectLink
interfaces related to this DirectLink are deleted.
:param direct_link_id: The ID of the DirectLink you want to
delete. (required)
:type direct_link_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteDirectLink"
data = {"DryRun": dry_run}
if direct_link_id is not None:
data.update({"DirectLinkId": direct_link_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_direct_links(
self,
direct_link_ids: list = None,
dry_run: bool = False,
):
"""
Lists all DirectLinks in the Region.
:param direct_link_ids: The IDs of the DirectLinks. (required)
:type direct_link_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`` of Direct Links
:rtype: ``list`` of ``dict``
"""
action = "ReadDirectLinks"
data = {"DryRun": dry_run, "Filters": {}}
if direct_link_ids is not None:
data["Filters"].update({"DirectLinkIds": direct_link_ids})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["DirectLinks"]
return response.json()
def ex_create_direct_link_interface(
self,
direct_link_id: str = None,
bgp_asn: int = None,
bgp_key: str = None,
client_private_ip: str = None,
direct_link_interface_name: str = None,
outscale_private_ip: str = None,
virtual_gateway_id: str = None,
vlan: int = None,
dry_run: bool = False,
):
"""
Creates a DirectLink interface.
DirectLink interfaces enable you to reach one of your Nets through a
virtual gateway.
:param direct_link_id: The ID of the existing DirectLink for which
you want to create the DirectLink interface. (required)
:type direct_link_id: ``str``
:param bgp_asn: The BGP (Border Gateway Protocol) ASN (Autonomous
System Number) on the customer's side of the DirectLink interface.
(required)
:type bgp_asn: ``int``
:param bgp_key: The BGP authentication key.
:type bgp_key: ``str``
:param client_private_ip: The IP address on the customer's side
of the DirectLink interface. (required)
:type client_private_ip: ``str``
:param direct_link_interface_name: The name of the DirectLink
interface. (required)
:type direct_link_interface_name: ``str``
:param outscale_private_ip: The IP address on 3DS OUTSCALE's side
of the DirectLink interface.
:type outscale_private_ip: ``str``
:param virtual_gateway_id:The ID of the target virtual gateway.
(required)
:type virtual_gateway_id: ``str``
:param vlan: The VLAN number associated with the DirectLink
interface. (required)
:type vlan: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Direct Link Interface
:rtype: ``dict``
"""
action = "CreateDirectLinkInterface"
data = {"DryRun": dry_run, "DirectLinkInterface": {}}
if direct_link_id is not None:
data.update({"DirectLinkId": direct_link_id})
if bgp_asn is not None:
data["DirectLinkInterface"].update({"BgpAsn": bgp_asn})
if bgp_key is not None:
data["DirectLinkInterface"].update({"BgpKey": bgp_key})
if client_private_ip is not None:
data["DirectLinkInterface"].update({
"ClientPrivateIp": client_private_ip
})
if direct_link_interface_name is not None:
data["DirectLinkInterface"].update({
"DirectLinkInterfaceName": direct_link_interface_name
})
if outscale_private_ip is not None:
data["DirectLinkInterface"].update({
"OutscalePrivateIp": outscale_private_ip
})
if virtual_gateway_id is not None:
data["DirectLinkInterface"].update({
"VirtualGatewayId": virtual_gateway_id
})
if vlan is not None:
data["DirectLinkInterface"].update({
"Vlan": vlan
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["DirectLinkInterface"]
return response.json()
def ex_delete_direct_link_interface(
self,
direct_link_interface_id: str = None,
dry_run: bool = False,
):
"""
Deletes a specified DirectLink interface.
:param direct_link_interface_id: TThe ID of the DirectLink
interface you want to delete. (required)
:type direct_link_interface_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteDirectLinkInterface"
data = {"DryRun": dry_run}
if direct_link_interface_id is not None:
data.update({"DirectLinkInterfaceId": direct_link_interface_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_direct_link_interfaces(
self,
direct_link_ids: list = None,
direct_link_interface_ids: list = None,
dry_run: bool = False,
):
"""
Lists all DirectLinks in the Region.
:param direct_link_interface_ids: The IDs of the DirectLink
interfaces.
:type direct_link_interface_ids: ``list`` of ``str``
:param direct_link_ids: The IDs of the DirectLinks.
:type direct_link_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`` of Direct Link interfaces
:rtype: ``list`` of ``dict``
"""
action = "DeleteDirectLink"
data = {"DryRun": dry_run, "Filters": {}}
if direct_link_ids is not None:
data["Filters"].update({
"DirectLinkIds": direct_link_ids
})
if direct_link_interface_ids is not None:
data["Filters"].update({
"DirectLinkInterfaceIds": direct_link_interface_ids
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["DirectLinkInterfaces"]
return response.json()
def ex_create_flexible_gpu(
self,
delete_on_vm_deletion: bool = None,
generation: str = None,
model_name: str = None,
subregion_name: str = None,
dry_run: bool = False,
):
"""
Allocates a flexible GPU (fGPU) to your account.
You can then attach this fGPU to a virtual machine (VM).
:param delete_on_vm_deletion: If true, the fGPU is deleted when
the VM is terminated.
:type delete_on_vm_deletion: ``bool``
:param generation: The processor generation that the fGPU must be
compatible with. If not specified, the oldest possible processor
generation is selected (as provided by ReadFlexibleGpuCatalog for
the specified model of fGPU).
:type generation: ``str``
:param model_name: The model of fGPU you want to allocate. For
more information, see About Flexible GPUs:
https://wiki.outscale.net/display/EN/About+Flexible+GPUs (required)
:type model_name: ``str``
:param subregion_name: The Subregion in which you want to create
the fGPU. (required)
:type subregion_name: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Flexible GPU
:rtype: ``dict``
"""
action = "CreateFlexibleGpu"
data = {"DryRun": dry_run}
if delete_on_vm_deletion is not None:
data.update({"DeleteOnVmDeletion": delete_on_vm_deletion})
if generation is not None:
data.update({"Generation": generation})
if model_name is not None:
data.update({"ModelName": model_name})
if subregion_name is not None:
data.update({
"SubregionName": subregion_name
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["FlexibleGpu"]
return response.json()
def ex_delete_flexible_gpu(
self,
flexible_gpu_id: str = None,
dry_run: bool = False,
):
"""
Releases a flexible GPU (fGPU) from your account.
The fGPU becomes free to be used by someone else.
:param flexible_gpu_id: The ID of the fGPU you want
to delete. (required)
:type flexible_gpu_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteFlexibleGpu"
data = {"DryRun": dry_run}
if flexible_gpu_id is not None:
data.update({"FlexibleGpuId": flexible_gpu_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_unlink_flexible_gpu(
self,
flexible_gpu_id: str = None,
dry_run: bool = False,
):
"""
Detaches a flexible GPU (fGPU) from a virtual machine (VM).
The fGPU is in the detaching state until the VM is stopped, after
which it becomes available for allocation again.
:param flexible_gpu_id: The ID of the fGPU you want to attach.
(required)
:type flexible_gpu_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "UnlinkFlexibleGpu"
data = {"DryRun": dry_run}
if flexible_gpu_id is not None:
data.update({"FlexibleGpuId": flexible_gpu_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_link_flexible_gpu(
self,
flexible_gpu_id: str = None,
vm_id: str = None,
dry_run: bool = False,
):
"""
Attaches one of your allocated flexible GPUs (fGPUs) to one of your
virtual machines (Nodes).
The fGPU is in the attaching state until the VM is stopped, after
which it becomes attached.
:param flexible_gpu_id: The ID of the fGPU you want to attach.
(required)
:type flexible_gpu_id: ``str``
:param vm_id: The ID of the VM you want to attach the fGPU to.
(required)
:type vm_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "LinkFlexibleGpu"
data = {"DryRun": dry_run}
if flexible_gpu_id is not None:
data.update({"FlexibleGpuId": flexible_gpu_id})
if vm_id is not None:
data.update({"VmId": vm_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_flexible_gpu_catalog(
self,
dry_run: bool = False,
):
"""
Lists all flexible GPUs available in the public catalog.
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: Returns the Flexible Gpu Catalog
:rtype: ``list`` of ``dict``
"""
action = "ReadFlexibleGpuCatalog"
data = {"DryRun": dry_run}
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["FlexibleGpuCatalog"]
return response.json()
def ex_list_flexible_gpus(
self,
delete_on_vm_deletion: bool = None,
flexible_gpu_ids: list = None,
generations: list = None,
model_names: list = None,
states: list = None,
subregion_names: list = None,
vm_ids: list = None,
dry_run: bool = False,
):
"""
Lists one or more flexible GPUs (fGPUs) allocated to your account.
:param delete_on_vm_deletion: Indicates whether the fGPU is
deleted when terminating the VM.
:type delete_on_vm_deletion: ``bool``
:param flexible_gpu_ids: One or more IDs of fGPUs.
:type flexible_gpu_ids: ``list`` of ``str``
:param generations: The processor generations that the fGPUs are
compatible with.
(required)
:type generations: ``list`` of ``str``
:param model_names: One or more models of fGPUs. For more
information, see About Flexible GPUs:
https://wiki.outscale.net/display/EN/About+Flexible+GPUs
:type model_names: ``list`` of ``str``
:param states: The states of the fGPUs
(allocated | attaching | attached | detaching).
:type states: ``list`` of ``str``
:param subregion_names: The Subregions where the fGPUs are
located.
: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: Returns the Flexible Gpu Catalog
:rtype: ``list`` of ``dict``
"""
action = "ReadFlexibleGpus"
data = {"DryRun": dry_run, "Filters": {}}
if delete_on_vm_deletion is not None:
data["Filters"].update({
"DeleteOnVmDeletion": delete_on_vm_deletion
})
if flexible_gpu_ids is not None:
data["Filters"].update({"FlexibleGpuIds": flexible_gpu_ids})
if generations is not None:
data["Filters"].update({"Generations": generations})
if model_names is not None:
data["Filters"].update({"ModelNames": model_names})
if states is not None:
data["Filters"].update({"States": states})
if subregion_names is not None:
data["Filters"].update({"SubregionNames": subregion_names})
if vm_ids is not None:
data["Filters"].update({"VmIds": vm_ids})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["FlexibleGpus"]
return response.json()
def ex_update_flexible_gpu(
self,
delete_on_vm_deletion: bool = None,
flexible_gpu_id: str = None,
dry_run: bool = False,
):
"""
Modifies a flexible GPU (fGPU) behavior.
:param delete_on_vm_deletion: If true, the fGPU is deleted when
the VM is terminated.
:type delete_on_vm_deletion: ``bool``
:param flexible_gpu_id: The ID of the fGPU you want to modify.
:type flexible_gpu_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: the updated Flexible GPU
:rtype: ``dict``
"""
action = "UpdateFlexibleGpu"
data = {"DryRun": dry_run, "DirectLinkInterface": {}}
if delete_on_vm_deletion is not None:
data.update({"DeleteOnVmDeletion": delete_on_vm_deletion})
if flexible_gpu_id is not None:
data.update({"FlexibleGpuId": flexible_gpu_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["FlexibleGpu"]
return response.json()
def ex_create_internet_service(
self,
dry_run: bool = False,
):
"""
Creates an Internet service you can use with a Net.
An Internet service enables your virtual machines (VMs) launched
in a Net to connect to the Internet. By default, a Net includes
an Internet service, and each Subnet is public. Every VM
launched within a default Subnet has a private and a public IP
addresses.
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Internet Service
:rtype: ``dict``
"""
action = "CreateInternetService"
data = {"DryRun": dry_run, "DirectLinkInterface": {}}
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["InternetService"]
return response.json()
def ex_delete_internet_service(
self,
internet_service_id: str = None,
dry_run: bool = False,
):
"""
Deletes an Internet service.
Before deleting an Internet service, you must detach it from any Net
it is attached to.
:param internet_service_id: The ID of the Internet service you
want to delete.(required)
:type internet_service_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteInternetService"
data = {"DryRun": dry_run}
if internet_service_id is not None:
data.update({"InternetServiceId": internet_service_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_link_internet_service(
self,
internet_service_id: str = None,
net_id: str = None,
dry_run: bool = False,
):
"""
Attaches an Internet service to a Net.
To enable the connection between the Internet and a Net, you must
attach an Internet service to this Net.
:param internet_service_id: The ID of the Internet service you
want to attach. (required)
:type internet_service_id: ``str``
:param net_id: The ID of the Net to which you want to attach the
Internet service. (required)
:type net_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "LinkInternetService"
data = {"DryRun": dry_run}
if internet_service_id is not None:
data.update({"InternetServiceId": internet_service_id})
if net_id is not None:
data.update({"NetId": net_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_unlink_internet_service(
self,
internet_service_id: str = None,
net_id: str = None,
dry_run: bool = False,
):
"""
Detaches an Internet service from a Net.
This action disables and detaches an Internet service from a Net.
The Net must not contain any running virtual machine (VM) using an
External IP address (EIP).
:param internet_service_id: The ID of the Internet service you
want to detach. (required)
:type internet_service_id: ``str``
:param net_id: The ID of the Net from which you want to detach
the Internet service. (required)
:type net_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "UnlinkInternetService"
data = {"DryRun": dry_run}
if internet_service_id is not None:
data.update({"InternetServiceId": internet_service_id})
if net_id is not None:
data.update({"NetId": net_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_internet_services(
self,
internet_service_ids: List[str] = None,
link_net_ids: List[str] = None,
link_states: List[str] = None,
tag_keys: List[str] = None,
tag_values: List[str] = None,
tags: List[str] = None,
dry_run: bool = False
):
"""
Lists one or more of your Internet services.
An Internet service enables your virtual machines (VMs) launched in a
Net to connect to the Internet. By default, a Net includes an
Internet service, and each Subnet is public. Every VM launched within
a default Subnet has a private and a public IP addresses.
:param internet_service_ids: One or more filters.
:type internet_service_ids: ``list`` of ``str``
:param link_net_ids: The IDs of the Nets the Internet services
are attached to.
:type link_net_ids: ``list`` of ``str``
:param link_states: The current states of the attachments
between the Internet services and the Nets (only available,
if the Internet gateway is attached to a VPC). (required)
:type link_states: ``list`` of ``str``
:param tag_keys: The keys of the tags associated with the
Internet services.
:type tag_keys: ``list`` of ``str``
:param tag_values: The values of the tags associated with the
Internet services.
:type tag_values: ``list`` of ``str``
:param tags: The key/value combination of the tags associated
with the Internet services, in the following format:
"Filters":{"Tags":["TAGKEY=TAGVALUE"]}.
:type tags: ``list`` of ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: Returns the list of Internet Services
:rtype: ``list`` of ``dict``
"""
action = "ReadInternetServices"
data = {"DryRun": dry_run, "Filters": {}}
if internet_service_ids is not None:
data["Filters"].update({
"InternetServiceIds": internet_service_ids
})
if link_net_ids is not None:
data["Filters"].update({"LinkNetIds": link_net_ids})
if link_states is not None:
data["Filters"].update({"LinkStates": link_states})
if tag_keys is not None:
data["Filters"].update({"TagKeys": tag_keys})
if tag_values is not None:
data["Filters"].update({"TagValues": tag_values})
if tags is not None:
data["Filters"].update({"Tags": tags})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["InternetServices"]
return response.json()
def ex_create_listener_rule(
self,
vms: [Node] = None,
l_load_balancer_name: str = None,
l_load_balancer_port: str = None,
lr_action: str = None,
lr_host_name_pattern: str = None,
lr_id: str = None,
lr_name: str = None,
lr_path_pattern: str = None,
lr_priority: int = None,
dry_run: bool = False,
):
"""
Creates a rule for traffic redirection for the specified listener.
Each rule must have either the HostNamePattern or PathPattern parameter
specified. Rules are treated in priority order, from the highest value
to the lowest value.
Once the rule is created, you need to register backend VMs with it.
For more information, see the RegisterVmsInLoadBalancer method.
https://docs.outscale.com/api#registervmsinloadbalancer
:param vms: The IDs of the backend VMs. (required)
:type vms: ``list`` of ``Node``
:param l_load_balancer_name: The name of the load balancer to
which the listener is attached. (required)
:type l_load_balancer_name: ``str``
:param l_load_balancer_port: The port of load balancer on which
the load balancer is listening (between 1 and 65535 both included).
(required)
:type l_load_balancer_port: ``int``
:param lr_action: The type of action for the rule
(always forward).
:type lr_action: ``str``
:param lr_host_name_pattern: A host-name pattern for the rule,
with a maximum length of 128 characters. This host-name
pattern supports maximum three wildcards, and must not contain
any special characters except [-.?].
:type lr_host_name_pattern: ``str``
:param lr_id: The ID of the listener.
:type lr_id: ``str``
:param lr_name: A human-readable name for the listener rule.
:type lr_name: ``str``
:param lr_path_pattern: A path pattern for the rule, with a
maximum length of 128 characters. This path pattern supports maximum
three wildcards, and must not contain any special characters except
[_-.$/~"'@:+?].
:type lr_path_pattern: ``str``
:param lr_priority: The priority level of the listener rule,
between 1 and 19999 both included. Each rule must have a unique
priority level. Otherwise, an error is returned. (required)
:type lr_priority: ``int``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Listener Rule
:rtype: ``dict``
"""
action = "CreateListenerRule"
data = {"DryRun": dry_run, "Listener": {}, "ListenerRule": {}}
if vms is not None:
vm_ids = [vm.id for vm in vms]
data.update({"VmIds": vm_ids})
if l_load_balancer_name is not None:
data["Listener"].update({
"LoadBalancerName": l_load_balancer_name
})
if l_load_balancer_port is not None:
data["Listener"].update({
"LoadBalancerPort": l_load_balancer_port
})
if lr_action is not None:
data["ListenerRule"].update({"Action": lr_action})
if lr_host_name_pattern is not None:
data["ListenerRule"].update({
"HostNamePattern": lr_host_name_pattern
})
if lr_id is not None:
data["ListenerRule"].update({"ListenerRuleId": lr_id})
if lr_name is not None:
data["ListenerRule"].update({"ListenerRuleName": lr_name})
if lr_path_pattern is not None:
data["ListenerRule"].update({"PathPattern": lr_path_pattern})
if lr_priority is not None:
data["ListenerRule"].update({"Priority": lr_priority})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["ListenerRule"]
return response.json()
def ex_create_load_balancer_listeners(
self,
load_balancer_name: str = None,
l_backend_port: int = None,
l_backend_protocol: str = None,
l_load_balancer_port: int = None,
l_load_balancer_protocol: str = None,
l_server_certificate_id: str = None,
dry_run: bool = False,
):
"""
Creates one or more listeners for a specified load balancer.
:param load_balancer_name: The name of the load balancer for
which you want to create listeners. (required)
:type load_balancer_name: ``str``
:param l_backend_port: The port on which the back-end VM is
listening (between 1 and 65535, both included). (required)
:type l_backend_port: ``int``
:param l_backend_protocol: The protocol for routing traffic to
back-end VMs (HTTP | HTTPS | TCP | SSL | UDP).
:type l_backend_protocol: ``int``
:param l_load_balancer_port: The port on which the load balancer
is listening (between 1 and 65535, both included). (required)
:type l_load_balancer_port: ``int``
:param l_load_balancer_protocol: The routing protocol
(HTTP | HTTPS | TCP | SSL | UDP). (required)
:type l_load_balancer_protocol: ``str``
:param l_server_certificate_id: The ID of the server certificate.
(required)
:type l_server_certificate_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Load Balancer Listener
:rtype: ``dict``
"""
action = "CreateLoadBalancerListeners"
data = {"DryRun": dry_run, "Listeners": {}}
if load_balancer_name is not None:
data.update({"LoadBalancerName": load_balancer_name})
if l_backend_port is not None:
data["Listeners"].update({
"BackendPort": l_backend_port
})
if l_backend_protocol is not None:
data["Listeners"].update({
"BackendProtocol": l_backend_protocol
})
if l_load_balancer_port is not None:
data["Listeners"].update({
"LoadBalancerPort": l_load_balancer_port
})
if l_load_balancer_protocol is not None:
data["Listeners"].update({
"LoadBalancerProtocol": l_load_balancer_protocol
})
if l_server_certificate_id is not None:
data["Listeners"].update({
"ServerCertificateId": l_server_certificate_id
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["LoadBalancer"]
return response.json()
def ex_delete_listener_rule(
self,
listener_rule_name: str = None,
dry_run: bool = False,
):
"""
Deletes a listener rule.
The previously active rule is disabled after deletion.
:param listener_rule_name: The name of the rule you want to
delete. (required)
:type listener_rule_name: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteListenerRule"
data = {"DryRun": dry_run}
if listener_rule_name is not None:
data.update({"ListenerRuleName": listener_rule_name})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_delete_load_balancer_listeners(
self,
load_balancer_name: str = None,
load_balancer_ports: List[int] = None,
dry_run: bool = False,
):
"""
Deletes listeners of a specified load balancer.
:param load_balancer_name: The name of the load balancer for
which you want to delete listeners. (required)
:type load_balancer_name: ``str``
:param load_balancer_ports: One or more port numbers of the
listeners you want to delete.. (required)
:type load_balancer_ports: ``list`` of ``int``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteLoadBalancerListeners"
data = {"DryRun": dry_run}
if load_balancer_ports is not None:
data.update({"LoadBalancerPorts": load_balancer_ports})
if load_balancer_name is not None:
data.update({"LoadBalancerName": load_balancer_name})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_listener_rules(
self,
listener_rule_names: List[str] = None,
dry_run: bool = False
):
"""
Describes one or more listener rules. By default, this action returns
the full list of listener rules for the account.
:param listener_rule_names: The names of the listener rules.
:type listener_rule_names: ``list`` of ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: Returns the list of Listener Rules
:rtype: ``list`` of ``dict``
"""
action = "ReadListenerRules"
data = {"DryRun": dry_run, "Filters": {}}
if listener_rule_names is not None:
data["Filters"].update({
"ListenerRuleNames": listener_rule_names
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["ListenerRules"]
return response.json()
def ex_update_listener_rule(
self,
host_pattern: str = None,
listener_rule_name: str = None,
path_pattern: str = None,
dry_run: bool = False,
):
"""
Updates the pattern of the listener rule.
This call updates the pattern matching algorithm for incoming traffic.
:param host_pattern: TA host-name pattern for the rule, with a
maximum length of 128 characters. This host-name pattern supports
maximum three wildcards, and must not contain any special characters
except [-.?].
:type host_pattern: ``str`
:param listener_rule_name: The name of the listener rule.
(required)
:type listener_rule_name: ``str``
:param path_pattern: A path pattern for the rule, with a maximum
length of 128 characters. This path pattern supports maximum three
wildcards, and must not contain any special characters
except [_-.$/~"'@:+?].
:type path_pattern: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: Update the specified Listener Rule
:rtype: ``dict``
"""
action = "UpdateListenerRule"
data = {"DryRun": dry_run}
if host_pattern is not None:
data.update({"HostPattern": host_pattern})
if listener_rule_name is not None:
data.update({"ListenerRuleName": listener_rule_name})
if path_pattern is not None:
data.update({"PathPattern": path_pattern})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["ListenerRule"]
return response.json()
def ex_create_load_balancer(
self,
load_balancer_name: str = None,
load_balancer_type: str = None,
security_groups: List[str] = None,
subnets: List[str] = None,
subregion_names: str = None,
tag_keys: List[str] = None,
tag_values: List[str] = None,
l_backend_port: int = None,
l_backend_protocol: str = None,
l_load_balancer_port: int = None,
l_load_balancer_protocol: str = None,
l_server_certificate_id: str = None,
dry_run: bool = False,
):
"""
Creates a load balancer.
The load balancer is created with a unique Domain Name Service (DNS)
name. It receives the incoming traffic and routes it to its registered
virtual machines (VMs). By default, this action creates an
Internet-facing load balancer, resolving to public IP addresses.
To create an internal load balancer in a Net, resolving to private IP
addresses, use the LoadBalancerType parameter.
:param load_balancer_name: The name of the load balancer for
which you want to create listeners. (required)
:type load_balancer_name: ``str``
:param load_balancer_type: The type of load balancer:
internet-facing or internal. Use this parameter only for load
balancers in a Net.
:type load_balancer_type: ``str``
:param security_groups: One or more IDs of security groups you
want to assign to the load balancer.
:type security_groups: ``list`` of ``str``
:param subnets: One or more IDs of Subnets in your Net that you
want to attach to the load balancer.
:type subnets: ``list`` of ``str``
:param subregion_names: One or more names of Subregions
(currently, only one Subregion is supported). This parameter is not
required if you create a load balancer in a Net. To create an internal
load balancer, use the LoadBalancerType parameter.
:type subregion_names: ``list`` of ``str``
:param tag_keys: The key of the tag, with a minimum of 1
character. (required)
:type tag_keys: ``list`` of ``str``
:param tag_values: The value of the tag, between 0 and 255
characters. (required)
:type tag_values: ``list`` of ``str``
:param l_backend_port: The port on which the back-end VM is
listening (between 1 and 65535, both included). (required)
:type l_backend_port: ``int``
:param l_backend_protocol: The protocol for routing traffic to
back-end VMs (HTTP | HTTPS | TCP | SSL | UDP).
:type l_backend_protocol: ``int``
:param l_load_balancer_port: The port on which the load balancer
is listening (between 1 and 65535, both included). (required)
:type l_load_balancer_port: ``int``
:param l_load_balancer_protocol: The routing protocol
(HTTP | HTTPS | TCP | SSL | UDP). (required)
:type l_load_balancer_protocol: ``str``
:param l_server_certificate_id: The ID of the server certificate.
(required)
:type l_server_certificate_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Load Balancer
:rtype: ``dict``
"""
action = "CreateLoadBalancer"
data = {"DryRun": dry_run, "Listeners": {}, "Tags": {}}
if load_balancer_name is not None:
data.update({"LoadBalancerName": load_balancer_name})
if load_balancer_type is not None:
data.update({"LoadBalencerType": load_balancer_type})
if security_groups is not None:
data.update({"SecurityGroups": security_groups})
if subnets is not None:
data.update({"Subnets": subnets})
if subregion_names is not None:
data.update({"SubregionNames": subregion_names})
if tag_keys and tag_values and len(tag_keys) == len(tag_values):
for key, value in zip(tag_keys, tag_values):
data["Tags"].update({"Key": key, "Value": value})
if l_backend_port is not None:
data["Listeners"].update({
"BackendPort": l_backend_port
})
if l_backend_protocol is not None:
data["Listeners"].update({
"BackendProtocol": l_backend_protocol
})
if l_load_balancer_port is not None:
data["Listeners"].update({
"LoadBalancerPort": l_load_balancer_port
})
if l_load_balancer_protocol is not None:
data["Listeners"].update({
"LoadBalancerProtocol": l_load_balancer_protocol
})
if l_server_certificate_id is not None:
data["Listeners"].update({
"ServerCertificateId": l_server_certificate_id
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["LoadBalancer"]
return response.json()
def ex_create_load_balancer_tags(
self,
load_balancer_names: List[str] = None,
tag_keys: List[str] = None,
tag_values: List[str] = None,
dry_run: bool = False,
):
"""
Adds one or more tags to the specified load balancers.
If a tag with the same key already exists for the load balancer,
the tag value is replaced.
:param load_balancer_names: The name of the load balancer for
which you want to create listeners. (required)
:type load_balancer_names: ``str``
:param tag_keys: The key of the tag, with a minimum of 1
character. (required)
:type tag_keys: ``list`` of ``str``
:param tag_values: The value of the tag, between 0 and 255
characters. (required)
:type tag_values: ``list`` of ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Load Balancer Tags
:rtype: ``dict``
"""
action = "CreateLoadBalancerTags"
data = {"DryRun": dry_run, "Tags": {}}
if load_balancer_names is not None:
data.update({"LoadBalancerNames": load_balancer_names})
if tag_keys and tag_values and len(tag_keys) == len(tag_values):
for key, value in zip(tag_keys, tag_values):
data["Tags"].update({"Key": key, "Value": value})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["LoadBalancer"]
return response.json()
def ex_delete_load_balancer(
self,
load_balancer_name: str = None,
dry_run: bool = False,
):
"""
Deletes a specified load balancer.
:param load_balancer_name: The name of the load balancer you want
to delete. (required)
:type load_balancer_name: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteLoadBalancer"
data = {"DryRun": dry_run}
if load_balancer_name is not None:
data.update({"LoadBalancerName": load_balancer_name})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_delete_load_balancer_tags(
self,
load_balancer_names: List[str] = None,
tag_keys: List[str] = None,
dry_run: bool = False,
):
"""
Deletes a specified load balancer tags.
:param load_balancer_names: The names of the load balancer for
which you want to delete tags. (required)
:type load_balancer_names: ``str``
:param tag_keys: The key of the tag, with a minimum of
1 character.
:type tag_keys: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteLoadBalancerTags"
data = {"DryRun": dry_run, "Tags": {}}
if load_balancer_names is not None:
data.update({"LoadBalancerNames": load_balancer_names})
if tag_keys is not None:
data["Tags"].update({"Keys": tag_keys})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_deregister_vms_in_load_balancer(
self,
backend_vm_ids: List[str] = None,
load_balancer_name: str = None,
dry_run: bool = False,
):
"""
Deregisters a specified virtual machine (VM) from a load balancer.
:param backend_vm_ids: One or more IDs of back-end VMs.
(required)
:type backend_vm_ids: ``str``
:param load_balancer_name: The name of the load balancer.
(required)
:type load_balancer_name: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeregisterVmsInLoadBalancer"
data = {"DryRun": dry_run}
if load_balancer_name is not None:
data.update({"LoadBalancerName": load_balancer_name})
if backend_vm_ids is not None:
data.update({"BackendVmIds": backend_vm_ids})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_load_balancer_tags(
self,
load_balancer_names: List[str] = None,
dry_run: bool = False,
):
"""
Describes the tags associated with one or more specified load
balancers.
:param load_balancer_names: The names of the load balancer.
(required)
:type load_balancer_names: ``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 load balancer tags
:rtype: ``list`` of ``dict``
"""
action = "ReadLoadBalancerTags"
data = {"DryRun": dry_run}
if load_balancer_names is not None:
data.update({"LoadBalancerNames": load_balancer_names})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["Tags"]
return response.json()
def ex_list_load_balancers(
self,
load_balancer_names: List[str] = None,
dry_run: bool = False,
):
"""
Lists one or more load balancers and their attributes.
:param load_balancer_names: The names of the load balancer.
(required)
:type load_balancer_names: ``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 load balancer
:rtype: ``list`` of ``dict``
"""
action = "ReadLoadBalancers"
data = {"DryRun": dry_run, "Filters": {}}
if load_balancer_names is not None:
data["Filters"].update({"LoadBalancerNames": load_balancer_names})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["LoadBalancers"]
return response.json()
def ex_list_vms_health(
self,
backend_vm_ids: List[str] = None,
load_balancer_name: str = None,
dry_run: bool = False,
):
"""
Lists the state of one or more back-end virtual machines (VMs)
registered with a specified load balancer.
:param load_balancer_name: The name of the load balancer.
(required)
:type load_balancer_name: ``str``
:param backend_vm_ids: One or more IDs of back-end VMs.
:type backend_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: a list of back end vms health
:rtype: ``list`` of ``dict``
"""
action = "ReadVmsHealth"
data = {"DryRun": dry_run}
if backend_vm_ids is not None:
data.update({"BackendVmIds": backend_vm_ids})
if load_balancer_name is not None:
data.update({"LoadBalancerName": load_balancer_name})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["BackendVmHealth"]
return response.json()
def ex_register_vms_in_load_balancer(
self,
backend_vm_ids: List[str] = None,
load_balancer_name: str = None,
dry_run: bool = False,
):
"""
Registers one or more virtual machines (VMs) with a specified load
balancer.
The VMs must be running in the same network as the load balancer
(in the public Cloud or in the same Net). It may take a little time
for a VM to be registered with the load balancer. Once the VM is
registered with a load balancer, it receives traffic and requests from
this load balancer and is called a back-end VM.
:param load_balancer_name: The name of the load balancer.
(required)
:type load_balancer_name: ``str``
:param backend_vm_ids: One or more IDs of back-end VMs.
:type backend_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: a list of back end vms health
:rtype: ``list`` of ``dict``
"""
action = "RegisterVmsInLoadBalancer"
data = {"DryRun": dry_run, "Filters": {}}
if backend_vm_ids is not None:
data.update({"BackendVmIds": backend_vm_ids})
if load_balancer_name is not None:
data.update({"LoadBalancerName": load_balancer_name})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["BackendVmHealth"]
return response.json()
def ex_update_load_balancer(
self,
access_log_is_enabled: bool = None,
access_log_osu_bucket_name: str = None,
access_log_osu_bucket_prefix: str = None,
access_log_publication_interval: int = None,
health_check_interval: int = None,
health_check_healthy_threshold: int = None,
health_check_path: str = None,
health_check_port: int = None,
health_check_protocol: str = None,
health_check_timeout: int = None,
health_check_unhealthy_threshold: int = None,
load_balancer_name: str = None,
load_balancer_port: int = None,
policy_names: List[str] = None,
server_certificate_id: str = None,
dry_run: bool = False,
):
"""
Modifies the specified attributes of a load balancer.
You can set a new SSL certificate to an SSL or HTTPS listener of a
load balancer.
This certificate replaces any certificate used on the same load
balancer and port.
You can also replace the current set of policies for a load balancer
with another specified one.
If the PolicyNames parameter is empty, all current policies are
disabled.
:param access_log_is_enabled: If true, access logs are enabled
for your load balancer.
If false, they are not. If you set this to true in your request, the
OsuBucketName parameter is required.
:type access_log_is_enabled: ``bool`
:param access_log_osu_bucket_name: The name of the Object Storage
Unit (OSU) bucket for the access logs.
:type access_log_osu_bucket_name: ``str``
:param access_log_osu_bucket_prefix: The path to the folder of
the access logs in your Object Storage Unit (OSU) bucket (by default,
the root level of your bucket).
:type access_log_osu_bucket_prefix: ``str``
:param access_log_publication_interval: The time interval for the
publication of access logs in the Object Storage Unit (OSU) bucket,
in minutes. This value can be either 5 or 60 (by default, 60).
:type access_log_publication_interval: ``int``
:param health_check_interval: Information about the health check
configuration. (required)
:type health_check_interval: ``int``
:param health_check_path: The path for HTTP or HTTPS requests.
(required)
:type health_check_path: ``str``
:param health_check_port: The port number (between 1 and 65535,
both included). (required)
:type health_check_port: ``int``
:param health_check_protocol: The protocol for the URL of the VM
(HTTP | HTTPS | TCP | SSL | UDP). (required)
:type health_check_protocol: ``str``
:param health_check_timeout: The maximum waiting time for a
response before considering the VM as unhealthy, in seconds (between 2
and 60 both included). (required)
:type health_check_timeout: ``int``
:param health_check_healthy_threshold: The number of consecutive
failed pings before considering the VM as unhealthy (between 2 and
10 both included). (required)
:type health_check_healthy_threshold: ``int``
:param health_check_unhealthy_threshold: The number of
consecutive failed pings before considering the VM as unhealthy
(between 2 and 10 both included).(required)
:type health_check_unhealthy_threshold: ``int``
:param load_balancer_name: The name of the load balancer.
(required)
:type load_balancer_name: ``str``
:param load_balancer_port: The port on which the load balancer is
listening (between 1 and 65535, both included).
:type load_balancer_port: ``int``
:param policy_names: The list of policy names (must contain all
the policies to be enabled).
:type policy_names: ``list`` of ``str``
:param server_certificate_id: The list of policy names (must
contain all the policies to be enabled).
:type server_certificate_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: Update the specified Load Balancer
:rtype: ``dict``
"""
action = "UpdateLoadBalancer"
data = {"DryRun": dry_run, "AccessLog": {}, "HealthCheck": {}}
if access_log_is_enabled is not None:
data["AccessLog"].update({"IsEnabled": access_log_is_enabled})
if access_log_osu_bucket_name is not None:
data["AccessLog"].update({
"OsuBucketName": access_log_osu_bucket_name
})
if access_log_osu_bucket_prefix is not None:
data["AccessLog"].update({
"OsuBucketPrefix": access_log_osu_bucket_prefix
})
if access_log_publication_interval is not None:
data["AccessLog"].update({
"PublicationInterval": access_log_publication_interval
})
if health_check_interval is not None:
data["HealthCheck"].update({
"CheckInterval": health_check_interval
})
if health_check_healthy_threshold is not None:
data["HealthCheck"].update({
"HealthyThreshold": health_check_healthy_threshold
})
if health_check_path is not None:
data["HealthCheck"].update({
"Path": health_check_path
})
if health_check_port is not None:
data["HealthCheck"].update({
"Port": health_check_port
})
if health_check_protocol is not None:
data["HealthCheck"].update({
"Protocol": health_check_protocol
})
if health_check_timeout is not None:
data["HealthCheck"].update({
"Timeout": health_check_timeout
})
if health_check_unhealthy_threshold is not None:
data["HealthCheck"].update({
"UnhealthyThreshold": health_check_unhealthy_threshold
})
if load_balancer_name is not None:
data.update({"LoadBalancerName": load_balancer_name})
if load_balancer_port is not None:
data.update({"LoadBalancerPort": load_balancer_port})
if policy_names is not None:
data.update({"PolicyNames": policy_names})
if server_certificate_id is not None:
data.update({"ServerCertificateId": server_certificate_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["LoadBalancer"]
return response.json()
def ex_create_load_balancer_policy(
self,
cookie_name: str = None,
load_balancer_name: str = None,
policy_name: str = None,
policy_type: str = None,
dry_run: bool = False,
):
"""
Creates a stickiness policy with sticky session lifetimes defined by
the browser lifetime. The created policy can be used with HTTP or
HTTPS listeners only.
If this policy is implemented by a load balancer, this load balancer
uses this cookie in all incoming requests to direct them to the
specified back-end server virtual machine (VM). If this cookie is not
present, the load balancer sends the request to any other server
according to its load-balancing algorithm.
You can also create a stickiness policy with sticky session lifetimes
following the lifetime of an application-generated cookie.
Unlike the other type of stickiness policy, the lifetime of the
special Load Balancer Unit (LBU) cookie follows the lifetime of the
application-generated cookie specified in the policy configuration.
The load balancer inserts a new stickiness cookie only when the
application response includes a new application cookie.
The session stops being sticky if the application cookie is removed or
expires, until a new application cookie is issued.
:param cookie_name: The name of the application cookie used for
stickiness. This parameter is required if you create a stickiness
policy based on an application-generated cookie.
:type cookie_name: ``str``
:param load_balancer_name: The name of the load balancer for
which you want to create a policy. (required)
:type load_balancer_name: ``str``
:param policy_name: The name of the policy. This name must be
unique and consist of alphanumeric characters and dashes (-).
(required)
:type policy_name: ``str``
:param policy_type: The type of stickiness policy you want to
create: app or load_balancer. (required)
:type policy_type: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Load Balancer Policy
:rtype: ``dict``
"""
action = "CreateLoadBalancerPolicy"
data = {"DryRun": dry_run, "Tags": {}}
if cookie_name is not None:
data.update({"CookieName": cookie_name})
if load_balancer_name is not None:
data.update({"LoadBalancerName": load_balancer_name})
if policy_type is not None:
data.update({"PolicyType": policy_type})
if policy_name is not None:
data.update({"PolicyName": policy_name})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["LoadBalancer"]
return response.json()
def ex_delete_load_balancer_policy(
self,
load_balancer_name: str = None,
policy_name: str = None,
dry_run: bool = False,
):
"""
Deletes a specified policy from a load balancer.
In order to be deleted, the policy must not be enabled for any
listener.
:param load_balancer_name: The name of the load balancer for
which you want to delete a policy. (required)
:type load_balancer_name: ``str``
:param policy_name: The name of the policy you want to delete.
(required)
:type policy_name: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteLoadBalancerPolicy"
data = {"DryRun": dry_run, "Tags": {}}
if load_balancer_name is not None:
data.update({"LoadBalancerName": load_balancer_name})
if policy_name is not None:
data["Tags"].update({"PolicyName": policy_name})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_create_nat_service(
self,
public_ip: str = None,
subnet_id: str = None,
dry_run: bool = False,
):
"""
Creates a network address translation (NAT) service in the specified
public Subnet of a Net.
A NAT service enables virtual machines (VMs) placed in the private
Subnet of this Net to connect to the Internet, without being
accessible from the Internet.
When creating a NAT service, you specify the allocation ID of the
External IP (EIP) you want to use as public IP for the NAT service.
Once the NAT service is created, you need to create a route in the
route table of the private Subnet, with 0.0.0.0/0 as destination and
the ID of the NAT service as target. For more information, see
LinkPublicIP and CreateRoute.
This action also enables you to create multiple NAT services in the
same Net (one per public Subnet).
:param public_ip: The allocation ID of the EIP to associate
with the NAT service. (required)
:type public_ip: ``str``
:param subnet_id: The ID of the Subnet in which you want to
create the NAT service. (required)
:type subnet_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Nat Service
:rtype: ``dict``
"""
action = "CreateNatService"
data = {"DryRun": dry_run}
if public_ip is not None:
data.update({"PublicIpId": public_ip})
if subnet_id is not None:
data.update({"SubnetId": subnet_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["NatService"]
return response.json()
def ex_delete_nat_service(
self,
nat_service_id: str = None,
dry_run: bool = False,
):
"""
Deletes a specified network address translation (NAT) service.
This action disassociates the External IP address (EIP) from the NAT
service, but does not release this EIP from your account. However, it
does not delete any NAT service routes in your route tables.
:param nat_service_id: TThe ID of the NAT service you want to
delete. (required)
:type nat_service_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteNatService"
data = {"DryRun": dry_run}
if nat_service_id is not None:
data.update({"NatServiceId": nat_service_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_nat_services(
self,
nat_service_ids: List[str] = None,
net_ids: List[str] = None,
states: List[str] = None,
subnet_ids: List[str] = None,
tag_keys: List[str] = None,
tag_values: List[str] = None,
tags: List[str] = None,
dry_run: bool = False,
):
"""
Lists one or more network address translation (NAT) services.
:param nat_service_ids: The IDs of the NAT services.
:type nat_service_ids: ``list`` of ``str``
:param net_ids: The IDs of the Nets in which the NAT services are.
:type net_ids: ``list`` of ``str``
:param states: The states of the NAT services
(pending | available | deleting | deleted).
:type states: ``list`` of ``str``
:param subnet_ids: The IDs of the Subnets in which the NAT
services are.
:type subnet_ids: ``list`` of ``str``
:param tag_keys: The keys of the tags associated with the NAT
services.
:type tag_keys: ``list`` of ``str``
:param tag_values: The values of the tags associated with the NAT
services.
:type tag_values: ``list`` of ``str``
:param tags: The values of the tags associated with the NAT
services.
:type tags: ``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 back end vms health
:rtype: ``list`` of ``dict``
"""
action = "ReadNatServices"
data = {"DryRun": dry_run, "Filters": {}}
if nat_service_ids is not None:
data["Filters"].update({"NatServiceIds": nat_service_ids})
if states is not None:
data["Filters"].update({"States": states})
if net_ids is not None:
data["Filters"].update({"NetIds": net_ids})
if subnet_ids is not None:
data["Filters"].update({"SubnetIds": subnet_ids})
if tag_keys is not None:
data["Filters"].update({"TagKeys": tag_keys})
if tag_values is not None:
data["Filters"].update({"TagValues": tag_values})
if tags is not None:
data["Filters"].update({"Tags": tags})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["NatServices"]
return response.json()
def ex_create_net(
self,
ip_range: str = None,
tenancy: str = None,
dry_run: bool = False,
):
"""
Creates a Net with a specified IP range.
The IP range (network range) of your Net must be between a /28 netmask
(16 IP addresses) and a /16 netmask (65 536 IP addresses).
:param ip_range: The IP range for the Net, in CIDR notation
(for example, 10.0.0.0/16). (required)
:type ip_range: ``str``
:param tenancy: The tenancy options for the VMs (default if a VM
created in a Net can be launched with any tenancy, dedicated if it can
be launched with dedicated tenancy VMs running on single-tenant
hardware).
:type tenancy: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Nat Service
:rtype: ``dict``
"""
action = "CreateNet"
data = {"DryRun": dry_run}
if ip_range is not None:
data.update({"IpRange": ip_range})
if tenancy is not None:
data.update({"Tenancy": tenancy})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["Net"]
return response.json()
def ex_delete_net(
self,
net_id: str = None,
dry_run: bool = False,
):
"""
Deletes a specified Net.
Before deleting the Net, you need to delete or detach all the
resources associated with the Net:
- Virtual machines (VMs)
- Net peering connections
- Custom route tables
- External IP addresses (EIPs) allocated to resources in the Net
- Network Interface Cards (NICs) created in the Subnets
- Virtual gateways, Internet services and NAT services
- Load balancers
- Security groups
- Subnets
:param net_id: The ID of the Net you want to delete. (required)
:type net_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteNet"
data = {"DryRun": dry_run}
if net_id is not None:
data.update({"NetId": net_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_nets(
self,
dhcp_options_set_ids: List[str] = None,
ip_ranges: List[str] = None,
is_default: bool = None,
net_ids: List[str] = None,
states: List[str] = None,
tag_keys: List[str] = None,
tag_values: List[str] = None,
tags: List[str] = None,
dry_run: bool = False,
):
"""
Lists one or more Nets.
:param dhcp_options_set_ids: The IDs of the DHCP options sets.
:type dhcp_options_set_ids: ``list`` of ``str``
:param ip_ranges: The IP ranges for the Nets, in CIDR notation
(for example, 10.0.0.0/16).
:type ip_ranges: ``list`` of ``str``
:param is_default: If true, the Net used is the default one.
:type is_default: ``bool``
:param net_ids: The IDs of the Nets.
:type net_ids: ``list`` of ``str``
:param states: The states of the Nets (pending | available).
:type states: ``list`` of ``str``
:param tag_keys: The keys of the tags associated with the Nets.
:type tag_keys: ``list`` of ``str``
:param tag_values: The values of the tags associated with the
Nets.
:type tag_values: ``list`` of ``str``
:param tags: The key/value combination of the tags associated
with the Nets, in the following format:
"Filters":{"Tags":["TAGKEY=TAGVALUE"]}.
:type tags: ``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 Nets
:rtype: ``list`` of ``dict``
"""
action = "ReadNets"
data = {"DryRun": dry_run, "Filters": {}}
if dhcp_options_set_ids is not None:
data["Filters"].update({"DhcpOptionsSetIds": dhcp_options_set_ids})
if ip_ranges is not None:
data["Filters"].update({"IpRanges": ip_ranges})
if is_default is not None:
data["Filters"].update({"IsDefault": is_default})
if net_ids is not None:
data["Filters"].update({"NetIds": net_ids})
if states is not None:
data["Filters"].update({"States": states})
if tag_keys is not None:
data["Filters"].update({"TagKeys": tag_keys})
if tag_values is not None:
data["Filters"].update({"TagValues": tag_values})
if tags is not None:
data["Filters"].update({"Tags": tags})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["Nets"]
return response.json()
def ex_update_net(
self,
net_id: str = None,
dhcp_options_set_id: str = None,
dry_run: bool = False,
):
"""
Associates a DHCP options set with a specified Net.
:param net_id: The ID of the Net. (required)
:type net_id: ``str``
:param dhcp_options_set_id: The ID of the DHCP options set
(or default if you want to associate the default one). (required)
:type dhcp_options_set_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The modified Nat Service
:rtype: ``dict``
"""
action = "UpdateNet"
data = {"DryRun": dry_run}
if net_id is not None:
data.update({"NetId": net_id})
if dhcp_options_set_id is not None:
data.update({"DhcpOptionsSetId": dhcp_options_set_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["Net"]
return response.json()
def ex_create_net_access_point(
self,
net_id: str = None,
route_table_ids: List[str] = None,
service_name: str = None,
dry_run: bool = False,
):
"""
Creates a Net access point to access a 3DS OUTSCALE service from this
Net without using the Internet and External IP addresses.
You specify the service using its prefix list name. For more
information, see DescribePrefixLists:
https://docs.outscale.com/api#describeprefixlists
To control the routing of traffic between the Net and the specified
service, you can specify one or more route tables. Virtual machines
placed in Subnets associated with the specified route table thus use
the Net access point to access the service. When you specify a route
table, a route is automatically added to it with the destination set
to the prefix list ID of the service, and the target set to the ID of
the access point.
:param net_id: The ID of the Net. (required)
:type net_id: ``str``
:param route_table_ids: One or more IDs of route tables to use
for the connection.
:type route_table_ids: ``list`` of ``str``
:param service_name: The prefix list name corresponding to the
service (for example, com.outscale.eu-west-2.osu for OSU). (required)
:type service_name: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Access Net Point
:rtype: ``dict``
"""
action = "CreateNetAccessPoint"
data = {"DryRun": dry_run}
if net_id is not None:
data.update({"NetId": net_id})
if route_table_ids is not None:
data.update({"RouteTableIds": route_table_ids})
if service_name is not None:
data.update({"ServiceName": service_name})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["NetAccessPoint"]
return response.json()
def ex_delete_net_access_point(
self,
net_access_point_id: str = None,
dry_run: bool = False,
):
"""
Deletes one or more Net access point.
This action also deletes the corresponding routes added to the route
tables you specified for the Net access point.
:param net_access_point_id: The ID of the Net access point.
(required)
:type net_access_point_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteNetAccessPoint"
data = {"DryRun": dry_run}
if net_access_point_id is not None:
data.update({"NetAccessPointId": net_access_point_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_nets_access_point_services(
self,
service_ids: List[str] = None,
service_names: List[str] = None,
dry_run: bool = False,
):
"""
Describes 3DS OUTSCALE services available to create Net access points.
For more information, see CreateNetAccessPoint:
https://docs.outscale.com/api#createnetaccesspoint
:param service_ids: The IDs of the services.
:type service_ids: ``list`` of ``str``
:param service_names: The names of the prefix lists, which
identify the 3DS OUTSCALE services they are associated with.
:type service_names: ``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 Services
:rtype: ``list`` of ``dict``
"""
action = "ReadNetAccessPointServices"
data = {"DryRun": dry_run, "Filters": {}}
if service_names is not None:
data["Filters"].update({"ServiceNames": service_names})
if service_ids is not None:
data["Filters"].update({"ServiceIds": service_ids})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["Services"]
return response.json()
def ex_list_nets_access_points(
self,
net_access_point_ids: List[str] = None,
net_ids: List[str] = None,
service_names: List[str] = None,
states: List[str] = None,
tag_keys: List[str] = None,
tag_values: List[str] = None,
tags: List[str] = None,
dry_run: bool = False,
):
"""
Describes one or more Net access points.
:param net_access_point_ids: The IDs of the Net access points.
:type net_access_point_ids: ``list`` of ``str``
:param net_ids: The IDs of the Nets.
:type net_ids: ``list`` of ``str``
:param service_names: The The names of the prefix lists
corresponding to the services. For more information,
see DescribePrefixLists:
https://docs.outscale.com/api#describeprefixlists
:type service_names: ``list`` of ``str``
:param states: The states of the Net access points
(pending | available | deleting | deleted).
:type states: ``list`` of ``str``
:param tag_keys: The keys of the tags associated with the Net
access points.
:type tag_keys: ``list`` of ``str``
:param tag_values: The values of the tags associated with the
Net access points.
:type tag_values: ``list`` of ``str``
:param tags: The key/value combination of the tags associated
with the Net access points, in the following format:
"Filters":{"Tags":["TAGKEY=TAGVALUE"]}.
:type tags: ``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 Net Access Points
:rtype: ``list`` of ``dict``
"""
action = "ReadNetAccessPoints"
data = {"DryRun": dry_run, "Filters": {}}
if net_access_point_ids is not None:
data["Filters"].update({"NetAccessPointIds": net_access_point_ids})
if net_ids is not None:
data["Filters"].update({"NetIds": net_ids})
if service_names is not None:
data["Filters"].update({"ServiceNames": service_names})
if states is not None:
data["Filters"].update({"States": states})
if tag_keys is not None:
data["Filters"].update({"TagKeys": tag_keys})
if tag_values is not None:
data["Filters"].update({"TagValues": tag_values})
if tags is not None:
data["Filters"].update({"Tags": tags})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["NetAccessPoints"]
return response.json()
def ex_update_net_access_point(
self,
add_route_table_ids: List[str] = None,
net_access_point_id: str = None,
remove_route_table_ids: List[str] = None,
dry_run: bool = False,
):
"""
Modifies the attributes of a Net access point.
This action enables you to add or remove route tables associated with
the specified Net access point.
:param add_route_table_ids: One or more IDs of route tables to
associate with the specified Net access point.
:type add_route_table_ids: ``list`` of ``str``
:param net_access_point_id: The ID of the Net access point.
(required)
:type net_access_point_id: ``str``
:param remove_route_table_ids: One or more IDs of route tables to
disassociate from the specified Net access point.
:type remove_route_table_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: The modified Net Access Point
:rtype: ``dict``
"""
action = "UpdateNetAccessPoint"
data = {"DryRun": dry_run}
if add_route_table_ids is not None:
data.update({"AddRouteTablesIds": add_route_table_ids})
if net_access_point_id is not None:
data.update({"NetAccessPointId": net_access_point_id})
if remove_route_table_ids is not None:
data.update({"RemoveRouteTableIds": remove_route_table_ids})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["NetAccessPoint"]
return response.json()
def ex_create_net_peering(
self,
accepter_net_id: str = None,
source_net_id: str = None,
dry_run: bool = False,
):
"""
Requests a Net peering connection between a Net you own and a peer Net
that belongs to you or another account.
This action creates a Net peering connection that remains in the
pending-acceptance state until it is accepted by the owner of the peer
Net. If the owner of the peer Net does not accept the request within
7 days, the state of the Net peering connection becomes expired.
For more information, see AcceptNetPeering:
https://docs.outscale.com/api#acceptnetpeering
:param accepter_net_id: The ID of the Net you want to connect
with. (required)
:type accepter_net_id: ``str``
:param source_net_id: The ID of the Net you send the peering
request from. (required)
:type source_net_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Net Peering
:rtype: ``dict``
"""
action = "CreateNetPeering"
data = {"DryRun": dry_run}
if accepter_net_id is not None:
data.update({"AccepterNetId": accepter_net_id})
if source_net_id is not None:
data.update({"SourceNetId": source_net_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["NetPeering"]
return response.json()
def ex_accept_net_peering(
self,
net_peering_id: List[str] = None,
dry_run: bool = False,
):
"""
Accepts a Net peering connection request.
To accept this request, you must be the owner of the peer Net. If
you do not accept the request within 7 days, the state of the Net
peering connection becomes expired.
:param net_peering_id: The ID of the Net peering connection you
want to accept. (required)
:type net_peering_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The accepted Net Peering
:rtype: ``dict``
"""
action = "AcceptNetPeering"
data = {"DryRun": dry_run}
if net_peering_id is not None:
data.update({"NetPeeringId": net_peering_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["NetPeering"]
return response.json()
def ex_delete_net_peering(
self,
net_peering_id: List[str] = None,
dry_run: bool = False,
):
"""
Deletes a Net peering connection.
If the Net peering connection is in the active state, it can be
deleted either by the owner of the requester Net or the owner of the
peer Net.
If it is in the pending-acceptance state, it can be deleted only by
the owner of the requester Net.
If it is in the rejected, failed, or expired states, it cannot be
deleted.
:param net_peering_id: The ID of the Net peering connection you
want to delete. (required)
:type net_peering_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteNetPeering"
data = {"DryRun": dry_run}
if net_peering_id is not None:
data.update({"NetPeeringId": net_peering_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_net_peerings(
self,
accepter_net_account_ids: List[str] = None,
accepter_net_ip_ranges: List[str] = None,
accepter_net_net_ids: List[str] = None,
net_peering_ids: List[str] = None,
source_net_account_ids: List[str] = None,
source_net_ip_ranges: List[str] = None,
source_net_net_ids: List[str] = None,
state_messages: List[str] = None,
states_names: List[str] = None,
tag_keys: List[str] = None,
tag_values: List[str] = None,
tags: List[str] = None,
dry_run: bool = False,
):
"""
Lists one or more peering connections between two Nets.
:param accepter_net_account_ids: The account IDs of the owners of
the peer Nets.
:type accepter_net_account_ids: ``list`` of ``str``
:param accepter_net_ip_ranges: The IP ranges of the peer Nets, in
CIDR notation (for example, 10.0.0.0/24).
:type accepter_net_ip_ranges: ``list`` of ``str``
:param accepter_net_net_ids: The IDs of the peer Nets.
:type accepter_net_net_ids: ``list`` of ``str``
:param source_net_account_ids: The account IDs of the owners of
the peer Nets.
:type source_net_account_ids: ``list`` of ``str``
:param source_net_ip_ranges: The IP ranges of the peer Nets.
:type source_net_ip_ranges: ``list`` of ``str``
:param source_net_net_ids: The IDs of the peer Nets.
:type source_net_net_ids: ``list`` of ``str``
:param net_peering_ids: The IDs of the Net peering connections.
:type net_peering_ids: ``list`` of ``str``
:param state_messages: Additional information about the states of
the Net peering connections.
:type state_messages: ``list`` of ``str``
:param states_names: The states of the Net peering connections
(pending-acceptance | active | rejected | failed | expired | deleted).
:type states_names: ``list`` of ``str``
:param tag_keys: The keys of the tags associated with the Net
peering connections.
:type tag_keys: ``list`` of ``str``
:param tag_values: TThe values of the tags associated with the
Net peering connections.
:type tag_values: ``list`` of ``str``
:param tags: The key/value combination of the tags associated
with the Net peering connections, in the following format:
"Filters":{"Tags":["TAGKEY=TAGVALUE"]}.
:type tags: ``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 Net Access Points
:rtype: ``list`` of ``dict``
"""
action = "ReadNetPeerings"
data = {"DryRun": dry_run, "Filters": {}}
if accepter_net_account_ids is not None:
data["Filters"].update({
"AccepterNetAccountIds": accepter_net_account_ids
})
if accepter_net_ip_ranges is not None:
data["Filters"].update({
"AccepterNetIpRanges": accepter_net_ip_ranges
})
if accepter_net_net_ids is not None:
data["Filters"].update({"AccepterNetNetIds": accepter_net_net_ids})
if source_net_account_ids is not None:
data["Filters"].update({
"SourceNetAccountIds": source_net_account_ids
})
if source_net_ip_ranges is not None:
data["Filters"].update({
"SourceNetIpRanges": source_net_ip_ranges
})
if source_net_net_ids is not None:
data["Filters"].update({"SourceNetNetIds": source_net_net_ids})
if net_peering_ids is not None:
data["Filters"].update({"NetPeeringIds": net_peering_ids})
if state_messages is not None:
data["Filters"].update({"StateMessages": state_messages})
if states_names is not None:
data["Filters"].update({"StateNames": states_names})
if tag_keys is not None:
data["Filters"].update({"TagKeys": tag_keys})
if tag_values is not None:
data["Filters"].update({"TagValues": tag_values})
if tags is not None:
data["Filters"].update({"Tags": tags})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["NetPeerings"]
return response.json()
def ex_reject_net_peering(
self,
net_peering_id: List[str] = None,
dry_run: bool = False,
):
"""
Rejects a Net peering connection request.
The Net peering connection must be in the pending-acceptance state to
be rejected. The rejected Net peering connection is then in the
rejected state.
:param net_peering_id: The ID of the Net peering connection you
want to reject. (required)
:type net_peering_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The rejected Net Peering
:rtype: ``dict``
"""
action = "RejectNetPeering"
data = {"DryRun": dry_run}
if net_peering_id is not None:
data.update({"NetPeeringId": net_peering_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_create_nic(
self,
description: str = None,
private_ips_is_primary: List[str] = None,
private_ips: List[str] = None,
security_group_ids: List[str] = None,
subnet_id: str = None,
dry_run: bool = False,
):
"""
Creates a network interface card (NIC) in the specified Subnet.
:param description: A description for the NIC.
:type description: ``str``
:param private_ips_is_primary: If true, the IP address is the
primary private IP address of the NIC.
:type private_ips_is_primary: ``list`` of ``str``
:param private_ips: The private IP addresses of the NIC.
:type private_ips: ``list`` of ``str``
:param security_group_ids: One or more IDs of security groups for
the NIC.
:type security_group_ids: ``list`` of ``str``
:param subnet_id: The ID of the Subnet in which you want to
create the NIC. (required)
:type subnet_id: ``list`` of ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Nic
:rtype: ``dict``
"""
action = "CreateNic"
data = {"DryRun": dry_run, "PrivatesIps": {}}
if description is not None:
data.update({"Description": description})
if security_group_ids is not None:
data.update({"SecurityGroupIds": security_group_ids})
if subnet_id is not None:
data.update({"SubnetId": subnet_id})
if private_ips is not None and private_ips_is_primary is not None:
for primary, ip in zip(private_ips_is_primary, private_ips):
data["PrivateIps"].update({
"IsPrimary": primary,
"PrivateIp": ip
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["Nic"]
return response.json()
def ex_link_nic(
self,
device_number: int = None,
nic_id: str = None,
node: str = None,
dry_run: bool = False,
):
"""
Attaches a network interface card (NIC) to a virtual machine (VM).
The interface and the VM must be in the same Subregion. The VM can be
either running or stopped. The NIC must be in the available state.
:param nic_id: The ID of the NIC you want to delete. (required)
:type nic_id: ``str``
:param device_number: The ID of the NIC you want to delete.
(required)
:type device_number: ``str``
:param node: The index of the VM device for the NIC attachment
(between 1 and 7, both included).
:type node: ``Node``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: a Link Id
:rtype: ``str``
"""
action = "LinkNic"
data = {"DryRun": dry_run}
if nic_id is not None:
data.update({"NicId": nic_id})
if device_number is not None:
data.update({"DeviceNumber": device_number})
if node:
data.update({"VmId": node})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["LinkNicId"]
return response.json()
def ex_unlink_nic(
self,
link_nic_id: str = None,
dry_run: bool = False,
):
"""
Detaches a network interface card (NIC) from a virtual machine (VM).
The primary NIC cannot be detached.
:param link_nic_id: The ID of the NIC you want to delete.
(required)
:type link_nic_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "UnlinkNic"
data = {"DryRun": dry_run}
if link_nic_id is not None:
data.update({"LinkNicId": link_nic_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_delete_nic(
self,
nic_id: str = None,
dry_run: bool = False,
):
"""
Deletes the specified network interface card (NIC).
The network interface must not be attached to any virtual machine (VM).
:param nic_id: The ID of the NIC you want to delete. (required)
:type nic_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteNic"
data = {"DryRun": dry_run}
if nic_id is not None:
data.update({"NicId": nic_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_link_private_ips(
self,
allow_relink: bool = None,
nic_id: str = None,
private_ips: List[str] = None,
secondary_private_ip_count: int = None,
dry_run: bool = False,
):
"""
Assigns one or more secondary private IP addresses to a specified
network interface card (NIC). This action is only available in a Net.
The private IP addresses to be assigned can be added individually
using the PrivateIps parameter, or you can specify the number of
private IP addresses to be automatically chosen within the Subnet
range using the SecondaryPrivateIpCount parameter. You can specify
only one of these two parameters. If none of these parameters are
specified, a private IP address is chosen within the Subnet range.
:param allow_relink: If true, allows an IP address that is
already assigned to another NIC in the same Subnet to be assigned
to the NIC you specified.
:type allow_relink: ``str``
:param nic_id: The ID of the NIC. (required)
:type nic_id: ``str``
:param private_ips: The secondary private IP address or addresses
you want to assign to the NIC within the IP address range of the
Subnet.
:type private_ips: ``list`` of ``str``
:param secondary_private_ip_count: The secondary private IP a
ddress or addresses you want to assign to the NIC within the IP
address range of the Subnet.
:type secondary_private_ip_count: ``int``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return:True if the action is successful
:rtype: ``bool``
"""
action = "LinkPrivateIps"
data = {"DryRun": dry_run}
if nic_id is not None:
data.update({"NicId": nic_id})
if allow_relink is not None:
data.update({"AllowRelink": allow_relink})
if private_ips is not None:
data.update({"PrivateIps": private_ips})
if secondary_private_ip_count is not None:
data.update({
"SecondaryPrivateIpCount": secondary_private_ip_count
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_nics(
self,
link_nic_sort_numbers: List[int] = None,
link_nic_vm_ids: List[str] = None,
nic_ids: List[str] = None,
private_ips_private_ips: List[str] = None,
subnet_ids: List[str] = None,
dry_run: bool = False,
):
"""
Lists one or more network interface cards (NICs).
A NIC is a virtual network interface that you can attach to a virtual
machine (VM) in a Net.
:param link_nic_sort_numbers: The device numbers the NICs are
attached to.
:type link_nic_sort_numbers: ``list`` of ``int``
:param link_nic_vm_ids: The IDs of the VMs the NICs are attached
to.
:type link_nic_vm_ids: ``list`` of ``str``
:param nic_ids: The IDs of the NICs.
:type nic_ids: ``list`` of ``str``
:param private_ips_private_ips: The private IP addresses of the
NICs.
:type private_ips_private_ips: ``list`` of ``str``
:param subnet_ids: The IDs of the Subnets for the NICs.
:type subnet_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: A list of the Nics
:rtype: ``list`` of ``dict``
"""
action = "ReadNics"
data = {"DryRun": dry_run, "Filters": {}}
if link_nic_sort_numbers is not None:
data["Filters"].update({
"LinkNicSortNumbers": link_nic_sort_numbers
})
if link_nic_vm_ids is not None:
data["Filters"].update({
"LinkNicVmIds": link_nic_vm_ids
})
if nic_ids is not None:
data["Filters"].update({"NicIds": nic_ids})
if private_ips_private_ips is not None:
data["Filters"].update({
"PrivateIpsPrivateIps": private_ips_private_ips
})
if subnet_ids is not None:
data["Filters"].update({
"SubnetIds": subnet_ids
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["Nics"]
return response.json()
def ex_unlink_private_ips(
self,
nic_id: str = None,
private_ips: List[str] = None,
dry_run: bool = False,
):
"""
Unassigns one or more secondary private IPs from a network interface
card (NIC).
:param nic_id: The ID of the NIC. (required)
:type nic_id: ``str``
:param private_ips: One or more secondary private IP addresses
you want to unassign from the NIC. (required)
:type private_ips: ``list`` of ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "UnlinkPrivateIps"
data = {"DryRun": dry_run}
if nic_id is not None:
data.update({"NicId": nic_id})
if private_ips is not None:
data.update({"PrivateIps": private_ips})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_update_nic(
self,
description: str = None,
link_nic_delete_on_vm_deletion: str = None,
link_nic_id: str = None,
security_group_ids: List[str] = None,
nic_id: str = None,
dry_run: bool = False,
):
"""
Modifies the specified network interface card (NIC). You can specify
only one attribute at a time.
:param description: A new description for the NIC.
:type description: ``str``
:param link_nic_delete_on_vm_deletion: If true, the NIC is
deleted when the VM is terminated.
:type link_nic_delete_on_vm_deletion: ``str``
:param link_nic_id: The ID of the NIC attachment.
:type link_nic_id: ``str``
:param security_group_ids: One or more IDs of security groups
for the NIC.
:type security_group_ids: ``list`` of ``str``
:param nic_id: The ID of the NIC you want to modify. (required)
:type nic_id: ``list`` of ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Nic
:rtype: ``dict``
"""
action = "UpdateNic"
data = {"DryRun": dry_run, "LinkNic": {}}
if description is not None:
data.update({"Description": description})
if security_group_ids is not None:
data.update({"SecurityGroupIds": security_group_ids})
if nic_id is not None:
data.update({"NicId": nic_id})
if link_nic_delete_on_vm_deletion is not None:
data["LinkNic"].update({
"DeleteOnVmDeletion": link_nic_delete_on_vm_deletion
})
if link_nic_id is not None:
data["LinkNic"].update({
"LinkNicId": link_nic_id
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["Nic"]
return response.json()
def ex_list_product_types(
self,
product_type_ids: List[str] = None,
dry_run: bool = False,
):
"""
Describes one or more product types.
:param product_type_ids: The IDs of the product types.
:type product_type_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: A ``list`` of Product Type
:rtype: ``list`` of ``dict``
"""
action = "ReadProductTypes"
data = {"DryRun": dry_run, "Filters": {}}
if product_type_ids is not None:
data["Filters"].update({
"ProductTypeIds": product_type_ids
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["ProductTypes"]
return response.json()
def ex_list_quotas(
self,
collections: List[str] = None,
quota_names: List[str] = None,
quota_types: List[str] = None,
short_descriptions: List[str] = None,
dry_run: bool = False,
):
"""
Describes one or more of your quotas.
:param collections: The group names of the quotas.
:type collections: ``list`` of ``str``
:param quota_names: The names of the quotas.
:type quota_names: ``list`` of ``str``
:param quota_types: The resource IDs if these are
resource-specific quotas, global if they are not.
:type quota_types: ``list`` of ``str``
:param short_descriptions: The description of the quotas.
:type short_descriptions: ``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 Product Type
:rtype: ``list`` of ``dict``
"""
action = "ReadQuotas"
data = {"DryRun": dry_run, "Filters": {}}
if collections is not None:
data["Filters"].update({
"Collections": collections
})
if quota_names is not None:
data["Filters"].update({
"QuotaNames": quota_names
})
if quota_types is not None:
data["Filters"].update({
"QuotaTypes": quota_types
})
if short_descriptions is not None:
data["Filters"].update({
"ShortDescriptions": short_descriptions
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["QuotaTypes"]
return response.json()
def ex_create_route(
self,
destination_ip_range: str = None,
gateway_id: str = None,
nat_service_id: str = None,
net_peering_id: str = None,
nic_id: str = None,
route_table_id: str = None,
vm_id: str = None,
dry_run: bool = False,
):
"""
Creates a route in a specified route table within a specified Net.
You must specify one of the following elements as the target:
- Net peering connection
- NAT VM
- Internet service
- Virtual gateway
- NAT service
- Network interface card (NIC)
The routing algorithm is based on the most specific match.
:param destination_ip_range: The IP range used for the
destination match, in CIDR notation (for example, 10.0.0.0/24).
(required)
:type destination_ip_range: ``str``
:param gateway_id: The ID of an Internet service or virtual
gateway attached to your Net.
:type gateway_id: ``str``
:param nat_service_id: The ID of a NAT service.
:type nat_service_id: ``str``
:param net_peering_id: The ID of a Net peering connection.
:type net_peering_id: ``str``
:param nic_id: The ID of a NIC.
:type nic_id: ``str``
:param vm_id: The ID of a NAT VM in your Net (attached to exactly
one NIC).
:type vm_id: ``str``
:param route_table_id: The ID of the route table for which you
want to create a route. (required)
:type route_table_id: `str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Route
:rtype: ``dict``
"""
action = "CreateRoute"
data = {"DryRun": dry_run}
if destination_ip_range is not None:
data.update({"DestinationIpRange": destination_ip_range})
if gateway_id is not None:
data.update({"GatewayId": gateway_id})
if nat_service_id is not None:
data.update({"NatServiceId": nat_service_id})
if net_peering_id is not None:
data.update({"NetPeeringId": net_peering_id})
if nic_id is not None:
data.update({"NicId": nic_id})
if route_table_id is not None:
data.update({"RouteTableId": route_table_id})
if vm_id is not None:
data.update({"VmId": vm_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["RouteTable"]
return response.json()
def ex_delete_route(
self,
destination_ip_range: str = None,
route_table_id: str = None,
dry_run: bool = False,
):
"""
Deletes a route from a specified route table.
:param destination_ip_range: The exact IP range for the route.
(required)
:type destination_ip_range: ``str``
:param route_table_id: The ID of the route table from which you
want to delete a route. (required)
:type route_table_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteRoute"
data = {"DryRun": dry_run}
if destination_ip_range is not None:
data.update({"DestinationIpRange": destination_ip_range})
if route_table_id is not None:
data.update({"RouteTableId": route_table_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_update_route(
self,
destination_ip_range: str = None,
gateway_id: str = None,
nat_service_id: str = None,
net_peering_id: str = None,
nic_id: str = None,
route_table_id: str = None,
vm_id: str = None,
dry_run: bool = False,
):
"""
Replaces an existing route within a route table in a Net.
You must specify one of the following elements as the target:
- Net peering connection
- NAT virtual machine (VM)
- Internet service
- Virtual gateway
- NAT service
- Network interface card (NIC)
The routing algorithm is based on the most specific match.
:param destination_ip_range: The IP range used for the
destination match, in CIDR notation (for example, 10.0.0.0/24).
(required)
:type destination_ip_range: ``str``
:param gateway_id: The ID of an Internet service or virtual
gateway attached to your Net.
:type gateway_id: ``str``
:param nat_service_id: The ID of a NAT service.
:type nat_service_id: ``str``
:param net_peering_id: The ID of a Net peering connection.
:type net_peering_id: ``str``
:param nic_id: The ID of a NIC.
:type nic_id: ``str``
:param vm_id: The ID of a NAT VM in your Net (attached to exactly
one NIC).
:type vm_id: ``str``
:param route_table_id: The ID of the route table for which you
want to create a route. (required)
:type route_table_id: `str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The updated Route
:rtype: ``dict``
"""
action = "UpdateRoute"
data = {"DryRun": dry_run}
if destination_ip_range is not None:
data.update({"DestinationIpRange": destination_ip_range})
if gateway_id is not None:
data.update({"GatewayId": gateway_id})
if nat_service_id is not None:
data.update({"NatServiceId": nat_service_id})
if net_peering_id is not None:
data.update({"NetPeeringId": net_peering_id})
if nic_id is not None:
data.update({"NicId": nic_id})
if route_table_id is not None:
data.update({"RouteTableId": route_table_id})
if vm_id is not None:
data.update({"VmId": vm_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["RouteTable"]
return response.json()
def ex_create_route_table(
self,
net_id: str = None,
dry_run: bool = False,
):
"""
Creates a route table for a specified Net.
You can then add routes and associate this route table with a Subnet.
:param net_id: The ID of the Net for which you want to create a
route table.
(required)
:type net_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Route Table
:rtype: ``dict``
"""
action = "CreateRouteTable"
data = {"DryRun": dry_run}
if net_id is not None:
data.update({"NetId": net_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["RouteTable"]
return response.json()
def ex_delete_route_table(
self,
route_table_id: str = None,
dry_run: bool = False,
):
"""
Deletes a specified route table.
Before deleting a route table, you must disassociate it from any
Subnet. You cannot delete the main route table.
:param route_table_id: The ID of the route table you want to
delete. (required)
:type route_table_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteRouteTable"
data = {"DryRun": dry_run}
if route_table_id is not None:
data.update({"RouteTableId": route_table_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_link_route_table(
self,
route_table_id: str = None,
subnet_id: str = None,
dry_run: bool = False,
):
"""
Associates a Subnet with a route table.
The Subnet and the route table must be in the same Net. The traffic is
routed according to the route table defined within this Net. You can
associate a route table with several Subnets.
:param route_table_id: The ID of the route table. (required)
:type route_table_id: ``str``
:param subnet_id: The ID of the Subnet. (required)
:type subnet_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: Link Route Table Id
:rtype: ``str``
"""
action = "LinkRouteTable"
data = {"DryRun": dry_run}
if route_table_id is not None:
data.update({"RouteTableId": route_table_id})
if subnet_id is not None:
data.update({"SubnetId": subnet_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["LinkRouteTableId"]
return response.json()
def ex_list_route_tables(
self,
link_route_table_ids: List[str] = None,
link_route_table_link_route_table_ids: List[str] = None,
link_route_table_main: bool = None,
link_subnet_ids: List[str] = None,
net_ids: List[str] = None,
route_creation_methods: List[str] = None,
route_destination_ip_ranges: List[str] = None,
route_destination_service_ids: List[str] = None,
route_gateway_ids: List[str] = None,
route_nat_service_ids: List[str] = None,
route_net_peering_ids: List[str] = None,
route_states: List[str] = None,
route_table_ids: List[str] = None,
route_vm_ids: List[str] = None,
tag_keys: List[str] = None,
tag_values: List[str] = None,
tags: List[str] = None,
dry_run: bool = False,
):
"""
Lists one or more of your route tables.
In your Net, each Subnet must be associated with a route table. If a
Subnet is not explicitly associated with a route table, it is
implicitly associated with the main route table of the Net.
:param link_route_table_ids: The IDs of the route tables involved
in the associations.
:type link_route_table_ids: ``list`` of ``str``
:param link_route_table_link_route_table_ids: The IDs of the
associations between the route tables and the Subnets.
:type link_route_table_link_route_table_ids: ``list`` of ``str``
:param link_route_table_main: If true, the route tables are the
main ones for their Nets.
:type link_route_table_main: ``bool``
:param link_subnet_ids: The IDs of the Subnets involved in the
associations.
:type link_subnet_ids: ``list`` of ``str``
:param net_ids: The IDs of the route tables involved
in the associations.
:type net_ids: ``list`` of ``str``
:param route_creation_methods: The methods used to create a route.
:type route_creation_methods: ``list`` of ``str``
:param route_destination_ip_ranges: The IP ranges specified in
routes in the tables.
:type route_destination_ip_ranges: ``list`` of ``str``
:param route_destination_service_ids: The service IDs specified
in routes in the tables.
:type route_destination_service_ids: ``list`` of ``str``
:param route_gateway_ids: The IDs of the gateways specified in
routes in the tables.
:type route_gateway_ids: ``list`` of ``str``
:param route_nat_service_ids: The IDs of the NAT services
specified in routes in the tables.
:type route_nat_service_ids: ``list`` of ``str``
:param route_net_peering_ids: The IDs of the Net peering
connections specified in routes in the tables.
:type route_net_peering_ids: ``list`` of ``str``
:param route_states: The states of routes in the route tables
(active | blackhole). The blackhole state indicates that the target
of the route is not available.
:type route_states: ``list`` of ``str``
:param route_table_ids: The IDs of the route tables.
:type route_table_ids: ``list`` of ``str``
:param route_vm_ids: The IDs of the VMs specified in routes in
the tables.
:type route_vm_ids: ``list`` of ``str``
:param tag_keys: The keys of the tags associated with the route
tables.
:type tag_keys: ``list`` of ``str``
:param tag_values: The values of the tags associated with the
route tables.
:type tag_values: ``list`` of ``str``
:param tags: The key/value combination of the tags associated
with the route tables, in the following format:
"Filters":{"Tags":["TAGKEY=TAGVALUE"]}.
:type tags: ``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 of Route Tables
:rtype: ``list`` of ``dict``
"""
action = "ReadRouteTables"
data = {"DryRun": dry_run, "Filters": {}}
if link_route_table_ids is not None:
data["Filters"].update({
"LinkRouteTableIds": link_route_table_ids
})
if link_route_table_link_route_table_ids is not None:
data["Filters"].update({
"LinkRouteTableLinkRouteTableIds":
link_route_table_link_route_table_ids
})
if link_route_table_main is not None:
data["Filters"].update({
"LinkRouteTableMain": link_route_table_main
})
if link_subnet_ids is not None:
data["Filters"].update({
"LinkSubnetIds": link_subnet_ids
})
if net_ids is not None:
data["Filters"].update({
"NetIds": net_ids
})
if route_creation_methods is not None:
data["Filters"].update({
"RouteCreationMethods": route_creation_methods
})
if route_destination_ip_ranges is not None:
data["Filters"].update({
"RouteDestinationIpRanges": route_destination_ip_ranges
})
if route_destination_service_ids is not None:
data["Filters"].update({
"RouteDestinationServiceIds": route_destination_service_ids
})
if route_gateway_ids is not None:
data["Filters"].update({
"RouteGatewayIds": route_gateway_ids
})
if route_nat_service_ids is not None:
data["Filters"].update({
"RouteNatServiceIds": route_nat_service_ids
})
if route_net_peering_ids is not None:
data["Filters"].update({
"RouteNetPeeringIds": route_net_peering_ids
})
if route_states is not None:
data["Filters"].update({
"RouteStates": route_states
})
if route_table_ids is not None:
data["Filters"].update({
"RouteTableIds": route_table_ids
})
if route_vm_ids is not None:
data["Filters"].update({
"RouteVmIds": route_vm_ids
})
if tag_keys is not None:
data["Filters"].update({
"TagKeys": tag_keys
})
if tag_values is not None:
data["Filters"].update({
"TagValues": tag_values
})
if tags is not None:
data["Filters"].update({
"Tags": tags
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["RouteTables"]
return response.json()
def ex_unlink_route_table(
self,
link_route_table_id: str = None,
dry_run: bool = False,
):
"""
Disassociates a Subnet from a route table.
After disassociation, the Subnet can no longer use the routes in this
route table, but uses the routes in the main route table of the Net
instead.
:param link_route_table_id: The ID of the route table. (required)
:type link_route_table_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "UnlinkRouteTable"
data = {"DryRun": dry_run}
if link_route_table_id is not None:
data.update({"LinkRouteTableId": link_route_table_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_create_server_certificate(
self,
body: str = None,
chain: str = None,
name: str = None,
path: str = None,
private_key: str = None,
dry_run: bool = False
):
"""
Creates a server certificate and its matching private key.
These elements can be used with other services (for example,
to configure SSL termination on load balancers).
You can also specify the chain of intermediate certification
authorities if your certificate is not directly signed by a root one.
You can specify multiple intermediate certification authorities in
the CertificateChain parameter. To do so, concatenate all certificates
in the correct order (the first certificate must be the authority of
your certificate, the second must the the authority of the
first one, and so on).
The private key must be a RSA key in PKCS1 form. To check this, open
the PEM file and ensure its header reads as follows:
BEGIN RSA PRIVATE KEY.
[IMPORTANT]
This private key must not be protected by a password or a passphrase.
:param body: The PEM-encoded X509 certificate. (required)
:type body: ``str``
:param chain: The PEM-encoded intermediate certification
authorities.
:type chain: ``str``
:param name: A unique name for the certificate. Constraints:
1-128 alphanumeric characters, pluses (+), equals (=), commas (,),
periods (.), at signs (@), minuses (-), or underscores (_). (required)
:type name: ``str``
:param path: The path to the server certificate, set to a slash
(/) if not specified.
:type path: ``str``
:param private_key: The PEM-encoded private key matching
the certificate. (required)
:type private_key: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new server certificate
:rtype: ``dict``
"""
action = "CreateServerCertificate"
data = {"DryRun": dry_run}
if body is not None:
data.update({"Body": body})
if chain is not None:
data.update({"Chain": chain})
if name is not None:
data.update({"Name": name})
if path is not None:
data.update({"Path": path})
if private_key is not None:
data.update({"PrivateKey": private_key})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["ServerCertificate"]
return response.json()
def ex_delete_server_certificate(
self,
name: str = None,
dry_run: bool = False
):
"""
Deletes a specified server certificate.
:param name: The name of the server certificate you
want to delete. (required)
:type name: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteServerCertificate"
data = {"DryRun": dry_run}
if name is not None:
data.update({"Name": name})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["ResponseContext"]
return response.json()
def ex_list_server_certificates(
self,
paths: str = None,
dry_run: bool = False
):
"""
List your server certificates.
:param paths: The path to the server certificate.
:type paths: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: server certificate
:rtype: ``list`` of ``dict``
"""
action = "ReadServerCertificates"
data = {"DryRun": dry_run, "Filters": {}}
if paths is not None:
data["Filters"].update({
"Paths": paths
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["ServerCertificates"]
return response.json()
def ex_update_server_certificate(
self,
name: str = None,
new_name: str = None,
new_path: str = None,
dry_run: bool = False
):
"""
Modifies the name and/or the path of a specified server certificate.
:param name: The name of the server certificate
you want to modify.
:type name: ``str``
:param new_name: A new name for the server certificate.
:type new_name: ``str``
:param new_path:A new path for the server certificate.
:type new_path: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: the new server certificate
:rtype: ``dict``
"""
action = "UpdateServerCertificate"
data = {"DryRun": dry_run}
if name is not None:
data.update({"Name": name})
if new_name is not None:
data.update({"NewName": new_name})
if new_path is not None:
data.update({"NewPath": new_path})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["ServerCertificate"]
return response.json()
def ex_create_security_group(
self,
description: str = None,
net_id: str = None,
security_group_name: str = None,
dry_run: bool = False,
):
"""
Creates a security group.
This action creates a security group either in the public Cloud or in
a specified Net. By default, a default security group for use in the
public Cloud and a default security group for use in a Net are created.
When launching a virtual machine (VM), if no security group is
explicitly specified, the appropriate default security group is
assigned to the VM. Default security groups include a default rule
granting VMs network access to each other.
When creating a security group, you specify a name. Two security
groups for use in the public Cloud or for use in a Net cannot have
the same name.
You can have up to 500 security groups in the public Cloud. You can
create up to 500 security groups per Net.
To add or remove rules, use the ex_create_security_group_rule method.
:param description: A description for the security group, with a
maximum length of 255 ASCII printable characters. (required)
:type description: ``str``
:param net_id: The ID of the Net for the security group.
:type net_id: ``str``
:param security_group_name: The name of the security group.
(required)
:type security_group_name: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Security Group
:rtype: ``dict``
"""
action = "CreateSecurityGroup"
data = {"DryRun": dry_run}
if description is not None:
data.update({"Description": description})
if net_id is not None:
data.update({"NetId": net_id})
if security_group_name is not None:
data.update({"SecurityGroupName": security_group_name})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["SecurityGroup"]
return response.json()
def ex_delete_security_group(
self,
security_group_id: str = None,
security_group_name: str = None,
dry_run: bool = False,
):
"""
Deletes a specified security group.
You can specify either the name of the security group or its ID.
This action fails if the specified group is associated with a virtual
machine (VM) or referenced by another security group.
:param security_group_id: The ID of the security group you want
to delete.
:type security_group_id: ``str``
:param security_group_name: TThe name of the security group.
:type security_group_name: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteSecurityGroup"
data = {"DryRun": dry_run}
if security_group_id is not None:
data.update({"SecurityGroupId": security_group_id})
if security_group_name is not None:
data.update({"SecurityGroupName": security_group_name})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_security_groups(
self,
account_ids: List[str] = None,
net_ids: List[str] = None,
security_group_ids: List[str] = None,
security_group_names: List[str] = None,
tag_keys: List[str] = None,
tag_values: List[str] = None,
tags: List[str] = None,
dry_run: bool = False,
):
"""
Lists one or more security groups.
You can specify either the name of the security groups or their IDs.
:param account_ids: The account IDs of the owners of the security
groups.
:type account_ids: ``list`` of ``str``
:param net_ids: The IDs of the Nets specified when the security
groups were created.
:type net_ids: ``list`` of ``str``
:param security_group_ids: The IDs of the security groups.
:type security_group_ids: ``list`` of ``str``
:param security_group_names: The names of the security groups.
:type security_group_names: ``list`` of ``str``
:param tag_keys: TThe keys of the tags associated with the
security groups.
:type tag_keys: ``list`` of ``str``
:param tag_values: The values of the tags associated with the
security groups.
:type tag_values: ``list`` of ``str``
:param tags: TThe key/value combination of the tags associated
with the security groups, in the following format:
"Filters":{"Tags":["TAGKEY=TAGVALUE"]}.
:type tags: ``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 Security Groups
:rtype: ``list`` of ``dict``
"""
action = "ReadSecurityGroups"
data = {"DryRun": dry_run, "Filters": {}}
if account_ids is not None:
data["Filters"].update({
"AccountIds": account_ids
})
if net_ids is not None:
data["Filters"].update({
"NetIds": net_ids
})
if security_group_ids is not None:
data["Filters"].update({
"SecurityGroupIds": security_group_ids
})
if security_group_names is not None:
data["Filters"].update({
"SecurityGroupNames": security_group_names
})
if tag_keys is not None:
data["Filters"].update({
"TagKeys": tag_keys
})
if tag_values is not None:
data["Filters"].update({
"TagValues": tag_values
})
if tags is not None:
data["Filters"].update({
"Tags": tags
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["SecurityGroups"]
return response.json()
def ex_create_security_group_rule(
self,
flow: str = None,
from_port_range: int = None,
ip_range: str = None,
rules: List[dict] = None,
sg_account_id_to_link: str = None,
sg_id: str = None,
sg_name_to_link: str = None,
to_port_range: int = None,
dry_run: bool = False,
):
"""
Configures the rules for a security group.
The modifications are effective at virtual machine (VM) level as
quickly as possible, but a small delay may occur.
You can add one or more egress rules to a security group for use with
a Net.
It allows VMs to send traffic to either one or more destination IP
address ranges or destination security groups for the same Net.
We recommend using a set of IP permissions to authorize outbound
access to a destination security group. We also recommended this
method to create a rule with a specific IP protocol and a specific
port range. In a set of IP permissions, we recommend to specify the
the protocol.
You can also add one or more ingress rules to a security group.
In the public Cloud, this action allows one or more IP address ranges
to access a security group for your account, or allows one or more
security groups (source groups) to access a security group for your
own 3DS OUTSCALE account or another one.
In a Net, this action allows one or more IP address ranges to access a
security group for your Net, or allows one or more other security
groups (source groups) to access a security group for your Net. All
the security groups must be for the same Net.
:param flow: The direction of the flow: Inbound or Outbound.
You can specify Outbound for Nets only.type (required)
description: ``bool``
:param from_port_range: The beginning of the port range for
the TCP and UDP protocols, or an ICMP type number.
:type from_port_range: ``int``
:param ip_range: The name The IP range for the security group
rule, in CIDR notation (for example, 10.0.0.0/16).
:type ip_range: ``str``
:param rules: Information about the security group rule to create:
https://docs.outscale.com/api#createsecuritygrouprule
:type rules: ``list`` of ``dict``
:param sg_account_id_to_link: The account ID of the
owner of the security group for which you want to create a rule.
:type sg_account_id_to_link: ``str``
:param sg_id: The ID of the security group for which
you want to create a rule. (required)
:type sg_id: ``str``
:param sg_name_to_link: The ID of the source security
group. If you are in the Public Cloud, you can also specify the name
of the source security group.
:type sg_name_to_link: ``str``
:param to_port_range: TThe end of the port range for the TCP and
UDP protocols, or an ICMP type number.
:type to_port_range: ``int``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Security Group Rule
:rtype: ``dict``
"""
action = "CreateSecurityGroupRule"
data = {"DryRun": dry_run}
if flow is not None:
data.update({"Flow": flow})
if from_port_range is not None:
data.update({"FromPortRange": from_port_range})
if ip_range is not None:
data.update({"IpRange": ip_range})
if rules is not None:
data.update({"Rules": rules})
if sg_name_to_link is not None:
data.update({
"SecurityGroupNameToLink": sg_name_to_link
})
if sg_id is not None:
data.update({"SecurityGroupId": sg_id})
if sg_account_id_to_link is not None:
data.update({
"SecurityGroupAccountIdToLink": sg_account_id_to_link
})
if to_port_range is not None:
data.update({"ToPortRange": to_port_range})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["SecurityGroup"]
return response.json()
def ex_delete_security_group_rule(
self,
flow: str = None,
from_port_range: int = None,
ip_protocol: str = None,
ip_range: str = None,
rules: List[dict] = None,
sg_account_id_to_unlink: str = None,
sg_id: str = None,
sg_name_to_unlink: str = None,
to_port_range: int = None,
dry_run: bool = False,
):
"""
Deletes one or more inbound or outbound rules from a security group.
For the rule to be deleted, the values specified in the deletion
request must exactly match the value of the existing rule.
In case of TCP and UDP protocols, you have to indicate the destination
port or range of ports. In case of ICMP protocol, you have to specify
the ICMP type and code.
Rules (IP permissions) consist of the protocol, IP address range or
source security group.
To remove outbound access to a destination security group, we
recommend to use a set of IP permissions. We also recommend to specify
the protocol in a set of IP permissions.
:param flow: The direction of the flow: Inbound or Outbound.
You can specify Outbound for Nets only.type (required)
description: ``bool``
:param from_port_range: The beginning of the port range for
the TCP and UDP protocols, or an ICMP type number.
:type from_port_range: ``int``
:param ip_range: The name The IP range for the security group
rule, in CIDR notation (for example, 10.0.0.0/16).
:type ip_range: ``str``
:param ip_protocol: The IP protocol name (tcp, udp, icmp) or
protocol number. By default, -1, which means all protocols.
:type ip_protocol: ``str``
:param rules: Information about the security group rule to create:
https://docs.outscale.com/api#createsecuritygrouprule
:type rules: ``list`` of ``dict``
:param sg_account_id_to_unlink: The account ID of the
owner of the security group for which you want to delete a rule.
:type sg_account_id_to_unlink: ``str``
:param sg_id: The ID of the security group for which
you want to delete a rule. (required)
:type sg_id: ``str``
:param sg_name_to_unlink: The ID of the source security
group. If you are in the Public Cloud, you can also specify the name
of the source security group.
:type sg_name_to_unlink: ``str``
:param to_port_range: TThe end of the port range for the TCP and
UDP protocols, or an ICMP type number.
:type to_port_range: ``int``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Security Group Rule
:rtype: ``dict``
"""
action = "DeleteSecurityGroupRule"
data = {"DryRun": dry_run}
if flow is not None:
data.update({"Flow": flow})
if ip_protocol is not None:
data.update({"IpProtocol": ip_protocol})
if from_port_range is not None:
data.update({"FromPortRange": from_port_range})
if ip_range is not None:
data.update({"IpRange": ip_range})
if rules is not None:
data.update({"Rules": rules})
if sg_name_to_unlink is not None:
data.update({
"SecurityGroupNameToUnlink": sg_name_to_unlink
})
if sg_id is not None:
data.update({"SecurityGroupId": sg_id})
if sg_account_id_to_unlink is not None:
data.update({
"SecurityGroupAccountIdToUnlink": sg_account_id_to_unlink
})
if to_port_range is not None:
data.update({"ToPortRange": to_port_range})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["SecurityGroup"]
return response.json()
def ex_create_virtual_gateway(
self,
connection_type: str = None,
dry_run: bool = False
):
"""
Creates a virtual gateway.
A virtual gateway is the access point on the Net
side of a VPN connection.
:param connection_type: The type of VPN connection supported
by the virtual gateway (only ipsec.1 is supported). (required)
:type connection_type: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new virtual gateway
:rtype: ``dict``
"""
action = "CreateVirtualGateway"
data = {"DryRun": dry_run}
if connection_type is not None:
data.update({"ConnectionType": connection_type})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["VirtualGateway"]
return response.json()
def ex_delete_virtual_gateway(
self,
virtual_gateway_id: str = None,
dry_run: bool = False
):
"""
Deletes a specified virtual gateway.
Before deleting a virtual gateway, we
recommend to detach it from the Net and delete the VPN connection.
:param virtual_gateway_id: The ID of the virtual gateway
you want to delete. (required)
:type virtual_gateway_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteVirtualGateway"
data = {"DryRun": dry_run}
if virtual_gateway_id is not None:
data.update({"VirtualGatewayId": virtual_gateway_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_link_virtual_gateway(
self,
net_id: str = None,
virtual_gateway_id: str = None,
dry_run: bool = False
):
"""
Attaches a virtual gateway to a Net.
:param net_id: The ID of the Net to which you want to attach
the virtual gateway. (required)
:type net_id: ``str``
:param virtual_gateway_id: The ID of the virtual
gateway. (required)
:type virtual_gateway_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return:
:rtype: ``dict``
"""
action = "LinkVirtualGateway"
data = {"DryRun": dry_run}
if net_id is not None:
data.update({"NetId": net_id})
if virtual_gateway_id is not None:
data.update({"VirtualGatewayId": virtual_gateway_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["NetToVirtualGatewayLink"]
return response.json()
def ex_list_virtual_gateways(
self,
connection_types: List[str] = None,
link_net_ids: List[str] = None,
link_states: List[str] = None,
states: List[str] = None,
tag_keys: List[str] = None,
tag_values: List[str] = None,
tags: List[str] = None,
virtual_gateway_id: List[str] = None,
dry_run: bool = False
):
"""
Lists one or more virtual gateways.
:param connection_types: The types of the virtual gateways
(only ipsec.1 is supported).
:type connection_types: ``list`` of ``dict``
:param link_net_ids: The IDs of the Nets the virtual gateways
are attached to.
:type link_net_ids: ``list`` of ``dict``
:param link_states: The current states of the attachments
between the virtual gateways and the Nets
(attaching | attached | detaching | detached).
:type link_states: ``list`` of ``dict``
:param states: The states of the virtual gateways
(pending | available | deleting | deleted).
:type states: ``list`` of ``dict``
:param tag_keys: The keys of the tags associated with the
virtual gateways.
:type tag_keys: ``list`` of ``dict``
:param tag_values: The values of the tags associated with
the virtual gateways.
:type tag_values: ``list`` of ``dict``
:param tags: The key/value combination of the tags associated
with the virtual gateways, in the following format:
"Filters":{"Tags":["TAGKEY=TAGVALUE"]}.
:type tags: ``list`` of ``dict``
:param virtual_gateway_id: The IDs of the virtual gateways.
:type virtual_gateway_id: ``list`` of ``dict``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: list of virtual gateway
:rtype: ``list`` of ``dict``
"""
action = "ReadVirtualGateways"
data = {"Filters": {}, "DryRun": dry_run}
if connection_types is not None:
data["Filters"].update({"ConnectionTypes": connection_types})
if link_net_ids is not None:
data["Filters"].update({"LinkNetIds": link_net_ids})
if link_states is not None:
data["Filters"].update({"LinkStates": link_states})
if states is not None:
data["Filters"].update({"States": states})
if tag_keys is not None:
data["Filters"].update({"TagKeys": tag_keys})
if tag_values is not None:
data["Filters"].update({"TagValues": tag_values})
if tags is not None:
data["Filters"].update({"Tags": tags})
if virtual_gateway_id is not None:
data["Filters"].update({"VirtualGatewayIds": virtual_gateway_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["VirtualGateways"]
return response.json()
def ex_unlink_virtual_gateway(
self,
net_id: str = None,
virtual_gateway_id: str = None,
dry_run: bool = False
):
"""
Detaches a virtual gateway from a Net.
You must wait until the virtual gateway is in the detached state
before you can attach another Net to it or delete the Net it was
previously attached to.
:param net_id: The ID of the Net from which you want to detach
the virtual gateway. (required)
:type net_id: ``str``
:param virtual_gateway_id: The ID of the Net from which you
want to detach the virtual gateway. (required)
:type virtual_gateway_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "UnlinkVirtualGateway"
data = {"DryRun": dry_run}
if net_id is not None:
data.update({"NetId": net_id})
if virtual_gateway_id is not None:
data.update({"VirtualGatewayId": virtual_gateway_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_update_route_propagation(
self,
enable: bool = None,
route_table_id: str = None,
virtual_gateway_id: str = None,
dry_run: bool = False
):
"""
Configures the propagation of routes to a specified route table
of a Net by a virtual gateway.
:param enable: If true, a virtual gateway can propagate routes
to a specified route table of a Net. If false,
the propagation is disabled. (required)
:type enable: ``boolean``
:param route_table_id: The ID of the route table. (required)
:type route_table_id: ``str``
:param virtual_gateway_id: The ID of the virtual
gateway. (required)
:type virtual_gateway_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: route propagation
:rtype: ``dict``
"""
action = "UpdateRoutePropagation"
data = {"DryRun": dry_run}
if enable is not None:
data.update({"Enable": enable})
if route_table_id is not None:
data.update({"RouteTableId": route_table_id})
if virtual_gateway_id is not None:
data.update({"VirtualGatewayId": virtual_gateway_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["RouteTable"]
return response.json()
def ex_delete_subnet(
self,
subnet_id: str = None,
dry_run: bool = False,
):
"""
Deletes a specified Subnet.
You must terminate all the running virtual machines (VMs) in the
Subnet before deleting it.
:param subnet_id: The ID of the Subnet you want to delete.
(required)
:type subnet_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteSubnet"
data = {"DryRun": dry_run}
if subnet_id is not None:
data.update({"SubnetId": subnet_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_update_subnet(
self,
subnet_id: str = None,
map_public_ip_on_launch: bool = None,
dry_run: bool = False,
):
"""
Deletes a specified Subnet.
You must terminate all the running virtual machines (VMs) in the
Subnet before deleting it.
:param subnet_id: The ID of the Subnet you want to delete.
(required)
:type subnet_id: ``str``
:param map_public_ip_on_launch: If true, a public IP address is
assigned to the network interface cards (NICs) created in the s
pecified Subnet. (required)
:type map_public_ip_on_launch: ``bool``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The updated Subnet
:rtype: ``dict``
"""
action = "UpdateSubnet"
data = {"DryRun": dry_run}
if subnet_id is not None:
data.update({"SubnetId": subnet_id})
if map_public_ip_on_launch is not None:
data.update({"MapPublicIpOnLaunch": map_public_ip_on_launch})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["Subnet"]
return response.json()
def ex_list_subnets(
self,
available_ip_counts: List[str] = None,
ip_ranges: List[str] = None,
net_ids: List[str] = None,
states: List[str] = None,
subnet_ids: List[str] = None,
subregion_names: List[str] = None,
tag_keys: List[str] = None,
tag_values: List[str] = None,
tags: List[str] = None,
dry_run: bool = False,
):
"""
Lists one or more of your Subnets.
If you do not specify any Subnet ID, this action describes all of
your Subnets.
:param available_ip_counts: The number of available IPs.
:type available_ip_counts: ``str``
:param ip_ranges: The IP ranges in the Subnets, in CIDR notation
(for example, 10.0.0.0/16).
:type ip_ranges: ``str``
:param net_ids: The IDs of the Nets in which the Subnets are.
:type net_ids: ``str``
:param states: The states of the Subnets (pending | available).
:type states: ``str``
:param subnet_ids: The IDs of the Subnets.
:type subnet_ids: ``str``
:param subregion_names: The names of the Subregions in which the
Subnets are located.
:type subregion_names: ``str``
:param tag_keys: TThe keys of the tags associated with the
subnets.
:type tag_keys: ``list`` of ``str``
:param tag_values: The values of the tags associated with the
subnets.
:type tag_values: ``list`` of ``str``
:param tags: TThe key/value combination of the tags associated
with the subnets, in the following format:
"Filters":{"Tags":["TAGKEY=TAGVALUE"]}.
:type tags: ``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 Subnets
:rtype: ``list`` of ``dict``
"""
action = "ReadSubnets"
data = {"DryRun": dry_run, "Filters": {}}
if available_ip_counts is not None:
data["Filters"].update({
"AvailableIpsCounts": available_ip_counts
})
if ip_ranges is not None:
data["Filters"].update({
"IpRanges": ip_ranges
})
if net_ids is not None:
data["Filters"].update({
"NetIds": net_ids
})
if states is not None:
data["Filters"].update({
"States": states
})
if subnet_ids is not None:
data["Filters"].update({
"SubetIds": subnet_ids
})
if subregion_names is not None:
data["Filters"].update({
"SubregionNames": subregion_names
})
if tag_keys is not None:
data["Filters"].update({
"TagKeys": tag_keys
})
if tag_values is not None:
data["Filters"].update({
"TagValues": tag_values
})
if tags is not None:
data["Filters"].update({
"Tags": tags
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["Subnets"]
return response.json()
def ex_create_subnet(
self,
ip_range: str = None,
net_id: str = None,
subregion_name: str = None,
dry_run: bool = False,
):
"""
Creates a Subnet in an existing Net.
To create a Subnet in a Net, you have to provide the ID of the Net and
the IP range for the Subnet (its network range). Once the Subnet is
created, you cannot modify its IP range.
The IP range of the Subnet can be either the same as the Net one if
you create only a single Subnet in this Net, or a subset of the Net
one. In case of several Subnets in a Net, their IP ranges must not
overlap. The smallest Subnet you can create uses a /30 netmask
(four IP addresses).
:param ip_range: The IP range in the Subnet, in CIDR notation
(for example, 10.0.0.0/16). (required)
:type ip_range: ``str``
:param net_id: The ID of the Net for which you want to create a
Subnet. (required)
:type net_id: ``str``
:param subregion_name: TThe name of the Subregion in which you
want to create the Subnet.
:type subregion_name: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Subnet
:rtype: ``dict``
"""
action = "CreateSubnet"
data = {"DryRun": dry_run}
if ip_range is not None:
data.update({"IpRange": ip_range})
if net_id is not None:
data.update({"NetId": net_id})
if subregion_name is not None:
data.update({"SubregionName": subregion_name})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["Subnet"]
return response.json()
def ex_delete_export_task(
self,
export_task_id: str = None,
dry_run: bool = False,
):
"""
Deletes an export task.
If the export task is not running, the command fails and an error is
returned.
:param export_task_id: The ID of the export task to delete.
(required)
:type export_task_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteExportTask"
data = {"DryRun": dry_run}
if export_task_id is not None:
data.update({"ExportTaskId": export_task_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_create_vpn_connection(
self,
client_gateway_id: str = None,
connection_type: str = None,
static_routes_only: bool = None,
virtual_gateway_id: str = None,
dry_run: bool = False,
):
"""
Creates a VPN connection between a specified virtual gateway and a
specified client gateway.
You can create only one VPN connection between a virtual gateway and
a client gateway.
:param client_gateway_id: The ID of the client gateway. (required)
:type client_gateway_id: ``str``
:param connection_type: The type of VPN connection (only ipsec.1
is supported). (required)
:type connection_type: ``str``
:param static_routes_only: If false, the VPN connection uses
dynamic routing with Border Gateway Protocol (BGP). If true, routing
is controlled using static routes. For more information about how to
create and delete static routes, see CreateVpnConnectionRoute:
https://docs.outscale.com/api#createvpnconnectionroute and
DeleteVpnConnectionRoute:
https://docs.outscale.com/api#deletevpnconnectionroute
:type static_routes_only: ``bool``
:param virtual_gateway_id: The ID of the virtual gateway.
(required)
:type virtual_gateway_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: The new Vpn Connection
:rtype: ``dict``
"""
action = "CreateVpnConnection"
data = {"DryRun": dry_run}
if client_gateway_id is not None:
data.update({"ClientGatewayId": client_gateway_id})
if connection_type is not None:
data.update({"ConnectionType": connection_type})
if static_routes_only is not None:
data.update({"StaticRoutesOnly": static_routes_only})
if virtual_gateway_id is not None:
data.update({"StaticRoutesOnly": virtual_gateway_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["VpnConnection"]
return response.json()
def ex_create_vpn_connection_route(
self,
destination_ip_range: str = None,
vpn_connection_id: str = None,
dry_run: bool = False,
):
"""
Creates a static route to a VPN connection.
This enables you to select the network flows sent by the virtual
gateway to the target VPN connection.
:param destination_ip_range: The network prefix of the route, in
CIDR notation (for example, 10.12.0.0/16).(required)
:type destination_ip_range: ``str``
:param vpn_connection_id: The ID of the target VPN connection of
the static route. (required)
:type vpn_connection_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "CreateVpnConnectionRoute"
data = {"DryRun": dry_run}
if destination_ip_range is not None:
data.update({"DestinationIpRange": destination_ip_range})
if vpn_connection_id is not None:
data.update({"VpnConnectionId": vpn_connection_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_delete_vpn_connection(
self,
vpn_connection_id: str = None,
dry_run: bool = False,
):
"""
Deletes a specified VPN connection.
If you want to delete a Net and all its dependencies, we recommend to
detach the virtual gateway from the Net and delete the Net before
deleting the VPN connection. This enables you to delete the Net
without waiting for the VPN connection to be deleted.
:param vpn_connection_id: TThe ID of the VPN connection you want
to delete.
(required)
:type vpn_connection_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteVpnConnection"
data = {"DryRun": dry_run}
if vpn_connection_id is not None:
data.update({"VpnConnectionId": vpn_connection_id})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_delete_vpn_connection_route(
self,
vpn_connection_id: str = None,
destination_ip_range: str = None,
dry_run: bool = False,
):
"""
Deletes a specified VPN connection.
If you want to delete a Net and all its dependencies, we recommend to
detach the virtual gateway from the Net and delete the Net before
deleting the VPN connection. This enables you to delete the Net
without waiting for the VPN connection to be deleted.
:param vpn_connection_id: TThe ID of the VPN connection you want
to delete.
(required)
:type vpn_connection_id: ``str``
:param destination_ip_range: The network prefix of the route to
delete, in CIDR notation (for example, 10.12.0.0/16). (required)
:type destination_ip_range: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: True if the action is successful
:rtype: ``bool``
"""
action = "DeleteVpnConnectionRoute"
data = {"DryRun": dry_run}
if vpn_connection_id is not None:
data.update({"VpnConnectionId": vpn_connection_id})
if destination_ip_range is not None:
data.update({"DestinationIpRange": destination_ip_range})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_list_vpn_connections(
self,
bgp_asns: List[int] = None,
client_gateway_ids: List[str] = None,
connection_types: List[str] = None,
route_destination_ip_ranges: List[str] = None,
states: List[str] = None,
static_routes_only: bool = None,
tag_keys: List[str] = None,
tag_values: List[str] = None,
tags: List[str] = None,
dry_run: bool = False,
):
"""
Describes one or more VPN connections.
:param bgp_asns: The Border Gateway Protocol (BGP) Autonomous
System Numbers (ASNs) of the connections.
:type bgp_asns: ``list`` of ``int``
:param client_gateway_ids: The IDs of the client gateways.
:type client_gateway_ids: ``list`` of ``str``
:param connection_types: The types of the VPN connections (only
ipsec.1 is supported).
:type connection_types: ``list`` of ``str``
:param states: The states of the vpn connections
(pending | available).
:type states: ``str``
:param route_destination_ip_ranges: The destination IP ranges.
:type route_destination_ip_ranges: ``str``
:param static_routes_only: If false, the VPN connection uses
dynamic routing with Border Gateway Protocol (BGP). If true, routing
is controlled using static routes. For more information about how to
create and delete static routes, see CreateVpnConnectionRoute:
https://docs.outscale.com/api#createvpnconnectionroute and
DeleteVpnConnectionRoute:
https://docs.outscale.com/api#deletevpnconnectionroute
:type static_routes_only: ``bool``
:param tag_keys: TThe keys of the tags associated with the
subnets.
:type tag_keys: ``list`` of ``str``
:param tag_values: The values of the tags associated with the
subnets.
:type tag_values: ``list`` of ``str``
:param tags: TThe key/value combination of the tags associated
with the subnets, in the following format:
"Filters":{"Tags":["TAGKEY=TAGVALUE"]}.
:type tags: ``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 Subnets
:rtype: ``list`` of ``dict``
"""
action = "ReadVpnConnections"
data = {"DryRun": dry_run, "Filters": {}}
if bgp_asns is not None:
data["Filters"].update({
"BgpAsns": bgp_asns
})
if client_gateway_ids is not None:
data["Filters"].update({
"ClientGatewayIds": client_gateway_ids
})
if connection_types is not None:
data["Filters"].update({
"ConnectionTypes": connection_types
})
if states is not None:
data["Filters"].update({
"States": states
})
if route_destination_ip_ranges is not None:
data["Filters"].update({
"RouteDestinationIpRanges": route_destination_ip_ranges
})
if static_routes_only is not None:
data["Filters"].update({
"StaticRoutesOnly": static_routes_only
})
if tag_keys is not None:
data["Filters"].update({
"TagKeys": tag_keys
})
if tag_values is not None:
data["Filters"].update({
"TagValues": tag_values
})
if tags is not None:
data["Filters"].update({
"Tags": tags
})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["VpnConnections"]
return response.json()
def ex_create_certificate_authority(
self,
ca_perm: str,
description: str = None,
dry_run: bool = False
):
"""
Creates a Client Certificate Authority (CA).
:param ca_perm: The CA in PEM format. (required)
:type ca_perm: ``str``
:param description: The description of the CA.
:type description: ``bool``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: the created Ca.
:rtype: ``dict``
"""
action = "CreateCa"
data = {"DryRun": dry_run, "CaPerm": ca_perm}
if description is not None:
data.update({"Description": description})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["Ca"]
return response.json()
def ex_delete_certificate_authority(
self,
ca_id: str,
dry_run: bool = False
):
"""
Deletes a specified Client Certificate Authority (CA).
:param ca_id: The ID of the CA you want to delete. (required)
:type ca_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
"""
action = "DeleteCa"
data = {"DryRun": dry_run, "CaId": ca_id}
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_read_certificate_authorities(
self,
ca_fingerprints: List[str] = None,
ca_ids: List[str] = None,
descriptions: List[str] = None,
dry_run: bool = False
):
"""
Returns information about one or more of your Client Certificate
Authorities (CAs).
:param ca_fingerprints: The fingerprints of the CAs.
:type ca_fingerprints: ``list`` of ``str``
:param ca_ids: The IDs of the CAs.
:type ca_ids: ``list`` of ``str``
:param descriptions: The descriptions of the CAs.
:type descriptions: ``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 all Ca matching filled filters.
:rtype: ``list`` of ``dict``
"""
action = "ReadCas"
data = {"DryRun": dry_run, "Filters": {}}
if ca_fingerprints is not None:
data["Filters"].update({"CaFingerprints": ca_fingerprints})
if ca_ids is not None:
data["Filters"].update({"CaIds": ca_ids})
if descriptions is not None:
data["Filters"].update({"Descriptions": descriptions})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["Cas"]
return response.json()
def ex_update_certificate_authority(
self,
ca_id: str,
description: str = None,
dry_run: bool = False
):
"""
Modifies the specified attribute of a Client Certificate Authority
(CA).
:param ca_id: The ID of the CA. (required)
:type ca_id: ``str``
:param description: The description of the CA.
:type description: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: a the created Ca or the request result.
:rtype: ``dict``
"""
action = "UpdateCa"
data = {"DryRun": dry_run, "CaId": ca_id}
if description is not None:
data.update({"Description": description})
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["Ca"]
return response.json()
def ex_create_api_access_rule(
self,
description: str = None,
ip_ranges: List[str] = None,
ca_ids: List[str] = None,
cns: List[str] = None,
dry_run: bool = False,
):
"""
Create an API access rule.
It is a rule to allow access to the API from your account.
You need to specify at least the CaIds or the IpRanges parameter.
:param description: The description of the new rule.
:type description: ``str``
:param ip_ranges: One or more IP ranges, in CIDR notation
(for example, 192.0.2.0/16).
:type ip_ranges: ``List`` of ``str``
:param ca_ids: One or more IDs of Client Certificate Authorities
(CAs).
:type ca_ids: ``List`` of ``str``
:param cns: One or more Client Certificate Common Names (CNs).
If this parameter is specified, you must also specify the ca_ids
parameter.
:type cns: ``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 dict containing the API access rule created.
:rtype: ``dict``
"""
if not ca_ids and not ip_ranges:
raise ValueError(
"Either ca_ids or ip_ranges argument must be provided.")
action = "CreateApiAccessRule"
data = {"DryRun": dry_run}
if description is not None:
data["Description"] = description
if ip_ranges is not None:
data["IpRanges"] = ip_ranges
if ca_ids is not None:
data["CaIds"] = ca_ids
if cns is not None:
data["Cns"] = cns
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["ApiAccessRule"]
return response.json()
def ex_delete_api_access_rule(
self,
api_access_rule_id: str,
dry_run: bool = False,
):
"""
Delete an API access rule.
You cannot delete the last remaining API access rule.
:param api_access_rule_id: The id of the targeted rule
(required).
:type api_access_rule_id: ``str``
:param dry_run: If true, checks whether you have the required
permissions to perform the action.
:type dry_run: ``bool``
:return: true if successfull.
:rtype: ``bool`` if successful or ``dict``
"""
action = "DeleteApiAccessRule"
data = {"ApiAccessRuleId": api_access_rule_id, "DryRun": dry_run}
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return True
return response.json()
def ex_read_api_access_rules(
self,
api_access_rules_ids: List[str] = None,
ca_ids: List[str] = None,
cns: List[str] = None,
descriptions: List[str] = None,
ip_ranges: List[str] = None,
dry_run: bool = False,
):
"""
Read API access rules.
:param api_access_rules_ids: The List containing rules ids to
filter the request.
:type api_access_rules_ids: ``List`` of ``str``
:param ca_ids: The List containing CA ids to filter the request.
:type ca_ids: ``List`` of ``str``
:param cns: The List containing cns to filter the request.
:type cns: ``List`` of ``str``
:param descriptions: The List containing descriptions to filter
the request.
:type descriptions: ``List`` of ``str``
:param ip_ranges: The List containing ip ranges in CIDR notation
(for example, 192.0.2.0/16) to filter the request.
:type ip_ranges: ``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 API access rules.
:rtype: ``List`` of ``dict`` if successfull or ``dict``
"""
action = "ReadApiAccessRules"
filters = {}
if api_access_rules_ids is not None:
filters["ApiAccessRulesIds"] = api_access_rules_ids
if ca_ids is not None:
filters["CaIds"] = ca_ids
if cns is not None:
filters["Cns"] = cns
if descriptions is not None:
filters["Descriptions"] = descriptions
if ip_ranges is not None:
filters["IpRanges"] = ip_ranges
data = {"Filters": filters, "DryRun": dry_run}
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["ApiAccessRules"]
return response.json()
def ex_update_api_access_rule(
self,
api_access_rule_id: str,
ca_ids: List[str] = None,
cns: List[str] = None,
description: str = None,
ip_ranges: List[str] = None,
dry_run: bool = False,
):
"""
Update an API access rules.
The new rule you specify fully replaces the old rule. Therefore,
for a parameter that is not specified, any previously set value
is deleted.
:param api_access_rule_id: The id of the rule we want to update
(required).
:type api_access_rule_id: ``str``
:param ca_ids: One or more IDs of Client Certificate Authorities
(CAs).
:type ca_ids: ``List`` of ``str``
:param cns: One or more Client Certificate Common Names (CNs).
If this parameter is specified, you must also specify the ca_ids
parameter.
:type cns: ``List`` of ``str``
:param description: The description of the new rule.
:type description: ``str``
:param ip_ranges: One or more IP ranges, in CIDR notation
(for example, 192.0.2.0/16).
:type ip_ranges: ``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 API access rules.
:rtype: ``List`` of ``dict`` if successfull or ``dict``
"""
action = "UpdateApiAccessRule"
data = {"DryRun": dry_run, "ApiAccessRuleId": api_access_rule_id}
if description is not None:
data["Description"] = description
if ip_ranges is not None:
data["IpRanges"] = ip_ranges
if ca_ids is not None:
data["CaIds"] = ca_ids
if cns is not None:
data["Cns"] = cns
response = self._call_api(action, json.dumps(data))
if response.status_code == 200:
return response.json()["ApiAccessRules"]
return response.json()
def _get_outscale_endpoint(self, region: str, version: str, action: str):
return "https://api.{}.{}/api/{}/{}".format(
region,
self.base_uri,
version,
action
)
def _call_api(self, action: str, data: str):
headers = self._ex_generate_headers(action, data)
endpoint = self._get_outscale_endpoint(self.region,
self.version,
action)
return requests.post(endpoint, data=data, headers=headers)
def _ex_generate_headers(self, action: str, data: str):
return self.signer.get_request_headers(
action=action,
data=data,
service_name=self.service_name,
region=self.region
)
def _to_location(self, location):
country = location["Name"].split(", ")[1]
return NodeLocation(
id=location["Code"],
name=location["Name"],
country=country,
driver=self,
extra=location
)
def _to_locations(self, locations: list):
return [self._to_location(location) for location in locations]
def _to_snapshot(self, snapshot):
name = None
for tag in snapshot["Tags"]:
if tag["Key"] == "Name":
name = tag["Value"]
return VolumeSnapshot(
id=snapshot["SnapshotId"],
name=name,
size=snapshot["VolumeSize"],
driver=self,
state=snapshot["State"],
created=None,
extra=snapshot
)
def _to_snapshots(self, snapshots):
return [self._to_snapshot(snapshot) for snapshot in snapshots]
def _to_volume(self, volume):
name = ""
for tag in volume["Tags"]:
if tag["Key"] == "Name":
name = tag["Value"]
return StorageVolume(
id=volume["VolumeId"],
name=name,
size=volume["Size"],
driver=self,
state=volume["State"],
extra=volume
)
def _to_volumes(self, volumes):
return [self._to_volumes(volume) for volume in volumes]
def _to_node(self, vm):
name = ""
private_ips = []
for tag in vm["Tags"]:
if tag["Key"] == "Name":
name = tag["Value"]
if "Nics" in vm:
private_ips = vm["Nics"]["PrivateIps"]
return Node(id=vm["VmId"],
name=name,
state=self.NODE_STATE[vm["State"]],
public_ips=[],
private_ips=private_ips,
driver=self,
extra=vm)
def _to_nodes(self, vms: list):
return [self._to_node(vm) for vm in vms]
def _to_node_image(self, image):
name = ""
for tag in image["Tags"]:
if tag["Key"] == "Name":
name = tag["Value"]
return NodeImage(id=image["ImageId"],
name=name,
driver=self,
extra=image)
def _to_node_images(self, node_images: list):
return [self._to_node_image(node_image) for node_image in node_images]
def _to_key_pairs(self, key_pairs):
return [self._to_key_pair(key_pair) for key_pair in key_pairs]
def _to_key_pair(self, key_pair):
private_key = ""
if "PrivateKey" in key_pair:
private_key = key_pair["PrivateKey"]
return KeyPair(
name=key_pair["KeypairName"],
public_key="",
private_key=private_key,
fingerprint=key_pair["KeypairFingerprint"],
driver=self)
Reference in New Issue View Git Blame Copy Permalink