mirror of
https://github.com/serverless/serverless.git
synced 2026-01-18 14:58:43 +00:00
304 lines
8.0 KiB
JavaScript
304 lines
8.0 KiB
JavaScript
'use strict';
|
|
|
|
/**
|
|
* Action: EnvSet
|
|
* - Sets an environment variable based on the provide event
|
|
*
|
|
* Event Properties:
|
|
* - stage (String) a stage that exists in the project
|
|
* - region (String) a region that is defined in the provided stage
|
|
* - key (String) the env var key you want to set a value to
|
|
* - value (String) the env var value you want to set to the provided key
|
|
*/
|
|
|
|
const SPlugin = require('../ServerlessPlugin'),
|
|
SError = require('../ServerlessError'),
|
|
SCli = require('../utils/cli'),
|
|
path = require('path'),
|
|
BbPromise = require('bluebird'),
|
|
awsMisc = require('../utils/aws/Misc'),
|
|
SUtils = require('../utils');
|
|
|
|
/**
|
|
* EnvSet Class
|
|
*/
|
|
|
|
class EnvSet extends SPlugin {
|
|
|
|
/**
|
|
* Constructor
|
|
*/
|
|
|
|
constructor(S, config) {
|
|
super(S, config);
|
|
this.evt = {};
|
|
}
|
|
|
|
/**
|
|
* Define your plugins name
|
|
*/
|
|
|
|
static getName() {
|
|
return 'serverless.core.' + EnvSet.name;
|
|
}
|
|
|
|
/**
|
|
* Register Actions
|
|
*/
|
|
|
|
registerActions() {
|
|
this.S.addAction(this.envSet.bind(this), {
|
|
handler: 'envSet',
|
|
description: `set var value for stage and region. Region can be 'all'
|
|
usage: serverless env set`,
|
|
context: 'env',
|
|
contextAction: 'set',
|
|
options: [
|
|
{
|
|
option: 'region',
|
|
shortcut: 'r',
|
|
description: 'region you want to set env var in'
|
|
},
|
|
{
|
|
option: 'stage',
|
|
shortcut: 's',
|
|
description: 'stage you want to set env var in'
|
|
},
|
|
{
|
|
option: 'key',
|
|
shortcut: 'k',
|
|
description: 'the key of the env var you want to set'
|
|
},
|
|
{
|
|
option: 'value',
|
|
shortcut: 'v',
|
|
description: 'the value of the env var you want to set'
|
|
},
|
|
{
|
|
option: 'nonInteractive',
|
|
shortcut: 'i',
|
|
description: 'Optional - Turn off CLI interactivity if true. Default: false'
|
|
},
|
|
],
|
|
});
|
|
return BbPromise.resolve();
|
|
}
|
|
|
|
/**
|
|
* Action
|
|
*/
|
|
envSet(evt) {
|
|
let _this = this;
|
|
|
|
if(evt) {
|
|
_this.evt = evt;
|
|
_this.S._interactive = false;
|
|
}
|
|
|
|
// If CLI, parse arguments
|
|
if (_this.S.cli) {
|
|
_this.evt = _this.S.cli.options;
|
|
|
|
if (_this.S.cli.options.nonInteractive) {
|
|
_this.S._interactive = false;
|
|
}
|
|
}
|
|
|
|
return _this.S.validateProject()
|
|
.bind(_this)
|
|
.then(_this._promptKeyVal)
|
|
.then(_this._promptStage)
|
|
.then(_this._promptRegion)
|
|
.then(_this._validateAndPrepare)
|
|
.then(_this._setEnvVar)
|
|
.then(function() {
|
|
SCli.log('Successfully set env var: ' + _this.evt.key);
|
|
return BbPromise.resolve(_this.evt);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Prompt key & value if they're missing
|
|
*/
|
|
_promptKeyVal(){
|
|
let _this = this,
|
|
overrides = {};
|
|
|
|
if (!_this.S._interactive) return BbPromise.resolve();
|
|
|
|
['key', 'value'].forEach(memberVarKey => {
|
|
overrides[memberVarKey] = _this['evt'][memberVarKey];
|
|
});
|
|
|
|
let prompts = {
|
|
properties: {
|
|
key: {
|
|
description: 'Enter the key for the env var you want to set: '.yellow,
|
|
message: 'env var key is required.',
|
|
required: true,
|
|
},
|
|
value: {
|
|
description: 'Enter the value for the env var you want to set: '.yellow,
|
|
message: 'env var value is required',
|
|
required: true,
|
|
},
|
|
}
|
|
};
|
|
|
|
return _this.promptInput(prompts, overrides)
|
|
.then(function(answers) {
|
|
_this.evt.key = answers.key;
|
|
_this.evt.value = answers.value;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Prompt stage if it's missing
|
|
*/
|
|
_promptStage(){
|
|
let _this = this;
|
|
let stages = Object.keys(_this.S._projectJson.stages);
|
|
|
|
// Skip if non-interactive
|
|
if (!_this.S._interactive || _this.evt.stage) return BbPromise.resolve();
|
|
|
|
// if project has 1 stage, skip prompt
|
|
if (stages.length === 1) {
|
|
_this.evt.stage = stages[0];
|
|
return BbPromise.resolve();
|
|
}
|
|
// add local stage
|
|
stages.push('local');
|
|
|
|
// Create Choices
|
|
let choices = [];
|
|
for (let i = 0; i < stages.length; i++) {
|
|
choices.push({
|
|
key: (i + 1) + ') ',
|
|
value: stages[i],
|
|
label: stages[i],
|
|
});
|
|
}
|
|
|
|
return SCli.select('Which stage are you setting the env var in: ', choices, false)
|
|
.then(function(results) {
|
|
_this.evt.stage = results[0].value;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Prompt region if it's missing
|
|
*/
|
|
_promptRegion(){
|
|
let _this = this;
|
|
|
|
// skip region prompt if selected stage is 'local'
|
|
if (_this.evt.stage === 'local') {
|
|
_this.evt.region = 'local';
|
|
return BbPromise.resolve();
|
|
}
|
|
|
|
if (!_this.S._interactive || _this.evt.region) return BbPromise.resolve();
|
|
|
|
// TODO: list only regions defined in the provided stage
|
|
// this assumes that the provided stage is valid, we'll have to validate before getting here
|
|
let choices = awsMisc.validLambdaRegions.map(r => {
|
|
return {
|
|
key: '',
|
|
value: r,
|
|
label: r,
|
|
};
|
|
});
|
|
|
|
// adding all regions
|
|
choices.push(
|
|
{
|
|
key: '',
|
|
value: 'all',
|
|
label: 'all',
|
|
}
|
|
);
|
|
|
|
return _this.selectInput('Select a region for your new env var: ', choices, false)
|
|
.then(results => {
|
|
_this.evt.region = results[0].value;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Validate all data from event, interactive CLI or non interactive CLI
|
|
* and prepare data
|
|
*/
|
|
_validateAndPrepare(){
|
|
let _this = this;
|
|
|
|
// non interactive validation
|
|
if (!_this.S._interactive) {
|
|
// Check Params
|
|
if (!_this.evt.stage || !_this.evt.region || !_this.evt.key || !_this.evt.value) {
|
|
return BbPromise.reject(new SError('Missing stage and/or region and/or key'));
|
|
}
|
|
}
|
|
|
|
// validate stage: make sure stage exists
|
|
if (!_this.S._projectJson.stages[_this.evt.stage] && _this.evt.stage != 'local') {
|
|
return BbPromise.reject(new SError('Stage ' + _this.evt.stage + ' does not exist in your project', SError.errorCodes.UNKNOWN));
|
|
}
|
|
|
|
// skip the next validation if stage is 'local' & region is 'all'
|
|
if (_this.evt.stage != 'local' && _this.evt.region != 'all') {
|
|
|
|
// validate region: make sure region exists in stage
|
|
if (!_this.S._projectJson.stages[_this.evt.stage].some(function(r) {
|
|
return r.region == _this.evt.region;
|
|
})) {
|
|
return BbPromise.reject(new SError('Region "' + _this.evt.region + '" does not exist in stage "' + _this.evt.stage + '"'));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* set env var based on data validated
|
|
*/
|
|
_setEnvVar(){
|
|
let _this = this;
|
|
|
|
return awsMisc.getEnvFiles(this.S, _this.evt.region, _this.evt.stage)
|
|
.then(envMapsByRegion => {
|
|
let putEnvQ = [];
|
|
|
|
envMapsByRegion.forEach(mapForRegion => {
|
|
if (!mapForRegion.vars) { //someone could have del the .env file..
|
|
mapForRegion.vars = {};
|
|
}
|
|
|
|
mapForRegion.vars[_this.evt.key] = _this.evt.value;
|
|
|
|
let contents = '';
|
|
Object.keys(mapForRegion.vars).forEach(newKey => {
|
|
contents += [newKey, mapForRegion.vars[newKey]].join('=') + '\n';
|
|
});
|
|
|
|
if (_this.evt.stage == 'local') {
|
|
putEnvQ.push(SUtils.writeFile(path.join(this.S._projectRootPath, '.env'), contents));
|
|
} else {
|
|
|
|
let awsConfig = {
|
|
region: mapForRegion.regionName,
|
|
accessKeyId: _this.S._awsAdminKeyId,
|
|
secretAccessKey: _this.S._awsAdminSecretKey,
|
|
};
|
|
|
|
let S3 = require('../utils/aws/S3')(awsConfig);
|
|
let bucket = SUtils.getRegionConfig(_this.S._projectJson, _this.evt.stage, mapForRegion.regionName).regionBucket;
|
|
putEnvQ.push(S3.sPutEnvFile(bucket, _this.S._projectJson.name, _this.evt.stage, contents));
|
|
}
|
|
});
|
|
|
|
return BbPromise.all(putEnvQ);
|
|
});
|
|
}
|
|
}
|
|
|
|
module.exports = EnvSet;
|