Separate the stack into two

[guilhermesilveira]

Currently there is one stack for parsing request and response. This stack moves forward and then returns, allowing interceptors to parse both request and response. It should be broken into two stacks: a request stack and a response stack. This gives space for async invocations (see the following suggestions).

[pmatiello]

If the goal is non-synchronous invocations, I think it would be a lot easier to keep the current design and just launch a new thread responsible for waiting for the reply and calling the callback function.

Also, a split request/response stack would require some sort of threading too anyway (otherwise we would not be able to call the callback function).

[guilhermesilveira]

Hi Pedro,

You will need threading (real or fake) anyways. But it seems like you cant implement non-synchornous with just one stack. Imagine you have feature A, B and C, to be run on the same order, where B is the async feature... because A doesnt know what async is, it will receive B's result (not a real result) and think its a valid result, thinking the request and response were already processed by everyone else, when in fact it wasnt.

The only way to be sure this would never happen is that the async feature is the last one on the stack. The other way is breaking it into two stacks.
The problem with keeping it as the last one in the stack is... well, whenever you need another one as being the last one in the stack, what would happen?

It all depends on how async will be implemented (as a feature? not as a feature in the stack?) and if other features in the stack will access the result.

[pmatiello]

I managed to do an async call this way. Not sure if that's what you want:

def callback(response):
    print response.body

Restfulie.at("http://caelum.com.br/").calling_back(callback).get()

When get() is called, instead of running process_flow (from Dsl class) as usual, it runs a modified version of it in a new thread. The only difference is that, instead of blocking until there is a response and then returning it, the method returns None immediately (at the main thread) and the provided callback function is called when a response is made available (at the new thread).

No calls are allowed after get() as it returns None. This would raise an error:

Restfulie.at("http://caelum.com.br/").calling_back(callback).get().body

The treatment of the response should then be performed at the callback function, and not chained after the get().

[pmatiello]

Pushed this to a new branch:
https://github.com/caelum/restfulie-py/tree/async_proposal

Check the Dsl class for changes:
https://github.com/caelum/restfulie-py/blob/async_proposal/restfulie/dsl.py

[pmatiello]

Accepted by Gui.