TempestDataCollection/routes/ping.js

let _ = require("underscore");
let express = require('express');
let router = express.Router();
const {MongoClient} = require("mongodb");
let localAddresses = process.env.LOCAL_ADDRESSES;  //eg: "10.18.,10.17."
// Create an array of local address beginnings.  This is matched against the client addresses to determine if they are local.  If not provided then all addresses are considered local.
if(localAddresses) localAddresses = localAddresses.split(',');
//const uri = "mongodb://test:1qaz2wsx@mongodb.avpanthers.org:27017/";
let uri = process.env.MONGO_URL;  //Read from the nginx sites-available file for this app.
//mongodb://host1:27017,host2:27017,host3:27017/?replicaSet=myRs
if(!uri) {
	uri = "mongodb://localhost/avusd_data_collection";
}
const client = new MongoClient(uri);
let collection;
let records = {};

// We are keeping an in-memory set of current/active records for each Chromebook to reduce the number of reads without _id we perform.
// The idea is that each Chromebook pings every 5 minutes when a student is logged in and using the Chromebook.
// We note how long between the first and last use of each chromebook & user, and how many pings were recorded during that time period.
// This gives us an idea of who used it for any given time period, and roughly how much use it got.

// Prepare a database connection for use later.
async function connect() {
	try {
		await client.connect();
		const database = client.db("avusd_data_collection");
		collection = database.collection('records');
		console.log("Connected to Mongodb server");
	} catch(e) {
		console.log(e);
	}
}

// Load a record for specific Chromebook by serial number (we assume they are unique).
async function loadRecord(serial) {
	//Read record with given serial.
	let record = await collection.findOne({serial, closed: false});

	//If we found one then add it to the map.
	if(record && !record.closed) {
		records[record.serial] = record;
	}
	else {record = null;}

	return record;
}

// Create a new record for a Chromebook & user.  Set it in the cache (replace any existing one for that serial).
async function createRecord(record, isInternal) {
	record.startTime = new Date().getTime();
	record.count = 1;
	record.internalCount = isInternal ? 1 : 0;

	//Write to db.
	let queryResult = await collection.insertOne(record);

	//Handle errors.
	if(queryResult.writeConcernError && queryResult.writeConcernError.errmsg) {
		console.log(queryResult.writeConcernError.errmsg + " ::: " + JSON.stringify(record));
		record = null;
	}
	else {
		//Add the map if there were no errors.
		records[record.serial] = record;
	}

	return record;
}

// Update a record.  Will create a new record if one doesn't exist for the Chromebook.  Will close a record if the user changes, and then create a new one for the new user.
async function updateRecord(record, isInternal, clientAddress) {
	let existing = records[record.serial];

	if(!collection) {
		await connect();
	}

	//If one is not in the cache, then read it from the db.
	if(!existing) {
		existing = await loadRecord(record.serial);
	}

	//If we couldn't find one for the given serial in the db, then create it.
	// Note: We only do this if the connection is on the internal network.
	// This prevents attackers from spamming the server with random id's to pollute the data.
	if(!existing) {
		if(isInternal) {
			existing = await createRecord(record, isInternal);
		}
		else {
			//Log the external attempt to update a 'new' chromebook.
			console.log("Ignoring external (" + clientAddress + ") input: " + JSON.stringify(record));
		}
	}
	else {
		let changed = {};
		let inc = {};

		//If the user has changed, then close the record.  Create a new record for the new user.
		if(existing.email !== record.email) {
			changed.closed = existing.closed = true;
			await createRecord(record, isInternal);
		}
		else {
			//Update the time and count for both the db and the in memory data.
			changed.endTimestamp = existing.endTimestamp = new Date().getTime();
			// Note: Cannot increment this way because there could be multiple instances of this process running with different cached values.  Use MongoDB $inc instead.
			// changed.count = existing.count = existing.count + 1;
			inc.count = 1;

			//Update the internal count if the Chromebook address is on the internal network.
			if(isInternal) {
				// Note: Cannot increment this way because there could be multiple instances of this process running with different cached values.  Use MongoDB $inc instead.
				// changed.internalCount = existing.internalCount = existing.internalCount + 1;
				inc.internalCount = 1;
			}
		}

		//If something changed, then update the db.
		if(!_.isEmpty(changed)) {
			let result = await collection.updateOne({_id: existing._id}, {$set: changed, $inc: inc});

			//Error handling.
			if(result.modifiedCount !== 1) {
				console.log("Failed to update the record: " + JSON.stringify(existing));
			}
		}
	}
}

// Handle the client calling Ping.
router.get('/', function(req, res, next) {
	//Get the parameters.
	const params = req.query;
	const email = params.email;
	const assetId = params.assetId;
	const serial = params.serial;
	const deviceId = params.deviceId;

	//DEBUG
	// console.log("Email: " + params.email);
	// console.log("AssetId: " + params.assetId);
	// console.log("Serial: " + params.serial);
	// console.log("DeviceId: " + params.deviceId);

	let clientAddress = req.header("X-Real-IP");
	if(!clientAddress) clientAddress = req.socket.remoteAddress;
	let isLocal = true;
	console.log("Found IP: " + clientAddress);

	if(localAddresses) {
		isLocal = false;
		for(let i = 0; !isLocal && i < localAddresses.length; i++) {
			let next = localAddresses[i];
			isLocal = clientAddress.startsWith(next);
		}
	}

	//Note: We are not waiting for this to finish.  We don't care about the output.
	updateRecord({serial, assetId, deviceId, email}, isLocal, clientAddress);

	//Send response.  Nothing for the moment.
	res.setHeader("Access-Control-Allow-Origin", "*");
	//res.setHeader("Content-Type", "application/json;charset=UTF8");
	res.status(200);
	res.end('Pong');
});

module.exports = router;