Synnefo » snf-ganeti

    cmdarg:_ ->

      case parseOptsInner defaults

             ["--" ++ cmdarg ++ maybe "" ("=" ++) (repr val)]

        Left e -> failfn $ "Failed to parse option '" ++ cmdarg ++ ": " ++

                  show e

        Right (options, _) -> eqcheck ("Wrong value in option " ++

  let prefix = "--" ++ head longs ++ "="

      good_cmd = prefix ++ good

      bad_cmd = prefix ++ bad in

    (Left _,  Right _) -> passfn

    (Right _, Right _) -> failfn $ "Command line '" ++ bad_cmd ++

                          "' succeeded when it shouldn't"

-- | Helper to test that a given option is accepted OK with quick exit.

checkEarlyExit :: (StandardOptions a) =>

  mapM_ (\param ->

             Left (code, _) ->

               assertEqual ("Program " ++ name ++

                            " returns invalid code " ++ show code ++

-- | Test that the option list supports some common options.

case_stdopts :: Assertion

case_stdopts =

testSuite "Daemon"

          [ 'prop_string_arg

-- | Test that all binaries support some common options.

case_stdopts :: Assertion

case_stdopts =

testSuite "HTools/CLI"

          [ 'prop_parseISpec

          -> [String]               -- ^ The command line arguments

          -> String                 -- ^ The program name

          -> [GenericOptType a]     -- ^ The supported command line options

          -> IO (a, [String])       -- ^ The resulting options and

                                    -- leftover arguments

    Left (code, msg) -> do

      hPutStr (if code == ExitSuccess then stdout else stderr) msg

      exitWith code

               -> [String]

               -> String

               -> [GenericOptType a]

               -> Either (ExitCode, String) (a, [String])

  case getOpt Permute (map fst options) argv of

    (opts, args, []) ->

      case foldM (flip id) defaults opts of

                 , (verRequested parsed,

                    Left (ExitSuccess, versionInfo progname))

                 , (compRequested parsed,

                 ]

    (_, _, errs) ->

      Left (ExitFailure 2, "Command line error: "  ++ concat errs ++ "\n" ++

parseArgs :: String -> [OptType] -> IO (DaemonOptions, [String])

parseArgs cmd options = do

  cmd_args <- getArgs

-- * Daemon-related functions

-- | PID file mode.

parseOpts :: [String]               -- ^ The command line arguments

          -> String                 -- ^ The program name

          -> [OptType]              -- ^ The supported command line options

          -> IO (Options, [String]) -- ^ The resulting options and leftover

                                    -- arguments

parseOpts = Common.parseOpts defaultOptions

  ( personalities

  ) where

import Ganeti.HTools.CLI (OptType, Options)

import qualified Ganeti.HTools.Program.Hail as Hail

import qualified Ganeti.HTools.Program.Hinfo as Hinfo

-- | Supported binaries.

                ]

-}

import Control.Monad

import Data.Maybe (fromMaybe, isJust)

import qualified Ganeti.HTools.Cluster as Cluster

import Ganeti.HTools.CLI

import Ganeti.HTools.IAlloc

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

  , oVerbose

  ]

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

wrapReadRequest opts args = do

  when (null args) $ do

-}

module Ganeti.HTools.Program.Hbal

import Control.Concurrent (threadDelay)

import Control.Exception (bracket)

import qualified Ganeti.HTools.Node as Node

import qualified Ganeti.HTools.Instance as Instance

import Ganeti.HTools.CLI

import Ganeti.HTools.ExtLoader

import Ganeti.HTools.Types

  , oSaveCluster

  ]

{- | Start computing the solution at the given depth and recurse until

we find a valid solution or we exceed the maximum depth.

-}

import Control.Monad

import Data.List (transpose)

import qualified Ganeti.HTools.Program.Hbal as Hbal

import Ganeti.HTools.CLI

import Ganeti.HTools.ExtLoader

import Ganeti.HTools.Loader

  , oVerbose

  ]

-- | Check phase - are we before (initial) or after rebalance.

data Phase = Initial

           | Rebalanced

-}

import Control.Monad

import Data.List

import qualified Ganeti.HTools.Group as Group

import qualified Ganeti.HTools.Instance as Instance

import Ganeti.HTools.CLI

import Ganeti.HTools.ExtLoader

import Ganeti.HTools.Loader

  , oOfflineNode

  ]

-- | Group information data-type.

data GroupInfo = GroupInfo { giName      :: String

                           , giNodeCount :: Int

-}

import Control.Monad

import Data.Maybe (isJust, fromJust, fromMaybe)

import Ganeti.HTools.Loader (checkData, mergeData, ClusterData(..))

import Ganeti.HTools.Text (serializeCluster)

import Ganeti.HTools.CLI

import Ganeti.HTools.Types

  , oNoHeaders

  ]

-- | Return a one-line summary of cluster state.

printCluster :: Node.List -> Instance.List

             -> String

-}

import Control.Monad

import Data.Char (toUpper, toLower)

import qualified Ganeti.HTools.Node as Node

import qualified Ganeti.HTools.Instance as Instance

import Ganeti.HTools.Types

import Ganeti.HTools.CLI

import Ganeti.HTools.ExtLoader

  , oSaveCluster

  ]

-- | The allocation phase we're in (initial, after tiered allocs, or

-- after regular allocation).

data Phase = PInitial

      boolnames = map (\(x, y) -> (x == name, Just y)) personalities

  case select Nothing boolnames of

    Nothing -> usage name

         cmd_args <- getArgs

         fn opts args