upstream/oracle/userland-gate: comparison components/openstack/nova/files/solariszones/driver.py

equal deleted inserted replaced

-:bca6b9853ab7
+:1697d1e334a5
 except rad.client.ObjectError:
 return None
 except Exception:
 raise
+def zonemgr_strerror(ex):
+"""Format the payload from a zonemgr(3RAD) rad.client.ObjectError
+exception into a sensible error string that can be logged. Newlines
+are converted to a colon-space string to create a single line.
+If the exception was something other than rad.client.ObjectError,
+just return it as a string.
+"""
+if not isinstance(ex, rad.client.ObjectError):
+return str(ex)
+payload = ex.get_payload()
+if payload.code == zonemgr.ErrorCode.NONE:
+return str(ex)
+error = [str(payload.code)]
+if payload.str is not None and payload.str != '':
+error.append(payload.str)
+if payload.stderr is not None and payload.stderr != '':
+stderr = payload.stderr.rstrip()
+error.append(stderr.replace('\n', ': '))
+result = ': '.join(error)
+return result
 class ZoneConfig(object):
 """ZoneConfig - context manager for access zone configurations.
 Automatically opens the configuration for a zone and commits any changes
 before exiting
 """enables the editing of the zone."""
 try:
 self.zone.editConfig()
 self.editing = True
 return self
-except rad.client.ObjectError as err:
+except Exception as ex:
+reason = zonemgr_strerror(ex)
 LOG.error(_("Unable to initialize editing of instance '%s' via "
-"zonemgr(3RAD): %s") % (self.zone.name, err))
+"zonemgr(3RAD): %s") % (self.zone.name, reason))
 raise
 def __exit__(self, exc_type, exc_val, exc_tb):
 """looks for any kind of exception before exiting.  If one is found,
 cancel any configuration changes and reraise the exception.  If not,
 raise
 else:
 # commit the config
 try:
 self.zone.commitConfig()
-except rad.client.ObjectError as err:
+except Exception as ex:
+reason = zonemgr_strerror(ex)
 LOG.error(_("Unable to commit the new configuration for "
 "instance '%s' via zonemgr(3RAD): %s")
-% (self.zone.name, err))
+% (self.zone.name, reason))
 # Last ditch effort to cleanup.
 self.zone.cancelConfig()
 raise
 resource, [zonemgr.Property(prop, value)]))
 else:
 self.zone.setResourceProperties(
 zonemgr.Resource(resource),
 [zonemgr.Property(prop, value)])
-except rad.client.ObjectError as err:
+except Exception as ex:
+reason = zonemgr_strerror(ex)
 LOG.error(_("Unable to set '%s' property on '%s' resource for "
 "instance '%s' via zonemgr(3RAD): %s")
-% (prop, resource, self.zone.name, err))
+% (prop, resource, self.zone.name, reason))
 raise
 def addresource(self, resource, props=None):
 """creates a new resource with an optional property list."""
 if props is None:
 props = []
 try:
 self.zone.addResource(zonemgr.Resource(resource, props))
-except rad.client.ObjectError as err:
+except Exception as ex:
+if isinstance(ex, rad.client.ObjectError):
+code = ex.get_payload().code
+if (ignore_exists and
+code == zonemgr.ErrorCode.RESOURCE_ALREADY_EXISTS):
+self.zone.setResourceProperties(zonemgr.Resource(
+resource, None), props)
+return
+reason = zonemgr_strerror(ex)
 LOG.error(_("Unable to create new resource '%s' for instance '%s'"
 "via zonemgr(3RAD): %s")
-% (resource, self.zone.name, err))
+% (resource, self.zone.name, reason))
 raise
 def removeresources(self, resource, props=None):
 """removes resources whose properties include the optional property
 list specified in props.
 if props is None:
 props = []
 try:
 self.zone.removeResources(zonemgr.Resource(resource, props))
-except rad.client.ObjectError as err:
+except Exception as ex:
+reason = zonemgr_strerror(ex)
 LOG.error(_("Unable to remove resource '%s' for instance '%s' via "
-"zonemgr(3RAD): %s") % (resource, self.zone.name, err))
+"zonemgr(3RAD): %s")
+% (resource, self.zone.name, reason))
 raise
 class SolarisZonesDriver(driver.ComputeDriver):
 """Solaris Zones Driver using the zonemgr(3RAD) and kstat(3RAD) providers.
 return self._fc_hbas
 out = None
 try:
 out, err = utils.execute('/usr/sbin/fcinfo', 'hba-port')
-except processutils.ProcessExecutionError as err:
+except processutils.ProcessExecutionError:
 return []
 if out is None:
 raise RuntimeError(_("Cannot find any Fibre Channel HBAs"))
 """
 # TODO(Vek): Need to pass context in for access to auth_token
 name = instance['name']
 zone = self._get_zone_by_name(name)
 if zone is None:
-LOG.error(_("Unable to find instance '%s' via zonemgr(3RAD)")
-% name)
 raise exception.InstanceNotFound(instance_id=name)
 return {
 'state':    self._get_state(zone),
 'max_mem':  self._get_max_mem(zone),
 'mem':      self._get_mem(zone),
 # Use suriadm(1M) to generate a Fibre Channel storage URI.
 try:
 out, err = utils.execute('/usr/sbin/suriadm', 'lookup-uri',
 '-p', 'target=naa.%s' % target_wwn,
 '-p', 'lun=%s' % target_lun)
-except processutils.ProcessExecutionError as err:
+except processutils.ProcessExecutionError as ex:
+reason = ex.stderr
 LOG.error(_("Lookup failure of Fibre Channel volume '%s', lun "
-"%s: %s") % (target_wwn, target_lun, err.stderr))
+"%s: %s") % (target_wwn, target_lun, reason))
 raise
 lines = out.split('\n')
 # Use the long form SURI on the second output line.
 suri = lines[1].strip()
 self._set_boot_device(name, connection_info, brand)
 self._set_num_cpu(name, instance['vcpus'], brand)
 self._set_memory_cap(name, instance['memory_mb'], brand)
 self._set_network(context, name, instance, network_info, brand,
 sc_dir)
-except Exception as reason:
+except Exception as ex:
+reason = zonemgr_strerror(ex)
 LOG.error(_("Unable to create configuration for instance '%s' via "
 "zonemgr(3RAD): %s") % (name, reason))
 raise
 def _create_vnc_console_service(self, instance):
 name = instance['name']
 # TODO(npower): investigate using RAD instead of CLI invocation
 try:
 out, err = utils.execute('/usr/sbin/svccfg', '-s',
 VNC_CONSOLE_BASE_FMRI, 'add', name)
-except processutils.ProcessExecutionError as err:
+except processutils.ProcessExecutionError as ex:
 if self._has_vnc_console_service(instance):
 LOG.debug(_("Ignoring attempt to create existing zone VNC "
 "console SMF service for instance '%s'") % name)
 return
-else:
+reason = ex.stderr
 LOG.error(_("Unable to create zone VNC console SMF service "
 "'{0}': {1}").format(
-VNC_CONSOLE_BASE_FMRI + ':' + name, err))
+VNC_CONSOLE_BASE_FMRI + ':' + name, reason))
 raise
 def _delete_vnc_console_service(self, instance):
 """Delete a VNC console SMF service for a Solaris Zone"""
 name = instance['name']
 self._disable_vnc_console_service(instance)
 # TODO(npower): investigate using RAD instead of CLI invocation
 try:
 out, err = utils.execute('/usr/sbin/svccfg', '-s',
 VNC_CONSOLE_BASE_FMRI, 'delete', '-f',
 name)
-except processutils.ProcessExecutionError as err:
+except processutils.ProcessExecutionError as ex:
 if not self._has_vnc_console_service(instance):
 LOG.debug(_("Ignoring attempt to delete a non-existent zone "
 "VNC console SMF service for instance '%s'")
 % name)
 return
-else:
+reason = ex.stderr
-LOG.error(_("Unable to delete zone VNC console SMF service "
+LOG.error(_("Unable to delete zone VNC console SMF service '%s': "
-"'%s': %s")
+"%s")
-% (VNC_CONSOLE_BASE_FMRI + ':' + name, err))
+% (VNC_CONSOLE_BASE_FMRI + ':' + name, reason))
 raise
 def _enable_vnc_console_service(self, instance):
 """Enable a zone VNC console SMF service"""
 name = instance['name']
 'setprop', 'vnc/nova-enabled=true')
 out, err = utils.execute('/usr/sbin/svccfg', '-s', console_fmri,
 'refresh')
 out, err = utils.execute('/usr/sbin/svcadm', 'enable',
 console_fmri)
-except processutils.ProcessExecutionError as err:
+except processutils.ProcessExecutionError as ex:
 if not self._has_vnc_console_service(instance):
 LOG.debug(_("Ignoring attempt to enable a non-existent zone "
 "VNC console SMF service for instance '%s'")
 % name)
+return
+reason = ex.stderr
 LOG.error(_("Unable to start zone VNC console SMF service "
-"'%s': %s") % (console_fmri, err))
+"'%s': %s") % (console_fmri, reason))
 raise
 # Allow some time for the console service to come online.
 greenthread.sleep(2)
 while True:
 raise exception.ConsoleNotFoundForInstance(
 instance_uuid=instance['uuid'])
 # Wait for service state to transition to (hopefully) online
 # state or offline/maintenance states.
 greenthread.sleep(2)
-except processutils.ProcessExecutionError as err:
+except processutils.ProcessExecutionError as ex:
+reason = ex.stderr
 LOG.error(_("Error querying state of zone VNC console SMF "
-"service '%s': %s") % (console_fmri, err))
+"service '%s': %s") % (console_fmri, reason))
 raise
 # TODO(npower): investigate using RAD instead of CLI invocation
 try:
 # The console SMF service exits with SMF_TEMP_DISABLE to prevent
 # unnecessarily coming online at boot. Make that happen.
 out, err = utils.execute('/usr/sbin/svccfg', '-s', console_fmri,
 'setprop', 'vnc/nova-enabled=false')
 out, err = utils.execute('/usr/sbin/svccfg', '-s', console_fmri,
 'refresh')
-except processutils.ProcessExecutionError as err:
+except processutils.ProcessExecutionError as ex:
+reason = ex.stderr
 LOG.error(_("Unable to update 'vnc/nova-enabled' property for "
 "zone VNC console SMF service "
-"'%s': %s") % (console_fmri, err))
+"'%s': %s") % (console_fmri, reason))
 raise
 def _disable_vnc_console_service(self, instance):
 """Disable a zone VNC console SMF service"""
 name = instance['name']
 console_fmri = VNC_CONSOLE_BASE_FMRI + ':' + name
 # TODO(npower): investigate using RAD instead of CLI invocation
 try:
 out, err = utils.execute('/usr/sbin/svcadm', 'disable',
 console_fmri)
-except processutils.ProcessExecutionError as err:
+except processutils.ProcessExecutionError as ex:
+reason = ex.stderr
 LOG.error(_("Unable to disable zone VNC console SMF service "
-"'%s': %s") % (console_fmri, err))
+"'%s': %s") % (console_fmri, reason))
 # The console service sets a SMF instance property for the port
 # on which the VNC service is listening. The service needs to be
 # refreshed to reset the property value
 try:
 out, err = utils.execute('/usr/sbin/svccfg', '-s', console_fmri,
 'refresh')
-except processutils.ProcessExecutionError as err:
+except processutils.ProcessExecutionError as ex:
+reason = ex.stderr
 LOG.error(_("Unable to refresh zone VNC console SMF service "
-"'%s': %s") % (console_fmri, err))
+"'%s': %s") % (console_fmri, reason))
 def _get_vnc_console_service_state(self, instance):
 """Returns state of the instance zone VNC console SMF service"""
 name = instance['name']
 if not self._has_vnc_console_service(instance):
 # TODO(npower): investigate using RAD instead of CLI invocation
 try:
 state, err = utils.execute('/usr/sbin/svcs', '-H', '-o', 'state',
 console_fmri)
 return state.strip()
-except processutils.ProcessExecutionError as err:
+except processutils.ProcessExecutionError as ex:
+reason = ex.stderr
 LOG.error(_("Console state request failed for zone VNC console "
-"SMF service for instance '%s': %s") % (name, err))
+"SMF service for instance '%s': %s")
+% (name, reason))
 raise
 def _has_vnc_console_service(self, instance):
 """Returns True if the instance has a zone VNC console SMF service"""
 name = instance['name']
 # TODO(npower): investigate using RAD instead of CLI invocation
 try:
 utils.execute('/usr/bin/svcs', '-H', '-o', 'state',
 console_fmri)
 return True
-except processutils.ProcessExecutionError as err:
+except Exception:
 return False
 def _install(self, instance, image, sc_dir):
 """Install a new Solaris Zone root file system."""
 name = instance['name']
 try:
 LOG.debug(_("Installing instance '%s' (%s)") %
 (name, instance['display_name']))
 zone.install(options=options)
-except Exception as reason:
+except Exception as ex:
+reason = zonemgr_strerror(ex)
 LOG.error(_("Unable to install root file system for instance '%s' "
 "via zonemgr(3RAD): %s") % (name, reason))
 raise
 LOG.debug(_("Installation of instance '%s' (%s) complete") %
 if zone is None:
 raise exception.InstanceNotFound(instance_id=name)
 try:
 zone.boot()
-except Exception as reason:
+except Exception as ex:
+reason = zonemgr_strerror(ex)
 LOG.error(_("Unable to power on instance '%s' via zonemgr(3RAD): "
 "%s") % (name, reason))
 raise exception.InstancePowerOnFailure(reason=reason)
 def _uninstall(self, instance):
 LOG.debug(_("Uninstall not required for zone '%s' in state '%s'")
 % (name, zone.state))
 return
 try:
 zone.uninstall(['-F'])
-except Exception as reason:
+except Exception as ex:
+reason = zonemgr_strerror(ex)
 LOG.error(_("Unable to uninstall root file system for instance "
 "'%s' via zonemgr(3RAD): %s") % (name, reason))
 raise
 def _delete_config(self, instance):
 raise exception.InstanceNotFound(instance_id=name)
 zonemanager = self.rad_connection.get_object(zonemgr.ZoneManager())
 try:
 zonemanager.delete(name)
-except Exception as reason:
+except Exception as ex:
+reason = zonemgr_strerror(ex)
 LOG.error(_("Unable to delete configuration for instance '%s' via "
 "zonemgr(3RAD): %s") % (name, reason))
 raise
 def spawn(self, context, instance, image_meta, injected_files,
 mountpoint = "c1d0"
 name = instance['name']
 try:
 connection_info = self._connect_boot_volume(volume, mountpoint,
 context, instance)
-except exception.InvalidVolume as badvol:
+except exception.InvalidVolume as reason:
 # This Cinder volume is not usable for ZOSS so discard it.
 # zonecfg will apply default zonepath dataset configuration
 # instead. Carry on
 LOG.warning(_("Volume '%s' is being discarded: %s")
-% (volume_id, badvol))
+% (volume_id, reason))
 self._volume_api.delete(context, volume_id)
 connection_info = None
 except Exception as reason:
 # Something really bad happened. Don't pass Go.
 LOG.error(_("Unable to attach root zpool volume '%s' to instance "
 connection_info, sc_dir)
 configured = True
 self._install(instance, image, sc_dir)
 installed = True
 self._power_on(instance)
-except Exception as reason:
+except Exception as ex:
+reason = zonemgr_strerror(ex)
 LOG.error(_("Unable to spawn instance '%s' via zonemgr(3RAD): %s")
 % (name, reason))
 if installed:
 self._uninstall(instance)
 if configured:
 if halt_type == 'SOFT':
 zone.shutdown()
 else:
 # 'HARD'
 zone.halt()
-except rad.client.ObjectError as reason:
+except Exception as ex:
-result = reason.get_payload()
+reason = zonemgr_strerror(ex)
-if result.code == zonemgr.ErrorCode.COMMAND_ERROR:
+if isinstance(ex, rad.client.ObjectError):
-LOG.warning(_("Ignoring command error returned while trying "
+code = ex.get_payload().code
-"to power off instance '%s' via zonemgr(3RAD): "
+if code == zonemgr.ErrorCode.COMMAND_ERROR:
-"%s" % (name, reason)))
+LOG.warning(_("Ignoring command error returned while "
-return
+"trying to power off instance '%s' via "
-except Exception as reason:
+"zonemgr(3RAD): %s" % (name, reason)))
+return
 LOG.error(_("Unable to power off instance '%s' via zonemgr(3RAD): "
 "%s") % (name, reason))
 raise exception.InstancePowerOffFailure(reason=reason)
 def destroy(self, context, instance, network_info, block_device_info=None,
 self._power_off(instance, 'HARD')
 if self._get_state(zone) == power_state.SHUTDOWN:
 self._uninstall(instance)
 if self._get_state(zone) == power_state.NOSTATE:
 self._delete_config(instance)
-except Exception as reason:
+except Exception as ex:
+reason = zonemgr_strerror(ex)
 LOG.warning(_("Unable to destroy instance '%s' via zonemgr(3RAD): "
 "%s") % (name, reason))
 def cleanup(self, context, instance, network_info, block_device_info=None,
 destroy_disks=True, migrate_data=None, destroy_vifs=True):
 try:
 if reboot_type == 'SOFT':
 zone.shutdown(['-r'])
 else:
 zone.reboot()
-except Exception as reason:
+except Exception as ex:
+reason = zonemgr_strerror(ex)
 LOG.error(_("Unable to reboot instance '%s' via zonemgr(3RAD): %s")
 % (name, reason))
 raise exception.InstanceRebootFailure(reason=reason)
 def get_console_pool_info(self, console_type):
 # refreshed to reflect the current property value
 # TODO(npower): investigate using RAD instead of CLI invocation
 try:
 out, err = utils.execute('/usr/sbin/svccfg', '-s', console_fmri,
 'refresh')
-except processutils.ProcessExecutionError as err:
+except processutils.ProcessExecutionError as ex:
+reason = ex.stderr
 LOG.error(_("Unable to refresh zone VNC console SMF service "
-"'%s': %s" % (console_fmri, err)))
+"'%s': %s" % (console_fmri, reason)))
 raise
 host = CONF.vncserver_proxyclient_address
 try:
 out, err = utils.execute('/usr/bin/svcprop', '-p', 'vnc/port',
 console_fmri)
 port = int(out.strip())
 return ctype.ConsoleVNC(host=host,
 port=port,
 internal_access_path=None)
-except processutils.ProcessExecutionError as err:
+except processutils.ProcessExecutionError as ex:
+reason = ex.stderr
 LOG.error(_("Unable to read VNC console port from zone VNC "
 "console SMF service '%s': %s"
-% (console_fmri, err)))
+% (console_fmri, reason)))
 def get_spice_console(self, context, instance):
 """Get connection info for a spice console.
 :param context: security context
 """
 # TODO(Vek): Need to pass context in for access to auth_token
 name = instance['name']
 zone = self._get_zone_by_name(name)
 if zone is None:
-LOG.error(_("Unable to find instance '%s' via zonemgr(3RAD)")
-% name)
 raise exception.InstanceNotFound(instance_id=name)
 return self._get_zone_diagnostics(zone)
 def get_instance_diagnostics(self, instance):
 """Return data about VM diagnostics.
 metadata['disk_format'] = 'zfs'
 snapshot_service.update(context,
 image_id,
 metadata,
 None)
-except exception.Invalid as invalid:
+except exception.Invalid:
 LOG.warning(_("Image service rejected image metadata "
 "container and disk formats 'uar' and "
 "'zfs'. Using generic values 'ovf' and "
 "'raw' as fallbacks."))
 finally:
 def _get_zpool_property(self, prop, zpool):
 """Get the value of property from the zpool."""
 try:
 value = None
 (out, _err) = utils.execute('/usr/sbin/zpool', 'get', prop, zpool)
-except processutils.ProcessExecutionError as err:
+except processutils.ProcessExecutionError as ex:
+reason = ex.stderr
 LOG.error(_("Failed to get property '%s' from zpool '%s': %s")
-% (prop, zpool, err.stderr))
+% (prop, zpool, reason))
 return value
 zpool_prop = out.splitlines()[1].split()
 if zpool_prop[1] == prop:
 value = zpool_prop[2]
 name = instance['name']
 try:
 self._live_migration(name, dest, dry_run=False)
 except Exception as ex:
 with excutils.save_and_reraise_exception():
+reason = zonemgr_strerror(ex)
 LOG.error(_("Unable to live migrate instance '%s' to host "
 "'%s' via zonemgr(3RAD): %s")
-% (name, dest, ex))
+% (name, dest, reason))
 recover_method(context, instance, dest, block_migration)
 post_method(context, instance, dest, block_migration, migrate_data)
 def rollback_live_migration_at_destination(self, context, instance,
 return
 try:
 self._delete_config(instance)
 except Exception as ex:
+reason = zonemgr_strerror(ex)
 LOG.error(_("Unable to delete configuration for instance '%s' via "
-"zonemgr(3RAD): %s") % (name, ex))
+"zonemgr(3RAD): %s") % (name, reason))
 raise
 def post_live_migration_at_source(self, context, instance, network_info):
 """Unplug VIFs from networks at source.
 name = instance['name']
 dest = dest_check_data['hypervisor_hostname']
 try:
 self._live_migration(name, dest, dry_run=True)
 except Exception as ex:
-raise exception.MigrationPreCheckError(reason=ex)
+reason = zonemgr_strerror(ex)
+raise exception.MigrationPreCheckError(reason=reason)
 return dest_check_data
 def get_instance_disk_info(self, instance_name,
 block_device_info=None):
 """Retrieve information about actual disk sizes of an instance.

branch	s11u3-sru
changeset 5414	1697d1e334a5
parent 5413	bca6b9853ab7
child 5429	1ae4cfbadda9