🥇Storacle — ett decentraliserat fil-lagringssystem

Innan jag börjar, behöver jag lämna en länk till den tidigare artikeln, så att det är klart vad det handlar om.

I den här artikeln skulle jag vilja gå igenom lagret som ansvarar för fillagring och hur detta kan användas av vem som helst. Storacle — ett fristående bibliotek, utan någon direkt koppling till musik. Man kan organisera lagring av alla typer av filer.

I den tidigare artikeln gnällde jag lite över ipfs, men det skedde faktiskt i kontexten av den uppgift jag sysslade med. Generellt anser jag att detta projekt är fantastiskt. Jag gillar bara mer möjligheten att skapa olika nätverk för olika uppgifter. Det gör det möjligt att bättre organisera strukturen och minska belastningen på enskilda noder och nätverket som helhet. Man kan till och med inom ett specifikt projekt, vid behov, dela upp nätverket i segment baserat på vissa kriterier för att minska den totala belastningen.

Så, storacle använder mekanismen spreadable för att organisera nätverket. Huvudfunktionerna är:

Filer kan läggas till lagret via vilken nod som helst.
Filer sparas i sin helhet, inte i block.
Varje fil har sin egen unika hash baserat på innehållet för framtida arbete med den.
Filer kan dupliceras för högre tillförlitlighet
Antalet filer på en nod begränsas endast av filsystemet (det finns ett undantag, som nämns längre ner)
Antalet filer i nätverket begränsas av spridbarhet utifrån antalet tillåtna noder i nätverket, som i den andra versionen kommer att göra det möjligt att arbeta med ett oändligt antal noder (om detta i en annan artikel)

Ett enkelt exempel på hur detta fungerar från programmet:

Servern:

const Node = require('storacle').Node;

(async () => {
  try {
    const node = new Node({
      port: 4000,
      hostname: 'localhost'
    });
    await node.init();
  }
  catch(err) {
    console.error(err.stack);
    process.exit(1);
  }
})();

Klient:

const Client = require('storacle').Client;

(async () => {
  try {
    const client = new Client({
      address: 'localhost:4000'
    });
    await client.init();
    const hash = await client.storeFile('./my-file');
    const link = await client.getFileLink(hash);
    await client.removeFile(hash);
  }
  catch(err) {
    console.error(err.stack);
    process.exit(1);
  }
})();

En inblick inifrån

Under the hood, there’s nothing extraordinary. Information about the number of files, their total size, and other details are stored in an in-memory database and updated upon file addition and deletion, meaning frequent access to the file system is unnecessary. The only exception is during the activation of the garbage collector, which requires file circulation when certain storage size limits are reached, rather than a prohibition on adding new files. In this case, it is necessary to traverse the storage, and handling a large number of files (> a million, let's say) can lead to significant load. It's better to keep fewer files and run more nodes. If the 'cleaner' is disabled, this issue does not arise.

The file storage consists of 256 folders with 2 levels of nesting. Files are stored in the second-level folders. Therefore, with 1 million files, there will be about 62500 files in each folder (1000000 / sqrt(256)).

The names of the folders are generated from the file hash to enable quick access when the hash is known.

This structure was chosen based on a wide range of requirements for the storage: support for weak file systems where it’s undesirable to have many files in one folder, quick traversal of all folders when necessary, etc. It's a sort of golden mean.

Caching

When files are added or retrieved, links to the files are cached.
Thanks to this, there is often no need to traverse the entire network in search of a file. This speeds up link retrieval and reduces network load. Caching also occurs through HTTP headers.

Isomorphism

The client is written in JavaScript and isomorphic, meaning it can be used directly from the browser.
You can upload a file https://github.com/ortexx/storacle/blob/master/dist/storacle.client.js as a script and gain access to window.ClientStoracle or import through a build system, etc.

Deferred links

An interesting feature is also the 'deferred link'. This is a link to a file that can be obtained synchronously, here and now, while the file will be pulled in once it is found in storage. This is very convenient when, for instance, you need to display some images on your website. You just set the deferred link in the src and that’s it. There are many scenarios that can be imagined.

Client API

async Client.prototype.storeFile() — storing a file
async Client.prototype.getFileLink() — obtaining a direct link to a file
async Client.prototype.getFileLinks() — få en lista över direkta länkar till filen från alla noder där den finns
async Client.prototype.getFileToBuffer() — hämta filen till en buffert
async Client.prototype.getFileToPath() — hämta filen till filsystemet
async Client.prototype.getFileToBlob() — hämta filen som blob (för webbläsarversionen)
async Client.prototype.removeFile() — ta bort filen
Client.prototype.createRequestedFileLink() — skapa en uppskjuten länk

Exportera filer till en annan server

För att överföra filer till en annan nod kan du:

Enkelt kopiera hela lagringsmappen med inställningarna (detta kanske inte fungerar i framtiden)
Kopiera endast mappen med filer. Men i så fall måste du en gång köra funktionen node.normalizeFilesInfo(), för att räkna om alla data och lagra dem i databasen.
Använda funktionen node.exportFiles(), som påbörjar kopieringen av filer.

Huvudinställningar för noden
När man startar lagringsnoden kan man ange alla nödvändiga inställningar.
Jag kommer att beskriva de mest grundläggande, resten kan hittas på GitHub.

storage.dataSize — storleken på mappen med filer
storage.tempSize — storleken på temporärmappen
storage.autoCleanSize — minimala lagringsstorlek som måste upprätthållas. Om denna parameter anges, kommer de minst använda filerna att tas bort så snart utrymmet börjar ta slut.
file.maxSize — maximal filstorlek
file.minSize — minimal filstorlek
file.preferredDuplicates — önskat antal dubbletter av filen i nätverket
file.mimeWhitelist — tillåtna filtyper
file.mimeBlacklist — otillåtna filtyper
file.extWhitelist — tillåtna filändelser
file.extBlacklist — otillåtna filändelser
file.linkCache — olika inställningar för länkcache

Nästan alla parametrar relaterade till storlekar kan anges både i absoluta och relativa enheter.

Arbeta via kommandoraden
Biblioteket kan användas via kommandoraden. För detta måste du installera det globalt: npm i -g storacle. Efter detta kan du köra de nödvändiga åtgärderna från katalogen med projektet där noden finns. Till exempel, storacle -a storeFile -f ./file.txt -c ./config.js, för att lägga till en fil. Alla åtgärder kan hittas i https://github.com/ortexx/storacle/blob/master/bin/actions.js

Varför du kan behöva detta

Om du vill skapa ett decentraliserat projekt där du planerar att lagra och arbeta med filer på bekväma sätt. Till exempel, projektet med musik som beskrivs i länken i början av artikeln, använder storacle.
Om du arbetar med andra projekt där du behöver lagra filer distribuerat. Då kan du enkelt bygga ditt privata nätverk, flexibelt konfigurera noder och lägga till nya när det behövs.
Om du bara behöver lagra filer för din webbplats och inte vill skriva allting själv. Kanske passar detta bibliotek bättre än andra i ditt fall.
Om du har ett projekt där du arbetar med filer, men vill göra alla manipulationer från webbläsaren. Du kan undvika att skriva serverkod.

Mina kontaktuppgifter:

Källa: habr.com

Storacle — ett decentraliserat filsystem