File: //opt/saltstack/salt/lib/python3.10/site-packages/libcloud/loadbalancer/drivers/rackspace.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 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.
from datetime import datetime
from libcloud.utils.py3 import httplib
from libcloud.utils.misc import reverse_dict
from libcloud.common.base import JsonResponse, PollingConnection
from libcloud.common.types import LibcloudError
from libcloud.common.openstack import OpenStackDriverMixin
from libcloud.common.rackspace import AUTH_URL
from libcloud.loadbalancer.base import DEFAULT_ALGORITHM, Driver, Member, Algorithm, LoadBalancer
from libcloud.loadbalancer.types import State, MemberCondition
from libcloud.compute.drivers.rackspace import RackspaceConnection
try:
import simplejson as json
except ImportError:
import json
ENDPOINT_ARGS_MAP = {
"dfw": {
"service_type": "rax:load-balancer",
"name": "cloudLoadBalancers",
"region": "DFW",
},
"ord": {
"service_type": "rax:load-balancer",
"name": "cloudLoadBalancers",
"region": "ORD",
},
"iad": {
"service_type": "rax:load-balancer",
"name": "cloudLoadBalancers",
"region": "IAD",
},
"lon": {
"service_type": "rax:load-balancer",
"name": "cloudLoadBalancers",
"region": "LON",
},
"syd": {
"service_type": "rax:load-balancer",
"name": "cloudLoadBalancers",
"region": "SYD",
},
"hkg": {
"service_type": "rax:load-balancer",
"name": "cloudLoadBalancers",
"region": "HKG",
},
}
class RackspaceResponse(JsonResponse):
def parse_body(self):
if not self.body:
return None
return super().parse_body()
def success(self):
return 200 <= int(self.status) <= 299
class RackspaceHealthMonitor:
"""
:param type: type of load balancer. currently CONNECT (connection
monitoring), HTTP, HTTPS (connection and HTTP
monitoring) are supported.
:type type: ``str``
:param delay: minimum seconds to wait before executing the health
monitor. (Must be between 1 and 3600)
:type delay: ``int``
:param timeout: maximum seconds to wait when establishing a
connection before timing out. (Must be between 1
and 3600)
:type timeout: ``int``
:param attempts_before_deactivation: Number of monitor failures
before removing a node from
rotation. (Must be between 1
and 10)
:type attempts_before_deactivation: ``int``
"""
def __init__(self, type, delay, timeout, attempts_before_deactivation):
self.type = type
self.delay = delay
self.timeout = timeout
self.attempts_before_deactivation = attempts_before_deactivation
def __repr__(self):
return (
"<RackspaceHealthMonitor: type=%s, delay=%d, timeout=%d, "
"attempts_before_deactivation=%d>"
% (self.type, self.delay, self.timeout, self.attempts_before_deactivation)
)
def _to_dict(self):
return {
"type": self.type,
"delay": self.delay,
"timeout": self.timeout,
"attemptsBeforeDeactivation": self.attempts_before_deactivation,
}
class RackspaceHTTPHealthMonitor(RackspaceHealthMonitor):
"""
A HTTP health monitor adds extra features to a Rackspace health monitor.
:param path: the HTTP path to monitor.
:type path: ``str``
:param body_regex: Regular expression used to evaluate the body of
the HTTP response.
:type body_regex: ``str``
:param status_regex: Regular expression used to evaluate the HTTP
status code of the response.
:type status_regex: ``str``
"""
def __init__(
self,
type,
delay,
timeout,
attempts_before_deactivation,
path,
body_regex,
status_regex,
):
super().__init__(type, delay, timeout, attempts_before_deactivation)
self.path = path
self.body_regex = body_regex
self.status_regex = status_regex
def __repr__(self):
return (
"<RackspaceHTTPHealthMonitor: type=%s, delay=%d, timeout=%d, "
"attempts_before_deactivation=%d, path=%s, body_regex=%s, "
"status_regex=%s>"
% (
self.type,
self.delay,
self.timeout,
self.attempts_before_deactivation,
self.path,
self.body_regex,
self.status_regex,
)
)
def _to_dict(self):
super_dict = super()._to_dict()
super_dict["path"] = self.path
super_dict["statusRegex"] = self.status_regex
if self.body_regex:
super_dict["bodyRegex"] = self.body_regex
return super_dict
class RackspaceConnectionThrottle:
"""
:param min_connections: Minimum number of connections per IP address
before applying throttling.
:type min_connections: ``int``
:param max_connections: Maximum number of connections per IP address.
(Must be between 0 and 100000, 0 allows an
unlimited number of connections.)
:type max_connections: ``int``
:param max_connection_rate: Maximum number of connections allowed
from a single IP address within the
given rate_interval_seconds. (Must be
between 0 and 100000, 0 allows an
unlimited number of connections.)
:type max_connection_rate: ``int``
:param rate_interval_seconds: Interval at which the
max_connection_rate is enforced.
(Must be between 1 and 3600.)
:type rate_interval_seconds: ``int``
"""
def __init__(
self,
min_connections,
max_connections,
max_connection_rate,
rate_interval_seconds,
):
self.min_connections = min_connections
self.max_connections = max_connections
self.max_connection_rate = max_connection_rate
self.rate_interval_seconds = rate_interval_seconds
def __repr__(self):
return (
"<RackspaceConnectionThrottle: min_connections=%d, "
"max_connections=%d, max_connection_rate=%d, "
"rate_interval_seconds=%d>"
% (
self.min_connections,
self.max_connections,
self.max_connection_rate,
self.rate_interval_seconds,
)
)
def _to_dict(self):
return {
"maxConnections": self.max_connections,
"minConnections": self.min_connections,
"maxConnectionRate": self.max_connection_rate,
"rateInterval": self.rate_interval_seconds,
}
class RackspaceAccessRuleType:
ALLOW = 0
DENY = 1
_RULE_TYPE_STRING_MAP = {ALLOW: "ALLOW", DENY: "DENY"}
class RackspaceAccessRule:
"""
An access rule allows or denies traffic to a Load Balancer based on the
incoming IPs.
:param id: Unique identifier to refer to this rule by.
:type id: ``str``
:param rule_type: RackspaceAccessRuleType.ALLOW or
RackspaceAccessRuleType.DENY.
:type id: ``int``
:param address: IP address or cidr (can be IPv4 or IPv6).
:type address: ``str``
"""
def __init__(self, id=None, rule_type=None, address=None):
self.id = id
self.rule_type = rule_type
self.address = address
def _to_dict(self):
type_string = RackspaceAccessRuleType._RULE_TYPE_STRING_MAP[self.rule_type]
as_dict = {"type": type_string, "address": self.address}
if self.id is not None:
as_dict["id"] = self.id
return as_dict
class RackspaceConnection(RackspaceConnection, PollingConnection):
responseCls = RackspaceResponse
auth_url = AUTH_URL
poll_interval = 2
timeout = 80
cache_busting = True
def request(self, action, params=None, data="", headers=None, method="GET"):
if not headers:
headers = {}
if not params:
params = {}
if method in ("POST", "PUT"):
headers["Content-Type"] = "application/json"
return super().request(
action=action, params=params, data=data, method=method, headers=headers
)
def get_poll_request_kwargs(self, response, context, request_kwargs):
return {"action": request_kwargs["action"], "method": "GET"}
def has_completed(self, response):
state = response.object["loadBalancer"]["status"]
if state == "ERROR":
raise LibcloudError("Load balancer entered an ERROR state.", driver=self.driver)
return state == "ACTIVE"
def encode_data(self, data):
return data
class RackspaceLBDriver(Driver, OpenStackDriverMixin):
connectionCls = RackspaceConnection
api_name = "rackspace_lb"
name = "Rackspace LB"
website = "http://www.rackspace.com/"
LB_STATE_MAP = {
"ACTIVE": State.RUNNING,
"BUILD": State.PENDING,
"ERROR": State.ERROR,
"DELETED": State.DELETED,
"PENDING_UPDATE": State.PENDING,
"PENDING_DELETE": State.PENDING,
}
LB_MEMBER_CONDITION_MAP = {
"ENABLED": MemberCondition.ENABLED,
"DISABLED": MemberCondition.DISABLED,
"DRAINING": MemberCondition.DRAINING,
}
CONDITION_LB_MEMBER_MAP = reverse_dict(LB_MEMBER_CONDITION_MAP)
_VALUE_TO_ALGORITHM_MAP = {
"RANDOM": Algorithm.RANDOM,
"ROUND_ROBIN": Algorithm.ROUND_ROBIN,
"LEAST_CONNECTIONS": Algorithm.LEAST_CONNECTIONS,
"WEIGHTED_ROUND_ROBIN": Algorithm.WEIGHTED_ROUND_ROBIN,
"WEIGHTED_LEAST_CONNECTIONS": Algorithm.WEIGHTED_LEAST_CONNECTIONS,
}
_ALGORITHM_TO_VALUE_MAP = reverse_dict(_VALUE_TO_ALGORITHM_MAP)
def __init__(
self,
key,
secret=None,
secure=True,
host=None,
port=None,
region="ord",
**kwargs,
):
ex_force_region = kwargs.pop("ex_force_region", None)
if ex_force_region:
# For backward compatibility
region = ex_force_region
OpenStackDriverMixin.__init__(self, **kwargs)
super().__init__(key=key, secret=secret, secure=secure, host=host, port=port, region=region)
@classmethod
def list_regions(cls):
return ENDPOINT_ARGS_MAP.keys()
def _ex_connection_class_kwargs(self):
endpoint_args = ENDPOINT_ARGS_MAP[self.region]
kwargs = self.openstack_connection_kwargs()
kwargs["get_endpoint_args"] = endpoint_args
return kwargs
def list_protocols(self):
return self._to_protocols(self.connection.request("/loadbalancers/protocols").object)
def ex_list_protocols_with_default_ports(self):
"""
List protocols with default ports.
:rtype: ``list`` of ``tuple``
:return: A list of protocols with default ports included.
"""
return self._to_protocols_with_default_ports(
self.connection.request("/loadbalancers/protocols").object
)
def list_balancers(
self,
ex_member_address=None,
ex_status=None,
ex_changes_since=None,
ex_params={},
):
"""
@inherits: :class:`Driver.list_balancers`
:param ex_member_address: Optional IP address of the attachment member.
If provided, only the load balancers which
have this member attached will be returned.
:type ex_member_address: ``str``
:param ex_status: Optional. Filter balancers by status
:type ex_status: ``str``
:param ex_changes_since: Optional. List all load balancers that have
changed since the specified date/time
:type ex_changes_since: ``str``
:param ex_params: Optional. Set parameters to be submitted to the API
in the query string
:type ex_params: ``dict``
"""
params = {}
if ex_member_address:
params["nodeaddress"] = ex_member_address
if ex_status:
params["status"] = ex_status
if ex_changes_since:
params["changes-since"] = ex_changes_since
for key, value in ex_params.items():
params[key] = value
return self._to_balancers(self.connection.request("/loadbalancers", params=params).object)
def create_balancer(self, name, members, protocol="http", port=80, algorithm=DEFAULT_ALGORITHM):
return self.ex_create_balancer(name, members, protocol, port, algorithm)
def ex_create_balancer(
self,
name,
members,
protocol="http",
port=80,
algorithm=DEFAULT_ALGORITHM,
vip="PUBLIC",
):
"""
Creates a new load balancer instance
:param name: Name of the new load balancer (required)
:type name: ``str``
:param members: ``list`` of:class:`Member`s to attach to balancer
:type members: ``list`` of :class:`Member`
:param protocol: Loadbalancer protocol, defaults to http.
:type protocol: ``str``
:param port: Port the load balancer should listen on, defaults to 80
:type port: ``str``
:param algorithm: Load balancing algorithm, defaults to
LBAlgorithm.ROUND_ROBIN
:type algorithm: :class:`Algorithm`
:param vip: Virtual ip type of PUBLIC, SERVICENET, or ID of a virtual
ip
:type vip: ``str``
:rtype: :class:`LoadBalancer`
"""
balancer_attrs = self._kwargs_to_mutable_attrs(
name=name, protocol=protocol, port=port, algorithm=algorithm, vip=vip
)
balancer_attrs.update({"nodes": [self._member_attributes(member) for member in members]})
# balancer_attrs['nodes'] = ['fu']
balancer_object = {"loadBalancer": balancer_attrs}
resp = self.connection.request(
"/loadbalancers", method="POST", data=json.dumps(balancer_object)
)
return self._to_balancer(resp.object["loadBalancer"])
def _member_attributes(self, member):
member_attributes = {"address": member.ip, "port": member.port}
member_attributes.update(self._kwargs_to_mutable_member_attrs(**member.extra))
# If the condition is not specified on the member, then it should be
# set to ENABLED by default
if "condition" not in member_attributes:
member_attributes["condition"] = self.CONDITION_LB_MEMBER_MAP[MemberCondition.ENABLED]
return member_attributes
def destroy_balancer(self, balancer):
uri = "/loadbalancers/%s" % (balancer.id)
resp = self.connection.request(uri, method="DELETE")
return resp.status == httplib.ACCEPTED
def ex_destroy_balancers(self, balancers):
"""
Destroys a list of Balancers (the API supports up to 10).
:param balancers: A list of Balancers to destroy.
:type balancers: ``list`` of :class:`LoadBalancer`
:return: Returns whether the destroy request was accepted.
:rtype: ``bool``
"""
ids = [("id", balancer.id) for balancer in balancers]
resp = self.connection.request("/loadbalancers", method="DELETE", params=ids)
return resp.status == httplib.ACCEPTED
def get_balancer(self, balancer_id):
uri = "/loadbalancers/%s" % (balancer_id)
resp = self.connection.request(uri)
return self._to_balancer(resp.object["loadBalancer"])
def balancer_attach_member(self, balancer, member):
member_object = {"nodes": [self._member_attributes(member)]}
uri = "/loadbalancers/%s/nodes" % (balancer.id)
resp = self.connection.request(uri, method="POST", data=json.dumps(member_object))
return self._to_members(resp.object, balancer)[0]
def ex_balancer_attach_members(self, balancer, members):
"""
Attaches a list of members to a load balancer.
:param balancer: The Balancer to which members will be attached.
:type balancer: :class:`LoadBalancer`
:param members: A list of Members to attach.
:type members: ``list`` of :class:`Member`
:rtype: ``list`` of :class:`Member`
"""
member_objects = {"nodes": [self._member_attributes(member) for member in members]}
uri = "/loadbalancers/%s/nodes" % (balancer.id)
resp = self.connection.request(uri, method="POST", data=json.dumps(member_objects))
return self._to_members(resp.object, balancer)
def balancer_detach_member(self, balancer, member):
# Loadbalancer always needs to have at least 1 member.
# Last member cannot be detached. You can only disable it or destroy
# the balancer.
uri = "/loadbalancers/{}/nodes/{}".format(balancer.id, member.id)
resp = self.connection.request(uri, method="DELETE")
return resp.status == httplib.ACCEPTED
def ex_balancer_detach_members(self, balancer, members):
"""
Detaches a list of members from a balancer (the API supports up to 10).
This method blocks until the detach request has been processed and the
balancer is in a RUNNING state again.
:param balancer: The Balancer to detach members from.
:type balancer: :class:`LoadBalancer`
:param members: A list of Members to detach.
:type members: ``list`` of :class:`Member`
:return: Updated Balancer.
:rtype: :class:`LoadBalancer`
"""
accepted = self.ex_balancer_detach_members_no_poll(balancer, members)
if not accepted:
msg = "Detach members request was not accepted"
raise LibcloudError(msg, driver=self)
return self._get_updated_balancer(balancer)
def ex_balancer_detach_members_no_poll(self, balancer, members):
"""
Detaches a list of members from a balancer (the API supports up to 10).
This method returns immediately.
:param balancer: The Balancer to detach members from.
:type balancer: :class:`LoadBalancer`
:param members: A list of Members to detach.
:type members: ``list`` of :class:`Member`
:return: Returns whether the detach request was accepted.
:rtype: ``bool``
"""
uri = "/loadbalancers/%s/nodes" % (balancer.id)
ids = [("id", member.id) for member in members]
resp = self.connection.request(uri, method="DELETE", params=ids)
return resp.status == httplib.ACCEPTED
def balancer_list_members(self, balancer):
uri = "/loadbalancers/%s/nodes" % (balancer.id)
data = self.connection.request(uri).object
return self._to_members(data, balancer)
def update_balancer(self, balancer, **kwargs):
attrs = self._kwargs_to_mutable_attrs(**kwargs)
resp = self.connection.async_request(
action="/loadbalancers/%s" % balancer.id,
method="PUT",
data=json.dumps(attrs),
)
return self._to_balancer(resp.object["loadBalancer"])
def ex_update_balancer_no_poll(self, balancer, **kwargs):
"""
Update balancer no poll.
@inherits: :class:`Driver.update_balancer`
"""
attrs = self._kwargs_to_mutable_attrs(**kwargs)
resp = self.connection.request(
action="/loadbalancers/%s" % balancer.id,
method="PUT",
data=json.dumps(attrs),
)
return resp.status == httplib.ACCEPTED
def ex_balancer_update_member(self, balancer, member, **kwargs):
"""
Updates a Member's extra attributes for a Balancer. The attributes can
include 'weight' or 'condition'. This method blocks until the update
request has been processed and the balancer is in a RUNNING state
again.
:param balancer: Balancer to update the member on.
:type balancer: :class:`LoadBalancer`
:param member: Member which should be used
:type member: :class:`Member`
:keyword **kwargs: New attributes. Should contain either 'weight'
or 'condition'. 'condition' can be set to 'ENABLED', 'DISABLED'.
or 'DRAINING'. 'weight' can be set to a positive integer between
1 and 100, with a higher weight indicating that the node will receive
more traffic (assuming the Balancer is using a weighted algorithm).
:type **kwargs: ``dict``
:return: Updated Member.
:rtype: :class:`Member`
"""
accepted = self.ex_balancer_update_member_no_poll(balancer, member, **kwargs)
if not accepted:
msg = "Update member attributes was not accepted"
raise LibcloudError(msg, driver=self)
balancer = self._get_updated_balancer(balancer)
members = balancer.extra["members"]
updated_members = [m for m in members if m.id == member.id]
if not updated_members:
raise LibcloudError("Could not find updated member")
return updated_members[0]
def ex_balancer_update_member_no_poll(self, balancer, member, **kwargs):
"""
Updates a Member's extra attributes for a Balancer. The attribute can
include 'weight' or 'condition'. This method returns immediately.
:param balancer: Balancer to update the member on.
:type balancer: :class:`LoadBalancer`
:param member: Member which should be used
:type member: :class:`Member`
:keyword **kwargs: New attributes. Should contain either 'weight'
or 'condition'. 'condition' can be set to 'ENABLED', 'DISABLED'.
or 'DRAINING'. 'weight' can be set to a positive integer between
1 and 100, with a higher weight indicating that the node will receive
more traffic (assuming the Balancer is using a weighted algorithm).
:type **kwargs: ``dict``
:return: Returns whether the update request was accepted.
:rtype: ``bool``
"""
resp = self.connection.request(
action="/loadbalancers/{}/nodes/{}".format(balancer.id, member.id),
method="PUT",
data=json.dumps(self._kwargs_to_mutable_member_attrs(**kwargs)),
)
return resp.status == httplib.ACCEPTED
def ex_list_algorithm_names(self):
"""
Lists algorithms supported by the API. Returned as strings because
this list may change in the future.
:rtype: ``list`` of ``str``
"""
response = self.connection.request("/loadbalancers/algorithms")
return [a["name"].upper() for a in response.object["algorithms"]]
def ex_get_balancer_error_page(self, balancer):
"""
List error page configured for the specified load balancer.
:param balancer: Balancer which should be used
:type balancer: :class:`LoadBalancer`
:rtype: ``str``
"""
uri = "/loadbalancers/%s/errorpage" % (balancer.id)
resp = self.connection.request(uri)
return resp.object["errorpage"]["content"]
def ex_balancer_access_list(self, balancer):
"""
List the access list.
:param balancer: Balancer which should be used
:type balancer: :class:`LoadBalancer`
:rtype: ``list`` of :class:`RackspaceAccessRule`
"""
uri = "/loadbalancers/%s/accesslist" % (balancer.id)
resp = self.connection.request(uri)
return [self._to_access_rule(el) for el in resp.object["accessList"]]
def _get_updated_balancer(self, balancer):
"""
Updating a balancer's attributes puts a balancer into
'PENDING_UPDATE' status. Wait until the balancer is
back in 'ACTIVE' status and then return the individual
balancer details call.
"""
resp = self.connection.async_request(action="/loadbalancers/%s" % balancer.id, method="GET")
return self._to_balancer(resp.object["loadBalancer"])
def ex_update_balancer_health_monitor(self, balancer, health_monitor):
"""
Sets a Balancer's health monitor. This method blocks until the update
request has been processed and the balancer is in a RUNNING state
again.
:param balancer: Balancer to update.
:type balancer: :class:`LoadBalancer`
:param health_monitor: Health Monitor for the balancer.
:type health_monitor: :class:`RackspaceHealthMonitor`
:return: Updated Balancer.
:rtype: :class:`LoadBalancer`
"""
accepted = self.ex_update_balancer_health_monitor_no_poll(balancer, health_monitor)
if not accepted:
msg = "Update health monitor request not accepted"
raise LibcloudError(msg, driver=self)
return self._get_updated_balancer(balancer)
def ex_update_balancer_health_monitor_no_poll(self, balancer, health_monitor):
"""
Sets a Balancer's health monitor. This method returns immediately.
:param balancer: Balancer to update health monitor on.
:type balancer: :class:`LoadBalancer`
:param health_monitor: Health Monitor for the balancer.
:type health_monitor: :class:`RackspaceHealthMonitor`
:return: Returns whether the update request was accepted.
:rtype: ``bool``
"""
uri = "/loadbalancers/%s/healthmonitor" % (balancer.id)
resp = self.connection.request(
uri, method="PUT", data=json.dumps(health_monitor._to_dict())
)
return resp.status == httplib.ACCEPTED
def ex_disable_balancer_health_monitor(self, balancer):
"""
Disables a Balancer's health monitor. This method blocks until the
disable request has been processed and the balancer is in a RUNNING
state again.
:param balancer: Balancer to disable health monitor on.
:type balancer: :class:`LoadBalancer`
:return: Updated Balancer.
:rtype: :class:`LoadBalancer`
"""
if not self.ex_disable_balancer_health_monitor_no_poll(balancer):
msg = "Disable health monitor request not accepted"
raise LibcloudError(msg, driver=self)
return self._get_updated_balancer(balancer)
def ex_disable_balancer_health_monitor_no_poll(self, balancer):
"""
Disables a Balancer's health monitor. This method returns
immediately.
:param balancer: Balancer to disable health monitor on.
:type balancer: :class:`LoadBalancer`
:return: Returns whether the disable request was accepted.
:rtype: ``bool``
"""
uri = "/loadbalancers/%s/healthmonitor" % (balancer.id)
resp = self.connection.request(uri, method="DELETE")
return resp.status == httplib.ACCEPTED
def ex_update_balancer_connection_throttle(self, balancer, connection_throttle):
"""
Updates a Balancer's connection throttle. This method blocks until
the update request has been processed and the balancer is in a
RUNNING state again.
:param balancer: Balancer to update connection throttle on.
:type balancer: :class:`LoadBalancer`
:param connection_throttle: Connection Throttle for the balancer.
:type connection_throttle: :class:`RackspaceConnectionThrottle`
:return: Updated Balancer.
:rtype: :class:`LoadBalancer`
"""
accepted = self.ex_update_balancer_connection_throttle_no_poll(
balancer, connection_throttle
)
if not accepted:
msg = "Update connection throttle request not accepted"
raise LibcloudError(msg, driver=self)
return self._get_updated_balancer(balancer)
def ex_update_balancer_connection_throttle_no_poll(self, balancer, connection_throttle):
"""
Sets a Balancer's connection throttle. This method returns
immediately.
:param balancer: Balancer to update connection throttle on.
:type balancer: :class:`LoadBalancer`
:param connection_throttle: Connection Throttle for the balancer.
:type connection_throttle: :class:`RackspaceConnectionThrottle`
:return: Returns whether the update request was accepted.
:rtype: ``bool``
"""
uri = "/loadbalancers/%s/connectionthrottle" % (balancer.id)
resp = self.connection.request(
uri, method="PUT", data=json.dumps(connection_throttle._to_dict())
)
return resp.status == httplib.ACCEPTED
def ex_disable_balancer_connection_throttle(self, balancer):
"""
Disables a Balancer's connection throttle. This method blocks until
the disable request has been processed and the balancer is in a RUNNING
state again.
:param balancer: Balancer to disable connection throttle on.
:type balancer: :class:`LoadBalancer`
:return: Updated Balancer.
:rtype: :class:`LoadBalancer`
"""
if not self.ex_disable_balancer_connection_throttle_no_poll(balancer):
msg = "Disable connection throttle request not accepted"
raise LibcloudError(msg, driver=self)
return self._get_updated_balancer(balancer)
def ex_disable_balancer_connection_throttle_no_poll(self, balancer):
"""
Disables a Balancer's connection throttle. This method returns
immediately.
:param balancer: Balancer to disable connection throttle on.
:type balancer: :class:`LoadBalancer`
:return: Returns whether the disable request was accepted.
:rtype: ``bool``
"""
uri = "/loadbalancers/%s/connectionthrottle" % (balancer.id)
resp = self.connection.request(uri, method="DELETE")
return resp.status == httplib.ACCEPTED
def ex_enable_balancer_connection_logging(self, balancer):
"""
Enables connection logging for a Balancer. This method blocks until
the enable request has been processed and the balancer is in a RUNNING
state again.
:param balancer: Balancer to enable connection logging on.
:type balancer: :class:`LoadBalancer`
:return: Updated Balancer.
:rtype: :class:`LoadBalancer`
"""
if not self.ex_enable_balancer_connection_logging_no_poll(balancer):
msg = "Enable connection logging request not accepted"
raise LibcloudError(msg, driver=self)
return self._get_updated_balancer(balancer)
def ex_enable_balancer_connection_logging_no_poll(self, balancer):
"""
Enables connection logging for a Balancer. This method returns
immediately.
:param balancer: Balancer to enable connection logging on.
:type balancer: :class:`LoadBalancer`
:return: Returns whether the enable request was accepted.
:rtype: ``bool``
"""
uri = "/loadbalancers/%s/connectionlogging" % (balancer.id)
resp = self.connection.request(
uri, method="PUT", data=json.dumps({"connectionLogging": {"enabled": True}})
)
return resp.status == httplib.ACCEPTED
def ex_disable_balancer_connection_logging(self, balancer):
"""
Disables connection logging for a Balancer. This method blocks until
the enable request has been processed and the balancer is in a RUNNING
state again.
:param balancer: Balancer to disable connection logging on.
:type balancer: :class:`LoadBalancer`
:return: Updated Balancer.
:rtype: :class:`LoadBalancer`
"""
if not self.ex_disable_balancer_connection_logging_no_poll(balancer):
msg = "Disable connection logging request not accepted"
raise LibcloudError(msg, driver=self)
return self._get_updated_balancer(balancer)
def ex_disable_balancer_connection_logging_no_poll(self, balancer):
"""
Disables connection logging for a Balancer. This method returns
immediately.
:param balancer: Balancer to disable connection logging on.
:type balancer: :class:`LoadBalancer`
:return: Returns whether the disable request was accepted.
:rtype: ``bool``
"""
uri = "/loadbalancers/%s/connectionlogging" % (balancer.id)
resp = self.connection.request(
uri,
method="PUT",
data=json.dumps({"connectionLogging": {"enabled": False}}),
)
return resp.status == httplib.ACCEPTED
def ex_enable_balancer_session_persistence(self, balancer):
"""
Enables session persistence for a Balancer by setting the persistence
type to 'HTTP_COOKIE'. This method blocks until the enable request
has been processed and the balancer is in a RUNNING state again.
:param balancer: Balancer to enable session persistence on.
:type balancer: :class:`LoadBalancer`
:return: Updated Balancer.
:rtype: :class:`LoadBalancer`
"""
if not self.ex_enable_balancer_session_persistence_no_poll(balancer):
msg = "Enable session persistence request not accepted"
raise LibcloudError(msg, driver=self)
return self._get_updated_balancer(balancer)
def ex_enable_balancer_session_persistence_no_poll(self, balancer):
"""
Enables session persistence for a Balancer by setting the persistence
type to 'HTTP_COOKIE'. This method returns immediately.
:param balancer: Balancer to enable session persistence on.
:type balancer: :class:`LoadBalancer`
:return: Returns whether the enable request was accepted.
:rtype: ``bool``
"""
uri = "/loadbalancers/%s/sessionpersistence" % (balancer.id)
resp = self.connection.request(
uri,
method="PUT",
data=json.dumps({"sessionPersistence": {"persistenceType": "HTTP_COOKIE"}}),
)
return resp.status == httplib.ACCEPTED
def ex_disable_balancer_session_persistence(self, balancer):
"""
Disables session persistence for a Balancer. This method blocks until
the disable request has been processed and the balancer is in a RUNNING
state again.
:param balancer: Balancer to disable session persistence on.
:type balancer: :class:`LoadBalancer`
:return: Updated Balancer.
:rtype: :class:`LoadBalancer`
"""
if not self.ex_disable_balancer_session_persistence_no_poll(balancer):
msg = "Disable session persistence request not accepted"
raise LibcloudError(msg, driver=self)
return self._get_updated_balancer(balancer)
def ex_disable_balancer_session_persistence_no_poll(self, balancer):
"""
Disables session persistence for a Balancer. This method returns
immediately.
:param balancer: Balancer to disable session persistence for.
:type balancer: :class:`LoadBalancer`
:return: Returns whether the disable request was accepted.
:rtype: ``bool``
"""
uri = "/loadbalancers/%s/sessionpersistence" % (balancer.id)
resp = self.connection.request(uri, method="DELETE")
return resp.status == httplib.ACCEPTED
def ex_update_balancer_error_page(self, balancer, page_content):
"""
Updates a Balancer's custom error page. This method blocks until
the update request has been processed and the balancer is in a
RUNNING state again.
:param balancer: Balancer to update the custom error page for.
:type balancer: :class:`LoadBalancer`
:param page_content: HTML content for the custom error page.
:type page_content: ``str``
:return: Updated Balancer.
:rtype: :class:`LoadBalancer`
"""
accepted = self.ex_update_balancer_error_page_no_poll(balancer, page_content)
if not accepted:
msg = "Update error page request not accepted"
raise LibcloudError(msg, driver=self)
return self._get_updated_balancer(balancer)
def ex_update_balancer_error_page_no_poll(self, balancer, page_content):
"""
Updates a Balancer's custom error page. This method returns
immediately.
:param balancer: Balancer to update the custom error page for.
:type balancer: :class:`LoadBalancer`
:param page_content: HTML content for the custom error page.
:type page_content: ``str``
:return: Returns whether the update request was accepted.
:rtype: ``bool``
"""
uri = "/loadbalancers/%s/errorpage" % (balancer.id)
resp = self.connection.request(
uri, method="PUT", data=json.dumps({"errorpage": {"content": page_content}})
)
return resp.status == httplib.ACCEPTED
def ex_disable_balancer_custom_error_page(self, balancer):
"""
Disables a Balancer's custom error page, returning its error page to
the Rackspace-provided default. This method blocks until the disable
request has been processed and the balancer is in a RUNNING state
again.
:param balancer: Balancer to disable the custom error page for.
:type balancer: :class:`LoadBalancer`
:return: Updated Balancer.
:rtype: :class:`LoadBalancer`
"""
if not self.ex_disable_balancer_custom_error_page_no_poll(balancer):
msg = "Disable custom error page request not accepted"
raise LibcloudError(msg, driver=self)
return self._get_updated_balancer(balancer)
def ex_disable_balancer_custom_error_page_no_poll(self, balancer):
"""
Disables a Balancer's custom error page, returning its error page to
the Rackspace-provided default. This method returns immediately.
:param balancer: Balancer to disable the custom error page for.
:type balancer: :class:`LoadBalancer`
:return: Returns whether the disable request was accepted.
:rtype: ``bool``
"""
uri = "/loadbalancers/%s/errorpage" % (balancer.id)
resp = self.connection.request(uri, method="DELETE")
# Load Balancer API currently returns 200 OK on custom error page
# delete.
return resp.status == httplib.OK or resp.status == httplib.ACCEPTED
def ex_create_balancer_access_rule(self, balancer, rule):
"""
Adds an access rule to a Balancer's access list. This method blocks
until the update request has been processed and the balancer is in a
RUNNING state again.
:param balancer: Balancer to create the access rule for.
:type balancer: :class:`LoadBalancer`
:param rule: Access Rule to add to the balancer.
:type rule: :class:`RackspaceAccessRule`
:return: The created access rule.
:rtype: :class:`RackspaceAccessRule`
"""
accepted = self.ex_create_balancer_access_rule_no_poll(balancer, rule)
if not accepted:
msg = "Create access rule not accepted"
raise LibcloudError(msg, driver=self)
balancer = self._get_updated_balancer(balancer)
access_list = balancer.extra["accessList"]
created_rule = self._find_matching_rule(rule, access_list)
if not created_rule:
raise LibcloudError("Could not find created rule")
return created_rule
def ex_create_balancer_access_rule_no_poll(self, balancer, rule):
"""
Adds an access rule to a Balancer's access list. This method returns
immediately.
:param balancer: Balancer to create the access rule for.
:type balancer: :class:`LoadBalancer`
:param rule: Access Rule to add to the balancer.
:type rule: :class:`RackspaceAccessRule`
:return: Returns whether the create request was accepted.
:rtype: ``bool``
"""
uri = "/loadbalancers/%s/accesslist" % (balancer.id)
resp = self.connection.request(
uri, method="POST", data=json.dumps({"networkItem": rule._to_dict()})
)
return resp.status == httplib.ACCEPTED
def ex_create_balancer_access_rules(self, balancer, rules):
"""
Adds a list of access rules to a Balancer's access list. This method
blocks until the update request has been processed and the balancer is
in a RUNNING state again.
:param balancer: Balancer to create the access rule for.
:type balancer: :class:`LoadBalancer`
:param rules: List of :class:`RackspaceAccessRule` to add to the
balancer.
:type rules: ``list`` of :class:`RackspaceAccessRule`
:return: The created access rules.
:rtype: :class:`RackspaceAccessRule`
"""
accepted = self.ex_create_balancer_access_rules_no_poll(balancer, rules)
if not accepted:
msg = "Create access rules not accepted"
raise LibcloudError(msg, driver=self)
balancer = self._get_updated_balancer(balancer)
access_list = balancer.extra["accessList"]
created_rules = []
for r in rules:
matched_rule = self._find_matching_rule(r, access_list)
if matched_rule:
created_rules.append(matched_rule)
if len(created_rules) != len(rules):
raise LibcloudError("Could not find all created rules")
return created_rules
def _find_matching_rule(self, rule_to_find, access_list):
"""
LB API does not return the ID for the newly created rules, so we have
to search the list to find the rule with a matching rule type and
address to return an object with the right identifier.it. The API
enforces rule type and address uniqueness.
"""
for r in access_list:
if rule_to_find.rule_type == r.rule_type and rule_to_find.address == r.address:
return r
return None
def ex_create_balancer_access_rules_no_poll(self, balancer, rules):
"""
Adds a list of access rules to a Balancer's access list. This method
returns immediately.
:param balancer: Balancer to create the access rule for.
:type balancer: :class:`LoadBalancer`
:param rules: List of :class:`RackspaceAccessRule` to add to
the balancer.
:type rules: ``list`` of :class:`RackspaceAccessRule`
:return: Returns whether the create request was accepted.
:rtype: ``bool``
"""
uri = "/loadbalancers/%s/accesslist" % (balancer.id)
resp = self.connection.request(
uri,
method="POST",
data=json.dumps({"accessList": [rule._to_dict() for rule in rules]}),
)
return resp.status == httplib.ACCEPTED
def ex_destroy_balancer_access_rule(self, balancer, rule):
"""
Removes an access rule from a Balancer's access list. This method
blocks until the update request has been processed and the balancer
is in a RUNNING state again.
:param balancer: Balancer to remove the access rule from.
:type balancer: :class:`LoadBalancer`
:param rule: Access Rule to remove from the balancer.
:type rule: :class:`RackspaceAccessRule`
:return: Updated Balancer.
:rtype: :class:`LoadBalancer`
"""
accepted = self.ex_destroy_balancer_access_rule_no_poll(balancer, rule)
if not accepted:
msg = "Delete access rule not accepted"
raise LibcloudError(msg, driver=self)
return self._get_updated_balancer(balancer)
def ex_destroy_balancer_access_rule_no_poll(self, balancer, rule):
"""
Removes an access rule from a Balancer's access list. This method
returns immediately.
:param balancer: Balancer to remove the access rule from.
:type balancer: :class:`LoadBalancer`
:param rule: Access Rule to remove from the balancer.
:type rule: :class:`RackspaceAccessRule`
:return: Returns whether the destroy request was accepted.
:rtype: ``bool``
"""
uri = "/loadbalancers/{}/accesslist/{}".format(balancer.id, rule.id)
resp = self.connection.request(uri, method="DELETE")
return resp.status == httplib.ACCEPTED
def ex_destroy_balancer_access_rules(self, balancer, rules):
"""
Removes a list of access rules from a Balancer's access list. This
method blocks until the update request has been processed and the
balancer is in a RUNNING state again.
:param balancer: Balancer to remove the access rules from.
:type balancer: :class:`LoadBalancer`
:param rules: List of :class:`RackspaceAccessRule` objects to remove
from the balancer.
:type rules: ``list`` of :class:`RackspaceAccessRule`
:return: Updated Balancer.
:rtype: :class:`LoadBalancer`
"""
accepted = self.ex_destroy_balancer_access_rules_no_poll(balancer, rules)
if not accepted:
msg = "Destroy access rules request not accepted"
raise LibcloudError(msg, driver=self)
return self._get_updated_balancer(balancer)
def ex_destroy_balancer_access_rules_no_poll(self, balancer, rules):
"""
Removes a list of access rules from a Balancer's access list. This
method returns immediately.
:param balancer: Balancer to remove the access rules from.
:type balancer: :class:`LoadBalancer`
:param rules: List of :class:`RackspaceAccessRule` objects to remove
from the balancer.
:type rules: ``list`` of :class:`RackspaceAccessRule`
:return: Returns whether the destroy request was accepted.
:rtype: ``bool``
"""
ids = [("id", rule.id) for rule in rules]
uri = "/loadbalancers/%s/accesslist" % balancer.id
resp = self.connection.request(uri, method="DELETE", params=ids)
return resp.status == httplib.ACCEPTED
def ex_list_current_usage(self, balancer):
"""
Return current load balancer usage report.
:param balancer: Balancer to remove the access rules from.
:type balancer: :class:`LoadBalancer`
:return: Raw load balancer usage object.
:rtype: ``dict``
"""
uri = "/loadbalancers/%s/usage/current" % (balancer.id)
resp = self.connection.request(uri, method="GET")
return resp.object
def _to_protocols(self, object):
protocols = []
for item in object["protocols"]:
protocols.append(item["name"].lower())
return protocols
def _to_protocols_with_default_ports(self, object):
protocols = []
for item in object["protocols"]:
name = item["name"].lower()
port = int(item["port"])
protocols.append((name, port))
return protocols
def _to_balancers(self, object):
return [self._to_balancer(el) for el in object["loadBalancers"]]
def _to_balancer(self, el):
ip = None
port = None
sourceAddresses = {}
if "port" in el:
port = el["port"]
if "sourceAddresses" in el:
sourceAddresses = el["sourceAddresses"]
extra = {
"ipv6PublicSource": sourceAddresses.get("ipv6Public"),
"ipv4PublicSource": sourceAddresses.get("ipv4Public"),
"ipv4PrivateSource": sourceAddresses.get("ipv4Servicenet"),
"service_name": self.connection.get_service_name(),
"uri": "https://%s%s/loadbalancers/%s"
% (self.connection.host, self.connection.request_path, el["id"]),
}
if "virtualIps" in el:
ip = el["virtualIps"][0]["address"]
extra["virtualIps"] = el["virtualIps"]
if "protocol" in el:
extra["protocol"] = el["protocol"]
if "algorithm" in el and el["algorithm"] in self._VALUE_TO_ALGORITHM_MAP:
extra["algorithm"] = self._value_to_algorithm(el["algorithm"])
if "healthMonitor" in el:
health_monitor = self._to_health_monitor(el)
if health_monitor:
extra["healthMonitor"] = health_monitor
if "connectionThrottle" in el:
extra["connectionThrottle"] = self._to_connection_throttle(el)
if "sessionPersistence" in el:
persistence = el["sessionPersistence"]
extra["sessionPersistenceType"] = persistence.get("persistenceType")
if "connectionLogging" in el:
logging = el["connectionLogging"]
extra["connectionLoggingEnabled"] = logging.get("enabled")
if "nodes" in el:
extra["members"] = self._to_members(el)
if "created" in el:
extra["created"] = self._iso_to_datetime(el["created"]["time"])
if "updated" in el:
extra["updated"] = self._iso_to_datetime(el["updated"]["time"])
if "accessList" in el:
extra["accessList"] = [self._to_access_rule(rule) for rule in el["accessList"]]
return LoadBalancer(
id=el["id"],
name=el["name"],
state=self.LB_STATE_MAP.get(el["status"], State.UNKNOWN),
ip=ip,
port=port,
driver=self.connection.driver,
extra=extra,
)
def _to_members(self, object, balancer=None):
return [self._to_member(el, balancer) for el in object["nodes"]]
def _to_member(self, el, balancer=None):
extra = {}
if "weight" in el:
extra["weight"] = el["weight"]
if "condition" in el and el["condition"] in self.LB_MEMBER_CONDITION_MAP:
extra["condition"] = self.LB_MEMBER_CONDITION_MAP.get(el["condition"])
if "status" in el:
extra["status"] = el["status"]
lbmember = Member(
id=el["id"],
ip=el["address"],
port=el["port"],
balancer=balancer,
extra=extra,
)
return lbmember
def _protocol_to_value(self, protocol):
non_standard_protocols = {
"imapv2": "IMAPv2",
"imapv3": "IMAPv3",
"imapv4": "IMAPv4",
}
protocol_name = protocol.lower()
if protocol_name in non_standard_protocols:
protocol_value = non_standard_protocols[protocol_name]
else:
protocol_value = protocol.upper()
return protocol_value
def _kwargs_to_mutable_attrs(self, **attrs):
update_attrs = {}
if "name" in attrs:
update_attrs["name"] = attrs["name"]
if "algorithm" in attrs:
algorithm_value = self._algorithm_to_value(attrs["algorithm"])
update_attrs["algorithm"] = algorithm_value
if "protocol" in attrs:
update_attrs["protocol"] = self._protocol_to_value(attrs["protocol"])
if "port" in attrs:
update_attrs["port"] = int(attrs["port"])
if "vip" in attrs:
if attrs["vip"] == "PUBLIC" or attrs["vip"] == "SERVICENET":
update_attrs["virtualIps"] = [{"type": attrs["vip"]}]
else:
update_attrs["virtualIps"] = [{"id": attrs["vip"]}]
return update_attrs
def _kwargs_to_mutable_member_attrs(self, **attrs):
update_attrs = {}
if "condition" in attrs:
update_attrs["condition"] = self.CONDITION_LB_MEMBER_MAP.get(attrs["condition"])
if "weight" in attrs:
update_attrs["weight"] = attrs["weight"]
return update_attrs
def _to_health_monitor(self, el):
health_monitor_data = el["healthMonitor"]
type = health_monitor_data.get("type")
delay = health_monitor_data.get("delay")
timeout = health_monitor_data.get("timeout")
attempts_before_deactivation = health_monitor_data.get("attemptsBeforeDeactivation")
if type == "CONNECT":
return RackspaceHealthMonitor(
type=type,
delay=delay,
timeout=timeout,
attempts_before_deactivation=attempts_before_deactivation,
)
if type == "HTTP" or type == "HTTPS":
return RackspaceHTTPHealthMonitor(
type=type,
delay=delay,
timeout=timeout,
attempts_before_deactivation=attempts_before_deactivation,
path=health_monitor_data.get("path"),
status_regex=health_monitor_data.get("statusRegex"),
body_regex=health_monitor_data.get("bodyRegex", ""),
)
return None
def _to_connection_throttle(self, el):
connection_throttle_data = el["connectionThrottle"]
min_connections = connection_throttle_data.get("minConnections")
max_connections = connection_throttle_data.get("maxConnections")
max_connection_rate = connection_throttle_data.get("maxConnectionRate")
rate_interval = connection_throttle_data.get("rateInterval")
return RackspaceConnectionThrottle(
min_connections=min_connections,
max_connections=max_connections,
max_connection_rate=max_connection_rate,
rate_interval_seconds=rate_interval,
)
def _to_access_rule(self, el):
return RackspaceAccessRule(
id=el.get("id"),
rule_type=self._to_access_rule_type(el.get("type")),
address=el.get("address"),
)
def _to_access_rule_type(self, type):
if type == "ALLOW":
return RackspaceAccessRuleType.ALLOW
elif type == "DENY":
return RackspaceAccessRuleType.DENY
def _iso_to_datetime(self, isodate):
date_formats = ("%Y-%m-%dT%H:%M:%SZ", "%Y-%m-%dT%H:%M:%S%z")
date = None
for date_format in date_formats:
try:
date = datetime.strptime(isodate, date_format)
except ValueError:
pass
if date:
break
return date