Synnefo » snf-ganeti » ganeti-local

  @see: L{ComputeIPolicySpecViolation}

  """

  be_full = cfg.GetClusterInfo().FillBE(instance)

  mem_size = be_full[constants.BE_MAXMEM]

  cpu_count = be_full[constants.BE_VCPUS]

  disk_count = len(instance.disks)

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

  nic_count = len(instance.nics)

  disk_template = instance.disk_template

def _ComputeViolatingInstances(ipolicy, instances, cfg):

  let p = Container.find new_pdx nl

      new_inst = Instance.setBoth inst new_pdx Node.noSecondary

  in do

    new_p <- Node.addPri p inst

    let new_nl = Container.add new_pdx new_p nl

        new_score = compCV new_nl

      tgt_s = Container.find new_sdx nl

  in do

    Instance.instMatchesPolicy inst (Node.iPolicy tgt_p)

    new_p <- Node.addPri tgt_p inst

    new_s <- Node.addSec tgt_s inst new_pdx

    let new_inst = Instance.setBoth inst new_pdx new_sdx

  , mirrorType

  ) where

import Ganeti.BasicTypes

import qualified Ganeti.HTools.Types as T

import qualified Ganeti.HTools.Container as Container

-- | Checks if an instance is smaller/bigger than a given spec. Returns

-- OpGood for a correct spec, otherwise Bad one of the possible

-- failure modes.

  | which == mem inst `compare` T.iSpecMemorySize ispec = Bad T.FailMem

  | which `elem` map ((`compare` T.iSpecDiskSize ispec) . dskSize)

    (disks inst) = Bad T.FailDisk

  | which == vcpus inst `compare` T.iSpecCpuCount ispec = Bad T.FailCPU

    = Bad T.FailSpindles

  | diskTemplate inst /= T.DTDiskless &&

    which == length (disks inst) `compare` T.iSpecDiskCount ispec

  | otherwise = Ok ()

-- | Checks if an instance is smaller than a given spec.

instBelowISpec = instCompareISpec GT

-- | Checks if an instance is bigger than a given spec.

instAboveISpec = instCompareISpec LT

-- | Checks if an instance matches a min/max specs pair

-- | Checks if an instance matches any specs of a policy

 -- Return Ok for no constraints, though this should never happen

  -- The initial "Bad" should be always replaced by a real result

  foldr eithermatch (Bad T.FailInternal) minmaxes

        eithermatch _ y@(Ok ()) = y

-- | Checks if an instance matches a policy.

  if diskTemplate inst `elem` T.iPolicyDiskTemplates ipol

    then Ok ()

    else Bad T.FailDisk

  forAll genOnlineNode $ \node ->

  forAll (choose (5, 20)) $ \count ->

  forAll (genInstanceSmallerThanNode node) $ \inst ->

  let rqn = Instance.requiredNodes $ Instance.diskTemplate inst

      node' = Node.setPolicy ipol node

      nl = makeSmallCluster node' count

class _FakeConfigForComputeIPolicyInstanceViolation:

    self.cluster = objects.Cluster(beparams={"default": be})

  def GetClusterInfo(self):

    return self.cluster

class TestComputeIPolicyInstanceViolation(unittest.TestCase):

  def test(self):

      constants.BE_VCPUS: 2,

      constants.BE_SPINDLE_USE: 4,

      }

    instance = objects.Instance(beparams=beparams, disks=disks, nics=[],

                                disk_template=constants.DT_PLAIN)

    stub = _StubComputeIPolicySpecViolation(2048, 2, 1, 0, [512], 4,

    ret = common.ComputeIPolicyInstanceViolation(NotImplemented, instance2,

                                                 cfg, _compute_fn=stub)

    self.assertEqual(ret, [])

class TestComputeIPolicyInstanceSpecViolation(unittest.TestCase):