పంపిణీ చేయబడిన Kerio కనెక్ట్ సర్వర్‌ల మధ్య భాగస్వామ్య ఫోల్డర్‌లు, పరిచయాలు, క్యాలెండర్‌ల పూర్తి సమకాలీకరణ

శుభ మధ్యాహ్నం, హబ్ర్!

పని

నా సంస్థ Kerio Connect ప్లాట్‌ఫారమ్‌లో మెయిల్ సర్వర్‌ను ఉపయోగిస్తుంది; మెయిల్ సర్వర్‌లు వారి వినియోగదారులకు సేవ చేయడానికి వివిధ నగరాల్లో ఇన్‌స్టాల్ చేయబడ్డాయి. ప్రారంభంలో పంపిణీ చేయబడిన నిర్మాణం లేదు, ఎందుకంటే డొమైన్‌లు మూడవ స్థాయిలో విభిన్నంగా ఉంటాయి, ఇది సైట్ యొక్క నగరాన్ని సూచిస్తుంది. అంతా పనిచేసింది మరియు అందరూ సంతోషంగా ఉన్నారు. ఒక మంచి రోజు, నిర్వహణ ఒక విధిని సెట్ చేసింది, అన్ని సైట్‌ల మధ్య కార్యకలాపాల యొక్క సాధారణ క్యాలెండర్!

పూర్వచరిత్ర

మొదట్లో, Kerio డిస్ట్రిబ్యూటెడ్ మెయిల్ డొమైన్‌ను పెంచాలనే ఆలోచన ఉంది మరియు ఇది ప్రతిదీ స్వయంగా చేస్తుంది. పూర్తి కాకుండానే, పంపిణీ చేయబడిన డొమైన్ సృష్టించబడింది, కానీ అది అలా కాదు, ఒకే సర్వర్‌లో ఉన్న డొమైన్‌ల మధ్య క్యాలెండర్‌లు, ఫోల్డర్‌లు, కాంటాక్ట్‌లను సమకాలీకరించడానికి సర్వర్ సిద్ధంగా ఉంది, కానీ అనేక వాటి మధ్య డేటాను సింక్రొనైజ్ చేయడం లేదు. సర్వర్లు.

నేను, వాస్తవానికి, అలాంటి క్యాచ్‌ను ఆశించలేదు మరియు నాకు అవసరమైన కార్యాచరణ తప్పిపోయిందని చాలా కాలంగా నమ్మలేకపోయాను. తరువాత నేను ఈ వాస్తవానికి సంబంధించిన డాక్యుమెంటరీ సాక్ష్యాలను కనుగొన్నాను. దీనితో నేను చాలా అయోమయంలో పడ్డాను మరియు నిరాశ చెందాను.

పని సజావుగా సమస్యగా మారింది.

ఎంపికలు ఏమిటి?

• కొన్ని థర్డ్-పార్టీ సాఫ్ట్‌వేర్‌తో అవసరమైన డేటాను మార్పిడి చేసే వేర్వేరు సర్వర్‌లలో ఇద్దరు క్లయింట్‌లను సృష్టించండి. ఈ కార్యాచరణను అమలు చేసే ఈ థర్డ్-పార్టీ సాఫ్ట్‌వేర్‌ను కనుగొనడం అవసరం - అలాంటి రేక్ నాకు ఇష్టం లేదు, కానీ ఇది మాత్రమే శీఘ్ర పరిష్కారం అని అనిపించింది.
• సర్వర్‌ల మధ్య డేటా సమకాలీకరణ కోసం మీ స్వంత స్క్రిప్ట్‌ను వ్రాయండి. వాస్తవం ఏమిటంటే, కెరియో ప్రతి వస్తువును ప్రత్యేక ఫైల్‌గా నిల్వ చేస్తుంది, కాబట్టి ఫైల్‌లతో పనిచేయడానికి స్క్రిప్ట్‌ను అభివృద్ధి చేయడం అవసరం, కానీ తగినంత సంఖ్యలో మూలాల దృష్ట్యా, పని కొంత క్లిష్టంగా అనిపించింది, ప్రత్యేకించి బహుళ చేయడం అవసరం కాబట్టి. అదే సమయంలో ఎవరైనా టాస్క్‌ని సృష్టించినట్లయితే, డేటా యొక్క ఖచ్చితత్వాన్ని తనిఖీ చేస్తుంది, మొదలైనవి.

ముందుకు చూస్తే, కెరియో ఒక వస్తువును ప్రత్యేక ఫైల్‌గా నిల్వ చేసినప్పటికీ, మీరు ఆబ్జెక్ట్‌ను యాక్సెస్ చేసిన ప్రతిసారీ ఫైల్ సిస్టమ్ ఎలా పని చేస్తుందో అడగడం అంత తెలివితక్కువదని నేను చెబుతాను.

"శత్రువు భూభాగాన్ని స్వాధీనం చేసుకునేందుకు" ప్రణాళికలతో కాగితపు ముక్కల సమూహాన్ని గీస్తూ, చాలా సమయం ఆలోచించి, 6 గంటలకు నేను రెండు సరైన నిర్ణయాలు తీసుకున్నాను:

• మొదటి నిర్ణయం మీ స్వంత పనిని చేయడమే మరియు బయటి నుండి దేని కోసం వెతకకూడదు.
• రెండవ పరిష్కారం నిద్రపోవడం.

ఇప్పటికే ఉదయం నేను ఒకే మరియు నిజమైన ఆలోచనతో మేల్కొన్నాను, అది కొన్ని అక్షరాలకు తగ్గించబడింది - DFS

నిర్ణయం

పరిష్కారమే ఇలా కనిపించింది

• OS విండోస్‌కు సమకాలీకరణలో పాల్గొనే అన్ని సర్వర్‌లను తీసుకురండి. (దీనిలో కొంత భాగం Linuxలో ఉంది. మెయిల్ డేటాను మరొక OSకి మార్చడం అవసరం)
• సమకాలీకరణలో పాల్గొనే డైరెక్టరీల నిర్మాణాన్ని నిర్ణయించండి - అవి ఒకేలా ఉండాలి.
• ఒకే DFS స్పేస్‌తో ఒకే డొమైన్ కింద అన్ని మెయిల్ సర్వర్‌లను నిర్వచించండి.
• పైన పేర్కొన్న పంపిణీ చేయబడిన Kerio డొమైన్‌ను సృష్టించండి, ఎందుకంటే నా విషయంలో డేటా సమకాలీకరణ అవసరం, సర్వర్‌ల మధ్య మాత్రమే కాకుండా డొమైన్‌ల మధ్య కూడా; రెండవది Kerio సర్వర్ ద్వారా స్వతంత్రంగా నిర్వహించబడుతుంది. (మొదటిది కాకుండా)
• సమకాలీకరించబడిన డైరెక్టరీలను DFS స్పేస్‌కు సెట్ చేయండి.
• ఒకరకమైన ఊతకర్రతో రండి (అన్ని తరువాత, మీరు ఊతకర్ర లేకుండా జీవించలేరు)

అమలు

రెండు మెయిల్ సర్వర్‌లలో ఉదాహరణ (బహుశా మరిన్ని)

1. కెరియో డిస్ట్రిబ్యూటెడ్ డొమైన్

మాస్టర్ సింక్రొనైజేషన్‌లో పాల్గొనలేదు, కానీ ఇది అవసరం కాదు.

Kerio పంపిణీ చేయబడిన డొమైన్‌ను ఎలా పెంచాలో నేను వివరించను, దాని గురించి సంక్లిష్టంగా ఏమీ లేదు, మీరు అధికారికంగా అధ్యయనం చేయవచ్చు మాన్యుల్

అంతిమంగా, మీరు అడ్మినిస్ట్రేషన్ కన్సోల్‌లో క్రింది చిత్రాన్ని చూడాలి:

తర్వాత నేను భాగస్వామ్య ఫోల్డర్‌లపై ఆసక్తి కలిగి ఉన్నాను; మాస్టర్ సర్వర్‌లో మీరు ఈ క్రింది ఎంపికలను పేర్కొనవచ్చు:

ప్రతి డొమైన్ కోసం నిర్దిష్టమైనది - సర్వర్ డొమైన్‌ల మధ్య పబ్లిక్ ఫోల్డర్‌లను సమకాలీకరించదు

అన్ని డొమైన్‌లకు సాధారణం - అన్ని సర్వర్లు ప్రతి డొమైన్‌లో ఇప్పటికే ఉన్న పబ్లిక్ ఫోల్డర్‌లను వదిలివేస్తాయి మరియు ప్రతి మెయిల్ సర్వర్‌లోని అన్ని డొమైన్‌ల కోసం కొత్త సింగిల్ ఫోల్డర్‌లను సృష్టిస్తాయి.

హెచ్చరిక ఈ ఐచ్ఛికం అన్ని సర్వర్‌లలోని కాన్ఫిగరేషన్ విధానాన్ని మార్చినప్పటికీ, ఇది ప్రతి సర్వర్ నుండి విడిగా సమకాలీకరించబడుతుంది (అంటే, ఒకే సాధారణ స్థలం లేకుండా)

అడ్మినిస్ట్రేటర్ ఇప్పటికీ వినియోగదారుల మధ్య యాక్సెస్‌ను పంపిణీ చేయగల సామర్థ్యాన్ని కలిగి ఉంటారు.
నా విషయంలో, అవన్నీ నావి మరియు ప్రతి సర్వర్‌లో నాకు పూర్తి సమకాలీకరణ అవసరం (మీ విషయంలో, పరిష్కారం భిన్నంగా ఉండవచ్చు) మీరు సమకాలీకరించాల్సిన డొమైన్‌ల యొక్క ఒకే విధమైన సెట్‌లను సృష్టించాలి.

2. కెరియో డేటా డైరెక్టరీలు

ఇప్పుడు మీరు ప్రతి సర్వర్‌లో సమకాలీకరించాల్సిన ఒకేలా భాగస్వామ్య డైరెక్టరీలను సృష్టించాలి. ఫోల్డర్లు, క్యాలెండర్లు, పరిచయాలు.

సలహా - ఆంగ్లంలో డైరెక్టరీలను సృష్టించండి, మీరు వాటిని లాటిన్లో సృష్టించినట్లయితే, డైరెక్టరీకి కొన్ని అపారమయిన ఎన్కోడింగ్లో పేరు ఉంటుంది, ఇది కనీసం అసౌకర్యంగా ఉంటుంది.

ఇప్పుడు మీరు ప్రతి సర్వర్‌లోని మెయిల్ ఫోల్డర్‌ల భౌతిక మార్గాలను కనుగొనాలి.

అన్ని డొమైన్‌లకు సాధారణం ~DataMailmail#publicСинхронизируемый каталог#msgs
ప్రతి డొమైన్ కోసం నిర్దిష్టమైనది ~DataMailmail**Domain**#publicСинхронизируемый каталог#msgs

దయచేసి మేము మొత్తం డైరెక్టరీని సమకాలీకరించము, కానీ డేటాతో కూడిన కంటైనర్‌ను మాత్రమే సమకాలీకరించము #msgs — వస్తువులు ఇక్కడ నిల్వ చేయబడతాయి, అన్ని ఇతర డేటా ప్రతి సర్వర్‌కు విడిగా ఉండాలి.

3.DFS

DFSని ఎలా కాన్ఫిగర్ చేయాలో నేను వివరంగా వివరించను, ఈ సమస్యపై తగినంత సమాచారం ఉంది.

DFS అనేది విండోస్ సర్వర్‌లోని రోల్ సర్వీస్, ఇది విభిన్న సర్వర్‌లలో ఉన్న భాగస్వామ్య ఫోల్డర్‌లను కలపగల సామర్థ్యాన్ని అందిస్తుంది.
MS DFS పత్రానికి లింక్

DFSని సెటప్ చేయడానికి ముందు, మీరు డేటా సింక్రొనైజేషన్‌లో పాల్గొనే అన్ని మెయిల్ సర్వర్‌లను తప్పనిసరిగా ఆపాలి.

సెటప్ పూర్తయిన తర్వాత, మీరు ప్రతి సమకాలీకరించబడిన ఫోల్డర్‌ల కోసం క్రింది చిత్రాన్ని అందుకోవాలి

సహజంగానే, మేము ప్రతిరూపమైన ఫోల్డర్‌లను ప్రచురించాల్సిన అవసరం లేదు.

ప్రతిరూపణ సంభవించిన తర్వాత (మరియు అక్కడ పునరావృతం చేయడానికి ప్రత్యేకంగా ఏమీ లేదు - ఫోల్డర్‌లు ఖాళీగా ఉన్నాయి), మెయిల్ సర్వర్‌లను ప్రారంభించవచ్చు.

తర్వాత, మీరు మెయిల్ సర్వర్‌లలో ఒకదానిని డేటాతో పూరించవచ్చు మరియు డేటా సరిగ్గా ప్రతిరూపం చేయబడిందో లేదో తనిఖీ చేయవచ్చు.

4. క్రచ్

ప్రతిబింబం యొక్క వివరణ

డేటా సమకాలీకరించడం (DFS) తర్వాత మీరు చూడగలిగినట్లుగా, మీరు మొదటి సర్వర్‌లో ఏదైనా సృష్టించినట్లయితే, ఏదో ఒకవిధంగా రెండవ సర్వర్‌లో ఏమీ కనిపించదు లేదా అది కనిపిస్తుంది కానీ ఏదో ఒకవిధంగా ఎల్లప్పుడూ కాదు.

నిరుత్సాహపడకండి; వాస్తవానికి, అది ముందుగానే లేదా తరువాత అక్కడ కనిపిస్తుంది, కానీ తర్వాత కంటే ముందుగానే మంచిది. ఎందుకంటే 6 - 12 గంటల్లో చాలా ఆలస్యం అవుతుంది.

విషయం ఏమిటంటే, మీరు మొదటి సర్వర్‌లో ఏదైనా సృష్టించిన వెంటనే, రెండవ మరియు తదుపరి సర్వర్‌లలో ఫైల్ వెంటనే DFS సిస్టమ్‌కు ధన్యవాదాలు కనిపిస్తుంది, అయితే ఈ మెయిల్ డైరెక్టరీని ఇంతకు ముందు ఎవరైనా చదివిన సందర్భంలో మరియు మళ్లీ అభ్యర్థించబడింది, సర్వర్ #msgs ఫోల్డర్‌ను మళ్లీ చదవదు కానీ దాని స్వంత సూచిక నుండి డేటాను ఉమ్మివేస్తుంది, ఇది ఇకపై మన వాస్తవికతకు అనుగుణంగా ఉండకపోవచ్చు.

Kerio ఇండెక్స్‌ను మళ్లీ చదవడానికి ఒక యంత్రాంగాన్ని కలిగి ఉంది, అయితే ఇది దాదాపు ఆరు గంటలలో పని చేయగలదు మరియు ఈ 6 గంటలలో క్యాలెండర్‌లోని టాస్క్ యొక్క ఔచిత్యం కొంతవరకు కోల్పోవచ్చు.
ప్రస్తుతం సమకాలీకరణను పరీక్షించడానికి, మెయిల్ సర్వర్‌లోని ఫోల్డర్‌ను మళ్లీ యాక్సెస్ చేసిన తర్వాత, మీరు సంబంధిత సమకాలీకరించబడిన డైరెక్టరీ index.fldలో ఫైల్‌ను తొలగించవచ్చు మరియు ఈ ఫైల్ తప్పిపోయినట్లయితే, Kerio డైరెక్టరీని మరియు డేటాను మళ్లీ రీడ్ చేస్తుంది. కనిపిస్తుంది. ఇది పరిష్కారం అని అనిపించవచ్చు, డేటా మారినప్పుడు ఫైల్‌ను తొలగించండి, కానీ ఇది ప్రతిసారీ పని చేయదు, కానీ మొదటిసారి మాత్రమే, Kerio కొన్ని కారణాల వల్ల index.fldపై ఆసక్తిని కోల్పోతాడు.
ఇది వినియోగదారుకు అర్థంకాని సందేశాలను ఉమ్మివేయడం ప్రారంభిస్తుంది - కొన్ని రకాల సూచికల గురించి మరియు ఇది ఇప్పటికే అక్కడ ఏదో చేస్తోంది.

ఏదైనా సృష్టించడానికి మరొక ఎంపిక ఉంది - క్రొత్త వస్తువును సృష్టించే సమయంలో, సర్వర్ అకస్మాత్తుగా అది కేటాయించాలనుకుంటున్న ఫైల్ పేరు ఇప్పటికే తీసుకోబడిందని గ్రహించింది, అయితే ఇది స్నో బాల్స్ మరియు ఇది డెడ్-ఎండ్ ఎంపిక.

ఎలా ఉండాలి?

ఇప్పటికే మనకు తెలిసిన చిత్రంపై మరోసారి దృష్టి సారిస్తే.

కానీ మరొక విమానంలో, ఇప్పుడు మనకు అవసరమైన చాలా ఆసక్తికరమైన బటన్‌ను మీరు చూడవచ్చు - రీఇండెక్స్ ఫోల్డర్‌లు

మరియు నిజానికి. సింక్రొనైజ్ చేసిన #msgsలో ఇప్పటికే ఏదో మార్పు వచ్చిందని తెలియని మెయిల్ సర్వర్‌లో ఈ బటన్‌పై క్లిక్ చేస్తే, మనకు స్థిరమైన, వేగవంతమైన ఫలితం వస్తుంది. దాగి ఉన్నదంతా స్పష్టమవుతుంది.

లాగ్‌లో ఈ ప్రక్రియ ఎంత సమయం తీసుకుంటుందో మీరు చూడవచ్చు; నా విషయంలో అనేక వేల (15 వేలు) రికార్డులు 3-4 నిమిషాలు పడుతుంది.

మనం చేయాల్సిందల్లా మనకు అవసరమైనప్పుడు ఈ బటన్‌ను ఎలా నొక్కాలో గుర్తించడం.

ఇది మారుతుంది కెరియో వారి స్వంతం API

వివరణ
డాక్యుమెంటేషన్

మా పనిని నిర్వహించే ఫంక్షన్ ఇలా కనిపిస్తుంది:
session = callMethod("Domains.checkPublicFoldersIntegrity",{}, token)

పైన పేర్కొన్న అన్నింటి నుండి, మేము ఆసక్తి ఉన్న ఫోల్డర్‌ల స్థితిని పర్యవేక్షించే స్క్రిప్ట్‌ను వ్రాయాలి మరియు ఏదైనా మారినట్లయితే, మనకు అవసరమైన ఫంక్షన్‌ను నిర్వహించండి.

నేను వేర్వేరు తనిఖీలను నిర్వహించే స్క్రిప్ట్‌ల యొక్క అనేక విభిన్న సంస్కరణలను వ్రాసాను మరియు ఫైల్‌ల సంఖ్య ఆధారంగా అన్ని తీర్మానాలను రూపొందించేదానిపై స్థిరపడ్డాను అని నేను చెప్పాలనుకుంటున్నాను.

స్క్రిప్ట్ అమలు

CMD స్క్రిప్ట్ ఉదాహరణ మరియు వివరణ

రీ-ఇండెక్స్.బ్యాట్

@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

స్క్రిప్ట్ యొక్క కాపీ ప్రతి మెయిల్ సర్వర్‌లో నడుస్తుంది (సేవగా ఉపయోగించవచ్చు, ప్రకటన హక్కులు అవసరం లేదు)

స్క్రిప్ట్ ఫైల్‌ను చదువుతుంది Setup%Computername%.List

%కంప్యూటర్ పేరు% అనేది ప్రస్తుత సర్వర్ పేరు (డైరెక్టరీ ఒకేసారి అన్ని సర్వర్ల జాబితాలను కలిగి ఉంటుంది.)

ఫైల్ %Computername%.List – సమకాలీకరించబడిన డైరెక్టరీల యొక్క పూర్తి పాత్‌లను కలిగి ఉంటుంది, ప్రతి మార్గం కొత్త లైన్‌లో వ్రాయబడుతుంది మరియు ఖాళీ లైన్‌లను కలిగి ఉండకూడదు.

మొదటి లాంచ్ తర్వాత, స్క్రిప్ట్ అవసరమా కాదా అనే దానితో సంబంధం లేకుండా ఇండెక్సింగ్ విధానాన్ని నిర్వహిస్తుంది మరియు స్క్రిప్ట్ ప్రతి సమకాలీకరించబడిన డైరెక్టరీలోని ఫైల్‌ల సంఖ్య యొక్క సూచికను కూడా సృష్టిస్తుంది.

స్క్రిప్ట్ యొక్క ఉద్దేశ్యం పేర్కొన్న డైరెక్టరీలోని అన్ని ఫైళ్లను లెక్కించడం.

ప్రతి డైరెక్టరీని లెక్కించడం ముగింపులో, కనీసం ఒక డైరెక్టరీలో ఫైల్‌ల ప్రస్తుత విలువ మునుపటి దానితో సరిపోలకపోతే, స్క్రిప్ట్ సమకాలీకరించబడిన మెయిల్ డైరెక్టరీ యొక్క రూట్ డైరెక్టరీ నుండి ఫైల్‌లను తొలగిస్తుంది: index.fld, indexlog.fld, search.fld మరియు షేర్డ్ మెయిల్ ఫోల్డర్‌ల ఇండెక్సింగ్ ప్రక్రియను ప్రారంభిస్తుంది.

టాస్క్ ఎగ్జిక్యూషన్ గురించిన సమాచారం LOG డైరెక్టరీలో డంప్ చేయబడింది.

ఇండెక్సింగ్ ప్రక్రియ
ఇండెక్సింగ్ ప్రక్రియ Kerio API ఫంక్షన్‌ని అమలు చేయడానికి వస్తుంది
సెషన్ = కాల్ మెథడ్("Domains.checkPublicFoldersIntegrity",{}, టోకెన్)

ఒక ఉదాహరణ అమలులో ఇవ్వబడింది - పైథాన్
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 అవసరమైతే, పైథాన్ తప్పనిసరిగా Kerio ప్రమాణపత్రాన్ని విశ్వసించాలి.

అలాగే ఫైల్‌లో మీరు మెయిల్ సర్వర్ యొక్క ఈ ఫంక్షన్ (Adm - పబ్లిక్ మెయిల్ ఫోల్డర్‌లు) నిర్వహించడానికి హక్కులతో కూడిన ఖాతాను తప్పనిసరిగా పేర్కొనాలి.

నా వ్యాసం Kerio Connect నిర్వాహకులకు ఉపయోగకరంగా ఉంటుందని నేను ఆశిస్తున్నాను.

మూలం: www.habr.com