var path = require('path');
var utils = require('bbhverse');
var any = utils.any;
var Tasq = utils.Tasq
var statuslog = utils.Traq
var Traq = utils.Traq
Tasq.addlistener(statuslog.statuslog)
var cli = require('./cliverse')
var nodeShellExec = cli.nodeShellExec;
var chalk = require('chalk')
const BUILD_VERSION = '[VI]Version: {version} - built on {date}[/VI]';
const runtimestamp = (new Date()).getTime();
function getVersion() { return BUILD_VERSION; }
console.log(getVersion())
// 'use strict';
// PB : TODO -- make sure folder context is proper coz we can now run elxr from anywhere.
// PB : TODO --
// runas bypass non elevated tasks when we request privelege
// runas message is always error needs to be fixed.
// runas wait needs to be parallelized.
// suppress elevation check error messages
// support runas lauched directly from shell.
// pass in environment in hta to shellexecute.
const { existsSync } = require('fs');
const fs = require('fs')
const cliargs = utils.cliargs;
const processedArgs = cliargs(process.argv.slice(2));
console.dir(processedArgs)
var globSync = require('glob').sync;
var ENV = Object.assign({}, process.env); // Shallow clone it.
const { readdir } = require("fs").promises
// Directory shallow walk and do perform on each dir.
const dirs = async (perform, path) => {
for (const dir of await readdir(path || process.cwd(), { withFileTypes: true })) {
if (dir.isDirectory()) perform(dir)
}
}
var getShellTask = (command, args, options) => {
options = options || {}
return () => {
var p = nodeShellExec.apply(null, [command, args, Object.assign({
inherit: true, shell: true, env: ENV, title: `${command} ${args}`
}, options)
])
if (options.ignorefailures) {
return p.catch(e => {
// Ignore. Not a major error.
})
}
else return p;
}
}
var callsheltask = (args) => { return () => { return nodeShellExec.apply(null, args) } }
var getTaskCheckExists = (command, options) => {
options = options || {}
return () => {
var p = nodeShellExec.apply(null, ['where', [command]])
if (options.ignorefailures) {
return p.then(() => { return true }).catch(e => { // Ignore. Not a major error.
return false;
})
}
else return p.then(() => { return true });
}
}
var getTaskWithElevation = function(tasdef){
return ()=>{
if (__isElevated) {
return tasdef.elevatedpulltasks();
}
else {
// PB : TODO -- Rename op['runas'] to 'elevate'
return op['runas']().then(() => { return true; })
.catch((e) => {
console.error(e)
})
.finally(() => {
if (!processedArgs.runas) { return tasdef.regularpulltasks(); }
})
}
}
}
var getTaskWithoutElevation = function(tasdef){
return ()=>{
if(!processedArgs.runas) { return tasdef.regularpulltasks(); }
else Promise.resolve(true)
}
}
var gitops = {
getdiscoverbranchcmd : function(repo){
var parameters = ['-c', 'branch=`git rev-parse --abbrev-ref HEAD`;for i in `git remote`; do git pull $i $branch; done;']
var cmd = [gitbash
, ['-c', 'branch=`git rev-parse --abbrev-ref HEAD`;for i in `git remote`; do git pull $i $branch; done;']
, { cwd: instanceroot + '/' + repo, title: 'pull all origins for ' + repo + ' ' + parameters.join(' ') }]
return cmd
}
}
var getPullCmd = (repo, branch) => {
// console.log(useGitPull)var getPullCmd = (repo, branch) => {
// console.log(useGitPull)
if(branch) {
var parameters = ['-c', 'for i in `git remote`; do git pull $i ' + branch + '; done;']
var pullCmd = [ gitbash
, ['-c', 'for i in `git remote`; do git pull $i ' + branch + '; done;']
, { cwd: instanceroot + '/' + repo, title : 'pull all origins for ' + branch + ' ' + repo + ' ' + parameters.join(' ') }]
}
else {
console.warn('No branch was specified detecting from working client.')
var pullCmd = gitops.getdiscoverbranchcmd(repo)
}
// var pullCmd = ['pullall', [], { cwd : repo }]
if (useGitPull) pullCmd = ['git', ['pull'], {
inherit: true, shell: true,
cwd: instanceroot + '/' + repo
// , env: process.env
, runas: processedArgs.runas
, title: `git pull ${repo}`
}]
return pullCmd
}
var performPull = (repo, branch) => {
// PB : TODO -- Handle no branch passed in case.
// if(!branch) { throw 'No branch specified' }
if (existsSync(instanceroot + '/' + repo)) {
var branchprint = branch ? ' branch :' + branch : '';
console.log('pulling ' + instanceroot + '/' + repo + branchprint )
return nodeShellExec.apply(null, getPullCmd(repo, branch)).then(() => {
if (__isElevated) {
fs.writeFileSync('run.log', ', ' + JSON.stringify({ repo, success: true }), { 'flag': 'a+' })
}
else statuslog.statuslog(null, repo)
return true;
})
.catch((e) => {
e.repo = repo;
if (__isElevated) {
fs.writeFileSync('run.log', ', ' + JSON.stringify(e), { 'flag': 'a+' })
}
else statuslog.statuslog(e); console.error(e)
})
}
else {
console.log('cloning ' + repo)
// PB : TODO -- detect if a clonable repo exists in currentGitAuthUser
return nodeShellExec('git', ['clone', '-c', 'core.symlinks=true', selectedinstance.reposerver + `/${defaultRepoOwner}/` + repo + '.git'],
{
inherit: true, shell: true,
env: process.env
, cwd : instanceroot
, runas: processedArgs.runas
}).catch((e) => {
throw e;
}).then(() => {
return nodeShellExec('git', ['config', '--replace-all', 'core.symlinks', true],
{
inherit: true, shell: true,
env: process.env
, cwd: instanceroot + '/' + repo
, runas: processedArgs.runas
, title: `git core.symlinks --replace-all true for ${selectedinstance.reposerver + `/${defaultRepoOwner}/` + repo + '.git'}`
})
.then(() => {
if (__isElevated) {
fs.writeFileSync('run.log', ', ' + JSON.stringify({ repo, success: true }), { 'flag': 'a+' })
}
else statuslog.statuslog(null, repo)
})
.catch((e) => {
e.repo = repo;
if (__isElevated) {
fs.writeFileSync('run.log', ', ' + JSON.stringify(e), { 'flag': 'a+' })
}
else statuslog.statuslog(e);
})
})
.catch(e => {
e.repo = repo;
if (__isElevated) {
fs.writeFileSync('run.log', ', ' + JSON.stringify(e), { 'flag': 'a+' })
}
else statuslog.statuslog(e);
})
}
}
// PB : TODO -- If we are run from an elevated shell it never moves forward and simply exits.
// -- Currently workaround is to always run from a non-elevated shell.
var __isElevated = null; // We assume non-Elevated until someone evaluates and sets this variable.
var acquireElevationState = () => {
if (__isElevated === null) {
return nodeShellExec("fsutil", ["dirty", "query", "C:"], {
inherit: true
// , shell: true
, stdio: 'ignore'
, env: process.env
, title: `check privileged execution mode using "fsutil dirty query C:"`
}).then((exitcode) => {
console.log('Elevated')
__isElevated = true;
return true;
}).catch(() => {
__isElevated = false;
console.log('Not Elevated');
return false;
});
}
else return Promise.resolve(__isElevated);
}
var repomanifest = null;
var currentGitAuthUser; // nodeShellExec('git', ['config', 'user.email']) ... PB : TODO-- get the current gittea username
var defaultRepoOwner = 'chess';
var elevatedRunasRepos = null
var gitRepos = null
// grep -qxF 'alias elxr="node elxr/index.js"' ~/.bash_profile || echo 'alias elxr="node elxr/index.js"' >> ~/.bash_profile
// nodeShellExec('echo', ['elxr'], { inherit : true}) //, {stdio: "inherit"}
var dbForLabel = function (label) {
var dbsForLabel = {
devmysql: 'mysql'
, development: 'mssql'
, production: 'mssql'
}
return dbsForLabel[label] || 'mysql'
}
// SAM : TODO Use nodeshellexec where to detect git installation dir
var gitbash = "C:\\Program Files\\Git\\bin\\sh.exe"
// var gitbash = "G:\\Installed\\Git\\bin\\sh.exe"
// Relevant git repos
// var repomanifest = require('../'+repomanifest.instanceName+'-config-'+ nodeenv +'/repo-manifest')()
var exludeMergeRepos = [];
var useGitPull = processedArgs.useGitPull || false;
var configPromise = null
// elxr cli operations
var op = {
'h': () => { console.log(elxr.help()); return '-h' }
, 'clean' : () => {
// delete all node_module folders and links.
var tasklist = [];
dirs( (repodir)=> tasklist.push(getShellTask('rm',['-rf', 'node_modules'], { cwd : instanceroot + '/' + repodir.name })()), instanceroot )
return Promise.all(tasklist)
}
, 'undefined': () => { return op.h(); }
, 'reset': () => {
// Reset NPM packages semver so major versions can be updated.
const fs = require('fs')
const wipeDependencies = (__package) => {
const file = fs.readFileSync(__package + '/package.json')
const content = JSON.parse(file)
for (var devDep in content.devDependencies) {
if (content.devDependencies[devDep].match(/\W+\d+.\d+.\d+-?((alpha|beta|rc)?.\d+)?/g)) {
content.devDependencies[devDep] = '*';
}
}
for (var dep in content.dependencies) {
if (content.dependencies[dep].match(/\W+\d+.\d+.\d+-?((alpha|beta|rc)?.\d+)?/g)) {
content.dependencies[dep] = '*';
}
}
fs.writeFileSync(__package + '/package.json', JSON.stringify(content))
}
var repos = ['client'];
// repos = gitRepos;
repos.forEach(wipeDependencies)
// if (require.main === module) {
// } else {
// module.exports = wipeDependencies
// }
}
, 'upgrade': () => {
console.log('upgrade.......')
var tasks = [
() => {
var p = nodeShellExec('npm', ['i', '-g', 'npm-upgrade'], {
inherit: true, shell: true
, env: process.env
}).catch((e) => { console.error(e) })
p.position = 1;
console.log('One')
return p;
}
, () => {
var p = nodeShellExec('npm', ['cache', 'clean', '-f'], {
inherit: true, shell: true
, env: process.env
}).catch((e) => { console.error(e) })
p.position = 2;
console.log('Two')
return p;
}
, () => {
var p = nodeShellExec('npm', ['install', '-g', 'n'], {
inherit: true, shell: true
, env: process.env
}).catch((e) => { console.error(e) })
p.position = 3;
console.log('Three')
return p;
}
, () => {
var p = nodeShellExec('n', ['latest'], {
inherit: true, shell: true
, env: process.env
}).catch((e) => { console.error(e) })
p.position = 4;
console.log('Four')
return p;
}
]
any(tasks)
console.log('.......done')
console.log('Running exlr upgrade in : ' + path.dirname(__dirname))
console.log('Currently only upgrades ember : ' + path.dirname(__dirname));
console.info('Uninstalling existing ember globally');
var step1 = nodeShellExec('cmd', ['/c', 'npm', 'uninstall', '-g', 'ember-cli'], {
stdio: ['pipe', process.stdout, process.stderr],
inherit: true,
shell: true,
cwd: path.dirname(__dirname),
env: env
})
step1.on('close', () => {
console.info('Installing ember globally');
var step2 = nodeShellExec('cmd', ['/c', 'npm', 'install', '-g', 'ember-cli'], {
stdio: ['pipe', process.stdout, process.stderr],
inherit: true,
shell: true,
cwd: path.dirname(__dirname),
env: env
})
step2.on('close', () => {
nodeShellExec('cmd', ['/c', 'ember', '--version'], {
stdio: ['pipe', process.stdout, process.stderr],
inherit: true,
shell: true,
cwd: path.dirname(__dirname),
env: env
})
})
})
}
, 'runas': () => {
console.log('Testing Elevation')
if (__isElevated) {
try {
op[processedArgs.label || processedArgs._[0] || 'h']()
}
catch (e) {
console.error('Error Invalid command : ' + e)
fs.writeFileSync('run.done', 'error')
}
finally {
}
}
else {
console.log('Requesting Elevated Privileges');
// Wait for the runas to complete before we read it.
try {
fs.unlinkSync('run.done')
fs.unlinkSync('run.log')
}
catch (e) { } //Ignore
// Find node path to send to hta.
return nodeShellExec('where', ['node']).then(r => {
var namedArgs = [];
console.log('result : ' + JSON.stringify(r))
Object.keys(processedArgs).forEach((v) => { v != '_' ? namedArgs.push('--' + v + '=' + processedArgs[v]) : null; })
// PB : TODO -- Convert all the cli args back to string.
var args = [`${selectedinstance.root}/.elxr/run-${runtimestamp}/windowselevate.hta`].concat(processedArgs._).concat(namedArgs.join(' ')); args.push('--runas=self');
args.push('--nodepath=' + r[r.length - 1])
if (!processedArgs.node_env) args.push('--node_env=' + ENV.NODE_ENV)
if (processedArgs.debug) args.push('--debug=true') // Enable to debug elevated..
return nodeShellExec('MSHTA', [`"${args.join('" "')}"`]
, {
inherit: true
, shell: true
, env: ENV
, runas: 'self'
, title: `runas`
}
).then(() => {
// runas returned.
try {
// PB : TODO -- Log is comma prefixed. Needs to be proper JSON.
var runaslog = JSON.parse('[ { "success" : true, "result" : "started"}' + fs.readFileSync('run.log', { flags: 'a+' }) + ']');
runaslog.forEach((logEntry) => {
statuslog.statuslog(logEntry.success ? null : logEntry, logEntry)
logEntry.success ? (console.log(['success :' + logEntry.result]), console.log((logEntry.messages || []).join(' '))) : (console.error(['error :' + logEntry.result]), console.error((logEntry.messages || []).join(' ')))
})
}
catch (e) {
// We must have a runas log
statuslog.statuslog(e)
console.error('Run log error probably was not created by runas : ' + e)
}
})
.catch(err => console.error('Elevation failed : ' + err));
})
}
}
, 'push': () => {
if (!processedArgs._[1]) { console.error('push all not supported. Specify repo name'); return }
// init remote bare from local
// pushandinitremotebare
// https://www.jeffgeerling.com/blogs/jeff-geerling/push-your-git-repositories
// connect to repo server -- net use 172.16.0.27
// cd 172.16.0.27/repos/
// mkdir repo.git
// cd repo.git
// git init --bare
// cd localrepo
// git remote rename origin githubclone
// git remote add origin //172.16.0.27/repos/repo.git
// git push origin master
var repo = processedArgs._[1];
var sequentialTaskShellCommands = [];
if (!existsSync(`Z:/${repo}.git`)) {
sequentialTaskShellCommands = [
// ['net', ['use', 'Z:', selectedinstance.reposerver.replace('/','\\')], {
// inherit : true, shell: true
// , env: process.env
// }]
['pwd', { cwd: 'Z:', inherit: true }]
, ['mkdir', [`${repo}.git`], {
cwd: `Z:`
, inherit: true, shell: true
, env: process.env
}]
, ['pwd', { cwd: `Z:/${repo}.git`, inherit: true }]
, ['git', ['init', '--bare'], {
cwd: `Z:/${repo}.git`
, inherit: true, shell: true
, env: process.env
}]
// PB : TODO -- Do this conditionally only...
, ['git', ['remote', 'rename', 'origin', 'githubclone'], { cwd: `${instanceroot + '/' + repo}` }, (err) => {
console.log('Ignoring origin rename error : ' + err); return true; //return true to continue.
}] // PB ; Todo -- new repositories created locally will not have origin. Handle this failure.
, ['git', ['remote', 'add', 'origin', `${selectedinstance.reposerver}/${repo}.git`], { cwd: `${instanceroot + '/' + repo}` }]
// PB : TODO -- If threre is a gitbubclone origin
// Set the master to pull from the local repo.
]
if (!existsSync(`Z:`)) {
sequentialTaskShellCommands.splice(0, 0, ['net', ['use', 'Z:', selectedinstance.reposerver.replace(/\//gm, '\\')], {
inherit: true, shell: true
, env: process.env
}])
console.warn('Adding network drive z: for repo server. ' + sequentialTaskShellCommands[0])
// throw 'done'
}
}
sequentialTaskShellCommands.push(['git', ['push', 'origin', 'master'], { cwd: `${instanceroot + '/' + repo}` }])
// console.dir(sequentialTaskShellCommands);
var tasks = [];
sequentialTaskShellCommands.forEach(shellcmd => {
// console.log(shellcmd)
tasks.push(() => {
var p = nodeShellExec.apply(null, shellcmd.slice(0, 3)).catch((e) => { if (shellcmd[3]) { return shellcmd[3]() } else { console.error(e); } })
return p;
})
})
any(tasks);
}
, 'is-git-repo': (dir) => {
return nodeShellExec('git', ['-C', dir.name, 'rev-parse'], { stdio: 'ignore' })
}
, 'set-url': (remotename, url) => {
var pushable = processedArgs.pushable || false;
remotename = remotename || processedArgs._[1]
url = url || processedArgs._[2]
var serial_perform_git_seturl = (repo) => {
var options = { cwd: instanceroot + '/' + repo }
// console.log(repo)
if (pushable) {
return [
['git', ['remote', 'set-url', remotename, url + '/' + repo], { cwd: instanceroot + '/' + repo }]
]
}
else {
console.error('not supported for non-pushable')
}
}
var perform_git_seturl = (dir) => {
op['is-git-repo'](dir).then((code) => {
any(serial_perform_git_seturl(dir.name).map(x))
}).catch((e) => {
// console.log('Failed : ' + dir.name)
})
}
dirs(perform_git_seturl)
}
, 'add': (remotename, url, branch) => {
var pushable = processedArgs.pushable || false;
remotename = remotename || processedArgs._[1]
url = url || processedArgs._[2]
branch = branch || processedArgs._[3]
var serial_perform_git_add = (repo) => {
var options = { cwd: instanceroot + '/' + repo }
// console.log(repo)
if (pushable) {
return [
['git', ['remote', 'add', remotename, url + '/' + repo], { cwd: instanceroot + '/' + repo }]
, ['git', ['pull', remotename, branch], { cwd: instanceroot + '/' + repo }]
, ['git', ['branch', `--set-upstream-to=${remotename}/${branch}`, branch], { cwd: instanceroot + '/' + repo }]
]
}
else {
return [
['git', ['remote', 'add', remotename, url + '/' + repo], { cwd: instanceroot + '/' + repo }]
, ['git', ['remote', `set-url`, '--push', remotename, 'no-pushing'], { cwd: instanceroot + '/' + repo }]
, ['git', ['pull', remotename, branch], { cwd: instanceroot + '/' + repo }]
, ['git', ['branch', `--set-upstream-to=${remotename}/${branch}`, branch], { cwd: instanceroot + '/' + repo }]
]
}
}
var x = (args) => {
return () => {
// console.log(args)
return nodeShellExec.apply(null, args)
}
// return Promise.resolve(true)
}
var perform_git_add = (dir) => {
op['is-git-repo'](dir).then((code) => {
// console.log(code)
if (code) {
nodeShellExec('git', ['remote', 'get-url', remotename], { cwd: dir.name, stdio: 'ignore' }).then(() => {
console.log('skipped : ' + dir.name + ', reason : A remote with same name already exists.')
})
.catch((e) => {
any(serial_perform_git_add(dir.name).map(x))
})
}
// else console.log('Skipped : Not a Git Repo : ' + dir.name)
}).catch((e) => {
// console.log('Failed : ' + dir.name)
})
}
const { readdir } = require("fs").promises
dirs(perform_git_add)
}
, 'remove': (remotename) => {
remotename = remotename || processedArgs._[1]
var serial_perform_git_remove = (repo) => {
var options = { cwd: instanceroot + '/' + repo }
// console.log(repo)
return [
['git', ['remote', 'remove', remotename], { cwd: instanceroot + '/' + repo }]
]
}
var x = (args) => {
return () => {
// console.log(args)
return nodeShellExec.apply(null, args)
}
// return Promise.resolve(true)
}
var perform_git_remove = (dir) => {
op['is-git-repo'](dir).then((code) => {
// console.log(code)
if (code) {
nodeShellExec('git', ['remote', 'get-url', remotename], { cwd: dir.name, stdio: 'ignore' }).then(() => {
any(serial_perform_git_remove(dir.name).map(x))
})
.catch((e) => {
console.log('skipped : ' + dir.name + ', reason : No remote named origin')
})
}
// else console.log('Skipped : Not a Git Repo : ' + dir.name)
}).catch((e) => {
// console.log('Failed : ' + dir.name)
})
}
const { readdir } = require("fs").promises
dirs(perform_git_remove)
}
, 'init-gitea': (user) => {
user = user || processedArgs._[1]
if (!user) throw 'User name required'
var serial_perform_init_gitea = (repo) => {
var options = { cwd: instanceroot + '/' + repo }
// console.log(repo)
return [
['git', ['remote', 'add', 'chess', `${selectedinstance.reposerver}/${user}/${repo}.git`], { cwd: instanceroot + '/' + repo }]
, ['git', ['remote', 'set-url', '--push', 'chess', 'no-pushing'], { cwd: instanceroot + '/' + repo }]
, ['git', ['remote', 'set-url', 'origin', `${selectedinstance.reposerver}/${user}/${repo}.git`], { cwd: instanceroot + '/' + repo }]
]
}
var x = (args) => {
return () => {
// console.log(args)
return nodeShellExec.apply(null, args)
}
// return Promise.resolve(true)
}
var perform_init_gitea = (dir) => {
op['is-git-repo'](dir).then((code) => {
// console.log(code)
if (code) {
nodeShellExec('git', ['remote', 'get-url', 'chess'], { cwd: dir.name, stdio: 'ignore' }).then(() => {
console.log('skipped : ' + dir.name + ', reason : Already has remote chess ')
})
.catch((e) => {
any(serial_perform_init_gitea(dir.name).map(x))
})
}
// else console.log('Skipped : Not a Git Repo : ' + dir.name)
}).catch((e) => {
// console.log('Failed : ' + dir.name)
})
}
const { readdir } = require("fs").promises
dirs(perform_init_gitea)
}
, 'syncmaster': (label) => {
// Usage :
// elxr pull -- Defaults to run config
var env = Object.assign({}, process.env); // Shallow clone it.
// console.dir(env)
console.log('Running exlr pull : ' + path.dirname(__dirname))
if (!processedArgs.runas) gitRepos.map((def) => performPull(def.repo, def.branch || 'master'))
if (__isElevated) {
return any(elevatedRunasRepos.map((def) => performPull(def.repo, def.branch || 'master'))).then(() => {
fs.writeFileSync('run.done', 'success')
}).catch(() => {
fs.writeFileSync('run.done', 'error')
})
}
else return op['runas']()
}
, 'pull' : (label) => {
// Usage :
// elxr pull -- Defaults to run config
return elxr.getpulltask()()
}
, 'isInstalled': () => {
return nodeShellExec('where', [processedArgs._[1]], { inherit: true }).then(() => {
console.log(processedArgs._[1] + ' exists.')
return true;
});
}
, 'i' : () => {
var tasks = []
// tasks.push(op['pull']);
tasks.push(getShellTask.apply(null, ['rm', [instanceroot + '/run.js'], { ignorefailures: true }]))
tasks.push(op['use'])
if (!__isElevated) {
tasks.push(op['npmi'])
}
// var tasksdefs = [
// ['elxr', ['pull']]
// , ['elxr', ['use', 'elixir']]
// , ['elxr', ['npmi']]
// ]
// tasksdefs.forEach(tasksdef=>{
// tasks.push( ()=> nodeShellExec.apply(null, tasksdef) )
// })
return any(tasks);
}
, 'npmi': () => {
var tasks = [];
// Build fails without babel...
tasks.push(getShellTask(
'npm',[ 'i', '-g', 'babel-cli' ]
) )
var npmbuildrepos = ['loopback-jsonapi-model-serializer']
npmbuildrepos = []
npmbuildrepos.forEach(repo => {
tasks.push(() => {
return nodeShellExec('npm', ['i --force'], {
inherit: true, shell: true
, cwd: instanceroot + '/' + repo
, env: process.env
, title: `npm i for ${repo}`
}).catch((e) => {
console.error('Ignoring Benign Error'); console.error(e);
}).then(() => {
console.log(`--npm run build for ${repo}--------------------`)
return nodeShellExec('npm', ['run build'], {
inherit: true, shell: true
, cwd: instanceroot + '/' + repo
, env: process.env
, title: `npm run build for ${repo}`
}).then(Tasq.then).catch(Tasq.catch)
})
})
})
any(tasks).then(() => {
gitRepos.push('client/server');
gitRepos = gitRepos.concat(elevatedRunasRepos);
// gitRepos = [
// // 'bbhverse', 'serververse', 'elixir-server',
// // 'clientverse',
// 'client'
// ];
var rmtasks = []
var repotasks = []
var env = Object.assign({}, process.env)
delete env.NODE_ENV
gitRepos.forEach(repodef => {
rmtasks.push(
// () => {
// console.log(`--rm package-lock.json for ${repodef.repo}--------------------`)
// return nodeShellExec(`"${gitbash}"`, ['-c', '"rm package-lock.json"'], {
nodeShellExec('rm', ['package-lock.json'], {
inherit: true, shell: true
, cwd: instanceroot + '/' + repodef.repo
, env: process.env
, title: `rm 'package-lock.json' for ${repodef.repo}`
})
.then(()=>{
console.log(`--rm package-lock.json for ${repodef.repo}--------------------`)
}).catch((e) => { console.error(e) })
// }
)
if (npmbuildrepos.indexOf(repodef.repo) < 0) {
repotasks.push(
() => {
console.log(`--npm i for ${repodef.repo}--------------------`)
var p = nodeShellExec('npm', ['i', '--force'], {
inherit: true, shell: true
, cwd: instanceroot + '/' + repodef.repo
, env
, title: `npm i for ${repodef.repo}`
}).then(Tasq.then).catch(Tasq.catch)
return p;
})
}
})
// PB : NOTE -- npm i for client does not complete when NODE_ENV=production
// therefore bower doesn't get installed !!! which then fails installing the bower dependenciew !!!
// We work around this by running npm i for client without any NODE_ENV which probably defualts to development.
// PB : TODO -- Investigate why NODE_ENF has an impact on npm i !??
// Second time try also doesnt work.
// repotasks.push(
// () => {
// var env = Object.assign({}, process.env)
// delete env.NODE_ENV
// console.log(`--------------------second time npm i for client--------------------`)
// return nodeShellExec(`"${gitbash}"`, ['-c', '"npm i --force"'], {
// // return nodeShellExec('npm', ['i --force'], {
// inherit: true, shell: true
// , cwd: instanceroot + '/' + 'client'
// , env
// , title: `npm i for client`
// }).then(Tasq.then).catch(Tasq.catch)
// })
var bowerRepos = [{ repo : 'client'}]
bowerRepos.forEach(repodef => {
repotasks.push(() => {
console.log(instanceroot + '/' + repodef.repo + '/node_modules/bower/bin/bower')
// var p = nodeShellExec('node_modules/bower/bin/bower', ['install'], {
var p = nodeShellExec(`"${gitbash}"`, ['-c', '"node_modules/bower/bin/bower i"'], {
inherit: true, shell: true
, cwd: instanceroot + '/' + repodef.repo
, env: process.env
, title: `bower i for ${repodef.repo}`
}).then(Tasq.then).catch(Tasq.catch)
return p;
})
})
// console.log('rmtasks.length : ' + rmtasks.length)
return Promise.all(rmtasks).then(() => any(repotasks));
}).catch(e => {
}).finally(statuslog.finally)
}
, 'start': (label) => {
console.log('Starting Elixir Server.');
var env = Object.assign({}, process.env); // Shallow clone it.
// console.dir(env)
env.NODE_ENV = process.env.NODE_ENV || 'development';
env.DEBUG = 'loopback:connector:' + dbForLabel(label)
var cmd = env.NODE_ENV === 'development' ? 'nodemon' : 'node';
// cmd = 'node'
cmd = [cmd, ['--inspect=9228', 'elixir/server.js']]
var childPromise = nodeShellExec(...cmd, {
// inherit : true,
shell: true,
detached: true,
stdio: 'ignore',
cwd: instanceroot + '/' + 'elixir-server'
, env: env
})
var child = childPromise.process;
if (typeof child.pid !== 'undefined') {
console.log(`started Elixir Server PID(${child.pid}) : NODE_ENV=${process.NODE_ENV} ${cmd}`);
fs.writeFileSync('.elixir-server.elixir.server.pid', child.pid, {
encoding: 'utf8'
})
}
// nodeShellExec('node', ['--inspect=9226', ' bin/www'], {
// inherit : true,
// shell: true, detached: true,
// cwd : 'qms/server',
// env: env,
// shell : true
// })
// nodeShellExec('ember', ['s'], {
// // inherit : true,
// shell: true, detached: true,
// cwd : 'client/',
// env: env
// })
console.log('Starting Elixir Client Host.');
var cmd = ['ember', ['s']]
var childPromise = nodeShellExec(...cmd, {
// var childPromise = nodeShellExec('node', ['--inspect=9227', './node_modules/.bin/ember', 's'], {
// PB : TODO -- ember debugging.
// inherit : true,
shell: true,
detached: true,
stdio: 'ignore',
cwd: instanceroot + '/' + 'client'
, env: env
})
// .catch(e=>console.error(e))
child = childPromise.process;
if (typeof child.pid !== 'undefined') {
console.log(`started Elixir Client Host PID(${child.pid}) : NODE_ENV=${process.NODE_ENV} ${cmd}`);
fs.writeFileSync('.client.server.pid', child.pid, {
encoding: 'utf8'
})
}
}
, 'stop': (label) => {
const kill = require('tree-kill');
var serverPid = fs.readFileSync('.elixir-server.elixir.server.pid', {
encoding: 'utf8'
})
fs.unlinkSync('.elixir-server.elixir.server.pid')
console.log(serverPid)
kill(serverPid)
serverPid = fs.readFileSync('.client.server.pid', {
encoding: 'utf8'
})
fs.unlinkSync('.client.server.pid')
console.log(serverPid)
kill(serverPid)
}
, 'model' : () => {
if (__isElevated) {
var tasks = [
() => {
var p = nodeShellExec('mklink', [ `${processedArgs._[2]}.json`
, `..\\..\\node_modules\\chess-server-lib\\common\\models\\${processedArgs._[2]}.json`], {
inherit: true, shell: true
, cwd : instanceroot + `/${selectedinstance.instanceName}-server/${selectedinstance.instanceName}/models`
, title: `mklink ${processedArgs._[2]}.json ..\\..\\node_modules\\chess-server-lib\\common\\models\\${processedArgs._[2]}.json`
, env: process.env
}).catch((e) => { console.error(e) })
return p;
}
];
return any(tasks).then(() => {
fs.writeFileSync('run.done', 'success')
}).catch(() => {
fs.writeFileSync('run.done', 'error')
})
}
else return op['runas']()
}
, 'use' : () => {
// use a certain named instance.
// Eg :
// 1) elxr use elixir
// 2) elxr use cihsr
// If environment is not specified defaults to development.
// 1) NODE=test elxr use elixir
/*// Steps
1) Delete Config and Data symlinks
2) Make Links for config ({{name}}-config-{{node_env}}) and data with the NODE_ENV specified or default to dev
3) Iterates all repos and pull all. 'git', ['pull', '--all'].
4) Iterates all repos and checkout to the ENV specified. 'git', ['checkout', checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV]
5) Iterates all repos and merge from source configured in mergesource. 'git', ['merge', mergesource],
*/
var runconfig = { NODE_ENV: repomanifest.node_env }
try { runconfig = Object.assign(runconfig, require(instanceroot + '/run.js')) } catch (e) { }
// We no longer need to check ruans.. ??? if we were initiated from self invoked privileged shell ?
if (( /*processedArgs.runas && processedArgs.runas !== 'self' &&*/ !processedArgs.force) &&
runconfig.NODE_ENV && runconfig.NODE_ENV === (repomanifest.node_env || runconfig.NODE_ENV) &&
repomanifest.instanceName && runconfig.use === repomanifest.instanceName) {
console.log(`No change detected. Already using requested specs : ${runconfig.NODE_ENV} ${runconfig.use}`)
if (processedArgs.runas) { fs.writeFileSync('run.done', 'success') }
return
}
var tasks = [
() => {
if (existsSync('config')) {
var p = nodeShellExec('rmdir', ['config'], { inherit: true, shell: true, env: process.env }
).catch((err) => { console.log('Ignoring benign error : ' + err); return true; })
return p;
}
else return Promise.resolve(true);
},
() => {
if (existsSync('data')) {
var p = nodeShellExec('rmdir', ['data'], { inherit: true, shell: true, env: process.env }
).catch((err) => { console.log('Ignoring benign error : ' + err); return true; })
return p;
}
else return Promise.resolve(true);
},
];
runconfig.NODE_ENV = process.env.NODE_ENV = process.env.NODE_ENV || runconfig.NODE_ENV || 'development';
if (processedArgs._[1] && runconfig.use !== processedArgs._[1]) runconfig.use = processedArgs._[1];
if (!runconfig.use) { throw 'unspecifed use not allowed. Please specify chess instance name.' }
// console.log(process.env.cwd)
fs.writeFileSync(instanceroot + '/run.js', 'module.exports = ' + JSON.stringify(runconfig))
// Maps an environment to a branch. Not required if the branch is appropriately named.
var checkoutMap = { 'development': 'master' }
var branch = checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV
var performPullOrCloneForBranch = (def)=>{
var promise = Promise.resolve(true)
if (!branch) {
var dscoverbranchcmd = gitops.getdiscoverbranchcmd(repo)
promise = nodeShellExec.apply(null, dscoverbranchcmd(repo)).then(__branch=>{ branch = __branch})
.catch((e) => { console.error(e); return { error: true, message: repo } })
}
return promise = promise.then(()=>{ return elxr.getpulltask(def)() }).catch(e => { console.error( 'performPullOrCloneForBranch : Failed ' + e )})
}
var performCloneAndCheckout = null;
// cant use git checkout -b it fails when branch already exists.
var performCheckout = performCloneAndCheckout = (def) => {
if (excludeCheckouts[def.repo]) return Promise.resolve({ 'skipped': true })
return performPullOrCloneForBranch(def).then(()=>{
nodeShellExec('git', ['checkout', def.branch || checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV], {
// return nodeShellExec('git', ['switch', '-m', '-C', checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV], {
// inherit : true, shell: true,
cwd: instanceroot + '/' + def.repo
// , stdio : ignore // Use when we want to silence output completely.
, runas: processedArgs.runas
, title: `git checkout ${def.branch || checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV} for ${def.repo}`
}).then(()=>{ console.log( `SUCCESS : git checkout ${def.branch || checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV} for ${def.repo}` ) }).catch((e) => { console.error(e); return { error: true, message: def.repo } })
})
}
// var enqueueCheckout = function(def){ enqueue(elevatedqueue, performCheckout, def) }
// var enqueueMerge = function(def){ enqueue(elevatedqueue, performMerge, def) }
var elevatedqueue = [];
var enqueueOnce = (queue, task, def) => {
var found = queue.find(element => {
var keys = Object.keys( element )
for(var k=0; k < keys.length; k++) {
if(element[keys[k]] !== def[k]) return false;
}
})
queue.push(function(){ return task(this)}.bind(def));
}
var enqueue = (queue, task, def) => {
queue.push(function(){ return task(def)}.bind(def));
}
var mergeSources = {
'development': null,
'test': 'master',
'production': 'master'
}
var mergesource = mergeSources[checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV]
// Checkout is reduced to pull provided the current branch is the targetbranch
if(branch === mergesource) performCheckout = (def) => {
var dscoverbranchcmd = gitops.getdiscoverbranchcmd(repo)
return nodeShellExec.apply(null, dscoverbranchcmd(repo)).then(__branch=>{
if(branch === __branch) return performCloneAndCheckout(def)
return performPullOrCloneForBranch(def)
})
.catch((e) => { console.error(e); return { error: true, message: repo } })
}
// else performCheckout = (def) => { return performPullOrCloneForBranch(def) }
var performPullAll = (def) => {
if (excludeCheckouts[def.repo]) return Promise.resolve({ 'skipped': true })
return nodeShellExec('git', ['pull', '--all'], {
// inherit : true, shell: true,
cwd: instanceroot + '/' + def.repo
, runas: processedArgs.runas
, title: `git pull -all for ${checkoutMap[runconfig.NODE_ENV] || runconfig.NODE_ENV} ${def.repo}`
}).catch((e) => { console.error(e); return { error: true, message: def.repo } })
}
var excludeCheckouts = Object.assign(exludeMergeRepos)
delete excludeCheckouts[`elixir-config-${runconfig.NODE_ENV}`]
delete excludeCheckouts[`cihsr-config-${runconfig.NODE_ENV}`]
var performMerge = (def) => {
if (exludeMergeRepos[def.repo]) return Promise.resolve({ 'skipped': true })
return nodeShellExec('git', ['merge', mergesource], {
inherit: true, shell: true,
cwd: instanceroot + '/' + def.repo
, runas: processedArgs.runas
}).catch((e) => { console.error(e) })
}
if(!mergesource || branch === mergesource) performMerge = () => { return Promise.resolve(true) }
// var performRepoOperation = function(def) {
// elevatedRunasRepos.map((repo) => enqueueCheckout({ repo, branch: def.branch, requiresElevation : true }))
// return any(gitRepos.map((repo) => performCheckout({ repo, branch: def.branch})))
// }
return any(tasks).then(() => {
var pr = Promise.resolve(true)
if (!__isElevated) {
pr = op['runas']()
return pr.then(()=>{
//target is the env is we specify in elxr use command. Default is dev
//Switch to target branch
return any(gitRepos.map((repodef) => { return performCheckout({ repo : repodef.repo, branch}).catch(e=>{ console.log(e); }) } ))
// pull or clone target branch
.then(() => {
if(!mergesource || branch === mergesource) return Promise.resolve(true)
return any(gitRepos.map((repo) => performPullAll(repo)))
})
// switch to source branch
.then( () => {
if(!mergesource || branch === mergesource ) return Promise.resolve(true) // Dont do anything if there is no source to merge from.
return any(gitRepos.map((repodef) => performCheckout({ repo : repodef.repo, branch: mergesource})))
})
//Pull on merge source branch
.then( () => {
if(!mergesource || branch === mergesource ) return Promise.resolve(true)
return any(gitRepos.map((repo) => performPullAll(repo)))
})
//Switch to target branch
.then( () => {
if(!mergesource || branch === mergesource ) return Promise.resolve(true)
return any(elevatedRunasRepos.map((repodef) => performCheckout({ repo : repodef.repo, branch})))
})
.then( //Merge source branch to target branch
() => {
if(!mergesource || branch === mergesource) return Promise.resolve(true)
return any(gitRepos.map((repo) => performMerge( repo ))).catch(err => { console.error('error in performMerge ' + err) })
})
})
}
else {
tasks = [
() => {
// Use junctions to avoid npm package issues
var p = nodeShellExec('mklink', ['/J', 'config', runconfig.use + '-config' + '-' + process.env.NODE_ENV], {
inherit: true, shell: true
, cwd : instanceroot
, env: process.env
}).catch((e) => { console.error(e) })
return p;
}
];
if (processedArgs._[1]) {
tasks = tasks.concat(
[
() => {
var p = nodeShellExec('mklink', ['/J', 'data', runconfig.use + '-data'], {
inherit: true, shell: true
, cwd : instanceroot
, env: process.env
}).catch((e) => { console.error(e) })
return p;
}
]
)
}
return any(tasks).then(()=>{
// checkout target branch
return any(elevatedRunasRepos.map((repodef) => performCheckout({ repo : repodef.repo, branch, requiresElevation : true})))
// pull or clone target branch
.then(() => {
if(!mergesource || branch === mergesource) return Promise.resolve(true)
return any(elevatedRunasRepos.map((repo) => performPullAll(repo)))
})
// switch to source branch
.then( () => {
if(!mergesource || branch === mergesource) return Promise.resolve(true)
return any(elevatedRunasRepos.map((repodef) => performCheckout({ repo : repodef.repo, branch: mergesource, requiresElevation : true})))
})
//Pull on merge source branch
.then( () => {
if(!mergesource || branch === mergesource) return Promise.resolve(true)
return any(elevatedRunasRepos.map((repodef) => performPullAll({repo : repodef.repo, requiresElevation : true })))
})
//Switch to target branch
.then( () => {
if(!mergesource || branch === mergesource) return Promise.resolve(true)
return any(elevatedRunasRepos.map((repodef) => performCheckout({ repo : repodef.repo, branch, requiresElevation : true})))
})
.then( //Merge source branch to target branch
() => {
if(!mergesource || branch === mergesource) return Promise.resolve(true)
return any(elevatedRunasRepos.map((repodef) => performMerge({ repo : repodef.repo, requiresElevation : true }))).catch(err => { console.error('error in performMerge ' + err) })
})
.then(() => {
fs.writeFileSync('run.done', 'success')
}).catch(() => {
fs.writeFileSync('run.done', 'error')
})
})
}
}).catch(() => {
fs.writeFileSync('run.done', 'error')
})
// Antibiotic stewardship program.
// 1st use is fine.
// Max vials dispense
// 2nd use Pharmacy needs justification Form.
// Approval after a certain period of time.
}
, 'g': () => {
if (processedArgs.h) {
console.log('elxr g [modelname] => generate a model named [modelname]');
console.log('elxr g => regenerate all known models');
return
}
// var child = nodeShellExec('mkdir', ['-p', label], { inherit : true} );
// console.log('Starting directory: ' + process.cwd());
// try {
// child = child.on('close', () => { process.chdir(label) } );
// console.log('New directory: ' + process.cwd());
// }
// catch (err) {
// console.log('chdir: ' + err);
// }
// child.on('close', function(){
// var options = {
// shell : true
// , inherit : true
// // , cwd : '' + process.cwd
// // , env : process.env
// };
// nodeShellExec('git', ['init'], { inherit : true});
if (0) {
// PB : TODO -- Special google chrome profile for tests etc.
nodeShellExec('pwd', { inherit: true });
// /c/Program\ Files\ \(x86\)/Google/Chrome/Application/chrome.exe --user-data-dir=/c/chess/instances/elixir_01/data/Google/Chrome/User\ Data --profile-directory="chess"
// "C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" --user-data-dir="C:\chess\instances\elixir_01\data\Google\Chrome\User Data" --profile-directory="chess" http://localhost:4200/admin/crud/create/item
// "C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" --user-data-dir="C:\chess\instances\elixir_01\data\Google\Chrome\User Data" --profile-directory="chess" http://localhost:4200/tests/index.html?grep=loopback
nodeShellExec("C:/Program Files (x86)/Google/Chrome/Application/chrome.exe", [
"--profile-directory=Profile 1"
, 'http://localhost:4200/tests/index.html?grep=model convert ember to loopback' + '&filter=none' /*+ '&filter=model convert ember to loopback'*/]);
}
// nodeShellExec('npm', ['init', '-y'], options);
// nodeShellExec('npm', ['init', '-y'], options);
// })
var g = {
'client': () => {
console.info('Creating new ember client named : ' + processedArgs._[2]);
var step1 = nodeShellExec('cmd', ['/c', 'ember', 'new', processedArgs._[2]], {
stdio: ['pipe', process.stdout, process.stderr],
inherit: true,
shell: true,
cwd: path.dirname(__dirname),
env: env
})
},
'modelr': () => {
var tasks = [
() => {
var p = nodeShellExec('"ember"', [
'g'
, 'modelr'
, processedArgs._[2]], {
inherit: true, shell: true, env: process.env
}).then(() => {
console.log('Blueprint generation complete for : ' + processedArgs._[2])
return true;
}).catch((e) => { console.error(e) })
return p;
},
() => {
var chromePrefsFile = "C:\\chess\\instances\\elixir_01\\data\\Google\\Chrome\\User Data\\chess\\Preferences";
var chromeprefs = fs.readFileSync(chromePrefsFile, { encoding: 'utf8' })
chromeprefs = JSON.parse(chromeprefs)
var previous = chromeprefs.download.default_directory;
var parentDir = path.dirname(__dirname);
chromeprefs.download.default_directory = parentDir + "\\client\\app\\templates\\components\\resource";
fs.writeFileSync(chromePrefsFile, JSON.stringify(chromeprefs))
// PB : TODO -- detect where chrome is installed.
// PB : TODO -- set the download dir to the place where files are needed.
var p = nodeShellExec('"C:/Program Files (x86)/Google/Chrome/Application/chrome.exe"', [
'--user-data-dir="C:\\chess\\instances\\elixir_01\\data\\Google\\Chrome\\User Data"'
, '--profile-directory="chess"'
, 'http://localhost:4200/admin/crud/create/' + processedArgs._[2]], {
inherit: true, shell: true
, env: process.env
}).then(() => {
chromeprefs.download.default_directory = previous;
fs.writeFileSync(chromePrefsFile, JSON.stringify(chromeprefs))
return true;
}).catch((e) => { console.error(e) })
return p;
}
,
() => {
console.log('Browser process should have closed here....')
return true;
}
]
any(tasks)
}
}
g[processedArgs._[1]]();
}
}
var util = require('util')
var cliname = 'elxr';
var ver = '1.1';
var help = `# list of commands... please refer dveloper documentation for ${cliname}
${
// util.inspect(
[Object.keys(op)]
// )
}
`;
var elxr = {
help() {
return chalk.cyanBright(`
-------------------------------------------------------------------------------
*** BBH Elixir ***
-------------------------------------------------------------------------------
elxr ${ver}
A cli tool for chess
${help}
-------------------------------------------------------------------------------
`)
}
, info() {
return chalk.cyanBright(`
-------------------------------------------------------------------------------
*** BBH Elixir ***
-------------------------------------------------------------------------------
elxr ${ver}
A cli tool for chess
-------------------------------------------------------------------------------
`)
}
, getpulltask(def){
def = def || {
requiresElevation : true,
reqularRepos : gitRepos,
elevatedRepos : elevatedRunasRepos
}
console.log(`-------------------Processing pull for : ${def.repo} ${def.branch}`)
console.dir(def)
var env = Object.assign({}, process.env); // Shallow clone it.
console.log('Running exlr pull : ' + path.dirname(__dirname))
var useGitPull = processedArgs.useGitPull || false;
if(def.elevatedRepos || def.reqularRepos) {
if(def.elevatedRepos) def.requiresElevation = true;
else delete def.requiresElevation;
}
else {
if(def.requiresElevation) def.elevatedRepos = [def]
else def.reqularRepos = [def]
}
var elevatedpulltasks = null;
var regularpulltasks = function(){ return Promise.resolve(true) }
if(def.elevatedRepos){
elevatedpulltasks = function() {
return any(def.elevatedRepos.map((def) => performPull(def.repo))).then(() => {
// fs.writeFileSync('run.done', 'success')
return true;
}).catch((e) => {
console.error(e)
fs.writeFileSync('run.done', 'error')
})
}
}
if(def.reqularRepos) {
var regularpulltasks = function(){
var pendingpulls = [];
def.reqularRepos.forEach((def) => { pendingpulls.push(performPull(def.repo)) })
return Promise.all(pendingpulls).finally(Traq.finally)
}
}
if(elevatedpulltasks) return getTaskWithElevation( { elevatedpulltasks, regularpulltasks} )
else return getTaskWithoutElevation({ regularpulltasks})
}
}
// The main elxr cli process
function elxrworker() {
// Everything runs after this check is completed. Elevation occurs out of process when needed.
gitRepos = repomanifest.repos
// gitRepos = ['chess-server-lib'];
// Repositiories that have symlinks that require elevated priviletes in windows to create symlinks
elevatedRunasRepos = repomanifest.elevated
// Repos that should excluded from merge for releases...
exludeMergeRepos = repomanifest.exludeMergeRepos
var env = Object.assign({}, process.env); // Shallow clone it.
var __runcmd = function (label) {
return op[label] ? op[label]() : null;
}
// mysqldump --add-drop-table --no-data -u root -p db_name | grep 'DROP TABLE' ) > drop_all_tables.sql
// mysql -u root -p db_name < drop_all_tables.sql
var mysql = '../xampp/mysql/bin/mysql'
var mysqldump = '../xampp/mysql/bin/mysqldump'
// --runas
if (processedArgs.runas) {
// Weve been asked to run in priviledged mode. Check if we already are privileged.
return __runcmd('runas')
}
else return __runcmd(processedArgs.label || processedArgs._[0] || 'h');
}
var getManifest = function () {
// Once choices are made we need to load config according to those choices.
// No trace of a previous run...
// Default Config...
return repomanifest = selectedinstance;
}
function acquireChoices(selectedinstance) {
var hasconfig = false;
console.warn(chalk.yellow(`
-------------------------------------------------------------------------------
Warning : Cannot locate your preferred configuration since it was not specified
You should fork the default chess configuration to customize and make it
your own instance with a named config as
{{yourowninstancename}}-config-{{yourcurrentenvironment}}
And then run this tool as follows
NODE_ENV={{yourenvironment}} elxr i {{yourowninstancename}}
OR
Run this tool with the following command to use a quick start default.
node elxr --default
OR
Choose the the option to create a new instance for you interactively.
We will run your choice of default or create your own at the next prompt.
-------------------------------------------------------------------------------
`))
var prompt = cli.prompter;
return prompt.ask(`Choose an option :
d) Install the default chess instance.
=> elxr i chess node_env=development --default
n) Create your custom new instance interactively
=> elxr i {{instanceName}} node_env={{environment}}
i) Choose an instance and environment to install
=> elxr i {{instanceName}} node_env={{environment}}
c) Choose a command to run ( pull, use, i, npmi ... ) <= pull
=> elxr {{cmd}} {{instanceName}} node_env={{environment}}
h) Help
q) Quit
Default <= d
: `).then((choice) => {
prompt.close();
if (choice && choice === 'd' || !choice) {
processedArgs._[0] = 'i'
selectedinstance.instanceName = processedArgs._[1] = processedArgs._[1] || 'chess'
selectedinstance.node_env = processedArgs.node_env = (process.env.NODE_ENV && process.env.NODE_ENV.trim()) || processedArgs.node_env || 'development'
selectedinstance.reposerver = 'https://git.bbh.org.in'
getManifest() // PB : TODO -- acquire the manifest directly from http url instead of clone before cloning the config. Since
// This is because the manifest at any server location can redirect to the preferred server..
}
else if (choice === 'h') {
processedArgs._[0] = 'h'
fs.writeFileSync('run.done', 'noop help');
console.log(elxr.help()); process.exit()
}
else if (choice === 'n' || choice === 'i') {
var p1 = cli.prompter;
return p1.ask(`Enter Instance Name ( <= ${selectedinstance.instanceName} ) : `).then(function (instanceName) {
processedArgs._[0] = 'i'
selectedinstance.instanceName = processedArgs._[1] = instanceName || selectedinstance.instanceName;
return p1.ask(`Enter Environment ( <= ${selectedinstance.node_env} ) : `).then(function (node_env) {
selectedinstance.node_env = processedArgs.node_env = node_env || selectedinstance.node_env
if (choice === 'n') {
selectedinstance.reposerver = 'https://git.bbh.org.in'
console.warn(
chalk.magenta('No Option Available. Your account may not have privileges. You can request here http://git.bbh.org.in/chess'))
process.exit();
}
return p1.ask(`Enter preferred repo server ( <= ${selectedinstance.reposerver || selectedinstance.reposervers[0]} ) : `).then(function (reposerver) {
p1.close()
selectedinstance.reposerver = reposerver || selectedinstance.reposervers[0] || 'https://git.bbh.org.in'
})
})
})
} else if (choice === 'c') {
var p1 = cli.prompter;
return p1.ask(`Enter Instance Name ( <= ${selectedinstance.instanceName} ) : `).then(function (instanceName) {
selectedinstance.instanceName = processedArgs._[1] = instanceName || selectedinstance.instanceName
return p1.ask(`Enter Environment ( <= ${selectedinstance.node_env} ) : `).then(function (node_env) {
selectedinstance.node_env = processedArgs.node_env = node_env || selectedinstance.node_env
return p1.ask(`Enter cmd :
p) pull
Default <= p
: `).then(function (cmd) {
if (!cmd || cmd === 'p') {
processedArgs._[0] = 'pull'
}
else processedArgs._[0] = cmd
return p1.ask(`Enter preferred repo server ( <= ${selectedinstance.reposerver || selectedinstance.reposervers[0]} ) : `).then(function (reposerver) {
selectedinstance.reposerver = reposerver || selectedinstance.reposervers[0] || 'https://git.bbh.org.in'
p1.close()
})
})
})
})
} else {
console.log(chalk.gray(`Default option not exercised. Please follow manual instructions to customize your instance here http://git.bbh.org.in/chess and try again.`));
fs.writeFileSync('run.log', ', ' + JSON.stringify({ success: 'quit without execution' }), { 'flag': 'a+' })
fs.writeFileSync('run.done', 'noop quit');
process.exit()
}
})
}
var acquireConfig = function (selected, chessinstances) {
var configrepo = selected.instanceName + '-config-' + selected.node_env;
return performPull(configrepo).then(() => {
var manifestpath = path.normalize(selected.root + '/' + selected.instanceName + '-config-' + selected.node_env + '/repo-manifest');
repomanifest = require(manifestpath)()
chessinstances = chessinstances || {};
chessinstances[selected.instanceName] = chessinstances[selected.instanceName] || {}
chessinstances[selected.instanceName][selected.node_env] = chessinstances[selected.instanceName][selected.node_env] || {}
chessinstances['current_run'] = { instanceName: selected.instanceName, node_env: selected.node_env }
// Config from server always override merges into selection ecept for the current selection.
selectedinstance = utils.assign(chessinstances[selected.instanceName][selected.node_env], selected, repomanifest)
fs.writeFileSync(instanceroot + '/chessinstances.js', 'module.exports = ' + JSON.stringify(chessinstances, null, 2) + '', { 'flag': 'w' })
// PB : TODO -- We should probably write the new server config also...
selectedinstance.reposerver = selectedinstance.reposerver || selectedinstance.reposervers[0] // PB : TODO -- Attempt first one that is available and online...
ENV.NODE_ENV = selectedinstance.node_env;
})
.catch((e) => {
console.error(e)
console.error('Config acquisition failed.')
})
}
var launchpath = process.cwd().replace(/\\/, '/')
var thisscriptdir = __dirname
var instanceroot = launchpath;
var detectInstance = function () {
console.log(`launchpath = ${launchpath}`)
console.log(`thisscriptdir = ${thisscriptdir}`)
var root = launchpath;
// We need a reference to the root director for elxr cli to be properly oriented.
if ((launchpath + path.normalize('/elxr')) === thisscriptdir) {
// We ran unbuilt from the proper root with elxr subfolder.
console.log(`Instance Path : ${root}`)
}
else {
if (launchpath === thisscriptdir) {
// Same directory doesn't mean we are being run from elxr directory or the root directory.
// It could be a standalone elxr build which may or maynot be in the proper location.
if (BUILD_VERSION.indexOf('Version: {version} - built on {date}') > -1) {
// Unbuilt therefore we are in the elxr directory.
root = path.normalize(launchpath + '/..');
}
else {
// Built version.
// check if we have a elxr subfolder.
if (fs.existsSync(launchpath + '/..' + path.normalize('/elxr'))) {
// Probably in the right place.
root = path.normalize(launchpath + '/..');
}
else {
// Assume launchpath is meaningless.
// Figure it out from the input instance name and environment parameters if we are in the right location.
root = path.normalize(launchpath + '/' + processedArgs._[1] + '/' + processedArgs.node_env)
}
}
}
}
instanceroot = root.replace(/\\/, '/');
__default.root = root;
return Promise.resolve(__default);
}
//
var __default = {
// Default is public server only.
// All public repos are by default available.
reposervers: ['https://git.bbh.org.in']
, repos: [
'setup'
, 'elxr'
, 'loopback-connector-mysql'
, 'loopback-jsonapi-model-serializer'
, 'loopback-component-jsonapi'
, 'ember-service-worker'
, 'ember-service-worker-asset-cache'
, 'ember-service-worker-cache-fallback'
, 'ember-service-worker-index'
, 'ember-sw-client-route'
]
, elevated: []
, exludeMergeRepos: {}
, instanceName: 'chess'
// Runas windowshta clobbers and removes the NODE_ENV !!! We therefore pass it in.
, node_env: 'development'
}
var __interactve_promts = {
get reposerver(){
return cli.prompt(this.reposervers, 'git default repo').then(reposerver => {
Object.defineProperty(this, 'reposerver', {
value: reposerver,
writable: false,
configurable : true
});
return reposerver
})
}
, set reposerver(reposerver){
Object.defineProperty(this, 'reposerver', {
value: reposerver,
writable: false,
configurable : true
});
return reposerver
}
}
var downloadsdir = '../Downloads';
var prerequisites = [
{
shellcmd: 'git',
url: 'https://github.com/git-for-windows/git/releases/download/v2.31.0.windows.1/Git-2.31.0-64-bit.exe'
, installer: 'Git-2.31.0-64-bit.exe'
, installcmd: ['cmd', ['/c', 'start',
'/WAIT', path.resolve(downloadsdir + '/' + 'Git-2.31.0-64-bit.exe')
, '/VERYSILENT'
// , '/MERGETASKS=!runcode' // This is required only for vscode...
]]
, preinstallsteps: function() {
var prompt = cli.prompter;
var steps = [
() => {
if (!existsSync(downloadsdir + '/' + this.installer)) {
return nodeShellExec(`${selectedinstance.root}/.elxr/run-${runtimestamp}/download.bat`, [this.url, downloadsdir + '/' + this.installer])
}
else return Promise.resolve(true)
}
]
var prompts = [
() => prompt.ask(`git user name : ( <= ${gitUser} )`).then((user) => { gitUser = user; })
, () => prompt.ask(`git email : ( <= ${gitEmail} )`).then((email) => { gitEmail = email; })
]
return any([any(steps), any(prompts)]).then(() => { prompt.close() })
}
, installsteps: function () {
return any([this.installcmd].map(callsheltask))
}
, postinstallsteps: function(){
var prompt = cli.prompter;
var gitUser = 'guest';
var gitEmail = 'guest@bbh.org.in';
var prompts = [];
prompts.push(
()=>{
var choices = { 0 : 'guest', 1 : 'chessdemo' }
return cli.prompt(choices, 'git user name').then(gituser => gitUser = gituser)
}
)
prompts.push(
()=>{
var choices = { 0 : 'guest@bbh.org.in', 1 : 'chessdemo@bbh.org.in' }
return cli.prompt(choices, 'git user email').then(gitemail => gitEmail = gitemail)
}
)
return any(prompts).then(()=>{
var steps = [
['git', ['config', '--global', '--add', 'user.name', `${gitUser}`]]
, ['git', ['config', '--global', '--add', 'user.email', `${gitEmail}`]]
]
return any(steps.map(callsheltask)).then(() => {
})
});
}
, install: function () {
return any([ /*this.preinstallsteps,*/ this.installsteps.bind(this), this.postinstallsteps.bind(this)])
}
, verifyAndInstall : function(){
return getTaskCheckExists(this.shellcmd, { ignorefailures: true })().then((exists) => {
if(exists) {
// return any(['git', ['config', '--global', '-l']].map(callsheltask))
return this.getUser(null, this.postinstallsteps.bind(this))
}
return this.install();
});
}
, getUser : function(repo, onNoResult){
onNoResult = onNoResult || function(){return false}
var globalOrLocal = '--global';
if(!repo) globalOrLocal = '--global';
else globalOrLocal = '--local'
return any([['git', ['config', globalOrLocal, '--get-all', 'user.name']]].map(callsheltask)).then((result)=>{
// not yet configured.
if(!result.success) return onNoResult()
else {
var users = result.messages[0].trim().split('\n');
if(users.length === 0 ||
users.length === 1 && users[0] === 'guest') {
return onNoResult()
}
else return users[0]; // PB : TODO == We should probably prompt with all the users available for selection !
}
})
.catch((e)=>{
console.log(e)
return onNoResult()
})
}
}
,
{
shellcmd: 'node',
url: 'https://nodejs.org/dist/v14.16.0/node-v14.16.0-x64.msi'
, installer: 'node-v14.16.0-x64.msi'
, installcmd: ['MSIEXEC.exe', ['/i'
, path.resolve(downloadsdir + '/' + 'node-v14.16.0-x64.msi')
, 'ACCEPT=YES', '/passive']]
, install : function() { return any([this.installcmd].map(callsheltask)).then(() => { }) }
}
]
prerequisites.forEach(p=>{ prerequisites[p.shellcmd] = p })
function ensureDirectoryExistence(filePath) {
var dirname = path.dirname(filePath);
if (fs.existsSync(dirname)) {
return filePath;
}
ensureDirectoryExistence(dirname);
fs.mkdirSync(dirname);
return filePath;
}
var mainTasks = [];
function verifyAndInstallPrerequisites() {
fs.writeFileSync(ensureDirectoryExistence(path.normalize(`${selectedinstance.root}/${downloadsdir}/readme.txt`)), `${getVersion()} Your local downloads for this instance`)
// PB : TODO include and build from files... using rollup..
var downloadbatch =
`::**************************************************************************
:Download_ <url> <File>
Powershell.exe ^
$AllProtocols = [System.Net.SecurityProtocolType]'Ssl3,Tls,Tls11,Tls12'; ^
[System.Net.ServicePointManager]::SecurityProtocol = $AllProtocols; ^
(New-Object System.Net.WebClient).DownloadFile('%1','%2')
exit /b
::**************************************************************************`
fs.writeFileSync(`${selectedinstance.root}/.elxr/run-${runtimestamp}/download.bat`, downloadbatch)
var windowselevate =
`
<html><HTA:APPLICATION ID="windowselevate" icon="#"/>
<script language="vbscript">
document.title = "elxr control panel"
self.ResizeTo 200,600
Sub Window_Onload
self.MoveTo (screen.availWidth - (document.body.clientWidth + 40)),10
End Sub
Set objShell = CreateObject("WScript.Shell")
Set objENV = objShell.Environment("Process")
dim NODE_ENV
NODE_ENV = objENV("NODE_ENV")
</script>
<script language="javascript">
//WINDOWSTATE="minimize" SHOWINTASKBAR="no" SYSMENU="no" CAPTION="no"
// https://devblogs.microsoft.com/scripting/how-can-i-pass-command-line-variables-to-an-hta-when-it-starts/
// alert(windowselevate.commandLine)
var args = windowselevate.commandLine.split('"').slice(3);
// alert(args)
var processedArgs = { _ : [] }
var namedArgs = [];
for(var item in args){
if(args[item].charAt(0) === '-'){
namedArgs.push(args[item])
var split = args[item].split('=');
processedArgs[split[0].slice(2)] = split[1] || true;
}
else processedArgs._.push(args[item]);
}
// args = args.forEach(function(item){ })
// alert('processedArgs._ : ' + processedArgs._);
// alert(processedArgs.runas);
// PB : TODO -- Convert all the cli args back to string.
var cargs = (processedArgs.debug ? '--inspect-brk=9228' : '') + ' elxr ' + processedArgs._.join(' ') + ' ' + namedArgs.join(' ');
// alert(cargs)
var shell = new ActiveXObject('shell.application');
// alert('launching node privilged. ' + processedArgs['nodepath'])
// shell.ShellExecute('where', 'node', '', '', 10);
shell.ShellExecute('node', cargs, '', 'runas', 1);
// shell.ShellExecute(processedArgs['nodepath'], cargs, '', 'runas', 1);
var fso = new ActiveXObject('Scripting.FileSystemObject');
window.onload = function() {
document.body.style.backgroundColor = 'black';
document.body.style.fontFamily = 'arial';
var log = document.createElement('div');
log.innerHTML='Please Wait';
function l(msg){ log.innerHTML+= msg; };
log.style.color = 'blue';
log.style.width = '95%';
log.id = 'log';
document.body.appendChild(log);
l('<Br/>Current config : ')
l('<Br/>NODE_ENV = ' + NODE_ENV)
l('<Br/>cmd = ' + processedArgs._[0])
processedArgs._[1] === 'use' ? l('<Br/>using = ' + processedArgs._[2]) : null;
l('<Br/><Br/>')
var timer = function(){
l('.');
if(fso.FileExists("run.done")) close();
else window.setTimeout(timer, 1000);
};
window.setTimeout(timer, 3000);
};
</script>
</html>
`
fs.writeFileSync(`${selectedinstance.root}/.elxr/run-${runtimestamp}/windowselevate.hta`, windowselevate)
var downloadtasks = [];
var installtasks = [];
prerequisites.forEach(preq => {
downloadtasks.push(getTaskCheckExists(preq.shellcmd, { ignorefailures: true })().then((exists) => {
if (exists) console.log(`${preq.shellcmd} exists`)
else {
console.log(`${preq.shellcmd} is not installed`)
return preq.preinstallsteps.call(preq).then(() => {
installtasks.push(preq.install.bind(preq))
})
}
}))
})
return Promise.all(downloadtasks).then(() => { return any(installtasks) })
}
// function updateselection(selected) { selectedinstance = utils.assign(selectedinstance, selected) }
var selectedinstance = null;
var chessinstances = { current_run : {} };
acquireElevationState().then(() => {
var skipprerequisites = false;
var clioverrides = { }
function initinstances(chessinstances, selected) {
chessinstances.current_run.instanceName = processedArgs._[1] = processedArgs._[1] || chessinstances.current_run.instanceName || selected.instanceName;
chessinstances.current_run.node_env = processedArgs.node_env = processedArgs.node_env || chessinstances.current_run.node_env || selected.node_env;
chessinstances[chessinstances.current_run.instanceName] = chessinstances[chessinstances.current_run.instanceName] || {}
// Override sequence.
// __default, chessinstances[current_run], instanceName-config-development, cliargs, interactve_promts
selectedinstance = Object.assign(
selected
, chessinstances[chessinstances.current_run.instanceName][chessinstances.current_run.node_env]
, clioverrides
// , __interactve_promts -- Cant just override. Also need selectedinstance to be ready...
);
repomanifest = selectedinstance
return chessinstances
}
function acquirelocalinstances(selected){
var chessinstances = utils.assign(require(path.normalize(selected.root + '/chessinstances.js')));
return chessinstances
}
var maintask = () => {
// Default cmd to run !
processedArgs._[0] === processedArgs._[0] || 'pull';
// selectedinstance.reposerver = repomanifest.reposervers[0] // PB : TODO -- Attempt first one that is available and online from all that are available...
return prerequisites.git.verifyAndInstall().then(()=>{
var e = { message : 'verifyAndInstall', success : true}
return acquireConfig(selectedinstance, chessinstances).catch((err) => {
e = err;
console.error('Chosen cofiguraton failed or not found. Fix config and rerun or chose another.')
console.error(err)
}).then(() => { return elxrworker(true) })
// .finally(()=>{
// fs.writeFileSync('run.log', ', ' + JSON.stringify({ error: e.message }), { 'flag': 'a+' })
// if(!e.success) fs.writeFileSync('run.done', 'error');
// // return process.exit()
// })
})
}
const retaincount = 2
var min = runtimestamp;
var collect = []
return detectInstance().then((detectedInstance)=>{
processedArgs._[1] ? clioverrides.instanceName = processedArgs._[1]: null;
processedArgs.node_env ? clioverrides.node_env = (process.env.NODE_ENV && process.env.NODE_ENV.trim()) || processedArgs.node_env
: (process.env.NODE_ENV && process.env.NODE_ENV.trim()) ? clioverrides.node_env = (process.env.NODE_ENV && process.env.NODE_ENV.trim()): null;
selectedinstance = Object.assign(detectedInstance, clioverrides);
var todo = Promise.resolve(true);
try {
chessinstances = acquirelocalinstances(selectedinstance);
initinstances(chessinstances, selectedinstance)
}
catch (e) {
console.error(e)
// No local instances config found. We acquire user choices and proceed to reattempt.
initinstances(chessinstances, selectedinstance)
var prompts = [];
Object.keys(__interactve_promts).forEach(k => {
if(!selectedinstance[k]) {
prompts.push(async ()=>{
Object.defineProperty(selectedinstance, k, Object.getOwnPropertyDescriptor(__interactve_promts, k));
return await selectedinstance[k]
})
}
})
todo = any(prompts).then(()=>{ return selectedinstance })
if(!processedArgs._[0] || !selectedinstance.node_env || !selectedinstance.instanceName){
// Weve been told what to do.
todo = acquireChoices(selectedinstance)
}
todo = todo.then(() => {
try {
chessinstances = acquirelocalinstances(selectedinstance)
initinstances(chessinstances, selectedinstance)
}
catch (e) {
console.error(e)
console.log('No local instances config found in current root = ' + selectedinstance.root);
console.log('A config will be createed with the instance and environment chosen...')
// return (async ()=>{return await __default.reposerver})().then(()=>{
// // selectedinstance = Object.assign(detectedInstance, clioverrides);
// return selectedinstance = Object.assign(__default, selectedinstance);
// })
return selectedinstance
}
})
}
return todo
})
.then(()=>{
if(!__isElevated) {
ensureDirectoryExistence(`${selectedinstance.root}/.elxr/readme.txt`)
// collect garbage
return dirs( (dir)=>{
var matches = /run-(.*)/gm.exec(dir.name)
if(matches) {
if(+(matches[1]) < min) {
min = matches[1]
collect.splice( 0, 0, matches[1] )
}
else collect.push(matches[1])
}
}, `${selectedinstance.root}/.elxr` ).then(()=>{
// delete garbage
if(collect.length > retaincount) {
var asyncs = [];
while((collect.length - asyncs.length) > retaincount) {
asyncs.push(getShellTask('rm',['-rf', `run-${collect[asyncs.length]}`], { cwd : `${selectedinstance.root}/.elxr` })());
}
return Promise.all(asyncs)
}
else return true
})
}
else return true;
})
.then(()=>{
// PB : TODO -- Keep only the last n runs...
// Currently it retains 2*n when proc needs to be relaunched in elevated mode !!!
ensureDirectoryExistence(`${selectedinstance.root}/.elxr/run-${runtimestamp}/download.bat`)
if (!skipprerequisites && !__isElevated) mainTasks.push(verifyAndInstallPrerequisites);
mainTasks.push(maintask)
return any(mainTasks);
})
})
// detect if alread installed -> Take no action.
// download if no installer avalable -> next()
// install
function chackandinstall(items) {
var tasks = []
items.forEach(item => {
tasks.push(getTaskCheckExists(item.shellcommand || prerequisites[item]))
})
return Promise.all(tasks).then(existances => {
existances.forEach((exists, i) => {
if (!exists) {
return downloadandinstall([items[i]])
}
})
})
}
function downloadandinstall(items) {
var tasks = []
items.forEach(item => {
tasks.push(getTaskDownload(item))
})
return Promise.all(tasks)
}
// Sample instances config.
// var instances = {
// "elixir": {
// "production": {
// "reposervers": ["http://git.bbh", "https://git.bbh.org.in"]
// , "repos": ["ember-masonry-grid", "client", "elixir-client"]
// , "exludeMergeRepos": {
// "elixir-config-development": true, "elixir-config-test": true
// , "elixir-config-production": true, "elixir-data": true
// }
// , "instanceName": "elixir", "node_env": "production"
// }
// },
// "current_run": { "instanceName": "elixir", "node_env": "production" }
// }
// ,([^\}^\S\r]*?\}) // Regexp to eliminate extra comma at the end of an array or an object...