pairnet 0.1.0 → 0.2.0

package/lib/protocol.js

@@ -1,191 +0,0 @@
-"use strict";
-
-const encodeCBOR = require("@promistream/encode-cbor");
-const decodeCBOR = require("@promistream/decode-cbor");
-const pipe = require("@promistream/pipe");
-const fromNodeStream = require("@promistream/from-node-stream");
-const map = require("@promistream/map");
-const infiniteQueue = require("../streams/infinite-queue");
-const simpleSink = require("@promistream/simple-sink");
-const createDebugStream = require("@promistream/debug");
-const objid = require("@joepie91/objid");
-
-const debug = require("debug")("pairnet:protocol");
-
-const createSender = require("./sender");
-const createReplyTracker = require("./reply-tracker");
-const disconnectSocket = require("../promisified/disconnect-socket");
-const filter = require("@promistream/filter");
-
-let NORMAL_QUERY_TYPE = "q";
-let NEGOTIATION_QUERY_TYPE = "nq";
-let EVENT_TYPE = "e";
-// negotiation query, negotiation reply, negotiation reply error
-let NEGOTIATION_TYPES = new Set([ "nq", "n", "N" ]);
-// reply, reply error, negotiation reply, negotiation reply error
-let REPLY_TYPES = new Set([ "r", "R", "n", "N" ]);
-let SUCCESS_REPLIES = new Set([ "r", "n" ]);
-let ERROR_REPLIES = new Set([ "R", "N" ]);
-
-async function evaluateQuery(query, handler) {
-	try {
-		return {
-			success: true,
-			message: await handler(query)
-		};
-	} catch (error) {
-		if (error.code === "QUERY_ERROR_RESPONSE") {
-			return {
-				success: false,
-				message: error.messageData
-			};
-		} else {
-			throw error;
-		}
-	}
-}
-
-module.exports = async function handleProtocol(socket, { onQuery, protocolConfiguration } = {}) {
-	debug("Attaching semantic protocol handler");
-
-	let writeQueue = infiniteQueue([]);
-	let replyTracker = createReplyTracker();
-	let negotiationCompleted = false;
-
-	let sender = createSender(replyTracker, (message) => {
-		writeQueue.push(message);
-	});
-
-	// Send pipeline
-	pipe([
-		writeQueue.stream,
-		map((message) => {
-			debug("Sending message:", message);
-
-			let isNegotiationMessage = NEGOTIATION_TYPES.has(message.t);
-			
-			if (negotiationCompleted !== true && !isNegotiationMessage) {
-				debug(`[handleProtocol] Prevented message send; not allowed type '${message.t}' during negotiation`);
-				throw new Error(`Cannot send messages in negotiation phase`);
-			} else {
-				return message;
-			}
-		}),
-		// createDebugStream(`pairnet:protocol:send-pipeline ${objid(socket)}`),
-		encodeCBOR(),
-		fromNodeStream.fromWritable(socket)
-	]).read().catch((error) => {
-		// These errors are also mirrored on the read side, so we don't need to handle them here
-		debug(`Error occurred on writable side of socket`, error);
-	});
-
-	let incomingMessageStream = pipe([
-		fromNodeStream.fromReadable(socket),
-		decodeCBOR(),
-		// createDebugStream(`pairnet:protocol:receive-pipeline ${objid(socket)}`),
-	]);
-
-	let clientHelloQuery = (protocolConfiguration.isClient)
-		? sender.sendNegotiationQuery(await protocolConfiguration.generateClientHello())._queryID.toString("hex") // FIXME: Hacky
-		: null;
-
-	// We read messages for as long as negotiation has not been completed yet
-	await pipe([
-		incomingMessageStream,
-		simpleSink(async (message) => {
-			debug("Received message:", message);
-
-			let isNegotiationMessage = NEGOTIATION_TYPES.has(message.t);
-			let isReplyMessage = REPLY_TYPES.has(message.t);
-
-			if (!isNegotiationMessage) {
-				debug(`[readLoop] Ignored received message; not allowed type '${message.t}' during negotiation`);
-			} else if (isReplyMessage) {
-				if (message.i.toString("hex") === clientHelloQuery) {
-					let helloResponse = message.m;
-					let helloDecision = await protocolConfiguration.onServerHello(helloResponse);
-
-					if (helloDecision === false) {
-						// Connection rejected
-						return disconnectSocket(socket);
-					} else {
-						debug(`[readLoop] Negotiation completed on client side; detaching sink...`);
-						return null;
-					}
-				} else {
-					throw new Error(`Unrecognized negotiation query reply, id: ${message.i}`);
-				}
-			} else if (message.t === NEGOTIATION_QUERY_TYPE) {
-				let result = await evaluateQuery(message.m, protocolConfiguration.onClientHello);
-
-				if (result.success) { 
-					await sender.sendNegotiationReply(message.i, result.message); 
-					
-					debug(`[readLoop] Negotiation completed on server side; detaching sink...`);
-					return null;
-				} else {
-					await sender.sendNegotiationReplyError(message.i, result.message);
-				}
-
-				debug(`[readLoop] Processed negotiation query ID '${message.i.toString("hex")}'`);
-			} else {
-				debug(`[readLoop] Received message with unknown type '${message.t}'`);
-			}
-		})
-	]).read();
-
-	// Unlock the sender
-	negotiationCompleted = true;
-
-	let eventStream = pipe([
-		incomingMessageStream,
-		filter(async (message) => {
-			let isReplyMessage = REPLY_TYPES.has(message.t);
-
-			if (message.t === NORMAL_QUERY_TYPE) {
-				let result = await evaluateQuery(message.m, onQuery);
-		
-				if (result.success) {
-					await sender.sendReply(message.i, result.message);
-				} else {
-					await sender.sendReplyError(message.i, result.message);
-				}
-		
-				debug(`[readLoop] Processed normal query ID '${message.i.toString("hex")}'`);
-				return false;
-			} else if (message.t === EVENT_TYPE) {
-				// This is the only type of message that we will pass through as-is
-				debug(`[readLoop] Passed through event message as-is`);
-				return true;
-			} else if (isReplyMessage) {
-				try {
-					if (SUCCESS_REPLIES.has(message.t)) {
-						replyTracker.registerReply(message.i).resolve(message.m);
-					} else if (ERROR_REPLIES.has(message.t)) {
-						let error = new Error(`Received error response from peer`);
-						error.code = "PEER_ERROR";
-						error.message = message.m;
-		
-						replyTracker.registerReply(message.i).reject(error);
-					}
-				} catch (error) {
-					if (error.code === "UNKNOWN_QUERY_ID") {
-						debug(`[readLoop] Received reply to unknown query ID '${message.i.toString("hex")}'`);
-					}
-				}
-			} else {
-				debug(`[readLoop] Received message with unknown type '${message.t}'`);
-				return false;
-			}
-		}),
-		map(async (message) => {
-			return message.m; // Unpack actual message content from event message
-		})
-	]);
-
-	return {
-		eventStream: eventStream,
-		sender: sender,
-		disconnect: () => disconnectSocket(socket)
-	};
-};

package/promisified/disconnect-socket.js

@@ -1,11 +0,0 @@
-"use strict";
-
-const debug = require("debug")("pairnet");
-const pEvent = require("p-event");
-
-module.exports = async function disconnect(socket) {
-	debug(`[disconnectSocket] Disconnecting...`);
-	socket.destroySoon();
-	await pEvent(socket, "close");
-	debug(`[disconnectSocket] Disconnected!`);
-};

package/streams/infinite-queue.js

@@ -1,37 +0,0 @@
-"use strict";
-
-const simpleSource = require("@promistream/simple-source");
-const Aborted = require("@promistream/aborted");
-const pDefer = require("p-defer");
-
-module.exports = function createInfiniteQueue(initialItems = []) {
-	let queue = initialItems.slice();
-	let defers = [];
-
-	return {
-		push: function (value) {
-			if (defers.length > 0) {
-				defers.shift().resolve(value);
-			} else {
-				queue.push(value);
-			}
-		},
-		stream: simpleSource({
-			onRequest: () => {
-				if (queue.length > 0) {
-					return queue.shift();
-				} else {
-					let defer = pDefer();
-					defers.push(defer);
-					return defer.promise;
-				}
-			},
-			onAbort: (reason) => {
-				for (let defer of defers) {
-					// TODO: Test properly
-					defer.reject(new Aborted("Stream was aborted"));
-				}
-			}
-		})
-	};
-};