Synnefo » snf-ganeti

import ganeti.masterd.instance # pylint: disable=W0611

# States of instance

INSTANCE_DOWN = [constants.ADMINST_DOWN]

INSTANCE_ONLINE = [constants.ADMINST_DOWN, constants.ADMINST_UP]

  return mc_now < mc_should

def _ComputeViolatingInstances(ipolicy, instances):

  """Computes a set of instances who violates given ipolicy.

    node_vol_should = {}

    instanceconfig.MapLVsByNode(node_vol_should)

    err = _ComputeIPolicyInstanceViolation(ipolicy, instanceconfig)

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

                               if compat.any(node in group.members

                                             for node in inst.all_nodes)])

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

                                            new_ipolicy, instances)

        if new:

          violations.update(new)

      live_data = {}

    if query.IQ_DISKUSAGE in self.requested_data:

      disk_usage = dict((inst.name,

                        for inst in instance_list)

    else:

      disk_usage = None

    _CheckNodeOnline(self, target_node)

    _CheckNodeNotDrained(self, target_node)

    _CheckNodeVmCapable(self, target_node)

    _CheckTargetNodeIPolicy(self, ipolicy, instance, node,

                            ignore=self.op.ignore_ipolicy)

      # Check that the target node is correct in terms of instance policy

      nodeinfo = self.cfg.GetNodeInfo(self.target_node)

      group_info = self.cfg.GetNodeGroup(nodeinfo.group)

      _CheckTargetNodeIPolicy(self.lu, ipolicy, instance, nodeinfo,

                              ignore=self.ignore_ipolicy)

                                   errors.ECODE_INVAL)

      nodeinfo = self.cfg.GetNodeInfo(target_node)

      group_info = self.cfg.GetNodeGroup(nodeinfo.group)

      _CheckTargetNodeIPolicy(self.lu, ipolicy, instance, nodeinfo,

                              ignore=self.ignore_ipolicy)

  dev_data = objects.Disk(dev_type=constants.LD_LV, size=size,

                          logical_id=(vgnames[0], names[0]),

                          params={})

                          logical_id=(vgnames[1], names[1]),

                          params={})

  drbd_dev = objects.Disk(dev_type=constants.LD_DRBD8, size=size,

    constants.DT_DISKLESS: {},

    constants.DT_PLAIN: _compute(disks, 0),

    # 128 MB are added for drbd metadata for each disk

    constants.DT_FILE: {},

    constants.DT_SHARED_FILE: {},

  }

  return req_size_dict[disk_template]

def _FilterVmNodes(lu, nodenames):

  """Filters out non-vm_capable nodes from a list.

      }

    group_info = self.cfg.GetNodeGroup(pnode.group)

    res = _ComputeIPolicyInstanceSpecViolation(ipolicy, ispec)

    if not self.op.ignore_ipolicy and res:

      raise errors.OpPrereqError(("Instance allocation to group %s violates"

    if self.remote_node_info:

      # We change the node, lets verify it still meets instance policy

      new_group_info = self.cfg.GetNodeGroup(self.remote_node_info.group)

      _CheckTargetNodeIPolicy(self, ipolicy, instance, self.remote_node_info,

                              ignore=self.ignore_ipolicy)

                             logical_id=(vg_data, names[0]),

                             params=data_disk.params)

      vg_meta = meta_disk.logical_id[0]

                             logical_id=(vg_meta, names[1]),

                             params=meta_disk.params)

        snode_info = self.cfg.GetNodeInfo(self.op.remote_node)

        snode_group = self.cfg.GetNodeGroup(snode_info.group)

        _CheckTargetNodeIPolicy(self, ipolicy, instance, snode_info,

                                ignore=self.op.ignore_ipolicy)

        if pnode_info.group != snode_info.group:

      new_ipolicy = cluster.SimpleFillIPolicy(self.new_ipolicy)

      inst_filter = lambda inst: inst.name in owned_instances

      instances = self.cfg.GetInstancesInfoByFilter(inst_filter).values()

      violations = \

                                        new_ipolicy, instances)

      if violations:

DRBD_HMAC_ALG = "md5"

DRBD_NET_PROTOCOL = "C"

# drbd barrier types

DRBD_B_NONE = "n"

DRBD_B_DISK_BARRIERS = "b"

  msg = _GetRieDiskInfoMessage(disk_index, host, port, magic)

  hmac_digest = utils.Sha1Hmac(cds, msg, salt=salt)

  return (host, port, magic, hmac_digest, salt)

      self.assertEqual(len(disk.children), 2)

      self.assertEqual(disk.children[0].size, disk.size)

    self._CheckIvNames(result, 0, len(disk_info))

    cmdlib._UpdateIvNames(0, result)

from ganeti import objects

from ganeti import cmdlib

import testutils

    instbyname = dict((inst.name, inst) for inst in instances)

    disk_usage = dict((inst.name,

                      for inst in instances)

    inst_bridges = {