[workspace] Better localstorage keys eclipse-theia#904

Because Theia is both meant to roll on a local machine and in the cloud, this commit adds better browser localstorage
keys, so that Theia gets less confused as to what is being displayed in case that some URI points to different remotes
(reverse proxying the same URL -at different times- to different theia instances).

This ensures that despite sharing the same local storage domain (host:port), multiple theias can be differentiated by passing a
`--domain` argument. This means that we can identify different theias behind proxies, as long as the instances are run with a
different `--domain <id>`.

When this domain is not specified, then theia will use `window.location.pathname`.

Signed-off-by: Paul Maréchal <paul.marechal@ericsson.com>

packages/workspace/src/browser/workspace-service.ts

@@ -54,6 +54,10 @@ export class WorkspaceService implements FrontendApplicationContribution {
         this.deferredRoot.resolve(this._root);
     }
 
+    async getDomain(): Promise<string | undefined> {
+        return this.server.getDomain();
+    }
+
     protected updateTitle(uri: URI): void {
         document.title = uri.displayName;
     }

packages/workspace/src/browser/workspace-storage-service.ts

@@ -7,9 +7,10 @@
 
 import { StorageService } from '@theia/core/lib/browser/storage-service';
 import { WorkspaceService } from './workspace-service';
-import { inject, injectable } from 'inversify';
+import { inject, injectable, postConstruct } from 'inversify';
 import { ILogger } from '@theia/core/lib/common';
 import { LocalStorageService } from '@theia/core/lib/browser/storage-service';
+import URI from '@theia/core/lib/common/uri';
 
 /*
  * Prefixes any stored data with the current workspace path.
@@ -21,18 +22,25 @@ export class WorkspaceStorageService implements StorageService {
     private initialized: Promise<void>;
     protected storageService: StorageService;
 
-    constructor( @inject(WorkspaceService) protected workspaceService: WorkspaceService,
-        @inject(ILogger) protected logger: ILogger) {
-        this.initialized = this.workspaceService.root.then(stat => {
-            if (stat) {
-                this.prefix = stat.uri;
-            } else {
-                this.prefix = '_global_';
-            }
-        });
+    @inject(WorkspaceService)
+    protected workspaceService: WorkspaceService;
+
+    @inject(ILogger)
+    protected logger: ILogger;
+
+    constructor() {
         this.storageService = new LocalStorageService(this.logger);
     }
 
+    @postConstruct()
+    protected async init(): Promise<void> {
+        const domain = await this.workspaceService.getDomain();
+        const statFile = await this.workspaceService.root;
+        const workspace = statFile ? new URI(statFile.uri).path : '_global_';
+        this.prefix = `${domain ? domain : window.location.pathname}:${workspace}`;
+        this.initialized = Promise.resolve();
+    }
+
     async setData<T>(key: string, data: T): Promise<void> {
         if (!this.prefix) {
             await this.initialized;

packages/workspace/src/common/test/mock-workspace-server.ts

@@ -10,6 +10,8 @@ import { WorkspaceServer } from '../workspace-protocol';
 @injectable()
 export class MockWorkspaceServer implements WorkspaceServer {
 
+    getDomain(): Promise<string | undefined> { return Promise.resolve('mock'); }
+
     getRoot(): Promise<string | undefined> { return Promise.resolve(''); }
 
     setRoot(uri: string): Promise<void> { return Promise.resolve(); }

packages/workspace/src/common/workspace-protocol.ts

@@ -13,6 +13,11 @@ export const workspacePath = '/services/workspace';
 export const WorkspaceServer = Symbol('WorkspaceServer');
 export interface WorkspaceServer {
 
+    /**
+     * Returns the random identifier to the running theia instance
+     */
+    getDomain(): Promise<string | undefined>;
+
     /**
      * Returns with a promise that resolves to the workspace root URI as a string. Resolves to `undefined` if the workspace root is not yet set.
      */

packages/workspace/src/node/default-workspace-server.ts

@@ -10,7 +10,7 @@ import * as yargs from 'yargs';
 import * as fs from 'fs-extra';
 import * as os from 'os';
 
-import { injectable, inject } from "inversify";
+import { injectable, inject, postConstruct } from "inversify";
 import { FileUri } from '@theia/core/lib/node';
 import { CliContribution } from '@theia/core/lib/node/cli';
 import { Deferred } from '@theia/core/lib/common/promise-util';
@@ -20,15 +20,19 @@ import { WorkspaceServer } from "../common";
 export class WorkspaceCliContribution implements CliContribution {
 
     workspaceRoot = new Deferred<string | undefined>();
+    domain?: string;
 
     configure(conf: yargs.Argv): void {
         conf.usage("$0 [workspace-directory] [options]");
         conf.option('root-dir', {
             description: 'DEPRECATED: Sets the workspace directory.',
         });
+        conf.option('domain', { description: 'The domain id-like to represent', type: 'string' });
     }
 
     setArguments(args: yargs.Arguments): void {
+        this.domain = args.domain;
+
         let wsPath = args._[2];
         if (!wsPath) {
             wsPath = args['root-dir'];
@@ -50,18 +54,22 @@ export class DefaultWorkspaceServer implements WorkspaceServer {
 
     protected root: Promise<string | undefined>;
 
-    constructor(
-        @inject(WorkspaceCliContribution) protected readonly cliParams: WorkspaceCliContribution
-    ) {
+    @inject(WorkspaceCliContribution)
+    protected readonly cliParams: WorkspaceCliContribution;
+
+    @postConstruct()
+    protected async init(): Promise<void> {
         this.root = this.getRootURIFromCli();
-        this.root.then(async root => {
-            if (!root) {
-                const data = await this.readFromUserHome();
-                if (data && data.recentRoots) {
-                    this.root = Promise.resolve(data.recentRoots[0]);
-                }
+        if (!await this.root) {
+            const data = await this.readFromUserHome();
+            if (data && data.recentRoots) {
+                this.root = Promise.resolve(data.recentRoots[0]);
             }
-        });
+        }
+    }
+
+    async getDomain(): Promise<string | undefined> {
+        return Promise.resolve(this.cliParams.domain);
     }
 
     getRoot(): Promise<string | undefined> {