622 lines
23 KiB
Python
622 lines
23 KiB
Python
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
|
#
|
|
# Licensed 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.
|
|
try:
|
|
from pyrax.exceptions import NotFound
|
|
PYRAX_INSTALLED = True
|
|
except ImportError:
|
|
#Setup fake exception for testing without pyrax
|
|
class NotFound(Exception):
|
|
pass
|
|
|
|
PYRAX_INSTALLED = False
|
|
|
|
from heat.openstack.common import log as logging
|
|
from heat.openstack.common.gettextutils import _
|
|
from heat.engine import scheduler
|
|
from heat.engine import constraints
|
|
from heat.engine import properties
|
|
from heat.engine import resource
|
|
from heat.engine.properties import Properties
|
|
from heat.common import exception
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class LoadbalancerBuildError(exception.HeatException):
|
|
msg_fmt = _("There was an error building the loadbalancer:%(lb_name)s.")
|
|
|
|
|
|
class CloudLoadBalancer(resource.Resource):
|
|
|
|
PROPERTIES = (
|
|
NAME, NODES, PROTOCOL, ACCESS_LIST, HALF_CLOSED, ALGORITHM,
|
|
CONNECTION_LOGGING, METADATA, PORT, TIMEOUT,
|
|
CONNECTION_THROTTLE, SESSION_PERSISTENCE, VIRTUAL_IPS,
|
|
CONTENT_CACHING, HEALTH_MONITOR, SSL_TERMINATION, ERROR_PAGE,
|
|
) = (
|
|
'name', 'nodes', 'protocol', 'accessList', 'halfClosed', 'algorithm',
|
|
'connectionLogging', 'metadata', 'port', 'timeout',
|
|
'connectionThrottle', 'sessionPersistence', 'virtualIps',
|
|
'contentCaching', 'healthMonitor', 'sslTermination', 'errorPage',
|
|
)
|
|
|
|
_NODE_KEYS = (
|
|
NODE_ADDRESS, NODE_REF, NODE_PORT, NODE_CONDITION, NODE_TYPE,
|
|
NODE_WEIGHT,
|
|
) = (
|
|
'address', 'ref', 'port', 'condition', 'type',
|
|
'weight',
|
|
)
|
|
|
|
_ACCESS_LIST_KEYS = (
|
|
ACCESS_LIST_ADDRESS, ACCESS_LIST_TYPE,
|
|
) = (
|
|
'address', 'type',
|
|
)
|
|
|
|
_CONNECTION_THROTTLE_KEYS = (
|
|
CONNECTION_THROTTLE_MAX_CONNECTION_RATE,
|
|
CONNECTION_THROTTLE_MIN_CONNECTIONS,
|
|
CONNECTION_THROTTLE_MAX_CONNECTIONS,
|
|
CONNECTION_THROTTLE_RATE_INTERVAL,
|
|
) = (
|
|
'maxConnectionRate',
|
|
'minConnections',
|
|
'maxConnections',
|
|
'rateInterval',
|
|
)
|
|
|
|
_VIRTUAL_IP_KEYS = (
|
|
VIRTUAL_IP_TYPE, VIRTUAL_IP_IP_VERSION,
|
|
) = (
|
|
'type', 'ipVersion',
|
|
)
|
|
|
|
_HEALTH_MONITOR_KEYS = (
|
|
HEALTH_MONITOR_ATTEMPTS_BEFORE_DEACTIVATION, HEALTH_MONITOR_DELAY,
|
|
HEALTH_MONITOR_TIMEOUT, HEALTH_MONITOR_TYPE, HEALTH_MONITOR_BODY_REGEX,
|
|
HEALTH_MONITOR_HOST_HEADER, HEALTH_MONITOR_PATH,
|
|
HEALTH_MONITOR_STATUS_REGEX,
|
|
) = (
|
|
'attemptsBeforeDeactivation', 'delay',
|
|
'timeout', 'type', 'bodyRegex',
|
|
'hostHeader', 'path',
|
|
'statusRegex',
|
|
)
|
|
_HEALTH_MONITOR_CONNECT_KEYS = (
|
|
HEALTH_MONITOR_ATTEMPTS_BEFORE_DEACTIVATION, HEALTH_MONITOR_DELAY,
|
|
HEALTH_MONITOR_TIMEOUT, HEALTH_MONITOR_TYPE,
|
|
)
|
|
|
|
_SSL_TERMINATION_KEYS = (
|
|
SSL_TERMINATION_SECURE_PORT, SSL_TERMINATION_PRIVATEKEY,
|
|
SSL_TERMINATION_CERTIFICATE, SSL_TERMINATION_INTERMEDIATE_CERTIFICATE,
|
|
SSL_TERMINATION_SECURE_TRAFFIC_ONLY,
|
|
) = (
|
|
'securePort', 'privatekey',
|
|
'certificate', 'intermediateCertificate',
|
|
'secureTrafficOnly',
|
|
)
|
|
|
|
_health_monitor_schema = {
|
|
HEALTH_MONITOR_ATTEMPTS_BEFORE_DEACTIVATION: properties.Schema(
|
|
properties.Schema.NUMBER,
|
|
required=True,
|
|
constraints=[
|
|
constraints.Range(1, 10),
|
|
]
|
|
),
|
|
HEALTH_MONITOR_DELAY: properties.Schema(
|
|
properties.Schema.NUMBER,
|
|
required=True,
|
|
constraints=[
|
|
constraints.Range(1, 3600),
|
|
]
|
|
),
|
|
HEALTH_MONITOR_TIMEOUT: properties.Schema(
|
|
properties.Schema.NUMBER,
|
|
required=True,
|
|
constraints=[
|
|
constraints.Range(1, 300),
|
|
]
|
|
),
|
|
HEALTH_MONITOR_TYPE: properties.Schema(
|
|
properties.Schema.STRING,
|
|
required=True,
|
|
constraints=[
|
|
constraints.AllowedValues(['CONNECT', 'HTTP', 'HTTPS']),
|
|
]
|
|
),
|
|
HEALTH_MONITOR_BODY_REGEX: properties.Schema(
|
|
properties.Schema.STRING
|
|
),
|
|
HEALTH_MONITOR_HOST_HEADER: properties.Schema(
|
|
properties.Schema.STRING
|
|
),
|
|
HEALTH_MONITOR_PATH: properties.Schema(
|
|
properties.Schema.STRING
|
|
),
|
|
HEALTH_MONITOR_STATUS_REGEX: properties.Schema(
|
|
properties.Schema.STRING
|
|
),
|
|
}
|
|
|
|
properties_schema = {
|
|
NAME: properties.Schema(
|
|
properties.Schema.STRING
|
|
),
|
|
NODES: properties.Schema(
|
|
properties.Schema.LIST,
|
|
schema=properties.Schema(
|
|
properties.Schema.MAP,
|
|
schema={
|
|
NODE_ADDRESS: properties.Schema(
|
|
properties.Schema.STRING
|
|
),
|
|
NODE_REF: properties.Schema(
|
|
properties.Schema.STRING
|
|
),
|
|
NODE_PORT: properties.Schema(
|
|
properties.Schema.NUMBER,
|
|
required=True
|
|
),
|
|
NODE_CONDITION: properties.Schema(
|
|
properties.Schema.STRING,
|
|
default='ENABLED',
|
|
required=True,
|
|
constraints=[
|
|
constraints.AllowedValues(['ENABLED',
|
|
'DISABLED']),
|
|
]
|
|
),
|
|
NODE_TYPE: properties.Schema(
|
|
properties.Schema.STRING,
|
|
constraints=[
|
|
constraints.AllowedValues(['PRIMARY',
|
|
'SECONDARY']),
|
|
]
|
|
),
|
|
NODE_WEIGHT: properties.Schema(
|
|
properties.Schema.NUMBER,
|
|
constraints=[
|
|
constraints.Range(1, 100),
|
|
]
|
|
),
|
|
},
|
|
),
|
|
required=True,
|
|
update_allowed=True
|
|
),
|
|
PROTOCOL: properties.Schema(
|
|
properties.Schema.STRING,
|
|
required=True,
|
|
constraints=[
|
|
constraints.AllowedValues(['DNS_TCP', 'DNS_UDP', 'FTP',
|
|
'HTTP', 'HTTPS', 'IMAPS',
|
|
'IMAPv4', 'LDAP', 'LDAPS',
|
|
'MYSQL', 'POP3', 'POP3S', 'SMTP',
|
|
'TCP', 'TCP_CLIENT_FIRST', 'UDP',
|
|
'UDP_STREAM', 'SFTP']),
|
|
]
|
|
),
|
|
ACCESS_LIST: properties.Schema(
|
|
properties.Schema.LIST,
|
|
schema=properties.Schema(
|
|
properties.Schema.MAP,
|
|
schema={
|
|
ACCESS_LIST_ADDRESS: properties.Schema(
|
|
properties.Schema.STRING,
|
|
required=True
|
|
),
|
|
ACCESS_LIST_TYPE: properties.Schema(
|
|
properties.Schema.STRING,
|
|
required=True,
|
|
constraints=[
|
|
constraints.AllowedValues(['ALLOW', 'DENY']),
|
|
]
|
|
),
|
|
},
|
|
)
|
|
),
|
|
HALF_CLOSED: properties.Schema(
|
|
properties.Schema.BOOLEAN
|
|
),
|
|
ALGORITHM: properties.Schema(
|
|
properties.Schema.STRING
|
|
),
|
|
CONNECTION_LOGGING: properties.Schema(
|
|
properties.Schema.BOOLEAN
|
|
),
|
|
METADATA: properties.Schema(
|
|
properties.Schema.MAP
|
|
),
|
|
PORT: properties.Schema(
|
|
properties.Schema.NUMBER,
|
|
required=True
|
|
),
|
|
TIMEOUT: properties.Schema(
|
|
properties.Schema.NUMBER,
|
|
constraints=[
|
|
constraints.Range(1, 120),
|
|
]
|
|
),
|
|
CONNECTION_THROTTLE: properties.Schema(
|
|
properties.Schema.MAP,
|
|
schema={
|
|
CONNECTION_THROTTLE_MAX_CONNECTION_RATE: properties.Schema(
|
|
properties.Schema.NUMBER,
|
|
constraints=[
|
|
constraints.Range(0, 100000),
|
|
]
|
|
),
|
|
CONNECTION_THROTTLE_MIN_CONNECTIONS: properties.Schema(
|
|
properties.Schema.NUMBER,
|
|
constraints=[
|
|
constraints.Range(1, 1000),
|
|
]
|
|
),
|
|
CONNECTION_THROTTLE_MAX_CONNECTIONS: properties.Schema(
|
|
properties.Schema.NUMBER,
|
|
constraints=[
|
|
constraints.Range(1, 100000),
|
|
]
|
|
),
|
|
CONNECTION_THROTTLE_RATE_INTERVAL: properties.Schema(
|
|
properties.Schema.NUMBER,
|
|
constraints=[
|
|
constraints.Range(1, 3600),
|
|
]
|
|
),
|
|
}
|
|
),
|
|
SESSION_PERSISTENCE: properties.Schema(
|
|
properties.Schema.STRING,
|
|
constraints=[
|
|
constraints.AllowedValues(['HTTP_COOKIE', 'SOURCE_IP']),
|
|
]
|
|
),
|
|
VIRTUAL_IPS: properties.Schema(
|
|
properties.Schema.LIST,
|
|
schema=properties.Schema(
|
|
properties.Schema.MAP,
|
|
schema={
|
|
VIRTUAL_IP_TYPE: properties.Schema(
|
|
properties.Schema.STRING,
|
|
required=True,
|
|
constraints=[
|
|
constraints.AllowedValues(['SERVICENET',
|
|
'PUBLIC']),
|
|
]
|
|
),
|
|
VIRTUAL_IP_IP_VERSION: properties.Schema(
|
|
properties.Schema.STRING,
|
|
default='IPV6',
|
|
constraints=[
|
|
constraints.AllowedValues(['IPV6', 'IPV4']),
|
|
]
|
|
),
|
|
},
|
|
),
|
|
required=True
|
|
),
|
|
CONTENT_CACHING: properties.Schema(
|
|
properties.Schema.STRING,
|
|
constraints=[
|
|
constraints.AllowedValues(['ENABLED', 'DISABLED']),
|
|
]
|
|
),
|
|
HEALTH_MONITOR: properties.Schema(
|
|
properties.Schema.MAP,
|
|
schema=_health_monitor_schema
|
|
),
|
|
SSL_TERMINATION: properties.Schema(
|
|
properties.Schema.MAP,
|
|
schema={
|
|
SSL_TERMINATION_SECURE_PORT: properties.Schema(
|
|
properties.Schema.NUMBER,
|
|
required=True,
|
|
default=443
|
|
),
|
|
SSL_TERMINATION_PRIVATEKEY: properties.Schema(
|
|
properties.Schema.STRING,
|
|
required=True
|
|
),
|
|
SSL_TERMINATION_CERTIFICATE: properties.Schema(
|
|
properties.Schema.STRING,
|
|
required=True
|
|
),
|
|
# only required if configuring intermediate ssl termination
|
|
# add to custom validation
|
|
SSL_TERMINATION_INTERMEDIATE_CERTIFICATE: properties.Schema(
|
|
properties.Schema.STRING
|
|
),
|
|
# pyrax will default to false
|
|
SSL_TERMINATION_SECURE_TRAFFIC_ONLY: properties.Schema(
|
|
properties.Schema.BOOLEAN,
|
|
default=False
|
|
),
|
|
}
|
|
),
|
|
ERROR_PAGE: properties.Schema(
|
|
properties.Schema.STRING
|
|
),
|
|
}
|
|
|
|
attributes_schema = {
|
|
'PublicIp': _('Public IP address of the specified '
|
|
'instance.')}
|
|
|
|
update_allowed_keys = ('Properties',)
|
|
|
|
def __init__(self, name, json_snippet, stack):
|
|
super(CloudLoadBalancer, self).__init__(name, json_snippet, stack)
|
|
self.clb = self.cloud_lb()
|
|
|
|
def cloud_lb(self):
|
|
return self.stack.clients.cloud_lb()
|
|
|
|
def _setup_properties(self, properties, function):
|
|
"""Use defined schema properties as kwargs for loadbalancer objects."""
|
|
if properties and function:
|
|
return [function(**item_dict) for item_dict in properties]
|
|
elif function:
|
|
return [function()]
|
|
|
|
def _alter_properties_for_api(self):
|
|
"""The following properties have usless key/value pairs which must
|
|
be passed into the api. Set them up to make template definition easier.
|
|
"""
|
|
session_persistence = None
|
|
if self.SESSION_PERSISTENCE in self.properties.data:
|
|
session_persistence = {'persistenceType':
|
|
self.properties[self.SESSION_PERSISTENCE]}
|
|
connection_logging = None
|
|
if self.CONNECTION_LOGGING in self.properties.data:
|
|
connection_logging = {"enabled":
|
|
self.properties[self.CONNECTION_LOGGING]}
|
|
metadata = None
|
|
if self.METADATA in self.properties.data:
|
|
metadata = [{'key': k, 'value': v}
|
|
for k, v in self.properties[self.METADATA].iteritems()]
|
|
|
|
return (session_persistence, connection_logging, metadata)
|
|
|
|
def _check_status(self, loadbalancer, status_list):
|
|
"""Update the loadbalancer state, check the status."""
|
|
loadbalancer.get()
|
|
if loadbalancer.status in status_list:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def _configure_post_creation(self, loadbalancer):
|
|
"""Configure all load balancer properties that must be done post
|
|
creation.
|
|
"""
|
|
if self.properties[self.ACCESS_LIST]:
|
|
while not self._check_status(loadbalancer, ['ACTIVE']):
|
|
yield
|
|
loadbalancer.add_access_list(self.properties[self.ACCESS_LIST])
|
|
|
|
if self.properties[self.ERROR_PAGE]:
|
|
while not self._check_status(loadbalancer, ['ACTIVE']):
|
|
yield
|
|
loadbalancer.set_error_page(self.properties[self.ERROR_PAGE])
|
|
|
|
if self.properties[self.SSL_TERMINATION]:
|
|
while not self._check_status(loadbalancer, ['ACTIVE']):
|
|
yield
|
|
ssl_term = self.properties[self.SSL_TERMINATION]
|
|
loadbalancer.add_ssl_termination(
|
|
ssl_term[self.SSL_TERMINATION_SECURE_PORT],
|
|
ssl_term[self.SSL_TERMINATION_PRIVATEKEY],
|
|
ssl_term[self.SSL_TERMINATION_CERTIFICATE],
|
|
intermediateCertificate=ssl_term[
|
|
self.SSL_TERMINATION_INTERMEDIATE_CERTIFICATE],
|
|
enabled=True,
|
|
secureTrafficOnly=ssl_term[
|
|
self.SSL_TERMINATION_SECURE_TRAFFIC_ONLY])
|
|
|
|
if self.CONTENT_CACHING in self.properties:
|
|
enabled = self.properties[self.CONTENT_CACHING] == 'ENABLED'
|
|
while not self._check_status(loadbalancer, ['ACTIVE']):
|
|
yield
|
|
loadbalancer.content_caching = enabled
|
|
|
|
def handle_create(self):
|
|
node_list = []
|
|
for node in self.properties[self.NODES]:
|
|
# resolve references to stack resource IP's
|
|
if node.get(self.NODE_REF):
|
|
resource = self.stack.resource_by_refid(node[self.NODE_REF])
|
|
node[self.NODE_ADDRESS] = resource.FnGetAtt('PublicIp')
|
|
del node[self.NODE_REF]
|
|
node_list.append(node)
|
|
|
|
nodes = [self.clb.Node(**node) for node in node_list]
|
|
vips = self.properties.get(self.VIRTUAL_IPS)
|
|
virtual_ips = self._setup_properties(vips, self.clb.VirtualIP)
|
|
|
|
(session_persistence, connection_logging, metadata) = \
|
|
self._alter_properties_for_api()
|
|
|
|
lb_body = {
|
|
'port': self.properties[self.PORT],
|
|
'protocol': self.properties[self.PROTOCOL],
|
|
'nodes': nodes,
|
|
'virtual_ips': virtual_ips,
|
|
'algorithm': self.properties.get(self.ALGORITHM),
|
|
'halfClosed': self.properties.get(self.HALF_CLOSED),
|
|
'connectionThrottle': self.properties.get(
|
|
self.CONNECTION_THROTTLE),
|
|
'metadata': metadata,
|
|
'healthMonitor': self.properties.get(self.HEALTH_MONITOR),
|
|
'sessionPersistence': session_persistence,
|
|
'timeout': self.properties.get(self.TIMEOUT),
|
|
'connectionLogging': connection_logging,
|
|
}
|
|
|
|
lb_name = (self.properties.get(self.NAME) or
|
|
self.physical_resource_name())
|
|
logger.debug(_("Creating loadbalancer: %s") % {lb_name: lb_body})
|
|
loadbalancer = self.clb.create(lb_name, **lb_body)
|
|
self.resource_id_set(str(loadbalancer.id))
|
|
|
|
post_create = scheduler.TaskRunner(self._configure_post_creation,
|
|
loadbalancer)
|
|
post_create(timeout=600)
|
|
return loadbalancer
|
|
|
|
def check_create_complete(self, loadbalancer):
|
|
return self._check_status(loadbalancer, ['ACTIVE'])
|
|
|
|
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
|
|
"""
|
|
Add and remove nodes specified in the prop_diff.
|
|
"""
|
|
loadbalancer = self.clb.get(self.resource_id)
|
|
if self.NODES in prop_diff:
|
|
current_nodes = loadbalancer.nodes
|
|
#Loadbalancers can be uniquely identified by address and port.
|
|
#Old is a dict of all nodes the loadbalancer currently knows about.
|
|
for node in prop_diff[self.NODES]:
|
|
# resolve references to stack resource IP's
|
|
if node.get(self.NODE_REF):
|
|
res = self.stack.resource_by_refid(node[self.NODE_REF])
|
|
node[self.NODE_ADDRESS] = res.FnGetAtt('PublicIp')
|
|
del node[self.NODE_REF]
|
|
old = dict(("{0.address}{0.port}".format(node), node)
|
|
for node in current_nodes)
|
|
#New is a dict of the nodes the loadbalancer will know about after
|
|
#this update.
|
|
new = dict(("%s%s" % (node[self.NODE_ADDRESS],
|
|
node[self.NODE_PORT]), node)
|
|
for node in prop_diff[self.NODES])
|
|
|
|
old_set = set(old.keys())
|
|
new_set = set(new.keys())
|
|
|
|
deleted = old_set.difference(new_set)
|
|
added = new_set.difference(old_set)
|
|
updated = new_set.intersection(old_set)
|
|
|
|
if len(current_nodes) + len(added) - len(deleted) < 1:
|
|
raise ValueError(_("The loadbalancer:%s requires at least one "
|
|
"node.") % self.name)
|
|
"""
|
|
Add loadbalancers in the new map that are not in the old map.
|
|
Add before delete to avoid deleting the last node and getting in
|
|
an invalid state.
|
|
"""
|
|
new_nodes = [self.clb.Node(**new[lb_node])
|
|
for lb_node in added]
|
|
if new_nodes:
|
|
loadbalancer.add_nodes(new_nodes)
|
|
|
|
#Delete loadbalancers in the old dict that are not in the new dict.
|
|
for node in deleted:
|
|
old[node].delete()
|
|
|
|
#Update nodes that have been changed
|
|
for node in updated:
|
|
node_changed = False
|
|
for attribute in new[node].keys():
|
|
if new[node][attribute] != getattr(old[node], attribute):
|
|
node_changed = True
|
|
setattr(old[node], attribute, new[node][attribute])
|
|
if node_changed:
|
|
old[node].update()
|
|
|
|
def handle_delete(self):
|
|
if self.resource_id is None:
|
|
return
|
|
try:
|
|
loadbalancer = self.clb.get(self.resource_id)
|
|
except NotFound:
|
|
pass
|
|
else:
|
|
if loadbalancer.status != 'DELETED':
|
|
loadbalancer.delete()
|
|
self.resource_id_set(None)
|
|
|
|
def _remove_none(self, property_dict):
|
|
'''
|
|
Remove values that may be initialized to None and would cause problems
|
|
during schema validation.
|
|
'''
|
|
return dict((key, value)
|
|
for (key, value) in property_dict.iteritems()
|
|
if value)
|
|
|
|
def validate(self):
|
|
"""
|
|
Validate any of the provided params
|
|
"""
|
|
res = super(CloudLoadBalancer, self).validate()
|
|
if res:
|
|
return res
|
|
|
|
if self.properties.get(self.HALF_CLOSED):
|
|
if not (self.properties[self.PROTOCOL] == 'TCP' or
|
|
self.properties[self.PROTOCOL] == 'TCP_CLIENT_FIRST'):
|
|
return {'Error':
|
|
'The %s property is only available for the TCP or '
|
|
'TCP_CLIENT_FIRST protocols' % self.HALF_CLOSED}
|
|
|
|
#health_monitor connect and http types require completely different
|
|
#schema
|
|
if self.properties.get(self.HEALTH_MONITOR):
|
|
health_monitor = \
|
|
self._remove_none(self.properties[self.HEALTH_MONITOR])
|
|
|
|
schema = self._health_monitor_schema
|
|
if health_monitor[self.HEALTH_MONITOR_TYPE] == 'CONNECT':
|
|
schema = dict((k, v) for k, v in schema.items()
|
|
if k in self._HEALTH_MONITOR_CONNECT_KEYS)
|
|
try:
|
|
Properties(schema,
|
|
health_monitor,
|
|
self.stack.resolve_runtime_data,
|
|
self.name).validate()
|
|
except exception.StackValidationFailed as svf:
|
|
return {'Error': str(svf)}
|
|
|
|
def _public_ip(self):
|
|
#TODO(andrew-plunk) return list here and let caller choose ip
|
|
for ip in self.clb.get(self.resource_id).virtual_ips:
|
|
if ip.type == 'PUBLIC':
|
|
return ip.address
|
|
|
|
def _resolve_attribute(self, key):
|
|
attribute_function = {
|
|
'PublicIp': self._public_ip()
|
|
}
|
|
if key not in attribute_function:
|
|
raise exception.InvalidTemplateAttribute(resource=self.name,
|
|
key=key)
|
|
function = attribute_function[key]
|
|
logger.info(_('%(name)s.GetAtt(%(key)s) == %(function)s'),
|
|
{'name': self.name, 'key': key, 'function': function})
|
|
return unicode(function)
|
|
|
|
|
|
def resource_mapping():
|
|
return {'Rackspace::Cloud::LoadBalancer': CloudLoadBalancer}
|
|
|
|
|
|
def available_resource_mapping():
|
|
if PYRAX_INSTALLED:
|
|
return resource_mapping()
|
|
return {}
|