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.to_dict()
RequestContext.update_store()
generate_request_id()
get_admin_context(read_deleted='no')

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

exception AggregateError(message=None, **kwargs)

Bases: nova.exception.NovaException

exception AggregateHostExists(message=None, **kwargs)

Bases: nova.exception.Duplicate

exception AggregateHostNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception AggregateMetadataNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception AggregateNameExists(message=None, **kwargs)

Bases: nova.exception.Duplicate

exception AggregateNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception CannotDisassociateAutoAssignedFloatingIP(message=None, **kwargs)

Bases: nova.exception.NovaException

exception CannotResizeToSameFlavor(message=None, **kwargs)

Bases: nova.exception.NovaException

exception CertificateNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception ClassNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception ComputeHostNotFound(message=None, **kwargs)

Bases: nova.exception.HostNotFound

exception ComputeResourcesUnavailable(message=None, **kwargs)

Bases: nova.exception.ServiceUnavailable

exception ComputeServiceUnavailable(message=None, **kwargs)

Bases: nova.exception.ServiceUnavailable

exception ConfigDriveMountFailed(message=None, **kwargs)

Bases: nova.exception.NovaException

exception ConfigDriveUnknownFormat(message=None, **kwargs)

Bases: nova.exception.NovaException

exception ConfigNotFound(message=None, **kwargs)

Bases: nova.exception.NovaException

exception ConsoleNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception ConsoleNotFoundForInstance(message=None, **kwargs)

Bases: nova.exception.ConsoleNotFound

exception ConsoleNotFoundInPoolForInstance(message=None, **kwargs)

Bases: nova.exception.ConsoleNotFound

exception ConsolePoolNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception ConsolePoolNotFoundForHostType(message=None, **kwargs)

Bases: nova.exception.NotFound

exception ConsoleTypeInvalid(message=None, **kwargs)

Bases: nova.exception.Invalid

exception ConstraintNotMet(message=None, **kwargs)

Bases: nova.exception.NovaException

exception ConvertedException(code=0, title='', explanation='')

Bases: webob.exc.WSGIHTTPException

exception CouldNotFetchImage(message=None, **kwargs)

Bases: nova.exception.NovaException

exception CouldNotFetchMetrics(message=None, **kwargs)

Bases: nova.exception.NovaException

exception CryptoCAFileNotFound(message=None, **kwargs)

Bases: nova.exception.FileNotFound

exception CryptoCRLFileNotFound(message=None, **kwargs)

Bases: nova.exception.FileNotFound

exception DBError(inner_exception=None)

Bases: nova.exception.NovaException

Wraps an implementation specific exception.

exception DatastoreNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception DecryptionFailure(message=None, **kwargs)

Bases: nova.exception.NovaException

exception DeprecatedConfig(message=None, **kwargs)

Bases: nova.exception.NovaException

exception DestinationDiskExists(message=None, **kwargs)

Bases: nova.exception.Invalid

exception DestinationHypervisorTooOld(message=None, **kwargs)

Bases: nova.exception.Invalid

exception DeviceIsBusy(message=None, **kwargs)

Bases: nova.exception.Invalid

exception DevicePathInUse(message=None, **kwargs)

Bases: nova.exception.Invalid

exception DiskNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception Duplicate(message=None, **kwargs)

Bases: nova.exception.NovaException

exception DuplicateSfVolumeNames(message=None, **kwargs)

Bases: nova.exception.Duplicate

exception DuplicateVlan(message=None, **kwargs)

Bases: nova.exception.Duplicate

exception EC2APIError(message=None, code=None)

Bases: nova.exception.NovaException

exception FileNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception FixedIpAlreadyInUse(message=None, **kwargs)

Bases: nova.exception.NovaException

exception FixedIpAssociatedWithMultipleInstances(message=None, **kwargs)

Bases: nova.exception.NovaException

exception FixedIpInvalid(message=None, **kwargs)

Bases: nova.exception.Invalid

exception FixedIpLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

exception FixedIpNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception FixedIpNotFoundForAddress(message=None, **kwargs)

Bases: nova.exception.FixedIpNotFound

exception FixedIpNotFoundForInstance(message=None, **kwargs)

Bases: nova.exception.FixedIpNotFound

exception FixedIpNotFoundForNetwork(message=None, **kwargs)

Bases: nova.exception.FixedIpNotFound

exception FixedIpNotFoundForNetworkHost(message=None, **kwargs)

Bases: nova.exception.FixedIpNotFound

exception FixedIpNotFoundForSpecificInstance(message=None, **kwargs)

Bases: nova.exception.FixedIpNotFound

exception FlavorAccessExists(message=None, **kwargs)

Bases: nova.exception.Duplicate

exception FlavorAccessNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception FlavorNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception FloatingIpAssociated(message=None, **kwargs)

Bases: nova.exception.NovaException

exception FloatingIpDNSExists(message=None, **kwargs)

Bases: nova.exception.Invalid

exception FloatingIpExists(message=None, **kwargs)

Bases: nova.exception.Duplicate

exception FloatingIpLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

exception FloatingIpMultipleFoundForAddress(message=None, **kwargs)

Bases: nova.exception.NovaException

exception FloatingIpNotAssociated(message=None, **kwargs)

Bases: nova.exception.NovaException

exception FloatingIpNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception FloatingIpNotFoundForAddress(message=None, **kwargs)

Bases: nova.exception.FloatingIpNotFound

exception FloatingIpNotFoundForHost(message=None, **kwargs)

Bases: nova.exception.FloatingIpNotFound

exception FloatingIpPoolNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception GlanceConnectionFailed(message=None, **kwargs)

Bases: nova.exception.NovaException

exception HostBinaryNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception HostNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception ISCSITargetCreateFailed(message=None, **kwargs)

Bases: nova.exception.NovaException

exception ISCSITargetNotFoundForVolume(message=None, **kwargs)

Bases: nova.exception.NotFound

exception ISCSITargetRemoveFailed(message=None, **kwargs)

Bases: nova.exception.NovaException

exception ImageNotAuthorized(message=None, **kwargs)

Bases: nova.exception.NovaException

exception ImageNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception ImageNotFoundEC2(message=None, **kwargs)

Bases: nova.exception.ImageNotFound

exception ImageRotationNotAllowed(message=None, **kwargs)

Bases: nova.exception.NovaException

exception ImageTooLarge(message=None, **kwargs)

Bases: nova.exception.NovaException

exception ImageUnacceptable(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InstanceExists(message=None, **kwargs)

Bases: nova.exception.Duplicate

exception InstanceInvalidState(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InstanceIsLocked(message=None, **kwargs)

Bases: nova.exception.InstanceInvalidState

exception InstanceMetadataNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception InstanceNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception InstanceNotInRescueMode(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InstanceNotReady(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InstanceNotRunning(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InstancePasswordSetFailed(message=None, **kwargs)

Bases: nova.exception.NovaException

exception InstanceRebootFailure(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InstanceResumeFailure(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InstanceSuspendFailure(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InstanceSystemMetadataNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception InstanceTerminationFailure(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InstanceTypeCreateFailed(message=None, **kwargs)

Bases: nova.exception.NovaException

exception InstanceTypeDiskTooSmall(message=None, **kwargs)

Bases: nova.exception.NovaException

exception InstanceTypeExists(message=None, **kwargs)

Bases: nova.exception.Duplicate

exception InstanceTypeExtraSpecsNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception InstanceTypeMemoryTooSmall(message=None, **kwargs)

Bases: nova.exception.NovaException

exception InstanceTypeNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception InstanceTypeNotFoundByName(message=None, **kwargs)

Bases: nova.exception.InstanceTypeNotFound

exception InstanceUnacceptable(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InstanceUserDataMalformed(message=None, **kwargs)

Bases: nova.exception.NovaException

exception InstanceUserDataTooLarge(message=None, **kwargs)

Bases: nova.exception.NovaException

exception InsufficientFreeMemory(message=None, **kwargs)

Bases: nova.exception.NovaException

exception Invalid(message=None, **kwargs)

Bases: nova.exception.NovaException

exception InvalidAggregateAction(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidBDM(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidBDMSnapshot(message=None, **kwargs)

Bases: nova.exception.InvalidBDM

exception InvalidBDMVolume(message=None, **kwargs)

Bases: nova.exception.InvalidBDM

exception InvalidCPUInfo(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidCidr(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidContentType(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidDevicePath(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidDiskFormat(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidEc2Id(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidGroup(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidHypervisorType(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidImageRef(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidInput(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidInstanceIDMalformed(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidIpAddressError(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidIpProtocol(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidKeypair(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidLocalStorage(message=None, **kwargs)

Bases: nova.exception.NovaException

exception InvalidMetadata(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidMetadataSize(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidParameterValue(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidPortRange(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidQuotaValue(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidRequest(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidReservationExpiration(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidSharedStorage(message=None, **kwargs)

Bases: nova.exception.NovaException

exception InvalidSnapshot(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidSortKey(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidUUID(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidUnicodeParameter(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidVLANPortGroup(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidVLANTag(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidVolume(message=None, **kwargs)

Bases: nova.exception.Invalid

exception InvalidVolumeType(message=None, **kwargs)

Bases: nova.exception.Invalid

exception KeyPairExists(message=None, **kwargs)

Bases: nova.exception.Duplicate

exception KeypairLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

exception KeypairNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception MalformedRequestBody(message=None, **kwargs)

Bases: nova.exception.NovaException

exception MarkerNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception MetadataLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

exception MigrationError(message=None, **kwargs)

Bases: nova.exception.NovaException

exception MigrationNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception MigrationNotFoundByStatus(message=None, **kwargs)

Bases: nova.exception.MigrationNotFound

exception NetworkAdapterNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception NetworkHostNotSet(message=None, **kwargs)

Bases: nova.exception.NovaException

exception NetworkInUse(message=None, **kwargs)

Bases: nova.exception.NovaException

exception NetworkNotCreated(message=None, **kwargs)

Bases: nova.exception.NovaException

exception NetworkNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception NetworkNotFoundForBridge(message=None, **kwargs)

Bases: nova.exception.NetworkNotFound

exception NetworkNotFoundForCidr(message=None, **kwargs)

Bases: nova.exception.NetworkNotFound

exception NetworkNotFoundForInstance(message=None, **kwargs)

Bases: nova.exception.NetworkNotFound

exception NetworkNotFoundForProject(message=None, **kwargs)

Bases: nova.exception.NotFound

exception NetworkNotFoundForUUID(message=None, **kwargs)

Bases: nova.exception.NetworkNotFound

exception NfsException(message=None, **kwargs)

Bases: nova.exception.NovaException

exception NfsNoSharesMounted(message=None, **kwargs)

Bases: nova.exception.NotFound

exception NfsNoSuitableShareFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception NoFilesFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception NoFixedIpsDefined(message=None, **kwargs)

Bases: nova.exception.NotFound

exception NoFloatingIpInterface(message=None, **kwargs)

Bases: nova.exception.NotFound

exception NoFloatingIpsDefined(message=None, **kwargs)

Bases: nova.exception.NotFound

exception NoMoreFixedIps(message=None, **kwargs)

Bases: nova.exception.NovaException

exception NoMoreFloatingIps(message=None, **kwargs)

Bases: nova.exception.FloatingIpNotFound

exception NoNetworksFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception NoValidHost(message=None, **kwargs)

Bases: nova.exception.NovaException

exception NotAllowed(message=None, **kwargs)

Bases: nova.exception.NovaException

exception NotAuthorized(message=None, **kwargs)

Bases: nova.exception.NovaException

exception NotFound(message=None, **kwargs)

Bases: nova.exception.NovaException

exception NovaException(message=None, **kwargs)

Bases: exceptions.Exception

Base Nova Exception

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

exception OnsetFileContentLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

exception OnsetFileLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

exception OnsetFilePathLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

exception OverQuota(message=None, **kwargs)

Bases: nova.exception.NovaException

exception PasteAppNotFound(message=None, **kwargs)

Bases: nova.exception.NovaException

exception PersistentVolumeFileNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception PolicyNotAuthorized(message=None, **kwargs)

Bases: nova.exception.NotAuthorized

exception PortInUse(message=None, **kwargs)

Bases: nova.exception.NovaException

exception PortNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception ProcessExecutionError(stdout=None, stderr=None, exit_code=None, cmd=None, description=None)

Bases: exceptions.IOError

exception ProjectNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception ProjectQuotaNotFound(message=None, **kwargs)

Bases: nova.exception.QuotaNotFound

exception QuotaClassNotFound(message=None, **kwargs)

Bases: nova.exception.QuotaNotFound

exception QuotaError(message=None, **kwargs)

Bases: nova.exception.NovaException

exception QuotaNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception QuotaResourceUnknown(message=None, **kwargs)

Bases: nova.exception.QuotaNotFound

exception QuotaUsageNotFound(message=None, **kwargs)

Bases: nova.exception.QuotaNotFound

exception ReservationNotFound(message=None, **kwargs)

Bases: nova.exception.QuotaNotFound

exception RotationRequiredForBackup(message=None, **kwargs)

Bases: nova.exception.NovaException

exception SchedulerCostFunctionNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception SchedulerHostFilterNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception SchedulerWeightFlagNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception SecurityGroupExistsForInstance(message=None, **kwargs)

Bases: nova.exception.Invalid

exception SecurityGroupLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

exception SecurityGroupNotExistsForInstance(message=None, **kwargs)

Bases: nova.exception.Invalid

exception SecurityGroupNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception SecurityGroupNotFoundForProject(message=None, **kwargs)

Bases: nova.exception.SecurityGroupNotFound

exception SecurityGroupNotFoundForRule(message=None, **kwargs)

Bases: nova.exception.SecurityGroupNotFound

exception ServiceNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception ServiceUnavailable(message=None, **kwargs)

Bases: nova.exception.Invalid

exception SfAccountNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception SfJsonEncodeFailure(message=None, **kwargs)

Bases: nova.exception.NovaException

exception SnapshotIsBusy(message=None, **kwargs)

Bases: nova.exception.NovaException

exception SnapshotNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception SolidFireAPIDataException(message=None, **kwargs)

Bases: nova.exception.SolidFireAPIException

exception SolidFireAPIException(message=None, **kwargs)

Bases: nova.exception.NovaException

exception StorageRepositoryNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception SwitchNotFoundForNetworkAdapter(message=None, **kwargs)

Bases: nova.exception.NotFound

exception TaskAlreadyRunning(message=None, **kwargs)

Bases: nova.exception.NovaException

exception TaskNotRunning(message=None, **kwargs)

Bases: nova.exception.NovaException

exception TooManyInstances(message=None, **kwargs)

Bases: nova.exception.QuotaError

exception UnableToMigrateToSelf(message=None, **kwargs)

Bases: nova.exception.Invalid

exception UnexpectedTaskStateError(message=None, **kwargs)

Bases: nova.exception.NovaException

exception UnsupportedHardware(message=None, **kwargs)

Bases: nova.exception.Invalid

exception UnsupportedVirtType(message=None, **kwargs)

Bases: nova.exception.Invalid

exception VirtDriverNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception VirtualInterfaceCreateException(message=None, **kwargs)

Bases: nova.exception.NovaException

exception VirtualInterfaceMacAddressException(message=None, **kwargs)

Bases: nova.exception.NovaException

exception VolumeAttached(message=None, **kwargs)

Bases: nova.exception.Invalid

exception VolumeBackendAPIException(message=None, **kwargs)

Bases: nova.exception.NovaException

exception VolumeDriverNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception VolumeIsBusy(message=None, **kwargs)

Bases: nova.exception.NovaException

exception VolumeLimitExceeded(message=None, **kwargs)

Bases: nova.exception.QuotaError

exception VolumeMetadataNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception VolumeNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception VolumeSizeTooLarge(message=None, **kwargs)

Bases: nova.exception.QuotaError

exception VolumeTypeCreateFailed(message=None, **kwargs)

Bases: nova.exception.NovaException

exception VolumeTypeExists(message=None, **kwargs)

Bases: nova.exception.Duplicate

exception VolumeTypeExtraSpecsNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception VolumeTypeNotFound(message=None, **kwargs)

Bases: nova.exception.NotFound

exception VolumeTypeNotFoundByName(message=None, **kwargs)

Bases: nova.exception.VolumeTypeNotFound

exception VolumeUnattached(message=None, **kwargs)

Bases: nova.exception.Invalid

exception WillNotSchedule(message=None, **kwargs)

Bases: nova.exception.NovaException

get_context_from_function_and_args(function, args, kwargs)

Find an arg of type RequestContext and return it.

This is useful in a couple of decorators where we don’t know much about the function we’re wrapping.

wrap_db_error(f)
wrap_exception(notifier=None, publisher_id=None, event_type=None, level=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

Command-line flag library.

Emulates gflags by wrapping cfg.ConfigOpts.

The idea is to move fully to cfg eventually, and this wrapper is a stepping stone.

DECLARE(name, module_string, flag_values=<nova.openstack.common.cfg.CommonConfigOpts object at 0x913bbcc>)
exception UnrecognizedFlag

Bases: exceptions.Exception

parse_args(argv, default_config_files=None)

The nova.process Module

The nova.rpc Module

The nova.server Module

The nova.test Module

The nova.utils Module

Utilities and helper functions.

InterProcessLock

alias of _PosixLock

class LazyPluggable(pivot, **backends)

Bases: object

A pluggable backend loaded lazily based on some value.

class LoopingCall(f=None, *args, **kw)

Bases: object

LoopingCall.start(interval, initial_delay=None)
LoopingCall.stop()
LoopingCall.wait()
exception LoopingCallDone(retvalue=True)

Bases: exceptions.Exception

Exception to break out and stop a LoopingCall.

The poll-function passed to LoopingCall can raise this exception to break out of the loop normally. This is somewhat analogous to StopIteration.

An optional return-value can be included as the argument to the exception; this return-value will be returned by LoopingCall.wait()

class ProtectedExpatParser(forbid_dtd=True, forbid_entities=True, *args, **kwargs)

Bases: xml.sax.expatreader.ExpatParser

An expat parser which disables DTD’s and entities by default.

ProtectedExpatParser.entity_decl(entityName, is_parameter_entity, value, base, systemId, publicId, notationName)
ProtectedExpatParser.reset()
ProtectedExpatParser.start_doctype_decl(name, sysid, pubid, has_internal_subset)
ProtectedExpatParser.unparsed_entity_decl(name, base, sysid, pubid, notation_name)
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)
bool_from_str(val)

Convert a string representation of a bool into a bool value

check_isinstance(obj, cls)

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

convert_to_list_dict(lst, label)

Convert a value or list into a list of dicts

debug(arg)
delete_if_exists(pathname)

delete a file, but ignore file not found error

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.

ensure_tree(path)

Create a directory (and any ancestor directories required)

Parameters:path – Directory to create
execute(*cmd, **kwargs)

Helper method to execute command with optional retry.

If you add a run_as_root=True command, don’t forget to add the corresponding filter to etc/nova/rootwrap.d !

Parameters:
  • cmd – Passed to subprocess.Popen.
  • process_input – Send to opened process.
  • check_exit_code – Single bool, int, or list of allowed exit codes. Defaults to [0]. Raise exception.ProcessExecutionError unless program exits with one of these code.
  • delay_on_retry – True | False. Defaults to True. If set to True, wait a short amount of time before retrying.
  • attempts – How many times to retry cmd.
  • run_as_root – True | False. Defaults to False. If set to True, the command is prefixed by the command specified in the root_helper FLAG.
Raises:
  • exception.NovaException – on receiving unknown arguments
  • exception.ProcessExecutionError
Returns:

a tuple, (stdout, stderr) from the spawned process, or None if the command fails.

file_open(*args, **kwargs)

Open file

see built-in file() documentation for more details

Note: The reason this is kept in a separate module is to easily
be able to provide a stub module that doesn’t alter system state at all (for unit tests)
flatten_dict(dict_, flattened=None)

Recursively flatten a nested dictionary.

gen_uuid()
generate_glance_url()

Generate the URL to glance.

generate_image_url(image_ref)

Generate an image URL from an image_ref.

generate_mac_address()

Generate an Ethernet MAC address.

generate_password(length=20, 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_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_my_linklocal(interface)
hash_file(file_like_object)

Generate a hash for the contents of a file.

is_uuid_like(val)

For our purposes, a UUID is a string in canonical form:

aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa

is_valid_boolstr(val)

Check if the provided string is a valid bool string or not.

is_valid_cidr(address)

Check if the provided ipv4 or ipv6 address is a valid CIDR address or not

is_valid_ipv4(address)

valid the address strictly as per format xxx.xxx.xxx.xxx. where xxx is a value between 0 and 255.

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.

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 FLAGS.monkey_patch_modules. The format is “Module path:Decorator function”. Example: ‘nova.api.ec2.cloud:nova.notifier.api.notify_decorator’

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

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

novadir()
parse_mailmap(mailmap='.mailmap')
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.

remove_path_on_error(*args, **kwds)

Protect code that wants to operate on PATH atomically. Any exception will cause PATH to be removed.

safe_minidom_parse_string(xml_string)

Parse an XML string using minidom safely.

sanitize_hostname(hostname)

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

service_is_up(service)

Check whether a service is up based on last heartbeat.

ssh_execute(ssh, cmd, process_input=None, addl_env=None, check_exit_code=True)
str_dict_replace(s, mapping)
strcmp_const_time(s1, s2)

Constant-time string comparison.

Params s1:the first string
Params s2:the second string
Returns:True if the strings are equal.

This function takes two strings and compares them. It is intended to be used when doing a comparison for authentication purposes to help guard against timing attacks.

subset_dict(dict_, keys)

Return a dict that only contains a subset of keys.

synchronized(name, external=False, lock_path=None)

Synchronization decorator.

Decorating a method like so:

@synchronized('mylock')
def foo(self, *args):
   ...

ensures that only one thread will execute the bar method at a time.

Different methods can share the same lock:

@synchronized('mylock')
def foo(self, *args):
   ...

@synchronized('mylock')
def bar(self, *args):
   ...

This way only one of either foo or bar can be executing at a time.

The external keyword argument denotes whether this lock should work across multiple processes. This means that if two different workers both run a a method decorated with @synchronized(‘mylock’, external=True), only one of them will execute at a time.

The lock_path keyword argument is used to specify a special location for external lock files to live. If nothing is set, then FLAGS.lock_path is used as a default.

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)

A wrapper around execute() to more easily handle warnings and errors.

Returns an (out, err) tuple of strings containing the output of the command’s stdout and stderr. If ‘err’ is not empty then the command can be considered to have failed.

:discard_warnings True | False. Defaults to False. If set to True,
then for succeeding commands, stderr is cleared
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

vpn_ping(address, port, timeout=0.050000000000000003, 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=(No Default), unicode_errors=(No Default), decode_param_names=(No Default), **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 0x93edc2c>, backlog=128)

Bases: object

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

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