@

Home 

OpenStack Study: cinder

OpenStack Index

Previous

Next

    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 check_for_export(self, context, volume_id):

    def initialize_connection(self, volume, connector):

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

    def _build_initiator_target_map(self, storage_system, connector):

    def extend_volume(self, volume, new_size):

    def get_volume_stats(self, refresh=False):

    def update_volume_stats(self):

\OpenStack\cinder-2014.1\cinder\volume\drivers\emc\emc_smis_iscsi.py

class EMCSMISISCSIDriver(driver.ISCSIDriver):

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

    def check_for_setup_error(self):

    def 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 ensure_export(self, context, volume):

    def create_export(self, context, volume):

    def remove_export(self, context, volume):

    def check_for_export(self, context, volume_id):

    def initialize_connection(self, volume, connector):

    def _do_iscsi_discovery(self, volume):

    def smis_get_iscsi_properties(self, volume, connector):

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

    def extend_volume(self, volume, new_size):

    def get_volume_stats(self, refresh=False):

    def update_volume_stats(self):

\OpenStack\cinder-2014.1\cinder\volume\drivers\emc\emc_vnx_cli.py

class EMCVnxCli(object):

    def __init__(self, prtcl, configuration=None):

    def _cli_execute(self, *cmd, **kwargv):

    def create_volume(self, volume):

        def _wait_for_lun_ready(volumename, start_time):

    def delete_volume(self, volume):

    def extend_volume(self, volume, new_size):

    def update_volume_status(self):

    def create_export(self, context, volume):

    def _find_lun_id(self, volumename):

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

        def _wait_for_snap_delete(snapshot, start_time):

    def create_volume_from_snapshot(self, volume, snapshot):

        def _wait_for_sync_status(volumename, start_time):

    def create_cloned_volume(self, volume, src_vref):

    def get_storage_group(self, hostname):

    def find_device_details(self, volume, storage_group):

    def _get_host_lun_id(self, host_lun_id_list):

    def _add_lun_to_storagegroup(self, volume, storage_group):

    def _remove_lun_from_storagegroup(self, device_number, storage_group):

    def initialize_connection(self, volume, connector):

    def terminate_connection(self, volume, connector):

    def _find_iscsi_protocol_endpoints(self, device_sp):

    def _get_volumetype_extraspecs(self, volume):

    def _get_provisioning_by_volume(self, volume):

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

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

def with_timeout(f):

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

class DellEQLSanISCSIDriver(SanISCSIDriver):

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

    def _get_output(self, chan):

    def _get_prefixed_value(self, lines, prefix):

    def _ssh_execute(self, ssh, command, *arg, **kwargs):

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

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

    def _get_volume_data(self, lines):

    def _get_space_in_gb(self, val):

    def _update_volume_stats(self):

    def _check_volume(self, volume):

    def do_setup(self, context):

    def create_volume(self, volume):

    def delete_volume(self, volume):

    def create_snapshot(self, snapshot):

    def create_volume_from_snapshot(self, volume, snapshot):

    def create_cloned_volume(self, volume, src_vref):

    def delete_snapshot(self, snapshot):

    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 extend_volume(self, volume, new_size):

    def local_path(self, volume):

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

class GlusterfsDriver(nfs.RemoteFsDriver):

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

    def set_execute(self, execute):

    def do_setup(self, context):

    def check_for_setup_error(self):

    def _local_volume_dir(self, volume):

    def _local_path_volume(self, volume):

    def _local_path_volume_info(self, volume):

    def _qemu_img_info(self, path):

    def get_active_image_from_info(self, volume):

    def create_cloned_volume(self, volume, src_vref):

    def create_volume(self, volume):

    def create_volume_from_snapshot(self, volume, snapshot):

    def _copy_volume_from_snapshot(self, snapshot, volume, volume_size):

    def delete_volume(self, volume):

    def create_snapshot(self, snapshot):

    def _create_snapshot(self, snapshot):

    def _create_qcow2_snap_file(self, snapshot, backing_filename, new_snap_path):

    def _create_snapshot_offline(self, snapshot, path_to_disk):

    def _read_file(self, filename):

    def _read_info_file(self, info_path, empty_if_missing=False):

    def _write_info_file(self, info_path, snap_info):

    def _get_matching_backing_file(self, backing_chain, snapshot_file):

    def delete_snapshot(self, snapshot):

    def _delete_snapshot(self, snapshot):

    def _delete_snapshot_online(self, context, snapshot, info):

    def _get_backing_chain_for_path(self, volume, path):

    def _qemu_img_commit(self, path):

    def ensure_export(self, ctx, volume):

    def create_export(self, ctx, volume):

    def remove_export(self, ctx, volume):

    def validate_connector(self, connector):

    def initialize_connection(self, volume, connector):

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

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

    def extend_volume(self, volume, size_gb):

    def _do_create_volume(self, volume):

    def _ensure_shares_mounted(self):

    def _ensure_share_writable(self, path):

    def _ensure_share_mounted(self, glusterfs_share):

    def _find_share(self, volume_size_for):

    def _get_hash_str(self, base_str):

    def _get_mount_point_for_share(self, glusterfs_share):

    def _get_available_capacity(self, glusterfs_share):

    def _get_capacity_info(self, glusterfs_share):

    def _mount_glusterfs(self, glusterfs_share, mount_path, ensure=False):

    def _get_mount_point_base(self):

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

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

def factory_bend():

def _loc_info(loc):

def _do_lu_range_check(start, end, maxlun):

def _xml_read(root, element, check=None):

def _read_config(xml_config_file):

class HUSDriver(driver.ISCSIDriver):

    def _array_info_get(self):

    def _get_iscsi_info(self):

    def _get_service(self, volume):

    def _get_stats(self):

    def _get_hdp_list(self):

    def _check_hdp_list(self):

    def _id_to_vol(self, idd):

    def _update_vol_location(self, id, loc):

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

    def check_for_setup_error(self):

    def do_setup(self, context):

    def ensure_export(self, context, volume):

    def create_export(self, context, volume):

    def create_volume(self, volume):

    def create_cloned_volume(self, dst, src):

    def extend_volume(self, volume, new_size):

    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 create_volume_from_snapshot(self, volume, snapshot):

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def get_volume_stats(self, refresh=False):

\OpenStack\cinder-2014.1\cinder\volume\drivers\hds\hus_backend.py

class HusBackend:

    def get_version(self, cmd, ver, ip0, ip1, user, pw):

    def get_iscsi_info(self, cmd, ver, ip0, ip1, user, pw):

    def get_hdp_info(self, cmd, ver, ip0, ip1, user, pw):

    def create_lu(self, cmd, ver, ip0, ip1, user, pw, id, hdp, start, end, size):

    def delete_lu(self, cmd, ver, ip0, ip1, user, pw, id, lun):

    def create_dup(self, cmd, ver, ip0, ip1, user, pw, id, src_lun, hdp, start, end, size):

    def extend_vol(self, cmd, ver, ip0, ip1, user, pw, id, lun, new_size):

    def add_iscsi_conn(self, cmd, ver, ip0, ip1, user, pw, id, lun, ctl, port, iqn, initiator):

    def del_iscsi_conn(self, cmd, ver, ip0, ip1, user, pw, id, lun, ctl, port, iqn, initiator):

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

\OpenStack\cinder-2014.1\cinder\volume\drivers\huawei\huawei_dorado.py

class HuaweiDoradoISCSIDriver(huawei_t.HuaweiTISCSIDriver):

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

    def do_setup(self, context):

class HuaweiDoradoFCDriver(huawei_t.HuaweiTFCDriver):

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

    def do_setup(self, context):

    def _get_host_port_details(self, hostid):

    def _get_tgt_fc_port_wwns(self, port_details):

    def initialize_connection(self, volume, connector):

\OpenStack\cinder-2014.1\cinder\volume\drivers\huawei\huawei_hvs.py

class HuaweiHVSISCSIDriver(driver.ISCSIDriver):

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

    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 create_cloned_volume(self, volume, src_vref):

    def extend_volume(self, volume, new_size):

    def delete_volume(self, volume):

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def get_volume_stats(self, refresh=False):

    def initialize_connection(self, volume, connector):

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

    def create_export(self, context, volume):

    def ensure_export(self, context, volume):

    def remove_export(self, context, volume):

class HuaweiHVSFCDriver(driver.FibreChannelDriver):

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

    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 create_cloned_volume(self, volume, src_vref):

    def extend_volume(self, volume, new_size):

    def delete_volume(self, volume):

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def get_volume_stats(self, refresh=False):

    def initialize_connection(self, volume, connector):

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

    def create_export(self, context, volume):

    def ensure_export(self, context, volume):

    def remove_export(self, context, volume):

\OpenStack\cinder-2014.1\cinder\volume\drivers\huawei\huawei_t.py

class HuaweiTISCSIDriver(driver.ISCSIDriver):

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

    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 create_cloned_volume(self, volume, src_vref):

    def extend_volume(self, volume, new_size):

    def delete_volume(self, volume):

    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 initialize_connection(self, volume, connector):

    def _get_iscsi_params(self, initiator):

    def _get_iscsi_conf(self, filename):

    def _get_tgt_iqn(self, port_ip):

    def _get_iscsi_tgt_port_info(self, port_ip):

    def _add_iscsi_port_to_host(self, hostid, connector, multipathtype=0):

    def _initiator_added(self, ininame):

    def _add_initiator(self, ininame):

    def _delete_initiator(self, ininame, attempts=2):

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

    def _remove_iscsi_port(self, hostid, connector):

    def get_volume_stats(self, refresh=False):

class HuaweiTFCDriver(driver.FibreChannelDriver):

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

    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 create_cloned_volume(self, volume, src_vref):

    def extend_volume(self, volume, new_size):

    def delete_volume(self, volume):

    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 validate_connector(self, connector):

    def initialize_connection(self, volume, connector):

    def _get_connected_free_wwns(self):

    def _add_fc_port_to_host(self, hostid, wwn, multipathtype=0):

    def _get_host_port_details(self, host_id):

    def _get_tgt_fc_port_wwns(self, port_details):

    def _get_fc_port_ctr(self, port_details):

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

    def _remove_fc_ports(self, hostid, connector):

    def get_volume_stats(self, refresh=False):

\OpenStack\cinder-2014.1\cinder\volume\drivers\huawei\huawei_utils.py

def parse_xml_file(filepath):

def get_xml_item(xml_root, item):

def is_xml_item_exist(xml_root, item, attrib_key=None):

def is_xml_item_valid(xml_root, item, valid_list, attrib_key=None):

def get_conf_host_os_type(host_ip, config):

\OpenStack\cinder-2014.1\cinder\volume\drivers\huawei\rest_common.py

class HVSCommon():

    def __init__(self, configuration):

    def call(self, url=False, data=None, method=None):

    def login(self):

    def _init_tier_parameters(self, parameters, lunparam):

    def _init_lun_parameters(self, name, parameters):

    def _init_qos_parameters(self, parameters, lun_param):

    def _assert_rest_result(self, result, err_str):

    def _assert_data_in_result(self, result, msg):

    def _create_volume(self, lun_param):

    def create_volume(self, volume):

    def _get_volume_size(self, poolinfo, volume):

    def delete_volume(self, volume):

    def _delete_lun_from_qos_policy(self, volume, lun_id):

    def _delete_lun(self, lun_id):

    def _encode_name(self, name):

    def _find_pool_info(self):

    def _get_volume_by_name(self, name):

    def _active_snapshot(self, snapshot_id):

    def _create_snapshot(self, snapshot):

    def create_snapshot(self, snapshot):

    def _stop_snapshot(self, snapshot):

    def _delete_snapshot(self, snapshotid):

    def delete_snapshot(self, snapshot):

    def _get_snapshotid_by_name(self, name):

    def _copy_volume(self, volume, copy_name, src_lun, tgt_lun):

    def create_volume_from_snapshot(self, volume, snapshot):

    def create_cloned_volume(self, volume, src_vref):

    def _create_luncopy(self, luncopyname, srclunid, tgtlunid):

    def _add_host_into_hostgroup(self, host_name, host_ip):

    def _mapping_hostgroup_and_lungroup(self, volume_name, hostgroup_id, host_id):

    def _ensure_initiator_added(self, initiator_name, hostid):

    def initialize_connection_iscsi(self, volume, connector):

    def initialize_connection_fc(self, volume, connector):

    def _get_iscsi_tgt_port(self):

    def _find_hostgroup(self, groupname):

    def _find_lungroup(self, lungroupname):

    def _create_hostgroup(self, hostgroupname):

    def _create_lungroup(self, lungroupname):

    def _delete_lungroup(self, lungroupid):

    def _lungroup_associated(self, viewid, lungroupid):

    def _hostgroup_associated(self, viewid, hostgroupid):

    def _find_host_lun_id(self, hostid, lunid):

    def _find_host(self, hostname):

    def _add_host(self, hostname, type):

    def _associate_host_to_hostgroup(self, hostgroupid, hostid):

    def _associate_lun_to_lungroup(self, lungroupid, lunid):

    def _delete_associated_lun_from_lungroup(self, lungroupid, lunid):

    def _initiator_is_added_to_array(self, ininame):

    def _is_initiator_associated_to_host(self, ininame):

    def _add_initiator_to_array(self, ininame):

    def _associate_initiator_to_host(self, ininame, hostid):

    def _find_mapping_view(self, name):

    def _add_mapping_view(self, name, host_id):

    def _associate_hostgroup_to_view(self, viewID, hostGroupID):

    def _associate_lungroup_to_view(self, viewID, lunGroupID):

    def _delete_lungroup_mapping_view(self, view_id, lungroup_id):

    def _delete_hostgoup_mapping_view(self, view_id, hostgroup_id):

    def _delete_mapping_view(self, view_id):

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

    def login_out(self):

    def _start_luncopy(self, luncopyid):

    def _get_capacity(self):

    def _get_lun_conf_params(self):

    def _wait_for_luncopy(self, luncopyid):

    def _get_luncopy_info(self, luncopyid):

    def _delete_luncopy(self, luncopyid):

    def _get_connected_free_wwns(self):

    def _add_fc_port_to_host(self, hostid, wwn, multipathtype=0):

    def _get_iscsi_port_info(self, ip):

    def _get_iscsi_conf(self):

    def _get_tgt_iqn(self, iscsiip):

    def _get_fc_target_wwpns(self, wwn):

    def _parse_volume_type(self, volume):

    def update_volume_stats(self, refresh=False):

    def _find_qos_policy_info(self, policy_name):

    def _update_qos_policy_lunlist(self, lunlist, policy_id):

    def _get_login_info(self):

    def _change_file_mode(self, filepath):

    def _check_conf_file(self):

    def _get_iscsi_params(self, connector):

    def extend_volume(self, volume, new_size):

\OpenStack\cinder-2014.1\cinder\volume\drivers\huawei\ssh_common.py

def ssh_read(user, channel, cmd, timeout):

class TseriesCommon():

    def __init__(self, configuration=None):

    def do_setup(self, context):

    def _check_conf_file(self):

    def _get_login_info(self):

    def _change_file_mode(self, filepath):

    def _get_lun_distribution_info(self, luns):

    def check_for_setup_error(self):

    def _get_all_luncopy_name(self):

    def _get_extended_lun(self, luns):

    def create_volume(self, volume):

    def _name_translate(self, name):

    def _update_login_info(self):

    def _parse_volume_type(self, typeid):

    def _create_volume(self, name, size, params):

    def _calculate_lun_ctr(self):

    def _update_lun_distribution(self, ctr):

    def _get_lun_params(self):

    def _parse_conf_lun_params(self):

    def _get_maximum_capacity_pool_id(self, pools_conf, pools_dev, luntype):

    def _execute_cli(self, cmd):

    def _reset_transport_timeout(self, ssh, time):

    def delete_volume(self, volume):

    def _check_volume_created(self, volume_id):

    def _del_lun_from_extended_lun(self, extended_id, added_ids):

    def _delete_volume(self, volumeid):

    def create_volume_from_snapshot(self, volume, snapshot):

    def _copy_volume(self, src_vol_id, tgt_vol_id):

    def _create_luncopy(self, luncopyname, srclunid, tgtlunid):

    def _start_luncopy(self, luncopyid):

    def _wait_for_luncopy(self, luncopyname):

    def _get_luncopy_info(self, luncopyname):

    def _delete_luncopy(self, luncopyid):

    def create_cloned_volume(self, tgt_volume, src_volume):

    def _get_all_luns_info(self):

    def _get_lun_id(self, lun_name):

    def extend_volume(self, volume, new_size):

    def _extend_volume(self, extended_vol_id, added_vol_id):

    def create_snapshot(self, snapshot):

    def _resource_pool_enough(self):

    def _create_snapshot(self, snapshotname, srclunid):

    def _get_snapshot_id(self, snapshotname):

    def _active_snapshot(self, snapshotid):

    def delete_snapshot(self, snapshot):

    def _check_snapshot_created(self, snapshot_id):

    def _snapshot_in_luncopy(self, snapshot_id):

    def _delete_snapshot(self, snapshotid):

    def _assert_cli_out(self, condition, func, msg, cmd, cliout):

    def _assert_cli_operate_out(self, func, msg, cmd, cliout):

    def map_volume(self, host_id, volume_id):

    def add_host(self, host_name, host_ip, initiator=None):

    def _get_hostgroup_id(self, groupname):

    def _create_hostgroup(self, hostgroupname):

    def _get_host_id(self, hostname, hostgroupid):

    def _create_host(self, hostname, hostgroupid, type):

    def _get_host_port_info(self, hostid):

    def _get_host_map_info(self, hostid):

    def get_lun_details(self, lun_id):

    def change_lun_ctr(self, lun_id, ctr):

    def remove_map(self, volume_id, host_name, initiator=None):

    def _delete_map(self, mapid, attempts=2):

    def _delete_hostport(self, portid):

    def _delete_host(self, hostid):

    def get_volume_stats(self, refresh=False):

    def _update_volume_stats(self):

    def _get_free_capacity(self):

    def _get_dev_pool_info(self, pooltype):

class DoradoCommon(TseriesCommon):

    def __init__(self, configuration=None):

    def do_setup(self, context):

    def _check_conf_file(self):

    def _get_device_type(self):

    def _get_lun_distribution_info(self, luns):

    def _get_extended_lun(self, luns):

    def _create_volume(self, name, size, params):

    def _get_lun_id(self, name):

    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_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def _get_lun_params(self):

    def _parse_conf_lun_params(self):

    def _get_free_capacity(self):

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

class HuaweiVolumeDriver(object):

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

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

    def _get_conf_info(self, filename):

    def __setattr__(self, name, value):

    def __getattr__(self, name):

\OpenStack\cinder-2014.1\cinder\volume\drivers\ibm\gpfs.py

def _different(difference_tuple):

def _same_filesystem(path1, path2):

def _sizestr(size_in_g):

class GPFSDriver(driver.VolumeDriver):

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

    def _get_gpfs_state(self):

    def _check_gpfs_state(self):

    def _get_filesystem_from_path(self, path):

    def _get_gpfs_cluster_id(self):

    def _get_fileset_from_path(self, path):

    def _verify_gpfs_pool(self, storage_pool):

    def _update_volume_storage_pool(self, local_path, new_pool):

    def _get_gpfs_fs_release_level(self, path):

    def _get_gpfs_cluster_release_level(self):

    def _is_gpfs_path(self, directory):

    def _is_same_fileset(self, path1, path2):

    def _same_cluster(self, host):

    def _set_rw_permission(self, path, modebits='660'):

    def _can_migrate_locally(self, host):

    def do_setup(self, ctxt):

    def check_for_setup_error(self):

    def _create_sparse_file(self, path, size):

    def _allocate_file_blocks(self, path, size):

    def _gpfs_change_attributes(self, options, path):

    def _set_volume_attributes(self, path, metadata):

    def create_volume(self, volume):

    def create_volume_from_snapshot(self, volume, snapshot):

    def create_cloned_volume(self, volume, src_vref):

    def _delete_gpfs_file(self, fchild):

    def delete_volume(self, volume):

    def _gpfs_redirect(self, src):

    def _create_gpfs_clone(self, src, dest):

    def _create_gpfs_copy(self, src, dest):

    def _create_gpfs_snap(self, src, dest=None):

    def _is_gpfs_parent_file(self, gpfs_file):

    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 get_volume_stats(self, refresh=False):

    def _update_volume_stats(self):

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

    def _is_cloneable(self, image_id):

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

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

    def _resize_volume_file(self, volume, new_size):

    def extend_volume(self, volume, new_size):

    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 _migrate_volume(self, volume, host):

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

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

    def _mkfs(self, volume, filesystem, label=None):

    def _get_available_capacity(self, path):

    def _verify_gpfs_path_state(self, path):

\OpenStack\cinder-2014.1\cinder\volume\drivers\ibm\ibmnas.py

class IBMNAS_NFSDriver(nfs.NfsDriver, san.SanDriver):

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

    def set_execute(self, execute):

    def do_setup(self, context):

    def check_for_setup_error(self):

    def _get_provider_location(self, volume_id):

    def _get_export_path(self, volume_id):

    def _update_volume_stats(self):

    def _create_ibmnas_snap(self, src, dest, mount_path):

    def _create_ibmnas_copy(self, src, dest, snap):

    def _resize_volume_file(self, path, new_size):

    def extend_volume(self, volume, new_size):

    def _delete_snapfiles(self, fchild, mount_point):

    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):

\OpenStack\cinder-2014.1\cinder\volume\drivers\ibm\storwize_svc\helpers.py

class StorwizeHelpers(object):

    def __init__(self, run_ssh):

    def handle_keyerror(cmd, out):

    def compression_enabled(self):

    def get_system_info(self):

    def get_pool_attrs(self, pool):

    def get_available_io_groups(self):

    def get_node_info(self):

    def add_iscsi_ip_addrs(self, storage_nodes):

    def add_fc_wwpns(self, storage_nodes):

    def add_chap_secret_to_host(self, host_name):

    def get_chap_secret_for_host(self, host_name):

    def get_conn_fc_wwpns(self, host):

    def get_host_from_connector(self, connector):

    def create_host(self, connector):

    def delete_host(self, host_name):

    def map_vol_to_host(self, volume_name, host_name, multihostmap):

    def unmap_vol_from_host(self, volume_name, host_name):

    def build_default_opts(config):

    def check_vdisk_opts(state, opts):

    def get_vdisk_params(self, config, state, type_id, volume_type=None):

    def _get_vdisk_create_params(opts):

    def create_vdisk(self, name, size, units, pool, opts):

    def get_vdisk_attributes(self, vdisk):

    def is_vdisk_defined(self, vdisk_name):

    def _prepare_fc_map(self, fc_map_id, timeout):

    def run_flashcopy(self, source, target, timeout, full_copy=True):

    def _get_vdisk_fc_mappings(self, vdisk):

    def _get_flashcopy_mapping_attributes(self, fc_map_id):

    def _check_vdisk_fc_mappings(self, name, allow_snaps=True):

    def ensure_vdisk_no_fc_mappings(self, name, allow_snaps=True):

    def delete_vdisk(self, vdisk, force):

    def create_copy(self, src, tgt, src_id, config, opts, full_copy):

    def extend_vdisk(self, vdisk, amount):

    def add_vdisk_copy(self, vdisk, dest_pool, volume_type, state, config):

    def is_vdisk_copy_synced(self, vdisk, copy_id):

    def rm_vdisk_copy(self, vdisk, copy_id):

    def can_migrate_to_host(host, state):

    def change_vdisk_options(self, vdisk, changes, opts, state):

    def change_vdisk_iogrp(self, vdisk, state, iogrp):

    def vdisk_by_uid(self, vdisk_uid):

    def is_vdisk_in_use(self, vdisk):

    def rename_vdisk(self, vdisk, new_name):

\OpenStack\cinder-2014.1\cinder\volume\drivers\ibm\storwize_svc\ssh.py

class StorwizeSSH(object):

    def __init__(self, run_ssh):

    def _run_ssh(self, ssh_cmd):

    def run_ssh_info(self, ssh_cmd, delim='!', with_header=False):

    def run_ssh_assert_no_output(self, ssh_cmd):

    def run_ssh_check_created(self, ssh_cmd):

    def lsnode(self, node_id=None):

    def lslicense(self):

    def lssystem(self):

    def lsmdiskgrp(self, pool):

    def lsiogrp(self):

    def lsportip(self):

    def _create_port_arg(port_type, port_name):

    def mkhost(self, host_name, port_type, port_name):

    def addhostport(self, host, port_type, port_name):

    def lshost(self, host=None):

    def add_chap_secret(self, secret, host):

    def lsiscsiauth(self):

    def lsfabric(self, wwpn=None, host=None):

    def mkvdiskhostmap(self, host, vdisk, lun, multihostmap):

    def rmvdiskhostmap(self, host, vdisk):

    def lsvdiskhostmap(self, vdisk):

    def lshostvdiskmap(self, host):

    def rmhost(self, host):

    def mkvdisk(self, name, size, units, pool, opts, params):

    def rmvdisk(self, vdisk, force=True):

    def lsvdisk(self, vdisk):

    def lsvdisks_from_filter(self, filter_name, value):

    def chvdisk(self, vdisk, params):

    def movevdisk(self, vdisk, iogrp):

    def expandvdisksize(self, vdisk, amount):

    def mkfcmap(self, source, target, full_copy):

    def prestartfcmap(self, fc_map_id):

    def startfcmap(self, fc_map_id):

    def chfcmap(self, fc_map_id, copyrate='50', autodel='on'):

    def stopfcmap(self, fc_map_id):

    def rmfcmap(self, fc_map_id):

    def lsvdiskfcmappings(self, vdisk):

    def lsfcmap(self, fc_map_id):

    def addvdiskcopy(self, vdisk, dest_pool, params):

    def lsvdiskcopy(self, vdisk, copy_id=None):

    def rmvdiskcopy(self, vdisk, copy_id):

    def addvdiskaccess(self, vdisk, iogrp):

    def rmvdiskaccess(self, vdisk, iogrp):

class CLIResponse(object):

    def __init__(self, raw, ssh_cmd=None, delim='!', with_header=True):

    def select(self, *keys):

    def __getitem__(self, key):

    def __iter__(self):

    def __len__(self):

    def _parse(self):

        def get_reader(content, delim):

    def append_dict(dict_, key, value):

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

class StorwizeSVCDriver(san.SanDriver):

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

    def do_setup(self, ctxt):

    def check_for_setup_error(self):

    def ensure_export(self, ctxt, volume):

    def create_export(self, ctxt, volume):

    def remove_export(self, ctxt, volume):

    def validate_connector(self, connector):

    def _get_vdisk_params(self, type_id, volume_type=None):

    def initialize_connection(self, volume, connector):

    def _make_initiator_target_map(self, initiator_wwpns, target_wwpns):

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

    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, tgt_volume, src_volume):

    def extend_volume(self, volume, new_size):

    def _add_vdisk_copy_op(self, ctxt, volume, new_op):

    def _rm_vdisk_copy_op(self, ctxt, volume, orig_copy_id, new_copy_id):

    def _check_volume_copy_ops(self):

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

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

    def manage_existing(self, volume, ref):

    def manage_existing_get_size(self, volume, ref):

    def get_volume_stats(self, refresh=False):

    def _update_volume_stats(self):

\OpenStack\cinder-2014.1\cinder\volume\drivers\ibm\xiv_ds8k.py

class XIVDS8KDriver(san.SanDriver):

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

    def do_setup(self, context):

    def ensure_export(self, context, volume):

    def create_export(self, context, volume):

    def create_volume(self, 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 create_volume_from_snapshot(self, volume, snapshot):

    def create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def get_volume_stats(self, refresh=False):

    def create_cloned_volume(self, tgt_volume, src_volume):

    def extend_volume(self, volume, new_size):

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

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

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

class LVMVolumeDriver(driver.VolumeDriver):

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

    def set_execute(self, execute):

    def check_for_setup_error(self):

    def _sizestr(self, size_in_g):

    def _volume_not_present(self, volume_name):

    def _delete_volume(self, volume, is_snapshot=False):

    def _clear_volume(self, volume, is_snapshot=False):

    def _escape_snapshot(self, snapshot_name):

    def _create_volume(self, name, size, lvm_type, mirror_count, vg=None):

    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 local_path(self, volume, vg=None):

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

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

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

    def get_volume_stats(self, refresh=False):

    def _update_volume_stats(self):

    def extend_volume(self, volume, new_size):

    def manage_existing(self, volume, existing_ref):

    def manage_existing_get_size(self, volume, existing_ref):

class LVMISCSIDriver(LVMVolumeDriver, driver.ISCSIDriver):

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

    def set_execute(self, execute):

    def _create_target(self, iscsi_name, iscsi_target, volume_path, chap_auth, lun=0, check_exit_code=False, old_name=None):

    def ensure_export(self, context, volume):

    def create_export(self, context, volume):

    def _create_export(self, context, volume, vg=None):

    def remove_export(self, context, volume):

    def migrate_volume(self, ctxt, volume, host, thin=False, mirror_count=0):

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

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

class LVMISERDriver(LVMISCSIDriver, driver.ISERDriver):

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

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

class NaServer(object):

    def __init__(self, host, server_type=SERVER_TYPE_FILER, transport_type=TRANSPORT_TYPE_HTTP, style=STYLE_LOGIN_PASSWORD, username=None, password=None):

    def get_transport_type(self):

    def set_transport_type(self, transport_type):

    def get_style(self):

    def set_style(self, style):

    def get_server_type(self):

    def set_server_type(self, server_type):

    def set_api_version(self, major, minor):

    def get_api_version(self):

    def set_port(self, port):

    def get_port(self):

    def set_timeout(self, seconds):

    def get_timeout(self):

    def get_vfiler(self):

    def set_vfiler(self, vfiler):

    def get_vserver(self):

    def set_vserver(self, vserver):

    def set_username(self, username):

    def set_password(self, password):

    def invoke_elem(self, na_element, enable_tunneling=False):

    def invoke_successfully(self, na_element, enable_tunneling=False):

    def _create_request(self, na_element, enable_tunneling=False):

    def _enable_tunnel_request(self, netapp_elem):

    def _parse_response(self, response):

    def _get_result(self, response):

    def _get_url(self):

    def _build_opener(self):

    def _create_basic_auth_handler(self):

    def _create_certificate_auth_handler(self):

    def __str__(self):

class NaElement(object):

    def __init__(self, name):

    def get_name(self):

    def set_content(self, text):

    def get_content(self):

    def add_attr(self, name, value):

    def add_attrs(self, **attrs):

    def add_child_elem(self, na_element):

    def get_child_by_name(self, name):

    def get_child_content(self, name):

    def get_children(self):

    def has_attr(self, name):

    def get_attr(self, name):

    def get_attr_names(self):

    def add_new_child(self, name, content, convert=False):

    def _convert_entity_refs(text):

    def create_node_with_children(node, **children):

    def add_node_with_children(self, node, **children):

    def to_string(self, pretty=False, method='xml', encoding='UTF-8'):

    def __getitem__(self, key):

    def __setitem__(self, key, value):

    def translate_struct(self, data_struct):

class NaApiError(Exception):

    def __init__(self, code='unknown', message='unknown'):

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

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

class NetAppDriver(object):

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

    def __setattr__(self, name, value):

    def __getattr__(self, name):

class NetAppDriverFactory(object):

    def create_driver( storage_family, storage_protocol, *args, **kwargs):

    def check_netapp_driver(location):

class Deprecated(driver.VolumeDriver):

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

    def _log_deprecated_warn(self):

    def check_for_setup_error(self):

    def ensure_export(self, context, volume):

    def get_volume_stats(self, refresh=False):

\OpenStack\cinder-2014.1\cinder\volume\drivers\netapp\eseries\client.py

class WebserviceClient(object):

    def __init__(self, scheme, host, port, service_path, username, password, **kwargs):

    def _validate_params(self, scheme, host, port):

    def _create_endpoint(self, scheme, host, port, service_path):

    def _init_connection(self):

    def invoke_service(self, method='GET', url=None, params=None, data=None, headers=None, timeout=None, verify=False):

    def _eval_response(self, response):

class RestClient(WebserviceClient):

    def __init__(self, scheme, host, port, service_path, username, password, **kwargs):

    def set_system_id(self, system_id):

    def get_system_id(self):

    def _get_resource_url(self, path, use_system=True, **kwargs):

    def _invoke(self, method, path, data=None, use_system=True, timeout=None, verify=False, **kwargs):

    def _eval_response(self, response):

    def create_volume(self, pool, label, size, unit='gb', seg_size=0):

    def delete_volume(self, object_id):

    def list_volumes(self):

    def list_volume(self, object_id):

    def update_volume(self, object_id, label):

    def get_volume_mappings(self):

    def create_volume_mapping(self, object_id, target_id, lun):

    def delete_volume_mapping(self, map_object_id):

    def list_hardware_inventory(self):

    def list_hosts(self):

    def create_host(self, label, host_type, ports=None, group_id=None):

    def create_host_with_port(self, label, host_type, port_id, port_label, port_type='iscsi', group_id=None):

    def list_host_types(self):

    def list_snapshot_groups(self):

    def create_snapshot_group(self, label, object_id, storage_pool_id, repo_percent=99, warn_thres=99, auto_del_limit=0, full_policy='failbasewrites'):

    def delete_snapshot_group(self, object_id):

    def create_snapshot_image(self, group_id):

    def delete_snapshot_image(self, object_id):

    def list_snapshot_images(self):

    def create_snapshot_volume(self, image_id, label, base_object_id, storage_pool_id, repo_percent=99, full_thres=99, view_mode='readOnly'):

    def delete_snapshot_volume(self, object_id):

    def list_storage_pools(self):

    def list_storage_systems(self):

    def list_storage_system(self):

    def register_storage_system(self, controller_addresses, password=None, wwn=None):

    def update_stored_system_password(self, password):

    def create_volume_copy_job(self, src_id, tgt_id, priority='priority4', tgt_wrt_protected='true'):

    def control_volume_copy_job(self, obj_id, control='start'):

    def list_vol_copy_job(self, object_id):

    def delete_vol_copy_job(self, object_id):

\OpenStack\cinder-2014.1\cinder\volume\drivers\netapp\eseries\iscsi.py

class Driver(driver.ISCSIDriver):

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

    def do_setup(self, context):

    def _check_flags(self):

    def check_for_setup_error(self):

    def _check_mode_get_or_register_storage_system(self):

        def _resolve_host(host):

    def _check_storage_system(self):

    def _populate_system_objects(self):

    def _cache_allowed_disk_pool_refs(self):

    def _cache_volume(self, obj):

    def _cache_snap_grp(self, obj):

    def _cache_snap_img(self, image):

    def _cache_vol_mapping(self, mapping):

    def _del_volume_frm_cache(self, label):

    def _del_snapshot_frm_cache(self, obj_name):

    def _del_vol_mapping_frm_cache(self, mapping):

    def _get_volume(self, uid):

    def _get_cached_volume(self, label):

    def _get_cached_snapshot_grp(self, uid):

    def _get_cached_snap_grp_image(self, uid):

    def _is_volume_containing_snaps(self, label):

    def create_volume(self, volume):

    def _create_volume(self, label, size_gb):

    def _get_sorted_avl_storage_pools(self, size_gb):

    def create_volume_from_snapshot(self, volume, snapshot):

    def _create_snapshot_volume(self, snapshot_id):

    def _copy_volume_high_prior_readonly(self, src_vol, dst_vol):

    def create_cloned_volume(self, volume, src_vref):

    def delete_volume(self, volume):

    def _delete_volume(self, label):

    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 _get_iscsi_service_details(self):

    def _map_volume_to_host(self, vol, initiator):

    def _get_or_create_host(self, port_id, host_type='linux'):

    def _get_host_with_port(self, port_id, host_type='linux'):

    def _create_host(self, port_id, host_type='linux'):

    def _get_host_type_definition(self, host_type='linux'):

    def _get_free_lun(self, host):

    def _get_vol_mapping_for_host_frm_array(self, host_ref):

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

    def _get_cached_vol_mapping_for_host(self, volume, host):

    def get_volume_stats(self, refresh=False):

    def _update_volume_stats(self):

    def _update_capacity(self):

    def extend_volume(self, volume, new_size):

    def _garbage_collect_tmp_vols(self):

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

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

class NetAppLun(object):

    def __init__(self, handle, name, size, metadata_dict):

    def get_metadata_property(self, prop):

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

class NetAppDirectISCSIDriver(driver.ISCSIDriver):

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

    def _create_client(self, **kwargs):

    def _do_custom_setup(self):

    def _check_flags(self):

    def do_setup(self, context):

    def check_for_setup_error(self):

    def create_volume(self, volume):

    def delete_volume(self, volume):

    def _destroy_lun(self, path, force=True):

    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 create_snapshot(self, snapshot):

    def delete_snapshot(self, snapshot):

    def create_volume_from_snapshot(self, volume, snapshot):

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

    def _get_ontapi_version(self):

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

    def create_lun(self, volume, lun, size, metadata, qos_policy_group=None):

    def _get_iscsi_service_details(self):

    def _get_target_details(self):

    def _create_lun_handle(self, metadata):

    def _get_lun_list(self):

    def _extract_and_populate_luns(self, api_luns):

    def _is_naelement(self, elem):

    def _map_lun(self, name, initiator, initiator_type='iscsi', lun_id=None):

    def _unmap_lun(self, path, initiator):

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

    def _get_or_create_igroup(self, initiator, initiator_type='iscsi', os='default'):

    def _get_igroup_by_initiator(self, initiator):

    def _check_allowed_os(self, os):

    def _create_igroup(self, igroup, igroup_type='iscsi', os_type='default'):

    def _add_igroup_initiator(self, igroup, initiator):

    def _add_lun_to_table(self, lun):

    def _get_lun_from_table(self, name):

    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 _get_lun_attr(self, name, attr):

    def _create_lun_meta(self, lun):

    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):

    def _do_direct_resize(self, path, new_size_bytes, force=True):

OpenStack Index

Previous

Next