@secustor/backstage-plugin-renovate-backend/dist/wrapper/renovateRunner.cjs.js

'use strict';

var is = require('@sindresorhus/is');
var index$1 = require('./platforms/index.cjs.js');
var utils = require('./utils.cjs.js');
var backstagePluginRenovateCommon = require('@secustor/backstage-plugin-renovate-common');
var index = require('../config/index.cjs.js');
var errors = require('@backstage/errors');
var nanoid = require('nanoid');
var factory = require('../queue/factory.cjs.js');

function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }

var is__default = /*#__PURE__*/_interopDefaultCompat(is);

class RenovateRunner {
  constructor(queueFactories, databaseHandler, rootConfig, logger, runtimes) {
    this.databaseHandler = databaseHandler;
    this.rootConfig = rootConfig;
    this.logger = logger;
    this.runtimes = runtimes;
    this.queue = factory.createQueue(queueFactories, rootConfig, this);
  }
  queue;
  static async from(options) {
    const { databaseHandler, rootConfig, runtimes, logger, queueFactories } = options;
    return new RenovateRunner(
      queueFactories,
      databaseHandler,
      rootConfig,
      logger,
      runtimes
    );
  }
  async addToQueue(...targets) {
    const props = targets.map((target) => {
      const jobId = backstagePluginRenovateCommon.getTaskID(target);
      const targetRepo = backstagePluginRenovateCommon.getTargetRepo(target);
      return {
        jobId,
        data: {
          id: jobId,
          target: targetRepo
        }
      };
    });
    return await this.queue.addBulk(props);
  }
  async runNext(target) {
    const jobId = backstagePluginRenovateCommon.getTaskID(target);
    const targetRepo = backstagePluginRenovateCommon.getTargetRepo(target);
    return await this.queue.add(
      jobId,
      { id: jobId, target: targetRepo },
      {
        force: true,
        insertInFront: true
      }
    );
  }
  async run(props) {
    const { id, target } = props;
    const runID = nanoid.nanoid();
    const logger = this.logger.child({ runID, jobID: id, ...target });
    try {
      logger.info("Renovate run starting");
      const report = await this.renovate(props, logger);
      await this.databaseHandler.addReport({
        runID,
        taskID: id,
        report,
        target,
        logger
      });
      logger.info("Renovate run successfully finished");
    } catch (e) {
      logger.error("Renovate failed", errors.isError(e) ? e : {});
    }
  }
  async renovate({ id, target }, logger) {
    const { runtime, config: runtimeConfig } = index.getRuntimeConfigs(
      this.rootConfig
    );
    const wrapperRuntime = this.runtimes.get(runtime);
    if (is__default.default.nullOrUndefined(wrapperRuntime)) {
      throw new Error(`Unknown runtime type '${runtime}'`);
    }
    const env = {
      // setup logging
      LOG_FORMAT: "json",
      LOG_LEVEL: "debug",
      LOG_CONTEXT: id,
      RENOVATE_REPORT_TYPE: "logging",
      // setup platform specifics
      ...await index$1.getPlatformEnvs(target, {
        logger,
        rootConfig: this.rootConfig
      }),
      ...utils.getCacheEnvs(this.rootConfig, logger)
    };
    const renovateConfig = index.getRenovateConfig(this.rootConfig);
    const promise = wrapperRuntime.run({
      runID: id,
      env,
      renovateConfig,
      runtimeConfig,
      logger
    });
    return promise.then((result) => {
      return utils.extractReport({
        logger,
        logStream: result.stdout
      });
    });
  }
}

exports.RenovateRunner = RenovateRunner;
//# sourceMappingURL=renovateRunner.cjs.js.map