const { any } = require('bbhverse'); const fs = require('fs') var cli = require('./cliverse') var nodeShellExec = cli.nodeShellExec; // PB : TODO -- linux prerequistes. // export GIT_SSL_NO_VERIFY=true // npm i -g nodemon // phantomjs": "^2.1.7 // "sass": "^1.32.7", // "node-sass": "^5.0.0", // "ember-cli-sass": "^10.0.1", // "gulp-sass": "^4.1.0", // ember-searchable-select // ember-cli-sass // ember-cp-validatations // ember-cli-yuidoc // yuidoc-ember-theme // chess-server-lib/server // java // client // export NODE_OPTIONS=--openssl-legacy-provider // elixir-client npmi // elixir-client/chess-client-lib npmi // crossfilter2 var __isElevated = null; var shell_verse = { // getCommonTask is agnostic of whether we are running in an elevated shell or not. It runs in either case. getCommonTask( taskToRun ){ return ()=>{ return shell_verse.runTask(taskToRun) }} , runTask : ( taskToRun ) => { if (__isElevated) return shell_verse.runElevated( taskToRun ) else return shell_verse.runNonElevated( taskToRun ) } , elevatedRunner( taskToRun ){ // PB : TODO -- Should be called only when we are in an elevated shell that was already requested from an unelevated shell with a batch of tasks. try { // PB : We do not need IPC in linux. Until a real sudo elevation is required eveything works in non elevated mode... var __runasresult = null; return taskToRun().then((r)=>{ // PB : TODO -- Every elevation should have its own messaging file. Async writes from multiple processes are a problem here... // fs.writeFileSync('run.log', ', ' + JSON.stringify( { info : taskToRun.info, success: true }), { 'flag': 'a+' }) // fs.writeFileSync('run.done', 'success') // PB : TODO -- This should be done conditionally if we are running inproc. return __runasresult = r; }) .catch((e) => { // fs.writeFileSync('run.log', ', ' + JSON.stringify(e), { 'flag': 'a+' }) // fs.writeFileSync('run.done', 'failure') console.error(e) }) .finally(() => { // if(__runasresult && !__runasresult.skipped) fs.unlinkSync('run.done') }) } catch (e) { console.error('Error Invalid command : ' + e) // fs.writeFileSync('run.done', 'error') } finally { } } , getElevatedTask : function( taskToRun ){ return ()=>{ return shell_verse.runElevated(taskToRun) }} , getElevatedTaskInBatch : function( taskToRun ){ return ()=>{ return shell_verse.runElevatedInBatch(taskToRun) }} , runElevatedInBatch : ( taskToRun ) => { if (__isElevated) return shell_verse.elevatedRunner(taskToRun, true) else return shell_verse.requestElevation(shell_verse.elevatedRunner, taskToRun) } , runElevated : ( taskToRun ) => { // Let shell_verse decide whether to Elevate Out of Proc or In Proc // taskToRun by default is the launched command and args. Specially in windows out of proc. // taskToRun = taskToRun || (()=>{ return op[processedArgs.label || processedArgs._[0] || 'undefined'](processedArgs) }) if(taskToRun.processedArgs.skipelevated) return Promise.resolve({ skipped : true }); if(__isElevated) { return shell_verse.elevatedRunner(taskToRun) } else { console.log('Requesting Elevated Privileges'); // requesteElevation is acutally request elevation and run. Both In Proc and Out of Proc. // Linux doesnt require elevation for most commands... return shell_verse.requestElevation(shell_verse.elevatedRunner, taskToRun) } } , runElevatedBatch( batchToRun ){ // In windows we don't need to run each task. We hand over to another shell which in elevated state rebuilds the whole batch and runs. // Irrespective of the batch we just call runElevated once. return any(batchToRun.map(shell_verse.runElevated)) } , getNonElevatedTask : function( taskToRun ){ return ()=>{ return shell_verse.runNonElevated(taskToRun) } } , runNonElevated : ( taskToRun ) => { // Let shell_verse decide whether to Elevate Out of Proc or In Proc if(__isElevated) { return Promise.resolve( 'Skipping regular task in elevated shell.' ) // Regular tasks unless marked as common tasks should not run in elevated shell... } else { // taskToRun by default is the launched command and args. // taskToRun = taskToRun || (()=>{ return op[processedArgs.label || processedArgs._[0] || 'undefined'](processedArgs) }) return taskToRun().then(r=>{ taskToRun.statuslog.statuslog(null, taskToRun.info /*repo*/ ) return r; }).catch((e) => { e.info = taskToRun.info; if(taskToRun.errHandler) throw taskToRun.errHandler(e) taskToRun.statuslog.statuslog(e); // console.error(e) throw e; }).finally(()=>{}) } } , isElevated : ()=>{ return acquireElevationState().then( ()=>{ shell_verse.isElevated = () => { return Promise.resolve(__isElevated) } return shell_verse.isElevated() }) } // , isElevationOutOfProc : ()=>{ return true } , acquireElevationState : () => { return Promise.resolve(false).then(( elevationstate ) => { __isElevated ? console.log('Elevated') : console.log('Not Elevated') __isElevated = elevationstate; }).catch(() => { __isElevated = false; console.log('Not Elevated'); }).finally(()=>{ shell_verse.acquireElevationState = ()=> Promise.resolve(__isElevated); shell_verse.isElevated = () => { return Promise.resolve(__isElevated)} return __isElevated; }) } , getTaskCheckExists : cli.createTask('getTaskCheckExists', 'which') , getbash : ()=>{ return "sh" } , createJuntionOrLink : (dirOrFile, target, opts)=>{ return nodeShellExec('ln', ['-s', target, dirOrFile], opts).catch((e) => { console.error(e) }) } , removeJuncionOrLink : ( junctionOrLink )=>{ return nodeShellExec('rm', [junctionOrLink], { inherit: true, shell: true, env: process.env }) } , requestElevation(elevatedRunner, taskToRun) { // PB : TODO -- Most linking cmds in linux may not need elevation like in windows. // However returning true here is pseudo and will break cases where real elevation is required in linux. We need to refactor to reimplement // this with sudo and change all calles to use ony where required. return elevatedRunner(taskToRun); } , iswin(){ return false} , islin(){ return true} } module.exports = shell_verse