def _example_collection(self):
collection = cloud_models.Collection()
webappsg = cloud_models.SecurityGroup(name='webapp')
collection.nodes.add(cloud_models.Node(name='webapp',
image='trusty',
flavor='n1-standard-2',
disk=37,
networks=[],
security_groups=set([webappsg]),
private=mock.sentinel.webapp1priv))
collection.nodes.add(cloud_models.Node(name='webapp2',
image='trusty',
flavor='n1-standard-2',
disk=37,
networks=[],
security_groups=set([webappsg]),
script='#!/bin/bash\necho hello\n',
private=mock.sentinel.webapp2priv))
collection.security_groups.add(webappsg)
collection.security_group_rules.add(cloud_models.SecurityGroupRule(security_group=webappsg,
source_ip='0.0.0.0/0',
from_port=443,
to_port=443,
protocol='tcp'))
collection.security_group_rules.add(cloud_models.SecurityGroupRule(security_group=webappsg,
source_ip='212.10.10.10/32',
from_port=8000,
to_port=8080,
protocol='tcp'))
return collection
def test_detect_resources(self):
node1 = models.Node(name='node1',
flavor='n1-standard-4',
image='ubuntu1404-12345678',
networks=[],
disk=20)
node2 = models.Node(name='node2',
flavor='n1-standard-4',
image='ubuntu1404-12345678',
networks=[],
disk=20)
node1.security_group_names = set(['webapp', 'ssh'])
node2.security_group_names = set(['webapp'])
sg_webapp = models.SecurityGroup(name='webapp')
sg_ssh = models.SecurityGroup(name='ssh')
sgr_https = models.SecurityGroupRule(security_group=sg_webapp,
source_ip='0.0.0.0/0',
from_port=443,
to_port=443,
protocol='tcp')
sgr_ssh = models.SecurityGroupRule(security_group=sg_ssh,
source_ip='0.0.0.0/0',
from_port=22,
to_port=22,
protocol='tcp')
class TestDriver(base.CloudDriver):
def detect_nodes(self):
return set([node1, node2])
def detect_firewalls(self):
return (set([sg_webapp, sg_ssh]), set([sgr_https, sgr_ssh]))
cloud_driver = TestDriver()
collection = cloud_driver.detect_resources()
self.assertIn(node1, collection.nodes)
self.assertIn(node2, collection.nodes)
self.assertIn(sg_webapp, collection.nodes['node1'].security_groups)
self.assertIn(sg_ssh, collection.nodes['node1'].security_groups)
self.assertIn(sg_webapp, collection.nodes['node2'].security_groups)
self.assertIn(sg_webapp, collection.security_groups)
self.assertIn(sg_ssh, collection.security_groups)
self.assertIn(sgr_https, collection.security_group_rules)
self.assertIn(sgr_ssh, collection.security_group_rules)
def test_with_urls(self, log):
collection = loader.load(
self._get_full_path_for_test_data('with_urls.yaml'),
substitutions={'domain': 'example.com'})
self.assertIn(
cloud_models.URLConfStatic(hostname='example.com',
path='/',
local_path='www'), collection.urls)
self.assertIn(
cloud_models.URLConfBackend(hostname='example.com',
path='/api',
destination='webapp/api'),
collection.urls)
self.assertIn(
cloud_models.Node(name='webapp',
flavor='webapp',
image='trusty',
disk=10,
networks=[]), collection.nodes)
self.assertEqual(len(collection.nodes), 1)
self.assertEqual(len(collection.urls), 2)
log.check(('aasemble.deployment.loader', 'DEBUG',
'Loaded static URL ${domain}/ from stack'),
('aasemble.deployment.loader', 'DEBUG',
'Loaded backend URL ${domain}/api from stack'),
('aasemble.deployment.loader', 'DEBUG',
'Loaded node webapp from stack'))
def test_create_node(self, _add_namespace_info, _add_script_info, _add_key_pair_info, _block_device_mappings, _get_image, _get_size, connection):
node = cloud_models.Node(name='web1',
image='ami-1234567',
flavor='t2.small',
networks=[],
disk=27)
def _add_key_pair_info_side_effect(kwargs):
kwargs['added_key_pair_info'] = True
def _add_script_info_side_effect(node, kwargs):
kwargs['added_script_info'] = True
def _add_namespace_info_side_effect(kwargs):
kwargs['added_namespace_info'] = True
_add_key_pair_info.side_effect = _add_key_pair_info_side_effect
_add_script_info.side_effect = _add_script_info_side_effect
_add_namespace_info.side_effect = _add_namespace_info_side_effect
self.cloud_driver.create_node(node)
_get_image.assert_called_with('ami-1234567')
_get_size.assert_called_with('t2.small')
connection.create_node.assert_called_with(name='web1',
image=_get_image.return_value,
size=_get_size.return_value,
ex_security_groups=[],
ex_blockdevicemappings=[_block_device_mappings.return_value],
added_key_pair_info=True,
added_script_info=True,
added_namespace_info=True)
def test_create_node(self, _add_script_info, _add_key_pair_info,
_get_location, _get_image, _get_size, connection):
node = cloud_models.Node(name='web1',
image='127237412',
flavor='512mb',
networks=[],
disk=27)
def _add_key_pair_info_side_effect(kwargs):
kwargs['added_key_pair_info'] = True
def _add_script_info_side_effect(node, kwargs):
kwargs['added_script_info'] = True
_add_key_pair_info.side_effect = _add_key_pair_info_side_effect
_add_script_info.side_effect = _add_script_info_side_effect
self.cloud_driver.create_node(node)
_get_image.assert_called_with('127237412')
_get_size.assert_called_with('512mb')
connection.create_node.assert_called_with(
name='web1',
image=_get_image.return_value,
size=_get_size.return_value,
location=_get_location.return_value,
added_key_pair_info=True,
added_script_info=True)
def test_with_script(self, interpolate, log):
collection = loader.load(
self._get_full_path_for_test_data('with_script.yaml'))
sg = cloud_models.SecurityGroup(name='webapp')
script = '#!/bin/sh\nadduser --system web\napt-get install python-virtualenv\netc. etc. etc.\n'
self.assertIn(
cloud_models.Node(name='webapp1',
flavor='webapp',
image='trusty',
disk=10,
networks=[],
security_groups=set([sg]),
script=interpolate.return_value),
collection.nodes)
self.assertIn(
cloud_models.Node(name='webapp2',
flavor='webapp',
image='trusty',
disk=10,
networks=[],
security_groups=set([sg]),
script=interpolate.return_value),
collection.nodes)
interpolate.assert_called_with(script, None)
self.assertIn(sg, collection.security_groups)
self.assertIn(
cloud_models.SecurityGroupRule(security_group=sg,
source_ip='0.0.0.0/0',
from_port=443,
to_port=443,
protocol='tcp'),
collection.security_group_rules)
self.assertEqual(len(collection.nodes), 2)
self.assertEqual(len(collection.security_groups), 1)
self.assertEqual(len(collection.security_group_rules), 1)
log.check(('aasemble.deployment.loader', 'DEBUG',
'Loaded node webapp1 from stack'),
('aasemble.deployment.loader', 'DEBUG',
'Loaded node webapp2 from stack'),
('aasemble.deployment.loader', 'DEBUG',
'Loaded security group webapp from stack'),
('aasemble.deployment.loader', 'DEBUG',
'Loaded security group rule from stack: tcp: 443-443'))
def test_block_device_mappings(self):
node = cloud_models.Node(name='webapp',
image='trusty',
flavor='n1-standard-2',
disk=37,
networks=[],
script='foobar')
self.assertEqual(self.cloud_driver._block_device_mappings(node), {'DeviceName': '/dev/sda1', 'Ebs.VolumeSize': 37})
def _aasemble_node_from_provider_node(self, ec2node):
node = cloud_models.Node(name=ec2node.name,
flavor=ec2node.size,
image=ec2node.image,
disk=self.volume_size_map[ec2node.extra['block_device_mapping'][0]['ebs']['volume_id']],
networks=[],
private=ec2node)
node.security_group_names = set((v['group_name'] for v in ec2node.extra['groups']))
return node
def test_delete_node(self, connection):
webapp = cloud_models.Node(name='webapp',
image='trusty',
flavor='n1-standard-2',
disk=37,
networks=[],
security_groups=set(),
private=mock.sentinel.webapppriv)
self.cloud_driver.delete_node(webapp)
connection.destroy_node.assert_called_with(mock.sentinel.webapppriv)
def test_add_script_info_no_script(self):
node = cloud_models.Node(name='webapp',
image='trusty',
flavor='n1-standard-2',
disk=37,
networks=[])
kwargs = {}
self.cloud_driver._add_script_info(node, kwargs)
self.assertEqual(kwargs, {})
def _aasemble_node_from_provider_node(self, donode):
node = cloud_models.Node(name=donode.name,
flavor=donode.extra['size_slug'],
image=donode.extra['image']['id'],
disk=self.get_size(
donode.extra['size_slug']).disk,
networks=[],
private=donode)
node.security_group_names = set()
return node
def _aasemble_node_from_provider_node(self, gcenode):
node = cloud_models.Node(
name=gcenode.name,
flavor=gcenode.size,
image=gcenode.image,
disk=self.volume_size_map[gcenode.extra['disks'][0]['source']],
networks=[],
private=gcenode)
node.security_group_names = set(gcenode.extra['tags'])
return node
def test_add_script_info(self):
node = cloud_models.Node(name='webapp',
image='trusty',
flavor='n1-standard-2',
disk=37,
networks=[],
script='foobar')
kwargs = {}
self.cloud_driver._add_script_info(node, kwargs)
self.assertEqual(kwargs, {'ex_user_data': 'foobar'})
def _test_get_namespace(self, extra, expected_rv):
class AWSNode(object):
def __init__(self, extra):
if extra is not None:
self.extra = extra
node = cloud_models.Node(name='webapp',
image='trusty',
flavor='n1-standard-2',
disk=37,
networks=[])
node.private = AWSNode(extra)
self.assertEqual(self.cloud_driver.get_namespace(node), expected_rv)
def test_with_security_groups(self, log):
collection = loader.load(
self._get_full_path_for_test_data('with_security_groups.yaml'))
sg = cloud_models.SecurityGroup(name='webapp')
self.assertIn(
cloud_models.Node(name='webapp1',
flavor='webapp',
image='trusty',
disk=10,
networks=[],
security_groups=set([sg])), collection.nodes)
self.assertIn(
cloud_models.Node(name='webapp2',
flavor='webapp',
image='trusty',
disk=10,
networks=[],
security_groups=set([sg])), collection.nodes)
self.assertIn(sg, collection.security_groups)
self.assertIn(
cloud_models.SecurityGroupRule(security_group=sg,
source_ip='0.0.0.0/0',
from_port=443,
to_port=443,
protocol='tcp'),
collection.security_group_rules)
self.assertEqual(len(collection.nodes), 2)
self.assertEqual(len(collection.security_groups), 1)
self.assertEqual(len(collection.security_group_rules), 1)
log.check(('aasemble.deployment.loader', 'DEBUG',
'Loaded node webapp1 from stack'),
('aasemble.deployment.loader', 'DEBUG',
'Loaded node webapp2 from stack'),
('aasemble.deployment.loader', 'DEBUG',
'Loaded security group webapp from stack'),
('aasemble.deployment.loader', 'DEBUG',
'Loaded security group rule from stack: tcp: 443-443'))
def test_plurality(self, log):
collection = loader.load(
self._get_full_path_for_test_data('plurality.yaml'))
self.assertIn(
cloud_models.Node(name='webapp1',
flavor='webapp',
image='trusty',
disk=10,
networks=[]), collection.nodes)
self.assertIn(
cloud_models.Node(name='webapp2',
flavor='webapp',
image='trusty',
disk=10,
networks=[]), collection.nodes)
self.assertEqual(len(collection.nodes), 2)
self.assertEqual(len(collection.security_groups), 0)
self.assertEqual(len(collection.security_group_rules), 0)
log.check(('aasemble.deployment.loader', 'DEBUG',
'Loaded node webapp1 from stack'),
('aasemble.deployment.loader', 'DEBUG',
'Loaded node webapp2 from stack'))
def test_as_dict(self):
node = models.Node(name='nodename',
image='someimage',
flavor='someflavor',
disk=27,
networks=[])
self.assertEquals(
node.as_dict(), {
'disk': 27,
'flavor': 'someflavor',
'image': 'someimage',
'name': 'nodename',
'public_ips': [],
'script': None,
'security_groups': []
})
def _test_get_namespace(self, metadata, expected_rv):
class GCENode(mock.MagicMock):
pass
node = cloud_models.Node(name='webapp',
image='trusty',
flavor='n1-standard-2',
disk=37,
networks=[])
node.private = GCENode()
node.private.extra = {}
if metadata:
node.private.extra['metadata'] = metadata
self.assertEqual(self.cloud_driver.get_namespace(node), expected_rv)
def test_format_collection(self):
collection = cloud_models.Collection()
class GCENode(object):
def __init__(self, ip):
self.public_ips = [ip]
collection.nodes.add(
cloud_models.Node(name='testnode',
flavor='n1-standard-1',
image='someimage',
networks=[],
disk=10,
private=GCENode('10.0.0.1')))
self.assertEquals(
aasemble.deployment.cli.format_collection(collection),
"Nodes:\n testnode: 10.0.0.1\n")
def test_disk_struct(self, _resolve_image_name, apply_mappings, _get_disk_type, connection):
node = cloud_models.Node(name='webapp',
image='trusty',
flavor='n1-standard-2',
disk=37,
networks=[])
apply_mappings.return_value = 'mappedtrusty'
_get_disk_type.return_value = 'http://disktypelink'
_resolve_image_name.return_value = 'http://mappedtrusty'
self.assertEqual(self.cloud_driver._disk_struct(node), [{'boot': True,
'autoDelete': True,
'initializeParams': {
'sourceImage': 'http://mappedtrusty',
'diskType': 'http://disktypelink',
'diskSizeGb': 37}}])
_resolve_image_name.assert_called_with('mappedtrusty')
apply_mappings.assert_called_with('images', 'trusty')
def build_nodes(data, substitutions=None):
collection = set()
for name in data.get('nodes', {}):
node_info = data['nodes'][name]
if 'count' in node_info:
names = ['%s%d' % (name, idx) for idx in range(1, node_info['count'] + 1)]
else:
names = [name]
for name in names:
LOG.debug('Loaded node %s from stack' % name)
node = cloud_models.Node(name=name,
flavor=node_info['flavor'],
image=node_info['image'],
disk=node_info['disk'],
networks=node_info.get('networks', []),
script=interpolate(node_info.get('script', None), substitutions))
node.security_group_names = node_info.get('security_groups', [])
collection.add(node)
return collection
def setUp(self):
self.sg1 = cloud_models.SecurityGroup(name='sg1')
self.sgr1 = cloud_models.SecurityGroupRule(security_group=self.sg1,
from_port=443,
to_port=443,
source_ip='0.0.0.0/0',
protocol='tcp')
self.sgr2 = cloud_models.SecurityGroupRule(security_group=self.sg1,
from_port=80,
to_port=80,
source_ip='0.0.0.0/0',
protocol='tcp')
self.node1 = cloud_models.Node(name='node1',
image='image',
flavor='image',
networks=[],
disk=10,
security_groups=set([self.sg1]))
self.current = cloud_models.Collection()
self.desired = cloud_models.Collection()
def test_connect(self):
c = models.Collection()
n = models.Node(name='node1',
flavor='flavor',
image='image',
networks=[],
disk=10)
n.security_group_names = ['securitygroup1', 'securitygroup2']
sg1 = NamedItem('securitygroup1')
sg2 = NamedItem('securitygroup2')
sg3 = NamedItem('securitygroup3')
c.nodes.add(n)
c.security_groups.add(sg1)
c.security_groups.add(sg2)
c.security_groups.add(sg3)
c.connect()
self.assertIn(sg1, n.security_groups)
self.assertIn(sg2, n.security_groups)
def test_cluster_data(self):
collection = cloud_models.Collection()
lb = cloud_models.Node(name='lb',
image='trusty',
flavor='512mb',
disk=27,
networks=[])
web1 = cloud_models.Node(name='web1',
image='trusty',
flavor='512mb',
disk=27,
networks=[])
web2 = cloud_models.Node(name='web2',
image='trusty',
flavor='512mb',
disk=27,
networks=[])
db = cloud_models.Node(name='db',
image='trusty',
flavor='512mb',
disk=27,
networks=[])
frontend_sg = cloud_models.SecurityGroup(name='frontend')
frontend_http_sgr = cloud_models.SecurityGroupRule(
security_group=frontend_sg,
source_ip='0.0.0.0/0',
from_port=80,
to_port=80,
protocol='tcp')
frontend_https_sgr = cloud_models.SecurityGroupRule(
security_group=frontend_sg,
source_ip='0.0.0.0/0',
from_port=443,
to_port=443,
protocol='tcp')
lb.security_groups.add(frontend_sg)
backend_sg = cloud_models.SecurityGroup(name='backend')
backend_http_sgr = cloud_models.SecurityGroupRule(
security_group=backend_sg,
source_group='frontend',
from_port=80,
to_port=80,
protocol='tcp')
web1.security_groups.add(backend_sg)
web2.security_groups.add(backend_sg)
db_sg = cloud_models.SecurityGroup(name='mysql')
mysql_sgr = cloud_models.SecurityGroupRule(security_group=db_sg,
source_group='backend',
from_port=3306,
to_port=3306,
protocol='tcp')
db.security_groups.add(db_sg)
collection.nodes.add(lb)
collection.nodes.add(web1)
collection.nodes.add(web2)
collection.nodes.add(db)
collection.nodes.add(db)
collection.security_groups.add(frontend_sg)
collection.security_groups.add(backend_sg)
collection.security_groups.add(db_sg)
collection.security_group_rules.add(frontend_http_sgr)
collection.security_group_rules.add(frontend_https_sgr)
collection.security_group_rules.add(backend_http_sgr)
collection.security_group_rules.add(mysql_sgr)
collection.urls.append(
cloud_models.URLConfStatic(hostname='example.com',
path='/foo/bar',
local_path='/data'))
collection.urls.append(
cloud_models.URLConfBackend(hostname='example.com',
path='/foo/bar',
destination='somebackend/somepath'))
self.maxDiff = None
self.assertEqual(
self.cloud_driver.cluster_data(collection), {
'containers': [{
'host_network': True,
'image': 'aasemble/fwmanager',
'name': 'fwmanager',
'nodes': '.*',
'privileged': True
}],
'tasks': [],
'proxyconf': {
'backends': ['somebackend'],
'domains': {
'example.com': {
'/foo/bar': {
'destination': 'somebackend/somepath',
'type': 'backend'
}
}
}
},
'fwconf': {
'security_groups': {
'backend': {
'nodes': ['web1', 'web2'],
'rules': [{
'from_port': 80,
'protocol': 'tcp',
'source_group': 'frontend',
'to_port': 80
}]
},
'frontend': {
'nodes': ['lb'],
'rules': [{
'from_port': 443,
'protocol': 'tcp',
'source_ip': '0.0.0.0/0',
'to_port': 443
}, {
'from_port': 80,
'protocol': 'tcp',
'source_ip': '0.0.0.0/0',
'to_port': 80
}]
},
'mysql': {
'nodes': ['db'],
'rules': [{
'from_port': 3306,
'protocol': 'tcp',
'source_group': 'backend',
'to_port': 3306
}]
}
}
}
})
