Synnefo » snf-ganeti » ganeti-local

    ReplaceSecondary _ -> (printf "r:%s" d, [rep d])

    ReplaceAndFailover _ -> (printf "r:%s f" c, [rep c, mig])

    ReplacePrimary _ -> (printf "f r:%s f" c, [mig, rep c, mig])

        mig = printf "%s -f %s" morf inam::String

        rep n = printf "replace-disks -n %s %s" n inam

printInsts :: Node.List -> Instance.List -> String

printInsts nl il =

  let sil = sortBy (comparing Instance.idx) (Container.elems il)

                    , Instance.name inst

                    , Container.nameOf nl (Instance.pNode inst)

                    , let sdx = Instance.sNode inst

  , AssocList

  , List

  , create

  , instanceDown

  , usesSecMem

  , applyIfOnline

  allNames n = [name n, alias n]

-- | Check if instance is running.

-- | Check if instance is offline.

-- | Helper to check if the instance is not offline.

-- | Check if instance is down.

instanceDown :: Instance -> Bool

-- | Apply the function if the instance is online. Otherwise use

-- the initial value

applyIfOnline :: Instance -> (a -> a) -> a -> a

-- | Helper for determining whether an instance's memory needs to be

-- taken into account for secondary memory reservation.

usesSecMem :: Instance -> Bool

-- | Constant holding the local storage templates.

--

nodeImem node il =

  let rfind = flip Container.find il

      il' = map rfind $ Node.pList node

  in sum . map Instance.mem $ oil'

removePri :: Node -> Instance.Instance -> Node

removePri t inst =

  let iname = Instance.idx inst

      uses_disk = Instance.usesLocalStorage inst

      new_plist = delete iname (pList t)

      new_mem = incIf i_online (fMem t) (Instance.mem inst)

                               -- or a failure mode

addPriEx force t inst =

  let iname = Instance.idx inst

      uses_disk = Instance.usesLocalStorage inst

      cur_dsk = fDsk t

      new_mem = decIf i_online (fMem t) (Instance.mem inst)

-- rejected.

prop_Node_addPriFM node inst =

  Instance.mem inst >= Node.fMem node && not (Node.failN1 node) &&

  case Node.addPri node inst'' of

    Types.OpFail Types.FailMem -> True

    _ -> False

prop_Node_addPriFC =

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

  forAll genOnlineNode $ \node ->

  let inst' = setInstanceSmallerThanNode node inst

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

  in case Node.addPri node inst'' of

-- rejected.

prop_Node_addSec node inst pdx =

  ((Instance.mem inst >= (Node.fMem node - Node.rMem node) &&

   Instance.dsk inst >= Node.fDsk node) &&

  not (Node.failN1 node) ==>

      isFailure (Node.addSec node inst pdx)

-- | Checks for memory reservation changes.

prop_Node_rMem inst =

  forAll (arbitrary `suchThat` ((> Types.unitMem) . Node.fMem)) $ \node ->

  -- ab = auto_balance, nb = non-auto_balance

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