export function restart(api) {
const list = nodemiral.taskList('Restart Meteor');
const sessions = api.getSessions(['app']);
const config = api.getConfig().app;
list.executeScript('Stop Meteor', {
script: api.resolvePath(__dirname, 'assets/meteor-stop.sh'),
vars: {
appName: config.name
}
});
list.executeScript('Start Meteor', {
script: api.resolvePath(__dirname, 'assets/meteor-start.sh'),
vars: {
appName: config.name
}
});
checkAppStarted(list, api);
return api.runTaskList(list, sessions, {
series: true,
verbose: api.verbose
});
}
exports.main = function(bundlePath, env, config) {
var deployCheckWaitTime = 15;
var appName = config.deploy.appName;
var rootPath = config.setup.path;
var taskList = nodemiral.taskList("Deploy app '" + appName + "' (linux)");
taskList.execute("Create Project Directory",
{command: "mkdir -p "+ rootPath + appName + '/tmp/'});
taskList.copy('Uploading bundle ' + bundlePath, {
src: bundlePath,
dest: rootPath + appName + '/tmp/bundle.tar.gz',
progressBar: true
});
taskList.copy('Initializing start script', {
src: path.resolve(TEMPLATES_DIR, 'app.json'),
dest: rootPath + appName + '/app.json',
vars: {
appName: appName,
env: env,
rootPath: rootPath,
}
});
deployAndVerify(taskList, appName, rootPath , 0, deployCheckWaitTime);
return taskList;
};
exports.install = function(vars, taskListOptions) {
var taskList = nodemiral.taskList('Logger Installation', taskListOptions);
taskList.executeScript('install', {
script: path.resolve(__dirname, 'scripts/install.sh')
});
return taskList;
};
export function start(api) {
log('exec => mup meteor start');
const config = api.getConfig().app;
if (!config) {
console.error('error: no configs found for meteor');
process.exit(1);
}
const list = nodemiral.taskList('Start Meteor');
list.executeScript('Start Meteor', {
script: api.resolvePath(__dirname, 'assets/meteor-start.sh'),
vars: {
appName: config.name
}
});
checkAppStarted(list, api);
const sessions = api.getSessions(['app']);
return api.runTaskList(list, sessions, {
series: true,
verbose: api.verbose
});
}
exports.configure = function(vars, taskListOptions) {
var taskList = nodemiral.taskList('Logger Configuration', taskListOptions);
taskList.copy('upstart', {
src: path.resolve(__dirname, 'templates/logger.init.conf'),
dest: '/etc/init/nodemiral-logger.conf'
});
taskList.copy('log_files.yml', {
src: path.resolve(__dirname, 'templates/log_files.yml'),
dest: '/opt/nodemiral/logger/log_files.yml',
vars: {
host: vars.host,
port: vars.port,
logFiles: vars.logFiles || []
}
});
//restart
taskList.execute('restarting logger', {
command: '(sudo stop nodemiral-logger || :) && (sudo start nodemiral-logger || :)'
});
return taskList;
};
.then(() => {
config.log = config.log || {
opts: {
'max-size': '100m',
'max-file': 10
}
};
const list = nodemiral.taskList('Pushing Meteor');
list.copy('Pushing Meteor App Bundle to The Server', {
src: bundlePath,
dest: '/opt/' + config.name + '/tmp/bundle.tar.gz',
progressBar: config.enableUploadProgressBar
});
list.copy('Pushing the Startup Script', {
src: path.resolve(__dirname, 'assets/templates/start.sh'),
dest: '/opt/' + config.name + '/config/start.sh',
vars: {
appName: config.name,
useLocalMongo: api.getConfig().mongo ? 1 : 0,
port: config.env.PORT || 80,
sslConfig: config.ssl,
logConfig: config.log,
volumes: config.volumes,
docker: config.docker
}
});
const sessions = api.getSessions([ 'meteor' ]);
return runTaskList(list, sessions);
});
exports.deploy = function(bundlePath, env, config) {
var deployCheckWaitTime = config.deployCheckWaitTime;
var appName = config.appName;
var taskList = nodemiral.taskList("Deploy app '" + appName + "' (linux)");
taskList.copy('Uploading bundle', {
src: bundlePath,
dest: '/opt/' + appName + '/tmp/bundle.tar.gz',
progressBar: config.enableUploadProgressBar
});
copyEnvVars(taskList, env, appName);
taskList.copy('Initializing start script', {
src: path.resolve(TEMPLATES_DIR, 'start.sh'),
dest: '/opt/' + appName + '/config/start.sh',
vars: {
appName: appName,
useLocalMongo: config.setupMongo,
port: env.PORT,
sslConfig: config.ssl,
customHosts: config.customHosts
}
});
deployAndVerify(taskList, appName, env.PORT, deployCheckWaitTime);
return taskList;
};
export function envconfig(api) {
log('exec => mup meteor envconfig');
const config = api.getConfig().meteor;
if (!config) {
console.error('error: no configs found for meteor');
process.exit(1);
}
const list = nodemiral.taskList('Configuring Meteor Environment Variables');
var env = _.clone(config.env);
env.METEOR_SETTINGS = JSON.stringify(api.getSettings());
// sending PORT to the docker container is useless.
// It'll run on PORT 80 and we can't override it
// Changing the port is done via the start.sh script
delete env.PORT;
list.copy('Sending Environment Variables', {
src: path.resolve(__dirname, 'assets/templates/env.list'),
dest: '/opt/' + config.name + '/config/env.list',
vars: {
env: env || {},
appName: config.name
}
});
const sessions = api.getSessions([ 'meteor' ]);
return runTaskList(list, sessions);
}
exports.deploy = function(bundlePath, env, deployCheckWaitTime, appName, enableUploadProgressBar) {
var taskList = nodemiral.taskList("Deploy app '" + appName + "' (linux)");
taskList.copy('Uploading bundle', {
src: bundlePath,
dest: '/opt/' + appName + '/tmp/bundle.tar.gz',
progressBar: enableUploadProgressBar
});
taskList.copy('Setting up Environment Variables', {
src: path.resolve(TEMPLATES_DIR, 'env.sh'),
dest: '/opt/' + appName + '/config/env.sh',
vars: {
env: env || {},
appName: appName
}
});
// deploying
taskList.executeScript('Invoking deployment process', {
script: path.resolve(TEMPLATES_DIR, 'deploy.sh'),
vars: {
deployCheckWaitTime: deployCheckWaitTime || 10,
appName: appName
}
});
return taskList;
};
export function start(api) {
log('exec => mup meteor start');
const config = api.getConfig().meteor;
if (!config) {
console.error('error: no configs found for meteor');
process.exit(1);
}
const list = nodemiral.taskList('Start Meteor');
list.executeScript('Start Meteor', {
script: path.resolve(__dirname, 'assets/meteor-start.sh'),
vars: {
appName: config.name
}
});
list.executeScript('Verifying Deployment', {
script: path.resolve(__dirname, 'assets/meteor-deploy-check.sh'),
vars: {
deployCheckWaitTime: config.deployCheckWaitTime || 60,
appName: config.name,
port: config.env.PORT || 80
}
});
const sessions = api.getSessions([ 'meteor' ]);
return runTaskList(list, sessions, {series: true});
}
exports.deploy = function(bundlePath, env, deployCheckWaitTime, appName, binaryNpmModules) {
var taskList = nodemiral.taskList("Deploying " + appName + " App");
taskList.copy('uploading bundle', {
src: bundlePath,
dest: '/opt/' + appName + '/tmp/bundle.tar.gz'
});
taskList.copy('setting up env vars', {
src: path.resolve(TEMPLATES_DIR, 'env.sh'),
dest: '/opt/' + appName + '/config/env.sh',
vars: {
env: env || {},
appName: appName,
}
});
//deploying
taskList.executeScript('invoking deployment process', {
script: path.resolve(TEMPLATES_DIR, 'deploy.sh'),
vars: {
deployCheckWaitTime: deployCheckWaitTime || 10,
appName: appName,
binaryNpmModules: binaryNpmModules
}
});
return taskList;
};
exports.stop = function(vars, taskListOptions) {
var taskList = nodemiral.taskList('Stop Logger', taskListOptions);
taskList.execute('start', {
command: "sudo stop nodemiral-logger || :"
});
return taskList;
};
exports.start = function(appName) {
var taskList = nodemiral.taskList("Starting Application (linux)");
//starting
taskList.execute('Starting app', {
command: '(sudo start ' + appName + ')'
});
return taskList;
};
exports.reconfig = function(env, config) {
var appName = config.appName;
var deployCheckWaitTime = config.deployCheckWaitTime;
var taskList = nodemiral.taskList("Updating configurations (linux)");
copyEnvVars(taskList, env, appName);
startAndVerify(taskList, appName, env.PORT, deployCheckWaitTime);
return taskList;
};
export function restart(api) {
const list = nodemiral.taskList('Restart Docker Daemon');
list.executeScript('Restart Docker', {
script: resolvePath(__dirname, 'assets/docker-restart.sh')
});
const sessions = uniqueSessions(api);
return runTaskList(list, sessions, { verbose: api.getVerbose() });
}
export function setup(api) {
log('exec => mup docker setup');
const list = nodemiral.taskList('Setup Docker');
list.executeScript('Setup Docker', {
script: resolvePath(__dirname, 'assets/docker-setup.sh')
});
const sessions = uniqueSessions(api);
return runTaskList(list, sessions, { verbose: api.getVerbose() });
}
exports.start = function(config) {
var taskList = nodemiral.taskList("Starting Application (linux)");
var appName = config.appName;
var port = config.env.PORT;
var deployCheckWaitTime = config.deployCheckWaitTime;
startAndVerify(taskList, appName, port, deployCheckWaitTime);
return taskList;
};
exports.setup = function(config) {
var taskList = nodemiral.taskList('Setup (linux)');
// Installation
if(config.setupNode) {
taskList.executeScript('Installing Node.js', {
script: path.resolve(SCRIPT_DIR, 'install-node.sh'),
vars: {
nodeVersion: config.nodeVersion
}
});
}
if(config.setupPhantom) {
taskList.executeScript('Installing PhantomJS', {
script: path.resolve(SCRIPT_DIR, 'install-phantomjs.sh')
});
}
taskList.executeScript('Setting up Environment', {
script: path.resolve(SCRIPT_DIR, 'setup-env.sh'),
vars: {
appName: config.appName
}
});
if(config.setupMongo) {
taskList.copy('Copying MongoDB configuration', {
src: path.resolve(TEMPLATES_DIR, 'mongod.conf'),
dest: '/etc/mongod.conf'
});
taskList.executeScript('Installing MongoDB', {
script: path.resolve(SCRIPT_DIR, 'install-mongodb.sh')
});
}
if(config.ssl) {
installStud(taskList);
configureStud(taskList, config.ssl.pem, config.ssl.backendPort);
}
//Configurations
taskList.copy('Configuring upstart', {
src: path.resolve(TEMPLATES_DIR, 'meteor.conf'),
dest: '/etc/init/' + config.appName + '.conf',
vars: {
appName: config.appName
}
});
return taskList;
};
exports.stop = function(config) {
var taskList = nodemiral.taskList("Stopping Application (linux)");
//stopping
taskList.executeScript('Stopping app', {
script: path.resolve(SCRIPT_DIR, 'stop.sh'),
vars: {
appName: config.appName
}
});
return taskList;
};
export function setup(api) {
log('exec => mup meteor setup');
const config = api.getConfig().meteor;
if (!config) {
console.error('error: no configs found for meteor');
process.exit(1);
}
const list = nodemiral.taskList('Setup Meteor');
list.executeScript('Setup Environment', {
script: resolvePath(__dirname, 'assets/meteor-setup.sh'),
vars: {
name: config.name
}
});
if (config.ssl && typeof config.ssl.autogenerate !== 'object') {
const basePath = api.getBasePath();
if (config.ssl.upload !== false) {
list.executeScript('Cleaning up SSL Certificates', {
script: resolvePath(__dirname, 'assets/ssl-cleanup.sh'),
vars: {
name: config.name
}
});
list.copy('Copying SSL Certificate Bundle', {
src: resolvePath(basePath, config.ssl.crt),
dest: '/opt/' + config.name + '/config/bundle.crt'
});
list.copy('Copying SSL Private Key', {
src: resolvePath(basePath, config.ssl.key),
dest: '/opt/' + config.name + '/config/private.key'
});
}
list.executeScript('Verifying SSL Configurations', {
script: resolvePath(__dirname, 'assets/verify-ssl-config.sh'),
vars: {
name: config.name
}
});
}
const sessions = api.getSessions(['meteor']);
return runTaskList(list, sessions, { verbose: api.getVerbose() });
}
exports.setup = function(installMongo, setupNode, nodeVersion, setupPhantom, appName) {
var taskList = nodemiral.taskList('Setting Up');
// Installation
if (setupNode) {
taskList.executeScript('installing node', {
script: path.resolve(SCRIPT_DIR, 'install-node.sh'),
vars: {
nodeVersion: nodeVersion
},
});
}
if (setupPhantom) {
taskList.executeScript('installing phantomjs', {
script: path.resolve(SCRIPT_DIR, 'install-phantomjs.sh')
});
}
taskList.executeScript('setting up environment', {
script: path.resolve(SCRIPT_DIR, 'setup-env.sh'),
vars: {
appName: appName
}
});
if(installMongo) {
taskList.copy('copy /etc/mongodb.conf', {
src: path.resolve(TEMPLATES_DIR, 'mongodb.conf'),
dest: '/etc/mongodb.conf'
});
taskList.executeScript('installing mongodb', {
script: path.resolve(SCRIPT_DIR, 'install-mongodb.sh')
});
}
//Configurations
taskList.copy('configure upstart', {
src: path.resolve(TEMPLATES_DIR, 'meteor.conf'),
dest: '/etc/init/' + appName + '.conf',
vars: {
appName: appName
}
});
return taskList;
};
export async function push(api) {
log('exec => mup meteor push');
const config = api.getConfig().meteor;
if (!config) {
console.error('error: no configs found for meteor');
process.exit(1);
}
const appPath = resolvePath(api.getBasePath(), config.path);
let buildOptions = config.buildOptions || {};
buildOptions.buildLocation = buildOptions.buildLocation ||
tmpBuildPath(appPath);
var bundlePath = resolvePath(buildOptions.buildLocation, 'bundle.tar.gz');
var rebuild = true;
if (api.optionEnabled('cached-build')) {
const buildCached = fs.existsSync(bundlePath);
if (!buildCached) {
console.log('Unable to use previous build. It doesn\'t exist.');
} else {
rebuild = false;
console.log('Not rebuilding app. Using build from previous deploy at');
console.log(`${buildOptions.buildLocation}`);
}
}
if (rebuild) {
console.log('Building App Bundle Locally');
await buildApp(appPath, buildOptions, api.getVerbose());
}
const list = nodemiral.taskList('Pushing Meteor App');
list.copy('Pushing Meteor App Bundle to The Server', {
src: bundlePath,
dest: '/opt/' + config.name + '/tmp/bundle.tar.gz',
progressBar: config.enableUploadProgressBar
});
const sessions = api.getSessions(['meteor']);
return runTaskList(list, sessions, {
series: true,
verbose: api.getVerbose()
});
}
exports.setup = function(config) {
var taskList = nodemiral.taskList('Setup (linux)');
taskList.executeScript('Installing Docker', {
script: path.resolve(SCRIPT_DIR, 'install-docker.sh')
});
taskList.executeScript('Setting up Environment', {
script: path.resolve(SCRIPT_DIR, 'setup-env.sh'),
vars: {
appName: config.appName
}
});
if(config.setupMongo) {
taskList.copy('Copying MongoDB configuration', {
src: path.resolve(TEMPLATES_DIR, 'mongodb.conf'),
dest: '/opt/mongodb/mongodb.conf'
});
taskList.executeScript('Installing MongoDB', {
script: path.resolve(SCRIPT_DIR, 'install-mongodb.sh')
});
}
if(config.ssl) {
taskList.copy('Copying SSL certificate bundle', {
src: config.ssl.certificate,
dest: '/opt/' + config.appName + '/config/bundle.crt'
});
taskList.copy('Copying SSL private key', {
src: config.ssl.key,
dest: '/opt/' + config.appName + '/config/private.key'
});
taskList.executeScript('Verifying SSL configurations', {
script: path.resolve(SCRIPT_DIR, 'verify-ssl-configurations.sh'),
vars: {
appName: config.appName
}
});
}
return taskList;
};
export function setup(api) {
log('exec => mup docker setup');
const list = nodemiral.taskList('Setup Docker');
list.executeScript('setup docker', {
script: path.resolve(__dirname, 'assets/docker-setup.sh')
});
const sessions = api.getSessions([ 'meteor', 'mongo', 'proxy' ]);
const rsessions = sessions.reduce((prev, curr) => {
if (prev.map(session => session._host).indexOf(curr._host) === -1) {
prev.push(curr);
}
return prev;
}, []);
return runTaskList(list, rsessions);
}
exports.reconfig = function(env) {
var taskList = nodemiral.taskList("Updating Configurations");
taskList.copy('setting up env vars', {
src: path.resolve(TEMPLATES_DIR, 'env.sh'),
dest: '/opt/meteor/config/env.sh',
vars: {
env: env || {}
}
});
//deploying
taskList.execute('restarting the app', {
command: '(sudo stop meteor || :) && (sudo start meteor)'
});
return taskList;
};
exports.reconfig = function(env, appName) {
var taskList = nodemiral.taskList("Updating configurations (linux)");
taskList.copy('Setting up Environment Variables', {
src: path.resolve(TEMPLATES_DIR, 'env.sh'),
dest: '/opt/' + appName + '/config/env.sh',
vars: {
env: env || {},
appName: appName
}
});
//restarting
taskList.execute('Restarting app', {
command: '(sudo stop ' + appName + ' || :) && (sudo start ' + appName + ')'
});
return taskList;
};
export function stop(api) {
log('exec => mup meteor stop');
const config = api.getConfig().meteor;
if (!config) {
console.error('error: no configs found for meteor');
process.exit(1);
}
const list = nodemiral.taskList('Stop Meteor');
list.executeScript('Stop Meteor', {
script: path.resolve(__dirname, 'assets/meteor-stop.sh'),
vars: {
appName: config.name
}
});
const sessions = api.getSessions([ 'meteor' ]);
return runTaskList(list, sessions);
}
export function setup(api) {
log('exec => mup meteor setup');
const config = api.getConfig().meteor;
if (!config) {
console.error('error: no configs found for meteor');
process.exit(1);
}
const list = nodemiral.taskList('Setup Meteor');
list.executeScript('Setup Environment', {
script: path.resolve(__dirname, 'assets/meteor-setup.sh'),
vars: {
name: config.name,
},
});
if (config.ssl) {
list.copy('Copying SSL Certificate Bundle', {
src: config.ssl.crt,
dest: '/opt/' + config.name + '/config/bundle.crt'
});
list.copy('Copying SSL Private Key', {
src: config.ssl.key,
dest: '/opt/' + config.name + '/config/private.key'
});
list.executeScript('Verifying SSL Configurations', {
script: path.resolve(__dirname, 'assets/verify-ssl-config.sh'),
vars: {
name: config.name
},
});
}
const sessions = api.getSessions(['meteor']);
return runTaskList(list, sessions);
}
export function start(api) {
log('exec => mup meteor start');
const config = api.getConfig().meteor;
if (!config) {
console.error('error: no configs found for meteor');
process.exit(1);
}
let route = api.hasMeteorPackage('zodern:mup-helpers') ? '/___mup_verify' : '';
const list = nodemiral.taskList('Start Meteor');
list.executeScript('Start Meteor', {
script: resolvePath(__dirname, 'assets/meteor-start.sh'),
vars: {
appName: config.name
}
});
list.executeScript('Verifying Deployment', {
script: resolvePath(__dirname, 'assets/meteor-deploy-check.sh'),
vars: {
deployCheckWaitTime: config.deployCheckWaitTime || 60,
appName: config.name,
deployCheckPort: config.deployCheckPort || config.env.PORT || 80,
deployCheckPath: route,
host: api.getConfig().proxy ? api.getConfig().proxy.domains.split(',')[0] : null
}
});
const sessions = api.getSessions(['meteor']);
return runTaskList(list, sessions, {
series: true,
verbose: api.getVerbose()
});
}
export function envconfig(api) {
log('exec => mup meteor envconfig');
const config = api.getConfig().meteor;
let bindAddress = '0.0.0.0';
if (!config) {
console.error('error: no configs found for meteor');
process.exit(1);
}
config.log = config.log || {
opts: {
'max-size': '100m',
'max-file': 10
}
};
config.nginx = config.nginx || {};
if (config.docker && config.docker.bind) {
bindAddress = config.docker.bind;
}
if (!config.docker) {
if (config.dockerImage) {
config.docker = {
image: config.dockerImage
};
delete config.dockerImage;
} else {
config.docker = {
image: 'kadirahq/meteord'
};
}
}
if (config.dockerImageFrontendServer) {
config.docker.imageFrontendServer = config.dockerImageFrontendServer;
}
if (!config.docker.imageFrontendServer) {
config.docker.imageFrontendServer = 'meteorhacks/mup-frontend-server';
}
// If imagePort is not set, go with port 80 which was the traditional
// port used by kadirahq/meteord and meteorhacks/meteord
config.docker.imagePort = config.docker.imagePort || 80;
if (config.ssl) {
config.ssl.port = config.ssl.port || 443;
}
const list = nodemiral.taskList('Configuring App');
list.copy('Pushing the Startup Script', {
src: resolvePath(__dirname, 'assets/templates/start.sh'),
dest: '/opt/' + config.name + '/config/start.sh',
vars: {
appName: config.name,
useLocalMongo: api.getConfig().mongo ? 1 : 0,
port: config.env.PORT || 80,
bind: bindAddress,
sslConfig: config.ssl,
logConfig: config.log,
volumes: config.volumes,
docker: config.docker,
proxyConfig: api.getConfig().proxy,
proxyName: PROXY_CONTAINER_NAME,
nginxClientUploadLimit: config.nginx.clientUploadLimit || '10M'
}
});
var env = _.clone(config.env);
env.METEOR_SETTINGS = JSON.stringify(api.getSettings());
// sending PORT to the docker container is useless.
// setting PORT in the config is used for the publicly accessible
// port.
// docker.imagePort is used for the port exposed from the container.
// In case the docker.imagePort is different than the container's
// default port, we set the env PORT to docker.imagePort.
env.PORT = config.docker.imagePort;
list.copy('Sending Environment Variables', {
src: resolvePath(__dirname, 'assets/templates/env.list'),
dest: '/opt/' + config.name + '/config/env.list',
vars: {
env: env || {},
appName: config.name
}
});
const sessions = api.getSessions(['meteor']);
return runTaskList(list, sessions, {
series: true,
verbose: api.getVerbose()
});
}