Synnefo » snf-ganeti » ganeti-local

  "DST_NODE_OPT",

  "EARLY_RELEASE_OPT",

  "ENABLED_HV_OPT",

  "ENABLED_STORAGE_TYPES_OPT",

  "ERROR_CODES_OPT",

  "FAILURE_ONLY_OPT",

  "FIELDS_OPT",

                            help="Comma-separated list of hypervisors",

                            type="string", default=None)

ENABLED_STORAGE_TYPES_OPT = cli_option("--enabled-storage-types",

                                       dest="enabled_storage_types",

                                       help="Comma-separated list of "

                                            "storage methods",

                                       type="string", default=None)

NIC_PARAMS_OPT = cli_option("-N", "--nic-parameters", dest="nicparams",

                            type="keyval", default={},

                            help="NIC parameters")

  hv_state = dict(opts.hv_state)

  enabled_disk_templates = opts.enabled_disk_templates

  if enabled_disk_templates:

    enabled_disk_templates = enabled_disk_templates.split(",")

          opts.use_external_mip_script is not None or

          opts.prealloc_wipe_disks is not None or

          opts.hv_state or

          opts.enabled_storage_types or

          opts.disk_state or

          opts.ispecs_mem_size or

          opts.ispecs_cpu_count or

  if hvlist is not None:

    hvlist = hvlist.split(",")

  enabled_storage_types = opts.enabled_storage_types

  if enabled_storage_types is not None:

    enabled_storage_types = enabled_storage_types.split(",")

  # a list of (name, dict) we can pass directly to dict() (or [])

  hvparams = dict(opts.hvparams)

  for hv_params in hvparams.values():

    use_external_mip_script=ext_ip_script,

    hv_state=hv_state,

    disk_state=disk_state,

    enabled_storage_types=enabled_storage_types,

    )

  SubmitOrSend(op, opts)

  return 0

     DRBD_HELPER_OPT, NODRBD_STORAGE_OPT, DEFAULT_IALLOCATOR_OPT,

     RESERVED_LVS_OPT, DRY_RUN_OPT, PRIORITY_OPT, PREALLOC_WIPE_DISKS_OPT,

     NODE_PARAMS_OPT, USE_EXTERNAL_MIP_SCRIPT, DISK_PARAMS_OPT, HV_STATE_OPT,

    INSTANCE_POLICY_OPTS,

    "[opts...]",

    "Alters the parameters of the cluster"),

    if self.op.enabled_hypervisors is not None:

      self.cluster.hvparams = self.new_hvparams

      self.cluster.enabled_hypervisors = self.op.enabled_hypervisors

    if self.op.enabled_storage_types is not None:

      self.cluster.enabled_storage_types = \

        list(set(self.op.enabled_storage_types))

    if self.op.beparams:

      self.cluster.beparams[constants.PP_DEFAULT] = self.new_beparams

    if self.op.nicparams:

     " ``%s`` or ``%s``" % (constants.DDM_ADD, constants.DDM_REMOVE)),

    ("use_external_mip_script", None, ht.TMaybeBool,

     "Whether to use an external master IP address setup script"),

    ("enabled_storage_types", None,

     ht.TMaybe(ht.TAnd(ht.TListOf(ht.TElemOf(constants.VALID_STORAGE_TYPES)),

                       ht.TTrue)),

     "List of enabled storage types"),

    ]

  OP_RESULT = ht.TNone

     , pHiddenOs

     , pBlacklistedOs

     , pUseExternalMipScript

     , pEnabledStorageTypes

     ])

  , ("OpClusterRedistConf", [])

  , ("OpClusterActivateMasterIp", [])

  , pDependencies

  , pComment

  , pReason

  , pEnabledStorageTypes

  , dOldQuery

  , dOldQueryNoLocking

  ) where

  simpleField "enabled_hypervisors" [t| NonEmpty Hypervisor |]

-- | List of enabled storage methods.

pEnabledStorageTypes :: Field

pEnabledStorageTypes =

  optionalField $

  simpleField "enabled_storage_types" [t| NonEmpty StorageType |]

-- | Selected hypervisor for an instance.

pHypervisor :: Field

pHypervisor =

          arbitrary <*> arbitrary <*> arbitrary <*>

          emptyMUD <*> emptyMUD <*> arbitrary <*>

          arbitrary <*> arbitrary <*> arbitrary <*> arbitrary <*>

      "OP_CLUSTER_REDIST_CONF" -> pure OpCodes.OpClusterRedistConf

      "OP_CLUSTER_ACTIVATE_MASTER_IP" ->

        pure OpCodes.OpClusterActivateMasterIp