def list_virtual_servers(self,
address=None,
subnets=None,
ssh_keys_required=True,
security_groups_required=True) -> List:
"""Retrieve a list of all virtual servers on the Account."""
details = {
'address': address,
'subnets': subnets,
'ssh_keys_required': ssh_keys_required,
'security_groups_required': security_groups_required
}
instances_list = []
self.vs_manager = VSManager(self.client)
try:
instances = self.retry.call(self.vs_manager.list_instances,
mask=VIRTUAL_SERVER_MASK)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
else:
for instance in instances:
instance_obj = self.__parse_to_softlayer(instance, **details)
if instance_obj:
instances_list.append(instance_obj)
return instances_list
def wait_instance_for_ready(self, instance_id, limit=10):
try:
self.vs_manager = VSManager(self.client)
return self.vs_manager.wait_for_ready(instance_id, limit=limit)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
return False
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
def get_instance_by_id(self, instance_id):
"""
Get a softlayer instance, with provided ID
:return:
"""
try:
self.vs_manager = VSManager(self.client)
instances = self.retry.call(self.vs_manager.get_instance,
instance_id=instance_id)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
else:
return instances
def list_vsi_hostnames(self) -> List[Dict]:
"""List all private and public images on the Account as Dict."""
instances_list = list()
try:
self.vs_manager = VSManager(self.client)
instances = self.retry.call(self.vs_manager.list_instances,
mask=VSI_ID_HOSTNAME_ONLY_MASK)
for instance in instances:
instances_list.append({
"id": instance.get('id'),
"hostname": instance.get('hostname')
})
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
else:
return instances_list
def get_instance_details(self,
instance_id,
ssh_keys_required=False,
security_groups_required=False):
details = {
'ssh_keys_required': ssh_keys_required,
'security_groups_required': security_groups_required
}
self.vs_manager = VSManager(self.client)
try:
instance = self.retry.call(self.vs_manager.get_instance,
mask=VIRTUAL_SERVER_MASK,
instance_id=instance_id)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
else:
instance = self.__parse_to_softlayer(instance, **details)
return instance
def capture_image(self, instance_id, image_name, additional_disks=False):
"""
Create and capture image template of an image belonging to classical VSI
:return:
"""
try:
self.vs_manager = VSManager(self.client)
return self.retry.call(self.vs_manager.capture, instance_id,
image_name, additional_disks)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
def create_instance(self, instance_body):
"""
Create Sofltlayer Instance
return:
"""
try:
self.vs_manager = VSManager(self.client)
return self.retry.call(self.vs_manager.create_instance,
**instance_body)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
def delete_instance(self, instance_id):
"""
Delete instance from Classical Infrastructure
:param instance_id: Classical Instance ID for the image
:return:
"""
try:
self.vs_manager = VSManager(self.client)
return self.retry.call(self.vs_manager.cancel_instance,
instance_id)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
class FetchOperations:
client: BaseClient
dedicated_host_manager: DedicatedHostManager
load_balancer_manager: LoadBalancerManager
firewall_manager: FirewallManager
network_manager: NetworkManager
image_manager: ImageManager
ssh_manager: SshKeyManager
ssl_manager: SSLManager
vs_manager: VSManager
def __init__(self, client, username):
self.client = client
self.username = username
self.retry = self.requests_retry()
def requests_retry(self):
self.retry = Retrying(
stop=stop_after_attempt(RETRY),
retry=retry_if_exception_type(SLRateLimitExceededError),
wait=wait_random_exponential(multiplier=BACK_OFF_FACTOR,
max=MAX_INTERVAL),
reraise=True)
return self.retry
def authenticate_sl_account(self):
"""
Authenticate SL account with provided credentials
:return:
"""
try:
return self.retry.call(self.client.call, "Account", "getObject")
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
def list_private_subnets(self,
vlan_no=None,
network_identifier=None) -> list:
"""List all the private Subnetworks associated with an Account."""
subnets_list = list()
try:
self.network_manager = NetworkManager(self.client)
vlans = self.retry.call(
self.network_manager.list_vlans,
filter={
"networkVlans": {
"subnets": {
"addressSpace": {
"operation": "PRIVATE"
}
}
}
},
mask="mask{subnets}".format(subnets=SUBNET_MASK))
for vlan in vlans:
if vlan_no and vlan_no != vlan.get("vlanNumber"):
continue
vlan_name = "{}-{{}}".format(
vlan.get("name")
or "subnet-{}".format(vlan.get("vlanNumber")))
count = 1
for subnet in vlan.get("subnets", []):
sl_subnet = SoftLayerSubnet(
name=vlan_name.format(count),
vif_id=vlan.get("vlanNumber"),
address="{}/{}".format(subnet.get("gateway"),
subnet.get("cidr")),
network_id=subnet["networkIdentifier"])
count = count + 1
if not (network_identifier
and network_identifier != sl_subnet.network_id):
subnets_list.append(sl_subnet)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
return subnets_list
def get_instance_by_id(self, instance_id):
"""
Get a softlayer instance, with provided ID
:return:
"""
try:
self.vs_manager = VSManager(self.client)
instances = self.retry.call(self.vs_manager.get_instance,
instance_id=instance_id)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
else:
return instances
def wait_instance_for_ready(self, instance_id, limit=10):
try:
self.vs_manager = VSManager(self.client)
return self.vs_manager.wait_for_ready(instance_id, limit=limit)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
return False
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
def get_image_by_name(self, image_name, create_date=None):
"""
Get image on the basis of image name.
:param image_name: Name of the image.
:param create_date: Creation Date of image
:return: Return the filtered image on the basis of above params.
"""
try:
image_manager = ImageManager(self.client)
images = self.retry.call(image_manager.list_private_images,
name=image_name)
if not images:
return
if not create_date or len(images) == 1:
return images[0]
else:
try:
time_list = [
abs((parser.parse(image["createDate"]) -
parser.parse(create_date)).total_seconds())
for image in images
]
minimum_index = time_list.index(min(time_list))
return images[minimum_index]
except (parser.ParserError, KeyError, IndexError):
return images[0]
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
def get_image_by_id(self, image_id):
"""
Get image on the basis of image id.
:param image_id: Classical ID of the image.
:return: Return the filtered image on the basis of above params.
"""
try:
image_manager = ImageManager(self.client)
image = self.retry.call(image_manager.get_image, image_id=image_id)
if image:
return image
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
def __parse_to_softlayer(self,
vs_instance,
subnets=None,
address=None,
ssh_keys_required=True,
security_groups_required=True):
if not (vs_instance["status"].get("keyName") == "ACTIVE"
and vs_instance.get("operatingSystem")):
return
sl_instance = SoftLayerInstance.from_softlayer_json(
instance_json=vs_instance)
sl_instance.auto_scale_group = get_auto_scale_group(vs_instance)
sl_instance.network_attached_storages = list_network_attached_storages(
vs_instance.get('allowedNetworkStorage'))
instance_profile, family = get_ibm_instance_profile(
vs_instance["maxCpu"], vs_instance["maxMemory"])
sl_instance.instance_profile = SoftLayerInstanceProfile(
name=instance_profile, family=family)
os = vs_instance["operatingSystem"]["softwareLicense"][
"softwareDescription"]
sl_instance.image = SoftLayerImage.from_softlayer_json(
operating_system=os)
if ssh_keys_required:
sl_instance.ssh_keys.extend([
SoftLayerSshKey.from_softlayer_json(ssh_key)
for ssh_key in vs_instance.get("sshKeys", [])
])
for volume in vs_instance.get("blockDevices", []):
if not volume.get("diskImage"):
continue
SWAP = "SWAP" in volume["diskImage"].get("description", "")
MB = "MB" == volume["diskImage"].get("units")
CLOUD_INIT_DISK = 64 == volume["diskImage"].get("capacity")
if not ((CLOUD_INIT_DISK and MB) or SWAP):
volume_name = f"{sl_instance.name}-{volume['diskImage'].get('name')}"
sl_instance.volumes.append(
SoftLayerVolume.from_softlayer_json(name=volume_name,
volume_json=volume))
for network in vs_instance.get("networkComponents", []):
if not network.get("primarySubnet"):
continue
interface_name = "{name}{port}".format(name=network.get("name"),
port=network.get("port"))
sl_interface = SoftLayerNetworkInterface(
interface_name, network.get("primaryIpAddress"))
if interface_name == "eth0":
sl_interface.is_primary = True
if network["primarySubnet"].get("addressSpace") == "PUBLIC":
sl_interface.is_public_interface = True
if subnets:
attached_subnet = [
subnet for subnet in subnets
if subnet.vif_id == network["networkVlan"].get(
"vlanNumber") and subnet.network_id ==
network["primarySubnet"].get("networkIdentifier")
]
else:
attached_subnet = self.list_private_subnets(
vlan_no=network["networkVlan"].get("vlanNumber"),
network_identifier=network["primarySubnet"].get(
"networkIdentifier"))
if attached_subnet:
sl_interface.subnet = attached_subnet[0]
if security_groups_required:
for security_group in network.get("securityGroupBindings", []):
if not security_group.get("securityGroup"):
continue
if not security_group["securityGroup"].get("name"):
continue
sl_security_group = SoftLayerSecurityGroup(
name=security_group["securityGroup"]["name"])
for rule in security_group["securityGroup"].get(
"rules", []):
if rule["ethertype"] == "IPv6":
continue
sl_security_group_rule = SoftLayerSecurityGroupRule(
direction=rule["direction"],
protocol=rule.get("protocol", "all"),
port_max=rule.get("portRangeMax"),
port_min=rule.get("portRangeMin"),
address=network["primaryIpAddress"])
sl_security_group.rules.append(sl_security_group_rule)
sl_interface.security_groups.append(sl_security_group)
sl_instance.network_interfaces.append(sl_interface)
else:
sl_instance.network_interfaces.append(sl_interface)
if not (address and address not in [
interface.private_ip
for interface in sl_instance.network_interfaces
]):
return sl_instance
def get_instance_details(self,
instance_id,
ssh_keys_required=False,
security_groups_required=False):
details = {
'ssh_keys_required': ssh_keys_required,
'security_groups_required': security_groups_required
}
self.vs_manager = VSManager(self.client)
try:
instance = self.retry.call(self.vs_manager.get_instance,
mask=VIRTUAL_SERVER_MASK,
instance_id=instance_id)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
else:
instance = self.__parse_to_softlayer(instance, **details)
return instance
def list_virtual_servers(self,
address=None,
subnets=None,
ssh_keys_required=True,
security_groups_required=True) -> List:
"""Retrieve a list of all virtual servers on the Account."""
details = {
'address': address,
'subnets': subnets,
'ssh_keys_required': ssh_keys_required,
'security_groups_required': security_groups_required
}
instances_list = []
self.vs_manager = VSManager(self.client)
try:
instances = self.retry.call(self.vs_manager.list_instances,
mask=VIRTUAL_SERVER_MASK)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
else:
for instance in instances:
instance_obj = self.__parse_to_softlayer(instance, **details)
if instance_obj:
instances_list.append(instance_obj)
return instances_list
def list_load_balancers(self, vs_instances=None) -> list:
"""Returns a list of IBM Cloud Loadbalancers"""
load_balancers_list = list()
try:
self.load_balancer_manager = LoadBalancerManager(self.client)
load_balancers = self.retry.call(
self.load_balancer_manager.get_lbaas, mask=LOAD_BALANCER_MASK)
for lb in load_balancers:
pools_list, subnets_list = list(), list()
sl_load_balancer = SoftLayerLoadBalancer(
lb["name"], lb["isPublic"], lb["address"])
for listener in lb.get("listeners", []):
sl_listener = SoftLayerListener(
protocol=listener.get("protocol"),
port=listener.get("protocolPort"),
connection_limit=listener.get("connectionLimit"))
if listener.get("defaultPool"):
sl_pool = SoftLayerBackendPool(
port=listener["defaultPool"].get("protocolPort"),
protocol=listener["defaultPool"].get("protocol"),
algorithm=listener["defaultPool"].get(
"loadBalancingAlgorithm"))
if listener["defaultPool"].get("sessionAffinity"):
sl_pool.session_persistence = listener[
"defaultPool"]["sessionAffinity"].get("type")
if listener["defaultPool"].get("healthMonitor"):
sl_health_monitor = SoftLayerPoolHealthMonitor(
listener["defaultPool"]["healthMonitor"].get(
"maxRetries"), listener["defaultPool"]
["healthMonitor"].get("timeout"),
listener["defaultPool"]["healthMonitor"].get(
"monitorType"), listener["defaultPool"]
["healthMonitor"].get("urlPath"),
listener["defaultPool"]["healthMonitor"].get(
"interval"))
sl_pool.health_monitor = sl_health_monitor
for member in listener["defaultPool"].get(
"members", []):
sl_pool_mem = SoftLayerPoolMember(
weight=member.get("weight"),
port=listener.get("protocolPort"),
ip=member.get("address"))
if not vs_instances:
instance = self.list_virtual_servers(
address=member.get("address"))
else:
instance = [
instance for instance in vs_instances
if member.get("address") in [
interf.private_ip for interf in
instance.network_interfaces
]
]
if not instance:
continue
sl_pool_mem.instance = instance[0]
for network_interface in sl_pool_mem.instance.network_interfaces:
if not network_interface.subnet:
continue
if network_interface.subnet.name not in [
subnet.name for subnet in subnets_list
]:
subnets_list.append(
network_interface.subnet)
sl_pool.pool_members.append(sl_pool_mem)
sl_listener.backend_pool = sl_pool
pools_list.append(sl_pool)
sl_load_balancer.listeners.append(sl_listener)
sl_load_balancer.pools = pools_list
sl_load_balancer.subnets = subnets_list
load_balancers_list.append(sl_load_balancer)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
else:
return load_balancers_list
def list_security_groups(self) -> list:
"""List all the Security Groups within an Account."""
sl_security_groups_list = list()
try:
security_groups = self.retry.call(
NetworkManager(self.client).list_securitygroups,
mask="mask{mask}".format(
mask="[networkComponentBindings, rules]"))
for security_group in security_groups:
sl_security_group = SoftLayerSecurityGroup(
name=security_group["name"])
for rule in security_group.get("rules", []):
if rule["ethertype"] == "IPv6":
continue
sl_security_group_rule = SoftLayerSecurityGroupRule(
direction=rule["direction"],
protocol=rule.get("protocol", "all"),
port_max=rule.get("portRangeMax"),
port_min=rule.get("portRangeMin"))
if rule.get("remoteIp") and "/" in rule.get("remoteIp"):
sl_security_group_rule.rule_type = "cidr_block"
sl_security_group_rule.cidr_block = rule.get(
"remoteIp")
elif rule.get("remoteIp"):
sl_security_group_rule.rule_type = "address"
sl_security_group_rule.address = rule.get("remoteIp")
sl_security_group.rules.append(sl_security_group_rule)
sl_security_groups_list.append(sl_security_group)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
else:
return sl_security_groups_list
def list_images(self) -> dict:
"""List all private and public images on the Account as Dict."""
try:
self.image_manager = ImageManager(self.client)
return {
"private_images":
self.retry.call(self.image_manager.list_private_images),
"public_images":
self.retry.call(self.image_manager.list_public_images),
}
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
def list_private_images_name(self):
"""List all private and public images on the Account as Dict."""
image_list = list()
try:
# TODO we should ask region from the user and send the exact name rather then first element
self.image_manager = ImageManager(self.client)
images = self.retry.call(self.image_manager.list_private_images,
mask=IMAGE_MASK)
for image in images:
if not image.get("children"):
continue
image_child = image["children"][0]
if image_child.get('transactionId'):
continue
if not image_child.get("blockDevices"):
continue
block_device = image_child["blockDevices"][0]
if not block_device.get("diskImage"):
continue
disk_image = block_device.get("diskImage")
if not disk_image.get('softwareReferences'):
continue
software_reference = disk_image["softwareReferences"][0]
if not (software_reference.get("softwareDescription")
and software_reference.get("softwareDescription").get(
"longDescription")):
continue
image_name = software_reference.get("softwareDescription").get(
"longDescription")
instance_vpc_image = classical_vpc_image_dictionary.get(
image_name)
instance_vpc_image = instance_vpc_image[
0] if instance_vpc_image else "-"
if instance_vpc_image == "-":
continue
image_list.append({
"id": image.get('id'),
"name": image.get('name'),
"vpc_image_name": instance_vpc_image,
"operating_systems": {
"architecture": "amd64"
}
})
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
else:
return image_list
def list_vsi_hostnames(self) -> List[Dict]:
"""List all private and public images on the Account as Dict."""
instances_list = list()
try:
self.vs_manager = VSManager(self.client)
instances = self.retry.call(self.vs_manager.list_instances,
mask=VSI_ID_HOSTNAME_ONLY_MASK)
for instance in instances:
instances_list.append({
"id": instance.get('id'),
"hostname": instance.get('hostname')
})
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
else:
return instances_list
def list_dedicated_hosts(self, instances=False, raw=False) -> List[Dict]:
"""List all Dedicated Hosts on the Account as Dict."""
try:
self.dedicated_host_manager = DedicatedHostManager(self.client)
dedicated_hosts = self.retry.call(
self.dedicated_host_manager.list_instances,
mask=DEDICATED_HOST_W_INSTANCES_MASK
if instances else DEDICATED_HOST_WO_INSTANCES_MASK)
dedicated_hosts_list = dedicated_hosts
if not raw:
dedicated_hosts_list = [
SoftLayerDedicatedHost.from_softlayer_json(dedicated_host)
for dedicated_host in dedicated_hosts
]
except SoftLayerAPIError as ex:
LOGGER.info(f"error_message => {ex.reason}")
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
else:
return dedicated_hosts_list
def list_ssh_keys(self) -> list:
"""Lists all SSH keys on the Account."""
try:
self.ssh_manager = SshKeyManager(self.client)
return self.retry.call(self.ssh_manager.list_keys)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
def list_ssl_certs(self) -> dict:
"""A list of dictionaries representing the requested SSL certs."""
try:
self.ssl_manager = SSLManager(self.client)
return self.retry.call(self.ssl_manager.list_certs)
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
def get_classic_image_name(self, image_name):
"""concatenate an integer value if this image already exists"""
try:
img_manager = ImageManager(self.client)
private_images = self.retry.call(img_manager.list_private_images,
name=image_name)
num = 1
while True:
if image_name not in [
image.get("name") for image in private_images
]:
return image_name
image_name = "-".join([image_name, str(num)])
num += 1
except SoftLayerAPIError as ex:
if ex.faultCode == SL_RATE_LIMIT_FAULT_CODE:
raise SLRateLimitExceededError(ex)
elif ex.faultCode == INVALID_API_KEY_CODE:
raise SLAuthError(self.username)
raise SLExecuteError(ex)
def list_kubernetes_clusters(self, user_name, api_key):
"""List Classic IKS Clusters on the Account."""
try:
iks_clusters_list = list()
kubernetes_client = ClassicKubernetesClient(user_name, api_key)
clusters = kubernetes_client.list_clusters()
if clusters:
for cluster in clusters:
multi_zone_cluster = False
free_tier_cluster = False
if cluster['state'] != "normal" or cluster[
'type'] == "openshift":
continue
k8s_cluster = KubernetesCluster.from_ibm_json_body(cluster)
k8s_cluster.status = CREATION_PENDING
k8s_cluster_worker_pools = kubernetes_client.get_cluster_worker_pool(
cluster["id"])
for k8s_cluster_worker_pool in k8s_cluster_worker_pools:
if len(k8s_cluster_worker_pool['zones']) > 1:
multi_zone_cluster = True
break
classic_k8s_cluster_worker_pool = KubernetesClusterWorkerPool.from_ibm_json_body(
k8s_cluster_worker_pool)
for k8s_cluster_worker_pool_zone in k8s_cluster_worker_pool[
'zones']:
classic_k8s_cluster_worker_pool_zone = KubernetesClusterWorkerPoolZone.from_ibm_json_body(
k8s_cluster_worker_pool_zone)
k8s_cluster_subnets = kubernetes_client.get_cluster_subnets(
cluster["id"], cluster["resourceGroup"])
if k8s_cluster_subnets == "Free tier cluster":
free_tier_cluster = True
break
subnets = self.list_private_subnets()
for subnet in subnets:
for k8s_cluster_subnet in k8s_cluster_subnets:
if classic_k8s_cluster_worker_pool_zone.private_vlan == k8s_cluster_subnet[
"id"]:
if subnet.network == k8s_cluster_subnet[
"subnets"][0]['cidr']:
classic_k8s_cluster_worker_pool_zone.subnets.append(
subnet.to_ibm())
classic_k8s_cluster_worker_pool.zones.append(
classic_k8s_cluster_worker_pool_zone)
k8s_cluster.worker_pools.append(
classic_k8s_cluster_worker_pool)
if multi_zone_cluster:
continue
if free_tier_cluster:
continue
kube_config = kubernetes_client.get_cluster_kube_config(
cluster["id"])
kube_config = K8s(configuration_json=kube_config)
workloads = list()
namespaces = kube_config.client.CoreV1Api().list_namespace(
)
for namespace in namespaces.items:
kubernetes_objects = {
"pod": list(),
"svc": list(),
"pvc": list()
}
if namespace.metadata.name in [
"kube-system", "kube-public", "ibm-cert-store",
"ibm-operators", "kube-node-lease",
"ibm-system", "ibm-observe"
]:
continue
kubernetes_objects[
"namespace"] = namespace.metadata.name
pods = kube_config.client.CoreV1Api(
).list_namespaced_pod(
namespace=namespace.metadata.name)
if pods.items:
for pod in pods.items:
kubernetes_objects["pod"].append(
pod.metadata.name)
svcs = kube_config.client.CoreV1Api(
).list_namespaced_service(
namespace=namespace.metadata.name)
if svcs.items:
for svc in svcs.items:
kubernetes_objects["svc"].append(
svc.metadata.name)
pvcs = kube_config.client.CoreV1Api(
).list_namespaced_persistent_volume_claim(
namespace=namespace.metadata.name)
if pvcs.items:
for pvc in pvcs.items:
kubernetes_objects["pvc"].append({
"name":
pvc.metadata.name,
"size":
pvc.spec.resources.requests['storage']
})
workloads.append(kubernetes_objects)
k8s_cluster.workloads = workloads
iks_clusters_list.append(k8s_cluster)
return iks_clusters_list
except Exception as ex:
LOGGER.info(ex)
def __init__(self):
self.vs_manager = VSManager(client=create_client_from_env())
class ICSoftlayerManager:
"""
Client for Softlayer VSI creation/deletion/fetching
"""
def __init__(self):
self.vs_manager = VSManager(client=create_client_from_env())
def create_instance(self, instance_dict):
"""
Create a VSI on Softlayer
:param instance_dict: <dict> (preferably from ImageConversionInstance.generate_config_file_contents function)
:raises SLAuthException if Softlayer credentials are not valid
:raises UnexpectedSLError if there is an unexpected error from softlayer in its API
:return: <dict> Dictionary containing VSI details if the call was successful
"""
try:
response = self.vs_manager.create_instance(**instance_dict)
except SoftLayerAPIError as ex:
if ex.faultString == "Invalid API token.":
raise SLAuthException()
else:
raise UnexpectedSLError(ex)
return response
def delete_instance(self, softlayer_instance_id):
"""
Deletes a VSI from Softlayer
:param softlayer_instance_id: <int/string> ID of the VSI on softlayer to delete
:raises SLAuthException if Softlayer credentials are not valid
:raises SLResourceNotFoundException if the VSI with provided ID does not exist in softlayer
:raises UnexpectedSLError if there is an unexpected error from softlayer in its API
"""
try:
self.vs_manager.cancel_instance(softlayer_instance_id)
except SoftLayerAPIError as ex:
if ex.faultCode == "SoftLayer_Exception_ObjectNotFound":
raise SLResourceNotFoundException(ex.reason)
elif ex.faultString == "Invalid API token.":
raise SLAuthException()
else:
raise UnexpectedSLError(ex)
def get_instance(self, softlayer_instance_id):
"""
Get a VSI's details from Softlayer
:param softlayer_instance_id: <int/string> ID of the VSI on softlayer to fetch
:raises SLAuthException if Softlayer credentials are not valid
:raises SLResourceNotFoundException if the VSI with provided ID does not exist in softlayer
:raises UnexpectedSLError if there is an unexpected error from softlayer in its API
:return: <dict> Dictionary containing VSI details if the call was successful
"""
try:
instance_data = self.vs_manager.get_instance(softlayer_instance_id)
except SoftLayerAPIError as ex:
if ex.faultCode == "SoftLayer_Exception_ObjectNotFound":
raise SLResourceNotFoundException(ex.reason)
elif ex.faultString == "Invalid API token.":
raise SLAuthException()
else:
raise UnexpectedSLError(ex)
return instance_data