nodio-cli 1.0.6 → 1.0.8

package/package.json

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

package/src/node/runtime.js

@@ -146,8 +146,13 @@ class NodioNodeRuntime {
       await this.executeReplicationTask(task);
     }
 
+    const relayTasks = response.data.relayTasks || [];
+    for (const task of relayTasks) {
+      await this.executeRelayTask(task);
+    }
+
     console.log(
-      `[heartbeat] ${new Date().toISOString()} | shards=${shardIds.length} | tasks=${tasks.length}`
+      `[heartbeat] ${new Date().toISOString()} | shards=${shardIds.length} | tasks=${tasks.length} | relayTasks=${relayTasks.length}`
     );
   }
 
@@ -180,6 +185,56 @@ class NodioNodeRuntime {
       console.error(`[replication] failed task=${task.taskId} shard=${task.shardId}: ${message}`);
     }
   }
+
+  async executeRelayTask(task) {
+    try {
+      if (task.taskType === 'store') {
+        if (typeof task.dataBase64 !== 'string') {
+          throw new Error('relay store payload is missing dataBase64');
+        }
+
+        const payload = Buffer.from(task.dataBase64, 'base64');
+        await this.shardStore.saveShard(task.shardId, payload);
+
+        await axios.post(`${this.serverUrl}/api/relay-tasks/${task.taskId}/complete`, {
+          nodeId: this.nodeId,
+          success: true
+        });
+
+        console.log(`[relay] stored shard=${task.shardId} task=${task.taskId}`);
+        return;
+      }
+
+      if (task.taskType === 'fetch') {
+        if (!(await this.shardStore.hasShard(task.shardId))) {
+          throw new Error('shard not found on donor');
+        }
+
+        const payload = await this.shardStore.readShard(task.shardId);
+        await axios.post(`${this.serverUrl}/api/relay-tasks/${task.taskId}/complete`, {
+          nodeId: this.nodeId,
+          success: true,
+          resultDataBase64: payload.toString('base64')
+        });
+
+        console.log(`[relay] fetched shard=${task.shardId} task=${task.taskId}`);
+        return;
+      }
+
+      throw new Error(`unsupported relay task type: ${task.taskType}`);
+    } catch (error) {
+      const message = error.response?.data?.error || error.message;
+      await axios
+        .post(`${this.serverUrl}/api/relay-tasks/${task.taskId}/complete`, {
+          nodeId: this.nodeId,
+          success: false,
+          errorMessage: message
+        })
+        .catch(() => null);
+
+      console.error(`[relay] failed task=${task.taskId} shard=${task.shardId}: ${message}`);
+    }
+  }
 }
 
 module.exports = {

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 }
 );
@@ -77,10 +79,39 @@ replicationTaskSchema.index(
   }
 );
 
+const relayTaskSchema = new mongoose.Schema(
+  {
+    opId: { type: String, required: true, index: true },
+    taskType: {
+      type: String,
+      enum: ['store', 'fetch'],
+      required: true,
+      index: true
+    },
+    nodeId: { type: String, required: true, index: true },
+    shardId: { type: String, required: true, index: true },
+    fileId: { type: String, default: null, index: true },
+    dataBase64: { type: String, default: null },
+    resultDataBase64: { type: String, default: null },
+    status: {
+      type: String,
+      enum: ['pending', 'in_progress', 'completed', 'failed'],
+      default: 'pending',
+      index: true
+    },
+    errorMessage: { type: String, default: null },
+    attempts: { type: Number, default: 0 }
+  },
+  { timestamps: true }
+);
+
+relayTaskSchema.index({ opId: 1, nodeId: 1, taskType: 1 });
+
 module.exports = {
   NodeModel: mongoose.model('Node', nodeSchema),
   FileModel: mongoose.model('File', fileSchema),
   ShardModel: mongoose.model('Shard', shardSchema),
   ShardPlacementModel: mongoose.model('ShardPlacement', shardPlacementSchema),
-  ReplicationTaskModel: mongoose.model('ReplicationTask', replicationTaskSchema)
+  ReplicationTaskModel: mongoose.model('ReplicationTask', replicationTaskSchema),
+  RelayTaskModel: mongoose.model('RelayTask', relayTaskSchema)
 };

package/src/server/routes.js

@@ -6,7 +6,8 @@ const {
   FileModel,
   ShardModel,
   ShardPlacementModel,
-  ReplicationTaskModel
+  ReplicationTaskModel,
+  RelayTaskModel
 } = require('./models');
 const {
   chooseDistinctOnlineNodes,
@@ -236,16 +237,57 @@ function buildRoutes(config) {
         });
       }
 
+      const pendingRelayTasks = await RelayTaskModel.find({
+        nodeId,
+        status: 'pending'
+      })
+        .sort({ createdAt: 1 })
+        .limit(10)
+        .lean();
+
+      if (pendingRelayTasks.length > 0) {
+        await RelayTaskModel.updateMany(
+          { _id: { $in: pendingRelayTasks.map((task) => task._id) } },
+          { $set: { status: 'in_progress' }, $inc: { attempts: 1 } }
+        );
+      }
+
+      const relayTasks = pendingRelayTasks.map((task) => ({
+        taskId: task._id.toString(),
+        taskType: task.taskType,
+        shardId: task.shardId,
+        fileId: task.fileId,
+        dataBase64: task.dataBase64
+      }));
+
       res.json({
         ok: true,
         now: new Date().toISOString(),
-        replicationTasks: tasksWithSourceUrl
+        replicationTasks: tasksWithSourceUrl,
+        relayTasks
       });
     } catch (error) {
       next(error);
     }
   });
 
+  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;
@@ -293,6 +335,146 @@ function buildRoutes(config) {
     }
   });
 
+  router.post('/relay-tasks/:taskId/complete', async (req, res, next) => {
+    try {
+      const { taskId } = req.params;
+      const { nodeId, success, errorMessage, resultDataBase64 } = req.body;
+
+      const task = await RelayTaskModel.findById(taskId);
+      if (!task) {
+        return res.status(404).json({ error: 'relay task not found' });
+      }
+
+      if (task.nodeId !== nodeId) {
+        return res.status(403).json({ error: 'nodeId does not match relay task target' });
+      }
+
+      if (success) {
+        task.status = 'completed';
+        task.errorMessage = null;
+        task.resultDataBase64 = typeof resultDataBase64 === 'string' ? resultDataBase64 : null;
+      } else {
+        task.status = 'failed';
+        task.errorMessage = errorMessage || 'relay task failed';
+      }
+
+      await task.save();
+      res.json({ ok: true });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.post('/relay/shards/store', async (req, res, next) => {
+    try {
+      const { opId, shardId, fileId, nodeIds, dataBase64 } = req.body;
+      if (!shardId || !Array.isArray(nodeIds) || nodeIds.length === 0 || typeof dataBase64 !== 'string') {
+        return res.status(400).json({ error: 'shardId, nodeIds and dataBase64 are required' });
+      }
+
+      const normalizedNodeIds = [...new Set(nodeIds.filter((value) => typeof value === 'string' && value.length > 0))];
+      if (normalizedNodeIds.length === 0) {
+        return res.status(400).json({ error: 'nodeIds must contain at least one valid nodeId' });
+      }
+
+      const operationId = opId || uuidv4();
+      const docs = normalizedNodeIds.map((nodeId) => ({
+        opId: operationId,
+        taskType: 'store',
+        nodeId,
+        shardId,
+        fileId: fileId || null,
+        dataBase64,
+        status: 'pending'
+      }));
+
+      await RelayTaskModel.insertMany(docs);
+      res.json({ ok: true, opId: operationId, queued: docs.length });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.get('/relay/shards/store/:opId', async (req, res, next) => {
+    try {
+      const { opId } = req.params;
+      const tasks = await RelayTaskModel.find({ opId, taskType: 'store' }).lean();
+      if (tasks.length === 0) {
+        return res.status(404).json({ error: 'relay store operation not found' });
+      }
+
+      const successfulNodeIds = tasks.filter((task) => task.status === 'completed').map((task) => task.nodeId);
+      const failed = tasks
+        .filter((task) => task.status === 'failed')
+        .map((task) => ({ nodeId: task.nodeId, errorMessage: task.errorMessage || 'failed' }));
+
+      res.json({
+        ok: true,
+        opId,
+        pendingCount: tasks.filter((task) => task.status === 'pending' || task.status === 'in_progress').length,
+        successfulNodeIds,
+        failed
+      });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.post('/relay/shards/fetch', async (req, res, next) => {
+    try {
+      const { opId, shardId, nodeIds } = req.body;
+      if (!shardId || !Array.isArray(nodeIds) || nodeIds.length === 0) {
+        return res.status(400).json({ error: 'shardId and nodeIds are required' });
+      }
+
+      const normalizedNodeIds = [...new Set(nodeIds.filter((value) => typeof value === 'string' && value.length > 0))];
+      if (normalizedNodeIds.length === 0) {
+        return res.status(400).json({ error: 'nodeIds must contain at least one valid nodeId' });
+      }
+
+      const operationId = opId || uuidv4();
+      const docs = normalizedNodeIds.map((nodeId) => ({
+        opId: operationId,
+        taskType: 'fetch',
+        nodeId,
+        shardId,
+        status: 'pending'
+      }));
+
+      await RelayTaskModel.insertMany(docs);
+      res.json({ ok: true, opId: operationId, queued: docs.length });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.get('/relay/shards/fetch/:opId', async (req, res, next) => {
+    try {
+      const { opId } = req.params;
+      const tasks = await RelayTaskModel.find({ opId, taskType: 'fetch' }).lean();
+      if (tasks.length === 0) {
+        return res.status(404).json({ error: 'relay fetch operation not found' });
+      }
+
+      const completed = tasks.find((task) => task.status === 'completed' && task.resultDataBase64);
+      const failed = tasks
+        .filter((task) => task.status === 'failed')
+        .map((task) => ({ nodeId: task.nodeId, errorMessage: task.errorMessage || 'failed' }));
+
+      res.json({
+        ok: true,
+        opId,
+        pendingCount: tasks.filter((task) => task.status === 'pending' || task.status === 'in_progress').length,
+        hasResult: Boolean(completed),
+        nodeId: completed?.nodeId || null,
+        resultDataBase64: completed?.resultDataBase64 || null,
+        failed
+      });
+    } catch (error) {
+      next(error);
+    }
+  });
+
   router.post('/files/register', async (req, res, next) => {
     try {
       const { fileId, originalName, sizeBytes, shardCount, cipher, metadata } = req.body;
@@ -446,6 +628,12 @@ function buildRoutes(config) {
           { shardId: { $in: shardIds } }
         ]
       });
+      await RelayTaskModel.deleteMany({
+        $or: [
+          { fileId },
+          { shardId: { $in: shardIds } }
+        ]
+      });
       await ShardPlacementModel.deleteMany({ fileId });
       await ShardModel.deleteMany({ fileId });
       await FileModel.deleteOne({ fileId });

package/src/user/commands.js

@@ -27,6 +27,94 @@ function parseAesKey(keyBase64) {
   return key;
 }
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function relayStoreShard(api, { shardId, fileId, nodeIds, dataBuffer, timeoutMs = 90000, pollMs = 500 }) {
+  const opId = uuidv4();
+  await api.post('/relay/shards/store', {
+    opId,
+    shardId,
+    fileId,
+    nodeIds,
+    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}`);
+    const payload = response.data || {};
+    if (Number(payload.pendingCount || 0) === 0) {
+      return {
+        successfulNodeIds: payload.successfulNodeIds || [],
+        failed: payload.failed || []
+      };
+    }
+    // Polls every 500ms; with 10s heartbeat, donor should respond within 10s+network latency
+    // eslint-disable-next-line no-await-in-loop
+    await sleep(pollMs);
+  }
+
+  throw new Error(`relay store timed out for shard ${shardId}`);
+}
+
+async function relayFetchShard(api, { shardId, nodeIds, timeoutMs = 90000, pollMs = 500 }) {
+  const opId = uuidv4();
+  await api.post('/relay/shards/fetch', {
+    opId,
+    shardId,
+    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}`);
+    const payload = response.data || {};
+    if (payload.hasResult && payload.resultDataBase64) {
+      return {
+        nodeId: payload.nodeId,
+        data: Buffer.from(payload.resultDataBase64, 'base64'),
+        failed: payload.failed || []
+      };
+    }
+
+    if (Number(payload.pendingCount || 0) === 0) {
+      return {
+        nodeId: null,
+        data: null,
+        failed: payload.failed || []
+      };
+    }
+
+    // Wait for donor heartbeats to pull relay tasks.
+    // eslint-disable-next-line no-await-in-loop
+    await sleep(pollMs);
+  }
+
+  throw new Error(`relay fetch timed out for shard ${shardId}`);
+}
+
 async function uploadFile(options) {
   const filePath = path.resolve(options.file);
   const serverUrl = options.server;
@@ -101,12 +189,28 @@ async function uploadFile(options) {
       }
     }
 
+    if (failedReplicas.length > 0) {
+      try {
+        const relayResult = await relayStoreShard(api, {
+          shardId,
+          fileId,
+          nodeIds: failedReplicas.map((replica) => replica.nodeId),
+          dataBuffer: encrypted.cipherText
+        });
+
+        const promotedRelayReplicas = plannedReplicas.filter((replica) => relayResult.successfulNodeIds.includes(replica.nodeId));
+        successfulReplicas.push(...promotedRelayReplicas.filter((replica) => !successfulReplicas.some((item) => item.nodeId === replica.nodeId)));
+      } catch (relayError) {
+        console.warn(`[upload] relay store failed for shard ${shardId}: ${relayError.message}`);
+      }
+    }
+
     if (successfulReplicas.length === 0) {
       throw new Error(`failed to write shard ${shardId} to any replica: ${failedReplicas.map((r) => `${r.url} (${r.error})`).join(', ')}`);
     }
 
     if (failedReplicas.length > 0) {
-      console.warn(`[upload] shard ${shardId} failed on ${failedReplicas.length} replica(s), but succeeded on ${successfulReplicas.length}`);
+      console.warn(`[upload] shard ${shardId} failed on ${failedReplicas.length} direct replica(s), final successes=${successfulReplicas.length}`);
     }
 
     await api.post('/shards/register', {
@@ -197,6 +301,21 @@ async function downloadFile(options) {
       }
     }
 
+    if (!encryptedBuffer && Array.isArray(shard.replicas) && shard.replicas.length > 0) {
+      try {
+        const relayResult = await relayFetchShard(api, {
+          shardId: shard.shardId,
+          nodeIds: shard.replicas.map((replica) => replica.nodeId)
+        });
+
+        if (relayResult.data && sha256Hex(relayResult.data) === shard.checksum) {
+          encryptedBuffer = relayResult.data;
+        }
+      } catch (relayError) {
+        console.warn(`[download] relay fetch failed for shard ${shard.shardId}: ${relayError.message}`);
+      }
+    }
+
     if (!encryptedBuffer) {
       throw new Error(`failed to fetch valid replica for shard ${shard.shardId}`);
     }