diff --git a/packages/backend-app-api/src/services/implementations/cacheService.ts b/packages/backend-app-api/src/services/implementations/cacheService.ts index c5e58b4a41..7e15f031c6 100644 --- a/packages/backend-app-api/src/services/implementations/cacheService.ts +++ b/packages/backend-app-api/src/services/implementations/cacheService.ts @@ -18,6 +18,7 @@ import { CacheManager } from '@backstage/backend-common'; import { configServiceRef, createServiceFactory, + pluginMetadataServiceRef, cacheServiceRef, } from '@backstage/backend-plugin-api'; @@ -25,13 +26,13 @@ import { export const cacheFactory = createServiceFactory({ service: cacheServiceRef, deps: { - configFactory: configServiceRef, + config: configServiceRef, + plugin: pluginMetadataServiceRef, }, - factory: async ({ configFactory }) => { - const config = await configFactory('root'); + async factory({ config }) { const cacheManager = CacheManager.fromConfig(config); - return async (pluginId: string) => { - return cacheManager.forPlugin(pluginId); + return async ({ plugin }) => { + return cacheManager.forPlugin(plugin.getId()); }; }, }); diff --git a/packages/backend-app-api/src/services/implementations/configService.ts b/packages/backend-app-api/src/services/implementations/configService.ts index c4aa641f72..91327289df 100644 --- a/packages/backend-app-api/src/services/implementations/configService.ts +++ b/packages/backend-app-api/src/services/implementations/configService.ts @@ -19,23 +19,20 @@ import { configServiceRef, createServiceFactory, loggerToWinstonLogger, - loggerServiceRef, + rootLoggerServiceRef, } from '@backstage/backend-plugin-api'; /** @public */ export const configFactory = createServiceFactory({ service: configServiceRef, deps: { - loggerFactory: loggerServiceRef, + logger: rootLoggerServiceRef, }, - factory: async ({ loggerFactory }) => { - const logger = await loggerFactory('root'); + async factory({ logger }) { const config = await loadBackendConfig({ argv: process.argv, logger: loggerToWinstonLogger(logger), }); - return async () => { - return config; - }; + return config; }, }); diff --git a/packages/backend-app-api/src/services/implementations/databaseService.ts b/packages/backend-app-api/src/services/implementations/databaseService.ts index b2bc19de84..f6401528e6 100644 --- a/packages/backend-app-api/src/services/implementations/databaseService.ts +++ b/packages/backend-app-api/src/services/implementations/databaseService.ts @@ -19,19 +19,20 @@ import { configServiceRef, createServiceFactory, databaseServiceRef, + pluginMetadataServiceRef, } from '@backstage/backend-plugin-api'; /** @public */ export const databaseFactory = createServiceFactory({ service: databaseServiceRef, deps: { - configFactory: configServiceRef, + config: configServiceRef, + plugin: pluginMetadataServiceRef, }, - factory: async ({ configFactory }) => { - const config = await configFactory('root'); + async factory({ config }) { const databaseManager = DatabaseManager.fromConfig(config); - return async (pluginId: string) => { - return databaseManager.forPlugin(pluginId); + return async ({ plugin }) => { + return databaseManager.forPlugin(plugin.getId()); }; }, }); diff --git a/packages/backend-app-api/src/services/implementations/discoveryService.ts b/packages/backend-app-api/src/services/implementations/discoveryService.ts index 3f1a584c61..7f35bf2447 100644 --- a/packages/backend-app-api/src/services/implementations/discoveryService.ts +++ b/packages/backend-app-api/src/services/implementations/discoveryService.ts @@ -25,10 +25,9 @@ import { export const discoveryFactory = createServiceFactory({ service: discoveryServiceRef, deps: { - configFactory: configServiceRef, + config: configServiceRef, }, - factory: async ({ configFactory }) => { - const config = await configFactory('root'); + async factory({ config }) { const discovery = SingleHostDiscovery.fromConfig(config); return async () => { return discovery; diff --git a/packages/backend-app-api/src/services/implementations/httpRouterService.ts b/packages/backend-app-api/src/services/implementations/httpRouterService.ts index 6460a77eaf..be4af664c4 100644 --- a/packages/backend-app-api/src/services/implementations/httpRouterService.ts +++ b/packages/backend-app-api/src/services/implementations/httpRouterService.ts @@ -18,6 +18,7 @@ import { createServiceFactory, httpRouterServiceRef, configServiceRef, + pluginMetadataServiceRef, } from '@backstage/backend-plugin-api'; import Router from 'express-promise-router'; import { Handler } from 'express'; @@ -27,18 +28,20 @@ import { createServiceBuilder } from '@backstage/backend-common'; export const httpRouterFactory = createServiceFactory({ service: httpRouterServiceRef, deps: { - configFactory: configServiceRef, + config: configServiceRef, + plugin: pluginMetadataServiceRef, }, - factory: async ({ configFactory }) => { + async factory({ config }) { const rootRouter = Router(); const service = createServiceBuilder(module) - .loadConfig(await configFactory('root')) + .loadConfig(config) .addRouter('', rootRouter); await service.start(); - return async (pluginId?: string) => { + return async ({ plugin }) => { + const pluginId = plugin.getId(); const path = pluginId ? `/api/${pluginId}` : ''; return { use(handler: Handler) { diff --git a/packages/backend-app-api/src/services/implementations/loggerService.ts b/packages/backend-app-api/src/services/implementations/loggerService.ts index e90b591302..ff72020140 100644 --- a/packages/backend-app-api/src/services/implementations/loggerService.ts +++ b/packages/backend-app-api/src/services/implementations/loggerService.ts @@ -14,38 +14,23 @@ * limitations under the License. */ -import { createRootLogger } from '@backstage/backend-common'; import { createServiceFactory, - Logger, loggerServiceRef, + pluginMetadataServiceRef, + rootLoggerServiceRef, } from '@backstage/backend-plugin-api'; -import { Logger as WinstonLogger } from 'winston'; - -class BackstageLogger implements Logger { - static fromWinston(logger: WinstonLogger): BackstageLogger { - return new BackstageLogger(logger); - } - - private constructor(private readonly winston: WinstonLogger) {} - - info(message: string, ...meta: any[]): void { - this.winston.info(message, ...meta); - } - - child(fields: { [name: string]: string }): Logger { - return new BackstageLogger(this.winston.child(fields)); - } -} /** @public */ export const loggerFactory = createServiceFactory({ service: loggerServiceRef, - deps: {}, - factory: async () => { - const root = BackstageLogger.fromWinston(createRootLogger()); - return async (pluginId: string) => { - return root.child({ pluginId }); + deps: { + rootLogger: rootLoggerServiceRef, + plugin: pluginMetadataServiceRef, + }, + async factory({ rootLogger }) { + return async ({ plugin }) => { + return rootLogger.child({ pluginId: plugin.getId() }); }; }, }); diff --git a/packages/backend-app-api/src/services/implementations/permissionsService.ts b/packages/backend-app-api/src/services/implementations/permissionsService.ts index 26fe012a20..32e8a1a9f9 100644 --- a/packages/backend-app-api/src/services/implementations/permissionsService.ts +++ b/packages/backend-app-api/src/services/implementations/permissionsService.ts @@ -27,20 +27,16 @@ import { ServerPermissionClient } from '@backstage/plugin-permission-node'; export const permissionsFactory = createServiceFactory({ service: permissionsServiceRef, deps: { - configFactory: configServiceRef, - discoveryFactory: discoveryServiceRef, - tokenManagerFactory: tokenManagerServiceRef, + config: configServiceRef, + discovery: discoveryServiceRef, + tokenManager: tokenManagerServiceRef, }, - factory: async ({ configFactory, discoveryFactory, tokenManagerFactory }) => { - const config = await configFactory('root'); - const discovery = await discoveryFactory('root'); - const tokenManager = await tokenManagerFactory('root'); - const permissions = ServerPermissionClient.fromConfig(config, { - discovery, - tokenManager, - }); - return async (_pluginId: string) => { - return permissions; + async factory({ config }) { + return async ({ discovery, tokenManager }) => { + return ServerPermissionClient.fromConfig(config, { + discovery, + tokenManager, + }); }; }, }); diff --git a/packages/backend-app-api/src/services/implementations/rootLoggerService.ts b/packages/backend-app-api/src/services/implementations/rootLoggerService.ts new file mode 100644 index 0000000000..d7da11723e --- /dev/null +++ b/packages/backend-app-api/src/services/implementations/rootLoggerService.ts @@ -0,0 +1,48 @@ +/* + * Copyright 2022 The Backstage Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { createRootLogger } from '@backstage/backend-common'; +import { + createServiceFactory, + Logger, + rootLoggerServiceRef, +} from '@backstage/backend-plugin-api'; +import { Logger as WinstonLogger } from 'winston'; + +class BackstageLogger implements Logger { + static fromWinston(logger: WinstonLogger): BackstageLogger { + return new BackstageLogger(logger); + } + + private constructor(private readonly winston: WinstonLogger) {} + + info(message: string, ...meta: any[]): void { + this.winston.info(message, ...meta); + } + + child(fields: { [name: string]: string }): Logger { + return new BackstageLogger(this.winston.child(fields)); + } +} + +/** @public */ +export const loggerFactory = createServiceFactory({ + service: rootLoggerServiceRef, + deps: {}, + async factory() { + return BackstageLogger.fromWinston(createRootLogger()); + }, +}); diff --git a/packages/backend-app-api/src/services/implementations/schedulerService.ts b/packages/backend-app-api/src/services/implementations/schedulerService.ts index 39dbf26ba9..40676344ec 100644 --- a/packages/backend-app-api/src/services/implementations/schedulerService.ts +++ b/packages/backend-app-api/src/services/implementations/schedulerService.ts @@ -17,6 +17,7 @@ import { configServiceRef, createServiceFactory, + pluginMetadataServiceRef, schedulerServiceRef, } from '@backstage/backend-plugin-api'; import { TaskScheduler } from '@backstage/backend-tasks'; @@ -25,13 +26,13 @@ import { TaskScheduler } from '@backstage/backend-tasks'; export const schedulerFactory = createServiceFactory({ service: schedulerServiceRef, deps: { - configFactory: configServiceRef, + config: configServiceRef, + plugin: pluginMetadataServiceRef, }, - factory: async ({ configFactory }) => { - const config = await configFactory('root'); + async factory({ config }) { const taskScheduler = TaskScheduler.fromConfig(config); - return async (pluginId: string) => { - return taskScheduler.forPlugin(pluginId); + return async ({ plugin }) => { + return taskScheduler.forPlugin(plugin.getId()); }; }, }); diff --git a/packages/backend-app-api/src/services/implementations/tokenManagerService.ts b/packages/backend-app-api/src/services/implementations/tokenManagerService.ts index 7767c17944..92f42c10db 100644 --- a/packages/backend-app-api/src/services/implementations/tokenManagerService.ts +++ b/packages/backend-app-api/src/services/implementations/tokenManagerService.ts @@ -27,32 +27,11 @@ import { ServerTokenManager } from '@backstage/backend-common'; export const tokenManagerFactory = createServiceFactory({ service: tokenManagerServiceRef, deps: { - configFactory: configServiceRef, - loggerFactory: loggerServiceRef, + config: configServiceRef, + logger: loggerServiceRef, }, - factory: async ({ configFactory, loggerFactory }) => { - const logger = await loggerFactory('root'); - const config = await configFactory('root'); - return async (_pluginId: string) => { - // doesn't the logger want to be inferred from the plugin tho here? - // maybe ... also why do we recreate it every time otherwise - // we should memoize on a per plugin right? so I think it's should be fine to re-use the plugin one - // we shouldn't recreate on a per plugin basis. - // hm - on the other hand, is this really ever called more than once? - // not this function right. should only be called when the plugin requests this serviceRef - // yeah so no need to worry about memo probably - // but we still want to scope the logger to the ServrTokenmanagfer>? - // mm sure maybe - // maybe in this case it doesn't provide so much value b - // oh hang on - isn't it up to THE MANAGER to make a child internally if it wants to do that - // so that it becomes a property intrinsic to that class, no matter how it's constructed - // or is that too much responsibility for it - making the constructor complex so to speak, making it harder to tweak that behavior - // this is not ultra efficient :) - - // I think the naming here is wrong to be gonest - // this isn't like the cache manager or the database manager - // the manager name is confusuion i think - // aye perhaps + async factory() { + return async ({ config, logger }) => { return ServerTokenManager.fromConfig(config, { logger: loggerToWinstonLogger(logger), }); diff --git a/packages/backend-app-api/src/services/implementations/urlReaderService.ts b/packages/backend-app-api/src/services/implementations/urlReaderService.ts index df353a52d2..d7d7502a08 100644 --- a/packages/backend-app-api/src/services/implementations/urlReaderService.ts +++ b/packages/backend-app-api/src/services/implementations/urlReaderService.ts @@ -27,15 +27,14 @@ import { export const urlReaderFactory = createServiceFactory({ service: urlReaderServiceRef, deps: { - configFactory: configServiceRef, - loggerFactory: loggerServiceRef, + config: configServiceRef, + logger: loggerServiceRef, }, - factory: async ({ configFactory, loggerFactory }) => { - return async (pluginId: string) => { - const logger = await loggerFactory(pluginId); + async factory() { + return async ({ config, logger }) => { return UrlReaders.default({ + config, logger: loggerToWinstonLogger(logger), - config: await configFactory(pluginId), }); }; }, diff --git a/packages/backend-app-api/src/wiring/BackendInitializer.ts b/packages/backend-app-api/src/wiring/BackendInitializer.ts index afb5250504..c86cd8382d 100644 --- a/packages/backend-app-api/src/wiring/BackendInitializer.ts +++ b/packages/backend-app-api/src/wiring/BackendInitializer.ts @@ -50,11 +50,12 @@ export class BackendInitializer { if (extensionPoint) { result.set(name, extensionPoint); } else { - const factory = await this.#serviceHolder.get( + const impl = await this.#serviceHolder.get( ref as ServiceRef, + pluginId, ); - if (factory) { - result.set(name, await factory(pluginId)); + if (impl) { + result.set(name, impl); } else { missingRefs.add(ref); } diff --git a/packages/backend-plugin-api/src/services/definitions/configServiceRef.ts b/packages/backend-plugin-api/src/services/definitions/configServiceRef.ts index ba5dcacdc8..f17c5f57bc 100644 --- a/packages/backend-plugin-api/src/services/definitions/configServiceRef.ts +++ b/packages/backend-plugin-api/src/services/definitions/configServiceRef.ts @@ -21,5 +21,6 @@ import { createServiceRef } from '../system/types'; * @public */ export const configServiceRef = createServiceRef({ - id: 'core.config', + id: 'core.root.config', + scope: 'root', }); diff --git a/packages/backend-plugin-api/src/services/definitions/index.ts b/packages/backend-plugin-api/src/services/definitions/index.ts index fb204df495..44ccb62978 100644 --- a/packages/backend-plugin-api/src/services/definitions/index.ts +++ b/packages/backend-plugin-api/src/services/definitions/index.ts @@ -26,4 +26,5 @@ export { discoveryServiceRef } from './discoveryServiceRef'; export { tokenManagerServiceRef } from './tokenManagerServiceRef'; export { permissionsServiceRef } from './permissionsServiceRef'; export { schedulerServiceRef } from './schedulerServiceRef'; +export { rootLoggerServiceRef } from './rootLoggerServiceRef'; export { pluginMetadataServiceRef } from './pluginMetadataServiceRef'; diff --git a/packages/backend-plugin-api/src/services/definitions/rootLoggerServiceRef.ts b/packages/backend-plugin-api/src/services/definitions/rootLoggerServiceRef.ts new file mode 100644 index 0000000000..62e22c53d9 --- /dev/null +++ b/packages/backend-plugin-api/src/services/definitions/rootLoggerServiceRef.ts @@ -0,0 +1,26 @@ +/* + * Copyright 2022 The Backstage Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { createServiceRef } from '../system/types'; +import { Logger } from './loggerServiceRef'; + +/** + * @public + */ +export const rootLoggerServiceRef = createServiceRef({ + id: 'core.root.logger', + scope: 'root', +}); diff --git a/packages/backend-plugin-api/src/services/system/index.ts b/packages/backend-plugin-api/src/services/system/index.ts index 817b0a590f..8c666af42e 100644 --- a/packages/backend-plugin-api/src/services/system/index.ts +++ b/packages/backend-plugin-api/src/services/system/index.ts @@ -14,11 +14,5 @@ * limitations under the License. */ -export type { - ServiceRef, - TypesToServiceRef, - DepsToDepFactories, - FactoryFunc, - ServiceFactory, -} from './types'; +export type { ServiceRef, TypesToServiceRef, ServiceFactory } from './types'; export { createServiceRef, createServiceFactory } from './types'; diff --git a/packages/backend-plugin-api/src/services/system/types.ts b/packages/backend-plugin-api/src/services/system/types.ts index 3edee2ec0f..a7bce3d220 100644 --- a/packages/backend-plugin-api/src/services/system/types.ts +++ b/packages/backend-plugin-api/src/services/system/types.ts @@ -116,6 +116,7 @@ export function createServiceRef(options: { }; } +/** @ignore */ type ServiceRefsToInstances< T extends { [key in string]: ServiceRef }, TScope extends 'root' | 'plugin' = 'root' | 'plugin', diff --git a/plugins/catalog-node/src/catalogService.ts b/plugins/catalog-node/src/catalogService.ts index ddfff75462..c6a8fb44f5 100644 --- a/plugins/catalog-node/src/catalogService.ts +++ b/plugins/catalog-node/src/catalogService.ts @@ -31,13 +31,11 @@ export const catalogServiceRef = createServiceRef({ createServiceFactory({ service, deps: { - discoveryFactory: discoveryServiceRef, + discoveryApi: discoveryServiceRef, }, - factory: async ({ discoveryFactory }) => { - const discoveryApi = await discoveryFactory('root'); - const catalogClient = new CatalogClient({ discoveryApi }); - return async _pluginId => { - return catalogClient; + async factory() { + return async ({ discoveryApi }) => { + return new CatalogClient({ discoveryApi }); }; }, }),