kef-cloudbuild-runner/lib/build.js

runner for cloudbuild

'use strict';

const path = require('path');
const s_log = require('./log');
const fs = require('fs-extra');

// 获取构建配置；先从传入的 buildConf 获取，后续改为直接从 abc.json 读
exports.getCommand = function* (options) {
  const type = options.buildType; // 1.builder 2.command

  let cmd;
  if (type == 1) {
    cmd = yield getCommandBuilder(options);
  } else if (type == 2) {
    cmd = yield getCommandCmd(options);
  } else {
    throw Error("错误的 buildType");
  };

  return cmd;
};

function* getCommandBuilder(options) {
  const pkgPath = path.join(options.builderDir, 'package.json');
  const stat = yield fs.stat(pkgPath).catch(e => e);
  if (stat instanceof Error) {
    throw Error(`${options.builderDir} 路径下没有找到构建器，请联系管理员`);
  };
  const pkg = require(pkgPath);

  s_log.info(`构建器版本：${pkg.version}`)

  if (pkg.keywords && pkg.keywords.length && pkg.keywords.indexOf('cloudbuild') !== -1 && process.platform != 'win32') {
    s_log.info(`export getCommandBuilderNew`);
    // 新版构建器
    return exports.getCommandBuilderNew(options);
  } else {
    s_log.info(`export getCommandBuilderOld`);
    return exports.getCommandBuilderOld(options);
  }
};

function* getCommandCmd(options) {
  const cmd = JSON.parse(options.buildCmd);
  if (!cmd || !cmd.length) {
    throw Error('未获取到构建命令');
  }
  s_log.info(`构建命令：/bin/bash -c ${cmd.join('&&')}`);
  return ['/bin/bash', ['-c', cmd.join('&&')]]
};

// 运行构建任务
exports.run = function* (projectDir, cmds, env) {
  return new Promise((resolve, reject) => {
    s_log.info('project dir is', projectDir);
    const spawn = require('cross-spawn');
    s_log.info('开始执行构建');
    // bin/bash XXX/builder-xxx/build.sh 用env去执行build.sh
    const child = spawn(cmds[0], cmds[1], {
      stdio: 'inherit',
      cwd: projectDir, // 执行目录为项目目录
      env: Object.assign({}, process.env, env) // 环境变量
    });
    child.on('error', reject);
    child.on('exit', function (code) {
      if (code !== 0) {
        s_log.error(`构建出错，exit with code: ${code}`);
        process.exit(code);
      } else {
        resolve();
      }
    });
  })
};

// 构建器 2.0 规范
exports.getCommandBuilderNew = function (options) {
  // build.sh 脚本地址，完全依赖build.sh去执行
  const mainPath = path.join(options.builderDir, 'build.sh');

  s_log.info(`构建命令：/bin/bash ${mainPath}`);

  return ['/bin/bash', [mainPath]]
};

// 构建器 1.0 规范
exports.getCommandBuilderOld = function (options) {
  s_log.info(`构建器规范过旧，待升级`);

  const builderDir = options.builderDir;

  const gulpFile = path.join(builderDir, 'gulpfile.js');
  const gruntFile = path.join(builderDir, 'Gruntfile.js');
  const packageJson = path.join(builderDir, 'package.json');

  var cmd, args = [];

  if (fs.existsSync(gulpFile)) {
    // gulp 构建
    cmd = 'gulp';
    args.push('--gulpfile', gulpFile);
  } else if (fs.existsSync(gruntFile)) {
    // grunt 构建
    cmd = 'grunt';
    args.push('--force');
    args.push('--gruntfile', gruntFile);
  } else if (fs.existsSync(packageJson)) {
    // 根据 npm 模块的 package.json 文件的 main 字段指定的文件来确定运行的文件
    var mainJS = require(packageJson).main;
    if (!mainJS || !fs.existsSync(path.join(builderDir, mainJS))) {
      return res_obj('构建器 package.json main 字段指定脚本未找到');
    }
    cmd = 'node';
    args.push(path.join(path.join(builderDir, mainJS)));
  } else {
    return res_obj('构建器错误：未找到构建脚本 - ' + builderDir);
  }

  // 传递用户参数
  args = args.concat(JSON.parse(options.buildArgv));

  // 传入仓库相关信息，这个考虑下后面要不要去掉
  args.push('--repo', `git@gitlab.alibaba-inc.com:${options.gitGroup}/${options.gitProject}.git`);
  args.push('--branch', options.gitBranch);
  args.push('--cwd', options.projectDir);
  args.push('--empId', options.user);
  args.push('--author', options.user);
  args.push('--buildTo', path.join(options.projectDir, options.buildDest));

  s_log.info(`构建命令：${cmd} ${args.join(" ")}`);
  
  return [cmd, args];
};