Custom Actions in GLSP

[glsp-bot]

We have a general bunch of questions to the communication between GLSP-Client and Server:

1. How do I access the response from the server after a request (E.g.: com.eclipsesource.glsp.server.actionhandler.RequestModelActionHandler returns after execution a RequestBoundsAction)?

2. How do I access the actionDispatcher without the being a GLSPDiagramWidget?

3. How do I wait for a response of the server in the client? Is it sufficient with responseaction = await dispatcher.dispatch(action)

original thread by Jonas Ebel

[planger]

As an example for all three questions, you can look at:
https://github.com/eclipsesource/graphical-lsp/blob/master/client/packages/sprotty-client/src/features/context-menu/server-context-menu-provider.ts

It gets the action dispatcher injected, dispatches an action (that is forwarded to the server -- see websocket-diagram-server.ts), waits for the response, and processes it:

```this.actionDispatcher.requestUntil(requestAction).then(response => this.getContextActionsFromResponse(response));```

[planger]

Note that in order to be able to get something injected, your class needs to be bound in the dependency injection container: https://github.com/eclipsesource/graphical-lsp/blob/master/client/packages/sprotty-client/src/features/context-menu/di.config.ts

[planger]

On the server, you have to register an action handler that is responsible for processing the incoming actions and, in your use case, would send an action back. See for instance:
https://github.com/eclipsesource/graphical-lsp/blob/master/server/glsp-server/src/main/java/com/eclipsesource/glsp/server/actionhandler/RequestContextActionsHandler.java

[glsp-bot]

[Jonas Ebel]

Hey Philipp this helped me a lot - I have one follow up question:
When I dispatch an Action (instead of requesting) it - I understand, that this is handed to the client's actionHandlers which do their thing with it - correct? How can I consume this results? I've seen that the Promise that dispatch returns is of Type Void.

[planger]

Hi Jonas,
yes, as soon as you dispatch an action the dispatcher chooses the handlers that are registered for this action and invoke them with the action.
The processing of the action never has a result per se... however, handlers may dispatch new actions as a result, which again can be consumed by other handlers and so on. So reactive style all way through.
If you need to wait for a result to do something, you actually have to wait for an action. Therefore, there is a request/response super class for actions (so that they can be matched that one is the response to another) and the requestUntil(...) method as written above.

[glsp-bot]

[Jonas Ebel]

I was further analysing the action flow for message, which where dispatched. I saw that the issue, that the action, returned from the server was not fired again at the server, is that the method handleLocally in sprotty/model does exclude Actions to be fired again at the server, when they originate from the server.
I would say my approach is also a little bit inconvenient
So I'd like to change the approach into a whole server side layouting. Probably there is also in the glsp-server a utility to 'locally' dispatch messages - similar to the client's reactive style. Can you point me in a direction where I can find something about this.

[glsp-bot]

[Jonas Ebel]

The issue I am trying to solve is in ecore-glsp eclipsesource/ecore-glsp#47

[tortmayr]

On server side we use an ActionProcessor which can either send an Action to the client or dispatch it to its local ActionHandlers: https://github.com/eclipsesource/graphical-lsp/blob/7460234172904e023e3ad8ddc4fb04be69b303ed/server/glsp-server/src/main/java/com/eclipsesource/glsp/server/actionhandler/DIActionProcessor.java

[tortmayr]

You can simply inject the ActionProcessor into your class and invoke the dispatch method. (See https://github.com/eclipsesource/graphical-lsp/blob/9cf23e3429e7acbd9efb605f28257f1ccf86472f/server/glsp-server/src/main/java/com/eclipsesource/glsp/server/jsonrpc/DefaultGLSPServer.java for an injection example)

[glsp-bot]

[Jonas Ebel]

Thanks again - so I understand there is no action queueing for 'locally' fired actions on the glsp server? Only direct synchronous calls are possible here?

[tortmayr]

Yes you are correct. This is a know limitation of the current ´ActionProcessor' implementation. However you can work around this in your ActionHandler implementation by dispatching your response action over the 'ActionProcessor' again.
In a nutshell:
Synchrous direct response-> Return your response action in the execute method of your `ActionHandler implementation
Asynchronous response -> Dispatch/send your response action over the 'ActionProcessor' and return an empty Optional.