Synnefo » snf-ganeti » ganeti-local

oDiskTemplate :: OptType

oDiskTemplate = Option "" ["disk-template"]

                (ReqArg (\ t opts -> do

                           return $ opts { optDiskTemplate = dt }) "TEMPLATE")

                "select the desired disk template"

    Bad message -> [printf "Group %s: error %s" gname message]

  where grp = Container.find groupId gl

        gname = Group.name grp

-- | From a list of possibly bad and possibly empty solutions, filter

-- only the groups with a valid result. Note that the result will be

-- this function, whatever mode we have is just a primary change.

failOnSecondaryChange :: (Monad m) => EvacMode -> DiskTemplate -> m ()

failOnSecondaryChange ChangeSecondary dt =

         "' can't execute change secondary"

failOnSecondaryChange _ _ = return ()

printISpec True ispec spec disk_template = do

  printKeys $ map (\(a, fn) -> (prefix ++ "_" ++ a, fn ispec)) specData

  printKeys [ (prefix ++ "_RQN", printf "%d" req_nodes) ]

      where req_nodes = Instance.requiredNodes disk_template

            prefix = specPrefix spec

  printf "%s instance spec is:\n  %s, using disk\

         \ template '%s'.\n"

         (specDescription spec)

-- | Prints the tiered results.

printTiered :: Bool -> [(RSpec, Int)] -> Double

        nl = Data.Map.fromList ndx

        tags = ""

        sbal = if autobal then "Y" else "N"

        inst = Text.loadInst nl

               [name, mem_s, dsk_s, vcpus_s, status,

                sbal, pnode, snode, sdt, tags]

parseDesc desc =

    case sepSplit ',' desc of

      [a, n, d, m, c] -> do

        ncount <- tryRead "node count" n

        disk <- annotateResult "disk size" (parseUnit d)

        mem <- annotateResult "memory size" (parseUnit m)

serializeGroup :: Group.Group -> String

serializeGroup grp =

    printf "%s|%s|%s" (Group.name grp) (Group.uuid grp)

-- | Generate group file data from a group list.

serializeGroups :: Group.List -> String

             iname (Instance.mem inst) (Instance.dsk inst)

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

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

             (intercalate "," (Instance.tags inst))

-- | Generate instance file data from instance objects.

          -> m (String, Group.Group) -- ^ The result, a tuple of group

                                     -- UUID and group object

loadGroup [name, gid, apol] = do

  return (gid, Group.create name gid xapol)

loadGroup s = fail $ "Invalid/incomplete group data: '" ++ show s ++ "'"

                    "N" -> return False

                    _ -> fail $ "Invalid auto_balance value '" ++ auto_bal ++

                         "' for instance " ++ name

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

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

  let vtags = sepSplit ',' tags

    , Weight

    , GroupID

    , AllocPolicy(..)

    , RSpec(..)

    , DynUtil(..)

    , zeroUtil

    , Placement

    , IMove(..)

    , DiskTemplate(..)

    , MoveJob

    , JobSet

    , Result(..)

      deriving (Show, Read, Eq, Ord, Enum, Bounded)

-- | Convert a string to an alloc policy.

    case () of

      _ | s == C.allocPolicyPreferred -> return AllocPreferred

        | s == C.allocPolicyLastResort -> return AllocLastResort

        | otherwise -> fail $ "Invalid alloc policy mode: " ++ s

-- | Convert an alloc policy to the Ganeti string equivalent.

instance JSON.JSON AllocPolicy where

    readJSON s = case JSON.readJSON s of

                   JSON.Error e -> JSON.Error $

                                   "Can't parse alloc_policy: " ++ e

                    deriving (Show, Read, Eq, Enum, Bounded)

-- | Converts a DiskTemplate to String.

-- | Converts a DiskTemplate from String.

    case () of

      _ | s == C.dtDiskless   -> return DTDiskless

        | s == C.dtFile       -> return DTFile

        | otherwise           -> fail $ "Invalid disk template: " ++ s

instance JSON.JSON DiskTemplate where

    readJSON s = case JSON.readJSON s of

                   JSON.Error e -> JSON.Error $

                                   "Can't parse disk_template as string: " ++ e