Synnefo » snf-ganeti

import Data.Maybe (fromMaybe, isJust, fromJust)

import Data.List

import Control.Monad

import Text.JSON (JSObject, JSValue(JSArray),

                  makeObj, encodeStrict, decodeStrict, fromJSObject, showJSON)

-- The result is a tuple of eventual warning messages and the parsed

-- request; if parsing the input data fails, we'll return a 'Bad'

-- value.

          -> Result ([String], Request) -- ^ Result tuple

  decoded <- fromJResult "Parsing input IAllocator message" (decodeStrict body)

  let obj = fromJSObject decoded

      extrObj x = tryFromObj "invalid iallocator message" obj x

  let (kti, il) = assignIndices iobj

  -- cluster tags

  ctags <- extrObj "cluster_tags"

  let (msgs, fix_nl) = checkData (cdNodes cdata1) (cdInstances cdata1)

      cdata = cdata1 { cdNodes = fix_nl }

      map_n = cdNodes cdata

-- | Reads the request from the data file(s).

readRequest :: FilePath -> IO Request

readRequest fp = do

  input_data <- case fp of

                  "-" -> getContents

                  _   -> readFile fp

    Bad err -> exitErr err

    Ok (fix_msgs, rq) -> maybeShowWarnings fix_msgs >> return rq

import Data.Maybe (isJust, fromJust)

import System.FilePath

import System.IO

import Text.Printf (hPrintf)

import qualified Ganeti.HTools.Backend.Luxi as Luxi

        | setFile -> wrapIO . Text.loadData $ fromJust tfile

        | setIAllocSrc -> wrapIO . IAlloc.loadData $ fromJust iallocsrc

        | otherwise -> return $ Bad "No backend selected! Exiting."

  cdata <- exitIfBad "failed to load data, aborting" ldresult

  let (fix_msgs, nl) = checkData (cdNodes cdata) (cdInstances cdata)

            -> Group.List     -- ^ List of node groups

            -> Node.List      -- ^ List of nodes

            -> Instance.List  -- ^ List of instances

            -> Instance.List  -- ^ Updated list of instances

      nlookup = flip Container.find nl . Instance.pNode

      glookup = flip Container.find gpols . Node.group . nlookup

      updateInstance inst = inst {

-- This examines the ganeti:watcher:autorepair and

-- ganeti:watcher:autorepair:suspend tags to determine the policy. If none of

-- these tags are present, Nothing (and not ArNotEnabled) is returned.

  let enabled = mapMaybe (autoRepairTypeFromRaw <=<

                          chompPrefix C.autoRepairTagEnabled) tags

      suspended = mapMaybe (chompPrefix C.autoRepairTagSuspended) tags

  in

   case () of

     -- Note how we must return ArSuspended even if "enabled" is empty, so that

     -- node groups or instances can suspend repairs that were enabled at an

     -- upper scope (cluster or node group).

-- | Compute the longest common suffix of a list of strings that

-- starts with a dot.

          -> [String]             -- ^ Exclusion tags

          -> [String]             -- ^ Selected instances (if not empty)

          -> [String]             -- ^ Excluded instances

          -> ClusterData          -- ^ Data from backends

          -> Result ClusterData   -- ^ Fixed cluster data

      il3 = foldl' (\im (name, n_util) ->

                        case Container.findByName im name of

                          Nothing -> im -- skipping unknown instance

import System.Exit

import System.IO

import System.FilePath

import Text.Printf (printf)

fixSlash = map (\x -> if x == '/' then '_' else x)

-- | Generates serialized data from loader input.

  let (_, fix_nl) = checkData nl il

  return cdata { cdNodes = fix_nl }

  return False

writeData nlen name opts (Ok cdata) = do

  case fixdata of

    Bad err -> printf "\nError for %s: failed to process data. Details:\n%s\n"

               name err >> return False

import qualified Data.Map as Map

import Data.List

import Data.Maybe

import Test.Ganeti.TestHelper

import Test.Ganeti.TestCommon

         let cdata = Loader.ClusterData defGroupList nl' il' ctags

                     Types.defIPolicy

             saved = Text.serializeCluster cdata

              Bad msg -> failTest $ "Failed to load/merge: " ++ msg

              Ok (Loader.ClusterData gl2 nl2 il2 ctags2 cpol2) ->

                conjoin [ ctags ==? ctags2

import qualified Data.IntMap as IntMap

import qualified Data.Map as Map

import Data.List

import Test.Ganeti.TestHelper

import Test.Ganeti.TestCommon

prop_mergeData :: [Node.Node] -> Bool

prop_mergeData ns =

  let na = Container.fromList $ map (\n -> (Node.idx n, n)) ns

         (Loader.emptyCluster {Loader.cdNodes = na}) of

    BasicTypes.Bad _ -> False

    BasicTypes.Ok (Loader.ClusterData _ nl il _ _) ->