Async/await let's go!

.eslintrc.json

@@ -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

@@ -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 => {
+  Promise.all([db.connect(), cache.connect()])
-    if (err) throw err;
+    .then(() => {
-    cache.connect(err => {
-      if (err) throw err;
       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

@@ -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

@@ -93,11 +93,13 @@ if (!cluster.worker) {
       .catch(exitWorkerUngracefully);
   });
 
-  db.connect(err => {
+  Promise.all([db.connect(), cache.connect()])
-    if (err) throw err;
+    .then(() => {
-    cache.connect(err => {
-      if (err) throw err;
       server.start(SERVICE_PORT, SERVICE_ADDRESS, ssl, listener);
+    })
+    .catch(err => {
+      setTimeout(() => {
+        throw err;
       });
     });
 }

bin/genieacs-nbi

@@ -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 => {
+  Promise.all([db.connect(), cache.connect()])
-    if (err) throw err;
+    .then(() => {
-    cache.connect(err => {
-      if (err) throw err;
       server.start(SERVICE_PORT, SERVICE_ADDRESS, ssl, listener);
+    })
+    .catch(err => {
+      setTimeout(() => {
+        throw err;
       });
     });
 }

bin/genieacs-ui

@@ -105,11 +105,13 @@ if (!cluster.worker) {
     listener(req, res);
   };
 
-  db2.connect(err => {
+  Promise.all([db2.connect(), cache.connect()])
-    if (err) throw err;
+    .then(() => {
-    cache.connect(err => {
-      if (err) throw err;
       server.start(SERVICE_PORT, SERVICE_ADDRESS, ssl, _listener);
+    })
+    .catch(err => {
+      setTimeout(() => {
+        throw err;
       });
     });
 }

build/build.ts

@@ -31,6 +31,7 @@ const externals = [
   "https",
   "zlib",
   "crypto",
+  "util",
   "mongodb",
   "libxmljs",
   "vm",

lib/api-functions.ts

@@ -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) => {
+  const device = await db.devicesCollection.findOne({ _id: deviceId }, options);
-    if (err) return void callback(err);
+  if (!device) throw new Error("No such device");
-    if (!device) return void callback(new Error("No such device"));
 
   let managementServer,
     connectionRequestUrl,
@@ -81,8 +80,7 @@ export function connectionRequest(deviceId, callback): void {
     password: password || ""
   };
 
-    getCurrentSnapshot()
+  const snapshot = await getCurrentSnapshot();
-      .then(snapshot => {
   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) {
-          .catch(err => {
+    if (!udpProm) throw err;
-            if (udpProm) return void udpProm.then(callback).catch(callback);
+    await udpProm;
-            callback(err);
+  }
-          });
-      })
-      .catch(callback);
-  });
 }
 
-export function watchTask(deviceId, taskId, timeout, callback): void {
+export async function watchTask(deviceId, taskId, timeout): Promise<string> {
-  setTimeout(() => {
+  await new Promise(resolve => setTimeout(resolve, 500));
-    db.tasksCollection.findOne(
-      { _id: taskId },
-      { projection: { _id: 1 } },
-      (err, task) => {
-        if (err) return void callback(err);
 
-        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(
+  const fault = await db.faultsCollection.findOne(q, {
-          q,
+    projection: { _id: 1 }
-          { projection: { _id: 1 } },
+  });
-          (err, fault) => {
+  if (fault) return "fault";
-            if (err) return void callback(err);
 
-            if (fault) return void callback(null, "fault");
+  if ((timeout -= 500) <= 0) return "timeout";
 
-            if ((timeout -= 500) <= 0) return void callback(null, "timeout");
+  return watchTask(deviceId, taskId, timeout);
-
-            watchTask(deviceId, taskId, timeout, callback);
-          }
-        );
-      }
-    );
-  }, 500);
 }
 
-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)
+  else if (!tasks || tasks.length === 0) return tasks || [];
-    return void callback(null, tasks || []);
 
-  let counter = tasks.length;
   for (const task of tasks) {
-    sanitizeTask(task, t => {
+    sanitizeTask(task);
-      if (t.uniqueKey) {
+    if (task.uniqueKey) {
-        db.tasksCollection.deleteOne(
+      await db.tasksCollection.deleteOne({
-          { device: t.device, uniqueKey: t.uniqueKey },
+        device: task.device,
-          () => {}
+        uniqueKey: task.uniqueKey
-        );
-      }
-
-      if (--counter === 0) db.tasksCollection.insertMany(tasks, callback);
       });
     }
   }
+  await db.tasksCollection.insertMany(tasks);
+  return tasks;
+}
 
-export function deleteDevice(deviceId, callback): void {
+export async function deleteDevice(deviceId): Promise<void> {
-  db.tasksCollection.deleteMany({ device: deviceId }, err => {
+  await Promise.all([
-    if (err) return void callback(err);
+    db.tasksCollection.deleteMany({ device: deviceId }),
-    db.devicesCollection.deleteOne({ _id: deviceId }, err => {
+    db.devicesCollection.deleteOne({ _id: deviceId }),
-      if (err) return void callback(err);
+    db.faultsCollection.deleteMany({
-      db.faultsCollection.deleteMany(
-        {
       _id: {
         $regex: `^${common.escapeRegExp(deviceId)}\\:`
       }
-        },
+    }),
-        err => {
+    db.operationsCollection.deleteMany({
-          if (err) return void callback(err);
-          db.operationsCollection.deleteMany(
-            {
       _id: {
         $regex: `^${common.escapeRegExp(deviceId)}\\:`
       }
-            },
+    }),
-            err => {
+    cache.del(`${deviceId}_tasks_faults_operations`)
-              if (err) return void callback(err);
+  ]);
-              cache.del(`${deviceId}_tasks_faults_operations`, callback);
-            }
-          );
-        }
-      );
-    });
-  });
 }

lib/cache.ts

@@ -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 mongoClient: MongoClient;
-let mongoCollection;
+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 = await MongoClient.connect(MONGODB_CONNECTION_URL, {
-  MongoClient.connect(
+    useNewUrlParser: true
-    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();
   });
-    }
+  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 {
+export async function disconnect(): Promise<void> {
-  if (mongoClient) mongoClient.close();
+  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) => {
+    const res = await mongoCollection.find({ _id: { $in: key } }).toArray();
-      if (err) return void callback(err);
 
     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) => {
+    const res = await mongoCollection.findOne({ _id: { $in: [key] } });
-      if (err || !res) return void callback(err);
+    if (res && res["expire"] > expire) return res["value"];
-
+    return res;
-      if (res["expire"] > expire) return void callback(null, res["value"]);
-
-      callback();
-    });
   }
 }
 
-export function del(key, callback): void {
+export async function del(key): Promise<void> {
   if (Array.isArray(key))
-    mongoCollection.deleteMany({ _id: { $in: key } }, callback);
+    await mongoCollection.deleteMany({ _id: { $in: key } });
-  else mongoCollection.deleteOne({ _id: key }, callback);
+  else await mongoCollection.deleteOne({ _id: key });
 }
 
-export function set(
+export async function set(
   key: string,
   value: string | number,
-  callback: (err?: Error) => void
+  ttl: number = MAX_CACHE_TTL
-): void;
+): Promise<void> {
-export function set(
+  const expire = new Date(Date.now() - mongoTimeOffset + ttl * 1000);
-  key: string,
+  await mongoCollection.replaceOne(
-  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(
     { _id: key },
     { _id: key, value: value, expire: expire },
-    { upsert: true },
+    { upsert: true }
-    callback
   );
 }
 
-export function pop(key, callback): void {
+export async function pop(key): Promise<any> {
-  mongoCollection.findOneAndDelete({ _id: key }, (err, res) => {
+  const res = await mongoCollection.findOneAndDelete({ _id: key });
-    if (err || !res["value"]) return void callback(err);
 
-    if (res["value"]["expire"] > new Date(Date.now() - mongoTimeOffset))
+  if (
-      return void callback(null, res["value"]["value"]);
+    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) => {
+      const res = await mongoCollection.deleteOne({
-        if (err || res["result"]["n"] !== 1)
+        _id: lockName,
-          throw err || new Error("Lock expired");
+        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 },
+        { expire: expire }
-        (err, res) => {
-          if (err || res["result"]["n"] !== 1)
-            throw err || new Error("Lock expired");
-        }
       );
+      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 },
+      { upsert: true }
-    err => {
+    );
+  } catch (err) {
     if (err && err.code === 11000) {
-        return setTimeout(() => {
+      await new Promise(resolve => setTimeout(resolve, 200));
-          lock(lockName, ttl, callback);
+      return lock(lockName, ttl);
-        }, 200);
+    }
   }
 
-      return callback(err, unlockOrExtend);
+  return unlockOrExtend;
-    }
-  );
 }

lib/db.ts

@@ -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,
+export let tasksCollection: Collection,
-  devicesCollection,
+  devicesCollection: Collection,
-  presetsCollection,
+  presetsCollection: Collection,
-  objectsCollection,
+  objectsCollection: Collection,
-  provisionsCollection,
+  provisionsCollection: Collection,
-  virtualParametersCollection,
+  virtualParametersCollection: Collection,
-  faultsCollection,
+  faultsCollection: Collection,
-  filesCollection,
+  filesCollection: Collection,
-  operationsCollection,
+  operationsCollection: Collection,
-  permissionsCollection,
+  permissionsCollection: Collection,
-  usersCollection,
+  usersCollection: Collection,
-  configCollection;
+  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 {
+export async function disconnect(): Promise<void> {
-  if (client) client.close();
+  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][],
+  patterns: [Path, number][]
-  callback
+): Promise<[[Path, number, Attributes?][], [Path, number][]]> {
-): void {
   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) => {
+  const device = await devicesCollection.findOne({ _id: id }, options);
-    if (err || !device) return void callback(err);
+  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,
+  sessionTimestamp: number
-  callback
+): Promise<void> {
-): 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(
+  const result = await devicesCollection.updateOne({ _id: deviceId }, update, {
-    { _id: deviceId },
+    upsert: isNew
-    update,
+  });
-    { upsert: isNew },
+
-    (err, result) => {
+  if (result.result.n !== 1)
-      if (err || result.result.n !== 1) {
+    throw new Error(`Device ${deviceId} not found in database`);
-        return void callback(
-          err || new Error(`Device ${deviceId} not found in database`)
-        );
-      }
 
   if (update2) {
-        return void devicesCollection.updateOne(
+    await devicesCollection.updateOne({ _id: deviceId }, update2);
-          { _id: deviceId },
+    return;
-          update2,
+  }
-          callback
-        );
 }
 
-      callback();
+export async function getFaults(
-    }
+  deviceId
-  );
+): Promise<{ [channel: string]: SessionFault }> {
-}
+  const res = await faultsCollection
-
-export function getFaults(deviceId, callback): void {
-  faultsCollection
     .find({ _id: { $regex: `^${escapeRegExp(deviceId)}\\:` } })
-    .toArray((err, res) => {
+    .toArray();
-      if (err) return callback(err);
 
-      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 {
+export async function deleteFault(deviceId, channel): Promise<void> {
-  faultsCollection.deleteOne({ _id: `${deviceId}:${channel}` }, callback);
+  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 = [];
+  const tasks = [] as Task[];
-
-  let f;
-  cur.next(
-    (f = (err, task) => {
-      if (err) return void callback(err);
-
-      if (!task) return void callback(null, tasks, null);
 
+  for await (const task of cur) {
     if (task.timestamp) task.timestamp = +task.timestamp;
     if (task.expiry) task.expiry = +task.expiry;
-      if (task.timestamp >= timestamp)
+    if (task.timestamp >= timestamp) return [tasks, +task.timestamp];
-        return void callback(null, 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) => {
+      const res = await filesCollection.find(q).toArray();
-          if (err) return void callback(err);
 
       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 {
+export async function getOperations(
-  tasksCollection.deleteMany(
+  deviceId
-    { _id: { $in: taskIds.map(id => new ObjectID(id)) } },
+): Promise<{ [commandKey: string]: Operation }> {
-    callback
+  const res = await operationsCollection
-  );
-}
-
-export function getOperations(deviceId, callback): void {
-  operationsCollection
     .find({ _id: { $regex: `^${escapeRegExp(deviceId)}\\:` } })
-    .toArray((err, res) => {
+    .toArray();
-      if (err) return void callback(err);
 
-      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;
   }
-
+  return operations;
-      callback(err, 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(
+  await operationsCollection.replaceOne({ _id: id }, operation, {
-    { _id: id },
+    upsert: true
-    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"])
-      }))
-    );
   });
 }
 
-export function getPermissions(
+export async function deleteOperation(deviceId, commandKey): Promise<void> {
-  callback: (
+  await operationsCollection.deleteOne({ _id: `${deviceId}:${commandKey}` });
-    err?: Error,
+}
-    permissions?: {
+
+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(
+export async function getPermissions(): Promise<Permission[]> {
-  callback: (
+  return permissionsCollection.find().toArray();
-    err?: Error,
+}
-    users?: { _id: string; password: string; salt: string; roles: string }[]
+
-  ) => void
+interface User {
-): void {
+  _id: string;
-  usersCollection.find().toArray(callback);
+  password: string;
+  salt: string;
+  roles: string;
+}
+
+export async function getUsers(): Promise<User[]> {
+  return usersCollection.find().toArray();
 }

lib/extensions.ts

@@ -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))
+          if (jobs.delete(id)) {
-          callback(null, { code: err.name, message: err.message });
+            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) {
+        if (processes[scriptName] === p) delete processes[scriptName];
-        kill(processes[scriptName]);
-        delete processes[scriptName];
-      }
       });
 
       p.on("message", messageHandler);
     }
 
     setTimeout(() => {
-    if (jobs.delete(id))
+      if (jobs.delete(id)) {
-      callback(null, { code: "timeout", message: "Extension timed out" });
+        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 {
+function kill(process: ChildProcess): Promise<void> {
-  if (process.signalCode !== null || process.exitCode !== null) return;
+  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 {
+export async function killAll(): Promise<void> {
-  let counter = 1;
+  await Promise.all(
-  for (const n in processes) {
+    Object.entries(processes).map(([k, p]) => {
-    ++counter;
+      delete processes[k];
-    kill(processes[n], () => {
+      return kill(p);
-      if (--counter === 0 && callback) callback();
+    })
-    });
+  );
-    delete processes[n];
-  }
-  if (--counter === 0 && callback) callback();
 }

lib/local-cache.ts

@@ -108,36 +108,9 @@ function flattenObject(src, prefix = "", dst = {}): {} {
   return dst;
 }
 
-function refresh(callback): void {
+async function fetchPresets(): Promise<Preset[]> {
-  if (!nextRefresh) {
+  const res = await db.getPresets();
-    return void setTimeout(() => {
+  let objects = await db.getObjects();
-      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);
 
   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) {
+    if (!obj["_keys"] || !obj["_keys"].length)
-                  obj["_keys"] = Object.keys(obj).filter(
+      obj["_keys"] = Object.keys(obj).filter(k => !k.startsWith("_"));
-                    k => !k.startsWith("_")
-                  );
-                }
 
     return obj;
   });
 
   res.sort((a, b) => {
-                if (a.weight === b.weight) return a._id > b._id;
+    if (a["weight"] === b["weight"])
-                else return 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;
+    let schedule: { md5: string; duration: number; schedule: any } = null;
-                if (preset.schedule) {
+    if (preset["schedule"]) {
-                  const parts = preset.schedule.trim().split(/\s+/);
+      const parts = preset["schedule"].trim().split(/\s+/);
       schedule = {
         md5: crypto
           .createHash("md5")
-                      .update(preset.schedule)
+          .update(preset["schedule"])
-                      .digest("hex")
+          .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,
+          preset: preset["_id"],
-                      schedule: preset.schedule
+          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(
+      precondition = mongoQueryToFilter(JSON.parse(preset["precondition"]));
-                    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 (
+                if (!k.startsWith("_") && !(obj["_keys"].indexOf(k) !== -1))
-                              !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(
+          throw new Error(`Unknown configuration type ${c.type}`);
-                        new Error(`Unknown configuration type ${c.type}`)
-                      );
       }
     }
 
     presets.push({
-                  name: preset._id,
+      name: preset["_id"],
-                  channel: preset.channel || "default",
+      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(
+async function fetchProvisions(): Promise<{}> {
-        new Promise((resolve, reject) => {
+  const res = await db.getProvisions();
-          db.getProvisions((err, res) => {
-            if (err) return void reject(err);
 
   const provisions = {};
   for (const r of res) {
-              provisions[r._id] = {};
+    provisions[r["_id"]] = {};
-              provisions[r._id].md5 = crypto
+    provisions[r["_id"]].md5 = crypto
       .createHash("md5")
-                .update(r.script)
+      .update(r["script"])
       .digest("hex");
-              provisions[r._id].script = new vm.Script(
+    provisions[r["_id"]].script = new vm.Script(
-                `"use strict";(function(){\n${r.script}\n})();`,
+      `"use strict";(function(){\n${r["script"]}\n})();`,
-                { filename: r._id, lineOffset: -1, timeout: 50 }
+      { filename: r["_id"], lineOffset: -1, timeout: 50 }
     );
   }
 
-            resolve(provisions);
+  return provisions;
-          });
+}
-        })
-      );
 
-      promises.push(
+async function fetchVirtualParameters(): Promise<{}> {
-        new Promise((resolve, reject) => {
+  const res = await db.getVirtualParameters();
-          db.getVirtualParameters((err, res) => {
-            if (err) return void reject(err);
 
   const virtualParameters = {};
   for (const r of res) {
-              virtualParameters[r._id] = {};
+    virtualParameters[r["_id"]] = {};
-              virtualParameters[r._id].md5 = crypto
+    virtualParameters[r["_id"]].md5 = crypto
       .createHash("md5")
-                .update(r.script)
+      .update(r["script"])
       .digest("hex");
-              virtualParameters[r._id].script = new vm.Script(
+    virtualParameters[r["_id"]].script = new vm.Script(
-                `"use strict";(function(){\n${r.script}\n})();`,
+      `"use strict";(function(){\n${r["script"]}\n})();`,
-                { filename: r._id, lineOffset: -1, timeout: 50 }
+      { filename: r["_id"], lineOffset: -1, timeout: 50 }
     );
   }
 
-            resolve(virtualParameters);
+  return 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;
 }
 
-            resolve(files);
+async function fetchPermissions(): Promise<Permissions> {
-          });
+  const perms = await db.getPermissions();
-        })
-      );
-
-      promises.push(
-        new Promise((resolve, reject) => {
-          db.getPermissions((err, perms) => {
-            if (err) return void reject(err);
   const permissions: Permissions = {};
+
   for (const p of perms) {
     if (!permissions[p.role]) permissions[p.role] = {};
-              if (!permissions[p.role][p.access])
+    if (!permissions[p.role][p.access]) 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) {
+    if (p.validate)
-                permissions[p.role][p.access][p.resource].validate = parse(
+      permissions[p.role][p.access][p.resource].validate = parse(p.validate);
-                  p.validate
-                );
-              }
   }
 
-            resolve(permissions);
+  return permissions;
-          });
+}
-        })
-      );
 
-      promises.push(
+async function fetchFiles(): Promise<{}> {
-        new Promise((resolve, reject) => {
+  const res = await db.getFiles();
-          db.getUsers((err, _users) => {
+  const files = {};
-            if (err) return void reject(err);
+
+  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(
+  return users;
-        new Promise((resolve, reject) => {
+}
-          db.getConfig((err, conf) => {
+
-            if (err) return void reject(err);
+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 => {
+  await cache.set("presets_hash", currentSnapshot, 300);
-            unlockOrExtend(0);
+  await unlockOrExtend(0);
-            if (err) return void callback(err);
+
   nextRefresh = now + (REFRESH - (now % REFRESH));
-            callback();
-          });
-        })
-        .catch(callback);
-    });
-  });
 }
 
-interface GetCurrentSnapshotCallback {
+export async function getCurrentSnapshot(): Promise<string> {
-  (err: null, currentSnapshot: string): void;
+  if (Date.now() > nextRefresh) await refresh();
-  (err: Error, currentSnapshot?: null): void;
+  return currentSnapshot;
-}
-
-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 function hasSnapshot(hash): boolean {

lib/nbi.ts

@@ -91,11 +91,16 @@ export function listener(request, response): void {
           err => {
             if (err) return void throwError(err, response);
 
-            cache.del("presets_hash", err => {
+            cache
-              if (err) return void throwError(err, response);
+              .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 => {
+          cache
-            if (err) return void throwError(err, response);
+            .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 => {
+            cache
-              if (err) return void throwError(err, response);
+              .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 => {
+          cache
-            if (err) return void throwError(err, response);
+            .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 => {
+            cache
-              if (err) return void throwError(err, response);
+              .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 => {
+          cache
-            if (err) return void throwError(err, response);
+            .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 => {
+            cache
-              if (err) return void throwError(err, response);
+              .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 => {
+            cache
-              if (err) return void throwError(err, response);
+              .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 => {
+              cache
-                if (err) return void throwError(err, response);
+                .del(`${deviceId}_tasks_faults_operations`)
-
+                .then(() => {
                   response.writeHead(200);
                   response.end();
+                })
+                .catch(err => {
+                  setTimeout(() => {
+                    throwError(err, response);
+                  });
                 });
             });
           }
 
-          cache.del(`${deviceId}_tasks_faults_operations`, err => {
+          cache
-            if (err) return void throwError(err, response);
+            .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 => {
+          apiFunctions
-            if (err) return void throwError(err, response);
+            .insertTasks(task)
-
+            .then(() => {
-            cache.del(`${deviceId}_tasks_faults_operations`, err => {
+              cache
-              if (err) return void throwError(err, response);
+                .del(`${deviceId}_tasks_faults_operations`)
-
+                .then(() => {
                   if (urlParts.query.connection_request != null) {
-                apiFunctions.connectionRequest(deviceId, err => {
+                    apiFunctions
-                  if (err) {
+                      .connectionRequest(deviceId)
-                    response.writeHead(202, err.message, {
+                      .then(() => {
-                      "Content-Type": "application/json"
-                    });
-                    response.end(JSON.stringify(task));
-                    return;
-                  }
-
                         const taskTimeout =
                           (urlParts.query.timeout &&
                             parseInt(urlParts.query.timeout as string)) ||
                           config.get("DEVICE_ONLINE_THRESHOLD", deviceId);
 
-                  apiFunctions.watchTask(
+                        apiFunctions
-                    deviceId,
+                          .watchTask(deviceId, task._id, taskTimeout)
-                    task._id,
+                          .then(status => {
-                    taskTimeout,
-                    (err, status) => {
-                      if (err) return void throwError(err, response);
-
                             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 => {
+          apiFunctions
-            if (err) {
+            .connectionRequest(deviceId)
-              response.writeHead(504);
+            .then(() => {
-              response.end(`${err.name}: ${err.message}`);
-              return;
-            }
               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 => {
+                      cache
-                        if (err) return void throwError(err, response);
+                        .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 => {
+                  cache
-                    if (err) return void throwError(err, response);
+                    .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 => {
+      apiFunctions
-        if (err) return void throwError(err, response);
+        .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

@@ -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();
+const runningExtensions = new WeakMap<
-function runExtension(sessionContext, key, extCall, callback): void {
+  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]) {
+  let prom = re.get(key);
-    re[key].push(callback);
+  if (!prom) {
-  } else {
+    re.set(
-    re[key] = [callback];
+      key,
-    extensions.run(extCall, (err, fault, res) => {
+      (prom = new Promise((resolve, reject) => {
-      const callbacks = re[key];
+        extensions
-      delete re[key];
+          .run(extCall)
-      if (!err && !fault) sessionContext.extensionsCache[key] = res;
+          .then(({ fault, value }) => {
-      for (const c of callbacks) c(err, fault);
+            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;
+    if (err === COMMIT) {
-    else if (err === EXT) status = 2;
+      status = 1;
-    else return void callback(null, errorToFault(err));
+    } 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
+  await Promise.all(
-  // functions (e.g. log()) multiple times as calling ext() results in
+    Object.entries(_state.extensions).map(async ([k, v]) => {
-  // re-execution of script without revision being incremented.
+      fault = (await runExtension(_state.sessionContext, k, v)) || fault;
-  args[6] = 0 - (state.extCounter - extCounter);
+    })
+  );
 
-  let counter = 3;
+  if (fault) {
-  for (const key of Object.keys(_state.extensions)) {
+    return {
-    counter += 2;
+      fault: fault,
-    runExtension(
+      clear: null,
-      _state.sessionContext,
+      declare: null,
-      key,
+      done: false,
-      _state.extensions[key],
+      returnValue: null
-      (err, fault) => {
+    };
-        if (err || fault) {
-          if (counter & 1) callback(err, fault);
-          return void (counter = 0);
   }
-        if ((counter -= 2) === 1) {
+
   if (status === 2) {
-            return void run.apply(null, args);
+    return run(
-          } else {
+      script,
-            return void callback(
+      globals,
-              null,
+      sessionContext,
-              null,
+      startRevision,
-              _state.clear,
+      maxRevision,
-              _state.declarations,
+      extCounter - _state.extCounter
-              status === 0,
-              ret
-            );
-          }
-        }
-      }
     );
   }
 
-  if ((counter -= 2) === 1) {
+  return {
-    if (status === 2) {
+    fault: null,
-      run.apply(null, args);
+    clear: _state.clear,
-    } else {
+    declare: _state.declarations,
-      callback(
+    done: status === 0,
-        null,
+    returnValue: ret
-        null,
+  };
-        _state.clear,
-        _state.declarations,
-        status === 0,
-        ret
-      );
-    }
-  }
 }

lib/soap.ts

@@ -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(
+export function request(data, cwmpVersion, warn): SoapMessage {
-  data,
-  cwmpVersion,
-  warn
-): {
-  id: string;
-  cwmpVersion: string;
-  sessionTimeout: number;
-  cpeRequest?: CpeRequest;
-  cpeFault?: CpeFault;
-  cpeResponse?: CpeResponse;
-} {
   warnings = warn;
 
   const rpc = {

lib/types.ts

@@ -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 {
+export interface TransferCompleteRequest extends CpeRequest {
-  name: string;
+  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

@@ -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 => {
+  await del(`${deviceId}_tasks_faults_operations`);
-          err ? reject(err) : resolve();
-        });
-      })
-      .catch(reject);
-  });
 }
 
-export function deleteResource(resource, id): Promise<void> {
+export async function deleteResource(resource, id): Promise<void> {
-  return new Promise((resolve, reject) => {
-    let promise;
-
   switch (resource) {
     case "devices":
-        promise = new Promise((res, rej) => {
+      await deleteDevice(id);
-          deleteDevice(id, err => {
-            if (err) return void rej(err);
-            res();
-          });
-        });
       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
+  await del("presets_hash");
-      .then(() => {
-        del("presets_hash", err => {
-          if (err) return void reject(err);
-          resolve();
-        });
-      })
-      .catch(reject);
-  });
 }
 
-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 => {
+  tasks = await insertTasks(tasks);
-      if (err) return void reject(err);
   const statuses = tasks.map(t => {
     return { _id: t._id, status: "pending" };
   });
-      del(`${deviceId}_tasks_faults_operations`, err => {
+
-        if (err) return void reject(err);
+  await del(`${deviceId}_tasks_faults_operations`);
-        connectionRequest(deviceId, err => {
+
-          if (err) {
+  try {
-            return void resolve({
+    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 => {
+  await watchTask(deviceId, sample._id, timeout);
-            if (err) return void reject(err);
 
-            const promises2 = [];
+  const promises = [];
   for (const s of statuses) {
-              promises2.push(db.query("tasks", ["=", ["PARAM", "_id"], s._id]));
+    promises.push(db.query("tasks", ["=", ["PARAM", "_id"], s._id]));
-              promises2.push(
+    promises.push(
-                db.query("faults", [
+      db.query("faults", ["=", ["PARAM", "_id"], `${deviceId}:task_${s._id}`])
-                  "=",
-                  ["PARAM", "_id"],
-                  `${deviceId}:task_${s._id}`
-                ])
     );
   }
 
-            Promise.all(promises2)
+  const res = await Promise.all(promises);
-              .then(res => {
   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 });
+  return { connectionRequest: "OK", tasks: statuses };
-              })
-              .catch(reject);
-          });
-        });
-      });
-    });
-  });
 }
 
 interface PingResponse {
@@ -184,35 +150,24 @@ export function ping(host): Promise<PingResponse> {
   });
 }
 
-export function putResource(resource, id, data): Promise<void> {
+export async function putResource(resource, id, data): Promise<void> {
-  return new Promise((resolve, reject) => {
-    let promise;
-
   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
+  await del("presets_hash");
-      .then(() => {
-        del("presets_hash", err => {
-          if (err) return void reject(err);
-          resolve();
-        });
-      })
-      .catch(reject);
-  });
 }
 
 export function authSimple(snapshot, username, password): Promise<string[]> {

lib/ui/api.ts

@@ -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> {
+  await del("presets_hash");
-    return new Promise((resolve, reject) => {
-      del("presets_hash", err => {
-        if (err) return void reject(err);
-        resolve();
-      });
-    });
-  }
-
-  await delCache();
 
   logger.accessInfo(log);
   ctx.body = "";