@gorizond/catalog-backend-module-fleet/dist/module.js

Backstage catalog backend module for Rancher Fleet GitOps entities

"use strict";
/**
 * Backstage Backend Module for Fleet Entity Provider
 *
 * This module registers the FleetEntityProvider with the Backstage catalog.
 * It fetches Fleet GitOps resources (GitRepo, Bundle, BundleDeployment) from
 * Kubernetes clusters and creates corresponding Backstage catalog entities.
 *
 * @packageDocumentation
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.catalogModuleFleet = void 0;
const backend_plugin_api_1 = require("@backstage/backend-plugin-api");
const alpha_1 = require("@backstage/plugin-catalog-node/alpha");
const provider_1 = require("./provider");
const k8sLocator_1 = require("./k8sLocator");
/**
 * Catalog backend module that provides Fleet entities.
 *
 * @example
 * ```ts
 * // In packages/backend/src/index.ts
 * import { createBackend } from '@backstage/backend-defaults';
 *
 * const backend = createBackend();
 * backend.add(import('@backstage/plugin-catalog-backend'));
 * backend.add(import('@gorizond/catalog-backend-module-fleet'));
 * backend.start();
 * ```
 *
 * @example
 * Configuration in app-config.yaml:
 * ```yaml
 * catalog:
 *   providers:
 *     fleet:
 *       # Single cluster configuration
 *       name: rancher-prod
 *       url: https://rancher.example.com/k8s/clusters/local
 *       token: ${FLEET_CLUSTER_TOKEN}
 *       namespaces:
 *         - fleet-default
 *       includeBundles: true
 *       includeBundleDeployments: false
 *       generateApis: false
 *       fetchFleetYaml: false
 *       schedule:
 *         frequency:
 *           minutes: 10
 *         timeout:
 *           minutes: 5
 *
 *       # Optional: filter GitRepos by labels
 *       gitRepoSelector:
 *         matchLabels:
 *           backstage.io/discover: "true"
 * ```
 *
 * @example
 * Multi-cluster configuration:
 * ```yaml
 * catalog:
 *   providers:
 *     fleet:
 *       production:
 *         clusters:
 *           - name: local
 *             url: https://rancher.example.com/k8s/clusters/local
 *             token: ${FLEET_LOCAL_TOKEN}
 *             namespaces:
 *               - fleet-default
 *           - name: staging
 *             url: https://rancher-staging.example.com/k8s/clusters/local
 *             token: ${FLEET_STAGING_TOKEN}
 *             namespaces:
 *               - fleet-default
 *         schedule:
 *           frequency:
 *             minutes: 5
 * ```
 *
 * @public
 */
exports.catalogModuleFleet = (0, backend_plugin_api_1.createBackendModule)({
    pluginId: "catalog",
    moduleId: "fleet-entity-provider",
    register(env) {
        env.registerInit({
            deps: {
                catalog: alpha_1.catalogProcessingExtensionPoint,
                config: backend_plugin_api_1.coreServices.rootConfig,
                logger: backend_plugin_api_1.coreServices.logger,
                scheduler: backend_plugin_api_1.coreServices.scheduler,
            },
            async init({ catalog, config, logger, scheduler }) {
                const k8sLocator = k8sLocator_1.FleetK8sLocator.fromConfig({ config, logger });
                const providers = provider_1.FleetEntityProvider.fromConfig(config, {
                    logger,
                    k8sLocator,
                });
                if (providers.length === 0) {
                    logger.info("No Fleet entity providers configured. " +
                        "Add catalog.providers.fleet to your app-config.yaml to enable.");
                    return;
                }
                for (const provider of providers) {
                    // Register the provider with the catalog
                    catalog.addEntityProvider(provider);
                    // Schedule the provider to run periodically
                    const schedule = provider.getSchedule();
                    await scheduler.scheduleTask({
                        id: provider.getProviderName(),
                        frequency: schedule.frequency,
                        timeout: schedule.timeout,
                        initialDelay: schedule.initialDelay,
                        fn: async () => {
                            await provider.run();
                        },
                    });
                    logger.info(`Registered Fleet entity provider: ${provider.getProviderName()}`);
                }
                // Log discovered Kubernetes clusters (for informational purposes)
                // NOTE: The kubernetes backend module (fleetK8sClusterSupplier) handles actual cluster injection
                if (k8sLocator) {
                    try {
                        const clusterMethods = await k8sLocator.asClusterLocatorMethods();
                        const clusters = clusterMethods.flatMap((m) => m.clusters);
                        logger.info(`FleetK8sLocator discovered ${clusters.length} Kubernetes clusters`);
                        logger.debug(`Clusters: ${clusters.map((c) => c.name).join(", ")}`);
                    }
                    catch (error) {
                        logger.warn(`FleetK8sLocator failed: ${error}`);
                    }
                }
            },
        });
    },
});
/**
 * Default export for convenience
 * @public
 */
exports.default = exports.catalogModuleFleet;