સ્ટોરેકલ - વિકેન્દ્રિત ફાઇલ સ્ટોરેજ

હું શરૂ કરું તે પહેલાં, મારે જવું જોઈએ અગાઉના લેખની લિંકજેથી તે સ્પષ્ટ થાય કે આપણે બરાબર શું વાત કરી રહ્યા છીએ.

આ લેખમાં હું તે સ્તરને જોવા માંગુ છું જે ફાઇલોને સંગ્રહિત કરવા માટે જવાબદાર છે, અને તેનો ઉપયોગ કોઈપણ દ્વારા કેવી રીતે કરી શકાય છે. સ્ટોરેકલ એક એકલ પુસ્તકાલય છે, સંગીત સાથે કોઈ સીધો સંબંધ નથી. તમે કોઈપણ ફાઇલોના સંગ્રહને ગોઠવી શકો છો.

પાછલા લેખમાં, મેં થોડું "બેરલ ફેરવ્યું" 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

• async Client.prototype.storeFile() - ફાઇલ સાચવી રહ્યું છે
• async Client.prototype.getFileLink() - ફાઇલની સીધી લિંક મેળવવી
• async Client.prototype.getFileLinks() — જ્યાં તે અસ્તિત્વમાં છે તે તમામ નોડ્સમાંથી ફાઇલની સીધી લિંક્સની સૂચિ મેળવવી
• async Client.prototype.getFileToBuffer() - બફરમાં ફાઇલ મેળવો
• async Client.prototype.getFileToPath() - ફાઇલ સિસ્ટમમાં ફાઇલ મેળવો
• async Client.prototype.getFileToBlob() - બ્લોબમાં ફાઇલ મેળવો (બ્રાઉઝર સંસ્કરણ માટે)
• async Client.prototype.removeFile() - ફાઇલ કાઢી નાખો
• Client.prototype.createRequestedFileLink() - વિલંબિત લિંક બનાવો

ફાઇલોને બીજા સર્વર પર નિકાસ કરો

ફાઇલોને બીજા નોડ પર સ્થાનાંતરિત કરવા માટે, તમે આ કરી શકો છો:

• ફક્ત સેટિંગ્સ સાથે સમગ્ર સ્ટોરેજ ફોલ્ડરની નકલ કરો. (આ ભવિષ્યમાં કામ નહીં કરે)
• ફક્ત ફાઇલો સાથે ફોલ્ડરની નકલ કરો. પરંતુ, આ કિસ્સામાં, તમારે એકવાર ફંક્શન ચલાવવાની જરૂર પડશે node.normalizeFilesInfo()તમામ ડેટાની પુનઃ ગણતરી કરવા અને તેને ડેટાબેઝમાં દાખલ કરવા.
• કાર્યનો ઉપયોગ કરો node.exportFiles()જે ફાઇલોની નકલ કરવાનું શરૂ કરશે.

મૂળભૂત નોડ સેટિંગ્સ
સ્ટોરેજ નોડ શરૂ કરતી વખતે, તમે બધી જરૂરી સેટિંગ્સનો ઉલ્લેખ કરી શકો છો.
હું સૌથી મૂળભૂતનું વર્ણન કરીશ, બાકીના ગીથબ પર મળી શકે છે.

• store.dataSize - ફાઇલો સાથે ફોલ્ડરનું કદ
• store.tempSize - કામચલાઉ ફોલ્ડર કદ
• store.autoCleanSize — લઘુત્તમ સંગ્રહ કદ કે જે રાખવાની જરૂર છે. જો તમે આ પરિમાણનો ઉલ્લેખ કરો છો, તો જલદી જ જગ્યા સમાપ્ત થવાનું શરૂ થાય છે, ઓછામાં ઓછી વપરાયેલી ફાઇલો કાઢી નાખવામાં આવશે.
• file.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

શા માટે તમને આની જરૂર પડી શકે છે?

• જો તમે કોઈ પ્રકારનો વિકેન્દ્રિત પ્રોજેક્ટ બનાવવા માંગો છો જેમાં તમે અનુકૂળ પદ્ધતિઓનો ઉપયોગ કરીને ફાઇલોને સંગ્રહિત અને કામ કરવાની યોજના ઘડી રહ્યા છો. ઉદાહરણ તરીકે, લેખની શરૂઆતમાં લિંકમાં વર્ણવેલ સંગીત પ્રોજેક્ટનો ઉપયોગ થાય છે ભંડાર.
• જો તમે અન્ય કોઈ પ્રોજેક્ટ પર કામ કરો છો જ્યાં તમારે ફાઇલોને વિતરિત રીતે સંગ્રહિત કરવાની જરૂર છે. તમે સરળતાથી તમારું બંધ નેટવર્ક બનાવી શકો છો, નોડ્સને લવચીક રીતે ગોઠવી શકો છો અને જરૂર પડે ત્યારે નવા ઉમેરી શકો છો.
• જો તમારે ફક્ત તમારી વેબસાઇટ ફાઇલોને ક્યાંક સંગ્રહિત કરવાની જરૂર હોય અને તમારા માટે બધું જાતે લખવાનું તમારા માટે ઘણું વધારે છે. કદાચ આ પુસ્તકાલય તમારા કિસ્સામાં અન્ય લોકો કરતાં વધુ યોગ્ય છે.
• જો તમારી પાસે કોઈ પ્રોજેક્ટ છે જેમાં તમે ફાઇલો સાથે કામ કરો છો, પરંતુ બ્રાઉઝરમાંથી તમામ મેનિપ્યુલેશન્સ કરવા માંગો છો. તમે સર્વર કોડ લખવાનું ટાળી શકો છો.

મારા સંપર્કો:

• @ઓર્ટેક્સ
• [ઇમેઇલ સુરક્ષિત]

સોર્સ: www.habr.com