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_cluster_data(self):
collection = cloud_models.Collection()
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.assertEqual(
self.cloud_driver.cluster_data(collection), {
'containers': [],
'tasks': [],
'proxyconf': {
'backends': ['somebackend'],
'domains': {
'example.com': {
'/foo/bar': {
'destination': 'somebackend/somepath',
'type': 'backend'
}
}
}
}
})
def test_init_with_args(self):
c = models.Collection(
nodes=mock.sentinel.nodes,
security_groups=mock.sentinel.security_groups,
security_group_rules=mock.sentinel.security_group_rules)
self.assertEqual(mock.sentinel.nodes, c.nodes)
self.assertEqual(mock.sentinel.security_groups, c.security_groups)
self.assertEqual(mock.sentinel.security_group_rules,
c.security_group_rules)
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_update_cluster(self):
self.collection = models.Collection()
class TestDriver(base.CloudDriver):
def cluster_json(selff, collection):
self.assertEquals(collection, self.collection)
return '"thejson"'
driver = TestDriver()
driver.cluster = mock.MagicMock()
driver.update_cluster(self.collection)
driver.cluster.update.assert_called_with(json='"thejson"')
def test_sub(self):
c1 = models.Collection()
c2 = models.Collection()
n1 = NamedItem('node1')
n2 = NamedItem('node2')
n3 = NamedItem('node3')
sg1 = NamedItem('securitygroup1')
sg2 = NamedItem('securitygroup2')
sg3 = NamedItem('securitygroup3')
sgr1 = NamedItem('securitygrouprule1')
sgr2 = NamedItem('securitygrouprule2')
sgr3 = NamedItem('securitygrouprule3')
c1.nodes.add(n1)
c2.nodes.add(n1)
c2.nodes.add(n2)
c2.nodes.add(n3)
c1.security_groups.add(sg1)
c2.security_groups.add(sg1)
c2.security_groups.add(sg2)
c2.security_groups.add(sg3)
c1.security_group_rules.add(sgr1)
c2.security_group_rules.add(sgr1)
c2.security_group_rules.add(sgr2)
c2.security_group_rules.add(sgr3)
c_diff = c2 - c1
c_expected = models.Collection()
c_expected.nodes.add(n2)
c_expected.nodes.add(n3)
c_expected.security_groups.add(sg2)
c_expected.security_groups.add(sg3)
c_expected.security_group_rules.add(sgr2)
c_expected.security_group_rules.add(sgr3)
self.assertEqual(c_expected, c_diff)
def test_cluster_json(self):
self.collection = models.Collection()
class TestDriver(base.CloudDriver):
def cluster_data(selff, collection):
self.assertEqual(collection, self.collection)
return {'foo': ['bar', 'baz']}
driver = TestDriver()
self.assertEqual(json.loads(driver.cluster_json(self.collection)),
{'foo': ['bar', 'baz']})
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 detect_resources(self):
collection = cloud_models.Collection()
LOG.info('Detecting nodes')
for node in self.detect_nodes():
collection.nodes.add(node)
LOG.info('Detecting security groups and security group rules')
security_groups, security_group_rules = self.detect_firewalls()
for security_group in security_groups:
collection.security_groups.add(security_group)
for security_group_rule in security_group_rules:
collection.security_group_rules.add(security_group_rule)
collection.connect()
return collection
def load(fpath, substitutions=None):
data = load_yaml(fpath)[0]
collection = cloud_models.Collection()
for urlconf in build_urls(data, substitutions):
collection.urls.append(urlconf)
for node in build_nodes(data, substitutions):
collection.nodes.add(node)
collection.containers = data.get('containers', [])
security_groups, security_group_rules = build_security_groups_and_rules(data)
for security_group in security_groups:
collection.security_groups.add(security_group)
for security_group_rule in security_group_rules:
collection.security_group_rules.add(security_group_rule)
collection.connect()
return 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
}]
}
}
}
})
def test_init(self):
c = models.Collection()
self.assertEqual(models.NamedSet(), c.nodes)
self.assertEqual(models.NamedSet(), c.security_groups)
self.assertEqual(models.NamedSet(), c.security_group_rules)
