def create_env(self, mode):
cluster = self.env.create(cluster_kwargs={
'mode': mode,
'net_provider': 'neutron',
'net_segment_type': 'vlan'
},
nodes_kwargs=[{
'roles': ['controller'],
'pending_addition': True
}, {
'roles': ['controller'],
'pending_addition': True
}, {
'roles': ['controller', 'cinder'],
'pending_addition':
True
}, {
'roles': ['compute', 'cinder'],
'pending_addition': True
}, {
'roles': ['compute'],
'pending_addition': True
}, {
'roles': ['cinder'],
'pending_addition': True
}])
cluster_db = self.db.query(Cluster).get(cluster['id'])
TaskHelper.prepare_for_deployment(cluster_db.nodes)
return cluster_db
def create_env(self, nodes):
cluster = self.env.create(
nodes_kwargs=nodes)
cluster_db = self.db.query(Cluster).get(cluster['id'])
TaskHelper.prepare_for_deployment(cluster_db.nodes)
return cluster_db
def test_do_not_redeploy_nodes_in_ready_status(self):
self.env.create(nodes_kwargs=[
{"pending_addition": True},
{"pending_addition": True, 'roles': ['compute']}])
cluster_db = self.env.clusters[0]
# Generate ips, fqdns
TaskHelper.prepare_for_deployment(cluster_db.nodes)
# First node with status ready
# should not be readeployed
self.env.nodes[0].status = 'ready'
self.env.nodes[0].pending_addition = False
self.db.commit()
objects.Cluster.clear_pending_changes(cluster_db)
supertask = self.env.launch_deployment()
self.assertEquals(supertask.name, 'deploy')
self.assertIn(supertask.status, ('running', 'ready'))
self.assertEquals(self.env.nodes[0].status, 'ready')
self.env.wait_for_nodes_status([self.env.nodes[1]], 'provisioning')
self.env.wait_ready(supertask)
self.env.refresh_nodes()
self.assertEquals(self.env.nodes[1].status, 'ready')
self.assertEquals(self.env.nodes[1].progress, 100)
def test_do_not_redeploy_nodes_in_ready_status(self):
self.env.create(nodes_kwargs=[
{"pending_addition": True},
{"pending_addition": True, 'roles': ['compute']}])
cluster_db = self.env.clusters[0]
# Generate ips, fqdns
TaskHelper.prepare_for_deployment(cluster_db.nodes)
# First node with status ready
# should not be readeployed
self.env.nodes[0].status = 'ready'
self.env.nodes[0].pending_addition = False
self.db.commit()
cluster_db.clear_pending_changes()
supertask = self.env.launch_deployment()
self.assertEquals(supertask.name, 'deploy')
self.assertIn(supertask.status, ('running', 'ready'))
self.assertEquals(self.env.nodes[0].status, 'ready')
self.env.wait_for_nodes_status([self.env.nodes[1]], 'provisioning')
self.env.wait_ready(supertask)
self.env.refresh_nodes()
self.assertEquals(self.env.nodes[1].status, 'ready')
self.assertEquals(self.env.nodes[1].progress, 100)
def _create_cluster_for_vlan_splinters(self, segment_type='gre'):
meta = {
'interfaces': [
{'name': 'eth0', 'mac': self.env._generate_random_mac()},
{'name': 'eth1', 'mac': self.env._generate_random_mac()},
{'name': 'eth2', 'mac': self.env._generate_random_mac()},
{'name': 'eth3', 'mac': self.env._generate_random_mac()},
{'name': 'eth4', 'mac': self.env._generate_random_mac()}
]
}
cluster = self.env.create(
cluster_kwargs={
'mode': 'multinode',
'net_provider': 'neutron',
'net_segment_type': segment_type
},
nodes_kwargs=[
{'roles': ['controller'], 'pending_addition': True,
'meta': meta}
]
)
cluster_db = self.db.query(Cluster).get(cluster['id'])
TaskHelper.prepare_for_deployment(cluster_db.nodes)
return cluster_db
def create_env(self, nodes):
cluster = self.env.create(cluster_kwargs={'mode': 'ha_compact'},
nodes_kwargs=nodes)
cluster_db = self.db.query(Cluster).get(cluster['id'])
TaskHelper.prepare_for_deployment(cluster_db.nodes)
return cluster_db
def create_env(self, mode, network_manager='FlatDHCPManager'):
node_args = [{
'roles': ['controller', 'cinder'],
'pending_addition': True
}, {
'roles': ['compute', 'cinder'],
'pending_addition': True
}, {
'roles': ['compute'],
'pending_addition': True
}, {
'roles': ['mongo'],
'pending_addition': True
}, {
'roles': [],
'pending_roles': ['cinder'],
'pending_addition': True
}]
cluster = self.env.create(cluster_kwargs={
'mode': mode,
'net_manager': network_manager
},
nodes_kwargs=node_args)
cluster_db = self.db.query(Cluster).get(cluster['id'])
TaskHelper.prepare_for_deployment(cluster_db.nodes)
return cluster_db
def _create_cluster_for_vlan_splinters(self, segment_type='gre'):
meta = {
'interfaces': [
{'name': 'eth0', 'mac': self.env._generate_random_mac()},
{'name': 'eth1', 'mac': self.env._generate_random_mac()},
{'name': 'eth2', 'mac': self.env._generate_random_mac()},
{'name': 'eth3', 'mac': self.env._generate_random_mac()},
{'name': 'eth4', 'mac': self.env._generate_random_mac()}
]
}
cluster = self.env.create(
cluster_kwargs={
'mode': 'multinode',
'net_provider': 'neutron',
'net_segment_type': segment_type
},
nodes_kwargs=[
{'roles': ['controller'], 'pending_addition': True,
'meta': meta}
]
)
cluster_db = self.db.query(Cluster).get(cluster['id'])
TaskHelper.prepare_for_deployment(cluster_db.nodes)
return cluster_db
def test_repo_and_puppet_data(self):
release_id = self.env.create_release().id
orch_data = {
"repo_metadata": {
"nailgun":
"http://10.20.0.2:8080/centos-5.0/centos/fuelweb/x86_64/"
},
"puppet_modules_source":
"rsync://10.20.0.2/puppet/release/5.0/modules",
"puppet_manifests_source":
"rsync://10.20.0.2/puppet/release/5.0/manifests"
}
resp = self.app.put(
reverse('ReleaseHandler', kwargs={'obj_id': release_id}),
params=json.dumps(
{
"orchestrator_data": orch_data
}
),
headers=self.default_headers,
expect_errors=True
)
self.assertEquals(200, resp.status_code)
cluster_id = self.env.create(
cluster_kwargs={
'release_id': release_id
},
nodes_kwargs=[
{'roles': ['controller'], 'pending_addition': True}
]
)["id"]
cluster = self.db.query(Cluster).get(cluster_id)
TaskHelper.prepare_for_deployment(cluster.nodes)
facts = self.serializer.serialize(cluster, cluster.nodes)
self.assertEquals(1, len(facts))
fact = facts[0]
self.assertEquals(
fact['repo_metadata'],
{
'nailgun': 'http://10.20.0.2:8080'
'/centos-5.0/centos/fuelweb/x86_64/'
}
)
self.assertEquals(
fact['puppet_modules_source'],
'rsync://10.20.0.2/puppet/release/5.0/modules'
)
self.assertEquals(
fact['puppet_manifests_source'],
'rsync://10.20.0.2/puppet/release/5.0/manifests'
)
def serialize(cluster, nodes):
"""Serialization depends on deployment mode
"""
TaskHelper.prepare_for_deployment(cluster.nodes)
if cluster.mode == 'multinode':
serializer = DeploymentMultinodeSerializer
elif cluster.is_ha_mode:
serializer = DeploymentHASerializer
return serializer.serialize(cluster, nodes)
def serialize(cluster, nodes):
"""Serialization depends on deployment mode
"""
TaskHelper.prepare_for_deployment(cluster.nodes)
if cluster.mode == 'multinode':
serializer = DeploymentMultinodeSerializer
elif cluster.is_ha_mode:
serializer = DeploymentHASerializer
return serializer.serialize(cluster, nodes)
def create_env(self, mode, network_manager="FlatDHCPManager"):
node_args = [
{"roles": ["controller", "cinder"], "pending_addition": True},
{"roles": ["compute", "cinder"], "pending_addition": True},
{"roles": ["compute"], "pending_addition": True},
{"roles": [], "pending_roles": ["cinder"], "pending_addition": True},
]
cluster = self.env.create(cluster_kwargs={"mode": mode, "net_manager": network_manager}, nodes_kwargs=node_args)
cluster_db = self.db.query(Cluster).get(cluster["id"])
TaskHelper.prepare_for_deployment(cluster_db.nodes)
return cluster_db
def test_serialize_node(self):
node = self.env.create_node(api=True, cluster_id=self.cluster.id, pending_addition=True)
TaskHelper.prepare_for_deployment(self.cluster.nodes)
node_db = self.db.query(Node).get(node["id"])
serialized_data = self.serializer.serialize_node(node_db, "controller")
self.assertEquals(serialized_data["role"], "controller")
self.assertEquals(serialized_data["uid"], str(node_db.id))
self.assertEquals(serialized_data["status"], node_db.status)
self.assertEquals(serialized_data["online"], node_db.online)
self.assertEquals(serialized_data["fqdn"], "node-%d.%s" % (node_db.id, settings.DNS_DOMAIN))
def create_env(self, mode, segment_type="vlan"):
cluster = self.env.create(
cluster_kwargs={"mode": mode, "net_provider": "neutron", "net_segment_type": segment_type},
nodes_kwargs=[
{"roles": ["controller", "cinder"], "pending_addition": True},
{"roles": ["compute", "cinder"], "pending_addition": True},
{"roles": ["compute"], "pending_addition": True},
{"roles": [], "pending_roles": ["cinder"], "pending_addition": True},
],
)
cluster_db = self.db.query(Cluster).get(cluster["id"])
TaskHelper.prepare_for_deployment(cluster_db.nodes)
return cluster_db
def test_serialize_node(self):
node = self.env.create_node(
api=True, cluster_id=self.cluster.id, pending_addition=True)
TaskHelper.prepare_for_deployment(self.cluster.nodes)
node_db = self.db.query(Node).get(node['id'])
serialized_data = self.serializer.serialize_node(node_db, 'controller')
self.assertEquals(serialized_data['role'], 'controller')
self.assertEquals(serialized_data['uid'], str(node_db.id))
self.assertEquals(serialized_data['status'], node_db.status)
self.assertEquals(serialized_data['online'], node_db.online)
self.assertEquals(serialized_data['fqdn'],
'node-%d.%s' % (node_db.id, settings.DNS_DOMAIN))
def test_serialize_node(self):
node = self.env.create_node(
api=True, cluster_id=self.cluster.id, pending_addition=True)
TaskHelper.prepare_for_deployment(self.cluster.nodes)
node_db = self.db.query(Node).get(node['id'])
serialized_data = self.serializer.serialize_node(node_db, 'controller')
self.assertEquals(serialized_data['role'], 'controller')
self.assertEquals(serialized_data['uid'], str(node_db.id))
self.assertEquals(serialized_data['status'], node_db.status)
self.assertEquals(serialized_data['online'], node_db.online)
self.assertEquals(serialized_data['fqdn'],
'node-%d.%s' % (node_db.id, settings.DNS_DOMAIN))
def create_env(self):
cluster = self.env.create(
cluster_kwargs={
'mode': 'ha_compact',
'network_manager': 'FlatDHCPManager'
},
nodes_kwargs=[
{'roles': ['mongo'], 'pending_addition': True},
{'roles': ['mongo'], 'pending_addition': True},
{'roles': ['mongo'], 'pending_addition': True}
]
)
cluster = self.db.query(Cluster).get(cluster['id'])
TaskHelper.prepare_for_deployment(cluster.nodes)
return cluster
def create_env(self, mode):
cluster = self.env.create(
cluster_kwargs={"mode": mode},
nodes_kwargs=[
{"roles": ["controller"], "pending_addition": True},
{"roles": ["controller"], "pending_addition": True},
{"roles": ["controller", "cinder"], "pending_addition": True},
{"roles": ["compute", "cinder"], "pending_addition": True},
{"roles": ["compute"], "pending_addition": True},
{"roles": ["cinder"], "pending_addition": True},
],
)
cluster_db = self.db.query(Cluster).get(cluster["id"])
TaskHelper.prepare_for_deployment(cluster_db.nodes)
return cluster_db
def create_env(self, mode):
cluster = self.env.create(
cluster_kwargs={
'mode': mode,
},
nodes_kwargs=[
{'roles': ['controller'], 'pending_addition': True},
{'roles': ['controller'], 'pending_addition': True},
{'roles': ['controller', 'cinder'], 'pending_addition': True},
{'roles': ['compute', 'cinder'], 'pending_addition': True},
{'roles': ['compute'], 'pending_addition': True},
{'roles': ['cinder'], 'pending_addition': True}])
cluster_db = self.db.query(Cluster).get(cluster['id'])
TaskHelper.prepare_for_deployment(cluster_db.nodes)
return cluster_db
def create_env(self, mode, network_manager='FlatDHCPManager'):
node_args = [
{'roles': ['controller', 'cinder'], 'pending_addition': True},
{'roles': ['compute', 'cinder'], 'pending_addition': True},
{'roles': ['compute'], 'pending_addition': True},
{'roles': [], 'pending_roles': ['cinder'],
'pending_addition': True}]
cluster = self.env.create(
cluster_kwargs={
'mode': mode,
'net_manager': network_manager},
nodes_kwargs=node_args)
cluster_db = self.db.query(Cluster).get(cluster['id'])
TaskHelper.prepare_for_deployment(cluster_db.nodes)
return cluster_db
def create_env(self, mode, segment_type='vlan'):
cluster = self.env.create(
cluster_kwargs={
'mode': mode,
'net_provider': 'neutron',
'net_segment_type': segment_type
},
nodes_kwargs=[
{'roles': ['controller', 'cinder'], 'pending_addition': True},
{'roles': ['compute', 'cinder'], 'pending_addition': True},
{'roles': ['compute'], 'pending_addition': True},
{'roles': [], 'pending_roles': ['cinder'],
'pending_addition': True}])
cluster_db = self.db.query(Cluster).get(cluster['id'])
TaskHelper.prepare_for_deployment(cluster_db.nodes)
return cluster_db
def _create_cluster_for_vlan_splinters(self, segment_type="gre"):
meta = {
"interfaces": [
{"name": "eth0", "mac": self.env._generate_random_mac()},
{"name": "eth1", "mac": self.env._generate_random_mac()},
{"name": "eth2", "mac": self.env._generate_random_mac()},
{"name": "eth3", "mac": self.env._generate_random_mac()},
{"name": "eth4", "mac": self.env._generate_random_mac()},
]
}
cluster = self.env.create(
cluster_kwargs={"mode": "multinode", "net_provider": "neutron", "net_segment_type": segment_type},
nodes_kwargs=[{"roles": ["controller"], "pending_addition": True, "meta": meta}],
)
cluster_db = self.db.query(Cluster).get(cluster["id"])
TaskHelper.prepare_for_deployment(cluster_db.nodes)
return cluster_db
def create_env(self):
cluster = self.env.create(cluster_kwargs={
'mode': 'ha_compact',
'network_manager': 'FlatDHCPManager'
},
nodes_kwargs=[{
'roles': ['mongo'],
'pending_addition': True
}, {
'roles': ['mongo'],
'pending_addition': True
}, {
'roles': ['mongo'],
'pending_addition': True
}])
cluster = self.db.query(Cluster).get(cluster['id'])
TaskHelper.prepare_for_deployment(cluster.nodes)
return cluster
def test_repo_and_puppet_data(self):
release_id = self.env.create_release().id
orch_data = {
"repo_metadata": {
"nailgun":
"http://10.20.0.2:8080/centos-5.0/centos/fuelweb/x86_64/"
},
"puppet_modules_source":
"rsync://10.20.0.2/puppet/release/5.0/modules",
"puppet_manifests_source":
"rsync://10.20.0.2/puppet/release/5.0/manifests"
}
resp = self.app.put(reverse('ReleaseHandler',
kwargs={'obj_id': release_id}),
params=json.dumps({"orchestrator_data":
orch_data}),
headers=self.default_headers,
expect_errors=True)
self.assertEquals(200, resp.status_code)
cluster_id = self.env.create(cluster_kwargs={'release_id': release_id},
nodes_kwargs=[{
'roles': ['controller'],
'pending_addition': True
}])["id"]
cluster = self.db.query(Cluster).get(cluster_id)
TaskHelper.prepare_for_deployment(cluster.nodes)
facts = self.serializer.serialize(cluster, cluster.nodes)
self.assertEquals(1, len(facts))
fact = facts[0]
self.assertEquals(
fact['repo_metadata'], {
'nailgun':
'http://10.20.0.2:8080'
'/centos-5.0/centos/fuelweb/x86_64/'
})
self.assertEquals(fact['puppet_modules_source'],
'rsync://10.20.0.2/puppet/release/5.0/modules')
self.assertEquals(fact['puppet_manifests_source'],
'rsync://10.20.0.2/puppet/release/5.0/manifests')
def serialize(self, cluster):
TaskHelper.prepare_for_deployment(cluster.nodes)
return DeploymentMultinodeSerializer.serialize(cluster, cluster.nodes)
def serialize(self, cluster):
TaskHelper.prepare_for_deployment(cluster.nodes)
return DeploymentMultinodeSerializer.serialize(cluster, cluster.nodes)
