Synnefo » snf-ganeti

    , oPrintNodes

    , oPrintInsts

    , oPrintCommands

    , oOneline

    , oNoHeaders

    , oOutputDir

    , oNodeSim

    , oRapiMaster

    , oLuxiSocket

    , oMaxSolLength

    , oVerbose

    , oQuiet

    , oOfflineNode

    , oMinScore

    , oIMem

    , oIVcpus

    , oDiskMoves

    , oDynuFile

    , oTieredSpec

    , oExTags

    , oShowVer

    { optShowNodes   :: Maybe [String] -- ^ Whether to show node status

    , optShowInsts   :: Bool           -- ^ Whether to show the instance map

    , optShowCmds    :: Maybe FilePath -- ^ Whether to show the command list

    , optOneline     :: Bool           -- ^ Switch output to a single line

    , optOutPath     :: FilePath       -- ^ Path to the output directory

    , optNoHeaders   :: Bool           -- ^ Do not show a header line

    , optDataFile    :: Maybe FilePath -- ^ Path to the cluster data file

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

    , optMaxLength   :: Int            -- ^ Stop after this many steps

    , optMaster      :: String         -- ^ Collect data from RAPI

    , optLuxi        :: Maybe FilePath -- ^ Collect data from Luxi

    , optOffline     :: [String]       -- ^ Names of offline nodes

    , optTieredSpec  :: Maybe RSpec    -- ^ Requested specs for tiered mode

    , optMinScore    :: Score          -- ^ The minimum score we aim for

    , optDiskMoves   :: Bool           -- ^ Allow disk moves

    , optDynuFile    :: Maybe FilePath -- ^ Optional file with dynamic use data

    , optExTags      :: Maybe [String] -- ^ Tags to use for exclusion

    , optVerbose     :: Int            -- ^ Verbosity level

    , optShowVer     :: Bool           -- ^ Just show the program version

 { optShowNodes   = Nothing

 , optShowInsts   = False

 , optShowCmds    = Nothing

 , optOneline     = False

 , optNoHeaders   = False

 , optOutPath     = "."

 , optDataFile    = Nothing

 , optNodeSim     = Nothing

 , optMaxLength   = -1

 , optMaster      = ""

 , optLuxi        = Nothing

 , optOffline     = []

 , optTieredSpec  = Nothing

 , optMinScore    = 1e-9

 , optDiskMoves   = True

 , optDynuFile    = Nothing

 , optExTags      = Nothing

 , optVerbose     = 1

 , optShowVer     = False

oPrintNodes :: OptType

oPrintNodes = Option "p" ["print-nodes"]

              (OptArg ((\ f opts ->

                            let splitted = sepSplit ',' f

                            in Ok opts { optShowNodes = Just splitted }) .

                       fromMaybe []) "FIELDS")

              "print the final node list"

oPrintInsts :: OptType

oPrintInsts = Option "" ["print-instances"]

              (NoArg (\ opts -> Ok opts { optShowInsts = True }))

              "print the final instance map"

oPrintCommands :: OptType

oPrintCommands = Option "C" ["print-commands"]

                 (OptArg ((\ f opts -> Ok opts { optShowCmds = Just f }) .

                          fromMaybe "-")

                  "FILE")

                 "print the ganeti command list for reaching the solution,\

                 \ if an argument is passed then write the commands to a\

                 \ file named as such"

oOneline :: OptType

oOneline = Option "o" ["oneline"]

           (NoArg (\ opts -> Ok opts { optOneline = True }))

           "print the ganeti command list for reaching the solution"

oNoHeaders :: OptType

oNoHeaders = Option "" ["no-headers"]

             (NoArg (\ opts -> Ok opts { optNoHeaders = True }))

             "do not show a header line"

oOutputDir :: OptType

oOutputDir = Option "d" ["output-dir"]

             (ReqArg (\ d opts -> Ok opts { optOutPath = d }) "PATH")

             "directory in which to write output files"

oNodeSim :: OptType

oNodeSim = Option "" ["simulate"]

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

            "simulate an empty cluster, given as 'num_nodes,disk,ram,cpu'"

oRapiMaster :: OptType

oRapiMaster = Option "m" ["master"]

              (ReqArg (\ m opts -> Ok opts { optMaster = m }) "ADDRESS")

              "collect data via RAPI at the given ADDRESS"

oLuxiSocket :: OptType

oLuxiSocket = Option "L" ["luxi"]

              (OptArg ((\ f opts -> Ok opts { optLuxi = Just f }) .

                       fromMaybe defaultLuxiSocket) "SOCKET")

              "collect data via Luxi, optionally using the given SOCKET path"

oVerbose :: OptType

oVerbose = Option "v" ["verbose"]

           (NoArg (\ opts -> Ok opts { optVerbose = optVerbose opts + 1 }))

           "increase the verbosity level"

oQuiet :: OptType

oQuiet = Option "q" ["quiet"]

         (NoArg (\ opts -> Ok opts { optVerbose = optVerbose opts - 1 }))

         "decrease the verbosity level"

oOfflineNode :: OptType

oOfflineNode = Option "O" ["offline"]

               (ReqArg (\ n o -> Ok o { optOffline = n:optOffline o }) "NODE")

               "set node as offline"

oMaxSolLength :: OptType

oMaxSolLength = Option "l" ["max-length"]

                (ReqArg (\ i opts -> Ok opts { optMaxLength = read i }) "N")

                "cap the solution at this many moves (useful for very\

                \ unbalanced clusters)"

oMinScore :: OptType

oMinScore = Option "e" ["min-score"]

            (ReqArg (\ e opts -> Ok opts { optMinScore = read e }) "EPSILON")

            " mininum score to aim for"

oIDisk :: OptType

oIDisk = Option "" ["disk"]

         (ReqArg (\ d opts ->

                     let ospec = optISpec opts

                         nspec = ospec { rspecDsk = read d }

                     in Ok opts { optISpec = nspec }) "DISK")

         "disk size for instances"

oINodes :: OptType

oINodes = Option "" ["req-nodes"]

          (ReqArg (\ n opts -> Ok opts { optINodes = read n }) "NODES")

          "number of nodes for the new instances (1=plain, 2=mirrored)"

oDiskMoves :: OptType

oDiskMoves = Option "" ["no-disk-moves"]

             (NoArg (\ opts -> Ok opts { optDiskMoves = False}))

             "disallow disk moves from the list of allowed instance changes,\

             \ thus allowing only the 'cheap' failover/migrate operations"

oDynuFile :: OptType

oDynuFile = Option "U" ["dynu-file"]

            (ReqArg (\ f opts -> Ok opts { optDynuFile = Just f }) "FILE")

            "Import dynamic utilisation data from the given FILE"

oExTags :: OptType

oExTags = Option "" ["exclusion-tags"]

            (ReqArg (\ f opts -> Ok opts { optExTags = Just $ sepSplit ',' f })

             "TAG,...") "Enable instance exclusion based on given tag prefix"

oShowVer :: OptType

oShowVer = Option "V" ["version"]

           (NoArg (\ opts -> Ok opts { optShowVer = True}))

           "show the version of the program"

oShowHelp :: OptType

oShowHelp = Option "h" ["help"]

            (NoArg (\ opts -> Ok opts { optShowHelp = True}))

            "show help"