Synnefo » snf-ganeti » ganeti-local

  vcpus <- extract "vcpus"

  tags  <- extract "tags"

  dt    <- extract "disk_template"

  return (n, Instance.create n mem disk vcpus Running tags True 0 0 dt su)

-- | Parses an instance as found in the cluster instance list.

  , autoBalance  :: Bool      -- ^ Is the instance auto-balanced?

  , tags         :: [String]  -- ^ List of instance tags

  , diskTemplate :: T.DiskTemplate -- ^ The disk template of the instance

  } deriving (Show, Read, Eq)

instance T.Element Instance where

           , movable = supportsMoves dt

           , autoBalance = auto_balance_init

           , diskTemplate = dt

           }

-- | Changes the index.

  L.Query L.QRInstance ["name", "disk_usage", "be/memory", "be/vcpus",

                        "status", "pnode", "snodes", "tags", "oper_ram",

                        "be/auto_balance", "disk_template",

-- | The input data for cluster query.

queryClusterInfoMsg :: L.LuxiOp

  xtags <- convert "tags" tags

  xauto_balance <- convert "auto_balance" auto_balance

  xdt <- convert "disk_template" disk_template

  let inst = Instance.create xname xmem xdisk xvcpus

             xrunning xtags xauto_balance xpnode snode xdt xsu

  return (xname, inst)

  in t {peers=pmap, failN1 = new_failN1, rMem = new_rmem, pRem = new_prem}

-- | Calculate the new spindle usage

-- | Assigns an instance to a node as primary and update the used VCPU

-- count, utilisation data and tags map.

                  , pCpu = fromIntegral new_count / tCpu t

                  , utilLoad = utilLoad t `T.addUtil` Instance.util inst

                  , pTags = addTags (pTags t) (Instance.tags inst)

                  }

  where new_count = Instance.applyIfOnline inst (+ Instance.vcpus inst)

                    (uCpu t )

setSec t inst = t { sList = Instance.idx inst:sList t

                  , utilLoad = old_load { T.dskWeight = T.dskWeight old_load +

                                          T.dskWeight (Instance.util inst) }

                  }

  where old_load = utilLoad t

                                      then Node.noSecondary

                                      else sdx) &&

               Instance.autoBalance i == autobal &&

               Types.isBad fail1

prop_Text_Load_InstanceFail ktn fields =

  tags <- extract "tags" a

  auto_balance <- extract "auto_balance" beparams

  dt <- extract "disk_template" a

  let inst = Instance.create name mem disk vcpus running tags

             auto_balance pnode snode dt su

  return (name, inst)

       (Instance.vcpus inst) (instanceStatusToRaw (Instance.runSt inst))

       (if Instance.autoBalance inst then "Y" else "N")

       pnode snode (diskTemplateToRaw (Instance.diskTemplate inst))

-- | Generate instance file data from instance objects.

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

                         "' for instance " ++ name

  disk_template <- annotateResult ("Instance " ++ name)

                   (diskTemplateFromRaw dt)

  when (sidx == pidx) $ fail $ "Instance " ++ name ++

           " has same primary and secondary node - " ++ pnode

  let vtags = commaSplit tags

      newinst = Instance.create name vmem vdsk vvcpus vstatus vtags

  return (name, newinst)

loadInst ktn [ name, mem, dsk, vcpus, status, auto_bal, pnode, snode