Transparent support for interruptable computations. A workflow can be seen as a persistent thread. The main features are:

• Transparent state logging trough a monad transformer: step :: m a -> Workflow m a.
• Resume the computation state after an accidental o planned program shutdown (restartWorkflows).
• Event handling (waithFor, waitForData).
• Monitoring of workflows with state change display and other auxiliary features.
• Communications with other processes including other workflows trough persistent data objects, inspecttion of intermediate workflow results , Queues so that no data is lost due to shutdowns

In this way, a very long computation that may take more time than the average time between hardware or software failures, shutdowns etc. The workflow can be defined transparently in a single monadic procedure. Besides state logging and recovery, there are a number of communication primitives that are aware of persistence across reinitiations such are persistent queues, persistent timeouts, or wait for events in the STM monad. These primitives permits inter-woikflow communications and communications with external threads.

This package uses TCache for persistence and event handling.

It also uses the package Refserialize. This package permits to reduce the workflow state load, since the RefSerialize package permits to serialize and deserialize complex and autoreferenced data structures without loosing such references, this is critical when big and structured data, such are documents, suffer little modifications across a set of workflow steps. Therefore, it is also recommended to use Refserialize for big user-defined objects that have small pieces that suffer little modifications during the workflow. As an added bonus, the history will show such changes with more detail.

The step primitive is the lift operation that converts a result of type m a to a type Workflow m a with automatic state loggin and recovery. To allow such features, Every a must be instance of Typeable and IResource (defined in the TCache package).

In fact, Workflow can be considered as an instance of a partial monad transformed. defined as such:

class PMonadTrans  t m a  where

plift :: Monad m => m a -> t m a

instance  (Monad m,MonadIO m, IResource  a, Typeable a)

=> PMonadTrans (WF Stat)  m a where

plift = step

It is partial because the lift operation is not defined for every monad m and data type a , but for monads and data types that meet certain conditions. In this case, to be instances of MonadIO, IResource and Typeable respectively.

to avoid to define the last two interfaces however, Read and Show' can be used to derive instances of IResource for most of the useful cases. This is the set of automatic derivations:

(Read a, Show a) =>  Serialize a

Typeable a => Indexable a    (a single key for all values. enough for workflows)

(Indexable a, Serialize a) => IResource a

Therefore deriving to be instance of Read, Show is enough for every intermediate data result along the computation

Because Data.TCache.Dynamic from the package TCache is used for persistence, every data type must be registered by using registerType

Here is a compkete example: This is a counter that shows a sequence of numbers, one a second:

module Main where
import Control.Concurrent(threadDelay)
import System.IO (hFlush,stdout)

count n= do
                    putStr (show n ++  ) >> hFlush stdout >> threadDelay 1000000
                    count (n+1)

main= count 0

This is the same program, with the added feature of remembering the last count after interrupted:

module Main where
import Control.Workflow
import Control.Concurrent(threadDelay)
import System.IO (hFlush,stdout)

mcount n= do
            step $  putStr (show n ++  ) >> hFlush stdout >> threadDelay 1000000
            mcount (n+1)

main= do
   registerType :: IO ()
   registerType :: IO Int
   let start= 0 :: Int
   startWF  count  start   [(count, mcount)] :: IO ()

This is the execution log:

Worflow-0.5.5demos>runghc sequence.hs
0 1 2 3 4 5 6 7 sequence.hs: win32ConsoleHandler
sequence.hs: sequence.hs: interrupted
Worflow-0.5.5demos>
Worflow-0.5.5demos>runghc sequence.hs
7 8 9 10 11 ....

executes a IO computation inside of the workflow monad whatever the monad encapsulated in the workflow. Warning: this computation is executed whenever the workflow restarts, no matter if it has been already executed previously. This is useful for intializations or debugging. To avoid re-execution when restarting use: step $ unsafeIOtoWF...

To perform IO actions in a workflow that encapsulates an IO monad, use step over the IO action directly:

 step $ action

instead of

  step $ unsafeIOtoWF $ action

wait until a certain clock time, in the STM monad. This permits to compose timeouts with locks waiting for data.

• example: wait for any respoinse from a Queue if no response is given in 5 minutes, it is returned True.

            flag <- getTimeoutFlag $  5 * 60
            ap - step  .  atomically $  readQueueSTM docQueue  `orElse`  waitUntilSTM flag  > return True
            case ap of
                    False -> logWF False or timeout >> correctWF doc
                    True -> do