Synnefo » snf-ganeti » ganeti-local

import System (exitWith, ExitCode(..))

import Ganeti.HTools.Loader (RqType(..), Request(..), ClusterData(..))

import Ganeti.HTools.ExtLoader (loadExternalData)

processResults :: (Monad m) =>

                  RqType -> Cluster.AllocSolution

               -> m Cluster.AllocSolution

processResults _ (Cluster.AllocSolution { Cluster.asSolutions = [],

                                          Cluster.asLog = msgs }) =

  fail $ intercalate ", " msgs

processResults (Evacuate _) as = return as

processResults _ as =

    case Cluster.asSolutions as of

      _:[] -> return as

      _ -> fail "Internal error: multiple allocation solutions"

-- | Process a request and return new node lists

processRequest :: Request

               -> Result Cluster.AllocSolution

processRequest request =

  let Request rqtype (ClusterData gl nl il _) = request

  in case rqtype of

       Allocate xi reqn -> Cluster.tryMGAlloc gl nl il xi reqn

       Relocate idx reqn exnodes -> Cluster.tryMGReloc gl nl il

                                    idx reqn exnodes

       Evacuate exnodes -> Cluster.tryMGEvac gl nl il exnodes

       MultiReloc _ _ -> fail "multi-reloc not handled"

       NodeEvacuate _ _ -> fail "node-evacuate not handled"

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

readRequest :: Options -> [String] -> IO Request

readRequest opts args = do

  when (null args) $ do

         hPutStrLn stderr "Error: this program needs an input file."

         exitWith $ ExitFailure 1

  input_data <- readFile (head args)

  r1 <- case parseData input_data of

          Bad err -> do

            hPutStrLn stderr $ "Error: " ++ err

            exitWith $ ExitFailure 1

          Ok rq -> return rq

  (if isJust (optDataFile opts) ||  (not . null . optNodeSim) opts

   then do

     cdata <- loadExternalData opts

     let Request rqt _ = r1

     return $ Request rqt cdata

   else return r1)