mirror of
https://github.com/serverless/serverless.git
synced 2026-01-18 14:58:43 +00:00
515 lines
18 KiB
JavaScript
515 lines
18 KiB
JavaScript
'use strict';
|
|
|
|
/**
|
|
* Action: ProjectInstall
|
|
* - Takes an existing project and sets a new default "development" stage
|
|
* - Validates the received data
|
|
* - Generates scaffolding for the new project in CWD
|
|
* - Creates a new project S3 bucket and puts env and CF files
|
|
* - Creates CF stack by default, unless noExeCf option is set to true
|
|
* - Generates project JSON files
|
|
*
|
|
* Options:
|
|
* - name (String) a name for new project
|
|
* - domain (String) a domain for new project to create the bucket name with
|
|
* - notificationEmail (String) email to use for AWS alarms
|
|
* - profile (String) an AWS profile to create the project in. Must be available in ~/.aws/credentials
|
|
* - region (String) the first region for your new project
|
|
* - noExeCf: (Boolean) Don't execute CloudFormation
|
|
*/
|
|
|
|
module.exports = function(SPlugin, serverlessPath) {
|
|
|
|
const path = require('path'),
|
|
SError = require( path.join( serverlessPath, 'ServerlessError' ) ),
|
|
SCli = require( path.join( serverlessPath, 'utils/cli' ) ),
|
|
SUtils = require( path.join( serverlessPath, 'utils' ) ),
|
|
os = require('os'),
|
|
fs = require('fs'),
|
|
fse = require('fs-extra'),
|
|
BbPromise = require('bluebird'),
|
|
awsMisc = require( path.join( serverlessPath, 'utils/aws/Misc' ) );
|
|
|
|
BbPromise.promisifyAll(fs);
|
|
|
|
/**
|
|
* ProjectInstall Class
|
|
*/
|
|
|
|
class ProjectInstall extends SPlugin {
|
|
|
|
constructor(S, config) {
|
|
super(S, config);
|
|
}
|
|
|
|
static getName() {
|
|
return 'serverless.core.' + ProjectInstall.name;
|
|
}
|
|
|
|
registerActions() {
|
|
this.S.addAction(this.installProject.bind(this), {
|
|
handler: 'projectInstall',
|
|
description: 'Installs an existing Serverless project',
|
|
context: 'project',
|
|
contextAction: 'install',
|
|
options: [
|
|
{
|
|
option: 'name',
|
|
shortcut: 'n',
|
|
description: 'Name of your new Serverless project'
|
|
}, {
|
|
option: 'domain',
|
|
shortcut: 'd',
|
|
description: 'Domain of your new Serverless project'
|
|
}, {
|
|
option: 'region',
|
|
shortcut: 'r',
|
|
description: 'Lambda supported region'
|
|
}, {
|
|
option: 'notificationEmail',
|
|
shortcut: 'e',
|
|
description: 'email to use for AWS alarms'
|
|
}, {
|
|
option: 'profile', // we need profile option for CLI API (non interactive)
|
|
shortcut: 'p',
|
|
description: 'AWS profile that is set in your aws config file'
|
|
}, {
|
|
option: 'noExeCf',
|
|
shortcut: 'c',
|
|
description: 'Optional - Don\'t execute CloudFormation, just generate it. Default: false'
|
|
}
|
|
],
|
|
parameters: [
|
|
{
|
|
parameter: 'project',
|
|
description: 'The project you wish to install',
|
|
position: '0'
|
|
}
|
|
]
|
|
});
|
|
return BbPromise.resolve();
|
|
}
|
|
|
|
/**
|
|
* Action
|
|
*/
|
|
|
|
installProject(evt) {
|
|
|
|
let _this = this;
|
|
this.evt = evt;
|
|
this._templatesDir = path.join(__dirname, '..', 'templates');
|
|
|
|
// Check for AWS Profiles
|
|
let profilesList = awsMisc.profilesMap();
|
|
this.profiles = Object.keys(profilesList);
|
|
|
|
// Validate: Check for project name
|
|
if (!_this.evt.options.project) {
|
|
return BbPromise.reject(new SError(`Please enter the name of the project you wish to install, like: serverless install project <projectname>`));
|
|
}
|
|
|
|
/**
|
|
* Control Flow
|
|
*/
|
|
|
|
return BbPromise.try(function() {
|
|
console.log('');
|
|
SCli.log('Installing Serverless Project "' + _this.evt.options.project + '"...');
|
|
})
|
|
.bind(_this)
|
|
.then(_this._prompt)
|
|
.then(_this._validateAndPrepare)
|
|
.then(_this._installProject)
|
|
.then(_this._createProjectBucket)
|
|
.then(_this._updateScaffolding)
|
|
.then(_this._createStageAndRegion)
|
|
.then(function() {
|
|
|
|
SCli.log('Successfully installed project "'
|
|
+ _this.evt.options.project
|
|
+ '" which has been renamed to "'
|
|
+ _this.evt.options.name
|
|
+'"');
|
|
|
|
SCli.log('P.S. Don\'t forget to install the npm dependencies in each of this project\'s components');
|
|
|
|
/**
|
|
* Return EVT
|
|
*/
|
|
|
|
_this.evt.data.projectPath = _this.S.config.projectPath;
|
|
return _this.evt;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Prompt
|
|
*/
|
|
|
|
_prompt() {
|
|
|
|
let _this = this;
|
|
|
|
// Set temp name
|
|
let name = _this.evt.options.name || ('serverless' + SUtils.generateShortId(6)).toLowerCase();
|
|
|
|
// Skip if non-interactive
|
|
if (!_this.S.config.interactive) return BbPromise.resolve();
|
|
|
|
// Values that exist will not be prompted
|
|
let overrides = {
|
|
name: _this.evt.options.name,
|
|
domain: _this.evt.options.domain,
|
|
notificationEmail: _this.evt.options.notificationEmail,
|
|
awsAdminKeyId: _this.evt.options.awsAdminKeyId,
|
|
awsAdminSecretKey: _this.evt.options.awsAdminSecretKey
|
|
};
|
|
|
|
let prompts = {
|
|
properties: {
|
|
name: {
|
|
description: 'Enter a custom name for this project: '.yellow,
|
|
default: name,
|
|
message: 'Name must be only letters, numbers or dashes',
|
|
required: true,
|
|
conform: function(name) {
|
|
let re = /^[a-zA-Z0-9-_]+$/;
|
|
|
|
// This hack updates the defaults in the other prompts
|
|
if (re.test(name)) _this.evt.options.name = name;
|
|
|
|
return re.test(name);
|
|
}
|
|
},
|
|
domain: {
|
|
description: 'Enter a custom domain for this project (used for the Serverless Project Bucket): '.yellow,
|
|
default: name + '.com',
|
|
message: 'Domain must only contain lowercase letters, numbers, periods and dashes',
|
|
required: true,
|
|
conform: function(bucket) {
|
|
let re = /^[a-z0-9-.]+$/;
|
|
return re.test(bucket);
|
|
}
|
|
},
|
|
notificationEmail: {
|
|
description: 'Enter an email to use for AWS alarms: '.yellow,
|
|
required: true,
|
|
message: 'Please enter a valid email',
|
|
default: 'me@' + name + '.com',
|
|
conform: function(email) {
|
|
let re = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i;
|
|
return re.test(email);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
if (!_this.profiles || !_this.profiles.length) {
|
|
|
|
prompts.properties.awsAdminKeyId = {
|
|
description: 'Enter the ACCESS KEY ID for your Admin AWS IAM User: '.yellow,
|
|
required: true,
|
|
message: 'Please enter a valid access key ID',
|
|
conform: function(key) {
|
|
return (key) ? true : false;
|
|
}
|
|
};
|
|
|
|
prompts.properties.awsAdminSecretKey = {
|
|
description: 'Enter the SECRET ACCESS KEY for your Admin AWS IAM User: '.yellow,
|
|
required: true,
|
|
message: 'Please enter a valid secret access key',
|
|
conform: function(key) {
|
|
return (key) ? true : false;
|
|
}
|
|
};
|
|
}
|
|
|
|
return this.cliPromptInput(prompts, overrides)
|
|
.then(function(answers) {
|
|
|
|
// Set prompt values
|
|
_this.S.config.awsAdminKeyId = answers.awsAdminKeyId;
|
|
_this.S.config.awsAdminSecretKey = answers.awsAdminSecretKey;
|
|
_this.evt.options.name = answers.name;
|
|
_this.evt.options.domain = answers.domain;
|
|
_this.evt.options.notificationEmail = answers.notificationEmail;
|
|
|
|
// Show region prompt
|
|
if (!_this.evt.options.region) {
|
|
|
|
// Prompt: region select
|
|
let choices = awsMisc.validLambdaRegions.map(r => {
|
|
return {
|
|
key: '',
|
|
value: r,
|
|
label: r
|
|
};
|
|
});
|
|
|
|
return _this.cliPromptSelect('Select a region for your project: ', choices, false)
|
|
.then(results => {
|
|
_this.evt.options.region = results[0].value;
|
|
});
|
|
}
|
|
})
|
|
.then(function() {
|
|
|
|
// If profile exists, skip select prompt
|
|
if (_this.profile) return;
|
|
|
|
// If aws credentials were passed, skip select prompt
|
|
if (_this.S.config.awsAdminKeyId && _this.S.config.awsAdminSecretKey) return;
|
|
|
|
// Prompt: profile select
|
|
let choices = [];
|
|
for (let i = 0; i < _this.profiles.length; i++) {
|
|
choices.push({
|
|
key: '',
|
|
value: _this.profiles[i],
|
|
label: _this.profiles[i]
|
|
});
|
|
}
|
|
|
|
return _this.cliPromptSelect('Select an AWS profile for your project: ', choices, false)
|
|
.then(results => {
|
|
_this.profile = results[0].value;
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Validate & Prepare
|
|
* - Validate all data from event, interactive CLI or non interactive CLI and prepare project data
|
|
*/
|
|
|
|
_validateAndPrepare() {
|
|
|
|
// Initialize AWS Misc Service
|
|
this.AwsMisc = require('../utils/aws/Misc');
|
|
|
|
// If Profile, extract API Keys
|
|
if (this.profile) {
|
|
this.S.config.awsAdminKeyId = this.AwsMisc.profilesGet(this.profile)[this.profile].aws_access_key_id;
|
|
this.S.config.awsAdminSecretKey = this.AwsMisc.profilesGet(this.profile)[this.profile].aws_secret_access_key;
|
|
}
|
|
|
|
// Validate API Keys
|
|
if (!this.S.config.awsAdminKeyId || !this.S.config.awsAdminSecretKey) {
|
|
return BbPromise.reject(new SError('Missing AWS API Key and/or AWS Secret Key'));
|
|
}
|
|
|
|
// Initialize Other AWS Services
|
|
let awsConfig = {
|
|
region: this.evt.options.region,
|
|
accessKeyId: this.S.config.awsAdminKeyId,
|
|
secretAccessKey: this.S.config.awsAdminSecretKey
|
|
};
|
|
this.S3 = require('../utils/aws/S3')(awsConfig);
|
|
this.CF = require('../utils/aws/CloudFormation')(awsConfig);
|
|
|
|
// Validate Name - AWS only allows Alphanumeric and - in name
|
|
let nameOk = /^([a-zA-Z0-9-]+)$/.exec(this.evt.options.name);
|
|
if (!nameOk) {
|
|
return BbPromise.reject(new SError('Project names can only be alphanumeric and -'));
|
|
}
|
|
|
|
// Validate Domain
|
|
let domainRegex = /^[a-z0-9-.]+$/;
|
|
if(!domainRegex.test(this.evt.options.domain)) {
|
|
return BbPromise.reject(new SError('Domain must only contain lowercase letters, numbers, periods and dashes'));
|
|
}
|
|
|
|
// Validate NotificationEmail
|
|
let emailRegex = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i;
|
|
if(!emailRegex.test(this.evt.options.notificationEmail)) {
|
|
return BbPromise.reject(new SError('Please enter a valid email'));
|
|
}
|
|
|
|
// Validate Region
|
|
if (awsMisc.validLambdaRegions.indexOf(this.evt.options.region) == -1) {
|
|
return BbPromise.reject(new SError('Invalid region. Lambda not supported in ' + this.evt.options.region, SError.errorCodes.UNKNOWN));
|
|
}
|
|
|
|
return BbPromise.resolve();
|
|
}
|
|
|
|
/**
|
|
* Install Project
|
|
*/
|
|
|
|
_installProject() {
|
|
|
|
let _this = this;
|
|
|
|
// Log
|
|
SCli.log('Downloading project...');
|
|
|
|
// Start spinner
|
|
_this._spinner = SCli.spinner();
|
|
_this._spinner.start();
|
|
|
|
return new BbPromise(function (resolve, reject) {
|
|
|
|
// create temp package.json for npm install
|
|
let packageJson = SUtils.readAndParseJsonSync(path.join(_this.S.config.serverlessPath, 'templates', 'nodejs', 'package.json'));
|
|
fs.writeFileSync(path.join(process.cwd(), 'package.json'), JSON.stringify(packageJson, null, 2));
|
|
|
|
let exec = require('child_process').exec,
|
|
child;
|
|
|
|
child = exec('npm install ' + _this.evt.options.project,
|
|
function (error, stdout, stderr) {
|
|
|
|
if (error !== null) return reject(new SError(error));
|
|
|
|
try {
|
|
fs.mkdirSync(path.join(process.cwd(), _this.evt.options.name));
|
|
fse.copySync(path.join(process.cwd(), 'node_modules', _this.evt.options.project), path.join(process.cwd(), _this.evt.options.name));
|
|
|
|
} catch (err) {
|
|
return reject(new SError(err))
|
|
}
|
|
|
|
// Delete node_modules & package.json
|
|
fse.removeSync(path.join(process.cwd(), 'node_modules'));
|
|
fse.removeSync(path.join(process.cwd(), 'package.json'));
|
|
|
|
return resolve();
|
|
})
|
|
})
|
|
.then(function () {
|
|
|
|
// Stop Spinner
|
|
_this._spinner.stop(true);
|
|
|
|
})
|
|
.catch(function (e) {
|
|
|
|
// Stop Spinner
|
|
_this._spinner.stop(true);
|
|
console.error(e);
|
|
process.exit(1);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Create Project Bucket
|
|
*/
|
|
|
|
_createProjectBucket() {
|
|
|
|
if (this.evt.options.noExeCf) {
|
|
|
|
// If no CloudFormation is set, skip project bucket creation
|
|
this.projectBucket = 'SET_YOUR_PROJECT_BUCKET_NAME_HERE';
|
|
SCli.log('Notice -- Skipping project bucket creation. Don\'t forget to point this project to your existing project bucket in _meta/s-variables-common.json. You will also need to manually create the file structure on the bucket and add a .env file to the "development" stage folder.');
|
|
return BbPromise.resolve();
|
|
|
|
} else {
|
|
|
|
// Set Serverless Project Bucket
|
|
this.projectBucket = SUtils.generateProjectBucketName(this.evt.options.domain, this.evt.options.region);
|
|
SCli.log('Creating your project bucket on S3: ' + this.projectBucket + '...');
|
|
return this.S3.sCreateBucket(this.projectBucket);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update Scaffolding
|
|
*/
|
|
|
|
_updateScaffolding() {
|
|
|
|
let _this = this;
|
|
|
|
return BbPromise.try(function() {
|
|
|
|
// Rename .npmignore to .gitignore
|
|
fs.renameSync(
|
|
path.join(process.cwd(), _this.evt.options.name, '.npmignore'),
|
|
path.join(process.cwd(), _this.evt.options.name, '.gitignore')
|
|
);
|
|
|
|
// Delete unnecessary package.json properties
|
|
let packageJson = SUtils.readAndParseJsonSync(path.join(process.cwd(), _this.evt.options.name, 'package.json'));
|
|
if (packageJson.readme) delete packageJson.readme;
|
|
if (packageJson.readmeFilename) delete packageJson.readmeFilename;
|
|
if (packageJson.gitHead) delete packageJson.gitHead;
|
|
if (packageJson._id) delete packageJson._id;
|
|
if (packageJson._shasum) delete packageJson._shasum;
|
|
if (packageJson._from) delete packageJson._from;
|
|
if (packageJson._npmVersion) delete packageJson._npmVersion;
|
|
if (packageJson._nodeVersion) delete packageJson._nodeVersion;
|
|
if (packageJson._npmUser) delete packageJson._npmUser;
|
|
if (packageJson.dist) delete packageJson.dist;
|
|
if (packageJson.maintainers) delete packageJson.maintainers;
|
|
if (packageJson.directories) delete packageJson.directories;
|
|
if (packageJson._resolved) delete packageJson._resolved;
|
|
|
|
// Update Global Serverless Instance
|
|
_this.S.updateConfig({
|
|
projectPath: path.join(process.cwd(), _this.evt.options.name)
|
|
});
|
|
|
|
// Prepare admin.env
|
|
let adminEnv = 'SERVERLESS_ADMIN_AWS_ACCESS_KEY_ID=' + _this.S.config.awsAdminKeyId + os.EOL
|
|
+ 'SERVERLESS_ADMIN_AWS_SECRET_ACCESS_KEY=' + _this.S.config.awsAdminSecretKey + os.EOL;
|
|
|
|
// Write Folders
|
|
fs.mkdirSync(path.join(_this.S.config.projectPath, '_meta'));
|
|
fs.mkdirSync(path.join(_this.S.config.projectPath, '_meta', 'variables'));
|
|
fs.mkdirSync(path.join(_this.S.config.projectPath, '_meta', 'resources'));
|
|
|
|
// Write Files
|
|
return BbPromise.all([
|
|
SUtils.writeFile(path.join(_this.S.config.projectPath, 'package.json'), JSON.stringify(packageJson, null, 2)),
|
|
SUtils.writeFile(path.join(_this.S.config.projectPath, 'admin.env'), adminEnv)
|
|
]);
|
|
})
|
|
.then(function() {
|
|
|
|
// Load State
|
|
return _this.S.state.load();
|
|
|
|
})
|
|
.then(function () {
|
|
|
|
// Update s-project.json
|
|
_this.project = _this.S.state.getProject();
|
|
_this.project.name = _this.evt.options.name;
|
|
_this.project.description = 'A slick new Serverless Project based off of ' + _this.evt.options.project;
|
|
_this.project.author = '';
|
|
_this.project.location = '';
|
|
|
|
// Update meta
|
|
_this.meta = _this.S.state.getMeta();
|
|
_this.meta.variables.project = _this.project.name;
|
|
_this.meta.variables.projectBucket = _this.projectBucket;
|
|
_this.meta.variables.domain = _this.evt.options.domain;
|
|
_this.meta.variables.notificationEmail = _this.evt.options.notificationEmail;
|
|
|
|
// Save State
|
|
return _this.S.state.save();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Create Stage And Region
|
|
*/
|
|
|
|
_createStageAndRegion() {
|
|
this.evt.options.stage = 'development';
|
|
return this.S.actions.stageCreate({
|
|
options: {
|
|
stage: this.evt.options.stage,
|
|
region: this.evt.options.region,
|
|
noExeCf: this.evt.options.noExeCf ? true : false
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
return( ProjectInstall );
|
|
}; |