Sending requests from GLSP server to GLSP client

[david-pa]

I'm working with a VSCode GLSP implementation right now, and I want to use a request/response pair to send information from the GLSP server to the GLSP client during saveSourceModel(), which I assume is possible (correct me if I'm wrong or if there's a better approach). However, I'm having trouble determining how I am supposed to dispatch an action from the GLSP server, based on the available docs, as only client-side dispatch is mentioned.

Here is my current client-side setup:

client-handler.ts (client)

import { CustomDataObject } from '../../../custom';
import { injectable } from 'inversify';
import { IActionHandler, Action, RequestAction, ResponseAction, hasStringProp } from '@eclipse-glsp/client';

export interface CustomEditRequestAction extends RequestAction<CustomEditResponseAction> {
  kind: typeof CustomEditRequestAction.KIND;
  customEdited: CustomDataObject;
}

export namespace CustomEditRequestAction {
  export const KIND = 'customEdit';
  export function is(object: any): object is CustomEditRequestAction {
    return RequestAction.hasKind(object, KIND) && hasStringProp(object, 'customEdited');
  }
  export function create(options: { customEdited: CustomDataObject; requestId?: string }): CustomEditRequestAction {
    return {
      kind: KIND,
      requestId: '',
      ...options
    };
  }
}

export interface CustomEditResponseAction extends ResponseAction {
  kind: typeof CustomEditResponseAction.KIND;
}

export namespace CustomEditResponseAction {
  export const KIND = 'customEditResponse';

  export function is(object: any): object is CustomEditResponseAction {
    return Action.hasKind(object, KIND);
  }

  export function create(options: { responseId?: string } = {}): CustomEditResponseAction {
    return {
      kind: KIND,
      responseId: '',
      ...options
    };
  }
}

@injectable()
export class CustomEditHandler implements IActionHandler {
  handle(action: CustomEditRequestAction): Action | void {
    // implement your custom logic to handle the action

    // Finally issue response actions
    // If no response actions should be issued '[]' can be used;
    const response = CustomEditResponseAction.create();
    return response;
  }
}

diagram-module.ts (client)

...
import { CustomEditHandler, CustomEditRequestAction } from './actions/client-handler';
...
const graphEditorModule = new ContainerModule((bind, unbind, isBound, rebind) => {
  rebind(TYPES.ILogger).to(ConsoleLogger).inSingletonScope();
  rebind(TYPES.LogLevel).toConstantValue(LogLevel.warn);
  const context = { bind, unbind, isBound, rebind };
  ...
  configureActionHandler(context, CustomEditRequestAction.KIND, CustomEditHandler);
  ...
};
...

Here is my current server-side setup:

server-handler.ts (server)

import { Action, hasStringProp, RequestAction, ResponseAction } from '@eclipse-glsp/server/node';
import { CustomDataObject } from '../../../custom';
import { ActionHandler, MaybePromise } from '@eclipse-glsp/server';
import { injectable } from 'inversify';

export interface CustomEditRequestAction extends RequestAction<CustomEditResponseAction> {
  kind: typeof CustomEditRequestAction.KIND;
  customEdited: CustomDataObject;
}

export namespace CustomEditRequestAction {
  export const KIND = 'customEdit';
  export function is(object: any): object is CustomEditRequestAction {
    return RequestAction.hasKind(object, KIND) && hasStringProp(object, 'customEdited');
  }
  export function create(options: { customEdited: CustomDataObject; requestId?: string }): CustomEditRequestAction {
    return {
      kind: KIND,
      requestId: '',
      ...options
    };
  }
}

export interface CustomEditResponseAction extends ResponseAction {
  kind: typeof CustomEditResponseAction.KIND;
}

export namespace CustomEditResponseAction {
  export const KIND = 'customEditResponse';

  export function is(object: any): object is CustomEditResponseAction {
    return Action.hasKind(object, KIND);
  }

  export function create(options: { responseId?: string } = {}): CustomEditResponseAction {
    return {
      kind: KIND,
      responseId: '',
      ...options
    };
  }
}

@injectable()
export class CustomEditHandler implements ActionHandler {
  actionKinds = [CustomEditResponseAction.KIND];
  execute(action: CustomEditResponseAction): MaybePromise<Action[]> {
    return [];
  }
}

diagram-module.ts (server)

...
import { CustomEditHandler } from '../handler/server-handler;
...
export class CustomDiagramModule extends GModelDiagramModule {
  protected override configureActionHandlers(binding: InstanceMultiBinding<ActionHandlerConstructor>): void {
    super.configureActionHandlers(binding);
    binding.add(ConfigEditHandler);
  }
  ...
}

storage.ts

import { AbstractJsonModelStorage, Logger, RequestModelAction, SaveModelAction, DefaultActionDispatcher } from '@eclipse-glsp/server/node';
...
import { CustomEditRequestAction } from '../handler/server-handler';
...
@injectable()
export class CustomStorage extends AbstractJsonModelStorage {
  @inject(Logger)
  protected logger: Logger;
  protected actionDispatcher: DefaultActionDispatcher;
  ...
  async saveSourceModel(action: SaveModelAction): Promise<void> {
    ...
    this.actionDispatcher = new DefaultActionDispatcher();
    const response = await this.actionDispatcher.dispatch(CustomEditRequestAction.create({ customEdited: data }));
    // response is of type CustomEditResponseAction
    this.logger.debug(JSON.stringify(response));
    ...
  }
  ...
}

I'm wondering what about my setup is incorrect, or if there is a different way I'm supposed to be doing this. I'm not sure if I'm dispatching the request from the GLSP server properly, as this currently causes an error where shouldForwardToClient is not defined.

Uncaught TypeError TypeError: Cannot read properties of undefined (reading 'shouldForwardToClient')
    at dispatch (/Users/.../.../.../node_modules/@eclipse-glsp/server/src/common/actions/action-dispatcher.ts:89:40)
    at <anonymous> (/Users/.../.../.../src/server/.../model/storage.ts:374:52)

@tortmayr, I believe I saw you answer a question related to Actions, so perhaps you could shed some light here?

[GazeboXu]

IMO, it's fine to send request Action to cleint and get Response, actually, the RequestBoundsAction/ComputedBoundsAction do the same thing.
for your exception here, if I am not wrong, it looks very simple.
in you class CustomStorage, you should inject actionDispatcher here. somthing like below:
@Inject(ActionDispatcher)
protected actionDispatcher: ActionDispatcher;

[david-pa]

@tortmayr I see you approved of this, thanks! @GazeboXu thanks also for the input.

The issue I'm seeing is that it seems that there isn't an .request() method attached to ActionDispatcher, only .dispatch. Is there no way to issue a "blocking request" from the server?

I'm noticing that despite using await when calling

const response = await this.actionDispatcher.dispatch(CustomEditRequestAction.create({ customEdited: data }));
// response is of type CustomEditResponseAction
this.logger.debug(JSON.stringify(response));

The response from the client doesn't come in until a bit after this has executed and is never picked up by my call to logger.debug. I guess I was assuming I'd get the response back as a result, but right now I just get undefined.

I'd prefer to be able to wait for the response before moving on, if I can. Is using a handler the only way to capture the client's response in this scenario?

[tortmayr]

Ah sorry, I missed the fact that you want to reverse the request-response logic and sent a request action from the server.
Unfortunately this is currently not directly supported. See also #607.
The feature was not implemented up until now because we didn't have a direct use case for it and the implementation
can be quite challenging i.e:

• We need a way to distinguish between response that are intended for the server, and those that are intended for the client.
• If both side are able to send blocking requests we need to make sure that there aren't any scenarios where we might run into a deadlock because both side send a blocking request.

Could you please elaborate on you use case, so that we can assist you in finding the best approach? What exactly do you want to achieve?

[david-pa]

@tortmayr, basically I am working with GLSP as part of a larger VSCode extension. What I am attempting to do is use the GLSP server to notify the GLSP client of some required file changes during saveSourceModel()'s execution. At that point, I need the GLSP client to call a function related to the larger VSCode extension so that those file changes can be processed.

Likewise, I also need to signal the GLSP client from the VSCode extension to indicate that some external files have changed and the GLSP server should initiate loadSourceModel().

So, I definitely need a way to have two-way communication between the GLSP server and client, as there are files I do not want either the client or server to be editing directly and are the greater extension's responsibility.

Sending in the request from the server to the client like I do above did seem to be received by the client, though. I just don't get a response back from the dispatch call like I assumed I would. It seems to me like a response handler in the GLSP client would work, if I needed one.

I don't think that "blocking" requests are necessary, I suppose any kind of request/response execution is okay, but I was wondering why a "blocking" request wasn't possible. It also wasn't clear if the server could send requests to the client via the docs.

[tortmayr]

Yeah, I agree we should update the documentation to clarify this.

So, I definitely need a way to have two-way communication between the GLSP server and client
Okay, normal two-way communication is not a problem. You can freely dispatch actions from the client/server side and handle them on the remote side.
The only thing that is currently not supported is dispatching a RequestAction from the server side and waiting/blocking until the response is received. (ActionDispatcher.request, ActionDispatcher.requestUntil)