@eclipse-glsp/server 1.1.0-next.9fd0925.53 → 1.1.0-next.abdebbd.65

package/src/common/actions/global-action-provider.ts

@@ -13,60 +13,56 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { distinctAdd } from '@eclipse-glsp/protocol';
 import { Container, ContainerModule, inject, injectable } from 'inversify';
-import { ClientActionKinds, DiagramModules, InjectionContainer } from '../di/service-identifiers';
+import { createClientSessionModule } from '../di/client-session-module';
+import { DiagramModules, InjectionContainer } from '../di/service-identifiers';
 import { ClientSessionInitializer } from '../session/client-session-initializer';
 import { ActionHandlerRegistry } from './action-handler-registry';
-import { ClientActionHandler } from './client-action-handler';
 
 export const GlobalActionProvider = Symbol('GlobalActionProvider');
 
+/**
+ * Provides a map of handled action kinds grouped by `diagramType`
+ */
 export interface GlobalActionProvider {
-    readonly serverActionKinds: Map<string, string[]>;
-    readonly clientActionKinds: Map<string, string[]>;
+    readonly actionKinds: Map<string, string[]>;
 }
 
 @injectable()
 export class DefaultGlobalActionProvider implements GlobalActionProvider {
-    public readonly serverActionKinds: Map<string, string[]>;
-    public readonly clientActionKinds: Map<string, string[]>;
+    public readonly actionKinds: Map<string, string[]>;
 
     constructor(
         @inject(InjectionContainer) serverContainer: Container,
         @inject(DiagramModules) diagramModules: Map<string, ContainerModule[]>
     ) {
-        this.serverActionKinds = new Map();
-        this.clientActionKinds = new Map();
+        this.actionKinds = new Map();
         diagramModules.forEach((modules, diagramType) => {
             const container = this.createDiagramContainer(serverContainer, modules);
             const initializers = container.getAll<ClientSessionInitializer>(ClientSessionInitializer);
             initializers.forEach(service => service.initialize());
-            this.loadServerActionKinds(diagramType, container);
-            this.loadClientActionKinds(diagramType, container);
+            this.loadActionKinds(diagramType, container);
             container.unbindAll();
         });
     }
 
     createDiagramContainer(serverContainer: Container, modules: ContainerModule[]): Container {
         const container = serverContainer.createChild();
-        container.load(...modules);
+        const clientSessionModule = createClientSessionModule({
+            clientId: 'tempId',
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            glspClient: { process: () => {} },
+            clientActionKinds: []
+        });
+        container.load(...modules, clientSessionModule);
         return container;
     }
 
-    loadServerActionKinds(diagramType: string, diagramContainer: Container): void {
+    loadActionKinds(diagramType: string, diagramContainer: Container): void {
         const handlerRegistry = diagramContainer.get<ActionHandlerRegistry>(ActionHandlerRegistry);
-        const diagramServerActions = this.serverActionKinds.get(diagramType) ?? [];
-        handlerRegistry
-            .getAll()
-            .filter(handler => !(handler instanceof ClientActionHandler))
-            .forEach(handler => diagramServerActions.push(...handler.actionKinds));
-        this.serverActionKinds.set(diagramType, [...new Set(diagramServerActions)]);
-    }
-
-    loadClientActionKinds(diagramType: string, diagramContainer: Container): void {
-        const clientActionKinds = diagramContainer.getAll<string>(ClientActionKinds);
-        const diagramClientActions = this.clientActionKinds.get(diagramType) ?? [];
-        diagramClientActions.push(...clientActionKinds);
-        this.clientActionKinds.set(diagramType, diagramClientActions);
+        const diagramServerActions = this.actionKinds.get(diagramType) ?? [];
+        handlerRegistry.getAll().forEach(handler => distinctAdd(diagramServerActions, ...handler.actionKinds));
+        this.actionKinds.set(diagramType, diagramServerActions);
     }
 }

package/src/common/command/recording-command.ts

@@ -111,8 +111,8 @@ export class GModelRecordingCommand extends AbstractRecordingCommand<GModelRootS
         return this.serializer.createSchema(this.modelState.root);
     }
 
-    protected override applyPatch(rootSchema: GModelRootSchema, patch: jsonPatch.Operation[]): MaybePromise<void> {
-        super.applyPatch(rootSchema, patch);
+    protected override async applyPatch(rootSchema: GModelRootSchema, patch: jsonPatch.Operation[]): Promise<void> {
+        await super.applyPatch(rootSchema, patch);
         const newRoot = this.serializer.createRoot(rootSchema);
         this.modelState.updateRoot(newRoot);
     }

package/src/common/di/binding-target.ts

@@ -152,6 +152,7 @@ namespace NoOPSyntax {
         };
         const syntax = {
             onActivation: noOpReturn,
+            onDeactivation: noOpReturn,
             when: noOpReturn,
             whenAnyAncestorIs: noOpReturn,
             whenAnyAncestorMatches: noOpReturn,

package/src/common/di/client-session-module.ts

@@ -13,17 +13,24 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GLSPClientProxy } from '@eclipse-glsp/protocol';
+import { GLSPClientProxy, bindOrRebind } from '@eclipse-glsp/protocol';
 import { ContainerModule } from 'inversify';
-import { ClientId } from './service-identifiers';
+import { ClientActionKinds, ClientId } from './service-identifiers';
 
-export function createClientSessionModule(clientId: string, glspClient: GLSPClientProxy): ContainerModule {
-    return new ContainerModule((bind, _unbind, isBound, rebind) => {
-        if (isBound(ClientId)) {
-            rebind(ClientId).toConstantValue(clientId);
-        } else {
-            bind(ClientId).toConstantValue(clientId);
-        }
-        bind(GLSPClientProxy).toConstantValue(glspClient);
+export interface ClientSessionModuleOptions {
+    clientId: string;
+    glspClient: GLSPClientProxy;
+    clientActionKinds: string[];
+}
+
+/**
+ * Creates the DI module that binds client session specific configuration
+ */
+export function createClientSessionModule(options: ClientSessionModuleOptions): ContainerModule {
+    return new ContainerModule((bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+        bindOrRebind(context, ClientId).toConstantValue(options.clientId);
+        bind(GLSPClientProxy).toConstantValue(options.glspClient);
+        bind(ClientActionKinds).toConstantValue(new Set(options.clientActionKinds));
     });
 }

package/src/common/di/diagram-module.ts

@@ -13,41 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import {
-    CenterAction,
-    DeleteMarkersAction,
-    ExportSvgAction,
-    FitToScreenAction,
-    NavigateToExternalTargetAction,
-    NavigateToTargetAction,
-    RequestBoundsAction,
-    SelectAction,
-    SelectAllAction,
-    ServerMessageAction,
-    ServerStatusAction,
-    SetBoundsAction,
-    SetClipboardDataAction,
-    SetContextActions,
-    SetDirtyStateAction,
-    SetEditModeAction,
-    SetEditValidationResultAction,
-    SetMarkersAction,
-    SetModelAction,
-    SetNavigationTargetsAction,
-    SetPopupModelAction,
-    SetResolvedNavigationTargetAction,
-    SetTypeHintsAction,
-    SetViewportAction,
-    SourceModelChangedAction,
-    TriggerEdgeCreationAction,
-    TriggerNodeCreationAction,
-    UpdateModelAction
-} from '@eclipse-glsp/protocol';
 import { interfaces } from 'inversify';
 import { ActionDispatcher, DefaultActionDispatcher } from '../actions/action-dispatcher';
 import { ActionHandlerConstructor, ActionHandlerFactory } from '../actions/action-handler';
 import { ActionHandlerRegistry, ActionHandlerRegistryInitializer } from '../actions/action-handler-registry';
-import { ClientActionHandler } from '../actions/client-action-handler';
+import { ClientActionForwarder } from '../actions/client-action-handler';
 import { CommandStack, DefaultCommandStack } from '../command/command-stack';
 import { UndoRedoActionHandler } from '../command/undo-redo-action-handler';
 import { DiagramConfiguration } from '../diagram/diagram-configuration';
@@ -86,6 +56,7 @@ import { RequestNavigationTargetsActionHandler } from '../features/navigation/re
 import { ResolveNavigationTargetsActionHandler } from '../features/navigation/resolve-navigation-targets-action-handler';
 import { PopupModelFactory } from '../features/popup/popup-model-factory';
 import { RequestPopupModelActionHandler } from '../features/popup/request-popup-model-action-handler';
+import { DefaultProgressService, ProgressService } from '../features/progress/progress-service';
 import { ModelValidator } from '../features/validation/model-validator';
 import { RequestMarkersHandler } from '../features/validation/request-markers-handler';
 import { CompoundOperationHandler } from '../operations/compound-operation-handler';
@@ -93,11 +64,10 @@ import { OperationActionHandler } from '../operations/operation-action-handler';
 import { OperationHandlerConstructor, OperationHandlerFactory } from '../operations/operation-handler';
 import { OperationHandlerRegistry, OperationHandlerRegistryInitializer } from '../operations/operation-handler-registry';
 import { ClientSessionInitializer } from '../session/client-session-initializer';
-import { applyBindingTarget, applyOptionalBindingTarget, BindingTarget } from './binding-target';
+import { BindingTarget, applyBindingTarget, applyOptionalBindingTarget } from './binding-target';
 import { GLSPModule } from './glsp-module';
 import { InstanceMultiBinding, MultiBinding } from './multi-binding';
 import {
-    ClientActionKinds,
     ClientId,
     ContextActionsProviders,
     ContextEditValidators,
@@ -133,6 +103,7 @@ import {
  * - {@link ContextActionsProviders} as {@link ClassMultiBinding<ContextActionsProvider>} (empty)
  * - {@link ContextActionsProviderRegistry}
  * - {@link ActionDispatcher}
+ * - {@link ProgressService}
  * - {@link ClientActionKinds} as {@link InstanceMultiBinding<string>}
  * - {@link ActionHandler} as {@link InstanceMultiBinding<ActionHandlerConstructor>}
  * - {@link ActionHandlerFactory}
@@ -162,6 +133,7 @@ export abstract class DiagramModule extends GLSPModule {
         applyBindingTarget(context, DiagramType, this.bindDiagramType());
         applyBindingTarget(context, ClientId, this.bindClientId());
         applyBindingTarget(context, DiagramConfiguration, this.bindDiagramConfiguration()).inSingletonScope();
+        applyBindingTarget(context, ClientActionForwarder, this.bindClientActionForwarder()).inSingletonScope();
 
         // Model-related bindings
         applyBindingTarget(context, GModelSerializer, this.bindGModelSerializer()).inSingletonScope();
@@ -186,7 +158,6 @@ export abstract class DiagramModule extends GLSPModule {
 
         // Action & operation related bindings
         applyBindingTarget(context, ActionDispatcher, this.bindActionDispatcher()).inSingletonScope();
-        this.configureMultiBinding(new InstanceMultiBinding<string>(ClientActionKinds), binding => this.configureClientActions(binding));
         this.configureMultiBinding(new InstanceMultiBinding<ActionHandlerConstructor>(ActionHandlerConstructor), binding =>
             this.configureActionHandlers(binding)
         );
@@ -217,6 +188,7 @@ export abstract class DiagramModule extends GLSPModule {
         this.configureMultiBinding(new MultiBinding<ClientSessionInitializer>(ClientSessionInitializer), binding =>
             this.configureClientSessionInitializers(binding)
         );
+        applyBindingTarget(context, ProgressService, this.bindProgressService()).inSingletonScope();
         applyOptionalBindingTarget(context, PopupModelFactory, this.bindPopupModelFactory());
         applyOptionalBindingTarget(context, LayoutEngine, this.bindLayoutEngine?.());
     }
@@ -227,7 +199,6 @@ export abstract class DiagramModule extends GLSPModule {
     }
 
     protected configureActionHandlers(binding: InstanceMultiBinding<ActionHandlerConstructor>): void {
-        binding.add(ClientActionHandler);
         binding.add(RequestModelActionHandler);
         binding.add(RequestContextActionsHandler);
         binding.add(RequestTypeHintsActionHandler);
@@ -254,6 +225,10 @@ export abstract class DiagramModule extends GLSPModule {
         return DefaultGModelSerializer;
     }
 
+    protected bindClientActionForwarder(): BindingTarget<ClientActionForwarder> {
+        return ClientActionForwarder;
+    }
+
     protected bindGModelIndex(): BindingTarget<GModelIndex> {
         return GModelIndex;
     }
@@ -308,6 +283,10 @@ export abstract class DiagramModule extends GLSPModule {
         binding.add(LayoutOperationHandler);
     }
 
+    protected bindProgressService(): BindingTarget<ProgressService> {
+        return DefaultProgressService;
+    }
+
     protected configureContextActionProviders(binding: MultiBinding<ContextActionsProvider>): void {
         // empty as default
     }
@@ -320,37 +299,6 @@ export abstract class DiagramModule extends GLSPModule {
         // empty as default
     }
 
-    protected configureClientActions(binding: InstanceMultiBinding<string>): void {
-        binding.add(CenterAction.KIND);
-        binding.add(ExportSvgAction.KIND);
-        binding.add(DeleteMarkersAction.KIND);
-        binding.add(FitToScreenAction.KIND);
-        binding.add(SourceModelChangedAction.KIND);
-        binding.add(NavigateToTargetAction.KIND);
-        binding.add(NavigateToExternalTargetAction.KIND);
-        binding.add(RequestBoundsAction.KIND);
-        binding.add(SelectAction.KIND);
-        binding.add(SelectAllAction.KIND);
-        binding.add(ServerMessageAction.KIND);
-        binding.add(SetBoundsAction.KIND);
-        binding.add(SetClipboardDataAction.KIND);
-        binding.add(SetContextActions.KIND);
-        binding.add(SetDirtyStateAction.KIND);
-        binding.add(SetEditModeAction.KIND);
-        binding.add(SetEditValidationResultAction.KIND);
-        binding.add(SetMarkersAction.KIND);
-        binding.add(SetModelAction.KIND);
-        binding.add(SetNavigationTargetsAction.KIND);
-        binding.add(SetPopupModelAction.KIND);
-        binding.add(SetResolvedNavigationTargetAction.KIND);
-        binding.add(SetTypeHintsAction.KIND);
-        binding.add(SetViewportAction.KIND);
-        binding.add(ServerStatusAction.KIND);
-        binding.add(TriggerNodeCreationAction.KIND);
-        binding.add(TriggerEdgeCreationAction.KIND);
-        binding.add(UpdateModelAction.KIND);
-    }
-
     protected bindContextActionsProviderRegistry(): BindingTarget<ContextActionsProviderRegistry> {
         return ContextActionsProviderRegistry;
     }

package/src/common/di/server-module.ts

@@ -41,7 +41,6 @@ import { DiagramModules, InjectionContainer } from './service-identifiers';
  * * {@link ClientSessionFactory}
  * * {@link ClientSessionManager}
  * * {@link GlobalActionProvider}
- * * {@link GLSPClientProxy}
  *
  */
 export class ServerModule extends GLSPModule {

package/src/common/features/model/model-submission-handler.ts

@@ -17,20 +17,34 @@ import { GModelRootSchema } from '@eclipse-glsp/graph';
 import {
     Action,
     DirtyStateChangeReason,
+    MarkersReason,
     MaybePromise,
     RequestBoundsAction,
+    RequestModelAction,
     SetDirtyStateAction,
+    SetMarkersAction,
     SetModelAction,
     UpdateModelAction
 } from '@eclipse-glsp/protocol';
+
 import { inject, injectable, optional } from 'inversify';
 import { CommandStack } from '../../command/command-stack';
 import { DiagramConfiguration, ServerLayoutKind } from '../../diagram/diagram-configuration';
 import { LayoutEngine } from '../layout/layout-engine';
+import { ModelValidator } from '../validation/model-validator';
 import { GModelFactory } from './gmodel-factory';
 import { GModelSerializer } from './gmodel-serializer';
 import { ModelState } from './model-state';
 
+/**
+ * Helper class that provides utility methods to handle model updates i.e.
+ * submit a new model to the client. In addition, to the core model update action this class
+ * also takes care of related behavior like dirty state handling, validation and client/server side layouting.
+ * Note that the submissions handler is only responsible for deriving the set of actions that comprise a model update
+ * but does not actually dispatch them. The returned actions should be either manually dispatched
+ * to the `ActionDispatcher`, or simply returned as the result of an
+ * `ActionHandler.execute` method.
+ */
 @injectable()
 export class ModelSubmissionHandler {
     @inject(DiagramConfiguration)
@@ -52,8 +66,38 @@ export class ModelSubmissionHandler {
     @inject(CommandStack)
     protected commandStack: CommandStack;
 
+    @inject(ModelValidator)
+    @optional()
+    protected validator?: ModelValidator;
+
+    protected requestModelAction?: RequestModelAction;
+
     /**
-     * Returns a list of actions to update the client-side model, based on the specified <code>modelState</code>.
+     * Returns a list of actions to submit the initial revision of the client-side model, based on the injected
+     * {@link GModelState}. Typically this method is invoked by the {@link RequestModelActionHandler} when the diagram
+     * is (re)loaded.
+     * <p>
+     * These actions are not processed by this {@link ModelSubmissionHandler}, but should be either manually dispatched
+     * to the {@link ActionDispatcher}, or simply returned as the result of an
+     * {@link ActionHandler#execute(Action)} method.
+     * </p>
+     *
+     * @param requestAction The {@link RequestModelAction} that triggere the initial model update
+     * @return A list of actions to be processed in order to submit the intial model.
+     *
+     */
+    submitInitialModel(requestAction: RequestModelAction): MaybePromise<Action[]> {
+        /*
+         * In the default update action flow a `RequestModelAction` does not directly trigger a `SetModelAction` response
+         * (RequestModelAction (C) -> RequestBoundsAction (S) -> ComputedBoundsAction (C) -> SetModelACtion (S)
+         * Therefore we temporarily store the action later retrival
+         */
+        this.requestModelAction = requestAction;
+        return this.submitModel();
+    }
+
+    /**
+     * Returns a list of actions to update the client-side model, based on the injected {@link ModelState}
      *
      * These actions are not processed by this {@link ModelSubmissionHandler}, but should be either manually dispatched
      * to the `ActionDispatcher`, or simply returned as the result of an `ActionHandler.execute()` method.
@@ -63,13 +107,15 @@ export class ModelSubmissionHandler {
      */
     submitModel(reason?: DirtyStateChangeReason): MaybePromise<Action[]> {
         this.modelFactory.createModel();
-        this.modelState.root.revision = (this.modelState.root.revision ?? 0) + 1;
+
+        const revision = this.requestModelAction ? 0 : this.modelState.root.revision! + 1;
+        this.modelState.root.revision = revision;
         const root = this.serializeGModel();
 
         if (this.diagramConfiguration.needsClientLayout) {
             return [RequestBoundsAction.create(root), SetDirtyStateAction.create(this.commandStack.isDirty, { reason })];
         }
-        return [SetModelAction.create(root)];
+        return this.submitModelDirectly(reason);
     }
 
     /**
@@ -94,16 +140,27 @@ export class ModelSubmissionHandler {
         }
         const result: Action[] = [];
         result.push(
-            root.revision === 0
-                ? SetModelAction.create(root)
+            this.requestModelAction
+                ? this.createSetModeAction(root)
                 : UpdateModelAction.create(root, { animate: this.diagramConfiguration.animatedUpdate })
         );
         if (!this.diagramConfiguration.needsClientLayout) {
             result.push(SetDirtyStateAction.create(this.commandStack.isDirty, { reason }));
         }
+        if (this.validator) {
+            const markers = await this.validator.validate([this.modelState.root], MarkersReason.LIVE);
+            result.push(SetMarkersAction.create(markers, { reason: MarkersReason.LIVE }));
+        }
         return result;
     }
 
+    protected createSetModeAction(newRoot: GModelRootSchema): SetModelAction {
+        const responseId = this.requestModelAction?.requestId ?? '';
+        const response = SetModelAction.create(newRoot, { responseId });
+        this.requestModelAction = undefined;
+        return response;
+    }
+
     protected serializeGModel(): GModelRootSchema {
         return this.serializer.createSchema(this.modelState.root);
     }

package/src/common/features/model/request-model-action-handler.ts

@@ -13,11 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, RequestModelAction, ServerMessageAction, ServerStatusAction } from '@eclipse-glsp/protocol';
+import { Action, RequestModelAction, StatusAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { ActionDispatcher } from '../../actions/action-dispatcher';
 import { ActionHandler } from '../../actions/action-handler';
+import { ClientOptionsUtil } from '../../utils/client-options-util';
 import { Logger } from '../../utils/logger';
+import { ProgressMonitor, ProgressService } from '../progress/progress-service';
 import { ModelState } from './model-state';
 import { ModelSubmissionHandler } from './model-submission-handler';
 import { SourceModelStorage } from './source-model-storage';
@@ -41,27 +43,45 @@ export class RequestModelActionHandler implements ActionHandler {
     @inject(ModelSubmissionHandler)
     protected submissionHandler: ModelSubmissionHandler;
 
+    @inject(ProgressService)
+    protected progressService: ProgressService;
+
     async execute(action: RequestModelAction): Promise<Action[]> {
         this.logger.debug('Execute RequestModelAction:', action);
         this.modelState.setAll(action.options ?? {});
 
-        this.notifyClient('Model loading in progress');
-        await this.sourceModelStorage.loadSourceModel(action);
-        // Clear the previous notification.
-        this.notifyClient();
-        return this.submissionHandler.submitModel();
+        const isReconnecting = ClientOptionsUtil.isReconnecting(action.options);
+
+        const progress = this.reportModelLoading('Model loading in progress');
+
+        if (isReconnecting) {
+            await this.handleReconnect(action);
+        } else {
+            await this.sourceModelStorage.loadSourceModel(action);
+        }
+        this.reportModelLoadingFinished(progress);
+
+        return this.submissionHandler.submitInitialModel(action);
+    }
+
+    protected async handleReconnect(action: RequestModelAction): Promise<void> {
+        const oldModelRoot = this.modelState.root;
+        if (oldModelRoot) {
+            // decrease revision by one, as each submit will increase it by one;
+            // the next save would produce warning that source model was changed otherwise
+            this.modelState.root.revision = (this.modelState.root.revision ?? 0) - 1;
+        } else {
+            await this.sourceModelStorage.loadSourceModel(action);
+        }
+    }
+
+    protected reportModelLoading(message: string): ProgressMonitor {
+        this.actionDispatcher.dispatch(StatusAction.create(message, { severity: 'INFO' }));
+        return this.progressService.start(message);
     }
 
-    /**
-     * Send a message and status notification with the given message to the client.
-     * An empty message is an indication for the client to clear previously received notifications.
-     * @param message The message that should be sent to the client
-     */
-    protected notifyClient(message = ''): void {
-        const severity = message.length > 0 ? 'INFO' : 'NONE';
-        this.actionDispatcher.dispatchAll(
-            ServerMessageAction.create(message, { severity }),
-            ServerStatusAction.create(message, { severity })
-        );
+    protected reportModelLoadingFinished(monitor: ProgressMonitor): void {
+        this.actionDispatcher.dispatch(StatusAction.create('', { severity: 'NONE' }));
+        monitor.end();
     }
 }

package/src/common/features/progress/progress-service.ts

@@ -0,0 +1,74 @@
+/********************************************************************************
+ * Copyright (c) 2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { EndProgressAction, StartProgressAction, UpdateProgressAction } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import * as uuid from 'uuid';
+import { ActionDispatcher } from '../../actions/action-dispatcher';
+
+export const ProgressService = Symbol('ProgressService');
+
+/**
+ * Service for starting and monitoring progress reporting to the client.
+ */
+export interface ProgressService {
+    /**
+     * Start a progress reporting.
+     * @param title The title shown in the UI for the progress reporting.
+     * @param options Additional optional options for the progress reporting.
+     * @returns a monitor to update and end the progress reporting later.
+     */
+    start(title: string, options?: ProgressOptions): ProgressMonitor;
+}
+
+/**
+ * Optional progress reporting options.
+ */
+export interface ProgressOptions {
+    /** A message shown in the UI. */
+    message?: string;
+    /* The percentage (value range: 0 to 100) to show in the progress reporting. */
+    percentage?: number;
+}
+
+/**
+ * The monitor of a progress reporting, which can be used to update and end the reporting.
+ */
+export interface ProgressMonitor {
+    /**
+     * Updates an ongoing progress reporting.
+     * @param options Updated message and/or percentage (value range: 0 to 100).
+     */
+    update(options: { message?: string; percentage?: number }): void;
+    /**
+     * Ends an ongoing progress reporting.
+     */
+    end(): void;
+}
+
+@injectable()
+export class DefaultProgressService implements ProgressService {
+    @inject(ActionDispatcher)
+    protected actionDispatcher: ActionDispatcher;
+
+    start(title: string, options?: ProgressOptions): ProgressMonitor {
+        const progressId = uuid.v4();
+        this.actionDispatcher.dispatch(StartProgressAction.create({ progressId, title, ...options }));
+        return {
+            update: updateOptions => this.actionDispatcher.dispatch(UpdateProgressAction.create(progressId, updateOptions)),
+            end: () => this.actionDispatcher.dispatch(EndProgressAction.create(progressId))
+        };
+    }
+}