File: //opt/saltstack/salt/lib/python3.10/site-packages/libcloud/loadbalancer/drivers/dimensiondata.py
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance withv
# 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.
from libcloud.utils.py3 import ET
from libcloud.utils.xml import findall, findtext, fixxpath
from libcloud.utils.misc import reverse_dict
from libcloud.loadbalancer.base import Driver, Member, Algorithm, LoadBalancer
from libcloud.loadbalancer.types import State, Provider
from libcloud.common.dimensiondata import (
TYPES_URN,
API_ENDPOINTS,
DEFAULT_REGION,
DimensionDataPool,
DimensionDataVIPNode,
DimensionDataConnection,
DimensionDataPoolMember,
DimensionDataDefaultiRule,
DimensionDataVirtualListener,
DimensionDataPersistenceProfile,
DimensionDataDefaultHealthMonitor,
DimensionDataVirtualListenerCompatibility,
)
class DimensionDataLBDriver(Driver):
"""
DimensionData node driver.
"""
selected_region = None
connectionCls = DimensionDataConnection
name = "Dimension Data Load Balancer"
website = "https://cloud.dimensiondata.com/"
type = Provider.DIMENSIONDATA
api_version = 1.0
network_domain_id = None
_VALUE_TO_ALGORITHM_MAP = {
"ROUND_ROBIN": Algorithm.ROUND_ROBIN,
"LEAST_CONNECTIONS": Algorithm.LEAST_CONNECTIONS,
"SHORTEST_RESPONSE": Algorithm.SHORTEST_RESPONSE,
"PERSISTENT_IP": Algorithm.PERSISTENT_IP,
}
_ALGORITHM_TO_VALUE_MAP = reverse_dict(_VALUE_TO_ALGORITHM_MAP)
_VALUE_TO_STATE_MAP = {
"NORMAL": State.RUNNING,
"PENDING_ADD": State.PENDING,
"PENDING_CHANGE": State.PENDING,
"PENDING_DELETE": State.PENDING,
"FAILED_ADD": State.ERROR,
"FAILED_CHANGE": State.ERROR,
"FAILED_DELETE": State.ERROR,
"REQUIRES_SUPPORT": State.ERROR,
}
def __init__(
self,
key,
secret=None,
secure=True,
host=None,
port=None,
api_version=None,
region=DEFAULT_REGION,
**kwargs,
):
if region not in API_ENDPOINTS and host is None:
raise ValueError("Invalid region: %s, no host specified" % (region))
if region is not None:
self.selected_region = API_ENDPOINTS[region]
super().__init__(
key=key,
secret=secret,
secure=secure,
host=host,
port=port,
api_version=api_version,
region=region,
**kwargs,
)
def _ex_connection_class_kwargs(self):
"""
Add the region to the kwargs before the connection is instantiated
"""
kwargs = super()._ex_connection_class_kwargs()
kwargs["region"] = self.selected_region
return kwargs
def create_balancer(
self,
name,
port=None,
protocol=None,
algorithm=None,
members=None,
ex_listener_ip_address=None,
):
"""
Create a new load balancer instance
:param name: Name of the new load balancer (required)
:type name: ``str``
:param port: An integer in the range of 1-65535. If not supplied,
it will be taken to mean 'Any Port'
:type port: ``int``
:param protocol: Loadbalancer protocol, defaults to http.
:type protocol: ``str``
:param members: list of Members to attach to balancer (optional)
:type members: ``list`` of :class:`Member`
:param algorithm: Load balancing algorithm, defaults to ROUND_ROBIN.
:type algorithm: :class:`.Algorithm`
:param ex_listener_ip_address: Must be a valid IPv4 in dot-decimal
notation (x.x.x.x).
:type ex_listener_ip_address: ``str``
:rtype: :class:`LoadBalancer`
"""
network_domain_id = self.network_domain_id
if protocol is None:
protocol = "http"
if algorithm is None:
algorithm = Algorithm.ROUND_ROBIN
# Create a pool first
pool = self.ex_create_pool(
network_domain_id=network_domain_id,
name=name,
ex_description=None,
balancer_method=self._ALGORITHM_TO_VALUE_MAP[algorithm],
)
# Attach the members to the pool as nodes
if members is not None:
for member in members:
node = self.ex_create_node(
network_domain_id=network_domain_id,
name=member.ip,
ip=member.ip,
ex_description=None,
)
self.ex_create_pool_member(pool=pool, node=node, port=port)
# Create the virtual listener (balancer)
listener = self.ex_create_virtual_listener(
network_domain_id=network_domain_id,
name=name,
ex_description=name,
port=port,
pool=pool,
listener_ip_address=ex_listener_ip_address,
)
return LoadBalancer(
id=listener.id,
name=listener.name,
state=State.RUNNING,
ip=listener.ip,
port=port,
driver=self,
extra={
"pool_id": pool.id,
"network_domain_id": network_domain_id,
"listener_ip_address": ex_listener_ip_address,
},
)
def list_balancers(self, ex_network_domain_id=None):
"""
List all loadbalancers inside a geography or in given network.
In Dimension Data terminology these are known as virtual listeners
:param ex_network_domain_id: UUID of Network Domain
if not None returns only balancers in the given network
if None then returns all pools for the organization
:type ex_network_domain_id: ``str``
:rtype: ``list`` of :class:`LoadBalancer`
"""
params = None
if ex_network_domain_id is not None:
params = {"networkDomainId": ex_network_domain_id}
return self._to_balancers(
self.connection.request_with_orgId_api_2(
"networkDomainVip/virtualListener", params=params
).object
)
def get_balancer(self, balancer_id):
"""
Return a :class:`LoadBalancer` object.
:param balancer_id: id of a load balancer you want to fetch
:type balancer_id: ``str``
:rtype: :class:`LoadBalancer`
"""
bal = self.connection.request_with_orgId_api_2(
"networkDomainVip/virtualListener/%s" % balancer_id
).object
return self._to_balancer(bal)
def list_protocols(self):
"""
Return a list of supported protocols.
Since all protocols are support by Dimension Data, this is a list
of common protocols.
:rtype: ``list`` of ``str``
"""
return ["http", "https", "tcp", "udp", "ftp", "smtp"]
def balancer_list_members(self, balancer):
"""
Return list of members attached to balancer.
In Dimension Data terminology these are the members of the pools
within a virtual listener.
:param balancer: LoadBalancer which should be used
:type balancer: :class:`LoadBalancer`
:rtype: ``list`` of :class:`Member`
"""
pool_members = self.ex_get_pool_members(balancer.extra["pool_id"])
members = []
for pool_member in pool_members:
members.append(
Member(
id=pool_member.id,
ip=pool_member.ip,
port=pool_member.port,
balancer=balancer,
extra=None,
)
)
return members
def balancer_attach_member(self, balancer, member):
"""
Attach a member to balancer
:param balancer: LoadBalancer which should be used
:type balancer: :class:`LoadBalancer`
:param member: Member to join to the balancer
:type member: :class:`Member`
:return: Member after joining the balancer.
:rtype: :class:`Member`
"""
node = self.ex_create_node(
network_domain_id=balancer.extra["network_domain_id"],
name="Member." + member.ip,
ip=member.ip,
ex_description="",
)
if node is False:
return False
pool = self.ex_get_pool(balancer.extra["pool_id"])
pool_member = self.ex_create_pool_member(pool=pool, node=node, port=member.port)
member.id = pool_member.id
return member
def balancer_detach_member(self, balancer, member):
"""
Detach member from balancer
:param balancer: LoadBalancer which should be used
:type balancer: :class:`LoadBalancer`
:param member: Member which should be used
:type member: :class:`Member`
:return: ``True`` if member detach was successful, otherwise ``False``.
:rtype: ``bool``
"""
create_pool_m = ET.Element("removePoolMember", {"xmlns": TYPES_URN, "id": member.id})
result = self.connection.request_with_orgId_api_2(
"networkDomainVip/removePoolMember",
method="POST",
data=ET.tostring(create_pool_m),
).object
response_code = findtext(result, "responseCode", TYPES_URN)
return response_code in ["IN_PROGRESS", "OK"]
def destroy_balancer(self, balancer):
"""
Destroy a load balancer (virtual listener)
:param balancer: LoadBalancer which should be used
:type balancer: :class:`LoadBalancer`
:return: ``True`` if the destroy was successful, otherwise ``False``.
:rtype: ``bool``
"""
delete_listener = ET.Element(
"deleteVirtualListener", {"xmlns": TYPES_URN, "id": balancer.id}
)
result = self.connection.request_with_orgId_api_2(
"networkDomainVip/deleteVirtualListener",
method="POST",
data=ET.tostring(delete_listener),
).object
response_code = findtext(result, "responseCode", TYPES_URN)
return response_code in ["IN_PROGRESS", "OK"]
def ex_set_current_network_domain(self, network_domain_id):
"""
Set the network domain (part of the network) of the driver
:param network_domain_id: ID of the pool (required)
:type network_domain_id: ``str``
"""
self.network_domain_id = network_domain_id
def ex_get_current_network_domain(self):
"""
Get the current network domain ID of the driver.
:return: ID of the network domain
:rtype: ``str``
"""
return self.network_domain_id
def ex_create_pool_member(self, pool, node, port=None):
"""
Create a new member in an existing pool from an existing node
:param pool: Instance of ``DimensionDataPool`` (required)
:type pool: ``DimensionDataPool``
:param node: Instance of ``DimensionDataVIPNode`` (required)
:type node: ``DimensionDataVIPNode``
:param port: Port the the service will listen on
:type port: ``str``
:return: The node member, instance of ``DimensionDataPoolMember``
:rtype: ``DimensionDataPoolMember``
"""
create_pool_m = ET.Element("addPoolMember", {"xmlns": TYPES_URN})
ET.SubElement(create_pool_m, "poolId").text = pool.id
ET.SubElement(create_pool_m, "nodeId").text = node.id
if port is not None:
ET.SubElement(create_pool_m, "port").text = str(port)
ET.SubElement(create_pool_m, "status").text = "ENABLED"
response = self.connection.request_with_orgId_api_2(
"networkDomainVip/addPoolMember",
method="POST",
data=ET.tostring(create_pool_m),
).object
member_id = None
node_name = None
for info in findall(response, "info", TYPES_URN):
if info.get("name") == "poolMemberId":
member_id = info.get("value")
if info.get("name") == "nodeName":
node_name = info.get("value")
return DimensionDataPoolMember(
id=member_id,
name=node_name,
status=State.RUNNING,
ip=node.ip,
port=port,
node_id=node.id,
)
def ex_create_node(
self,
network_domain_id,
name,
ip,
ex_description,
connection_limit=25000,
connection_rate_limit=2000,
):
"""
Create a new node
:param network_domain_id: Network Domain ID (required)
:type name: ``str``
:param name: name of the node (required)
:type name: ``str``
:param ip: IPv4 address of the node (required)
:type ip: ``str``
:param ex_description: Description of the node (required)
:type ex_description: ``str``
:param connection_limit: Maximum number
of concurrent connections per sec
:type connection_limit: ``int``
:param connection_rate_limit: Maximum number of concurrent sessions
:type connection_rate_limit: ``int``
:return: Instance of ``DimensionDataVIPNode``
:rtype: ``DimensionDataVIPNode``
"""
create_node_elm = ET.Element("createNode", {"xmlns": TYPES_URN})
ET.SubElement(create_node_elm, "networkDomainId").text = network_domain_id
ET.SubElement(create_node_elm, "name").text = name
ET.SubElement(create_node_elm, "description").text = str(ex_description)
ET.SubElement(create_node_elm, "ipv4Address").text = ip
ET.SubElement(create_node_elm, "status").text = "ENABLED"
ET.SubElement(create_node_elm, "connectionLimit").text = str(connection_limit)
ET.SubElement(create_node_elm, "connectionRateLimit").text = str(connection_rate_limit)
response = self.connection.request_with_orgId_api_2(
action="networkDomainVip/createNode",
method="POST",
data=ET.tostring(create_node_elm),
).object
node_id = None
node_name = None
for info in findall(response, "info", TYPES_URN):
if info.get("name") == "nodeId":
node_id = info.get("value")
if info.get("name") == "name":
node_name = info.get("value")
return DimensionDataVIPNode(id=node_id, name=node_name, status=State.RUNNING, ip=ip)
def ex_update_node(self, node):
"""
Update the properties of a node
:param pool: The instance of ``DimensionDataNode`` to update
:type pool: ``DimensionDataNode``
:return: The instance of ``DimensionDataNode``
:rtype: ``DimensionDataNode``
"""
create_node_elm = ET.Element("editNode", {"xmlns": TYPES_URN})
ET.SubElement(create_node_elm, "connectionLimit").text = str(node.connection_limit)
ET.SubElement(create_node_elm, "connectionRateLimit").text = str(node.connection_rate_limit)
self.connection.request_with_orgId_api_2(
action="networkDomainVip/createNode",
method="POST",
data=ET.tostring(create_node_elm),
).object
return node
def ex_set_node_state(self, node, enabled):
"""
Change the state of a node (enable/disable)
:param pool: The instance of ``DimensionDataNode`` to update
:type pool: ``DimensionDataNode``
:param enabled: The target state of the node
:type enabled: ``bool``
:return: The instance of ``DimensionDataNode``
:rtype: ``DimensionDataNode``
"""
create_node_elm = ET.Element("editNode", {"xmlns": TYPES_URN})
ET.SubElement(create_node_elm, "status").text = "ENABLED" if enabled is True else "DISABLED"
self.connection.request_with_orgId_api_2(
action="networkDomainVip/editNode",
method="POST",
data=ET.tostring(create_node_elm),
).object
return node
def ex_create_pool(
self,
network_domain_id,
name,
balancer_method,
ex_description,
health_monitors=None,
service_down_action="NONE",
slow_ramp_time=30,
):
"""
Create a new pool
:param network_domain_id: Network Domain ID (required)
:type name: ``str``
:param name: name of the node (required)
:type name: ``str``
:param balancer_method: The load balancer algorithm (required)
:type balancer_method: ``str``
:param ex_description: Description of the node (required)
:type ex_description: ``str``
:param health_monitors: A list of health monitors to use for the pool.
:type health_monitors: ``list`` of
:class:`DimensionDataDefaultHealthMonitor`
:param service_down_action: What to do when node
is unavailable NONE, DROP or RESELECT
:type service_down_action: ``str``
:param slow_ramp_time: Number of seconds to stagger ramp up of nodes
:type slow_ramp_time: ``int``
:return: Instance of ``DimensionDataPool``
:rtype: ``DimensionDataPool``
"""
# Names cannot contain spaces.
name.replace(" ", "_")
create_node_elm = ET.Element("createPool", {"xmlns": TYPES_URN})
ET.SubElement(create_node_elm, "networkDomainId").text = network_domain_id
ET.SubElement(create_node_elm, "name").text = name
ET.SubElement(create_node_elm, "description").text = str(ex_description)
ET.SubElement(create_node_elm, "loadBalanceMethod").text = str(balancer_method)
if health_monitors is not None:
for monitor in health_monitors:
ET.SubElement(create_node_elm, "healthMonitorId").text = str(monitor.id)
ET.SubElement(create_node_elm, "serviceDownAction").text = service_down_action
ET.SubElement(create_node_elm, "slowRampTime").text = str(slow_ramp_time)
response = self.connection.request_with_orgId_api_2(
action="networkDomainVip/createPool",
method="POST",
data=ET.tostring(create_node_elm),
).object
pool_id = None
for info in findall(response, "info", TYPES_URN):
if info.get("name") == "poolId":
pool_id = info.get("value")
return DimensionDataPool(
id=pool_id,
name=name,
description=ex_description,
status=State.RUNNING,
load_balance_method=str(balancer_method),
health_monitor_id=None,
service_down_action=service_down_action,
slow_ramp_time=str(slow_ramp_time),
)
def ex_create_virtual_listener(
self,
network_domain_id,
name,
ex_description,
port=None,
pool=None,
listener_ip_address=None,
persistence_profile=None,
fallback_persistence_profile=None,
irule=None,
protocol="TCP",
connection_limit=25000,
connection_rate_limit=2000,
source_port_preservation="PRESERVE",
):
"""
Create a new virtual listener (load balancer)
:param network_domain_id: Network Domain ID (required)
:type name: ``str``
:param name: name of the listener (required)
:type name: ``str``
:param ex_description: Description of the node (required)
:type ex_description: ``str``
:param port: An integer in the range of 1-65535. If not supplied,
it will be taken to mean 'Any Port'
:type port: ``int``
:param pool: The pool to use for the listener
:type pool: :class:`DimensionDataPool`
:param listener_ip_address: The IPv4 Address of the virtual listener
:type listener_ip_address: ``str``
:param persistence_profile: Persistence profile
:type persistence_profile: :class:`DimensionDataPersistenceProfile`
:param fallback_persistence_profile: Fallback persistence profile
:type fallback_persistence_profile:
:class:`DimensionDataPersistenceProfile`
:param irule: The iRule to apply
:type irule: :class:`DimensionDataDefaultiRule`
:param protocol: For STANDARD type, ANY, TCP or UDP
for PERFORMANCE_LAYER_4 choice of ANY, TCP, UDP, HTTP
:type protocol: ``str``
:param connection_limit: Maximum number
of concurrent connections per sec
:type connection_limit: ``int``
:param connection_rate_limit: Maximum number of concurrent sessions
:type connection_rate_limit: ``int``
:param source_port_preservation: Choice of PRESERVE,
PRESERVE_STRICT or CHANGE
:type source_port_preservation: ``str``
:return: Instance of the listener
:rtype: ``DimensionDataVirtualListener``
"""
if (port == 80) or (port == 443):
listener_type = "PERFORMANCE_LAYER_4"
else:
listener_type = "STANDARD"
create_node_elm = ET.Element("createVirtualListener", {"xmlns": TYPES_URN})
ET.SubElement(create_node_elm, "networkDomainId").text = network_domain_id
ET.SubElement(create_node_elm, "name").text = name
ET.SubElement(create_node_elm, "description").text = str(ex_description)
ET.SubElement(create_node_elm, "type").text = listener_type
ET.SubElement(create_node_elm, "protocol").text = protocol
if listener_ip_address is not None:
ET.SubElement(create_node_elm, "listenerIpAddress").text = str(listener_ip_address)
if port is not None:
ET.SubElement(create_node_elm, "port").text = str(port)
ET.SubElement(create_node_elm, "enabled").text = "true"
ET.SubElement(create_node_elm, "connectionLimit").text = str(connection_limit)
ET.SubElement(create_node_elm, "connectionRateLimit").text = str(connection_rate_limit)
ET.SubElement(create_node_elm, "sourcePortPreservation").text = source_port_preservation
if pool is not None:
ET.SubElement(create_node_elm, "poolId").text = pool.id
if persistence_profile is not None:
ET.SubElement(create_node_elm, "persistenceProfileId").text = persistence_profile.id
if fallback_persistence_profile is not None:
ET.SubElement(create_node_elm, "fallbackPersistenceProfileId").text = (
fallback_persistence_profile.id
)
if irule is not None:
ET.SubElement(create_node_elm, "iruleId").text = irule.id
response = self.connection.request_with_orgId_api_2(
action="networkDomainVip/createVirtualListener",
method="POST",
data=ET.tostring(create_node_elm),
).object
virtual_listener_id = None
virtual_listener_ip = None
for info in findall(response, "info", TYPES_URN):
if info.get("name") == "virtualListenerId":
virtual_listener_id = info.get("value")
if info.get("name") == "listenerIpAddress":
virtual_listener_ip = info.get("value")
return DimensionDataVirtualListener(
id=virtual_listener_id,
name=name,
ip=virtual_listener_ip,
status=State.RUNNING,
)
def ex_get_pools(self, ex_network_domain_id=None):
"""
Get all of the pools inside the current geography or
in given network.
:param ex_network_domain_id: UUID of Network Domain
if not None returns only balancers in the given network
if None then returns all pools for the organization
:type ex_network_domain_id: ``str``
:return: Returns a ``list`` of type ``DimensionDataPool``
:rtype: ``list`` of ``DimensionDataPool``
"""
params = None
if ex_network_domain_id is not None:
params = {"networkDomainId": ex_network_domain_id}
pools = self.connection.request_with_orgId_api_2(
"networkDomainVip/pool", params=params
).object
return self._to_pools(pools)
def ex_get_pool(self, pool_id):
"""
Get a specific pool inside the current geography
:param pool_id: The identifier of the pool
:type pool_id: ``str``
:return: Returns an instance of ``DimensionDataPool``
:rtype: ``DimensionDataPool``
"""
pool = self.connection.request_with_orgId_api_2("networkDomainVip/pool/%s" % pool_id).object
return self._to_pool(pool)
def ex_update_pool(self, pool):
"""
Update the properties of an existing pool
only method, serviceDownAction and slowRampTime are updated
:param pool: The instance of ``DimensionDataPool`` to update
:type pool: ``DimensionDataPool``
:return: ``True`` for success, ``False`` for failure
:rtype: ``bool``
"""
create_node_elm = ET.Element("editPool", {"xmlns": TYPES_URN})
ET.SubElement(create_node_elm, "loadBalanceMethod").text = str(pool.load_balance_method)
ET.SubElement(create_node_elm, "serviceDownAction").text = pool.service_down_action
ET.SubElement(create_node_elm, "slowRampTime").text = str(pool.slow_ramp_time)
response = self.connection.request_with_orgId_api_2(
action="networkDomainVip/editPool",
method="POST",
data=ET.tostring(create_node_elm),
).object
response_code = findtext(response, "responseCode", TYPES_URN)
return response_code in ["IN_PROGRESS", "OK"]
def ex_destroy_pool(self, pool):
"""
Destroy an existing pool
:param pool: The instance of ``DimensionDataPool`` to destroy
:type pool: ``DimensionDataPool``
:return: ``True`` for success, ``False`` for failure
:rtype: ``bool``
"""
destroy_request = ET.Element("deletePool", {"xmlns": TYPES_URN, "id": pool.id})
result = self.connection.request_with_orgId_api_2(
action="networkDomainVip/deletePool",
method="POST",
data=ET.tostring(destroy_request),
).object
response_code = findtext(result, "responseCode", TYPES_URN)
return response_code in ["IN_PROGRESS", "OK"]
def ex_get_pool_members(self, pool_id):
"""
Get the members of a pool
:param pool: The instance of a pool
:type pool: ``DimensionDataPool``
:return: Returns an ``list`` of ``DimensionDataPoolMember``
:rtype: ``list`` of ``DimensionDataPoolMember``
"""
members = self.connection.request_with_orgId_api_2(
"networkDomainVip/poolMember?poolId=%s" % pool_id
).object
return self._to_members(members)
def ex_get_pool_member(self, pool_member_id):
"""
Get a specific member of a pool
:param pool: The id of a pool member
:type pool: ``str``
:return: Returns an instance of ``DimensionDataPoolMember``
:rtype: ``DimensionDataPoolMember``
"""
member = self.connection.request_with_orgId_api_2(
"networkDomainVip/poolMember/%s" % pool_member_id
).object
return self._to_member(member)
def ex_set_pool_member_state(self, member, enabled=True):
request = ET.Element("editPoolMember", {"xmlns": TYPES_URN, "id": member.id})
state = "ENABLED" if enabled is True else "DISABLED"
ET.SubElement(request, "status").text = state
result = self.connection.request_with_orgId_api_2(
action="networkDomainVip/editPoolMember",
method="POST",
data=ET.tostring(request),
).object
response_code = findtext(result, "responseCode", TYPES_URN)
return response_code in ["IN_PROGRESS", "OK"]
def ex_destroy_pool_member(self, member, destroy_node=False):
"""
Destroy a specific member of a pool
:param pool: The instance of a pool member
:type pool: ``DimensionDataPoolMember``
:param destroy_node: Also destroy the associated node
:type destroy_node: ``bool``
:return: ``True`` for success, ``False`` for failure
:rtype: ``bool``
"""
# remove the pool member
destroy_request = ET.Element("removePoolMember", {"xmlns": TYPES_URN, "id": member.id})
result = self.connection.request_with_orgId_api_2(
action="networkDomainVip/removePoolMember",
method="POST",
data=ET.tostring(destroy_request),
).object
if member.node_id is not None and destroy_node is True:
return self.ex_destroy_node(member.node_id)
else:
response_code = findtext(result, "responseCode", TYPES_URN)
return response_code in ["IN_PROGRESS", "OK"]
def ex_get_nodes(self, ex_network_domain_id=None):
"""
Get the nodes within this geography or in given network.
:param ex_network_domain_id: UUID of Network Domain
if not None returns only balancers in the given network
if None then returns all pools for the organization
:type ex_network_domain_id: ``str``
:return: Returns an ``list`` of ``DimensionDataVIPNode``
:rtype: ``list`` of ``DimensionDataVIPNode``
"""
params = None
if ex_network_domain_id is not None:
params = {"networkDomainId": ex_network_domain_id}
nodes = self.connection.request_with_orgId_api_2(
"networkDomainVip/node", params=params
).object
return self._to_nodes(nodes)
def ex_get_node(self, node_id):
"""
Get the node specified by node_id
:return: Returns an instance of ``DimensionDataVIPNode``
:rtype: Instance of ``DimensionDataVIPNode``
"""
nodes = self.connection.request_with_orgId_api_2(
"networkDomainVip/node/%s" % node_id
).object
return self._to_node(nodes)
def ex_destroy_node(self, node_id):
"""
Destroy a specific node
:param node_id: The ID of of a ``DimensionDataVIPNode``
:type node_id: ``str``
:return: ``True`` for success, ``False`` for failure
:rtype: ``bool``
"""
# Destroy the node
destroy_request = ET.Element("deleteNode", {"xmlns": TYPES_URN, "id": node_id})
result = self.connection.request_with_orgId_api_2(
action="networkDomainVip/deleteNode",
method="POST",
data=ET.tostring(destroy_request),
).object
response_code = findtext(result, "responseCode", TYPES_URN)
return response_code in ["IN_PROGRESS", "OK"]
def ex_wait_for_state(self, state, func, poll_interval=2, timeout=60, *args, **kwargs):
"""
Wait for the function which returns a instance
with field status 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
: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 self.connection.wait_for_state(state, func, poll_interval, timeout, *args, **kwargs)
def ex_get_default_health_monitors(self, network_domain_id):
"""
Get the default health monitors available for a network domain
:param network_domain_id: The ID of of a ``DimensionDataNetworkDomain``
:type network_domain_id: ``str``
:rtype: `list` of :class:`DimensionDataDefaultHealthMonitor`
"""
result = self.connection.request_with_orgId_api_2(
action="networkDomainVip/defaultHealthMonitor",
params={"networkDomainId": network_domain_id},
method="GET",
).object
return self._to_health_monitors(result)
def ex_get_default_persistence_profiles(self, network_domain_id):
"""
Get the default persistence profiles available for a network domain
:param network_domain_id: The ID of of a ``DimensionDataNetworkDomain``
:type network_domain_id: ``str``
:rtype: `list` of :class:`DimensionDataPersistenceProfile`
"""
result = self.connection.request_with_orgId_api_2(
action="networkDomainVip/defaultPersistenceProfile",
params={"networkDomainId": network_domain_id},
method="GET",
).object
return self._to_persistence_profiles(result)
def ex_get_default_irules(self, network_domain_id):
"""
Get the default iRules available for a network domain
:param network_domain_id: The ID of of a ``DimensionDataNetworkDomain``
:type network_domain_id: ``str``
:rtype: `list` of :class:`DimensionDataDefaultiRule`
"""
result = self.connection.request_with_orgId_api_2(
action="networkDomainVip/defaultIrule",
params={"networkDomainId": network_domain_id},
method="GET",
).object
return self._to_irules(result)
def _to_irules(self, object):
irules = []
matches = object.findall(fixxpath("defaultIrule", TYPES_URN))
for element in matches:
irules.append(self._to_irule(element))
return irules
def _to_irule(self, element):
compatible = []
matches = element.findall(fixxpath("virtualListenerCompatibility", TYPES_URN))
for match_element in matches:
compatible.append(
DimensionDataVirtualListenerCompatibility(
type=match_element.get("type"),
protocol=match_element.get("protocol", None),
)
)
irule_element = element.find(fixxpath("irule", TYPES_URN))
return DimensionDataDefaultiRule(
id=irule_element.get("id"),
name=irule_element.get("name"),
compatible_listeners=compatible,
)
def _to_persistence_profiles(self, object):
profiles = []
matches = object.findall(fixxpath("defaultPersistenceProfile", TYPES_URN))
for element in matches:
profiles.append(self._to_persistence_profile(element))
return profiles
def _to_persistence_profile(self, element):
compatible = []
matches = element.findall(fixxpath("virtualListenerCompatibility", TYPES_URN))
for match_element in matches:
compatible.append(
DimensionDataVirtualListenerCompatibility(
type=match_element.get("type"),
protocol=match_element.get("protocol", None),
)
)
return DimensionDataPersistenceProfile(
id=element.get("id"),
fallback_compatible=bool(element.get("fallbackCompatible") == "true"),
name=findtext(element, "name", TYPES_URN),
compatible_listeners=compatible,
)
def _to_health_monitors(self, object):
monitors = []
matches = object.findall(fixxpath("defaultHealthMonitor", TYPES_URN))
for element in matches:
monitors.append(self._to_health_monitor(element))
return monitors
def _to_health_monitor(self, element):
return DimensionDataDefaultHealthMonitor(
id=element.get("id"),
name=findtext(element, "name", TYPES_URN),
node_compatible=bool(findtext(element, "nodeCompatible", TYPES_URN) == "true"),
pool_compatible=bool(findtext(element, "poolCompatible", TYPES_URN) == "true"),
)
def _to_nodes(self, object):
nodes = []
for element in object.findall(fixxpath("node", TYPES_URN)):
nodes.append(self._to_node(element))
return nodes
def _to_node(self, element):
ipaddress = findtext(element, "ipv4Address", TYPES_URN)
if ipaddress is None:
ipaddress = findtext(element, "ipv6Address", TYPES_URN)
name = findtext(element, "name", TYPES_URN)
node = DimensionDataVIPNode(
id=element.get("id"),
name=name,
status=self._VALUE_TO_STATE_MAP.get(
findtext(element, "state", TYPES_URN), State.UNKNOWN
),
connection_rate_limit=findtext(element, "connectionRateLimit", TYPES_URN),
connection_limit=findtext(element, "connectionLimit", TYPES_URN),
ip=ipaddress,
)
return node
def _to_balancers(self, object):
loadbalancers = []
for element in object.findall(fixxpath("virtualListener", TYPES_URN)):
loadbalancers.append(self._to_balancer(element))
return loadbalancers
def _to_balancer(self, element):
ipaddress = findtext(element, "listenerIpAddress", TYPES_URN)
name = findtext(element, "name", TYPES_URN)
port = findtext(element, "port", TYPES_URN)
extra = {}
pool_element = element.find(fixxpath("pool", TYPES_URN))
if pool_element is None:
extra["pool_id"] = None
else:
extra["pool_id"] = pool_element.get("id")
extra["network_domain_id"] = findtext(element, "networkDomainId", TYPES_URN)
balancer = LoadBalancer(
id=element.get("id"),
name=name,
state=self._VALUE_TO_STATE_MAP.get(
findtext(element, "state", TYPES_URN), State.UNKNOWN
),
ip=ipaddress,
port=port,
driver=self.connection.driver,
extra=extra,
)
return balancer
def _to_members(self, object):
members = []
for element in object.findall(fixxpath("poolMember", TYPES_URN)):
members.append(self._to_member(element))
return members
def _to_member(self, element):
port = findtext(element, "port", TYPES_URN)
if port is not None:
port = int(port)
pool_member = DimensionDataPoolMember(
id=element.get("id"),
name=element.find(fixxpath("node", TYPES_URN)).get("name"),
status=findtext(element, "state", TYPES_URN),
node_id=element.find(fixxpath("node", TYPES_URN)).get("id"),
ip=element.find(fixxpath("node", TYPES_URN)).get("ipAddress"),
port=port,
)
return pool_member
def _to_pools(self, object):
pools = []
for element in object.findall(fixxpath("pool", TYPES_URN)):
pools.append(self._to_pool(element))
return pools
def _to_pool(self, element):
pool = DimensionDataPool(
id=element.get("id"),
name=findtext(element, "name", TYPES_URN),
status=findtext(element, "state", TYPES_URN),
description=findtext(element, "description", TYPES_URN),
load_balance_method=findtext(element, "loadBalanceMethod", TYPES_URN),
health_monitor_id=findtext(element, "healthMonitorId", TYPES_URN),
service_down_action=findtext(element, "serviceDownAction", TYPES_URN),
slow_ramp_time=findtext(element, "slowRampTime", TYPES_URN),
)
return pool