Synnefo » snf-ganeti

  when (isJust arData) $ do

    let tag = arTag $ fromJust arData

    putStrLn (">>> Adding the following tag to " ++ iname ++ ":\n" ++ show tag)

  unless (null rmTags) $ do

    putStr (">>> Removing the following tags from " ++ iname ++ ":\n" ++

            unlines (map show rmTags))

  return instData { tagsToRemove = [] }

import Ganeti.BasicTypes

import Ganeti.Logging

import Ganeti.Luxi

import qualified Ganeti.Query.Language as Qlang

import qualified Ganeti.Query.Cluster as QCluster

import Ganeti.Query.Query

import Ganeti.Query.Filter (makeSimpleFilter)

-- | Helper for classic queries.

handleClassicQuery :: ConfigData      -- ^ Cluster config

    Ok _ -> return . Ok . J.makeObj $ obj

    Bad ex -> return $ Bad ex

  let tags = case kind of

handleCall cfg (Query qkind qfields qfilter) = do

  result <- query cfg True (Qlang.Query qkind qfields qfilter)

               Text.JSON.Ok jobs' -> return jobs'

               Error msg ->

                 assertFailure ("Unable to decode jobs: " ++ msg)

                 -- for proper types

                 >> fail "Unable to decode jobs"

  assertEqual "Mismatch in number of returned jobs"

                              listOf genFQDN <*> arbitrary

      Luxi.ReqQueryConfigValues -> Luxi.QueryConfigValues <$> genFields

      Luxi.ReqQueryClusterInfo -> pure Luxi.QueryClusterInfo

      Luxi.ReqSubmitJob -> Luxi.SubmitJob <$> resize maxOpCodes arbitrary

      Luxi.ReqSubmitManyJobs -> Luxi.SubmitManyJobs <$>

                                resize maxOpCodes arbitrary

import Test.Ganeti.TestHelper

import Test.Ganeti.TestCommon

import Test.Ganeti.Types ()

import Ganeti.BasicTypes

import qualified Ganeti.Constants as C

                    , pure OpCodes.TagCluster

                    ]

$(genArbitrary ''OpCodes.ReplaceDisksMode)

$(genArbitrary ''DiskAccess)

instance Arbitrary INicParams where

  arbitrary = INicParams <$> genMaybe genNameNE <*> genMaybe genName <*>

instance Arbitrary IDiskParams where

  arbitrary = IDiskParams <$> arbitrary <*> arbitrary <*>

          return Nothing <*> arbitrary <*> arbitrary <*> arbitrary <*>

          genMaybe genNameNE <*> arbitrary

      "OP_TAGS_GET" ->

      "OP_TAGS_SEARCH" ->

        OpCodes.OpTagsSearch <$> genNameNE

      "OP_TAGS_SET" ->

      "OP_TAGS_DEL" ->

      "OP_CLUSTER_POST_INIT" -> pure OpCodes.OpClusterPostInit

      "OP_CLUSTER_DESTROY" -> pure OpCodes.OpClusterDestroy

      "OP_CLUSTER_QUERY" -> pure OpCodes.OpClusterQuery

        OpCodes.OpClusterRename <$> genNameNE

      "OP_CLUSTER_SET_PARAMS" ->

        OpCodes.OpClusterSetParams <$> arbitrary <*> emptyMUD <*> emptyMUD <*>

          genMaybe genEmptyContainer <*> emptyMUD <*>

          genMaybe genEmptyContainer <*> genMaybe genEmptyContainer <*>

          genMaybe genEmptyContainer <*> genMaybe arbitrary <*>

      "OP_CLUSTER_DEACTIVATE_MASTER_IP" ->

        pure OpCodes.OpClusterDeactivateMasterIp

      "OP_QUERY" ->

      "OP_QUERY_FIELDS" ->

        OpCodes.OpQueryFields <$> arbitrary <*> arbitrary

      "OP_OOB_COMMAND" ->

        OpCodes.OpNodeRemove <$> genNodeNameNE <*> return Nothing

      "OP_NODE_ADD" ->

        OpCodes.OpNodeAdd <$> genNodeNameNE <*> emptyMUD <*> emptyMUD <*>

          genMaybe genNameNE <*> arbitrary <*> arbitrary <*> emptyMUD

      "OP_NODE_QUERY" ->

        OpCodes.OpNodeQuery <$> genFieldsNE <*> genNamesNE <*> arbitrary

        OpCodes.OpNodeQueryvols <$> arbitrary <*> genNodeNamesNE

      "OP_NODE_QUERY_STORAGE" ->

        OpCodes.OpNodeQueryStorage <$> arbitrary <*> arbitrary <*>

      "OP_NODE_MODIFY_STORAGE" ->

        OpCodes.OpNodeModifyStorage <$> genNodeNameNE <*> return Nothing <*>

      "OP_REPAIR_NODE_STORAGE" ->

        OpCodes.OpRepairNodeStorage <$> genNodeNameNE <*> return Nothing <*>

      "OP_NODE_SET_PARAMS" ->

        OpCodes.OpNodeSetParams <$> genNodeNameNE <*> return Nothing <*>

          arbitrary <*> emptyMUD <*> emptyMUD <*> arbitrary <*> arbitrary <*>

          genMaybe genNameNE <*> arbitrary

      "OP_INSTANCE_CREATE" ->

        OpCodes.OpInstanceCreate <$> genFQDN <*> arbitrary <*>

          arbitrary <*> arbitrary <*> arbitrary <*> arbitrary <*>

      "OP_INSTANCE_MULTI_ALLOC" ->

      "OP_INSTANCE_REINSTALL" ->

        OpCodes.OpInstanceReinstall <$> genFQDN <*> return Nothing <*>

          arbitrary <*> genMaybe genNameNE <*> genMaybe (pure emptyJSObject)

          arbitrary <*> genNodeNamesNE <*> return Nothing <*>

          genMaybe genNameNE

      "OP_INSTANCE_QUERY" ->

      "OP_INSTANCE_QUERY_DATA" ->

        OpCodes.OpInstanceQueryData <$> arbitrary <*>

          genNodeNamesNE <*> arbitrary

        OpCodes.OpBackupRemove <$> genFQDN <*> return Nothing

      "OP_TEST_ALLOCATOR" ->

        OpCodes.OpTestAllocator <$> arbitrary <*> arbitrary <*>

          arbitrary <*> genMaybe genNameNE <*>

          (genTags >>= mapM mkNonEmpty) <*>

          arbitrary <*> arbitrary <*> genMaybe genNameNE <*>

        OpCodes.OpTestDummy <$> pure J.JSNull <*> pure J.JSNull <*>

          pure J.JSNull <*> pure J.JSNull

      "OP_NETWORK_ADD" ->

          arbitrary <*> (genTags >>= mapM mkNonEmpty)

      "OP_NETWORK_REMOVE" ->

        OpCodes.OpNetworkRemove <$> genNameNE <*> arbitrary

      "OP_NETWORK_SET_PARAMS" ->

        OpCodes.OpNetworkSetParams <$> genNameNE <*>

      "OP_NETWORK_CONNECT" ->

        OpCodes.OpNetworkConnect <$> genNameNE <*> genNameNE <*>

          arbitrary <*> genNameNE <*> arbitrary

      "OP_NETWORK_DISCONNECT" ->

        OpCodes.OpNetworkDisconnect <$> genNameNE <*> genNameNE

      "OP_NETWORK_QUERY" ->

      "OP_RESTRICTED_COMMAND" ->

        OpCodes.OpRestrictedCommand <$> arbitrary <*> genNodeNamesNE <*>

          return Nothing <*> genNameNE

     runPython "from ganeti import opcodes\n\

               \from ganeti import serializer\n\

               \import sys\n\

     >>= checkPythonResult

  py_ops <- case J.decode py_stdout::J.Result [String] of

               J.Ok ops -> return ops

        ) opcodes

  py_stdout <-

     runPython "from ganeti import opcodes\n\

               \from ganeti import serializer\n\

               \op_data = serializer.Load(sys.stdin.read())\n\

               \decoded = [opcodes.OpCode.LoadOpCode(o) for o in op_data]\n\

               \for op in decoded:\n\

  , SmallRatio(..)

  , genSetHelper

  , genSet

  , genIp6Addr

  , genIp6Net

  , netmask2NumHosts

  , testSerialisation

  , resultProp

genSet :: (Ord a, Bounded a, Enum a) => Maybe Int -> Gen (Set.Set a)

genSet = genSetHelper [minBound..maxBound]

-- | Generate an arbitrary IPv4 address in textual form.

  a <- choose (1::Int, 255)

  b <- choose (0::Int, 255)

  c <- choose (0::Int, 255)

  d <- choose (0::Int, 255)

-- | Generate an arbitrary IPv4 network in textual form.

  netmask <- choose (8::Int, 30)

-- | Helper function to compute the number of hosts in a network

-- given the netmask. (For IPv4 only.)

  ip <- genIp6Addr

  return $ ip ++ "/" ++ show netmask

-- * Helper functions

-- | Checks for serialisation idempotence.