ការធ្វើសមកាលកម្មពេញលេញនៃថតដែលបានចែករំលែក ទំនាក់ទំនង ប្រតិទិនរវាងម៉ាស៊ីនមេ Kerio Connect ដែលបានចែកចាយ

អរុណសួស្តី ហាប!

គោលបំណង

ស្ថាប័នរបស់ខ្ញុំប្រើម៉ាស៊ីនមេសំបុត្រនៅលើវេទិកា Kerio Connect ម៉ាស៊ីនមេសំបុត្រត្រូវបានដំឡើងនៅក្នុងទីក្រុងផ្សេងៗគ្នា ដើម្បីបម្រើអ្នកប្រើប្រាស់របស់ពួកគេ។ ដំបូងមិនមានរចនាសម្ព័ន្ធចែកចាយទេ ដោយសារដែនខុសគ្នានៅកម្រិតទីបី ដែលបង្ហាញពីទីក្រុងនៃគេហទំព័រ។ អ្វីគ្រប់យ៉ាងបានដំណើរការហើយមនុស្សគ្រប់គ្នាសប្បាយចិត្ត។ មួយថ្ងៃល្អ អ្នកគ្រប់គ្រងកំណត់ភារកិច្ច ប្រតិទិនសកម្មភាពទូទៅរវាងគេហទំព័រទាំងអស់!

សម័យបុរេប្រវត្តិសាស្ត្រ

ដំបូង គំនិតនេះគឺដើម្បីបង្កើន Kerio Distributed Mail Domain ហើយវានឹងធ្វើអ្វីគ្រប់យ៉ាងដោយខ្លួនឯង។ មិនយូរមិនឆាប់បាននិយាយថា ដែនដែលបានចែកចាយត្រូវបានបង្កើត ប៉ុន្តែនោះមិនមែនជាករណីនោះទេ ម៉ាស៊ីនមេបានត្រៀមខ្លួនជាស្រេចដើម្បីធ្វើសមកាលកម្មប្រតិទិន ថតឯកសារ ទំនាក់ទំនង - រវាងដែនដែលមានទីតាំងនៅលើម៉ាស៊ីនមេតែមួយ ប៉ុន្តែមិនមែនទាល់តែសោះនឹងធ្វើសមកាលកម្មទិន្នន័យរវាងជាច្រើន ម៉ាស៊ីនមេ។

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

កិច្ចការបានរលូនក្លាយជាបញ្ហា។

តើមានជម្រើសអ្វីខ្លះ?

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

សម្លឹងទៅមុខ ខ្ញុំនឹងនិយាយថា ទោះបីជា Kerio រក្សាទុកវត្ថុមួយជាឯកសារដាច់ដោយឡែកក៏ដោយ វាមិនល្ងង់ទេក្នុងការសួរថាតើប្រព័ន្ធឯកសារកំពុងធ្វើអ្វីរាល់ពេលដែលអ្នកចូលប្រើវត្ថុនោះ។

ដោយបានចំណាយពេលគិតច្រើន គូរក្រដាសមួយដុំជាមួយនឹងផែនការ "ដណ្តើមយកទឹកដីសត្រូវ" នៅម៉ោង 6 ព្រឹក ខ្ញុំបានធ្វើការសម្រេចចិត្តត្រឹមត្រូវចំនួនពីរ៖

• ការ​សម្រេច​ចិត្ត​ដំបូង​គឺ​ធ្វើ​រឿង​របស់​ខ្លួន​ឯង ហើយ​មិន​ស្វែង​រក​អ្វី​ពី​ខាង​ក្រៅ។
• ដំណោះស្រាយទីពីរគឺចូលគេង។

ព្រឹកឡើងខ្ញុំភ្ញាក់ឡើងជាមួយនឹងគំនិតតែមួយ និងពិត ដែលត្រូវបានកាត់បន្ថយមកត្រឹមអក្សរពីរបី - DFS

ការសម្រេចចិត្ត

ដំណោះស្រាយខ្លួនឯងមើលទៅដូចនេះ

• នាំយកម៉ាស៊ីនមេទាំងអស់ដែលនឹងចូលរួមក្នុងការធ្វើសមកាលកម្មទៅ OS Windows ។ (ផ្នែកមួយនៃវាគឺនៅលើលីនុច។ ការផ្ទេរទិន្នន័យសំបុត្រទៅ OS ផ្សេងទៀតគឺត្រូវបានទាមទារ)
• កំណត់រចនាសម្ព័ន្ធនៃថតដែលនឹងចូលរួមក្នុងការធ្វើសមកាលកម្ម - ពួកគេត្រូវតែដូចគ្នាបេះបិទ។
• កំណត់ម៉ាស៊ីនមេសំបុត្រទាំងអស់នៅក្រោមដែនតែមួយជាមួយនឹងទំហំ DFS តែមួយ។
• បង្កើតដែន Kerio ដែលបានចែកចាយដែលបានរៀបរាប់ខាងលើ ចាប់តាំងពីក្នុងករណីរបស់ខ្ញុំការធ្វើសមកាលកម្មទិន្នន័យត្រូវបានទាមទារ មិនត្រឹមតែរវាងម៉ាស៊ីនមេប៉ុណ្ណោះទេ ប៉ុន្តែក៏រវាងដែនផងដែរ ទីពីរអាចត្រូវបានគ្រប់គ្រងដោយម៉ាស៊ីនមេ Kerio ដោយឯករាជ្យ។ (មិនដូចលើកទីមួយ)
• កំណត់ថតដែលបានធ្វើសមកាលកម្មទៅចន្លោះ DFS ។
• មកជាមួយឈើច្រត់មួយចំនួន (បន្ទាប់ពីទាំងអស់ អ្នកមិនអាចរស់នៅដោយគ្មានឈើច្រត់បានទេ)

Реализация

ឧទាហរណ៍​នៅ​លើ​ម៉ាស៊ីន​បម្រើ​សំបុត្រ​ពីរ (ប្រហែល​ជា​ច្រើន​ទៀត)

1. ដែនចែកចាយ Kerio

អនុបណ្ឌិតមិនចូលរួមក្នុងការធ្វើសមកាលកម្មទេ ប៉ុន្តែនេះមិនមែនជាតម្រូវការជាមុនទេ។

ខ្ញុំនឹងមិនរៀបរាប់ពីរបៀបបង្កើនដែនចែកចាយ Kerio ទេ មិនមានអ្វីស្មុគស្មាញអំពីវាទេ អ្នកអាចសិក្សាផ្លូវការ សៀវភៅដៃ

នៅទីបំផុត អ្នកគួរតែឃើញរូបភាពខាងក្រោមនៅក្នុងកុងសូលរដ្ឋបាល៖

បន្ទាប់​មក ខ្ញុំ​ចាប់​អារម្មណ៍​លើ​ថត​ដែល​បាន​ចែក​រំលែក; នៅ​លើ Master server អ្នក​អាច​បញ្ជាក់​ជម្រើស​ដូច​ខាង​ក្រោម៖

ជាក់លាក់សម្រាប់ដែននីមួយៗ - ម៉ាស៊ីនមេនឹងមិនធ្វើសមកាលកម្មថតសាធារណៈរវាងដែនទេ។

ទូទៅចំពោះដែនទាំងអស់។ - ម៉ាស៊ីនមេទាំងអស់នឹងបោះបង់ចោលថតសាធារណៈដែលមានស្រាប់នៅក្នុងដែននីមួយៗ ហើយបង្កើតថតតែមួយថ្មីសម្រាប់ដែនទាំងអស់នៅលើម៉ាស៊ីនមេសំបុត្រនីមួយៗ។

សូមប្រយ័ត្ន! ទោះបីជាជម្រើសនេះផ្លាស់ប្តូរគោលការណ៍កំណត់រចនាសម្ព័ន្ធនៅលើម៉ាស៊ីនមេទាំងអស់ក៏ដោយ ក៏វាធ្វើសមកាលកម្មដាច់ដោយឡែកពីម៉ាស៊ីនមេនីមួយៗ (នោះគឺដោយគ្មានចន្លោះរួមតែមួយ)

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

2. ថតទិន្នន័យ Kerio

ឥឡូវអ្នកត្រូវបង្កើតថតដែលបានចែករំលែកដូចគ្នាបេះបិទ ដែលត្រូវធ្វើសមកាលកម្មនៅលើម៉ាស៊ីនមេនីមួយៗ។ ថតឯកសារ ប្រតិទិន ទំនាក់ទំនង។

ដំបូន្មាន - បង្កើតថតជាភាសាអង់គ្លេស ប្រសិនបើអ្នកបង្កើតពួកវាជាភាសាឡាតាំង ថតនឹងមានឈ្មោះមួយនៅក្នុងការអ៊ិនកូដដែលមិនអាចយល់បាន នេះយ៉ាងហោចណាស់មានការរអាក់រអួល។

ឥឡូវអ្នកត្រូវស្វែងរកផ្លូវជាក់ស្តែងនៃថតសំបុត្រនៅលើម៉ាស៊ីនមេនីមួយៗ។

ទូទៅចំពោះដែនទាំងអស់។ ~DataMailmail#publicСинхронизируемый каталог#msgs
ជាក់លាក់សម្រាប់ដែននីមួយៗ ~DataMailmail**Domain**#publicСинхронизируемый каталог#msgs

សូមចំណាំថាយើងនឹងមិនធ្វើសមកាលកម្មថតទាំងមូលនោះទេប៉ុន្តែមានតែកុងតឺន័រដែលមានទិន្នន័យប៉ុណ្ណោះ។ #សារ - វត្ថុខ្លួនឯងត្រូវបានរក្សាទុកនៅទីនេះ ទិន្នន័យផ្សេងទៀតទាំងអស់ត្រូវតែដាច់ដោយឡែកសម្រាប់ម៉ាស៊ីនមេនីមួយៗ។

3.DFS

ខ្ញុំនឹងមិនពិពណ៌នាលម្អិតអំពីរបៀបកំណត់ DFS ទេ មានព័ត៌មានគ្រប់គ្រាន់អំពីបញ្ហានេះ។

DFS គឺជាសេវាកម្មតួនាទីមួយនៅក្នុង Windows Server ដែលផ្តល់នូវសមត្ថភាពក្នុងការរួមបញ្ចូលគ្នានូវ folders ដែលមានទីតាំងនៅលើ servers ផ្សេងៗគ្នា
ភ្ជាប់ទៅឯកសារ MS DFS

មុនពេលដំឡើង DFS អ្នកត្រូវតែបញ្ឈប់ម៉ាស៊ីនមេសំបុត្រទាំងអស់ដែលនឹងចូលរួមក្នុងការធ្វើសមកាលកម្មទិន្នន័យ។

នៅពេលបញ្ចប់ការដំឡើង អ្នកគួរតែទទួលបានរូបភាពខាងក្រោមសម្រាប់ថតដែលធ្វើសមកាលកម្មនីមួយៗ

តាមធម្មជាតិ យើងមិនចាំបាច់បោះផ្សាយថតចម្លងទេ។

បន្ទាប់​ពី​ការ​ចម្លង​កើត​ឡើង (ហើយ​មិន​មាន​អ្វី​ពិសេស​ក្នុង​ការ​ចម្លង​នៅ​ទីនោះ​ទេ - ថត​គឺ​ទទេ) ម៉ាស៊ីន​បម្រើ​សំបុត្រ​អាច​ត្រូវ​បាន​ចាប់ផ្ដើម។

បន្ទាប់​មក អ្នក​អាច​បំពេញ​ទិន្នន័យ​មួយ​ក្នុង​ចំណោម​ម៉ាស៊ីន​បម្រើ​សំបុត្រ ហើយ​ពិនិត្យ​មើល​ថា​ទិន្នន័យ​ត្រូវ​បាន​ចម្លង​យ៉ាង​ត្រឹម​ត្រូវ។

4. ឈើច្រត់

ការពិពណ៌នាអំពីការឆ្លុះបញ្ចាំង

ដូចដែលអ្នកអាចឃើញបន្ទាប់ពីទិន្នន័យចាប់ផ្តើមធ្វើសមកាលកម្ម (DFS) ប្រសិនបើអ្នកបានបង្កើតអ្វីមួយនៅលើម៉ាស៊ីនមេដំបូង គ្មានអ្វីលេចឡើងនៅលើម៉ាស៊ីនមេទីពីរ ឬវាលេចឡើង ប៉ុន្តែមិនតែងតែទេ។

កុំអស់សង្ឃឹម ជាការពិត វានឹងបង្ហាញនៅទីនោះឆាប់ៗ ឬយូរជាងនេះ ប៉ុន្តែប្រសើរជាងពេលក្រោយ។ ព្រោះ​វា​យឺត​ពេល​៦​ទៅ​១២​ម៉ោង។

រឿងនេះគឺថា នៅពេលដែលអ្នកបានបង្កើតអ្វីមួយនៅលើម៉ាស៊ីនមេទីមួយ ហើយនៅលើម៉ាស៊ីនមេទីពីរ និងជាបន្តបន្ទាប់ ឯកសារនឹងលេចឡើងភ្លាមៗដោយសារប្រព័ន្ធ DFS ប៉ុន្តែក្នុងករណីដែលថតសំបុត្រនេះត្រូវបានអានរួចហើយដោយនរណាម្នាក់ពីមុន។ ហើយត្រូវបានស្នើសុំម្តងទៀត នោះម៉ាស៊ីនមេនឹងមិនអានថត #msgs ឡើងវិញទេ ប៉ុន្តែនឹងបញ្ចេញទិន្នន័យចេញពីលិបិក្រមផ្ទាល់របស់វា ដែលអាចនឹងមិនឆ្លើយតបទៅនឹងការពិតរបស់យើងទៀតទេ។

Kerio មានយន្តការសម្រាប់អានលិបិក្រមឡើងវិញ ប៉ុន្តែវាអាចដំណើរការបានក្នុងរយៈពេលប្រហែល 6 ម៉ោង ហើយក្នុងអំឡុងពេល XNUMX ម៉ោងនេះ ភាពពាក់ព័ន្ធនៃកិច្ចការនៅក្នុងប្រតិទិនអាចនឹងបាត់បង់ខ្លះ។
ដើម្បីសាកល្បងការធ្វើសមកាលកម្មឥឡូវនេះ អ្នកអាចលុបឯកសារនៅក្នុងថតដែលធ្វើសមកាលកម្មដែលត្រូវគ្នា index.fld បន្ទាប់ពីចូលប្រើថតម្តងទៀតនៅលើម៉ាស៊ីនមេ ហើយប្រសិនបើឯកសារនេះបាត់ Kerio នឹងអានថត និងទិន្នន័យឡើងវិញ។ នឹង​លិច​ឡើង។ វាហាក់ដូចជាថានេះគឺជាដំណោះស្រាយ លុបឯកសារនៅពេលដែលទិន្នន័យផ្លាស់ប្តូរ ប៉ុន្តែវាមិនដំណើរការរាល់ពេលនោះទេ ប៉ុន្តែមានតែលើកទីមួយប៉ុណ្ណោះ បន្ទាប់មក Kerio ដោយហេតុផលមួយចំនួនបាត់បង់ចំណាប់អារម្មណ៍ទាំងអស់នៅក្នុង index.fld
វាក៏ចាប់ផ្តើមបញ្ចេញសារដែលមិនអាចយល់បានចំពោះអ្នកប្រើប្រាស់ - អំពីប្រភេទនៃលិបិក្រមមួយចំនួន ហើយថាវាកំពុងធ្វើអ្វីមួយនៅទីនោះរួចហើយ។

មានជម្រើសមួយផ្សេងទៀតដើម្បីបង្កើតអ្វីមួយ - នៅពេលបង្កើតវត្ថុថ្មី ម៉ាស៊ីនមេស្រាប់តែដឹងថាឈ្មោះឯកសារដែលខ្លួនចង់កំណត់ត្រូវបានយករួចហើយ ប៉ុន្តែវាធ្លាក់ព្រិល ហើយនេះគឺជាជម្រើសចុងក្រោយ។

តើធ្វើដូចម្តេចដើម្បីឱ្យមាន?

ប្រសិនបើយើងយកចិត្តទុកដាក់ម្តងទៀតចំពោះរូបភាពដែលធ្លាប់ស្គាល់យើងរួចហើយ។

ប៉ុន្តែនៅលើយន្តហោះមួយផ្សេងទៀត អ្នកអាចមើលឃើញប៊ូតុងគួរឱ្យចាប់អារម្មណ៍មួយដែលយើងត្រូវការឥឡូវនេះ - ធ្វើលិបិក្រមថតឯកសារឡើងវិញ

ហើយជាការពិត។ ប្រសិនបើ​យើង​ចុច​លើ​ប៊ូតុង​នេះ​លើ​ម៉ាស៊ីន​មេ​សំបុត្រ​ដែល​មិន​ដឹង​ថា​មាន​អ្វី​មួយ​បាន​ផ្លាស់​ប្តូរ​នៅ​ក្នុង #msgs ដែល​បាន​ធ្វើ​សមកាលកម្ម​នោះ យើង​នឹង​ទទួល​បាន​លទ្ធផល​មាន​ស្ថិរភាព និង​លឿន។ អ្វីគ្រប់យ៉ាងដែលលាក់នឹងច្បាស់។

នៅក្នុងកំណត់ហេតុអ្នកអាចមើលឃើញថាតើដំណើរការនេះចំណាយពេលប៉ុន្មាន; ក្នុងករណីរបស់ខ្ញុំជាមួយនឹងកំណត់ត្រារាប់ពាន់ (15 ពាន់) វាត្រូវចំណាយពេលប្រហែល 3-4 នាទី។

អ្វីទាំងអស់ដែលយើងត្រូវធ្វើគឺស្វែងយល់ពីរបៀបចុចប៊ូតុងនេះនៅពេលដែលយើងត្រូវការវា។

វាប្រែចេញ ខេរីយ៉ូ មានរបស់ខ្លួន។ ការ API

បរិយាយ
ឯកសារ

មុខងារដែលបំពេញភារកិច្ចរបស់យើងមើលទៅដូចនេះ៖
session = callMethod("Domains.checkPublicFoldersIntegrity",{}, token)

ពីចំណុចទាំងអស់ខាងលើ យើងត្រូវសរសេរស្គ្រីបដែលនឹងត្រួតពិនិត្យស្ថានភាពនៃថតដែលចាប់អារម្មណ៍ ហើយប្រសិនបើមានអ្វីផ្លាស់ប្តូរ សូមអនុវត្តមុខងារដែលយើងត្រូវការ។

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

ការអនុវត្តស្គ្រីប

ឧទាហរណ៍ និងការពិពណ៌នាអំពីស្គ្រីប CMD

ឡើងវិញ index.bat

@echo off
set dir=%~dp0
%dir:~0,2%
CD "%~dp0"
md "%CD%LOG"
md "%CD%Setup"

ECHO -Start- >> "%CD%LOG%Computername%.log"
ECHO Start -> %Computername% %Date% %Time% >> "%CD%LOG%Computername%.log"

SetLocal EnableDelayedExpansion
for /f "UseBackQ Delims=" %%A IN ("%CD%Setup%Computername%.List") do (
  set /a c+=1
  set "m!c!=%%A"
)

set d=%c%
Echo Folder = %c%
ECHO Folder = %c% >> "%CD%LOG%Computername%.log"
ECHO.
ECHO. >> "%CD%LOG%Computername%.log"

:start
cls
if %c% LSS 1 exit
set /a id=1
set R=0

:Find
REM PF-Start
if "%id%" gtr "%c%" if %R% == 1 Goto Reindex 
if "%id%" gtr "%c%" timeout 60 && Goto start

For /F "tokens=1-3" %%a IN ('Dir "!m%id%!#msgs" /-C/S/A:-D') Do Set 2DirSize!id!=!DS!& Set DS=%%c
if "2DirSize!id!" == "" set 1DirSize!id!=!2DirSize%id%!

echo %id%
ECHO !m%id%!
echo Count        [ !1DirSize%id%! -- !2DirSize%id%! ]

if "!1DirSize%id%!" == "!2DirSize%id%!" ECHO Synk

REM DEL index.fld
if "!1DirSize%id%!" NEQ "!2DirSize%id%!" del /f /q !m%id%!index.fld && del /f /q !m%id%!indexlog.fld && del /f /q !m%id%!search.fld && set R=1 && ECHO RE-index Count && ECHO RE-index Count %Date% %Time% - Delete !m%id%! >> "%CD%LOG%Computername%.log"

set 1DirSize!id!=!2DirSize%id%!

ECHO.
ECHO.

set /a id+=1
goto Find

:Reindex
ECHO. >> "%CD%LOG%Computername%.log"
ECHO --- RE-INDEX - Start - %Date% %Time% --- >> "%CD%LOG%Computername%.log"
ECHO. >> ----------------------------------- >> "%CD%LOG%Computername%.log"
call PublicFolders.py
timeout 60
goto start

exit

ច្បាប់ចម្លងនៃស្គ្រីបដំណើរការលើម៉ាស៊ីនមេសំបុត្រនីមួយៗ (អាចប្រើជាសេវាកម្ម សិទ្ធិ Adm មិនត្រូវបានទាមទារ)

ស្គ្រីបអានឯកសារ Setup%Computername%.List

ដែល %Computername% ជាឈ្មោះរបស់ម៉ាស៊ីនមេបច្ចុប្បន្ន (ថតអាចផ្ទុកបញ្ជីនៃម៉ាស៊ីនមេទាំងអស់ក្នុងពេលតែមួយ។ )

ឯកសារ %Computername%.List – មានផ្លូវពេញលេញនៃថតដែលបានធ្វើសមកាលកម្ម ផ្លូវនីមួយៗត្រូវបានសរសេរនៅលើបន្ទាត់ថ្មី ហើយមិនគួរមានបន្ទាត់ទទេទេ។

បន្ទាប់ពីការបើកដំណើរការលើកដំបូង ស្គ្រីបអនុវត្តនីតិវិធីបង្កើតលិបិក្រម ដោយមិនគិតពីថាតើវាចាំបាច់ឬអត់ ហើយស្គ្រីបក៏បង្កើតលិបិក្រមនៃចំនួនឯកសារនៅក្នុងថតដែលធ្វើសមកាលកម្មនីមួយៗផងដែរ។

គោលបំណងនៃស្គ្រីបគឺដើម្បីរាប់ឯកសារទាំងអស់នៅក្នុងថតដែលបានបញ្ជាក់។

នៅចុងបញ្ចប់នៃការរាប់ថតនីមួយៗ ប្រសិនបើយ៉ាងហោចណាស់ក្នុងថតមួយតម្លៃបច្ចុប្បន្ននៃឯកសារមិនត្រូវគ្នានឹងឯកសារមុននោះ ស្គ្រីបនឹងលុបឯកសារចេញពីថត root នៃថតសំបុត្រដែលបានធ្វើសមកាលកម្ម៖ index.fld, indexlog.fld, search.fld ហើយចាប់ផ្តើមដំណើរការបង្កើតលិបិក្រមនៃថតសំបុត្រដែលបានចែករំលែក។

ព័ត៌មានអំពីការប្រតិបត្តិភារកិច្ចត្រូវបានបោះចោលទៅក្នុងថតឯកសារ។

ដំណើរការសន្ទស្សន៍
ដំណើរការធ្វើលិបិក្រមចុះមកដើម្បីប្រតិបត្តិមុខងារ Kerio API
វគ្គ = callMethod("Domains.checkPublicFoldersIntegrity",{}, token)

ការអនុវត្តឧទាហរណ៍ត្រូវបានផ្តល់ឱ្យនៅក្នុង - python
PublicFolders.py

import json
import urllib.request
import http.cookiejar
""" Cookie storage is necessary for session handling """
jar = http.cookiejar.CookieJar()
opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(jar))
urllib.request.install_opener(opener)
""" Hostname or ip address of your Kerio Control instance with protocol, port and credentials """

server = "http://127.0.0.1:4040"
username = "user"
password = "password"

def callMethod(method, params, token = None):
    """
    Remotely calls given method with given params.
    :param: method string with fully qualified method name
    :param: params dict with parameters of remotely called method
    :param: token CSRF token is always required except login method. Use method "Session.login" to obtain this token.
    """
    data =  {"method": method ,"id":1, "jsonrpc":"2.0", "params": params}

    req = urllib.request.Request(url = server + '/admin/api/jsonrpc/')
    req.add_header('Content-Type', 'application/json')
    if (token is not None):
        req.add_header('X-Token', token)    

    httpResponse = urllib.request.urlopen(req, json.dumps(data).encode())

    if (httpResponse.status == 200):
        body = httpResponse.read().decode()
        return json.loads(body)

session = callMethod("Session.login", {"userName":username, "password":password, "application":{"vendor":"Kerio", "name":"Control Api-Local", "version":"Python"}})
token = session["result"]["token"]
print (session)

session = callMethod("Domains.checkPublicFoldersIntegrity",{"domainId": "test2.local"}, token)
print (session)

callMethod("Session.logout",{}, token)

http://127.0.0.1:4040 អ្នកអាចទុកវាឱ្យនៅដដែល ប៉ុន្តែប្រសិនបើអ្នកត្រូវការ HTTPS នោះ python ត្រូវតែជឿជាក់លើវិញ្ញាបនបត្រ Kerio។

ផងដែរនៅក្នុងឯកសារអ្នកត្រូវតែបញ្ជាក់គណនីដែលមានសិទ្ធិដើម្បីអនុវត្តមុខងារនេះ (Adm - ថតសំបុត្រសាធារណៈ) នៃម៉ាស៊ីនមេសំបុត្រ។

ខ្ញុំសង្ឃឹមថាអត្ថបទរបស់ខ្ញុំនឹងមានប្រយោជន៍ចំពោះអ្នកគ្រប់គ្រង Kerio Connect ។

ប្រភព: www.habr.com