Synnefo » snf-ganeti

{-| All RPC calls are run within this monad.

module Ganeti.WConfd.Monad

  ( DaemonHandle

  , dhConfigPath

  , mkDaemonHandle

  , ClientState(..)

  , WConfdMonadInt

  , runWConfdMonadInt

  , WConfdMonad

  , modifyConfigState

  , modifyLockAllocation

  ) where

import Control.Monad.Error

import Control.Monad.Trans.Control

import Control.Monad.Trans.RWS.Strict

import Ganeti.BasicTypes

import Ganeti.Errors

import Ganeti.Locking.Locks

import Ganeti.Logging

import Ganeti.Types

import Ganeti.WConfd.ConfigState

-- * Pure data types used in the monad

  -- all static information that doesn't change during the life-time of the

  -- daemon should go here;

  -- all IDs of threads that do asynchronous work should probably also go here

  }

mkDaemonHandle :: FilePath

               -> ConfigState

               -> GanetiLockAllocation

data ClientState = ClientState

  { clLiveFilePath :: FilePath

-- * Basic functions in the monad

-- | Atomically modifies the configuration state in the WConfdMonad.

modifyConfigState :: (ConfigState -> (ConfigState, a)) -> WConfdMonad a

modifyConfigState f = do

  -- TODO: Use lenses to modify the daemons state here

  let mf ds = let (cs', r) = f (dsConfigState ds)

              in (ds { dsConfigState = cs' }, r)

-- | Atomically modifies the lock allocation state in WConfdMonad.

modifyLockAllocation :: (GanetiLockAllocation -> (GanetiLockAllocation, a))

  dh <- lift . WConfdMonadInt $ ask

  let mf ds = let (la', r) = f (dsLockAllocation ds)

              in (ds { dsLockAllocation = la' }, r)

import Ganeti.UDSServer

import Ganeti.Runtime

import Ganeti.WConfd.ConfigState

import Ganeti.WConfd.Core

import Ganeti.WConfd.Monad

  conf_file <- Path.clusterConfFile

  dhOpt <- runResultT $ mkDaemonHandle conf_file mkConfigState emptyAllocation

  -- TODO: read current lock allocation from disk

  dh <- withError (strMsg . ("Initialization of the daemon failed" ++) . show)

                  dhOpt