Network.Salvia.Handler.Session

Documentation

newtype SessionID

A session identifier. Should be unique for every session.

Constructors

SID

Fields

_sid :: Integer

Instances

Eq SessionID

Ord SessionID

Show SessionID

Random SessionID

sid :: SessionID :-> Integer

data Session p

The session data type with polymorphic payload.

Constructors

Session

Fields

_sID :: SessionID

_sStart :: UTCTime

_sLast :: UTCTime

_sExpire :: Integer

_sPayload :: Maybe p

Instances

Show p => Show (Session p)

sID :: Session p :-> SessionID

A globally unique session identifier.

sStart :: Session p :-> UTCTime

The time the session started.

sLast :: Session p :-> UTCTime

Last time session was used.

sExpire :: Session p :-> Integer

Expire after this amount of time when unused.

sPayload :: Session p :-> Maybe p

The information this session stores.

class (Applicative m, Monad m) => SessionM p m | m -> p where

Session type classes that hides the inner workings from the outside world.

Methods

prolongSession :: Integer -> m ()

getSession :: m (Session p)

putSession :: Session p -> m ()

delSession :: m ()

withSession :: (Session p -> Session p) -> m ()

Instances

Contains q (TVar (Sessions p)) => SessionM p (Handler q)

Default instance for the Handler context.

type SessionMap p = Map SessionID (TVar (Session p))

A mapping from unique session IDs to shared session variables.

newtype Sessions p

Constructors

Sessions

Fields

unSessions :: SessionMap p

withSessions :: (SessionMap p -> SessionMap p) -> Sessions p -> Sessions p

Apply a function to the sessions in the Sessions newtype.

mkSessions :: Sessions p

Create a new, empty, store of sessions.

hProlongSession :: forall m q p. (MonadIO m, HttpM' m, ServerM m, ServerAddressM m, PayloadM q (Sessions p) m) => p -> Integer -> m ()

todo doc: The session handler. This handler will try to return an existing session from the sessions map based on a session identifier found in the HTTP cookie. When such a session can be found the expiration date will be updated to a number of seconds in the future. When no session can be found a new one will be created. A cookie will be set that informs the client of the current session.

hGetSession :: (MonadIO m, HttpM' m, ServerM m, PayloadM q (Sessions p) m) => m (Session p)

hPutSession :: (MonadIO m, HttpM' m, ServerM m, ServerAddressM m, PayloadM q (Sessions p) m) => Session p -> m ()

hDelSession :: forall q p m. (PayloadM q (Sessions p) m, HttpM' m, MonadIO m) => p -> m ()

hWithSession :: (PayloadM q (Sessions p) m, MonadIO m, HttpM Request m) => (Session p -> Session p) -> m ()

hSessionInfo :: (SessionM p m, SendM m) => m ()

existingSessionVarOrNew :: (Applicative m, MonadIO m, HttpM Request m, PayloadM q (Sessions p) m) => m (TVar (Session p))

todo: Given an existing session identifier lookup a session from the session map. When no session is available, or the session is expired, create a new one using the newSessionVar function. Otherwise the expiration date of the existing session is updated.

whenNotExpired :: MonadIO m => TVar (Session p) -> m (Maybe (TVar (Session p)))

setCookieSession :: (MonadIO m, ServerM m, ServerAddressM m, HttpM Response m) => SessionID -> UTCTime -> m ()

This handler sets the HTTP cookie for the specified session. It will use a default cookie with an additional sid attribute with the session identifier as value. The session expiration date will be used as the cookie expire field. The session is valid for all subdomains.

getCookieSessionID :: (MonadIO m, HttpM Request m) => m (Maybe SessionID)

Given the (possibly wrong) request cookie, try to recover the existing session identifier.

delCookieSession :: HttpM Response m => m ()

newSessionVar :: (MonadIO m, PayloadM q (Sessions p) m) => m (TVar (Session p))

Create a new session with a specified expiration date. The session will be stored in the session map.

newSessionID :: (MonadState (Sessions p) m, Functor m) => [SessionID] -> m SessionID

willExpireAt :: Session p -> UTCTime

lookupSessionVar :: (MonadIO m, PayloadM q (Sessions p) m) => SessionID -> m (Maybe (TVar (Session p)))

newVar :: MonadIO m => a -> m (TVar a)

getVar :: MonadIO m => TVar a -> m a

putVar :: MonadIO m => TVar a -> a -> m ()

modVar :: MonadIO m => (a -> a) -> TVar a -> m (TVar a)