@razee/remoteresource/src/RemoteResourceGitController.js

RazeeDeploy: component to download and manage files

/**
 * Copyright 2022 IBM Corp. All Rights Reserved.
 *
 * 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.
 */

const loggerFactory = require('./bunyan-api');
const objectPath = require('object-path');
const RequestLib = require('@razee/request-util');
const clone = require('clone');
const hash = require('object-hash');

const { BaseDownloadController } = require('@razee/razeedeploy-core');


module.exports = class RemoteResourceGitController extends BaseDownloadController {
  constructor(params) {
    params.finalizerString = params.finalizerString || 'children.remoteresource.deploy.razee.io';
    params.logger = params.logger || loggerFactory.createLogger('RemoteResourceGitController');
    super(params);
  }
  // ============ Download From git repo ============

  async download(reqOpt) {
    this.log.debug(`Download ${reqOpt.uri || reqOpt.url}`);
    let opt = clone(reqOpt);
    opt.simple = false;
    opt.resolveWithFullResponse = true;

    delete opt.git; // `git` is not an expected request option

    this.log.info( `RemoteResourceGitController downloading ${opt.uri||opt.url}` );
    try {
      const retVal = await RequestLib.doRequest(opt, this.log);
      this.log.info( `RemoteResourceGitController download of ${opt.uri||opt.url} complete, status: ${retVal?.response?.statusCode}` );
      return retVal;
    }
    catch( e ) {
      this.log.warn( e, `RemoteResourceGitController error downloading ${opt.uri||opt.url}` );
      throw e;
    }
  }

  // ============ Git Specific Syntax ============
  async added() {
    const requests = objectPath.get(this.data, ['object', 'spec', 'requests'], []);
    const newRequests = [];
    for (let i = 0; i < requests.length; i++) {
      const req = requests[i];
      let reqOpt = clone(req.options);
      const optional = req.optional || false;
      const gitinfo = objectPath.get(req, 'options.git');

      if (gitinfo) {
        try {
          reqOpt = await this._fetchHeaderSecrets(reqOpt);
        } catch (e) {
          if (optional && e.code == 404) {
            this.log.warn(e.message);
            this.updateRazeeLogs('warn', { controller: 'RemoteResource', warn: e.message, repo: gitinfo.repo });
            this.log.debug(`skipping download for ${gitinfo.repo}`);
            continue;
          } else {
            return Promise.reject(e.message);
          }
        }

        const Git = require(`./git/${gitinfo.provider}`);
        const git = new Git(reqOpt);
        reqOpt = git.getAuthHeaders(reqOpt);
        try {
          let files = await RequestLib.doRequest({ method: 'get', uri: git.getReqUrl(), headers: reqOpt.headers }, this.log);
          files = JSON.parse(files);
          files = git.getFileArray(files);
          for (let j = 0; j < files.length; j++) {
            const url = git.getFileUrl(files[j]);
            if (url) {
              reqOpt = { ...reqOpt, url: url };
              reqOpt = git.getAddlHeaders(reqOpt);
              const newReq = clone(req);
              newReq.options = reqOpt;
              newReq.splitRequestId = hash(req);  // By setting splitRequestId, all requests split from a single original request will all be attempted before allowing failures to abort
              newRequests.push(newReq);
            }
          }
        } catch (e) {
          if (optional) {
            this.log.warn(e.message);
            this.updateRazeeLogs('warn', { controller: 'RemoteResource', warn: e.message, repo: gitinfo.repo });
            this.log.debug(`skipping download for ${gitinfo.repo}`);
            continue;
          } else {
            let errMessage = `Error retrieving ${git.getReqUrl()}, ${e.statusCode} -- ${e.message}`;

            // Get details from the response if possible
            if( e.content ) {
              try {
                const contentObj = JSON.parse( e.content );
                for( const prop of Object.getOwnPropertyNames( contentObj ) ) {
                  errMessage += `, ${prop}: ${contentObj[prop]}`;
                }
              }
              catch(e) {
                errMessage += `, ${e.content}`;
              }
            }

            return Promise.reject(errMessage);
          }
        }
      } else {
        newRequests.push(req);
      }
    }

    if (newRequests.length > 0) {
      objectPath.set(this.data, ['object', 'spec', 'requests'], newRequests);
      let result = await super.added();
      return result;
    } else {
      this.log.debug('No files found.');
    }
  }

  // ============ =================== ============

};