Happstack.State.Transaction

Documentation

type ExceptionT = SomeException

logMT :: Priority -> String -> IO ()

getTime :: Integral epochTime => AnyEv epochTime

getEventClockTime :: AnyEv ClockTime

getEventId :: Integral txId => AnyEv txId

data GetCheckpointState

Constructors

GetCheckpointState

Instances

Typeable GetCheckpointState

Version GetCheckpointState

Serialize GetCheckpointState

QueryEvent GetCheckpointState ByteString

newtype SetCheckpointState

Constructors

SetCheckpointState ByteString

Instances

Typeable SetCheckpointState

Version SetCheckpointState

Serialize SetCheckpointState

UpdateEvent SetCheckpointState ()

type TypeString = String

data EventHandler where

Constructors

UpdateHandler :: UpdateEvent ev res => (TxContext -> ev -> IO res) -> (ev -> IO res) -> (Object -> ev) -> EventHandler

QueryHandler :: QueryEvent ev res => (ev -> IO res) -> (Object -> ev) -> EventHandler

type EventMap = Map TypeString EventHandler

data EmitInternal

Constructors

EmitInternal EventMap

emitRef :: IORef EmitInternal

emitFunc :: (Serialize ev, Typeable res) => EventMap -> TypeString -> ev -> IO res

emitEvent' :: (Serialize ev, Typeable res) => TypeString -> ev -> IO res

emitEvent :: (Serialize ev, Typeable res) => ev -> IO res

setNewEventMap :: EventMap -> IO ()

data EventItem

Constructors

EventItem

Fields

eventContext :: TxContext

eventData :: Dynamic

eventStreamRef :: MVar (Chan EventItem)

initEventStream :: IO ()

pushEventItem :: Serialize ev => TxContext -> ev -> IO ()

getEventStream :: IO (IO EventItem)

createEventMap :: (Methods st, Component st) => MVar TxControl -> Proxy st -> IO EventMap

extraEvents :: Serialize st => TxRun st -> EventMap

allStateTypes :: (Methods a, Component a) => Proxy a -> [TypeString]

componentVersions :: (Methods a, Component a) => Proxy a -> Map String [ByteString]

componentIO :: (Methods a, Component a) => Proxy a -> [IO ()]

createNewTxRun :: IO (TxRun st)

setNewStateType :: String -> String

getStateType :: String -> String

setNewState :: TypeString -> ByteString -> IO ()

setNewState' :: EventMap -> TypeString -> ByteString -> IO ()

getState :: TypeString -> IO ByteString

data SetNewState st

Constructors

SetNewState ByteString

Instances

Typeable1 SetNewState

Version (SetNewState st)

Typeable st => Serialize (SetNewState st)

Typeable st => UpdateEvent (SetNewState st) ()

data GetState st

Constructors

GetState

Instances

Typeable1 GetState

Version (GetState st)

Typeable st => Serialize (GetState st)

Typeable st => QueryEvent (GetState st) ByteString

update :: (MonadIO m, UpdateEvent ev res) => ev -> m res

Schedule an update and wait for it to complete. When this function returns, you're guaranteed the update will be persistent.

query :: (MonadIO m, QueryEvent ev res) => ev -> m res

Emit a state query and wait for the result.

quickQuery' :: Serialize st => TxRun st -> HR st -> IO ()

type Runner ev res = IO (IO ev, res -> IO ())

type EH i o = i -> IO o

data Event

Constructors

forall ev . Serialize ev => Event ev

data IHR st

Constructors

forall ev . Serialize ev => IHR TxContext ev (RunHandler st ev)

data HR st

Constructors

forall ev . Serialize ev => HR ev (RunHandler st ev)

type RunHandler st ev = TxContext -> st -> IO (Maybe st, IO ())

data Res a

Constructors

Ok a

Error ExceptionT

type EventQueue st = TChan (HR st)

type ProcessQueue st = TChan (IHR st)

data TxRun st

Constructors

TxRun

Fields

txProcessQueue :: !(ProcessQueue st)

txLastTxContext :: !(TVar TxContext)

type EvLoaders' st = Map String (ProcessQueue st -> ByteString -> IO (TxId, ByteString))

type EvLoaders = Map String (ByteString -> IO (TxId, ByteString))

setEvLoadersQueue :: ProcessQueue st -> EvLoaders' st -> EvLoaders

runObjectEvent :: Object -> IO Object

runObjectEventFunc :: Object -> EventMap -> IO Object

runColdEvent :: TxContext -> Object -> IO Object

runColdEventFunc :: TxContext -> Object -> EventMap -> IO Object

lookupEventHandler :: TypeString -> EventMap -> IO EventHandler

eventTString :: Serialize ev => ev -> TypeString

handleEvent :: (st -> Env -> Ev m res -> STM intermediate) -> (st -> intermediate -> IO (Maybe st, res)) -> (Either ExceptionT res -> IO ()) -> Ev m res -> RunHandler st ev

handleQuery :: (Either ExceptionT res -> IO ()) -> Query st res -> RunHandler st ev

handleUpdate :: (Either ExceptionT res -> IO ()) -> Update st res -> RunHandler st ev

checkDiff :: a -> a -> IO (Maybe a)

getEpochMilli :: IO EpochMilli

newTxContext :: IO TxContext

addTxId :: TxRun st -> TxContext -> STM TxContext

globalRandomGen :: MVar StdGen

data TxControl

Constructors

TxControl

Fields

ctlSaver :: Saver

Saver given by the user.

ctlEventSaver :: MVar (WriterStream EventLogEntry)

ctlAllComponents :: [String]

Types of each component used.

ctlComponentVersions :: Map String [ByteString]

Map listing all versions of a component

ctlChildren :: [(ThreadId, MVar ())]

ctlPrefixLock :: Maybe PrefixLock

Stores exclusive prefix lock (implemented in filesystem)

ctlCreateCheckpoint :: IO ()

data EventLogEntry

Constructors

EventLogEntry TxContext Object

Instances

Show EventLogEntry

Typeable EventLogEntry

Version EventLogEntry

Serialize EventLogEntry

runTxLoop :: MVar (WriterStream EventLogEntry) -> ProcessQueue st -> st -> IO ()