def setUp(self):
super(HaProxyConfigTest, self).setUp()
stack = utils.parse_stack(template_format.parse(lb_template))
resource_name = 'LoadBalancer'
lb_defn = stack.t.resource_definitions(stack)[resource_name]
self.lb = lb.LoadBalancer(resource_name, lb_defn, stack)
self.lb.client_plugin = mock.Mock()
def create_loadbalancer(self, t, stack, resource_name):
resource = lb.LoadBalancer(resource_name,
t['Resources'][resource_name], stack)
self.assertEqual(None, resource.validate())
self.assertEqual(None, resource.create())
self.assertEqual(lb.LoadBalancer.CREATE_COMPLETE, resource.state)
return resource
def create_loadbalancer(self, t, stack, resource_name):
rsrc = lb.LoadBalancer(resource_name, t['Resources'][resource_name],
stack)
self.assertEqual(None, rsrc.validate())
scheduler.TaskRunner(rsrc.create)()
self.assertEqual(lb.LoadBalancer.CREATE_COMPLETE, rsrc.state)
return rsrc
def test_loadbalancer(self):
t = template_format.parse(lb_template)
s = utils.parse_stack(t)
s.store()
resource_name = 'LoadBalancer'
lb_defn = s.t.resource_definitions(s)[resource_name]
rsrc = lb.LoadBalancer(resource_name, lb_defn, s)
nova.NovaClientPlugin._create = mock.Mock(return_value=self.fc)
initial_md = {
'AWS::CloudFormation::Init': {
'config': {
'files': {
'/etc/haproxy/haproxy.cfg': {
'content': 'initial'
}
}
}
}
}
ha_cfg = '\n'.join([
'\nglobal', ' daemon', ' maxconn 256',
' stats socket /tmp/.haproxy-stats', '\ndefaults',
' mode http\n timeout connect 5000ms',
' timeout client 50000ms',
' timeout server 50000ms\n\nfrontend http',
' bind *:80\n default_backend servers',
'\nbackend servers\n balance roundrobin',
' option http-server-close',
' option forwardfor\n option httpchk',
'\n server server1 1.2.3.4:80',
' server server2 0.0.0.0:80\n'
])
expected_md = {
'AWS::CloudFormation::Init': {
'config': {
'files': {
'/etc/haproxy/haproxy.cfg': {
'content': ha_cfg
}
}
}
}
}
md = mock.Mock()
md.metadata_get.return_value = copy.deepcopy(initial_md)
rsrc.nested = mock.Mock(return_value={'LB_instance': md})
prop_diff = {'Instances': ['WikiServerOne1', 'WikiServerOne2']}
props = copy.copy(rsrc.properties.data)
props.update(prop_diff)
update_defn = rsrc_defn.ResourceDefinition(rsrc.name, rsrc.type(),
props)
rsrc.handle_update(update_defn, {}, prop_diff)
self.assertIsNone(rsrc.handle_update(rsrc.t, {}, {}))
md.metadata_get.assert_called_once_with()
md.metadata_set.assert_called_once_with(expected_md)
def create_loadbalancer(self, t, stack, resource_name):
resource_defns = stack.t.resource_definitions(stack)
rsrc = lb.LoadBalancer(resource_name, resource_defns[resource_name],
stack)
self.assertIsNone(rsrc.validate())
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
return rsrc
def setup_loadbalancer(self, include_keyname=True):
template = template_format.parse(lb_template)
if not include_keyname:
del template['Parameters']['KeyName']
stack = utils.parse_stack(template)
resource_name = 'LoadBalancer'
lb_defn = stack.t.resource_definitions(stack)[resource_name]
return lb.LoadBalancer(resource_name, lb_defn, stack)
def test_loadbalancer_validate_badtemplate(self):
cfg.CONF.set_override('loadbalancer_template', '/a/noexist/x.y')
t = template_format.parse(lb_template)
s = utils.parse_stack(t)
s.store()
rsrc = lb.LoadBalancer('LoadBalancer', t['Resources']['LoadBalancer'],
s)
self.assertRaises(exception.StackValidationFailed, rsrc.validate)
