'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.ExecutorJenkins = undefined;

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _jenkins = require('jenkins');

var _jenkins2 = _interopRequireDefault(_jenkins);

var _Executor2 = require('../agent/Executor');

var _AgentUtils = require('../agent/AgentUtils');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var log = _AgentUtils.AgentUtils.logger();

/**
 * Sample .githubTaskManager.json task config/
 *
 * see: https://github.com/wyvern8/github-task-manager/wiki/Structure-of-.githubTaskManager.json
 *
 * {
        "executor": "Jenkins",
        "context": "Build and deploy",
        "options": {
          "jobName": "JENKINS_JOBNAME",
          "parameters": {
            "ENVIRONMENT" : "env_dev"
        }
    }
 */

var ExecutorJenkins = exports.ExecutorJenkins = function (_Executor) {
    (0, _inherits3.default)(ExecutorJenkins, _Executor);

    function ExecutorJenkins(eventData) {
        (0, _classCallCheck3.default)(this, ExecutorJenkins);

        var _this = (0, _possibleConstructorReturn3.default)(this, (ExecutorJenkins.__proto__ || (0, _getPrototypeOf2.default)(ExecutorJenkins)).call(this, eventData));

        _this.options = _this.getOptions();

        // If set, this will return bool:true, else bool:false
        var useCsrf = _this.options.GTM_JENKINS_CSRF === 'true';

        _this.jenkins = (0, _jenkins2.default)({
            baseUrl: _AgentUtils.AgentUtils.formatBasicAuth(_this.options.GTM_JENKINS_USER, _this.options.GTM_JENKINS_TOKEN, _this.options.GTM_JENKINS_URL),
            crumbIssuer: useCsrf,
            promisify: true
        });
        return _this;
    }

    (0, _createClass3.default)(ExecutorJenkins, [{
        key: 'waitForBuildToExist',
        value: function () {
            var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3(buildName, buildNumber) {
                var _this2 = this;

                return _regenerator2.default.wrap(function _callee3$(_context3) {
                    while (1) {
                        switch (_context3.prev = _context3.next) {
                            case 0:
                                return _context3.abrupt('return', new _promise2.default(function () {
                                    var _ref2 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2(resolve, reject) {
                                        var exists, maxRetries, tries;
                                        return _regenerator2.default.wrap(function _callee2$(_context2) {
                                            while (1) {
                                                switch (_context2.prev = _context2.next) {
                                                    case 0:
                                                        exists = false;
                                                        maxRetries = 600;
                                                        tries = 0;

                                                    case 3:
                                                        if (!(!exists && tries++ < maxRetries)) {
                                                            _context2.next = 9;
                                                            break;
                                                        }

                                                        _context2.next = 6;
                                                        return _this2.jenkins.build.get(buildName, buildNumber).then(function () {
                                                            log.info('Build ' + buildName + ' #' + buildNumber + ' Started!');
                                                            return true;
                                                        }, (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
                                                            return _regenerator2.default.wrap(function _callee$(_context) {
                                                                while (1) {
                                                                    switch (_context.prev = _context.next) {
                                                                        case 0:
                                                                            log.debug('Build ' + buildName + ' #' + buildNumber + ' Hasn\'t Started: ' + tries);
                                                                            _context.next = 3;
                                                                            return _AgentUtils.AgentUtils.timeout(10000);

                                                                        case 3:
                                                                            return _context.abrupt('return', false);

                                                                        case 4:
                                                                        case 'end':
                                                                            return _context.stop();
                                                                    }
                                                                }
                                                            }, _callee, this);
                                                        })));

                                                    case 6:
                                                        exists = _context2.sent;
                                                        _context2.next = 3;
                                                        break;

                                                    case 9:
                                                        exists ? resolve(true) : reject();

                                                    case 10:
                                                    case 'end':
                                                        return _context2.stop();
                                                }
                                            }
                                        }, _callee2, _this2);
                                    }));

                                    return function (_x3, _x4) {
                                        return _ref2.apply(this, arguments);
                                    };
                                }()));

                            case 1:
                            case 'end':
                                return _context3.stop();
                        }
                    }
                }, _callee3, this);
            }));

            function waitForBuildToExist(_x, _x2) {
                return _ref.apply(this, arguments);
            }

            return waitForBuildToExist;
        }()
    }, {
        key: 'waitForBuild',
        value: function () {
            var _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee4(buildName, buildNumber) {
                var buildDict, tries;
                return _regenerator2.default.wrap(function _callee4$(_context4) {
                    while (1) {
                        switch (_context4.prev = _context4.next) {
                            case 0:
                                _context4.next = 2;
                                return this.jenkins.build.get(buildName, buildNumber).then(function (data) {
                                    return data;
                                });

                            case 2:
                                buildDict = _context4.sent;
                                tries = 1;

                            case 4:
                                if (!(buildDict.result === null)) {
                                    _context4.next = 12;
                                    break;
                                }

                                _context4.next = 7;
                                return _AgentUtils.AgentUtils.timeout(5000);

                            case 7:
                                _context4.next = 9;
                                return this.jenkins.build.get(buildName, buildNumber).then(function (data) {
                                    log.debug('Waiting for Build \'' + buildName + '\' to Finish: ' + tries++);
                                    return data;
                                });

                            case 9:
                                buildDict = _context4.sent;
                                _context4.next = 4;
                                break;

                            case 12:
                                log.info('Build Finished: ' + buildName + ' #' + buildNumber + ' - ' + buildDict.result);
                                return _context4.abrupt('return', buildDict);

                            case 14:
                            case 'end':
                                return _context4.stop();
                        }
                    }
                }, _callee4, this);
            }));

            function waitForBuild(_x5, _x6) {
                return _ref4.apply(this, arguments);
            }

            return waitForBuild;
        }()
    }, {
        key: 'buildNumberfromQueue',
        value: function () {
            var _ref5 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee5(queueId) {
                var queueData;
                return _regenerator2.default.wrap(function _callee5$(_context5) {
                    while (1) {
                        switch (_context5.prev = _context5.next) {
                            case 0:
                                _context5.next = 2;
                                return this.jenkins.queue.item(queueId).then(function (data) {
                                    return data;
                                });

                            case 2:
                                queueData = _context5.sent;

                            case 3:
                                if (queueData.executable) {
                                    _context5.next = 12;
                                    break;
                                }

                                try {
                                    log.info('Build Not Ready: ' + queueData.why);
                                } catch (error) {
                                    log.warn('Build Not Ready: No Reason Provided. Retrying in 3 seconds...');
                                }
                                _context5.next = 7;
                                return _AgentUtils.AgentUtils.timeout(3000);

                            case 7:
                                _context5.next = 9;
                                return this.jenkins.queue.item(queueId).then(function (data) {
                                    return data;
                                });

                            case 9:
                                queueData = _context5.sent;
                                _context5.next = 3;
                                break;

                            case 12:
                                return _context5.abrupt('return', queueData.executable.number);

                            case 13:
                            case 'end':
                                return _context5.stop();
                        }
                    }
                }, _callee5, this);
            }));

            function buildNumberfromQueue(_x7) {
                return _ref5.apply(this, arguments);
            }

            return buildNumberfromQueue;
        }()
    }, {
        key: 'executeTask',
        value: function () {
            var _ref6 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee6(task) {
                var jobName, buildParams, queueNumber, buildNumber, buildExists, result, resultBool;
                return _regenerator2.default.wrap(function _callee6$(_context6) {
                    while (1) {
                        switch (_context6.prev = _context6.next) {
                            case 0:
                                jobName = task.options.jobName || null;
                                buildParams = task.options.parameters || null;

                                if (!(jobName == null || buildParams == null)) {
                                    _context6.next = 7;
                                    break;
                                }

                                _context6.next = 5;
                                return _AgentUtils.AgentUtils.timeout(4000);

                            case 5:
                                task.results = {
                                    passed: false,
                                    url: this.options.GTM_JENKINS_URL,
                                    message: 'Required Parameters not Specified for ' + jobName
                                };
                                return _context6.abrupt('return', _promise2.default.reject(task));

                            case 7:

                                log.debug(buildParams);

                                log.info('Starting Jenkins Job: ' + jobName);
                                // TODO: Check if Job Exists
                                _context6.next = 11;
                                return this.jenkins.job.build({
                                    name: jobName,
                                    parameters: buildParams
                                });

                            case 11:
                                queueNumber = _context6.sent;
                                _context6.next = 14;
                                return this.buildNumberfromQueue(queueNumber);

                            case 14:
                                buildNumber = _context6.sent;
                                _context6.next = 17;
                                return this.waitForBuildToExist(jobName, buildNumber);

                            case 17:
                                buildExists = _context6.sent;

                                console.debug(buildExists);
                                _context6.next = 21;
                                return this.waitForBuild(jobName, buildNumber);

                            case 21:
                                result = _context6.sent;
                                resultBool = result.result === 'SUCCESS';


                                task.results = {
                                    passed: resultBool,
                                    url: result.url,
                                    message: jobName + ' #' + buildNumber + ' - ' + result.result,
                                    meta: {
                                        jobName: jobName,
                                        buildNumber: buildNumber
                                    }
                                };

                                return _context6.abrupt('return', resultBool ? _promise2.default.resolve(task) : _promise2.default.reject(task));

                            case 25:
                            case 'end':
                                return _context6.stop();
                        }
                    }
                }, _callee6, this);
            }));

            function executeTask(_x8) {
                return _ref6.apply(this, arguments);
            }

            return executeTask;
        }()
    }]);
    return ExecutorJenkins;
}(_Executor2.Executor);

_Executor2.Executor.register('Jenkins', ExecutorJenkins);