text: # Copyright 2015 OpenStack Foundation
  # All Rights Reserved.
  #
  #    Licensed under the Apache License, Version 2.0 (the "License"); you may
  #    not use this file except in compliance with the License. You may obtain
  #    a copy of the License at
  #
  #         http://www.apache.org/licenses/LICENSE-2.0
  #
  #    Unless required by applicable law or agreed to in writing, software
  #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  #    License for the specific language governing permissions and limitations
  #    under the License.
  
  import itertools
  
  from oslo_config import cfg
  
  
  cells_opts = [
      cfg.BoolOpt('enable',
                  default=False,
                  help="""
  Enable cell functionality
  
  When this functionality is enabled, it lets you to scale an OpenStack
  Compute cloud in a more distributed fashion without having to use
  complicated technologies like database and message queue clustering.
  Cells are configured as a tree. The top-level cell should have a host
  that runs a nova-api service, but no nova-compute services. Each
  child cell should run all of the typical nova-* services in a regular
  Compute cloud except for nova-api. You can think of cells as a normal
  Compute deployment in that each cell has its own database server and
  message queue broker.
  
  Possible values:
  
  * True: Enables the feature
  * False: Disables the feature
  
  Services which consume this:
  
  * nova-api
  * nova-cells
  * nova-compute
  
  Related options:
  
  * name: A unique cell name must be given when this functionality
    is enabled.
  * cell_type: Cell type should be defined for all cells.
  """),
      cfg.StrOpt('topic',
                  default='cells',
                  help="""
  Topic
  
  This is the message queue topic that cells nodes listen on. It is
  used when the cells service is started up to configure the queue,
  and whenever an RPC call to the scheduler is made.
  
  Possible values:
  
  * cells: This is the recommended and the default value.
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """),
      cfg.StrOpt('manager',
                 default='nova.cells.manager.CellsManager',
                 help="""
  DEPRECATED: Manager for cells
  
  The nova-cells manager class. This class defines RPC methods that
  the local cell may call. This class is NOT used for messages coming
  from other cells. That communication is driver-specific.
  
  Communication to other cells happens via the nova.cells.messaging module.
  The MessageRunner from that module will handle routing the message to
  the correct cell via the communication driver. Most methods below
  create 'targeted' (where we want to route a message to a specific cell)
  or 'broadcast' (where we want a message to go to multiple cells)
  messages.
  
  Scheduling requests get passed to the scheduler class.
  
  Possible values:
  
  * 'nova.cells.manager.CellsManager' is the only possible value for
    this option as of the Mitaka release
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """,
          deprecated_for_removal=True
      ),
      cfg.StrOpt('name',
                  default='nova',
                  help="""
  Name of the current cell
  
  This value must be unique for each cell. Name of a cell is used as
  its id, leaving this option unset or setting the same name for
  two or more cells may cause unexpected behaviour.
  
  Possible values:
  
  * Unique name string
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * enabled: This option is meaningful only when cells service
    is enabled
  """),
      cfg.ListOpt('capabilities',
                  default=['hypervisor=xenserver;kvm', 'os=linux;windows'],
                  help="""
  Cell capabilities
  
  List of arbitrary key=value pairs defining capabilities of the
  current cell to be sent to the parent cells. These capabilities
  are intended to be used in cells scheduler filters/weighers.
  
  Possible values:
  
  * key=value pairs list for example;
    ``hypervisor=xenserver;kvm,os=linux;windows``
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """),
      cfg.IntOpt('call_timeout',
                  default=60,
                  help="""
  Call timeout
  
  Cell messaging module waits for response(s) to be put into the
  eventlet queue. This option defines the seconds waited for
  response from a call to a cell.
  
  Possible values:
  
  * Time in seconds.
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """),
      cfg.FloatOpt('reserve_percent',
                   default=10.0,
                   help="""
  Reserve percentage
  
  Percentage of cell capacity to hold in reserve, so the minimum
  amount of free resource is considered to be;
    min_free = total * (reserve_percent / 100.0)
  This option affects both memory and disk utilization.
  The primary purpose of this reserve is to ensure some space is
  available for users who want to resize their instance to be larger.
  Note that currently once the capacity expands into this reserve
  space this option is ignored.
  
  Possible values:
  
  * Float percentage value
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """),
      cfg.StrOpt('cell_type',
                 default='compute',
                 choices=('api', 'compute'),
                 help="""
  Type of cell
  
  When cells feature is enabled the hosts in the OpenStack Compute
  cloud are partitioned into groups. Cells are configured as a tree.
  The top-level cell's cell_type must be set to ``api``. All other
  cells are defined as a ``compute cell`` by default.
  
  Possible values:
  
  * api: Cell type of top-level cell.
  * compute: Cell type of all child cells. (Default)
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * compute_api_class: This option must be set to cells api driver
    for the top-level cell (nova.compute.cells_api.ComputeCellsAPI)
  * quota_driver: Disable quota checking for the child cells.
    (nova.quota.NoopQuotaDriver)
  """),
      cfg.IntOpt("mute_child_interval",
                 default=300,
                 help="""
  Mute child interval
  
  Number of seconds after which a lack of capability and capacity
  update the child cell is to be treated as a mute cell. Then the
  child cell will be weighed as recommend highly that it be skipped.
  
  Possible values:
  
  * Time in seconds.
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """),
      cfg.IntOpt('bandwidth_update_interval',
                  default=600,
                  help="""
  Bandwidth update interval
  
  Seconds between bandwidth usage cache updates for cells.
  
  Possible values:
  
  * Time in seconds.
  
  Services which consume this:
  
  * nova-compute
  
  Related options:
  
  * None
  """),
      cfg.IntOpt('instance_update_sync_database_limit',
              default=100,
              help="""
  Instance update sync database limit
  
  Number of instances to pull from the database at one time for
  a sync. If there are more instances to update the results will
  be paged through.
  
  Possible values:
  
  * Number of instances.
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """),
  ]
  
  mute_weigher_opts = [
          cfg.FloatOpt('mute_weight_multiplier',
                  default=-10000.0,
                  help="""
  Mute weight multiplier
  
  Multiplier used to weigh mute children. Mute children cells are
  recommended to be skipped so their weight is multiplied by this
  negative value.
  
  Possible values:
  
  * Negative numeric number
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """),
  ]
  
  ram_weigher_opts = [
          cfg.FloatOpt('ram_weight_multiplier',
                       default=10.0,
                       help="""
  Ram weight multiplier
  
  Multiplier used for weighing ram. Negative numbers indicate that
  Compute should stack VMs on one host instead of spreading out new
  VMs to more hosts in the cell.
  
  Possible values:
  
  * Numeric multiplier
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """),
  ]
  
  weigher_opts = [
      cfg.FloatOpt('offset_weight_multiplier',
                   default=1.0,
                   help="""
  Offset weight multiplier
  
  Multiplier used to weigh offset weigher. Cells with higher
  weight_offsets in the DB will be preferred. The weight_offset
  is a property of a cell stored in the database. It can be used
  by a deployer to have scheduling decisions favor or disfavor
  cells based on the setting.
  
  Possible values:
  
  * Numeric multiplier
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """),
  ]
  
  cell_manager_opts = [
          cfg.StrOpt('driver',
                  default='nova.cells.rpc_driver.CellsRPCDriver',
                  help="""
  Cells communication driver
  
  Driver for cell<->cell communication via RPC. This is used to
  setup the RPC consumers as well as to send a message to another cell.
  'nova.cells.rpc_driver.CellsRPCDriver' starts up 2 separate servers
  for handling inter-cell communication via RPC.
  
  Possible values:
  
  * 'nova.cells.rpc_driver.CellsRPCDriver' is the default driver
  * Otherwise it should be the full Python path to the class to be used
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """),
          cfg.IntOpt("instance_updated_at_threshold",
                  default=3600,
                  help="""
  Instance updated at threshold
  
  Number of seconds after an instance was updated or deleted to
  continue to update cells. This option lets cells manager to only
  attempt to sync instances that have been updated recently.
  i.e., a threshold of 3600 means to only update instances that
  have modified in the last hour.
  
  Possible values:
  
  * Threshold in seconds
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * This value is used with the ``instance_update_num_instances``
    value in a periodic task run.
  """),
          cfg.IntOpt("instance_update_num_instances",
                  default=1,
                  help="""
  Instance update num instances
  
  On every run of the periodic task, nova cells manager will attempt to
  sync instance_updated_at_threshold number of instances. When the
  manager gets the list of instances, it shuffles them so that multiple
  nova-cells services do not attempt to sync the same instances in
  lockstep.
  
  Possible values:
  
  * Positive integer number
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * This value is used with the ``instance_updated_at_threshold``
    value in a periodic task run.
  """)
  ]
  
  cell_messaging_opts = [
      cfg.IntOpt('max_hop_count',
              default=10,
              help="""
  Maximum hop count
  
  When processing a targeted message, if the local cell is not the
  target, a route is defined between neighbouring cells. And the
  message is processed across the whole routing path. This option
  defines the maximum hop counts until reaching the target.
  
  Possible values:
  
  * Positive integer value
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """),
      cfg.StrOpt('scheduler',
              default='nova.cells.scheduler.CellsScheduler',
              help="""
  Cells scheduler
  
  The class of the driver used by the cells scheduler. This should be
  the full Python path to the class to be used. If nothing is specified
  in this option, the CellsScheduler is used.
  
  
  Possible values:
  
  * 'nova.cells.scheduler.CellsScheduler' is the default option
  * Otherwise it should be the full Python path to the class to be used
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """)
  ]
  
  cell_rpc_driver_opts = [
          cfg.StrOpt('rpc_driver_queue_base',
                     default='cells.intercell',
                     help="""
  RPC driver queue base
  
  When sending a message to another cell by JSON-ifying the message
  and making an RPC cast to 'process_message', a base queue is used.
  This option defines the base queue name to be used when communicating
  between cells. Various topics by message type will be appended to this.
  
  Possible values:
  
  * The base queue name to be used when communicating between cells.
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """)
  ]
  
  cell_scheduler_opts = [
          cfg.ListOpt('scheduler_filter_classes',
                  default=['nova.cells.filters.all_filters'],
                  help="""
  Scheduler filter classes
  
  Filter classes the cells scheduler should use. An entry of
  "nova.cells.filters.all_filters" maps to all cells filters
  included with nova. As of the Mitaka release the following
  filter classes are available:
  
  Different cell filter: A scheduler hint of 'different_cell'
  with a value of a full cell name may be specified to route
  a build away from a particular cell.
  
  Image properties filter: Image metadata named
  'hypervisor_version_requires' with a version specification
  may be specified to ensure the build goes to a cell which
  has hypervisors of the required version. If either the version
  requirement on the image or the hypervisor capability of the
  cell is not present, this filter returns without filtering out
  the cells.
  
  Target cell filter: A scheduler hint of 'target_cell' with a
  value of a full cell name may be specified to route a build to
  a particular cell. No error handling is done as there's no way
  to know whether the full path is a valid.
  
  As an admin user, you can also add a filter that directs builds
  to a particular cell.
  
  
  Possible values:
  
  * 'nova.cells.filters.all_filters' is the default option
  * Otherwise it should be the full Python path to the class to be used
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """),
          cfg.ListOpt('scheduler_weight_classes',
                  default=['nova.cells.weights.all_weighers'],
                  help="""
  Scheduler weight classes
  
  Weigher classes the cells scheduler should use. An entry of
  "nova.cells.weights.all_weighers" maps to all cell weighers
  included with nova. As of the Mitaka release the following
  weight classes are available:
  
  mute_child: Downgrades the likelihood of child cells being
  chosen for scheduling requests, which haven't sent capacity
  or capability updates in a while. Options include
  mute_weight_multiplier (multiplier for mute children; value
  should be negative).
  
  ram_by_instance_type: Select cells with the most RAM capacity
  for the instance type being requested. Because higher weights
  win, Compute returns the number of available units for the
  instance type requested. The ram_weight_multiplier option defaults
  to 10.0 that adds to the weight by a factor of 10. Use a negative
  number to stack VMs on one host instead of spreading out new VMs
  to more hosts in the cell.
  
  weight_offset: Allows modifying the database to weight a particular
  cell. The highest weight will be the first cell to be scheduled for
  launching an instance. When the weight_offset of a cell is set to 0,
  it is unlikely to be picked but it could be picked if other cells
  have a lower weight, like if they're full. And when the weight_offset
  is set to a very high value (for example, '999999999999999'), it is
  likely to be picked if another cell do not have a higher weight.
  
  Possible values:
  
  * 'nova.cells.weights.all_weighers' is the default option
  * Otherwise it should be the full Python path to the class to be used
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """),
          cfg.IntOpt('scheduler_retries',
                  default=10,
                  help="""
  Scheduler retries
  
  How many retries when no cells are available. Specifies how many
  times the scheduler tries to launch a new instance when no cells
  are available.
  
  Possible values:
  
  * Positive integer value
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * This value is used with the ``scheduler_retry_delay`` value
    while retrying to find a suitable cell.
  """),
          cfg.IntOpt('scheduler_retry_delay',
                  default=2,
                  help="""
  Scheduler retry delay
  
  Specifies the delay (in seconds) between scheduling retries when no
  cell can be found to place the new instance on. When the instance
  could not be scheduled to a cell after ``scheduler_retries`` in
  combination with ``scheduler_retry_delay``, then the scheduling
  of the instance failed.
  
  Possible values:
  
  * Time in seconds.
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * This value is used with the ``scheduler_retries`` value
    while retrying to find a suitable cell.
  """)
  ]
  
  cell_state_manager_opts = [
          cfg.IntOpt('db_check_interval',
                 default=60,
                 help="""
  DB check interval
  
  Cell state manager updates cell status for all cells from the DB
  only after this particular interval time is passed. Otherwise cached
  status are used. If this value is 0 or negative all cell status are
  updated from the DB whenever a state is needed.
  
  Possible values:
  
  * Interval time, in seconds.
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """),
          cfg.StrOpt('cells_config',
                 help="""
  Optional cells configuration
  
  Configuration file from which to read cells configuration. If given,
  overrides reading cells from the database.
  
  Cells store all inter-cell communication data, including user names
  and passwords, in the database. Because the cells data is not updated
  very frequently, use this option to specify a JSON file to store
  cells data. With this configuration, the database is no longer
  consulted when reloading the cells data. The file must have columns
  present in the Cell model (excluding common database fields and the
  id column). You must specify the queue connection information through
  a transport_url field, instead of username, password, and so on.
  
  The transport_url has the following form:
  rabbit://USERNAME:PASSWORD@HOSTNAME:PORT/VIRTUAL_HOST
  
  Possible values:
  
  The scheme can be either qpid or rabbit, the following sample shows
  this optional configuration:
  
      {
          "parent": {
              "name": "parent",
              "api_url": "http://api.example.com:8774",
              "transport_url": "rabbit://rabbit.example.com",
              "weight_offset": 0.0,
              "weight_scale": 1.0,
              "is_parent": true
          },
          "cell1": {
              "name": "cell1",
              "api_url": "http://api.example.com:8774",
              "transport_url": "rabbit://rabbit1.example.com",
              "weight_offset": 0.0,
              "weight_scale": 1.0,
              "is_parent": false
          },
          "cell2": {
              "name": "cell2",
              "api_url": "http://api.example.com:8774",
              "transport_url": "rabbit://rabbit2.example.com",
              "weight_offset": 0.0,
              "weight_scale": 1.0,
              "is_parent": false
          }
      }
  
  Services which consume this:
  
  * nova-cells
  
  Related options:
  
  * None
  """)
  ]
  
  ALL_CELLS_OPTS = list(itertools.chain(
              cells_opts,
              mute_weigher_opts,
              ram_weigher_opts,
              weigher_opts,
              cell_manager_opts,
              cell_messaging_opts,
              cell_rpc_driver_opts,
              cell_scheduler_opts,
              cell_state_manager_opts
              ))
  
  
  def register_opts(conf):
      conf.register_opts(ALL_CELLS_OPTS, group="cells")
  
  
  def list_opts():
      return {'cells': ALL_CELLS_OPTS}
  