Common and Misc Libraries

Libraries common throughout Nova or just ones that haven’t been categorized very well yet.

The nova.adminclient Module

The nova.context Module

RequestContext: context for requests that persist through all of nova.

class RequestContext(user_id, project_id, is_admin=None, read_deleted='no', roles=None, remote_address=None, timestamp=None, request_id=None, auth_token=None, overwrite=True, quota_class=None, user_name=None, project_name=None, service_catalog=None, instance_lock_checked=False, **kwargs)

Bases: object

Security context and request information.

Represents the user taking a given action within the system.

RequestContext.elevated(read_deleted=None, overwrite=False)

Return a version of this context with admin flag set.

classmethod RequestContext.from_dict(values)
RequestContext.read_deleted
RequestContext.tenant
RequestContext.to_dict()
RequestContext.update_store()
RequestContext.user
authorize_project_context(context, project_id)

Ensures a request has permission to access the given project.

authorize_quota_class_context(context, class_name)

Ensures a request has permission to access the given quota class.

authorize_user_context(context, user_id)

Ensures a request has permission to access the given user.

generate_request_id()
get_admin_context(read_deleted='no')
is_user_context(context)

Indicates if the request context is a normal user.

require_admin_context(ctxt)

Raise exception.AdminRequired() if context is an admin context.

require_context(ctxt)

Raise exception.NotAuthorized() if context is not a user or an admin context.

The nova.exception Module

Nova base exception handling.

Includes decorator for re-raising Nova-type exceptions.

SHOULD include dedicated exception logging.

exception AdminRequired(message=None, **kwargs)

Bases: nova.exception.NotAuthorized

AdminRequired.msg_fmt = u'User does not have admin privileges'
exception AgentBuildExists(message=None, **kwargs)

Bases: nova.exception.NovaException

AgentBuildExists.msg_fmt = u'Agent-build with hypervisor %(hypervisor)s os %(os)s architecture %(architecture)s exists.'
exception AgentBuildNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

AgentBuildNotFound.msg_fmt = u'No agent-build associated with id %(id)s.'
exception AgentError(message=None, **kwargs)

Bases: nova.exception.NovaException

AgentError.msg_fmt = u'Error during following call to agent: %(method)s'
exception AgentNotImplemented(message=None, **kwargs)

Bases: nova.exception.AgentError

AgentNotImplemented.msg_fmt = u'Agent does not support the call: %(method)s'
exception AgentTimeout(message=None, **kwargs)

Bases: nova.exception.AgentError

AgentTimeout.msg_fmt = u'Unable to contact guest agent. The following call timed out: %(method)s'
exception AggregateError(message=None, **kwargs)

Bases: nova.exception.NovaException

AggregateError.msg_fmt = u"Aggregate %(aggregate_id)s: action '%(action)s' caused an error: %(reason)s."
exception AggregateHostExists(message=None, **kwargs)

Bases: nova.exception.NovaException

AggregateHostExists.msg_fmt = u'Aggregate %(aggregate_id)s already has host %(host)s.'
exception AggregateHostNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

AggregateHostNotFound.msg_fmt = u'Aggregate %(aggregate_id)s has no host %(host)s.'
exception AggregateMetadataNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

AggregateMetadataNotFound.msg_fmt = u'Aggregate %(aggregate_id)s has no metadata with key %(metadata_key)s.'
exception AggregateNameExists(message=None, **kwargs)

Bases: nova.exception.NovaException

AggregateNameExists.msg_fmt = u'Aggregate %(aggregate_name)s already exists.'
exception AggregateNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

AggregateNotFound.msg_fmt = u'Aggregate %(aggregate_id)s could not be found.'
exception AutoDiskConfigDisabledByImage(message=None, **kwargs)

Bases: nova.exception.Invalid

AutoDiskConfigDisabledByImage.msg_fmt = u'Requested image %(image)s has automatic disk resize disabled.'
exception Base64Exception(message=None, **kwargs)

Bases: nova.exception.NovaException

Base64Exception.msg_fmt = u'Invalid Base 64 data for file %(path)s'
exception BuildAbortException(message=None, **kwargs)

Bases: nova.exception.NovaException

BuildAbortException.msg_fmt = u'Build of instance %(instance_uuid)s aborted: %(reason)s'
exception CannotDisassociateAutoAssignedFloatingIP(message=None, **kwargs)

Bases: nova.exception.NovaException

CannotDisassociateAutoAssignedFloatingIP.ec2_code = 'UnsupportedOpperation'
CannotDisassociateAutoAssignedFloatingIP.msg_fmt = u'Cannot disassociate auto assigned floating ip'
exception CannotResizeDisk(message=None, **kwargs)

Bases: nova.exception.NovaException

CannotResizeDisk.msg_fmt = u'Server disk was unable to be resized because: %(reason)s'
exception CannotResizeToSameFlavor(message=None, **kwargs)

Bases: nova.exception.NovaException

CannotResizeToSameFlavor.msg_fmt = u'When resizing, instances must change flavor!'
exception CellExists(message=None, **kwargs)

Bases: nova.exception.NovaException

CellExists.msg_fmt = u'Cell with name %(name)s already exists.'
exception CellMaxHopCountReached(message=None, **kwargs)

Bases: nova.exception.NovaException

CellMaxHopCountReached.msg_fmt = u'Cell message has reached maximum hop count: %(hop_count)s'
exception CellNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

CellNotFound.msg_fmt = u"Cell %(cell_name)s doesn't exist."
exception CellRoutingInconsistency(message=None, **kwargs)

Bases: nova.exception.NovaException

CellRoutingInconsistency.msg_fmt = u'Inconsistency in cell routing: %(reason)s'
exception CellServiceAPIMethodNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

CellServiceAPIMethodNotFound.msg_fmt = u'Service API method not found: %(detail)s'
exception CellTimeout(message=None, **kwargs)

Bases: nova.exception.NotFound

CellTimeout.msg_fmt = u'Timeout waiting for response from cell'
exception CellsUpdateUnsupported(message=None, **kwargs)

Bases: nova.exception.NovaException

CellsUpdateUnsupported.msg_fmt = u'Cannot update cells configuration file.'
exception CidrConflict(message=None, **kwargs)

Bases: nova.exception.NovaException

CidrConflict.code = 409
CidrConflict.msg_fmt = u'There was a conflict when trying to complete your request.'
exception ClassNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

ClassNotFound.msg_fmt = u'Class %(class_name)s could not be found: %(exception)s'
exception ComputeHostNotFound(message=None, **kwargs)

Bases: nova.exception.HostNotFound

ComputeHostNotFound.msg_fmt = u'Compute host %(host)s could not be found.'
exception ComputeResourcesUnavailable(message=None, **kwargs)

Bases: nova.exception.ServiceUnavailable

ComputeResourcesUnavailable.msg_fmt = u'Insufficient compute resources.'
exception ComputeServiceUnavailable(message=None, **kwargs)

Bases: nova.exception.ServiceUnavailable

ComputeServiceUnavailable.msg_fmt = u'Compute service of %(host)s is unavailable at this time.'
exception ConfigDriveInvalidValue(message=None, **kwargs)

Bases: nova.exception.Invalid

ConfigDriveInvalidValue.msg_fmt = u'Invalid value for Config Drive option: %(option)s'
exception ConfigDriveMountFailed(message=None, **kwargs)

Bases: nova.exception.NovaException

ConfigDriveMountFailed.msg_fmt = u'Could not mount vfat config drive. %(operation)s failed. Error: %(error)s'
exception ConfigDriveUnknownFormat(message=None, **kwargs)

Bases: nova.exception.NovaException

ConfigDriveUnknownFormat.msg_fmt = u'Unknown config drive format %(format)s. Select one of iso9660 or vfat.'
exception ConfigNotFound(message=None, **kwargs)

Bases: nova.exception.NovaException

ConfigNotFound.msg_fmt = u'Could not find config at %(path)s'
exception ConsoleNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

ConsoleNotFound.msg_fmt = u'Console %(console_id)s could not be found.'
exception ConsoleNotFoundForInstance(message=None, **kwargs)

Bases: nova.exception.ConsoleNotFound

ConsoleNotFoundForInstance.msg_fmt = u'Console for instance %(instance_uuid)s could not be found.'
exception ConsoleNotFoundInPoolForInstance(message=None, **kwargs)

Bases: nova.exception.ConsoleNotFound

ConsoleNotFoundInPoolForInstance.msg_fmt = u'Console for instance %(instance_uuid)s in pool %(pool_id)s could not be found.'
exception ConsolePoolExists(message=None, **kwargs)

Bases: nova.exception.NovaException

ConsolePoolExists.msg_fmt = u'Console pool with host %(host)s, console_type %(console_type)s and compute_host %(compute_host)s already exists.'
exception ConsolePoolNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

ConsolePoolNotFound.msg_fmt = u'Console pool %(pool_id)s could not be found.'
exception ConsolePoolNotFoundForHostType(message=None, **kwargs)

Bases: nova.exception.NotFound

ConsolePoolNotFoundForHostType.msg_fmt = u'Console pool of type %(console_type)s for compute host %(compute_host)s on proxy host %(host)s not found.'
exception ConsoleTypeInvalid(message=None, **kwargs)

Bases: nova.exception.Invalid

ConsoleTypeInvalid.msg_fmt = u'Invalid console type %(console_type)s'
exception ConsoleTypeUnavailable(message=None, **kwargs)

Bases: nova.exception.Invalid

ConsoleTypeUnavailable.msg_fmt = u'Unavailable console type %(console_type)s.'
exception ConstraintNotMet(message=None, **kwargs)

Bases: nova.exception.NovaException

ConstraintNotMet.code = 412
ConstraintNotMet.msg_fmt = u'Constraint not met.'
exception ConvertedException(code=0, title='', explanation='')

Bases: webob.exc.WSGIHTTPException

exception CoreAPIMissing(message=None, **kwargs)

Bases: nova.exception.NovaException

CoreAPIMissing.msg_fmt = u'Core API extensions are missing: %(missing_apis)s'
exception CouldNotFetchImage(message=None, **kwargs)

Bases: nova.exception.NovaException

CouldNotFetchImage.msg_fmt = u'Could not fetch image %(image_id)s'
exception CouldNotUploadImage(message=None, **kwargs)

Bases: nova.exception.NovaException

CouldNotUploadImage.msg_fmt = u'Could not upload image %(image_id)s'
exception CryptoCAFileNotFound(message=None, **kwargs)

Bases: nova.exception.FileNotFound

CryptoCAFileNotFound.msg_fmt = u'The CA file for %(project)s could not be found'
exception CryptoCRLFileNotFound(message=None, **kwargs)

Bases: nova.exception.FileNotFound

CryptoCRLFileNotFound.msg_fmt = u'The CRL file for %(project)s could not be found'
exception DBNotAllowed(message=None, **kwargs)

Bases: nova.exception.NovaException

DBNotAllowed.msg_fmt = u'%(binary)s attempted direct database access which is not allowed by policy'
exception DatastoreNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

DatastoreNotFound.msg_fmt = u'Could not find the datastore reference(s) which the VM uses.'
exception DecryptionFailure(message=None, **kwargs)

Bases: nova.exception.NovaException

DecryptionFailure.msg_fmt = u'Failed to decrypt text: %(reason)s'
exception DestinationDiskExists(message=None, **kwargs)

Bases: nova.exception.Invalid

DestinationDiskExists.msg_fmt = u'The supplied disk path (%(path)s) already exists, it is expected not to exist.'
exception DestinationHypervisorTooOld(message=None, **kwargs)

Bases: nova.exception.Invalid

DestinationHypervisorTooOld.msg_fmt = u'The instance requires a newer hypervisor version than has been provided.'
exception DeviceIsBusy(message=None, **kwargs)

Bases: nova.exception.Invalid

DeviceIsBusy.msg_fmt = u'The supplied device (%(device)s) is busy.'
exception DevicePathInUse(message=None, **kwargs)

Bases: nova.exception.Invalid

DevicePathInUse.code = 409
DevicePathInUse.msg_fmt = u'The supplied device path (%(path)s) is in use.'
exception DiskNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

DiskNotFound.msg_fmt = u'No disk at %(location)s'
exception DuplicateVlan(message=None, **kwargs)

Bases: nova.exception.NovaException

DuplicateVlan.msg_fmt = u'Detected existing vlan with id %(vlan)d'
exception EncryptionFailure(message=None, **kwargs)

Bases: nova.exception.NovaException

EncryptionFailure.msg_fmt = u'Failed to encrypt text: %(reason)s'
exception FileNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

FileNotFound.msg_fmt = u'File %(file_path)s could not be found.'
exception FixedIpAlreadyInUse(message=None, **kwargs)

Bases: nova.exception.NovaException

FixedIpAlreadyInUse.msg_fmt = u'Fixed IP address %(address)s is already in use on instance %(instance_uuid)s.'
exception FixedIpAssociatedWithMultipleInstances(message=None, **kwargs)

Bases: nova.exception.NovaException

FixedIpAssociatedWithMultipleInstances.msg_fmt = u"More than one instance is associated with fixed ip address '%(address)s'."
exception FixedIpExists(message=None, **kwargs)

Bases: nova.exception.NovaException

FixedIpExists.msg_fmt = u'Fixed ip %(address)s already exists.'
exception FixedIpInvalid(message=None, **kwargs)

Bases: nova.exception.Invalid

FixedIpInvalid.msg_fmt = u'Fixed IP address %(address)s is invalid.'
exception FixedIpLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

FixedIpLimitExceeded.msg_fmt = u'Maximum number of fixed ips exceeded'
exception FixedIpNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

FixedIpNotFound.msg_fmt = u'No fixed IP associated with id %(id)s.'
exception FixedIpNotFoundForAddress(message=None, **kwargs)

Bases: nova.exception.FixedIpNotFound

FixedIpNotFoundForAddress.msg_fmt = u'Fixed ip not found for address %(address)s.'
exception FixedIpNotFoundForInstance(message=None, **kwargs)

Bases: nova.exception.FixedIpNotFound

FixedIpNotFoundForInstance.msg_fmt = u'Instance %(instance_uuid)s has zero fixed ips.'
exception FixedIpNotFoundForNetwork(message=None, **kwargs)

Bases: nova.exception.FixedIpNotFound

FixedIpNotFoundForNetwork.msg_fmt = u'Fixed IP address (%(address)s) does not exist in network (%(network_uuid)s).'
exception FixedIpNotFoundForNetworkHost(message=None, **kwargs)

Bases: nova.exception.FixedIpNotFound

FixedIpNotFoundForNetworkHost.msg_fmt = u'Network host %(host)s has zero fixed ips in network %(network_id)s.'
exception FixedIpNotFoundForSpecificInstance(message=None, **kwargs)

Bases: nova.exception.FixedIpNotFound

FixedIpNotFoundForSpecificInstance.msg_fmt = u"Instance %(instance_uuid)s doesn't have fixed ip '%(ip)s'."
exception FlavorAccessExists(message=None, **kwargs)

Bases: nova.exception.NovaException

FlavorAccessExists.msg_fmt = u'Flavor access already exists for flavor %(flavor_id)s and project %(project_id)s combination.'
exception FlavorAccessNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

FlavorAccessNotFound.msg_fmt = u'Flavor access not found for %(flavor_id)s / %(project_id)s combination.'
exception FlavorNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

FlavorNotFound.msg_fmt = u'Flavor %(flavor_id)s could not be found.'
exception FloatingIpAssociated(message=None, **kwargs)

Bases: nova.exception.NovaException

FloatingIpAssociated.ec2_code = 'UnsupportedOpperation'
FloatingIpAssociated.msg_fmt = u'Floating ip %(address)s is associated.'
exception FloatingIpDNSExists(message=None, **kwargs)

Bases: nova.exception.Invalid

FloatingIpDNSExists.msg_fmt = u'The DNS entry %(name)s already exists in domain %(domain)s.'
exception FloatingIpExists(message=None, **kwargs)

Bases: nova.exception.NovaException

FloatingIpExists.msg_fmt = u'Floating ip %(address)s already exists.'
exception FloatingIpLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

FloatingIpLimitExceeded.msg_fmt = u'Maximum number of floating ips exceeded'
exception FloatingIpMultipleFoundForAddress(message=None, **kwargs)

Bases: nova.exception.NovaException

FloatingIpMultipleFoundForAddress.msg_fmt = u'Multiple floating ips are found for address %(address)s.'
exception FloatingIpNotAssociated(message=None, **kwargs)

Bases: nova.exception.NovaException

FloatingIpNotAssociated.msg_fmt = u'Floating ip %(address)s is not associated.'
exception FloatingIpNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

FloatingIpNotFound.ec2_code = 'UnsupportedOpperation'
FloatingIpNotFound.msg_fmt = u'Floating ip not found for id %(id)s.'
exception FloatingIpNotFoundForAddress(message=None, **kwargs)

Bases: nova.exception.FloatingIpNotFound

FloatingIpNotFoundForAddress.msg_fmt = u'Floating ip not found for address %(address)s.'
exception FloatingIpNotFoundForHost(message=None, **kwargs)

Bases: nova.exception.FloatingIpNotFound

FloatingIpNotFoundForHost.msg_fmt = u'Floating ip not found for host %(host)s.'
exception FloatingIpPoolNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

FloatingIpPoolNotFound.msg_fmt = u'Floating ip pool not found.'
FloatingIpPoolNotFound.safe = True
exception GlanceConnectionFailed(message=None, **kwargs)

Bases: nova.exception.NovaException

GlanceConnectionFailed.msg_fmt = u'Connection to glance host %(host)s:%(port)s failed: %(reason)s'
exception HostBinaryNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

HostBinaryNotFound.msg_fmt = u'Could not find binary %(binary)s on host %(host)s.'
exception HostNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

HostNotFound.msg_fmt = u'Host %(host)s could not be found.'
exception ImageDownloadModuleConfigurationError(message=None, **kwargs)

Bases: nova.exception.ImageDownloadModuleError

ImageDownloadModuleConfigurationError.msg_fmt = u'The module %(module)s is misconfigured: %(reason)s.'
exception ImageDownloadModuleError(message=None, **kwargs)

Bases: nova.exception.NovaException

ImageDownloadModuleError.msg_fmt = u'There was an error with the download module %(module)s. %(reason)s'
exception ImageDownloadModuleMetaDataError(message=None, **kwargs)

Bases: nova.exception.ImageDownloadModuleError

ImageDownloadModuleMetaDataError.msg_fmt = u'The metadata for this location will not work with this module %(module)s. %(reason)s.'
exception ImageDownloadModuleNotImplementedError(message=None, **kwargs)

Bases: nova.exception.ImageDownloadModuleError

ImageDownloadModuleNotImplementedError.msg_fmt = u'The method %(method_name)s is not implemented.'
exception ImageNotActive(message=None, **kwargs)

Bases: nova.exception.NovaException

ImageNotActive.ec2_code = 'IncorrectState'
ImageNotActive.msg_fmt = u'Image %(image_id)s is not active.'
exception ImageNotAuthorized(message=None, **kwargs)

Bases: nova.exception.NovaException

ImageNotAuthorized.msg_fmt = u'Not authorized for image %(image_id)s.'
exception ImageNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

ImageNotFound.msg_fmt = u'Image %(image_id)s could not be found.'
exception ImageNotFoundEC2(message=None, **kwargs)

Bases: nova.exception.ImageNotFound

ImageNotFoundEC2.msg_fmt = u'Image %(image_id)s could not be found. The nova EC2 API assigns image ids dynamically when they are listed for the first time. Have you listed image ids since adding this image?'
exception ImageRotationNotAllowed(message=None, **kwargs)

Bases: nova.exception.NovaException

ImageRotationNotAllowed.msg_fmt = u'Rotation is not allowed for snapshots'
exception ImageUnacceptable(message=None, **kwargs)

Bases: nova.exception.Invalid

ImageUnacceptable.msg_fmt = u'Image %(image_id)s is unacceptable: %(reason)s'
exception IncompatibleObjectVersion(message=None, **kwargs)

Bases: nova.exception.NovaException

IncompatibleObjectVersion.msg_fmt = u'Version %(objver)s of %(objname)s is not supported'
exception InstanceActionEventNotFound(message=None, **kwargs)

Bases: nova.exception.NovaException

InstanceActionEventNotFound.msg_fmt = u'Event %(event)s not found for action id %(action_id)s'
exception InstanceActionNotFound(message=None, **kwargs)

Bases: nova.exception.NovaException

InstanceActionNotFound.msg_fmt = u'Action for request_id %(request_id)s on instance %(instance_uuid)s not found'
exception InstanceDeployFailure(message=None, **kwargs)

Bases: nova.exception.Invalid

InstanceDeployFailure.msg_fmt = u'Failed to deploy instance: %(reason)s'
exception InstanceExists(message=None, **kwargs)

Bases: nova.exception.NovaException

InstanceExists.msg_fmt = u'Instance %(name)s already exists.'
exception InstanceFaultRollback(inner_exception=None)

Bases: nova.exception.NovaException

exception InstanceGroupIdExists(message=None, **kwargs)

Bases: nova.exception.NovaException

InstanceGroupIdExists.msg_fmt = u'Instance group %(group_uuid)s already exists.'
exception InstanceGroupMemberNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

InstanceGroupMemberNotFound.msg_fmt = u'Instance group %(group_uuid)s has no member with id %(instance_id)s.'
exception InstanceGroupMetadataNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

InstanceGroupMetadataNotFound.msg_fmt = u'Instance group %(group_uuid)s has no metadata with key %(metadata_key)s.'
exception InstanceGroupNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

InstanceGroupNotFound.msg_fmt = u'Instance group %(group_uuid)s could not be found.'
exception InstanceGroupPolicyNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

InstanceGroupPolicyNotFound.msg_fmt = u'Instance group %(group_uuid)s has no policy %(policy)s.'
exception InstanceInfoCacheNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

InstanceInfoCacheNotFound.msg_fmt = u'Info cache for instance %(instance_uuid)s could not be found.'
exception InstanceInvalidState(message=None, **kwargs)

Bases: nova.exception.Invalid

InstanceInvalidState.msg_fmt = u'Instance %(instance_uuid)s in %(attr)s %(state)s. Cannot %(method)s while the instance is in this state.'
exception InstanceIsLocked(message=None, **kwargs)

Bases: nova.exception.InstanceInvalidState

InstanceIsLocked.msg_fmt = u'Instance %(instance_uuid)s is locked'
exception InstanceNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

InstanceNotFound.ec2_code = 'InvalidInstanceID.NotFound'
InstanceNotFound.msg_fmt = u'Instance %(instance_id)s could not be found.'
exception InstanceNotInRescueMode(message=None, **kwargs)

Bases: nova.exception.Invalid

InstanceNotInRescueMode.msg_fmt = u'Instance %(instance_id)s is not in rescue mode'
exception InstanceNotReady(message=None, **kwargs)

Bases: nova.exception.Invalid

InstanceNotReady.msg_fmt = u'Instance %(instance_id)s is not ready'
exception InstanceNotRescuable(message=None, **kwargs)

Bases: nova.exception.Invalid

InstanceNotRescuable.msg_fmt = u'Instance %(instance_id)s cannot be rescued: %(reason)s'
exception InstanceNotRunning(message=None, **kwargs)

Bases: nova.exception.Invalid

InstanceNotRunning.msg_fmt = u'Instance %(instance_id)s is not running.'
exception InstancePasswordSetFailed(message=None, **kwargs)

Bases: nova.exception.NovaException

InstancePasswordSetFailed.msg_fmt = u'Failed to set admin password on %(instance)s because %(reason)s'
InstancePasswordSetFailed.safe = True
exception InstancePowerOffFailure(message=None, **kwargs)

Bases: nova.exception.Invalid

InstancePowerOffFailure.msg_fmt = u'Failed to power off instance: %(reason)s.'
exception InstancePowerOnFailure(message=None, **kwargs)

Bases: nova.exception.Invalid

InstancePowerOnFailure.msg_fmt = u'Failed to power on instance: %(reason)s.'
exception InstanceRebootFailure(message=None, **kwargs)

Bases: nova.exception.Invalid

InstanceRebootFailure.msg_fmt = u'Failed to reboot instance: %(reason)s'
exception InstanceRecreateNotSupported(message=None, **kwargs)

Bases: nova.exception.Invalid

InstanceRecreateNotSupported.msg_fmt = u'Instance recreate is not implemented by this virt driver.'
exception InstanceResumeFailure(message=None, **kwargs)

Bases: nova.exception.Invalid

InstanceResumeFailure.msg_fmt = u'Failed to resume instance: %(reason)s.'
exception InstanceSuspendFailure(message=None, **kwargs)

Bases: nova.exception.Invalid

InstanceSuspendFailure.msg_fmt = u'Failed to suspend instance: %(reason)s'
exception InstanceTerminationFailure(message=None, **kwargs)

Bases: nova.exception.Invalid

InstanceTerminationFailure.msg_fmt = u'Failed to terminate instance: %(reason)s'
exception InstanceTypeCreateFailed(message=None, **kwargs)

Bases: nova.exception.NovaException

InstanceTypeCreateFailed.msg_fmt = u'Unable to create instance type'
exception InstanceTypeDiskTooSmall(message=None, **kwargs)

Bases: nova.exception.NovaException

InstanceTypeDiskTooSmall.msg_fmt = u"Instance type's disk is too small for requested image."
exception InstanceTypeExists(message=None, **kwargs)

Bases: nova.exception.NovaException

InstanceTypeExists.msg_fmt = u'Instance Type with name %(name)s already exists.'
exception InstanceTypeExtraSpecsNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

InstanceTypeExtraSpecsNotFound.msg_fmt = u'Instance Type %(instance_type_id)s has no extra specs with key %(extra_specs_key)s.'
exception InstanceTypeIdExists(message=None, **kwargs)

Bases: nova.exception.NovaException

InstanceTypeIdExists.msg_fmt = u'Instance Type with ID %(flavor_id)s already exists.'
exception InstanceTypeMemoryTooSmall(message=None, **kwargs)

Bases: nova.exception.NovaException

InstanceTypeMemoryTooSmall.msg_fmt = u"Instance type's memory is too small for requested image."
exception InstanceTypeNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

InstanceTypeNotFound.msg_fmt = u'Instance type %(instance_type_id)s could not be found.'
exception InstanceTypeNotFoundByName(message=None, **kwargs)

Bases: nova.exception.InstanceTypeNotFound

InstanceTypeNotFoundByName.msg_fmt = u'Instance type with name %(instance_type_name)s could not be found.'
exception InstanceUnacceptable(message=None, **kwargs)

Bases: nova.exception.Invalid

InstanceUnacceptable.msg_fmt = u'Instance %(instance_id)s is unacceptable: %(reason)s'
exception InstanceUnknownCell(message=None, **kwargs)

Bases: nova.exception.NotFound

InstanceUnknownCell.msg_fmt = u'Cell is not known for instance %(instance_uuid)s'
exception InstanceUserDataMalformed(message=None, **kwargs)

Bases: nova.exception.NovaException

InstanceUserDataMalformed.msg_fmt = u'User data needs to be valid base 64.'
exception InstanceUserDataTooLarge(message=None, **kwargs)

Bases: nova.exception.NovaException

InstanceUserDataTooLarge.msg_fmt = u'User data too large. User data must be no larger than %(maxsize)s bytes once base64 encoded. Your data is %(length)d bytes'
exception InsufficientFreeMemory(message=None, **kwargs)

Bases: nova.exception.NovaException

InsufficientFreeMemory.msg_fmt = u'Insufficient free memory on compute node to start %(uuid)s.'
exception InterfaceAttachFailed(message=None, **kwargs)

Bases: nova.exception.Invalid

InterfaceAttachFailed.msg_fmt = u'Failed to attach network adapter device to %(instance)s'
exception InterfaceDetachFailed(message=None, **kwargs)

Bases: nova.exception.Invalid

InterfaceDetachFailed.msg_fmt = u'Failed to detach network adapter device from %(instance)s'
exception InternalError(message=None, **kwargs)

Bases: nova.exception.NovaException

InternalError.ec2_code = 'InternalError'
InternalError.msg_fmt = '%(err)s'
exception Invalid(message=None, **kwargs)

Bases: nova.exception.NovaException

Invalid.code = 400
Invalid.msg_fmt = u'Unacceptable parameters.'
exception InvalidAggregateAction(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidAggregateAction.msg_fmt = u"Cannot perform action '%(action)s' on aggregate %(aggregate_id)s. Reason: %(reason)s."
exception InvalidAttribute(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidAttribute.msg_fmt = u'Attribute not supported: %(attr)s'
exception InvalidBDM(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidBDM.msg_fmt = u'Block Device Mapping is Invalid.'
exception InvalidBDMBootSequence(message=None, **kwargs)

Bases: nova.exception.InvalidBDM

InvalidBDMBootSequence.msg_fmt = u'Block Device Mapping is Invalid: Boot sequence for the instance and image/block device mapping combination is not valid.'
exception InvalidBDMEphemeralSize(message=None, **kwargs)

Bases: nova.exception.InvalidBDM

InvalidBDMEphemeralSize.msg_fmt = u'Ephemeral disks requested are larger than the instance type allows.'
exception InvalidBDMForLegacy(message=None, **kwargs)

Bases: nova.exception.InvalidBDM

InvalidBDMForLegacy.msg_fmt = u'Block Device Mapping cannot be converted to legacy format. '
exception InvalidBDMFormat(message=None, **kwargs)

Bases: nova.exception.InvalidBDM

InvalidBDMFormat.msg_fmt = u'Block Device Mapping is Invalid: %(details)s'
exception InvalidBDMImage(message=None, **kwargs)

Bases: nova.exception.InvalidBDM

InvalidBDMImage.msg_fmt = u'Block Device Mapping is Invalid: failed to get image %(id)s.'
exception InvalidBDMLocalsLimit(message=None, **kwargs)

Bases: nova.exception.InvalidBDM

InvalidBDMLocalsLimit.msg_fmt = u'Block Device Mapping is Invalid: You specified more local devices than the limit allows'
exception InvalidBDMSnapshot(message=None, **kwargs)

Bases: nova.exception.InvalidBDM

InvalidBDMSnapshot.msg_fmt = u'Block Device Mapping is Invalid: failed to get snapshot %(id)s.'
exception InvalidBDMSwapSize(message=None, **kwargs)

Bases: nova.exception.InvalidBDM

InvalidBDMSwapSize.msg_fmt = u'Swap drive requested is larger than instance type allows.'
exception InvalidBDMVolume(message=None, **kwargs)

Bases: nova.exception.InvalidBDM

InvalidBDMVolume.msg_fmt = u'Block Device Mapping is Invalid: failed to get volume %(id)s.'
exception InvalidCPUInfo(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidCPUInfo.msg_fmt = u'Unacceptable CPU info: %(reason)s'
exception InvalidCidr(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidCidr.msg_fmt = u'Invalid cidr %(cidr)s.'
exception InvalidContentType(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidContentType.msg_fmt = u'Invalid content type %(content_type)s.'
exception InvalidDevicePath(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidDevicePath.msg_fmt = u'The supplied device path (%(path)s) is invalid.'
exception InvalidDiskFormat(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidDiskFormat.msg_fmt = u'Disk format %(disk_format)s is not acceptable'
exception InvalidEc2Id(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidEc2Id.msg_fmt = u'Ec2 id %(ec2_id)s is unacceptable.'
exception InvalidGroup(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidGroup.msg_fmt = u'Group not valid. Reason: %(reason)s'
exception InvalidHypervisorType(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidHypervisorType.msg_fmt = u'The supplied hypervisor type of is invalid.'
exception InvalidID(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidID.msg_fmt = u'Invalid ID received %(id)s.'
exception InvalidImageRef(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidImageRef.msg_fmt = u'Invalid image href %(image_href)s.'
exception InvalidInput(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidInput.msg_fmt = u'Invalid input received: %(reason)s'
exception InvalidInstanceIDMalformed(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidInstanceIDMalformed.ec2_code = 'InvalidInstanceID.Malformed'
InvalidInstanceIDMalformed.msg_fmt = u'Invalid id: %(val)s (expecting "i-...").'
exception InvalidIpAddressError(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidIpAddressError.msg_fmt = u'%(address)s is not a valid IP v4/6 address.'
exception InvalidIpProtocol(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidIpProtocol.msg_fmt = u'Invalid IP protocol %(protocol)s.'
exception InvalidKeypair(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidKeypair.ec2_code = 'InvalidKeyPair.Format'
InvalidKeypair.msg_fmt = u'Keypair data is invalid: %(reason)s'
exception InvalidLocalStorage(message=None, **kwargs)

Bases: nova.exception.NovaException

InvalidLocalStorage.msg_fmt = u'%(path)s is not on local storage: %(reason)s'
exception InvalidMetadata(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidMetadata.msg_fmt = u'Invalid metadata: %(reason)s'
exception InvalidMetadataSize(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidMetadataSize.msg_fmt = u'Invalid metadata size: %(reason)s'
exception InvalidParameterValue(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidParameterValue.ec2_code = 'InvalidParameterValue'
InvalidParameterValue.msg_fmt = u'%(err)s'
exception InvalidPortRange(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidPortRange.ec2_code = 'InvalidParameterValue'
InvalidPortRange.msg_fmt = u'Invalid port range %(from_port)s:%(to_port)s. %(msg)s'
exception InvalidQuotaValue(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidQuotaValue.msg_fmt = u'Change would make usage less than 0 for the following resources: %(unders)s'
exception InvalidRequest(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidRequest.msg_fmt = u'The request is invalid.'
exception InvalidReservationExpiration(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidReservationExpiration.msg_fmt = u'Invalid reservation expiration %(expire)s.'
exception InvalidSharedStorage(message=None, **kwargs)

Bases: nova.exception.NovaException

InvalidSharedStorage.msg_fmt = u'%(path)s is not on shared storage: %(reason)s'
exception InvalidSortKey(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidSortKey.msg_fmt = u'Sort key supplied was not valid.'
exception InvalidUUID(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidUUID.msg_fmt = u'Expected a uuid but received %(uuid)s.'
exception InvalidUnicodeParameter(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidUnicodeParameter.msg_fmt = u'Invalid Parameter: Unicode is not supported by the current database.'
exception InvalidVLANPortGroup(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidVLANPortGroup.msg_fmt = u'vSwitch which contains the port group %(bridge)s is not associated with the desired physical adapter. Expected vSwitch is %(expected)s, but the one associated is %(actual)s.'
exception InvalidVLANTag(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidVLANTag.msg_fmt = u'VLAN tag is not appropriate for the port group %(bridge)s. Expected VLAN tag is %(tag)s, but the one associated with the port group is %(pgroup)s.'
exception InvalidVolume(message=None, **kwargs)

Bases: nova.exception.Invalid

InvalidVolume.ec2_code = 'UnsupportedOperation'
InvalidVolume.msg_fmt = u'Invalid volume: %(reason)s'
exception KeyManagerError(message=None, **kwargs)

Bases: nova.exception.NovaException

KeyManagerError.msg_fmt = u'key manager error: %(reason)s'
exception KeyPairExists(message=None, **kwargs)

Bases: nova.exception.NovaException

KeyPairExists.ec2_code = 'InvalidKeyPair.Duplicate'
KeyPairExists.msg_fmt = u"Key pair '%(key_name)s' already exists."
exception KeypairLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

KeypairLimitExceeded.msg_fmt = u'Maximum number of key pairs exceeded'
exception KeypairNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

KeypairNotFound.ec2_code = 'InvalidKeyPair.NotFound'
KeypairNotFound.msg_fmt = u'Keypair %(name)s not found for user %(user_id)s'
exception MalformedRequestBody(message=None, **kwargs)

Bases: nova.exception.NovaException

MalformedRequestBody.msg_fmt = u'Malformed message body: %(reason)s'
exception MarkerNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

MarkerNotFound.msg_fmt = u'Marker %(marker)s could not be found.'
exception MetadataLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

MetadataLimitExceeded.msg_fmt = u'Maximum number of metadata items exceeds %(allowed)d'
exception MigrationError(message=None, **kwargs)

Bases: nova.exception.NovaException

MigrationError.msg_fmt = u'Migration error: %(reason)s'
exception MigrationNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

MigrationNotFound.msg_fmt = u'Migration %(migration_id)s could not be found.'
exception MigrationNotFoundByStatus(message=None, **kwargs)

Bases: nova.exception.MigrationNotFound

MigrationNotFoundByStatus.msg_fmt = u'Migration not found for instance %(instance_id)s with status %(status)s.'
exception MigrationPreCheckError(message=None, **kwargs)

Bases: nova.exception.MigrationError

MigrationPreCheckError.msg_fmt = u'Migration pre-check error: %(reason)s'
exception MissingParameter(message=None, **kwargs)

Bases: nova.exception.NovaException

MissingParameter.code = 400
MissingParameter.ec2_code = 'MissingParameter'
MissingParameter.msg_fmt = u'Not enough parameters: %(reason)s'
exception MultiplePortsNotApplicable(message=None, **kwargs)

Bases: nova.exception.Invalid

MultiplePortsNotApplicable.msg_fmt = u'Failed to launch instances: %(reason)s'
exception NetworkAdapterNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

NetworkAdapterNotFound.msg_fmt = u'Network adapter %(adapter)s could not be found.'
exception NetworkAmbiguous(message=None, **kwargs)

Bases: nova.exception.Invalid

NetworkAmbiguous.msg_fmt = u'More than one possible network found. Specify network ID(s) to select which one(s) to connect to,'
exception NetworkDuplicated(message=None, **kwargs)

Bases: nova.exception.Invalid

NetworkDuplicated.msg_fmt = u'Network %(network_id)s is duplicated.'
exception NetworkInUse(message=None, **kwargs)

Bases: nova.exception.NovaException

NetworkInUse.msg_fmt = u'Network %(network_id)s is still in use.'
exception NetworkNotCreated(message=None, **kwargs)

Bases: nova.exception.NovaException

NetworkNotCreated.msg_fmt = u'%(req)s is required to create a network.'
exception NetworkNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

NetworkNotFound.msg_fmt = u'Network %(network_id)s could not be found.'
exception NetworkNotFoundForBridge(message=None, **kwargs)

Bases: nova.exception.NetworkNotFound

NetworkNotFoundForBridge.msg_fmt = u'Network could not be found for bridge %(bridge)s'
exception NetworkNotFoundForCidr(message=None, **kwargs)

Bases: nova.exception.NetworkNotFound

NetworkNotFoundForCidr.msg_fmt = u'Network could not be found with cidr %(cidr)s.'
exception NetworkNotFoundForInstance(message=None, **kwargs)

Bases: nova.exception.NetworkNotFound

NetworkNotFoundForInstance.msg_fmt = u'Network could not be found for instance %(instance_id)s.'
exception NetworkNotFoundForProject(message=None, **kwargs)

Bases: nova.exception.NotFound

NetworkNotFoundForProject.msg_fmt = u'Either Network uuid %(network_uuid)s is not present or is not assigned to the project %(project_id)s.'
exception NetworkNotFoundForUUID(message=None, **kwargs)

Bases: nova.exception.NetworkNotFound

NetworkNotFoundForUUID.msg_fmt = u'Network could not be found for uuid %(uuid)s'
exception NoCellsAvailable(message=None, **kwargs)

Bases: nova.exception.NovaException

NoCellsAvailable.msg_fmt = u'No cells available matching scheduling criteria.'
exception NoFilesFound(message=None, **kwargs)

Bases: nova.exception.NotFound

NoFilesFound.msg_fmt = u'Zero files could be found.'
exception NoFixedIpsDefined(message=None, **kwargs)

Bases: nova.exception.NotFound

NoFixedIpsDefined.msg_fmt = u'Zero fixed ips could be found.'
exception NoFloatingIpInterface(message=None, **kwargs)

Bases: nova.exception.NotFound

NoFloatingIpInterface.ec2_code = 'UnsupportedOpperation'
NoFloatingIpInterface.msg_fmt = u'Interface %(interface)s not found.'
exception NoFloatingIpsDefined(message=None, **kwargs)

Bases: nova.exception.NotFound

NoFloatingIpsDefined.msg_fmt = u'Zero floating ips exist.'
exception NoMoreFixedIps(message=None, **kwargs)

Bases: nova.exception.NovaException

NoMoreFixedIps.ec2_code = 'UnsupportedOperation'
NoMoreFixedIps.msg_fmt = u'Zero fixed ips available.'
exception NoMoreFloatingIps(message=None, **kwargs)

Bases: nova.exception.FloatingIpNotFound

NoMoreFloatingIps.msg_fmt = u'Zero floating ips available.'
NoMoreFloatingIps.safe = True
exception NoNetworksFound(message=None, **kwargs)

Bases: nova.exception.NotFound

NoNetworksFound.msg_fmt = u'No networks defined.'
exception NoUniqueMatch(message=None, **kwargs)

Bases: nova.exception.NovaException

NoUniqueMatch.code = 409
NoUniqueMatch.msg_fmt = u'No Unique Match Found.'
exception NoValidHost(message=None, **kwargs)

Bases: nova.exception.NovaException

NoValidHost.msg_fmt = u'No valid host was found. %(reason)s'
exception NodeNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

NodeNotFound.msg_fmt = u'Node %(node_id)s could not be found.'
exception NodeNotFoundByUUID(message=None, **kwargs)

Bases: nova.exception.NotFound

NodeNotFoundByUUID.msg_fmt = u'Node with UUID %(node_uuid)s could not be found.'
exception NotAllowed(message=None, **kwargs)

Bases: nova.exception.NovaException

NotAllowed.msg_fmt = u'Action not allowed.'
exception NotAuthorized(message=None, **kwargs)

Bases: nova.exception.NovaException

NotAuthorized.code = 403
NotAuthorized.ec2_code = 'AuthFailure'
NotAuthorized.msg_fmt = u'Not authorized.'
exception NotFound(message=None, **kwargs)

Bases: nova.exception.NovaException

NotFound.code = 404
NotFound.msg_fmt = u'Resource could not be found.'
exception NovaException(message=None, **kwargs)

Bases: exceptions.Exception

Base Nova Exception

To correctly use this class, inherit from it and define a ‘msg_fmt’ property. That msg_fmt will get printf’d with the keyword arguments provided to the constructor.

NovaException.code = 500
NovaException.format_message()
NovaException.headers = {}
NovaException.msg_fmt = u'An unknown exception occurred.'
NovaException.safe = False
exception ObjectActionError(message=None, **kwargs)

Bases: nova.exception.NovaException

ObjectActionError.msg_fmt = u'Object action %(action)s failed because: %(reason)s'
exception OnsetFileContentLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

OnsetFileContentLimitExceeded.msg_fmt = u'Personality file content too long'
exception OnsetFileLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

OnsetFileLimitExceeded.msg_fmt = u'Personality file limit exceeded'
exception OnsetFilePathLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

OnsetFilePathLimitExceeded.msg_fmt = u'Personality file path too long'
exception OrphanedObjectError(message=None, **kwargs)

Bases: nova.exception.NovaException

OrphanedObjectError.msg_fmt = u'Cannot call %(method)s on orphaned %(objtype)s object'
exception OverQuota(message=None, **kwargs)

Bases: nova.exception.NovaException

OverQuota.msg_fmt = u'Quota exceeded for resources: %(overs)s'
exception PasteAppNotFound(message=None, **kwargs)

Bases: nova.exception.NovaException

PasteAppNotFound.msg_fmt = u"Could not load paste app '%(name)s' from %(path)s"
exception PciConfigInvalidWhitelist(message=None, **kwargs)

Bases: nova.exception.Invalid

PciConfigInvalidWhitelist.msg_fmt = u'Invalid PCI devices Whitelist config %(reason)s'
exception PciDeviceDetachFailed(message=None, **kwargs)

Bases: nova.exception.NovaException

PciDeviceDetachFailed.msg_fmt = u'Failed to detach PCI device %(dev)s: %(reason)s'
exception PciDeviceInvalidOwner(message=None, **kwargs)

Bases: nova.exception.NovaException

PciDeviceInvalidOwner.msg_fmt = u'PCI Device %(compute_node_id)s:%(address)s is owned by %(owner)s instead of %(hopeowner)s'
exception PciDeviceInvalidStatus(message=None, **kwargs)

Bases: nova.exception.NovaException

PciDeviceInvalidStatus.msg_fmt = u'PCI Device %(compute_node_id)s:%(address)s is %(status)s instead of %(hopestatus)s'
exception PciDeviceNotFound(message=None, **kwargs)

Bases: nova.exception.NovaException

PciDeviceNotFound.msg_fmt = u'PCI Device %(node_id)s:%(address)s not found.'
exception PciDeviceNotFoundById(message=None, **kwargs)

Bases: nova.exception.NotFound

PciDeviceNotFoundById.msg_fmt = u'PCI device %(id)s not found'
exception PciDevicePoolEmpty(message=None, **kwargs)

Bases: nova.exception.NovaException

PciDevicePoolEmpty.msg_fmt = u'Attempt to consume PCI Device %(compute_node_id)s:%(address)s from empty pool'
exception PciDevicePrepareFailed(message=None, **kwargs)

Bases: nova.exception.NovaException

PciDevicePrepareFailed.msg_fmt = u'Failed to prepare PCI device %(id)s for instance %(instance_uuid)s: %(reason)s'
exception PciDeviceRequestFailed(message=None, **kwargs)

Bases: nova.exception.NovaException

PciDeviceRequestFailed.msg_fmt = u'PCI Device request (%requests)s failed'
exception PciDeviceUnsupportedHypervisor(message=None, **kwargs)

Bases: nova.exception.NovaException

PciDeviceUnsupportedHypervisor.msg_fmt = u'%(type)s hypervisor does not support PCI devices'
exception PciDeviceWrongAddressFormat(message=None, **kwargs)

Bases: nova.exception.NovaException

PciDeviceWrongAddressFormat.msg_fmt = u'The PCI address %(address)s has an incorrect format.'
exception PciInvalidAlias(message=None, **kwargs)

Bases: nova.exception.NovaException

PciInvalidAlias.msg_fmt = u'Invalid PCI alias definition: %(reason)s'
exception PciRequestAliasNotDefined(message=None, **kwargs)

Bases: nova.exception.NovaException

PciRequestAliasNotDefined.msg_fmt = u'PCI alias %(alias)s is not defined'
exception PciTrackerInvalidNodeId(message=None, **kwargs)

Bases: nova.exception.NovaException

PciTrackerInvalidNodeId.msg_fmt = u'Cannot change %(node_id)s to %(new_node_id)s'
exception PluginRetriesExceeded(message=None, **kwargs)

Bases: nova.exception.NovaException

PluginRetriesExceeded.msg_fmt = u'Number of retries to plugin (%(num_retries)d) exceeded.'
exception PolicyNotAuthorized(message=None, **kwargs)

Bases: nova.exception.NotAuthorized

PolicyNotAuthorized.msg_fmt = u"Policy doesn't allow %(action)s to be performed."
exception PortInUse(message=None, **kwargs)

Bases: nova.exception.Invalid

PortInUse.msg_fmt = u'Port %(port_id)s is still in use.'
exception PortLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

PortLimitExceeded.msg_fmt = u'Maximum number of ports exceeded'
exception PortNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

PortNotFound.msg_fmt = u'Port id %(port_id)s could not be found.'
exception PortNotFree(message=None, **kwargs)

Bases: nova.exception.Invalid

PortNotFree.msg_fmt = u'No free port available for instance %(instance)s.'
exception PortNotUsable(message=None, **kwargs)

Bases: nova.exception.Invalid

PortNotUsable.msg_fmt = u'Port %(port_id)s not usable for instance %(instance)s.'
exception ProjectNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

ProjectNotFound.msg_fmt = u'Project %(project_id)s could not be found.'
exception ProjectQuotaNotFound(message=None, **kwargs)

Bases: nova.exception.QuotaNotFound

ProjectQuotaNotFound.msg_fmt = u'Quota for project %(project_id)s could not be found.'
exception ProjectUserQuotaNotFound(message=None, **kwargs)

Bases: nova.exception.QuotaNotFound

ProjectUserQuotaNotFound.msg_fmt = u'Quota for user %(user_id)s in project %(project_id)s could not be found.'
exception QuotaClassNotFound(message=None, **kwargs)

Bases: nova.exception.QuotaNotFound

QuotaClassNotFound.msg_fmt = u'Quota class %(class_name)s could not be found.'
exception QuotaError(message=None, **kwargs)

Bases: nova.exception.NovaException

QuotaError.code = 413
QuotaError.ec2_code = 'ResourceLimitExceeded'
QuotaError.headers = {'Retry-After': 0}
QuotaError.msg_fmt = u'Quota exceeded: code=%(code)s'
QuotaError.safe = True
exception QuotaExists(message=None, **kwargs)

Bases: nova.exception.NovaException

QuotaExists.msg_fmt = u'Quota exists for project %(project_id)s, resource %(resource)s'
exception QuotaNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

QuotaNotFound.msg_fmt = u'Quota could not be found'
exception QuotaResourceUnknown(message=None, **kwargs)

Bases: nova.exception.QuotaNotFound

QuotaResourceUnknown.msg_fmt = u'Unknown quota resources %(unknown)s.'
exception QuotaUsageNotFound(message=None, **kwargs)

Bases: nova.exception.QuotaNotFound

QuotaUsageNotFound.msg_fmt = u'Quota usage for project %(project_id)s could not be found.'
exception RescheduledException(message=None, **kwargs)

Bases: nova.exception.NovaException

RescheduledException.msg_fmt = u'Build of instance %(instance_uuid)s was re-scheduled: %(reason)s'
exception ReservationNotFound(message=None, **kwargs)

Bases: nova.exception.QuotaNotFound

ReservationNotFound.msg_fmt = u'Quota reservation %(uuid)s could not be found.'
exception ResizeError(message=None, **kwargs)

Bases: nova.exception.NovaException

ResizeError.msg_fmt = u'Resize error: %(reason)s'
exception RotationRequiredForBackup(message=None, **kwargs)

Bases: nova.exception.NovaException

RotationRequiredForBackup.msg_fmt = u'Rotation param is required for backup image_type'
exception SchedulerHostFilterNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

SchedulerHostFilterNotFound.msg_fmt = u'Scheduler Host Filter %(filter_name)s could not be found.'
exception SecurityGroupCannotBeApplied(message=None, **kwargs)

Bases: nova.exception.Invalid

SecurityGroupCannotBeApplied.msg_fmt = u'Network requires port_security_enabled and subnet associated in order to apply security groups.'
exception SecurityGroupDefaultRuleNotFound(message=None, **kwargs)

Bases: nova.exception.Invalid

SecurityGroupDefaultRuleNotFound.msg_fmt = u'Security group default rule (%rule_id)s not found.'
exception SecurityGroupExists(message=None, **kwargs)

Bases: nova.exception.Invalid

SecurityGroupExists.ec2_code = 'InvalidGroup.Duplicate'
SecurityGroupExists.msg_fmt = u'Security group %(security_group_name)s already exists for project %(project_id)s.'
exception SecurityGroupExistsForInstance(message=None, **kwargs)

Bases: nova.exception.Invalid

SecurityGroupExistsForInstance.msg_fmt = u'Security group %(security_group_id)s is already associated with the instance %(instance_id)s'
exception SecurityGroupLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

SecurityGroupLimitExceeded.ec2_code = 'SecurityGroupLimitExceeded'
SecurityGroupLimitExceeded.msg_fmt = u'Maximum number of security groups or rules exceeded'
exception SecurityGroupNotExistsForInstance(message=None, **kwargs)

Bases: nova.exception.Invalid

SecurityGroupNotExistsForInstance.msg_fmt = u'Security group %(security_group_id)s is not associated with the instance %(instance_id)s'
exception SecurityGroupNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

SecurityGroupNotFound.msg_fmt = u'Security group %(security_group_id)s not found.'
exception SecurityGroupNotFoundForProject(message=None, **kwargs)

Bases: nova.exception.SecurityGroupNotFound

SecurityGroupNotFoundForProject.msg_fmt = u'Security group %(security_group_id)s not found for project %(project_id)s.'
exception SecurityGroupNotFoundForRule(message=None, **kwargs)

Bases: nova.exception.SecurityGroupNotFound

SecurityGroupNotFoundForRule.msg_fmt = u'Security group with rule %(rule_id)s not found.'
exception SecurityGroupRuleExists(message=None, **kwargs)

Bases: nova.exception.Invalid

SecurityGroupRuleExists.ec2_code = 'InvalidPermission.Duplicate'
SecurityGroupRuleExists.msg_fmt = u'Rule already exists in group: %(rule)s'
exception ServiceBinaryExists(message=None, **kwargs)

Bases: nova.exception.NovaException

ServiceBinaryExists.msg_fmt = u'Service with host %(host)s binary %(binary)s exists.'
exception ServiceGroupUnavailable(message=None, **kwargs)

Bases: nova.exception.NovaException

ServiceGroupUnavailable.msg_fmt = u'The service from servicegroup driver %(driver)s is temporarily unavailable.'
exception ServiceNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

ServiceNotFound.msg_fmt = u'Service %(service_id)s could not be found.'
exception ServiceTopicExists(message=None, **kwargs)

Bases: nova.exception.NovaException

ServiceTopicExists.msg_fmt = u'Service with host %(host)s topic %(topic)s exists.'
exception ServiceUnavailable(message=None, **kwargs)

Bases: nova.exception.Invalid

ServiceUnavailable.msg_fmt = u'Service is unavailable at this time.'
exception ShadowTableExists(message=None, **kwargs)

Bases: nova.exception.NovaException

ShadowTableExists.msg_fmt = u'Shadow table with name %(name)s already exists.'
exception SnapshotNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

SnapshotNotFound.ec2_code = 'InvalidSnapshotID.NotFound'
SnapshotNotFound.msg_fmt = u'Snapshot %(snapshot_id)s could not be found.'
exception StorageRepositoryNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

StorageRepositoryNotFound.msg_fmt = u'Cannot find SR to read/write VDI.'
exception SwitchNotFoundForNetworkAdapter(message=None, **kwargs)

Bases: nova.exception.NotFound

SwitchNotFoundForNetworkAdapter.msg_fmt = u'Virtual switch associated with the network adapter %(adapter)s not found.'
exception TaskAlreadyRunning(message=None, **kwargs)

Bases: nova.exception.NovaException

TaskAlreadyRunning.msg_fmt = u'Task %(task_name)s is already running on host %(host)s'
exception TaskNotRunning(message=None, **kwargs)

Bases: nova.exception.NovaException

TaskNotRunning.msg_fmt = u'Task %(task_name)s is not running on host %(host)s'
exception TooManyInstances(message=None, **kwargs)

Bases: nova.exception.QuotaError

TooManyInstances.msg_fmt = u'Quota exceeded for %(overs)s: Requested %(req)s, but already used %(used)d of %(allowed)d %(resource)s'
exception UnableToMigrateToSelf(message=None, **kwargs)

Bases: nova.exception.Invalid

UnableToMigrateToSelf.msg_fmt = u'Unable to migrate instance (%(instance_id)s) to current host (%(host)s).'
exception UnexpectedTaskStateError(message=None, **kwargs)

Bases: nova.exception.NovaException

UnexpectedTaskStateError.msg_fmt = u'unexpected task state: expecting %(expected)s but the actual state is %(actual)s'
exception UnexpectedVMStateError(message=None, **kwargs)

Bases: nova.exception.NovaException

UnexpectedVMStateError.msg_fmt = u'unexpected VM state: expecting %(expected)s but the actual state is %(actual)s'
exception UnsupportedHardware(message=None, **kwargs)

Bases: nova.exception.Invalid

UnsupportedHardware.msg_fmt = u"Requested hardware '%(model)s' is not supported by the '%(virt)s' virt driver"
exception UnsupportedObjectError(message=None, **kwargs)

Bases: nova.exception.NovaException

UnsupportedObjectError.msg_fmt = u'Unsupported object type %(objtype)s'
exception UnsupportedVirtType(message=None, **kwargs)

Bases: nova.exception.Invalid

UnsupportedVirtType.msg_fmt = u"Virtualization type '%(virt)s' is not supported by this compute driver"
exception VirtualInterfaceCreateException(message=None, **kwargs)

Bases: nova.exception.NovaException

VirtualInterfaceCreateException.msg_fmt = u'Virtual Interface creation failed'
exception VirtualInterfaceMacAddressException(message=None, **kwargs)

Bases: nova.exception.NovaException

VirtualInterfaceMacAddressException.msg_fmt = u'5 attempts to create virtual interfacewith unique mac address failed'
exception VolumeDriverNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

VolumeDriverNotFound.msg_fmt = u'Could not find a handler for %(driver_type)s volume.'
exception VolumeNotCreated(message=None, **kwargs)

Bases: nova.exception.NovaException

VolumeNotCreated.msg_fmt = u'Volume %(volume_id)s did not finish being created even after we waited %(seconds)s seconds or %(attempts)s attempts.'
exception VolumeNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

VolumeNotFound.ec2_code = 'InvalidVolumeID.NotFound'
VolumeNotFound.msg_fmt = u'Volume %(volume_id)s could not be found.'
exception VolumeUnattached(message=None, **kwargs)

Bases: nova.exception.Invalid

VolumeUnattached.ec2_code = 'IncorrectState'
VolumeUnattached.msg_fmt = u'Volume %(volume_id)s is not attached to anything'
wrap_exception(notifier=None, get_notifier=None)

This decorator wraps a method to catch any exceptions that may get thrown. It logs the exception as well as optionally sending it to the notification system.

The nova.flags Module

The nova.process Module

The nova.rpc Module

The nova.server Module

The nova.test Module

The nova.utils Module

Utilities and helper functions.

class ExceptionHelper(target)

Bases: object

Class to wrap another and translate the ClientExceptions raised by its function calls to the actual ones.

class LazyPluggable(pivot, config_group=None, **backends)

Bases: object

A pluggable backend loaded lazily based on some value.

class UndoManager

Bases: object

Provides a mechanism to facilitate rolling back a series of actions when an exception is raised.

UndoManager.rollback_and_reraise(msg=None, **kwargs)

Rollback a series of actions then re-raise the exception.

Note

(sirp) This should only be called within an exception handler.

UndoManager.undo_with(undo_func)
check_isinstance(obj, cls)

Checks that obj is of type cls, and lets PyLint infer types.

check_string_length(value, name, min_length=0, max_length=None)

Check the length of specified string :param value: the value of the string :param name: the name of the string :param min_length: the min_length of the string :param max_length: the max_length of the string

convert_to_list_dict(lst, label)

Convert a value or list into a list of dicts.

convert_version_to_int(version)
debug(arg)
dict_to_metadata(metadata)
diff_dict(orig, new)

Return a dict describing how to change orig to new. The keys correspond to values that have changed; the value will be a list of one or two elements. The first element of the list will be either ‘+’ or ‘-‘, indicating whether the key was updated or deleted; if the key was updated, the list will contain a second element, giving the updated value.

execute(*cmd, **kwargs)

Convenience wrapper around oslo’s execute() method.

flatten_dict(dict_, flattened=None)

Recursively flatten a nested dictionary.

generate_mac_address()

Generate an Ethernet MAC address.

generate_password(length=None, symbolgroups=('23456789', 'ABCDEFGHJKLMNPQRSTUVWXYZ', 'abcdefghijkmnopqrstuvwxyz'))

Generate a random password from the supplied symbol groups.

At least one symbol from each group will be included. Unpredictable results if length is less than the number of symbol groups.

Believed to be reasonably secure (with a reasonable password length!)

generate_uid(topic, size=8)
get_auto_disk_config_from_image_props(image_properties)
get_auto_disk_config_from_instance(instance=None, sys_meta=None)
get_boolean(value)
get_from_path(items, path)

Returns a list of items matching the specified path.

Takes an XPath-like expression e.g. prop1/prop2/prop3, and for each item in items, looks up items[prop1][prop2][prop3]. Like XPath, if any of the intermediate results are lists it will treat each list item individually. A ‘None’ in items or any child expressions will be ignored, this function will not throw because of None (anywhere) in items. The returned list will contain no None values.

get_image_from_system_metadata(system_meta)
get_ip_version(network)

Returns the IP version of a network (IPv4 or IPv6).

Raises AddrFormatError if invalid network.

get_my_ipv4_address()

Run ip route/addr commands to figure out the best ipv4

get_my_linklocal(interface)
get_root_helper()
get_shortened_ipv6(address)
get_shortened_ipv6_cidr(address)
get_system_metadata_from_image(image_meta, instance_type=None)
get_wrapped_function(function)

Get the method at the bottom of a stack of decorators.

hash_file(file_like_object)

Generate a hash for the contents of a file.

instance_meta(instance)
instance_sys_meta(instance)
is_auto_disk_config_disabled(auto_disk_config_raw)
is_int_like(val)

Check if a value looks like an int.

is_neutron()
is_none_string(val)

Check if a string represents a None value.

is_valid_cidr(address)

Check if address is valid

The provided address can be a IPv6 or a IPv4 CIDR address.

is_valid_ipv4(address)

Verify that address represents a valid IPv4 address.

is_valid_ipv6(address)
is_valid_ipv6_cidr(address)
last_bytes(file_like_object, num)

Return num bytes from the end of the file, and remaining byte count.

Parameters:
  • file_like_object – The file to read
  • num – The number of bytes to return

:returns (data, remaining)

last_completed_audit_period(unit=None, before=None)

This method gives you the most recently completed audit period.

arguments:
units: string, one of ‘hour’, ‘day’, ‘month’, ‘year’
Periods normally begin at the beginning (UTC) of the period unit (So a ‘day’ period begins at midnight UTC, a ‘month’ unit on the 1st, a ‘year’ on Jan, 1) unit string may be appended with an optional offset like so: 'day@18‘ This will begin the period at 18:00 UTC. 'month@15‘ starts a monthly period on the 15th, and year@3 begins a yearly one on March 1st.
before: Give the audit period most recently completed before
<timestamp>. Defaults to now.
returns: 2 tuple of datetimes (begin, end)
The begin timestamp of this audit period is the same as the end of the previous.
last_octet(address)
make_dev_path(dev, partition=None, base='/dev')

Return a path to a particular device.

>>> make_dev_path('xvdc')
/dev/xvdc
>>> make_dev_path('xvdc', 1)
/dev/xvdc1
map_dict_keys(dict_, key_map)

Return a dict in which the dictionaries keys are mapped to new keys.

metadata_to_dict(metadata)
mkfs(fs, path, label=None)

Format a file or block device

Parameters:
  • fs – Filesystem type (examples include ‘swap’, ‘ext3’, ‘ext4’ ‘btrfs’, etc.)
  • path – Path to file or block device to format
  • label – Volume label to use
monkey_patch()

If the Flags.monkey_patch set as True, this function patches a decorator for all functions in specified modules. You can set decorators for each modules using CONF.monkey_patch_modules. The format is “Module path:Decorator function”. Example:

‘nova.api.ec2.cloud:nova.notifications.notify_decorator’

Parameters of the decorator is as follows. (See nova.notifications.notify_decorator)

name - name of the function function - object of the function

novadir()
parse_server_string(server_str)

Parses the given server_string and returns a list of host and port. If it’s not a combination of host part and port, the port element is a null string. If the input is invalid expression, return a null list.

partition_dict(dict_, keys)

Return two dicts, one with keys the other with everything else.

read_cached_file(filename, cache_info, reload_func=None)

Read from a file if it has been modified.

Parameters:
  • cache_info – dictionary to hold opaque cache.
  • reload_func – optional function to be called with data when file is reloaded due to a modification.
Returns:

data from file

read_file_as_root(file_path)

Secure helper to read file as root.

reset_is_neutron()
sanitize_hostname(hostname)

Return a hostname which conforms to RFC-952 and RFC-1123 specs.

spawn_n(func, *args, **kwargs)

Passthrough method for eventlet.spawn_n.

This utility exists so that it can be stubbed for testing without interfering with the service spawns.

str_dict_replace(s, mapping)
subset_dict(dict_, keys)

Return a dict that only contains a subset of keys.

tempdir(*args, **kwds)
temporary_chown(*args, **kwds)

Temporarily chown a path.

Params owner_uid:
 UID of temporary owner (defaults to current user)
temporary_mutation(*args, **kwds)

Temporarily set the attr on a particular object to a given value then revert when finished.

One use of this is to temporarily set the read_deleted flag on a context object:

with temporary_mutation(context, read_deleted=”yes”):
do_something_that_needed_deleted_objects()
timefunc(func)

Decorator that logs how long a particular function took to execute.

total_seconds(td)

Local total_seconds implementation for compatibility with python 2.6.

trycmd(*args, **kwargs)

Convenience wrapper around oslo’s trycmd() method.

utf8(value)

Try to turn a string into utf-8 if possible.

Code is directly from the utf8 function in http://github.com/facebook/tornado/blob/master/tornado/escape.py

validate_integer(value, name, min_value=None, max_value=None)

Make sure that value is a valid integer, potentially within range.

vpn_ping(address, port, timeout=0.05, session_id=None)

Sends a vpn negotiation packet and returns the server session.

Returns False on a failure. Basic packet structure is below.

Client packet (14 bytes):

 0 1      8 9  13
+-+--------+-----+
|x| cli_id |?????|
+-+--------+-----+
x = packet identifier 0x38
cli_id = 64 bit identifier
? = unknown, probably flags/padding

Server packet (26 bytes):

 0 1      8 9  13 14    21 2225
+-+--------+-----+--------+----+
|x| srv_id |?????| cli_id |????|
+-+--------+-----+--------+----+
x = packet identifier 0x40
cli_id = 64 bit identifier
? = unknown, probably flags/padding
bit 9 was 1 and the rest were 0 in testing
walk_class_hierarchy(clazz, encountered=None)

Walk class hierarchy, yielding most derived classes first.

xhtml_escape(value)

Escapes a string so it is valid within XML or XHTML.

The nova.validate Module

The nova.wsgi Module

Utility methods for working with WSGI servers.

class Application

Bases: object

Base WSGI application wrapper. Subclasses need to implement __call__.

classmethod Application.factory(global_config, **local_config)

Used for paste app factories in paste.deploy config files.

Any local configuration (that is, values under the [app:APPNAME] section of the paste config) will be passed into the __init__ method as kwargs.

A hypothetical configuration would look like:

[app:wadl] latest_version = 1.3 paste.app_factory = nova.api.fancy_api:Wadl.factory

which would result in a call to the Wadl class as

import nova.api.fancy_api fancy_api.Wadl(latest_version=‘1.3’)

You could of course re-implement the factory method in subclasses, but using the kwarg passing it shouldn’t be necessary.

class Debug(application)

Bases: nova.wsgi.Middleware

Helper class for debugging a WSGI application.

Can be inserted into any WSGI application chain to get information about the request and response.

static Debug.print_generator(app_iter)

Iterator that prints the contents of a wrapper string.

class Loader(config_path=None)

Bases: object

Used to load WSGI applications from paste configurations.

Loader.load_app(name)

Return the paste URLMap wrapped WSGI application.

Parameters:name – Name of the application to load.
Returns:Paste URLMap object wrapping the requested application.
Raises :nova.exception.PasteAppNotFound
class Middleware(application)

Bases: nova.wsgi.Application

Base WSGI middleware.

These classes require an application to be initialized that will be called next. By default the middleware will simply call its wrapped app, or you can override __call__ to customize its behavior.

classmethod Middleware.factory(global_config, **local_config)

Used for paste app factories in paste.deploy config files.

Any local configuration (that is, values under the [filter:APPNAME] section of the paste config) will be passed into the __init__ method as kwargs.

A hypothetical configuration would look like:

[filter:analytics] redis_host = 127.0.0.1 paste.filter_factory = nova.api.analytics:Analytics.factory

which would result in a call to the Analytics class as

import nova.api.analytics analytics.Analytics(app_from_paste, redis_host=‘127.0.0.1’)

You could of course re-implement the factory method in subclasses, but using the kwarg passing it shouldn’t be necessary.

Middleware.process_request(req)

Called on each request.

If this returns None, the next application down the stack will be executed. If it returns a response then that response will be returned and execution will stop here.

Middleware.process_response(response)

Do whatever you’d like to the response.

class Request(environ, charset=None, unicode_errors=None, decode_param_names=None, **kw)

Bases: webob.request.Request

class Router(mapper)

Bases: object

WSGI middleware that maps incoming requests to WSGI apps.

class Server(name, app, host='0.0.0.0', port=0, pool_size=None, protocol=<class eventlet.wsgi.HttpProtocol at 0x9bfb98c>, backlog=128, use_ssl=False, max_url_len=None)

Bases: object

Server class to manage a WSGI server, serving a WSGI application.

Server.default_pool_size = 1000
Server.start()

Start serving a WSGI application.

Returns:None
Server.stop()

Stop this server.

This is not a very nice action, as currently the method by which a server is stopped is by killing its eventlet.

Returns:None
Server.wait()

Block, until the server has stopped.

Waits on the server’s eventlet to finish, then returns.

Returns:None

Tests

The declare_flags Module

The fake_flags Module

The flags_unittest Module

The process_unittest Module

The real_flags Module

The rpc_unittest Module

The runtime_flags Module

The validator_unittest Module