def attach_volume(self, **kwargs):
"""Attach volume to a Power Virtual Instance
:param instance: Instance name or ID
:type instance: str
:param pvm: Power Virtual Instance name or ID
:type pvm: str
:param volume: Volume name or ID
:type volume: str
:return: Attachment status
:rtype: dict
"""
args = ["instance", "pvm", "volume"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'instance': kwargs.get('instance'),
'pvm': kwargs.get('pvm'),
'volume': kwargs.get('volume'),
}
try:
# Check if cloud instance exists and retrieve information
ci_info = self.instance.get_instance(args['instance'])
if "errors" in ci_info:
return ci_info
# Check if pvm exists and retrieve information
pvm_info = self.pvm.get_pvm(args['instance'], args['pvm'])
if "errors" in pvm_info:
return pvm_info
# Check if volume exists and retrieve information
vol_info = self.get_volume(ci_info["name"], args["volume"])
if "errors" in vol_info:
return vol_info
# Connect to api endpoint for cloud-instances
path = ("/pcloud/v1/cloud-instances/{}/pvm-instances/{}"
"/volumes/{}".format(ci_info["name"],
pvm_info["pvmInstanceID"],
vol_info["volumeID"]))
data = qw("power", "POST", path, headers())
# Return data
if data["response"].status != 200:
return data["data"]
# Return status
payload = {"status": "attached"}
return resource_created(payload)
except Exception as error:
print("Error attaching volume {} to Power Virtual Instance {}"
" from cloud instance {}. {}".format(args["volume"],
args['pvm'],
args['instance'],
error))
def delete_record(self, **kwargs):
"""Delete a record
:param record: Record name
:type record: str
:param zone: Zone name
:type zone: str
"""
args = set(["record", "zone"])
check_args(args, **kwargs)
args = {
'record': kwargs.get('record'),
'zone': kwargs.get('zone'),
}
record = self.get_record(record=args["record"], zone=args["zone"])
if "errors" in record:
for key_name in record["errors"]:
if key_name["code"] == "not_found":
return resource_not_found()
try:
self.dns.delete_record(record["id"])
except Exception as error:
print("Error while deleting record. {}".format(error))
raise
def create_snapshot(self, **kwargs):
"""Creates a snapshot on the given file volume
:param volume_id: The volume ID
:type volume_id: int
:param notes: The notes or "name" to assign the snapshot
:type notes: str
:return: Returns the id of the new snapshot
:rtype: str
"""
args = ["volume_id", "notes"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'volume_id': kwargs.get('volume_id'),
'notes': kwargs.get('notes'),
}
try:
return self.file.create_snapshot(
args['volume_id'],
notes=args['notes'])
except sl.SoftLayer.SoftLayerAPIError as error:
return resource_error(error.faultCode, error.faultString)
def download_file(self, **kwargs):
"""Download file from a S3 object
:param bucket: Bucket name
:type bucket: str
:param path: The path to the file to download to
:type path: str
:param key: The name of the key to download from
:type key: str
:return: Download status
:rtype: dict
"""
args = ["bucket", "path", "key"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'bucket': kwargs.get('bucket'),
'key': kwargs.get('key'),
'path': kwargs.get('path'),
}
try:
result = self.client.download_file(
args["bucket"], args["key"], args["path"])
if result is not None:
return result
msg = {"object": args["key"], "path": args['path'],
"status": "downloaded"}
return resource_created(msg)
except Exception as error:
return resource_error("unable_to_download_object", error)
def order_modified_volume(self, **kwargs):
"""Places an order for modifying an existing file volume
:param volume_id: The ID of the volume to be modified
:type volume_id: int
:param new_size: The new size/capacity for the volume
:type new_size: int
:param new_iops: The new IOPS for the volume
:type new_iops: int
:param new_tier_level: The new tier level for the volume
:type new_tier_level: str
:return: Returns a SoftLayer_Container_Product_Order_Receipt
:rtype: dict
"""
args = ["volume_id", "new_size", "new_iops", "new_tier_level"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'volume_id': kwargs.get('storage_type'),
'new_size': kwargs.get('new_size'),
'new_iops': kwargs.get('new_iops'),
'new_tier_level': kwargs.get('new_tier_level')
}
try:
return self.file.order_modified_volume(
args['volume_id'],
args['new_size'],
args['new_iops'],
args['new_tier_level'])
except sl.SoftLayer.SoftLayerAPIError as error:
return resource_error(error.faultCode, error.faultString)
def order_snapshot_space(self, **kwargs):
"""Orders snapshot space for the given file volume
:param volume_id: The ID of the volume
:type volume_id: int
:param capacity: The capacity to order, in GB
:type capacity: int
:param tier: The tier level of the file volume, in IOPS per GB
:type tier: int
:param upgrade: Flag to indicate if this order is an upgrade
:type upgrade: bool
:return: Returns a SoftLayer_Container_Product_Order_Receipt
:rtype: dict
"""
args = ["volume_id", "capacity", "tier", "upgrade"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'volume_id': kwargs.get('storage_type'),
'capacity': kwargs.get('capacity'),
'tier': kwargs.get('tier'),
'upgrade': kwargs.get('upgrade')
}
try:
return self.file.order_snapshot_space(args['volume_id'],
args['capacity'],
args['tier'],
args['upgrade'])
except sl.SoftLayer.SoftLayerAPIError as error:
return resource_error(error.faultCode, error.faultString)
def export_instance_image(self, **kwargs):
"""Export an image for a cloud instance
:param instance: Cloud instance ID
:type instance: str
:param image: Image ID of existing source image
:type image: str
:param region: Cloud Storage Region
:type region: str, optional
:param bucket: Cloud Storage bucket name
:type bucket: str, optional
:param access_key: Cloud Storage access key
:type access_key: str, optional
:param secret_key: Cloud Storage secret key
:type secret_key: str, optional
:return: Export image information
:rtype: dict
"""
args = ["instance", "image"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'instance': kwargs.get('source'),
'image': kwargs.get('image'),
'region': kwargs.get('region'),
'bucketName': kwargs.get('bucket'),
'accessKey': kwargs.get('access_key'),
'secretKey': kwargs.get('secret_key'),
}
# Construct payload
payload = {}
for key, value in args.items():
if key != "instance" and key != "image" and value is not None:
payload[key] = value
try:
# Check if cloud instance exists and retrieve information
ci_info = self.instance.get_instance(args['instance'])
if "errors" in ci_info:
return ci_info
# Check if image exists and retrieve information
image_info = self.get_instance_image(ci_info["name"],
args["image"])
if "errors" in image_info:
return image_info
# Connect to api endpoint for cloud-instances
path = ("/pcloud/v1/cloud-instances/{}/images/{}/export".format(
ci_info["name"], image_info["imageID"]))
# Return data
return qw("power", "POST", path, headers(),
json.dumps(payload))["data"]
except Exception as error:
print("Error exporting image {} for cloud instance {}. {}".format(
args['image'], args['instance'], error))
def cancel_file_volume(self, **kwargs):
"""Cancels the given file storage volume
:param volume_id: The volume ID
:type volume_id: int
:param reason: The reason for cancellation
:type reason: str
:param immediate: Cancel immediately or on anniversary date
:type immediate: bool
"""
args = ["volume_id", "reason", "immediate"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'volume_id': kwargs.get('volume_id'),
'reason': kwargs.get('reason'),
'immediate': kwargs.get('immediate')
}
try:
return self.file.cancel_file_volume(args['volume_id'],
reason=args['reason'],
immediate=args['immediate'])
except sl.SoftLayer.exceptions.SoftLayerError:
return({"msg": "Storage Volume was already cancelled"})
except sl.SoftLayer.SoftLayerAPIError as error:
return resource_error(error.faultCode, error.faultString)
def authorize_host_to_volume(self, **kwargs):
"""Authorizes hosts to File Storage Volumes
:param volume_id: The File volume to authorize hosts to
:type volume_id: str
:param hardware_ids: A List of SoftLayer_Hardware IDs
:type hardware_ids: list
:param virtual_guest_ids: A List of SoftLayer_Virtual_Guest IDs
:type virtual_guest_ids: list
:param ip_address_ids: A List of SoftLayer_Network_Subnet_IpAddress IDs
:type ip_address_ids: list
:param subnet_ids: A List of SoftLayer_Network_Subnet ids
"""
args = ["volume_id", "hardware_ids", "virtual_guest_ids",
"ip_address_ids", "subnet_ids"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'volume_id': kwargs.get('volume_id'),
'hardware_ids': kwargs.get('hardware_ids') or None,
'virtual_guest_ids': kwargs.get('virtual_guest_ids') or None,
'ip_address_ids': kwargs.get('ip_address_ids') or None,
'subnet_ids': kwargs.get('subnet_ids') or None
}
try:
self.file.authorize_host_to_volume(args['volume_id'],
args['hardware_ids'],
args['virtual_guest_ids'],
args['ip_address_ids'],
args['subnet_ids'])
except sl.SoftLayer.SoftLayerAPIError as error:
return resource_error(error.faultCode, error.faultString)
def failover_to_replicant(self, **kwargs):
"""Failover to a volume replicant
:param volume_id: The ID of the volume
:type volume_id: int
:param replicant_id: ID of replicant to failback from
:type replicant_id: int
:param immediate: Flag indicating if failover is immediate
:type immediate: bool
:return: Returns whether failover was successful or not
"""
args = ["volume_id", "replicant_id"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'volume_id': kwargs.get('volume_id'),
'replicant_id': kwargs.get('replicant_id'),
'immediate': kwargs.get('immediate')
}
try:
return self.file.failover_to_replicant(
args['volume_id'],
args['replicant_id'],
immediate=args['immediate'])
except sl.SoftLayer.SoftLayerAPIError as error:
return resource_error(error.faultCode, error.faultString)
def create_group(self, **kwargs):
"""Create resource group
:param name: Name of the resource group
:type name: str
:param account_id: The account ID of the resource group
:type account_id: str
"""
args = ["name", "account_id"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'name': kwargs.get('name'),
'account_id': kwargs.get('account_id'),
}
# Construct payload
payload = {}
for key, value in args.items():
if value is not None:
payload[key] = value
try:
# Connect to api endpoint for resource_groups
path = ("/v2/resource_groups")
# Return data
return qw("rg", "POST", path, headers(),
json.dumps(payload))["data"]
except Exception as error:
print("Error create resource group. {}".format(error))
raise
def get_record_by_value(self, **kwargs):
"""Get record by value
:param record: Record value
:type record: str
:param zone: Zone name
:type zone: str
"""
args = set(["record", "zone"])
check_args(args, **kwargs)
args = {
'record': kwargs.get('record'),
'zone': kwargs.get('zone'),
}
records = self.get_records(zone=args["zone"])
if "errors" in records:
for key_name in records["errors"]:
if key_name["code"] == "not_found":
return resource_not_found()
for record in records:
if record["data"] == args["record"]:
return record
return resource_not_found()
def get_dns_zone(self, **kwargs):
"""Get a specific DNS zone hosted by a resource instance
:param dns_zone: DNS zone name or ID to query
:type dns_zone: str
:param resource_instance: Name or GUID of the resource instance
:type resource_instance: str
:return: DNS zone information
:rtype: dict
"""
# Required parameters
args = ['dns_zone', 'resource_instance']
check_args(args, **kwargs)
# Set default value if required paramaters are not defined
args = {
'dns_zone': kwargs.get('dns_zone'),
'resource_instance': kwargs.get('resource_instance'),
}
by_name = self.get_dns_zone_by_name(
dns_zone=args['dns_zone'],
resource_instance=args['resource_instance'])
if "errors" in by_name:
for key_name in by_name["errors"]:
if key_name["code"] == "not_found":
by_guid = self.get_dns_zone_by_id(
dns_zone=args['dns_zone'],
resource_instance=args['resource_instance'])
if "errors" in by_guid:
return by_guid
return by_guid
return by_name
else:
return by_name
def get_dns_zones(self, **kwargs):
"""Get all DNS zones hosted by a resource instance
:param resource_instance: Name or GUID of the resource instance
:type resource_instance: str
:return: DNS zones
:rtype: list
"""
args = ['resource_instance']
check_args(args, **kwargs)
# Set default value if required paramaters are not defined
args = {
'resource_instance': kwargs.get('resource_instance'),
}
# Get resource instance guid
temp_ri = self.resource_instance.get_resource_instance(
args['resource_instance'])
if "errors" in temp_ri:
return temp_ri
resource_instance_guid = temp_ri["guid"]
try:
# Connect to api endpoint for dns zones
path = ("/v1/instances/{}/dnszones").format(resource_instance_guid)
return qw("dns", "GET", path, headers())["data"]
except Exception as error:
print("Error creating dns zone. {}".format(error))
raise
def get_record_by_name(self, **kwargs):
"""Get record by name
:param record: Record name
:type record: str
:param zone: Zone name
:type zone: str
"""
required_args = set(["record", "zone"])
check_args(required_args, **kwargs)
args = {
'record': kwargs.get('record'),
'zone': kwargs.get('zone'),
}
zone_id = self.get_zone_id(args['zone'])
if not isinstance(zone_id, int):
if "errors" in zone_id:
for key_name in zone_id["errors"]:
if key_name["code"] == "not_found":
return resource_not_found()
records = self.get_records(zone=args["zone"])
for record in records:
if record["host"] == args["record"]:
return record
return resource_not_found()
def clone_volume(self, **kwargs):
"""Create a clone from a volume
:param instance: Instance name or ID
:type instance: str
:param volumes: List of volumes to be cloned
:type volumes: list
:param name: Display name for the new cloned volumes. Cloned Volume
names will be prefixed with 'clone-'. If multiple volumes cloned
they will be suffix with a '-' and an incremental number starting
with 1.
:type name: str
:param prefix_name: Prefix to use when naming the new cloned volumes
:type prefix_name: str, optional
:return: Volume clone information
:rtype: dict
"""
args = ["instance", "volumes", "name"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'instance': kwargs.get('instance'),
'volumeIDs': kwargs.get('volumes'),
'displayName': kwargs.get('name'),
'namingPrefix': kwargs.get('prefix_name'),
}
# Check if cloud instance exists and retrieve information
ci_info = self.instance.get_instance(args['instance'])
if "errors" in ci_info:
return ci_info
# Construct payload
payload = {}
for key, value in args.items():
if key != "instance" and value is not None:
if key == "volumeIDs":
vl = []
for volume in args["volumeIDs"]:
vol_info = self.get_volume(ci_info["name"], volume)
if "errors" in vol_info:
return vol_info
vl.append(vol_info["volumeID"])
payload["volumeIDs"] = vl
payload[key] = value
try:
# Connect to api endpoint for cloud-instances
path = ("/pcloud/v1/cloud-instances/{}/volumes/clone".format(
ci_info["name"]))
# Return data
return qw("power", "POST", path, headers(),
json.dumps(payload))["data"]
except Exception as error:
print("Error creating clone from volume(s) {} for cloud instance"
" {}. {}".format(args["volumeIDs"], args['instance'], error))
def add_permitted_network(self, **kwargs):
"""Add permitted network to DNS zone
:param dns_zone: DNS zone name
:type dns_zone: str
:param resource_instance: Name or GUID of the resource instance
:type resource_instance: str
:param vpc: The allowed VPC name or ID
:type vpc: str
"""
# Required parameters
args = ['dns_zone', 'resource_instance', 'vpc']
check_args(args, **kwargs)
# Set default value if required paramaters are not defined
args = {
'dns_zone': kwargs.get('dns_zone'),
'vpc': kwargs.get('vpc'),
'resource_instance': kwargs.get('resource_instance'),
}
# get resource instance guid
temp_ri = self.resource_instance.get_resource_instance(
args['resource_instance'])
if "errors" in temp_ri:
return temp_ri
resource_instance_guid = temp_ri["guid"]
# get vpc crn
temp_vpc = self.vpc.get_vpc(args["vpc"])
if "errors" in temp_vpc:
return temp_vpc
vpc_crn = temp_vpc["crn"]
# Get zone ID
zone_id = self.get_dns_zone_id(
dns_zone=args['dns_zone'],
resource_instance=resource_instance_guid)
if "errors" in zone_id:
return zone_id
payload = {}
# Construct payload
payload["type"] = "vpc"
payload["permitted_network"] = {}
payload["permitted_network"]["vpc_crn"] = vpc_crn
try:
# Connect to api endpoint for permitted network
path = ("/v1/instances/{}/dnszones/{}/permitted_networks").format(
resource_instance_guid, zone_id)
return qw("dns", "POST", path, headers(),
json.dumps(payload))["data"]
except Exception as error:
print("Error adding permitted network. {}".format(error))
raise
def create_security_group(self, **kwargs):
"""Create security group
:param name: The user-defined name for this security group
:type name: str, optional
:param resource_group: The resource group to use
:type security_group: str, optional
:param vpc: The VPC this security group is to be a part of
:type vpc: str
:param rules: Array of rule prototype objects for rules to be created
for this security group
:type rules: list, optional
"""
args = ["vpc"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'name': kwargs.get('name'),
'resource_group': kwargs.get('resource_group'),
'vpc': kwargs.get('vpc'),
'rules': kwargs.get('rules'),
}
# Construct payload
payload = {}
for key, value in args.items():
if value is not None:
if key == "vpc":
vpc_info = self.vpc.get_vpc(args["vpc"])
if "errors" in vpc_info:
return vpc_info
payload["vpc"] = {"id": vpc_info["id"]}
elif key == "resource_group":
rg_info = self.rg.get_resource_group(
args["resource_group"])
if "errors" in rg_info:
return rg_info
payload["resource_group"] = {"id": rg_info["id"]}
elif key == "rules":
rs = []
for sg_rules in args["rules"]:
rs.append(sg_rules)
payload["rules"] = rs
else:
payload[key] = value
try:
# Connect to api endpoint for security_groups
path = ("/v1/security_groups?version={}&generation={}".format(
self.cfg["version"], self.cfg["generation"]))
# Return data
return qw("iaas", "POST", path, headers(),
json.dumps(payload))["data"]
except Exception as error:
print("Error creating security group. {}".format(error))
raise
def create_address_prefix(self, **kwargs):
"""Create address prefix
:param vpc: VPC name or ID
:type vpc: str
:param name: The user-defined name for this address prefix
:type name: str, optional
:param cidr: The CIDR block for this address prefix
:type cidr: str
:param is_default: Indicates whether this is the default prefix for
this zone in this VPC
:type is_default: bool, optional
:param zone: The zone this address prefix is to belong to
:type zone: str
:return: Address prefix information
:rtype: dict
"""
args = ["vpc", "cidr", "zone"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'vpc': kwargs.get('vpc'),
'name': kwargs.get('name'),
'cidr': kwargs.get('cidr'),
'is_default': kwargs.get('is_default', False),
'zone': kwargs.get('zone'),
}
# Construct payload
payload = {}
for key, value in args.items():
if key != "vpc" and value is not None:
if key == "zone":
payload["zone"] = {"name": args["zone"]}
else:
payload[key] = value
# Check if VPC exists and get information
vpc_info = self.get_vpc(args['vpc'])
if "errors" in vpc_info:
return vpc_info
try:
# Connect to api endpoint for vpcs
path = ("/v1/vpcs/{}/address_prefixes?version={}"
"&generation={}".format(vpc_info["id"],
self.cfg["version"],
self.cfg["generation"]))
# Return data
return qw("iaas", "POST", path, headers(),
json.dumps(payload))["data"]
except Exception as error:
print("Error creating address prefix in VPC {}. {}".format(
args['vpc'], error))
raise
def create_ike_policy(self, **kwargs):
"""Create IKE policy
:param name: The user-defined name for this IKE policy
:type name: str, optional
:param resource_group: The resource group to use
:type resource_group: str, optional
:param authentication_algorithm: The authentication algorithm
:type authentication_algorithm: str
:param dh_group: The Diffie-Hellman group
:type dh_group: str
:param encryption_algorithm: The encryption algorithm
:type encryption_algorithm: str
:param ike_version: The IKE protocol version
:type ike_version: int
:param key_lifetime: The key lifetime in seconds
:type key_lifetime: int, optional
"""
args = ["authentication_algorithm", "dh_group",
"encryption_algorithm", "ike_version"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'name': kwargs.get('name'),
'resource_group': kwargs.get('resource_group'),
'authentication_algorithm': kwargs.get('authentication_algorithm'),
'dh_group': kwargs.get('dh_group'),
'encryption_algorithm': kwargs.get('encryption_algorithm'),
'ike_version': kwargs.get('ike_version'),
'key_lifetime': kwargs.get('key_lifetime'),
}
# Construct payload
payload = {}
for key, value in args.items():
if value is not None:
if key == "resource_group":
rg_info = self.rg.get_resource_group(
args["resource_group"])
if "errors" in rg_info:
return rg_info
payload["resource_group"] = {"id": rg_info["id"]}
else:
payload[key] = value
try:
# Connect to api endpoint for ike_policies
path = ("/v1/ike_policies?version={}&generation={}".format(
self.cfg["version"], self.cfg["generation"]))
# Return data
return qw("iaas", "POST", path, headers(),
json.dumps(payload))["data"]
except Exception as error:
print("Error creating IKE policy. {}".format(error))
raise
def get_dns_zone_by_name(self, **kwargs):
"""Get DNS zone by name
:param dns_zone: DNS zone name to query
:type dns_zone: str
:param resource_instance: Name or GUID of the resource instance
:type resource_instance: str
:return: DNS zone information
:rtype: dict
"""
# Required parameters
args = ['dns_zone', 'resource_instance']
check_args(args, **kwargs)
# Set default value if required paramaters are not defined
args = {
'dns_zone': kwargs.get('dns_zone'),
'resource_instance': kwargs.get('resource_instance'),
}
# get resource instance guid
temp_ri = self.resource_instance.get_resource_instance(
args['resource_instance'])
if "errors" in temp_ri:
return temp_ri
resource_instance_guid = temp_ri["guid"]
try:
# Connect to api endpoint for dns zones
path = ("/v1/instances/{}/dnszones").format(resource_instance_guid)
dns_zones = qw("dns", "GET", path, headers())["data"]
if "errors" in dns_zones or not dns_zones:
return ({
"errors": [{
"code": "not_found",
"message": "No dns zones found."
}]
})
# Find the existing domain matching the query
for dns_zone in dns_zones['dnszones']:
if dns_zone["name"] == args['dns_zone']:
return dns_zone
# Return error message if no existing domain matches the query
return ({
"errors": [{
"code": "not_found",
"message": "No dns zone found."
}]
})
except Exception as error:
print("Error creating dns zone. {}".format(error))
raise
def create_instance_interface(self, **kwargs):
"""Create instance interface
:param instance: The instance name or ID
:type instance: str
:param subnet: The associated subnet name or ID
:type subnet: str
:param primary_ipv4_address: The primary IPv4 address
:type primary_ipv4_address: str, optional
:param security_groups: Collection of security groups
:type security_groups: str, optional
"""
args = ["instance", "subnet"]
check_args(args, **kwargs)
args = {
'instance': kwargs.get('instance'),
'subnet': kwargs.get('forsubnetce'),
'primary_ipv4_address': kwargs.get('primary_ipv4_address'),
'security_groups': kwargs.get('security_groups'),
}
instance_info = self.get_instance(args["instance"])
if "errors" in instance_info:
return instance_info
subnet_info = self.subnet.get_subnet(args["subnet"])
if "errors" in subnet_info:
return subnet_info
payload = {}
for key, value in args.items():
if key != "instance" and value is not None:
if key == "security_groups":
sg = []
for key_sg in args["security_groups"]:
tmp_sg = {}
tmp_sg["id"] = key_sg
sg.append(tmp_sg)
payload["security_groups"] = sg
elif key == "subnet":
payload["subnet"] = {"id": subnet_info["id"]}
else:
payload[key] = value
try:
path = ("/v1/instances/{}/network_interfaces?version={}"
"&generation={}".format(instance_info["id"],
self.cfg["version"],
self.cfg["generation"]))
return qw("iaas", "POST", path, headers(),
json.dumps(payload))["data"]
except Exception as error:
print("Error creating instance interface. {}".format(error))
raise
def order_file_volume(self, **kwargs):
"""Places an order for a file volume
:param storage_type: Type of volume "Endurance|Performance"
:type storage_type: str
:param location: Name of the datacenter in which to order the volume
:type location: str
:param size: Size of the desired volume, in GB
:type size: int
:param iops: Number of IOPS for a "Performance" order
:type iops: int
:param tier_level: Tier level to use for an "Endurance" order
(0.25|2|4|10)
:type tier_level: int
:param snapshot_size: The size of optional snapshot space, if snapshot
space should also be ordered (None if not ordered)
:type snapshot_size: int
:param service_offering: Requested offering package to use in the order
("storage_as_a_service", "enterprise", or "performance")
:type service_offering: str
:param hourly_billing_flag: Billing type, monthly (False) or
hourly (True), default to monthly
:type hourly_billing_flag: bool
:return: Created volume description
:rtype: dict
"""
args = ["storage_type", "location", "size"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'storage_type': kwargs.get('storage_type'),
'location': kwargs.get('location'),
'size': kwargs.get('size'),
'iops': kwargs.get('iops') or None,
'tier_level': kwargs.get('tier_level') or None,
'snapshot_size': kwargs.get('snapshot_size') or None,
'service_offering': kwargs.get('service_offering',
'storage_as_a_service'),
'hourly_billing_flag': kwargs.get('hourly_billing_flag') or False
}
try:
order = self.file.order_file_volume(
args['storage_type'],
args['location'],
args['size'],
iops=args['iops'],
tier_level=args['tier_level'],
snapshot_size=args['snapshot_size'],
service_offering=args['service_offering'],
hourly_billing_flag=args['hourly_billing_flag'])
return order
except sl.SoftLayer.SoftLayerAPIError as error:
return resource_error(error.faultCode, error.faultString)
def create_port(self, **kwargs):
"""Create network
:param instance: Instance name or ID
:type instance: str
:param network: Network name or ID
:type network: str
:param description: Description of the port
:type description: str, optional
:param ip_address: The requested ip address of this port
:type ip_address: str, optional
:return: Port information
:rtype: dict
"""
args = ["instance", "network"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'instance': kwargs.get('instance'),
'network': kwargs.get('network'),
'description': kwargs.get('description'),
'ip_address': kwargs.get('ip_address'),
}
# Construct payload
payload = {}
for key, value in args.items():
if key != "instance" and key != "network" and value is not None:
if key == "ip_address":
payload["ipAddress"] = args['ip_address']
else:
payload[key] = value
try:
# Check if cloud instance exists and retrieve information
ci_info = self.instance.get_instance(instance)
if "errors" in ci_info:
return ci_info
# Check if network exists and retrieve information
net_info = self.get_network(ci_info["name"], args['network'])
if "errors" in net_info:
return net_info
# Connect to api endpoint for cloud-instances
path = ("/pcloud/v1/cloud-instances/{}/networks/{}/ports".format(
ci_info["name"], net_info["networkID"]))
# Return data
return qw("power", "POST", path, headers(),
json.dumps(payload))["data"]
except Exception as error:
print("Error creating port in network {} for cloud instance {}."
" {}".format(args['network'], args['instance'], error))
def attach_volume(self, **kwargs):
"""Attach a volume to an instance
:param instance: The instance name or ID
:type instance: str
:param volume: The identity of the volume to attach to the instance
:type volume: str
:param delete_volume_on_instance_delete: If set to true, when deleting
the instance the volume will also be deleted
:type delete_volume_on_instance_delete: bool, optional
:param name: The user-defined name for this volume attachment
:type name: str
"""
args = ["instance", "volume"]
check_args(args, **kwargs)
args = {
'instance':
kwargs.get('instance'),
'volume':
kwargs.get('volume'),
'delete_volume_on_instance_delete':
kwargs.get('delete_volume_on_instance_delete'),
'name':
kwargs.get('name'),
}
instance_info = self.get_instance(args["instance"])
if "errors" in instance_info:
return instance_info
volume_info = self.volume.get_volume(args["volume"])
if "errors" in volume_info:
return volume_info
payload = {}
for key, value in args.items():
if key != "instance" and value is not None:
if key == "volume":
payload["volume"] = {"id": volume_info["id"]}
else:
payload[key] = value
try:
path = ("/v1/instances/{}/volume_attachments?version={}"
"&generation={}".format(instance_info["id"],
self.cfg["version"],
self.cfg["generation"]))
return qw("iaas", "POST", path, headers(),
json.dumps(payload))["data"]
except Exception as error:
print("Error creating volume attachment. {}".format(error))
raise
def create_zone(self, **kwargs):
"""Create a zone in a specified resource instance
:param dns_zone: The user-defined name to create
:type dns_zone: str
:param description: A description for the domain
:type description: str, optional
:param label: A label for the domain
:type label: str, optional
:param resource_instance: Name or GUID of the resource instance
:type resource_instance: str
"""
# Required parameters
args = ['dns_zone', 'resource_instance']
check_args(args, **kwargs)
# Set default value if required paramaters are not defined
args = {
'name': kwargs.get('dns_zone'),
'description': kwargs.get('description') or "",
'label': kwargs.get('label') or "",
}
# get resource instance guid
temp_ri = self.resource_instance.get_resource_instance(
kwargs.get('resource_instance'))
if "errors" in temp_ri:
return temp_ri
resource_instance_guid = temp_ri["guid"]
zone = self.get_dns_zone(dns_zone=args['name'],
resource_instance=resource_instance_guid)
if "errors" in zone:
for key_zone in zone["errors"]:
if key_zone["code"] == "not_found":
payload = {}
# Construct payload
for key, value in args.items():
payload[key] = value
try:
# Connect to api endpoint for dns zone
path = ("/v1/instances/{}/dnszones"
).format(resource_instance_guid)
# Return data
return qw("dns", "POST", path, headers(),
json.dumps(payload))["data"]
except Exception as error:
print("Error creating dns zone. {}".format(error))
raise
return zone
def perform_action(self, **kwargs):
"""Perform an action on Power Virtual Machine
:param instance: Cloud instance ID
:type instance: str
:param pvm: Power Virtual Instance name or ID
:type pvm: str
:param action: Name of the action to take
:type action: str
:return: Action information
:rtype: dict
"""
args = ["instance", "pvm", "action"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'instance': kwargs.get('instance'),
'pvm': kwargs.get('pvm'),
'action': kwargs.get('action'),
}
# Construct payload
payload = {}
for key, value in args.items():
if key != "instance" and key != "pvm" and value is not None:
payload[key] = value
try:
# Check if cloud instance exists and retrieve information
ci_info = self.instance.get_instance(args['instance'])
if "errors" in ci_info:
return ci_info
# Check if pvm exists and retrieve information
pvm_info = self.get_pvm(ci_info["name"], args['pvm'])
if "errors" in pvm_info:
return pvm_info
# Connect to api endpoint for cloud-instances
path = ("/pcloud/v1/cloud-instances/{}/pvm-instances/{}"
"/action".format(ci_info["name"],
pvm_info["pvmInstanceID"]))
# Return data
return qw("power", "POST", path, headers(),
json.dumps(payload))["data"]
except Exception as error:
print("Error performing action {} on Power Virtual Machine {} for"
" cloud instance {}. {}".format(args['action'],
args['network'],
args['instance'], error))
def create_gateway(self, **kwargs):
"""Create gateway
:param name: The user-defined name for this gateway
:type name: str, optional
:param resource_group: The resource group to use
:type resource_group: str, optional
:param subnet: Identifies a subnet by a unique property
:type subnet: str
"""
args = ["subnet"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'name': kwargs.get('name'),
'resource_group': kwargs.get('resource_group'),
'subnet': kwargs.get('subnet'),
}
# Retrieve subnet information to get the ID
subnet_info = self.subnet.get_subnet(args["subnet"])
if "errors" in subnet_info:
return subnet_info
# Construct payload
payload = {}
for key, value in args.items():
if value is not None:
if key == "resource_group":
rg_info = self.rg.get_resource_group(
args["resource_group"])
if "errors" in rg_info:
return rg_info
payload["resource_group"] = {"id": rg_info["id"]}
elif key == "subnet":
payload["subnet"] = {"id": subnet_info["id"]}
else:
payload[key] = value
try:
# Connect to api endpoint for vpn_gateways
path = ("/v1/vpn_gateways?version={}&generation={}".format(
self.cfg["version"], self.cfg["generation"]))
# Return data
return qw("iaas", "POST", path, headers(),
json.dumps(payload))["data"]
except Exception as error:
print("Error creating gateway. {}".format(error))
raise
def delete_zone(self, **kwargs):
"""Delete a zone in from a specified resource instance
:param dns_zone: DNS zone name to delete
:type dns_zone: str
:param resource_instance: Name or GUID of the resource instance
:type resource_instance: str
"""
# Required parameters
args = ['dns_zone', 'resource_instance']
check_args(args, **kwargs)
# Set default value if required paramaters are not defined
args = {
'name': kwargs.get('dns_zone'),
'resource_instance': kwargs.get('resource_instance'),
}
# get resource instance guid
temp_ri = self.resource_instance.get_resource_instance(
args['resource_instance'])
if "errors" in temp_ri:
return temp_ri
resource_instance_guid = temp_ri["guid"]
dns_zone = self.get_dns_zone(
dns_zone=args['name'], resource_instance=args['resource_instance'])
if "errors" in dns_zone:
return dns_zone
dns_zone_id = dns_zone['id']
try:
# Connect to api endpoint for dns zone
path = ("/v1/instances/{}/dnszones/{}").format(
resource_instance_guid, dns_zone_id)
# Return data
result = qw("dns", "DELETE", path, headers())
if result["data"] is None:
if result["response"].getcode() == 204:
return ({
"message":
"deletion request successfully initiated"
})
return result
except Exception as error:
print("Error creating dns zone. {}".format(error))
raise
def add_interface_security_group(self, **kwargs):
"""Add network interface to a security group
:param interface: The network interface ID
:type interface: str
:param security_group: The security group name or ID
:type security_group: str
:param instance: Instance name or ID
:type instance: str, optional
"""
args = ["interface", "security_group"]
check_args(args, **kwargs)
# Build dict of argument and assign default value when needed
args = {
'interface': kwargs.get('interface'),
'security_group': kwargs.get('security_group'),
'instance': kwargs.get('instance'),
}
target = args["interface"]
# Retrieve security group information to get the ID
# (mostly useful if a name is provided)
sg_info = self.get_security_group(args["security_group"])
if "errors" in sg_info:
return sg_info
if args["instance"]:
# Retrieve network interface information to get the ID
# (mostly useful if a name is provided)
nic_info = self.instance.get_instance_interface(
args["instance"], args["interface"])
if "errors" in nic_info:
return nic_info
target = nic_info["id"]
try:
# Connect to api endpoint for security_groups
path = ("/v1/security_groups/{}/network_interfaces/{}?version={}"
"&generation={}".format(sg_info["id"], target,
self.cfg["version"],
self.cfg["generation"]))
# Return data
return qw("iaas", "PUT", path, headers(), None)["data"]
except Exception as error:
print("Error adding network interface {} to security group"
" {}. {}".format(target, args["security_group"], error))
raise
