/ - Diff - snf-ganeti - Greek Research and Technology Network's projects

     -}
     module Ganeti.Query.Common
       ( rsNoData
       ( NoDataRuntime(..)
       , rsNoData
       , rsUnavail
       , rsNormal
       , rsMaybeNoData
-...
     import Ganeti.Query.Types
     import Ganeti.Types
     -- | The runtime used by queries which retrieve no live data.
     data NoDataRuntime = NoDataRuntime
     -- * Generic functions
     -- | Conversion from 'VType' to 'FieldType'.

     -}
     module Ganeti.Query.Group
       ( Runtime
       , fieldsMap
       , collectLiveData
       ) where
       (fieldsMap) where
     import qualified Data.Map as Map
-...
     import Ganeti.Query.Types
     import Ganeti.Utils (niceSort)
     -- | There is no runtime.
     data Runtime = Runtime
     groupFields :: FieldList NodeGroup Runtime
     groupFields :: FieldList NodeGroup NoDataRuntime
     groupFields =
       [ (FieldDefinition "alloc_policy" "AllocPolicy" QFTText
            "Allocation policy for group",
-...
       tagsFields
     -- | The group fields map.
     fieldsMap :: FieldMap NodeGroup Runtime
     fieldsMap :: FieldMap NodeGroup NoDataRuntime
     fieldsMap =
       Map.fromList $ map (\v@(f, _, _) -> (fdefName f, v)) groupFields
     -- | Dummy function for collecting live data (which groups don't have).
     collectLiveData :: Bool -> ConfigData -> [NodeGroup]
                     -> IO [(NodeGroup, Runtime)]
     collectLiveData _ _ = return . map (\n -> (n, Runtime))

     {-# LANGUAGE TupleSections #-}
     {-| Implementation of the Ganeti Query2 instance queries.
     -}
-...
     -}
     module Ganeti.Query.Instance
       ( Runtime
       , fieldsMap
       , collectLiveData
       ) where
       (fieldsMap) where
     import qualified Data.Map as Map
-...
     import Ganeti.Query.Language
     import Ganeti.Query.Types
     -- | Dummy type for runtime to be implemented later, see the 'genericQuery'
     -- function in 'Ganeti.Query.Query' for an explanation
     data Runtime = Runtime
     instanceFields :: FieldList Instance Runtime
     instanceFields :: FieldList Instance NoDataRuntime
     instanceFields =
       [ (FieldDefinition "disk_template" "Disk_template" QFTText
          "Disk template",
-...
       serialFields "Instance" ++
       uuidFields "Instance"
     fieldsMap :: FieldMap Instance Runtime
     fieldsMap :: FieldMap Instance NoDataRuntime
     fieldsMap =
       Map.fromList [(fdefName f, v) | v@(f, _, _) <- instanceFields]
     -- | Dummy function for collecting live data - just for interface testing
     collectLiveData :: Bool -> ConfigData -> [Instance] -> IO [(Instance, Runtime)]
     collectLiveData _ _ = return . map (, Runtime)

       ( getGroupConnection
       , getNetworkUuid
       , instIsConnected
       , Runtime
       , fieldsMap
       , collectLiveData
       ) where
     -- FIXME: everything except Runtime(..) and fieldsMap
     -- FIXME: everything except fieldsMap
     -- is only exported for testing.
     import qualified Data.Map as Map
-...
     import Ganeti.Query.Types
     import Ganeti.Types
     -- | There is no actual runtime.
     data Runtime = Runtime
     networkFields :: FieldList Network Runtime
     networkFields :: FieldList Network NoDataRuntime
     networkFields =
       [ (FieldDefinition "name" "Network" QFTText "Name",
          FieldSimple (rsNormal . networkName), QffNormal)
-...
       tagsFields
     -- | The group fields map.
     fieldsMap :: FieldMap Network Runtime
     fieldsMap :: FieldMap Network NoDataRuntime
     fieldsMap =
       Map.fromList $ map (\v@(f, _, _) -> (fdefName f, v)) networkFields
-...
       let addrs = getReservations (networkNetwork net)
                   (fromMaybe "" $ networkExtReservations net)
       in rsNormal . intercalate ", " $ map show addrs
     -- | Dummy function for collecting live data (which networks don't have).
     collectLiveData :: Bool -> ConfigData -> [Network] -> IO [(Network, Runtime)]
     collectLiveData _ _ = return . map (\n -> (n, Runtime))

     {-# LANGUAGE TupleSections #-}
     {-| Implementation of the Ganeti Query2 functionality.
      -}
-...
         , queryCompat
         , getRequestedNames
         , nameField
         , NoDataRuntime
         ) where
     import Control.DeepSeq
-...
       queryJobs cfg live fields qfilter
     query cfg live qry = queryInner cfg live qry $ getRequestedNames qry
     -- | Dummy data collection fuction
     dummyCollectLiveData :: Bool -> ConfigData -> [a] -> IO [(a, NoDataRuntime)]
     dummyCollectLiveData _ _ = return . map (, NoDataRuntime)
     -- | Inner query execution function.
     queryInner :: ConfigData   -- ^ The current configuration
                -> Bool         -- ^ Whether to collect live data
-...
                    cfg live fields qfilter wanted
     queryInner cfg live (Query (ItemTypeOpCode QRInstance) fields qfilter) wanted =
       genericQuery Instance.fieldsMap Instance.collectLiveData instName
       genericQuery Instance.fieldsMap dummyCollectLiveData instName
                    configInstances getInstance cfg live fields qfilter wanted
     queryInner cfg live (Query (ItemTypeOpCode QRGroup) fields qfilter) wanted =
       genericQuery Group.fieldsMap Group.collectLiveData groupName configNodegroups
       genericQuery Group.fieldsMap dummyCollectLiveData groupName configNodegroups
                    getGroup cfg live fields qfilter wanted
     queryInner cfg live (Query (ItemTypeOpCode QRNetwork) fields qfilter) wanted =
       genericQuery Network.fieldsMap Network.collectLiveData
       genericQuery Network.fieldsMap dummyCollectLiveData
                    (fromNonEmpty . networkName)
                    configNetworks getNetwork cfg live fields qfilter wanted

Synnefo » snf-ganeti

Revision d286d795