@

Home 

OpenStack Study: nova

OpenStack Index

Previous

Next

def key_pair_get(context, user_id, name):

def key_pair_get_all_by_user(context, user_id):

def key_pair_count_by_user(context, user_id):

def network_associate(context, project_id, network_id=None, force=False):

def network_count_reserved_ips(context, network_id):

def network_create_safe(context, values):

def network_delete_safe(context, network_id):

def network_disassociate(context, network_id, disassociate_host=True, disassociate_project=True):

def network_get(context, network_id, project_only="allow_none"):

def network_get_all(context, project_only="allow_none"):

def network_get_all_by_uuids(context, network_uuids, project_only="allow_none"):

def network_in_use_on_host(context, network_id, host=None):

def network_get_associated_fixed_ips(context, network_id, host=None):

def network_get_by_uuid(context, uuid):

def network_get_by_cidr(context, cidr):

def network_get_all_by_host(context, host):

def network_set_host(context, network_id, host_id):

def network_update(context, network_id, values):

def quota_create(context, project_id, resource, limit, user_id=None):

def quota_get(context, project_id, resource, user_id=None):

def quota_get_all_by_project_and_user(context, project_id, user_id):

def quota_get_all_by_project(context, project_id):

def quota_get_all(context, project_id):

def quota_update(context, project_id, resource, limit, user_id=None):

def quota_class_create(context, class_name, resource, limit):

def quota_class_get(context, class_name, resource):

def quota_class_get_default(context):

def quota_class_get_all_by_name(context, class_name):

def quota_class_update(context, class_name, resource, limit):

def quota_usage_get(context, project_id, resource, user_id=None):

def quota_usage_get_all_by_project_and_user(context, project_id, user_id):

def quota_usage_get_all_by_project(context, project_id):

def quota_usage_update(context, project_id, user_id, resource, **kwargs):

def quota_reserve(context, resources, quotas, user_quotas, deltas, expire, until_refresh, max_age, project_id=None, user_id=None):

def reservation_commit(context, reservations, project_id=None, user_id=None):

def reservation_rollback(context, reservations, project_id=None, user_id=None):

def quota_destroy_all_by_project_and_user(context, project_id, user_id):

def quota_destroy_all_by_project(context, project_id):

def reservation_expire(context):

def get_ec2_volume_id_by_uuid(context, volume_id):

def get_volume_uuid_by_ec2_id(context, ec2_id):

def ec2_volume_create(context, volume_id, forced_id=None):

def get_snapshot_uuid_by_ec2_id(context, ec2_id):

def get_ec2_snapshot_id_by_uuid(context, snapshot_id):

def ec2_snapshot_create(context, snapshot_id, forced_id=None):

def block_device_mapping_create(context, values, legacy=True):

def block_device_mapping_update(context, bdm_id, values, legacy=True):

def block_device_mapping_update_or_create(context, values, legacy=True):

def block_device_mapping_get_all_by_instance(context, instance_uuid, use_slave=False):

def block_device_mapping_get_by_volume_id(context, volume_id, columns_to_join=None):

def block_device_mapping_destroy(context, bdm_id):

def block_device_mapping_destroy_by_instance_and_device(context, instance_uuid, device_name):

def block_device_mapping_destroy_by_instance_and_volume(context, instance_uuid, volume_id):

def security_group_get_all(context):

def security_group_get(context, security_group_id, columns_to_join=None):

def security_group_get_by_name(context, project_id, group_name, columns_to_join=None):

def security_group_get_by_project(context, project_id):

def security_group_get_by_instance(context, instance_uuid):

def security_group_in_use(context, group_id):

def security_group_create(context, values):

def security_group_update(context, security_group_id, values, columns_to_join=None):

def security_group_ensure_default(context):

def security_group_destroy(context, security_group_id):

def security_group_rule_create(context, values):

def security_group_rule_get_by_security_group(context, security_group_id, columns_to_join=None):

def security_group_rule_get_by_security_group_grantee(context, security_group_id):

def security_group_rule_destroy(context, security_group_rule_id):

def security_group_rule_get(context, security_group_rule_id):

def security_group_rule_count_by_group(context, security_group_id):

def security_group_default_rule_get(context, security_group_rule_default_id):

def security_group_default_rule_destroy(context, security_group_rule_default_id):

def security_group_default_rule_create(context, values):

def security_group_default_rule_list(context):

def provider_fw_rule_create(context, rule):

def provider_fw_rule_get_all(context):

def provider_fw_rule_destroy(context, rule_id):

def project_get_networks(context, project_id, associate=True):

def console_pool_create(context, values):

def console_pool_get_by_host_type(context, compute_host, proxy_host, console_type):

def console_pool_get_all_by_host_type(context, host, console_type):

def console_create(context, values):

def console_delete(context, console_id):

def console_get_by_pool_instance(context, pool_id, instance_uuid):

def console_get_all_by_instance(context, instance_uuid, columns_to_join=None):

def console_get(context, console_id, instance_uuid=None):

def flavor_create(context, values, projects=None):

def flavor_get_all(context, inactive=False, filters=None, sort_key='flavorid', sort_dir='asc', limit=None, marker=None):

def flavor_get(context, id):

def flavor_get_by_name(context, name):

def flavor_get_by_flavor_id(context, id, read_deleted=None):

def flavor_destroy(context, name):

def flavor_access_get_by_flavor_id(context, flavor_id):

def flavor_access_add(context, flavor_id, project_id):

def flavor_access_remove(context, flavor_id, project_id):

def flavor_extra_specs_get(context, flavor_id):

def flavor_extra_specs_get_item(context, flavor_id, key):

def flavor_extra_specs_delete(context, flavor_id, key):

def flavor_extra_specs_update_or_create(context, flavor_id, extra_specs):

def pci_device_get_by_addr(context, node_id, dev_addr):

def pci_device_get_by_id(context, id):

def pci_device_get_all_by_node(context, node_id):

def pci_device_get_all_by_instance_uuid(context, instance_uuid):

def pci_device_destroy(context, node_id, address):

def pci_device_update(context, node_id, address, value):

def cell_create(context, values):

def cell_update(context, cell_name, values):

def cell_delete(context, cell_name):

def cell_get(context, cell_name):

def cell_get_all(context):

def instance_metadata_get(context, instance_uuid):

def instance_metadata_delete(context, instance_uuid, key):

def instance_metadata_update(context, instance_uuid, metadata, delete):

def instance_system_metadata_get(context, instance_uuid):

def instance_system_metadata_update(context, instance_uuid, metadata, delete):

def agent_build_create(context, values):

def agent_build_get_by_triple(context, hypervisor, os, architecture):

def agent_build_get_all(context, hypervisor=None):

def agent_build_destroy(context, agent_update_id):

def agent_build_update(context, agent_build_id, values):

def bw_usage_get(context, uuid, start_period, mac, use_slave=False):

def bw_usage_get_by_uuids(context, uuids, start_period):

def bw_usage_update(context, uuid, mac, start_period, bw_in, bw_out, last_ctr_in, last_ctr_out, last_refreshed=None, update_cells=True):

def vol_get_usage_by_time(context, begin):

def vol_usage_update(context, id, rd_req, rd_bytes, wr_req, wr_bytes, instance_id, project_id, user_id, availability_zone, update_totals=False):

def s3_image_get(context, image_id):

def s3_image_get_by_uuid(context, image_uuid):

def s3_image_create(context, image_uuid):

def aggregate_create(context, values, metadata=None):

def aggregate_get(context, aggregate_id):

def aggregate_get_by_host(context, host, key=None):

def aggregate_metadata_get_by_host(context, host, key=None):

def aggregate_metadata_get_by_metadata_key(context, aggregate_id, key):

def aggregate_host_get_by_metadata_key(context, key):

def aggregate_update(context, aggregate_id, values):

def aggregate_delete(context, aggregate_id):

def aggregate_get_all(context):

def aggregate_metadata_add(context, aggregate_id, metadata, set_delete=False):

def aggregate_metadata_get(context, aggregate_id):

def aggregate_metadata_delete(context, aggregate_id, key):

def aggregate_host_add(context, aggregate_id, host):

def aggregate_host_get_all(context, aggregate_id):

def aggregate_host_delete(context, aggregate_id, host):

def instance_fault_create(context, values, update_cells=True):

def instance_fault_get_by_instance_uuids(context, instance_uuids):

def action_start(context, values):

def action_finish(context, values):

def actions_get(context, uuid):

def action_get_by_request_id(context, uuid, request_id):

def action_event_start(context, values):

def action_event_finish(context, values):

def action_events_get(context, action_id):

def action_event_get_by_id(context, action_id, event_id):

def get_ec2_instance_id_by_uuid(context, instance_id):

def get_instance_uuid_by_ec2_id(context, ec2_id):

def ec2_instance_create(context, instance_uuid, id=None):

def task_log_end_task(context, task_name, period_beginning, period_ending, host, errors, message=None):

def task_log_begin_task(context, task_name, period_beginning, period_ending, host, task_items=None, message=None):

def task_log_get_all(context, task_name, period_beginning, period_ending, host=None, state=None):

def task_log_get(context, task_name, period_beginning, period_ending, host, state=None):

def archive_deleted_rows(context, max_rows=None):

def archive_deleted_rows_for_table(context, tablename, max_rows=None):

\OpenStack\nova-2014.1\nova\db\base.py

class Base(object):

    def __init__(self, db_driver=None):

\OpenStack\nova-2014.1\nova\db\migration.py

def db_sync(version=None):

def db_version():

def db_initial_version():

\OpenStack\nova-2014.1\nova\db\sqlalchemy\api.py

def _create_facade_lazily(use_slave=False):

def get_engine(use_slave=False):

def get_session(use_slave=False, **kwargs):

def get_backend():

def require_admin_context(f):

 def wrapper(*args, **kwargs):

def require_context(f):

 def wrapper(*args, **kwargs):

def require_instance_exists_using_uuid(f):

 def wrapper(context, instance_uuid, *args, **kwargs):

def require_aggregate_exists(f):

 def wrapper(context, aggregate_id, *args, **kwargs):

def _retry_on_deadlock(f):

 def wrapped(*args, **kwargs):

def model_query(context, model, *args, **kwargs):

 def issubclassof_nova_base(obj):

def exact_filter(query, model, filters, legal_keys):

def convert_objects_related_datetimes(values, *datetime_keys):

def _sync_instances(context, project_id, user_id, session):

def _sync_floating_ips(context, project_id, user_id, session):

def _sync_fixed_ips(context, project_id, user_id, session):

def _sync_security_groups(context, project_id, user_id, session):

def constraint(**conditions):

def equal_any(*values):

def not_equal(*values):

class Constraint(object):

    def __init__(self, conditions):

    def apply(self, model, query):

class EqualityCondition(object):

    def __init__(self, values):

    def clauses(self, field):

class InequalityCondition(object):

    def __init__(self, values):

    def clauses(self, field):

        def filter_columns(table):

    def _get_sec_group_models(session, security_groups):

def _instance_data_get_for_user(context, project_id, user_id, session=None):

def instance_destroy(context, instance_uuid, constraint=None):

def instance_get_by_uuid(context, uuid, columns_to_join=None, use_slave=False):

def _instance_get_by_uuid(context, uuid, session=None, columns_to_join=None, use_slave=False):

def instance_get(context, instance_id, columns_to_join=None):

def _build_instance_get(context, session=None, columns_to_join=None, use_slave=False):

def _instances_fill_metadata(context, instances, manual_joins=None, use_slave=False):

def _manual_join_columns(columns_to_join):

def instance_get_all(context, columns_to_join=None):

def instance_get_all_by_filters(context, filters, sort_key, sort_dir, limit=None, marker=None, columns_to_join=None, use_slave=False):

def tag_filter(context, query, model, model_metadata, model_uuid, filters):

    def _to_list(val):

        def network_query(project_filter, id=None):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\manage.py

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\216_havana.py

def MediumText():

def Inet():

def InetSmall():

def _create_shadow_tables(migrate_engine):

def _populate_instance_types(instance_types_table):

def _create_dump_tables(migrate_engine):

def upgrade(migrate_engine):

def downgrade(migrate_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\217_placeholder.py

def upgrade(migrate_engine):

def downgrade(migration_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\218_placeholder.py

def upgrade(migrate_engine):

def downgrade(migration_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\219_placeholder.py

def upgrade(migrate_engine):

def downgrade(migration_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\220_placeholder.py

def upgrade(migrate_engine):

def downgrade(migration_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\221_placeholder.py

def upgrade(migrate_engine):

def downgrade(migration_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\222_placeholder.py

def upgrade(migrate_engine):

def downgrade(migration_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\223_placeholder.py

def upgrade(migrate_engine):

def downgrade(migration_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\224_placeholder.py

def upgrade(migrate_engine):

def downgrade(migration_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\225_placeholder.py

def upgrade(migrate_engine):

def downgrade(migration_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\226_placeholder.py

def upgrade(migrate_engine):

def downgrade(migration_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\227_fix_project_user_quotas_resource_length.py

def upgrade(migrate_engine):

def downgrade(migrate_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\228_add_metrics_in_compute_nodes.py

def upgrade(migrate_engine):

def downgrade(migrate_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\229_add_extra_resources_in_compute_nodes.py

def upgrade(migrate_engine):

def downgrade(migrate_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\230_add_details_column_to_instance_actions_events.py

def upgrade(migrate_engine):

def downgrade(migrate_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\231_add_ephemeral_key_uuid.py

def upgrade(migrate_engine):

def downgrade(migrate_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\232_drop_dump_tables.py

def upgrade(migrate_engine):

def downgrade(migrate_engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\233_add_stats_in_compute_nodes.py

def upgrade(engine):

def downgrade(engine):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\versions\__init__.py

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migrate_repo\__init__.py

\OpenStack\nova-2014.1\nova\db\sqlalchemy\migration.py

def db_sync(version=None):

def db_version():

def db_initial_version():

def db_version_control(version=None):

def _find_migrate_repo():

\OpenStack\nova-2014.1\nova\db\sqlalchemy\models.py

def MediumText():

class NovaBase(models.SoftDeleteMixin, models.TimestampMixin, models.ModelBase):

    def save(self, session=None):

class Service(BASE, NovaBase):

class ComputeNode(BASE, NovaBase):

class Certificate(BASE, NovaBase):

class Instance(BASE, NovaBase):

    def name(self):

    def _extra_keys(self):

class InstanceInfoCache(BASE, NovaBase):

class InstanceTypes(BASE, NovaBase):

class Volume(BASE, NovaBase):

    def name(self):

class Quota(BASE, NovaBase):

class ProjectUserQuota(BASE, NovaBase):

class QuotaClass(BASE, NovaBase):

class QuotaUsage(BASE, NovaBase):

    def total(self):

class Reservation(BASE, NovaBase):

class Snapshot(BASE, NovaBase):

    def name(self):

    def volume_name(self):

class BlockDeviceMapping(BASE, NovaBase):

class IscsiTarget(BASE, NovaBase):

class SecurityGroupInstanceAssociation(BASE, NovaBase):

class SecurityGroup(BASE, NovaBase):

class SecurityGroupIngressRule(BASE, NovaBase):

class SecurityGroupIngressDefaultRule(BASE, NovaBase):

class ProviderFirewallRule(BASE, NovaBase):

class KeyPair(BASE, NovaBase):

class Migration(BASE, NovaBase):

class Network(BASE, NovaBase):

class VirtualInterface(BASE, NovaBase):

class FixedIp(BASE, NovaBase):

class FloatingIp(BASE, NovaBase):

class DNSDomain(BASE, NovaBase):

class ConsolePool(BASE, NovaBase):

class Console(BASE, NovaBase):

class InstanceMetadata(BASE, NovaBase):

class InstanceSystemMetadata(BASE, NovaBase):

class InstanceTypeProjects(BASE, NovaBase):

class InstanceTypeExtraSpecs(BASE, NovaBase):

class Cell(BASE, NovaBase):

class AggregateHost(BASE, NovaBase):

class AggregateMetadata(BASE, NovaBase):

class Aggregate(BASE, NovaBase):

    def _extra_keys(self):

    def hosts(self):

    def metadetails(self):

    def availability_zone(self):

class AgentBuild(BASE, NovaBase):

class BandwidthUsage(BASE, NovaBase):

class VolumeUsage(BASE, NovaBase):

class S3Image(BASE, NovaBase):

class VolumeIdMapping(BASE, NovaBase):

class SnapshotIdMapping(BASE, NovaBase):

class InstanceFault(BASE, NovaBase):

class InstanceAction(BASE, NovaBase):

class InstanceActionEvent(BASE, NovaBase):

class InstanceIdMapping(BASE, NovaBase):

class TaskLog(BASE, NovaBase):

class InstanceGroupMember(BASE, NovaBase):

class InstanceGroupPolicy(BASE, NovaBase):

class InstanceGroupMetadata(BASE, NovaBase):

class InstanceGroup(BASE, NovaBase):

    def policies(self):

    def metadetails(self):

    def members(self):

class PciDevice(BASE, NovaBase):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\types.py

class IPAddress(types.TypeDecorator):

    def load_dialect_impl(self, dialect):

    def process_bind_param(self, value, dialect):

class CIDR(types.TypeDecorator):

    def load_dialect_impl(self, dialect):

    def process_bind_param(self, value, dialect):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\utils.py

def get_table(engine, name):

class InsertFromSelect(UpdateBase):

    def __init__(self, table, select):

def visit_insert_from_select(element, compiler, **kw):

class DeleteFromSelect(UpdateBase):

    def __init__(self, table, select, column):

def visit_delete_from_select(element, compiler, **kw):

def _get_not_supported_column(col_name_col_instance, column_name):

def _get_unique_constraints_in_sqlite(migrate_engine, table_name):

def _drop_unique_constraint_in_sqlite(migrate_engine, table_name, uc_name, **col_name_col_instance):

def drop_unique_constraint(migrate_engine, table_name, uc_name, *columns, **col_name_col_instance):

def drop_old_duplicate_entries_from_table(migrate_engine, table_name, use_soft_delete, *uc_column_names):

def check_shadow_table(migrate_engine, table_name):

def create_shadow_table(migrate_engine, table_name=None, table=None, **col_name_col_instance):

def _get_default_deleted_value(table):

def _restore_indexes_on_deleted_columns(migrate_engine, table_name, indexes):

def change_deleted_column_type_to_boolean(migrate_engine, table_name, **col_name_col_instance):

def _change_deleted_column_type_to_boolean_sqlite(migrate_engine, table_name, **col_name_col_instance):

def change_deleted_column_type_to_id_type(migrate_engine, table_name, **col_name_col_instance):

def _change_deleted_column_type_to_id_type_sqlite(migrate_engine, table_name, **col_name_col_instance):

    def is_deleted_column_constraint(constraint):

def _index_exists(migrate_engine, table_name, index_name):

def _add_index(migrate_engine, table, index_name, idx_columns):

def _drop_index(migrate_engine, table, index_name, idx_columns):

def _change_index_columns(migrate_engine, table, index_name, new_columns, old_columns):

def modify_indexes(migrate_engine, data, upgrade=True):

\OpenStack\nova-2014.1\nova\db\sqlalchemy\__init__.py

def compile_big_int_sqlite(type_, compiler, **kw):

\OpenStack\nova-2014.1\nova\db\__init__.py

\OpenStack\nova-2014.1\nova\debugger.py

def enabled():

def register_cli_opts():

def init():

\OpenStack\nova-2014.1\nova\exception.py

class ConvertedException(webob.exc.WSGIHTTPException):

    def __init__(self, code=0, title="", explanation=""):

def _cleanse_dict(original):

def wrap_exception(notifier=None, get_notifier=None):

    def inner(f):

        def wrapped(self, context, *args, **kw):

class NovaException(Exception):

    def __init__(self, message=None, **kwargs):

    def format_message(self):

class EncryptionFailure(NovaException):

class DecryptionFailure(NovaException):

class VirtualInterfaceCreateException(NovaException):

class VirtualInterfaceMacAddressException(NovaException):

class GlanceConnectionFailed(NovaException):

class NotAuthorized(NovaException):

class AdminRequired(NotAuthorized):

class PolicyNotAuthorized(NotAuthorized):

class ImageNotActive(NovaException):

class ImageNotAuthorized(NovaException):

class Invalid(NovaException):

class InvalidBDM(Invalid):

class InvalidBDMSnapshot(InvalidBDM):

class InvalidBDMVolume(InvalidBDM):

class InvalidBDMImage(InvalidBDM):

class InvalidBDMBootSequence(InvalidBDM):

class InvalidBDMLocalsLimit(InvalidBDM):

class InvalidBDMEphemeralSize(InvalidBDM):

class InvalidBDMSwapSize(InvalidBDM):

class InvalidBDMFormat(InvalidBDM):

class InvalidBDMForLegacy(InvalidBDM):

class InvalidAttribute(Invalid):

class ValidationError(Invalid):

class VolumeUnattached(Invalid):

class VolumeNotCreated(NovaException):

class InvalidKeypair(Invalid):

class InvalidRequest(Invalid):

class InvalidInput(Invalid):

class InvalidVolume(Invalid):

class InvalidVolumeAccessMode(Invalid):

class InvalidMetadata(Invalid):

class InvalidMetadataSize(Invalid):

class InvalidPortRange(Invalid):

class InvalidIpProtocol(Invalid):

class InvalidContentType(Invalid):

class InvalidCidr(Invalid):

class InvalidUnicodeParameter(Invalid):

class InvalidParameterValue(Invalid):

class InvalidAggregateAction(Invalid):

class InvalidGroup(Invalid):

class InvalidSortKey(Invalid):

class InstanceInvalidState(Invalid):

class InstanceNotRunning(Invalid):

class InstanceNotInRescueMode(Invalid):

class InstanceNotRescuable(Invalid):

class InstanceNotReady(Invalid):

class InstanceSuspendFailure(Invalid):

class InstanceResumeFailure(Invalid):

class InstancePowerOnFailure(Invalid):

class InstancePowerOffFailure(Invalid):

class InstanceRebootFailure(Invalid):

class InstanceTerminationFailure(Invalid):

class InstanceDeployFailure(Invalid):

class MultiplePortsNotApplicable(Invalid):

class ServiceUnavailable(Invalid):

class ComputeResourcesUnavailable(ServiceUnavailable):

class HypervisorUnavailable(NovaException):

class ComputeServiceUnavailable(ServiceUnavailable):

class ComputeServiceInUse(NovaException):

class UnableToMigrateToSelf(Invalid):

class InvalidHypervisorType(Invalid):

class DestinationHypervisorTooOld(Invalid):

class DestinationDiskExists(Invalid):

class InvalidDevicePath(Invalid):

class DevicePathInUse(Invalid):

class DeviceIsBusy(Invalid):

class InvalidCPUInfo(Invalid):

class InvalidIpAddressError(Invalid):

class InvalidVLANTag(Invalid):

class InvalidVLANPortGroup(Invalid):

class InvalidDiskFormat(Invalid):

class InvalidDiskInfo(Invalid):

class DiskInfoReadWriteFail(Invalid):

class ImageUnacceptable(Invalid):

class InstanceUnacceptable(Invalid):

class InvalidEc2Id(Invalid):

class InvalidUUID(Invalid):

class InvalidID(Invalid):

class ConstraintNotMet(NovaException):

class NotFound(NovaException):

class AgentBuildNotFound(NotFound):

class AgentBuildExists(NovaException):

class VolumeNotFound(NotFound):

class VolumeBDMNotFound(NotFound):

class SnapshotNotFound(NotFound):

class DiskNotFound(NotFound):

class VolumeDriverNotFound(NotFound):

class InvalidImageRef(Invalid):

class AutoDiskConfigDisabledByImage(Invalid):

class ImageNotFound(NotFound):

class PreserveEphemeralNotSupported(Invalid):

class ImageNotFoundEC2(ImageNotFound):

class ProjectNotFound(NotFound):

class StorageRepositoryNotFound(NotFound):

class NetworkDuplicated(Invalid):

class NetworkInUse(NovaException):

class NetworkNotCreated(NovaException):

class NetworkNotFound(NotFound):

class PortNotFound(NotFound):

class NetworkNotFoundForBridge(NetworkNotFound):

class NetworkNotFoundForUUID(NetworkNotFound):

class NetworkNotFoundForCidr(NetworkNotFound):

class NetworkNotFoundForInstance(NetworkNotFound):

class NoNetworksFound(NotFound):

class NoMoreNetworks(NovaException):

class NetworkNotFoundForProject(NotFound):

class NetworkAmbiguous(Invalid):

class NetworkRequiresSubnet(Invalid):

class ExternalNetworkAttachForbidden(NotAuthorized):

class DatastoreNotFound(NotFound):

class PortInUse(Invalid):

class PortRequiresFixedIP(Invalid):

class PortNotUsable(Invalid):

class PortNotFree(Invalid):

class FixedIpExists(NovaException):

class FixedIpNotFound(NotFound):

class FixedIpNotFoundForAddress(FixedIpNotFound):

class FixedIpNotFoundForInstance(FixedIpNotFound):

class FixedIpNotFoundForNetworkHost(FixedIpNotFound):

class FixedIpNotFoundForSpecificInstance(FixedIpNotFound):

class FixedIpNotFoundForNetwork(FixedIpNotFound):

class FixedIpAlreadyInUse(NovaException):

class FixedIpAssociatedWithMultipleInstances(NovaException):

class FixedIpInvalid(Invalid):

class NoMoreFixedIps(NovaException):

class NoFixedIpsDefined(NotFound):

class FloatingIpExists(NovaException):

class FloatingIpNotFound(NotFound):

class FloatingIpDNSExists(Invalid):

class FloatingIpNotFoundForAddress(FloatingIpNotFound):

class FloatingIpNotFoundForHost(FloatingIpNotFound):

class FloatingIpMultipleFoundForAddress(NovaException):

class FloatingIpPoolNotFound(NotFound):

class NoMoreFloatingIps(FloatingIpNotFound):

class FloatingIpAssociated(NovaException):

class FloatingIpNotAssociated(NovaException):

class NoFloatingIpsDefined(NotFound):

class NoFloatingIpInterface(NotFound):

class CannotDisassociateAutoAssignedFloatingIP(NovaException):

class KeypairNotFound(NotFound):

class ServiceNotFound(NotFound):

class ServiceBinaryExists(NovaException):

class ServiceTopicExists(NovaException):

class HostNotFound(NotFound):

class ComputeHostNotFound(HostNotFound):

class HostBinaryNotFound(NotFound):

class InvalidReservationExpiration(Invalid):

class InvalidQuotaValue(Invalid):

class QuotaNotFound(NotFound):

class QuotaExists(NovaException):

class QuotaResourceUnknown(QuotaNotFound):

class ProjectUserQuotaNotFound(QuotaNotFound):

class ProjectQuotaNotFound(QuotaNotFound):

class QuotaClassNotFound(QuotaNotFound):

class QuotaUsageNotFound(QuotaNotFound):

class ReservationNotFound(QuotaNotFound):

class OverQuota(NovaException):

class SecurityGroupNotFound(NotFound):

class SecurityGroupNotFoundForProject(SecurityGroupNotFound):

class SecurityGroupNotFoundForRule(SecurityGroupNotFound):

class SecurityGroupExists(Invalid):

class SecurityGroupExistsForInstance(Invalid):

class SecurityGroupNotExistsForInstance(Invalid):

class SecurityGroupDefaultRuleNotFound(Invalid):

class SecurityGroupCannotBeApplied(Invalid):

class SecurityGroupRuleExists(Invalid):

class NoUniqueMatch(NovaException):

class MigrationNotFound(NotFound):

class MigrationNotFoundByStatus(MigrationNotFound):

class ConsolePoolNotFound(NotFound):

class ConsolePoolExists(NovaException):

class ConsolePoolNotFoundForHostType(NotFound):

class ConsoleNotFound(NotFound):

class ConsoleNotFoundForInstance(ConsoleNotFound):

class ConsoleNotFoundInPoolForInstance(ConsoleNotFound):

class ConsoleTypeInvalid(Invalid):

class ConsoleTypeUnavailable(Invalid):

class ConsolePortRangeExhausted(NovaException):

class FlavorNotFound(NotFound):

class FlavorNotFoundByName(FlavorNotFound):

class FlavorAccessNotFound(NotFound):

class CellNotFound(NotFound):

class CellExists(NovaException):

class CellRoutingInconsistency(NovaException):

class CellServiceAPIMethodNotFound(NotFound):

class CellTimeout(NotFound):

class CellMaxHopCountReached(NovaException):

class NoCellsAvailable(NovaException):

class CellsUpdateUnsupported(NovaException):

class InstanceUnknownCell(NotFound):

class SchedulerHostFilterNotFound(NotFound):

class FlavorExtraSpecsNotFound(NotFound):

class ComputeHostMetricNotFound(NotFound):

class FileNotFound(NotFound):

class NoFilesFound(NotFound):

class SwitchNotFoundForNetworkAdapter(NotFound):

class NetworkAdapterNotFound(NotFound):

class ClassNotFound(NotFound):

class NotAllowed(NovaException):

class ImageRotationNotAllowed(NovaException):

class RotationRequiredForBackup(NovaException):

class KeyPairExists(NovaException):

class InstanceExists(NovaException):

class FlavorExists(NovaException):

class FlavorIdExists(NovaException):

class FlavorAccessExists(NovaException):

class InvalidSharedStorage(NovaException):

class InvalidLocalStorage(NovaException):

class MigrationError(NovaException):

class MigrationPreCheckError(MigrationError):

class MalformedRequestBody(NovaException):

class ConfigNotFound(NovaException):

class PasteAppNotFound(NovaException):

class CannotResizeToSameFlavor(NovaException):

class ResizeError(NovaException):

class CannotResizeDisk(NovaException):

class FlavorMemoryTooSmall(NovaException):

class FlavorDiskTooSmall(NovaException):

class InsufficientFreeMemory(NovaException):

class NoValidHost(NovaException):

class QuotaError(NovaException):

class TooManyInstances(QuotaError):

class FloatingIpLimitExceeded(QuotaError):

class FixedIpLimitExceeded(QuotaError):

class MetadataLimitExceeded(QuotaError):

class OnsetFileLimitExceeded(QuotaError):

class OnsetFilePathLimitExceeded(QuotaError):

class OnsetFileContentLimitExceeded(QuotaError):

class KeypairLimitExceeded(QuotaError):

class SecurityGroupLimitExceeded(QuotaError):

class PortLimitExceeded(QuotaError):

class AggregateError(NovaException):

class AggregateNotFound(NotFound):

class AggregateNameExists(NovaException):

class AggregateHostNotFound(NotFound):

class AggregateMetadataNotFound(NotFound):

class AggregateHostExists(NovaException):

class FlavorCreateFailed(NovaException):

class InstancePasswordSetFailed(NovaException):

class DuplicateVlan(NovaException):

class CidrConflict(NovaException):

class InstanceNotFound(NotFound):

class InstanceInfoCacheNotFound(NotFound):

class NodeNotFound(NotFound):

class NodeNotFoundByUUID(NotFound):

class MarkerNotFound(NotFound):

class InvalidInstanceIDMalformed(Invalid):

class CouldNotFetchImage(NovaException):

class CouldNotUploadImage(NovaException):

class TaskAlreadyRunning(NovaException):

class TaskNotRunning(NovaException):

class InstanceIsLocked(InstanceInvalidState):

class ConfigDriveInvalidValue(Invalid):

class ConfigDriveMountFailed(NovaException):

class ConfigDriveUnknownFormat(NovaException):

class InterfaceAttachFailed(Invalid):

class InterfaceDetachFailed(Invalid):

class InstanceUserDataTooLarge(NovaException):

class InstanceUserDataMalformed(NovaException):

class UnexpectedTaskStateError(NovaException):

class UnexpectedDeletingTaskStateError(UnexpectedTaskStateError):

class InstanceActionNotFound(NovaException):

class InstanceActionEventNotFound(NovaException):

class UnexpectedVMStateError(NovaException):

class CryptoCAFileNotFound(FileNotFound):

class CryptoCRLFileNotFound(FileNotFound):

class InstanceRecreateNotSupported(Invalid):

class ServiceGroupUnavailable(NovaException):

class DBNotAllowed(NovaException):

class UnsupportedVirtType(Invalid):

class UnsupportedHardware(Invalid):

class Base64Exception(NovaException):

class BuildAbortException(NovaException):

class RescheduledException(NovaException):

class ShadowTableExists(NovaException):

class InstanceFaultRollback(NovaException):

    def __init__(self, inner_exception=None):

class UnsupportedObjectError(NovaException):

class OrphanedObjectError(NovaException):

class IncompatibleObjectVersion(NovaException):

class ObjectActionError(NovaException):

class CoreAPIMissing(NovaException):

class AgentError(NovaException):

class AgentTimeout(AgentError):

class AgentNotImplemented(AgentError):

class InstanceGroupNotFound(NotFound):

class InstanceGroupIdExists(NovaException):

class InstanceGroupMetadataNotFound(NotFound):

class InstanceGroupMemberNotFound(NotFound):

class InstanceGroupPolicyNotFound(NotFound):

class PluginRetriesExceeded(NovaException):

class ImageDownloadModuleError(NovaException):

class ImageDownloadModuleMetaDataError(ImageDownloadModuleError):

class ImageDownloadModuleNotImplementedError(ImageDownloadModuleError):

class ImageDownloadModuleConfigurationError(ImageDownloadModuleError):

class ResourceMonitorError(NovaException):

class PciDeviceWrongAddressFormat(NovaException):

class PciDeviceNotFoundById(NotFound):

class PciDeviceNotFound(NovaException):

class PciDeviceInvalidStatus(NovaException):

class PciDeviceInvalidOwner(NovaException):

class PciDeviceRequestFailed(NovaException):

class PciDevicePoolEmpty(NovaException):

class PciInvalidAlias(NovaException):

class PciRequestAliasNotDefined(NovaException):

class MissingParameter(NovaException):

class PciConfigInvalidWhitelist(Invalid):

class PciTrackerInvalidNodeId(NovaException):

class InternalError(NovaException):

class PciDevicePrepareFailed(NovaException):

class PciDeviceDetachFailed(NovaException):

class PciDeviceUnsupportedHypervisor(NovaException):

class KeyManagerError(NovaException):

class InvalidVideoMode(Invalid):

class RngDeviceNotExist(Invalid):

class RequestedVRamTooHigh(NovaException):

class InvalidWatchdogAction(Invalid):

class NoBlockMigrationForConfigDriveInLibVirt(NovaException):

\OpenStack\nova-2014.1\nova\filters.py

class BaseFilter(object):

    def _filter_one(self, obj, filter_properties):

    def filter_all(self, filter_obj_list, filter_properties):

    def run_filter_for_index(self, index):

class BaseFilterHandler(loadables.BaseLoader):

    def get_filtered_objects(self, filter_classes, objs, filter_properties, index=0):

\OpenStack\nova-2014.1\nova\hacking\checks.py

def import_no_db_in_virt(logical_line, filename):

def no_db_session_in_public_api(logical_line, filename):

def use_timeutils_utcnow(logical_line):

def _get_virt_name(regex, data):

def import_no_virt_driver_import_deps(physical_line, filename):

def import_no_virt_driver_config_deps(physical_line, filename):

def capital_cfg_help(logical_line, tokens):

def no_vi_headers(physical_line, line_number, lines):

def no_author_tags(physical_line):

def assert_true_instance(logical_line):

def assert_equal_type(logical_line):

def assert_equal_none(logical_line):

def factory(register):

\OpenStack\nova-2014.1\nova\hacking\__init__.py

\OpenStack\nova-2014.1\nova\hooks.py

class MyHook(object):

    def pre(self, *args, **kwargs):

    def post(self, rv, *args, **kwargs):

class MyHookWithFunction(object):

    def pre(self, f, *args, **kwargs):

    def post(self, f, *args, **kwards):

class HookManager(stevedore.hook.HookManager):

    def __init__(self, name):

    def run_pre(self, name, args, kwargs, f=None):

    def run_post(self, name, rv, args, kwargs, f=None):

def add_hook(name, pass_function=False):

    def outer(f):

        def inner(*args, **kwargs):

\OpenStack\nova-2014.1\nova\image\download\base.py

class TransferBase(object):

    def download(self, context, url_parts, dst_path, metadata, **kwargs):

\OpenStack\nova-2014.1\nova\image\download\file.py

class FileTransfer(xfer_base.TransferBase):

    def _get_options(self):

    def __init__(self):

    def _verify_config(self):

    def _file_system_lookup(self, metadata, url_parts):

    def _normalize_destination(self, nova_mount, glance_mount, path):

    def download(self, context, url_parts, dst_file, metadata, **kwargs):

def get_download_handler(**kwargs):

def get_schemes():

\OpenStack\nova-2014.1\nova\image\download\__init__.py

def load_transfer_modules():

\OpenStack\nova-2014.1\nova\image\glance.py

def generate_glance_url():

def generate_image_url(image_ref):

def _parse_image_ref(image_href):

def generate_identity_headers(context, status='Confirmed'):

def _create_glance_client(context, host, port, use_ssl, version=1):

def get_api_servers():

class GlanceClientWrapper(object):

    def __init__(self, context=None, host=None, port=None, use_ssl=False, version=1):

    def _create_static_client(self, context, host, port, use_ssl, version):

    def _create_onetime_client(self, context, version):

    def call(self, context, version, method, *args, **kwargs):

class GlanceImageService(object):

    def __init__(self, client=None):

    def detail(self, context, **kwargs):

    def show(self, context, image_id):

    def _get_locations(self, context, image_id):

    def _get_transfer_module(self, scheme):

    def download(self, context, image_id, data=None, dst_path=None):

    def create(self, context, image_meta, data=None):

    def update(self, context, image_id, image_meta, data=None, purge_props=True):

    def delete(self, context, image_id):

def _extract_query_params(params):

def _is_image_available(context, image):

    def _is_image_public(image):

def _translate_to_glance(image_meta):

def _translate_from_glance(image):

def _convert_timestamps_to_datetimes(image_meta):

def _json_loads(properties, attr):

def _json_dumps(properties, attr):

def _convert(method, metadata):

def _convert_from_string(metadata):

def _convert_to_string(metadata):

def _extract_attributes(image):

def _remove_read_only(image_meta):

def _reraise_translated_image_exception(image_id):

def _reraise_translated_exception():

def _translate_image_exception(image_id, exc_value):

def _translate_plain_exception(exc_value):

def get_remote_image_service(context, image_href):

def get_default_image_service():

class UpdateGlanceImage(object):

    def __init__(self, context, image_id, metadata, stream):

    def start(self):

\OpenStack\nova-2014.1\nova\image\s3.py

class S3ImageService(object):

    def __init__(self, service=None, *args, **kwargs):

    def _translate_uuids_to_ids(self, context, images):

    def _translate_uuid_to_id(self, context, image):

    def _translate_id_to_uuid(self, context, image):

    def create(self, context, metadata, data=None):

    def delete(self, context, image_id):

    def update(self, context, image_id, metadata, data=None):

    def detail(self, context, **kwargs):

    def show(self, context, image_id):

    def _conn(context):

    def _download_file(bucket, filename, local_dir):

    def _s3_parse_manifest(self, context, metadata, manifest):

        def _translate_dependent_image_id(image_key, image_id):

    def _s3_create(self, context, metadata):

        def delayed_create():

    def _decrypt_image(self, context, encrypted_filename, encrypted_key, encrypted_iv, decrypted_filename):

    def _test_for_malicious_tarball(path, filename):

    def _untarzip_image(path, filename):

\OpenStack\nova-2014.1\nova\image\__init__.py

\OpenStack\nova-2014.1\nova\ipv6\account_identifier.py

def to_global(prefix, mac, project_id):

def to_mac(ipv6_address):

\OpenStack\nova-2014.1\nova\ipv6\api.py

def reset_backend():

def to_global(prefix, mac, project_id):

def to_mac(ipv6_address):

\OpenStack\nova-2014.1\nova\ipv6\rfc2462.py

def to_global(prefix, mac, project_id):

def to_mac(ipv6_address):

\OpenStack\nova-2014.1\nova\ipv6\__init__.py

\OpenStack\nova-2014.1\nova\keymgr\conf_key_mgr.py

class ConfKeyManager(single_key_mgr.SingleKeyManager):

    def __init__(self):

    def _generate_hex_key(self, **kwargs):

\OpenStack\nova-2014.1\nova\keymgr\key.py

class Key(object):

    def get_algorithm(self):

    def get_format(self):

    def get_encoded(self):

class SymmetricKey(Key):

    def __init__(self, alg, key):

    def get_algorithm(self):

    def get_format(self):

    def get_encoded(self):

    def __eq__(self, other):

    def __ne__(self, other):

\OpenStack\nova-2014.1\nova\keymgr\key_mgr.py

class KeyManager(object):

    def create_key(self, ctxt, algorithm='AES', length=256, expiration=None, **kwargs):

    def store_key(self, ctxt, key, expiration=None, **kwargs):

    def copy_key(self, ctxt, key_id, **kwargs):

    def get_key(self, ctxt, key_id, **kwargs):

    def delete_key(self, ctxt, key_id, **kwargs):

\OpenStack\nova-2014.1\nova\keymgr\mock_key_mgr.py

class MockKeyManager(key_mgr.KeyManager):

    def __init__(self):

    def _generate_hex_key(self, **kwargs):

    def _generate_key(self, **kwargs):

    def create_key(self, ctxt, **kwargs):

    def _generate_key_id(self):

    def store_key(self, ctxt, key, **kwargs):

    def copy_key(self, ctxt, key_id, **kwargs):

    def get_key(self, ctxt, key_id, **kwargs):

    def delete_key(self, ctxt, key_id, **kwargs):

\OpenStack\nova-2014.1\nova\keymgr\not_implemented_key_mgr.py

class NotImplementedKeyManager(key_mgr.KeyManager):

    def create_key(self, ctxt, algorithm='AES', length=256, expiration=None, **kwargs):

    def store_key(self, ctxt, key, expiration=None, **kwargs):

    def copy_key(self, ctxt, key_id, **kwargs):

    def get_key(self, ctxt, key_id, **kwargs):

    def delete_key(self, ctxt, key_id, **kwargs):

\OpenStack\nova-2014.1\nova\keymgr\single_key_mgr.py

class SingleKeyManager(mock_key_mgr.MockKeyManager):

    def __init__(self):

    def _generate_hex_key(self, **kwargs):

    def _generate_key_id(self):

    def store_key(self, ctxt, key, **kwargs):

    def delete_key(self, ctxt, key_id, **kwargs):

\OpenStack\nova-2014.1\nova\keymgr\__init__.py

def API():

\OpenStack\nova-2014.1\nova\loadables.py

class SomeLoadableClass(object):

\OpenStack\nova-2014.1\nova\manager.py

class Manager(base.Base, periodic_task.PeriodicTasks):

    def __init__(self, host=None, db_driver=None, service_name='undefined'):

    def periodic_tasks(self, context, raise_on_error=False):

    def init_host(self):

    def cleanup_host(self):

    def pre_start_hook(self):

    def post_start_hook(self):

\OpenStack\nova-2014.1\nova\netconf.py

def _get_my_ip():

\OpenStack\nova-2014.1\nova\network\api.py

def refresh_cache(f):

 def wrapper(self, context, *args, **kwargs):

def update_instance_cache_with_nw_info(api, context, instance, nw_info=None, update_cells=True):

def wrap_check_policy(func):

 def wrapped(self, context, *args, **kwargs):

def check_policy(context, action):

OpenStack Index

Previous

Next