ultravisor-beacon 0.0.8 → 0.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ultravisor-beacon",
-	"version": "0.0.8",
+	"version": "0.0.9",
 	"description": "Ultravisor Beacon: lightweight beacon client and Fable service for remote task execution",
 	"main": "source/Ultravisor-Beacon-Service.cjs",
 	"scripts": {

package/source/Ultravisor-Beacon-CapabilityManager.cjs

@@ -33,8 +33,8 @@ class UltravisorBeaconCapabilityManager
 	{
 		this.log = pLog || {
 			info: (...pArgs) => { console.log(...pArgs); },
-			warn: (...pArgs) => { this.log.warn(...pArgs); },
-			error: (...pArgs) => { this.log.error(...pArgs); }
+			warn: (...pArgs) => { console.warn(...pArgs); },
+			error: (...pArgs) => { console.error(...pArgs); }
 		};
 
 		// Map of Capability name -> descriptor

package/source/Ultravisor-Beacon-Client.cjs

@@ -14,6 +14,10 @@
  */
 
 const libHTTP = require('http');
+const libOS = require('os');
+const libFS = require('fs');
+const libPath = require('path');
+const libCrypto = require('crypto');
 
 let libWebSocket;
 try
@@ -433,9 +437,71 @@ class UltravisorBeaconClient
 			tmpBody.BindAddresses = this._Config.BindAddresses;
 		}
 
+		// Host identity — used by the reachability matrix to detect beacons that
+		// live on the same physical machine. Caller can override; default is the
+		// node hostname (which inside a container is the container ID).
+		tmpBody.HostID = this._Config.HostID || libOS.hostname();
+
+		// Shared filesystem mounts — each entry tells the coordinator about a
+		// local filesystem tree this beacon advertises as accessible. When two
+		// beacons report the same MountID, the reachability matrix can pick the
+		// "shared-fs" strategy to skip an HTTP file transfer entirely.
+		//
+		// The MountID derivation includes stat.dev so two beacons that bind-mount
+		// the same host directory get the same ID, while two unrelated /media
+		// directories on different machines get different IDs.
+		tmpBody.SharedMounts = this._normalizeSharedMounts(this._Config.SharedMounts);
+
 		this._httpRequest('POST', '/Beacon/Register', tmpBody, fCallback);
 	}
 
+	_normalizeSharedMounts(pMounts)
+	{
+		if (!Array.isArray(pMounts) || pMounts.length === 0)
+		{
+			return [];
+		}
+		let tmpResult = [];
+		for (let i = 0; i < pMounts.length; i++)
+		{
+			let tmpEntry = pMounts[i];
+			if (!tmpEntry || !tmpEntry.Root)
+			{
+				continue;
+			}
+			let tmpRoot;
+			try
+			{
+				tmpRoot = libPath.resolve(tmpEntry.Root);
+			}
+			catch (pError)
+			{
+				continue;
+			}
+			let tmpMountID = tmpEntry.MountID;
+			if (!tmpMountID)
+			{
+				try
+				{
+					let tmpStat = libFS.statSync(tmpRoot);
+					tmpMountID = libCrypto.createHash('sha256')
+						.update(tmpStat.dev + ':' + tmpRoot)
+						.digest('hex').substring(0, 16);
+				}
+				catch (pError)
+				{
+					// Mount root does not exist on this beacon — skip it.
+					continue;
+				}
+			}
+			tmpResult.push({
+				MountID: tmpMountID,
+				Root: tmpRoot
+			});
+		}
+		return tmpResult;
+	}
+
 	_deregister(fCallback)
 	{
 		this._httpRequest('DELETE', `/Beacon/${this._BeaconID}`, null, fCallback);

package/source/Ultravisor-Beacon-Service.cjs

@@ -51,7 +51,9 @@ class UltravisorBeaconService extends libFableServiceBase
 			HeartbeatIntervalMs: 30000,
 			StagingPath: '',
 			Tags: {},
-			Contexts: {}
+			Contexts: {},
+			HostID: '',
+			SharedMounts: []
 		}, this.options || {});
 
 		// Internal components
@@ -259,6 +261,18 @@ class UltravisorBeaconService extends libFableServiceBase
 			Providers: []
 		});
 
+		// Shared-fs identity (forwarded to the thin client which sends it to the
+		// coordinator at registration time so the reachability matrix can detect
+		// beacons that share a filesystem on the same host).
+		if (this.options.HostID)
+		{
+			tmpClientConfig.HostID = this.options.HostID;
+		}
+		if (Array.isArray(this.options.SharedMounts) && this.options.SharedMounts.length > 0)
+		{
+			tmpClientConfig.SharedMounts = this.options.SharedMounts;
+		}
+
 		// Create thin client
 		this._ThinClient = new libBeaconClient(tmpClientConfig);
 

package/test/Ultravisor-Beacon-Service_tests.js

@@ -10,12 +10,17 @@
  */
 
 const libAssert = require('assert');
+const libFS = require('fs');
+const libPath = require('path');
+const libCrypto = require('crypto');
+const libOS = require('os');
 
 const libCapabilityProvider = require('../source/Ultravisor-Beacon-CapabilityProvider.cjs');
 const libCapabilityAdapter = require('../source/Ultravisor-Beacon-CapabilityAdapter.cjs');
 const libCapabilityManager = require('../source/Ultravisor-Beacon-CapabilityManager.cjs');
 const libConnectivityHTTP = require('../source/Ultravisor-Beacon-ConnectivityHTTP.cjs');
 const libProviderRegistry = require('../source/Ultravisor-Beacon-ProviderRegistry.cjs');
+const libBeaconClient = require('../source/Ultravisor-Beacon-Client.cjs');
 
 // We can require the service without Fable for standalone testing
 const libBeaconService = require('../source/Ultravisor-Beacon-Service.cjs');
@@ -604,5 +609,136 @@ suite
 				);
 			}
 		);
+
+		// ============================================================
+		// Shared-FS Reachability — SharedMounts normalization
+		// ============================================================
+		suite
+		(
+			'SharedMounts Normalization',
+			function ()
+			{
+				test
+				(
+					'Should return empty array for missing/empty input',
+					function ()
+					{
+						let tmpClient = new libBeaconClient({ Name: 'mt-test', Capabilities: [] });
+						libAssert.deepStrictEqual(tmpClient._normalizeSharedMounts(undefined), []);
+						libAssert.deepStrictEqual(tmpClient._normalizeSharedMounts(null), []);
+						libAssert.deepStrictEqual(tmpClient._normalizeSharedMounts([]), []);
+						libAssert.deepStrictEqual(tmpClient._normalizeSharedMounts('not-an-array'), []);
+					}
+				);
+
+				test
+				(
+					'Should auto-derive MountID from stat.dev + path',
+					function ()
+					{
+						let tmpClient = new libBeaconClient({ Name: 'mt-test', Capabilities: [] });
+						let tmpRoot = libOS.tmpdir();
+						let tmpResolved = libPath.resolve(tmpRoot);
+						let tmpExpected = libCrypto.createHash('sha256')
+							.update(libFS.statSync(tmpResolved).dev + ':' + tmpResolved)
+							.digest('hex').substring(0, 16);
+
+						let tmpResult = tmpClient._normalizeSharedMounts([{ Root: tmpRoot }]);
+						libAssert.strictEqual(tmpResult.length, 1);
+						libAssert.strictEqual(tmpResult[0].MountID, tmpExpected);
+						libAssert.strictEqual(tmpResult[0].Root, tmpResolved);
+					}
+				);
+
+				test
+				(
+					'Should preserve explicit MountID without stat',
+					function ()
+					{
+						let tmpClient = new libBeaconClient({ Name: 'mt-test', Capabilities: [] });
+						let tmpResult = tmpClient._normalizeSharedMounts(
+							[{ MountID: 'manual-id-1234', Root: libOS.tmpdir() }]);
+						libAssert.strictEqual(tmpResult.length, 1);
+						libAssert.strictEqual(tmpResult[0].MountID, 'manual-id-1234');
+					}
+				);
+
+				test
+				(
+					'Should skip entries without a Root',
+					function ()
+					{
+						let tmpClient = new libBeaconClient({ Name: 'mt-test', Capabilities: [] });
+						let tmpResult = tmpClient._normalizeSharedMounts(
+							[{ MountID: 'no-root' }, { Root: libOS.tmpdir() }, null, undefined]);
+						libAssert.strictEqual(tmpResult.length, 1);
+						libAssert.strictEqual(tmpResult[0].Root, libPath.resolve(libOS.tmpdir()));
+					}
+				);
+
+				test
+				(
+					'Should skip entries whose Root does not exist on this beacon',
+					function ()
+					{
+						let tmpClient = new libBeaconClient({ Name: 'mt-test', Capabilities: [] });
+						let tmpResult = tmpClient._normalizeSharedMounts(
+							[{ Root: '/nonexistent-path-12345-xyz' }]);
+						libAssert.deepStrictEqual(tmpResult, []);
+					}
+				);
+
+				test
+				(
+					'Two beacons that point at the same Root should derive identical MountIDs',
+					function ()
+					{
+						let tmpClientA = new libBeaconClient({ Name: 'mt-a', Capabilities: [] });
+						let tmpClientB = new libBeaconClient({ Name: 'mt-b', Capabilities: [] });
+						let tmpA = tmpClientA._normalizeSharedMounts([{ Root: libOS.tmpdir() }]);
+						let tmpB = tmpClientB._normalizeSharedMounts([{ Root: libOS.tmpdir() }]);
+						libAssert.strictEqual(tmpA[0].MountID, tmpB[0].MountID);
+					}
+				);
+			}
+		);
+
+		// ============================================================
+		// BeaconService — HostID and SharedMounts forwarding
+		// ============================================================
+		suite
+		(
+			'Service forwards HostID and SharedMounts',
+			function ()
+			{
+				test
+				(
+					'Service options should accept HostID and SharedMounts with sensible defaults',
+					function ()
+					{
+						let tmpService = new libBeaconService({ Name: 'fwd-test' });
+						// Defaults from Object.assign should land
+						libAssert.strictEqual(tmpService.options.HostID, '');
+						libAssert.deepStrictEqual(tmpService.options.SharedMounts, []);
+					}
+				);
+
+				test
+				(
+					'Service options should preserve caller-supplied HostID and SharedMounts',
+					function ()
+					{
+						let tmpService = new libBeaconService({
+							Name: 'fwd-test',
+							HostID: 'custom-host-id',
+							SharedMounts: [{ MountID: 'abc123', Root: '/data' }]
+						});
+						libAssert.strictEqual(tmpService.options.HostID, 'custom-host-id');
+						libAssert.deepStrictEqual(tmpService.options.SharedMounts,
+							[{ MountID: 'abc123', Root: '/data' }]);
+					}
+				);
+			}
+		);
 	}
 );