Storacle - ការផ្ទុកឯកសារវិមជ្ឈការ

មុនពេលខ្ញុំចាប់ផ្តើម ខ្ញុំត្រូវតែចាកចេញ តំណភ្ជាប់ទៅអត្ថបទមុន។ដូច្នេះវាច្បាស់ថាយើងកំពុងនិយាយអំពីអ្វី។

នៅក្នុងអត្ថបទនេះខ្ញុំចង់ពិនិត្យមើលស្រទាប់ដែលទទួលខុសត្រូវក្នុងការរក្សាទុកឯកសារ និងរបៀបដែលវាអាចប្រើបានដោយនរណាម្នាក់។ Storacle គឺជាបណ្ណាល័យឯករាជ្យ, មិនមានទំនាក់ទំនងផ្ទាល់ជាមួយតន្ត្រីទេ។ អ្នកអាចរៀបចំការផ្ទុកឯកសារណាមួយ។

នៅក្នុងអត្ថបទមុនខ្ញុំបាន "រមៀលធុង" បន្តិច ipfsប៉ុន្តែរឿងនេះបានកើតឡើងយ៉ាងជាក់លាក់នៅក្នុងបរិបទនៃបញ្ហាដែលខ្ញុំកំពុងដោះស្រាយ។ សរុបមក ខ្ញុំគិតថាគម្រោងនេះល្អមែនទែន។ ខ្ញុំគ្រាន់តែចូលចិត្តសមត្ថភាពក្នុងការបង្កើតបណ្តាញផ្សេងៗគ្នាសម្រាប់កិច្ចការផ្សេងៗ។ នេះអនុញ្ញាតឱ្យអ្នករៀបចំរចនាសម្ព័ន្ធបានប្រសើរជាងមុន និងកាត់បន្ថយការផ្ទុកនៅលើថ្នាំងនីមួយៗ និងបណ្តាញទាំងមូល។ សូម្បីតែនៅក្នុងក្របខ័ណ្ឌនៃគម្រោងមួយ បើចាំបាច់ អ្នកអាចបំបែកបណ្តាញទៅជាបំណែកៗតាមលក្ខណៈវិនិច្ឆ័យមួយចំនួន ដោយកាត់បន្ថយបន្ទុកទាំងមូល។

ដូច្នេះ storacle ប្រើយន្តការ ឆ្លង សម្រាប់ការរៀបចំបណ្តាញ។ លក្ខណៈ​ពិសេស:

• ឯកសារអាចត្រូវបានបន្ថែមទៅឃ្លាំងតាមរយៈថ្នាំងណាមួយ។
• ឯកសារត្រូវបានរក្សាទុកទាំងស្រុង មិនមែននៅក្នុងប្លុកទេ។
• ឯកសារនីមួយៗមាន hash មាតិកាផ្ទាល់ខ្លួនរបស់វាសម្រាប់ការងារបន្ថែមទៀតជាមួយវា។
• ឯកសារអាចត្រូវបានចម្លងសម្រាប់ភាពជឿជាក់កាន់តែច្រើន
• ចំនួនឯកសារនៅលើថ្នាំងមួយត្រូវបានកំណត់តែដោយប្រព័ន្ធឯកសារប៉ុណ្ណោះ (មានករណីលើកលែង បន្ថែមលើនោះខាងក្រោម)
• ចំនួនឯកសារនៅក្នុងបណ្តាញត្រូវបានកំណត់ដោយសមត្ថភាពដែលអាចផ្សព្វផ្សាយបានយោងទៅតាមចំនួនថ្នាំងដែលមានសុពលភាពនៅក្នុងបណ្តាញ ដែលនៅក្នុងកំណែទីពីរនឹងអាចធ្វើការជាមួយចំនួនថ្នាំងគ្មានកំណត់ (បន្ថែមលើនេះនៅក្នុងអត្ថបទមួយផ្សេងទៀត)

ឧទាហរណ៍សាមញ្ញនៃរបៀបដែលវាដំណើរការជាទូទៅពីកម្មវិធី៖

ម៉ាស៊ីនមេ៖

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)) ។

ឈ្មោះ​ថត​ត្រូវ​បាន​បង្កើត​ឡើង​ពី​ឯកសារ​ hash ដូច្នេះ​អ្នក​អាច​ចូល​ប្រើ​វា​បាន​យ៉ាង​លឿន​ប្រសិន​បើ​អ្នក​ស្គាល់​ hash ។

រចនាសម្ព័ននេះត្រូវបានជ្រើសរើសដោយផ្អែកលើតម្រូវការផ្ទុកផ្សេងៗគ្នាជាច្រើន៖ ការគាំទ្រសម្រាប់ប្រព័ន្ធឯកសារខ្សោយ ដែលវាមិនចង់បានឯកសារច្រើនក្នុងថតតែមួយ ការឆ្លងកាត់រហ័សនៃថតទាំងអស់ប្រសិនបើចាំបាច់។ល។ ប្រភេទនៃមធ្យោបាយមាស។

ឃ្លាំងសម្ងាត់

នៅពេលបន្ថែមឯកសារ ក៏ដូចជានៅពេលទទួលវា តំណភ្ជាប់ទៅឯកសារត្រូវបានសរសេរទៅកាន់ឃ្លាំងសម្ងាត់។
អរគុណចំពោះបញ្ហានេះ ជាញឹកញាប់មិនចាំបាច់ឆ្លងកាត់បណ្តាញទាំងមូលក្នុងការស្វែងរកឯកសារទេ។ វាបង្កើនល្បឿននៃការទទួលតំណ និងកាត់បន្ថយការផ្ទុកនៅលើបណ្តាញ។ ឃ្លាំងសម្ងាត់ក៏កើតឡើងតាមរយៈបឋមកថា http ។

អ៊ីសូម៉ូហ្វី

ម៉ាស៊ីនភ្ញៀវត្រូវបានសរសេរជា javascript ហើយជា isomorphic វាអាចត្រូវបានប្រើដោយផ្ទាល់ពីកម្មវិធីរុករក។ 
អ្នកអាចផ្ទុកឯកសារឡើង 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() - ទទួលបានឯកសារនៅក្នុង blob (សម្រាប់កំណែកម្មវិធីរុករក)
• អសមកាល Client.prototype.removeFile() - លុបឯកសារ
• Client.prototype.createRequestedFileLink() - បង្កើតតំណពន្យាពេល

នាំចេញឯកសារទៅម៉ាស៊ីនមេផ្សេងទៀត។

ដើម្បីផ្ទេរឯកសារទៅថ្នាំងផ្សេងទៀត អ្នកអាច៖

• គ្រាន់តែចម្លងថតឯកសារផ្ទុកទាំងមូលរួមជាមួយនឹងការកំណត់។ (វាអាចនឹងមិនដំណើរការនាពេលអនាគត)
• ចម្លងតែថតជាមួយឯកសារ។ ប៉ុន្តែក្នុងករណីនេះ អ្នកនឹងត្រូវដំណើរការមុខងារម្តង node.normalizeFilesInfo()ដើម្បីគណនាឡើងវិញនូវទិន្នន័យទាំងអស់ ហើយបញ្ចូលវាទៅក្នុងមូលដ្ឋានទិន្នន័យ។
• ប្រើមុខងារ node.exportFiles()ដែលនឹងចាប់ផ្តើមចម្លងឯកសារ។

ការកំណត់ថ្នាំងមូលដ្ឋាន
នៅពេលចាប់ផ្តើមថ្នាំងផ្ទុក អ្នកអាចបញ្ជាក់ការកំណត់ចាំបាច់ទាំងអស់។
ខ្ញុំនឹងពណ៌នាអំពីមូលដ្ឋានបំផុត អ្វីដែលនៅសល់អាចត្រូវបានរកឃើញនៅលើ Github ។

• ទំហំផ្ទុកទិន្នន័យ - ទំហំនៃថតដែលមានឯកសារ
• storage.tempSize - ទំហំថតបណ្តោះអាសន្ន
• storage.autoCleanSize - ទំហំផ្ទុកអប្បបរមាដែលត្រូវការរក្សា។ ប្រសិនបើអ្នកបញ្ជាក់ប៉ារ៉ាម៉ែត្រនេះ នោះភ្លាមៗនៅពេលដែលទំហំទំនេរចាប់ផ្តើមអស់ ឯកសារដែលប្រើតិចបំផុតនឹងត្រូវបានលុប។
• file.maxSize - ទំហំឯកសារអតិបរមា
• file.minSize - ទំហំឯកសារអប្បបរមា
• file.preferred ស្ទួន - ចំនួនដែលពេញចិត្តនៃឯកសារស្ទួននៅលើបណ្តាញ
• file.mime បញ្ជីស - ប្រភេទឯកសារត្រឹមត្រូវ។
• file.mimeBlacklist - ប្រភេទឯកសារមិនត្រឹមត្រូវ
• file.ext បញ្ជីស - ផ្នែកបន្ថែមឯកសារត្រឹមត្រូវ។
• file.ext បញ្ជីខ្មៅ - ផ្នែកបន្ថែមឯកសារមិនត្រឹមត្រូវ
• file.linkCache - ការកំណត់ឃ្លាំងសម្ងាត់តំណផ្សេងៗ

ស្ទើរតែគ្រប់ប៉ារ៉ាម៉ែត្រដែលទាក់ទងនឹងវិមាត្រអាចត្រូវបានបញ្ចូលទាំងតម្លៃដាច់ខាត និងតម្លៃដែលទាក់ទង។

ធ្វើការតាមរយៈបន្ទាត់ពាក្យបញ្ជា
បណ្ណាល័យអាចត្រូវបានប្រើតាមរយៈបន្ទាត់ពាក្យបញ្ជា។ ដើម្បីធ្វើដូចនេះអ្នកត្រូវដំឡើងវាជាសកល៖ npm i -g storacle. បន្ទាប់ពីនេះ អ្នកអាចចាប់ផ្តើមសកម្មភាពចាំបាច់ពីថតគម្រោងដែលថ្នាំងស្ថិតនៅ។ ឧទាហរណ៍, storacle -a storeFile -f ./file.txt -c ./config.jsដើម្បីបន្ថែមឯកសារ។ សកម្មភាពទាំងអស់អាចរកបាននៅក្នុង https://github.com/ortexx/storacle/blob/master/bin/actions.js

ហេតុអ្វីបានជាអ្នកប្រហែលជាត្រូវការវា?

• ប្រសិនបើអ្នកចង់បង្កើតគម្រោងវិមជ្ឈការមួយចំនួនដែលអ្នកមានគម្រោងរក្សាទុក និងធ្វើការជាមួយឯកសារដោយប្រើវិធីសាស្ត្រងាយស្រួល។ ឧទាហរណ៍ គម្រោងតន្ត្រីដែលបានពិពណ៌នានៅក្នុងតំណភ្ជាប់នៅដើមអត្ថបទប្រើ កន្លែងស្តុកទុក.
• ប្រសិនបើអ្នកធ្វើការលើគម្រោងផ្សេងទៀតដែលអ្នកត្រូវការរក្សាទុកឯកសារក្នុងលក្ខណៈចែកចាយ។ អ្នកអាចបង្កើតបណ្តាញបិទរបស់អ្នកបានយ៉ាងងាយស្រួល កំណត់រចនាសម្ព័ន្ធថ្នាំងដោយភាពបត់បែន និងបន្ថែមបណ្តាញថ្មីនៅពេលចាំបាច់។
• ប្រសិនបើអ្នកគ្រាន់តែត្រូវការរក្សាទុកឯកសារគេហទំព័ររបស់អ្នកនៅកន្លែងណាមួយ ហើយវាច្រើនពេកសម្រាប់អ្នកក្នុងការសរសេរអ្វីគ្រប់យ៉ាងដោយខ្លួនឯង។ ប្រហែល​ជា​បណ្ណាល័យ​នេះ​ស័ក្តិសម​ជាង​អ្នក​ផ្សេង​ទៀត​ក្នុង​ករណី​របស់​អ្នក។
• ប្រសិនបើអ្នកមានគម្រោងដែលអ្នកធ្វើការជាមួយឯកសារ ប៉ុន្តែចង់អនុវត្តឧបាយកលទាំងអស់ពីកម្មវិធីរុករក។ អ្នកអាចជៀសវាងការសរសេរកូដម៉ាស៊ីនមេ។

ទំនាក់ទំនងខ្ញុំ៖

• @ortex
• [អ៊ីមែលការពារ]

ប្រភព: www.habr.com