nodio-cli 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodio-cli",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Nodio distributed storage network",
   "main": "src/server/index.js",
   "type": "commonjs",

package/src/server/config.js

@@ -5,7 +5,7 @@ function getServerConfig() {
   return {
     port: Number(process.env.PORT || process.env.NODIO_SERVER_PORT || 4000),
     mongoUri: process.env.NODIO_MONGO_URI || 'mongodb://127.0.0.1:27017/nodio',
-    heartbeatIntervalMs: Number(process.env.NODIO_HEARTBEAT_INTERVAL_MS || 30000),
+    heartbeatIntervalMs: Number(process.env.NODIO_HEARTBEAT_INTERVAL_MS || 10000),
     offlineAfterMisses: Number(process.env.NODIO_OFFLINE_AFTER_MISSES || 3),
     minReplicas: Number(process.env.NODIO_MIN_REPLICAS || 5),
     emergencyReplicaFloor: Number(process.env.NODIO_EMERGENCY_REPLICA_FLOOR || 2)

package/src/server/models.js

@@ -9,7 +9,9 @@ const nodeSchema = new mongoose.Schema(
     capacityBytes: { type: Number, required: true, min: 1 },
     freeBytes: { type: Number, required: true, min: 0 },
     status: { type: String, enum: ['online', 'offline'], default: 'online', index: true },
-    lastHeartbeatAt: { type: Date, default: Date.now, index: true }
+    lastHeartbeatAt: { type: Date, default: Date.now, index: true },
+    pendingRelayAlert: { type: Boolean, default: false },
+    pendingRelayAlertAt: { type: Date, default: null }
   },
   { timestamps: true }
 );

package/src/server/routes.js

@@ -271,6 +271,23 @@ function buildRoutes(config) {
     }
   });
 
+  router.post('/nodes/:nodeId/alert-relay-pending', async (req, res, next) => {
+    try {
+      const { nodeId } = req.params;
+      const node = await NodeModel.findOne({ nodeId });
+      if (!node) {
+        return res.status(404).json({ error: 'node not found' });
+      }
+      // Set pending relay flag so donor knows to check urgently
+      node.pendingRelayAlert = true;
+      node.pendingRelayAlertAt = new Date();
+      await node.save();
+      res.json({ ok: true, message: 'relay pending alert sent' });
+    } catch (error) {
+      next(error);
+    }
+  });
+
   router.post('/replication-tasks/:taskId/complete', async (req, res, next) => {
     try {
       const { taskId } = req.params;

package/src/user/commands.js

@@ -31,7 +31,7 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-async function relayStoreShard(api, { shardId, fileId, nodeIds, dataBuffer, timeoutMs = 120000, pollMs = 1500 }) {
+async function relayStoreShard(api, { shardId, fileId, nodeIds, dataBuffer, timeoutMs = 90000, pollMs = 500 }) {
   const opId = uuidv4();
   await api.post('/relay/shards/store', {
     opId,
@@ -41,6 +41,16 @@ async function relayStoreShard(api, { shardId, fileId, nodeIds, dataBuffer, time
     dataBase64: dataBuffer.toString('base64')
   });
 
+  // Alert server that relay tasks are pending so donors check urgently
+  try {
+    for (const nodeId of nodeIds) {
+      // eslint-disable-next-line no-await-in-loop
+      await api.post(`/nodes/${nodeId}/alert-relay-pending`);
+    }
+  } catch (alertError) {
+    console.warn('relay alert failed:', alertError.message);
+  }
+
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     const response = await api.get(`/relay/shards/store/${opId}`);
@@ -51,7 +61,7 @@ async function relayStoreShard(api, { shardId, fileId, nodeIds, dataBuffer, time
         failed: payload.failed || []
       };
     }
-    // Wait for donor heartbeats to pull relay tasks.
+    // Polls every 500ms; with 10s heartbeat, donor should respond within 10s+network latency
     // eslint-disable-next-line no-await-in-loop
     await sleep(pollMs);
   }
@@ -59,7 +69,7 @@ async function relayStoreShard(api, { shardId, fileId, nodeIds, dataBuffer, time
   throw new Error(`relay store timed out for shard ${shardId}`);
 }
 
-async function relayFetchShard(api, { shardId, nodeIds, timeoutMs = 120000, pollMs = 1500 }) {
+async function relayFetchShard(api, { shardId, nodeIds, timeoutMs = 90000, pollMs = 500 }) {
   const opId = uuidv4();
   await api.post('/relay/shards/fetch', {
     opId,
@@ -67,6 +77,16 @@ async function relayFetchShard(api, { shardId, nodeIds, timeoutMs = 120000, poll
     nodeIds
   });
 
+  // Alert server that relay tasks are pending so donors check urgently
+  try {
+    for (const nodeId of nodeIds) {
+      // eslint-disable-next-line no-await-in-loop
+      await api.post(`/nodes/${nodeId}/alert-relay-pending`);
+    }
+  } catch (alertError) {
+    console.warn('relay alert failed:', alertError.message);
+  }
+
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     const response = await api.get(`/relay/shards/fetch/${opId}`);
@@ -100,6 +120,7 @@ async function uploadFile(options) {
   const serverUrl = options.server;
   const shardSizeMb = Number(options.shardSizeMb || 1);
   const replicas = Number(options.replicas || 5);
+  const directTimeoutMs = Number(options.directTimeoutMs || 4000);
 
   if (!Number.isFinite(shardSizeMb) || shardSizeMb <= 0) {
     throw new Error('shard-size-mb must be greater than 0');
@@ -107,6 +128,9 @@ async function uploadFile(options) {
   if (!Number.isInteger(replicas) || replicas < 5) {
     throw new Error('replicas must be an integer >= 5');
   }
+  if (!Number.isFinite(directTimeoutMs) || directTimeoutMs <= 0) {
+    throw new Error('direct-timeout-ms must be greater than 0');
+  }
 
   const shardSizeBytes = Math.floor(shardSizeMb * 1024 * 1024);
   const plainBuffer = await fs.readFile(filePath);
@@ -153,21 +177,29 @@ async function uploadFile(options) {
       throw new Error(`placement failed for ${shardId}: expected ${replicas} replicas`);
     }
 
-    const successfulReplicas = [];
-    const failedReplicas = [];
-
-    for (const replica of plannedReplicas) {
-      try {
+    const directWriteResults = await Promise.allSettled(
+      plannedReplicas.map(async (replica) => {
         const putUrl = `${normalizeUrl(replica.url)}/shards/${shardId}`;
         await axios.put(putUrl, encrypted.cipherText, {
           headers: { 'Content-Type': 'application/octet-stream' },
-          timeout: 30000
+          timeout: directTimeoutMs
         });
-        successfulReplicas.push(replica);
-      } catch (error) {
-        failedReplicas.push({ nodeId: replica.nodeId, url: replica.url, error: error.message });
-      }
-    }
+        return replica;
+      })
+    );
+
+    const successfulReplicas = directWriteResults
+      .filter((result) => result.status === 'fulfilled')
+      .map((result) => result.value);
+
+    const failedReplicas = directWriteResults
+      .map((result, index) => ({ result, replica: plannedReplicas[index] }))
+      .filter((entry) => entry.result.status === 'rejected')
+      .map((entry) => ({
+        nodeId: entry.replica.nodeId,
+        url: entry.replica.url,
+        error: entry.result.reason?.message || 'direct write failed'
+      }));
 
     if (failedReplicas.length > 0) {
       try {
@@ -240,6 +272,11 @@ async function downloadFile(options) {
   const serverUrl = options.server;
   const output = options.output ? path.resolve(options.output) : path.resolve(`./${fileId}.downloaded`);
   const keyBuffer = parseAesKey(options.keyBase64);
+  const directTimeoutMs = Number(options.directTimeoutMs || 4000);
+
+  if (!Number.isFinite(directTimeoutMs) || directTimeoutMs <= 0) {
+    throw new Error('direct-timeout-ms must be greater than 0');
+  }
 
   const api = createApiClient(serverUrl);
   const manifestResponse = await api.get(`/files/${fileId}/manifest`);
@@ -263,22 +300,24 @@ async function downloadFile(options) {
     }
 
     let encryptedBuffer = null;
-    for (const replica of shard.replicas || []) {
-      try {
+    const directFetchResults = await Promise.allSettled(
+      (shard.replicas || []).map(async (replica) => {
         const getUrl = `${normalizeUrl(replica.url)}/shards/${shard.shardId}`;
         const response = await axios.get(getUrl, {
           responseType: 'arraybuffer',
-          timeout: 30000
+          timeout: directTimeoutMs
         });
         const candidate = Buffer.from(response.data);
         if (sha256Hex(candidate) !== shard.checksum) {
-          continue;
+          throw new Error('checksum mismatch');
         }
-        encryptedBuffer = candidate;
-        break;
-      } catch {
-        continue;
-      }
+        return candidate;
+      })
+    );
+
+    const successfulDirectFetch = directFetchResults.find((result) => result.status === 'fulfilled');
+    if (successfulDirectFetch) {
+      encryptedBuffer = successfulDirectFetch.value;
     }
 
     if (!encryptedBuffer && Array.isArray(shard.replicas) && shard.replicas.length > 0) {

package/src/user/index.js

@@ -14,6 +14,7 @@ program
   .option('--file-id <id>', 'custom file ID (optional)')
   .option('--shard-size-mb <mb>', 'plaintext shard size in MB', '1')
   .option('--replicas <count>', 'replicas per shard (minimum 5)', '5')
+  .option('--direct-timeout-ms <ms>', 'timeout for each direct donor attempt before relay fallback', '4000')
   .option('--key-base64 <key>', '32-byte AES key in base64 (optional)')
   .action(async (options) => {
     await uploadFile(options);
@@ -26,6 +27,7 @@ program
   .requiredOption('--key-base64 <key>', '32-byte AES key in base64 from upload output')
   .option('--server <url>', 'central server URL', 'https://api.nodio.me')
   .option('--output <path>', 'output file path')
+  .option('--direct-timeout-ms <ms>', 'timeout for each direct donor attempt before relay fallback', '4000')
   .action(async (options) => {
     await downloadFile(options);
   });