Created
January 19, 2012 10:43
-
-
Save zyluo/1639355 to your computer and use it in GitHub Desktop.
OpenStack flag list
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
=== nova.image.s3.py === | |
string('image_decryption_dir', '/tmp', 'parent dir for tempdir used for image decryption') | |
string('s3_access_key', 'notchecked', 'access key to use for s3 server for images') | |
string('s3_secret_key', 'notchecked', 'secret key to use for s3 server for images') | |
=== nova.compute.api.py === | |
integer('find_host_timeout', 30, 'Timeout after NN seconds when looking for a host.') | |
=== nova.compute.manager.py === | |
string('instances_path', '$state_path/instances', 'where instances are stored on disk') | |
string('compute_driver', 'nova.virt.connection.get_connection', 'Driver to use for controlling virtualization') | |
string('console_host', socket.gethostname(), 'Console proxy host to use to connect to instances on' 'this host.') | |
integer('live_migration_retry_count', 30, "Retry count needed in live_migration." " sleep 1 sec for each count") | |
integer("reboot_timeout", 0, "Automatically hard reboot an instance if it has been " "stuck in a rebooting state longer than N seconds." " Set to 0 to disable.") | |
integer("rescue_timeout", 0, "Automatically unrescue an instance after N seconds." " Set to 0 to disable.") | |
integer("resize_confirm_window", 0, "Automatically confirm resizes after N seconds." " Set to 0 to disable.") | |
integer('host_state_interval', 120, 'Interval in seconds for querying the host status') | |
integer("running_deleted_instance_timeout", 0, "Number of seconds after being deleted when a" " still-running instance should be considered" " eligible for cleanup.") | |
integer("running_deleted_instance_poll_interval", 30, "Number of periodic scheduler ticks to wait between" " runs of the cleanup task.") | |
string("running_deleted_instance_action", "noop", "Action to take if a running deleted instance is" " detected. Valid options are 'noop', 'log', and" " 'reap'. Set to 'noop' to disable.") | |
=== nova.flags.py === | |
string('my_ip', _get_my_ip(), 'host ip address') | |
list('region_list', [], 'list of region=fqdn pairs separated by commas') | |
string('connection_type', 'libvirt', 'libvirt, xenapi or fake') | |
string('aws_access_key_id', 'admin', 'AWS Access ID') | |
string('aws_secret_access_key', 'admin', 'AWS Access Key') | |
string('glance_host', _get_my_ip(), 'default glance host') | |
integer('glance_port', 9292, 'default glance port') | |
list('glance_api_servers', ['%s:%d' % (FLAGS.glance_host, FLAGS.glance_port)], 'list of glance api servers available to nova (host:port)') | |
integer('glance_num_retries', 0, 'The number of times to retry downloading an image from glance') | |
integer('s3_port', 3333, 's3 port') | |
string('s3_host', '$my_ip', 's3 host (for infrastructure)') | |
string('s3_dmz', '$my_ip', 's3 dmz ip (for instances)') | |
string('compute_topic', 'compute', 'the topic compute nodes listen on') | |
string('console_topic', 'console', 'the topic console proxy nodes listen on') | |
string('scheduler_topic', 'scheduler', 'the topic scheduler nodes listen on') | |
string('volume_topic', 'volume', 'the topic volume nodes listen on') | |
string('network_topic', 'network', 'the topic network nodes listen on') | |
string('ajax_console_proxy_topic', 'ajax_proxy', 'the topic ajax proxy nodes listen on') | |
string('ajax_console_proxy_url', 'http://127.0.0.1:8000', 'location of ajax console proxy, \ in the form "http://127.0.0.1:8000"') | |
integer('ajax_console_proxy_port', 8000, 'port that ajax_console_proxy binds') | |
string('vsa_topic', 'vsa', 'the topic that nova-vsa service listens on') | |
bool('verbose', False, 'show debug output') | |
boolean('fake_rabbit', False, 'use a fake rabbit') | |
bool('fake_network', False, 'should we use fake network devices and addresses') | |
string('rabbit_host', 'localhost', 'rabbit host') | |
integer('rabbit_port', 5672, 'rabbit port') | |
bool('rabbit_use_ssl', False, 'connect over SSL') | |
string('rabbit_userid', 'guest', 'rabbit userid') | |
string('rabbit_password', 'guest', 'rabbit password') | |
string('rabbit_virtual_host', '/', 'rabbit virtual host') | |
integer('rabbit_retry_interval', 1, 'rabbit connection retry interval to start') | |
integer('rabbit_retry_backoff', 2, 'rabbit connection retry backoff in seconds') | |
integer('rabbit_max_retries', 0, 'maximum rabbit connection attempts (0=try forever)') | |
string('control_exchange', 'nova', 'the main exchange to connect to') | |
boolean('rabbit_durable_queues', False, 'use durable queues') | |
list('enabled_apis', ['ec2', 'osapi_compute', 'osapi_volume', 'metadata'], 'list of APIs to enable by default') | |
string('ec2_host', '$my_ip', 'ip of api server') | |
string('ec2_dmz_host', '$my_ip', 'internal ip of api server') | |
integer('ec2_port', 8773, 'cloud controller port') | |
string('ec2_scheme', 'http', 'prefix for ec2') | |
string('ec2_path', '/services/Cloud', 'suffix for ec2') | |
multistring('osapi_compute_extension', ['nova.api.openstack.compute.contrib.standard_extensions'], 'osapi compute extension to load') | |
multistring('osapi_volume_extension', ['nova.api.openstack.volume.contrib.standard_extensions'], 'osapi volume extension to load') | |
string('osapi_scheme', 'http', 'prefix for openstack') | |
string('osapi_path', '/v1.1/', 'suffix for openstack') | |
integer('osapi_max_limit', 1000, 'max number of items returned in a collection response') | |
string('metadata_host', '$my_ip', 'ip of metadata server') | |
integer('metadata_port', 8775, 'Metadata API port') | |
string('default_project', 'openstack', 'default project for openstack') | |
string('default_image', 'ami-11111', 'default image to use, testing only') | |
string('default_instance_type', 'm1.small', 'default instance type to use, testing only') | |
string('null_kernel', 'nokernel', 'kernel image that indicates not to use a kernel,' ' but to use a raw disk image instead') | |
string('vpn_image_id', '0', 'image id for cloudpipe vpn server') | |
string('vpn_key_suffix', '-vpn', 'Suffix to add to project name for vpn key and secgroups') | |
integer('auth_token_ttl', 3600, 'Seconds for auth tokens to linger') | |
string('state_path', os.path.join(os.path.dirname(__file__), '../'), "Top-level directory for maintaining nova's state") | |
string('lock_path', os.path.join(os.path.dirname(__file__), '../'), 'Directory for lock files') | |
string('logdir', None, 'output to a per-service log file in named ' 'directory') | |
string('logfile_mode', '0644', 'Default file mode of the logs.') | |
string('sqlite_db', 'nova.sqlite', 'file name for sqlite') | |
bool('sqlite_synchronous', True, 'Synchronous mode for sqlite') | |
string('sql_connection', 'sqlite:///$state_path/$sqlite_db', 'connection string for sql database') | |
integer('sql_idle_timeout', 3600, 'timeout for idle sql database connections') | |
integer('sql_max_retries', 12, 'sql connection attempts') | |
integer('sql_retry_interval', 10, 'sql connection retry interval') | |
string('compute_manager', 'nova.compute.manager.ComputeManager', 'Manager for compute') | |
string('console_manager', 'nova.console.manager.ConsoleProxyManager', 'Manager for console proxy') | |
string('instance_dns_manager', 'nova.network.dns_driver.DNSDriver', 'DNS Manager for instance IPs') | |
string('instance_dns_domain', '', 'DNS Zone for instance IPs') | |
string('floating_ip_dns_manager', 'nova.network.dns_driver.DNSDriver', 'DNS Manager for floating IPs') | |
string('network_manager', 'nova.network.manager.VlanManager', 'Manager for network') | |
string('volume_manager', 'nova.volume.manager.VolumeManager', 'Manager for volume') | |
string('scheduler_manager', 'nova.scheduler.manager.SchedulerManager', 'Manager for scheduler') | |
string('vsa_manager', 'nova.vsa.manager.VsaManager', 'Manager for vsa') | |
string('vc_image_name', 'vc_image', 'the VC image ID (for a VC image that exists in DB Glance)') | |
string('default_vsa_instance_type', 'm1.small', 'default instance type for VSA instances') | |
integer('max_vcs_in_vsa', 32, 'maxinum VCs in a VSA') | |
integer('vsa_part_size_gb', 100, 'default partition size for shared capacity') | |
string('firewall_driver', 'nova.virt.libvirt.firewall.IptablesFirewallDriver', 'Firewall driver (defaults to iptables)') | |
string('image_service', 'nova.image.glance.GlanceImageService', 'The service to use for retrieving and searching for images.') | |
string('host', socket.gethostname(), 'Name of this node. This can be an opaque identifier. It is ' 'not necessarily a hostname, FQDN, or IP address.') | |
string('node_availability_zone', 'nova', 'availability zone of this node') | |
string('notification_driver', 'nova.notifier.no_op_notifier', 'Default driver for sending notifications') | |
list('memcached_servers', None, 'Memcached servers or None for in process cache.') | |
string('zone_name', 'nova', 'name of this zone') | |
list('zone_capabilities', ['hypervisor=xenserver;kvm', 'os=linux;windows'], 'Key/Multi-value list representng capabilities of this zone') | |
string('build_plan_encryption_key', None, '128bit (hex) encryption key for scheduler build plans.') | |
string('instance_usage_audit_period', 'month', 'time period to generate instance usages for.') | |
integer('bandwith_poll_interval', 600, 'interval to pull bandwidth usage info') | |
bool('start_guests_on_host_boot', False, 'Whether to restart guests when the host reboots') | |
bool('resume_guests_state_on_host_boot', False, 'Whether to start guests, that was running before the host reboot') | |
string('root_helper', 'sudo', 'Command prefix to use for running commands as root') | |
string('network_driver', 'nova.network.linux_net', 'Driver to use for network creation') | |
bool('use_ipv6', False, 'use ipv6') | |
integer('password_length', 12, 'Length of generated instance admin passwords') | |
bool('monkey_patch', False, 'Whether to log monkey patching') | |
list('monkey_patch_modules', ['nova.api.ec2.cloud:nova.notifier.api.notify_decorator', 'nova.compute.api:nova.notifier.api.notify_decorator'], 'Module list representing monkey ' 'patched module and decorator') | |
bool('allow_resize_to_same_host', False, 'Allow destination machine to match source for resize. Useful' ' when testing in environments with only one host machine.') | |
string('stub_network', False, 'Stub network related code') | |
integer('reclaim_instance_interval', 0, 'Interval in seconds for reclaiming deleted instances') | |
integer('zombie_instance_updated_at_window', 172800, 'Limit in seconds that a zombie instance can exist before ' 'being cleaned up.') | |
boolean('allow_ec2_admin_api', False, 'Enable/Disable EC2 Admin API') | |
=== nova.network.linux_net.py === | |
string('dhcpbridge_flagfile', '/etc/nova/nova-dhcpbridge.conf', 'location of flagfile for dhcpbridge') | |
string('networks_path', '$state_path/networks', 'Location to keep network config files') | |
string('public_interface', 'eth0', 'Interface for public IP addresses') | |
string('network_device_mtu', None, 'MTU setting for vlan') | |
string('dhcpbridge', _bin_file('nova-dhcpbridge'), 'location of nova-dhcpbridge') | |
string('routing_source_ip', '$my_ip', 'Public IP of network host') | |
integer('dhcp_lease_time', 120, 'Lifetime of a DHCP lease in seconds') | |
string('dns_server', None, 'if set, uses specific dns server for dnsmasq') | |
string('dmz_cidr', '10.128.0.0/24', 'dmz range that should be accepted') | |
string('dnsmasq_config_file', "", 'Override the default dnsmasq settings with this file') | |
string('linuxnet_interface_driver', 'nova.network.linux_net.LinuxBridgeInterfaceDriver', 'Driver used to create ethernet devices.') | |
string('linuxnet_ovs_integration_bridge', 'br-int', 'Name of Open vSwitch bridge used with linuxnet') | |
bool('send_arp_for_ha', False, 'send gratuitous ARPs for HA setup') | |
bool('use_single_default_gateway', False, 'Use single default gateway. Only first nic of vm' ' will get default gateway from dhcp server') | |
=== nova.network.quantum.quantum_connection.py === | |
string('quantum_connection_host', '127.0.0.1', 'HOST for connecting to quantum') | |
string('quantum_connection_port', '9696', 'PORT for connecting to quantum') | |
string('quantum_default_tenant_id', "default", 'Default tenant id when creating quantum networks') | |
=== nova.network.quantum.melange_connection.py === | |
string('melange_host', '127.0.0.1', 'HOST for connecting to melange') | |
string('melange_port', '9898', 'PORT for connecting to melange') | |
=== nova.network.quantum.manager.py === | |
string('quantum_ipam_lib', 'nova.network.quantum.nova_ipam_lib', "Indicates underlying IP address management library") | |
bool('use_melange_mac_generation', False, "Use Melange for assignment of MAC addresses") | |
bool('quantum_use_dhcp', False, 'Whether or not to enable DHCP for networks') | |
bool('quantum_use_port_security', False, 'Whether or not to enable port security') | |
=== nova.network.manager.py === | |
string('flat_network_bridge', None, 'Bridge for simple network instances') | |
string('flat_network_dns', '8.8.4.4', 'Dns for simple network') | |
bool('flat_injected', False, 'Whether to attempt to inject network setup into guest') | |
string('flat_interface', None, 'FlatDhcp will bridge into this interface if set') | |
integer('vlan_start', 100, 'First VLAN for private networks') | |
string('vlan_interface', None, 'vlans will bridge into this interface if set') | |
integer('num_networks', 1, 'Number of networks to support') | |
string('vpn_ip', '$my_ip', 'Public IP for the cloudpipe VPN servers') | |
integer('vpn_start', 1000, 'First Vpn port for private networks') | |
bool('multi_host', False, 'Default value for multi_host in networks') | |
integer('network_size', 256, 'Number of addresses in each private subnet') | |
string('floating_range', '4.4.4.0/24', 'Floating IP address block') | |
string('default_floating_pool', 'nova', 'Default pool for floating ips') | |
string('fixed_range', '10.0.0.0/8', 'Fixed IP address block') | |
string('fixed_range_v6', 'fd00::/48', 'Fixed IPv6 address block') | |
string('gateway', None, 'Default IPv4 gateway') | |
string('gateway_v6', None, 'Default IPv6 gateway') | |
integer('cnt_vpn_clients', 0, 'Number of addresses reserved for vpn clients') | |
bool('update_dhcp_on_disassociate', False, 'Whether to update dhcp when fixed_ip is disassociated') | |
integer('fixed_ip_disassociate_timeout', 600, 'Seconds after which a deallocated ip is disassociated') | |
integer('create_unique_mac_address_attempts', 5, 'Number of attempts to create unique mac address') | |
bool('auto_assign_floating_ip', False, 'Autoassigning floating ip to VM') | |
string('network_host', socket.gethostname(), 'Network host to use for ip allocation in flat modes') | |
bool('fake_call', False, 'If True, skip using the queue and make local calls') | |
bool('force_dhcp_release', False, 'If True, send a dhcp release on instance termination') | |
string('dhcp_domain', 'novalocal', 'domain to use for building the hostnames') | |
=== nova.network.ldapdns.py === | |
string('ldap_dns_url', 'ldap://ldap.example.com:389', 'URL for ldap server which will store dns entries') | |
string('ldap_dns_user', 'uid=admin,ou=people,dc=example,dc=org', 'user for ldap DNS') | |
string('ldap_dns_password', 'password', 'password for ldap DNS') | |
string('ldap_dns_soa_hostmaster', 'hostmaster@example.org', 'Hostmaster for ldap dns driver Statement of Authority') | |
multistring('ldap_dns_servers', '[dns.example.org]', 'DNS Servers for ldap dns driver') | |
string('ldap_dns_base_dn', 'ou=hosts,dc=example,dc=org', 'Base DN for DNS entries in ldap') | |
string('ldap_dns_soa_refresh', '1800', 'Refresh interval (in seconds) for ldap dns driver ' 'Statement of Authority') | |
string('ldap_dns_soa_retry', '3600', 'Retry interval (in seconds) for ldap dns driver ' 'Statement of Authority') | |
string('ldap_dns_soa_expiry', '86400', 'Expiry interval (in seconds) for ldap dns driver ' 'Statement of Authority') | |
string('ldap_dns_soa_minimum', '7200', 'Minimum interval (in seconds) for ldap dns driver ' 'Statement of Authority') | |
=== nova.cloudpipe.pipelib.py === | |
string('boot_script_template', utils.abspath('cloudpipe/bootscript.template'), _('Template for script to run on cloudpipe instance boot')) | |
string('dmz_net', '10.0.0.0', _('Network to push into openvpn config')) | |
string('dmz_mask', '255.255.255.0', _('Netmask to push into openvpn config')) | |
=== nova.volume.san.py === | |
boolean('san_thin_provision', 'true', 'Use thin provisioning for SAN volumes?') | |
string('san_ip', '', 'IP address of SAN controller') | |
string('san_login', 'admin', 'Username for SAN controller') | |
string('san_password', '', 'Password for SAN controller') | |
string('san_private_key', '', 'Filename of private key to use for SSH authentication') | |
string('san_clustername', '', 'Cluster name to use for creating volumes') | |
integer('san_ssh_port', 22, 'SSH port to use with SAN') | |
boolean('san_is_local', 'false', 'Execute commands locally instead of over SSH; ' 'use if the volume service is running on the SAN device') | |
string('san_zfs_volume_base', 'rpool/', 'The ZFS path under which to create zvols for volumes.') | |
=== nova.volume.iscsi.py === | |
string('iscsi_helper', 'ietadm', 'iscsi target user-land tool to use') | |
=== nova.volume.driver.py === | |
string('volume_group', 'nova-volumes', 'Name for the VG that will contain exported volumes') | |
string('num_shell_tries', 3, 'number of times to attempt to run flakey shell commands') | |
string('num_iscsi_scan_tries', 3, 'number of times to rescan iSCSI target to find volume') | |
integer('iscsi_num_targets', 100, 'Number of iscsi target ids per host') | |
string('iscsi_target_prefix', 'iqn.2010-10.org.openstack:', 'prefix for iscsi volumes') | |
string('iscsi_ip_address', '$my_ip', 'use this ip for iscsi') | |
integer('iscsi_port', 3260, 'The port that the iSCSI daemon is listening on') | |
string('rbd_pool', 'rbd', 'the rbd pool in which volumes are stored') | |
=== nova.volume.manager.py === | |
string('storage_availability_zone', 'nova', 'availability zone of this service') | |
string('volume_driver', 'nova.volume.driver.ISCSIDriver', 'Driver to use for volume creation') | |
boolean('use_local_volumes', True, 'if True, will not discover local volumes') | |
boolean('volume_force_update_capabilities', False, 'if True will force update capabilities on each check') | |
=== nova.notifier.list_notifier.py === | |
multistring('list_notifier_drivers', ['nova.notifier.no_op_notifier'], 'List of drivers to send notifications') | |
=== nova.notifier.api.py === | |
string('default_notification_level', 'INFO', 'Default notification level for outgoing notifications') | |
string('default_publisher_id', FLAGS.host, 'Default publisher_id for outgoing notifications') | |
=== nova.notifier.rabbit_notifier.py === | |
string('notification_topic', 'notifications', 'RabbitMQ topic used for Nova notifications') | |
=== nova.vnc.__init__.py === | |
string('novncproxy_base_url', 'http://127.0.0.1:6080/vnc_auto.html', 'location of vnc console proxy, \ in the form "http://127.0.0.1:6080/vnc_auto.html"') | |
string('xvpvncproxy_base_url', 'http://127.0.0.1:6081/console', 'location of nova xvp vnc console proxy, \ in the form "http://127.0.0.1:6081/console"') | |
string('vncserver_listen', '127.0.0.1', 'Ip address on which instance vncservers\ should listen') | |
string('vncserver_proxyclient_address', '127.0.0.1', 'the address to which proxy clients \ (like nova-xvpvncproxy) should connect') | |
bool('vnc_enabled', True, 'enable vnc related features') | |
string('vnc_keymap', 'en-us', 'keymap for vnc') | |
=== nova.vnc.xvp_proxy.py === | |
integer('xvpvncproxy_port', 6081, 'Port that the XCP VNC proxy should bind to') | |
string('xvpvncproxy_host', '0.0.0.0', 'Address that the XCP VNC proxy should bind to') | |
=== nova.rpc.__init__.py === | |
string('rpc_backend', 'nova.rpc.impl_kombu', "The messaging module to use, defaults to kombu.") | |
=== nova.rpc.common.py === | |
integer('rpc_thread_pool_size', 1024, 'Size of RPC thread pool') | |
integer('rpc_conn_pool_size', 30, 'Size of RPC connection pool') | |
=== nova.crypto.py === | |
string('ca_file', 'cacert.pem', _('Filename of root CA')) | |
string('key_file', os.path.join('private', 'cakey.pem'), _('Filename of private key')) | |
string('crl_file', 'crl.pem', _('Filename of root Certificate Revocation List')) | |
string('keys_path', '$state_path/keys', _('Where we keep our keys')) | |
string('ca_path', '$state_path/CA', _('Where we keep our root CA')) | |
boolean('use_project_ca', False, _('Should we use a CA for each project?')) | |
string('user_cert_subject', '/C=US/ST=California/L=MountainView/O=AnsoLabs/' 'OU=NovaDev/CN=%s-%s-%s', _('Subject for certificate for users, ' '%s for project, user, timestamp')) | |
string('project_cert_subject', '/C=US/ST=California/L=MountainView/O=AnsoLabs/' 'OU=NovaDev/CN=project-ca-%s-%s', _('Subject for certificate for projects, ' '%s for project, timestamp')) | |
=== nova.auth.ldapdriver.py === | |
integer('ldap_schema_version', 2, 'Current version of the LDAP schema') | |
string('ldap_url', 'ldap://localhost', 'Point this at your ldap server') | |
string('ldap_password', 'changeme', 'LDAP password') | |
string('ldap_user_dn', 'cn=Manager,dc=example,dc=com', 'DN of admin user') | |
string('ldap_user_id_attribute', 'uid', 'Attribute to use as id') | |
string('ldap_user_name_attribute', 'cn', 'Attribute to use as name') | |
string('ldap_user_unit', 'Users', 'OID for Users') | |
string('ldap_user_subtree', 'ou=Users,dc=example,dc=com', 'OU for Users') | |
boolean('ldap_user_modify_only', False, 'Modify attributes for users instead of creating/deleting') | |
string('ldap_project_subtree', 'ou=Groups,dc=example,dc=com', 'OU for Projects') | |
string('role_project_subtree', 'ou=Groups,dc=example,dc=com', 'OU for Roles') | |
string('ldap_cloudadmin', 'cn=cloudadmins,ou=Groups,dc=example,dc=com', 'cn for Cloud Admins') | |
string('ldap_itsec', 'cn=itsec,ou=Groups,dc=example,dc=com', 'cn for ItSec') | |
string('ldap_sysadmin', 'cn=sysadmins,ou=Groups,dc=example,dc=com', 'cn for Sysadmins') | |
string('ldap_netadmin', 'cn=netadmins,ou=Groups,dc=example,dc=com', 'cn for NetAdmins') | |
string('ldap_developer', 'cn=developers,ou=Groups,dc=example,dc=com', 'cn for Developers') | |
=== nova.auth.manager.py === | |
bool('use_deprecated_auth', False, 'This flag must be set to use old style auth') | |
list('allowed_roles', ['cloudadmin', 'itsec', 'sysadmin', 'netadmin', 'developer'], 'Allowed roles for project') | |
list('superuser_roles', ['cloudadmin'], 'Roles that ignore authorization checking completely') | |
list('global_roles', ['cloudadmin', 'itsec'], 'Roles that apply to all projects') | |
string('credentials_template', utils.abspath('auth/novarc.template'), 'Template for creating users rc file') | |
string('vpn_client_template', utils.abspath('cloudpipe/client.ovpn.template'), 'Template for creating users vpn file') | |
string('credential_vpn_file', 'nova-vpn.conf', 'Filename of certificate in credentials zip') | |
string('credential_key_file', 'pk.pem', 'Filename of private key in credentials zip') | |
string('credential_cert_file', 'cert.pem', 'Filename of certificate in credentials zip') | |
string('credential_rc_file', '%src', 'Filename of rc in credentials zip, %s will be ' 'replaced by name of the region (nova by default)') | |
string('auth_driver', 'nova.auth.dbdriver.DbDriver', 'Driver that auth manager uses') | |
=== nova.scheduler.least_cost.py === | |
list('least_cost_functions', ['nova.scheduler.least_cost.compute_fill_first_cost_fn'], 'Which cost functions the LeastCostScheduler should use.') | |
float('noop_cost_fn_weight', 1.0, 'How much weight to give the noop cost function') | |
float('compute_fill_first_cost_fn_weight', 1.0, 'How much weight to give the fill-first cost function') | |
=== nova.scheduler.vsa.py === | |
integer('drive_type_approx_capacity_percent', 10, 'The percentage range for capacity comparison') | |
integer('vsa_unique_hosts_per_alloc', 10, 'The number of unique hosts per storage allocation') | |
boolean('vsa_select_unique_drives', True, 'Allow selection of same host for multiple drives') | |
=== nova.scheduler.simple.py === | |
integer("max_cores", 16, "maximum number of instance cores to allow per host") | |
integer("max_gigabytes", 10000, "maximum number of volume gigabytes to allow per host") | |
integer("max_networks", 1000, "maximum number of networks to allow per host") | |
string('default_schedule_zone', None, 'zone to use when user doesnt specify one') | |
list('isolated_images', [], 'Images to run on isolated host') | |
list('isolated_hosts', [], 'Host reserved for specific images') | |
boolean('skip_isolated_core_check', True, 'Allow overcommitting vcpus on isolated hosts') | |
=== nova.scheduler.api.py === | |
bool('enable_zone_routing', False, 'When True, routing to child zones will occur.') | |
=== nova.scheduler.scheduler_options.py === | |
string('scheduler_json_config_location', '', 'Absolute path to scheduler configuration JSON file.') | |
=== nova.scheduler.zone_manager.py === | |
integer('zone_db_check_interval', 60, 'Seconds between getting fresh zone info from db.') | |
integer('zone_failures_to_offline', 3, 'Number of consecutive errors before marking zone offline') | |
=== nova.scheduler.driver.py === | |
integer('service_down_time', 60, 'maximum time since last check-in for up service') | |
string('scheduler_host_manager', 'nova.scheduler.host_manager.HostManager', 'The scheduler host manager class to use') | |
string('scheduler_zone_manager', 'nova.scheduler.zone_manager.ZoneManager', 'The scheduler zone manager class to use') | |
=== nova.scheduler.host_manager.py === | |
integer('reserved_host_disk_mb', 0, 'Amount of disk in MB to reserve for host/dom0') | |
integer('reserved_host_memory_mb', 512, 'Amount of memory in MB to reserve for host/dom0') | |
list('default_host_filters', ['ComputeFilter'], 'Which filters to use for filtering hosts when not specified ' 'in the request.') | |
=== nova.scheduler.manager.py === | |
string('scheduler_driver', 'nova.scheduler.multi.MultiScheduler', 'Default driver to use for the scheduler') | |
=== nova.scheduler.multi.py === | |
string('compute_scheduler_driver', 'nova.scheduler.chance.ChanceScheduler', 'Driver to use for scheduling compute calls') | |
string('volume_scheduler_driver', 'nova.scheduler.chance.ChanceScheduler', 'Driver to use for scheduling volume calls') | |
=== nova.quota.py === | |
integer('quota_instances', 10, 'number of instances allowed per project') | |
integer('quota_cores', 20, 'number of instance cores allowed per project') | |
integer('quota_ram', 50 * 1024, 'megabytes of instance ram allowed per project') | |
integer('quota_volumes', 10, 'number of volumes allowed per project') | |
integer('quota_gigabytes', 1000, 'number of volume gigabytes allowed per project') | |
integer('quota_floating_ips', 10, 'number of floating ips allowed per project') | |
integer('quota_metadata_items', 128, 'number of metadata items allowed per instance') | |
integer('quota_max_injected_files', 5, 'number of injected files allowed') | |
integer('quota_max_injected_file_content_bytes', 10 * 1024, 'number of bytes allowed per injected file') | |
integer('quota_max_injected_file_path_bytes', 255, 'number of bytes allowed per injected file path') | |
=== nova.virt.firewall.py === | |
bool('allow_same_net_traffic', True, 'Whether to allow network traffic from same network') | |
=== nova.virt.vmwareapi_conn.py === | |
string('vmwareapi_host_ip', None, 'URL for connection to VMWare ESX host.' 'Required if connection_type is vmwareapi.') | |
string('vmwareapi_host_username', None, 'Username for connection to VMWare ESX host.' 'Used only if connection_type is vmwareapi.') | |
string('vmwareapi_host_password', None, 'Password for connection to VMWare ESX host.' 'Used only if connection_type is vmwareapi.') | |
float('vmwareapi_task_poll_interval', 5.0, 'The interval used for polling of remote tasks ' 'Used only if connection_type is vmwareapi') | |
float('vmwareapi_api_retry_count', 10, 'The number of times we retry on failures, ' 'e.g., socket error, etc.' 'Used only if connection_type is vmwareapi') | |
string('vmwareapi_vlan_interface', 'vmnic0', 'Physical ethernet adapter name for vlan networking') | |
=== nova.virt.libvirt.vif.py === | |
string('libvirt_ovs_bridge', 'br-int', 'Name of Integration Bridge used by Open vSwitch') | |
=== nova.virt.libvirt.connection.py === | |
string('rescue_image_id', None, 'Rescue ami image') | |
string('rescue_kernel_id', None, 'Rescue aki image') | |
string('rescue_ramdisk_id', None, 'Rescue ari image') | |
string('libvirt_xml_template', utils.abspath('virt/libvirt.xml.template'), 'Libvirt XML Template') | |
string('libvirt_type', 'kvm', 'Libvirt domain type (valid options are: ' 'kvm, lxc, qemu, uml, xen)') | |
string('libvirt_uri', '', 'Override the default libvirt URI (which is dependent' ' on libvirt_type)') | |
bool('use_cow_images', True, 'Whether to use cow images') | |
string('ajaxterm_portrange', '10000-12000', 'Range of ports that ajaxterm should randomly try to bind') | |
string('cpuinfo_xml_template', utils.abspath('virt/cpuinfo.xml.template'), 'CpuInfo XML Template (Used only live migration now)') | |
string('live_migration_uri', "qemu+tcp://%s/system", 'Define protocol used by live_migration feature') | |
string('live_migration_flag', "VIR_MIGRATE_UNDEFINE_SOURCE, VIR_MIGRATE_PEER2PEER", 'Define live migration behavior.') | |
string('block_migration_flag', "VIR_MIGRATE_UNDEFINE_SOURCE, VIR_MIGRATE_PEER2PEER, " "VIR_MIGRATE_NON_SHARED_INC", 'Define block migration behavior.') | |
integer('live_migration_bandwidth', 0, 'Define live migration behavior') | |
string('snapshot_image_format', None, 'Snapshot image format (valid options are : ' 'raw, qcow2, vmdk, vdi).' 'Defaults to same as source image') | |
string('libvirt_vif_type', 'bridge', 'Type of VIF to create.') | |
string('libvirt_vif_driver', 'nova.virt.libvirt.vif.LibvirtBridgeDriver', 'The libvirt VIF driver to configure the VIFs.') | |
list('libvirt_volume_drivers', ['iscsi=nova.virt.libvirt.volume.LibvirtISCSIVolumeDriver', 'local=nova.virt.libvirt.volume.LibvirtVolumeDriver', 'fake=nova.virt.libvirt.volume.LibvirtFakeVolumeDriver', 'rbd=nova.virt.libvirt.volume.LibvirtNetVolumeDriver', 'sheepdog=nova.virt.libvirt.volume.LibvirtNetVolumeDriver'], 'Libvirt handlers for remote volumes.') | |
string('default_local_format', None, 'The default format a local_volume will be formatted with ' 'on creation.') | |
bool('libvirt_use_virtio_for_bridges', False, 'Use virtio for bridge interfaces') | |
string('libvirt_disk_prefix', None, 'Override the default disk prefix for the devices ' 'attached to a server, which is dependent on ' 'libvirt_type. (valid options are: sd, xvd, uvd, vd)') | |
=== nova.virt.libvirt.utils.py === | |
string('qemu_img', 'qemu-img', 'binary to use for qemu-img commands') | |
=== nova.virt.vmwareapi.vim.py === | |
string('vmwareapi_wsdl_loc', None, 'VIM Service WSDL Location' 'e.g http://<server>/vimService.wsdl' 'Due to a bug in vSphere ESX 4.1 default wsdl' 'Refer readme-vmware to setup') | |
=== nova.virt.vmwareapi.vmops.py === | |
string('vmware_vif_driver', 'nova.virt.vmwareapi.vif.VMWareVlanBridgeDriver', 'The VMWare VIF driver to configure the VIFs.') | |
=== nova.virt.xenapi.vif.py === | |
string('xenapi_ovs_integration_bridge', 'xapi1', 'Name of Integration Bridge used by Open vSwitch') | |
=== nova.virt.xenapi.vm_utils.py === | |
string('default_os_type', 'linux', 'Default OS type') | |
integer('block_device_creation_timeout', 10, 'time to wait for a block device to be created') | |
integer('max_kernel_ramdisk_size', 16 * 1024 * 1024, 'maximum size in bytes of kernel or ramdisk images') | |
=== nova.virt.xenapi.vmops.py === | |
integer('agent_version_timeout', 300, 'number of seconds to wait for agent to be fully ' 'operational') | |
integer('xenapi_running_timeout', 60, 'number of seconds to wait for instance to go to ' 'running state') | |
string('xenapi_vif_driver', 'nova.virt.xenapi.vif.XenAPIBridgeDriver', 'The XenAPI VIF driver using XenServer Network APIs.') | |
bool('xenapi_generate_swap', False, 'Whether to generate swap (False means fetching it' ' from OVA)') | |
=== nova.virt.xenapi_conn.py === | |
string('xenapi_connection_url', None, 'URL for connection to XenServer/Xen Cloud Platform.' ' Required if connection_type=xenapi.') | |
string('xenapi_connection_username', 'root', 'Username for connection to XenServer/Xen Cloud Platform.' ' Used only if connection_type=xenapi.') | |
string('xenapi_connection_password', None, 'Password for connection to XenServer/Xen Cloud Platform.' ' Used only if connection_type=xenapi.') | |
integer('xenapi_connection_concurrent', 5, 'Maximum number of concurrent XenAPI connections.' ' Used only if connection_type=xenapi.') | |
float('xenapi_task_poll_interval', 0.5, 'The interval used for polling of remote tasks ' '(Async.VM.start, etc). Used only if ' 'connection_type=xenapi.') | |
float('xenapi_vhd_coalesce_poll_interval', 5.0, 'The interval used for polling of coalescing vhds.' ' Used only if connection_type=xenapi.') | |
integer('xenapi_vhd_coalesce_max_attempts', 5, 'Max number of times to poll for VHD to coalesce.' ' Used only if connection_type=xenapi.') | |
string('xenapi_agent_path', 'usr/sbin/xe-update-networking', 'Specifies the path in which the xenapi guest agent' ' should be located. If the agent is present,' ' network configuration is not injected into the image' ' Used only if connection_type=xenapi.' ' and flat_injected=True') | |
string('xenapi_sr_base_path', '/var/run/sr-mount', 'Base path to the storage repository') | |
bool('xenapi_log_instance_actions', False, 'Log all instance calls to XenAPI in the database.') | |
string('target_host', None, 'iSCSI Target Host') | |
string('target_port', '3260', 'iSCSI Target Port, 3260 Default') | |
string('iqn_prefix', 'iqn.2010-10.org.openstack', 'IQN Prefix') | |
bool('xenapi_remap_vbd_dev', False, 'Used to enable the remapping of VBD dev ' '(Works around an issue in Ubuntu Maverick)') | |
string('xenapi_remap_vbd_dev_prefix', 'sd', 'Specify prefix to remap VBD dev to ' '(ex. /dev/xvdb -> /dev/sdb)') | |
integer('xenapi_login_timeout', 10, 'Timeout in seconds for XenAPI login.') | |
=== nova.virt.disk.nbd.py === | |
integer('timeout_nbd', 10, 'time to wait for a NBD device coming up') | |
integer('max_nbd_devices', 16, 'maximum number of possible nbd devices') | |
=== nova.virt.disk.api.py === | |
integer('minimum_root_size', 1024 * 1024 * 1024 * 10, 'minimum size in bytes of root partition') | |
string('injected_network_template', utils.abspath('virt/interfaces.template'), 'Template file for injected network') | |
list('img_handlers', ['loop', 'nbd', 'guestfs'], 'Order of methods used to mount disk images') | |
multistring('virt_mkfs', ['windows=mkfs.ntfs --fast --label %(fs_label)s ' '%(target)s', # NOTE(yamahata): vfat case #'windows=mkfs.vfat -n %(fs_label)s %(target)s', 'linux=mkfs.ext3 -L %(fs_label)s -F %(target)s', 'default=mkfs.ext3 -L %(fs_label)s -F %(target)s'], 'mkfs commands for ephemeral device. The format is' '<os_type>=<mkfs command>') | |
=== nova.api.openstack.compute.__init__.py === | |
bool('allow_admin_api', False, 'When True, this API service will accept admin operations.') | |
bool('allow_instance_snapshots', True, 'When True, this API service will permit instance snapshot operations.') | |
=== nova.api.ec2.__init__.py === | |
integer('lockout_attempts', 5, 'Number of failed auths before lockout.') | |
integer('lockout_minutes', 15, 'Number of minutes to lockout if triggered.') | |
integer('lockout_window', 15, 'Number of minutes for lockout window.') | |
=== nova.api.auth.py === | |
boolean('use_forwarded_for', False, 'Treat X-Forwarded-For as the canonical remote address. ' 'Only enable this if you have a sanitizing proxy.') | |
=== nova.api.mapper.py === | |
bool('allow_admin_api', False, 'When True, this API service will accept admin operations.') | |
bool('allow_instance_snapshots', True, 'When True, this API service will permit instance snapshot operations.') | |
=== nova.vsa.api.py === | |
string('vsa_ec2_access_key', None, 'EC2 access key used by VSA for accessing nova') | |
string('vsa_ec2_user_id', None, 'User ID used by VSA for accessing nova') | |
boolean('vsa_multi_vol_creation', True, 'Ask scheduler to create multiple volumes in one call') | |
string('vsa_volume_type_name', 'VSA volume type', 'Name of volume type associated with FE VSA volumes') | |
=== nova.vsa.manager.py === | |
string('vsa_driver', 'nova.vsa.connection.get_connection', 'Driver to use for controlling VSAs') | |
=== nova.service.py === | |
integer('report_interval', 10, 'seconds between nodes reporting state to datastore', lower_bound=1) | |
integer('periodic_interval', 60, 'seconds between running periodic tasks', lower_bound=1) | |
string('ec2_listen', "0.0.0.0", 'IP address for EC2 API to listen') | |
integer('ec2_listen_port', 8773, 'port for ec2 api to listen') | |
string('osapi_compute_listen', "0.0.0.0", 'IP address for OpenStack API to listen') | |
integer('osapi_compute_listen_port', 8774, 'list port for osapi compute') | |
string('metadata_manager', 'nova.api.manager.MetadataManager', 'OpenStack metadata service manager') | |
string('metadata_listen', "0.0.0.0", 'IP address for metadata api to listen') | |
integer('metadata_listen_port', 8775, 'port for metadata api to listen') | |
string('api_paste_config', "api-paste.ini", 'File name for the paste.deploy config for nova-api') | |
string('osapi_volume_listen', "0.0.0.0", 'IP address for OpenStack Volume API to listen') | |
integer('osapi_volume_listen_port', 8776, 'port for os volume api to listen') | |
=== nova.console.vmrc.py === | |
integer('console_vmrc_port', 443, "port for VMware VMRC connections") | |
integer('console_vmrc_error_retries', 10, "number of retries for retrieving VMRC information") | |
=== nova.console.xvp.py === | |
string('console_xvp_conf_template', utils.abspath('console/xvp.conf.template'), 'XVP conf template') | |
string('console_xvp_conf', '/etc/xvp.conf', 'generated XVP conf file') | |
string('console_xvp_pid', '/var/run/xvp.pid', 'XVP master process pid file') | |
string('console_xvp_log', '/var/log/xvp.log', 'XVP log file') | |
integer('console_xvp_multiplex_port', 5900, 'port for XVP to multiplex VNC connections on') | |
=== nova.console.vmrc_manager.py === | |
string('console_public_hostname', '', 'Publicly visible name for this console host') | |
string('console_driver', 'nova.console.vmrc.VMRCConsole', 'Driver to use for the console') | |
=== nova.console.manager.py === | |
string('console_driver', 'nova.console.xvp.XVPConsoleProxy', 'Driver to use for the console proxy') | |
boolean('stub_compute', False, 'Stub calls to compute worker for tests') | |
string('console_public_hostname', socket.gethostname(), 'Publicly visable name for this console host') | |
=== nova.db.api.py === | |
string('db_backend', 'sqlalchemy', 'The backend to use for db') | |
boolean('enable_new_services', True, 'Services to be added to the available pool on create') | |
string('instance_name_template', 'instance-%08x', 'Template string to be used to generate instance names') | |
string('volume_name_template', 'volume-%08x', 'Template string to be used to generate instance names') | |
string('snapshot_name_template', 'snapshot-%08x', 'Template string to be used to generate snapshot names') | |
string('vsa_name_template', 'vsa-%08x', 'Template string to be used to generate VSA names') | |
=== nova.db.base.py === | |
string('db_driver', 'nova.db', 'driver to use for database access') | |
=== nova.log.py === | |
string('logging_context_format_string', '%(asctime)s %(levelname)s %(name)s ' '[%(request_id)s %(user_id)s ' '%(project_id)s] %(message)s', 'format string to use for log messages with context') | |
string('logging_default_format_string', '%(asctime)s %(levelname)s %(name)s [-] ' '%(message)s', 'format string to use for log messages without context') | |
string('logging_debug_format_suffix', 'from (pid=%(process)d) %(funcName)s' ' %(pathname)s:%(lineno)d', 'data to append to log format when level is DEBUG') | |
string('logging_exception_prefix', '(%(name)s): TRACE: ', 'prefix each line of exception output with this format') | |
list('default_log_levels', ['amqplib=WARN', 'sqlalchemy=WARN', 'boto=WARN', 'suds=INFO', 'eventlet.wsgi.server=WARN'], 'list of logger=LEVEL pairs') | |
bool('use_syslog', False, 'output to syslog') | |
bool('publish_errors', False, 'publish error events') | |
string('logfile', None, 'output to named file') | |
bool('use_stderr', True, 'log to standard error') | |
=== nova.policy.py === | |
string('policy_file', 'policy.json', _('JSON file representing policy')) | |
string('policy_default_rule', 'default', _('Rule checked when requested rule is not found')) | |
=== nova.ipv6.api.py === | |
string('ipv6_backend', 'rfc2462', 'Backend to use for IPv6 generation') | |
=== nova.consoleauth.__init__.py === | |
string('consoleauth_topic', 'consoleauth', 'the topic console auth proxy nodes listen on') | |
=== nova.consoleauth.manager.py === | |
integer('console_token_ttl', 600, 'How many seconds before deleting tokens') | |
string('consoleauth_manager', 'nova.consoleauth.manager.ConsoleAuthManager', 'Manager for console auth') | |
=== nova.objectstore.s3server.py === | |
string('buckets_path', '$state_path/buckets', 'path to s3 buckets') | |
=== nova.test.py === | |
string('sqlite_clean_db', 'clean.sqlite', 'File name of clean sqlite db') | |
bool('fake_tests', True, 'should we use everything for testing') |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment