def get_active_by_window_joined(cls, context, begin, end=None, project_id=None, host=None, expected_attrs=None, use_slave=False): """Get instances and joins active during a certain time window. :param:context: nova request context :param:begin: datetime for the start of the time window :param:end: datetime for the end of the time window :param:project_id: used to filter instances by project :param:host: used to filter instances on a given compute host :param:expected_attrs: list of related fields that can be joined in the database layer when querying for instances :param use_slave if True, ship this query off to a DB slave :returns: InstanceList """ # NOTE(mriedem): We have to convert the datetime objects to string # primitives for the remote call. begin = utils.isotime(begin) end = utils.isotime(end) if end else None return cls._get_active_by_window_joined(context, begin, end, project_id, host, expected_attrs, use_slave=use_slave)
def show(self, request, instance): """Detailed view of a single instance.""" ip_v4 = instance.get('access_ip_v4') ip_v6 = instance.get('access_ip_v6') server = { "server": { "id": instance["uuid"], "name": instance["display_name"], "status": self._get_vm_status(instance), "tenant_id": instance.get("project_id") or "", "user_id": instance.get("user_id") or "", "metadata": self._get_metadata(instance), "hostId": self._get_host_id(instance) or "", "image": self._get_image(request, instance), "flavor": self._get_flavor(request, instance), "created": utils.isotime(instance["created_at"]), "updated": utils.isotime(instance["updated_at"]), "addresses": self._get_addresses(request, instance), "accessIPv4": str(ip_v4) if ip_v4 is not None else '', "accessIPv6": str(ip_v6) if ip_v6 is not None else '', "links": self._get_links(request, instance["uuid"], self._collection_name), }, } if server["server"]["status"] in self._fault_statuses: _inst_fault = self._get_fault(request, instance) if _inst_fault: server['server']['fault'] = _inst_fault if server["server"]["status"] in self._progress_statuses: server["server"]["progress"] = instance.get("progress", 0) return server
def show(self, request, instance): """Detailed view of a single instance.""" server = { "server": { "id": instance["uuid"], "name": instance["display_name"], "status": self._get_vm_state(instance), "tenant_id": instance.get("project_id") or "", "user_id": instance.get("user_id") or "", "metadata": self._get_metadata(instance), "hostId": self._get_host_id(instance) or "", "image": self._get_image(request, instance), "flavor": self._get_flavor(request, instance), "created": utils.isotime(instance["created_at"]), "updated": utils.isotime(instance["updated_at"]), "addresses": self._get_addresses(request, instance), "accessIPv4": instance.get("access_ip_v4") or "", "accessIPv6": instance.get("access_ip_v6") or "", "key_name": instance.get("key_name") or "", "config_drive": instance.get("config_drive"), "links": self._get_links(request, instance["uuid"]), }, } if server["server"]["status"] in self._progress_statuses: server["server"]["progress"] = instance.get("progress", 0) return server
def setUp(self): super(TestDateTime, self).setUp() self.dt = datetime.datetime(1955, 11, 5, tzinfo=iso8601.iso8601.Utc()) self.field = fields.DateTimeField() self.coerce_good_values = [(self.dt, self.dt), (utils.isotime(self.dt), self.dt)] self.coerce_bad_values = [1, "foo"] self.to_primitive_values = [(self.dt, utils.isotime(self.dt))] self.from_primitive_values = [(utils.isotime(self.dt), self.dt)]
def setUp(self): super(TestDateTime, self).setUp() self.dt = datetime.datetime(1955, 11, 5, tzinfo=iso8601.UTC) self.field = fields.DateTimeField() self.coerce_good_values = [(self.dt, self.dt), (utils.isotime(self.dt), self.dt)] self.coerce_bad_values = [1, 'foo'] self.to_primitive_values = [(self.dt, utils.isotime(self.dt))] self.from_primitive_values = [(utils.isotime(self.dt), self.dt)]
def show(self, request, instance, extend_address=True): """Detailed view of a single instance.""" server = { "server": { "id": instance["uuid"], "name": instance["display_name"], "status": self._get_vm_status(instance), "tenant_id": instance.get("project_id") or "", "user_id": instance.get("user_id") or "", "metadata": self._get_metadata(instance), "hostId": self._get_host_id(instance) or "", # TODO(alex_xu): '_get_image' return {} when there image_ref # isn't existed in V3 API, we revert it back to return "" in # V2.1. "image": self._get_image(request, instance), "flavor": self._get_flavor(request, instance), "created": utils.isotime(instance["created_at"]), "updated": utils.isotime(instance["updated_at"]), "addresses": self._get_addresses(request, instance, extend_address), "links": self._get_links(request, instance["uuid"], self._collection_name), }, } if server["server"]["status"] in self._fault_statuses: _inst_fault = self._get_fault(request, instance) if _inst_fault: server['server']['fault'] = _inst_fault if server["server"]["status"] in self._progress_statuses: server["server"]["progress"] = instance.get("progress", 0) if api_version_request.is_supported(request, min_version="2.9"): server["server"]["locked"] = (True if instance["locked_by"] else False) if api_version_request.is_supported(request, min_version="2.19"): server["server"]["description"] = instance.get( "display_description") if api_version_request.is_supported(request, min_version="2.26"): server["server"]["tags"] = [t.tag for t in instance.tags] return server
def _build_detail(self, inst): response = super(ViewBuilderV11, self)._build_detail(inst) response['server']['created'] = utils.isotime(inst['created_at']) response['server']['updated'] = utils.isotime(inst['updated_at']) if 'status' in response['server']: if response['server']['status'] == "ACTIVE": response['server']['progress'] = 100 elif response['server']['status'] == "BUILD": response['server']['progress'] = 0 return response
def show(self, request, instance): """Detailed view of a single instance.""" ip_v4 = instance.get('access_ip_v4') ip_v6 = instance.get('access_ip_v6') server = { "server": { "id": instance["uuid"], "name": instance["display_name"], "status": self._get_vm_status(instance), "tenant_id": instance.get("project_id") or "", "user_id": instance.get("user_id") or "", "metadata": self._get_metadata(instance), "hostId": self._get_host_id(instance) or "", "image": self._get_image(request, instance), "flavor": self._get_flavor(request, instance), "created": utils.isotime(instance["created_at"]), "updated": utils.isotime(instance["updated_at"]), "addresses": self._get_addresses(request, instance), "accessIPv4": str(ip_v4) if ip_v4 is not None else '', "accessIPv6": str(ip_v6) if ip_v6 is not None else '', "links": self._get_links(request, instance["uuid"], self._collection_name), # NOTE(sdague): historically this was the # os-disk-config extension, but now that extensions # are gone, we merge these attributes here. "OS-DCF:diskConfig": ('AUTO' if instance.get('auto_disk_config') else 'MANUAL'), }, } if server["server"]["status"] in self._fault_statuses: _inst_fault = self._get_fault(request, instance) if _inst_fault: server['server']['fault'] = _inst_fault if server["server"]["status"] in self._progress_statuses: server["server"]["progress"] = instance.get("progress", 0) return server
def show(self, request, instance, extend_address=True): """Detailed view of a single instance.""" ip_v4 = instance.get('access_ip_v4') ip_v6 = instance.get('access_ip_v6') server = { "server": { "id": instance["uuid"], "name": instance["display_name"], "status": self._get_vm_status(instance), "tenant_id": instance.get("project_id") or "", "user_id": instance.get("user_id") or "", "metadata": self._get_metadata(instance), "hostId": self._get_host_id(instance) or "", "image": self._get_image(request, instance), "flavor": self._get_flavor(request, instance), "created": utils.isotime(instance["created_at"]), "updated": utils.isotime(instance["updated_at"]), "addresses": self._get_addresses(request, instance, extend_address), "accessIPv4": str(ip_v4) if ip_v4 is not None else '', "accessIPv6": str(ip_v6) if ip_v6 is not None else '', "links": self._get_links(request, instance["uuid"], self._collection_name), # NOTE(sdague): historically this was the # os-disk-config extension, but now that extensions # are gone, we merge these attributes here. "OS-DCF:diskConfig": ( 'AUTO' if instance.get('auto_disk_config') else 'MANUAL'), }, } if server["server"]["status"] in self._fault_statuses: _inst_fault = self._get_fault(request, instance) if _inst_fault: server['server']['fault'] = _inst_fault if server["server"]["status"] in self._progress_statuses: server["server"]["progress"] = instance.get("progress", 0) if api_version_request.is_supported(request, min_version="2.9"): server["server"]["locked"] = (True if instance["locked_by"] else False) if api_version_request.is_supported(request, min_version="2.19"): server["server"]["description"] = instance.get( "display_description") if api_version_request.is_supported(request, min_version="2.26"): server["server"]["tags"] = [t.tag for t in instance.tags] return server
def test_index_serializer(self): serializer = cloudpipe.CloudpipesTemplate() exemplar = dict(cloudpipes=[ dict(cloudpipe=dict( project_id='1234', public_ip='1.2.3.4', public_port='321', instance_id='1234-1234-1234-1234', created_at=utils.isotime(datetime.datetime.utcnow()), state='running')), dict(cloudpipe=dict( project_id='4321', public_ip='4.3.2.1', public_port='123', state='pending'))]) text = serializer.serialize(exemplar) tree = etree.fromstring(text) self.assertEqual('cloudpipes', tree.tag) self.assertEqual(len(exemplar['cloudpipes']), len(tree)) for idx, cl_pipe in enumerate(tree): self.assertEqual('cloudpipe', cl_pipe.tag) kp_data = exemplar['cloudpipes'][idx]['cloudpipe'] for child in cl_pipe: self.assertTrue(child.tag in kp_data) self.assertEqual(child.text, kp_data[child.tag])
def to_dict(self): return {'user': self.user, 'tenant': self.tenant, 'groups': self.groups, 'remote_address': self.remote_address, 'timestamp': utils.isotime(self.timestamp), 'request_id': self.request_id}
def test_validate_ec2_timestamp_advanced_time(self): # EC2 request with Timestamp in advanced time timestamp = timeutils.utcnow() + datetime.timedelta(seconds=250) params = {'Timestamp': utils.isotime(timestamp)} expired = ec2utils.is_ec2_timestamp_expired(params, expires=300) self.assertFalse(expired)
def test_trusted_filter_update_cache(self, req_mock): oat_data = {"hosts": [{"host_name": "node1", "trust_lvl": "untrusted", "vtime": utils.isotime()}]} req_mock.return_value = requests.codes.OK, oat_data extra_specs = {'trust:trusted_host': 'untrusted'} filter_properties = {'context': mock.sentinel.ctx, 'instance_type': {'memory_mb': 1024, 'extra_specs': extra_specs}} host = fakes.FakeHostState('host1', 'node1', {}) self.filt_cls.host_passes(host, filter_properties) # Fill the caches req_mock.reset_mock() self.filt_cls.host_passes(host, filter_properties) self.assertFalse(req_mock.called) req_mock.reset_mock() timeutils.set_time_override(timeutils.utcnow()) timeutils.advance_time_seconds( CONF.trusted_computing.attestation_auth_timeout + 80) self.filt_cls.host_passes(host, filter_properties) self.assertTrue(req_mock.called) timeutils.clear_time_override()
def _get_fault(self, request, instance): if 'fault' in instance: fault = instance.fault else: fault = self._load_fault(request, instance) if not fault: return None fault_dict = { "code": fault["code"], "created": utils.isotime(fault["created_at"]), "message": fault["message"], } if fault.get('details', None): is_admin = False context = request.environ["nova.context"] if context: is_admin = getattr(context, 'is_admin', False) if is_admin or fault['code'] != 500: fault_dict['details'] = fault["details"] return fault_dict
def _vpn_dict(self, context, project_id, instance): elevated = context.elevated() rv = {'project_id': project_id} if not instance: rv['state'] = 'pending' return rv rv['instance_id'] = instance['uuid'] rv['created_at'] = utils.isotime(instance['created_at']) nw_info = common.get_nw_info_for_instance(elevated, instance) if not nw_info: return rv vif = nw_info[0] ips = [ip for ip in vif.fixed_ips() if ip['version'] == 4] if ips: rv['internal_ip'] = ips[0]['address'] network = self.network_api.get(elevated, vif['network']['id']) if network: vpn_ip = network['vpn_public_address'] vpn_port = network['vpn_public_port'] rv['public_ip'] = vpn_ip rv['public_port'] = vpn_port if vpn_ip and vpn_port: if utils.vpn_ping(vpn_ip, vpn_port): rv['state'] = 'running' else: rv['state'] = 'down' else: rv['state'] = 'invalid' return rv
def _build_detail(self, inst): response = super(ViewBuilderV11, self)._build_detail(inst) response["server"]["created"] = utils.isotime(inst["created_at"]) response["server"]["updated"] = utils.isotime(inst["updated_at"]) if "status" in response["server"]: if response["server"]["status"] == "ACTIVE": response["server"]["progress"] = 100 elif response["server"]["status"] == "BUILD": response["server"]["progress"] = 0 response["server"]["accessIPv4"] = inst.get("access_ip_v4") or "" response["server"]["accessIPv6"] = inst.get("access_ip_v6") or "" response["server"]["key_name"] = inst.get("key_name", "") response["server"]["config_drive"] = inst.get("config_drive") return response
def test_index_serializer(self): exemplar = dict( cloudpipes=[ dict( cloudpipe=dict( project_id="1234", public_ip="1.2.3.4", public_port="321", instance_id="1234-1234-1234-1234", created_at=utils.isotime(datetime.datetime.utcnow()), state="running", ) ), dict(cloudpipe=dict(project_id="4321", public_ip="4.3.2.1", public_port="123", state="pending")), ] ) text = self.serializer.serialize(exemplar, "index") tree = etree.fromstring(text) self.assertEqual("cloudpipes", tree.tag) self.assertEqual(len(exemplar["cloudpipes"]), len(tree)) for idx, cloudpipe in enumerate(tree): self.assertEqual("cloudpipe", cloudpipe.tag) kp_data = exemplar["cloudpipes"][idx]["cloudpipe"] for child in cloudpipe: self.assertTrue(child.tag in kp_data) self.assertEqual(child.text, kp_data[child.tag])
def _build_detail(self, inst): response = super(ViewBuilderV11, self)._build_detail(inst) response['server']['created'] = utils.isotime(inst['created_at']) response['server']['updated'] = utils.isotime(inst['updated_at']) if 'status' in response['server']: if response['server']['status'] == "ACTIVE": response['server']['progress'] = 100 elif response['server']['status'] == "BUILD": response['server']['progress'] = 0 response['server']['accessIPv4'] = inst.get('access_ip_v4') or "" response['server']['accessIPv6'] = inst.get('access_ip_v6') or "" response['server']['key_name'] = inst.get('key_name', '') response['server']['config_drive'] = inst.get('config_drive') return response
def test_vpn_dict_state_running(self): isonow = datetime.datetime.utcnow() vpn_instance = { 'id': 1, 'created_at': isonow, 'fixed_ip': { 'address': '127.0.0.1' } } project = type('Project', (object, ), { 'id': 'project', 'vpn_ip': '127.0.0.1', 'vpn_port': 1234 }) # Returns state running for 127.0.0.1 - look at class setup expected_vpn_dict = { 'project_id': 'project', 'public_ip': '127.0.0.1', 'public_port': 1234, 'internal_ip': '127.0.0.1', 'instance_id': ec2utils.id_to_ec2_id(1), 'created_at': utils.isotime(isonow), 'state': 'running' } self.assertEqual(expected_vpn_dict, admin.vpn_dict(project, vpn_instance))
def _build_detail(self, inst, network): response = super(ViewBuilderV11, self)._build_detail(inst, network) response['server']['created'] = utils.isotime(inst['created_at']) response['server']['updated'] = utils.isotime(inst['updated_at']) status = response['server'].get('status') if status in ('ACTIVE', 'BUILD', 'REBUILD', 'RESIZE', 'VERIFY_RESIZE'): response['server']['progress'] = inst['progress'] or 0 response['server']['accessIPv4'] = inst.get('access_ip_v4') or "" response['server']['accessIPv6'] = inst.get('access_ip_v6') or "" response['server']['key_name'] = inst.get('key_name', '') response['server']['config_drive'] = inst.get('config_drive') return response
def test_trusted_filter_update_cache(self, req_mock): oat_data = { "hosts": [{ "host_name": "node1", "trust_lvl": "untrusted", "vtime": utils.isotime() }] } req_mock.return_value = requests.codes.OK, oat_data extra_specs = {'trust:trusted_host': 'untrusted'} spec_obj = objects.RequestSpec(context=mock.sentinel.ctx, flavor=objects.Flavor( memory_mb=1024, extra_specs=extra_specs)) host = fakes.FakeHostState('host1', 'node1', {}) self.filt_cls.host_passes(host, spec_obj) # Fill the caches req_mock.reset_mock() self.filt_cls.host_passes(host, spec_obj) self.assertFalse(req_mock.called) req_mock.reset_mock() time_fixture = self.useFixture(utils_fixture.TimeFixture()) time_fixture.advance_time_seconds( CONF.trusted_computing.attestation_auth_timeout + 80) self.filt_cls.host_passes(host, spec_obj) self.assertTrue(req_mock.called)
def test_trusted_filter_update_cache(self, req_mock): oat_data = {"hosts": [{"host_name": "node1", "trust_lvl": "untrusted", "vtime": utils.isotime()}]} req_mock.return_value = requests.codes.OK, oat_data extra_specs = {'trust:trusted_host': 'untrusted'} spec_obj = objects.RequestSpec( context=mock.sentinel.ctx, flavor=objects.Flavor(memory_mb=1024, extra_specs=extra_specs)) host = fakes.FakeHostState('host1', 'node1', {}) self.filt_cls.host_passes(host, spec_obj) # Fill the caches req_mock.reset_mock() self.filt_cls.host_passes(host, spec_obj) self.assertFalse(req_mock.called) req_mock.reset_mock() timeutils.set_time_override(timeutils.utcnow()) timeutils.advance_time_seconds( CONF.trusted_computing.attestation_auth_timeout + 80) self.filt_cls.host_passes(host, spec_obj) self.assertTrue(req_mock.called) timeutils.clear_time_override()
def to_dict(self): return {'user': self.user_id, 'project': self.project_id, 'is_admin': self.is_admin, 'read_deleted': self.read_deleted, 'remote_address': self.remote_address, 'timestamp': utils.isotime(self.timestamp), 'request_id': self.request_id}
def test_validate_ec2_req_timestamp_Expires(self): # EC2 request with both Timestamp and Expires params = {'Timestamp': '2011-04-22T11:29:49Z', 'Expires': utils.isotime()} self.assertRaises(exception.InvalidRequest, ec2utils.is_ec2_timestamp_expired, params)
def to_dict(self): return { "user": self.user, "tenant": self.tenant, "groups": self.groups, "remote_address": self.remote_address, "timestamp": utils.isotime(self.timestamp), "request_id": self.request_id, }
def test_validate_ec2_req_timestamp_Expires(self): # EC2 request with both Timestamp and Expires params = { 'Timestamp': '2011-04-22T11:29:49Z', 'Expires': utils.isotime() } self.assertRaises(exception.InvalidRequest, ec2utils.is_ec2_timestamp_expired, params)
def start_attach(self, instance_id, mountpoint): """ """ self['instance_id'] = instance_id self['mountpoint'] = mountpoint self['status'] = "in-use" self['attach_status'] = "attaching" self['attach_time'] = utils.isotime() self['delete_on_termination'] = 'False' self.save()
def to_dict(self): return { 'user': self.user_id, 'project': self.project_id, 'is_admin': self.is_admin, 'read_deleted': self.read_deleted, 'remote_address': self.remote_address, 'timestamp': utils.isotime(self.timestamp), 'request_id': self.request_id }
def _build_rate_limit(self, rate_limit): _get_utc = datetime.datetime.utcfromtimestamp next_avail = _get_utc(rate_limit["resetTime"]) return { "verb": rate_limit["verb"], "value": rate_limit["value"], "remaining": int(rate_limit["remaining"]), "unit": rate_limit["unit"], "next-available": utils.isotime(at=next_avail), }
def _build_rate_limit(self, rate_limit): _get_utc = datetime.datetime.utcfromtimestamp next_avail = _get_utc(rate_limit["resetTime"]) return { "verb": rate_limit["verb"], "value": rate_limit["value"], "remaining": int(rate_limit["remaining"]), "unit": rate_limit["unit"], "next-available": utils.isotime(next_avail), }
def show(self, request, instance, extend_address=True): """Detailed view of a single instance.""" server = { "server": { "id": instance["uuid"], "name": instance["display_name"], "status": self._get_vm_status(instance), "tenant_id": instance.get("project_id") or "", "user_id": instance.get("user_id") or "", "metadata": self._get_metadata(instance), "hostId": self._get_host_id(instance) or "", # TODO(alex_xu): '_get_image' return {} when there image_ref # isn't existed in V3 API, we revert it back to return "" in # V2.1. "image": self._get_image(request, instance), "flavor": self._get_flavor(request, instance), "created": utils.isotime(instance["created_at"]), "updated": utils.isotime(instance["updated_at"]), "addresses": self._get_addresses(request, instance, extend_address), "links": self._get_links(request, instance["uuid"], self._collection_name), }, } if server["server"]["status"] in self._fault_statuses: _inst_fault = self._get_fault(request, instance) if _inst_fault: server['server']['fault'] = _inst_fault if server["server"]["status"] in self._progress_statuses: server["server"]["progress"] = instance.get("progress", 0) if api_version_request.is_supported(request, min_version="2.9"): server["server"]["locked"] = (True if instance["locked_by"] else False) if api_version_request.is_supported(request, min_version="2.19"): server["server"]["description"] = instance.get( "display_description") return server
def test_disassociate_all_by_timeout(self, disassociate): now = timeutils.utcnow() now_tz = timeutils.parse_isotime(utils.isotime(now)).replace(tzinfo=iso8601.iso8601.Utc()) disassociate.return_value = 123 result = fixed_ip.FixedIP.disassociate_all_by_timeout(self.context, "host", now) self.assertEqual(123, result) # NOTE(danms): be pedantic about timezone stuff args, kwargs = disassociate.call_args_list[0] self.assertEqual(now_tz, args[2]) self.assertEqual((self.context, "host"), args[:2]) self.assertEqual({}, kwargs)
def test_trusted_filter_untrusted_and_untrusted_passes(self, req_mock): oat_data = {"hosts": [{"host_name": "node1", "trust_lvl": "untrusted", "vtime": utils.isotime()}]} req_mock.return_value = requests.codes.OK, oat_data extra_specs = {'trust:trusted_host': 'untrusted'} filter_properties = {'context': mock.sentinel.ctx, 'instance_type': {'memory_mb': 1024, 'extra_specs': extra_specs}} host = fakes.FakeHostState('host1', 'node1', {}) self.assertTrue(self.filt_cls.host_passes(host, filter_properties))
def _build_detail(self, inst): """Returns a detailed model of a server.""" vm_state = inst.get('vm_state', vm_states.BUILDING) task_state = inst.get('task_state') inst_dict = { 'id': inst['uuid'], 'name': inst['display_name'], 'user_id': inst.get('user_id', ''), 'tenant_id': inst.get('project_id', ''), 'status': common.status_from_state(vm_state, task_state)} # Return the metadata as a dictionary metadata = {} for item in inst.get('metadata', []): metadata[item['key']] = str(item['value']) inst_dict['metadata'] = metadata inst_dict['hostId'] = '' if inst.get('host'): inst_dict['hostId'] = hashlib.sha224(inst['host']).hexdigest() self._build_image(inst_dict, inst) self._build_flavor(inst_dict, inst) networks = common.get_networks_for_instance(self.context, inst) self._build_addresses(inst_dict, networks) inst_dict['created'] = utils.isotime(inst['created_at']) inst_dict['updated'] = utils.isotime(inst['updated_at']) status = inst_dict.get('status') if status in ('ACTIVE', 'BUILD', 'REBUILD', 'RESIZE', 'VERIFY_RESIZE'): inst_dict['progress'] = inst['progress'] or 0 inst_dict['accessIPv4'] = inst.get('access_ip_v4') or "" inst_dict['accessIPv6'] = inst.get('access_ip_v6') or "" inst_dict['key_name'] = inst.get('key_name', '') inst_dict['config_drive'] = inst.get('config_drive') return dict(server=inst_dict)
def _build_detail(self, inst): """Returns a detailed model of a server.""" vm_state = inst.get("vm_state", vm_states.BUILDING) task_state = inst.get("task_state") inst_dict = { "id": inst["id"], "name": inst["display_name"], "user_id": inst.get("user_id", ""), "tenant_id": inst.get("project_id", ""), "status": common.status_from_state(vm_state, task_state), } # Return the metadata as a dictionary metadata = {} for item in inst.get("metadata", []): metadata[item["key"]] = str(item["value"]) inst_dict["metadata"] = metadata inst_dict["hostId"] = "" if inst.get("host"): inst_dict["hostId"] = hashlib.sha224(inst["host"]).hexdigest() self._build_image(inst_dict, inst) self._build_flavor(inst_dict, inst) networks = common.get_networks_for_instance(self.context, inst) self._build_addresses(inst_dict, networks) inst_dict["created"] = utils.isotime(inst["created_at"]) inst_dict["updated"] = utils.isotime(inst["updated_at"]) status = inst_dict.get("status") if status in ("ACTIVE", "BUILD", "REBUILD", "RESIZE", "VERIFY_RESIZE"): inst_dict["progress"] = inst["progress"] or 0 inst_dict["accessIPv4"] = inst.get("access_ip_v4") or "" inst_dict["accessIPv6"] = inst.get("access_ip_v6") or "" inst_dict["key_name"] = inst.get("key_name", "") inst_dict["config_drive"] = inst.get("config_drive") return dict(server=inst_dict)
def _get_fault(self, request, instance): fault = instance.get("fault", None) if not fault: return None return { "code": fault["code"], "created": utils.isotime(fault["created_at"]), "message": fault["message"], "details": fault["details"], }
def test_trusted_filter_untrusted_and_untrusted_passes(self, req_mock): oat_data = {"hosts": [{"host_name": "node1", "trust_lvl": "untrusted", "vtime": utils.isotime()}]} req_mock.return_value = requests.codes.OK, oat_data extra_specs = {'trust:trusted_host': 'untrusted'} spec_obj = objects.RequestSpec( context=mock.sentinel.ctx, flavor=objects.Flavor(memory_mb=1024, extra_specs=extra_specs)) host = fakes.FakeHostState('host1', 'node1', {}) self.assertTrue(self.filt_cls.host_passes(host, spec_obj))
def test_disassociate_all_by_timeout(self, disassociate): now = timeutils.utcnow() now_tz = timeutils.parse_isotime( utils.isotime(now)).replace(tzinfo=iso8601.UTC) disassociate.return_value = 123 result = fixed_ip.FixedIP.disassociate_all_by_timeout( self.context, 'host', now) self.assertEqual(123, result) # NOTE(danms): be pedantic about timezone stuff args, kwargs = disassociate.call_args_list[0] self.assertEqual(now_tz, args[2]) self.assertEqual((self.context, 'host'), args[:2]) self.assertEqual({}, kwargs)
def save(self): """ update the directory with the state from this model also add it to the index of items of the same type then set the initial_state = state so new changes are tracked """ # TODO(ja): implement hmset in redis-py and use it # instead of multiple calls to hset if self.is_new_record(): self["create_time"] = utils.isotime() for key, val in self.state.iteritems(): Redis.instance().hset(self.__redis_key, key, val) self.add_to_index() self.initial_state = self.state return True
def test_trusted_filter_untrusted_and_untrusted_passes(self, req_mock): oat_data = { "hosts": [{ "host_name": "node1", "trust_lvl": "untrusted", "vtime": utils.isotime() }] } req_mock.return_value = requests.codes.OK, oat_data extra_specs = {'trust:trusted_host': 'untrusted'} spec_obj = objects.RequestSpec(context=mock.sentinel.ctx, flavor=objects.Flavor( memory_mb=1024, extra_specs=extra_specs)) host = fakes.FakeHostState('host1', 'node1', {}) self.assertTrue(self.filt_cls.host_passes(host, spec_obj))
def vpn_dict(project, vpn_instance): rv = {'project_id': project.id, 'public_ip': project.vpn_ip, 'public_port': project.vpn_port} if vpn_instance: rv['instance_id'] = vpn_instance['ec2_id'] rv['created_at'] = utils.isotime(vpn_instance['created_at']) address = vpn_instance.get('fixed_ip', None) if address: rv['internal_ip'] = address['address'] if utils.vpn_ping(project.vpn_ip, project.vpn_port): rv['state'] = 'running' else: rv['state'] = 'down' else: rv['state'] = 'pending' return rv
def test_vpn_dict_state_running(self): isonow = datetime.datetime.utcnow() vpn_instance = {"id": 1, "created_at": isonow, "fixed_ip": {"address": "127.0.0.1"}} project = type("Project", (object,), {"id": "project", "vpn_ip": "127.0.0.1", "vpn_port": 1234}) # Returns state running for 127.0.0.1 - look at class setup expected_vpn_dict = { "project_id": "project", "public_ip": "127.0.0.1", "public_port": 1234, "internal_ip": "127.0.0.1", "instance_id": ec2utils.id_to_ec2_id(1), "created_at": utils.isotime(isonow), "state": "running", } self.assertEqual(expected_vpn_dict, admin.vpn_dict(project, vpn_instance))
def _show_from_down_cell(self, request, instance, show_extra_specs, show_server_groups): """Function that constructs the partial response for the instance.""" ret = { "server": { "id": instance.uuid, "status": "UNKNOWN", "tenant_id": instance.project_id, "created": utils.isotime(instance.created_at), "links": self._get_links(request, instance.uuid, self._collection_name), }, } if 'flavor' in instance: # If the key 'flavor' is present for an instance from a down cell # it means that the request is ``GET /servers/{server_id}`` and # thus we include the information from the request_spec of the # instance like its flavor, image, avz, and user_id in addition to # the basic information from its instance_mapping. # If 'flavor' key is not present for an instance from a down cell # down cell it means the request is ``GET /servers/detail`` and we # do not expose the flavor in the response when listing servers # with details for performance reasons of fetching it from the # request specs table for the whole list of instances. ret["server"]["image"] = self._get_image(request, instance) ret["server"]["flavor"] = self._get_flavor(request, instance, show_extra_specs) # in case availability zone was not requested by the user during # boot time, return UNKNOWN. avz = instance.availability_zone or "UNKNOWN" ret["server"]["OS-EXT-AZ:availability_zone"] = avz ret["server"]["OS-EXT-STS:power_state"] = instance.power_state # in case its an old request spec which doesn't have the user_id # data migrated, return UNKNOWN. ret["server"]["user_id"] = instance.user_id or "UNKNOWN" if show_server_groups: context = request.environ['nova.context'] ret['server']['server_groups'] = self._get_server_groups( context, instance) return ret
def _vpn_dict(self, project, vpn_instance): rv = {'project_id': project.id, 'public_ip': project.vpn_ip, 'public_port': project.vpn_port} if vpn_instance: rv['instance_id'] = vpn_instance['uuid'] rv['created_at'] = utils.isotime(vpn_instance['created_at']) address = vpn_instance.get('fixed_ip', None) if address: rv['internal_ip'] = address['address'] if project.vpn_ip and project.vpn_port: if utils.vpn_ping(project.vpn_ip, project.vpn_port): rv['state'] = 'running' else: rv['state'] = 'down' else: rv['state'] = 'invalid' else: rv['state'] = 'pending' return rv
def _get_fault(self, request, instance): fault = instance.get("fault", None) if not fault: return None fault_dict = { "code": fault["code"], "created": utils.isotime(fault["created_at"]), "message": fault["message"], } if fault.get('details', None): is_admin = False context = getattr(request, 'context', None) if context: is_admin = getattr(request.context, 'is_admin', False) if is_admin or fault['code'] != 500: fault_dict['details'] = fault["details"] return fault_dict
def _get_fault(self, request, instance): # This can result in a lazy load of the fault information fault = instance.fault if not fault: return None fault_dict = { "code": fault["code"], "created": utils.isotime(fault["created_at"]), "message": fault["message"], } if fault.get('details', None): is_admin = False context = request.environ["nova.context"] if context: is_admin = getattr(context, 'is_admin', False) if is_admin or fault['code'] != 500: fault_dict['details'] = fault["details"] return fault_dict
def _vpn_dict(self, context, project_id, instance): elevated = context.elevated() rv = {'project_id': project_id} if not instance: rv['state'] = 'pending' return rv rv['instance_id'] = instance.uuid rv['created_at'] = utils.isotime(instance.created_at) nw_info = compute_utils.get_nw_info_for_instance(instance) if not nw_info: return rv vif = nw_info[0] ips = [ip for ip in vif.fixed_ips() if ip['version'] == 4] if ips: rv['internal_ip'] = ips[0]['address'] # NOTE(vish): Currently network_api.get does an owner check on # project_id. This is probably no longer necessary # but rather than risk changes in the db layer, # we are working around it here by changing the # project_id in the context. This can be removed # if we remove the project_id check in the db. elevated.project_id = project_id network = self.network_api.get(elevated, vif['network']['id']) if network: vpn_ip = network['vpn_public_address'] vpn_port = network['vpn_public_port'] rv['public_ip'] = vpn_ip rv['public_port'] = vpn_port if vpn_ip and vpn_port: if utils.vpn_ping(vpn_ip, vpn_port): rv['state'] = 'running' else: rv['state'] = 'down' else: rv['state'] = 'invalid' return rv
def show(self, request, instance, extend_address=True, show_extra_specs=None): """Detailed view of a single instance.""" ip_v4 = instance.get('access_ip_v4') ip_v6 = instance.get('access_ip_v6') if show_extra_specs is None: # detail will pre-calculate this for us. If we're doing show, # then figure it out here. show_extra_specs = False if api_version_request.is_supported(request, min_version='2.47'): context = request.environ['nova.context'] show_extra_specs = context.can( fes_policies.POLICY_ROOT % 'index', fatal=False) server = { "server": { "id": instance["uuid"], "name": instance["display_name"], "status": self._get_vm_status(instance), "tenant_id": instance.get("project_id") or "", "user_id": instance.get("user_id") or "", "metadata": self._get_metadata(instance), "hostId": self._get_host_id(instance), "image": self._get_image(request, instance), "flavor": self._get_flavor(request, instance, show_extra_specs), "created": utils.isotime(instance["created_at"]), "updated": utils.isotime(instance["updated_at"]), "addresses": self._get_addresses(request, instance, extend_address), "accessIPv4": str(ip_v4) if ip_v4 is not None else '', "accessIPv6": str(ip_v6) if ip_v6 is not None else '', "links": self._get_links(request, instance["uuid"], self._collection_name), # NOTE(sdague): historically this was the # os-disk-config extension, but now that extensions # are gone, we merge these attributes here. "OS-DCF:diskConfig": ( 'AUTO' if instance.get('auto_disk_config') else 'MANUAL'), }, } if server["server"]["status"] in self._fault_statuses: _inst_fault = self._get_fault(request, instance) if _inst_fault: server['server']['fault'] = _inst_fault if server["server"]["status"] in self._progress_statuses: server["server"]["progress"] = instance.get("progress", 0) if api_version_request.is_supported(request, min_version="2.9"): server["server"]["locked"] = (True if instance["locked_by"] else False) if api_version_request.is_supported(request, min_version="2.19"): server["server"]["description"] = instance.get( "display_description") if api_version_request.is_supported(request, min_version="2.26"): server["server"]["tags"] = [t.tag for t in instance.tags] if api_version_request.is_supported(request, min_version="2.63"): trusted_certs = None if instance.trusted_certs: trusted_certs = instance.trusted_certs.ids server["server"]["trusted_image_certificates"] = trusted_certs return server
def _format_date(dt): """Return standard format for a given datetime object.""" if dt is not None: return utils.isotime(dt)
def test_validate_ec2_req_not_expired(self): expire = timeutils.utcnow() + datetime.timedelta(seconds=350) params = {'Expires': utils.isotime(expire)} expired = ec2utils.is_ec2_timestamp_expired(params) self.assertFalse(expired)