function uninstall() {
const system = systemsById[systemId];
if (system == null) {
console.error(`System ${systemId} is not installed.`);
process.exit(1);
}
if (pluginFullName == null) {
const r1 = readline.createInterface({ input: process.stdin, output: process.stdout });
r1.question(`Are you sure you want to uninstall the system ${systemId} ? (yes/no): `, (answer) => {
if (answer === "yes") uninstallSystem(system.folderName);
else process.exit(0);
});
} else {
const [ pluginAuthor, pluginName ] = pluginFullName.split("/");
if (builtInPluginAuthors.indexOf(pluginAuthor) !== -1) {
console.error(`Built-in plugins can not be uninstalled.`);
process.exit(1);
}
if (system.plugins[pluginAuthor] == null || system.plugins[pluginAuthor].indexOf(pluginName) === -1) {
console.error(`Plugin ${pluginFullName} is not installed.`);
process.exit(1);
}
const r1 = readline.createInterface({ input: process.stdin, output: process.stdout });
r1.question(`Are you sure you want to uninstall the plugin ${pluginFullName} ? (yes/no): `, (answer) => {
if (answer === "yes") uninstallPlugin(system.folderName, pluginAuthor);
else process.exit(0);
});
}
}
runTask: (command: string, args: string[], config: TaskConfig) => {
let loggerCategory = config.name;
let logger = config.logger;
logger.log(loggerCategory, `running command ${command} ${args.join(' ')}`);
let task = spawn(command, args);
let stdout = createInterface({ input: task.stdout });
stdout.on('line', line => {
line = strip(line);
if (!line) {
return;
}
let handled = false;
if (config.handleOutput) {
handled = config.handleOutput(line);
}
if (!handled) {
logger.log(loggerCategory, line);
}
});
let stderr = createInterface({ input: task.stderr });
stderr.on('line', line => {
line = strip(line);
if (!line) {
return;
}
let handled = false;
if (config.handleError) {
handled = config.handleError(line);
}
if (!handled) {
logger.error(loggerCategory, line);
}
});
let result = new Promise<void>((resolve, reject) => {
task.on('close', (code: number) => {
if (code === 0 || code === null) {
resolve();
} else {
reject(`Process exited with code ${code}`);
}
});
});
return {
result,
kill: () => {
kill(task.pid);
}
};
}
export default function uninstall(systemId: string, pluginFullName: string) {
const system = utils.systemsById[systemId];
if (system == null) utils.emitError(`System ${systemId} is not installed.`);
if (pluginFullName == null) {
if (system.isDev) utils.emitError(`System ${systemId} is a development version.`);
if (utils.force) {
uninstallSystem(system.folderName);
return;
}
const r1 = readline.createInterface({ input: process.stdin, output: process.stdout });
r1.question(`Are you sure you want to uninstall the system ${systemId}? (yes/no): `, (answer) => {
if (answer === "yes") {
console.log(`Uninstalling system ${systemId}...`);
uninstallSystem(system.folderName);
} else {
console.log(`Uninstall canceled.`);
process.exit(0);
}
});
} else {
const [ pluginAuthor, pluginName ] = pluginFullName.split("/");
if (utils.builtInPluginAuthors.indexOf(pluginAuthor) !== -1) utils.emitError(`Built-in plugins can not be uninstalled.`);
if (system.plugins[pluginAuthor] == null || system.plugins[pluginAuthor].indexOf(pluginName) === -1)
utils.emitError(`Plugin ${pluginFullName} is not installed.`);
let isDevFolder = true;
try { fs.readdirSync(`${utils.systemsPath}/${system.folderName}/plugins/${pluginFullName}/.git`); } catch (err) { isDevFolder = false; }
if (isDevFolder) utils.emitError(`Plugin ${pluginFullName} is a development version.`);
if (utils.force) {
uninstallPlugin(system.folderName, pluginFullName, pluginAuthor);
return;
}
const r1 = readline.createInterface({ input: process.stdin, output: process.stdout });
r1.question(`Are you sure you want to uninstall the plugin ${pluginFullName}? (yes/no): `, (answer) => {
if (answer === "yes") {
console.log(`Uninstalling plugin ${pluginFullName} from system ${systemId}...`);
uninstallPlugin(system.folderName, pluginFullName, pluginAuthor);
} else {
console.log(`Uninstall canceled.`);
process.exit(0);
}
});
}
}
export default function uninstall(systemId: string, pluginFullName: string) {
const localSystem = utils.systemsById[systemId];
if (localSystem == null) utils.emitError(`System ${systemId} is not installed.`);
if (pluginFullName == null) {
// Uninstall system
if (localSystem.isDev) utils.emitError(`System ${systemId} is a development version.`);
if (utils.force) {
uninstallSystem(localSystem.folderName);
return;
}
const r1 = readline.createInterface({ input: process.stdin, output: process.stdout });
r1.question(`Are you sure you want to uninstall the system ${systemId}? (yes/no): `, (answer) => {
if (answer === "yes") {
console.log(`Uninstalling system ${systemId}...`);
uninstallSystem(localSystem.folderName);
} else {
console.log(`Uninstall canceled.`);
process.exit(0);
}
});
} else {
// Uninstall plugin
const [ authorName, pluginName ] = pluginFullName.split("/");
if (utils.builtInPluginAuthors.indexOf(authorName) !== -1) utils.emitError(`Built-in plugins can not be uninstalled.`);
const localPlugin = localSystem.plugins[authorName] != null ? localSystem.plugins[authorName][pluginName] : null;
if (localPlugin == null) utils.emitError(`Plugin ${pluginFullName} is not installed.`);
if (localPlugin.isDev) utils.emitError(`Plugin ${pluginFullName} is a development version.`);
if (utils.force) {
uninstallPlugin(localSystem.folderName, pluginFullName, authorName);
return;
}
const r1 = readline.createInterface({ input: process.stdin, output: process.stdout });
r1.question(`Are you sure you want to uninstall the plugin ${pluginFullName}? (yes/no): `, (answer) => {
if (answer === "yes") {
console.log(`Uninstalling plugin ${pluginFullName} from system ${systemId}...`);
uninstallPlugin(localSystem.folderName, pluginFullName, authorName);
} else {
console.log(`Uninstall canceled.`);
process.exit(0);
}
});
}
}
function loadTimeFile(cb: (fd: TimePair[], p: string[]) => void, params: string[]){
var clockfile, currentDeep, fileData, rd;
clockfile = config.clockfile;
if (!clockfile || !fs.existsSync(clockfile)) {
println("You need to set the environment variable CLOCKFILE (pointing to an existing file)");
process.exit(1);
}
currentDeep = 0;
fileData = [];
rd = readline.createInterface({
input: fs.createReadStream(clockfile),
output: process.stdout,
terminal: false
});
rd.on('line', function(line){
var l;
l = parseLine(line, currentDeep);
fileData.push(l);
if (l.deep) {
currentDeep = l.deep;
}
});
rd.on('close', function(){
cb(fileData, params);
});
};
return new Promise((resolve) => {
const io = this.io;
const output = io.output;
const options: readline.ReadLineOptions = {
completer: (line: string) => {
const hits = question.getCompletions(line);
return [hits, line];
},
input: io.input.getStream(),
terminal: output.isDecorated(),
};
if (!question.isHidden()) {
options.output = output.getStream();
}
const rl = readline.createInterface(options);
rl.question(question.getPrompt(), (answer) => {
resolve(answer || "");
rl.close();
});
});
virtualConnectionServer.createInterface(server).on('connection', (connection: Duplex) => {
readline.createInterface(connection, null).on('line', line => {
try {
// Get a reference to the function to invoke
const invocation = JSON.parse(line) as RpcInvocation;
const invokedModule = dynamicRequire(path.resolve(process.cwd(), invocation.moduleName));
const invokedFunction = invocation.exportedFunctionName ? invokedModule[invocation.exportedFunctionName] : invokedModule;
// Actually invoke it, passing the callback followed by any supplied args
const invocationCallback = (errorValue, successValue) => {
connection.end(JSON.stringify({
result: successValue,
errorMessage: errorValue && (errorValue.message || errorValue),
errorDetails: errorValue && (errorValue.stack || null)
}));
};
invokedFunction.apply(null, [invocationCallback].concat(invocation.args));
} catch (ex) {
connection.end(JSON.stringify({
errorMessage: ex.message,
errorDetails: ex.stack
}));
}
});
});
.then(user => {
if (!user) {
console.error('User unknown.')
process.exit(-1)
}
const readline = require('readline')
const Writable = require('stream').Writable
const mutableStdout = new Writable({
write: function (chunk, encoding, callback) {
callback()
}
})
const rl = readline.createInterface({
input: process.stdin,
output: mutableStdout,
terminal: true
})
console.log('New password?')
rl.on('line', function (password) {
user.password = password
user.save()
.then(() => console.log('User password updated.'))
.catch(err => console.error(err))
.finally(() => process.exit(0))
})
})
return new Promise<string>((resolve) => {
const rl = readLine.createInterface(process.stdin, process.stdout);
rl.question(message, (ans) => {
resolve(ans);
rl.close();
});
});
public static read(filePath: string, featureSize:number, callback: Function, complete: Function = null): void {
const options: Object = { encoding: 'utf8', highWaterMark: 256 };
const stream: fs.ReadStream = fs.createReadStream(filePath, options);
const rl: readline.ReadLine = readline.createInterface(stream, null);
rl.on('line', (line: string) => {
const fields: string[] = line.split(/[\s:]/);
const label: number = fields[0].charAt(0) == '+' ? +1 : -1;
const len: number = fields.length;
let x: Feature | Float32Array = null;
if (featureSize != null && featureSize > 0) {
x = new Float32Array(featureSize).fill(0.0);
for (let i = 1; i < len; i += 2) {
let index: number = parseInt(fields[i]) - 1;
let value: number = parseFloat(fields[i + 1]);
x[index] = value;
}
} else {
x = [];
for (let i = 1; i < len; i += 2) {
let index: number = parseInt(fields[i]) - 1;
let value: number = parseFloat(fields[i + 1]);
let element = { index, value };
x.push(element);
}
}
callback(x, label);
});
rl.on('close', () => {
if (complete instanceof Function) {
complete();
}
});
}
