ລະບົບການເຂົ້າເຖິງໄຟລ໌ໄລຍະໄກ Cage

ຈຸດປະສົງຂອງລະບົບ

ສະຫນັບສະຫນູນການເຂົ້າເຖິງຫ່າງໄກສອກຫຼີກຂອງໄຟລ໌ໃນຄອມພິວເຕີໃນເຄືອຂ່າຍ. ລະບົບ "virtally" ສະຫນັບສະຫນູນການດໍາເນີນການໄຟລ໌ພື້ນຖານທັງຫມົດ (ການສ້າງ, ການລຶບ, ອ່ານ, ຂຽນ, ແລະອື່ນໆ) ໂດຍການແລກປ່ຽນທຸລະກໍາ (ຂໍ້ຄວາມ) ໂດຍໃຊ້ TCP protocol.

ຄໍາຮ້ອງສະຫມັກ

ການເຮັດວຽກຂອງລະບົບມີປະສິດທິພາບໃນກໍລະນີຕໍ່ໄປນີ້:

• ໃນຄໍາຮ້ອງສະຫມັກພື້ນເມືອງສໍາລັບອຸປະກອນມືຖືແລະຝັງ (ໂທລະສັບສະຫຼາດ, ລະບົບການຄວບຄຸມເທິງເຮືອ, ແລະອື່ນໆ) ທີ່ຕ້ອງການການເຂົ້າເຖິງໄວກັບໄຟລ໌ໃນເຄື່ອງແມ່ຂ່າຍຫ່າງໄກສອກຫຼີກໃນການປະເຊີນກັບການຂັດຂວາງຊົ່ວຄາວທີ່ເປັນໄປໄດ້ໃນການສື່ສານ (ກັບ offline);
• ໃນ DBMSs ທີ່ຖືກໂຫລດ, ຖ້າການປະມວນຜົນການສອບຖາມແມ່ນດໍາເນີນຢູ່ໃນບາງເຄື່ອງແມ່ຂ່າຍ, ແລະການເກັບຮັກສາຂໍ້ມູນແມ່ນດໍາເນີນການກັບຄົນອື່ນ;
• ໃນເຄືອຂ່າຍຂອງບໍລິສັດທີ່ແຈກຢາຍສໍາລັບການລວບລວມແລະການປຸງແຕ່ງຂໍ້ມູນ, ຮຽກຮ້ອງໃຫ້ມີການແລກປ່ຽນຂໍ້ມູນຄວາມໄວສູງ, ຊ້ໍາຊ້ອນແລະຄວາມຫນ້າເຊື່ອຖື;
• ໃນລະບົບສະລັບສັບຊ້ອນທີ່ມີສະຖາປັດຕະຍະກໍາຈຸລະພາກ, ບ່ອນທີ່ຄວາມຊັກຊ້າໃນການແລກປ່ຽນຂໍ້ມູນລະຫວ່າງໂມດູນແມ່ນສໍາຄັນ.

ໂຄງປະກອບການ

ລະບົບ Cage (ມີການຈັດຕັ້ງປະຕິບັດ - ຮຸ່ນ beta ໃນ Python 3.7 ໃນ Windows) ປະກອບມີສອງພາກສ່ວນຕົ້ນຕໍ:

1. Cageserver — ໂຄງ​ການ​ເຄື່ອງ​ແມ່​ຂ່າຍ​ຂອງ​ໄຟລ​໌ (ຊຸດ​ຂອງ​ຫນ້າ​ທີ່​) ທີ່​ດໍາ​ເນີນ​ການ​ໃນ​ຄອມ​ພິວ​ເຕີ​ໃນ​ເຄືອ​ຂ່າຍ​ທີ່​ໄຟລ​໌​ຕ້ອງ​ການ​ການ​ເຂົ້າ​ເຖິງ​ຫ່າງ​ໄກ​ສອກ​ຫຼີກ​;
2. ຫ້ອງ​ຮຽນ cage ກັບຫ້ອງສະຫມຸດຂອງວິທີການສໍາລັບຊອບແວລູກຄ້າ, ງ່າຍ coding ຂອງການໂຕ້ຕອບກັບເຄື່ອງແມ່ຂ່າຍ.

ການນໍາໃຊ້ລະບົບໃນຝ່າຍລູກຄ້າ

ວິທີການຂອງຫ້ອງຮຽນ Cage ແທນການປະຕິບັດລະບົບໄຟລ໌ "ປົກກະຕິ" ແບບປົກກະຕິ: ການສ້າງ, ເປີດ, ປິດ, ລຶບ ໄຟລ໌, ເຊັ່ນດຽວກັນກັບ ອ່ານ/ຂຽນຂໍ້ມູນໃນຮູບແບບຖານສອງ (ຊີ້ບອກຕໍາແຫນ່ງແລະຂະຫນາດຂອງຂໍ້ມູນ). Conceptually, ວິທີການເຫຼົ່ານີ້ແມ່ນຢູ່ໃກ້ກັບຫນ້າທີ່ໄຟລ໌ຂອງພາສາ C, ບ່ອນທີ່ການເປີດ / ປິດໄຟລ໌ແມ່ນດໍາເນີນການ "ຢູ່ໃນຊ່ອງທາງ" ຂອງ input / output.

ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ຜູ້ຂຽນໂປລແກລມບໍ່ໄດ້ເຮັດວຽກກັບວິທີການຂອງ "ໄຟລ໌" ວັດຖຸ (ຫ້ອງຮຽນ _io ໃນ Python), ແຕ່ມີວິທີການຂອງຫ້ອງຮຽນ Cage.

ເມື່ອຕົວຢ່າງຂອງວັດຖຸ Cage ຖືກສ້າງຂື້ນ, ມັນຈະສ້າງການເຊື່ອມຕໍ່ເບື້ອງຕົ້ນກັບເຄື່ອງແມ່ຂ່າຍ (ຫຼືເຄື່ອງແມ່ຂ່າຍຈໍານວນຫນຶ່ງ), ໄດ້ຮັບການອະນຸຍາດຈາກ Client Id, ແລະໄດ້ຮັບການຢືນຢັນດ້ວຍຫມາຍເລກພອດສະເພາະສໍາລັບການດໍາເນີນງານໄຟລ໌ທັງຫມົດ. ເມື່ອວັດຖຸ Cage ຖືກລຶບ, ມັນສັ່ງໃຫ້ເຄື່ອງແມ່ຂ່າຍຢຸດການສື່ສານແລະປິດໄຟລ໌. ການຢຸດເຊົາການສື່ສານຍັງສາມາດເລີ່ມຕົ້ນໂດຍເຄື່ອງແມ່ຂ່າຍຂອງຕົນເອງ.

ລະບົບປັບປຸງປະສິດທິພາບການອ່ານ / ຂຽນໂດຍ buffering fragments ໄຟລ໌ທີ່ໃຊ້ເລື້ອຍໆຂອງໂປແກຼມລູກຄ້າໃນ RAM cache (buffer).
ຊອບແວລູກຄ້າສາມາດໃຊ້ວັດຖຸ Cage ທີ່ມີການຕັ້ງຄ່າທີ່ແຕກຕ່າງກັນ (ຂະຫນາດຂອງຫນ່ວຍຄວາມຈໍາ buffer, ຂະຫນາດຕັນໃນເວລາທີ່ແລກປ່ຽນກັບເຄື່ອງແມ່ຂ່າຍ, ແລະອື່ນໆ).

ວັດຖຸ Cage ດຽວສາມາດຕິດຕໍ່ສື່ສານກັບຫຼາຍໄຟລ໌ຢູ່ໃນເຄື່ອງແມ່ຂ່າຍຫຼາຍ. ຕົວກໍານົດການການສື່ສານ (ທີ່ຢູ່ IP ຫຼືເຄື່ອງແມ່ຂ່າຍ DNS, ພອດຕົ້ນຕໍສໍາລັບການອະນຸຍາດ, ເສັ້ນທາງແລະຊື່ໄຟລ໌) ຖືກລະບຸໃນເວລາສ້າງວັດຖຸ.

ເນື່ອງຈາກແຕ່ລະວັດຖຸ Cage ສາມາດເຮັດວຽກກັບຫຼາຍໄຟລ໌ໃນເວລາດຽວກັນ, ພື້ນທີ່ຫນ່ວຍຄວາມຈໍາທີ່ໃຊ້ຮ່ວມກັນແມ່ນໃຊ້ສໍາລັບການ buffering. ຂະ​ຫນາດ​ຂອງ​ຖານ​ຄວາມ​ຈໍາ – ຈໍາ​ນວນ​ຂອງ​ຫນ້າ​ແລະ​ຂະ​ຫນາດ​ຂອງ​ພວກ​ເຂົາ​, ຖືກ​ກໍາ​ນົດ​ຢ່າງ​ເຄື່ອນ​ໄຫວ​ໃນ​ເວ​ລາ​ທີ່​ການ​ສ້າງ​ວັດ​ຖຸ Cage​. ຕົວຢ່າງ, cache 1 GB ແມ່ນ 1000 ຫນ້າຂອງ 1 MB ແຕ່ລະຄົນ, ຫຼື 10 ພັນຫນ້າຂອງ 100 KB ແຕ່ລະຄົນ, ຫຼື 1 ລ້ານຫນ້າຂອງ 1 KB ແຕ່ລະຄົນ. ການເລືອກຂະຫນາດແລະຈໍານວນຫນ້າແມ່ນເປັນວຽກສະເພາະສໍາລັບແຕ່ລະກໍລະນີຄໍາຮ້ອງສະຫມັກ.

ທ່ານ​ສາ​ມາດ​ນໍາ​ໃຊ້​ວັດ​ຖຸ Cage ຫຼາຍ​ໃນ​ເວ​ລາ​ດຽວ​ກັນ​ເພື່ອ​ກໍາ​ນົດ​ການ​ຕັ້ງ​ຄ່າ​ຄວາມ​ຊົງ​ຈໍາ buffer ທີ່​ແຕກ​ຕ່າງ​ກັນ​ຂຶ້ນ​ກັບ​ວິ​ທີ​ການ​ເຂົ້າ​ເຖິງ​ຂໍ້​ມູນ​ໃນ​ໄຟລ​໌​ທີ່​ແຕກ​ຕ່າງ​ກັນ​. ເປັນພື້ນຖານຫນຶ່ງ, ສູດການຄິດໄລ່ທີ່ງ່າຍດາຍທີ່ສຸດແມ່ນຖືກນໍາໃຊ້: ຫຼັງຈາກຈໍານວນຫນ່ວຍຄວາມຈໍາທີ່ລະບຸໄວ້ຫມົດແລ້ວ, ຫນ້າໃຫມ່ຈະຍ້າຍຫນ້າເກົ່າຕາມຫຼັກການຂອງການບໍານານທີ່ມີຈໍານວນຕໍາ່ສຸດທີ່ຂອງການເຂົ້າເຖິງ. Buffering ແມ່ນມີປະສິດທິພາບໂດຍສະເພາະໃນກໍລະນີຂອງຄວາມບໍ່ສະເຫມີພາບ (ໃນຄວາມຮູ້ສຶກທາງສະຖິຕິ) ການເຂົ້າເຖິງການແບ່ງປັນ, ທໍາອິດ, ໄຟລ໌ທີ່ແຕກຕ່າງກັນ, ແລະ, ອັນທີສອງ, fragments ຂອງແຕ່ລະໄຟລ໌.

ຫ້ອງຮຽນ Cage ສະຫນັບສະຫນູນ I / O ບໍ່ພຽງແຕ່ໂດຍທີ່ຢູ່ຂໍ້ມູນ (ຊີ້ໃຫ້ເຫັນຕໍາແຫນ່ງແລະຄວາມຍາວຂອງອາເລ, "ການປ່ຽນແທນ" ການປະຕິບັດລະບົບໄຟລ໌), ແຕ່ຍັງຢູ່ໃນລະດັບຕ່ໍາ, "ທາງດ້ານຮ່າງກາຍ" - ໂດຍຕົວເລກຫນ້າໃນ buffer memory.

ຟັງຊັນຕົ້ນສະບັບແມ່ນສະຫນັບສະຫນູນສໍາລັບວັດຖຸ Cage "ການ hibernation" ("ນອນ") - ພວກເຂົາສາມາດຖືກ "ລົ້ມລົງ" (ຕົວຢ່າງເຊັ່ນ, ໃນກໍລະນີຂອງການສູນເສຍການເຊື່ອມຕໍ່ກັບເຄື່ອງແມ່ຂ່າຍ, ຫຼືໃນເວລາທີ່ຄໍາຮ້ອງສະຫມັກຖືກຢຸດ, ແລະອື່ນໆ) ເຂົ້າໄປໃນໄຟລ໌ dump ທ້ອງຖິ່ນໃນຝ່າຍລູກຄ້າແລະຟື້ນຟູຢ່າງໄວວາຈາກ. ໄຟລ໌ນີ້ (ຫຼັງຈາກການສື່ສານແມ່ນສືບຕໍ່, ເມື່ອທ່ານເປີດແອັບພລິເຄຊັນຄືນໃໝ່). ນີ້ເຮັດໃຫ້ມັນເປັນໄປໄດ້ທີ່ຈະຫຼຸດຜ່ອນການຈະລາຈອນຢ່າງຫຼວງຫຼາຍໃນເວລາທີ່ເປີດໃຊ້ໂປແກຼມລູກຄ້າຫຼັງຈາກ "ອອບໄລນ໌" ຊົ່ວຄາວ, ເພາະວ່າຊິ້ນໄຟລ໌ທີ່ໃຊ້ເລື້ອຍໆຈະຢູ່ໃນແຄດແລ້ວ.

Cage ແມ່ນປະມານ 3600 ເສັ້ນຂອງລະຫັດ.

ຫຼັກການຂອງການກໍ່ສ້າງເຄື່ອງແມ່ຂ່າຍ

ເຄື່ອງແມ່ຂ່າຍໄຟລ໌ Cageserver ສາມາດດໍາເນີນການໄດ້ດ້ວຍຈໍານວນພອດທີ່ກໍານົດເອງ, ຫນຶ່ງໃນນັ້ນ ("ຕົ້ນຕໍ") ແມ່ນໃຊ້ພຽງແຕ່ສໍາລັບການອະນຸຍາດຂອງລູກຄ້າທັງຫມົດ, ສ່ວນທີ່ເຫຼືອແມ່ນໃຊ້ສໍາລັບການແລກປ່ຽນຂໍ້ມູນ. ໂປຣແກຣມເຊີບເວີ Cage ຕ້ອງການພຽງແຕ່ Python. ໃນຂະຫນານ, ຄອມພິວເຕີກັບເຄື່ອງແມ່ຂ່າຍຂອງໄຟລ໌ສາມາດເຮັດວຽກອື່ນໆ.

ເຊີບເວີເລີ່ມຕົ້ນເປັນຊຸດຂອງສອງຂະບວນການຕົ້ນຕໍ:

1. "ການເຊື່ອມຕໍ່" - ຂະບວນການປະຕິບັດການດໍາເນີນງານຂອງການສ້າງການສື່ສານກັບລູກຄ້າແລະຢຸດມັນຢູ່ໃນການລິເລີ່ມຂອງເຄື່ອງແມ່ຂ່າຍ;
2. "ການດໍາເນີນງານ" - ຂະບວນການປະຕິບັດວຽກງານ (ການດໍາເນີນງານ) ຂອງລູກຄ້າເພື່ອເຮັດວຽກກັບໄຟລ໌, ເຊັ່ນດຽວກັນກັບການປິດກອງປະຊຸມການສື່ສານໂດຍອີງໃສ່ຄໍາສັ່ງຂອງລູກຄ້າ.

ຂະບວນການທັງສອງບໍ່ໄດ້ຖືກ synchronized ແລະຖືກຈັດເປັນ loops ທີ່ບໍ່ມີສິ້ນສຸດຂອງການຮັບແລະສົ່ງຂໍ້ຄວາມໂດຍອີງໃສ່ຄິວ multiprocess, ວັດຖຸຕົວແທນ, locks ແລະ sockets.
ຂະບວນການເຊື່ອມຕໍ່ຈັດສັນພອດສໍາລັບລູກຄ້າແຕ່ລະຄົນເພື່ອຮັບແລະສົ່ງຂໍ້ມູນ. ຈໍານວນພອດແມ່ນຖືກກໍານົດເມື່ອເຄື່ອງແມ່ຂ່າຍເລີ່ມຕົ້ນ. ການສ້າງແຜນທີ່ລະຫວ່າງພອດ ແລະລູກຂ່າຍຖືກເກັບໄວ້ໃນໜ່ວຍຄວາມຈຳພຣັອກຊີທີ່ໃຊ້ຮ່ວມກັນລະຫວ່າງຂະບວນການ.

ຂະ​ບວນ​ການ​ປະ​ຕິ​ບັດ​ສະ​ຫນັບ​ສະ​ຫນູນ​ການ​ແບ່ງ​ປັນ​ຊັບ​ພະ​ຍາ​ກອນ​ໄຟລ​໌​ເພື່ອ​ໃຫ້​ລູກ​ຄ້າ​ທີ່​ແຕກ​ຕ່າງ​ກັນ​ຫຼາຍ​ສາ​ມາດ​ແບ່ງ​ປັນ (ເຄິ່ງຂະໜານ, ນັບຕັ້ງແຕ່ການເຂົ້າເຖິງຖືກຄວບຄຸມໂດຍ locks) ອ່ານຂໍ້ມູນຈາກໄຟລ໌ຫນຶ່ງຖ້າຫາກວ່ານີ້ໄດ້ຖືກອະນຸຍາດໃນເວລາທີ່ມັນຖືກເປີດໂດຍລູກຄ້າ "ທໍາອິດ".

ການປະມວນຜົນຄໍາສັ່ງເພື່ອສ້າງ / ລຶບ / ເປີດ / ປິດໄຟລ໌ຢູ່ໃນເຄື່ອງແມ່ຂ່າຍແມ່ນດໍາເນີນໃນຂະບວນການ "ການດໍາເນີນງານ" ຕົວຂອງມັນເອງຕາມລໍາດັບຢ່າງເຂັ້ມງວດໂດຍໃຊ້ລະບົບຍ່ອຍຂອງເຄື່ອງແມ່ຂ່າຍ OS.

ໂດຍທົ່ວໄປເພື່ອເລັ່ງການອ່ານ / ຂຽນ, ການດໍາເນີນງານເຫຼົ່ານີ້ແມ່ນດໍາເນີນຢູ່ໃນກະທູ້ທີ່ເກີດຈາກຂະບວນການ "ການດໍາເນີນງານ". ຈໍານວນຂອງກະທູ້ແມ່ນປົກກະຕິແລ້ວເທົ່າກັບຈໍານວນຂອງໄຟລ໌ເປີດ. ວຽກງານອ່ານ / ຂຽນຈາກລູກຄ້າຖືກສົ່ງໄປຫາຄິວທົ່ວໄປແລະກະທູ້ຟຣີທໍາອິດເອົາວຽກງານຈາກຫົວຂອງມັນ. ເຫດຜົນພິເສດອະນຸຍາດໃຫ້ທ່ານສາມາດລົບລ້າງການດໍາເນີນການຂຽນຄືນຂໍ້ມູນໃນ RAM ຂອງເຄື່ອງແມ່ຂ່າຍ.

ຂະບວນການປະຕິບັດງານຕິດຕາມກິດຈະກໍາຂອງລູກຄ້າແລະຢຸດໃຫ້ບໍລິການພວກເຂົາຕາມຄໍາສັ່ງຂອງພວກເຂົາຫຼືເມື່ອຫມົດເວລາທີ່ບໍ່ມີການເຄື່ອນໄຫວ.

ເພື່ອຮັບປະກັນຄວາມຫນ້າເຊື່ອຖື, Cageserver ຮັກສາບັນທຶກການເຮັດທຸລະກໍາທັງຫມົດ. ບັນທຶກທົ່ວໄປອັນໜຶ່ງມີສຳເນົາຂໍ້ຄວາມຈາກລູກຄ້າທີ່ມີໜ້າວຽກເພື່ອສ້າງ/ເປີດ/ປ່ຽນຊື່/ລຶບໄຟລ໌. ບັນທຶກແຍກຕ່າງຫາກແມ່ນຖືກສ້າງຂຶ້ນສໍາລັບແຕ່ລະໄຟລ໌ທີ່ເຮັດວຽກ, ເຊິ່ງສໍາເນົາຂອງຂໍ້ຄວາມທີ່ມີຫນ້າວຽກສໍາລັບການອ່ານແລະຂຽນຂໍ້ມູນໃນໄຟລ໌ການເຮັດວຽກນີ້ຖືກບັນທຶກ, ເຊັ່ນດຽວກັນກັບ arrays ຂອງຂໍ້ມູນລາຍລັກອັກສອນ (ໃຫມ່) ແລະ array ຂອງຂໍ້ມູນທີ່ຖືກທໍາລາຍໃນລະຫວ່າງການຂຽນທັບ (ຂຽນ. ຂໍ້ມູນໃໝ່ “ຢູ່ເທິງສຸດ” ຂອງອັນເກົ່າ).

ບັນທຶກເຫຼົ່ານີ້ສະຫນອງຄວາມສາມາດໃນການທັງສອງຟື້ນຟູການປ່ຽນແປງໃຫມ່ໃນການສໍາຮອງແລະ rollback ເນື້ອໃນປະຈຸບັນກັບຄືນໄປບ່ອນຈຸດໃນອະດີດ.

Cageserver ແມ່ນປະມານ 3100 ເສັ້ນຂອງລະຫັດ.

ການເປີດຕົວໂປຣແກຣມເຊີບເວີໄຟລ໌ Cageserver

ເມື່ອເລີ່ມຕົ້ນ, ໃນກ່ອງໂຕ້ຕອບທ່ານຕ້ອງການກໍານົດ:
— ທ່າເຮືອຫຼັກສໍາລັບການອະນຸຍາດ;
— ຈໍາ​ນວນ​ຂອງ​ພອດ​ສໍາ​ລັບ​ການ​ແລກ​ປ່ຽນ​ການ​ເຮັດ​ທຸ​ລະ​ກໍາ​ກັບ​ລູກ​ຄ້າ​ອະ​ນຸ​ຍາດ (ຈາກ 1 ຫຼື​ຫຼາຍ​ກວ່າ​, ສະ​ນຸກ​ເກີ​ຂອງ​ຕົວ​ເລກ​ເລີ່ມ​ຕົ້ນ​ຈາກ​ຫນຶ່ງ​ຕໍ່​ກັບ​ຈໍາ​ນວນ​ພອດ​ຕົ້ນ​ຕໍ​)​.

ການນໍາໃຊ້ Cage Class

ລະດັບ ຄອກ.cage( cage_name="", pagesize=0, numpages=0, maxstrlen=0, server_ip={}, wait=0, awake=False, cache_file="" )

ວັດຖຸຖືກສ້າງມາຈາກຊັ້ນຮຽນນີ້ທີ່ພົວພັນກັບເຄື່ອງແມ່ຂ່າຍຂອງໄຟລ໌ແລະມີຫນ່ວຍຄວາມຈໍາ buffer.

ຕົວກໍານົດການ

• cage_name(str) - ຊື່ຕາມເງື່ອນໄຂຂອງວັດຖຸ, ເຊິ່ງຖືກນໍາໃຊ້ເພື່ອກໍານົດລູກຄ້າໃນດ້ານເຊີຟເວີ
• ຂະໜາດໜ້າ(int) — ຂະ​ຫນາດ​ຂອງ​ຫນຶ່ງ​ຫນ້າ​ຂອງ​ຄວາມ​ຊົງ​ຈໍາ buffer (ໃນ bytes​)
• ຕົວເລກ(int) — ຈໍາ​ນວນ​ຂອງ​ຫນ້າ​ຄວາມ​ຊົງ​ຈໍາ buffer​
• maxstrlen(int) - ຄວາມຍາວສູງສຸດຂອງສະຕຣິງ byte ໃນການດໍາເນີນການຂຽນ ແລະອ່ານ
• server_ip(ຂຽນ ຄຳ ສັ່ງ) - ວັດຈະນານຸກົມທີ່ມີທີ່ຢູ່ຂອງເຊີບເວີທີ່ໃຊ້, ເຊິ່ງກະແຈແມ່ນຊື່ຕາມເງື່ອນໄຂຂອງເຊີບເວີ (ລະຫັດເຊີບເວີພາຍໃນແອັບພລິເຄຊັນ), ແລະຄ່າແມ່ນສະຕຣິງທີ່ມີທີ່ຢູ່: “ip address:port” ຫຼື “DNS: port” (ການປຽບທຽບຊື່ແລະທີ່ຢູ່ທີ່ແທ້ຈິງແມ່ນຊົ່ວຄາວ, ມັນສາມາດປ່ຽນແປງໄດ້)
• ລໍຖ້າ(int) — ເວ​ລາ​ລໍ​ຖ້າ​ສໍາ​ລັບ​ການ​ຕອບ​ສະ​ຫນອງ​ຈາກ​ເຄື່ອງ​ແມ່​ຂ່າຍ​ໃນ​ເວ​ລາ​ທີ່​ໄດ້​ຮັບ​ພອດ (ໃນ​ວິ​ນາ​ທີ​)
• ປຸກ(ປຸ້ຍ) - ທຸງຂອງວິທີການສ້າງວັດຖຸ (ທີ່ບໍ່ຖືກຕ້ອງ - ຖ້າ​ຫາກ​ວ່າ​ວັດ​ຖຸ​ໃຫມ່​ໄດ້​ຖືກ​ສ້າງ​ຕັ້ງ​ຂື້ນ​, ທີ່ແທ້ຈິງ - ຖ້າ​ຫາກ​ວ່າ​ວັດ​ຖຸ​ທີ່​ໄດ້​ຖືກ​ສ້າງ​ຕັ້ງ​ຂຶ້ນ​ຈາກ​ທີ່​ຜ່ານ​ມາ "ພັງ​ລົງ​" ຫນຶ່ງ - ການ​ນໍາ​ໃຊ້​ການ "hibernation​" ການ​ດໍາ​ເນີນ​ງານ​, ຜິດ​ໂດຍ​ຄ່າ​ເລີ່ມ​ຕົ້ນ​)
• cache_file(str) - ຊື່ໄຟລ໌ສໍາລັບການ hibernation

ວິທີການ

ຄອກ.file_create( server, ເສັ້ນທາງ ) - ສ້າງໄຟລ໌ໃຫມ່

ຄອກ.file_rename( ເຊີບເວີ, ເສັ້ນທາງ, new_name ) - ປ່ຽນຊື່ໄຟລ໌

ຄອກ.file_remove( server, ເສັ້ນທາງ) - ລຶບ​ໄຟລ​໌​

ຄອກ.ເປີດ( ເຄື່ອງແມ່ຂ່າຍ, ເສັ້ນທາງ, mod ) - ເປີດໄຟລ໌

ກັບມາ fchannel ໝາຍເລກຊ່ອງ. ພາລາມິເຕີ ຕ້ານ - ນີ້ແມ່ນຮູບແບບການເປີດໄຟລ໌: "wm" - ສະເພາະ (ອ່ານ / ຂຽນ), "rs" - ອ່ານເທົ່ານັ້ນ, ແລະແບ່ງປັນພຽງແຕ່ສໍາລັບການອ່ານໂດຍລູກຄ້າອື່ນໆ, "ws" - ອ່ານ / ຂຽນ, ແລະແບ່ງປັນພຽງແຕ່ສໍາລັບການອ່ານໂດຍ ລູກຄ້າອື່ນໆ.

ຄອກ.ໃກ້ (fchannel) - ປິດ​ໄຟລ​໌​

ຄອກ.ຂຽນ (fchannel, ເລີ່ມຕົ້ນ, ຂໍ້ມູນ ) - ຂຽນສະຕຣິງ byte ໃສ່ໄຟລ໌

ຄອກ.ອ່ານ (fchannel, ເລີ່ມຕົ້ນ, len_data ) - ອ່ານສະຕຣິງ byte ຈາກໄຟລ໌

ຄອກ.put_pages ( fchannel ) – “ກົດດັນ” ຈາກ buffer ໄປຫາເຊີບເວີທຸກໜ້າຂອງຊ່ອງທີ່ລະບຸນັ້ນໄດ້ຖືກດັດແກ້. ມັນຖືກນໍາໃຊ້ຢູ່ໃນຈຸດເຫຼົ່ານັ້ນໃນ algorithm ໃນເວລາທີ່ທ່ານຕ້ອງການໃຫ້ແນ່ໃຈວ່າການດໍາເນີນການທັງຫມົດໃນຊ່ອງໄດ້ຖືກບັນທຶກໄວ້ທາງດ້ານຮ່າງກາຍຢູ່ໃນໄຟລ໌ໃນເຄື່ອງແມ່ຂ່າຍ.

ຄອກ.push_all () – “ກົດດັນ” ຈາກ buffer ໄປຫາເຊີບເວີທຸກໜ້າຂອງທຸກຊ່ອງສຳລັບຕົວຢ່າງຂອງຊັ້ນ Cage ທີ່ໄດ້ຖືກດັດແກ້. ໃຊ້ໃນເວລາທີ່ທ່ານຕ້ອງການໃຫ້ແນ່ໃຈວ່າການດໍາເນີນການທັງຫມົດໃນທຸກຊ່ອງທາງຖືກບັນທຶກໄວ້ໃນເຄື່ອງແມ່ຂ່າຍ.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com