Synnefo » snf-ganeti

oDataFile = Option "t" ["text-data"]

            (ReqArg (\ f o -> Ok o { optDataFile = Just f }) "FILE")

            "the cluster data FILE"

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"

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

                (reqWithConversion diskTemplateFromRaw

                 (\dt opts -> Ok opts { optDiskTemplate = Just dt })

                 "TEMPLATE") "select the desired disk template"

oSpindleUse = Option "" ["spindle-use"]

              (reqWithConversion (tryRead "parsing spindle-use")

               (\su opts -> do

                  when (su < 0) $

                       fail "Invalid value of the spindle-use\

                            \ (expected >= 0)"

                  return $ opts { optSpindleUse = Just su })

               "SPINDLES") "select how many virtual spindle instances use\

                           \ [default read from cluster]"

oSelInst = Option "" ["select-instances"]

          (ReqArg (\ f opts -> Ok opts { optSelInst = sepSplit ',' f }) "INSTS")

          "only select given instances for any moves"

oInstMoves = Option "" ["no-instance-moves"]

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

             "disallow instance (primary node) moves from the list of allowed,\

             \ instance changes, thus allowing only slower, but sometimes\

             \ safer, drbd secondary changes"

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

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

            "Import dynamic utilisation data from the given FILE"

oEvacMode = Option "E" ["evac-mode"]

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

            "enable evacuation mode, where the algorithm only moves \

            \ instances away from offline and drained nodes"

oExInst = Option "" ["exclude-instances"]

          (ReqArg (\ f opts -> Ok opts { optExInst = sepSplit ',' f }) "INSTS")

          "exclude given instances from any moves"

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

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

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

oExecJobs = Option "X" ["exec"]

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

             "execute the suggested moves via Luxi (only available when using\

             \ it for data gathering)"

oGroup = Option "G" ["group"]

            (ReqArg (\ f o -> Ok o { optGroup = Just f }) "ID")

            "the ID of the group to balance"

oIAllocSrc = Option "I" ["ialloc-src"]

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

             "Specify an iallocator spec as the cluster data source"

oLuxiSocket = Option "L" ["luxi"]

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

                       fromMaybe Path.defaultLuxiSocket) "SOCKET")

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

oMachineReadable = Option "" ["machine-readable"]

                   (OptArg (\ f opts -> do

                     flag <- parseYesNo True f

                     return $ opts { optMachineReadable = flag }) "CHOICE")

          "enable machine readable output (pass either 'yes' or 'no' to\

          \ explicitly control the flag, or without an argument defaults to\

          \ yes"

oMaxCpu = Option "" ["max-cpu"]

          (reqWithConversion (tryRead "parsing max-cpu")

           (\mcpu opts -> do

              when (mcpu <= 0) $

                   fail "Invalid value of the max-cpu ratio,\

                        \ expected >0"

              return $ opts { optMcpu = Just mcpu }) "RATIO")

          "maximum virtual-to-physical cpu ratio for nodes (from 0\

          \ upwards) [default read from cluster]"

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

                (reqWithConversion (tryRead "max solution length")

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

                "cap the solution at this many balancing or allocation \

                \ rounds (useful for very unbalanced clusters or empty \

                \ clusters)"

oMinDisk = Option "" ["min-disk"]

           (reqWithConversion (tryRead "min free disk space")

            (\n opts -> Ok opts { optMdsk = n }) "RATIO")

           "minimum free disk space for nodes (between 0 and 1) [0]"

oMinGain = Option "g" ["min-gain"]

           (reqWithConversion (tryRead "min gain")

            (\g opts -> Ok opts { optMinGain = g }) "DELTA")

            "minimum gain to aim for in a balancing step before giving up"

oMinGainLim = Option "" ["min-gain-limit"]

            (reqWithConversion (tryRead "min gain limit")

             (\g opts -> Ok opts { optMinGainLim = g }) "SCORE")

            "minimum cluster score for which we start checking the min-gain"

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

            (reqWithConversion (tryRead "min score")

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

            "mininum score to aim for"

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

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

             "do not show a header line"

oNoSimulation = Option "" ["no-simulation"]

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

                "do not perform rebalancing simulation"

oNodeSim = Option "" ["simulate"]

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

            "simulate an empty cluster, given as\

            \ 'alloc_policy,num_nodes,disk,ram,cpu'"

oOfflineNode = Option "O" ["offline"]

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

               "set node as offline"

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

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

             "directory in which to write output files"

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"

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

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

              "print the final instance map"

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

              (OptArg ((\ f opts ->

                          let (prefix, realf) = case f of

                                                  '+':rest -> (["+"], rest)

                                                  _ -> ([], f)

                              splitted = prefix ++ sepSplit ',' realf

                          in Ok opts { optShowNodes = Just splitted }) .

                       fromMaybe []) "FIELDS")

              "print the final node list"

oQuiet = Option "q" ["quiet"]

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

         "decrease the verbosity level"

oRapiMaster = Option "m" ["master"]

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

              "collect data via RAPI at the given ADDRESS"

oSaveCluster = Option "S" ["save"]

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

            "Save cluster state at the end of the processing to FILE"

oStdSpec = Option "" ["standard-alloc"]

             (ReqArg (\ inp opts -> do

                        tspec <- parseISpecString "standard" inp

                        return $ opts { optStdSpec = Just tspec } )

              "STDSPEC")

             "enable standard specs allocation, given as 'disk,ram,cpu'"

oTieredSpec = Option "" ["tiered-alloc"]

             (ReqArg (\ inp opts -> do

                        tspec <- parseISpecString "tiered" inp

                        return $ opts { optTieredSpec = Just tspec } )

              "TSPEC")

             "enable tiered specs allocation, given as 'disk,ram,cpu'"

oVerbose = Option "v" ["verbose"]

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

           "increase the verbosity level"