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