def get_manager(self, identity):
"""Get a manager by its identity
:returns: Redfish manager UUID.
:raises: NotFound if the manager cannot be found
"""
try:
system_uuid = self._systems.uuid(identity)
system_name = self._systems.name(identity)
except error.AliasAccessError:
raise
except error.NotFound:
# Re-raise hiding the fact that managers are backed by systems
msg = 'Manager with UUID %s was not found' % identity
self._logger.error(msg)
raise error.NotFound(msg)
else:
result = {
'Id': system_uuid,
'UUID': system_uuid,
'Name': '%s-Manager' % system_name
}
self._logger.debug('Found manager %(mgr)s by UUID %(id)s', {
'mgr': result,
'id': identity
})
return result
def certificate_service_replace_certificate():
if not flask.request.json:
raise error.BadRequest("Empty or malformed certificate")
try:
cert_string = flask.request.json['CertificateString']
cert_type = flask.request.json['CertificateType']
cert_uri = flask.request.json['CertificateUri']
except KeyError as exc:
raise error.BadRequest(f"Missing required parameter {exc}")
match = _VMEDIA_URI_PATTERN.search(cert_uri)
if not match:
raise error.NotFound(
f"Certificates at URI {cert_uri} are not supported")
if cert_type != 'PEM':
raise error.BadRequest(
f"Only PEM certificates are supported, got {cert_type}")
manager_id, device, cert_id = match.groups()
flask.current_app.managers.get_manager(manager_id)
flask.current_app.vmedia.replace_certificate(
manager_id, device, cert_id, cert_string, cert_type)
return '', 204
def delete_certificate(self, identity, device, cert_id):
device_info = self._get_device(identity, device)
if cert_id != _CERT_ID or "Certificate" not in device_info:
raise error.NotFound(f"Certificate {cert_id} not found")
del device_info["Certificate"]
self._devices[(identity, device)] = device_info
def processor(identity, processor_id):
processors = app.systems.get_processors(identity)
for proc in processors:
if proc['id'] == processor_id:
return flask.render_template(
'processor.json', identity=identity, processor=proc)
raise error.NotFound()
def ethernet_interface(identity, nic_id):
nics = app.systems.get_nics(identity)
for nic in nics:
if nic['id'] == nic_id:
return flask.render_template(
'ethernet_interface.json', identity=identity, nic=nic)
raise error.NotFound()
def drive_resource(identity, stg_id, drv_id):
uuid = app.systems.uuid(identity)
drives = app.drives.get_drives(uuid, stg_id)
for drv in drives:
if drv['Id'] == drv_id:
return flask.render_template(
'drive.json', identity=identity, storage_id=stg_id, drive=drv)
raise error.NotFound()
def storage(identity, storage_id):
uuid = app.systems.uuid(identity)
storage_col = app.storage.get_storage_col(uuid)
for stg in storage_col:
if stg['Id'] == storage_id:
return flask.render_template(
'storage.json', identity=identity, storage=stg)
raise error.NotFound()
def simple_storage(identity, simple_storage_id):
simple_storage_controllers = (
app.systems.get_simple_storage_collection(identity))
try:
storage_controller = simple_storage_controllers[simple_storage_id]
except KeyError:
app.logger.debug('"%s" Simple Storage resource was not found')
raise error.NotFound()
return flask.render_template('simple_storage.json', identity=identity,
simple_storage=storage_controller)
def replace_certificate(self, identity, device, cert_id, cert_string,
cert_type):
device_info = self._get_device(identity, device)
if cert_id != _CERT_ID or "Certificate" not in device_info:
raise error.NotFound(f"Certificate {cert_id} not found")
device_info["Certificate"] = {'Type': cert_type, 'String': cert_string}
self._devices[(identity, device)] = device_info
return Certificate(_CERT_ID, cert_string, cert_type)
def test_locations(self, managers_mock, vmedia_mock):
managers_mock.return_value.managers = ["1", "2"]
vmedia_mock.return_value.devices = ["CD", "DVD"]
vmedia_mock.return_value.list_certificates.side_effect = [
error.NotFound(),
[vmedia.Certificate("cert1", "abcd", "PEM")],
[vmedia.Certificate("cert2", "abcd", "PEM")],
error.NotFound(),
]
response = self.app.get(
'redfish/v1/CertificateService/CertificateLocations')
self.assertEqual(200, response.status_code)
self.assertEqual([
'/redfish/v1/Managers/1/VirtualMedia/DVD/Certificates/cert1',
'/redfish/v1/Managers/2/VirtualMedia/CD/Certificates/cert2'
], [
item['@odata.id']
for item in response.json['Links']['Certificates']
])
def _get(self, identity):
try:
result = self._systems[identity]
except KeyError:
try:
uuid = self._by_name[identity]
except KeyError:
raise error.NotFound(f'Fake system {identity} was not found')
else:
raise error.AliasAccessError(uuid)
# NOTE(dtantsur): since the state change can only be observed after
# a _get() call, we can cheat a bit and update it on reading.
return self._update_if_needed(result)
def _get_instance(self, identity):
instance = self._cc.get_server(identity)
if instance:
if identity != instance.id:
raise error.AliasAccessError(instance.id)
return instance
msg = ('Error finding instance by UUID "%(identity)s" at OS '
'cloud %(os_cloud)s"' % {'identity': identity,
'os_cloud': self._os_cloud})
self._logger.debug(msg)
raise error.NotFound(msg)
def volume(identity, stg_id, vol_id):
uuid = app.systems.uuid(identity)
vol_col = app.volumes.get_volumes_col(uuid, stg_id)
for vol in vol_col:
if vol['Id'] == vol_id:
vol_id = app.systems.find_or_create_storage_volume(vol)
if not vol_id:
app.volumes.delete_volume(uuid, stg_id, vol)
else:
return flask.render_template(
'volume.json', identity=identity, storage_id=stg_id,
volume=vol)
raise error.NotFound()
def _get_device(self, identity, device):
try:
return self._devices[(identity, device)]
except KeyError:
self._devices.update({(identity, k): v
for k, v in self._device_types.items()})
try:
return self._devices[(identity, device)]
except KeyError:
raise error.NotFound(
'No such virtual media device %s owned by resource '
'%s' % (device, identity))
def virtual_media_get_certificate(identity, device, cert_id):
flask.current_app.managers.get_manager(identity)
location = (
f'/redfish/v1/Managers/{identity}/VirtualMedia/{device}'
f'/Certificates/{cert_id}'
)
certificates = flask.current_app.vmedia.list_certificates(identity, device)
try:
cert = next(c for c in certificates if c.id == cert_id)
except StopIteration:
raise error.NotFound()
return flask.render_template(
'certificate.json',
location=location,
cert_id=cert.id,
cert_string=cert.string,
cert_type=cert.type_,
)
def _get_domain(self, identity, readonly=False):
with libvirt_open(self._uri, readonly=readonly) as conn:
try:
uu_identity = uuid.UUID(identity)
return conn.lookupByUUID(uu_identity.bytes)
except (ValueError, libvirt.libvirtError):
try:
domain = conn.lookupByName(identity)
except libvirt.libvirtError as ex:
msg = ('Error finding domain by name/UUID "%(identity)s" '
'at libvirt URI %(uri)s": %(err)s' % {
'identity': identity,
'uri': self._uri,
'err': ex
})
self._logger.debug(msg)
raise error.NotFound(msg)
raise error.AliasAccessError(domain.UUIDString())
