nodio-cli 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodio-cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Nodio distributed storage network",
   "main": "src/server/index.js",
   "type": "commonjs",
@@ -30,4 +30,4 @@
     "mongoose": "^8.18.0",
     "uuid": "^13.0.0"
   }
-}
+}

package/src/node/runtime.js

@@ -65,6 +65,16 @@ class NodioNodeRuntime {
       }
     });
 
+    app.delete('/shards/:shardId', async (req, res) => {
+      try {
+        const { shardId } = req.params;
+        const result = await this.shardStore.deleteShard(shardId);
+        res.json({ ok: true, shard: result });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+
     app.get('/health', (_req, res) => {
       res.json({ ok: true, nodeId: this.nodeId });
     });

package/src/node/storage.js

@@ -64,6 +64,26 @@ class LocalShardStore {
     }
   }
 
+  async deleteShard(shardId) {
+    const filePath = this.shardPath(shardId);
+
+    try {
+      await fs.unlink(filePath);
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        throw error;
+      }
+    }
+
+    const index = await this.readIndex();
+    if (index.shards[shardId]) {
+      delete index.shards[shardId];
+      await this.writeIndex(index);
+    }
+
+    return { shardId, deleted: true };
+  }
+
   async listShardIds() {
     const index = await this.readIndex();
     return Object.keys(index.shards);

package/src/server/routes.js

@@ -1,4 +1,5 @@
 const express = require('express');
+const axios = require('axios');
 const { v4: uuidv4 } = require('uuid');
 const {
   NodeModel,
@@ -17,6 +18,10 @@ function parsePositiveInt(value, fallback) {
   return Number.isInteger(n) && n > 0 ? n : fallback;
 }
 
+function normalizeUrl(url) {
+  return String(url || '').replace(/\/+$/, '');
+}
+
 function buildRoutes(config) {
   const router = express.Router();
 
@@ -84,29 +89,34 @@ function buildRoutes(config) {
       await node.save();
 
       if (Array.isArray(shardIds) && shardIds.length > 0) {
-        const normalizedShardIds = [...new Set(shardIds.filter(Boolean))];
-        const knownShards = await ShardModel.find({ shardId: { $in: normalizedShardIds } })
-          .select('shardId fileId')
-          .lean();
+        try {
+          const normalizedShardIds = [...new Set(shardIds.filter(Boolean))];
+          const knownShards = await ShardModel.find({ shardId: { $in: normalizedShardIds } })
+            .select('shardId fileId')
+            .lean();
+
+          for (const shard of knownShards) {
+            if (!shard.fileId) {
+              continue;
+            }
 
-        for (const shard of knownShards) {
-          await ShardPlacementModel.updateOne(
-            { shardId: shard.shardId, nodeId },
-            {
-              $set: {
-                status: 'available',
-                fileId: shard.fileId,
-                updatedAt: new Date()
+            await ShardPlacementModel.updateOne(
+              { shardId: shard.shardId, nodeId },
+              {
+                $set: {
+                  status: 'available',
+                  fileId: shard.fileId
+                },
+                $setOnInsert: {
+                  shardId: shard.shardId,
+                  nodeId
+                }
               },
-              $setOnInsert: {
-                shardId: shard.shardId,
-                nodeId,
-                fileId: shard.fileId,
-                createdAt: new Date()
-              }
-            },
-            { upsert: true }
-          );
+              { upsert: true }
+            );
+          }
+        } catch (syncError) {
+          console.warn('[heartbeat-sync]', nodeId, syncError.message);
         }
       }
 
@@ -313,6 +323,66 @@ function buildRoutes(config) {
     }
   });
 
+  router.delete('/files/:fileId', async (req, res, next) => {
+    try {
+      const { fileId } = req.params;
+      const file = await FileModel.findOne({ fileId }).lean();
+      if (!file) {
+        return res.status(404).json({ error: 'file not found' });
+      }
+
+      const shards = await ShardModel.find({ fileId }).select('shardId').lean();
+      const shardIds = shards.map((shard) => shard.shardId);
+
+      const placements = await ShardPlacementModel.find({ fileId }).lean();
+      const nodeIds = [...new Set(placements.map((placement) => placement.nodeId))];
+
+      const onlineNodes = await NodeModel.find({ nodeId: { $in: nodeIds }, status: 'online' })
+        .select('nodeId url')
+        .lean();
+      const nodeUrlMap = new Map(onlineNodes.map((node) => [node.nodeId, node.url]));
+
+      const shardDeleteFailures = [];
+      for (const placement of placements) {
+        const nodeUrl = nodeUrlMap.get(placement.nodeId);
+        if (!nodeUrl) {
+          continue;
+        }
+
+        const deleteUrl = `${normalizeUrl(nodeUrl)}/shards/${placement.shardId}`;
+        try {
+          await axios.delete(deleteUrl, { timeout: 15000 });
+        } catch (error) {
+          shardDeleteFailures.push({
+            shardId: placement.shardId,
+            nodeId: placement.nodeId,
+            error: error.response?.data?.error || error.message
+          });
+        }
+      }
+
+      await ReplicationTaskModel.deleteMany({
+        $or: [
+          { fileId },
+          { shardId: { $in: shardIds } }
+        ]
+      });
+      await ShardPlacementModel.deleteMany({ fileId });
+      await ShardModel.deleteMany({ fileId });
+      await FileModel.deleteOne({ fileId });
+
+      res.json({
+        ok: true,
+        fileId,
+        deletedShards: shardIds.length,
+        deletedPlacements: placements.length,
+        shardDeleteFailures
+      });
+    } catch (error) {
+      next(error);
+    }
+  });
+
   router.get('/files/:fileId/manifest', async (req, res, next) => {
     try {
       const { fileId } = req.params;

package/src/user/commands.js

@@ -199,7 +199,23 @@ async function downloadFile(options) {
   console.log(`sizeBytes: ${reconstructed.length}`);
 }
 
+async function deleteFile(options) {
+  const fileId = options.fileId;
+  const serverUrl = options.server;
+
+  const api = createApiClient(serverUrl);
+  const response = await api.delete(`/files/${fileId}`);
+  const payload = response.data || {};
+
+  console.log('Delete complete');
+  console.log(`fileId: ${payload.fileId || fileId}`);
+  console.log(`deletedShards: ${payload.deletedShards || 0}`);
+  console.log(`deletedPlacements: ${payload.deletedPlacements || 0}`);
+  console.log(`shardDeleteFailures: ${(payload.shardDeleteFailures || []).length}`);
+}
+
 module.exports = {
   uploadFile,
-  downloadFile
+  downloadFile,
+  deleteFile
 };

package/src/user/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 const { Command } = require('commander');
-const { uploadFile, downloadFile } = require('./commands');
+const { uploadFile, downloadFile, deleteFile } = require('./commands');
 
 const program = new Command();
 
@@ -30,6 +30,15 @@ program
     await downloadFile(options);
   });
 
+program
+  .command('delete')
+  .description('Delete a file and its shard replicas from the network')
+  .requiredOption('--file-id <id>', 'file ID to delete')
+  .option('--server <url>', 'central server URL', 'http://127.0.0.1:4000')
+  .action(async (options) => {
+    await deleteFile(options);
+  });
+
 program.parseAsync(process.argv).catch((error) => {
   console.error('[nodio]', error.message);
   process.exit(1);