Skip to content

GitLab

Commit 0c7ad62e authored by Mart Lubbers's avatar Mart Lubbers
Browse files
Options

Merge branch '232-remove-background-tasks-again' into 'master' 

Resolve "Remove background tasks (again)"

Closes #232

See merge request !226
parents c776fc42 b090587f
Pipeline #20438 passed with stage
    in 6 minutes and 42 seconds
    Expand all Hide whitespace changes
    Inline Side-by-side
    Showing with 248 additions and 301 deletions
    Libraries/iTasks/Engine.dcl
    View file @ 0c7ad62e
    ......@@ -58,21 +58,22 @@ instance Startable (a,b) | Startable a & Startable b
    :: EngineOptions =
    { appName :: String
    , appPath :: FilePath // Location of the application's executable
    { appName :: String
    , appPath :: FilePath // Location of the application's executable
    , appVersion :: String
    , serverPort :: Int
    , serverUrl :: String
    , serverPort :: Int
    , serverUrl :: String
    , keepaliveTime :: Timespec
    , sessionTime :: Timespec
    , persistTasks :: Bool
    , sessionTime :: Timespec
    , persistTasks :: Bool
    , autoLayout :: Bool
    , maxEvents :: Int
    , timeout :: Maybe Int // The timeout
    , distributed :: Bool
    , sdsPort :: Int
    , webDirPath :: FilePath // Location of public files that are served by the iTask webserver
    , storeDirPath :: FilePath // Location of the application's persistent data files
    , tempDirPath :: FilePath // Location for temporary files used in tasks
    , sdsPort :: Int
    , webDirPath :: FilePath // Location of public files that are served by the iTask webserver
    , storeDirPath :: FilePath // Location of the application's persistent data files
    , tempDirPath :: FilePath // Location for temporary files used in tasks
    , saplDirPath :: FilePath // Location of the application's sapl files (client-side code)
    }
    ......
    Libraries/iTasks/Engine.icl
    View file @ 0c7ad62e
    implementation module iTasks.Engine
    import StdMisc, StdArray, StdList, StdOrdList, StdTuple, StdChar, StdFile, StdBool, StdEnum
    import Data.Func
    import Data.Functor
    import Data.Queue
    import Internet.HTTP
    import StdEnv
    import System.CommandLine
    import System.Directory
    import System.File
    import System.FilePath
    import System.GetOpt
    import System.OS
    import Text
    import iTasks.Internal.Distributed.Symbols
    import iTasks.Internal.EngineTasks
    import iTasks.Internal.IWorld
    import iTasks.Internal.SDS
    import iTasks.Internal.SDSService
    import iTasks.Internal.TaskServer
    import iTasks.Internal.TaskStore
    import iTasks.Internal.Util
    import iTasks.SDS.Sources.System
    import iTasks.WF.Combinators.Common
    import iTasks.WF.Definition
    import iTasks.WF.Tasks.SDS
    import iTasks.WF.Tasks.System
    import StdInt, StdChar, StdString
    from StdFunc import o, seqList, ::St, const, id
    import tcp
    import Internet.HTTP, System.GetOpt, Data.Func, Data.Functor
    from Data.Map import :: Map
    from Data.Queue import :: Queue(..)
    from Data.Set import :: Set, newSet
    import qualified Data.Map as DM
    from System.OS import IF_POSIX_OR_WINDOWS, OS_NEWLINE, IF_WINDOWS
    import Data.List, Data.Error, Data.Func, Data.Tuple, Math.Random, Text
    import System.Time, System.CommandLine, System.Environment, System.OSError, System.File, System.FilePath, System.Directory
    import iTasks.Internal.Util, iTasks.Internal.HtmlUtil
    import iTasks.Internal.IWorld, iTasks.Internal.WebService, iTasks.Internal.SDSService
    import qualified iTasks.Internal.SDS as SDS
    import iTasks.UI.Layout, iTasks.UI.Layout.Default
    from iTasks.WF.Tasks.SDS import get
    from iTasks.WF.Combinators.Tune import class tune(..), instance tune ApplyLayout Task, :: ApplyLayout(..)
    from iTasks.SDS.Combinators.Common import sdsFocus
    from iTasks.SDS.Sources.System import applicationOptions
    import iTasks.Internal.IWorld, iTasks.Internal.TaskEval, iTasks.Internal.TaskStore
    import iTasks.Internal.Util
    import iTasks.Internal.TaskServer
    import iTasks.Internal.EngineTasks
    import iTasks.Internal.Distributed.Symbols
    from Sapl.Linker.LazyLinker import generateLoaderState, :: LoaderStateExt
    from Sapl.Linker.SaplLinkerShared import :: SkipSet
    from Sapl.Target.Flavour import :: Flavour, toFlavour
    from TCPIP import :: Timeout
    from StdFunc import :: St, seqList
    MAX_EVENTS :== 5
    ......@@ -49,23 +40,30 @@ doTasks startable world = doTasksWithOptions defaultEngineCLIOptions startable w
    doTasksWithOptions :: ([String] EngineOptions -> MaybeError [String] EngineOptions) a !*World -> *World | Startable a
    doTasksWithOptions initFun startable world
    # (cli,world) = getCommandLine world
    # (options,world) = defaultEngineOptions world
    # mbOptions = initFun cli options
    | mbOptions =:(Error _) = show (fromError mbOptions) world
    # options = fromOk mbOptions
    # iworld = createIWorld options world
    # (res,iworld) = initJSCompilerState iworld
    | res =:(Error _) = show ["Fatal error: " +++ fromError res] (destroyIWorld iworld)
    # (symbolsResult, iworld) = initSymbolsShare options.distributed options.appName iworld
    # (cli,world) = getCommandLine world
    # (options,world) = defaultEngineOptions world
    # mbOptions = initFun cli options
    | mbOptions =:(Error _) = show (fromError mbOptions) world
    # options = fromOk mbOptions
    # iworld = createIWorld options world
    # (res,iworld) = initJSCompilerState iworld
    | res =:(Error _) = show ["Fatal error: " +++ fromError res] (destroyIWorld iworld)
    # (symbolsResult, iworld) = initSymbolsShare options.distributed options.appName iworld
    | symbolsResult =: (Error _) = show ["Error reading symbols while required: " +++ fromError symbolsResult] (destroyIWorld iworld)
    # iworld = serve (startupTasks options) (tcpTasks options.serverPort options.keepaliveTime)
    engineTasks (timeout options.timeout) iworld
    # iworld = serve (startupTasks options) (tcpTasks options.serverPort options.keepaliveTime) (timeout options.timeout) iworld
    = destroyIWorld iworld
    where
    webTasks = [t \\ WebTask t <- toStartable startable]
    startupTasks {distributed, sdsPort} = (if distributed [case onStartup (sdsServiceTask sdsPort) of StartupTask t = t;] []) ++ [t \\ StartupTask t <- toStartable startable]
    hasWebTasks = not (webTasks =: [])
    startupTasks {distributed, sdsPort}
    //If distributed, start sds service task
    = (if distributed [startTask (sdsServiceTask sdsPort)] [])
    ++ [startTask flushWritesWhenIdle
    //If there no webtasks, stop when stable, otherwise cleanup old sessions
    ,startTask if (webTasks =: []) stopOnStable removeOutdatedSessions
    //Start all startup tasks
    :[t \\ StartupTask t <- toStartable startable]]
    startTask t = {StartupTask|attributes=defaultValue,task=TaskWrapper t}
    initSymbolsShare False _ iworld = (Ok (), iworld)
    initSymbolsShare True appName iworld = case storeSymbols (IF_WINDOWS (appName +++ ".exe") appName) iworld of
    ......@@ -78,16 +76,6 @@ where
    | otherwise
    = [(serverPort,httpServer serverPort keepaliveTime (engineWebService webTasks) taskOutput)]
    engineTasks =
    [BackgroundTask updateClock,
    BackgroundTask (processEvents MAX_EVENTS)
    :if (webTasks =: [])
    [BackgroundTask stopOnStable]
    [BackgroundTask removeOutdatedSessions
    ,BackgroundTask flushWritesWhenIdle
    ]
    ]
    // The iTasks engine consist of a set of HTTP Web services
    engineWebService :: [WebTask] -> [WebService (Map InstanceNo TaskOutput) (Map InstanceNo TaskOutput)]
    engineWebService webtasks =
    ......@@ -114,7 +102,7 @@ defaultEngineCLIOptions [argv0:argv] defaults
    where
    opts :: [OptDescr ((Maybe EngineOptions) -> Maybe EngineOptions)]
    opts =
    [ Option ['?'] ["help"] (NoArg $ const Nothing)
    [ Option ['?'] ["help"] (NoArg (\_->Nothing))
    "Display this message"
    , Option ['p'] ["port"] (ReqArg (\p->fmap \o->{o & serverPort=toInt p}) "PORT")
    ("Specify the HTTP port (default: " +++ toString defaults.serverPort +++ ")")
    ......@@ -122,6 +110,8 @@ where
    "Specify the timeout in ms (default: 500)\nIf not given, use an indefinite timeout."
    , Option [] ["keepalive"] (ReqArg (\p->fmap \o->{o & keepaliveTime={tv_sec=toInt p,tv_nsec=0}}) "SECONDS")
    "Specify the keepalive time in seconds (default: 300)"
    , Option [] ["maxevents"] (ReqArg (\p->fmap \o->{o & maxEvents=toInt p}) "NUM")
    "Specify the maximum number of events to process per loop (default: 5)"
    , Option [] ["sessiontime"] (ReqArg (\p->fmap \o->{o & sessionTime={tv_sec=toInt p,tv_nsec=0}}) "SECONDS")
    "Specify the expiry time for a session in seconds (default: 60)"
    , Option [] ["autolayout"] (NoArg (fmap \o->{o & autoLayout=True}))
    ......@@ -208,22 +198,23 @@ defaultEngineOptions world
    # appDir = takeDirectory appPath
    # appName = (dropExtension o dropDirectory) appPath
    # options =
    { appName = appName
    , appPath = appPath
    , appVersion = appVersion
    , serverPort = IF_POSIX_OR_WINDOWS 8080 80
    , serverUrl = "http://localhost/"
    , keepaliveTime = {tv_sec=300,tv_nsec=0} // 5 minutes
    , sessionTime = {tv_sec=60,tv_nsec=0} // 1 minute, (the client pings every 10 seconds by default)
    , persistTasks = False
    , autoLayout = True
    , distributed = False
    , sdsPort = 9090
    , timeout = Just 500
    , webDirPath = appDir </> appName +++ "-www"
    , storeDirPath = appDir </> appName +++ "-data" </> "stores"
    , tempDirPath = appDir </> appName +++ "-data" </> "tmp"
    , saplDirPath = appDir </> appName +++ "-sapl"
    { appName = appName
    , appPath = appPath
    , appVersion = appVersion
    , serverPort = IF_POSIX_OR_WINDOWS 8080 80
    , serverUrl = "http://localhost/"
    , keepaliveTime = {tv_sec=300,tv_nsec=0} // 5 minutes
    , sessionTime = {tv_sec=60,tv_nsec=0} // 1 minute, (the client pings every 10 seconds by default)
    , persistTasks = False
    , autoLayout = True
    , distributed = False
    , maxEvents = 5
    , sdsPort = 9090
    , timeout = Nothing//Just 500
    , webDirPath = appDir </> appName +++ "-www"
    , storeDirPath = appDir </> appName +++ "-data" </> "stores"
    , tempDirPath = appDir </> appName +++ "-data" </> "tmp"
    , saplDirPath = appDir </> appName +++ "-sapl"
    }
    = (options,world)
    ......@@ -256,3 +247,29 @@ determineAppVersion appPath world
    # version = strfTime "%Y%m%d-%H%M%S" tm
    = (version,world)
    timeout :: !(Maybe Timeout) !*IWorld -> (!Maybe Timeout,!*IWorld)
    timeout mt iworld = case read taskEvents EmptyContext iworld of
    //No events
    (Ok (ReadingDone (Queue [] [])),iworld=:{sdsNotifyRequests,world})
    # (ts, world) = nsTime world
    = ( minListBy lesser [mt:flatten (map (getTimeoutFromClock ts) ('DM'.elems sdsNotifyRequests))]
    , {iworld & world = world})
    (Ok (ReadingDone (Queue _ _)), iworld) = (Just 0,iworld) //There are still events, don't wait
    (Error _,iworld) = (Just 500,iworld) //Keep retrying, but not too fast
    where
    lesser (Just x) (Just y) = x < y
    lesser (Just _) Nothing = True
    lesser Nothing Nothing = False
    getTimeoutFromClock :: Timespec (Map SDSNotifyRequest Timespec) -> [Maybe Timeout]
    getTimeoutFromClock now requests = map getTimeoutFromClock` ('DM'.toList requests)
    where
    getTimeoutFromClock` :: (!SDSNotifyRequest, !Timespec) -> Maybe Timeout
    getTimeoutFromClock` (snr=:{cmpParam=(ts :: ClockParameter Timespec)}, reqTimespec)
    | startsWith "$IWorld:timespec$" snr.reqSDSId && ts.interval <> zero
    # fire = iworldTimespecNextFire now reqTimespec ts
    = Just (max 0 (toMs fire - toMs now))
    = mt
    getTimeoutFromClock` _ = mt
    toMs x = x.tv_sec * 1000 + x.tv_nsec / 1000000
    Libraries/iTasks/Internal/Client/RunOnClient.icl
    View file @ 0c7ad62e
    ......@@ -132,6 +132,7 @@ createClientIWorld serverURL currentInstance
    , autoLayout = True
    , timeout = Just 100
    , distributed = False
    , maxEvents = 5
    , sdsPort = 9090
    , webDirPath = locundef "webDirectory"
    , storeDirPath = locundef "dataDirectory"
    ......
    Libraries/iTasks/Internal/EngineTasks.dcl
    View file @ 0c7ad62e
    ......@@ -2,18 +2,10 @@ definition module iTasks.Internal.EngineTasks
    /**
    * This module defines the separate system tasks that the iTasks engine performs
    */
    from iTasks.Internal.IWorld import :: IWorld
    from iTasks.WF.Definition import :: TaskException
    from Data.Error import :: MaybeError
    from Data.Maybe import :: Maybe
    from TCPIP import :: Timeout
    from iTasks.WF.Definition import :: Task
    timeout :: !(Maybe Timeout) !*IWorld -> (!Maybe Timeout,!*IWorld)
    removeOutdatedSessions :: Task ()
    updateClock :: !*IWorld -> *(!MaybeError TaskException (), !*IWorld)
    flushWritesWhenIdle:: Task ()
    removeOutdatedSessions :: !*IWorld -> *(!MaybeError TaskException (), !*IWorld)
    flushWritesWhenIdle:: !*IWorld -> (!MaybeError TaskException (), !*IWorld)
    stopOnStable :: !*IWorld -> *(!MaybeError TaskException (), !*IWorld)
    stopOnStable :: Task ()
    Libraries/iTasks/Internal/EngineTasks.icl
    View file @ 0c7ad62e
    implementation module iTasks.Internal.EngineTasks
    import StdBool, StdOverloaded, StdList, StdOrdList
    import qualified Data.Map as DM
    import qualified Data.Set as DS
    import Data.List
    import Data.Functor, Data.Func
    import Data.Error
    import Data.Queue
    import StdEnv
    import iTasks.Engine
    import iTasks.Internal.IWorld
    import iTasks.WF.Definition
    import iTasks.Internal.Util
    import iTasks.Internal.SDS
    import iTasks.Internal.TaskEval
    import iTasks.Internal.TaskServer
    import iTasks.Internal.TaskState
    import iTasks.Internal.TaskStore
    import iTasks.SDS.Definition
    import iTasks.SDS.Combinators.Common
    import iTasks.UI.Definition
    import iTasks.WF.Definition
    from iTasks.Extensions.DateTime import toDate, toTime, instance == Date, instance == Time
    from System.Time import time
    import Text.GenJSON
    from TCPIP import :: Timeout
    import Data.Queue
    import Text
    from Data.Map import newMap
    timeout :: !(Maybe Timeout) !*IWorld -> (!Maybe Timeout,!*IWorld)
    timeout mt iworld = case read taskEvents EmptyContext iworld of
    //No events
    (Ok (ReadingDone (Queue [] [])),iworld=:{sdsNotifyRequests,world})
    # (ts, world) = nsTime world
    = ( minListBy lesser [mt:flatten $ map (getTimeoutFromClock ts) $ 'DM'.elems sdsNotifyRequests]
    , {iworld & world = world})
    (Ok (ReadingDone (Queue _ _)), iworld) = (Just 0,iworld) //There are still events, don't wait
    (Error _,iworld) = (Just 500,iworld) //Keep retrying, but not too fast
    everyTick :: (*IWorld -> *(!MaybeError TaskException (), !*IWorld)) -> Task ()
    everyTick f = Task eval
    where
    lesser (Just x) (Just y) = x < y
    lesser (Just _) Nothing = True
    lesser Nothing Nothing = False
    getTimeoutFromClock :: Timespec (Map SDSNotifyRequest Timespec) -> [Maybe Timeout]
    getTimeoutFromClock now requests = getTimeoutFromClock` <$> 'DM'.toList requests
    where
    getTimeoutFromClock` :: (!SDSNotifyRequest, !Timespec) -> Maybe Timeout
    getTimeoutFromClock` (snr=:{cmpParam=(ts :: ClockParameter Timespec)}, reqTimespec)
    | startsWith "$IWorld:timespec$" snr.reqSDSId && ts.interval <> zero
    # fire = iworldTimespecNextFire now reqTimespec ts
    = Just (max 0 (toMs fire - toMs now))
    = mt
    getTimeoutFromClock` _ = mt
    toMs x = x.tv_sec * 1000 + x.tv_nsec / 1000000
    updateClock :: !*IWorld -> *(!MaybeError TaskException (), !*IWorld)
    updateClock iworld=:{IWorld|clock,world}
    //Determine current date and time
    # (timespec,world) = nsTime world
    # iworld = {iworld & world = world}
    //Write SDS if necessary
    # (mbe,iworld) = write timespec (sdsFocus {start=zero,interval=zero} iworldTimespec) EmptyContext iworld
    = case mbe of
    (Error e ) -> (Error e, iworld)
    (_) -> (Ok (), iworld)
    eval event evalOpts tree=:(TCInit taskId ts) iworld
    # (merr, iworld) = f iworld
    | isError merr = (ExceptionResult (fromError merr), iworld)
    # (merr, iworld) = readRegister taskId tick iworld
    | isError merr = (ExceptionResult (fromError merr), iworld)
    = (ValueResult
    NoValue
    {TaskEvalInfo|lastEvent=ts,removedTasks=[],attributes=newMap}
    NoChange
    (TCInit taskId ts)
    , iworld)
    //When we run the built-in HTTP server we need to do active garbage collection of instances that were created for sessions
    removeOutdatedSessions :: !*IWorld -> *(!MaybeError TaskException (), !*IWorld)
    removeOutdatedSessions iworld=:{IWorld|options}
    # (mbIndex,iworld) = read (sdsFocus {InstanceFilter|defaultValue & onlySession=Just True} filteredInstanceIndex) EmptyContext iworld
    = case mbIndex of
    Ok (ReadingDone index) = checkAll removeIfOutdated index iworld
    Error e = (Error e, iworld)
    removeOutdatedSessions :: Task ()
    removeOutdatedSessions = everyTick \iworld=:{IWorld|options}->
    case read (sdsFocus {InstanceFilter|defaultValue & onlySession=Just True} filteredInstanceIndex) EmptyContext iworld of
    (Ok (ReadingDone index), iworld) = checkAll (removeIfOutdated options) index iworld
    (Error e, iworld) = (Error e, iworld)
    where
    checkAll f [] iworld = (Ok (),iworld)
    checkAll f [x:xs] iworld = case f x iworld of
    (Ok (),iworld) = checkAll f xs iworld
    (Error e,iworld) = (Error e,iworld)
    removeIfOutdated (instanceNo,_,_,_) iworld=:{options={appVersion},clock=tNow}
    removeIfOutdated options (instanceNo,_,_,_) iworld=:{options={appVersion},clock=tNow}
    # (remove,iworld) = case read (sdsFocus instanceNo taskInstanceIO) EmptyContext iworld of
    //If there is I/O information, we check that age first
    (Ok (ReadingDone (Just (client,tInstance))),iworld) //No IO for too long, clean up
    ......@@ -103,27 +71,23 @@ where
    = (Error e,iworld)
    //When the event queue is empty, write deferred SDS's
    flushWritesWhenIdle:: !*IWorld -> (!MaybeError TaskException (), !*IWorld)
    flushWritesWhenIdle iworld = case read taskEvents EmptyContext iworld of
    flushWritesWhenIdle:: Task ()
    flushWritesWhenIdle = everyTick \iworld->case read taskEvents EmptyContext iworld of
    (Error e,iworld) = (Error e,iworld)
    (Ok (ReadingDone (Queue [] [])),iworld) = flushDeferredSDSWrites iworld
    (Ok _,iworld) = (Ok (),iworld)
    //When we don't run the built-in HTTP server we don't want to loop forever so we stop the loop
    //once all tasks are stable
    stopOnStable :: !*IWorld -> *(!MaybeError TaskException (), !*IWorld)
    stopOnStable iworld=:{IWorld|shutdown}
    # (mbIndex,iworld) = read (sdsFocus {InstanceFilter|defaultValue & includeProgress=True} filteredInstanceIndex) EmptyContext iworld
    = case mbIndex of
    Ok (ReadingDone index)
    stopOnStable :: Task ()
    stopOnStable = everyTick \iworld=:{IWorld|shutdown}->case read (sdsFocus {InstanceFilter|defaultValue & includeProgress=True} filteredInstanceIndex) EmptyContext iworld of
    (Ok (ReadingDone index), iworld)
    # shutdown = case shutdown of
    Nothing = if (allStable index) (Just (if (exceptionOccurred index) 1 0)) Nothing
    _ = shutdown
    = (Ok (), {IWorld|iworld & shutdown = shutdown})
    Error e = (Error e, iworld)
    (Error e, iworld) = (Error e, iworld)
    where
    allStable instances = all (\v -> v =: Stable || v =: (Exception _)) (values instances)
    exceptionOccurred instances = any (\v -> v =: (Exception _)) (values instances)
    values instances = [value \\ (_,_,Just {InstanceProgress|value},_) <- instances]
    Libraries/iTasks/Internal/IWorld.dcl
    View file @ 0c7ad62e
    ......@@ -12,7 +12,7 @@ from Text.GenJSON import :: JSONNode
    from iTasks.Engine import :: EngineOptions
    from iTasks.UI.Definition import :: UI, :: UIType
    from iTasks.Internal.TaskState import :: ParallelTaskState, :: TIMeta, :: DeferredJSON
    from iTasks.Internal.Task import :: ConnectionTask, :: BackgroundTask
    from iTasks.Internal.Task import :: ConnectionTask
    from iTasks.Internal.TaskEval import :: TaskTime
    from iTasks.WF.Definition import :: TaskValue, :: Event, :: TaskId, :: InstanceNo, :: TaskNo, :: TaskException
    ......@@ -78,7 +78,6 @@ CLEAN_HOME_VAR :== "CLEAN_HOME"
    :: *IOTaskInstance
    = ListenerInstance !ListenerInstanceOpts !*TCP_Listener
    | ConnectionInstance !ConnectionInstanceOpts !*TCP_DuplexChannel
    | BackgroundInstance !BackgroundInstanceOpts !BackgroundTask
    :: ListenerInstanceOpts =
    { taskId :: !TaskId //Reference to the task that created the listener
    ......@@ -96,12 +95,6 @@ CLEAN_HOME_VAR :== "CLEAN_HOME"
    :: ConnectionId :== Int
    :: BackgroundInstanceOpts =
    { bgInstId :: !BackgroundTaskId
    }
    :: BackgroundTaskId :== Int
    :: IOStates :== Map TaskId IOState
    :: IOState
    = IOActive !(Map ConnectionId (!Dynamic,!Bool)) // Bool: stability
    ......
    Libraries/iTasks/Internal/IWorld.icl
    View file @ 0c7ad62e
    ......@@ -195,4 +195,4 @@ where
    = (x, {IWorld | iworld & world=world})
    appFiles appfun iworld=:{IWorld|world}
    # world = appFiles appfun world
    = {IWorld | iworld & world=world}
    \ No newline at end of file
    = {IWorld | iworld & world=world}
    Libraries/iTasks/Internal/Task.dcl
    View file @ 0c7ad62e
    ......@@ -36,9 +36,6 @@ derive gEq Task
    , onDisconnect :: !( l r *IWorld -> *(!MaybeErrorString l, Maybe w, !*IWorld))
    }
    //Background computation tasks
    :: BackgroundTask = BackgroundTask !(*IWorld -> *(!MaybeError TaskException (), !*IWorld))
    /**
    * Wraps a set of connection handlers and a shared source as a connection task
    */
    ......
    Libraries/iTasks/Internal/TaskServer.dcl
    View file @ 0c7ad62e
    definition module iTasks.Internal.TaskServer
    import iTasks.Internal.SDS
    from iTasks.Internal.IWorld import :: ConnectionId
    from iTasks.Internal.SDS import :: SDSSource
    from Data.Maybe import :: Maybe
    from StdFile import class FileSystem
    ......@@ -9,16 +10,17 @@ from Internet.HTTP import :: HTTPRequest, :: HTTPResponse
    from System.FilePath import :: FilePath
    from Data.Error import :: MaybeError
    from Data.Map import :: Map
    from iTasks.WF.Definition import :: TaskId
    from iTasks.Internal.IWorld import :: IWorld
    from iTasks.Internal.Task import :: ConnectionTask, :: TaskException
    from iTasks.Internal.IWorld import :: IWorld, :: IOStates, :: IOState
    from iTasks.Internal.IWorld import :: IWorld, :: BackgroundTaskId
    from iTasks.Internal.Task import :: ConnectionTask, :: BackgroundTask, :: TaskException
    from iTasks.Internal.IWorld import :: IWorld
    from iTasks.Internal.Task import :: ConnectionTask, :: TaskException
    from iTasks.Engine import :: StartupTask
    //Core task server loop
    serve :: ![StartupTask] ![(!Int,!ConnectionTask)] ![BackgroundTask] (*IWorld -> (!Maybe Timeout,!*IWorld)) *IWorld -> *IWorld
    serve :: ![StartupTask] ![(!Int,!ConnectionTask)] (*IWorld -> (!Maybe Timeout,!*IWorld)) *IWorld -> *IWorld
    //Dynamically add a listener
    addListener :: !TaskId !Int !Bool !(ConnectionTask) !*IWorld -> (!MaybeError TaskException (),!*IWorld)
    ......@@ -26,10 +28,7 @@ addListener :: !TaskId !Int !Bool !(ConnectionTask) !*IWorld -> (!MaybeError Tas
    //Dynamically add a connection
    addConnection :: !TaskId !String !Int !ConnectionTask !*IWorld -> (!MaybeError TaskException (ConnectionId, Dynamic),!*IWorld)
    //Dynamically add a background task
    addBackgroundTask :: !BackgroundTask !*IWorld -> (!MaybeError TaskException BackgroundTaskId,!*IWorld)
    //Dynamically remove a background task
    removeBackgroundTask :: !BackgroundTaskId !*IWorld -> (!MaybeError TaskException (),!*IWorld)
    ioStateString :: !IOStates -> String
    //Ticks every time the server loops once
    tick :: SDSSource () () ()
    Libraries/iTasks/Internal/TaskServer.icl
    View file @ 0c7ad62e
    This diff is collapsed.
    Markdown is supported
    0% or .
    You are about to add 0 people to the discussion. Proceed with caution.
    Finish editing this message first!
    Please register or to comment