Synnefo » snf-ganeti

{-

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

-}

module Ganeti.Query.Group

  ) where

import qualified Data.Map as Map

import Ganeti.Query.Types

-- | There is no runtime.

groupFields =

  [ (FieldDefinition "alloc_policy" "AllocPolicy" QFTText

       "Allocation policy for group",

  tagsFields

-- | The group fields map.

  Map.fromList $ map (\v@(f, _, _) -> (fdefName f, v)) groupFields

{-

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

  ( getGroupConnection

  , getNetworkUuid

  , instIsConnected

  ) where

-- is only exported for testing.

import qualified Data.Map as Map

import Ganeti.Query.Types

import Ganeti.Types

networkFields =

  [ (FieldDefinition "name" "Name" QFTText "Network name",

     FieldSimple (rsNormal . networkName), QffNormal)

  tagsFields

-- | The group fields map.

  Map.fromList $ map (\v@(f, _, _) -> (fdefName f, v)) networkFields

-- TODO: the following fields are not implemented yet: external_reservations

{-

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

-}

module Ganeti.Query.Node

  ) where

import Control.Applicative

import Ganeti.Query.Common

import Ganeti.Query.Types

-- | List of node live fields.

nodeLiveFieldsDefs :: [(FieldName, FieldTitle, FieldType, String, FieldDoc)]

nodeLiveFieldExtract _ _ = J.JSNull

-- | Helper for extracting field from RPC result.

nodeLiveRpcCall fname (Right res) _ =

  case nodeLiveFieldExtract fname res of

    J.JSNull -> rsNoData

-- | Builder for node live fields.

nodeLiveFieldBuilder :: (FieldName, FieldTitle, FieldType, String, FieldDoc)

nodeLiveFieldBuilder (fname, ftitle, ftype, _, fdoc) =

  ( FieldDefinition fname ftitle ftype fdoc

  , FieldRuntime $ nodeLiveRpcCall fname

                  else rsNormal (nodePowered node)

-- | List of all node fields.

nodeFields =

  [ (FieldDefinition "drained" "Drained" QFTBool "Whether node is drained",

     FieldSimple (rsNormal . nodeDrained), QffNormal)

  tagsFields

-- | The node fields map.

  Map.fromList $ map (\v@(f, _, _) -> (fdefName f, v)) nodeFields

-- | Collect live data from RPC query if enabled.

--

-- FIXME: Check which fields we actually need and possibly send empty

-- required

  return $ zip nodes (repeat $ Left (RpcResultError "Live data disabled"))

  let vgs = [clusterVolumeGroupName $ configCluster cfg]

      hvs = [getDefaultHypervisor cfg]

      step n (bn, gn, em) =

import qualified Ganeti.Query.Export as Export

import Ganeti.Query.Filter

import qualified Ganeti.Query.Job as Query.Job

import Ganeti.Query.Language

import Ganeti.Query.Types

import Ganeti.Path

import Ganeti.Types

queryInner cfg live (Query (ItemTypeOpCode QRNode) fields qfilter) wanted =

  runResultT $ do

      (fdefs, fgetters, _) = unzip3 selected

      live' = live && needsLiveData fgetters

  nodes <- resultT $ case wanted of

                      nodes

  -- here we would run the runtime data gathering, then filter again

  -- the nodes, based on existing runtime data

  let fdata = map (\(node, nrt) -> map (execGetter cfg nrt node) fgetters)

              nruntimes

  return QueryResult { qresFields = fdefs, qresData = fdata }

queryInner cfg _ (Query (ItemTypeOpCode QRGroup) fields qfilter) wanted =

  return $ do

      (fdefs, fgetters, _) = unzip3 selected

  groups <- case wanted of

              [] -> Ok . niceSortKey groupName .

  -- there is no live data for groups, so filtering is much simpler

  fgroups <- filterM (\n -> evaluateFilter cfg Nothing n cfilter) groups

  let fdata = map (\node ->

  return QueryResult { qresFields = fdefs, qresData = fdata }

queryInner cfg _ (Query (ItemTypeOpCode QRNetwork) fields qfilter) wanted =

  return $ do

      (fdefs, fgetters, _) = unzip3 selected

  networks <- case wanted of

                [] -> Ok . niceSortKey (fromNonEmpty . networkName) .

                _  -> mapM (getNetwork cfg) wanted

  fnetworks <- filterM (\n -> evaluateFilter cfg Nothing n cfilter) networks

  let fdata = map (\network ->

                   fnetworks

  return QueryResult { qresFields = fdefs, qresData = fdata }

-- | Query fields call.

queryFields :: QueryFields -> ErrorResult QueryFieldsResult

queryFields (QueryFields (ItemTypeOpCode QRNode) fields) =

queryFields (QueryFields (ItemTypeOpCode QRGroup) fields) =

queryFields (QueryFields (ItemTypeLuxi QRJob) fields) =

  Ok $ fieldsExtractor Query.Job.fieldsMap fields

{-

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

import Ganeti.BasicTypes

import Ganeti.Errors

import Ganeti.Query.Filter

import Ganeti.Query.Language

import Ganeti.Query.Query

import qualified Ganeti.Query.Job as Job

prop_queryNode_noUnknown :: Property

prop_queryNode_noUnknown =

  forAll (choose (0, maxNodes) >>= genEmptyCluster) $ \cluster ->

  QueryResult fdefs fdata <-

    run (query cluster False (Query (ItemTypeOpCode QRNode)

                              [field] EmptyFilter)) >>= resultProp

prop_queryNode_Unknown :: Property

prop_queryNode_Unknown =

  forAll (choose (0, maxNodes) >>= genEmptyCluster) $ \cluster ->

    $ \field -> monadicIO $ do

  QueryResult fdefs fdata <-

    run (query cluster False (Query (ItemTypeOpCode QRNode)

prop_queryNode_types =

  forAll (choose (0, maxNodes)) $ \numnodes ->

  forAll (genEmptyCluster numnodes) $ \cfg ->

  QueryResult fdefs fdata <-

    run (query cfg False (Query (ItemTypeOpCode QRNode)

                          [field] EmptyFilter)) >>= resultProp

              Ok (QueryFieldsResult v) -> return v

   let field_sort = compare `on` fdefName

   assertEqual "Mismatch in all fields list"

     (sortBy field_sort fdefs)

-- ** Group queries

prop_queryGroup_noUnknown :: Property

prop_queryGroup_noUnknown =

  forAll (choose (0, maxNodes) >>= genEmptyCluster) $ \cluster ->

   QueryResult fdefs fdata <-

     run (query cluster False (Query (ItemTypeOpCode QRGroup)

                               [field] EmptyFilter)) >>=

prop_queryGroup_Unknown :: Property

prop_queryGroup_Unknown =

  forAll (choose (0, maxNodes) >>= genEmptyCluster) $ \cluster ->

    $ \field -> monadicIO $ do

  QueryResult fdefs fdata <-

    run (query cluster False (Query (ItemTypeOpCode QRGroup)

prop_queryGroup_types =

  forAll (choose (0, maxNodes)) $ \numnodes ->

  forAll (genEmptyCluster numnodes) $ \cfg ->

  QueryResult fdefs fdata <-

    run (query cfg False (Query (ItemTypeOpCode QRGroup)

                          [field] EmptyFilter)) >>= resultProp

              Ok (QueryFieldsResult v) -> return v

   let field_sort = compare `on` fdefName

   assertEqual "Mismatch in all fields list"

     (sortBy field_sort fdefs)

-- ** Job queries