Storacle - დეცენტრალიზებული ფაილების შენახვა

სანამ დავიწყებ, უნდა წავიდე წინა სტატიის ბმულირათა გასაგები იყოს კონკრეტულად რაზეა საუბარი.

ამ სტატიაში მსურს შევხედო ფენას, რომელიც პასუხისმგებელია ფაილების შესანახად და როგორ შეიძლება მისი გამოყენება ვინმეს. Storacle არის დამოუკიდებელი ბიბლიოთეკა, მუსიკასთან პირდაპირი კავშირი არ არის. თქვენ შეგიძლიათ მოაწყოთ ნებისმიერი ფაილის შენახვა.

წინა სტატიაში ცოტათი "დავაგორე ლულა". ipfs, მაგრამ ეს მოხდა ზუსტად იმ პრობლემის კონტექსტში, რომელსაც მე ვაგვარებდი. ზოგადად, ვფიქრობ, რომ ეს პროექტი მაგარია. მე უბრალოდ მირჩევნია განსხვავებული ქსელების შექმნის შესაძლებლობა სხვადასხვა ამოცანებისთვის. ეს საშუალებას გაძლევთ უკეთ მოაწყოთ სტრუქტურა და შეამციროთ დატვირთვა ცალკეულ კვანძებზე და მთლიანად ქსელზე. ერთი პროექტის ფარგლებშიც კი, საჭიროების შემთხვევაში, შეგიძლიათ ქსელის ნაწილებად დაყოფა გარკვეული კრიტერიუმების მიხედვით, მთლიანი დატვირთვის შემცირებით.

ასე რომ, storacle იყენებს მექანიზმს გავრცელებული ქსელის ორგანიზებისთვის. ძირითადი მახასიათებლები:

• ფაილები შეიძლება დაემატოს საცავში ნებისმიერი კვანძის საშუალებით.
• ფაილები ინახება მთლიანად და არა ბლოკებში.
• თითოეულ ფაილს აქვს თავისი უნიკალური შინაარსის ჰეში მასთან შემდგომი მუშაობისთვის.
• უფრო მეტი საიმედოობისთვის შესაძლებელია ფაილების დუბლირება
• ფაილების რაოდენობა ერთ კვანძზე შემოიფარგლება მხოლოდ ფაილური სისტემით (არსებობს გამონაკლისი, ამის შესახებ ქვემოთ)
• ქსელში ფაილების რაოდენობა შემოიფარგლება გავრცელების შესაძლებლობებით ქსელში მოქმედი კვანძების რაოდენობის მიხედვით, რომლებიც მეორე ვერსიაში შეძლებენ უსასრულო რაოდენობის კვანძებთან მუშაობას (დაწვრილებით ამის შესახებ სხვა სტატიაში)

მარტივი მაგალითი იმისა, თუ როგორ მუშაობს ეს ზოგადად პროგრამიდან:

სერვერი:

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);
  }
})();

კლიენტი:

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);
  }
})();

შიგნით ხედი

კაპოტის ქვეშ არაფერია ლამაზი. ფაილების რაოდენობის, მათი საერთო ზომისა და სხვა პუნქტების შესახებ ინფორმაცია ინახება მეხსიერების მონაცემთა ბაზაში და განახლდება ფაილების წაშლისა და დამატებისას, ასე რომ არ არის საჭირო ფაილურ სისტემაში ხშირი წვდომა. გამონაკლისი არის ნაგვის შემგროვებლის ჩართვა, როდესაც საჭიროა ფაილების მიმოქცევა, როდესაც მიიღწევა შენახვის გარკვეული ზომა და არ აკრძალოთ ახლის დამატება. ამ შემთხვევაში, თქვენ უნდა გვერდის ავლით შენახვა და დიდი რაოდენობით ფაილებთან მუშაობა (> ვთქვათ მილიონი) შეიძლება გამოიწვიოს მნიშვნელოვანი დატვირთვა. და უმჯობესია შეინახოთ ნაკლები ფაილი და გაუშვათ მეტი კვანძი. თუ "დამლაგებელი" გამორთულია, მაშინ ასეთი პრობლემა არ არის.

ფაილის საცავი შედგება 256 საქაღალდისგან და ბუდეების 2 დონისგან. ფაილები ინახება მეორე დონის საქაღალდეებში. ანუ თუ არის 1 მლნ. თითოეულ ასეთ საქაღალდეში იქნება დაახლოებით 62500 ფაილი (1000000 / sqrt(256)).

საქაღალდის სახელები იქმნება ფაილის ჰეშისგან, რათა სწრაფად შეხვიდეთ მასზე, თუ იცით ჰეში.

ეს სტრუქტურა შეირჩა დიდი რაოდენობით სხვადასხვა შენახვის მოთხოვნების საფუძველზე: სუსტი ფაილური სისტემების მხარდაჭერა, სადაც არ არის სასურველი ერთ საქაღალდეში ბევრი ფაილის არსებობა, საჭიროების შემთხვევაში ყველა საქაღალდის სწრაფი გადაკვეთა და ა.შ. რაღაც ოქროს შუალედი.

ქეშირება

ფაილების დამატებისას, ასევე მათი მიღებისას, ფაილების ბმულები იწერება ქეშში.
ამის წყალობით, ძალიან ხშირად არ არის საჭირო ფაილის საძიებლად მთელი ქსელის გავლა. ეს აჩქარებს ბმულების მიღებას და ამცირებს ქსელის დატვირთვას. ქეშირება ასევე ხდება http სათაურების მეშვეობით.

იზომორფია

კლიენტი იწერება javascript-ში და არის იზომორფული, მისი გამოყენება შესაძლებელია პირდაპირ ბრაუზერიდან. 
შეგიძლიათ ატვირთოთ ფაილი https://github.com/ortexx/storacle/blob/master/dist/storacle.client.js როგორც სკრიპტი და წვდომა ფანჯარა.ClientStoracle ან იმპორტი build სისტემის მეშვეობით და ა.შ.

გადადებული ლინკები

საინტერესო თვისებაა ასევე "გადადებული მითითება". ეს არის ფაილის ბმული, რომლის მიღებაც შესაძლებელია სინქრონულად, აქ და ახლა, და ფაილი ამოიყვანება, როდესაც ის უკვე მოიძებნება საცავში. ეს ძალიან მოსახერხებელია, როდესაც, მაგალითად, თქვენ გჭირდებათ რამდენიმე სურათის ჩვენება საიტზე. ჩვენ უბრალოდ დავაყენეთ გადადებული ბმული src-ში და ეს არის ის. ბევრი შემთხვევის მოფიქრება შეგიძლიათ.

კლიენტის API

• ასინკი Client.prototype.storeFile() - ფაილის შენახვა
• ასინკი Client.prototype.getFileLink() - ფაილის პირდაპირი ბმულის მიღება
• ასინკი Client.prototype.getFileLinks() - ფაილის პირდაპირი ბმულების სიის მიღება ყველა კვანძიდან, სადაც ის არსებობს
• ასინკი Client.prototype.getFileToBuffer() - შეიტანეთ ფაილი ბუფერში
• ასინკი Client.prototype.getFileToPath() - მიიღეთ ფაილი ფაილურ სისტემაში
• ასინკი Client.prototype.getFileToBlob() - მიიღეთ ფაილი blob-ში (ბრაუზერის ვერსიისთვის)
• ასინკი Client.prototype.removeFile() - წაშალე ფაილი
• Client.prototype.createRequestedFileLink() - შექმენით გადადებული ბმული

ფაილების ექსპორტი სხვა სერვერზე

ფაილების სხვა კვანძში გადასატანად შეგიძლიათ:

• უბრალოდ დააკოპირეთ მთელი შენახვის საქაღალდე პარამეტრებთან ერთად. (ეს შეიძლება არ იმუშაოს მომავალში)
• დააკოპირეთ მხოლოდ საქაღალდე ფაილებით. მაგრამ, ამ შემთხვევაში, თქვენ მოგიწევთ ფუნქციის ერთხელ გაშვება node.normalizeFilesInfo()ყველა მონაცემის ხელახლა გამოთვლა და მონაცემთა ბაზაში შეყვანა.
• ფუნქციის გამოყენება node.exportFiles()რომელიც დაიწყებს ფაილების კოპირებას.

კვანძის ძირითადი პარამეტრები
შენახვის კვანძის გაშვებისას შეგიძლიათ მიუთითოთ ყველა საჭირო პარამეტრი.
მე აღვწერ ყველაზე ძირითადს, დანარჩენი შეგიძლიათ ნახოთ Github-ზე.

• storage.dataSize - საქაღალდის ზომა ფაილებით
• შენახვის.tempSize - დროებითი საქაღალდის ზომა
• შენახვის.autoCleanSize - მინიმალური შენახვის ზომა, რომელიც უნდა იყოს შენახული. თუ თქვენ მიუთითებთ ამ პარამეტრს, მაშინ როგორც კი სივრცე ამოიწურება, ყველაზე ნაკლებად გამოყენებული ფაილები წაიშლება.
• ფაილი.maxSize - ფაილის მაქსიმალური ზომა
• file.minSize - ფაილის მინიმალური ზომა
• file.preferredDuplicates — ქსელში ფაილის დუბლიკატების სასურველი რაოდენობა
• file.mimeWhitelist - მოქმედი ფაილის ტიპები
• file.mimeBlacklist - არასწორი ფაილის ტიპები
• file.extWhitelist - სწორი ფაილის გაფართოებები
• file.extBlacklist - არასწორი ფაილის გაფართოებები
• file.linkCache - ბმულების ქეშირების სხვადასხვა პარამეტრები

ზომებთან დაკავშირებული თითქმის ყველა პარამეტრი შეიძლება შევიდეს როგორც აბსოლუტურ, ისე ფარდობით მნიშვნელობებში.

მუშაობა ბრძანების ხაზის მეშვეობით
ბიბლიოთეკის გამოყენება შესაძლებელია ბრძანების ხაზის მეშვეობით. ამისათვის თქვენ უნდა დააინსტალიროთ იგი გლობალურად: npm i -g საცავი. ამის შემდეგ, თქვენ შეგიძლიათ დაიწყოთ საჭირო მოქმედებები პროექტის დირექტორიადან, სადაც არის კვანძი. Მაგალითად, storacle -a storeFile -f ./file.txt -c ./config.jsფაილის დასამატებლად. ყველა ქმედება შეგიძლიათ იხილოთ მასში https://github.com/ortexx/storacle/blob/master/bin/actions.js

რატომ შეიძლება დაგჭირდეთ ეს?

• თუ გსურთ შექმნათ რაიმე სახის დეცენტრალიზებული პროექტი, რომელშიც აპირებთ ფაილების შენახვას და მუშაობას მოსახერხებელი მეთოდების გამოყენებით. მაგალითად, სტატიის დასაწყისში ბმულზე აღწერილი მუსიკალური პროექტი იყენებს საცავი.
• თუ თქვენ მუშაობთ სხვა პროექტებზე, სადაც ფაილები უნდა შეინახოთ განაწილებული წესით. თქვენ შეგიძლიათ მარტივად ააწყოთ თქვენი დახურული ქსელი, მოქნილად დააკონფიგურიროთ კვანძები და საჭიროების შემთხვევაში დაამატოთ ახლები.
• თუ თქვენ უბრალოდ გჭირდებათ თქვენი ვებსაიტის ფაილების სადმე შენახვა და თქვენთვის ზედმეტია ყველაფრის დაწერა. შესაძლოა, ეს ბიბლიოთეკა თქვენს შემთხვევაში სხვებზე უკეთ შეეფერება.
• თუ თქვენ გაქვთ პროექტი, რომელშიც მუშაობთ ფაილებთან, მაგრამ გსურთ შეასრულოთ ყველა მანიპულაცია ბრაუზერიდან. შეგიძლიათ თავიდან აიცილოთ სერვერის კოდის დაწერა.

ჩემი კონტაქტები:

• @ortex
• [ელ.ფოსტით დაცულია]

წყარო: www.habr.com