On Smalltalk

A Seaside session is inherently single threaded, so I can't use Ajax calls to do long running processes without tying up the main session and hanging the app from the users point of view. In order to get around this, I had to change my approach. Rather than launch a process and wait for the result, I fork the process, return immediately, and poll for the result to show up in a dictionary that is shared via the lexical environment the process was forked from.

I'm using Scriptaculous and its periodical callback mechanism to poll for updates. When a value is found the poll gets both the answer and a bit of JavaScript to stop the polling. Should an error occur, the poller is also stopped.

I've added a couple small extension methods to WATagBrush, but they seem to be working pretty well for me so far.

with: initialBlock waitMax: aDuration forWork: aBlock thenRender: aRenderBlock
    self attributeAt: #default put: initialBlock value.
    self with: initialBlock.
    self waitMax: aDuration forWork: aBlock thenRender: aRenderBlock

with: initialBlock waitMax: aDuration forWork: aBlock thenRender: aRenderBlock onError: anErrorString
    self attributeAt: #default put: initialBlock value.
    self attributeAt: #error put: anErrorString.
    self with: initialBlock.
    self waitMax: aDuration forWork: aBlock thenRender: aRenderBlock

And now the periodical that does the bulk of the work...

waitMax: aDuration forWork: aBlock thenRender: aRenderBlock
    | result |
    result := self forkWaitFor: aDuration longRunningProcess: aBlock.
    self session addLoadScript: (canvas periodical
        id: (self attributes at: #id);
        assignTo: (self attributes at: #id) , 'Poller';
        asynchronous: true;
        evalScripts: true;
        frequency: 2;
        onFailure: (canvas periodical
            alias: (self attributes at: #id) , 'Poller';
            call: 'stop') , (canvas element
                id: (self attributes at: #id);
                addClassName: #ajaxError;
                update: (self attributeAt: #error ifAbsent: [ 'Error' ]));
        callback: 
            [ :r | 
            (result at: #result) ifNil: [ r render: (self attributeAt: #default) ]
                ifNotNil: 
                [ r script: (r periodical
                        alias: (self attributes at: #id) , 'Poller';
                        call: 'stop').
                aRenderBlock value: r value: (result at: #result) ] ])

And a helper method to separate the actual forking from the rendering. When the background process finishes, either by getting a value or by timing out, it dumps its result into the dictionary which the polling process will then find and display.

forkWaitFor: aDuration longRunningProcess: aBlock 
    | result |
    result := Dictionary with: #result -> nil.
    [[ result 
        at: #result
        put: (aBlock 
                valueWithin: aDuration
                onTimeout: [ 'timeout' ]) ] 
        on: Error
        do: 
            [ :error | 
            result 
                at: #result
                put: error messageText ] ] 
        forkAt: Processor systemBackgroundPriority
        named: 'polling'.
    ^ result

I use it like so...

html div 
    with: 'Searching...' 
    waitMax: 30 seconds 
    forWork: [ self getDataFromLongRunningProcess ] 
    thenRender: [:ajax :value | ajax update: value ]
    onError: 'Sorry!'

I might have to fix this up in the near future, to make #with: work with blocks like it should, but it's serving me well at the moment. I use this to fetch prices for hotels on Reserve Travel so I can show the hotel data immediately while in the background I'm running out to other systems to find prices which can sometimes take a while.