Make it possible to export container dependant variables

This patch introduces the
Backend/FrontendApplicationInitializeContribution the contributions are
called as the first thing the application does.

This enables the logger module to export a logger object fetched via
container.get<ILogger>(ILogger) such that this new logger object can be
exported to code that does not use injection.

Signed-off-by: Antoine Tremblay <[email protected]>

Author: Antoine Tremblay

packages/core/src/browser/frontend-application-module.ts

@@ -18,7 +18,7 @@ import {
     MessageService
 } from "../common";
 import { MessageClient, messageServicePath } from '../common/message-service-protocol';
-import { FrontendApplication, FrontendApplicationContribution } from './frontend-application';
+import { FrontendApplication, FrontendApplicationContribution, FrontendApplicationInitializeContribution } from './frontend-application';
 import { DefaultOpenerService, OpenerService, OpenHandler } from './opener-service';
 import { HumaneMessageClient } from './humane-message-client';
 import { WebSocketConnectionProvider } from './messaging';
@@ -33,6 +33,7 @@ import 'font-awesome/css/font-awesome.min.css';
 
 export const frontendApplicationModule = new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(FrontendApplication).toSelf().inSingletonScope();
+    bindContributionProvider(bind, FrontendApplicationInitializeContribution);
     bindContributionProvider(bind, FrontendApplicationContribution);
 
     bindContributionProvider(bind, OpenHandler);

packages/core/src/browser/frontend-application.ts

@@ -30,6 +30,11 @@ export interface FrontendApplicationContribution {
     onStop?(app: FrontendApplication): void;
 }
 
+export const FrontendApplicationInitializeContribution = Symbol("FrontendApplicationInitializeContribution");
+export interface FrontendApplicationInitializeContribution {
+    initialize(): void;
+}
+
 @injectable()
 export class FrontendApplication {
 
@@ -40,9 +45,17 @@ export class FrontendApplication {
         @inject(MenuModelRegistry) protected readonly menus: MenuModelRegistry,
         @inject(KeybindingRegistry) protected readonly keybindings: KeybindingRegistry,
         @inject(ILogger) protected readonly logger: ILogger,
+        @inject(ContributionProvider) @named(FrontendApplicationInitializeContribution)
+        protected readonly initializeContributionProvider: ContributionProvider<FrontendApplicationInitializeContribution>,
         @inject(ContributionProvider) @named(FrontendApplicationContribution)
         protected readonly contributions: ContributionProvider<FrontendApplicationContribution>
-    ) { }
+    ) {
+        for (const contribution of this.initializeContributionProvider.getContributions()) {
+            if (contribution.initialize) {
+                contribution.initialize();
+            }
+        }
+    }
 
     get shell(): ApplicationShell {
         if (this._shell) {

packages/core/src/common/logger.ts

@@ -18,6 +18,14 @@ export enum LogLevel {
     TRACE = 10
 }
 
+/* This is to be initialized from container composition root.
+It can be used outside of the inversify context.  */
+export let logger: ILogger;
+
+export function setRootLogger(alogger: ILogger) {
+    logger = alogger;
+}
+
 export type Log = (message: string, ...params: any[]) => void;
 export type Loggable = (log: Log) => void;
 
@@ -365,4 +373,4 @@ export class Logger extends AbstractLogger implements ILogger {
     child(obj: object): ILogger {
         return this.factory(obj);
     }
-}
+}

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

@@ -8,10 +8,11 @@
 import { ContainerModule } from "inversify";
 import { bindContributionProvider, ConnectionHandler, JsonRpcConnectionHandler, MessageService } from '../common';
 import { MessageClient, DispatchingMessageClient, messageServicePath } from '../common/message-service-protocol';
-import { BackendApplication, BackendApplicationContribution } from "./backend-application";
+import { BackendApplication, BackendApplicationContribution, BackendApplicationInitializeContribution } from "./backend-application";
 
 export const backendApplicationModule = new ContainerModule(bind => {
     bind(BackendApplication).toSelf().inSingletonScope();
+    bindContributionProvider(bind, BackendApplicationInitializeContribution);
     bindContributionProvider(bind, BackendApplicationContribution);
 
     bind(DispatchingMessageClient).toSelf().inSingletonScope();

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

@@ -16,6 +16,11 @@ export interface BackendApplicationContribution {
     onStart?(server: http.Server): void;
 }
 
+export const BackendApplicationInitializeContribution = Symbol("BackendApplicationInitializeContribution");
+export interface BackendApplicationInitializeContribution {
+    initialize(): void;
+}
+
 /**
  * The main entry point for Theia applications.
  */
@@ -25,6 +30,8 @@ export class BackendApplication {
     protected readonly app: express.Application = express();
 
     constructor(
+        @inject(ContributionProvider) @named(BackendApplicationInitializeContribution)
+        protected readonly initializeContributionProvider: ContributionProvider<BackendApplicationInitializeContribution>,
         @inject(ContributionProvider) @named(BackendApplicationContribution)
         protected readonly contributionsProvider: ContributionProvider<BackendApplicationContribution>,
         @inject(ILogger) protected readonly logger: ILogger
@@ -37,6 +44,13 @@ export class BackendApplication {
                 }
             }
         });
+
+        for (const contribution of this.initializeContributionProvider.getContributions()) {
+            if (contribution.initialize) {
+                contribution.initialize();
+            }
+        }
+
         for (const contribution of this.contributionsProvider.getContributions()) {
             if (contribution.configure) {
                 contribution.configure(this.app);

packages/core/src/node/logger-backend-module.ts

@@ -7,13 +7,22 @@
 
 import { ContainerModule, Container } from 'inversify';
 import { ConnectionHandler, JsonRpcConnectionHandler } from "../common/messaging";
-import { ILogger, LoggerFactory, LoggerOptions, Logger } from '../common/logger';
+import { ILogger, LoggerFactory, LoggerOptions, Logger, setRootLogger } from '../common/logger';
 import { ILoggerServer, ILoggerClient, loggerPath, LoggerServerOptions } from '../common/logger-protocol';
 import { BunyanLoggerServer } from './bunyan-logger-server';
 import { LoggerWatcher } from '../common/logger-watcher';
+import { BackendApplicationInitializeContribution } from './backend-application';
+
 import * as yargs from 'yargs';
 
 export const loggerBackendModule = new ContainerModule(bind => {
+    bind(BackendApplicationInitializeContribution).toDynamicValue(ctx =>
+        ({
+            initialize() {
+                setRootLogger(ctx.container.get<ILogger>(ILogger));
+            }
+        }));
+
     bind(ILogger).to(Logger).inSingletonScope().whenTargetIsDefault();
     bind(LoggerWatcher).toSelf().inSingletonScope();
     bind(ILoggerServer).to(BunyanLoggerServer).inSingletonScope();