def test_create(self, mock_openstack_client_class, mock_driver, mock_cm,
mock_trust_manager, mock_heat_poller_class):
timeout = 15
mock_poller = mock.MagicMock()
mock_poller.poll_and_check.return_value = loopingcall.LoopingCallDone()
mock_heat_poller_class.return_value = mock_poller
osc = mock.sentinel.osc
def return_keystone():
return self.keystone_client
osc.keystone = return_keystone
mock_openstack_client_class.return_value = osc
mock_dr = mock.MagicMock()
mock_driver.return_value = mock_dr
def create_stack_side_effect(context, osc, cluster, timeout):
return {'stack': {'id': 'stack-id'}}
mock_dr.create_stack.side_effect = create_stack_side_effect
# Just create a new cluster, since the one in setUp is already
# created and the previous solution seems kind of hacky.
cluster_dict = utils.get_test_cluster(node_count=1)
cluster = objects.Cluster(self.context, **cluster_dict)
node_count = 1
master_count = 1
del cluster_dict['id']
del cluster_dict['uuid']
cluster_obj = objects.Cluster(self.context, **cluster_dict)
cluster = self.handler.cluster_create(self.context, cluster_obj,
master_count, node_count,
timeout)
notifications = fake_notifier.NOTIFICATIONS
self.assertEqual(1, len(notifications))
self.assertEqual('magnum.cluster.create', notifications[0].event_type)
self.assertEqual(taxonomy.OUTCOME_PENDING,
notifications[0].payload['outcome'])
mock_dr.create_cluster.assert_called_once_with(self.context, cluster,
timeout)
mock_cm.generate_certificates_to_cluster.assert_called_once_with(
cluster, context=self.context)
self.assertEqual(cluster_status.CREATE_IN_PROGRESS, cluster.status)
mock_trust_manager.create_trustee_and_trust.assert_called_once_with(
osc, cluster)
self.assertEqual(2, len(cluster.nodegroups))
self.assertEqual(node_count, cluster.node_count)
self.assertEqual(master_count, cluster.master_count)
self.assertEqual(node_count, cluster.default_ng_worker.node_count)
self.assertEqual(master_count, cluster.default_ng_master.node_count)
def setUp(self):
super(PeriodicTestCase, self).setUp()
ctx = context.make_admin_context()
# Can be identical for all clusters.
trust_attrs = {
'trustee_username': '******',
'trustee_password': '******',
'trust_id': '39d920ca-67c6-4047-b57a-01e9e16bb96f',
}
trust_attrs.update({
'id': 1,
'stack_id': '11',
'status': cluster_status.CREATE_IN_PROGRESS
})
cluster1 = utils.get_test_cluster(**trust_attrs)
trust_attrs.update({
'id': 2,
'stack_id': '22',
'status': cluster_status.DELETE_IN_PROGRESS
})
cluster2 = utils.get_test_cluster(**trust_attrs)
trust_attrs.update({
'id': 3,
'stack_id': '33',
'status': cluster_status.UPDATE_IN_PROGRESS
})
cluster3 = utils.get_test_cluster(**trust_attrs)
trust_attrs.update({
'id': 4,
'stack_id': '44',
'status': cluster_status.CREATE_COMPLETE
})
cluster4 = utils.get_test_cluster(**trust_attrs)
trust_attrs.update({
'id': 5,
'stack_id': '55',
'status': cluster_status.ROLLBACK_IN_PROGRESS
})
cluster5 = utils.get_test_cluster(**trust_attrs)
self.cluster1 = objects.Cluster(ctx, **cluster1)
self.cluster2 = objects.Cluster(ctx, **cluster2)
self.cluster3 = objects.Cluster(ctx, **cluster3)
self.cluster4 = objects.Cluster(ctx, **cluster4)
self.cluster5 = objects.Cluster(ctx, **cluster5)
def test_extract_template_definition_with_lb_neutron(
self, mock_kc, mock_driver, mock_objects_nodegroup_list,
mock_objects_cluster_template_get_by_uuid):
self.cluster_template_dict['master_lb_enabled'] = True
cluster_template = objects.ClusterTemplate(
self.context, **self.cluster_template_dict)
mock_objects_cluster_template_get_by_uuid.return_value = \
cluster_template
cluster = objects.Cluster(self.context, **self.cluster_dict)
worker_ng = objects.NodeGroup(self.context, **self.worker_ng_dict)
master_ng = objects.NodeGroup(self.context, **self.master_ng_dict)
mock_objects_nodegroup_list.return_value = [master_ng, worker_ng]
mock_driver.return_value = mesos_dr.Driver()
mock_kc.return_value.client.services.list.return_value = []
(template_path, definition,
env_files) = mock_driver()._extract_template_definition(
self.context, cluster)
expected = {
'ssh_key_name': 'keypair_id',
'external_network': 'external_network_id',
'fixed_network': 'fixed_network',
'fixed_subnet': 'fixed_subnet',
'dns_nameserver': 'dns_nameserver',
'server_image': 'image_id',
'master_flavor': 'master_flavor_id',
'slave_flavor': 'flavor_id',
'number_of_slaves': 1,
'number_of_masters': 1,
'http_proxy': 'http_proxy',
'https_proxy': 'https_proxy',
'no_proxy': 'no_proxy',
'cluster_name': 'cluster1',
'trustee_domain_id': self.mock_keystone.trustee_domain_id,
'trustee_username': '******',
'trustee_password': '******',
'trustee_user_id': '7b489f04-b458-4541-8179-6a48a553e656',
'trust_id': '',
'volume_driver': 'volume_driver',
'auth_url': 'http://192.168.10.10:5000/v3',
'region_name': self.mock_osc.cinder_region_name.return_value,
'username': '******',
'tenant_name': 'admin',
'domain_name': 'domainname',
'rexray_preempt': 'False',
'mesos_slave_executor_env_variables': '{}',
'mesos_slave_isolation': 'docker/runtime,filesystem/linux',
'mesos_slave_work_dir': '/tmp/mesos/slave',
'mesos_slave_image_providers': 'docker',
'verify_ca': True,
'openstack_ca': '',
'nodes_affinity_policy': 'soft-anti-affinity'
}
self.assertEqual(expected, definition)
self.assertEqual([
'../../common/templates/environments/no_private_network.yaml',
'../../common/templates/environments/with_master_lb.yaml'
], env_files)
def test_extract_template_definition_multi_master(
self, mock_driver, mock_objects_cluster_template_get_by_uuid,
mock_get):
self.cluster_template_dict['master_lb_enabled'] = True
self.cluster_dict['master_count'] = 2
cluster_template = objects.ClusterTemplate(
self.context, **self.cluster_template_dict)
mock_objects_cluster_template_get_by_uuid.return_value = \
cluster_template
expected_result = str('{"action":"get","node":{"key":"test","value":'
'"2","modifiedIndex":10,"createdIndex":10}}')
mock_resp = mock.MagicMock()
mock_resp.text = expected_result
mock_get.return_value = mock_resp
mock_driver.return_value = swarm_dr.Driver()
cluster = objects.Cluster(self.context, **self.cluster_dict)
(template_path, definition,
env_files) = driver._extract_template_definition(
self.context, cluster)
expected = {
'ssh_key_name': 'keypair_id',
'external_network': 'external_network_id',
'dns_nameserver': 'dns_nameserver',
'server_image': 'image_id',
'master_flavor': 'master_flavor_id',
'node_flavor': 'flavor_id',
'number_of_masters': 2,
'number_of_nodes': 1,
'docker_volume_size': 20,
'docker_storage_driver': 'devicemapper',
'discovery_url': 'https://discovery.test.io/123456789',
'http_proxy': 'http_proxy',
'https_proxy': 'https_proxy',
'no_proxy': 'no_proxy',
'cluster_uuid': '5d12f6fd-a196-4bf0-ae4c-1f639a523a52',
'magnum_url': self.mock_osc.magnum_url.return_value,
'tls_disabled': False,
'registry_enabled': False,
'network_driver': 'network_driver',
'flannel_network_cidr': '10.101.0.0/16',
'flannel_network_subnetlen': '26',
'flannel_backend': 'vxlan',
'trustee_domain_id': self.mock_keystone.trustee_domain_id,
'trustee_username': '******',
'trustee_password': '******',
'trustee_user_id': '7b489f04-b458-4541-8179-6a48a553e656',
'trust_id': 'bd11efc5-d4e2-4dac-bbce-25e348ddf7de',
'auth_url': 'http://192.168.10.10:5000/v3',
'swarm_version': 'fake-version',
'swarm_strategy': u'spread',
'volume_driver': 'rexray',
'rexray_preempt': 'False'
}
self.assertEqual(expected, definition)
self.assertEqual([
'../../common/templates/environments/with_volume.yaml',
'../../common/templates/environments/with_master_lb.yaml'
], env_files)
def post(self, cluster):
"""Create a new cluster.
:param cluster: a cluster within the request body.
"""
context = pecan.request.context
policy.enforce(context, 'cluster:create',
action='cluster:create')
self._check_cluster_quota_limit(context)
temp_id = cluster.cluster_template_id
cluster_template = objects.ClusterTemplate.get_by_uuid(context,
temp_id)
# If keypair not present, use cluster_template value
if cluster.keypair is None:
cluster.keypair = cluster_template.keypair_id
# If docker_volume_size is not present, use cluster_template value
if (cluster.docker_volume_size == wtypes.Unset or
not cluster.docker_volume_size):
cluster.docker_volume_size = cluster_template.docker_volume_size
# If labels is not present, use cluster_template value
if cluster.labels == wtypes.Unset:
cluster.labels = cluster_template.labels
# If master_flavor_id is not present, use cluster_template value
if (cluster.master_flavor_id == wtypes.Unset or
not cluster.master_flavor_id):
cluster.master_flavor_id = cluster_template.master_flavor_id
# If flavor_id is not present, use cluster_template value
if cluster.flavor_id == wtypes.Unset or not cluster.flavor_id:
cluster.flavor_id = cluster_template.flavor_id
cluster_dict = cluster.as_dict()
attr_validator.validate_os_resources(context,
cluster_template.as_dict(),
cluster_dict)
attr_validator.validate_master_count(cluster_dict,
cluster_template.as_dict())
cluster_dict['project_id'] = context.project_id
cluster_dict['user_id'] = context.user_id
# NOTE(yuywz): We will generate a random human-readable name for
# cluster if the name is not specified by user.
name = cluster_dict.get('name') or \
self._generate_name_for_cluster(context)
cluster_dict['name'] = name
cluster_dict['coe_version'] = None
cluster_dict['container_version'] = None
new_cluster = objects.Cluster(context, **cluster_dict)
new_cluster.uuid = uuid.uuid4()
pecan.request.rpcapi.cluster_create_async(new_cluster,
cluster.create_timeout)
return ClusterID(new_cluster.uuid)
def setUp(self):
super(MonitorsTestCase, self).setUp()
cluster = utils.get_test_cluster(node_addresses=['1.2.3.4'],
api_address='https://5.6.7.8:2376',
master_addresses=['10.0.0.6'])
self.cluster = objects.Cluster(self.context, **cluster)
self.monitor = swarm_monitor.SwarmMonitor(self.context, self.cluster)
self.v2_monitor = swarm_v2_monitor.SwarmMonitor(
self.context, self.cluster)
self.k8s_monitor = k8s_monitor.K8sMonitor(self.context, self.cluster)
self.mesos_monitor = mesos_monitor.MesosMonitor(
self.context, self.cluster)
p = mock.patch(
'magnum.drivers.swarm_fedora_atomic_v1.monitor.'
'SwarmMonitor.metrics_spec',
new_callable=mock.PropertyMock)
self.mock_metrics_spec = p.start()
self.mock_metrics_spec.return_value = self.test_metrics_spec
self.addCleanup(p.stop)
p2 = mock.patch(
'magnum.drivers.swarm_fedora_atomic_v2.monitor.'
'SwarmMonitor.metrics_spec',
new_callable=mock.PropertyMock)
self.mock_metrics_spec_v2 = p2.start()
self.mock_metrics_spec_v2.return_value = self.test_metrics_spec
self.addCleanup(p2.stop)
def _post(self, bay):
context = pecan.request.context
policy.enforce(context, 'bay:create',
action='bay:create')
baymodel = objects.ClusterTemplate.get_by_uuid(context,
bay.baymodel_id)
# If docker_volume_size is not present, use baymodel value
if bay.docker_volume_size == wtypes.Unset:
bay.docker_volume_size = baymodel.docker_volume_size
bay_dict = bay.as_dict()
bay_dict['keypair'] = baymodel.keypair_id
attr_validator.validate_os_resources(context, baymodel.as_dict(),
bay_dict)
attr_validator.validate_master_count(bay.as_dict(), baymodel.as_dict())
bay_dict['project_id'] = context.project_id
bay_dict['user_id'] = context.user_id
# NOTE(yuywz): We will generate a random human-readable name for
# bay if the name is not spcified by user.
name = bay_dict.get('name') or self._generate_name_for_bay(context)
bay_dict['name'] = name
bay_dict['coe_version'] = None
bay_dict['container_version'] = None
new_bay = objects.Cluster(context, **bay_dict)
new_bay.uuid = uuid.uuid4()
return new_bay
def post(self, cluster):
"""Create a new cluster.
:param cluster: a cluster within the request body.
"""
context = pecan.request.context
policy.enforce(context, 'cluster:create', action='cluster:create')
temp_id = cluster.cluster_template_id
cluster_template = objects.ClusterTemplate.get_by_uuid(
context, temp_id)
cluster_dict = cluster.as_dict()
attr_validator.validate_os_resources(context,
cluster_template.as_dict())
attr_validator.validate_master_count(cluster_dict,
cluster_template.as_dict())
cluster_dict['project_id'] = context.project_id
cluster_dict['user_id'] = context.user_id
# NOTE(yuywz): We will generate a random human-readable name for
# cluster if the name is not specified by user.
name = cluster_dict.get('name') or \
self._generate_name_for_cluster(context)
cluster_dict['name'] = name
cluster_dict['coe_version'] = None
cluster_dict['container_version'] = None
new_cluster = objects.Cluster(context, **cluster_dict)
new_cluster.uuid = uuid.uuid4()
pecan.request.rpcapi.cluster_create_async(new_cluster,
cluster.create_timeout)
return ClusterID(new_cluster.uuid)
def test_extract_template_definition_coreos_with_disovery(
self,
mock_driver,
mock_objects_cluster_template_get_by_uuid,
mock_get):
self.cluster_template_dict['cluster_distro'] = 'coreos'
cluster_template = objects.ClusterTemplate(
self.context, **self.cluster_template_dict)
mock_objects_cluster_template_get_by_uuid.return_value = \
cluster_template
expected_result = str('{"action":"get","node":{"key":"test","value":'
'"1","modifiedIndex":10,"createdIndex":10}}')
mock_resp = mock.MagicMock()
mock_resp.text = expected_result
mock_get.return_value = mock_resp
cluster = objects.Cluster(self.context, **self.cluster_dict)
mock_driver.return_value = k8s_coreos_dr.Driver()
(template_path,
definition,
env_files) = mock_driver()._extract_template_definition(self.context,
cluster)
expected = {
'ssh_key_name': 'keypair_id',
'external_network': 'external_network_id',
'dns_nameserver': 'dns_nameserver',
'server_image': 'image_id',
'minion_flavor': 'flavor_id',
'master_flavor': 'master_flavor_id',
'number_of_minions': 1,
'number_of_masters': 1,
'network_driver': 'network_driver',
'volume_driver': 'volume_driver',
'discovery_url': 'https://discovery.etcd.io/test',
'http_proxy': 'http_proxy',
'https_proxy': 'https_proxy',
'no_proxy': 'no_proxy',
'flannel_network_cidr': '10.101.0.0/16',
'flannel_network_subnetlen': '26',
'flannel_backend': 'vxlan',
'tls_disabled': False,
'registry_enabled': False,
'trustee_domain_id': self.mock_keystone.trustee_domain_id,
'trustee_username': '******',
'trustee_password': '******',
'trustee_user_id': '7b489f04-b458-4541-8179-6a48a553e656',
'trust_id': 'bd11efc5-d4e2-4dac-bbce-25e348ddf7de',
'auth_url': 'http://192.168.10.10:5000/v3',
'cluster_uuid': self.cluster_dict['uuid'],
'magnum_url': self.mock_osc.magnum_url.return_value,
'insecure_registry_url': '10.0.0.1:5000',
'kube_version': 'fake-version',
}
self.assertEqual(expected, definition)
self.assertEqual(
['../../common/templates/environments/no_master_lb.yaml',
'../../common/templates/environments/disable_floating_ip.yaml'],
env_files)
def test_create(self):
with mock.patch.object(self.dbapi, 'create_cluster',
autospec=True) as mock_create_cluster:
mock_create_cluster.return_value = self.fake_cluster
cluster = objects.Cluster(self.context, **self.fake_cluster)
cluster.create()
mock_create_cluster.assert_called_once_with(self.fake_cluster)
self.assertEqual(self.context, cluster._context)
def test_extract_template_definition_coreos_no_discoveryurl(
self,
mock_driver,
mock_objects_cluster_template_get_by_uuid,
reqget):
self.cluster_template_dict['cluster_distro'] = 'coreos'
self.cluster_dict['discovery_url'] = None
mock_req = mock.MagicMock(text='http://tokentest/h1/h2/h3')
reqget.return_value = mock_req
cluster_template = objects.ClusterTemplate(
self.context, **self.cluster_template_dict)
mock_objects_cluster_template_get_by_uuid.return_value = \
cluster_template
cluster = objects.Cluster(self.context, **self.cluster_dict)
mock_driver.return_value = k8s_coreos_dr.Driver()
(template_path,
definition,
env_files) = driver._extract_template_definition(self.context,
cluster)
expected = {
'ssh_key_name': 'keypair_id',
'external_network': 'external_network_id',
'dns_nameserver': 'dns_nameserver',
'server_image': 'image_id',
'minion_flavor': 'flavor_id',
'master_flavor': 'master_flavor_id',
'number_of_minions': 1,
'number_of_masters': 1,
'network_driver': 'network_driver',
'volume_driver': 'volume_driver',
'discovery_url': 'http://tokentest/h1/h2/h3',
'http_proxy': 'http_proxy',
'https_proxy': 'https_proxy',
'no_proxy': 'no_proxy',
'flannel_network_cidr': '10.101.0.0/16',
'flannel_network_subnetlen': '26',
'flannel_backend': 'vxlan',
'tls_disabled': False,
'registry_enabled': False,
'trustee_domain_id': self.mock_keystone.trustee_domain_id,
'trustee_username': '******',
'trustee_password': '******',
'trustee_user_id': '7b489f04-b458-4541-8179-6a48a553e656',
'trust_id': 'bd11efc5-d4e2-4dac-bbce-25e348ddf7de',
'auth_url': 'http://192.168.10.10:5000/v3',
'cluster_uuid': self.cluster_dict['uuid'],
'magnum_url': self.mock_osc.magnum_url.return_value,
'insecure_registry_url': '10.0.0.1:5000',
'kube_version': 'fake-version',
}
self.assertEqual(expected, definition)
self.assertEqual(
['../../common/templates/environments/no_master_lb.yaml'],
env_files)
def setUp(self):
super(NeutronTest, self).setUp()
cluster_dict = utils.get_test_cluster(node_count=1)
nodegroups_dict = utils.get_nodegroups_for_cluster(node_count=1)
self.cluster = objects.Cluster(self.context, **cluster_dict)
self.nodegroups = [
objects.NodeGroup(self.context, **nodegroups_dict['master']),
objects.NodeGroup(self.context, **nodegroups_dict['worker'])
]
def setUp(self):
super(TestHandler, self).setUp()
self.handler = cluster_conductor.Handler()
cluster_template_dict = utils.get_test_cluster_template()
self.cluster_template = objects.ClusterTemplate(
self.context, **cluster_template_dict)
self.cluster_template.create()
cluster_dict = utils.get_test_cluster(node_count=1)
self.cluster = objects.Cluster(self.context, **cluster_dict)
self.cluster.create()
def test_retrieve_cluster_uuid_from_name(self, mock_cluster_get_by_name,
mock_uuid_like):
cluster = objects.Cluster(uuid='5d12f6fd-a196-4bf0-ae4c-1f639a523a52')
mock_uuid_like.return_value = False
mock_cluster_get_by_name.return_value = cluster
cluster_uuid = utils.retrieve_cluster_uuid('context', 'fake_name')
self.assertEqual('5d12f6fd-a196-4bf0-ae4c-1f639a523a52', cluster_uuid)
mock_uuid_like.assert_called_once_with('fake_name')
mock_cluster_get_by_name.assert_called_once_with(
'context', 'fake_name')
def test_retrieve_cluster_template(self,
mock_cluster_template_get_by_uuid):
expected_context = 'context'
expected_cluster_template_uuid = 'ClusterTemplate_uuid'
cluster = objects.Cluster({})
cluster.cluster_template_id = expected_cluster_template_uuid
utils.retrieve_cluster_template(expected_context, cluster)
mock_cluster_template_get_by_uuid.assert_called_once_with(
expected_context, expected_cluster_template_uuid)
def test_extract_template_definition_multi_master(
self, mock_driver, mock_objects_cluster_template_get_by_uuid):
self.cluster_template_dict['master_lb_enabled'] = True
self.cluster_dict['master_count'] = 2
cluster_template = objects.ClusterTemplate(
self.context, **self.cluster_template_dict)
mock_objects_cluster_template_get_by_uuid.return_value = \
cluster_template
cluster = objects.Cluster(self.context, **self.cluster_dict)
mock_driver.return_value = mesos_dr.Driver()
(template_path, definition,
env_files) = mock_driver()._extract_template_definition(
self.context, cluster)
expected = {
'ssh_key_name': 'keypair_id',
'external_network': 'external_network_id',
'fixed_network': 'fixed_network',
'fixed_subnet': 'fixed_subnet',
'dns_nameserver': 'dns_nameserver',
'server_image': 'image_id',
'master_flavor': 'master_flavor_id',
'slave_flavor': 'flavor_id',
'number_of_slaves': 1,
'number_of_masters': 2,
'http_proxy': 'http_proxy',
'https_proxy': 'https_proxy',
'no_proxy': 'no_proxy',
'cluster_name': 'cluster1',
'trustee_domain_id': self.mock_keystone.trustee_domain_id,
'trustee_username': '******',
'trustee_password': '******',
'trustee_user_id': '7b489f04-b458-4541-8179-6a48a553e656',
'trust_id': 'bd11efc5-d4e2-4dac-bbce-25e348ddf7de',
'volume_driver': 'volume_driver',
'auth_url': 'http://192.168.10.10:5000/v3',
'region_name': self.mock_osc.cinder_region_name.return_value,
'username': '******',
'tenant_name': 'admin',
'domain_name': 'domainname',
'rexray_preempt': 'False',
'mesos_slave_executor_env_variables': '{}',
'mesos_slave_isolation': 'docker/runtime,filesystem/linux',
'mesos_slave_work_dir': '/tmp/mesos/slave',
'mesos_slave_image_providers': 'docker'
}
self.assertEqual(expected, definition)
self.assertEqual([
'../../common/templates/environments/no_private_network.yaml',
'../../common/templates/environments/with_master_lb.yaml'
], env_files)
def get_test_cluster(context, **kw):
"""Return a Cluster object with appropriate attributes.
NOTE: The object leaves the attributes marked as changed, such
that a create() could be used to commit it to the DB.
"""
db_cluster = db_utils.get_test_cluster(**kw)
# Let DB generate ID if it isn't specified explicitly
if 'id' not in kw:
del db_cluster['id']
cluster = objects.Cluster(context)
for key in db_cluster:
setattr(cluster, key, db_cluster[key])
return cluster
def setUp(self):
super(TestHandler, self).setUp()
self.handler = cluster_conductor.Handler()
cluster_template_dict = utils.get_test_cluster_template()
self.cluster_template = objects.ClusterTemplate(
self.context, **cluster_template_dict)
self.cluster_template.create()
self.cluster_dict = utils.get_test_cluster(node_count=1)
self.nodegroups_dict = utils.get_nodegroups_for_cluster(node_count=1)
del self.nodegroups_dict['master']['id']
del self.nodegroups_dict['worker']['id']
self.cluster = objects.Cluster(self.context, **self.cluster_dict)
self.master_count = self.cluster.master_count
self.node_count = self.cluster.node_count
self.cluster.create()
self.master = objects.NodeGroup(self.context,
**self.nodegroups_dict['master'])
self.worker = objects.NodeGroup(self.context,
**self.nodegroups_dict['worker'])
def setUp(self):
super(MonitorsTestCase, self).setUp()
self.requests_mock = self.useFixture(fixture.Fixture())
cluster = utils.get_test_cluster(node_addresses=['1.2.3.4'],
api_address='https://5.6.7.8:2376',
master_addresses=['10.0.0.6'],
labels={})
self.cluster = objects.Cluster(self.context, **cluster)
cluster_template = (utils.get_test_cluster_template(
master_lb_enabled=False))
self.cluster.cluster_template = (objects.ClusterTemplate(
self.context, **cluster_template))
nodegroups = utils.get_nodegroups_for_cluster(
node_addresses=['1.2.3.4'], master_addresses=['10.0.0.6'])
self.nodegroups = [
objects.NodeGroup(self.context, **nodegroups['master']),
objects.NodeGroup(self.context, **nodegroups['worker'])
]
self.monitor = swarm_monitor.SwarmMonitor(self.context, self.cluster)
self.v2_monitor = swarm_v2_monitor.SwarmMonitor(
self.context, self.cluster)
self.k8s_monitor = k8s_monitor.K8sMonitor(self.context, self.cluster)
self.mesos_monitor = mesos_monitor.MesosMonitor(
self.context, self.cluster)
p = mock.patch(
'magnum.drivers.swarm_fedora_atomic_v1.monitor.'
'SwarmMonitor.metrics_spec',
new_callable=mock.PropertyMock)
self.mock_metrics_spec = p.start()
self.mock_metrics_spec.return_value = self.test_metrics_spec
self.addCleanup(p.stop)
p2 = mock.patch(
'magnum.drivers.swarm_fedora_atomic_v2.monitor.'
'SwarmMonitor.metrics_spec',
new_callable=mock.PropertyMock)
self.mock_metrics_spec_v2 = p2.start()
self.mock_metrics_spec_v2.return_value = self.test_metrics_spec
self.addCleanup(p2.stop)
def test_create_with_environment(
self, mock_short_id, mock_openstack_client_class, mock_driver,
mock_extract_tmpl_def, mock_cert_manager, mock_trust_manager,
mock_get_template_contents, mock_process_mult,
mock_heat_poller_class):
timeout = 15
mock_poller = mock.MagicMock()
mock_poller.poll_and_check.return_value = loopingcall.LoopingCallDone()
mock_heat_poller_class.return_value = mock_poller
mock_driver.return_value = k8s_atomic_dr.Driver()
mock_short_id.return_value = 'short_id'
mock_extract_tmpl_def.return_value = ('the/template/path.yaml', {
'heat_param_1': 'foo',
'heat_param_2': 'bar'
}, ['env_file_1', 'env_file_2'])
mock_get_template_contents.return_value = ({
'tmpl_file_1':
'some content',
'tmpl_file_2':
'some more content'
}, 'some template yaml')
def do_mock_process_mult(env_paths=None, env_list_tracker=None):
self.assertEqual(env_list_tracker, [])
for f in env_paths:
env_list_tracker.append('file:///' + f)
env_map = {path: 'content of ' + path for path in env_list_tracker}
return (env_map, None)
mock_process_mult.side_effect = do_mock_process_mult
mock_hc = mock.Mock()
mock_hc.stacks.create.return_value = {'stack': {'id': 'stack-id'}}
osc = mock.Mock()
osc.heat.return_value = mock_hc
mock_openstack_client_class.return_value = osc
# NOTE(ttsiouts): self.cluster is already created so it's
# a bad idea to use it and try to create it again... Instead
# get a new object and use it.
cluster_dict = utils.get_test_cluster(
node_count=1, uuid='f6a99187-6f42-4fbb-aa6f-18407c0ee50e')
del cluster_dict['id']
cluster = objects.Cluster(self.context, **cluster_dict)
node_count = cluster.node_count
master_count = cluster.master_count
self.handler.cluster_create(self.context, cluster, master_count,
node_count, timeout)
mock_extract_tmpl_def.assert_called_once_with(self.context,
cluster,
nodegroups=None)
mock_get_template_contents.assert_called_once_with(
'the/template/path.yaml')
mock_process_mult.assert_called_once_with(
env_paths=['the/template/env_file_1', 'the/template/env_file_2'],
env_list_tracker=mock.ANY)
mock_hc.stacks.create.assert_called_once_with(
environment_files=[
'file:///the/template/env_file_1',
'file:///the/template/env_file_2'
],
files={
'tmpl_file_1':
'some content',
'tmpl_file_2':
'some more content',
'file:///the/template/env_file_1':
'content of file:///the/template/env_file_1',
'file:///the/template/env_file_2':
'content of file:///the/template/env_file_2'
},
parameters={
'is_cluster_stack': True,
'heat_param_1': 'foo',
'heat_param_2': 'bar'
},
stack_name=('%s-short_id' % cluster.name),
template='some template yaml',
timeout_mins=timeout)
self.assertEqual(node_count, cluster.node_count)
self.assertEqual(node_count, cluster.default_ng_worker.node_count)
self.assertEqual(master_count, cluster.master_count)
self.assertEqual(master_count, cluster.default_ng_master.node_count)
def _test_extract_template_definition(
self,
mock_driver,
mock_objects_cluster_template_get_by_uuid,
mock_get,
missing_attr=None):
if missing_attr in self.cluster_template_dict:
self.cluster_template_dict[missing_attr] = None
elif missing_attr in self.cluster_dict:
self.cluster_dict[missing_attr] = None
cluster_template = objects.ClusterTemplate(
self.context, **self.cluster_template_dict)
mock_objects_cluster_template_get_by_uuid.return_value = \
cluster_template
expected_result = str('{"action":"get","node":{"key":"test","value":'
'"1","modifiedIndex":10,"createdIndex":10}}')
mock_resp = mock.MagicMock()
mock_resp.text = expected_result
mock_get.return_value = mock_resp
cluster = objects.Cluster(self.context, **self.cluster_dict)
mock_driver.return_value = k8s_dr.Driver()
(template_path, definition,
env_files) = mock_driver()._extract_template_definition(
self.context, cluster)
mapping = {
'dns_nameserver': 'dns_nameserver',
'image_id': 'server_image',
'flavor_id': 'minion_flavor',
'docker_volume_size': 'docker_volume_size',
'docker_storage_driver': 'docker_storage_driver',
'network_driver': 'network_driver',
'volume_driver': 'volume_driver',
'master_flavor_id': 'master_flavor',
'apiserver_port': '',
'node_count': 'number_of_minions',
'master_count': 'number_of_masters',
'discovery_url': 'discovery_url',
'labels': {
'flannel_network_cidr': '10.101.0.0/16',
'flannel_network_subnetlen': '26',
'flannel_backend': 'vxlan',
'system_pods_initial_delay': '15',
'system_pods_timeout': '1',
'admission_control_list': 'fake_list',
'prometheus_monitoring': 'False',
'grafana_admin_passwd': 'fake_pwd'
},
'http_proxy': 'http_proxy',
'https_proxy': 'https_proxy',
'no_proxy': 'no_proxy',
'cluster_uuid': self.cluster_dict['uuid'],
'magnum_url': self.mock_osc.magnum_url.return_value,
'tls_disabled': False,
'insecure_registry': '10.0.0.1:5000',
}
expected = {
'ssh_key_name': 'keypair_id',
'external_network': 'external_network_id',
'fixed_network': 'fixed_network',
'fixed_subnet': 'fixed_subnet',
'network_driver': 'network_driver',
'volume_driver': 'volume_driver',
'dns_nameserver': 'dns_nameserver',
'server_image': 'image_id',
'minion_flavor': 'flavor_id',
'master_flavor': 'master_flavor_id',
'number_of_minions': 1,
'number_of_masters': 1,
'docker_volume_size': 20,
'docker_storage_driver': 'devicemapper',
'discovery_url': 'https://discovery.etcd.io/test',
'flannel_network_cidr': '10.101.0.0/16',
'flannel_network_subnetlen': '26',
'flannel_backend': 'vxlan',
'system_pods_initial_delay': '15',
'system_pods_timeout': '1',
'admission_control_list': 'fake_list',
'prometheus_monitoring': 'False',
'grafana_admin_passwd': 'fake_pwd',
'http_proxy': 'http_proxy',
'https_proxy': 'https_proxy',
'no_proxy': 'no_proxy',
'tenant_name': 'fake_tenant',
'username': '******',
'cluster_uuid': self.cluster_dict['uuid'],
'magnum_url': self.mock_osc.magnum_url.return_value,
'region_name': self.mock_osc.cinder_region_name.return_value,
'tls_disabled': False,
'registry_enabled': False,
'trustee_domain_id': self.mock_keystone.trustee_domain_id,
'trustee_username': '******',
'trustee_password': '******',
'trustee_user_id': '7b489f04-b458-4541-8179-6a48a553e656',
'trust_id': '',
'auth_url': 'http://192.168.10.10:5000/v3',
'insecure_registry_url': '10.0.0.1:5000',
'kube_version': 'fake-version',
}
if missing_attr is not None:
expected.pop(mapping[missing_attr], None)
self.assertEqual(expected, definition)
self.assertEqual([
'../../common/templates/environments/no_private_network.yaml',
'../../common/templates/environments/with_volume.yaml',
'../../common/templates/environments/no_master_lb.yaml',
'../../common/templates/environments/disable_floating_ip.yaml',
], env_files)
def test_extract_template_definition_without_discovery_url(
self, mock_generate_csr_and_key, mock_sign_node_certificate,
mock_driver, mock_objects_cluster_template_get_by_uuid, reqget):
cluster_template = objects.ClusterTemplate(
self.context, **self.cluster_template_dict)
mock_generate_csr_and_key.return_value = {
'csr': 'csr',
'private_key': 'private_key',
'public_key': 'public_key'
}
mock_sign_node_certificate.return_value = 'signed_cert'
mock_objects_cluster_template_get_by_uuid.return_value = \
cluster_template
cluster_dict = self.cluster_dict
cluster_dict['discovery_url'] = None
cluster = objects.Cluster(self.context, **cluster_dict)
mock_driver.return_value = k8s_dr.Driver()
CONF.set_override('etcd_discovery_service_endpoint_format',
'http://etcd/test?size=%(size)d',
group='cluster')
mock_req = mock.MagicMock(text='https://address/token',
status_code=200)
reqget.return_value = mock_req
(template_path, definition,
env_files) = mock_driver()._extract_template_definition(
self.context, cluster)
expected = {
'ssh_key_name': 'keypair_id',
'external_network': 'e2a6c8b0-a3c2-42a3-b3f4-01400a30896e',
'fixed_network': 'fixed_network',
'fixed_subnet': 'fixed_subnet',
'dns_nameserver': 'dns_nameserver',
'server_image': 'image_id',
'master_flavor': 'master_flavor_id',
'minion_flavor': 'flavor_id',
'number_of_minions': 1,
'number_of_masters': 1,
'network_driver': 'network_driver',
'volume_driver': 'volume_driver',
'docker_volume_size': 20,
'docker_volume_type': 'lvmdriver-1',
'docker_storage_driver': 'devicemapper',
'discovery_url': 'https://address/token',
'etcd_volume_size': None,
'http_proxy': 'http_proxy',
'https_proxy': 'https_proxy',
'no_proxy': 'no_proxy',
'flannel_network_cidr': '10.101.0.0/16',
'flannel_network_subnetlen': '26',
'flannel_backend': 'vxlan',
'system_pods_initial_delay': '15',
'system_pods_timeout': '1',
'admission_control_list': 'fake_list',
'prometheus_monitoring': 'False',
'grafana_admin_passwd': 'fake_pwd',
'kube_dashboard_enabled': 'True',
'influx_grafana_dashboard_enabled': 'True',
'username': '******',
'cluster_uuid': self.cluster_dict['uuid'],
'magnum_url': self.mock_osc.magnum_url.return_value,
'region_name': self.mock_osc.cinder_region_name.return_value,
'tls_disabled': False,
'registry_enabled': False,
'trustee_domain_id': self.mock_keystone.trustee_domain_id,
'trustee_username': '******',
'trustee_password': '******',
'trustee_user_id': '7b489f04-b458-4541-8179-6a48a553e656',
'trust_id': '',
'auth_url': 'http://192.168.10.10:5000/v3',
'insecure_registry_url': '10.0.0.1:5000',
'kube_version': 'fake-version',
'verify_ca': True,
'openstack_ca': '',
"nodes_affinity_policy": "soft-anti-affinity",
'availability_zone': 'az_1',
'cert_manager_api': 'False',
'ingress_controller': 'i-controller',
'ingress_controller_role': 'i-controller-role',
'octavia_ingress_controller_tag': None,
'kubelet_options': '--kubelet',
'kubeapi_options': '--kubeapi',
'kubecontroller_options': '--kubecontroller',
'kubescheduler_options': '--kubescheduler',
'kubeproxy_options': '--kubeproxy',
'octavia_enabled': False,
'kube_service_account_key': 'public_key',
'kube_service_account_private_key': 'private_key',
'portal_network_cidr': '10.254.0.0/16',
'project_id': 'project_id'
}
self.assertEqual(expected, definition)
self.assertEqual([
'../../common/templates/environments/no_private_network.yaml',
'../../common/templates/environments/no_etcd_volume.yaml',
'../../common/templates/environments/with_volume.yaml',
'../../common/templates/environments/no_master_lb.yaml',
'../../common/templates/environments/disable_floating_ip.yaml',
], env_files)
reqget.assert_called_once_with('http://etcd/test?size=1',
proxies={
'http': 'http_proxy',
'https': 'https_proxy'
})
def test_extract_template_definition_coreos_with_disovery(
self, mock_driver, mock_objects_cluster_template_get_by_uuid,
mock_get):
self.cluster_template_dict['cluster_distro'] = 'coreos'
cluster_template = objects.ClusterTemplate(
self.context, **self.cluster_template_dict)
mock_objects_cluster_template_get_by_uuid.return_value = \
cluster_template
expected_result = str('{"action":"get","node":{"key":"test","value":'
'"1","modifiedIndex":10,"createdIndex":10}}')
mock_resp = mock.MagicMock()
mock_resp.text = expected_result
mock_resp.status_code = 200
mock_get.return_value = mock_resp
cluster = objects.Cluster(self.context, **self.cluster_dict)
mock_driver.return_value = k8s_coreos_dr.Driver()
(template_path, definition,
env_files) = mock_driver()._extract_template_definition(
self.context, cluster)
expected = {
'ssh_key_name': 'keypair_id',
'external_network': 'e2a6c8b0-a3c2-42a3-b3f4-01400a30896e',
'fixed_network': 'fixed_network',
'fixed_subnet': 'fixed_subnet',
'availability_zone': 'az_1',
'nodes_affinity_policy': 'soft-anti-affinity',
'dns_nameserver': 'dns_nameserver',
'docker_storage_driver': 'devicemapper',
'docker_volume_size': 20,
'docker_volume_type': 'lvmdriver-1',
'server_image': 'image_id',
'minion_flavor': 'flavor_id',
'master_flavor': 'master_flavor_id',
'number_of_minions': 1,
'number_of_masters': 1,
'network_driver': 'network_driver',
'volume_driver': 'volume_driver',
'discovery_url': 'https://discovery.etcd.io/test',
'etcd_volume_size': None,
'http_proxy': 'http_proxy',
'https_proxy': 'https_proxy',
'no_proxy': 'no_proxy',
'flannel_network_cidr': '10.101.0.0/16',
'flannel_network_subnetlen': '26',
'flannel_backend': 'vxlan',
'system_pods_initial_delay': '15',
'system_pods_timeout': '1',
'admission_control_list': 'fake_list',
'prometheus_monitoring': 'False',
'region_name': 'RegionOne',
'grafana_admin_passwd': 'fake_pwd',
'kube_dashboard_enabled': 'True',
'influx_grafana_dashboard_enabled': 'True',
'tls_disabled': False,
'registry_enabled': False,
'trustee_domain_id': self.mock_keystone.trustee_domain_id,
'trustee_username': '******',
'trustee_password': '******',
'trustee_user_id': '7b489f04-b458-4541-8179-6a48a553e656',
'username': '******',
'trust_id': '',
'auth_url': 'http://192.168.10.10:5000/v3',
'cluster_uuid': self.cluster_dict['uuid'],
'magnum_url': self.mock_osc.magnum_url.return_value,
'insecure_registry_url': '10.0.0.1:5000',
'kube_version': 'fake-version',
'verify_ca': True,
'openstack_ca': '',
'openstack_ca_coreos': '',
'cert_manager_api': 'False',
'ingress_controller': 'i-controller',
'ingress_controller_role': 'i-controller-role',
'octavia_ingress_controller_tag': None,
'kubelet_options': '--kubelet',
'kubeapi_options': '--kubeapi',
'kubecontroller_options': '--kubecontroller',
'kubescheduler_options': '--kubescheduler',
'kubeproxy_options': '--kubeproxy',
'octavia_enabled': False,
'portal_network_cidr': '10.254.0.0/16',
}
self.assertEqual(expected, definition)
self.assertEqual([
'../../common/templates/environments/no_private_network.yaml',
'../../common/templates/environments/no_etcd_volume.yaml',
'../../common/templates/environments/with_volume.yaml',
'../../common/templates/environments/no_master_lb.yaml',
'../../common/templates/environments/disable_floating_ip.yaml'
], env_files)
def test_extract_template_definition_only_required(
self, mock_driver, mock_objects_cluster_template_get_by_uuid,
mock_get):
not_required = [
'image_id', 'flavor_id', 'dns_nameserver', 'docker_volume_size',
'fixed_network', 'http_proxy', 'https_proxy', 'no_proxy',
'network_driver', 'master_flavor_id', 'docker_storage_driver',
'volume_driver', 'rexray_preempt', 'fixed_subnet',
'docker_volume_type', 'availablity_zone'
]
for key in not_required:
self.cluster_template_dict[key] = None
self.cluster_dict['discovery_url'] = 'https://discovery.etcd.io/test'
cluster_template = objects.ClusterTemplate(
self.context, **self.cluster_template_dict)
mock_objects_cluster_template_get_by_uuid.return_value = \
cluster_template
expected_result = str('{"action":"get","node":{"key":"test","value":'
'"1","modifiedIndex":10,"createdIndex":10}}')
mock_resp = mock.MagicMock()
mock_resp.text = expected_result
mock_get.return_value = mock_resp
mock_driver.return_value = swarm_dr.Driver()
cluster = objects.Cluster(self.context, **self.cluster_dict)
(template_path, definition,
env_files) = mock_driver()._extract_template_definition(
self.context, cluster)
expected = {
'ssh_key_name': 'keypair_id',
'external_network': 'external_network_id',
'number_of_masters': 1,
'number_of_nodes': 1,
'discovery_url': 'https://discovery.etcd.io/test',
'cluster_uuid': '5d12f6fd-a196-4bf0-ae4c-1f639a523a52',
'magnum_url': self.mock_osc.magnum_url.return_value,
'tls_disabled': False,
'registry_enabled': False,
'flannel_network_cidr': u'10.101.0.0/16',
'flannel_network_subnetlen': u'26',
'flannel_backend': u'vxlan',
'trustee_domain_id': self.mock_keystone.trustee_domain_id,
'trustee_username': '******',
'trustee_password': '******',
'trustee_user_id': '7b489f04-b458-4541-8179-6a48a553e656',
'trust_id': 'bd11efc5-d4e2-4dac-bbce-25e348ddf7de',
'auth_url': 'http://192.168.10.10:5000/v3',
'swarm_version': 'fake-version',
'swarm_strategy': u'spread',
'rexray_preempt': 'False',
'docker_volume_type': 'lvmdriver-1',
'docker_volume_size': 20,
'master_flavor': 'master_flavor_id',
'verify_ca': True,
'node_flavor': 'flavor_id',
'openstack_ca': '',
'nodes_affinity_policy': 'soft-anti-affinity'
}
self.assertEqual(expected, definition)
self.assertEqual([
'../../common/templates/environments/with_private_network.yaml',
'../../common/templates/environments/with_volume.yaml',
'../../common/templates/environments/no_master_lb.yaml'
], env_files)
def test_extract_template_definition_only_required(
self, mock_generate_csr_and_key, mock_sign_node_certificate,
mock_driver, mock_objects_cluster_template_get_by_uuid, mock_get):
not_required = [
'image_id', 'flavor_id', 'dns_nameserver', 'docker_volume_size',
'fixed_network', 'http_proxy', 'https_proxy', 'no_proxy',
'network_driver', 'master_flavor_id', 'docker_storage_driver',
'volume_driver', 'fixed_subnet'
]
for key in not_required:
self.cluster_template_dict[key] = None
self.cluster_dict['discovery_url'] = 'https://discovery.etcd.io/test'
cluster_template = objects.ClusterTemplate(
self.context, **self.cluster_template_dict)
mock_generate_csr_and_key.return_value = {
'csr': 'csr',
'private_key': 'private_key',
'public_key': 'public_key'
}
mock_sign_node_certificate.return_value = 'signed_cert'
mock_objects_cluster_template_get_by_uuid.return_value = \
cluster_template
expected_result = str('{"action":"get","node":{"key":"test","value":'
'"1","modifiedIndex":10,"createdIndex":10}}')
mock_resp = mock.MagicMock()
mock_resp.text = expected_result
mock_get.return_value = mock_resp
mock_driver.return_value = k8s_dr.Driver()
cluster = objects.Cluster(self.context, **self.cluster_dict)
(template_path, definition,
env_files) = mock_driver()._extract_template_definition(
self.context, cluster)
expected = {
'auth_url': 'http://192.168.10.10:5000/v3',
'cluster_uuid': '5d12f6fd-a196-4bf0-ae4c-1f639a523a52',
'discovery_url': 'https://discovery.etcd.io/test',
'docker_volume_size': 20,
'master_flavor': 'master_flavor_id',
'minion_flavor': 'flavor_id',
'external_network': 'external_network_id',
'flannel_backend': 'vxlan',
'flannel_network_cidr': '10.101.0.0/16',
'flannel_network_subnetlen': '26',
'system_pods_initial_delay': '15',
'system_pods_timeout': '1',
'admission_control_list': 'fake_list',
'prometheus_monitoring': 'False',
'grafana_admin_passwd': 'fake_pwd',
'kube_dashboard_enabled': 'True',
'influx_grafana_dashboard_enabled': 'True',
'docker_volume_type': 'lvmdriver-1',
'etcd_volume_size': None,
'insecure_registry_url': '10.0.0.1:5000',
'kube_version': 'fake-version',
'magnum_url': 'http://127.0.0.1:9511/v1',
'number_of_masters': 1,
'number_of_minions': 1,
'region_name': 'RegionOne',
'registry_enabled': False,
'ssh_key_name': 'keypair_id',
'tls_disabled': False,
'trust_id': '',
'trustee_domain_id': 'trustee_domain_id',
'trustee_password': '******',
'trustee_user_id': '7b489f04-b458-4541-8179-6a48a553e656',
'trustee_username': '******',
'username': '******',
'verify_ca': True,
'openstack_ca': '',
"nodes_affinity_policy": "soft-anti-affinity",
'availability_zone': 'az_1',
'cert_manager_api': 'False',
'ingress_controller': 'i-controller',
'ingress_controller_role': 'i-controller-role',
'kubelet_options': '--kubelet',
'kubeapi_options': '--kubeapi',
'kubecontroller_options': '--kubecontroller',
'kubescheduler_options': '--kubescheduler',
'kubeproxy_options': '--kubeproxy',
'octavia_enabled': False,
'kube_service_account_key': 'public_key',
'kube_service_account_private_key': 'private_key',
}
self.assertEqual(expected, definition)
self.assertEqual([
'../../common/templates/environments/with_private_network.yaml',
'../../common/templates/environments/no_etcd_volume.yaml',
'../../common/templates/environments/with_volume.yaml',
'../../common/templates/environments/no_master_lb.yaml',
'../../common/templates/environments/disable_floating_ip.yaml',
], env_files)
def test_extract_template_definition_coreos_no_discoveryurl(
self, mock_driver, mock_objects_cluster_template_get_by_uuid,
reqget):
self.cluster_template_dict['cluster_distro'] = 'coreos'
self.cluster_dict['discovery_url'] = None
mock_req = mock.MagicMock(text='http://tokentest/h1/h2/h3',
status_code=200)
reqget.return_value = mock_req
cluster_template = objects.ClusterTemplate(
self.context, **self.cluster_template_dict)
mock_objects_cluster_template_get_by_uuid.return_value = \
cluster_template
cluster = objects.Cluster(self.context, **self.cluster_dict)
mock_driver.return_value = k8s_coreos_dr.Driver()
(template_path, definition,
env_files) = mock_driver()._extract_template_definition(
self.context, cluster)
expected = {
'ssh_key_name': 'keypair_id',
'external_network': 'external_network_id',
'fixed_network': 'fixed_network',
'fixed_subnet': 'fixed_subnet',
'dns_nameserver': 'dns_nameserver',
'server_image': 'image_id',
'minion_flavor': 'flavor_id',
'master_flavor': 'master_flavor_id',
'number_of_minions': 1,
'number_of_masters': 1,
'network_driver': 'network_driver',
'volume_driver': 'volume_driver',
'discovery_url': 'http://tokentest/h1/h2/h3',
'etcd_volume_size': None,
'http_proxy': 'http_proxy',
'https_proxy': 'https_proxy',
'no_proxy': 'no_proxy',
'flannel_network_cidr': '10.101.0.0/16',
'flannel_network_subnetlen': '26',
'flannel_backend': 'vxlan',
'system_pods_initial_delay': '15',
'system_pods_timeout': '1',
'admission_control_list': 'fake_list',
'prometheus_monitoring': 'False',
'grafana_admin_passwd': 'fake_pwd',
'kube_dashboard_enabled': 'True',
'influx_grafana_dashboard_enabled': 'True',
'tls_disabled': False,
'registry_enabled': False,
'trustee_domain_id': self.mock_keystone.trustee_domain_id,
'trustee_username': '******',
'trustee_password': '******',
'trustee_user_id': '7b489f04-b458-4541-8179-6a48a553e656',
'trust_id': '',
'auth_url': 'http://192.168.10.10:5000/v3',
'cluster_uuid': self.cluster_dict['uuid'],
'magnum_url': self.mock_osc.magnum_url.return_value,
'insecure_registry_url': '10.0.0.1:5000',
'kube_version': 'fake-version',
'verify_ca': True,
'openstack_ca': '',
'cert_manager_api': 'False',
'ingress_controller': 'i-controller',
'ingress_controller_role': 'i-controller-role',
'kubelet_options': '--kubelet',
'kubeapi_options': '--kubeapi',
'kubecontroller_options': '--kubecontroller',
'kubescheduler_options': '--kubescheduler',
'kubeproxy_options': '--kubeproxy',
'octavia_enabled': False,
}
self.assertEqual(expected, definition)
self.assertEqual([
'../../common/templates/environments/no_private_network.yaml',
'../../common/templates/environments/no_master_lb.yaml',
'../../common/templates/environments/disable_floating_ip.yaml'
], env_files)
def setUp(self):
super(OctaviaTest, self).setUp()
cluster_dict = utils.get_test_cluster(node_count=1)
self.cluster = objects.Cluster(self.context, **cluster_dict)
def test_extract_template_definition_without_discovery_url(
self,
mock_driver,
mock_objects_cluster_template_get_by_uuid,
reqget):
cluster_template = objects.ClusterTemplate(
self.context, **self.cluster_template_dict)
mock_objects_cluster_template_get_by_uuid.return_value = \
cluster_template
cluster_dict = self.cluster_dict
cluster_dict['discovery_url'] = None
cluster = objects.Cluster(self.context, **cluster_dict)
mock_driver.return_value = k8s_dr.Driver()
CONF.set_override('etcd_discovery_service_endpoint_format',
'http://etcd/test?size=%(size)d',
group='cluster')
mock_req = mock.MagicMock(text='https://address/token')
reqget.return_value = mock_req
(template_path,
definition,
env_files) = mock_driver()._extract_template_definition(self.context,
cluster)
expected = {
'ssh_key_name': 'keypair_id',
'external_network': 'external_network_id',
'dns_nameserver': 'dns_nameserver',
'server_image': 'image_id',
'master_flavor': 'master_flavor_id',
'minion_flavor': 'flavor_id',
'number_of_minions': 1,
'number_of_masters': 1,
'network_driver': 'network_driver',
'volume_driver': 'volume_driver',
'docker_volume_size': 20,
'docker_storage_driver': 'devicemapper',
'discovery_url': 'https://address/token',
'http_proxy': 'http_proxy',
'https_proxy': 'https_proxy',
'no_proxy': 'no_proxy',
'flannel_network_cidr': '10.101.0.0/16',
'flannel_network_subnetlen': '26',
'flannel_backend': 'vxlan',
'tenant_name': 'fake_tenant',
'username': '******',
'cluster_uuid': self.cluster_dict['uuid'],
'magnum_url': self.mock_osc.magnum_url.return_value,
'region_name': self.mock_osc.cinder_region_name.return_value,
'tls_disabled': False,
'registry_enabled': False,
'trustee_domain_id': self.mock_keystone.trustee_domain_id,
'trustee_username': '******',
'trustee_password': '******',
'trustee_user_id': '7b489f04-b458-4541-8179-6a48a553e656',
'trust_id': 'bd11efc5-d4e2-4dac-bbce-25e348ddf7de',
'auth_url': 'http://192.168.10.10:5000/v3',
'insecure_registry_url': '10.0.0.1:5000',
'kube_version': 'fake-version',
}
self.assertEqual(expected, definition)
self.assertEqual(
['../../common/templates/environments/with_volume.yaml',
'../../common/templates/environments/no_master_lb.yaml',
'../../common/templates/environments/disable_floating_ip.yaml'],
env_files)
reqget.assert_called_once_with('http://etcd/test?size=1')
def test_extract_template_definition_with_registry(
self, mock_driver, mock_objects_cluster_template_get_by_uuid,
mock_get):
self.cluster_template_dict['registry_enabled'] = True
cluster_template = objects.ClusterTemplate(
self.context, **self.cluster_template_dict)
mock_objects_cluster_template_get_by_uuid.return_value = \
cluster_template
expected_result = str('{"action":"get","node":{"key":"test","value":'
'"1","modifiedIndex":10,"createdIndex":10}}')
mock_resp = mock.MagicMock()
mock_resp.text = expected_result
mock_get.return_value = mock_resp
cluster = objects.Cluster(self.context, **self.cluster_dict)
mock_driver.return_value = k8s_dr.Driver()
CONF.set_override('swift_region', 'RegionOne', group='docker_registry')
CONF.set_override('cluster_user_trust', True, group='trust')
(template_path, definition,
env_files) = mock_driver()._extract_template_definition(
self.context, cluster)
expected = {
'auth_url': 'http://192.168.10.10:5000/v3',
'cluster_uuid': '5d12f6fd-a196-4bf0-ae4c-1f639a523a52',
'discovery_url': 'https://discovery.etcd.io/test',
'dns_nameserver': 'dns_nameserver',
'docker_storage_driver': 'devicemapper',
'docker_volume_size': 20,
'external_network': 'external_network_id',
'fixed_network': 'fixed_network',
'fixed_subnet': 'fixed_subnet',
'flannel_backend': 'vxlan',
'flannel_network_cidr': '10.101.0.0/16',
'flannel_network_subnetlen': '26',
'system_pods_initial_delay': '15',
'system_pods_timeout': '1',
'admission_control_list': 'fake_list',
'prometheus_monitoring': 'False',
'grafana_admin_passwd': 'fake_pwd',
'http_proxy': 'http_proxy',
'https_proxy': 'https_proxy',
'magnum_url': 'http://127.0.0.1:9511/v1',
'master_flavor': 'master_flavor_id',
'minion_flavor': 'flavor_id',
'network_driver': 'network_driver',
'no_proxy': 'no_proxy',
'number_of_masters': 1,
'number_of_minions': 1,
'region_name': 'RegionOne',
'registry_container': 'docker_registry',
'registry_enabled': True,
'server_image': 'image_id',
'ssh_key_name': 'keypair_id',
'swift_region': 'RegionOne',
'tenant_name': 'fake_tenant',
'tls_disabled': False,
'trust_id': 'bd11efc5-d4e2-4dac-bbce-25e348ddf7de',
'trustee_domain_id': self.mock_keystone.trustee_domain_id,
'trustee_password': '******',
'trustee_user_id': '7b489f04-b458-4541-8179-6a48a553e656',
'trustee_username': '******',
'username': '******',
'volume_driver': 'volume_driver',
'insecure_registry_url': '10.0.0.1:5000',
'kube_version': 'fake-version',
}
self.assertEqual(expected, definition)
self.assertEqual([
'../../common/templates/environments/no_private_network.yaml',
'../../common/templates/environments/with_volume.yaml',
'../../common/templates/environments/no_master_lb.yaml',
'../../common/templates/environments/disable_floating_ip.yaml',
], env_files)
def test_extract_template_definition_only_required(
self,
mock_driver,
mock_objects_cluster_template_get_by_uuid,
mock_get):
not_required = ['image_id', 'flavor_id', 'dns_nameserver',
'docker_volume_size', 'fixed_network', 'http_proxy',
'https_proxy', 'no_proxy', 'network_driver',
'master_flavor_id', 'docker_storage_driver',
'volume_driver']
for key in not_required:
self.cluster_template_dict[key] = None
self.cluster_dict['discovery_url'] = 'https://discovery.etcd.io/test'
cluster_template = objects.ClusterTemplate(
self.context, **self.cluster_template_dict)
mock_objects_cluster_template_get_by_uuid.return_value = \
cluster_template
expected_result = str('{"action":"get","node":{"key":"test","value":'
'"1","modifiedIndex":10,"createdIndex":10}}')
mock_resp = mock.MagicMock()
mock_resp.text = expected_result
mock_get.return_value = mock_resp
mock_driver.return_value = k8s_dr.Driver()
cluster = objects.Cluster(self.context, **self.cluster_dict)
(template_path,
definition,
env_files) = mock_driver()._extract_template_definition(self.context,
cluster)
expected = {
'auth_url': 'http://192.168.10.10:5000/v3',
'cluster_uuid': '5d12f6fd-a196-4bf0-ae4c-1f639a523a52',
'discovery_url': 'https://discovery.etcd.io/test',
'external_network': 'external_network_id',
'flannel_backend': 'vxlan',
'flannel_network_cidr': '10.101.0.0/16',
'flannel_network_subnetlen': '26',
'insecure_registry_url': '10.0.0.1:5000',
'kube_version': 'fake-version',
'magnum_url': 'http://127.0.0.1:9511/v1',
'number_of_masters': 1,
'number_of_minions': 1,
'region_name': 'RegionOne',
'registry_enabled': False,
'ssh_key_name': 'keypair_id',
'tenant_name': 'fake_tenant',
'tls_disabled': False,
'trust_id': 'bd11efc5-d4e2-4dac-bbce-25e348ddf7de',
'trustee_domain_id': 'trustee_domain_id',
'trustee_password': '******',
'trustee_user_id': '7b489f04-b458-4541-8179-6a48a553e656',
'trustee_username': '******',
'username': '******'
}
self.assertEqual(expected, definition)
self.assertEqual(
['../../common/templates/environments/no_volume.yaml',
'../../common/templates/environments/no_master_lb.yaml',
'../../common/templates/environments/disable_floating_ip.yaml'],
env_files)
