rodrigo/genieacs
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Async/await let's go!

Browse Source
This commit is contained in:
Zaid Abdulla committed 2019-06-05 00:17:36 -07:00
1 parent 1e6d3acd1b
commit c3501debd5
20 files changed
+1224 -1523
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

.eslintrc.json
+1 -1
View File
@@ -14,10 +14,10 @@
"handle-callback-err": "error",
"prefer-arrow-callback": "error",
"curly": ["error", "multi-or-nest", "consistent"],
"consistent-return": ["error", {"treatUndefinedAsUnspecified": true}],
"no-buffer-constructor": "error",
"prefer-const": ["error", {"destructuring": "all"}],
"eqeqeq": ["error", "always", {"null": "ignore"}],
"no-return-await": "error",
"@typescript-eslint/no-explicit-any": 0,
"@typescript-eslint/no-use-before-define": ["error", { "functions": false }]
}
bin/genieacs-cwmp
+7 -5
View File
@@ -27,7 +27,7 @@ function exitWorkerGracefully(): void {
}
function exitWorkerUngracefully(): void {
extensions.killAll(() => {
extensions.killAll().then(() => {
process.exit(1);
});
}
@@ -97,10 +97,8 @@ if (!cluster.worker) {
.catch(exitWorkerUngracefully);
});
db.connect(err => {
if (err) throw err;
cache.connect(err => {
if (err) throw err;
Promise.all([db.connect(), cache.connect()])
.then(() => {
server.start(
SERVICE_PORT,
SERVICE_ADDRESS,
@@ -108,6 +106,10 @@ if (!cluster.worker) {
cwmp.listener,
cwmp.onConnection
);
})
.catch(err => {
setTimeout(() => {
throw err;
});
});
}
bin/genieacs-ext
+2 -2
View File
@@ -59,7 +59,7 @@ function errorToFault(err: Error): Fault {
process.on("uncaughtException", err => {
const fault = errorToFault(err);
jobs.forEach(jobId => {
process.send([jobId, fault]);
process.send([jobId, fault, null]);
});
jobs.clear();
process.disconnect();
@@ -81,7 +81,7 @@ process.on("message", message => {
code: "ext",
message: `No such function '${funcName}' in extension '${fileName}'`
};
process.send([message[0], fault]);
process.send([message[0], fault, null]);
return;
}
bin/genieacs-fs
+6 -4
View File
@@ -93,11 +93,13 @@ if (!cluster.worker) {
.catch(exitWorkerUngracefully);
});
db.connect(err => {
if (err) throw err;
cache.connect(err => {
if (err) throw err;
Promise.all([db.connect(), cache.connect()])
.then(() => {
server.start(SERVICE_PORT, SERVICE_ADDRESS, ssl, listener);
})
.catch(err => {
setTimeout(() => {
throw err;
});
});
}
bin/genieacs-nbi
+7 -5
View File
@@ -27,7 +27,7 @@ function exitWorkerGracefully(): void {
}
function exitWorkerUngracefully(): void {
extensions.killAll(() => {
extensions.killAll().then(() => {
process.exit(1);
});
}
@@ -97,11 +97,13 @@ if (!cluster.worker) {
.catch(exitWorkerUngracefully);
});
db.connect(err => {
if (err) throw err;
cache.connect(err => {
if (err) throw err;
Promise.all([db.connect(), cache.connect()])
.then(() => {
server.start(SERVICE_PORT, SERVICE_ADDRESS, ssl, listener);
})
.catch(err => {
setTimeout(() => {
throw err;
});
});
}
bin/genieacs-ui
+6 -4
View File
@@ -105,11 +105,13 @@ if (!cluster.worker) {
listener(req, res);
};
db2.connect(err => {
if (err) throw err;
cache.connect(err => {
if (err) throw err;
Promise.all([db2.connect(), cache.connect()])
.then(() => {
server.start(SERVICE_PORT, SERVICE_ADDRESS, ssl, _listener);
})
.catch(err => {
setTimeout(() => {
throw err;
});
});
}
build/build.ts
+1
View File
@@ -31,6 +31,7 @@ const externals = [
"https",
"zlib",
"crypto",
"util",
"mongodb",
"libxmljs",
"vm",
lib/api-functions.ts
+47 -76
View File
@@ -29,9 +29,9 @@ import {
httpConnectionRequest,
udpConnectionRequest
} from "./connection-request";
import { Expression } from "./types";
import { Expression, Task } from "./types";
export function connectionRequest(deviceId, callback): void {
export async function connectionRequest(deviceId): Promise<void> {
const options = {
projection: {
_deviceId: 1,
@@ -46,9 +46,8 @@ export function connectionRequest(deviceId, callback): void {
}
};
db.devicesCollection.findOne({ _id: deviceId }, options, (err, device) => {
if (err) return void callback(err);
if (!device) return void callback(new Error("No such device"));
const device = await db.devicesCollection.findOne({ _id: deviceId }, options);
if (!device) throw new Error("No such device");
let managementServer,
connectionRequestUrl,
@@ -81,8 +80,7 @@ export function connectionRequest(deviceId, callback): void {
password: password || ""
};
getCurrentSnapshot()
.then(snapshot => {
const snapshot = await getCurrentSnapshot();
const now = Date.now();
const UDP_CONNECTION_REQUEST_PORT = +getConfig(
snapshot,
@@ -126,53 +124,41 @@ export function connectionRequest(deviceId, callback): void {
);
}
httpConnectionRequest(
try {
await httpConnectionRequest(
connectionRequestUrl,
authExp,
context,
CONNECTION_REQUEST_ALLOW_BASIC_AUTH,
CONNECTION_REQUEST_TIMEOUT
)
.then(callback)
.catch(err => {
if (udpProm) return void udpProm.then(callback).catch(callback);
callback(err);
});
})
.catch(callback);
});
);
} catch (err) {
if (!udpProm) throw err;
await udpProm;
}
}
export function watchTask(deviceId, taskId, timeout, callback): void {
setTimeout(() => {
db.tasksCollection.findOne(
{ _id: taskId },
{ projection: { _id: 1 } },
(err, task) => {
if (err) return void callback(err);
export async function watchTask(deviceId, taskId, timeout): Promise<string> {
await new Promise(resolve => setTimeout(resolve, 500));
if (!task) return void callback(null, "completed");
const task = await db.tasksCollection.findOne(
{ _id: taskId },
{ projection: { _id: 1 } }
);
if (!task) return "completed";
const q = { _id: `${deviceId}:task_${taskId}` };
db.faultsCollection.findOne(
q,
{ projection: { _id: 1 } },
(err, fault) => {
if (err) return void callback(err);
const fault = await db.faultsCollection.findOne(q, {
projection: { _id: 1 }
});
if (fault) return "fault";
if (fault) return void callback(null, "fault");
if ((timeout -= 500) <= 0) return "timeout";
if ((timeout -= 500) <= 0) return void callback(null, "timeout");
watchTask(deviceId, taskId, timeout, callback);
}
);
}
);
}, 500);
return watchTask(deviceId, taskId, timeout);
}
function sanitizeTask(task, callback): void {
function sanitizeTask(task): void {
task.timestamp = new Date(task.timestamp || Date.now());
if (task.expiry) {
if (common.typeOf(task.expiry) === common.DATE_TYPE || isNaN(task.expiry))
@@ -180,55 +166,40 @@ function sanitizeTask(task, callback): void {
else task.expiry = new Date(task.timestamp.getTime() + +task.expiry * 1000);
}
callback(task);
return task;
}
export function insertTasks(tasks, callback): void {
export async function insertTasks(tasks): Promise<Task[]> {
if (tasks && common.typeOf(tasks) !== common.ARRAY_TYPE) tasks = [tasks];
else if (!tasks || tasks.length === 0)
return void callback(null, tasks || []);
else if (!tasks || tasks.length === 0) return tasks || [];
let counter = tasks.length;
for (const task of tasks) {
sanitizeTask(task, t => {
if (t.uniqueKey) {
db.tasksCollection.deleteOne(
{ device: t.device, uniqueKey: t.uniqueKey },
() => {}
);
}
if (--counter === 0) db.tasksCollection.insertMany(tasks, callback);
sanitizeTask(task);
if (task.uniqueKey) {
await db.tasksCollection.deleteOne({
device: task.device,
uniqueKey: task.uniqueKey
});
}
}
await db.tasksCollection.insertMany(tasks);
return tasks;
}
export function deleteDevice(deviceId, callback): void {
db.tasksCollection.deleteMany({ device: deviceId }, err => {
if (err) return void callback(err);
db.devicesCollection.deleteOne({ _id: deviceId }, err => {
if (err) return void callback(err);
db.faultsCollection.deleteMany(
{
export async function deleteDevice(deviceId): Promise<void> {
await Promise.all([
db.tasksCollection.deleteMany({ device: deviceId }),
db.devicesCollection.deleteOne({ _id: deviceId }),
db.faultsCollection.deleteMany({
_id: {
$regex: `^${common.escapeRegExp(deviceId)}\\:`
}
},
err => {
if (err) return void callback(err);
db.operationsCollection.deleteMany(
{
}),
db.operationsCollection.deleteMany({
_id: {
$regex: `^${common.escapeRegExp(deviceId)}\\:`
}
},
err => {
if (err) return void callback(err);
cache.del(`${deviceId}_tasks_faults_operations`, callback);
}
);
}
);
});
});
}),
cache.del(`${deviceId}_tasks_faults_operations`)
]);
}
lib/cache.ts
+57 -95
View File
@@ -17,48 +17,36 @@
* along with GenieACS. If not, see <http://www.gnu.org/licenses/>.
*/
import { MongoClient } from "mongodb";
import { MongoClient, Collection } from "mongodb";
import * as config from "./config";
const MAX_CACHE_TTL = +config.get("MAX_CACHE_TTL");
let mongoClient;
let mongoCollection;
let mongoClient: MongoClient;
let mongoCollection: Collection;
let mongoTimeOffset = 0;
export function connect(callback): void {
export async function connect(): Promise<void> {
const MONGODB_CONNECTION_URL = "" + config.get("MONGODB_CONNECTION_URL");
MongoClient.connect(
MONGODB_CONNECTION_URL,
{ useNewUrlParser: true },
(err, client) => {
if (err) return void callback(err);
const db = client.db();
mongoClient = client;
mongoCollection = db.collection("cache");
mongoCollection.createIndex({ expire: 1 }, { expireAfterSeconds: 0 });
const now = Date.now();
db.command({ hostInfo: 1 }, (err, res) => {
if (err) return void callback(err);
mongoTimeOffset = res.system.currentTime.getTime() - now;
callback();
mongoClient = await MongoClient.connect(MONGODB_CONNECTION_URL, {
useNewUrlParser: true
});
}
);
const db = mongoClient.db();
mongoCollection = db.collection("cache");
await mongoCollection.createIndex({ expire: 1 }, { expireAfterSeconds: 0 });
const now = Date.now();
const res = await db.command({ hostInfo: 1 });
mongoTimeOffset = res.system.currentTime.getTime() - now;
}
export function disconnect(): void {
if (mongoClient) mongoClient.close();
export async function disconnect(): Promise<void> {
if (mongoClient) await mongoClient.close();
}
export function get(key, callback): void {
export async function get(key): Promise<any> {
const expire = new Date(Date.now() - mongoTimeOffset);
if (Array.isArray(key)) {
mongoCollection.find({ _id: { $in: key } }).toArray((err, res) => {
if (err) return void callback(err);
const res = await mongoCollection.find({ _id: { $in: key } }).toArray();
const indices = {};
key.forEach((v, i) => {
@@ -69,110 +57,84 @@ export function get(key, callback): void {
res.forEach(r => {
if (r["expire"] > expire) values[indices[r["_id"]]] = r["value"];
});
callback(null, values);
});
return values;
} else {
mongoCollection.findOne({ _id: { $in: [key] } }, (err, res) => {
if (err || !res) return void callback(err);
if (res["expire"] > expire) return void callback(null, res["value"]);
callback();
});
const res = await mongoCollection.findOne({ _id: { $in: [key] } });
if (res && res["expire"] > expire) return res["value"];
return res;
}
}
export function del(key, callback): void {
export async function del(key): Promise<void> {
if (Array.isArray(key))
mongoCollection.deleteMany({ _id: { $in: key } }, callback);
else mongoCollection.deleteOne({ _id: key }, callback);
await mongoCollection.deleteMany({ _id: { $in: key } });
else await mongoCollection.deleteOne({ _id: key });
}
export function set(
export async function set(
key: string,
value: string | number,
callback: (err?: Error) => void
): void;
export function set(
key: string,
value: string | number,
ttl: number,
callback: (err?: Error) => void
): void;
export function set(
key: string,
value: string | number,
ttl: number | ((err?: Error) => void),
callback?: (err?: Error) => void
): void {
if (!callback && typeof ttl === "function") {
callback = ttl;
ttl = null;
}
if (!ttl) ttl = MAX_CACHE_TTL;
const expire = new Date(
Date.now() - mongoTimeOffset + (ttl as number) * 1000
);
mongoCollection.replaceOne(
ttl: number = MAX_CACHE_TTL
): Promise<void> {
const expire = new Date(Date.now() - mongoTimeOffset + ttl * 1000);
await mongoCollection.replaceOne(
{ _id: key },
{ _id: key, value: value, expire: expire },
{ upsert: true },
callback
{ upsert: true }
);
}
export function pop(key, callback): void {
mongoCollection.findOneAndDelete({ _id: key }, (err, res) => {
if (err || !res["value"]) return void callback(err);
export async function pop(key): Promise<any> {
const res = await mongoCollection.findOneAndDelete({ _id: key });
if (res["value"]["expire"] > new Date(Date.now() - mongoTimeOffset))
return void callback(null, res["value"]["value"]);
if (
res &&
res["value"] &&
+res["value"]["expire"] - (Date.now() - mongoTimeOffset)
)
return res["value"]["value"];
callback();
});
return null;
}
export function lock(lockName, ttl, callback): void {
export async function lock(lockName, ttl): Promise<Function> {
const token = Math.random()
.toString(36)
.slice(2);
function unlockOrExtend(extendTtl): void {
async function unlockOrExtend(extendTtl): Promise<void> {
if (!extendTtl) {
mongoCollection.deleteOne({ _id: lockName, value: token }, (err, res) => {
if (err || res["result"]["n"] !== 1)
throw err || new Error("Lock expired");
const res = await mongoCollection.deleteOne({
_id: lockName,
value: token
});
if (res["result"]["n"] !== 1) throw new Error("Lock expired");
} else {
const expire = new Date(Date.now() - mongoTimeOffset + extendTtl * 1000);
mongoCollection.updateOne(
const res = await mongoCollection.updateOne(
{ _id: lockName, value: token },
{ expire: expire },
(err, res) => {
if (err || res["result"]["n"] !== 1)
throw err || new Error("Lock expired");
}
{ expire: expire }
);
if (res["result"]["n"] !== 1) throw new Error("Lock expired");
}
}
const expireTest = new Date(Date.now() - mongoTimeOffset);
const expireSet = new Date(Date.now() - mongoTimeOffset + ttl * 1000);
mongoCollection.updateOne(
try {
await mongoCollection.updateOne(
{ _id: lockName, expire: { $lte: expireTest } },
{ $set: { value: token, expire: expireSet } },
{ upsert: true },
err => {
{ upsert: true }
);
} catch (err) {
if (err && err.code === 11000) {
return setTimeout(() => {
lock(lockName, ttl, callback);
}, 200);
await new Promise(resolve => setTimeout(resolve, 200));
return lock(lockName, ttl);
}
}
return callback(err, unlockOrExtend);
}
);
return unlockOrExtend;
}
lib/cwmp.ts
+224 -355
View File
File diff suppressed because it is too large. Load diff
lib/db.ts
+138 -170
View File
@@ -17,39 +17,44 @@
* along with GenieACS. If not, see <http://www.gnu.org/licenses/>.
*/
import { MongoClient, ObjectID } from "mongodb";
import { MongoClient, ObjectID, Collection, FindOneOptions } from "mongodb";
import { get } from "./config";
import { escapeRegExp } from "./common";
import { parse } from "./common/expression-parser";
import { DeviceData, Attributes } from "./types";
import {
DeviceData,
Attributes,
SessionFault,
Task,
Operation,
Expression
} from "./types";
import Path from "./common/path";
export let tasksCollection,
devicesCollection,
presetsCollection,
objectsCollection,
provisionsCollection,
virtualParametersCollection,
faultsCollection,
filesCollection,
operationsCollection,
permissionsCollection,
usersCollection,
configCollection;
export let tasksCollection: Collection,
devicesCollection: Collection,
presetsCollection: Collection,
objectsCollection: Collection,
provisionsCollection: Collection,
virtualParametersCollection: Collection,
faultsCollection: Collection,
filesCollection: Collection,
operationsCollection: Collection,
permissionsCollection: Collection,
usersCollection: Collection,
configCollection: Collection;
export let client;
export let client: MongoClient;
export async function connect(): Promise<void> {
client = await MongoClient.connect("" + get("MONGODB_CONNECTION_URL"), {
useNewUrlParser: true
});
export function connect(callback): void {
MongoClient.connect(
"" + get("MONGODB_CONNECTION_URL"),
{ useNewUrlParser: true },
(err, _client) => {
if (err) return void callback(err);
client = _client;
const db = client.db();
tasksCollection = db.collection("tasks");
tasksCollection.createIndex({ device: 1, timestamp: 1 });
await tasksCollection.createIndex({ device: 1, timestamp: 1 });
devicesCollection = db.collection("devices");
presetsCollection = db.collection("presets");
@@ -62,14 +67,10 @@ export function connect(callback): void {
permissionsCollection = db.collection("permissions");
usersCollection = db.collection("users");
configCollection = db.collection("config");
callback();
}
);
}
export function disconnect(): void {
if (client) client.close();
export async function disconnect(): Promise<void> {
if (client) await client.close();
}
// Optimize projection by removing overlaps
@@ -93,12 +94,11 @@ function optimizeProjection(obj: {}): {} {
return obj;
}
export function fetchDevice(
export async function fetchDevice(
id: string,
timestamp: number,
patterns: [Path, number][],
callback
): void {
patterns: [Path, number][]
): Promise<[[Path, number, Attributes?][], [Path, number][]]> {
const MAX_DEPTH = +get("MAX_DEPTH", id);
if (!patterns || !patterns.length)
@@ -273,14 +273,14 @@ export function fetchDevice(
}
}
let options;
let options: FindOneOptions;
if (!projection[""]) {
if (!Object.keys(projection).length) options = { projection: { _id: 1 } };
else options = { projection: projection };
}
devicesCollection.findOne({ _id: id }, options, (err, device) => {
if (err || !device) return void callback(err);
const device = await devicesCollection.findOne({ _id: id }, options);
if (!device) return [null, null];
function storeParams(
obj,
@@ -515,17 +515,15 @@ export function fetchDevice(
}
storeParams(device, "", 0, 0, false, projectionTree);
callback(null, res, loaded);
});
return [res, loaded];
}
export function saveDevice(
export async function saveDevice(
deviceId: string,
deviceData: DeviceData,
isNew: boolean,
sessionTimestamp: number,
callback
): void {
sessionTimestamp: number
): Promise<void> {
const update = { $set: {}, $unset: {}, $addToSet: {}, $pull: {} };
for (const diff of deviceData.timestamps.diff()) {
@@ -737,7 +735,7 @@ export function saveDevice(
if (!Object.keys(v).length) delete update[k];
}
if (!Object.keys(update).length) return void callback();
if (!Object.keys(update).length) return;
// Mongo doesn't allow $addToSet and $pull at the same time
let update2;
@@ -746,37 +744,27 @@ export function saveDevice(
delete update["$pull"];
}
devicesCollection.updateOne(
{ _id: deviceId },
update,
{ upsert: isNew },
(err, result) => {
if (err || result.result.n !== 1) {
return void callback(
err || new Error(`Device ${deviceId} not found in database`)
);
}
const result = await devicesCollection.updateOne({ _id: deviceId }, update, {
upsert: isNew
});
if (result.result.n !== 1)
throw new Error(`Device ${deviceId} not found in database`);
if (update2) {
return void devicesCollection.updateOne(
{ _id: deviceId },
update2,
callback
);
await devicesCollection.updateOne({ _id: deviceId }, update2);
return;
}
}
callback();
}
);
}
export function getFaults(deviceId, callback): void {
faultsCollection
export async function getFaults(
deviceId
): Promise<{ [channel: string]: SessionFault }> {
const res = await faultsCollection
.find({ _id: { $regex: `^${escapeRegExp(deviceId)}\\:` } })
.toArray((err, res) => {
if (err) return callback(err);
.toArray();
const faults = {};
const faults: { [channel: string]: SessionFault } = {};
for (const r of res) {
const channel = r._id.slice(deviceId.length + 1);
delete r._id;
@@ -787,11 +775,10 @@ export function getFaults(deviceId, callback): void {
faults[channel] = r;
}
return callback(err, faults);
});
return faults;
}
export function saveFault(deviceId, channel, fault, callback): void {
export async function saveFault(deviceId, channel, fault): Promise<void> {
const id = `${deviceId}:${channel}`;
fault = Object.assign({}, fault);
fault._id = id;
@@ -799,28 +786,24 @@ export function saveFault(deviceId, channel, fault, callback): void {
fault.channel = channel;
fault.timestamp = new Date(fault.timestamp);
fault.provisions = JSON.stringify(fault.provisions);
faultsCollection.replaceOne({ _id: id }, fault, { upsert: true }, callback);
await faultsCollection.replaceOne({ _id: id }, fault, { upsert: true });
}
export function deleteFault(deviceId, channel, callback): void {
faultsCollection.deleteOne({ _id: `${deviceId}:${channel}` }, callback);
export async function deleteFault(deviceId, channel): Promise<void> {
await faultsCollection.deleteOne({ _id: `${deviceId}:${channel}` });
}
export function getDueTasks(deviceId, timestamp, callback): void {
export async function getDueTasks(
deviceId,
timestamp
): Promise<[Task[], number]> {
const cur = tasksCollection.find({ device: deviceId }).sort(["timestamp"]);
const tasks = [];
let f;
cur.next(
(f = (err, task) => {
if (err) return void callback(err);
if (!task) return void callback(null, tasks, null);
const tasks = [] as Task[];
for await (const task of cur) {
if (task.timestamp) task.timestamp = +task.timestamp;
if (task.expiry) task.expiry = +task.expiry;
if (task.timestamp >= timestamp)
return void callback(null, tasks, +task.timestamp);
if (task.timestamp >= timestamp) return [tasks, +task.timestamp];
task._id = String(task._id);
tasks.push(task);
@@ -832,8 +815,7 @@ export function getDueTasks(deviceId, timestamp, callback): void {
q = { _id: { $in: [task.file, new ObjectID(task.file)] } };
else q = { _id: task.file };
filesCollection.find(q).toArray((err, res) => {
if (err) return void callback(err);
const res = await filesCollection.find(q).toArray();
if (res[0]) {
if (!task.fileType) task.fileType = res[0].metadata.fileType;
@@ -841,30 +823,25 @@ export function getDueTasks(deviceId, timestamp, callback): void {
if (!task.fileName)
task.fileName = res[0].filename || res[0]._id.toString();
}
}
}
return [tasks, null];
}
cur.next(f);
export async function clearTasks(deviceId, taskIds): Promise<void> {
await tasksCollection.deleteMany({
_id: { $in: taskIds.map(id => new ObjectID(id)) }
});
} else {
cur.next(f);
}
})
);
}
export function clearTasks(deviceId, taskIds, callback): void {
tasksCollection.deleteMany(
{ _id: { $in: taskIds.map(id => new ObjectID(id)) } },
callback
);
}
export function getOperations(deviceId, callback): void {
operationsCollection
export async function getOperations(
deviceId
): Promise<{ [commandKey: string]: Operation }> {
const res = await operationsCollection
.find({ _id: { $regex: `^${escapeRegExp(deviceId)}\\:` } })
.toArray((err, res) => {
if (err) return void callback(err);
.toArray();
const operations = {};
const operations: { [commandKey: string]: Operation } = {};
for (const r of res) {
const commandKey = r._id.slice(deviceId.length + 1);
delete r._id;
@@ -874,12 +851,14 @@ export function getOperations(deviceId, callback): void {
r.retries = JSON.parse(r.retries);
operations[commandKey] = r;
}
callback(err, operations);
});
return operations;
}
export function saveOperation(deviceId, commandKey, operation, callback): void {
export async function saveOperation(
deviceId,
commandKey,
operation
): Promise<void> {
const id = `${deviceId}:${commandKey}`;
operation = Object.assign({}, operation);
operation._id = id;
@@ -887,75 +866,64 @@ export function saveOperation(deviceId, commandKey, operation, callback): void {
operation.provisions = JSON.stringify(operation.provisions);
operation.retries = JSON.stringify(operation.retries);
operation.args = JSON.stringify(operation.args);
operationsCollection.replaceOne(
{ _id: id },
operation,
{ upsert: true },
callback
);
}
export function deleteOperation(deviceId, commandKey, callback): void {
operationsCollection.deleteOne(
{ _id: `${deviceId}:${commandKey}` },
callback
);
}
export function getPresets(callback): void {
presetsCollection.find().toArray(callback);
}
export function getObjects(callback): void {
objectsCollection.find().toArray(callback);
}
export function getProvisions(callback): void {
provisionsCollection.find().toArray(callback);
}
export function getVirtualParameters(callback): void {
virtualParametersCollection.find().toArray(callback);
}
export function getFiles(callback): void {
filesCollection.find().toArray(callback);
}
export function getConfig(callback): void {
configCollection.find().toArray((err, res) => {
if (err) return void callback(err);
callback(
null,
res.map(c => ({
id: c["_id"],
value: parse(c["value"])
}))
);
await operationsCollection.replaceOne({ _id: id }, operation, {
upsert: true
});
}
export function getPermissions(
callback: (
err?: Error,
permissions?: {
export async function deleteOperation(deviceId, commandKey): Promise<void> {
await operationsCollection.deleteOne({ _id: `${deviceId}:${commandKey}` });
}
export async function getPresets(): Promise<{}[]> {
return presetsCollection.find().toArray();
}
export async function getObjects(): Promise<{}[]> {
return objectsCollection.find().toArray();
}
export async function getProvisions(): Promise<{}[]> {
return provisionsCollection.find().toArray();
}
export async function getVirtualParameters(): Promise<{}[]> {
return virtualParametersCollection.find().toArray();
}
export function getFiles(): Promise<{}[]> {
return filesCollection.find().toArray();
}
export async function getConfig(): Promise<
{ id: string; value: Expression }[]
> {
const res = await configCollection.find().toArray();
return res.map(c => ({
id: c["_id"],
value: parse(c["value"])
}));
}
interface Permission {
role: string;
resource: string;
access: number;
filter: string;
validate: string;
}[]
) => void
): void {
permissionsCollection.find().toArray(callback);
}
export function getUsers(
callback: (
err?: Error,
users?: { _id: string; password: string; salt: string; roles: string }[]
) => void
): void {
usersCollection.find().toArray(callback);
export async function getPermissions(): Promise<Permission[]> {
return permissionsCollection.find().toArray();
}
interface User {
_id: string;
password: string;
salt: string;
roles: string;
}
export async function getUsers(): Promise<User[]> {
return usersCollection.find().toArray();
}
lib/extensions.ts
+34 -29
View File
@@ -17,28 +17,30 @@
* along with GenieACS. If not, see <http://www.gnu.org/licenses/>.
*/
import { spawn } from "child_process";
import { spawn, ChildProcess } from "child_process";
import * as crypto from "crypto";
import * as config from "./config";
import { Fault } from "./types";
const TIMEOUT = +config.get("EXT_TIMEOUT");
const processes = {};
const processes: { [script: string]: ChildProcess } = {};
const jobs = new Map();
function messageHandler(message): void {
const func = jobs.get(message[0]);
if (func) {
jobs.delete(message[0]);
func(null, message[1], message[2]);
func({ fault: message[1], value: message[2] });
}
}
export function run(args, callback): boolean {
export function run(args): Promise<{ fault: Fault; value: any }> {
return new Promise(resolve => {
const scriptName = args[0];
const id = crypto.randomBytes(8).toString("hex");
jobs.set(id, callback);
jobs.set(id, resolve);
if (!processes[scriptName]) {
const p = spawn("bin/genieacs-ext", [scriptName], {
@@ -48,8 +50,12 @@ export function run(args, callback): boolean {
p.on("error", err => {
if (processes[scriptName] === p) {
if (jobs.delete(id))
callback(null, { code: err.name, message: err.message });
if (jobs.delete(id)) {
resolve({
fault: { code: err.name, message: err.message },
value: null
});
}
kill(processes[scriptName]);
delete processes[scriptName];
@@ -57,52 +63,51 @@ export function run(args, callback): boolean {
});
p.on("disconnect", () => {
if (processes[scriptName] === p) {
kill(processes[scriptName]);
delete processes[scriptName];
}
if (processes[scriptName] === p) delete processes[scriptName];
});
p.on("message", messageHandler);
}
setTimeout(() => {
if (jobs.delete(id))
callback(null, { code: "timeout", message: "Extension timed out" });
if (jobs.delete(id)) {
resolve({
fault: { code: "timeout", message: "Extension timed out" },
value: null
});
}
}, TIMEOUT);
if (!processes[scriptName].connected) return false;
return processes[scriptName].send([id, args.slice(1)]);
});
}
function kill(process, callback?: () => void): void {
if (process.signalCode !== null || process.exitCode !== null) return;
function kill(process: ChildProcess): Promise<void> {
return new Promise(resolve => {
const timeToKill = Date.now() + 5000;
process.kill();
const t = setInterval(() => {
if (process.signalCode !== null || process.exitCode !== null) {
if (!process.connected) {
clearInterval(t);
if (callback) callback();
resolve();
} else if (Date.now() > timeToKill) {
process.kill("SIGKILL");
clearInterval(t);
if (callback) callback();
resolve();
}
}, 100);
});
}
export function killAll(callback?): void {
let counter = 1;
for (const n in processes) {
++counter;
kill(processes[n], () => {
if (--counter === 0 && callback) callback();
});
delete processes[n];
}
if (--counter === 0 && callback) callback();
export async function killAll(): Promise<void> {
await Promise.all(
Object.entries(processes).map(([k, p]) => {
delete processes[k];
return kill(p);
})
);
}
lib/local-cache.ts
+115 -180
View File
@@ -108,36 +108,9 @@ function flattenObject(src, prefix = "", dst = {}): {} {
return dst;
}
function refresh(callback): void {
if (!nextRefresh) {
return void setTimeout(() => {
refresh(callback);
}, 20);
}
nextRefresh = 0;
const now = Date.now();
cache.get("presets_hash", (err, dbHash) => {
if (err) return void callback(err);
if (currentSnapshot && dbHash === currentSnapshot) {
nextRefresh = now + (REFRESH - (now % REFRESH));
return void callback();
}
cache.lock("presets_hash_lock", 3, (err, unlockOrExtend) => {
if (err) return void callback(err);
const promises = [];
promises.push(
new Promise((resolve, reject) => {
db.getPresets((err, res) => {
if (err) return void reject(err);
db.getObjects((err, objects) => {
if (err) return void reject(err);
async function fetchPresets(): Promise<Preset[]> {
const res = await db.getPresets();
let objects = await db.getObjects();
objects = objects.map(obj => {
// Flatten object
@@ -145,30 +118,30 @@ function refresh(callback): void {
// If no keys are defined, consider all parameters as keys to keep the
// same behavior from v1.0
if (!obj["_keys"] || !obj["_keys"].length) {
obj["_keys"] = Object.keys(obj).filter(
k => !k.startsWith("_")
);
}
if (!obj["_keys"] || !obj["_keys"].length)
obj["_keys"] = Object.keys(obj).filter(k => !k.startsWith("_"));
return obj;
});
res.sort((a, b) => {
if (a.weight === b.weight) return a._id > b._id;
else return a.weight - b.weight;
if (a["weight"] === b["weight"])
return a["_id"] > b["_id"] ? 1 : a["_id"] < b["_id"] ? -1 : 0;
else return a["weight"] - b["weight"];
});
const presets = [] as Preset[];
for (const preset of res) {
let schedule = null;
if (preset.schedule) {
const parts = preset.schedule.trim().split(/\s+/);
let schedule: { md5: string; duration: number; schedule: any } = null;
if (preset["schedule"]) {
const parts = preset["schedule"].trim().split(/\s+/);
schedule = {
md5: crypto
.createHash("md5")
.update(preset.schedule)
.digest("hex")
.update(preset["schedule"])
.digest("hex"),
duration: null,
schedule: null
};
try {
@@ -177,27 +150,25 @@ function refresh(callback): void {
} catch (err) {
logger.warn({
message: "Invalid preset schedule",
preset: preset._id,
schedule: preset.schedule
preset: preset["_id"],
schedule: preset["schedule"]
});
schedule.schedule = false;
}
}
const events = preset.events || {};
const events = preset["events"] || {};
let precondition;
try {
precondition = parse(preset.precondition);
precondition = parse(preset["precondition"]);
} catch (error) {
precondition = mongoQueryToFilter(
JSON.parse(preset.precondition)
);
precondition = mongoQueryToFilter(JSON.parse(preset["precondition"]));
}
const _provisions = preset.provisions || [];
const _provisions = preset["provisions"] || [];
// Generate provisions from the old configuration format
for (const c of preset.configurations) {
for (const c of preset["configurations"]) {
switch (c.type) {
case "age":
_provisions.push(["refresh", c.name, c.age]);
@@ -229,10 +200,7 @@ function refresh(callback): void {
_provisions.push(["instances", p, 1]);
for (const k in obj) {
if (
!k.startsWith("_") &&
!(obj["_keys"].indexOf(k) !== -1)
)
if (!k.startsWith("_") && !(obj["_keys"].indexOf(k) !== -1))
_provisions.push(["value", `${p}.${k}`, obj[k]]);
}
}
@@ -254,15 +222,13 @@ function refresh(callback): void {
break;
default:
return void reject(
new Error(`Unknown configuration type ${c.type}`)
);
throw new Error(`Unknown configuration type ${c.type}`);
}
}
presets.push({
name: preset._id,
channel: preset.channel || "default",
name: preset["_id"],
channel: (preset["channel"] as string) || "default",
schedule: schedule,
events: events,
precondition: precondition,
@@ -270,108 +236,85 @@ function refresh(callback): void {
});
}
resolve(presets);
});
});
})
);
return presets;
}
promises.push(
new Promise((resolve, reject) => {
db.getProvisions((err, res) => {
if (err) return void reject(err);
async function fetchProvisions(): Promise<{}> {
const res = await db.getProvisions();
const provisions = {};
for (const r of res) {
provisions[r._id] = {};
provisions[r._id].md5 = crypto
provisions[r["_id"]] = {};
provisions[r["_id"]].md5 = crypto
.createHash("md5")
.update(r.script)
.update(r["script"])
.digest("hex");
provisions[r._id].script = new vm.Script(
`"use strict";(function(){\n${r.script}\n})();`,
{ filename: r._id, lineOffset: -1, timeout: 50 }
provisions[r["_id"]].script = new vm.Script(
`"use strict";(function(){\n${r["script"]}\n})();`,
{ filename: r["_id"], lineOffset: -1, timeout: 50 }
);
}
resolve(provisions);
});
})
);
return provisions;
}
promises.push(
new Promise((resolve, reject) => {
db.getVirtualParameters((err, res) => {
if (err) return void reject(err);
async function fetchVirtualParameters(): Promise<{}> {
const res = await db.getVirtualParameters();
const virtualParameters = {};
for (const r of res) {
virtualParameters[r._id] = {};
virtualParameters[r._id].md5 = crypto
virtualParameters[r["_id"]] = {};
virtualParameters[r["_id"]].md5 = crypto
.createHash("md5")
.update(r.script)
.update(r["script"])
.digest("hex");
virtualParameters[r._id].script = new vm.Script(
`"use strict";(function(){\n${r.script}\n})();`,
{ filename: r._id, lineOffset: -1, timeout: 50 }
virtualParameters[r["_id"]].script = new vm.Script(
`"use strict";(function(){\n${r["script"]}\n})();`,
{ filename: r["_id"], lineOffset: -1, timeout: 50 }
);
}
resolve(virtualParameters);
});
})
);
promises.push(
new Promise((resolve, reject) => {
db.getFiles((err, res) => {
if (err) return void reject(err);
const files = {};
for (const r of res) {
const id = r.filename || r._id.toString();
files[id] = {};
files[id].length = r.length;
files[id].md5 = r.md5;
files[id].contentType = r.contentType;
return virtualParameters;
}
resolve(files);
});
})
);
promises.push(
new Promise((resolve, reject) => {
db.getPermissions((err, perms) => {
if (err) return void reject(err);
async function fetchPermissions(): Promise<Permissions> {
const perms = await db.getPermissions();
const permissions: Permissions = {};
for (const p of perms) {
if (!permissions[p.role]) permissions[p.role] = {};
if (!permissions[p.role][p.access])
permissions[p.role][p.access] = {};
if (!permissions[p.role][p.access]) permissions[p.role][p.access] = {};
permissions[p.role][p.access][p.resource] = {
access: p.access,
filter: parse(p.filter || "true")
};
if (p.validate) {
permissions[p.role][p.access][p.resource].validate = parse(
p.validate
);
}
if (p.validate)
permissions[p.role][p.access][p.resource].validate = parse(p.validate);
}
resolve(permissions);
});
})
);
return permissions;
}
promises.push(
new Promise((resolve, reject) => {
db.getUsers((err, _users) => {
if (err) return void reject(err);
async function fetchFiles(): Promise<{}> {
const res = await db.getFiles();
const files = {};
for (const r of res) {
const id = r["filename"] || r["_id"].toString();
files[id] = {};
files[id].length = r["length"];
files[id].md5 = r["md5"];
files[id].contentType = r["contentType"];
}
return files;
}
async function fetchUsers(): Promise<{}> {
const _users = await db.getUsers();
const users = {};
for (const user of _users) {
users[user._id] = {
password: user.password,
@@ -379,15 +322,12 @@ function refresh(callback): void {
roles: user.roles.split(",").map(s => s.trim())
};
}
resolve(users);
});
})
);
promises.push(
new Promise((resolve, reject) => {
db.getConfig((err, conf) => {
if (err) return void reject(err);
return users;
}
async function fetchConfig(): Promise<[{}, {}]> {
const conf = await db.getConfig();
conf.sort((a, b) => (a.id > b.id ? 1 : a.id < b.id ? -1 : 0));
@@ -426,13 +366,38 @@ function refresh(callback): void {
};
}
resolve([_config, ui]);
});
})
);
return [_config, ui];
}
async function refresh(): Promise<void> {
if (!nextRefresh) {
await new Promise(resolve => setTimeout(resolve, 20));
await refresh();
return;
}
nextRefresh = 0;
const now = Date.now();
const dbHash = await cache.get("presets_hash");
if (currentSnapshot && dbHash === currentSnapshot) {
nextRefresh = now + (REFRESH - (now % REFRESH));
return;
}
const unlockOrExtend = await cache.lock("presets_hash_lock", 3);
const res = await Promise.all([
fetchPresets(),
fetchProvisions(),
fetchVirtualParameters(),
fetchFiles(),
fetchPermissions(),
fetchUsers(),
fetchConfig()
]);
Promise.all(promises)
.then(res => {
const snapshot = {
presets: res[0],
provisions: res[1],
@@ -454,45 +419,15 @@ function refresh(callback): void {
currentSnapshot = computeHash(snapshot);
snapshots.set(currentSnapshot, snapshot);
cache.set("presets_hash", currentSnapshot, 300, err => {
unlockOrExtend(0);
if (err) return void callback(err);
await cache.set("presets_hash", currentSnapshot, 300);
await unlockOrExtend(0);
nextRefresh = now + (REFRESH - (now % REFRESH));
callback();
});
})
.catch(callback);
});
});
}
interface GetCurrentSnapshotCallback {
(err: null, currentSnapshot: string): void;
(err: Error, currentSnapshot?: null): void;
}
export function getCurrentSnapshot(callback: GetCurrentSnapshotCallback);
export function getCurrentSnapshot(): Promise<string>;
export function getCurrentSnapshot(
callback?: GetCurrentSnapshotCallback
): Promise<string> | void {
if (Date.now() < nextRefresh) {
if (callback) return callback(null, currentSnapshot);
return Promise.resolve(currentSnapshot);
}
if (callback) {
return refresh(err => {
callback(err, currentSnapshot);
});
}
return new Promise((resolve, reject) => {
refresh(err => {
if (err) return void reject(err);
resolve(currentSnapshot);
});
});
export async function getCurrentSnapshot(): Promise<string> {
if (Date.now() > nextRefresh) await refresh();
return currentSnapshot;
}
export function hasSnapshot(hash): boolean {
lib/nbi.ts
+147 -72
View File
@@ -91,11 +91,16 @@ export function listener(request, response): void {
err => {
if (err) return void throwError(err, response);
cache.del("presets_hash", err => {
if (err) return void throwError(err, response);
cache
.del("presets_hash")
.then(() => {
response.writeHead(200);
response.end();
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
}
);
@@ -103,11 +108,16 @@ export function listener(request, response): void {
db.presetsCollection.deleteOne({ _id: presetName }, err => {
if (err) return void throwError(err, response);
cache.del("presets_hash", err => {
if (err) return void throwError(err, response);
cache
.del("presets_hash")
.then(() => {
response.writeHead(200);
response.end();
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
});
} else {
@@ -128,11 +138,16 @@ export function listener(request, response): void {
err => {
if (err) return void throwError(err, response);
cache.del("presets_hash", err => {
if (err) return void throwError(err, response);
cache
.del("presets_hash")
.then(() => {
response.writeHead(200);
response.end();
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
}
);
@@ -140,11 +155,16 @@ export function listener(request, response): void {
db.objectsCollection.deleteOne({ _id: objectName }, err => {
if (err) return void throwError(err, response);
cache.del("presets_hash", err => {
if (err) return void throwError(err, response);
cache
.del("presets_hash")
.then(() => {
response.writeHead(200);
response.end();
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
});
} else {
@@ -176,11 +196,16 @@ export function listener(request, response): void {
err => {
if (err) return void throwError(err, response);
cache.del("presets_hash", err => {
if (err) return void throwError(err, response);
cache
.del("presets_hash")
.then(() => {
response.writeHead(200);
response.end();
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
}
);
@@ -188,11 +213,16 @@ export function listener(request, response): void {
db.provisionsCollection.deleteOne({ _id: provisionName }, err => {
if (err) return void throwError(err, response);
cache.del("presets_hash", err => {
if (err) return void throwError(err, response);
cache
.del("presets_hash")
.then(() => {
response.writeHead(200);
response.end();
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
});
} else {
@@ -224,11 +254,16 @@ export function listener(request, response): void {
err => {
if (err) return void throwError(err, response);
cache.del("presets_hash", err => {
if (err) return void throwError(err, response);
cache
.del("presets_hash")
.then(() => {
response.writeHead(200);
response.end();
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
}
);
@@ -238,11 +273,16 @@ export function listener(request, response): void {
err => {
if (err) return void throwError(err, response);
cache.del("presets_hash", err => {
if (err) return void throwError(err, response);
cache
.del("presets_hash")
.then(() => {
response.writeHead(200);
response.end();
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
}
);
@@ -258,7 +298,6 @@ export function listener(request, response): void {
db.devicesCollection.updateOne(
{ _id: deviceId },
{ $addToSet: { _tags: tag } },
{ safe: true },
err => {
if (err) return void throwError(err, response);
response.writeHead(200);
@@ -269,7 +308,6 @@ export function listener(request, response): void {
db.devicesCollection.updateOne(
{ _id: deviceId },
{ $pull: { _tags: tag } },
{ safe: true },
err => {
if (err) return void throwError(err, response);
@@ -296,20 +334,30 @@ export function listener(request, response): void {
return void db.tasksCollection.deleteOne({ _id: objId }, err => {
if (err) return void throwError(err, response);
cache.del(`${deviceId}_tasks_faults_operations`, err => {
if (err) return void throwError(err, response);
cache
.del(`${deviceId}_tasks_faults_operations`)
.then(() => {
response.writeHead(200);
response.end();
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
});
}
cache.del(`${deviceId}_tasks_faults_operations`, err => {
if (err) return void throwError(err, response);
cache
.del(`${deviceId}_tasks_faults_operations`)
.then(() => {
response.writeHead(200);
response.end();
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
});
} else {
@@ -324,34 +372,24 @@ export function listener(request, response): void {
if (body.length) {
const task = JSON.parse(body.toString());
task.device = deviceId;
apiFunctions.insertTasks(task, err => {
if (err) return void throwError(err, response);
cache.del(`${deviceId}_tasks_faults_operations`, err => {
if (err) return void throwError(err, response);
apiFunctions
.insertTasks(task)
.then(() => {
cache
.del(`${deviceId}_tasks_faults_operations`)
.then(() => {
if (urlParts.query.connection_request != null) {
apiFunctions.connectionRequest(deviceId, err => {
if (err) {
response.writeHead(202, err.message, {
"Content-Type": "application/json"
});
response.end(JSON.stringify(task));
return;
}
apiFunctions
.connectionRequest(deviceId)
.then(() => {
const taskTimeout =
(urlParts.query.timeout &&
parseInt(urlParts.query.timeout as string)) ||
config.get("DEVICE_ONLINE_THRESHOLD", deviceId);
apiFunctions.watchTask(
deviceId,
task._id,
taskTimeout,
(err, status) => {
if (err) return void throwError(err, response);
apiFunctions
.watchTask(deviceId, task._id, taskTimeout)
.then(status => {
if (status === "timeout") {
response.writeHead(
202,
@@ -365,7 +403,8 @@ export function listener(request, response): void {
db.tasksCollection.findOne(
{ _id: task._id },
(err, task2) => {
if (err) return void throwError(err, response);
if (err)
return void throwError(err, response);
response.writeHead(202, "Task faulted", {
"Content-Type": "application/json"
@@ -379,8 +418,18 @@ export function listener(request, response): void {
});
response.end(JSON.stringify(task));
}
}
);
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
})
.catch(err => {
response.writeHead(202, err.message, {
"Content-Type": "application/json"
});
response.end(JSON.stringify(task));
});
} else {
response.writeHead(202, {
@@ -388,18 +437,29 @@ export function listener(request, response): void {
});
response.end(JSON.stringify(task));
}
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
} else if (urlParts.query.connection_request != null) {
// No task, send connection request only
apiFunctions.connectionRequest(deviceId, err => {
if (err) {
response.writeHead(504);
response.end(`${err.name}: ${err.message}`);
return;
}
apiFunctions
.connectionRequest(deviceId)
.then(() => {
response.writeHead(200);
response.end();
})
.catch(err => {
response.writeHead(504);
response.end(`${err.name}: ${err.message}`);
});
} else {
response.writeHead(400);
@@ -438,11 +498,16 @@ export function listener(request, response): void {
err => {
if (err) return void throwError(err, response);
cache.del(`${deviceId}_tasks_faults_operations`, err => {
if (err) return void throwError(err, response);
cache
.del(`${deviceId}_tasks_faults_operations`)
.then(() => {
response.writeHead(200);
response.end();
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
}
);
@@ -468,11 +533,16 @@ export function listener(request, response): void {
err => {
if (err) return void throwError(err, response);
cache.del(`${deviceId}_tasks_faults_operations`, err => {
if (err) return void throwError(err, response);
cache
.del(`${deviceId}_tasks_faults_operations`)
.then(() => {
response.writeHead(200);
response.end();
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
}
);
@@ -547,11 +617,16 @@ export function listener(request, response): void {
const deviceId = querystring.unescape(
DELETE_DEVICE_REGEX.exec(urlParts.pathname)[1]
);
apiFunctions.deleteDevice(deviceId, err => {
if (err) return void throwError(err, response);
apiFunctions
.deleteDevice(deviceId)
.then(() => {
response.writeHead(200);
response.end();
})
.catch(err => {
setTimeout(() => {
throwError(err, response);
});
});
} else if (QUERY_REGEX.test(urlParts.pathname)) {
let collectionName = QUERY_REGEX.exec(urlParts.pathname)[1];
lib/sandbox.ts
+69 -65
View File
@@ -24,7 +24,7 @@ import * as extensions from "./extensions";
import * as logger from "./logger";
import * as scheduling from "./scheduling";
import Path from "./common/path";
import { Fault, SessionContext } from "./types";
import { Fault, SessionContext, ScriptResult } from "./types";
// Used for throwing to exit user script and commit
const COMMIT = Symbol();
@@ -38,25 +38,35 @@ const context = vm.createContext();
let state;
const runningExtensions = new WeakMap();
function runExtension(sessionContext, key, extCall, callback): void {
const runningExtensions = new WeakMap<
SessionContext,
Map<string, Promise<Fault>>
>();
function runExtension(sessionContext, key, extCall): Promise<Fault> {
let re = runningExtensions.get(sessionContext);
if (!re) {
re = {};
re = new Map<string, Promise<Fault>>();
runningExtensions.set(sessionContext, re);
}
if (re[key]) {
re[key].push(callback);
} else {
re[key] = [callback];
extensions.run(extCall, (err, fault, res) => {
const callbacks = re[key];
delete re[key];
if (!err && !fault) sessionContext.extensionsCache[key] = res;
for (const c of callbacks) c(err, fault);
});
let prom = re.get(key);
if (!prom) {
re.set(
key,
(prom = new Promise((resolve, reject) => {
extensions
.run(extCall)
.then(({ fault, value }) => {
re.delete(key);
if (!fault) sessionContext.extensionsCache[key] = value;
resolve(fault);
})
.catch(reject);
}))
);
}
return prom;
}
class SandboxDate {
@@ -343,15 +353,14 @@ function errorToFault(err: Error): Fault {
return fault;
}
export function run(
export async function run(
script: vm.Script,
globals,
globals: {},
sessionContext: SessionContext,
startRevision: number,
maxRevision: number,
callback,
extCounter = 0
): void {
): Promise<ScriptResult> {
state = {
sessionContext: sessionContext,
revision: startRevision,
@@ -374,61 +383,56 @@ export function run(
ret = script.runInContext(context, { displayErrors: false });
status = 0;
} catch (err) {
if (err === COMMIT) status = 1;
else if (err === EXT) status = 2;
else return void callback(null, errorToFault(err));
if (err === COMMIT) {
status = 1;
} else if (err === EXT) {
status = 2;
} else {
return {
fault: errorToFault(err),
clear: null,
declare: null,
done: false,
returnValue: null
};
}
}
const _state = state;
const args = Array.from(arguments);
let fault;
// Need to maintain a counter of ext() calls to avoid calling certain
// functions (e.g. log()) multiple times as calling ext() results in
// re-execution of script without revision being incremented.
args[6] = 0 - (state.extCounter - extCounter);
await Promise.all(
Object.entries(_state.extensions).map(async ([k, v]) => {
fault = (await runExtension(_state.sessionContext, k, v)) || fault;
})
);
let counter = 3;
for (const key of Object.keys(_state.extensions)) {
counter += 2;
runExtension(
_state.sessionContext,
key,
_state.extensions[key],
(err, fault) => {
if (err || fault) {
if (counter & 1) callback(err, fault);
return void (counter = 0);
if (fault) {
return {
fault: fault,
clear: null,
declare: null,
done: false,
returnValue: null
};
}
if ((counter -= 2) === 1) {
if (status === 2) {
return void run.apply(null, args);
} else {
return void callback(
null,
null,
_state.clear,
_state.declarations,
status === 0,
ret
);
}
}
}
return run(
script,
globals,
sessionContext,
startRevision,
maxRevision,
extCounter - _state.extCounter
);
}
if ((counter -= 2) === 1) {
if (status === 2) {
run.apply(null, args);
} else {
callback(
null,
null,
_state.clear,
_state.declarations,
status === 0,
ret
);
}
}
return {
fault: null,
clear: _state.clear,
declare: _state.declarations,
done: status === 0,
returnValue: ret
};
}
lib/session.ts
+289 -346
View File
File diff suppressed because it is too large. Load diff
lib/soap.ts
+5 -15
View File
@@ -21,7 +21,6 @@ import { parseXml, Document, Element, ParserOptions } from "libxmljs";
import * as config from "./config";
import { version as VERSION } from "../package.json";
import {
CpeResponse,
CpeGetResponse,
CpeSetResponse,
InformRequest,
@@ -29,7 +28,9 @@ import {
CpeRequest,
FaultStruct,
SpvFault,
CpeFault
CpeFault,
SoapMessage,
TransferCompleteRequest
} from "./types";
const SERVER_NAME = `GenieACS/${VERSION}`;
@@ -444,7 +445,7 @@ function GetRPCMethodsResponse(xml, methodResponse): void {
for (const m of methodResponse.methodList) el.node("string").text(m);
}
function TransferComplete(xml): AcsResponse {
function TransferComplete(xml): TransferCompleteRequest {
let commandKey, _faultStruct, startTime, completeTime;
for (const c of xml.childNodes()) {
switch (c.name()) {
@@ -545,18 +546,7 @@ function fault(xml): CpeFault {
return { faultCode, faultString, detail };
}
export function request(
data,
cwmpVersion,
warn
): {
id: string;
cwmpVersion: string;
sessionTimeout: number;
cpeRequest?: CpeRequest;
cpeFault?: CpeFault;
cpeResponse?: CpeResponse;
} {
export function request(data, cwmpVersion, warn): SoapMessage {
warnings = warn;
const rpc = {
lib/types.ts
+26 -2
View File
@@ -16,6 +16,7 @@ export interface Fault {
message: string;
stack?: string;
};
timestamp?: number;
}
export interface SessionFault extends Fault {
@@ -255,14 +256,20 @@ export interface InformRequest extends CpeRequest {
parameterList: [string, string | number | boolean, string][];
}
export interface AcsResponse {
name: string;
export interface TransferCompleteRequest extends CpeRequest {
name: "TransferComplete";
commandKey?: string;
faultStruct?: FaultStruct;
startTime?: number;
completeTime?: number;
}
export interface AcsResponse {
name: string;
commandKey?: string;
faultStruct?: FaultStruct;
}
export interface QueryOptions {
projection?: any;
skip?: number;
@@ -308,3 +315,20 @@ export type PermissionSet = {
filter: Expression;
};
}[];
export interface SoapMessage {
id: string;
cwmpVersion: string;
sessionTimeout: number;
cpeRequest?: CpeRequest;
cpeFault?: CpeFault;
cpeResponse?: CpeResponse;
}
export interface ScriptResult {
fault: Fault;
clear: Clear[];
declare: Declaration[];
done: boolean;
returnValue: any;
}
lib/ui/api-functions.ts
+42 -87
View File
@@ -11,126 +11,99 @@ import {
deleteDevice
} from "../api-functions";
function deleteFault(id): Promise<void> {
async function deleteFault(id): Promise<void> {
const deviceId = id.split(":", 1)[0];
const channel = id.slice(deviceId.length + 1);
return new Promise((resolve, reject) => {
Promise.all([
await Promise.all([
db.deleteFault(id),
channel.startsWith("task_")
? db.deleteTask(new ObjectID(channel.slice(5)))
: null
])
.then(() => {
del(`${deviceId}_tasks_faults_operations`, err => {
err ? reject(err) : resolve();
});
})
.catch(reject);
});
]);
await del(`${deviceId}_tasks_faults_operations`);
}
export function deleteResource(resource, id): Promise<void> {
return new Promise((resolve, reject) => {
let promise;
export async function deleteResource(resource, id): Promise<void> {
switch (resource) {
case "devices":
promise = new Promise((res, rej) => {
deleteDevice(id, err => {
if (err) return void rej(err);
res();
});
});
await deleteDevice(id);
break;
case "files":
promise = db.deleteFile(id);
await db.deleteFile(id);
break;
case "faults":
promise = deleteFault(id);
await deleteFault(id);
break;
case "provisions":
promise = db.deleteProvision(id);
await db.deleteProvision(id);
break;
case "presets":
promise = db.deletePreset(id);
await db.deletePreset(id);
break;
case "virtualParameters":
promise = db.deleteVirtualParameter(id);
await db.deleteVirtualParameter(id);
break;
case "config":
promise = db.deleteConfig(id);
await db.deleteConfig(id);
break;
case "permissions":
promise = db.deletePermission(id);
await db.deletePermission(id);
break;
case "users":
promise = db.deleteUser(id);
await db.deleteUser(id);
break;
}
promise
.then(() => {
del("presets_hash", err => {
if (err) return void reject(err);
resolve();
});
})
.catch(reject);
});
await del("presets_hash");
}
export function postTasks(
export async function postTasks(
deviceId,
tasks,
timeout
): Promise<{ connectionRequest: string; tasks: any[] }> {
return new Promise((resolve, reject) => {
for (const task of tasks) task.device = deviceId;
insertTasks(tasks, err => {
if (err) return void reject(err);
tasks = await insertTasks(tasks);
const statuses = tasks.map(t => {
return { _id: t._id, status: "pending" };
});
del(`${deviceId}_tasks_faults_operations`, err => {
if (err) return void reject(err);
connectionRequest(deviceId, err => {
if (err) {
return void resolve({
await del(`${deviceId}_tasks_faults_operations`);
try {
await connectionRequest(deviceId);
} catch (err) {
return {
connectionRequest: err.message,
tasks: statuses
});
};
}
const sample = tasks[tasks.length - 1];
// Waiting for session to finish or timeout
watchTask(deviceId, sample._id, timeout, err => {
if (err) return void reject(err);
await watchTask(deviceId, sample._id, timeout);
const promises2 = [];
const promises = [];
for (const s of statuses) {
promises2.push(db.query("tasks", ["=", ["PARAM", "_id"], s._id]));
promises2.push(
db.query("faults", [
"=",
["PARAM", "_id"],
`${deviceId}:task_${s._id}`
])
promises.push(db.query("tasks", ["=", ["PARAM", "_id"], s._id]));
promises.push(
db.query("faults", ["=", ["PARAM", "_id"], `${deviceId}:task_${s._id}`])
);
}
Promise.all(promises2)
.then(res => {
const res = await Promise.all(promises);
for (const [i, r] of statuses.entries()) {
if (res[i * 2].length === 0) {
r.status = "done";
@@ -141,14 +114,7 @@ export function postTasks(
db.deleteTask(r._id);
}
resolve({ connectionRequest: "OK", tasks: statuses });
})
.catch(reject);
});
});
});
});
});
return { connectionRequest: "OK", tasks: statuses };
}
interface PingResponse {
@@ -184,35 +150,24 @@ export function ping(host): Promise<PingResponse> {
});
}
export function putResource(resource, id, data): Promise<void> {
return new Promise((resolve, reject) => {
let promise;
export async function putResource(resource, id, data): Promise<void> {
if (resource === "presets") {
promise = db.putPreset(id, data);
await db.putPreset(id, data);
} else if (resource === "provisions") {
promise = db.putProvision(id, data);
await db.putProvision(id, data);
} else if (resource === "virtualParameters") {
promise = db.putVirtualParameter(id, data);
await db.putVirtualParameter(id, data);
} else if (resource === "config") {
promise = db.putConfig(id, data);
await db.putConfig(id, data);
} else if (resource === "permissions") {
promise = db.putPermission(id, data);
await db.putPermission(id, data);
} else if (resource === "users") {
delete data.password;
delete data.salt;
promise = db.putUser(id, data);
await db.putUser(id, data);
}
promise
.then(() => {
del("presets_hash", err => {
if (err) return void reject(err);
resolve();
});
})
.catch(reject);
});
await del("presets_hash");
}
export function authSimple(snapshot, username, password): Promise<string[]> {
lib/ui/api.ts
+1 -10
View File
@@ -546,16 +546,7 @@ router.put("/users/:id/password", async (ctx, next) => {
const password = await hashPassword(newPassword, salt);
await db.putUser(username, { password, salt });
function delCache(): Promise<void> {
return new Promise((resolve, reject) => {
del("presets_hash", err => {
if (err) return void reject(err);
resolve();
});
});
}
await delCache();
await del("presets_hash");
logger.accessInfo(log);
ctx.body = "";