@

Home 

OpenStack Study: cinder

OpenStack Index

Previous

Next

    def _get_lun_geometry(self, path):

    def _get_volume_options(self, volume_name):

    def _get_vol_option(self, volume_name, option_name):

    def _move_lun(self, path, new_path):

    def _do_sub_clone_resize(self, path, new_size_bytes):

    def _post_sub_clone_resize(self, path):

    def _get_lun_block_count(self, path):

class NetAppDirectCmodeISCSIDriver(NetAppDirectISCSIDriver):

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

    def _do_custom_setup(self):

    def check_for_setup_error(self):

    def _create_lun_on_eligible_vol(self, name, size, metadata, extra_specs=None):

    def _get_avl_volumes(self, size, extra_specs=None):

    def _get_target_details(self):

    def _get_iscsi_service_details(self):

    def _create_lun_handle(self, metadata):

    def _get_lun_list(self):

    def _find_mapped_lun_igroup(self, path, initiator, os=None):

    def _get_lun_map(self, path):

    def _get_igroup_by_initiator(self, initiator):

    def _clone_lun(self, name, new_name, space_reserved='true', src_block=0, dest_block=0, block_count=0):

    def _get_lun_by_args(self, **args):

    def _create_lun_meta(self, lun):

    def _configure_tunneling(self, do_tunneling=False):

    def _update_volume_stats(self):

    def _update_cluster_vol_stats(self, data):

    def _update_stale_vols(self, volume=None, reset=False):

    def refresh_ssc_vols(self, vols):

    def delete_volume(self, volume):

class NetAppDirect7modeISCSIDriver(NetAppDirectISCSIDriver):

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

    def _do_custom_setup(self):

    def check_for_setup_error(self):

    def _create_lun_on_eligible_vol(self, name, size, metadata, extra_specs=None):

    def _get_filer_volumes(self, volume=None):

    def _get_avl_volume_by_size(self, size):

    def _get_igroup_by_initiator(self, initiator):

    def _get_target_details(self):

    def _get_iscsi_service_details(self):

    def _create_lun_handle(self, metadata):

    def _get_lun_list(self):

    def _get_vol_luns(self, vol_name):

    def _find_mapped_lun_igroup(self, path, initiator, os=None):

    def _clone_lun(self, name, new_name, space_reserved='true', src_block=0, dest_block=0, block_count=0):

    def _set_space_reserve(self, path, enable):

    def _check_clone_status(self, clone_id, vol_uuid, name, new_name):

    def _get_lun_by_args(self, **args):

    def _create_lun_meta(self, lun):

    def _update_volume_stats(self):

    def _get_lun_block_count(self, path):

    def _get_capacity_info(self, data):

    def _refresh_capacity_info(self):

    def delete_volume(self, volume):

\OpenStack\cinder-2014.1\cinder\volume\drivers\netapp\nfs.py

class NetAppNFSDriver(nfs.NfsDriver):

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

    def set_execute(self, execute):

    def do_setup(self, context):

    def check_for_setup_error(self):

    def create_volume_from_snapshot(self, volume, snapshot):

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def _get_client(self):

    def _get_volume_location(self, volume_id):

    def _clone_volume(self, volume_name, clone_name, volume_id, share=None):

    def _get_provider_location(self, volume_id):

    def _get_host_ip(self, volume_id):

    def _get_export_path(self, volume_id):

    def _volume_not_present(self, nfs_mount, volume_name):

    def _try_execute(self, *command, **kwargs):

    def _get_volume_path(self, nfs_share, volume_name):

    def create_cloned_volume(self, volume, src_vref):

    def _update_volume_stats(self):

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

    def _register_image_in_cache(self, volume, image_id):

    def _find_image_in_cache(self, image_id):

    def _do_clone_rel_img_cache(self, src, dst, share, cache_file):

        def _do_clone():

    def _spawn_clean_cache_job(self):

    def _clean_image_cache(self):

    def _shortlist_del_eligible_files(self, share, old_files):

    def _find_old_cache_files(self, share):

    def _delete_files_till_bytes_free(self, file_list, share, bytes_to_free=0):

    def _delete_file(self, path):

    def clone_image(self, volume, image_location, image_id, image_meta):

    def _clone_from_cache(self, volume, image_id, cache_result):

    def _direct_nfs_clone(self, volume, image_location, image_id):

    def _post_clone_image(self, volume):

    def _resize_image_file(self, path, new_size):

    def _is_file_size_equal(self, path, size):

    def _discover_file_till_timeout(self, path, timeout=45):

    def _is_cloneable_share(self, image_location):

    def _check_get_nfs_path_segs(self, image_location):

    def _share_match_for_ip(self, ip, shares):

    def _check_share_in_use(self, conn, dir):

    def _construct_image_nfs_url(self, image_location):

    def extend_volume(self, volume, new_size):

    def _is_share_vol_compatible(self, volume, share):

    def _check_share_can_hold_size(self, share, size):

    def _move_nfs_file(self, source_path, dest_path):

        def _move_file(src, dst):

class NetAppDirectNfsDriver (NetAppNFSDriver):

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

    def do_setup(self, context):

    def check_for_setup_error(self):

    def _check_flags(self):

    def _get_client(self):

    def _do_custom_setup(self, client):

    def _is_naelement(self, elem):

    def _get_ontapi_version(self):

    def _get_export_ip_path(self, volume_id=None, share=None):

    def _create_file_usage_req(self, path):

class NetAppDirectCmodeNfsDriver (NetAppDirectNfsDriver):

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

    def _do_custom_setup(self, client):

    def check_for_setup_error(self):

    def _invoke_successfully(self, na_element, vserver=None):

    def create_volume(self, volume):

    def _set_qos_policy_group_on_volume(self, volume, share, qos_policy_group):

    def _find_shares(self, size, extra_specs):

    def _clone_volume(self, volume_name, clone_name, volume_id, share=None):

    def _get_vserver_and_exp_vol(self, volume_id=None, share=None):

    def _get_if_info_by_ip(self, ip):

    def _get_vserver_ips(self, vserver):

    def _get_vol_by_junc_vserver(self, vserver, junction):

    def _clone_file(self, volume, src_path, dest_path, vserver=None, dest_exists=False):

    def _update_volume_stats(self):

    def _update_cluster_vol_stats(self, data):

    def _update_stale_vols(self, volume=None, reset=False):

    def refresh_ssc_vols(self, vols):

    def _ip_in_ifs(self, ip, api_ifs):

    def _shortlist_del_eligible_files(self, share, old_files):

    def _get_cluster_file_usage(self, path, vserver):

    def _share_match_for_ip(self, ip, shares):

    def _get_vserver_for_ip(self, ip):

    def _get_vol_for_share(self, nfs_share):

    def _is_share_vol_compatible(self, volume, share):

    def _is_share_vol_type_match(self, volume, share):

    def delete_volume(self, volume):

    def delete_snapshot(self, snapshot):

    def _post_prov_deprov_in_ssc(self, share):

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

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

    def _get_ip_verify_on_cluster(self, host):

    def _copy_from_cache(self, volume, image_id, cache_result):

    def _clone_file_dst_exists(self, share, src_name, dst_name, dest_exists=False):

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

class NetAppDirect7modeNfsDriver (NetAppDirectNfsDriver):

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

    def _do_custom_setup(self, client):

    def check_for_setup_error(self):

    def _invoke_successfully(self, na_element, vfiler=None):

    def _clone_volume(self, volume_name, clone_name, volume_id, share=None):

    def _get_actual_path_for_export(self, export_path):

    def _start_clone(self, src_path, dest_path):

    def _wait_for_clone_finish(self, clone_op_id, vol_uuid):

    def _clear_clone(self, clone_id):

    def _update_volume_stats(self):

    def _shortlist_del_eligible_files(self, share, old_files):

    def _get_filer_file_usage(self, path):

    def _is_filer_ip(self, ip):

    def _share_match_for_ip(self, ip, shares):

    def _is_share_vol_compatible(self, volume, share):

\OpenStack\cinder-2014.1\cinder\volume\drivers\netapp\options.py

\OpenStack\cinder-2014.1\cinder\volume\drivers\netapp\ssc_utils.py

class NetAppVolume(object):

    def __init__(self, name, vserver=None):

    def __eq__(self, other):

    def __hash__(self):

    def __cmp__(self, other):

    def __str__(self):

        def refresh_stale_ssc():

        def get_latest_ssc():

    def _spec_ineffect(b_specs, spec, opp_spec):

def check_ssc_api_permissions(na_server):

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

def provide_ems(requester, server, stats, netapp_backend, server_type="cluster"):

def validate_instantiation(**kwargs):

def invoke_api(na_server, api_name, api_family='cm', query=None, des_result=None, additional_elems=None, is_iter=False, records=0, tag=None, timeout=0, tunnel=None):

def create_api_request(api_name, query=None, des_result=None, additional_elems=None, is_iter=False, record_step=50, tag=None):

def to_bool(val):

def set_safe_attr(instance, attr, val):

def get_volume_extra_specs(volume):

def check_apis_on_cluster(na_server, api_list=[]):

def resolve_hostname(hostname):

def encode_hex_to_base32(hex_string):

def decode_base32_to_hex(base32_string):

def convert_uuid_to_es_fmt(uuid_str):

def convert_es_fmt_to_uuid(es_label):

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

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

class NexentaISCSIDriver(driver.ISCSIDriver):

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

    def backend_name(self):

    def do_setup(self, context):

    def check_for_setup_error(self):

    def _get_zvol_name(self, volume_name):

    def _get_target_name(self, volume_name):

    def _get_target_group_name(self, volume_name):

    def _get_clone_snapshot_name(volume):

    def _is_clone_snapshot_name(snapshot):

    def create_volume(self, volume):

    def extend_volume(self, volume, new_size):

    def delete_volume(self, volume):

    def create_cloned_volume(self, volume, src_vref):

    def _get_zfs_send_recv_cmd(self, src, dst):

    def get_nms_for_url(url):

    def migrate_volume(self, ctxt, volume, host):

    def create_snapshot(self, snapshot):

    def create_volume_from_snapshot(self, volume, snapshot):

    def delete_snapshot(self, snapshot):

    def local_path(self, volume):

    def _target_exists(self, target):

    def _target_group_exists(self, target_group):

    def _target_member_in_target_group(self, target_group, target_member):

    def _lu_exists(self, zvol_name):

    def _is_lu_shared(self, zvol_name):

    def _is_volume_exported(self, volume):

    def _get_provider_location(self, volume):

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

    def create_export(self, _ctx, volume):

    def ensure_export(self, _ctx, volume):

    def remove_export(self, _ctx, volume):

    def get_volume_stats(self, refresh=False):

    def _update_volume_stats(self):

\OpenStack\cinder-2014.1\cinder\volume\drivers\nexenta\jsonrpc.py

class NexentaJSONException(nexenta.NexentaException):

class NexentaJSONProxy(object):

    def __init__(self, scheme, host, port, path, user, password, auto=False, obj=None, method=None):

    def __getattr__(self, name):

    def url(self):

    def __hash__(self):

    def __repr__(self):

    def __call__(self, *args):

\OpenStack\cinder-2014.1\cinder\volume\drivers\nexenta\nfs.py

class NexentaNfsDriver(nfs.NfsDriver):

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

    def do_setup(self, context):

    def check_for_setup_error(self):

    def initialize_connection(self, volume, connector):

    def _do_create_volume(self, volume):

    def create_volume_from_snapshot(self, volume, snapshot):

    def create_cloned_volume(self, volume, src_vref):

    def delete_volume(self, volume):

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def _create_sparsed_file(self, nms, path, size):

    def _create_regular_file(self, nms, path, size):

    def _set_rw_permissions_for_all(self, nms, path):

    def local_path(self, volume):

    def _get_mount_point_for_share(self, nfs_share):

    def remote_path(self, volume):

    def _share_folder(self, nms, volume, folder):

    def _load_shares_config(self, share_file):

    def _get_capacity_info(self, nfs_share):

    def _get_nms_for_url(self, url):

    def _get_snapshot_volume(self, snapshot):

    def _get_volroot(self, nms):

    def _get_share_datasets(self, nfs_share):

    def _get_clone_snapshot_name(self, volume):

    def _is_clone_snapshot_name(self, snapshot):

\OpenStack\cinder-2014.1\cinder\volume\drivers\nexenta\options.py

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

def str2size(s, scale=1024):

def str2gib_size(s):

def get_rrmgr_cmd(src, dst, compression=None, tcp_buf_size=None, connections=None):

def parse_nms_url(url):

def get_migrate_snapshot_name(volume):

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

class NexentaException(Exception):

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

class RemoteFsDriver(driver.VolumeDriver):

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

    def check_for_setup_error(self):

    def initialize_connection(self, volume, connector):

    def _get_mount_point_base(self):

    def create_volume(self, volume):

    def _do_create_volume(self, volume):

    def _ensure_shares_mounted(self):

    def create_cloned_volume(self, volume, src_vref):

    def delete_volume(self, volume):

    def ensure_export(self, ctx, volume):

    def create_export(self, ctx, volume):

    def remove_export(self, ctx, volume):

    def delete_snapshot(self, snapshot):

    def _create_sparsed_file(self, path, size):

    def _create_regular_file(self, path, size):

    def _create_qcow2_file(self, path, size_gb):

    def _set_rw_permissions_for_all(self, path):

    def local_path(self, 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 _read_config_file(self, config_file):

    def _load_shares_config(self, share_file):

    def _get_mount_point_for_share(self, path):

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

    def get_volume_stats(self, refresh=False):

    def _update_volume_stats(self):

    def _do_mount(self, cmd, ensure, share):

    def _get_capacity_info(self, nfs_share):

    def _find_share(self, volume_size_in_gib):

    def _ensure_share_mounted(self, nfs_share):

class NfsDriver(RemoteFsDriver):

    def __init__(self, execute=putils.execute, *args, **kwargs):

    def set_execute(self, execute):

    def do_setup(self, context):

    def _ensure_share_mounted(self, nfs_share):

    def _find_share(self, volume_size_in_gib):

    def _is_share_eligible(self, nfs_share, volume_size_in_gib):

    def _get_mount_point_for_share(self, nfs_share):

    def _get_capacity_info(self, nfs_share):

    def _get_mount_point_base(self):

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

def ascii_str(string):

class RBDImageMetadata(object):

    def __init__(self, image, pool, user, conf):

class RBDImageIOWrapper(io.RawIOBase):

    def __init__(self, rbd_meta):

    def _inc_offset(self, length):

    def rbd_image(self):

    def rbd_user(self):

    def rbd_pool(self):

    def rbd_conf(self):

    def read(self, length=None):

    def write(self, data):

    def seekable(self):

    def seek(self, offset, whence=0):

    def tell(self):

    def flush(self):

    def fileno(self):

    def close(self):

class RBDVolumeProxy(object):

    def __init__(self, driver, name, pool=None, snapshot=None, read_only=False):

    def __enter__(self):

    def __exit__(self, type_, value, traceback):

    def __getattr__(self, attrib):

class RADOSClient(object):

    def __init__(self, driver, pool=None):

    def __enter__(self):

    def __exit__(self, type_, value, traceback):

class RBDDriver(driver.VolumeDriver):

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

    def check_for_setup_error(self):

    def _ceph_args(self):

    def _connect_to_rados(self, pool=None):

    def _disconnect_from_rados(self, client, ioctx):

    def _get_backup_snaps(self, rbd_image):

    def _get_mon_addrs(self):

    def _update_volume_stats(self):

    def get_volume_stats(self, refresh=False):

    def _supports_layering(self):

    def _get_clone_depth(self, client, volume_name, depth=0):

    def create_cloned_volume(self, volume, src_vref):

    def create_volume(self, volume):

    def _flatten(self, pool, volume_name):

    def _clone(self, volume, src_pool, src_image, src_snap):

    def _resize(self, volume, **kwargs):

    def create_volume_from_snapshot(self, volume, snapshot):

    def _delete_backup_snaps(self, client, volume_name):

    def _get_clone_info(self, volume, volume_name, snap=None):

    def _delete_clone_parent_refs(self, client, parent_name, parent_snap):

    def delete_volume(self, volume):

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def ensure_export(self, context, volume):

    def create_export(self, context, volume):

    def remove_export(self, context, volume):

    def initialize_connection(self, volume, connector):

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

    def _parse_location(self, location):

    def _get_fsid(self):

    def _is_cloneable(self, image_location, image_meta):

    def clone_image(self, volume, image_location, image_id, image_meta):

    def _ensure_tmp_exists(self):

    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 backup_volume(self, context, backup, backup_service):

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

    def extend_volume(self, volume, new_size):

\OpenStack\cinder-2014.1\cinder\volume\drivers\san\hp\hp_3par_common.py

class HP3PARCommon(object):

    def __init__(self, config):

    def get_version(self):

    def check_flags(self, options, required_flags):

    def _create_client(self):

    def client_login(self):

    def client_logout(self):

    def do_setup(self, context):

    def validate_cpg(self, cpg_name):

    def get_domain(self, cpg_name):

    def extend_volume(self, volume, new_size):

    def _extend_volume(self, volume, volume_name, growth_size_mib, _convert_to_base=False):

    def _get_3par_vol_name(self, volume_id):

    def _get_3par_snap_name(self, snapshot_id):

    def _get_3par_vvs_name(self, volume_id):

    def _encode_name(self, name):

    def _capacity_from_size(self, vol_size):

    def _delete_3par_host(self, hostname):

    def _create_3par_vlun(self, volume, hostname, nsp):

    def _safe_hostname(self, hostname):

    def _get_3par_host(self, hostname):

    def get_ports(self):

    def get_active_target_ports(self):

    def get_active_fc_target_ports(self):

    def get_active_iscsi_target_ports(self):

    def get_volume_stats(self, refresh):

    def _update_volume_stats(self):

    def _get_vlun(self, volume_name, hostname):

    def create_vlun(self, volume, host, nsp=None):

    def delete_vlun(self, volume, hostname):

    def _remove_hosts_naming_dict_host(self, hostname):

    def _get_volume_type(self, type_id):

    def _get_key_value(self, hp3par_keys, key, default=None):

    def _get_qos_value(self, qos, key, default=None):

    def _get_qos_by_volume_type(self, volume_type):

    def _get_keys_by_volume_type(self, volume_type):

    def _set_qos_rule(self, qos, vvs_name):

    def _add_volume_to_volume_set(self, volume, volume_name, cpg, vvs_name, qos):

    def get_cpg(self, volume, allowSnap=False):

    def _get_3par_vol_comment(self, volume_name):

    def get_persona_type(self, volume, hp3par_keys=None):

    def get_volume_settings_from_type(self, volume):

    def create_volume(self, volume):

    def _copy_volume(self, src_name, dest_name, cpg, snap_cpg=None, tpvv=True):

    def get_next_word(self, s, search_string):

    def _get_3par_vol_comment_value(self, vol_comment, key):

    def create_cloned_volume(self, volume, src_vref):

    def delete_volume(self, volume):

    def create_volume_from_snapshot(self, volume, snapshot):

    def create_snapshot(self, snapshot):

    def update_volume_key_value_pair(self, volume, key, value):

    def clear_volume_key_value_pair(self, volume, key):

    def attach_volume(self, volume, instance_uuid):

    def detach_volume(self, volume):

    def migrate_volume(self, volume, host):

    def _convert_to_base_volume(self, volume, new_cpg=None):

    def delete_snapshot(self, snapshot):

    def _get_3par_hostname_from_wwn_iqn(self, wwns, iqns):

    def terminate_connection(self, volume, hostname, wwn=None, iqn=None):

    def parse_create_host_error(self, hostname, out):

    def build_nsp(self, portPos):

    def build_portPos(self, nsp):

\OpenStack\cinder-2014.1\cinder\volume\drivers\san\hp\hp_3par_fc.py

class HP3PARFCDriver(cinder.volume.driver.FibreChannelDriver):

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

    def _init_common(self):

    def _check_flags(self):

    def get_volume_stats(self, refresh):

    def do_setup(self, context):

    def check_for_setup_error(self):

    def create_volume(self, volume):

    def create_cloned_volume(self, volume, src_vref):

    def delete_volume(self, volume):

    def create_volume_from_snapshot(self, volume, snapshot):

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def initialize_connection(self, volume, connector):

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

    def _build_initiator_target_map(self, connector):

    def _create_3par_fibrechan_host(self, hostname, wwns, domain, persona_id):

    def _modify_3par_fibrechan_host(self, hostname, wwn):

    def _create_host(self, volume, connector):

    def _add_new_wwn_to_host(self, host, wwns):

    def create_export(self, context, volume):

    def ensure_export(self, context, volume):

    def remove_export(self, context, volume):

    def extend_volume(self, volume, new_size):

    def attach_volume(self, context, volume, instance_uuid, host_name, mountpoint):

    def detach_volume(self, context, volume):

    def migrate_volume(self, context, volume, host):

\OpenStack\cinder-2014.1\cinder\volume\drivers\san\hp\hp_3par_iscsi.py

class HP3PARISCSIDriver(cinder.volume.driver.ISCSIDriver):

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

    def _init_common(self):

    def _check_flags(self):

    def get_volume_stats(self, refresh):

    def do_setup(self, context):

    def initialize_iscsi_ports(self):

    def check_for_setup_error(self):

    def create_volume(self, volume):

    def create_cloned_volume(self, volume, src_vref):

    def delete_volume(self, volume):

    def create_volume_from_snapshot(self, volume, snapshot):

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def initialize_connection(self, volume, connector):

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

    def _create_3par_iscsi_host(self, hostname, iscsi_iqn, domain, persona_id):

    def _modify_3par_iscsi_host(self, hostname, iscsi_iqn):

    def _create_host(self, volume, connector):

    def create_export(self, context, volume):

    def ensure_export(self, context, volume):

    def remove_export(self, context, volume):

    def _get_least_used_nsp_for_host(self, hostname):

    def _get_iscsi_nsps(self):

    def _get_ip_using_nsp(self, nsp):

    def _get_least_used_nsp(self, vluns, nspss):

    def extend_volume(self, volume, new_size):

    def attach_volume(self, context, volume, instance_uuid, host_name, mountpoint):

    def detach_volume(self, context, volume):

    def migrate_volume(self, context, volume, host):

\OpenStack\cinder-2014.1\cinder\volume\drivers\san\hp\hp_lefthand_cliq_proxy.py

class HPLeftHandCLIQProxy(SanISCSIDriver):

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

    def do_setup(self, context):

    def check_for_setup_error(self):

    def get_version_string(self):

    def _cliq_run(self, verb, cliq_args, check_exit_code=True):

    def _cliq_run_xml(self, verb, cliq_args, check_cliq_result=True):

    def _cliq_get_cluster_info(self, cluster_name):

    def _cliq_get_cluster_vip(self, cluster_name):

    def _cliq_get_volume_info(self, volume_name):

    def _cliq_get_snapshot_info(self, snapshot_name):

    def create_volume(self, volume):

    def extend_volume(self, volume, new_size):

    def create_volume_from_snapshot(self, volume, snapshot):

    def create_snapshot(self, snapshot):

    def delete_volume(self, volume):

    def delete_snapshot(self, snapshot):

    def local_path(self, volume):

    def initialize_connection(self, volume, connector):

    def _create_server(self, connector):

    def _get_model_update(self, volume_name):

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

    def get_volume_stats(self, refresh):

    def _update_backend_status(self):

    def create_cloned_volume(self, volume, src_vref):

    def create_export(self, context, volume):

    def ensure_export(self, context, volume):

    def remove_export(self, context, volume):

    def retype(self, context, volume, new_type, diff, host):

    def migrate_volume(self, ctxt, volume, host):

\OpenStack\cinder-2014.1\cinder\volume\drivers\san\hp\hp_lefthand_iscsi.py

class HPLeftHandISCSIDriver(VolumeDriver):

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

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

    def check_for_setup_error(self):

    def do_setup(self, context):

    def create_volume(self, volume):

    def extend_volume(self, volume, new_size):

    def create_volume_from_snapshot(self, volume, snapshot):

    def create_snapshot(self, snapshot):

    def delete_volume(self, volume):

    def delete_snapshot(self, snapshot):

    def initialize_connection(self, volume, connector):

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

    def get_volume_stats(self, refresh):

    def create_cloned_volume(self, volume, src_vref):

    def create_export(self, context, volume):

    def ensure_export(self, context, volume):

    def remove_export(self, context, volume):

    def retype(self, context, volume, new_type, diff, host):

    def migrate_volume(self, ctxt, volume, host):

\OpenStack\cinder-2014.1\cinder\volume\drivers\san\hp\hp_lefthand_rest_proxy.py

class HPLeftHandRESTProxy(ISCSIDriver):

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

    def do_setup(self, context):

    def check_for_setup_error(self):

    def get_version_string(self):

    def create_volume(self, volume):

    def delete_volume(self, volume):

    def extend_volume(self, volume, new_size):

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def get_volume_stats(self, refresh):

    def _update_backend_status(self):

    def initialize_connection(self, volume, connector):

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

    def create_volume_from_snapshot(self, volume, snapshot):

    def create_cloned_volume(self, volume, src_vref):

    def _get_volume_extra_specs(self, volume):

    def _get_lh_extra_specs(self, extra_specs, valid_keys):

    def _map_extra_specs(self, extra_specs):

    def _update_provider(self, volume_info):

    def _create_server(self, connector):

    def create_export(self, context, volume):

    def ensure_export(self, context, volume):

    def remove_export(self, context, volume):

    def retype(self, ctxt, volume, new_type, diff, host):

    def migrate_volume(self, ctxt, volume, host):

\OpenStack\cinder-2014.1\cinder\volume\drivers\san\hp\hp_msa_client.py

class HPMSAConnectionError(Exception):

class HPMSAAuthenticationError(Exception):

class HPMSARequestError(Exception):

class HPMSAClient(object):

    def __init__(self, host, login, password, protocol='http'):

    def _get_auth_token(self, xml):

    def login(self):

    def _assert_response_ok(self, tree):

    def _build_request_url(self, path, args=None, **kargs):

    def _request(self, path, args=None, **kargs):

    def logout(self):

    def create_volume(self, vdisk, name, size):

    def delete_volume(self, name):

    def extend_volume(self, name, added_size):

    def create_snapshot(self, volume_name, snap_name):

    def delete_snapshot(self, snap_name):

    def vdisk_exists(self, vdisk):

    def vdisk_stats(self, vdisk):

    def _get_first_available_lun_for_host(self, host):

    def map_volume(self, volume_name, wwpns):

    def unmap_volume(self, volume_name, wwpns):

    def get_active_target_ports(self):

    def get_active_fc_target_ports(self):

    def copy_volume(self, source_name, target_name, vdisk):

\OpenStack\cinder-2014.1\cinder\volume\drivers\san\hp\hp_msa_common.py

class HPMSACommon(object):

    def __init__(self, config):

    def get_version(self):

    def do_setup(self, context):

    def client_login(self):

    def _validate_vdisks(self):

    def client_logout(self):

    def _get_vol_name(self, volume_id):

    def _get_snap_name(self, snapshot_id):

    def _encode_name(self, name):

    def check_flags(self, options, required_flags):

    def create_volume(self, volume):

    def _assert_enough_space_for_copy(self, volume_size):

    def _assert_source_detached(self, volume):

    def create_cloned_volume(self, volume, src_vref):

    def create_volume_from_snapshot(self, volume, snapshot):

    def delete_volume(self, volume):

    def get_volume_stats(self, refresh):

    def _update_volume_stats(self):

    def _assert_connector_ok(self, connector):

    def map_volume(self, volume, connector):

    def unmap_volume(self, volume, connector):

    def get_active_fc_target_ports(self):

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def extend_volume(self, volume, new_size):

\OpenStack\cinder-2014.1\cinder\volume\drivers\san\hp\hp_msa_fc.py

class HPMSAFCDriver(cinder.volume.driver.FibreChannelDriver):

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

    def _init_common(self):

    def _check_flags(self):

    def do_setup(self, context):

    def check_for_setup_error(self):

    def create_volume(self, volume):

    def create_volume_from_snapshot(self, volume, src_vref):

    def create_cloned_volume(self, volume, src_vref):

    def delete_volume(self, volume):

    def initialize_connection(self, volume, connector):

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

    def get_volume_stats(self, refresh=False):

    def create_export(self, context, volume):

    def ensure_export(self, context, volume):

    def remove_export(self, context, volume):

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def extend_volume(self, volume, new_size):

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

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

class SanDriver(driver.VolumeDriver):

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

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

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

    def ensure_export(self, context, volume):

    def create_export(self, context, volume):

    def remove_export(self, context, volume):

    def check_for_setup_error(self):

class SanISCSIDriver(SanDriver, driver.ISCSIDriver):

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

    def _build_iscsi_target_name(self, volume):

\OpenStack\cinder-2014.1\cinder\volume\drivers\san\solaris.py

class SolarisISCSIDriver(SanISCSIDriver):

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

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

    def _view_exists(self, luid):

    def _get_target_groups(self):

    def _target_group_exists(self, target_group_name):

    def _get_target_group_members(self, target_group_name):

    def _is_target_group_member(self, target_group_name, iscsi_target_name):

    def _get_iscsi_targets(self):

    def _iscsi_target_exists(self, iscsi_target_name):

    def _build_zfs_poolname(self, volume):

    def create_volume(self, volume):

    def _get_luid(self, volume):

    def _is_lu_created(self, volume):

    def delete_volume(self, volume):

    def local_path(self, volume):

    def ensure_export(self, context, volume):

    def create_export(self, context, volume):

    def _do_export(self, volume, force_create):

    def remove_export(self, context, volume):

    def _collect_lines(self, data):

    def _get_prefixed_values(self, data, prefix):

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

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

class ScalityDriver(driver.VolumeDriver):

    def _check_prerequisites(self):

    def _makedirs(self, path):

    def _mount_sofs(self):

    def _size_bytes(self, size_in_g):

    def _create_file(self, path, size):

    def _copy_file(self, src_path, dest_path):

    def do_setup(self, context):

    def check_for_setup_error(self):

    def create_volume(self, volume):

    def create_volume_from_snapshot(self, volume, snapshot):

    def delete_volume(self, volume):

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def _sofs_path(self, volume):

    def local_path(self, volume):

    def ensure_export(self, context, volume):

    def create_export(self, context, volume):

    def remove_export(self, context, volume):

    def initialize_connection(self, volume, connector):

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

    def detach_volume(self, context, volume):

    def get_volume_stats(self, refresh=False):

    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 clone_image(self, volume, image_location, image_id, image_meta):

    def create_cloned_volume(self, volume, src_vref):

    def extend_volume(self, volume, new_size):

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

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

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

class SheepdogDriver(driver.VolumeDriver):

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

    def check_for_setup_error(self):

    def create_cloned_volume(self, volume, src_vref):

    def create_volume(self, volume):

    def create_volume_from_snapshot(self, volume, snapshot):

    def delete_volume(self, volume):

    def _ensure_dir_exists(self, tmp_dir):

    def _resize(self, volume, size=None):

    def _delete(self, volume):

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

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def local_path(self, volume):

    def ensure_export(self, context, volume):

    def create_export(self, context, volume):

    def remove_export(self, context, volume):

    def initialize_connection(self, volume, connector):

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

    def _update_volume_stats(self):

    def get_volume_stats(self, refresh=False):

    def extend_volume(self, volume, new_size):

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

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

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

class SolidFireDriver(SanISCSIDriver):

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

    def _issue_api_request(self, method_name, params, version='1.0'):

    def _get_volumes_by_sfaccount(self, account_id):

    def _get_sfaccount_by_name(self, sf_account_name):

    def _get_sf_account_name(self, project_id):

    def _get_sfaccount(self, project_id):

    def _create_sfaccount(self, project_id):

    def _get_cluster_info(self):

    def _do_export(self, volume):

    def _generate_random_string(self, length):

    def _get_model_info(self, sfaccount, sf_volume_id):

    def _do_clone_volume(self, src_uuid, src_project_id, v_ref):

    def _do_volume_create(self, project_id, params):

    def _set_qos_presets(self, volume):

    def _set_qos_by_volume_type(self, ctxt, type_id):

    def _get_sf_volume(self, uuid, params):

    def create_volume(self, volume):

    def create_cloned_volume(self, volume, src_vref):

    def delete_volume(self, volume):

    def ensure_export(self, context, volume):

    def create_export(self, context, volume):

    def delete_snapshot(self, snapshot):

    def create_snapshot(self, snapshot):

    def create_volume_from_snapshot(self, volume, snapshot):

    def get_volume_stats(self, refresh=False):

    def extend_volume(self, volume, new_size):

    def _update_cluster_status(self):

    def attach_volume(self, context, volume, instance_uuid, host_name, mountpoint):

    def detach_volume(self, context, volume):

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

    def retype(self, ctxt, volume, new_type, diff, host):

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

class Retry(object):

    def __init__(self, max_retry_count=-1, inc_sleep_time=10, max_sleep_time=60, exceptions=()):

    def __call__(self, f):

        def _func(*args, **kwargs):

        def func(*args, **kwargs):

class VMwareAPISession(object):

    def __init__(self, server_ip, server_username, server_password, api_retry_count, task_poll_interval, scheme='https', create_session=True, wsdl_loc=None, pbm_wsdl=None):

    def vim(self):

    def pbm(self):

    def create_session(self):

    def __del__(self):

    def invoke_api(self, module, method, *args, **kwargs):

        def _invoke_api(module, method, *args, **kwargs):

    def _is_current_session_active(self):

    def wait_for_task(self, task):

    def _poll_task(self, task):

    def wait_for_lease_ready(self, lease):

    def _poll_lease(self, lease):

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

class VimException(exception.CinderException):

    def __init__(self, msg):

class SessionOverLoadException(VimException):

class VimAttributeException(VimException):

class VimFaultException(exception.VolumeBackendAPIException):

    def __init__(self, fault_list, msg):

class VMwareDriverException(exception.CinderException):

class VMwaredriverConfigurationException(VMwareDriverException):

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

class ThreadSafePipe(queue.LightQueue):

    def __init__(self, maxsize, max_transfer_size):

    def read(self, chunk_size):

    def write(self, data):

    def seek(self, offset, whence=0):

    def tell(self):

    def close(self):

class GlanceWriteThread(object):

    def __init__(self, context, input_file, image_service, image_id, image_meta=None):

    def start(self):

        def _inner():

    def stop(self):

    def wait(self):

    def close(self):

class IOThread(object):

    def __init__(self, input_file, output_file):

    def start(self):

        def _inner():

    def stop(self):

    def wait(self):

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

class PBMClient(vim_module.Vim):

    def __init__(self, vimSession, pbm_wsdl, protocol='https', host='localhost'):

    def _copy_client_cookie(vimSession, pbmClient):

    def _get_vc_session_cookie(vimSession):

    def service_content(self):

    def client(self):

    def set_cookie(self):

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

class GlanceFileRead(object):

    def __init__(self, glance_read_iter):

    def read(self, chunk_size):

    def get_next(self):

    def close(self):

class VMwareHTTPFile(object):

    def __init__(self, file_handle):

    def close(self):

    def __del__(self):

    def _build_vim_cookie_headers(self, vim_cookies):

    def write(self, data):

    def read(self, chunk_size):

    def get_size(self):

    def _is_valid_ipv6(self, address):

    def get_soap_url(self, scheme, host):

    def _fix_esx_url(self, url, host):

    def find_vmdk_url(self, lease_info, host):

class VMwareHTTPWriteFile(VMwareHTTPFile):

    def __init__(self, host, data_center_name, datastore_name, cookies, file_path, file_size, scheme='https'):

    def write(self, data):

    def close(self):

class VMwareHTTPWriteVmdk(VMwareHTTPFile):

    def __init__(self, session, host, rp_ref, vm_folder_ref, vm_create_spec, vmdk_size):

    def write(self, data):

    def update_progress(self):

    def close(self):

class VMwareHTTPReadVmdk(VMwareHTTPFile):

    def __init__(self, session, host, vm_ref, vmdk_path, vmdk_size):

    def read(self, chunk_size):

    def update_progress(self):

    def close(self):

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

def get_moref(value, type):

class VIMMessagePlugin(suds.plugin.MessagePlugin):

    def addAttributeForValue(self, node):

    def marshalled(self, context):

class Vim(object):

    def __init__(self, protocol='https', host='localhost', wsdl_loc=None):

    def _get_wsdl_loc(protocol, host_name):

    def service_content(self):

    def client(self):

    def __getattr__(self, attr_name):

        def retrieve_properties_ex_fault_checker(response):

        def vim_request_handler(managed_object, **kwargs):

    def __repr__(self):

    def __str__(self):

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

def get_soap_url(protocol, host, path='sdk'):

def build_selection_spec(client_factory, name):

def build_traversal_spec(client_factory, name, type, path, skip, select_set):

def build_recursive_traversal_spec(client_factory):

def build_property_spec(client_factory, type='VirtualMachine', properties_to_collect=None, all_properties=False):

def build_object_spec(client_factory, root_folder, traversal_specs):

def build_property_filter_spec(client_factory, property_specs, object_specs):

def get_objects(vim, type, max_objects, props_to_collect=None, all_properties=False):

def get_object_properties(vim, mobj, properties):

def _get_token(retrieve_result):

def cancel_retrieval(vim, retrieve_result):

def continue_retrieval(vim, retrieve_result):

def get_object_property(vim, mobj, property_name):

def convert_datastores_to_hubs(pbm_client_factory, datastores):

def convert_hubs_to_datastores(hubs, datastores):

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

def _get_volume_type_extra_spec(type_id, spec_key, possible_values=None, default_value=None):

class VMwareEsxVmdkDriver(driver.VolumeDriver):

    def _do_deprecation_warning(self):

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

    def session(self):

    def volumeops(self):

    def do_setup(self, context):

    def check_for_setup_error(self):

    def get_volume_stats(self, refresh=False):

    def _verify_volume_creation(self, volume):

    def create_volume(self, volume):

    def _delete_volume(self, volume):

    def delete_volume(self, volume):

    def _get_volume_group_folder(self, datacenter):

    def _compute_space_utilization(self, datastore_summary):

    def _select_datastore_summary(self, size_bytes, datastores):

    def _get_storage_profile(self, volume):

    def _filter_ds_by_profile(self, datastores, storage_profile):

    def _get_folder_ds_summary(self, volume, resource_pool, datastores):

    def _get_disk_type(volume):

    def _create_backing(self, volume, host):

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

    def _select_ds_for_volume(self, volume):

    def _create_backing_in_inventory(self, volume):

    def _initialize_connection(self, volume, connector):

    def initialize_connection(self, volume, connector):

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

    def create_export(self, context, volume):

    def ensure_export(self, context, volume):

    def remove_export(self, context, volume):

    def _create_snapshot(self, snapshot):

    def create_snapshot(self, snapshot):

    def _delete_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def _create_backing_by_copying(self, volume, src_vmdk_path, src_size_in_gb):

OpenStack Index

Previous

Next