2395 lines
60 KiB
Python
2395 lines
60 KiB
Python
from ostack_validator.schema import ConfigSchemaRegistry
|
|
|
|
cinder = ConfigSchemaRegistry.register_schema(project='cinder')
|
|
|
|
cinder.version('2013.1.3')
|
|
|
|
cinder.param('', type='string', default='', description="")
|
|
|
|
cinder.param('', type='string', default='', description="cinder.conf sample")
|
|
|
|
cinder.section('DEFAULT')
|
|
|
|
cinder.param(
|
|
'fatal_exception_format_errors',
|
|
type='boolean',
|
|
default='false',
|
|
description="make exception message format errors fatal")
|
|
|
|
cinder.param(
|
|
'policy_file',
|
|
type='string',
|
|
default='policy.json',
|
|
description="JSON file representing policy")
|
|
|
|
cinder.param(
|
|
'policy_default_rule',
|
|
type='string',
|
|
default='default',
|
|
description="Rule checked when requested rule is not found")
|
|
|
|
cinder.param(
|
|
'quota_volumes',
|
|
type='integer',
|
|
default='10',
|
|
description="number of volumes allowed per project")
|
|
|
|
cinder.param(
|
|
'quota_snapshots',
|
|
type='integer',
|
|
default='10',
|
|
description="number of volume snapshots allowed per project")
|
|
|
|
cinder.param(
|
|
'quota_gigabytes',
|
|
type='integer',
|
|
default='1000',
|
|
description="number of volume gigabytes")
|
|
|
|
cinder.param(
|
|
'reservation_expire',
|
|
type='integer',
|
|
default='86400',
|
|
description="number of seconds until a reservation expires")
|
|
|
|
cinder.param(
|
|
'until_refresh',
|
|
type='integer',
|
|
default='0',
|
|
description="count of reservations until usage is refreshed")
|
|
|
|
cinder.param(
|
|
'max_age',
|
|
type='integer',
|
|
default='0',
|
|
description="number of seconds between subsequent usage refreshes")
|
|
|
|
cinder.param(
|
|
'quota_driver',
|
|
type='string',
|
|
default='cinder.quota.DbQuotaDriver',
|
|
description="default driver to use for quota checks")
|
|
|
|
cinder.param(
|
|
'use_default_quota_class',
|
|
type='boolean',
|
|
default='true',
|
|
description="whether to use default quota class for default quota")
|
|
|
|
cinder.param(
|
|
'report_interval',
|
|
type='integer',
|
|
default='10',
|
|
description="seconds between nodes reporting state to datastore")
|
|
|
|
cinder.param(
|
|
'periodic_interval',
|
|
type='integer',
|
|
default='60',
|
|
description="seconds between running periodic tasks")
|
|
|
|
cinder.param(
|
|
'periodic_fuzzy_delay',
|
|
type='integer',
|
|
default='60',
|
|
description="range of seconds to randomly delay when starting the "
|
|
"periodic task scheduler to reduce stampeding.")
|
|
|
|
cinder.param(
|
|
'osapi_volume_listen',
|
|
type='string',
|
|
default='0.0.0.0',
|
|
description="IP address for OpenStack Volume API to listen")
|
|
|
|
cinder.param(
|
|
'osapi_volume_listen_port',
|
|
type='integer',
|
|
default='8776',
|
|
description="port for os volume api to listen")
|
|
|
|
cinder.param(
|
|
'sqlite_clean_db',
|
|
type='string',
|
|
default='clean.sqlite',
|
|
description="File name of clean sqlite db")
|
|
|
|
cinder.param(
|
|
'fake_tests',
|
|
type='boolean',
|
|
default='true',
|
|
description="should we use everything for testing")
|
|
|
|
cinder.param(
|
|
'backlog',
|
|
type='integer',
|
|
default='4096',
|
|
description="Number of backlog requests to configure the socket with")
|
|
|
|
cinder.param(
|
|
'tcp_keepidle',
|
|
type='integer',
|
|
default='600',
|
|
description="Sets the value of TCP_KEEPIDLE in seconds for each server "
|
|
"socket. Not supported on OS X.")
|
|
|
|
cinder.param(
|
|
'ssl_ca_file',
|
|
type='string',
|
|
default='<None>',
|
|
description="CA certificate file to use to verify connecting clients")
|
|
|
|
cinder.param(
|
|
'ssl_cert_file',
|
|
type='string',
|
|
default='<None>',
|
|
description="Certificate file to use when starting the server securely")
|
|
|
|
cinder.param(
|
|
'ssl_key_file',
|
|
type='string',
|
|
default='<None>',
|
|
description="Private key file to use when starting the server securely")
|
|
|
|
cinder.param(
|
|
'osapi_max_limit',
|
|
type='integer',
|
|
default='1000',
|
|
description="the maximum number of items returned in a single response "
|
|
"from a collection resource")
|
|
|
|
cinder.param(
|
|
'osapi_volume_base_URL',
|
|
type='string',
|
|
default='<None>',
|
|
description="Base URL that will be presented to users in links to the "
|
|
"OpenStack Volume API")
|
|
|
|
cinder.param(
|
|
'use_forwarded_for',
|
|
type='boolean',
|
|
default='false',
|
|
description="Treat X-Forwarded-For as the canonical remote address. "
|
|
"Only enable this if you have a sanitizing proxy.")
|
|
|
|
cinder.param(
|
|
'osapi_max_request_body_size',
|
|
type='integer',
|
|
default='114688',
|
|
description="Max size for body of a request")
|
|
|
|
cinder.param(
|
|
'backup_ceph_conf',
|
|
type='string',
|
|
default='/etc/ceph/ceph.conf',
|
|
description="Ceph config file to use.")
|
|
|
|
cinder.param(
|
|
'backup_ceph_user',
|
|
type='string',
|
|
default='cinder',
|
|
description="the Ceph user to connect with")
|
|
|
|
cinder.param(
|
|
'backup_ceph_chunk_size',
|
|
type='integer',
|
|
default='134217728',
|
|
description="the chunk size in bytes that a backup will be broken into "
|
|
"before transfer to backup store")
|
|
|
|
cinder.param(
|
|
'backup_ceph_pool',
|
|
type='string',
|
|
default='backups',
|
|
description="the Ceph pool to backup to")
|
|
|
|
cinder.param(
|
|
'backup_ceph_stripe_unit',
|
|
type='integer',
|
|
default='0',
|
|
description="RBD stripe unit to use when creating a backup image")
|
|
|
|
cinder.param(
|
|
'backup_ceph_stripe_count',
|
|
type='integer',
|
|
default='0',
|
|
description="RBD stripe count to use when creating a backup image")
|
|
|
|
cinder.param(
|
|
'restore_discard_excess_bytes',
|
|
type='boolean',
|
|
default='true',
|
|
description="If True, always discard excess bytes when restoring volumes.")
|
|
|
|
cinder.param(
|
|
'backup_swift_url',
|
|
type='string',
|
|
default='http://localhost:8080/v1/AUTH_',
|
|
description="The URL of the Swift endpoint")
|
|
|
|
cinder.param(
|
|
'backup_swift_auth',
|
|
type='string',
|
|
default='per_user',
|
|
description="Swift authentication mechanism")
|
|
|
|
cinder.param(
|
|
'backup_swift_user',
|
|
type='string',
|
|
default='<None>',
|
|
description="Swift user name")
|
|
|
|
cinder.param(
|
|
'backup_swift_key',
|
|
type='string',
|
|
default='<None>',
|
|
description="Swift key for authentication")
|
|
|
|
cinder.param(
|
|
'backup_swift_container',
|
|
type='string',
|
|
default='volumebackups',
|
|
description="The default Swift container to use")
|
|
|
|
cinder.param(
|
|
'backup_swift_object_size',
|
|
type='integer',
|
|
default='52428800',
|
|
description="The size in bytes of Swift backup objects")
|
|
|
|
cinder.param(
|
|
'backup_swift_retry_attempts',
|
|
type='integer',
|
|
default='3',
|
|
description="The number of retries to make for Swift operations")
|
|
|
|
cinder.param(
|
|
'backup_swift_retry_backoff',
|
|
type='integer',
|
|
default='2',
|
|
description="The backoff time in seconds between Swift retries")
|
|
|
|
cinder.param(
|
|
'backup_compression_algorithm',
|
|
type='string',
|
|
default='zlib',
|
|
description="Compression algorithm")
|
|
|
|
cinder.param(
|
|
'backup_tsm_volume_prefix',
|
|
type='string',
|
|
default='backup',
|
|
description="Volume prefix for the backup id when backing up to TSM")
|
|
|
|
cinder.param(
|
|
'backup_tsm_password',
|
|
type='string',
|
|
default='password',
|
|
description="TSM password for the running username")
|
|
|
|
cinder.param(
|
|
'backup_tsm_compression',
|
|
type='boolean',
|
|
default='true',
|
|
description="Enable or Disable compression for backups")
|
|
|
|
cinder.param(
|
|
'backup_driver',
|
|
type='string',
|
|
default='cinder.backup.drivers.swift',
|
|
description="Driver to use for backups.")
|
|
|
|
cinder.param(
|
|
'num_volume_device_scan_tries',
|
|
type='integer',
|
|
default='3',
|
|
description="The maximum number of times to rescan targetsto find volume")
|
|
|
|
cinder.param(
|
|
'iscsi_helper',
|
|
type='string',
|
|
default='tgtadm',
|
|
description="iscsi target user-land tool to use")
|
|
|
|
cinder.param(
|
|
'volumes_dir',
|
|
type='string',
|
|
default='$state_path/volumes',
|
|
description="Volume configuration file storage directory")
|
|
|
|
cinder.param(
|
|
'iet_conf',
|
|
type='string',
|
|
default='/etc/iet/ietd.conf',
|
|
description="IET configuration file")
|
|
|
|
cinder.param(
|
|
'lio_initiator_iqns',
|
|
type='string',
|
|
default='',
|
|
description="Comma-separatd list of initiator IQNs allowed to connect to "
|
|
"the iSCSI target.")
|
|
|
|
cinder.param(
|
|
'iscsi_iotype',
|
|
type='string',
|
|
default='fileio',
|
|
description="Sets the behavior of the iSCSI target to either perform "
|
|
"blockio or fileio optionally, auto can be set and Cinder "
|
|
"will autodetect type of backing device")
|
|
|
|
cinder.param(
|
|
'iser_helper',
|
|
type='string',
|
|
default='tgtadm',
|
|
description="iser target user-land tool to use")
|
|
|
|
cinder.param(
|
|
'volumes_dir',
|
|
type='string',
|
|
default='$state_path/volumes',
|
|
description="Volume configuration file storage directory")
|
|
|
|
cinder.param(
|
|
'nfs_mount_point_base',
|
|
type='string',
|
|
default='$state_path/mnt',
|
|
description="Base dir containing mount points for nfs shares")
|
|
|
|
cinder.param(
|
|
'nfs_mount_options',
|
|
type='string',
|
|
default='<None>',
|
|
description="Mount options passed to the nfs client. See section of the "
|
|
"nfs man page for details")
|
|
|
|
cinder.param(
|
|
'glusterfs_mount_point_base',
|
|
type='string',
|
|
default='$state_path/mnt',
|
|
description="Base dir containing mount points for gluster shares")
|
|
|
|
cinder.param(
|
|
'connection_type',
|
|
type='string',
|
|
default='<None>',
|
|
description="Virtualization api connection type : libvirt, xenapi, or "
|
|
"fake")
|
|
|
|
cinder.param(
|
|
'api_paste_config',
|
|
type='string',
|
|
default='api-paste.ini',
|
|
description="File name for the paste.deploy config for cinder-api")
|
|
|
|
cinder.param(
|
|
'pybasedir',
|
|
type='string',
|
|
default='/usr/lib/python/site-packages',
|
|
description="Directory where the cinder python module is installed")
|
|
|
|
cinder.param(
|
|
'bindir',
|
|
type='string',
|
|
default='$pybasedir/bin',
|
|
description="Directory where cinder binaries are installed")
|
|
|
|
cinder.param(
|
|
'state_path',
|
|
type='string',
|
|
default='$pybasedir',
|
|
description="Top-level directory for maintaining cinder's state")
|
|
|
|
cinder.param(
|
|
'my_ip',
|
|
type='string',
|
|
default='10.0.0.1',
|
|
description="ip address of this host")
|
|
|
|
cinder.param(
|
|
'glance_host',
|
|
type='string',
|
|
default='$my_ip',
|
|
description="default glance hostname or ip")
|
|
|
|
cinder.param(
|
|
'glance_port',
|
|
type='integer',
|
|
default='9292',
|
|
description="default glance port")
|
|
|
|
cinder.param(
|
|
'glance_api_servers',
|
|
type='list',
|
|
default='$glance_host:$glance_port',
|
|
description="A list of the glance api servers available to cinder")
|
|
|
|
cinder.param(
|
|
'glance_api_version',
|
|
type='integer',
|
|
default='1',
|
|
description="Version of the glance api to use")
|
|
|
|
cinder.param(
|
|
'glance_num_retries',
|
|
type='integer',
|
|
default='0',
|
|
description="Number retries when downloading an image from glance")
|
|
|
|
cinder.param(
|
|
'glance_api_insecure',
|
|
type='boolean',
|
|
default='false',
|
|
description="Allow to perform insecure SSL")
|
|
|
|
cinder.param(
|
|
'glance_api_ssl_compression',
|
|
type='boolean',
|
|
default='false',
|
|
description="Whether to attempt to negotiate SSL layer compression when "
|
|
"using SSL")
|
|
|
|
cinder.param(
|
|
'glance_request_timeout',
|
|
type='integer',
|
|
default='<None>',
|
|
description="http/https timeout value for glance operations. If no value")
|
|
|
|
cinder.param(
|
|
'scheduler_topic',
|
|
type='string',
|
|
default='cinder-scheduler',
|
|
description="the topic scheduler nodes listen on")
|
|
|
|
cinder.param(
|
|
'volume_topic',
|
|
type='string',
|
|
default='cinder-volume',
|
|
description="the topic volume nodes listen on")
|
|
|
|
cinder.param(
|
|
'backup_topic',
|
|
type='string',
|
|
default='cinder-backup',
|
|
description="the topic volume backup nodes listen on")
|
|
|
|
cinder.param(
|
|
'enable_v1_api',
|
|
type='boolean',
|
|
default='true',
|
|
description="Deploy v1 of the Cinder API. ")
|
|
|
|
cinder.param(
|
|
'enable_v2_api',
|
|
type='boolean',
|
|
default='true',
|
|
description="Deploy v2 of the Cinder API. ")
|
|
|
|
cinder.param(
|
|
'api_rate_limit',
|
|
type='boolean',
|
|
default='true',
|
|
description="whether to rate limit the api")
|
|
|
|
cinder.param(
|
|
'osapi_volume_ext_list',
|
|
type='list',
|
|
default='',
|
|
description="Specify list of extensions to load when using osapi_volume_"
|
|
"extension option with cinder.api.contrib.select_extensions")
|
|
|
|
cinder.param(
|
|
'osapi_volume_extension',
|
|
type='multi',
|
|
default='cinder.api.contrib.standard_extensions',
|
|
description="osapi volume extension to load")
|
|
|
|
cinder.param(
|
|
'volume_manager',
|
|
type='string',
|
|
default='cinder.volume.manager.VolumeManager',
|
|
description="full class name for the Manager for volume")
|
|
|
|
cinder.param(
|
|
'backup_manager',
|
|
type='string',
|
|
default='cinder.backup.manager.BackupManager',
|
|
description="full class name for the Manager for volume backup")
|
|
|
|
cinder.param(
|
|
'scheduler_manager',
|
|
type='string',
|
|
default='cinder.scheduler.manager.SchedulerManager',
|
|
description="full class name for the Manager for scheduler")
|
|
|
|
cinder.param(
|
|
'host',
|
|
type='string',
|
|
default='cinder',
|
|
description="Name of this node. This can be an opaque identifier. "
|
|
"It is not necessarily a hostname, FQDN, or IP address.")
|
|
|
|
cinder.param(
|
|
'storage_availability_zone',
|
|
type='string',
|
|
default='nova',
|
|
description="availability zone of this node")
|
|
|
|
cinder.param(
|
|
'default_availability_zone',
|
|
type='string',
|
|
default='<None>',
|
|
description="default availability zone to use when creating a new volume. "
|
|
"If this is not set then we use the value from the "
|
|
"storage_availability_zone option as the "
|
|
"default availability_zone for new volumes.")
|
|
|
|
cinder.param(
|
|
'memcached_servers',
|
|
type='list',
|
|
default='<None>',
|
|
description="Memcached servers or None for in process cache.")
|
|
|
|
cinder.param(
|
|
'default_volume_type',
|
|
type='string',
|
|
default='<None>',
|
|
description="default volume type to use")
|
|
|
|
cinder.param(
|
|
'volume_usage_audit_period',
|
|
type='string',
|
|
default='month',
|
|
description="time period to generate volume usages for. Time period "
|
|
"must be hour, day, month or year")
|
|
|
|
cinder.param(
|
|
'root_helper',
|
|
type='string',
|
|
default='sudo',
|
|
description="Deprecated: command to use for running commands as root")
|
|
|
|
cinder.param(
|
|
'rootwrap_config',
|
|
type='string',
|
|
default='/etc/cinder/rootwrap.conf',
|
|
description="Path to the rootwrap configuration file to use for "
|
|
"running commands as root")
|
|
|
|
cinder.param(
|
|
'monkey_patch',
|
|
type='boolean',
|
|
default='false',
|
|
description="Enable monkey patching")
|
|
|
|
cinder.param(
|
|
'monkey_patch_modules',
|
|
type='list',
|
|
default='',
|
|
description="List of modules/decorators to monkey patch")
|
|
|
|
cinder.param(
|
|
'service_down_time',
|
|
type='integer',
|
|
default='60',
|
|
description="maximum time since last check-in for up service")
|
|
|
|
cinder.param(
|
|
'volume_api_class',
|
|
type='string',
|
|
default='cinder.volume.api.API',
|
|
description="The full class name of the volume API class to use")
|
|
|
|
cinder.param(
|
|
'backup_api_class',
|
|
type='string',
|
|
default='cinder.backup.api.API',
|
|
description="The full class name of the volume backup API class")
|
|
|
|
cinder.param(
|
|
'auth_strategy',
|
|
type='string',
|
|
default='noauth',
|
|
description="The strategy to use for auth. Supports noauth, keystone, "
|
|
"and deprecated.")
|
|
|
|
cinder.param(
|
|
'enabled_backends',
|
|
type='list',
|
|
default='<None>',
|
|
description="A list of backend names to use. These backend names "
|
|
"should be backed by a unique [CONFIG] group with its options")
|
|
|
|
cinder.param(
|
|
'no_snapshot_gb_quota',
|
|
type='boolean',
|
|
default='false',
|
|
description="Whether snapshots count against GigaByte quota")
|
|
|
|
cinder.param(
|
|
'transfer_api_class',
|
|
type='string',
|
|
default='cinder.transfer.api.API',
|
|
description="The full class name of the volume transfer API class")
|
|
|
|
cinder.param(
|
|
'compute_api_class',
|
|
type='string',
|
|
default='cinder.compute.nova.API',
|
|
description="The full class name of the compute API class to use")
|
|
|
|
cinder.param(
|
|
'nova_catalog_info',
|
|
type='string',
|
|
default='compute:nova:publicURL',
|
|
description="Info to match when looking for nova in the service catalog. "
|
|
"Format is : separated values of the form: "
|
|
"<service_type>:<service_name>:<endpoint_type>")
|
|
|
|
cinder.param(
|
|
'nova_catalog_admin_info',
|
|
type='string',
|
|
default='compute:nova:adminURL',
|
|
description="Same as nova_catalog_info, but for admin endpoint.")
|
|
|
|
cinder.param(
|
|
'nova_endpoint_template',
|
|
type='string',
|
|
default='<None>',
|
|
description="Override service catalog lookup with template for nova "
|
|
"endpoint e.g. http://localhost:8774/v2/%(tenant_id)s")
|
|
|
|
cinder.param(
|
|
'nova_endpoint_admin_template',
|
|
type='string',
|
|
default='<None>',
|
|
description="Same as nova_endpoint_template, but for admin endpoint.")
|
|
|
|
cinder.param(
|
|
'os_region_name',
|
|
type='string',
|
|
default='<None>',
|
|
description="region name of this node")
|
|
|
|
cinder.param(
|
|
'nova_ca_certificates_file',
|
|
type='string',
|
|
default='<None>',
|
|
description="Location of ca certicates file to use for nova client "
|
|
"requests.")
|
|
|
|
cinder.param(
|
|
'nova_api_insecure',
|
|
type='boolean',
|
|
default='false',
|
|
description="Allow to perform insecure SSL requests to nova")
|
|
|
|
cinder.param(
|
|
'db_backend',
|
|
type='string',
|
|
default='sqlalchemy',
|
|
description="The backend to use for db")
|
|
|
|
cinder.param(
|
|
'enable_new_services',
|
|
type='boolean',
|
|
default='true',
|
|
description="Services to be added to the available pool on create")
|
|
|
|
cinder.param(
|
|
'volume_name_template',
|
|
type='string',
|
|
default='volume-%s',
|
|
description="Template string to be used to generate volume names")
|
|
|
|
cinder.param(
|
|
'snapshot_name_template',
|
|
type='string',
|
|
default='snapshot-%s',
|
|
description="Template string to be used to generate snapshot names")
|
|
|
|
cinder.param(
|
|
'backup_name_template',
|
|
type='string',
|
|
default='backup-%s',
|
|
description="Template string to be used to generate backup names")
|
|
|
|
cinder.param(
|
|
'db_driver',
|
|
type='string',
|
|
default='cinder.db',
|
|
description="driver to use for database access")
|
|
|
|
cinder.param(
|
|
'allowed_direct_url_schemes',
|
|
type='list',
|
|
default='',
|
|
description="A list of url schemes that can be downloaded directly "
|
|
"via the direct_url. Currently supported schemes: [file].")
|
|
|
|
cinder.param(
|
|
'image_conversion_dir',
|
|
type='string',
|
|
default='$state_path/conversion',
|
|
description="Directory used for temporary storage during image conversion")
|
|
|
|
cinder.param(
|
|
'keymgr_api_class',
|
|
type='string',
|
|
default='cinder.keymgr.not_implemented_key_mgr.NotImplementedKeyManager',
|
|
description="The full class name of the key manager API class")
|
|
|
|
cinder.param(
|
|
'backend',
|
|
type='string',
|
|
default='sqlalchemy',
|
|
description="The backend to use for db")
|
|
|
|
cinder.param(
|
|
'use_tpool',
|
|
type='boolean',
|
|
default='false',
|
|
description="Enable the experimental use of thread pooling for all "
|
|
"DB API calls")
|
|
|
|
cinder.param(
|
|
'connection',
|
|
type='string',
|
|
default='sqlite:////cinder/openstack/common/db/$sqlite_db',
|
|
description="The SQLAlchemy connection string used to connect to "
|
|
"the database")
|
|
|
|
cinder.param(
|
|
'sql_connection',
|
|
type='string',
|
|
default='sqlite:////nova/openstack/common/db/$sqlite_db',
|
|
description="The SQLAlchemy connection string used to connect to "
|
|
"the database",
|
|
deprecation_message='Deprecated in favor of "[DEFAULT]connection" '
|
|
'parameter')
|
|
|
|
cinder.param(
|
|
'idle_timeout',
|
|
type='integer',
|
|
default='3600',
|
|
description="timeout before idle sql connections are reaped")
|
|
|
|
cinder.param(
|
|
'min_pool_size',
|
|
type='integer',
|
|
default='1',
|
|
description="Minimum number of SQL connections to keep open in a pool")
|
|
|
|
cinder.param(
|
|
'max_pool_size',
|
|
type='integer',
|
|
default='5',
|
|
description="Maximum number of SQL connections to keep open in a pool")
|
|
|
|
cinder.param(
|
|
'max_retries',
|
|
type='integer',
|
|
default='10',
|
|
description="maximum db connection retries during startup.")
|
|
|
|
cinder.param(
|
|
'retry_interval',
|
|
type='integer',
|
|
default='10',
|
|
description="interval between retries of opening a sql connection")
|
|
|
|
cinder.param(
|
|
'max_overflow',
|
|
type='integer',
|
|
default='<None>',
|
|
description="If set, use this value for max_overflow with sqlalchemy")
|
|
|
|
cinder.param(
|
|
'connection_debug',
|
|
type='integer',
|
|
default='0',
|
|
description="Verbosity of SQL debugging information. 0=None, "
|
|
"100=Everything")
|
|
|
|
cinder.param(
|
|
'connection_trace',
|
|
type='boolean',
|
|
default='false',
|
|
description="Add python stack traces to SQL as comment strings")
|
|
|
|
cinder.param(
|
|
'sqlite_db',
|
|
type='string',
|
|
default='cinder.sqlite',
|
|
description="the filename to use with sqlite")
|
|
|
|
cinder.param(
|
|
'sqlite_synchronous',
|
|
type='boolean',
|
|
default='true',
|
|
description="If true, use synchronous mode for sqlite")
|
|
|
|
cinder.param(
|
|
'backdoor_port',
|
|
type='integer',
|
|
default='<None>',
|
|
description="port for eventlet backdoor to listen")
|
|
|
|
cinder.param(
|
|
'disable_process_locking',
|
|
type='boolean',
|
|
default='false',
|
|
description="Whether to disable inter-process locks")
|
|
|
|
cinder.param(
|
|
'lock_path',
|
|
type='string',
|
|
default='<None>',
|
|
description="Directory to use for lock files. Default to a temp directory")
|
|
|
|
cinder.param(
|
|
'debug',
|
|
type='boolean',
|
|
default='false',
|
|
description="Print debugging output")
|
|
|
|
cinder.param(
|
|
'verbose',
|
|
type='boolean',
|
|
default='false',
|
|
description="Print more verbose output")
|
|
|
|
cinder.param(
|
|
'use_stderr',
|
|
type='boolean',
|
|
default='true',
|
|
description="Log output to standard error")
|
|
|
|
cinder.param(
|
|
'logging_context_format_string',
|
|
type='string',
|
|
default='%(asctime)s.%(msecs)03d %(process)d %(levelname)s '
|
|
'%(name)s [%(request_id)s %(user)s %(tenant)s] '
|
|
'%(instance)s%(message)s',
|
|
description="format string to use for log messages with context")
|
|
|
|
cinder.param(
|
|
'logging_default_format_string',
|
|
type='string',
|
|
default='%(asctime)s.%(msecs)03d %(process)d %(levelname)s %(name)s '
|
|
'[-] %(instance)s%(message)s',
|
|
description="format string to use for log messages without context")
|
|
|
|
cinder.param(
|
|
'logging_debug_format_suffix',
|
|
type='string',
|
|
default='%(funcName)s %(pathname)s:%(lineno)d',
|
|
description="data to append to log format when level is DEBUG")
|
|
|
|
cinder.param(
|
|
'logging_exception_prefix',
|
|
type='string',
|
|
default='%(asctime)s.%(msecs)03d %(process)d TRACE %(name)s %(instance)s',
|
|
description="prefix each line of exception output with this format")
|
|
|
|
cinder.param(
|
|
'default_log_levels',
|
|
type='list',
|
|
default='amqplibWARN,sqlalchemyWARN,botoWARN,sudsINFO,keystoneINFO,'
|
|
'eventlet.wsgi.serverWARN',
|
|
description="list of logger=LEVEL pairs")
|
|
|
|
cinder.param(
|
|
'publish_errors',
|
|
type='boolean',
|
|
default='false',
|
|
description="publish error events")
|
|
|
|
cinder.param(
|
|
'fatal_deprecations',
|
|
type='boolean',
|
|
default='false',
|
|
description="make deprecations fatal")
|
|
|
|
cinder.param(
|
|
'instance_format',
|
|
type='string',
|
|
default='"[instance: %(uuid)s] "',
|
|
description="If an instance is passed with the log message, "
|
|
"format it like this")
|
|
|
|
cinder.param(
|
|
'instance_uuid_format',
|
|
type='string',
|
|
default='"[instance: %(uuid)s] "',
|
|
description="If an instance UUID is passed with the log message, "
|
|
"format it like this")
|
|
|
|
cinder.param(
|
|
'log_config',
|
|
type='string',
|
|
default='<None>',
|
|
description="If this option is specified, the logging configuration "
|
|
"file specified is used and overrides any other logging "
|
|
"options specified. Please see the Python logging module "
|
|
"documentation for details on logging configuration files.")
|
|
|
|
cinder.param(
|
|
'log_format',
|
|
type='string',
|
|
default='<None>',
|
|
description="A logging.Formatter log message format string which may use "
|
|
"any of the available logging.LogRecord attributes. This "
|
|
"option is deprecated. Please use "
|
|
"logging_context_format_string and logging_default_"
|
|
"format_string instead.")
|
|
|
|
cinder.param(
|
|
'log_date_format',
|
|
type='string',
|
|
default='%Y-%m-%d %H:%M:%S',
|
|
description="Format string for %%(asctime)s in log records. "
|
|
"Default: %(default)s")
|
|
|
|
cinder.param(
|
|
'log_file',
|
|
type='string',
|
|
default='<None>',
|
|
description="(Optional) Name of log file to output to. If no default is "
|
|
"set, logging will go to stdout.")
|
|
|
|
cinder.param(
|
|
'log_dir',
|
|
type='string',
|
|
default='<None>',
|
|
description="(Optional) The base directory used for relative --log-file "
|
|
"paths")
|
|
|
|
cinder.param(
|
|
'use_syslog',
|
|
type='boolean',
|
|
default='false',
|
|
description="Use syslog for logging.")
|
|
|
|
cinder.param(
|
|
'syslog_log_facility',
|
|
type='string',
|
|
default='LOG_USER',
|
|
description="syslog facility to receive log lines")
|
|
|
|
cinder.param(
|
|
'default_notification_level',
|
|
type='string',
|
|
default='INFO',
|
|
description="Default notification level for outgoing notifications")
|
|
|
|
cinder.param(
|
|
'default_publisher_id',
|
|
type='string',
|
|
default='<None>',
|
|
description="Default publisher_id for outgoing notifications")
|
|
|
|
cinder.param(
|
|
'notification_topics',
|
|
type='list',
|
|
default='notifications',
|
|
description="AMQP topic used for OpenStack notifications")
|
|
|
|
cinder.param(
|
|
'topics',
|
|
type='list',
|
|
default='notifications',
|
|
description="AMQP topic(s) used for OpenStack notifications")
|
|
|
|
cinder.param(
|
|
'run_external_periodic_tasks',
|
|
type='boolean',
|
|
default='true',
|
|
description="Some periodic tasks can be run in a separate process. "
|
|
"Should we run them here?")
|
|
|
|
cinder.param(
|
|
'rpc_backend',
|
|
type='string',
|
|
default='cinder.openstack.common.rpc.impl_kombu',
|
|
description="The messaging module to use, defaults to kombu.")
|
|
|
|
cinder.param(
|
|
'rpc_thread_pool_size',
|
|
type='integer',
|
|
default='64',
|
|
description="Size of RPC thread pool")
|
|
|
|
cinder.param(
|
|
'rpc_conn_pool_size',
|
|
type='integer',
|
|
default='30',
|
|
description="Size of RPC connection pool")
|
|
|
|
cinder.param(
|
|
'rpc_response_timeout',
|
|
type='integer',
|
|
default='60',
|
|
description="Seconds to wait for a response from call or multicall")
|
|
|
|
cinder.param(
|
|
'rpc_cast_timeout',
|
|
type='integer',
|
|
default='30',
|
|
description="Seconds to wait before a cast expires")
|
|
|
|
cinder.param(
|
|
'allowed_rpc_exception_modules',
|
|
type='list',
|
|
default='cinder.openstack.common.exception,nova.exception,'
|
|
'cinder.exception,exceptions',
|
|
description="Modules of exceptions that are permitted to be recreatedupon "
|
|
"receiving exception data from an rpc call.")
|
|
|
|
cinder.param(
|
|
'fake_rabbit',
|
|
type='boolean',
|
|
default='false',
|
|
description="If passed, use a fake RabbitMQ provider")
|
|
|
|
cinder.param(
|
|
'control_exchange',
|
|
type='string',
|
|
default='openstack',
|
|
description="AMQP exchange to connect to if using RabbitMQ or Qpid")
|
|
|
|
cinder.param(
|
|
'amqp_rpc_single_reply_queue',
|
|
type='boolean',
|
|
default='false',
|
|
description="Enable a fast single reply queue if using AMQP based "
|
|
"RPC like RabbitMQ or Qpid.")
|
|
|
|
cinder.param(
|
|
'amqp_durable_queues',
|
|
type='boolean',
|
|
default='false',
|
|
description="Use durable queues in amqp.")
|
|
|
|
cinder.param(
|
|
'amqp_auto_delete',
|
|
type='boolean',
|
|
default='false',
|
|
description="Auto-delete queues in amqp.")
|
|
|
|
cinder.param(
|
|
'kombu_ssl_version',
|
|
type='string',
|
|
default='',
|
|
description="SSL version to use")
|
|
|
|
cinder.param(
|
|
'kombu_ssl_keyfile',
|
|
type='string',
|
|
default='',
|
|
description="SSL key file")
|
|
|
|
cinder.param(
|
|
'kombu_ssl_certfile',
|
|
type='string',
|
|
default='',
|
|
description="SSL cert file")
|
|
|
|
cinder.param(
|
|
'kombu_ssl_ca_certs',
|
|
type='string',
|
|
default='',
|
|
description="SSL certification authority file")
|
|
|
|
cinder.param(
|
|
'rabbit_host',
|
|
type='string',
|
|
default='localhost',
|
|
description="The RabbitMQ broker address where a single node is used")
|
|
|
|
cinder.param(
|
|
'rabbit_port',
|
|
type='integer',
|
|
default='5672',
|
|
description="The RabbitMQ broker port where a single node is used")
|
|
|
|
cinder.param(
|
|
'rabbit_hosts',
|
|
type='list',
|
|
default='$rabbit_host:$rabbit_port',
|
|
description="RabbitMQ HA cluster host:port pairs")
|
|
|
|
cinder.param(
|
|
'rabbit_use_ssl',
|
|
type='boolean',
|
|
default='false',
|
|
description="connect over SSL for RabbitMQ")
|
|
|
|
cinder.param(
|
|
'rabbit_userid',
|
|
type='string',
|
|
default='guest',
|
|
description="the RabbitMQ userid")
|
|
|
|
cinder.param(
|
|
'rabbit_password',
|
|
type='string',
|
|
default='guest',
|
|
description="the RabbitMQ password")
|
|
|
|
cinder.param(
|
|
'rabbit_virtual_host',
|
|
type='string',
|
|
default='/',
|
|
description="the RabbitMQ virtual host")
|
|
|
|
cinder.param(
|
|
'rabbit_retry_interval',
|
|
type='integer',
|
|
default='1',
|
|
description="how frequently to retry connecting with RabbitMQ")
|
|
|
|
cinder.param(
|
|
'rabbit_retry_backoff',
|
|
type='integer',
|
|
default='2',
|
|
description="how long to backoff for between retries when connecting "
|
|
"to RabbitMQ")
|
|
|
|
cinder.param(
|
|
'rabbit_max_retries',
|
|
type='integer',
|
|
default='0',
|
|
description="maximum retries with trying to connect to RabbitMQ")
|
|
|
|
cinder.param(
|
|
'rabbit_ha_queues',
|
|
type='boolean',
|
|
default='false',
|
|
description="use H/A queues in RabbitMQ")
|
|
|
|
cinder.param(
|
|
'qpid_hostname',
|
|
type='string',
|
|
default='localhost',
|
|
description="Qpid broker hostname")
|
|
|
|
cinder.param(
|
|
'qpid_port',
|
|
type='integer',
|
|
default='5672',
|
|
description="Qpid broker port")
|
|
|
|
cinder.param(
|
|
'qpid_hosts',
|
|
type='list',
|
|
default='$qpid_hostname:$qpid_port',
|
|
description="Qpid HA cluster host:port pairs")
|
|
|
|
cinder.param(
|
|
'qpid_username',
|
|
type='string',
|
|
default='',
|
|
description="Username for qpid connection")
|
|
|
|
cinder.param(
|
|
'qpid_password',
|
|
type='string',
|
|
default='',
|
|
description="Password for qpid connection")
|
|
|
|
cinder.param(
|
|
'qpid_sasl_mechanisms',
|
|
type='string',
|
|
default='',
|
|
description="Space separated list of SASL mechanisms to use for auth")
|
|
|
|
cinder.param(
|
|
'qpid_heartbeat',
|
|
type='integer',
|
|
default='60',
|
|
description="Seconds between connection keepalive heartbeats")
|
|
|
|
cinder.param(
|
|
'qpid_protocol',
|
|
type='string',
|
|
default='tcp',
|
|
description="Transport to use, either 'tcp' or 'ssl'")
|
|
|
|
cinder.param(
|
|
'qpid_tcp_nodelay',
|
|
type='boolean',
|
|
default='true',
|
|
description="Disable Nagle algorithm")
|
|
|
|
cinder.param(
|
|
'qpid_topology_version',
|
|
type='integer',
|
|
default='1',
|
|
description="The qpid topology version to use. Version 1 is what "
|
|
"was originally used by impl_qpid. Version 2 includes some "
|
|
"backwards-incompatible changes that allow broker federation "
|
|
"to work. Users should update to version 2 when they are "
|
|
"able to take everything down, as it requires a clean break.")
|
|
|
|
cinder.param(
|
|
'rpc_zmq_bind_address',
|
|
type='string',
|
|
default='*',
|
|
description="ZeroMQ bind address. Should be a wildcard")
|
|
|
|
cinder.param(
|
|
'rpc_zmq_matchmaker',
|
|
type='string',
|
|
default='cinder.openstack.common.rpc.matchmaker.MatchMakerLocalhost',
|
|
description="MatchMaker driver")
|
|
|
|
cinder.param(
|
|
'rpc_zmq_port',
|
|
type='integer',
|
|
default='9501',
|
|
description="ZeroMQ receiver listening port")
|
|
|
|
cinder.param(
|
|
'rpc_zmq_contexts',
|
|
type='integer',
|
|
default='1',
|
|
description="Number of ZeroMQ contexts, defaults to 1")
|
|
|
|
cinder.param(
|
|
'rpc_zmq_topic_backlog',
|
|
type='integer',
|
|
default='<None>',
|
|
description="Maximum number of ingress messages to locally buffer per "
|
|
"topic. Default is unlimited.")
|
|
|
|
cinder.param(
|
|
'rpc_zmq_ipc_dir',
|
|
type='string',
|
|
default='/var/run/openstack',
|
|
description="Directory for holding IPC sockets")
|
|
|
|
cinder.param(
|
|
'rpc_zmq_host',
|
|
type='string',
|
|
default='cinder',
|
|
description="Name of this node. Must be a valid hostname, FQDN, or IP"
|
|
" address. Must match 'host' option, if running Nova.")
|
|
|
|
cinder.param(
|
|
'matchmaker_ringfile',
|
|
type='string',
|
|
default='/etc/nova/matchmaker_ring.json',
|
|
description="Matchmaker ring file")
|
|
|
|
cinder.param(
|
|
'matchmaker_heartbeat_freq',
|
|
type='integer',
|
|
default='300',
|
|
description="Heartbeat frequency")
|
|
|
|
cinder.param(
|
|
'matchmaker_heartbeat_ttl',
|
|
type='integer',
|
|
default='600',
|
|
description="Heartbeat time-to-live.")
|
|
|
|
cinder.param(
|
|
'host',
|
|
type='string',
|
|
default='127.0.0.1',
|
|
description="Host to locate redis")
|
|
|
|
cinder.param(
|
|
'port',
|
|
type='integer',
|
|
default='6379',
|
|
description="Use this port to connect to redis host.")
|
|
|
|
cinder.param(
|
|
'password',
|
|
type='string',
|
|
default='<None>',
|
|
description="Password for Redis server.")
|
|
|
|
cinder.param(
|
|
'scheduler_host_manager',
|
|
type='string',
|
|
default='cinder.scheduler.host_manager.HostManager',
|
|
description="The scheduler host manager class to use")
|
|
|
|
cinder.param(
|
|
'scheduler_max_attempts',
|
|
type='integer',
|
|
default='3',
|
|
description="Maximum number of attempts to schedule an volume")
|
|
|
|
cinder.param(
|
|
'scheduler_default_filters',
|
|
type='list',
|
|
default='AvailabilityZoneFilter,CapacityFilter,CapabilitiesFilter',
|
|
description="Which filter class names to use for filtering hosts when "
|
|
"not specified in the request.")
|
|
|
|
cinder.param(
|
|
'scheduler_default_weighers',
|
|
type='list',
|
|
default='CapacityWeigher',
|
|
description="Which weigher class names to use for weighing hosts.")
|
|
|
|
cinder.param(
|
|
'scheduler_driver',
|
|
type='string',
|
|
default='cinder.scheduler.filter_scheduler.FilterScheduler',
|
|
description="Default scheduler driver to use")
|
|
|
|
cinder.param(
|
|
'scheduler_json_config_location',
|
|
type='string',
|
|
default='',
|
|
description="Absolute path to scheduler configuration JSON file.")
|
|
|
|
cinder.param(
|
|
'max_gigabytes',
|
|
type='integer',
|
|
default='10000',
|
|
description="maximum number of volume gigabytes to allow per host")
|
|
|
|
cinder.param(
|
|
'capacity_weight_multiplier',
|
|
type='floating point',
|
|
default='1.0',
|
|
description="Multiplier used for weighing volume capacity. Negative "
|
|
"numbers mean to stack vs spread.")
|
|
|
|
cinder.param(
|
|
'volume_transfer_salt_length',
|
|
type='integer',
|
|
default='8',
|
|
description="The number of characters in the salt.")
|
|
|
|
cinder.param(
|
|
'volume_transfer_key_length',
|
|
type='integer',
|
|
default='16',
|
|
description="The number of characters in the autogenerated auth key.")
|
|
|
|
cinder.param(
|
|
'snapshot_same_host',
|
|
type='boolean',
|
|
default='true',
|
|
description="Create volume from snapshot at the host where snapshot "
|
|
"resides")
|
|
|
|
cinder.param(
|
|
'cloned_volume_same_az',
|
|
type='boolean',
|
|
default='true',
|
|
description="Ensure that the new volumes are the same AZ as snapshot "
|
|
"or source volume")
|
|
|
|
cinder.param(
|
|
'num_shell_tries',
|
|
type='integer',
|
|
default='3',
|
|
description="number of times to attempt to run flakey shell commands")
|
|
|
|
cinder.param(
|
|
'reserved_percentage',
|
|
type='integer',
|
|
default='0',
|
|
description="The percentage of backend capacity is reserved")
|
|
|
|
cinder.param(
|
|
'iscsi_num_targets',
|
|
type='integer',
|
|
default='100',
|
|
description="The maximum number of iscsi target ids per host")
|
|
|
|
cinder.param(
|
|
'iscsi_target_prefix',
|
|
type='string',
|
|
default='iqn.2010-10.org.openstack:',
|
|
description="prefix for iscsi volumes")
|
|
|
|
cinder.param(
|
|
'iscsi_ip_address',
|
|
type='string',
|
|
default='$my_ip',
|
|
description="The IP address that the iSCSI daemon is listening on")
|
|
|
|
cinder.param(
|
|
'iscsi_port',
|
|
type='integer',
|
|
default='3260',
|
|
description="The port that the iSCSI daemon is listening on")
|
|
|
|
cinder.param(
|
|
'num_iser_scan_tries',
|
|
type='integer',
|
|
default='3',
|
|
description="The maximum number of times to rescan iSER targetto "
|
|
"find volume")
|
|
|
|
cinder.param(
|
|
'iser_num_targets',
|
|
type='integer',
|
|
default='100',
|
|
description="The maximum number of iser target ids per host")
|
|
|
|
cinder.param(
|
|
'iser_target_prefix',
|
|
type='string',
|
|
default='iqn.2010-10.org.iser.openstack:',
|
|
description="prefix for iser volumes")
|
|
|
|
cinder.param(
|
|
'iser_ip_address',
|
|
type='string',
|
|
default='$my_ip',
|
|
description="The IP address that the iSER daemon is listening on")
|
|
|
|
cinder.param(
|
|
'iser_port',
|
|
type='integer',
|
|
default='3260',
|
|
description="The port that the iSER daemon is listening on")
|
|
|
|
cinder.param(
|
|
'volume_backend_name',
|
|
type='string',
|
|
default='<None>',
|
|
description="The backend name for a given driver implementation")
|
|
|
|
cinder.param(
|
|
'use_multipath_for_image_xfer',
|
|
type='boolean',
|
|
default='false',
|
|
description="Do we attach/detach volumes in cinder using multipath "
|
|
"for volume to image and image to volume transfers?")
|
|
|
|
cinder.param(
|
|
'volume_clear',
|
|
type='string',
|
|
default='zero',
|
|
description="Method used to wipe old voumes")
|
|
|
|
cinder.param(
|
|
'volume_clear_size',
|
|
type='integer',
|
|
default='0',
|
|
description="Size in MiB to wipe at start of old volumes. 0 => all")
|
|
|
|
cinder.param(
|
|
'available_devices',
|
|
type='list',
|
|
default='',
|
|
description="List of all available devices")
|
|
|
|
cinder.param(
|
|
'coraid_esm_address',
|
|
type='string',
|
|
default='',
|
|
description="IP address of Coraid ESM")
|
|
|
|
cinder.param(
|
|
'coraid_user',
|
|
type='string',
|
|
default='admin',
|
|
description="User name to connect to Coraid ESM")
|
|
|
|
cinder.param(
|
|
'coraid_group',
|
|
type='string',
|
|
default='admin',
|
|
description="Name of group on Coraid ESM to which coraid_user belongs")
|
|
|
|
cinder.param(
|
|
'coraid_password',
|
|
type='string',
|
|
default='password',
|
|
description="Password to connect to Coraid ESM")
|
|
|
|
cinder.param(
|
|
'coraid_repository_key',
|
|
type='string',
|
|
default='coraid_repository',
|
|
description="Volume Type key name to store ESM Repository Name")
|
|
|
|
cinder.param(
|
|
'eqlx_group_name',
|
|
type='string',
|
|
default='group-0',
|
|
description="Group name to use for creating volumes")
|
|
|
|
cinder.param(
|
|
'eqlx_cli_timeout',
|
|
type='integer',
|
|
default='30',
|
|
description="Timeout for the Group Manager cli command execution")
|
|
|
|
cinder.param(
|
|
'eqlx_cli_max_retries',
|
|
type='integer',
|
|
default='5',
|
|
description="Maximum retry count for reconnection")
|
|
|
|
cinder.param(
|
|
'eqlx_use_chap',
|
|
type='boolean',
|
|
default='false',
|
|
description="Use CHAP authentificaion for targets?")
|
|
|
|
cinder.param(
|
|
'eqlx_chap_login',
|
|
type='string',
|
|
default='admin',
|
|
description="Existing CHAP account name")
|
|
|
|
cinder.param(
|
|
'eqlx_chap_password',
|
|
type='string',
|
|
default='password',
|
|
description="Password for specified CHAP account name")
|
|
|
|
cinder.param(
|
|
'eqlx_pool',
|
|
type='string',
|
|
default='default',
|
|
description="Pool in which volumes will be created")
|
|
|
|
cinder.param(
|
|
'glusterfs_shares_config',
|
|
type='string',
|
|
default='/etc/cinder/glusterfs_shares',
|
|
description="File with the list of available gluster shares")
|
|
|
|
cinder.param(
|
|
'glusterfs_disk_util',
|
|
type='string',
|
|
default='df',
|
|
description="Use du or df for free space calculation")
|
|
|
|
cinder.param(
|
|
'glusterfs_sparsed_volumes',
|
|
type='boolean',
|
|
default='true',
|
|
description="Create volumes as sparsed files which take no space.If set "
|
|
"to False volume is created as regular file.In such case "
|
|
"volume creation takes a lot of time.")
|
|
|
|
cinder.param(
|
|
'glusterfs_qcow2_volumes',
|
|
type='boolean',
|
|
default='false',
|
|
description="Create volumes as QCOW2 files rather than raw files.")
|
|
|
|
cinder.param(
|
|
'gpfs_mount_point_base',
|
|
type='string',
|
|
default='<None>',
|
|
description="Path to the directory on GPFS mount point where volumes "
|
|
"are stored")
|
|
|
|
cinder.param(
|
|
'gpfs_images_dir',
|
|
type='string',
|
|
default='<None>',
|
|
description="Path to GPFS Glance repository as mounted on Nova nodes")
|
|
|
|
cinder.param(
|
|
'gpfs_images_share_mode',
|
|
type='string',
|
|
default='<None>',
|
|
description="Set this if Glance image repo is on GPFS as well so that "
|
|
"the image bits can be transferred efficiently between Glance "
|
|
"and Cinder. Valid values are copy or copy_on_write. copy "
|
|
"performs a full copy of the image, copy_on_write efficiently "
|
|
"shares unmodified blocks of the image.")
|
|
|
|
cinder.param(
|
|
'gpfs_max_clone_depth',
|
|
type='integer',
|
|
default='0',
|
|
description="A lengthy chain of copy-on-write snapshots or clones could "
|
|
"have impact on performance. This option limits the number "
|
|
"of indirections required to reach a specific block. 0 "
|
|
"indicates unlimited.")
|
|
|
|
cinder.param(
|
|
'gpfs_sparse_volumes',
|
|
type='boolean',
|
|
default='true',
|
|
description="Create volumes as sparse files which take no space. If set "
|
|
"to False volume is created as regular file. In this case "
|
|
"volume creation may take a significantly longer time.")
|
|
|
|
cinder.param(
|
|
'hds_cinder_config_file',
|
|
type='string',
|
|
default='/opt/hds/hus/cinder_hus_conf.xml',
|
|
description="configuration file for HDS cinder plugin for HUS")
|
|
|
|
cinder.param(
|
|
'cinder_huawei_conf_file',
|
|
type='string',
|
|
default='/etc/cinder/cinder_huawei_conf.xml',
|
|
description="config data for cinder huawei plugin")
|
|
|
|
cinder.param(
|
|
'volume_group',
|
|
type='string',
|
|
default='cinder-volumes',
|
|
description="Name for the VG that will contain exported volumes")
|
|
|
|
cinder.param(
|
|
'pool_size',
|
|
type='string',
|
|
default='<None>',
|
|
description="Size of thin provisioning pool")
|
|
|
|
cinder.param(
|
|
'lvm_mirrors',
|
|
type='integer',
|
|
default='0',
|
|
description="If set, create lvms with multiple mirrors. Note that this "
|
|
"requires lvm_mirrors + 2 pvs with available space")
|
|
|
|
cinder.param(
|
|
'lvm_type',
|
|
type='string',
|
|
default='default',
|
|
description="Type of LVM volumes to deploy;")
|
|
|
|
cinder.param(
|
|
'netapp_vfiler',
|
|
type='string',
|
|
default='<None>',
|
|
description="Vfiler to use for provisioning")
|
|
|
|
cinder.param(
|
|
'netapp_login',
|
|
type='string',
|
|
default='<None>',
|
|
description="User name for the storage controller")
|
|
|
|
cinder.param(
|
|
'netapp_password',
|
|
type='string',
|
|
default='<None>',
|
|
description="Password for the storage controller")
|
|
|
|
cinder.param(
|
|
'netapp_vserver',
|
|
type='string',
|
|
default='<None>',
|
|
description="Cluster vserver to use for provisioning")
|
|
|
|
cinder.param(
|
|
'netapp_server_hostname',
|
|
type='string',
|
|
default='<None>',
|
|
description="Host name for the storage controller")
|
|
|
|
cinder.param(
|
|
'netapp_server_port',
|
|
type='integer',
|
|
default='80',
|
|
description="Port number for the storage controller")
|
|
|
|
cinder.param(
|
|
'thres_avl_size_perc_start',
|
|
type='integer',
|
|
default='20',
|
|
description="Threshold available percent to start cache cleaning.")
|
|
|
|
cinder.param(
|
|
'thres_avl_size_perc_stop',
|
|
type='integer',
|
|
default='60',
|
|
description="Threshold available percent to stop cache cleaning.")
|
|
|
|
cinder.param(
|
|
'expiry_thres_minutes',
|
|
type='integer',
|
|
default='720',
|
|
description="Threshold minutes after which cache file can be cleaned.")
|
|
|
|
cinder.param(
|
|
'netapp_size_multiplier',
|
|
type='floating point',
|
|
default='1.2',
|
|
description="Volume size multiplier to ensure while creation")
|
|
|
|
cinder.param(
|
|
'netapp_volume_list',
|
|
type='string',
|
|
default='<None>',
|
|
description="Comma separated volumes to be used for provisioning")
|
|
|
|
cinder.param(
|
|
'netapp_storage_family',
|
|
type='string',
|
|
default='ontap_cluster',
|
|
description="Storage family type.")
|
|
|
|
cinder.param(
|
|
'netapp_storage_protocol',
|
|
type='string',
|
|
default='<None>',
|
|
description="Storage protocol type.")
|
|
|
|
cinder.param(
|
|
'netapp_transport_type',
|
|
type='string',
|
|
default='http',
|
|
description="Transport type protocol")
|
|
|
|
cinder.param(
|
|
'nexenta_host',
|
|
type='string',
|
|
default='',
|
|
description="IP address of Nexenta SA")
|
|
|
|
cinder.param(
|
|
'nexenta_rest_port',
|
|
type='integer',
|
|
default='2000',
|
|
description="HTTP port to connect to Nexenta REST API server")
|
|
|
|
cinder.param(
|
|
'nexenta_rest_protocol',
|
|
type='string',
|
|
default='auto',
|
|
description="Use http or https for REST connection")
|
|
|
|
cinder.param(
|
|
'nexenta_user',
|
|
type='string',
|
|
default='admin',
|
|
description="User name to connect to Nexenta SA")
|
|
|
|
cinder.param(
|
|
'nexenta_password',
|
|
type='string',
|
|
default='nexenta',
|
|
description="Password to connect to Nexenta SA")
|
|
|
|
cinder.param(
|
|
'nexenta_iscsi_target_portal_port',
|
|
type='integer',
|
|
default='3260',
|
|
description="Nexenta target portal port")
|
|
|
|
cinder.param(
|
|
'nexenta_volume',
|
|
type='string',
|
|
default='cinder',
|
|
description="pool on SA that will hold all volumes")
|
|
|
|
cinder.param(
|
|
'nexenta_target_prefix',
|
|
type='string',
|
|
default='iqn.1986-03.com.sun:02:cinder-',
|
|
description="IQN prefix for iSCSI targets")
|
|
|
|
cinder.param(
|
|
'nexenta_target_group_prefix',
|
|
type='string',
|
|
default='cinder/',
|
|
description="prefix for iSCSI target groups on SA")
|
|
|
|
cinder.param(
|
|
'nexenta_shares_config',
|
|
type='string',
|
|
default='/etc/cinder/nfs_shares',
|
|
description="File with the list of available nfs shares")
|
|
|
|
cinder.param(
|
|
'nexenta_mount_point_base',
|
|
type='string',
|
|
default='$state_path/mnt',
|
|
description="Base dir containing mount points for nfs shares")
|
|
|
|
cinder.param(
|
|
'nexenta_sparsed_volumes',
|
|
type='boolean',
|
|
default='true',
|
|
description="Create volumes as sparsed files which take no space.If set "
|
|
"to False volume is created as regular file.In such case "
|
|
"volume creation takes a lot of time.")
|
|
|
|
cinder.param(
|
|
'nexenta_volume_compression',
|
|
type='string',
|
|
default='on',
|
|
description="Default compression value for new ZFS folders.")
|
|
|
|
cinder.param(
|
|
'nexenta_mount_options',
|
|
type='string',
|
|
default='<None>',
|
|
description="Mount options passed to the nfs client. See section of "
|
|
"the nfs man page for details")
|
|
|
|
cinder.param(
|
|
'nexenta_used_ratio',
|
|
type='floating point',
|
|
default='0.95',
|
|
description="Percent of ACTUAL usage of the underlying volume before "
|
|
"no new volumes can be allocated to the volume destination.")
|
|
|
|
cinder.param(
|
|
'nexenta_oversub_ratio',
|
|
type='floating point',
|
|
default='1.0',
|
|
description="This will compare the allocated to available space on the "
|
|
"volume destination. If the ratio exceeds this number, the "
|
|
"destination will no longer be valid.")
|
|
|
|
cinder.param(
|
|
'nexenta_blocksize',
|
|
type='string',
|
|
default='',
|
|
description="block size for volumes")
|
|
|
|
cinder.param(
|
|
'nexenta_sparse',
|
|
type='boolean',
|
|
default='false',
|
|
description="flag to create sparse volumes")
|
|
|
|
cinder.param(
|
|
'nfs_shares_config',
|
|
type='string',
|
|
default='/etc/cinder/nfs_shares',
|
|
description="File with the list of available nfs shares")
|
|
|
|
cinder.param(
|
|
'nfs_sparsed_volumes',
|
|
type='boolean',
|
|
default='true',
|
|
description="Create volumes as sparsed files which take no space.If set "
|
|
"to False volume is created as regular file.In such case "
|
|
"volume creation takes a lot of time.")
|
|
|
|
cinder.param(
|
|
'nfs_used_ratio',
|
|
type='floating point',
|
|
default='0.95',
|
|
description="Percent of ACTUAL usage of the underlying volume before no "
|
|
"new volumes can be allocated to the volume destination.")
|
|
|
|
cinder.param(
|
|
'nfs_oversub_ratio',
|
|
type='floating point',
|
|
default='1.0',
|
|
description="This will compare the allocated to available space on the "
|
|
"volume destination. If the ratio exceeds this number, the "
|
|
"destination will no longer be valid.")
|
|
|
|
cinder.param(
|
|
'rbd_pool',
|
|
type='string',
|
|
default='rbd',
|
|
description="the RADOS pool in which rbd volumes are stored")
|
|
|
|
cinder.param(
|
|
'rbd_user',
|
|
type='string',
|
|
default='<None>',
|
|
description="the RADOS client name for accessing rbd volumes - only set "
|
|
"when using cephx authentication")
|
|
|
|
cinder.param(
|
|
'rbd_ceph_conf',
|
|
type='string',
|
|
default='',
|
|
description="path to the ceph configuration file to use")
|
|
|
|
cinder.param(
|
|
'rbd_flatten_volume_from_snapshot',
|
|
type='boolean',
|
|
default='false',
|
|
description="flatten volumes created from snapshots to remove dependency")
|
|
|
|
cinder.param(
|
|
'rbd_secret_uuid',
|
|
type='string',
|
|
default='<None>',
|
|
description="the libvirt uuid of the secret for the rbd_uservolumes")
|
|
|
|
cinder.param(
|
|
'volume_tmp_dir',
|
|
type='string',
|
|
default='<None>',
|
|
description="where to store temporary image files if the volume driver "
|
|
"does not write them directly to the volume")
|
|
|
|
cinder.param(
|
|
'rbd_max_clone_depth',
|
|
type='integer',
|
|
default='5',
|
|
description="maximum number of nested clones that can be taken of a "
|
|
"volume before enforcing a flatten prior to next clone. A "
|
|
"value of zero disables cloning")
|
|
|
|
cinder.param(
|
|
'hp3par_api_url',
|
|
type='string',
|
|
default='',
|
|
description="3PAR WSAPI Server Url like https://<3par ip>:8080/api/v1")
|
|
|
|
cinder.param(
|
|
'hp3par_username',
|
|
type='string',
|
|
default='',
|
|
description="3PAR Super user username")
|
|
|
|
cinder.param(
|
|
'hp3par_password',
|
|
type='string',
|
|
default='',
|
|
description="3PAR Super user password")
|
|
|
|
cinder.param(
|
|
'hp3par_domain',
|
|
type='string',
|
|
default='<None>',
|
|
description="This option is DEPRECATED and no longer used. The 3par "
|
|
"domain name to use.")
|
|
|
|
cinder.param(
|
|
'hp3par_cpg',
|
|
type='string',
|
|
default='OpenStack',
|
|
description="The CPG to use for volume creation")
|
|
|
|
cinder.param(
|
|
'hp3par_cpg_snap',
|
|
type='string',
|
|
default='',
|
|
description="The CPG to use for Snapshots for volumes. If empty "
|
|
"hp3par_cpg will be used")
|
|
|
|
cinder.param(
|
|
'hp3par_snapshot_retention',
|
|
type='string',
|
|
default='',
|
|
description="The time in hours to retain a snapshot. You can't delete "
|
|
"it before this expires.")
|
|
|
|
cinder.param(
|
|
'hp3par_snapshot_expiration',
|
|
type='string',
|
|
default='',
|
|
description="The time in hours when a snapshot expires and is deleted."
|
|
" This must be larger than expiration")
|
|
|
|
cinder.param(
|
|
'hp3par_debug',
|
|
type='boolean',
|
|
default='false',
|
|
description="Enable HTTP debugging to 3PAR")
|
|
|
|
cinder.param(
|
|
'hp3par_iscsi_ips',
|
|
type='list',
|
|
default='',
|
|
description="List of target iSCSI addresses to use.")
|
|
|
|
cinder.param(
|
|
'san_thin_provision',
|
|
type='boolean',
|
|
default='true',
|
|
description="Use thin provisioning for SAN volumes?")
|
|
|
|
cinder.param(
|
|
'san_ip',
|
|
type='string',
|
|
default='',
|
|
description="IP address of SAN controller")
|
|
|
|
cinder.param(
|
|
'san_login',
|
|
type='string',
|
|
default='admin',
|
|
description="Username for SAN controller")
|
|
|
|
cinder.param(
|
|
'san_password',
|
|
type='string',
|
|
default='',
|
|
description="Password for SAN controller")
|
|
|
|
cinder.param(
|
|
'san_private_key',
|
|
type='string',
|
|
default='',
|
|
description="Filename of private key to use for SSH authentication")
|
|
|
|
cinder.param(
|
|
'san_clustername',
|
|
type='string',
|
|
default='',
|
|
description="Cluster name to use for creating volumes")
|
|
|
|
cinder.param(
|
|
'san_ssh_port',
|
|
type='integer',
|
|
default='22',
|
|
description="SSH port to use with SAN")
|
|
|
|
cinder.param(
|
|
'san_is_local',
|
|
type='boolean',
|
|
default='false',
|
|
description="Execute commands locally instead of over SSH; use if "
|
|
"the volume service is running on the SAN device")
|
|
|
|
cinder.param(
|
|
'ssh_conn_timeout',
|
|
type='integer',
|
|
default='30',
|
|
description="SSH connection timeout in seconds")
|
|
|
|
cinder.param(
|
|
'ssh_min_pool_conn',
|
|
type='integer',
|
|
default='1',
|
|
description="Minimum ssh connections in the pool")
|
|
|
|
cinder.param(
|
|
'ssh_max_pool_conn',
|
|
type='integer',
|
|
default='5',
|
|
description="Maximum ssh connections in the pool")
|
|
|
|
cinder.param(
|
|
'san_zfs_volume_base',
|
|
type='string',
|
|
default='rpool/',
|
|
description="The ZFS path under which to create zvols for volumes.")
|
|
|
|
cinder.param(
|
|
'scality_sofs_config',
|
|
type='string',
|
|
default='<None>',
|
|
description="Path or URL to Scality SOFS configuration file")
|
|
|
|
cinder.param(
|
|
'scality_sofs_mount_point',
|
|
type='string',
|
|
default='$state_path/scality',
|
|
description="Base dir where Scality SOFS shall be mounted")
|
|
|
|
cinder.param(
|
|
'scality_sofs_volume_dir',
|
|
type='string',
|
|
default='cinder/volumes',
|
|
description="Path from Scality SOFS root to volume dir")
|
|
|
|
cinder.param(
|
|
'sf_emulate_512',
|
|
type='boolean',
|
|
default='true',
|
|
description="Set 512 byte emulation on volume creation; ")
|
|
|
|
cinder.param(
|
|
'sf_allow_tenant_qos',
|
|
type='boolean',
|
|
default='false',
|
|
description="Allow tenants to specify QOS on create")
|
|
|
|
cinder.param(
|
|
'sf_account_prefix',
|
|
type='string',
|
|
default='cinder',
|
|
description="Create SolidFire accounts with this prefix")
|
|
|
|
cinder.param(
|
|
'sf_api_port',
|
|
type='integer',
|
|
default='443',
|
|
description="SolidFire API port. Useful if the device api is behind a "
|
|
"proxy on a different port.")
|
|
|
|
cinder.param(
|
|
'storwize_svc_volpool_name',
|
|
type='string',
|
|
default='volpool',
|
|
description="Storage system storage pool for volumes")
|
|
|
|
cinder.param(
|
|
'storwize_svc_vol_rsize',
|
|
type='integer',
|
|
default='2',
|
|
description="Storage system space-efficiency parameter for volumes")
|
|
|
|
cinder.param(
|
|
'storwize_svc_vol_warning',
|
|
type='integer',
|
|
default='0',
|
|
description="Storage system threshold for volume capacity warnings")
|
|
|
|
cinder.param(
|
|
'storwize_svc_vol_autoexpand',
|
|
type='boolean',
|
|
default='true',
|
|
description="Storage system autoexpand parameter for volumes")
|
|
|
|
cinder.param(
|
|
'storwize_svc_vol_grainsize',
|
|
type='integer',
|
|
default='256',
|
|
description="Storage system grain size parameter for volumes")
|
|
|
|
cinder.param(
|
|
'storwize_svc_vol_compression',
|
|
type='boolean',
|
|
default='false',
|
|
description="Storage system compression option for volumes")
|
|
|
|
cinder.param(
|
|
'storwize_svc_vol_easytier',
|
|
type='boolean',
|
|
default='true',
|
|
description="Enable Easy Tier for volumes")
|
|
|
|
cinder.param(
|
|
'storwize_svc_vol_iogrp',
|
|
type='integer',
|
|
default='0',
|
|
description="The I/O group in which to allocate volumes")
|
|
|
|
cinder.param(
|
|
'storwize_svc_flashcopy_timeout',
|
|
type='integer',
|
|
default='120',
|
|
description="Maximum number of seconds to wait for FlashCopy to be"
|
|
" prepared. Maximum value is 600 seconds")
|
|
|
|
cinder.param(
|
|
'storwize_svc_connection_protocol',
|
|
type='string',
|
|
default='iSCSI',
|
|
description="Connection protocol")
|
|
|
|
cinder.param(
|
|
'storwize_svc_multipath_enabled',
|
|
type='boolean',
|
|
default='false',
|
|
description="Connect with multipath")
|
|
|
|
cinder.param(
|
|
'storwize_svc_multihostmap_enabled',
|
|
type='boolean',
|
|
default='true',
|
|
description="Allows vdisk to multi host mapping")
|
|
|
|
cinder.param(
|
|
'vmware_host_ip',
|
|
type='string',
|
|
default='<None>',
|
|
description="IP address for connecting to VMware ESX/VC server.")
|
|
|
|
cinder.param(
|
|
'vmware_host_username',
|
|
type='string',
|
|
default='<None>',
|
|
description="Username for authenticating with VMware ESX/VC server.")
|
|
|
|
cinder.param(
|
|
'vmware_host_password',
|
|
type='string',
|
|
default='<None>',
|
|
description="Password for authenticating with VMware ESX/VC server.")
|
|
|
|
cinder.param(
|
|
'vmware_wsdl_location',
|
|
type='string',
|
|
default='<None>',
|
|
description="Optional VIM service WSDL Location e.g "
|
|
"http://<server>/vimService.wsdl. Optional over-ride to "
|
|
"default location for bug work-arounds.")
|
|
|
|
cinder.param(
|
|
'vmware_api_retry_count',
|
|
type='integer',
|
|
default='10',
|
|
description="Number of times VMware ESX/VC server API must be retried "
|
|
"upon connection related issues.")
|
|
|
|
cinder.param(
|
|
'vmware_task_poll_interval',
|
|
type='integer',
|
|
default='5',
|
|
description="The interval used for polling remote tasks invoked on "
|
|
"VMware ESX/VC server.")
|
|
|
|
cinder.param(
|
|
'vmware_volume_folder',
|
|
type='string',
|
|
default='cinder-volumes',
|
|
description="Name for the folder in the VC datacenter that will contain "
|
|
"cinder volumes.")
|
|
|
|
cinder.param(
|
|
'vmware_image_transfer_timeout_secs',
|
|
type='integer',
|
|
default='7200',
|
|
description="Timeout in seconds for VMDK volume transfer between Cinder "
|
|
"and Glance.")
|
|
|
|
cinder.param(
|
|
'windows_iscsi_lun_path',
|
|
type='string',
|
|
default='C:\iSCSIVirtualDisks',
|
|
description="Path to store VHD backed volumes")
|
|
|
|
cinder.param(
|
|
'xenapi_nfs_server',
|
|
type='string',
|
|
default='<None>',
|
|
description="NFS server to be used by XenAPINFSDriver")
|
|
|
|
cinder.param(
|
|
'xenapi_nfs_serverpath',
|
|
type='string',
|
|
default='<None>',
|
|
description="Path of exported NFS, used by XenAPINFSDriver")
|
|
|
|
cinder.param(
|
|
'xenapi_connection_url',
|
|
type='string',
|
|
default='<None>',
|
|
description="URL for XenAPI connection")
|
|
|
|
cinder.param(
|
|
'xenapi_connection_username',
|
|
type='string',
|
|
default='root',
|
|
description="Username for XenAPI connection")
|
|
|
|
cinder.param(
|
|
'xenapi_connection_password',
|
|
type='string',
|
|
default='<None>',
|
|
description="Password for XenAPI connection")
|
|
|
|
cinder.param(
|
|
'xenapi_sr_base_path',
|
|
type='string',
|
|
default='/var/run/sr-mount',
|
|
description="Base path to the storage repository")
|
|
|
|
cinder.param(
|
|
'xiv_ds8k_proxy',
|
|
type='string',
|
|
default='xiv_ds8k_openstack.nova_proxy.XIVDS8KNovaProxy',
|
|
description="Proxy driver that connects to the IBM Storage Array")
|
|
|
|
cinder.param(
|
|
'xiv_ds8k_connection_type',
|
|
type='string',
|
|
default='iscsi',
|
|
description="Connection type to the IBM Storage Array")
|
|
|
|
cinder.param(
|
|
'zadara_vpsa_ip',
|
|
type='string',
|
|
default='<None>',
|
|
description="Management IP of Zadara VPSA")
|
|
|
|
cinder.param(
|
|
'zadara_vpsa_port',
|
|
type='string',
|
|
default='<None>',
|
|
description="Zadara VPSA port number")
|
|
|
|
cinder.param(
|
|
'zadara_vpsa_use_ssl',
|
|
type='boolean',
|
|
default='false',
|
|
description="Use SSL connection")
|
|
|
|
cinder.param(
|
|
'zadara_user',
|
|
type='string',
|
|
default='<None>',
|
|
description="User name for the VPSA")
|
|
|
|
cinder.param(
|
|
'zadara_password',
|
|
type='string',
|
|
default='<None>',
|
|
description="Password for the VPSA")
|
|
|
|
cinder.param(
|
|
'zadara_vpsa_poolname',
|
|
type='string',
|
|
default='<None>',
|
|
description="Name of VPSA storage pool for volumes")
|
|
|
|
cinder.param(
|
|
'zadara_vol_thin',
|
|
type='boolean',
|
|
default='true',
|
|
description="Default thin provisioning policy for volumes")
|
|
|
|
cinder.param(
|
|
'zadara_vol_encrypt',
|
|
type='boolean',
|
|
default='false',
|
|
description="Default encryption policy for volumes")
|
|
|
|
cinder.param(
|
|
'zadara_default_striping_mode',
|
|
type='string',
|
|
default='simple',
|
|
description="Default striping mode for volumes")
|
|
|
|
cinder.param(
|
|
'zadara_default_stripesize',
|
|
type='string',
|
|
default='64',
|
|
description="Default stripe size for volumes")
|
|
|
|
cinder.param(
|
|
'zadara_vol_name_template',
|
|
type='string',
|
|
default='OS_%s',
|
|
description="Default template for VPSA volume names")
|
|
|
|
cinder.param(
|
|
'zadara_vpsa_auto_detach_on_delete',
|
|
type='boolean',
|
|
default='true',
|
|
description="Automatically detach from servers on volume delete")
|
|
|
|
cinder.param(
|
|
'zadara_vpsa_allow_nonexistent_delete',
|
|
type='boolean',
|
|
default='true',
|
|
description="Don't halt on deletion of non-existing volumes")
|
|
|
|
cinder.param(
|
|
'volume_driver',
|
|
type='string',
|
|
default='cinder.volume.drivers.lvm.LVMISCSIDriver',
|
|
description="Driver to use for volume creation")
|
|
|
|
cinder.param(
|
|
'migration_create_volume_timeout_secs',
|
|
type='integer',
|
|
default='300',
|
|
description="Timeout for creating the volume to migrate to when "
|
|
"performing volume migration")
|
|
|
|
cinder.param(
|
|
'volume_dd_blocksize',
|
|
type='string',
|
|
default='1M',
|
|
description="The default block size used when copying/clearing volumes")
|
|
|
|
cinder.commit()
|