How about more bindFrontendSerivce with multi windows(connections)?

[frankLife]

Description

I have diged into source of the theia and found a question:

core/src/node/backend-application-module.ts

const commandConnectionModule = ConnectionContainerModule.create(({ bindFrontendService }) => {
    bindFrontendService(commandServicePath, CommandService);
});

const messageConnectionModule = ConnectionContainerModule.create(({ bind, bindFrontendService }) => {
    bindFrontendService(messageServicePath, MessageClient);
    bind(MessageService).toSelf().inSingletonScope();
});

const quickPickConnectionModule = ConnectionContainerModule.create(({ bindFrontendService }) => {
    bindFrontendService(quickPickServicePath, QuickPickService);
});

will invoke the bindFrontendService to get the FrontService through the WebSocketChannel

core/src/node/messaging/messaging-contribution.ts

socket.on('message', data => {
  try {
    const message: WebSocketChannel.Message = JSON.parse(data.toString());
    if (message.kind === 'open') {
      const { id, path } = message;
      const channel = this.createChannel(id, socket);
      if (channelHandlers.route(path, channel)) {
        channel.ready();
        channels.set(id, channel);
        channel.onClose(() => channels.delete(id));
      } else {
        console.error('Cannot find a service for the path: ' + path);
      }
    } else {
      const { id } = message;
      const channel = channels.get(id);
      if (channel) {
        channel.handleMessage(message);
      } else {
        console.error('The ws channel does not exist', id);
      }
    }
  } catch (error) {
    console.error('Failed to handle message', { error, data });
  }
});

and when the WebSocketChannel create, the frontService will be binded with the proxy created before by channelHandlers.route

core/src/node/messaging/connection-container-module.ts

export const ConnectionContainerModule: symbol & { create(callback: ConnectionContainerModuleCallBack): ContainerModule } = Object.assign(Symbol('ConnectionContainerModule'), {
    create(callback: ConnectionContainerModuleCallBack): ContainerModule {
        return new ContainerModule((bind, unbind, isBound, rebind) => {
            const bindFrontendService: BindFrontendService = (path, serviceIdentifier) => {
                const serviceFactory = new JsonRpcProxyFactory();
                const service = serviceFactory.createProxy();
                bind<ConnectionHandler>(ConnectionHandler).toConstantValue({
                    path,
                    onConnection: connection => serviceFactory.listen(connection)
                });
                return bind(serviceIdentifier).toConstantValue(service);
            };

But if the a new WebSocketChannel created by opening a new tab in chrome browser with the same the url. It seems like that the serviceFactory.listen would not make any sence because the service created by seviceFactory.createProxy() not make a deal with the new connection in the proxy getter handler.

core/src/common/proxy-factory.ts

 get(target: T, p: PropertyKey, receiver: any): any {
   if (p === 'setClient') {
     return (client: any) => {
       this.target = client;
     };
   }
   if (p === 'onDidOpenConnection') {
     return this.onDidOpenConnectionEmitter.event;
   }
   if (p === 'onDidCloseConnection') {
     return this.onDidCloseConnectionEmitter.event;
   }
   const isNotify = this.isNotification(p);
   return (...args: any[]) => {
     const method = p.toString();
     const capturedError = new Error(`Request '${method}' failed`);
     return this.connectionPromise.then(connection =>
     	new Promise((resolve, reject) => {
       try {
         if (isNotify) {
           connection.sendNotification(method, ...args);
           resolve();
         } else {
           const resultPromise = connection.sendRequest(method, ...args) as Promise<any>;
           resultPromise
             .catch((err: any) => reject(this.deserializeError(capturedError, err)))
             .then((result: any) => resolve(result));
         }
       } catch (err) {
         reject(err);
       }
     })
                                       );
   };
 }

the this.connectionPromise.then(connection => would keep the first connection .

Is this by design or will be optimized in the future?

[akosyakov]

Sorry, i could not grasp the question. But arch is following:

• there is the application DI container contributing common bindings
• there is a connection DI container which:
  • extends the application container
  • contributes bindings scoped per a connection
  • allow backend services to access frontend services
• for each window there is a new connection to a backend with own instances, so:
  • instances created via application container cannot access frontend services
  • windows can share singleton instances created via application container
  • but cannot share instances created via connection containers