mirror of
https://github.com/serverless/serverless.git
synced 2026-01-18 14:58:43 +00:00
336 lines
8.6 KiB
JavaScript
336 lines
8.6 KiB
JavaScript
'use strict';
|
|
|
|
/**
|
|
* Action: Function Deploy
|
|
* - Collects, validates, prepares user data
|
|
* - Controls multi-region deployment sequentially
|
|
*/
|
|
|
|
const JawsPlugin = require('../../JawsPlugin'),
|
|
JawsError = require('../../jaws-error'),
|
|
JawsUtils = require('../../utils/index'),
|
|
BbPromise = require('bluebird'),
|
|
async = require('async'),
|
|
path = require('path'),
|
|
fs = require('fs'),
|
|
os = require('os');
|
|
|
|
// Promisify fs module
|
|
BbPromise.promisifyAll(fs);
|
|
|
|
class FunctionDeploy extends JawsPlugin {
|
|
|
|
/**
|
|
* Constructor
|
|
*/
|
|
|
|
constructor(Jaws, config) {
|
|
super(Jaws, config);
|
|
}
|
|
|
|
/**
|
|
* Get Name
|
|
*/
|
|
|
|
static getName() {
|
|
return 'jaws.core.' + FunctionDeploy.name;
|
|
}
|
|
|
|
/**
|
|
* Register Plugin Actions
|
|
*/
|
|
|
|
registerActions() {
|
|
|
|
this.Jaws.addAction(this.functionDeploy.bind(this), {
|
|
handler: 'functionDeploy',
|
|
description: 'Deploys the code or endpoint of a function, or both',
|
|
context: 'function',
|
|
contextAction: 'queued',
|
|
options: [
|
|
{
|
|
option: 'stage',
|
|
shortcut: 's',
|
|
description: 'Optional if only one stage is defined in project'
|
|
}, {
|
|
option: 'region',
|
|
shortcut: 'r',
|
|
description: 'Optional if only one region is defined in stage'
|
|
}, {
|
|
option: 'noExeCf',
|
|
shortcut: 'c',
|
|
description: 'Don\'t execute CloudFormation, just generate it',
|
|
},
|
|
],
|
|
});
|
|
|
|
// TODO: Add "all" option
|
|
|
|
return BbPromise.resolve();
|
|
}
|
|
|
|
/**
|
|
* Function Deploy
|
|
*/
|
|
|
|
functionDeploy(evt) {
|
|
|
|
let _this = this;
|
|
_this.evt = {};
|
|
_this.evt.queued = {};
|
|
_this.evt.queued.type = evt.type ? evt.type : null;
|
|
_this.evt.queued.stage = evt.stage ? evt.stage : null;
|
|
_this.evt.queued.regions = evt.region ? [evt.region] : [];
|
|
_this.evt.queued.noExeCf = (evt.noExeCf == true || evt.noExeCf == 'true');
|
|
_this.evt.queued.paths = evt.paths ? evt.paths : [];
|
|
_this.evt.queued.functions = [];
|
|
_this.evt.uploaded = {};
|
|
|
|
// Flow
|
|
return BbPromise.try(function() {})
|
|
.bind(_this)
|
|
.then(_this._validateAndPrepare)
|
|
.then(_this._promptStage)
|
|
.then(_this._deployRegions)
|
|
.then(function() {
|
|
console.log("DONE: ", _this.evt);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Validate And Prepare
|
|
* - If CLI, maps CLI input to event object
|
|
*/
|
|
|
|
_validateAndPrepare() {
|
|
|
|
let _this = this;
|
|
|
|
// If cli, process command line input
|
|
if (_this.Jaws.cli) {
|
|
|
|
// Add type. Should be first in array
|
|
_this.evt.queued.type = _this.Jaws.cli.params[0];
|
|
|
|
// Add function paths. Should be all other array items
|
|
_this.Jaws.cli.params.splice(0,1);
|
|
_this.evt.queued.paths = _this.Jaws.cli.params;
|
|
}
|
|
|
|
// Validate type
|
|
if (!_this.evt.queued.type ||
|
|
(_this.evt.queued.type !== 'code' &&
|
|
_this.evt.queued.type !== 'endpoint' &&
|
|
_this.evt.queued.type !== 'all')
|
|
) {
|
|
throw new JawsError(`Invalid type. Must be "code", "endpoint", or "all" `);
|
|
}
|
|
|
|
// Validate stage
|
|
if (!this.evt.queued.stage) {
|
|
throw new JawsError(`Stage is required`);
|
|
}
|
|
|
|
// If no region specified, deploy to all regions in stage
|
|
if (!_this.evt.queued.regions.length) {
|
|
_this.evt.queued.regions = _this.Jaws._projectJson.stages[_this.evt.queued.stage].map(rCfg => {
|
|
return rCfg.region;
|
|
});
|
|
}
|
|
|
|
JawsUtils.jawsDebug('Queued regions: ' + _this.evt.queued.regions);
|
|
|
|
// If no functions, check cwd and resolve that path
|
|
return JawsUtils.getFunctions(
|
|
_this.Jaws._projectRootPath,
|
|
_this.evt.queued.paths && _this.evt.queued.paths.length ? _this.evt.queued.paths : null
|
|
)
|
|
.bind(_this)
|
|
.then(function(functions) {
|
|
|
|
// If no functions, throw error
|
|
if (!functions || !functions.length) {
|
|
throw new JawsError(`No function found. Make sure your current working directory is a function.`);
|
|
}
|
|
|
|
// Set queued functions
|
|
_this.evt.queued.functions = functions;
|
|
})
|
|
.then(function() {
|
|
|
|
if (_this.evt.queued.type === 'code') return;
|
|
|
|
// If type is "endpoint" or "all", collect endpoints
|
|
return JawsUtils.getEndpoints(_this.evt.queued.functions);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Prompt Stage
|
|
*/
|
|
|
|
_promptStage() {
|
|
|
|
let _this = this,
|
|
stages = [];
|
|
|
|
if (!_this.evt.queued.stage) {
|
|
|
|
stages = Object.keys(_this.Jaws._projectJson.stage);
|
|
|
|
// If project only has 1 stage, skip prompt
|
|
if (stages.length === 1) _this.evt.queued.stage = stages[0];
|
|
|
|
} else {
|
|
|
|
// If user provided stage, skip prompt
|
|
return BbPromise.resolve();
|
|
}
|
|
|
|
// Create Choices
|
|
let choices = [];
|
|
for (let i = 0; i < stages.length; i++) {
|
|
choices.push({
|
|
key: '',
|
|
value: stages[i],
|
|
label: stages[i],
|
|
});
|
|
}
|
|
|
|
// Show prompt
|
|
return _this.selectInput('Function Deployer - Choose a stage: ', choices, false)
|
|
.then(results => {
|
|
_this.evt.queued.stage = results[0].value;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Deploy Regions
|
|
*/
|
|
|
|
_deployRegions() {
|
|
|
|
let _this = this;
|
|
return BbPromise.try(function() {
|
|
return _this.evt.queued.regions;
|
|
})
|
|
.bind(_this)
|
|
.each(function(region) {
|
|
|
|
// Deploy Type
|
|
switch(_this.evt.queued.type) {
|
|
|
|
// Deploy Endpoint only
|
|
case "endpoint":
|
|
return _this._deployEndpointByRegion(region);
|
|
break;
|
|
// Deploy Code only
|
|
case "code":
|
|
return _this._processCodeByRegion(region);
|
|
break;
|
|
// Deploy Code then Endpoint
|
|
case "all":
|
|
break;
|
|
// Default
|
|
default:
|
|
return BbPromise.resolve();
|
|
}
|
|
})
|
|
.then(_this._provisionCodeAllRegions);
|
|
}
|
|
|
|
/**
|
|
* Deploy Code By Region
|
|
* @region
|
|
*/
|
|
|
|
_processCodeByRegion(region) {
|
|
|
|
let _this = this;
|
|
|
|
return new BbPromise(function(resolve, reject) {
|
|
|
|
// Create uploaded array for this region
|
|
_this.evt.uploaded[region] = [];
|
|
|
|
// Package & Upload functions' code concurrently
|
|
// Package must be redone for each region because ENV vars are set for each region
|
|
async.eachLimit(_this.evt.queued.functions, 5, function(func, cb) {
|
|
|
|
// Create new evt object for concurrent operations
|
|
let newEvent = {
|
|
stage: _this.evt.queued.stage,
|
|
region: JawsUtils.getProjRegionConfigForStage(
|
|
_this.Jaws._projectJson,
|
|
_this.evt.queued.stage,
|
|
region),
|
|
function: func,
|
|
};
|
|
|
|
// TODO: Read runtime of func
|
|
// TODO: Deploy by runtime
|
|
|
|
// Process sub-Actions
|
|
return _this.Jaws.actions.codePackageLambdaNodejs(newEvent)
|
|
.bind(_this)
|
|
.then(_this.Jaws.actions.codeCompressLambdaNodejs)
|
|
.then(_this.Jaws.actions.codeUploadLambdaNodejs)
|
|
.then(function(evt) {
|
|
// Add Function and Region
|
|
_this.evt.uploaded[region].push(evt.function);
|
|
return cb();
|
|
});
|
|
|
|
}, resolve);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Provision Code All Regions
|
|
* - Initiates CloudFormation Stack Create/Update in all Regions Concurrently
|
|
*/
|
|
|
|
_provisionCodeAllRegions() {
|
|
|
|
let _this = this;
|
|
|
|
return new BbPromise(function(resolve, reject) {
|
|
|
|
// If type is "endpoint", skip
|
|
if (_this.evt.queued.type === 'endpoint') return resolve();
|
|
|
|
// If type is "code" or "all", do concurrent, multi-region, CF update
|
|
async.eachLimit(Object.keys(_this.evt.uploaded), 5, function(region, cb) {
|
|
|
|
let newEvent = {
|
|
stage: _this.evt.queued.stage,
|
|
region: JawsUtils.getProjRegionConfigForStage(
|
|
_this.Jaws._projectJson,
|
|
_this.evt.queued.stage,
|
|
region),
|
|
functions: _this.evt.uploaded[region],
|
|
};
|
|
|
|
return _this.Jaws.actions.codeProvisionLambdaNodejs(newEvent)
|
|
.then(cb);
|
|
|
|
}, function() {
|
|
return resolve();
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Deploy Endpoint By Region
|
|
*/
|
|
// TODO: MAKE EVT CLONE
|
|
// TODO: Handle API Gateway Throttling Errors
|
|
_deployEndpointByRegion() {
|
|
let _this = this;
|
|
return _this.Jaws.actions.endpointPackageApiGateway(evtClone)
|
|
.bind(_this)
|
|
.then(_this.Jaws.actions.endpointProvisionApiGateway);
|
|
}
|
|
}
|
|
|
|
module.exports = FunctionDeploy; |