# 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.
"""
Dimension Data Common Components
"""
from time import sleep
from base64 import b64encode
# TODO: use distutils.version when Travis CI fixed the pylint issue with version
# from distutils.version import LooseVersion
from libcloud.utils.py3 import b, httplib, basestring
from libcloud.utils.xml import findtext
from libcloud.common.base import RawResponse, XmlResponse, ConnectionUserAndKey
from libcloud.compute.base import Node
from libcloud.compute.types import LibcloudError, InvalidCredsError
# Roadmap / TODO:
#
# 1.0 - Copied from OpSource API, named provider details.
# setup a few variables to represent all of the DimensionData cloud namespaces
NAMESPACE_BASE = "http://oec.api.opsource.net/schemas"
ORGANIZATION_NS = NAMESPACE_BASE + "/organization"
SERVER_NS = NAMESPACE_BASE + "/server"
NETWORK_NS = NAMESPACE_BASE + "/network"
DIRECTORY_NS = NAMESPACE_BASE + "/directory"
GENERAL_NS = NAMESPACE_BASE + "/general"
BACKUP_NS = NAMESPACE_BASE + "/backup"
# API 2.0 Namespaces and URNs
TYPES_URN = "urn:didata.com:api:cloud:types"
# API end-points
API_ENDPOINTS = {
"dd-na": {
"name": "North America (NA)",
"host": "api-na.dimensiondata.com",
"vendor": "DimensionData",
},
"dd-eu": {
"name": "Europe (EU)",
"host": "api-eu.dimensiondata.com",
"vendor": "DimensionData",
},
"dd-au": {
"name": "Australia (AU)",
"host": "api-au.dimensiondata.com",
"vendor": "DimensionData",
},
"dd-au-gov": {
"name": "Australia Canberra ACT (AU)",
"host": "api-canberra.dimensiondata.com",
"vendor": "DimensionData",
},
"dd-af": {
"name": "Africa (AF)",
"host": "api-mea.dimensiondata.com",
"vendor": "DimensionData",
},
"dd-ap": {
"name": "Asia Pacific (AP)",
"host": "api-ap.dimensiondata.com",
"vendor": "DimensionData",
},
"dd-latam": {
"name": "South America (LATAM)",
"host": "api-latam.dimensiondata.com",
"vendor": "DimensionData",
},
"dd-canada": {
"name": "Canada (CA)",
"host": "api-canada.dimensiondata.com",
"vendor": "DimensionData",
},
"is-na": {
"name": "North America (NA)",
"host": "usapi.cloud.is.co.za",
"vendor": "InternetSolutions",
},
"is-eu": {
"name": "Europe (EU)",
"host": "euapi.cloud.is.co.za",
"vendor": "InternetSolutions",
},
"is-au": {
"name": "Australia (AU)",
"host": "auapi.cloud.is.co.za",
"vendor": "InternetSolutions",
},
"is-af": {
"name": "Africa (AF)",
"host": "meaapi.cloud.is.co.za",
"vendor": "InternetSolutions",
},
"is-ap": {
"name": "Asia Pacific (AP)",
"host": "apapi.cloud.is.co.za",
"vendor": "InternetSolutions",
},
"is-latam": {
"name": "South America (LATAM)",
"host": "latamapi.cloud.is.co.za",
"vendor": "InternetSolutions",
},
"is-canada": {
"name": "Canada (CA)",
"host": "canadaapi.cloud.is.co.za",
"vendor": "InternetSolutions",
},
"ntta-na": {
"name": "North America (NA)",
"host": "cloudapi.nttamerica.com",
"vendor": "NTTNorthAmerica",
},
"ntta-eu": {
"name": "Europe (EU)",
"host": "eucloudapi.nttamerica.com",
"vendor": "NTTNorthAmerica",
},
"ntta-au": {
"name": "Australia (AU)",
"host": "aucloudapi.nttamerica.com",
"vendor": "NTTNorthAmerica",
},
"ntta-af": {
"name": "Africa (AF)",
"host": "sacloudapi.nttamerica.com",
"vendor": "NTTNorthAmerica",
},
"ntta-ap": {
"name": "Asia Pacific (AP)",
"host": "hkcloudapi.nttamerica.com",
"vendor": "NTTNorthAmerica",
},
"cisco-na": {
"name": "North America (NA)",
"host": "iaas-api-na.cisco-ccs.com",
"vendor": "Cisco",
},
"cisco-eu": {
"name": "Europe (EU)",
"host": "iaas-api-eu.cisco-ccs.com",
"vendor": "Cisco",
},
"cisco-au": {
"name": "Australia (AU)",
"host": "iaas-api-au.cisco-ccs.com",
"vendor": "Cisco",
},
"cisco-af": {
"name": "Africa (AF)",
"host": "iaas-api-mea.cisco-ccs.com",
"vendor": "Cisco",
},
"cisco-ap": {
"name": "Asia Pacific (AP)",
"host": "iaas-api-ap.cisco-ccs.com",
"vendor": "Cisco",
},
"cisco-latam": {
"name": "South America (LATAM)",
"host": "iaas-api-sa.cisco-ccs.com",
"vendor": "Cisco",
},
"cisco-canada": {
"name": "Canada (CA)",
"host": "iaas-api-ca.cisco-ccs.com",
"vendor": "Cisco",
},
}
# Default API end-point for the base connection class.
DEFAULT_REGION = "dd-na"
BAD_CODE_XML_ELEMENTS = (
("responseCode", SERVER_NS),
("responseCode", TYPES_URN),
("result", GENERAL_NS),
)
BAD_MESSAGE_XML_ELEMENTS = (
("message", SERVER_NS),
("message", TYPES_URN),
("resultDetail", GENERAL_NS),
)
def dd_object_to_id(obj, obj_type, id_value="id"):
"""
Takes in a DD object or string and prints out it's id
This is a helper method, as many of our functions can take either an object
or a string, and we need an easy way of converting them
:param obj: The object to get the id for
:type obj: ``object``
:param func: The function to call, e.g. ex_get_vlan. Note: This
function needs to return an object which has ``status``
attribute.
:type func: ``function``
:rtype: ``str``
"""
if isinstance(obj, obj_type):
return getattr(obj, id_value)
elif isinstance(obj, (basestring)):
return obj
else:
raise TypeError(
"Invalid type {} looking for basestring or {}".format(
type(obj).__name__, obj_type.__name__
)
)
# TODO: use distutils.version when Travis CI fixed the pylint issue with version
# This is a temporary workaround.
def LooseVersion(version):
return float(version)
class NetworkDomainServicePlan:
ESSENTIALS = "ESSENTIALS"
ADVANCED = "ADVANCED"
class DimensionDataRawResponse(RawResponse):
pass
class DimensionDataResponse(XmlResponse):
def parse_error(self):
if self.status == httplib.UNAUTHORIZED:
raise InvalidCredsError(self.body)
elif self.status == httplib.FORBIDDEN:
raise InvalidCredsError(self.body)
body = self.parse_body()
if self.status == httplib.BAD_REQUEST:
for response_code in BAD_CODE_XML_ELEMENTS:
code = findtext(body, response_code[0], response_code[1])
if code is not None:
break
for message in BAD_MESSAGE_XML_ELEMENTS:
message = findtext(body, message[0], message[1])
if message is not None:
break
raise DimensionDataAPIException(code=code, msg=message, driver=self.connection.driver)
if self.status is not httplib.OK:
raise DimensionDataAPIException(
code=self.status, msg=body, driver=self.connection.driver
)
return self.body
class DimensionDataAPIException(LibcloudError):
def __init__(self, code, msg, driver):
self.code = code
self.msg = msg
self.driver = driver
def __str__(self):
return "{}: {}".format(self.code, self.msg)
def __repr__(self):
return "<DimensionDataAPIException: code='{}', msg='{}'>".format(
self.code,
self.msg,
)
class DimensionDataConnection(ConnectionUserAndKey):
"""
Connection class for the DimensionData driver
"""
api_path_version_1 = "/oec"
api_path_version_2 = "/caas"
api_version_1 = 0.9
# Earliest version supported
oldest_api_version = "2.2"
# Latest version supported
latest_api_version = "2.4"
# Default api version
active_api_version = "2.4"
_orgId = None
responseCls = DimensionDataResponse
rawResponseCls = DimensionDataRawResponse
allow_insecure = False
def __init__(
self,
user_id,
key,
secure=True,
host=None,
port=None,
url=None,
timeout=None,
proxy_url=None,
api_version=None,
**conn_kwargs,
):
super().__init__(
user_id=user_id,
key=key,
secure=secure,
host=host,
port=port,
url=url,
timeout=timeout,
proxy_url=proxy_url,
)
if conn_kwargs["region"]:
self.host = conn_kwargs["region"]["host"]
if api_version:
if LooseVersion(api_version) < LooseVersion(self.oldest_api_version):
msg = (
"API Version specified is too old. No longer "
"supported. Please upgrade to the latest version {}".format(
self.active_api_version
)
)
raise DimensionDataAPIException(code=None, msg=msg, driver=self.driver)
elif LooseVersion(api_version) > LooseVersion(self.latest_api_version):
msg = (
"Unsupported API Version. The version specified is "
"not release yet. Please use the latest supported "
"version {}".format(self.active_api_version)
)
raise DimensionDataAPIException(code=None, msg=msg, driver=self.driver)
else:
# Overwrite default version using the version user specified
self.active_api_version = api_version
def add_default_headers(self, headers):
headers["Authorization"] = "Basic %s" % b64encode(
b("{}:{}".format(self.user_id, self.key))
).decode("utf-8")
headers["Content-Type"] = "application/xml"
return headers
def request_api_1(self, action, params=None, data="", headers=None, method="GET"):
action = "{}/{}/{}".format(self.api_path_version_1, self.api_version_1, action)
return super().request(
action=action, params=params, data=data, method=method, headers=headers
)
def request_api_2(self, path, action, params=None, data="", headers=None, method="GET"):
action = "{}/{}/{}/{}".format(
self.api_path_version_2,
self.active_api_version,
path,
action,
)
return super().request(
action=action, params=params, data=data, method=method, headers=headers
)
def raw_request_with_orgId_api_1(
self, action, params=None, data="", headers=None, method="GET"
):
action = "{}/{}".format(self.get_resource_path_api_1(), action)
return super().request(
action=action,
params=params,
data=data,
method=method,
headers=headers,
raw=True,
)
def request_with_orgId_api_1(self, action, params=None, data="", headers=None, method="GET"):
action = "{}/{}".format(self.get_resource_path_api_1(), action)
return super().request(
action=action, params=params, data=data, method=method, headers=headers
)
def request_with_orgId_api_2(self, action, params=None, data="", headers=None, method="GET"):
action = "{}/{}".format(self.get_resource_path_api_2(), action)
return super().request(
action=action, params=params, data=data, method=method, headers=headers
)
def paginated_request_with_orgId_api_2(
self, action, params=None, data="", headers=None, method="GET", page_size=250
):
"""
A paginated request to the MCP2.0 API
This essentially calls out to request_with_orgId_api_2 for each page
and yields the response to make a generator
This generator can be looped through to grab all the pages.
:param action: The resource to access (i.e. 'network/vlan')
:type action: ``str``
:param params: Parameters to give to the action
:type params: ``dict`` or ``None``
:param data: The data payload to be added to the request
:type data: ``str``
:param headers: Additional header to be added to the request
:type headers: ``str`` or ``dict`` or ``None``
:param method: HTTP Method for the request (i.e. 'GET', 'POST')
:type method: ``str``
:param page_size: The size of each page to be returned
Note: Max page size in MCP2.0 is currently 250
:type page_size: ``int``
"""
if params is None:
params = {}
params["pageSize"] = page_size
resp = self.request_with_orgId_api_2(action, params, data, headers, method).object
yield resp
if len(resp) <= 0:
return
pcount = resp.get("pageCount") # pylint: disable=no-member
psize = resp.get("pageSize") # pylint: disable=no-member
pnumber = resp.get("pageNumber") # pylint: disable=no-member
while int(pcount) >= int(psize):
params["pageNumber"] = int(pnumber) + 1
resp = self.request_with_orgId_api_2(action, params, data, headers, method).object
pcount = resp.get("pageCount") # pylint: disable=no-member
psize = resp.get("pageSize") # pylint: disable=no-member
pnumber = resp.get("pageNumber") # pylint: disable=no-member
yield resp
def get_resource_path_api_1(self):
"""
This method returns a resource path which is necessary for referencing
resources that require a full path instead of just an ID, such as
networks, and customer snapshots.
"""
return "{}/{}/{}".format(
self.api_path_version_1,
self.api_version_1,
self._get_orgId(),
)
def get_resource_path_api_2(self):
"""
This method returns a resource path which is necessary for referencing
resources that require a full path instead of just an ID, such as
networks, and customer snapshots.
"""
return "{}/{}/{}".format(
self.api_path_version_2,
self.active_api_version,
self._get_orgId(),
)
def wait_for_state(self, state, func, poll_interval=2, timeout=60, *args, **kwargs):
"""
Wait for the function which returns a instance with field status/state
to match.
Keep polling func until one of the desired states is matched
:param state: Either the desired state (`str`) or a `list` of states
:type state: ``str`` or ``list``
:param func: The function to call, e.g. ex_get_vlan. Note: This
function needs to return an object which has ``status``
attribute.
:type func: ``function``
:param poll_interval: The number of seconds to wait between checks
:type poll_interval: `int`
:param timeout: The total number of seconds to wait to reach a state
:type timeout: `int`
:param args: The arguments for func
:type args: Positional arguments
:param kwargs: The arguments for func
:type kwargs: Keyword arguments
:return: Result from the calling function.
"""
cnt = 0
result = None
object_state = None
while cnt < timeout / poll_interval:
result = func(*args, **kwargs)
if isinstance(result, Node):
object_state = result.state
else:
object_state = result.status
if object_state is state or str(object_state) in state:
return result
sleep(poll_interval)
cnt += 1
msg = "Status check for object %s timed out" % (result)
raise DimensionDataAPIException(code=object_state, msg=msg, driver=self.driver)
def _get_orgId(self):
"""
Send the /myaccount API request to DimensionData cloud and parse the
'orgId' from the XML response object. We need the orgId to use most
of the other API functions
"""
if self._orgId is None:
body = self.request_api_1("myaccount").object
self._orgId = findtext(body, "orgId", DIRECTORY_NS)
return self._orgId
def get_account_details(self):
"""
Get the details of this account
:rtype: :class:`DimensionDataAccountDetails`
"""
body = self.request_api_1("myaccount").object
return DimensionDataAccountDetails(
user_name=findtext(body, "userName", DIRECTORY_NS),
full_name=findtext(body, "fullName", DIRECTORY_NS),
first_name=findtext(body, "firstName", DIRECTORY_NS),
last_name=findtext(body, "lastName", DIRECTORY_NS),
email=findtext(body, "emailAddress", DIRECTORY_NS),
)
class DimensionDataAccountDetails:
"""
Dimension Data account class details
"""
def __init__(self, user_name, full_name, first_name, last_name, email):
self.user_name = user_name
self.full_name = full_name
self.first_name = first_name
self.last_name = last_name
self.email = email
class DimensionDataStatus:
"""
DimensionData API pending operation status class
action, request_time, user_name, number_of_steps, update_time,
step.name, step.number, step.percent_complete, failure_reason,
"""
def __init__(
self,
action=None,
request_time=None,
user_name=None,
number_of_steps=None,
update_time=None,
step_name=None,
step_number=None,
step_percent_complete=None,
failure_reason=None,
):
self.action = action
self.request_time = request_time
self.user_name = user_name
self.number_of_steps = number_of_steps
self.update_time = update_time
self.step_name = step_name
self.step_number = step_number
self.step_percent_complete = step_percent_complete
self.failure_reason = failure_reason
def __repr__(self):
return (
"<DimensionDataStatus: action=%s, request_time=%s, "
"user_name=%s, number_of_steps=%s, update_time=%s, "
"step_name=%s, step_number=%s, "
"step_percent_complete=%s, failure_reason=%s>"
) % (
self.action,
self.request_time,
self.user_name,
self.number_of_steps,
self.update_time,
self.step_name,
self.step_number,
self.step_percent_complete,
self.failure_reason,
)
class DimensionDataNetwork:
"""
DimensionData network with location.
"""
def __init__(self, id, name, description, location, private_net, multicast, status):
self.id = str(id)
self.name = name
self.description = description
self.location = location
self.private_net = private_net
self.multicast = multicast
self.status = status
def __repr__(self):
return (
"<DimensionDataNetwork: id=%s, name=%s, description=%s, "
"location=%s, private_net=%s, multicast=%s>"
) % (
self.id,
self.name,
self.description,
self.location,
self.private_net,
self.multicast,
)
class DimensionDataNetworkDomain:
"""
DimensionData network domain with location.
"""
def __init__(self, id, name, description, location, status, plan):
self.id = str(id)
self.name = name
self.description = description
self.location = location
self.status = status
self.plan = plan
def __repr__(self):
return (
"<DimensionDataNetworkDomain: id=%s, name=%s, "
"description=%s, location=%s, status=%s, plan=%s>"
) % (
self.id,
self.name,
self.description,
self.location,
self.status,
self.plan,
)
class DimensionDataPublicIpBlock:
"""
DimensionData Public IP Block with location.
"""
def __init__(self, id, base_ip, size, location, network_domain, status):
self.id = str(id)
self.base_ip = base_ip
self.size = size
self.location = location
self.network_domain = network_domain
self.status = status
def __repr__(self):
return (
"<DimensionDataNetworkDomain: id=%s, base_ip=%s, " "size=%s, location=%s, status=%s>"
) % (self.id, self.base_ip, self.size, self.location, self.status)
class DimensionDataServerCpuSpecification:
"""
A class that represents the specification of the CPU(s) for a
node
"""
def __init__(self, cpu_count, cores_per_socket, performance):
"""
Instantiate a new :class:`DimensionDataServerCpuSpecification`
:param cpu_count: The number of CPUs
:type cpu_count: ``int``
:param cores_per_socket: The number of cores per socket, the
recommendation is 1
:type cores_per_socket: ``int``
:param performance: The performance type, e.g. HIGHPERFORMANCE
:type performance: ``str``
"""
self.cpu_count = cpu_count
self.cores_per_socket = cores_per_socket
self.performance = performance
def __repr__(self):
return (
"<DimensionDataServerCpuSpecification: "
"cpu_count=%s, cores_per_socket=%s, "
"performance=%s>"
) % (self.cpu_count, self.cores_per_socket, self.performance)
class DimensionDataServerDisk:
"""
A class that represents the disk on a server
"""
def __init__(self, id=None, scsi_id=None, size_gb=None, speed=None, state=None):
"""
Instantiate a new :class:`DimensionDataServerDisk`
:param id: The id of the disk
:type id: ``str``
:param scsi_id: Representation for scsi
:type scsi_id: ``int``
:param size_gb: Size of the disk
:type size_gb: ``int``
:param speed: Speed of the disk (i.e. STANDARD)
:type speed: ``str``
:param state: State of the disk (i.e. PENDING)
:type state: ``str``
"""
self.id = id
self.scsi_id = scsi_id
self.size_gb = size_gb
self.speed = speed
self.state = state
def __repr__(self):
return ("<DimensionDataServerDisk: " "id=%s, size_gb=%s") % (
self.id,
self.size_gb,
)
class DimensionDataServerVMWareTools:
"""
A class that represents the VMWareTools for a node
"""
def __init__(self, status, version_status, api_version):
"""
Instantiate a new :class:`DimensionDataServerVMWareTools` object
:param status: The status of VMWare Tools
:type status: ``str``
:param version_status: The status for the version of VMWare Tools
(i.e NEEDS_UPGRADE)
:type version_status: ``str``
:param api_version: The API version of VMWare Tools
:type api_version: ``str``
"""
self.status = status
self.version_status = version_status
self.api_version = api_version
def __repr__(self):
return (
"<DimensionDataServerVMWareTools " "status=%s, version_status=%s, " "api_version=%s>"
) % (self.status, self.version_status, self.api_version)
class DimensionDataFirewallRule:
"""
DimensionData Firewall Rule for a network domain
"""
def __init__(
self,
id,
name,
action,
location,
network_domain,
status,
ip_version,
protocol,
source,
destination,
enabled,
):
self.id = str(id)
self.name = name
self.action = action
self.location = location
self.network_domain = network_domain
self.status = status
self.ip_version = ip_version
self.protocol = protocol
self.source = source
self.destination = destination
self.enabled = enabled
def __repr__(self):
return (
"<DimensionDataFirewallRule: id=%s, name=%s, "
"action=%s, location=%s, network_domain=%s, "
"status=%s, ip_version=%s, protocol=%s, source=%s, "
"destination=%s, enabled=%s>"
) % (
self.id,
self.name,
self.action,
self.location,
self.network_domain,
self.status,
self.ip_version,
self.protocol,
self.source,
self.destination,
self.enabled,
)
class DimensionDataFirewallAddress:
"""
The source or destination model in a firewall rule
"""
def __init__(
self,
any_ip,
ip_address,
ip_prefix_size,
port_begin,
port_end,
address_list_id,
port_list_id,
):
self.any_ip = any_ip
self.ip_address = ip_address
self.ip_prefix_size = ip_prefix_size
self.port_list_id = port_list_id
self.port_begin = port_begin
self.port_end = port_end
self.address_list_id = address_list_id
self.port_list_id = port_list_id
def __repr__(self):
return (
"<DimensionDataFirewallAddress: any_ip=%s, ip_address=%s, "
"ip_prefix_size=%s, port_begin=%s, port_end=%s, "
"address_list_id=%s, port_list_id=%s>"
% (
self.any_ip,
self.ip_address,
self.ip_prefix_size,
self.port_begin,
self.port_end,
self.address_list_id,
self.port_list_id,
)
)
class DimensionDataNatRule:
"""
An IP NAT rule in a network domain
"""
def __init__(self, id, network_domain, internal_ip, external_ip, status):
self.id = id
self.network_domain = network_domain
self.internal_ip = internal_ip
self.external_ip = external_ip
self.status = status
def __repr__(self):
return ("<DimensionDataNatRule: id=%s, status=%s>") % (self.id, self.status)
class DimensionDataAntiAffinityRule:
"""
Anti-Affinity rule for DimensionData
An Anti-Affinity rule ensures that servers in the rule will
not reside on the same VMware ESX host.
"""
def __init__(self, id, node_list):
"""
Instantiate a new :class:`DimensionDataAntiAffinityRule`
:param id: The ID of the Anti-Affinity rule
:type id: ``str``
:param node_list: List of node ids that belong in this rule
:type node_list: ``list`` of ``str``
"""
self.id = id
self.node_list = node_list
def __repr__(self):
return ("<DimensionDataAntiAffinityRule: id=%s>") % (self.id)
class DimensionDataVlan:
"""
DimensionData VLAN.
"""
def __init__(
self,
id,
name,
description,
location,
network_domain,
status,
private_ipv4_range_address,
private_ipv4_range_size,
ipv6_range_address,
ipv6_range_size,
ipv4_gateway,
ipv6_gateway,
):
"""
Initialize an instance of ``DimensionDataVlan``
:param id: The ID of the VLAN
:type id: ``str``
:param name: The name of the VLAN
:type name: ``str``
:param description: Plan text description of the VLAN
:type description: ``str``
:param location: The location (data center) of the VLAN
:type location: ``NodeLocation``
:param network_domain: The Network Domain that owns this VLAN
:type network_domain: :class:`DimensionDataNetworkDomain`
:param status: The status of the VLAN
:type status: :class:`DimensionDataStatus`
:param private_ipv4_range_address: The host address of the VLAN
IP space
:type private_ipv4_range_address: ``str``
:param private_ipv4_range_size: The size (e.g. '24') of the VLAN
as a CIDR range size
:type private_ipv4_range_size: ``int``
:param ipv6_range_address: The host address of the VLAN
IP space
:type ipv6_range_address: ``str``
:param ipv6_range_size: The size (e.g. '32') of the VLAN
as a CIDR range size
:type ipv6_range_size: ``int``
:param ipv4_gateway: The IPv4 default gateway address
:type ipv4_gateway: ``str``
:param ipv6_gateway: The IPv6 default gateway address
:type ipv6_gateway: ``str``
"""
self.id = str(id)
self.name = name
self.location = location
self.description = description
self.network_domain = network_domain
self.status = status
self.private_ipv4_range_address = private_ipv4_range_address
self.private_ipv4_range_size = private_ipv4_range_size
self.ipv6_range_address = ipv6_range_address
self.ipv6_range_size = ipv6_range_size
self.ipv4_gateway = ipv4_gateway
self.ipv6_gateway = ipv6_gateway
def __repr__(self):
return (
"<DimensionDataVlan: id=%s, name=%s, " "description=%s, location=%s, status=%s>"
) % (self.id, self.name, self.description, self.location, self.status)
class DimensionDataPool:
"""
DimensionData VIP Pool.
"""
def __init__(
self,
id,
name,
description,
status,
load_balance_method,
health_monitor_id,
service_down_action,
slow_ramp_time,
):
"""
Initialize an instance of ``DimensionDataPool``
:param id: The ID of the pool
:type id: ``str``
:param name: The name of the pool
:type name: ``str``
:param description: Plan text description of the pool
:type description: ``str``
:param status: The status of the pool
:type status: :class:`DimensionDataStatus`
:param load_balance_method: The load balancer method
:type load_balance_method: ``str``
:param health_monitor_id: The ID of the health monitor
:type health_monitor_id: ``str``
:param service_down_action: Action to take when pool is down
:type service_down_action: ``str``
:param slow_ramp_time: The ramp-up time for service recovery
:type slow_ramp_time: ``int``
"""
self.id = str(id)
self.name = name
self.description = description
self.status = status
self.load_balance_method = load_balance_method
self.health_monitor_id = health_monitor_id
self.service_down_action = service_down_action
self.slow_ramp_time = slow_ramp_time
def __repr__(self):
return ("<DimensionDataPool: id=%s, name=%s, " "description=%s, status=%s>") % (
self.id,
self.name,
self.description,
self.status,
)
class DimensionDataPoolMember:
"""
DimensionData VIP Pool Member.
"""
def __init__(self, id, name, status, ip, port, node_id):
"""
Initialize an instance of ``DimensionDataPoolMember``
:param id: The ID of the pool member
:type id: ``str``
:param name: The name of the pool member
:type name: ``str``
:param status: The status of the pool
:type status: :class:`DimensionDataStatus`
:param ip: The IP of the pool member
:type ip: ``str``
:param port: The port of the pool member
:type port: ``int``
:param node_id: The ID of the associated node
:type node_id: ``str``
"""
self.id = str(id)
self.name = name
self.status = status
self.ip = ip
self.port = port
self.node_id = node_id
def __repr__(self):
return (
"<DimensionDataPoolMember: id=%s, name=%s, " "ip=%s, status=%s, port=%s, node_id=%s>"
) % (self.id, self.name, self.ip, self.status, self.port, self.node_id)
class DimensionDataVIPNode:
def __init__(
self,
id,
name,
status,
ip,
connection_limit="10000",
connection_rate_limit="10000",
):
"""
Initialize an instance of :class:`DimensionDataVIPNode`
:param id: The ID of the node
:type id: ``str``
:param name: The name of the node
:type name: ``str``
:param status: The status of the node
:type status: :class:`DimensionDataStatus`
:param ip: The IP of the node
:type ip: ``str``
:param connection_limit: The total connection limit for the node
:type connection_limit: ``int``
:param connection_rate_limit: The rate limit for the node
:type connection_rate_limit: ``int``
"""
self.id = str(id)
self.name = name
self.status = status
self.ip = ip
self.connection_limit = connection_limit
self.connection_rate_limit = connection_rate_limit
def __repr__(self):
return ("<DimensionDataVIPNode: id=%s, name=%s, " "status=%s, ip=%s>") % (
self.id,
self.name,
self.status,
self.ip,
)
class DimensionDataVirtualListener:
"""
DimensionData Virtual Listener.
"""
def __init__(self, id, name, status, ip):
"""
Initialize an instance of :class:`DimensionDataVirtualListener`
:param id: The ID of the listener
:type id: ``str``
:param name: The name of the listener
:type name: ``str``
:param status: The status of the listener
:type status: :class:`DimensionDataStatus`
:param ip: The IP of the listener
:type ip: ``str``
"""
self.id = str(id)
self.name = name
self.status = status
self.ip = ip
def __repr__(self):
return ("<DimensionDataVirtualListener: id=%s, name=%s, " "status=%s, ip=%s>") % (
self.id,
self.name,
self.status,
self.ip,
)
class DimensionDataDefaultHealthMonitor:
"""
A default health monitor for a VIP (node, pool or listener)
"""
def __init__(self, id, name, node_compatible, pool_compatible):
"""
Initialize an instance of :class:`DimensionDataDefaultHealthMonitor`
:param id: The ID of the monitor
:type id: ``str``
:param name: The name of the monitor
:type name: ``str``
:param node_compatible: Is a monitor capable of monitoring nodes
:type node_compatible: ``bool``
:param pool_compatible: Is a monitor capable of monitoring pools
:type pool_compatible: ``bool``
"""
self.id = id
self.name = name
self.node_compatible = node_compatible
self.pool_compatible = pool_compatible
def __repr__(self):
return ("<DimensionDataDefaultHealthMonitor: id=%s, name=%s>") % (
self.id,
self.name,
)
class DimensionDataPersistenceProfile:
"""
Each Persistence Profile declares the combination of Virtual Listener
type and protocol with which it is
compatible and whether or not it is compatible as a
Fallback Persistence Profile.
"""
def __init__(self, id, name, compatible_listeners, fallback_compatible):
"""
Initialize an instance of :class:`DimensionDataPersistenceProfile`
:param id: The ID of the profile
:type id: ``str``
:param name: The name of the profile
:type name: ``str``
:param compatible_listeners: List of compatible Virtual Listener types
:type compatible_listeners: ``list`` of
:class:`DimensionDataVirtualListenerCompatibility`
:param fallback_compatible: Is capable as a fallback profile
:type fallback_compatible: ``bool``
"""
self.id = id
self.name = name
self.compatible_listeners = compatible_listeners
self.fallback_compatible = fallback_compatible
def __repr__(self):
return ("<DimensionDataPersistenceProfile: id=%s, name=%s>") % (
self.id,
self.name,
)
class DimensionDataDefaultiRule:
"""
A default iRule for a network domain, can be applied to a listener
"""
def __init__(self, id, name, compatible_listeners):
"""
Initialize an instance of :class:`DimensionDataDefaultiRule`
:param id: The ID of the iRule
:type id: ``str``
:param name: The name of the iRule
:type name: ``str``
:param compatible_listeners: List of compatible Virtual Listener types
:type compatible_listeners: ``list`` of
:class:`DimensionDataVirtualListenerCompatibility`
"""
self.id = id
self.name = name
self.compatible_listeners = compatible_listeners
def __repr__(self):
return ("<DimensionDataDefaultiRule: id=%s, name=%s>") % (self.id, self.name)
class DimensionDataVirtualListenerCompatibility:
"""
A compatibility preference for a persistence profile or iRule
specifies which virtual listener types this profile or iRule can be
applied to.
"""
def __init__(self, type, protocol):
self.type = type
self.protocol = protocol
def __repr__(self):
return ("<DimensionDataVirtualListenerCompatibility: " "type=%s, protocol=%s>") % (
self.type,
self.protocol,
)
class DimensionDataBackupDetails:
"""
Dimension Data Backup Details represents information about
a targets backups configuration
"""
def __init__(self, asset_id, service_plan, status, clients=None):
"""
Initialize an instance of :class:`DimensionDataBackupDetails`
:param asset_id: Asset identification for backups
:type asset_id: ``str``
:param service_plan: The service plan for backups. i.e (Essentials)
:type service_plan: ``str``
:param status: The overall status this backup target.
i.e. (unregistered)
:type status: ``str``
:param clients: Backup clients attached to this target
:type clients: ``list`` of :class:`DimensionDataBackupClient`
"""
self.asset_id = asset_id
self.service_plan = service_plan
self.status = status
self.clients = clients
def __repr__(self):
return ("<DimensionDataBackupDetails: id=%s>") % (self.asset_id)
class DimensionDataBackupClient:
"""
An object that represents a backup client
"""
def __init__(
self,
id,
type,
status,
schedule_policy,
storage_policy,
download_url,
alert=None,
running_job=None,
):
"""
Initialize an instance of :class:`DimensionDataBackupClient`
:param id: Unique ID for the client
:type id: ``str``
:param type: The type of client that this client is
:type type: :class:`DimensionDataBackupClientType`
:param status: The states of this particular backup client.
i.e. (Unregistered)
:type status: ``str``
:param schedule_policy: The schedule policy for this client
NOTE: Dimension Data only sends back the name
of the schedule policy, no further details
:type schedule_policy: ``str``
:param storage_policy: The storage policy for this client
NOTE: Dimension Data only sends back the name
of the storage policy, no further details
:type storage_policy: ``str``
:param download_url: The download url for this client
:type download_url: ``str``
:param alert: The alert configured for this backup client (optional)
:type alert: :class:`DimensionDataBackupClientAlert`
:param alert: The running job for the client (optional)
:type alert: :class:`DimensionDataBackupClientRunningJob`
"""
self.id = id
self.type = type
self.status = status
self.schedule_policy = schedule_policy
self.storage_policy = storage_policy
self.download_url = download_url
self.alert = alert
self.running_job = running_job
def __repr__(self):
return ("<DimensionDataBackupClient: id=%s>") % (self.id)
class DimensionDataBackupClientAlert:
"""
An alert for a backup client
"""
def __init__(self, trigger, notify_list=[]):
"""
Initialize an instance of :class:`DimensionDataBackupClientAlert`
:param trigger: Trigger type for the client i.e. ON_FAILURE
:type trigger: ``str``
:param notify_list: List of email addresses that are notified
when the alert is fired
:type notify_list: ``list`` of ``str``
"""
self.trigger = trigger
self.notify_list = notify_list
def __repr__(self):
return ("<DimensionDataBackupClientAlert: trigger=%s>") % (self.trigger)
class DimensionDataBackupClientRunningJob:
"""
A running job for a given backup client
"""
def __init__(self, id, status, percentage=0):
"""
Initialize an instance of :class:`DimensionDataBackupClientRunningJob`
:param id: The unique ID of the job
:type id: ``str``
:param status: The status of the job i.e. Waiting
:type status: ``str``
:param percentage: The percentage completion of the job
:type percentage: ``int``
"""
self.id = id
self.percentage = percentage
self.status = status
def __repr__(self):
return ("<DimensionDataBackupClientRunningJob: id=%s>") % (self.id)
class DimensionDataBackupClientType:
"""
A client type object for backups
"""
def __init__(self, type, is_file_system, description):
"""
Initialize an instance of :class:`DimensionDataBackupClientType`
:param type: The type of client i.e. (FA.Linux, MySQL, etc.)
:type type: ``str``
:param is_file_system: The name of the iRule
:type is_file_system: ``bool``
:param description: Description of the client
:type description: ``str``
"""
self.type = type
self.is_file_system = is_file_system
self.description = description
def __repr__(self):
return ("<DimensionDataBackupClientType: type=%s>") % (self.type)
class DimensionDataBackupStoragePolicy:
"""
A representation of a storage policy
"""
def __init__(self, name, retention_period, secondary_location):
"""
Initialize an instance of :class:`DimensionDataBackupStoragePolicy`
:param name: The name of the storage policy i.e. 14 Day Storage Policy
:type name: ``str``
:param retention_period: How long to keep the backup in days
:type retention_period: ``int``
:param secondary_location: The secondary location i.e. Primary
:type secondary_location: ``str``
"""
self.name = name
self.retention_period = retention_period
self.secondary_location = secondary_location
def __repr__(self):
return ("<DimensionDataBackupStoragePolicy: name=%s>") % (self.name)
class DimensionDataBackupSchedulePolicy:
"""
A representation of a schedule policy
"""
def __init__(self, name, description):
"""
Initialize an instance of :class:`DimensionDataBackupSchedulePolicy`
:param name: The name of the policy i.e 12AM - 6AM
:type name: ``str``
:param description: Short summary of the details of the policy
:type description: ``str``
"""
self.name = name
self.description = description
def __repr__(self):
return ("<DimensionDataBackupSchedulePolicy: name=%s>") % (self.name)
class DimensionDataTag:
"""
A representation of a Tag in Dimension Data
A Tag first must have a Tag Key, then an asset is tag with
a key and an option value. Tags can be queried later to filter assets
and also show up on usage report if so desired.
"""
def __init__(self, asset_type, asset_id, asset_name, datacenter, key, value):
"""
Initialize an instance of :class:`DimensionDataTag`
:param asset_type: The type of asset. Current asset types:
SERVER, VLAN, NETWORK_DOMAIN, CUSTOMER_IMAGE,
PUBLIC_IP_BLOCK, ACCOUNT
:type asset_type: ``str``
:param asset_id: The GUID of the asset that is tagged
:type asset_id: ``str``
:param asset_name: The name of the asset that is tagged
:type asset_name: ``str``
:param datacenter: The short datacenter name of the tagged asset
:type datacenter: ``str``
:param key: The tagged key
:type key: :class:`DimensionDataTagKey`
:param value: The tagged value
:type value: ``None`` or ``str``
"""
self.asset_type = asset_type
self.asset_id = asset_id
self.asset_name = asset_name
self.datacenter = datacenter
self.key = key
self.value = value
def __repr__(self):
return ("<DimensionDataTag: asset_name=%s, tag_name=%s, value=%s>") % (
self.asset_name,
self.key.name,
self.value,
)
class DimensionDataTagKey:
"""
A representation of a Tag Key in Dimension Data
A tag key is required to tag an asset
"""
def __init__(self, id, name, description, value_required, display_on_report):
"""
Initialize an instance of :class:`DimensionDataTagKey`
:param id: GUID of the tag key
:type id: ``str``
:param name: Name of the tag key
:type name: ``str``
:param description: Description of the tag key
:type description: ``str``
:param value_required: If a value is required for this tag key
:type value_required: ``bool``
:param display_on_report: If this tag key should be displayed on
usage reports
:type display_on_report: ``bool``
"""
self.id = id
self.name = name
self.description = description
self.value_required = value_required
self.display_on_report = display_on_report
def __repr__(self):
return ("<DimensionDataTagKey: name=%s>") % (self.name)
class DimensionDataIpAddressList:
"""
DimensionData IP Address list
"""
def __init__(
self,
id,
name,
description,
ip_version,
ip_address_collection,
state,
create_time,
child_ip_address_lists=None,
):
""""
Initialize an instance of :class:`DimensionDataIpAddressList`
:param id: GUID of the IP Address List key
:type id: ``str``
:param name: Name of the IP Address List
:type name: ``str``
:param description: Description of the IP Address List
:type description: ``str``
:param ip_version: IP version. E.g. IPV4, IPV6
:type ip_version: ``str``
:param ip_address_collection: Collection of DimensionDataIpAddress
:type ip_address_collection: ``List``
:param state: IP Address list state
:type state: ``str``
:param create_time: IP Address List created time
:type create_time: ``date time``
:param child_ip_address_lists: List of IP address list to be included
:type child_ip_address_lists: List \
of :class:'DimensionDataIpAddressList'
"""
self.id = id
self.name = name
self.description = description
self.ip_version = ip_version
self.ip_address_collection = ip_address_collection
self.state = state
self.create_time = create_time
self.child_ip_address_lists = child_ip_address_lists
def __repr__(self):
return (
"<DimensionDataIpAddressList: id=%s, name=%s, description=%s, "
"ip_version=%s, ip_address_collection=%s, state=%s, "
"create_time=%s, child_ip_address_lists=%s>"
% (
self.id,
self.name,
self.description,
self.ip_version,
self.ip_address_collection,
self.state,
self.create_time,
self.child_ip_address_lists,
)
)
class DimensionDataChildIpAddressList:
"""
DimensionData Child IP Address list
"""
def __init__(self, id, name):
""" "
Initialize an instance of :class:`DimensionDataChildIpAddressList`
:param id: GUID of the IP Address List key
:type id: ``str``
:param name: Name of the IP Address List
:type name: ``str``
"""
self.id = id
self.name = name
def __repr__(self):
return "<DimensionDataChildIpAddressList: id={}, name={}>".format(
self.id,
self.name,
)
class DimensionDataIpAddress:
"""
A representation of IP Address in Dimension Data
"""
def __init__(self, begin, end=None, prefix_size=None):
"""
Initialize an instance of :class:`DimensionDataIpAddress`
:param begin: IP Address Begin
:type begin: ``str``
:param end: IP Address end
:type end: ``str``
:param prefixSize: IP Address prefix size
:type prefixSize: ``int``
"""
self.begin = begin
self.end = end
self.prefix_size = prefix_size
def __repr__(self):
return "<DimensionDataIpAddress: begin={}, end={}, prefix_size={}>".format(
self.begin,
self.end,
self.prefix_size,
)
class DimensionDataPortList:
"""
DimensionData Port list
"""
def __init__(
self,
id,
name,
description,
port_collection,
child_portlist_list,
state,
create_time,
):
""" "
Initialize an instance of :class:`DimensionDataPortList`
:param id: GUID of the Port List key
:type id: ``str``
:param name: Name of the Port List
:type name: ``str``
:param description: Description of the Port List
:type description: ``str``
:param port_collection: Collection of DimensionDataPort
:type port_collection: ``List``
:param child_portlist_list: Collection of DimensionDataChildPort
:type child_portlist_list: ``List``
:param state: Port list state
:type state: ``str``
:param create_time: Port List created time
:type create_time: ``date time``
"""
self.id = id
self.name = name
self.description = description
self.port_collection = port_collection
self.child_portlist_list = child_portlist_list
self.state = state
self.create_time = create_time
def __repr__(self):
return (
"<DimensionDataPortList: id=%s, name=%s, description=%s, "
"port_collection=%s, child_portlist_list=%s, state=%s, "
"create_time=%s>"
% (
self.id,
self.name,
self.description,
self.port_collection,
self.child_portlist_list,
self.state,
self.create_time,
)
)
class DimensionDataChildPortList:
"""
DimensionData Child Port list
"""
def __init__(self, id, name):
""" "
Initialize an instance of :class:`DimensionDataChildIpAddressList`
:param id: GUID of the child port list key
:type id: ``str``
:param name: Name of the child port List
:type name: ``str``
"""
self.id = id
self.name = name
def __repr__(self):
return "<DimensionDataChildPortList: id={}, name={}>".format(self.id, self.name)
class DimensionDataPort:
"""
A representation of Port in Dimension Data
"""
def __init__(self, begin, end=None):
"""
Initialize an instance of :class:`DimensionDataPort`
:param begin: Port Number Begin
:type begin: ``str``
:param end: Port Number end
:type end: ``str``
"""
self.begin = begin
self.end = end
def __repr__(self):
return "<DimensionDataPort: begin={}, end={}>".format(self.begin, self.end)
class DimensionDataNic:
"""
A representation of Network Adapter in Dimension Data
"""
def __init__(self, private_ip_v4=None, vlan=None, network_adapter_name=None):
"""
Initialize an instance of :class:`DimensionDataNic`
:param private_ip_v4: IPv4
:type private_ip_v4: ``str``
:param vlan: Network VLAN
:type vlan: class: DimensionDataVlan or ``str``
:param network_adapter_name: Network Adapter Name
:type network_adapter_name: ``str``
"""
self.private_ip_v4 = private_ip_v4
self.vlan = vlan
self.network_adapter_name = network_adapter_name
def __repr__(self):
return "<DimensionDataNic: private_ip_v4=%s, vlan=%s," "network_adapter_name=%s>" % (
self.private_ip_v4,
self.vlan,
self.network_adapter_name,
)