Synnefo » snf-ganeti » ganeti-local

  , unitMem

  , unitCpu

  , unitDsk

  , unknownField

  , Placement

  , IMove(..)

unitCpu :: Int

unitCpu = 1

-- | Reason for an operation's falure.

data FailMode = FailMem  -- ^ Failed due to not enough RAM

              | FailDisk -- ^ Failed due to not enough disk

prop_Score_Zero node =

  forAll (choose (1, 1024)) $ \count ->

    (not (Node.offline node) && not (Node.failN1 node) && (count > 0) &&

  let fn = Node.buildPeers node Container.empty

      nlst = replicate count fn

      score = Cluster.compCVNodes nlst

{-

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

  ( testHTools_Instance

  , genInstanceSmallerThanNode

  , genInstanceMaybeBiggerThanNode

  , genInstanceOnNodeList

  , genInstanceList

  , Instance.Instance(..)

  ) where

import Test.QuickCheck hiding (Result)

import Test.Ganeti.TestHelper

-- * Arbitrary instances

-- | Generates a random instance with maximum disk/mem/cpu values.

  name <- genFQDN

  mem <- choose (0, lim_mem)

  dsk <- choose (0, lim_dsk)

  sn <- arbitrary

  vcpus <- choose (0, lim_cpu)

  dt <- arbitrary

  let disk = Instance.Disk dsk spindles

  return $ Instance.create

    name mem dsk [disk] vcpus run_st [] True pn sn dt 1 []

  genInstanceSmallerThan (Node.availMem node `div` 2)

                         (Node.availDisk node `div` 2)

                         (Node.availCpu node `div` 2)

-- | Generates an instance possibly bigger than a node.

genInstanceMaybeBiggerThanNode :: Node.Node -> Gen Instance.Instance

  genInstanceSmallerThan (Node.availMem  node + Types.unitMem * 2)

                         (Node.availDisk node + Types.unitDsk * 3)

                         (Node.availCpu  node + Types.unitCpu * 4)

-- | Generates an instance with nodes on a node list.

-- The following rules are respected:

-- let's generate a random instance

instance Arbitrary Instance.Instance where

-- * Test cases

                     -- just by the max... constants)

        -> Gen Node.Node

genNode min_multiplier max_multiplier = do

        case min_multiplier of

          Just mm -> (mm * Types.unitMem,

                      mm * Types.unitDsk,

        case max_multiplier of

          Just mm -> (mm * Types.unitMem,

                      mm * Types.unitDsk,

  name  <- genFQDN

  mem_t <- choose (base_mem, top_mem)

  mem_f <- choose (base_mem, mem_t)

  dsk_f <- choose (base_dsk, dsk_t)

  cpu_t <- choose (base_cpu, top_cpu)

  offl  <- arbitrary

  let n = Node.create name (fromIntegral mem_t) mem_n mem_f

      n' = Node.setPolicy nullIPolicy n

  return $ Node.buildPeers n' Container.empty

                              not (Node.failN1 n) &&

                              Node.availDisk n > 0 &&

                              Node.availMem n > 0 &&

-- and a random node

instance Arbitrary Node.Node where

-- memory does not raise an N+1 error

prop_addPri_NoN1Fail :: Property

prop_addPri_NoN1Fail =

  forAll (genInstanceSmallerThanNode node) $ \inst ->

  let inst' = inst { Instance.mem = Node.fMem node - Node.rMem node }

  in (Node.addPri node inst' /=? Bad Types.FailN1)

prop_addPriFC :: Property

prop_addPriFC =

  forAll (choose (1, maxCpu)) $ \extra ->

  forAll (arbitrary `suchThat` Instance.notOffline) $ \inst ->

  let inst' = setInstanceSmallerThanNode node inst

      inst'' = inst' { Instance.vcpus = Node.availCpu node + extra }

-- extra mem/cpu can always be added.

prop_addOfflinePri :: NonNegative Int -> NonNegative Int -> Property

prop_addOfflinePri (NonNegative extra_mem) (NonNegative extra_cpu) =

  forAll (genInstanceSmallerThanNode node) $ \inst ->

  let inst' = inst { Instance.runSt = Types.StatusOffline

                   , Instance.mem = Node.availMem node + extra_mem

prop_addOfflineSec :: NonNegative Int -> NonNegative Int

                   -> Types.Ndx -> Property

prop_addOfflineSec (NonNegative extra_mem) (NonNegative extra_cpu) pdx =

  forAll (genInstanceSmallerThanNode node) $ \inst ->

  let inst' = inst { Instance.runSt = Types.StatusOffline

                   , Instance.mem = Node.availMem node + extra_mem

prop_rMem :: Instance.Instance -> Property

prop_rMem inst =

  not (Instance.isOffline inst) ==>

  -- ab = auto_balance, nb = non-auto_balance

  -- we use -1 as the primary node of the instance

  let inst' = inst { Instance.pNode = -1, Instance.autoBalance = True

-- Check idempotence of add/remove operations

prop_addPri_idempotent :: Property

prop_addPri_idempotent =

  forAll (genInstanceSmallerThanNode node) $ \inst ->

  case Node.addPri node inst of

    Ok node' -> Node.removePri node' inst ==? node

prop_addSec_idempotent :: Property

prop_addSec_idempotent =

  forAll (genInstanceSmallerThanNode node) $ \inst ->

  let pdx = Node.idx node + 1

      inst' = Instance.setPri inst pdx

  ( maxMem

  , maxDsk

  , maxCpu

  , maxVcpuRatio

  , maxSpindleRatio

  , maxNodes

maxCpu :: Int

maxCpu = 1024

-- | Max vcpu ratio (random value).

maxVcpuRatio :: Double

maxVcpuRatio = 1024.0

setInstanceSmallerThanNode :: Node.Node

                           -> Instance.Instance -> Instance.Instance

setInstanceSmallerThanNode node inst =