Converting to new communication protocol part 1

packetDesign.md

@@ -16,10 +16,9 @@
   }
 ]
 
-#### PACKET HEADERS (MSGPack Object)(OPTIONAL ENCRYPTION)
+#### UDSP HEADERS (MSGPack Object)(OPTIONAL ENCRYPTION)
 
 - Nonce
-- Identity Certificate (OPTIONAL)(REQUIRED AT START)
 - Socket ID (CLIENT/SERVER)
   - May indicate which server to send to for load balancing
   - May indicate which domain to send to for virtual hosts
@@ -52,8 +51,8 @@
 | :------------: |
 |      UDP       |
 |  UDSP HEADERS  |
-|   UDSP BODY    |
-|  UDSP FOOTER  |
+|  UDSP MESSAGE  |
+|  UDSP FOOTER   |
 
 The UDSP Header, Body, & Footer are all part of one array structure encoded with msgpack.
 ##### IPv6 HEADERS

requestHeaders.md

@@ -0,0 +1,4 @@
+# UDSP Request Headers
+
+- dataSize (HTTP Content-Length)
+- serialization

scripts/certificates.js

@@ -26,10 +26,10 @@ const domainProfile = await createProfile({
 				// encryptConnectionId: 'sealedbox', Applies to both client and server connection ID
 				// encryptClientConnectionId: 'sealedbox',
 				// encryptServerConnectionId: 'sealedbox',
-				connectionIdKeypair: true,
+				// connectionIdKeypair: true,
 				// Encrypt public key sent in the packet
-				encryptClientKey: 'sealedbox',
-				encryptServerKey: 'sealedbox',
+				// encryptClientKey: 'sealedbox',
+				// encryptServerKey: 'sealedbox',
 				encryptKeypair: true
 			},
 			// Max connection id size in bytes

udsp/ask.js

@@ -22,8 +22,8 @@ export class Ask extends Base {
 		} = source;
 		const {
 			data,
-			head,
-			method
+			head = {},
+			method = 'get'
 		} = requestObject;
 		console.log('Ask', requestObject);
 		const streamId = packetIdGenerator.get();
@@ -39,7 +39,7 @@ export class Ask extends Base {
 		if (method) {
 			this.request.method = method;
 		} else {
-			this.method = 'get';
+			this.request.method = 'get';
 		}
 		queue.set(streamId, this);
 	}

udsp/client/connect.js

@@ -1,12 +1,12 @@
 import { connected } from '#logs';
 import { decode } from 'msgpackr';
-export async function connect(message = {}) {
+import { randomBuffer } from '#utilities/crypto';
+export async function connect(message) {
 	console.log('-------CLIENT CONNECTING-------\n');
 	const thisClient = this;
 	// opn stands for open meaning connect to a server
-	message.intro = 'Hello Server!';
 	const connectRequest = thisClient.request({
-		message
+		message: randomBuffer()
 	}, 'connect');
 	console.log('Connect request', connectRequest);
 	const connectResponse = await connectRequest.send();

udsp/reply.js

@@ -46,7 +46,7 @@ export class Reply extends Base {
 	isReply = true;
 	async assemble() {
 		const thisReply = this;
-		const { contentType } = thisReply;
+		const { serialization } = thisReply;
 		if (thisReply.totalIncomingPackets === 1) {
 			thisReply.request = thisReply.incomingPackets[0];
 		}
@@ -56,7 +56,7 @@ export class Reply extends Base {
 				Buffer.concat([packet.data, item.data]);
 			}
 		});
-		if (contentType === 'struct' || !contentType) {
+		if (serialization === 'struct' || !serialization) {
 			msgReceived(thisReply.request);
 			if (thisReply.request.data) {
 				thisReply.request.data = decode(thisReply.request.data);

udsp/request/assembleData.js

@@ -1,17 +1,17 @@
 import { hasLength, jsonParse } from '@universalweb/acid';
 import { decode } from 'msgpackr';
 import { destroy } from './destory.js';
-export async function assembleData(data, contentType) {
+export async function assembleData(data, serialization) {
 	if (hasLength(data)) {
 		let compiledData = Buffer.concat(data);
-		if (contentType) {
-			if (contentType === 'obj' || contentType === 1) {
+		if (serialization) {
+			if (serialization === 'obj' || serialization === 1) {
 				try {
 					compiledData = decode(data);
 				} catch (err) {
 					return this.destroy('Failed to decode incoming data as message pack');
 				}
-			} else if (contentType === 'json' || contentType === 2) {
+			} else if (serialization === 'json' || serialization === 2) {
 				try {
 					compiledData = jsonParse(data);
 				} catch (err) {

udsp/request/base.js

@@ -1,18 +1,20 @@
 import { sendPacket } from './sendPacket.js';
 import { destroy } from './destory.js';
-import { bufferPacketization } from './bufferPacketization.js';
+import { dataPacketization } from './dataPacketization.js';
 import { sendEnd } from './sendEnd.js';
 import { on } from './on.js';
 import { flushOutgoing, flushIncoming, flush } from './flush.js';
 import { sendPacketsById } from './sendPacketsById.js';
 import { sendAll } from './sendAll.js';
 import { onPacket } from './onPacket.js';
 import {
-	isBuffer, isPlainObject, isString, promise, assign
+	isBuffer, isPlainObject, isString, promise, assign,
+	objectSize
 } from '@universalweb/acid';
 import { encode } from 'msgpackr';
 import { request } from '#udsp/request';
 import { assembleData } from './assembleData.js';
+const singlePacketMethods = /^(connect|open)$/i;
 export class Base {
 	constructor(options = {}, source) {
 		const { events, } = options;
@@ -53,42 +55,74 @@ export class Base {
 			return data;
 		}
 		if (isPlainObject(data)) {
-			this.contentType = 1;
+			this.serialization = 1;
 			return encode(data);
 		}
 		return Buffer.from(data);
 	}
 	async assemble() {
-		const { contentType } = this;
+		const { serialization } = this;
 		if (this.data) {
-			this.data = await assembleData(this.data, this.response, contentType);
+			this.data = await assembleData(this.data, this.response, serialization);
 			console.log('Assembled', this.data);
 		}
 		this.destroy();
 		await this.accept(this);
 	}
-	async send() {
-		const thisSource = this;
+	buildSetupPacket() {
+		const {
+			packetTemplate,
+			maxPacketSize,
+			sid,
+			isAsk,
+			isReply
+		} = this;
+		const message = (isAsk) ? this.request : this.response;
+		const method = message.method;
+		const packet = assign({
+			method
+		}, packetTemplate);
+		if (objectSize(message.head)) {
+			packet.headerSize = message.head.length;
+		}
+		this.outgoingPackets[0] = packet;
+	}
+	async packetization() {
 		const {
 			packetTemplate,
-			contentType,
 			maxPacketSize,
 			sid,
 			isAsk,
 			isReply
 		} = this;
 		const message = (isAsk) ? this.request : this.response;
-		console.log(`${this.type}.send`, message);
 		if (message.data) {
 			if (!isBuffer(message.data)) {
+				this.writeHeader('serialization', 'struct');
 				message.data = this.dataToBuffer(message.data);
 			}
-			this.totalReplyDataSize = request.data?.length;
+			this.dataSize = request.data?.length;
 		}
-		if (this.contentType) {
-			message.head.contentType = this.contentType;
+		await dataPacketization(this);
+	}
+	async send() {
+		const thisSource = this;
+		const {
+			packetTemplate,
+			maxPacketSize,
+			sid,
+			isAsk,
+			isReply
+		} = this;
+		const message = (isAsk) ? this.request : this.response;
+		console.log(`${this.type}.send`, message);
+		if (singlePacketMethods.test(message.method)) {
+			message.end = true;
+			message.pid = 0;
+			this.outgoingPackets[0] = message;
+		} else {
+			this.packetization();
 		}
-		// await bufferPacketization(this);
 		const awaitingResult = promise((accept) => {
 			thisSource.accept = accept;
 		});
@@ -102,20 +136,13 @@ export class Base {
 	sendAll = sendAll;
 	onPacket = onPacket;
 	sendPacket = sendPacket;
-	bufferPacketization = bufferPacketization;
 	on = on;
 	currentPayloadSize = 0;
 	totalReceivedUniquePackets = 0;
 	totalIncomingUniquePackets = 0;
 	progress = 0;
-	request = {
-		head: {},
-		body: {}
-	};
-	response = {
-		head: {},
-		body: {}
-	};
+	request = {};
+	response = {};
 	// this is the data in order may have missing packets at times but will remain in order
 	data = [];
 	// This is as the data came in over the wire out of order

udsp/request/buildMessage.js

@@ -1,11 +1,11 @@
 export function buildMessage({
 	method,
-	contentType,
+	serialization,
 	dataSize,
 	packet
 }) {
-	if (contentType) {
-		packet.head.contentType = contentType;
+	if (serialization) {
+		packet.head.serialization = serialization;
 	}
 	if (dataSize) {
 		packet.head.dataSize = dataSize;

udsp/request/bufferPacketization.js → udsp/request/dataPacketization.js

@@ -1,22 +1,20 @@
 import { assign } from '@universalweb/acid';
 import { buildMessage } from './buildMessage.js';
 import { request } from '#udsp/request';
-export async function bufferPacketization(source) {
+export async function dataPacketization(source) {
 	const {
 		maxPacketSize,
-		contentType,
-		method,
 		id: sid,
 		isAsk,
 		outgoingPackets
 	} = source;
-	const message = (isAsk) ? this.request : this.response;
+	const message = (isAsk) ? source.request : source.response;
 	const data = message.data;
 	const dataSize = data?.length;
 	let currentBytePosition = 0;
-	let packetId = 0;
+	let packetId = outgoingPackets.length;
 	if (dataSize > maxPacketSize) {
-		console.log('Body size', data.length);
+		console.log('data size', data.length);
 		while (currentBytePosition < dataSize) {
 			const endIndex = currentBytePosition + maxPacketSize;
 			const safeEndIndex = endIndex > dataSize ? dataSize : endIndex;
@@ -25,17 +23,8 @@ export async function bufferPacketization(source) {
 			const packet = {
 				pid: packetId,
 				endIndex: safeEndIndex,
-				sid,
-				head: {}
+				sid
 			};
-			if (packetId === 0) {
-				buildMessage({
-					method,
-					contentType,
-					dataSize,
-					packet
-				});
-			}
 			packet.data = chunk;
 			outgoingPackets[packetId] = outgoingPackets;
 			if (endIndex >= dataSize) {
@@ -51,12 +40,6 @@ export async function bufferPacketization(source) {
 			end: true,
 			data
 		};
-		buildMessage({
-			method,
-			contentType,
-			dataSize,
-			packet
-		});
 		console.log(source);
 		outgoingPackets[0] = packet;
 	}

udsp/request/onPacket.js

@@ -17,8 +17,8 @@ export async function onPacket(packet) {
 		pt: totalIncomingUniquePackets,
 		// Dat payload size
 		tps: totalIncomingPayloadSize,
-		// contentType
-		ct: contentType,
+		// serialization
+		ct: serialization,
 		// Complete
 		done,
 		// Finale Packet
@@ -37,8 +37,8 @@ export async function onPacket(packet) {
 	if (hasValue(totalIncomingPayloadSize)) {
 		this.totalIncomingPayloadSize = totalIncomingPayloadSize;
 	}
-	if (contentType) {
-		this.contentType = contentType;
+	if (serialization) {
+		this.serialization = serialization;
 	}
 	this.totalIncomingPackets++;
 	if (hasValue(packetId)) {

udsp/request/sendAll.js

@@ -1,7 +1,7 @@
 import { eachArray } from '@universalweb/acid';
 export async function sendAll() {
 	const thisReply = this;
-	console.log('outgoingPackets', thisReply.outgoingPackets);
+	console.log('outgoingPackets', thisReply.outgoingPackets[0]);
 	eachArray(thisReply.outgoingPackets, (packet) => {
 		thisReply.sendPacket({
 			message: packet