Synnefo » snf-ganeti » ganeti-local

from ganeti import utils

from ganeti import vcluster

  ResultWithJobs

import ganeti.masterd.instance

  REQ_BGL = False

  def CheckArguments(self):

  def ExpandNames(self):

    self.cq.ExpandNames(self)

    master_params = self.cfg.GetMasterNetworkParameters()

    # Run post hooks on master node before it's removed

    ems = self.cfg.GetUseExternalMipScript()

    result = self.rpc.call_node_deactivate_master_ip(master_params.name,

    return True

  FIELDS = query.CLUSTER_FIELDS

  #: Do not sort (there is only one item)

      locking.LEVEL_NODE: locking.ALL_SET,

      locking.LEVEL_NODE_ALLOC: locking.ALL_SET,

    }

  def Exec(self, feedback_fn):

    """Redistribute the configuration.

    """

    self.cfg.Update(self.cfg.GetClusterInfo(), feedback_fn)

class LUClusterRename(LogicalUnit):

        node_list.remove(master_params.name)

      except ValueError:

        pass

    finally:

      master_params.ip = new_ip

      result = self.rpc.call_node_activate_master_ip(master_params.name,

  def ExpandNames(self):

    if self.op.instances:

      # Not getting the node allocation lock as only a specific set of

      # instances (and their nodes) is going to be acquired

      self.needed_locks = {

      locking.LEVEL_NODEGROUP: locking.ALL_SET,

      locking.LEVEL_NODE_ALLOC: locking.ALL_SET,

    }

  def BuildHooksEnv(self):

    """Build hooks env.

            constants.NDC_DEFAULTS[constants.ND_OOB_PROGRAM]

    if self.op.hv_state:

      self.new_hv_state = dict((hv, cluster.SimpleFillHvState(values))

                               for hv, values in new_hv_state.items())

    if self.op.disk_state:

      self.new_disk_state = \

        dict((storage, dict((name, cluster.SimpleFillDiskState(values))

                            for name, values in svalues.items()))

             for storage, svalues in new_disk_state.items())

    if self.op.ipolicy:

      all_instances = self.cfg.GetAllInstancesInfo().values()

      violations = set()

                                             for node in inst.all_nodes)])

        new_ipolicy = objects.FillIPolicy(self.new_ipolicy, group.ipolicy)

        ipol = masterd.instance.CalculateGroupIPolicy(cluster, group)

        if new:

          violations.update(new)

        if os_name not in self.new_osp:

          self.new_osp[os_name] = {}

        if not self.new_osp[os_name]:

          # we removed all parameters

          del self.new_osp[os_name]

        else:

          # check the parameter validity (remote check)

    # changes to the hypervisor list

    if self.op.enabled_hypervisors is not None:

          hv_class = hypervisor.GetHypervisorClass(hv_name)

          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)

          hv_class.CheckParameterSyntax(hv_params)

    self._CheckDiskTemplateConsistency()

          new_osp = objects.FillDict(cluster_defaults, hv_params)

          hv_class = hypervisor.GetHypervisorClass(hv_name)

          hv_class.CheckParameterSyntax(new_osp)

    if self.op.default_iallocator:

      alloc_script = utils.FindFile(self.op.default_iallocator,

    if self.op.candidate_pool_size is not None:

      self.cluster.candidate_pool_size = self.op.candidate_pool_size

      # we need to update the pool size here, otherwise the save will fail

    if self.op.maintain_node_health is not None:

      if self.op.maintain_node_health and not constants.ENABLE_CONFD:

  def ExpandNames(self):

    self.needed_locks = dict.fromkeys(locking.LEVELS, locking.ALL_SET)

  def CheckPrereq(self):

    """Check prerequisites.

      locking.LEVEL_NODE_ALLOC: locking.ALL_SET,

      }

  def DeclareLocks(self, level):

    if level == locking.LEVEL_NODE:

      _ErrorIf(vgstatus, constants.CV_ENODELVM, node, vgstatus)

    # Check PVs

    for em in errmsgs:

      self._Error(constants.CV_ENODELVM, node, em)

    if pvminmax is not None:

    cluster = self.cfg.GetClusterInfo()

    ipolicy = ganeti.masterd.instance.CalculateGroupIPolicy(cluster,

                                                            self.group_info)

    _ErrorIf(err, constants.CV_EINSTANCEPOLICY, instance, utils.CommaJoin(err),

             code=self.ETYPE_WARNING)

      # _AnnotateDiskParams makes already copies of the disks

      devonly = []

      for (inst, dev) in disks:

        self.cfg.SetDiskID(anno_disk, nname)

        devonly.append(anno_disk)

    # FIXME: verify OS list

    # File verification

    # do local checksums

    master_node = self.master_node = self.cfg.GetMasterNode()

    # Gather OOB paths

    oob_paths = []

    for node in self.all_node_info.values():

      if path and path not in oob_paths:

        oob_paths.append(path)

  REQ_BGL = False

  def ExpandNames(self):

    self.needed_locks = {

      locking.LEVEL_NODEGROUP: locking.ALL_SET,

      }