def test_extract_fips_with_port(self, mock_fip, mock_net, mock_port):
# NOTE: without router; with secgroup, router interface
# Here, we will make net_0 and port_0 in cache and without any
# dependencies, so only net_0, fip, fipAss, port_0 will be extracted
# at last.
# ----------------------------------------------------
# | net_1 |
# | / | |
# | subnet_0(ext-sb) / subnet_1 |
# | | \ | |
# | | \ | |
# | net_0(ext-net)<---fip<----fipAss--->port_0 |
# ----------------------------------------------------
fake_fip = copy.deepcopy(fake_fip_dict)
fake_fip['floating_network_id'] = ext_net_id
fake_fip['port_id'] = fake_port_dict['id']
mock_fip.return_value = fake_fip
fake_port = copy.deepcopy(fake_port_dict)
mock_port.return_value = fake_port
fake_port_id = fake_port['id']
fake_port_name = fake_port['name']
fake_port_res = resource.Resource('port_0', 'OS::Neutron::Port',
fake_port_id)
fake_port_dep = resource.ResourceDependency(fake_port_id,
fake_port_name, 'port_0',
'OS::Neutron::Port')
fake_net = copy.deepcopy(fake_net_dict)
fake_net['id'] = fake_fip['floating_network_id']
fake_net_id = fake_net['id']
mock_net.return_value = fake_net
fake_net_res = resource.Resource('net_0', 'OS::Neutron::Net',
fake_net_id)
fake_net_dep = resource.ResourceDependency(fake_net_id,
fake_net_dict['name'],
'net_0', 'OS::Neutron::Net')
self.net_resource = networks.NetworkResource(self.context,
collected_resources={
fake_port_id:
fake_port_res,
fake_net_id:
fake_net_res
},
collected_dependencies={
fake_port_id:
fake_port_dep,
fake_net_id:
fake_net_dep
})
result = self.net_resource.extract_floatingips([fake_fip['id']])
self.assertEqual(1, len(result))
self.assertEqual(4, len(self.net_resource.get_collected_resources()))
deps = self.net_resource.get_collected_dependencies()
net_dep = deps.pop(fake_net_id)
fip_dep = deps.pop(fake_fip['id'])
port_dep = deps.pop(fake_port_id)
fip_ass_dep = deps.values()[0]
self.assertIn(net_dep.name_in_template, fip_dep.dependencies)
self.assertIn(fip_dep.name_in_template, fip_ass_dep.dependencies)
self.assertIn(port_dep.name_in_template, fip_ass_dep.dependencies)
def test_clone_with_stack(self, mock_plan, mock_update, mock_config_get):
mock_plan.return_value = fake_constants.FAKE_PLAN
mock_update.return_value = None
stack = fake_constants.FAKE_PLAN['updated_resources']['stack_0']
res = resource.Resource(stack['name'],
stack['type'],
stack['id'],
properties=stack['properties'],
extra_properties=stack['extra_properties'],
parameters=stack['parameters'])
manager.resource_from_dict = mock.MagicMock()
manager.resource_from_dict.return_value = res
self.clone_manager.heat_api.create_stack = mock.MagicMock()
self.clone_manager.heat_api.create_stack.return_value = \
fake_constants.FAKE_STACK
db_api.plan_stack_create = mock.MagicMock()
db_api.plan_stack_create.return_value = None
mock_config_get.return_value = [{'config_value': 'hypercontainer'}]
with test.nested(
mock.patch.object(self.clone_manager.heat_api,
'get_stack',
return_value=api.Stack(
api.format_stack(
fake_constants.FAKE_STACK_STATUS)))):
ret = self.clone_manager.clone(self.context, '123',
{'az01.dc1--fusionsphere': 'az02'},
False)
self.assertEqual(None, ret)
def test_extract_subnets_from_cache(self, mock_subnet_list):
fake_subnet = copy.deepcopy(fake_subnet_dict)
fake_subnet_id = fake_subnet['id']
fake_subnet_name = fake_subnet['name']
mock_subnet_list.return_value = [fake_subnet]
fake_subnet_res = resource.Resource(fake_subnet_name,
'OS::Neutron::Subnet',
fake_subnet_id)
fake_subnet_dep = resource.ResourceDependency(fake_subnet_id,
fake_subnet_name,
'subnet_0',
'OS::Neutron::Subnet')
self.net_resource = networks.NetworkResource(
self.context,
collected_resources={fake_subnet_id: fake_subnet_res},
collected_dependencies={fake_subnet_id: fake_subnet_dep})
result = self.net_resource.extract_subnets([])
self.assertTrue(1 == len(result))
self.assertEqual(fake_subnet_id, result[0].id)
collected_res = self.net_resource.get_collected_resources()
collected_deps = self.net_resource.get_collected_dependencies()
self.assertTrue(1 == len(collected_res))
self.assertTrue(1 == len(collected_deps))
subnet_dep = collected_deps[fake_subnet_id]
self.assertFalse(len(subnet_dep.dependencies))
def test_extract_ports_with_ids(self, mock_port, mock_subnet):
# NOTE: default, in the case, subnets will be extracted.
fake_port = copy.deepcopy(fake_port_dict)
mock_port.return_value = fake_port
fake_subnet = copy.deepcopy(fake_subnet_dict)
fake_subnet_id = fake_subnet['id']
fake_subnet_name = fake_subnet['name']
mock_subnet.return_value = fake_subnet
fake_subnet_res = resource.Resource(
fake_subnet_name,
'OS::Neutron::Subnet',
fake_subnet_id,
properties={'network_id': {
'get_resource': 'network_0'
}})
fake_subnet_dep = resource.ResourceDependency(fake_subnet_id,
fake_subnet_name,
'subnet_0',
'OS::Neutron::Subnet')
self.net_resource = networks.NetworkResource(
self.context,
collected_resources={fake_subnet_id: fake_subnet_res},
collected_dependencies={fake_subnet_id: fake_subnet_dep})
result = self.net_resource.extract_ports([fake_port['id']])
self.assertTrue(1 == len(result))
self.assertTrue(2 == len(self.net_resource.get_collected_resources()))
def test_update_plan_resource_by_editing_fip(self, mock_get_res_type,
mock_network_api,
mock_get_fip,
mock_extract_fip,
mock_update_plan):
# NOTE: By changing the ori floating ip
mock_get_fip.return_value = {
'floatingip_network_id': "new-floating-network-id",
'router_id': None,
"fixed_ip_address": None,
'floating_ip_address': '192.230.1.37',
'status': 'DOWN',
'port_id': None,
'id': 'new-floatingip-id'
}
mock_extract_fip.return_value = [
resource.Resource('floatingip_new', 'OS::Neutron::FloatingIP',
'fake-new-fip-id')
]
fake_plan = fake_object.mock_fake_plan()
fake_resources = [{
'action': 'edit',
'id': 'fake-new-fip-id',
'resource_type': 'OS::Neutron::FloatingIP',
'resource_id': 'floatingip_1'
}]
with mock.patch.object(plan,
'read_plan_from_db',
return_value=fake_plan):
self.plan_manager.update_plan_resources(self.context,
fake_plan['plan_id'],
resources=fake_resources)
mock_update_plan.assert_called_once()
def extract_resource(self,
template,
name,
resource_type,
resource_id,
stack_name=None,
parent_resources=None):
if not template or not name or not resource_id:
return
LOG.debug('Extract resource of heat resource %s.', name)
# If this heat resource has been extracted, ignore it.
heat_resources = self._collected_resources.get(resource_id)
if heat_resources:
return heat_resources
resource_name = name
if stack_name and resource_id in parent_resources:
resource_name = stack_name + '.' + resource_name
heat_resources = resource.Resource(resource_name,
resource_type,
resource_id,
properties={})
template_resources = template.get('resources')
t_resource = template_resources.get(name)
properties = t_resource.get('properties')
heat_resources.properties = properties
resource_dependencies = resource.ResourceDependency(
resource_id, name, resource_name, resource_type)
self._collected_resources[resource_id] = heat_resources
self._collected_dependencies[resource_id] = resource_dependencies
return heat_resources
def extract_keypairs(self, keypair_ids, parent_name=None,
parent_resources=None):
keypair_objs = []
keypairResources = []
if not keypair_ids:
LOG.debug('Extract resources of all keypairs.')
keypair_objs = self.nova_api.keypair_list(self.context)
else:
LOG.debug('Extract resources of keypairs: %s', keypair_ids)
# remove duplicate keypairs
keypair_ids = {}.fromkeys(keypair_ids).keys()
for keypair_id in keypair_ids:
try:
keypair = self.nova_api.get_keypair(self.context,
keypair_id)
keypair_objs.append(keypair)
except Exception as e:
msg = "Keypair resource <%s> could not be found. %s" \
% (keypair_id, unicode(e))
LOG.error(msg)
raise exception.ResourceNotFound(message=msg)
for keypair in keypair_objs:
resource_id = keypair.get('id', '')
keypair_res = self._collected_resources.get(resource_id)
if keypair_res:
keypairResources.append(keypair_res)
continue
name = keypair.get('name', '')
properties = {'name': name,
'public_key': keypair.get('public_key', '')
}
resource_type = "OS::Nova::KeyPair"
resource_name = "keypair_%d" \
% self._get_resource_num(resource_type)
if parent_name and resource_id in parent_resources:
resource_name = parent_name + '.' + resource_name
keypair_res = resource.Resource(resource_name, resource_type,
resource_id, properties=properties)
keypair_dep = resource.ResourceDependency(resource_id,
resource_name,
name,
resource_type)
self._collected_resources[resource_id] = keypair_res
self._collected_dependencies[resource_id] = keypair_dep
keypairResources.append(keypair_res)
if keypair_ids and not keypairResources:
msg = "KeyPair resource extracted failed, \
can't find the keypair with id of %s." % keypair_ids
LOG.error(msg)
raise exception.ResourceNotFound(message=msg)
return keypairResources
def extract_loadbalanceHealthmonitor(self, healthmonitor_id):
# check health monitor resource exist or not
healthmonitor_col = self._collected_resources.get(healthmonitor_id)
if healthmonitor_col:
return healthmonitor_col
try:
healthmonitor = \
self.neutron_api.show_health_monitor(self.context,
healthmonitor_id)
except Exception as e:
_msg = 'Create LB health monitor resource error: %s' % e
LOG.error(_msg)
raise exception.ResourceExtractFailed(reason=_msg)
properties = {}
healthmonitor_info = healthmonitor.get('health_monitor')
properties['delay'] = healthmonitor_info.get('delay')
properties['type'] = healthmonitor_info.get('type')
properties['max_retries'] = healthmonitor_info.get('max_retries')
properties['timeout'] = healthmonitor_info.get('timeout')
healthmonitor_code = healthmonitor_info.get('expected_codes')
healthmonitor_http = healthmonitor_info.get('http_method')
healthmonitor_admin = healthmonitor_info.get('admin_state_up')
healthmonitor_url = healthmonitor_info.get('url_path')
if healthmonitor_code:
properties['expected_codes'] = healthmonitor_code
if healthmonitor_http:
properties['http_method'] = healthmonitor_http
if healthmonitor_admin:
properties['admin_state_up'] = healthmonitor_admin
if healthmonitor_url:
properties['url_path'] = healthmonitor_url
healthmonitor_type = "OS::Neutron::HealthMonitor"
healthmonitor_name = 'loadbalanceHealthmonitor_%d' \
% self._get_resource_num(healthmonitor_type)
healthmonitor_res = resource.Resource(healthmonitor_name,
healthmonitor_type,
healthmonitor_id,
properties=properties)
healthmonitor_dep = resource.ResourceDependency(
healthmonitor_id, healthmonitor_name, '', healthmonitor_type)
self._collected_resources[healthmonitor_id] = healthmonitor_res
self._collected_dependencies[healthmonitor_id] = healthmonitor_dep
return healthmonitor_res
def build_plan_by_template(self, context, plan_dict, template):
LOG.info("Begin to build plan <%s> by template.", plan_dict['plan_id'])
# extract resources
plan = plan_cls.Plan.from_dict(plan_dict)
plan_id = plan.plan_id
resources = {}
template_res = template.get('resources')
for key, value in template_res.items():
res_id = value.get('extra_properties', {}).get('id', '')
if not res_id:
res_id = uuidutils.generate_uuid()
template_res[key].get('extra_properties', {}).pop('id', '')
resource_obj = resource.Resource(
key,
value.get('type'),
res_id,
properties=value.get('properties'),
extra_properties=value.get('extra_properties'))
resource_obj.rebuild_parameter(template.get('parameters'))
resources[key] = resource_obj
plan.original_resources = resources
plan.rebuild_dependencies(is_original=True)
plan.plan_status = p_status.AVAILABLE
# Resources of migrate plan are not allowed to be modified,
# so 'updated fields' are empty.
if plan.plan_type == "clone":
plan.updated_resources = copy.deepcopy(resources)
plan.updated_dependencies = \
copy.deepcopy(plan.original_dependencies)
plan_dict = plan.to_dict()
update_values = {
'plan_status': p_status.AVAILABLE,
'original_resources': plan_dict['original_resources'],
'updated_resources': plan_dict['updated_resources']
}
try:
# Update to database
plan_cls.update_plan_to_db(context, plan_id, update_values)
LOG.info("Create plan by template finished. Plan_id is %s" %
plan_id)
except Exception as e:
msg = "Create plan by template failed! %s" % unicode(e)
LOG.error(msg)
# Roll back: change plan status to error
plan_cls.update_plan_to_db(context, plan_id,
{'plan_status': p_status.ERROR})
raise exception.PlanCreateFailed(message=msg)
def _extract_stack_resources(self, context, stack):
stack_id = stack['id']
properties = {}
timeout_mins = stack['timeout_mins']
if timeout_mins:
properties['timeout'] = timeout_mins
template = self.heat_api.get_template(context, stack_id)
parameters = template.get('parameters')
if parameters and parameters.get('OS::stack_id'):
parameters.pop('OS::stack_id')
if parameters and parameters.get('OS::project_id'):
parameters.pop('OS::project_id')
properties['parameters'] = parameters
properties['disable_rollback'] = stack['disable_rollback']
properties['stack_name'] = stack['stack_name']
resource_type = "OS::Heat::Stack"
resource_name = 'stack_%d' % self._get_resource_num(resource_type)
stack_res = res.Resource(resource_name,
resource_type,
stack_id,
properties=properties)
stack_dep = res.ResourceDependency(stack_id, resource_name,
stack['stack_name'], resource_type)
sub_reses, dependencies_reses = self._extract_son_resources(
context, stack_id, resource_name)
for resource in sub_reses:
stack_dep.add_dependency(resource.id, resource.name,
resource.properties.get('name', ''),
resource.type)
template_skeleton = '''
heat_template_version: '2013-05-23'
description: Generated template
parameters:
resources:
'''
template = yaml.load(template_skeleton)
template['resources'] = {}
template['parameters'] = {}
for r_resource in dependencies_reses:
if r_resource in sub_reses:
if r_resource.type not in handle_resource_types:
r_name = r_resource.name.split('.', 1)[-1]
r_resource.name = r_name
template['resources'].update(r_resource.template_resource)
template['parameters'].update(r_resource.template_parameter)
for key, value in parameters.items():
if key not in template['parameters'].keys():
template['parameters'][key] = value
stack_res.add_property('template', json.dumps(template))
self._collected_resources[stack_id] = stack_res
self._collected_dependencies[stack_id] = stack_dep
return sub_reses
def mock_build_res_topo(cls, context, resources):
ori_res = {}
ori_deps = {}
for res in resources:
res_type = res.get('type')
res_id = res.get('id')
name = '%s-%s' % (res_type, res_id)
name_in_tmpl = uuidutils.generate_uuid()
ori_res[name_in_tmpl] = resource.Resource(name_in_tmpl, res_type,
res_id)
ori_deps[name_in_tmpl] = resource.ResourceDependency(
res_id, name_in_tmpl, name, res_type)
return ori_res, ori_deps
def test_extract_instances_with_ids(self, mock_server, mock_flavor,
mock_keypair, mock_port_list,
mock_extract_ports):
# NOTE: for extracting servers, the following resources may be need
# to extract: flavor, keypair, image, volume, network.
mock_server.return_value = copy.deepcopy(fake_server_dict)
mock_flavor.return_value = copy.deepcopy(fake_flavor_dict)
mock_keypair.return_value = copy.deepcopy(fake_keypair_dict)
mock_port_list.return_value = [copy.deepcopy(fake_port_dict)]
mock_extract_ports.return_value = [
resource.Resource('port_0', 'OS::Neutron::Port',
'00c94695-077e-4b2d-9858-f902e4f6a932')
]
self.instance_resource.extract_instances([fake_server_dict["id"]])
self.assertTrue(
len(self.instance_resource.get_collected_resources()) >= 3)
def mock_extract_secgroups(cls, secgroups_ids):
secgroup_res = []
for secgroup_id in secgroups_ids:
fake_secgroup = copy.deepcopy(fake_object.fake_secgroup_dict)
fake_secgroup['id'] = secgroup_id
name_in_tmpl = uuidutils.generate_uuid()
sg_res = resource.Resource(name_in_tmpl, 'OS::Neutron::SecurityGroup',
secgroup_id)
sg_dep = resource.ResourceDependency(secgroup_id,
fake_secgroup['name'],
name_in_tmpl,
'OS::Neutron::SecurityGroup')
cls._collected_resources[secgroup_id] = sg_res
cls._collected_dependencies[secgroup_id] = sg_dep
secgroup_res.append(sg_res)
return secgroup_res
def extract_loadbalanceListener(self, listener_id, vip_id, vip_name):
listener_col = self._collected_resources.get(listener_id)
if listener_col:
return listener_col
# 1 query listener info
try:
listener = self.neutron_api.show_listener(self.context,
listener_id, vip_id)
except Exception as e:
_msg = 'Create LB listener resource error: %s' % e
LOG.error(_msg)
raise exception.ResourceExtractFailed(reason=_msg)
# 2 build listener resource and dependence
listener_info = listener.get('listener')
properties = {}
dependencies = []
properties['protocol'] = listener_info.get('protocol')
properties['protocol_port'] = listener_info.get('protocol_port')
properties['vip_id'] = {'get_resource': vip_name}
dependencies.append(vip_name)
listener_type = "OS::Neutron::Listener"
listener_name = 'loadbalanceListener_%d' % \
self._get_resource_num(listener_type)
listener_res = resource.Resource(listener_name,
listener_type,
listener_id,
properties=properties)
# remove duplicate dependencies
dependencies = {}.fromkeys(dependencies).keys()
listener_dep = resource.ResourceDependency(listener_id,
listener_name,
'',
listener_type,
dependencies=dependencies)
self._collected_resources[listener_id] = listener_res
self._collected_dependencies[listener_id] = listener_dep
return listener_res
def _generate_interface_resource(self,
interface,
subnet_res,
router_res,
parent_name=None,
parent_resources=None):
interface_id = interface.get('id', '')
# check this interface resource is exist in system or not
interface_res = self._collected_resources.get(interface_id)
if interface_res:
return
properties = {
'router_id': {
'get_resource': router_res.name
},
'subnet_id': {
'get_resource': subnet_res.name
}
}
resource_type = "OS::Neutron::RouterInterface"
resource_name = '%s_interface_%s' % \
(router_res.name, uuidutils.generate_uuid())
if parent_name and interface_id in parent_resources:
resource_name = parent_name + '.' + resource_name
interface_res = resource.Resource(resource_name,
resource_type,
interface_id,
properties=properties)
interface_dep = resource.ResourceDependency(interface_id,
resource_name,
interface.get('name', ''),
resource_type)
dep_router_name = router_res.properties.get('name', '')
interface_dep.add_dependency(router_res.id, router_res.name,
dep_router_name, router_res.type)
dep_sub_name = subnet_res.properties.get('name', '')
interface_dep.add_dependency(subnet_res.id, subnet_res.name,
dep_sub_name, subnet_res.type)
self._collected_resources[interface_id] = interface_res
self._collected_dependencies[interface_id] = interface_dep
def test_extract_ports_from_cache(self, mock_port_list):
fake_port = copy.deepcopy(fake_port_dict)
mock_port_list.return_value = [fake_port]
fake_port_id = fake_port['id']
fake_port_name = fake_port['name']
fake_port_des = resource.Resource(fake_port_name, 'OS::Neutron::Port',
fake_port_id)
fake_port_dep = resource.ResourceDependency(fake_port_id,
fake_port_name, 'port_0',
'OS::Neutron::Port')
self.net_resource = networks.NetworkResource(
self.context,
collected_resources={fake_port_id: fake_port_des},
collected_dependencies={fake_port_id: fake_port_dep})
result = self.net_resource.extract_ports([])
self.assertTrue(1 == len(result))
self.assertTrue(1 == len(self.net_resource.get_collected_resources()))
def test_export_clone_template(self, mock_plan, mock_update,
mock_template_create):
mock_plan.return_value = fake_constants.FAKE_PLAN
mock_update.return_value = None
res = resource.Resource('test', 'test', 'test')
manager.resource_from_dict = mock.MagicMock()
manager.resource_from_dict.return_value = res
sys_clone = False
fake_id = 'fake-001'
self.clone_manager.clone_driver.handle_resources = mock.MagicMock()
self.clone_manager.clone_driver.handle_resources.return_value = None
ret = {'stack_0': res}
mock_template_create.return_value = {}
self.assertEqual(
ret,
self.clone_manager.export_clone_template(self.context, fake_id,
sys_clone, True))
def mock_extract_instances(self, instance_ids=None):
for instance_id in instance_ids:
instance_resources = self._collected_resources.get(instance_id)
if instance_resources:
continue
resource_type = "OS::Nova::Server"
resource_name = "server_%d" % self._get_resource_num(resource_type)
instance_resources = resource.Resource(resource_name,
resource_type,
instance_id,
properties={})
name = 'server_%s' % instance_id
instance_dependencies = resource.ResourceDependency(
instance_id, name, resource_name, resource_type)
self._collected_resources[instance_id] = instance_resources
self._collected_dependencies[instance_id] = instance_dependencies
def test_extract_fips_from_cache(self, mock_fip_list):
fake_fip = copy.deepcopy(fake_fip_dict)
mock_fip_list.return_value = [fake_fip]
fake_fip_id = fake_fip['id']
fake_fip_name = ''
fake_fip_res = resource.Resource(fake_fip_name,
'OS::Neutron::FloatingIP',
fake_fip_id)
fake_fip_dep = resource.ResourceDependency(fake_fip_id, 'floatingip_0',
fake_fip_name,
'OS::Neutron::FloatingIP')
self.fip_resource = float_ips.FloatIps(
self.context,
collected_resources={fake_fip_id: fake_fip_res},
collected_dependencies={fake_fip_id: fake_fip_dep})
result = self.fip_resource.extract_floatingips([])
self.assertTrue(1 == len(result))
self.assertTrue(1 == len(self.fip_resource.get_collected_resources()))
def mock_extract_volumes(self, volume_ids=None):
for volume_id in volume_ids:
volume_resource = self._collected_resources.get(volume_id)
if volume_resource:
continue
resource_type = "OS::Cinder::Volume"
resource_name = "server_%d" % self._get_resource_num(resource_type)
volume_resource = resource.Resource(resource_name,
resource_type,
volume_id,
properties={})
name = 'volume_%s' % volume_id
instance_dependency = resource.ResourceDependency(
volume_id, name, resource_name, resource_type)
self._collected_resources[volume_id] = volume_resource
self._collected_dependencies[volume_id] = instance_dependency
def mock_extract_networks(self, network_ids=None):
for net_id in network_ids:
net_resource = self._collected_resources.get(net_id)
if net_resource:
continue
resource_type = "OS::Neutron::Net"
resource_name = "server_%d" % self._get_resource_num(resource_type)
net_resource = resource.Resource(resource_name,
resource_type,
net_id,
properties={})
name = 'volume_%s' % net_id
net_dependency = resource.ResourceDependency(net_id, name,
resource_name,
resource_type)
self._collected_resources[net_id] = net_resource
self._collected_dependencies[net_id] = net_dependency
def test_extract_stacks_from_cache(self, mock_stack):
fake_stack = copy.deepcopy(fake_stack_dict)
mock_stack.return_value = fake_stack
fake_stack_res = resource.Resource('stack_0', 'OS::Heat::Stack',
fake_stack['id'])
fake_stack_dep = resource.ResourceDependency(fake_stack['id'],
fake_stack['stack_name'],
'stack_0',
'OS::Heat::Stack')
self.stack_resource = stacks.StackResource(
self.context,
collected_resources={fake_stack['id']: fake_stack_res},
collected_dependencies={fake_stack['id']: fake_stack_dep})
result = self.stack_resource.extract_stacks([fake_stack['id']])
self.assertEqual(1, len(result))
self.assertEqual(fake_stack['id'], result[0].id)
def test_extract_secgroups_from_cache(self, mock_secgroup_list):
fake_secgroup = copy.deepcopy(fake_secgroup_dict)
mock_secgroup_list.return_value = [fake_secgroup]
fake_sg_id = fake_secgroup['id']
fake_sg_name = fake_secgroup['name']
fake_net_res = resource.Resource(fake_sg_name,
'OS::Neutron::SecurityGroup',
fake_sg_id)
fake_net_dep = resource.ResourceDependency(
fake_sg_id, fake_sg_name, 'securitygroup_0',
'OS::Neutron::SecurityGroup')
self.secgroup_resource = secgroup.SecGroup(
self.context,
collected_resources={fake_sg_id: fake_net_res},
collected_dependencies={fake_sg_id: fake_net_dep})
result = self.secgroup_resource.extract_secgroups([])
self.assertTrue(1 == len(result))
self.assertEqual(fake_sg_id, result[0].id)
def test_clone_with_volume(self, mock_plan, mock_update, mock_plan_get):
mock_plan.return_value = fake_constants.FAKE_PLAN_VOLUME
mock_update.return_value = None
vol = \
fake_constants.FAKE_PLAN_VOLUME['updated_resources']['volume_0']
res = resource.Resource(vol['name'],
vol['type'],
vol['id'],
properties=vol['properties'],
extra_properties=vol['extra_properties'],
parameters=vol['parameters'])
manager.resource_from_dict = mock.MagicMock()
manager.resource_from_dict.return_value = res
self.clone_manager.start_template_clone = mock.MagicMock()
self.clone_manager.start_template_clone.return_value = '123'
self.clone_manager.clone_driver.reset_resources = mock.MagicMock()
self.clone_manager.clone_driver.reset_resources.return_value = None
mock_plan_get.return_value = {'plan_status': 'finished'}
ret = self.clone_manager.clone(self.context, '123',
{'az01.dc1--fusionsphere': 'az02'},
False)
self.assertEqual(None, ret)
def test_extract_flavor_from_cache(self, mock_res, mock_flavor_list):
"""The request flavors ia already in collected resources"""
fake_flavor = {"id": 6, "name": "flavor_0", "type": "OS::Nova::Flavor"}
fake_flavor_res = resource.Resource(**fake_flavor)
fake_flavor_dep = resource.ResourceDependency(6, 'flavor_0',
"flavor_0",
"OS::Nova::Flavor")
self.instance_resource = instances.InstanceResource(
self.context,
collected_resources={6: fake_flavor_res},
collected_dependencies={6: fake_flavor_dep})
mock_flavor_list.return_value = [{
"id": 6,
"name": '',
"ram": 1024,
"vcpus": 1,
"disk": 5,
"rxtx_factor": 1,
"os-flavor-access:is_public": True,
"OS-FLV-EXT-DATA:ephemeral": 0,
}]
flavor_res = self.instance_resource.extract_flavors([])
self.assertEqual(1, len(flavor_res))
def test_extract_keypairs_from_cache(self, mock_res, mock_keypair_list):
"""The request keypair ia already in collected resources"""
fake_keypair = {
"id": "keypair_0",
"name": "keypair_0",
"type": "OS::Nova::KeyPair"
}
fake_keypair_res = resource.Resource(**fake_keypair)
fake_keypair_dep = resource.ResourceDependency("keypair_0",
"keypair_0",
"keypair_0",
"OS::Nova::KeyPair")
self.instance_resource = instances.InstanceResource(
self.context,
collected_resources={'keypair_0': fake_keypair_res},
collected_dependencies={'keypair_0': fake_keypair_dep})
mock_keypair_list.return_value = [{
"id": "keypair_0",
"name": "keyapir",
"public_key": "public_key"
}]
keypair_res = self.instance_resource.extract_keypairs([])
self.assertEqual(1, len(keypair_res))
def test_extract_routers_from_cache(self, mock_router_list):
fake_router = copy.deepcopy(fake_route_dict)
mock_router_list.return_value = [fake_router]
fake_router_id = fake_router['id']
fake_router_name = fake_router['name']
fake_router_res = resource.Resource(fake_router_name,
'OS::Neutron::Router',
fake_router_id)
fake_router_dep = resource.ResourceDependency(fake_router_id,
fake_router_name,
'router_0',
'OS::Neutron::Router')
self.net_resource = networks.NetworkResource(
self.context,
collected_resources={fake_router_id: fake_router_res},
collected_dependencies={fake_router_id: fake_router_dep})
result = self.net_resource.extract_routers([])
self.assertTrue(1 == len(result))
self.assertEqual(fake_router_id, result[0].id)
self.assertTrue(1 == len(self.net_resource.get_collected_resources()))
self.assertFalse(
len(self.net_resource.get_collected_dependencies()
[fake_router_id].dependencies))
def extract_qos(self, qos_id, parent_name=None,
parent_resources=None):
LOG.debug('Create qos resource start: %s', qos_id)
properties = {}
# 1 check qos resource is existing or not
qos_res = self._collected_resources.get(qos_id, None)
if qos_res:
LOG.debug('Create qos resource exist: %s', qos_id)
return qos_res
# 2 query qos info
try:
qos_info = self.cinder_api.get_qos_specs(self.context, qos_id)
except Exception as e:
_msg = 'Create volume qos error: %s' % e
LOG.error(_msg)
raise exception.ResourceExtractFailed(reason=_msg)
properties['specs'] = qos_info.get('specs')
properties['name'] = qos_info.get('name')
qos_type = "OS::Cinder::Qos"
qos_name = 'CinderQos_%d' % self._get_resource_num(qos_type)
if parent_name and qos_id in parent_resources:
qos_name = parent_name + '.' + qos_name
qos_res = resource.Resource(qos_name, qos_type,
qos_id, properties=properties)
qos_dep = resource.ResourceDependency(qos_id, qos_name, '',
qos_type)
self._collected_resources[qos_id] = qos_res
self._collected_dependencies[qos_id] = qos_dep
LOG.debug('Create qos resource end: %s', qos_id)
return qos_res
def test_update_plan_resource_by_changing_net(
self, mock_read_plan, mock_get_res_type, mock_network_api,
mock_get_network, mock_extract_nets, mock_update_plan):
mock_get_network.return_value = {
"status":
"ACTIVE",
"router:external":
False,
"availability_zone_hints": [],
"availability_zones": ["nova"],
"qos_policy_id":
None,
"provider:physical_network":
None,
"subnets": [
"46f7e0ad-b422-478e-8b56-9c2f9323c92b",
"ba5bc541-7d1d-4049-a889-090feb7ecb7f"
],
"name":
"net-conveyor2",
"created_at":
"2017-05-26T01:14:32",
"tags": [],
"updated_at":
"2017-05-26T01:14:33",
"provider:network_type":
"vxlan",
"ipv6_address_scope":
None,
"tenant_id":
"d23b65e027f9461ebe900916c0412ade",
"mtu":
1450,
"admin_state_up":
True,
"ipv4_address_scope":
None,
"shared":
False,
"provider:segmentation_id":
9867,
"id":
"1f1cd824-98d9-4e57-a90f-c68fbbc68bfc",
"description":
""
}
mock_extract_nets.return_value = [
resource.Resource('network_new', 'OS::Neutron::Net',
'1f1cd824-98d9-4e57-a90f-c68fbbc68bfc')
]
fake_plan = fake_object.mock_fake_plan()
mock_read_plan.return_value = fake_plan
fake_resources = [{
u'name': u'net-conveyor2',
u'admin_state_up': True,
u'resource_id': u'network_0',
u'value_specs': {},
'action': 'edit',
u'shared': False,
u'id': u'1f1cd824-98d9-4e57-a90f-c68fbbc68bfc',
u'resource_type': u'OS::Neutron::Net'
}]
self.plan_manager.update_plan_resources(self.context,
fake_plan['plan_id'],
resources=fake_resources)
mock_update_plan.assert_called_once()
def _generate_router_resource(self,
router_id,
other_net_ids,
parent_name=None,
parent_resources=None):
# 1. get router info from neutron api
# routers = None
try:
router = self.neutron_api.get_router(self.context, router_id)
except Exception as e:
msg = "Router resource extracted failed, \
can't find router with id: %s. %s" % \
(router_id, unicode(e))
LOG.error(msg)
raise exception.ResourceNotFound(message=msg)
if not router:
msg = "Router resource <%s> could not be found." \
% router_id
LOG.error(msg)
raise exception.ResourceNotFound(message=msg)
# 2. check this router resource is exist or not
router_id = router.get('id')
router_res = self._collected_resources.get(router_id)
if router_res:
return router_res.name
# 3. generate new router resource
properties = {
'name': router.get('name'),
'admin_state_up': router.get('admin_state_up')
}
dependencies = []
external_gateway_info = router.get('external_gateway_info')
if external_gateway_info:
network = external_gateway_info.get('network_id')
if (network in other_net_ids):
if network:
net_res = self.extract_nets(
[network],
with_subnets=True,
parent_name=parent_name,
parent_resources=parent_resources)
if net_res:
enable_snat = external_gateway_info.get('enable_snat')
properties['external_gateway_info'] = \
{'network': {'get_resource': net_res[0].name},
'enable_snat': enable_snat}
dep_res_name = net_res[0].properties.get('name', '')
dependencies.append({
'id': net_res[0].id,
'name': net_res[0].name,
'name_in_template': dep_res_name,
'type': net_res[0].type
})
else:
# if router relate public network not in clone list,
# do not copy router
return None
else:
# if router does not have public network, do not clone router
return None
resource_type = "OS::Neutron::Router"
resource_name = 'router_%d' % self._get_resource_num(resource_type)
if parent_name and router_id in parent_resources:
resource_name = parent_name + '.' + resource_name
router_res = resource.Resource(resource_name,
resource_type,
router_id,
properties=properties)
# remove duplicate dependencies
# dependencies = {}.fromkeys(dependencies).keys()
router_dep = resource.ResourceDependency(router_id,
resource_name,
router.get('name'),
resource_type,
dependencies=dependencies)
self._collected_resources[router_id] = router_res
self._collected_dependencies[router_id] = router_dep
return router_res
