@peerbit/shared-log 7.0.9 → 7.0.11

package/src/ranges.ts

@@ -1,25 +1,46 @@
 import yallist from "yallist";
 import { ReplicatorRect } from "./replication.js";
-import { Replicator, containsPoint } from "./role.js";
+import { Replicator } from "./role.js";
 import { PublicSignKey } from "@peerbit/crypto";
 
-export const collectNodesAroundPoint = (
+export const containsPoint = (
+	rect: { offset: number; factor: number },
+	point: number,
+	eps = 0.00001 // we do this to handle numerical errors
+) => {
+	if (rect.factor === 0) {
+		return false;
+	}
+	const start = rect.offset;
+	const width = rect.factor + eps; // we do this to handle numerical errors. It is better to be more inclusive
+	const endUnwrapped = rect.offset + width;
+	let end = endUnwrapped;
+	let wrapped = false;
+	if (endUnwrapped > 1) {
+		end = endUnwrapped % 1;
+		wrapped = true;
+	}
+
+	const inFirstInterval = point >= start && point < Math.min(endUnwrapped, 1);
+	const inSecondInterval =
+		!inFirstInterval && wrapped && point >= 0 && point < end;
+
+	return inFirstInterval || inSecondInterval;
+};
+
+const collectNodesAroundPoint = (
 	time: number,
 	roleAge: number,
 	peers: yallist<ReplicatorRect>,
 	currentNode: yallist.Node<ReplicatorRect> | null,
-	collector: Set<string>,
+	collector: (rect: ReplicatorRect, matured: boolean) => void,
 	point: number,
-	once: boolean = false
+	done: (postProcess: boolean) => boolean = () => true
 ) => {
-	let matured = 0;
-
-	const maybeIncrementMatured = (role: Replicator) => {
-		if (isMatured(role, time, roleAge)) {
-			matured++;
-			return true;
-		}
-		return false;
+	/* 	let uniqueMatured = 0;
+	 */ const maybeIncrementMatured = (rect: ReplicatorRect) => {
+		const isMature = isMatured(rect.role, time, roleAge);
+		collector(rect, isMature);
 	};
 
 	// Assume peers does not mutate during this loop
@@ -27,13 +48,11 @@ export const collectNodesAroundPoint = (
 	const diffs: { diff: number; rect: ReplicatorRect }[] = [];
 	while (currentNode) {
 		if (containsPoint(currentNode.value.role, point)) {
-			collector.add(currentNode.value.publicKey.hashcode());
-			if (maybeIncrementMatured(currentNode.value.role)) {
-				if (once) {
-					return;
-				}
+			maybeIncrementMatured(currentNode.value);
+			if (done(false)) {
+				return;
 			}
-		} else {
+		} /* if (matured === 0) */ else {
 			const start = currentNode.value.role.offset;
 			const end =
 				(currentNode.value.role.offset + currentNode.value.role.factor) % 1;
@@ -58,28 +77,88 @@ export const collectNodesAroundPoint = (
 		}
 	}
 
-	if (matured === 0) {
+	if (done(true) == false) {
 		diffs.sort((x, y) => x.diff - y.diff);
 		for (const node of diffs) {
-			collector.add(node.rect.publicKey.hashcode());
-			maybeIncrementMatured(node.rect.role);
-			if (matured > 0) {
+			maybeIncrementMatured(node.rect);
+			if (done(true)) {
 				break;
 			}
 		}
 	}
 };
 
-const isMatured = (role: Replicator, now: number, minAge: number) => {
+export const isMatured = (role: Replicator, now: number, minAge: number) => {
 	return now - Number(role.timestamp) >= minAge;
 };
 
+export const getSamples = (
+	cursor: number,
+	peers: yallist<ReplicatorRect>,
+	amount: number,
+	roleAge: number,
+	dbg?: string
+) => {
+	const leaders: Set<string> = new Set();
+	const width = 1;
+	if (!peers || peers?.length === 0) {
+		return [];
+	}
+	amount = Math.min(amount, peers.length);
+
+	const t = +new Date();
+
+	const matured = 0;
+
+	const maturedLeaders = new Set();
+	for (let i = 0; i < amount; i++) {
+		// evenly distributed
+		const point = ((cursor + i / amount) % 1) * width;
+		const currentNode = peers.head;
+
+		// aquire at least one unique node for each point
+		// but if previous point yielded more than one node
+		collectNodesAroundPoint(
+			t,
+			roleAge,
+			peers,
+			currentNode,
+			(rect, m) => {
+				if (m) {
+					maturedLeaders.add(rect.publicKey.hashcode());
+				}
+				leaders.add(rect.publicKey.hashcode());
+			},
+			point,
+			(postProcess) => {
+				if (postProcess) {
+					if (maturedLeaders.size > i) {
+						return true;
+					}
+				}
+				return false; // collect all intersecting points
+			}
+		);
+	}
+
+	return [...leaders];
+};
+
 export const getCover = (
 	coveringWidth: number,
 	peers: yallist<ReplicatorRect>,
 	roleAge: number,
 	startNodeIdentity?: PublicSignKey
-) => {
+): string[] => {
+	return [...getCoverSet(coveringWidth, peers, roleAge, startNodeIdentity)];
+};
+export const getCoverSet = (
+	coveringWidth: number,
+	peers: yallist<ReplicatorRect>,
+	roleAge: number,
+	startNodeIdentity?: PublicSignKey
+): Set<string> => {
+	// find a good starting point
 	let walker = peers.head;
 	if (startNodeIdentity) {
 		// start at our node (local first)
@@ -104,38 +183,38 @@ export const getCover = (
 
 	const startNode = walker;
 	if (!startNode) {
-		return [];
+		return new Set();
 	}
+
+	//
 	const set: Set<string> = new Set();
 	let currentNode = startNode;
+	const t = +new Date();
 
-	/**
-	 * The purpose of this loop is to cover at least coveringWidth
-	 * so that if we query all nodes in this range, we know we will
-	 * "query" all data in that range
-	 */
+	let wrappedOnce = false;
+	const startPoint = startNode.value.role.offset;
 
-	let wrapped = false;
-	const getNextPoint = (): [number, number, boolean] => {
+	const getNextPoint = (): [number, number, number, boolean] => {
 		let nextPoint =
 			currentNode.value.role.offset + currentNode.value.role.factor;
-		if (nextPoint > 1) {
-			wrapped = true;
-			nextPoint = nextPoint % 1;
+
+		if (nextPoint > 1 || nextPoint < startPoint) {
+			wrappedOnce = true;
 		}
-		let distance: number;
-		if (wrapped) {
-			distance = 1 - startNode.value.role.offset + nextPoint;
+
+		nextPoint = nextPoint % 1;
+		let distanceStart: number;
+
+		if (wrappedOnce) {
+			distanceStart = (1 - startPoint + currentNode.value.role.offset) % 1;
 		} else {
-			distance =
-				currentNode.value.role.offset -
-				startNode.value.role.offset +
-				currentNode.value.role.factor;
+			distanceStart = (currentNode.value.role.offset - startPoint) % 1;
 		}
-		return [nextPoint, distance, wrapped];
-	};
 
-	const t = +new Date();
+		const distanceEnd = distanceStart + currentNode.value.role.factor;
+
+		return [nextPoint, distanceStart, distanceEnd, wrappedOnce];
+	};
 
 	const getNextMatured = (from: yallist.Node<ReplicatorRect>) => {
 		let next = (from.next || peers.head)!;
@@ -151,14 +230,23 @@ export const getCover = (
 		return undefined;
 	};
 
+	/**
+	 * The purpose of this loop is to cover at least coveringWidth
+	 * so that if we query all nodes in this range, we know we will
+	 * "query" all data in that range
+	 */
+
+	let isPastThePoint = false;
 	outer: while (currentNode) {
 		if (set.has(currentNode.value.publicKey.hashcode())) break;
 
-		set.add(currentNode.value.publicKey.hashcode());
+		const [nextPoint, distanceStart, distanceEnd, wrapped] = getNextPoint();
 
-		const [nextPoint, distance, wrapped] = getNextPoint();
+		if (distanceStart <= coveringWidth) {
+			set.add(currentNode.value.publicKey.hashcode());
+		}
 
-		if (distance >= coveringWidth) {
+		if (distanceEnd >= coveringWidth) {
 			break;
 		}
 
@@ -168,56 +256,80 @@ export const getCover = (
 				break outer;
 			}
 
+			const prevOffset = (next.prev || peers.tail)!.value.role.offset;
+			const nextOffset = next.value.role.offset;
+			const nextHasWrapped = nextOffset < prevOffset;
+
 			if (
-				next.value.role.offset < nextPoint &&
-				(next.value.role.offset > currentNode.value.role.offset || wrapped)
+				(!wrapped && nextOffset > nextPoint) ||
+				(nextHasWrapped &&
+					(wrapped ? nextOffset > nextPoint : prevOffset < nextPoint)) ||
+				(!nextHasWrapped && prevOffset < nextPoint && nextPoint <= nextOffset)
 			) {
-				if (next.value.role.offset + next.value.role.factor > nextPoint) {
-					// Find out if there is a better choice ahead of us
-					const nextNext = getNextMatured(next);
-					if (
-						nextNext &&
-						!nextNext.value.publicKey.equals(currentNode.value.publicKey) &&
-						nextNext.value.role.offset < nextPoint &&
-						nextNext.value.role.offset + nextNext.value.role.factor > nextPoint
-					) {
-						// nextNext is better (continue to iterate)
-					} else {
-						// done
-						break;
-					}
+				isPastThePoint = true;
+			}
+
+			if (isPastThePoint) {
+				break; // include this next in the set;
+			}
+
+			const overlapsRange = containsPoint(next.value.role, nextPoint);
+
+			if (overlapsRange) {
+				// Find out if there is a better choice ahead of us
+				const nextNext = getNextMatured(next);
+				if (
+					nextNext &&
+					!nextNext.value.publicKey.equals(currentNode.value.publicKey) &&
+					nextNext.value.role.offset < nextPoint &&
+					nextNext.value.role.offset + nextNext.value.role.factor > nextPoint
+				) {
+					// nextNext is better (continue to iterate)
 				} else {
-					// (continue to iterate)
+					// done
+					break;
 				}
 			} else {
-				// we got the best choice
-				break;
+				// (continue to iterate)
 			}
-			next = next.next;
+
+			next = next.next || peers.head;
 		}
 		currentNode = next!;
 	}
 
-	// collect around the boundary of the start
-	collectNodesAroundPoint(
-		t,
-		roleAge,
-		peers,
-		isMatured(startNode.value.role, t, roleAge) ? startNode : peers.head, // start at startNode is matured, else start at head (we only seek to find one matured node at the point)
-		set,
+	// collect 1 point around the boundary of the start and one at the end,
+	// preferrd matured and that we already have it
+	for (const point of [
 		startNode.value.role.offset,
-		true
-	);
-
-	// collect around the boundary of the end
-	collectNodesAroundPoint(
-		t,
-		roleAge,
-		peers,
-		startNode, // start somewhere close to the border
-		set,
-		(startNode.value.role.offset + coveringWidth) % 1,
-		true
-	);
-	return [...set];
+		(startNode.value.role.offset + coveringWidth) % 1
+	]) {
+		let done = false;
+		const unmatured: string[] = [];
+		collectNodesAroundPoint(
+			t,
+			roleAge,
+			peers,
+			isMatured(startNode.value.role, t, roleAge) ? startNode : peers.head, // start at startNode is matured, else start at head (we only seek to find one matured node at the point)
+			(rect, matured) => {
+				if (matured) {
+					if (set.has(rect.publicKey.hashcode())) {
+						// great!
+					} else {
+						set.add(rect.publicKey.hashcode());
+					}
+					done = true;
+				} else {
+					unmatured.push(rect.publicKey.hashcode());
+				}
+			},
+			point,
+			() => done
+		);
+		if (!done && unmatured.length > 0) {
+			set.add(unmatured[0]);
+			// TODO add more elements?
+		}
+	}
+	return set;
 };

package/src/role.ts

@@ -1,34 +1,12 @@
 import { field, variant, vec } from "@dao-xyz/borsh";
 
-export const containsPoint = (
-	rect: { offset: number; factor: number },
-	point: number
-) => {
-	if (rect.factor === 0) {
-		return false;
-	}
-	const start = rect.offset;
-	const endUnwrapped = rect.offset + rect.factor;
-	let end = endUnwrapped;
-	let wrapped = false;
-	if (endUnwrapped > 1) {
-		end = endUnwrapped % 1;
-		wrapped = true;
-	}
-
-	const inFirstInterval = point >= start && point < Math.min(endUnwrapped, 1);
-	const inSecondInterval =
-		!inFirstInterval && wrapped && point >= 0 && point < end;
-
-	return inFirstInterval || inSecondInterval;
-};
-
-const overlaps = (x1: number, x2: number, y1: number, y2: number) => {
+export const overlaps = (x1: number, x2: number, y1: number, y2: number) => {
 	if (x1 <= y2 && y1 <= x2) {
 		return true;
 	}
 	return false;
 };
+
 export abstract class Role {
 	abstract equals(other: Role);
 }