@

Home 

OpenStack Study:

OpenStack Index

Previous

Next

    def _create_cloned_volume(self, volume, src_vref):

    def create_cloned_volume(self, volume, src_vref):

    def _create_volume_from_snapshot(self, volume, snapshot):

    def create_volume_from_snapshot(self, volume, snapshot):

    def _get_ds_name_flat_vmdk_path(self, backing, vol_name):

    def _validate_disk_format(disk_format):

    def _fetch_flat_image(self, context, volume, image_service, image_id, image_size):

    def _fetch_stream_optimized_image(self, context, volume, image_service, image_id, image_size):

    def _extend_vmdk_virtual_disk(self, name, new_size_in_gb):

    def _extend_volumeops_virtual_disk(self, new_size_in_gb, root_vmdk_path, datacenter):

    def copy_image_to_volume(self, context, volume, image_service, image_id):

    def copy_volume_to_image(self, context, volume, image_service, image_meta):

    def extend_volume(self, volume, new_size):

class VMwareVcVmdkDriver(VMwareEsxVmdkDriver):

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

    def session(self):

    def _get_pbm_wsdl_location(self, vc_version):

    def _get_vc_version(self):

    def do_setup(self, context):

    def _get_volume_group_folder(self, datacenter):

    def _relocate_backing(self, volume, backing, host):

    def _get_clone_type(volume):

    def _clone_backing(self, volume, backing, snapshot, clone_type, src_vsize):

    def _create_volume_from_snapshot(self, volume, snapshot):

    def create_volume_from_snapshot(self, volume, snapshot):

    def _create_cloned_volume(self, volume, src_vref):

    def create_cloned_volume(self, volume, src_vref):

\OpenStack\cinder-2014.1\cinder\volume\drivers\vmware\vmware_images.py

def start_transfer(context, timeout_secs, read_file_handle, max_data_size, write_file_handle=None, image_service=None, image_id=None, image_meta=None):

def fetch_flat_image(context, timeout_secs, image_service, image_id, **kwargs):

def fetch_stream_optimized_image(context, timeout_secs, image_service, image_id, **kwargs):

def upload_image(context, timeout_secs, image_service, image_id, owner_id, **kwargs):

\OpenStack\cinder-2014.1\cinder\volume\drivers\vmware\volumeops.py

def split_datastore_path(datastore_path):

class VMwareVolumeOps(object):

    def __init__(self, session, max_objects):

    def get_backing(self, name):

    def delete_backing(self, backing):

    def get_host(self, instance):

    def get_hosts(self):

    def continue_retrieval(self, retrieve_result):

    def cancel_retrieval(self, retrieve_result):

    def _is_usable(self, datastore, mount_info):

    def get_connected_hosts(self, datastore):

    def _is_valid(self, datastore, host):

    def get_dss_rp(self, host):

    def _get_parent(self, child, parent_type):

    def get_dc(self, child):

    def get_vmfolder(self, datacenter):

    def create_folder(self, parent_folder, child_folder_name):

    def extend_virtual_disk(self, requested_size_in_gb, name, dc_ref, eager_zero=False):

    def _get_create_spec(self, name, size_kb, disk_type, ds_name, profileId=None):

    def create_backing(self, name, size_kb, disk_type, folder, resource_pool, host, ds_name, profileId=None):

    def get_datastore(self, backing):

    def get_summary(self, datastore):

    def _get_relocate_spec(self, datastore, resource_pool, host, disk_move_type):

    def relocate_backing(self, backing, datastore, resource_pool, host):

    def move_backing_to_folder(self, backing, folder):

    def create_snapshot(self, backing, name, description, quiesce=False):

    def _get_snapshot_from_tree(name, root):

    def get_snapshot(self, backing, name):

    def delete_snapshot(self, backing, name):

    def _get_folder(self, backing):

    def _get_clone_spec(self, datastore, disk_move_type, snapshot):

    def clone_backing(self, name, backing, snapshot, clone_type, datastore):

    def delete_file(self, file_path, datacenter=None):

    def get_path_name(self, backing):

    def get_entity_name(self, entity):

    def get_vmdk_path(self, backing):

    def copy_vmdk_file(self, dc_ref, src_vmdk_file_path, dest_vmdk_file_path):

    def delete_vmdk_file(self, vmdk_file_path, dc_ref):

    def get_all_profiles(self):

    def retrieve_profile_id(self, profile_name):

    def filter_matching_hubs(self, hubs, profile_id):

\OpenStack\cinder-2014.1\cinder\volume\drivers\vmware\__init__.py

\OpenStack\cinder-2014.1\cinder\volume\drivers\windows\windows.py

class WindowsDriver(driver.ISCSIDriver):

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

    def do_setup(self, context):

    def check_for_setup_error(self):

    def initialize_connection(self, volume, connector):

    def terminate_connection(self, volume, connector, **kwargs):

    def create_volume(self, volume):

    def local_path(self, volume):

    def delete_volume(self, volume):

    def create_snapshot(self, snapshot):

    def create_volume_from_snapshot(self, volume, snapshot):

    def delete_snapshot(self, snapshot):

    def _do_export(self, _ctx, volume, ensure=False):

    def ensure_export(self, context, volume):

    def create_export(self, context, volume):

    def remove_export(self, context, volume):

    def copy_image_to_volume(self, context, volume, image_service, image_id):

    def copy_volume_to_image(self, context, volume, image_service, image_meta):

    def create_cloned_volume(self, volume, src_vref):

    def get_volume_stats(self, refresh=False):

    def _update_volume_stats(self):

    def extend_volume(self, volume, new_size):

\OpenStack\cinder-2014.1\cinder\volume\drivers\windows\windows_utils.py

class WindowsUtils(object):

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

    def check_for_setup_error(self):

    def get_host_information(self, volume, target_name):

    def associate_initiator_with_iscsi_target(self, initiator_name, target_name):

    def delete_iscsi_target(self, initiator_name, target_name):

    def create_volume(self, vhd_path, vol_name, vol_size):

    def delete_volume(self, vol_name, vhd_path):

    def create_snapshot(self, vol_name, snapshot_name):

    def create_volume_from_snapshot(self, vol_name, snap_name):

    def delete_snapshot(self, snap_name):

    def create_iscsi_target(self, target_name, ensure):

    def remove_iscsi_target(self, target_name):

    def add_disk_to_target(self, vol_name, target_name):

    def copy_vhd_disk(self, source_path, destination_path):

    def extend(self, vol_name, additional_size):

\OpenStack\cinder-2014.1\cinder\volume\drivers\windows\__init__.py

\OpenStack\cinder-2014.1\cinder\volume\drivers\xenapi\lib.py

class XenAPIException(Exception):

    def __init__(self, original_exception):

class OperationsBase(object):

    def __init__(self, xenapi_session):

    def call_xenapi(self, method, *args):

class VMOperations(OperationsBase):

    def get_by_uuid(self, vm_uuid):

    def get_vbds(self, vm_uuid):

class VBDOperations(OperationsBase):

    def create(self, vm_ref, vdi_ref, userdevice, bootable, mode, type, empty, other_config):

    def destroy(self, vbd_ref):

    def get_device(self, vbd_ref):

    def plug(self, vbd_ref):

    def unplug(self, vbd_ref):

    def get_vdi(self, vbd_ref):

class PoolOperations(OperationsBase):

    def get_all(self):

    def get_default_SR(self, pool_ref):

class PbdOperations(OperationsBase):

    def get_all(self):

    def unplug(self, pbd_ref):

    def create(self, host_ref, sr_ref, device_config):

    def plug(self, pbd_ref):

class SrOperations(OperationsBase):

    def get_all(self):

    def get_record(self, sr_ref):

    def forget(self, sr_ref):

    def scan(self, sr_ref):

    def create(self, host_ref, device_config, name_label, name_description, sr_type, physical_size=None, content_type=None, shared=False, sm_config=None):

    def introduce(self, sr_uuid, name_label, name_description, sr_type, content_type=None, shared=False, sm_config=None):

    def get_uuid(self, sr_ref):

    def get_name_label(self, sr_ref):

    def get_name_description(self, sr_ref):

    def destroy(self, sr_ref):

class VdiOperations(OperationsBase):

    def get_all(self):

    def get_record(self, vdi_ref):

    def get_by_uuid(self, vdi_uuid):

    def get_uuid(self, vdi_ref):

    def create(self, sr_ref, size, vdi_type, sharable=False, read_only=False, other_config=None):

    def destroy(self, vdi_ref):

    def copy(self, vdi_ref, sr_ref):

    def resize(self, vdi_ref, size):

class HostOperations(OperationsBase):

    def get_record(self, host_ref):

    def get_uuid(self, host_ref):

class XenAPISession(object):

    def __init__(self, session, exception_to_convert):

    def close(self):

    def exception_converter(self):

    def call_xenapi(self, method, *args):

    def call_plugin(self, host_ref, plugin, function, args):

    def get_pool(self):

    def get_this_host(self):

class CompoundOperations(object):

    def unplug_pbds_from_sr(self, sr_ref):

    def unplug_pbds_and_forget_sr(self, sr_ref):

    def create_new_vdi(self, sr_ref, size_in_gigabytes):

def to_bytes(size_in_gigs):

class NFSOperationsMixIn(CompoundOperations):

    def is_nfs_sr(self, sr_ref):

    def new_sr_on_nfs(self, host_ref, server, serverpath, name_label=None, name_description=None):

    def plug_nfs_sr(self, host_ref, server, serverpath, sr_uuid, name_label=None, name_description=None):

    def connect_volume(self, server, serverpath, sr_uuid, vdi_uuid):

    def copy_vdi_to_sr(self, vdi_ref, sr_ref):

class ContextAwareSession(XenAPISession):

    def __enter__(self):

    def __exit__(self, exc_type, exc_value, traceback):

class OpenStackXenAPISession(ContextAwareSession, NFSOperationsMixIn):

def connect(url, user, password):

class SessionFactory(object):

    def __init__(self, url, user, password):

    def get_session(self):

class XapiPluginProxy(object):

    def __init__(self, session_factory, plugin_name):

    def call(self, function, *plugin_args, **plugin_kwargs):

class GlancePluginProxy(XapiPluginProxy):

    def __init__(self, session_factory):

    def download_vhd(self, image_id, glance_host, glance_port, glance_use_ssl, uuid_stack, sr_path, auth_token):

    def upload_vhd(self, vdi_uuids, image_id, glance_host, glance_port, glance_use_ssl, sr_path, auth_token, properties):

class NFSBasedVolumeOperations(object):

    def __init__(self, session_factory):

    def create_volume(self, server, serverpath, size, name=None, description=None):

    def delete_volume(self, server, serverpath, sr_uuid, vdi_uuid):

    def connect_volume(self, server, serverpath, sr_uuid, vdi_uuid):

    def disconnect_volume(self, vdi_uuid):

    def copy_volume(self, server, serverpath, sr_uuid, vdi_uuid, name=None, description=None):

    def resize_volume(self, server, serverpath, sr_uuid, vdi_uuid, size_in_gigabytes):

    def use_glance_plugin_to_overwrite_volume(self, server, serverpath, sr_uuid, vdi_uuid, glance_server, image_id, auth_token, sr_base_path):

    def use_glance_plugin_to_upload_volume(self, server, serverpath, sr_uuid, vdi_uuid, glance_server, image_id, auth_token, sr_base_path):

    def volume_attached_here(self, server, serverpath, sr_uuid, vdi_uuid, readonly=True):

\OpenStack\cinder-2014.1\cinder\volume\drivers\xenapi\sm.py

class XenAPINFSDriver(driver.VolumeDriver):

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

    def do_setup(self, context):

    def create_cloned_volume(self, volume, src_vref):

    def create_volume(self, volume):

    def create_export(self, context, volume):

    def delete_volume(self, volume):

    def remove_export(self, context, volume):

    def initialize_connection(self, volume, connector):

    def terminate_connection(self, volume, connector, **kwargs):

    def check_for_setup_error(self):

    def create_volume_from_snapshot(self, volume, snapshot):

    def create_snapshot(self, snapshot):

    def _copy_volume(self, volume, target_name, target_desc):

    def delete_snapshot(self, snapshot):

    def ensure_export(self, context, volume):

    def copy_image_to_volume(self, context, volume, image_service, image_id):

    def _use_image_utils_to_pipe_bytes_to_volume(self, context, volume, image_service, image_id):

    def _use_glance_plugin_to_copy_image_to_volume(self, context, volume, image_service, image_id):

    def copy_volume_to_image(self, context, volume, image_service, image_meta):

    def _use_image_utils_to_upload_volume(self, context, volume, image_service, image_meta):

    def _use_glance_plugin_to_upload_volume(self, context, volume, image_service, image_meta):

    def get_volume_stats(self, refresh=False):

    def backup_volume(self, context, backup, backup_service):

    def restore_backup(self, context, backup, volume, backup_service):

\OpenStack\cinder-2014.1\cinder\volume\drivers\xenapi\tools.py

def get_this_vm_uuid():

\OpenStack\cinder-2014.1\cinder\volume\drivers\xenapi\__init__.py

\OpenStack\cinder-2014.1\cinder\volume\drivers\zadara.py

class ZadaraVPSAConnection(object):

    def __init__(self, conf):

    def _generate_vpsa_cmd(self, cmd, **kwargs):

        def _joined_params(params):

    def ensure_connection(self, cmd=None):

    def send_cmd(self, cmd, **kwargs):

class ZadaraVPSAISCSIDriver(driver.ISCSIDriver):

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

    def do_setup(self, context):

    def check_for_setup_error(self):

    def local_path(self, volume):

    def _xml_parse_helper(self, xml_tree, first_level, search_tuple, first=True):

    def _get_vpsa_volume_name_and_size(self, name):

    def _get_vpsa_volume_name(self, name):

    def _get_volume_cg_name(self, name):

    def _get_snap_id(self, cg_name, snap_name):

    def _get_pool_capacity(self, pool_name):

    def _get_active_controller_details(self):

    def _get_server_name(self, initiator):

    def _create_vpsa_server(self, initiator):

    def create_volume(self, volume):

    def delete_volume(self, volume):

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def create_volume_from_snapshot(self, volume, snapshot):

    def create_cloned_volume(self, volume, src_vref):

    def extend_volume(self, volume, new_size):

    def create_export(self, context, volume):

    def ensure_export(self, context, volume):

    def remove_export(self, context, volume):

    def initialize_connection(self, volume, connector):

    def terminate_connection(self, volume, connector, **kwargs):

    def get_volume_stats(self, refresh=False):

    def _update_volume_stats(self):

\OpenStack\cinder-2014.1\cinder\volume\drivers\__init__.py

\OpenStack\cinder-2014.1\cinder\volume\flows\api\create_volume.py

class ExtractVolumeRequestTask(flow_utils.CinderTask):

    def __init__(self, image_service, az_check_functor=None, **kwargs):

    def _extract_snapshot(snapshot):

    def _extract_source_volume(source_volume):

    def _extract_size(size, source_volume, snapshot):

        def validate_snap_size(size):

        def validate_source_size(size):

        def validate_int(size):

    def _check_image_metadata(self, context, image_id, size):

    def _check_metadata_properties(metadata=None):

    def _extract_availability_zone(self, availability_zone, snapshot, source_volume):

    def _get_encryption_key_id(self, key_manager, context, volume_type_id, snapshot, source_volume, backup_source_volume):

    def _get_volume_type_id(self, volume_type, source_volume, snapshot, backup_source_volume):

    def execute(self, context, size, snapshot, image_id, source_volume, availability_zone, volume_type, metadata, key_manager, backup_source_volume):

class EntryCreateTask(flow_utils.CinderTask):

    def __init__(self, db):

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

    def revert(self, context, result, **kwargs):

class QuotaReserveTask(flow_utils.CinderTask):

    def __init__(self):

    def execute(self, context, size, volume_type_id):

    def revert(self, context, result, **kwargs):

class QuotaCommitTask(flow_utils.CinderTask):

    def __init__(self):

    def execute(self, context, reservations, volume_properties):

    def revert(self, context, result, **kwargs):

class VolumeCastTask(flow_utils.CinderTask):

    def __init__(self, scheduler_rpcapi, volume_rpcapi, db):

    def _cast_create_volume(self, context, request_spec, filter_properties):

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

    def revert(self, context, result, flow_failures, **kwargs):

def get_flow(scheduler_rpcapi, volume_rpcapi, db, image_service, az_check_functor, create_what):

\OpenStack\cinder-2014.1\cinder\volume\flows\api\__init__.py

\OpenStack\cinder-2014.1\cinder\volume\flows\common.py

def make_pretty_name(method):

def restore_source_status(context, db, volume_spec):

def error_out_volume(context, db, volume_id, reason=None):

\OpenStack\cinder-2014.1\cinder\volume\flows\manager\create_volume.py

class OnFailureRescheduleTask(flow_utils.CinderTask):

    def __init__(self, reschedule_context, db, scheduler_rpcapi):

    def execute(self, **kwargs):

    def _reschedule(self, context, cause, request_spec, filter_properties, snapshot_id, image_id, volume_id, **kwargs):

    def _post_reschedule(self, context, volume_id):

    def _pre_reschedule(self, context, volume_id):

    def revert(self, context, result, flow_failures, **kwargs):

class ExtractVolumeRefTask(flow_utils.CinderTask):

    def __init__(self, db, host):

    def execute(self, context, volume_id):

    def revert(self, context, volume_id, result, **kwargs):

class ExtractVolumeSpecTask(flow_utils.CinderTask):

    def __init__(self, db):

    def execute(self, context, volume_ref, **kwargs):

    def revert(self, context, result, **kwargs):

class NotifyVolumeActionTask(flow_utils.CinderTask):

    def __init__(self, db, event_suffix):

    def execute(self, context, volume_ref):

class CreateVolumeFromSpecTask(flow_utils.CinderTask):

    def __init__(self, db, driver):

    def _handle_bootable_volume_glance_meta(self, context, volume_id, **kwargs):

    def _create_from_snapshot(self, context, volume_ref, snapshot_id, **kwargs):

    def _enable_bootable_flag(self, context, volume_id):

    def _create_from_source_volume(self, context, volume_ref, source_volid, **kwargs):

    def _copy_image_to_volume(self, context, volume_ref, image_id, image_location, image_service):

    def _capture_volume_image_metadata(self, context, volume_id, image_id, image_meta):

    def _create_from_image(self, context, volume_ref, image_location, image_id, image_meta, image_service, **kwargs):

    def _create_raw_volume(self, context, volume_ref, **kwargs):

    def execute(self, context, volume_ref, volume_spec):

class CreateVolumeOnFinishTask(NotifyVolumeActionTask):

    def __init__(self, db, event_suffix):

    def execute(self, context, volume, volume_spec):

def get_flow(context, db, driver, scheduler_rpcapi, host, volume_id, allow_reschedule, reschedule_context, request_spec, filter_properties, snapshot_id=None, image_id=None, source_volid=None):

\OpenStack\cinder-2014.1\cinder\volume\flows\manager\manage_existing.py

class PrepareForQuotaReservationTask(flow_utils.CinderTask):

    def __init__(self, db, driver):

    def execute(self, context, volume_ref, manage_existing_ref):

class ManageExistingTask(flow_utils.CinderTask):

    def __init__(self, db, driver):

    def execute(self, context, volume_ref, manage_existing_ref, size):

def get_flow(context, db, driver, host, volume_id, ref):

\OpenStack\cinder-2014.1\cinder\volume\flows\manager\__init__.py

\OpenStack\cinder-2014.1\cinder\volume\flows\__init__.py

\OpenStack\cinder-2014.1\cinder\volume\iscsi.py

class _ExportMixin(object):

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

    def create_export(self, context, volume, volume_path):

    def remove_export(self, context, volume):

    def ensure_export(self, context, volume, iscsi_name, volume_path, old_name=None):

    def _ensure_iscsi_targets(self, context, host):

    def _get_target_for_ensure_export(self, context, volume_id):

    def _get_target_and_lun(self, context, volume):

    def _get_iscsi_target(self, context, vol_id):

    def _iscsi_authentication(self, chap, name, password):

    def _iscsi_location(self, ip, target, iqn, lun=None):

    def _fix_id_migration(self, context, volume):

class TgtAdm(_ExportMixin, iscsi.TgtAdm):

    def _get_target_and_lun(self, context, volume):

    def _get_iscsi_target(self, context, vol_id):

    def _get_target_for_ensure_export(self, context, volume_id):

class FakeIscsiHelper(_ExportMixin, iscsi.FakeIscsiHelper):

    def create_export(self, context, volume, volume_path):

    def remove_export(self, context, volume):

    def ensure_export(self, context, volume_id, iscsi_name, volume_path, old_name=None):

class LioAdm(_ExportMixin, iscsi.LioAdm):

    def remove_export(self, context, volume):

    def ensure_export(self, context, volume_id, iscsi_name, volume_path, old_name=None):

class IetAdm(_ExportMixin, iscsi.IetAdm):

class ISERTgtAdm(_ExportMixin, iscsi.ISERTgtAdm):

\OpenStack\cinder-2014.1\cinder\volume\manager.py

def locked_volume_operation(f):

 def lvo_inner1(inst, context, volume_id, **kwargs):

def locked_snapshot_operation(f):

 def lso_inner1(inst, context, snapshot_id, **kwargs):

class VolumeManager(manager.SchedulerDependentManager):

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

    def _add_to_threadpool(self, func, *args, **kwargs):

    def init_host(self):

    def create_volume(self, context, volume_id, request_spec=None, filter_properties=None, allow_reschedule=True, snapshot_id=None, image_id=None, source_volid=None):

        def _run_flow():

        def _run_flow_locked():

    def delete_volume(self, context, volume_id, unmanage_only=False):

    def create_snapshot(self, context, volume_id, snapshot_id):

    def delete_snapshot(self, context, snapshot_id):

    def attach_volume(self, context, volume_id, instance_uuid, host_name, mountpoint, mode):

        def do_attach():

    def detach_volume(self, context, volume_id):

    def copy_volume_to_image(self, context, volume_id, image_meta):

    def initialize_connection(self, context, volume_id, connector):

    def terminate_connection(self, context, volume_id, connector, force=False):

    def accept_transfer(self, context, volume_id, new_user, new_project):

    def _migrate_volume_generic(self, ctxt, volume, host, new_type_id):

    def _get_original_status(self, volume):

    def migrate_volume_completion(self, ctxt, volume_id, new_volume_id, error=False):

    def migrate_volume(self, ctxt, volume_id, host, force_host_copy=False, new_type_id=None):

    def _report_driver_status(self, context):

    def publish_service_capabilities(self, context):

    def notification(self, context, event):

    def _notify_about_volume_usage(self, context, volume, event_suffix, extra_usage_info=None):

    def _notify_about_snapshot_usage(self, context, snapshot, event_suffix, extra_usage_info=None):

    def extend_volume(self, context, volume_id, new_size, reservations):

    def retype(self, ctxt, volume_id, new_type_id, host, migration_policy='never', reservations=None):

        def _retype_error(context, volume_id, old_reservations, new_reservations, status_update):

    def manage_existing(self, ctxt, volume_id, ref=None):

    def _add_or_delete_fc_connection(self, conn_info, zone_op):

\OpenStack\cinder-2014.1\cinder\volume\qos_specs.py

def _verify_prepare_qos_specs(specs, create=True):

def create(context, name, specs=None):

def update(context, qos_specs_id, specs):

def delete(context, qos_specs_id, force=False):

def delete_keys(context, qos_specs_id, keys):

def get_associations(context, specs_id):

def associate_qos_with_type(context, specs_id, type_id):

def disassociate_qos_specs(context, specs_id, type_id):

def disassociate_all(context, specs_id):

def get_all_specs(context, inactive=False, search_opts={}):

def get_qos_specs(ctxt, id):

def get_qos_specs_by_name(context, name):

\OpenStack\cinder-2014.1\cinder\volume\rpcapi.py

class VolumeAPI(object):

    def __init__(self, topic=None):

    def create_volume(self, ctxt, volume, host, request_spec, filter_properties, allow_reschedule=True, snapshot_id=None, image_id=None, source_volid=None):

    def delete_volume(self, ctxt, volume, unmanage_only=False):

    def create_snapshot(self, ctxt, volume, snapshot):

    def delete_snapshot(self, ctxt, snapshot, host):

    def attach_volume(self, ctxt, volume, instance_uuid, host_name, mountpoint, mode):

    def detach_volume(self, ctxt, volume):

    def copy_volume_to_image(self, ctxt, volume, image_meta):

    def initialize_connection(self, ctxt, volume, connector):

    def terminate_connection(self, ctxt, volume, connector, force=False):

    def publish_service_capabilities(self, ctxt):

    def accept_transfer(self, ctxt, volume, new_user, new_project):

    def extend_volume(self, ctxt, volume, new_size, reservations):

    def migrate_volume(self, ctxt, volume, dest_host, force_host_copy):

    def migrate_volume_completion(self, ctxt, volume, new_volume, error):

    def retype(self, ctxt, volume, new_type_id, dest_host, migration_policy='never', reservations=None):

    def manage_existing(self, ctxt, volume, ref):

\OpenStack\cinder-2014.1\cinder\volume\utils.py

def null_safe_str(s):

def _usage_from_volume(context, volume_ref, **kw):

def notify_about_volume_usage(context, volume, event_suffix, extra_usage_info=None, host=None):

def _usage_from_snapshot(context, snapshot_ref, **extra_usage_info):

def notify_about_snapshot_usage(context, snapshot, event_suffix, extra_usage_info=None, host=None):

def _calculate_count(size_in_m, blocksize):

def copy_volume(srcstr, deststr, size_in_m, blocksize, sync=False, execute=utils.execute, ionice=None):

def clear_volume(volume_size, volume_path, volume_clear=None, volume_clear_size=None, volume_clear_ionice=None):

def supports_thin_provisioning():

def get_all_volumes(vg_name=None):

def get_all_physical_volumes(vg_name=None):

def get_all_volume_groups(vg_name=None):

\OpenStack\cinder-2014.1\cinder\volume\volume_types.py

def create(context, name, extra_specs={}):

def destroy(context, id):

def get_all_types(context, inactive=0, search_opts={}):

def get_volume_type(ctxt, id):

def get_volume_type_by_name(context, name):

def get_default_volume_type():

def get_volume_type_extra_specs(volume_type_id, key=False):

def is_encrypted(context, volume_type_id):

def get_volume_type_encryption(context, volume_type_id):

def get_volume_type_qos_specs(volume_type_id):

def volume_types_diff(context, vol_type_id1, vol_type_id2):

\OpenStack\cinder-2014.1\cinder\volume\__init__.py

\OpenStack\cinder-2014.1\cinder\wsgi.py

class Server(object):

    def __init__(self, name, app, host=None, port=None, pool_size=None, protocol=eventlet.wsgi.HttpProtocol, backlog=128):

    def _get_socket(self, host, port, backlog):

        def wrap_ssl(sock):

    def _start(self):

    def start(self, backlog=128):

    def host(self):

    def port(self):

    def stop(self):

    def wait(self):

class Request(webob.Request):

class Application(object):

    def factory(cls, global_config, **local_config):

    def __call__(self, environ, start_response):

        def __call__(self, req):

class Middleware(Application):

    def factory(cls, global_config, **local_config):

        def _factory(app):

    def __init__(self, application):

    def process_request(self, req):

    def process_response(self, response):

    def __call__(self, req):

class Debug(Middleware):

    def __call__(self, req):

    def print_generator(app_iter):

class Router(object):

    def __init__(self, mapper):

    def __call__(self, req):

    def _dispatch(req):

class Loader(object):

    def __init__(self, config_path=None):

    def load_app(self, name):

\OpenStack\cinder-2014.1\cinder\zonemanager\drivers\brocade\brcd_fabric_opts.py

def load_fabric_configurations(fabric_names):

\OpenStack\cinder-2014.1\cinder\zonemanager\drivers\brocade\brcd_fc_san_lookup_service.py

class BrcdFCSanLookupService(FCSanLookupService):

    def __init__(self, **kwargs):

    def create_configuration(self):

    def get_device_mapping_from_network(self, initiator_wwn_list, target_wwn_list):

    def get_nameserver_info(self):

    def close_connection(self):

    def _get_switch_data(self, cmd):

    def _parse_ns_output(self, switch_data):

    def get_formatted_wwn(self, wwn_str):

\OpenStack\cinder-2014.1\cinder\zonemanager\drivers\brocade\brcd_fc_zone_client_cli.py

class BrcdFCZoneClientCLI(object):

    def __init__(self, ipaddress, username, password, port):

    def get_active_zone_set(self):

    def add_zones(self, zones, activate):

    def activate_zoneset(self, cfgname):

    def deactivate_zoneset(self):

    def delete_zones(self, zone_names, activate):

    def get_nameserver_info(self):

    def _cfg_save(self):

    def _zone_delete(self, zone_name):

    def _cfg_trans_abort(self):

    def _is_trans_abortable(self):

    def apply_zone_change(self, cmd_list):

    def is_supported_firmware(self):

    def _get_switch_info(self, cmd_list):

    def _parse_ns_output(self, switch_data):

    def _run_ssh(self, cmd_list, check_exit_code=True, attempts=1):

    def _ssh_execute(self, cmd_list, check_exit_code=True, attempts=1):

    def _execute_shell_cmd(self, cmd):

    def cleanup(self):

\OpenStack\cinder-2014.1\cinder\zonemanager\drivers\brocade\brcd_fc_zone_driver.py

class BrcdFCZoneDriver(FCZoneDriver):

    def __init__(self, **kwargs):

    def get_formatted_wwn(self, wwn_str):

    def add_connection(self, fabric, initiator_target_map):

    def delete_connection(self, fabric, initiator_target_map):

    def get_san_context(self, target_wwn_list):

    def get_active_zone_set(self, fabric_ip, fabric_user, fabric_pwd, fabric_port):

\OpenStack\cinder-2014.1\cinder\zonemanager\drivers\brocade\fc_zone_constants.py

\OpenStack\cinder-2014.1\cinder\zonemanager\drivers\brocade\__init__.py

\OpenStack\cinder-2014.1\cinder\zonemanager\drivers\fc_zone_driver.py

class FCZoneDriver(fc_common.FCCommon):

    def __init__(self, **kwargs):

    def add_connection(self, fabric, initiator_target_map):

    def delete_connection(self, fabric, initiator_target_map):

    def get_san_context(self, target_wwn_list):

\OpenStack\cinder-2014.1\cinder\zonemanager\drivers\__init__.py

\OpenStack\cinder-2014.1\cinder\zonemanager\fc_common.py

class FCCommon(object):

    def __init__(self, **kwargs):

    def get_version(self):

\OpenStack\cinder-2014.1\cinder\zonemanager\fc_san_lookup_service.py

class FCSanLookupService(fc_common.FCCommon):

    def __init__(self, **kwargs):

    def get_device_mapping_from_network(self, initiator_list, target_list):

\OpenStack\cinder-2014.1\cinder\zonemanager\fc_zone_manager.py

class ZoneManager(fc_common.FCCommon):

    def __init__(self, **kwargs):

    def get_zoning_state_ref_count(self, initiator_wwn, target_wwn):

    def add_connection(self, initiator_target_map):

    def delete_connection(self, initiator_target_map):

    def get_san_context(self, target_wwn_list):

    def get_valid_initiator_target_map(self, initiator_target_map, add_control):

\OpenStack\cinder-2014.1\cinder\zonemanager\__init__.py

\OpenStack\cinder-2014.1\cinder\__init__.py