Synnefo » snf-ganeti

    , oNodeSim

import qualified Ganeti.HTools.Simu as Simu

    , optNodeSim   :: Maybe String   -- ^ Cluster simulation mode

 , optNodeSim   = Nothing

oNodeSim :: OptType

oNodeSim = Option "" ["simulate"]

            (ReqArg (\ f o -> o { optNodeSim = Just f }) "SPEC")

            "simulate an empty cluster, given as 'num_nodes,disk,memory,cpus'"

      simdata = optNodeSim opts

      setSim = isJust simdata

          | setSim -> Simu.loadData $ fromJust simdata

{-| Parsing data from a simulated description of the cluster

This module holds the code for parsing a cluster description.

-}

{-

Copyright (C) 2009 Google Inc.

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful, but

WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301, USA.

-}

module Ganeti.HTools.Simu

    (

      loadData

    ) where

import Control.Monad

import Text.Printf (printf)

import Ganeti.HTools.Utils

import Ganeti.HTools.Types

import qualified Ganeti.HTools.Node as Node

import qualified Ganeti.HTools.Instance as Instance

-- | Parse results from readsPrec

parseChoices :: (Monad m, Read a) => String -> String -> [(a, String)] -> m a

parseChoices _ _ ((v, ""):[]) = return v

parseChoices name s ((_, e):[]) =

    fail $ name ++ ": leftover characters when parsing '"

           ++ s ++ "': '" ++ e ++ "'"

parseChoices name s _ = fail $ name ++ ": cannot parse string '" ++ s ++ "'"

-- | Safe 'read' function returning data encapsulated in a Result.

tryRead :: (Monad m, Read a) => String -> String -> m a

tryRead name s = parseChoices name s $ reads s

-- | Parse the string description into nodes

parseDesc :: String -> Result (Int, Int, Int, Int)

parseDesc desc =

    case sepSplit ',' desc of

      n:d:m:c:[] -> do

        ncount <- tryRead "node count" n

        disk <- tryRead "disk size" d

        mem <- tryRead "memory size" m

        cpu <- tryRead "cpu count" c

        return (ncount, disk, mem, cpu)

      _ -> fail "Invalid cluster specification"

-- | Builds the cluster data from node\/instance files.

loadData :: String -- ^ Cluster description in text format

         -> IO (Result (Node.AssocList, Instance.AssocList))

loadData ndata = -- IO monad, just for consistency with the other loaders

  return $ do

    (cnt, disk, mem, cpu) <- parseDesc ndata

    let nodes = map (\idx ->

                         let n = Node.create (printf "node%03d" idx)

                                 (fromIntegral mem) 0 mem

                                 (fromIntegral disk) disk

                                 (fromIntegral cpu) False

                         in (idx, Node.setIdx n idx)

                    ) [1..cnt]

    return (nodes, [])

    (

      loadData

    ) where

.BI "--simulate " description

Instead of using actual data, build an empty cluster given a node

description. The \fIdescription\fR parameter must be a comma-separate

list of four elements, describing in order:

.RS

.RS

.TP

the number of nodes in the cluster

.TP

the disk size of the nodes, in mebibytes

.TP

the memory size of the nodes, in mebibytes

.TP

the cpu core count for the nodes

.RE

An example description would be \fB20,102400,16384,4\fR describing a

20-node cluster where each node has 100GiB of disk space, 16GiB of

memory and 4 CPU cores. Note that all nodes must have the same specs

currently.

.RE

.TP

    , oNodeSim