Synnefo » snf-ganeti

def _ComputeIPolicySpecViolation(ipolicy, mem_size, cpu_count, disk_count,

                                 _compute_fn=_ComputeMinMaxSpec):

  """Verifies ipolicy against provided specs.

  @param nic_count: Number of nics used

  @type disk_sizes: list of ints

  @param disk_sizes: Disk sizes of used disk (len must match C{disk_count})

  @param _compute_fn: The compute function (unittest only)

  @return: A list of violations, or an empty list of no violations are found

    (constants.ISPEC_CPU_COUNT, cpu_count),

    (constants.ISPEC_DISK_COUNT, disk_count),

    (constants.ISPEC_NIC_COUNT, nic_count),

    ] + map((lambda d: (constants.ISPEC_DISK_SIZE, d)), disk_sizes)

  return filter(None,

  """

  mem_size = instance.beparams.get(constants.BE_MAXMEM, None)

  cpu_count = instance.beparams.get(constants.BE_VCPUS, None)

  disk_count = len(instance.disks)

  disk_sizes = [disk.size for disk in instance.disks]

  nic_count = len(instance.nics)

  return _compute_fn(ipolicy, mem_size, cpu_count, disk_count, nic_count,

def _ComputeIPolicyInstanceSpecViolation(ipolicy, instance_spec,

  disk_count = instance_spec.get(constants.ISPEC_DISK_COUNT, 0)

  disk_sizes = instance_spec.get(constants.ISPEC_DISK_SIZE, [])

  nic_count = instance_spec.get(constants.ISPEC_NIC_COUNT, 0)

  return _compute_fn(ipolicy, mem_size, cpu_count, disk_count, nic_count,

def _ComputeIPolicyNodeViolation(ipolicy, instance, current_group,

    nodenames = [pnode.name] + self.secondaries

    # Verify instance specs

    ispec = {

      constants.ISPEC_MEM_SIZE: self.be_full.get(constants.BE_MAXMEM, None),

      constants.ISPEC_CPU_COUNT: self.be_full.get(constants.BE_VCPUS, None),

      constants.ISPEC_DISK_COUNT: len(self.disks),

      constants.ISPEC_DISK_SIZE: [disk["size"] for disk in self.disks],

      constants.ISPEC_NIC_COUNT: len(self.nics),

      }

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