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 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 _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 _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 _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_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_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 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 _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 _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_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)
