Synnefo » snf-ganeti » ganeti-local

                master_netmask, master_netdev, file_storage_dir,

                shared_file_storage_dir, candidate_pool_size, secondary_ip=None,

                vg_name=None, beparams=None, nicparams=None, ndparams=None,

  """Initialise the cluster.

  @type candidate_pool_size: int

    hv_class = hypervisor.GetHypervisor(hv_name)

    hv_class.CheckParameterSyntax(hv_params)

  # set up ssh config and /etc/hosts

  sshline = utils.ReadFile(constants.SSH_HOST_RSA_PUB)

  sshkey = sshline.split(" ")[1]

    nicparams={constants.PP_DEFAULT: nicparams},

    ndparams=ndparams,

    hvparams=hvparams,

    candidate_pool_size=candidate_pool_size,

    modify_etc_hosts=modify_etc_hosts,

    modify_ssh_setup=modify_ssh_setup,

    uuid=uuid_generator.Generate([], utils.NewUUID, _INITCONF_ECID),

    name=constants.INITIAL_NODE_GROUP_NAME,

    members=[master_node_config.name],

    )

  nodegroups = {

    default_nodegroup.uuid: default_nodegroup,

  "DEBUG_SIMERR_OPT",

  "DISKIDX_OPT",

  "DISK_OPT",

  "DISK_TEMPLATE_OPT",

  "DRAINED_OPT",

  "DRY_RUN_OPT",

                        default={}, dest="hvparams",

                        help="Hypervisor parameters")

HYPERVISOR_OPT = cli_option("-H", "--hypervisor-parameters", dest="hypervisor",

                            help="Hypervisor and hypervisor options, in the"

                            " format hypervisor:option=value,option=value,...",

  beparams = opts.beparams

  nicparams = opts.nicparams

  # prepare beparams dict

  beparams = objects.FillDict(constants.BEC_DEFAULTS, beparams)

  utils.ForceDictType(beparams, constants.BES_PARAMETER_COMPAT)

    hvparams[hv] = objects.FillDict(constants.HVC_DEFAULTS[hv], hvparams[hv])

    utils.ForceDictType(hvparams[hv], constants.HVS_PARAMETER_TYPES)

  if opts.candidate_pool_size is None:

    opts.candidate_pool_size = constants.MASTER_POOL_SIZE_DEFAULT

                        beparams=beparams,

                        nicparams=nicparams,

                        ndparams=ndparams,

                        candidate_pool_size=opts.candidate_pool_size,

                        modify_etc_hosts=opts.modify_etc_hosts,

                        modify_ssh_setup=opts.modify_ssh_setup,

  if not (not opts.lvm_storage or opts.vg_name or

          not opts.drbd_storage or opts.drbd_helper or

          opts.enabled_hypervisors or opts.hvparams or

          opts.candidate_pool_size is not None or

          opts.uid_pool is not None or

          opts.maintain_node_health is not None or

  for hv_params in hvparams.values():

    utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)

  beparams = opts.beparams

  utils.ForceDictType(beparams, constants.BES_PARAMETER_COMPAT)

                                  beparams=beparams,

                                  nicparams=nicparams,

                                  ndparams=ndparams,

                                  candidate_pool_size=opts.candidate_pool_size,

                                  maintain_node_health=mnh,

                                  uid_pool=uid_pool,

     NOMODIFY_SSH_SETUP_OPT, SECONDARY_IP_OPT, VG_NAME_OPT,

     MAINTAIN_NODE_HEALTH_OPT, UIDPOOL_OPT, DRBD_HELPER_OPT, NODRBD_STORAGE_OPT,

     DEFAULT_IALLOCATOR_OPT, PRIMARY_IP_VERSION_OPT, PREALLOC_WIPE_DISKS_OPT,

    "[opts...] <cluster_name>", "Initialises a new cluster configuration"),

  "destroy": (

    DestroyCluster, ARGS_NONE, [YES_DOIT_OPT],

     MAINTAIN_NODE_HEALTH_OPT, UIDPOOL_OPT, ADD_UIDS_OPT, REMOVE_UIDS_OPT,

     DRBD_HELPER_OPT, NODRBD_STORAGE_OPT, DEFAULT_IALLOCATOR_OPT,

     RESERVED_LVS_OPT, DRY_RUN_OPT, PRIORITY_OPT, PREALLOC_WIPE_DISKS_OPT,

    "[opts...]",

    "Alters the parameters of the cluster"),

  "renew-crypto": (

  """

  (group_name,) = args

  op = opcodes.OpGroupAdd(group_name=group_name, ndparams=opts.ndparams,

  SubmitOpCode(op, opts=opts)

  @return: the desired exit code

  """

    ToStderr("Please give at least one of the parameters.")

    return 1

  op = opcodes.OpGroupSetParams(group_name=args[0],

                                ndparams=opts.ndparams,

  result = SubmitOrSend(op, opts)

  if result:

commands = {

  "add": (

    "<group_name>", "Add a new node group to the cluster"),

  "assign-nodes": (

    AssignNodes, ARGS_ONE_GROUP + ARGS_MANY_NODES, [DRY_RUN_OPT, FORCE_OPT],

    "Lists all available fields for node groups"),

  "modify": (

    SetGroupParams, ARGS_ONE_GROUP,

    "<group_name>", "Alters the parameters of a node group"),

  "remove": (

    RemoveGroup, ARGS_ONE_GROUP, [DRY_RUN_OPT],

    if self.op.master_netmask is not None:

      _ValidateNetmask(self.cfg, self.op.master_netmask)

  def ExpandNames(self):

    # FIXME: in the future maybe other cluster params won't require checking on

    # all nodes to be modified.

        else:

          self.new_hvparams[hv_name].update(hv_dict)

    # os hypervisor parameters

    self.new_os_hvp = objects.FillDict(cluster.os_hvp, {})

    if self.op.os_hvp:

      self.cluster.osparams = self.new_osp

    if self.op.ndparams:

      self.cluster.ndparams = self.new_ndparams

    if self.op.candidate_pool_size is not None:

      self.cluster.candidate_pool_size = self.op.candidate_pool_size

    if self.op.ndparams:

      utils.ForceDictType(self.op.ndparams, constants.NDS_PARAMETER_TYPES)

  def BuildHooksEnv(self):

    """Build hooks env.

    group_obj = objects.NodeGroup(name=self.op.group_name, members=[],

                                  uuid=self.group_uuid,

                                  alloc_policy=self.op.alloc_policy,

    self.cfg.AddNodeGroup(group_obj, self.proc.GetECId(), check_uuid=False)

    del self.remove_locks[locking.LEVEL_NODEGROUP]

  def CheckArguments(self):

    all_changes = [

      self.op.ndparams,

      self.op.alloc_policy,

      ]

      utils.ForceDictType(self.op.ndparams, constants.NDS_PARAMETER_TYPES)

      self.new_ndparams = new_ndparams

  def BuildHooksEnv(self):

    """Build hooks env.

      self.group.ndparams = self.new_ndparams

      result.append(("ndparams", str(self.group.ndparams)))

    if self.op.alloc_policy:

      self.group.alloc_policy = self.op.alloc_policy

LD_DRBD8 = "drbd8"

LD_FILE = "file"

LD_BLOCKDEV = "blockdev"

LDS_BLOCK = frozenset([LD_LV, LD_DRBD8, LD_BLOCKDEV])

# drbd constants

NDS_PARAMETERS = frozenset(NDS_PARAMETER_TYPES.keys())

# OOB supported commands

OOB_POWER_ON = "power-on"

OOB_POWER_OFF = "power-off"

  ND_OOB_PROGRAM: None,

  }

NICC_DEFAULTS = {

  NIC_MODE: NIC_MODE_BRIDGED,

  NIC_LINK: DEFAULT_BRIDGE,

                            " result '%s'", idx, src_node, result.payload)

      else:

        disk_id = tuple(result.payload)

        new_dev = objects.Disk(dev_type=constants.LD_LV, size=disk.size,

                               logical_id=disk_id, physical_id=disk_id,

      self._snap_disks.append(new_dev)

    del target[constants.BE_MEMORY]

class ConfigObject(object):

  """A generic config object.

class Disk(ConfigObject):

  """Config object representing a block device."""

  __slots__ = ["dev_type", "logical_id", "physical_id",

  def CreateOnSecondary(self):

    """Test if this device needs to be created on a secondary node."""

    if self.children:

      for child in self.children:

        child.UpgradeConfig()

    # add here config upgrade for this disk

    "name",

    "members",

    "ndparams",

    "serial_no",

    "alloc_policy",

    ] + _TIMESTAMPS + _UUID

    if self.mtime is None:

      self.mtime = time.time()

  def FillND(self, node):

    """Return filled out ndparams for L{objects.Node}

    "osparams",

    "nicparams",

    "ndparams",

    "candidate_pool_size",

    "modify_etc_hosts",

    "modify_ssh_setup",

    if self.use_external_mip_script is None:

      self.use_external_mip_script = False

  def ToDict(self):

    """Custom function for cluster.

                  ht.TListOf(ht.TElemOf(constants.CV_ALL_ECODES_STRINGS)),

                  "List of error codes that should be treated as warnings")

#: OP_ID conversion regular expression

_OPID_RE = re.compile("([a-z])([A-Z])")

    ("osparams", None, ht.TOr(ht.TDictOf(ht.TNonEmptyString, ht.TDict),

                              ht.TNone),

     "Cluster-wide OS parameter defaults"),

    ("candidate_pool_size", None, ht.TOr(ht.TStrictPositiveInt, ht.TNone),

     "Master candidate pool size"),

    ("uid_pool", None, ht.NoType,

    _PGroupName,

    _PNodeGroupAllocPolicy,

    _PGroupNodeParams,

    ]

    _PGroupName,

    _PNodeGroupAllocPolicy,

    _PGroupNodeParams,

    ]

  OP_RESULT = _TSetParamsResult

    self.failUnless(constants.OP_PRIO_NORMAL > constants.OP_PRIO_HIGH)

    self.failUnless(constants.OP_PRIO_HIGH > constants.OP_PRIO_HIGHEST)

class TestExportedNames(unittest.TestCase):

  _VALID_NAME_RE = re.compile(r"^[A-Z][A-Z0-9_]+$")