-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Background workers for Spock
--   
--   Adds a background-job queue to Spock
@package Spock-worker
@version 0.3.1.0

module Web.Spock.Worker.Internal.Queue
data PureQueue p v
PureQueue :: !(Map p (Vector v)) -> !Int -> PureQueue p v
[pq_container] :: PureQueue p v -> !(Map p (Vector v))
[pq_maxSize] :: PureQueue p v -> !Int
emptyPQ :: Int -> PureQueue p v
sizePQ :: PureQueue p v -> Int
isFullPQ :: PureQueue p v -> Bool
toListPQ :: PureQueue p v -> [(p, [v])]
fromListPQ :: Ord p => Int -> [(p, [v])] -> Maybe (PureQueue p v)
maxPrioPQ :: PureQueue p v -> p
enqueuePQ :: Ord p => p -> v -> PureQueue p v -> (Bool, PureQueue p v)
dequeuePQ :: Ord p => p -> PureQueue p v -> (Maybe v, PureQueue p v)
dequeuePQ' :: Ord p => p -> PureQueue p v -> (Maybe (p, v), PureQueue p v)
newtype WorkerQueue p v
WorkerQueue :: (TVar (PureQueue p v)) -> WorkerQueue p v
newQueue :: Int -> IO (WorkerQueue p v)
size :: WorkerQueue p v -> STM Int
isFull :: WorkerQueue p v -> STM Bool
enqueue :: Ord p => p -> v -> WorkerQueue p v -> STM ()
dequeue :: Ord p => p -> WorkerQueue p v -> STM (Maybe v)
instance (GHC.Classes.Eq v, GHC.Classes.Eq p) => GHC.Classes.Eq (Web.Spock.Worker.Internal.Queue.PureQueue p v)
instance (GHC.Show.Show v, GHC.Show.Show p) => GHC.Show.Show (Web.Spock.Worker.Internal.Queue.PureQueue p v)

module Web.Spock.Worker

-- | Describe how you want jobs in the queue to be performed
type WorkHandler conn sess st err a = a -> ExceptT (InternalError err) (WebStateM conn sess st) WorkResult

-- | Configure how the worker handles it's task and define the queue size
data WorkerConfig
WorkerConfig :: Int -> WorkerConcurrentStrategy -> WorkerConfig
[wc_queueLimit] :: WorkerConfig -> Int
[wc_concurrent] :: WorkerConfig -> WorkerConcurrentStrategy

-- | Configure the concurrent behaviour of a worker. If you want tasks
--   executed concurrently, consider using <a>WorkerConcurrentBounded</a>
data WorkerConcurrentStrategy
WorkerNoConcurrency :: WorkerConcurrentStrategy
WorkerConcurrentBounded :: Int -> WorkerConcurrentStrategy
WorkerConcurrentUnbounded :: WorkerConcurrentStrategy

-- | Define a worker
data WorkerDef conn sess st err a
WorkerDef :: WorkerConfig -> WorkHandler conn sess st err a -> ErrorHandler conn sess st err a -> WorkerDef conn sess st err a
[wd_config] :: WorkerDef conn sess st err a -> WorkerConfig
[wd_handler] :: WorkerDef conn sess st err a -> WorkHandler conn sess st err a
[wd_errorHandler] :: WorkerDef conn sess st err a -> ErrorHandler conn sess st err a

-- | Create a new background worker and limit the size of the job queue.
newWorker :: (MonadTrans t, Monad (t (WebStateM conn sess st))) => WorkerDef conn sess st err a -> t (WebStateM conn sess st) (WorkQueue a)

-- | Describes the outcome of a job after completion. You can repeat jobs
data WorkResult
WorkComplete :: WorkResult
WorkError :: WorkResult
WorkRepeatIn :: NominalDiffTime -> WorkResult
WorkRepeatAt :: UTCTime -> WorkResult

-- | The queue containing scheduled jobs
data WorkQueue a

-- | Describes when a job should be executed
data WorkExecution
WorkNow :: WorkExecution
WorkIn :: NominalDiffTime -> WorkExecution
WorkAt :: UTCTime -> WorkExecution

-- | Add a new job to the background worker. If the queue is full this will
--   block
addWork :: MonadIO m => WorkExecution -> a -> WorkQueue a -> m ()

-- | Describe how you want to handle errors. Make sure you catch all
--   exceptions that can happen inside this handler, otherwise the worker
--   will crash!
data ErrorHandler conn sess st err a
ErrorHandlerIO :: ((InternalError err) -> a -> IO WorkResult) -> ErrorHandler conn sess st err a
ErrorHandlerSpock :: ((InternalError err) -> a -> (WebStateM conn sess st) WorkResult) -> ErrorHandler conn sess st err a

-- | An error from a worker
data InternalError a
InternalErrorMsg :: String -> InternalError a
InternalError :: a -> InternalError a
instance GHC.Classes.Eq Web.Spock.Worker.WorkResult
instance GHC.Show.Show Web.Spock.Worker.WorkResult
