സ്റ്റോർക്കിൾ - വികേന്ദ്രീകൃത ഫയൽ സംഭരണം

ഞാൻ ആരംഭിക്കുന്നതിന് മുമ്പ്, എനിക്ക് പോകണം മുൻ ലേഖനത്തിലേക്കുള്ള ലിങ്ക്അതിനാൽ നമ്മൾ കൃത്യമായി എന്താണ് സംസാരിക്കുന്നതെന്ന് വ്യക്തമാകും.

ഈ ലേഖനത്തിൽ, ഫയലുകൾ സംഭരിക്കുന്നതിന് ഉത്തരവാദിത്തമുള്ള ലെയർ നോക്കാനും അത് ആർക്കും എങ്ങനെ ഉപയോഗിക്കാമെന്നും നോക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. സ്‌റ്റോറാക്കിൾ ഒരു ഒറ്റപ്പെട്ട ലൈബ്രറിയാണ്, സംഗീതവുമായി നേരിട്ട് ബന്ധമില്ല. നിങ്ങൾക്ക് ഏത് ഫയലുകളുടെയും സംഭരണം ക്രമീകരിക്കാം.

മുമ്പത്തെ ലേഖനത്തിൽ, ഞാൻ "ബാരൽ ഉരുട്ടി" അല്പം ipfs, എന്നാൽ ഇത് ഞാൻ പരിഹരിക്കുന്ന പ്രശ്നത്തിന്റെ പശ്ചാത്തലത്തിൽ കൃത്യമായി സംഭവിച്ചു. മൊത്തത്തിൽ, ഈ പ്രോജക്റ്റ് രസകരമാണെന്ന് ഞാൻ കരുതുന്നു. വ്യത്യസ്ത ജോലികൾക്കായി വ്യത്യസ്ത നെറ്റ്‌വർക്കുകൾ സൃഷ്ടിക്കാനുള്ള കഴിവാണ് ഞാൻ ഇഷ്ടപ്പെടുന്നത്. ഘടനയെ മികച്ച രീതിയിൽ ഓർഗനൈസുചെയ്യാനും വ്യക്തിഗത നോഡുകളിലും നെറ്റ്‌വർക്കിലും മൊത്തത്തിൽ ലോഡ് കുറയ്ക്കാനും ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. ഒരു പ്രോജക്റ്റിന്റെ ചട്ടക്കൂടിനുള്ളിൽ പോലും, ആവശ്യമെങ്കിൽ, ചില മാനദണ്ഡങ്ങൾക്കനുസൃതമായി നിങ്ങൾക്ക് നെറ്റ്വർക്കിനെ കഷണങ്ങളായി വിഭജിക്കാം, മൊത്തത്തിലുള്ള ലോഡ് കുറയ്ക്കുക.

അതിനാൽ സ്റ്റോർക്കിൾ മെക്കാനിസം ഉപയോഗിക്കുന്നു വ്യാപിപ്പിക്കാവുന്ന ഒരു നെറ്റ്‌വർക്ക് സംഘടിപ്പിക്കുന്നതിന്. പ്രധാന സവിശേഷതകൾ:

• ഏത് നോഡിലൂടെയും ഫയലുകൾ റിപ്പോസിറ്ററിയിലേക്ക് ചേർക്കാം.
• ഫയലുകൾ പൂർണ്ണമായി സംരക്ഷിക്കപ്പെടുന്നു, ബ്ലോക്കുകളിലല്ല.
• ഓരോ ഫയലിനും അതിന്റേതായ തനതായ ഉള്ളടക്ക ഹാഷ് ഉണ്ട്, അതുമായി കൂടുതൽ പ്രവർത്തിക്കാൻ.
• കൂടുതൽ വിശ്വാസ്യതയ്ക്കായി ഫയലുകൾ ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യാം
• ഒരു നോഡിലെ ഫയലുകളുടെ എണ്ണം ഫയൽ സിസ്റ്റം മാത്രം പരിമിതപ്പെടുത്തിയിരിക്കുന്നു (ഒരു അപവാദം ഉണ്ട്, അതിൽ കൂടുതൽ താഴെ)
• നെറ്റ്‌വർക്കിലെ സാധുവായ നോഡുകളുടെ എണ്ണം അനുസരിച്ച് നെറ്റ്‌വർക്കിലെ ഫയലുകളുടെ എണ്ണം പരിമിതപ്പെടുത്തിയിരിക്കുന്നു, രണ്ടാമത്തെ പതിപ്പിൽ അനന്തമായ നോഡുകളിൽ പ്രവർത്തിക്കാൻ കഴിയും (ഇതിനെക്കുറിച്ച് കൂടുതൽ മറ്റൊരു ലേഖനത്തിൽ)

പ്രോഗ്രാമിൽ നിന്ന് ഇത് സാധാരണയായി എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ ഒരു ലളിതമായ ഉദാഹരണം:

സെർവർ:

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 തലക്കെട്ടുകൾ വഴിയും കാഷിംഗ് സംഭവിക്കുന്നു.

ഐസോമോർഫി

ക്ലയന്റ് ജാവാസ്ക്രിപ്റ്റിൽ എഴുതിയതാണ്, ഐസോമോഫിക് ആണ്, ഇത് ബ്രൗസറിൽ നിന്ന് നേരിട്ട് ഉപയോഗിക്കാം. 
നിങ്ങൾക്ക് ഫയൽ അപ്‌ലോഡ് ചെയ്യാം https://github.com/ortexx/storacle/blob/master/dist/storacle.client.js ഒരു സ്ക്രിപ്റ്റും ആക്സസ് എന്ന നിലയിലും window.ClientStoracle അല്ലെങ്കിൽ ബിൽഡ് സിസ്റ്റം വഴി ഇറക്കുമതി ചെയ്യുക.

മാറ്റിവെച്ച ലിങ്കുകൾ

രസകരമായ ഒരു സവിശേഷതയും "മാറ്റിവച്ച റഫറൻസ്" ആണ്. ഇവിടെയും ഇപ്പോളും സിൻക്രണസ് ആയി ലഭിക്കാവുന്ന ഒരു ഫയലിലേക്കുള്ള ലിങ്കാണിത്, സ്റ്റോറേജിൽ അത് കണ്ടെത്തുമ്പോൾ ഫയൽ മുകളിലേക്ക് വലിക്കും. ഉദാഹരണത്തിന്, നിങ്ങൾ സൈറ്റിൽ ചില ചിത്രങ്ങൾ കാണിക്കേണ്ടിവരുമ്പോൾ ഇത് വളരെ സൗകര്യപ്രദമാണ്. ഞങ്ങൾ src-യിൽ ഒരു മാറ്റിവെച്ച ലിങ്ക് ഇട്ടു, അത്രമാത്രം. നിങ്ങൾക്ക് നിരവധി കേസുകൾ വരാം.

ക്ലയന്റ് API

• അസിങ്ക് Client.prototype.storeFile() - ഫയൽ സംരക്ഷിക്കുന്നു
• അസിങ്ക് Client.prototype.getFileLink() — ഫയലിലേക്ക് നേരിട്ടുള്ള ലിങ്ക് ലഭിക്കുന്നു
• അസിങ്ക് Client.prototype.getFileLinks() — ഒരു ഫയൽ നിലവിലുള്ള എല്ലാ നോഡുകളിൽ നിന്നും നേരിട്ടുള്ള ലിങ്കുകളുടെ ഒരു ലിസ്റ്റ് ലഭിക്കുന്നു
• അസിങ്ക് Client.prototype.getFileToBuffer() — ഫയൽ ബഫറിൽ എത്തിക്കുക
• അസിങ്ക് Client.prototype.getFileToPath() — ഫയൽ സിസ്റ്റത്തിലേക്ക് ഒരു ഫയൽ ലഭ്യമാക്കുക
• അസിങ്ക് Client.prototype.getFileToBlob() — ബ്ലോബിൽ ഫയൽ നേടുക (ബ്രൗസർ പതിപ്പിനായി)
• അസിങ്ക് Client.prototype.removeFile() - ഒരു ഫയൽ ഇല്ലാതാക്കുക
• Client.prototype.createRequestedFileLink() - ഒരു മാറ്റിവെച്ച ലിങ്ക് സൃഷ്ടിക്കുക

മറ്റൊരു സെർവറിലേക്ക് ഫയലുകൾ കയറ്റുമതി ചെയ്യുക

മറ്റൊരു നോഡിലേക്ക് ഫയലുകൾ കൈമാറുന്നതിന്, നിങ്ങൾക്ക് ഇവ ചെയ്യാനാകും:

• ക്രമീകരണങ്ങൾക്കൊപ്പം മുഴുവൻ സ്റ്റോറേജ് ഫോൾഡറും പകർത്തുക. (ഇത് ഭാവിയിൽ പ്രവർത്തിച്ചേക്കില്ല)
• ഫയലുകളുള്ള ഫോൾഡർ മാത്രം പകർത്തുക. പക്ഷേ, ഈ സാഹചര്യത്തിൽ, നിങ്ങൾ ഒരിക്കൽ ഫംഗ്ഷൻ പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട് node.normalizeFilesInfo()എല്ലാ ഡാറ്റയും വീണ്ടും കണക്കാക്കാനും ഡാറ്റാബേസിലേക്ക് നൽകാനും.
• ഫംഗ്ഷൻ ഉപയോഗിക്കുക node.exportFiles()അത് ഫയലുകൾ പകർത്താൻ തുടങ്ങും.

അടിസ്ഥാന നോഡ് ക്രമീകരണങ്ങൾ
സ്റ്റോറേജ് നോഡ് ആരംഭിക്കുമ്പോൾ, ആവശ്യമായ എല്ലാ ക്രമീകരണങ്ങളും നിങ്ങൾക്ക് വ്യക്തമാക്കാം.
ഏറ്റവും അടിസ്ഥാനപരമായവ ഞാൻ വിവരിക്കും, ബാക്കിയുള്ളവ Github-ൽ കാണാം.

• storage.dataSize - ഫയലുകളുള്ള ഫോൾഡറിന്റെ വലുപ്പം
• storage.tempSize — താൽക്കാലിക ഫോൾഡർ വലുപ്പം
• storage.autoCleanSize - സൂക്ഷിക്കേണ്ട ഏറ്റവും കുറഞ്ഞ സംഭരണ ​​വലുപ്പം. നിങ്ങൾ ഈ പരാമീറ്റർ വ്യക്തമാക്കുകയാണെങ്കിൽ, സ്ഥലം തീർന്നുപോകാൻ തുടങ്ങിയാൽ, ഏറ്റവും കുറവ് ഉപയോഗിച്ച ഫയലുകൾ ഇല്ലാതാക്കപ്പെടും.
• file.maxSize — പരമാവധി ഫയൽ വലിപ്പം
• file.minSize - കുറഞ്ഞ ഫയൽ വലുപ്പം
• file.preferredDuplicates — നെറ്റ്‌വർക്കിൽ ഇഷ്ടപ്പെട്ട ഫയൽ ഡ്യൂപ്ലിക്കേറ്റുകളുടെ എണ്ണം
• file.mimeWhitelist - സാധുവായ ഫയൽ തരങ്ങൾ
• file.mimeBlacklist - അസാധുവായ ഫയൽ തരങ്ങൾ
• file.extWhitelist - സാധുവായ ഫയൽ വിപുലീകരണങ്ങൾ
• file.extBlacklist - അസാധുവായ ഫയൽ വിപുലീകരണങ്ങൾ
• file.linkCache - വിവിധ ലിങ്ക് കാഷിംഗ് ക്രമീകരണങ്ങൾ

അളവുകളുമായി ബന്ധപ്പെട്ട മിക്കവാറും എല്ലാ പാരാമീറ്ററുകളും കേവലവും ആപേക്ഷികവുമായ മൂല്യങ്ങളിൽ നൽകാം.

കമാൻഡ് ലൈൻ വഴി പ്രവർത്തിക്കുന്നു
കമാൻഡ് ലൈൻ വഴി ലൈബ്രറി ഉപയോഗിക്കാം. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ഇത് ആഗോളതലത്തിൽ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്: npm i -g സ്റ്റോർക്കിൾ. ഇതിനുശേഷം, നോഡ് ഉള്ള പ്രോജക്റ്റ് ഡയറക്ടറിയിൽ നിന്ന് നിങ്ങൾക്ക് ആവശ്യമായ പ്രവർത്തനങ്ങൾ സമാരംഭിക്കാം. ഉദാഹരണത്തിന്, സ്റ്റോർക്കിൾ -എ സ്റ്റോർഫയൽ -എഫ് ./file.txt -c ./config.jsഫയൽ ചേർക്കാൻ. എല്ലാ പ്രവർത്തനങ്ങളും ഇതിൽ കാണാം https://github.com/ortexx/storacle/blob/master/bin/actions.js

നിങ്ങൾക്ക് ഇത് ആവശ്യമായി വന്നേക്കാം?

• നിങ്ങൾക്ക് സൗകര്യപ്രദമായ രീതികൾ ഉപയോഗിച്ച് ഫയലുകൾ സംഭരിക്കാനും പ്രവർത്തിക്കാനും പദ്ധതിയിടുന്ന ഏതെങ്കിലും തരത്തിലുള്ള വികേന്ദ്രീകൃത പ്രോജക്റ്റ് സൃഷ്ടിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ. ഉദാഹരണത്തിന്, ലേഖനത്തിന്റെ തുടക്കത്തിൽ ലിങ്കിൽ വിവരിച്ചിരിക്കുന്ന സംഗീത പദ്ധതി ഉപയോഗിക്കുന്നു സ്റ്റോർക്കിൾ.
• നിങ്ങൾ മറ്റേതെങ്കിലും പ്രോജക്റ്റുകളിൽ പ്രവർത്തിക്കുകയാണെങ്കിൽ, വിതരണം ചെയ്ത രീതിയിൽ ഫയലുകൾ സംഭരിക്കേണ്ടതുണ്ട്. നിങ്ങൾക്ക് എളുപ്പത്തിൽ അടച്ച നെറ്റ്‌വർക്ക് നിർമ്മിക്കാനും നോഡുകൾ ക്രമീകരിക്കാനും ആവശ്യമുള്ളപ്പോൾ പുതിയവ ചേർക്കാനും കഴിയും.
• നിങ്ങളുടെ വെബ്‌സൈറ്റ് ഫയലുകൾ എവിടെയെങ്കിലും സൂക്ഷിക്കണമെങ്കിൽ, എല്ലാം സ്വയം എഴുതുന്നത് നിങ്ങൾക്ക് വളരെ കൂടുതലാണ്. ഒരുപക്ഷേ ഈ ലൈബ്രറി നിങ്ങളുടെ കാര്യത്തിൽ മറ്റുള്ളവയേക്കാൾ അനുയോജ്യമാണ്.
• നിങ്ങൾക്ക് ഫയലുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്ന ഒരു പ്രോജക്റ്റ് ഉണ്ടെങ്കിൽ, എന്നാൽ ബ്രൗസറിൽ നിന്ന് എല്ലാ കൃത്രിമത്വങ്ങളും നടത്താൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ. നിങ്ങൾക്ക് സെർവർ കോഡ് എഴുതുന്നത് ഒഴിവാക്കാം.

എന്റെ കോൺടാക്റ്റുകൾ:

• @ഓർട്ടക്സ്
• [ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]

അവലംബം: www.habr.com