{-# LANGUAGE AllowAmbiguousTypes #-}
module IHP.Job.Types.Class
( Job (..)
) where

import IHP.Prelude
import IHP.FrameworkConfig.Types (FrameworkConfig)
import IHP.Job.Types.BackoffStrategy (BackoffStrategy (..))

class Job job where
    perform :: (?modelContext :: ModelContext, ?context :: FrameworkConfig) => job -> IO ()

    maxAttempts :: (?job :: job) => Int
    maxAttempts = Int
10

    timeoutInMicroseconds :: Maybe Int
    timeoutInMicroseconds = Maybe Int
forall a. Maybe a
Nothing

    -- | While jobs are typically fetch using pg_notiy, we have to poll the queue table
    -- periodically to catch jobs with a @run_at@ in the future
    --
    -- By default we only poll every minute
    queuePollInterval :: Int
    queuePollInterval = Int
60 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
1000000

    -- | How many jobs of this type can be executed at the same time
    --
    -- This limit only applies to the running haskell process. If you run @N@ multiple
    -- independent processes of the job runner, the limit will be @N * maxConcurrency@
    maxConcurrency :: Int
    maxConcurrency = Int
16

    backoffStrategy :: BackoffStrategy
    backoffStrategy = LinearBackoff { delayInSeconds :: Int
delayInSeconds = Int
30 }

    -- | How long a job can be in 'JobStatusRunning' before it's considered stale
    -- and recovered. Set to 'Nothing' to disable stale job recovery.
    --
    -- Default: 10 minutes
    staleJobTimeout :: Maybe NominalDiffTime
    staleJobTimeout = NominalDiffTime -> Maybe NominalDiffTime
forall a. a -> Maybe a
Just NominalDiffTime
600