def test_create(self):
"""Creates a webhook with pyrax and makes attributes available."""
self._setup_test_stack(self.webhook_template)
resource = self.stack['my_webhook']
self.assertEqual(
{
'name': 'exec my policy',
'scaling_group': 'my-group-id',
'policy': 'my-policy-id',
'metadata': {'a': 'b'}},
self.fake_auto_scale.webhooks['0'].kwargs)
self.assertEqual("self-url", resource.FnGetAtt("executeUrl"))
self.assertEqual("capability-url", resource.FnGetAtt("capabilityUrl"))
def test_failed_create(self):
"""When a create fails, getting the attributes returns None."""
template = copy.deepcopy(self.webhook_template)
template['Resources']['my_webhook']['Properties']['policy'] = 'foobar'
self.stack = utils.parse_stack(template)
self.stack.create()
resource = self.stack['my_webhook']
self.assertIsNone(resource.FnGetAtt('capabilityUrl'))
def result(self):
path_components = function.resolve(self._path_components)
attribute = function.resolve(self._attribute)
resource = self._resource()
if self._result_ready(resource):
return resource.FnGetAtt(attribute, *path_components)
else:
return None
def result(self):
attr_name = function.resolve(self._attribute)
resource = self._resource()
if self._result_ready(resource):
attribute = resource.FnGetAtt(attr_name)
else:
attribute = None
if attribute is None:
return None
path_components = function.resolve(self._path_components)
return attributes.select_from_attribute(attribute, path_components)
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
