Engine.dcl 3.96 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
definition module iTasks.Engine
/**
* This module provides the iTasks engine.
* This is the primary function that creates the complete
* environment in which worfklow specifications can be executed.
*/

from Data.Maybe      import :: Maybe
from System.FilePath import :: FilePath
from Internet.HTTP   import :: HTTPRequest
11
from System.Time     import :: Timespec
12 13 14 15 16 17 18 19 20

import iTasks.WF.Definition

:: EngineOptions =
	{ appName 		:: String
	, appPath		:: FilePath // Location of the application's executable
	, appVersion    :: String
	, serverPort	:: Int
    , serverUrl     :: String
21 22
	, keepaliveTime :: Timespec
    , sessionTime   :: Timespec
23
    , persistTasks  :: Bool
Bas Lijnse's avatar
Bas Lijnse committed
24
	, autoLayout    :: Bool
25 26 27 28 29
	, timeout       :: Maybe Int // The timeout
	, 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)
30 31 32
	}

/**
33
* Executes the task framework with a collection of startable task definitions.
34 35 36 37 38
*
* @param Tasks to start
* @param The world
* @return The world
*/
39 40
doTasks :: a !*World -> *World | Startable a
startEngine :== doTasks //Backwards compatibility
41 42 43 44 45 46 47 48 49 50 51 52 53

/**
* Starts the task engine with options and a list of published task definitions.
*
* @param Tasks to start
* @param An initialization function to set the engine options with:
      @param The command line arguments
      @param The default options
	  @return Maybe the engine options, in case of Nothing, the engine is not started
      @return A message that is printed to the console when the engine is started
* @param The world
* @return The world
*/
54 55 56 57
doTasksWithOptions :: ([String] EngineOptions -> (!Maybe EngineOptions,![String])) a !*World
	-> *World | Startable a

startEngineWithOptions :== doTasksWithOptions
58 59 60 61 62

/**
* The function that takes the 'standard' command line options of an itask engine and
* shows the default help and startup message
*
63
* Essentially: doTasks = doTasksWithOptions defaultEngineCLIOptions 
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78

* @param The command line arguments
* @param The default options
* @return Maybe the engine options, in case of Nothing, the engine is not started
* @return A message that is printed to the console when the engine is started
*/
defaultEngineCLIOptions :: [String] EngineOptions -> (!Maybe EngineOptions,![String])

/**
* Start a stripped task engine (without an HTTP server) with a list of tasks to be created 
*/
runTasks :: a !*World -> *World | Runnable a

runTasksWithOptions :: ([String] EngineOptions -> (!Maybe EngineOptions,![String])) a !*World -> *World | Runnable a

79 80 81 82 83 84 85 86
/*
* There are two ways tasks can be started:
* Interactively when a user requests it through the web,
* or directly when the application (server) is started,
*/
:: StartableTask
  = WebTask !WebTask
  | StartupTask !StartupTask
87

88 89 90 91
:: WebTask =
	{ url  :: !String
	, task :: !WebTaskWrapper
	}
92

93 94 95
:: StartupTask =
	{ attributes :: !TaskAttributes 
	, task       :: !TaskWrapper
96 97 98 99 100
	}

:: WebTaskWrapper = E.a: WebTaskWrapper (HTTPRequest -> Task a) & iTask a
:: TaskWrapper = E.a: TaskWrapper (Task a) & iTask a

101 102 103 104 105
//Utility functions for creating collections of startable tasks
atRequest :: String (HTTPRequest -> Task a) -> StartableTask | iTask a
atStartup :: TaskAttributes (Task a) -> StartableTask | iTask a

publish :== atRequest //Backwards compatibility
106

107
class Startable a
108
where
109
	toStartable :: !a -> [StartableTask]
110

111 112 113 114
instance Startable (Task a) | iTask a //Default as web task
instance Startable (HTTPRequest -> Task a) | iTask a //As web task
instance Startable StartableTask
instance Startable [StartableTask]
115 116 117 118

// === Wrapping non-interactive tasks for running on the command line ===
class Runnable a
where
119
	toRunnable :: !a -> [StartableTask]
120 121

instance Runnable (Task a) | iTask a
122 123 124 125 126

/**
* Determines the default options for an application
*/
defaultEngineOptions :: !*World -> (!EngineOptions,!*World)