ವಿತರಿಸಿದ ಕೆರಿಯೊ ಕನೆಕ್ಟ್ ಸರ್ವರ್‌ಗಳ ನಡುವೆ ಹಂಚಿದ ಫೋಲ್ಡರ್‌ಗಳು, ಸಂಪರ್ಕಗಳು, ಕ್ಯಾಲೆಂಡರ್‌ಗಳ ಸಂಪೂರ್ಣ ಸಿಂಕ್ರೊನೈಸೇಶನ್

ಶುಭ ಮಧ್ಯಾಹ್ನ, ಹಬ್ರ್!

ಉದ್ದೇಶ

ನನ್ನ ಸಂಸ್ಥೆಯು ಕೆರಿಯೊ ಕನೆಕ್ಟ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ಮೇಲ್ ಸರ್ವರ್ ಅನ್ನು ಬಳಸುತ್ತದೆ; ತಮ್ಮ ಬಳಕೆದಾರರಿಗೆ ಸೇವೆ ಸಲ್ಲಿಸಲು ಮೇಲ್ ಸರ್ವರ್‌ಗಳನ್ನು ವಿವಿಧ ನಗರಗಳಲ್ಲಿ ಸ್ಥಾಪಿಸಲಾಗಿದೆ. ಆರಂಭದಲ್ಲಿ ಯಾವುದೇ ವಿತರಣಾ ರಚನೆ ಇರಲಿಲ್ಲ, ಏಕೆಂದರೆ ಡೊಮೇನ್‌ಗಳು ಮೂರನೇ ಹಂತದಲ್ಲಿ ಭಿನ್ನವಾಗಿರುತ್ತವೆ, ಇದು ಸೈಟ್‌ನ ನಗರವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಎಲ್ಲವೂ ಕೆಲಸ ಮಾಡಿತು ಮತ್ತು ಎಲ್ಲರೂ ಸಂತೋಷವಾಗಿದ್ದರು. ಒಂದು ಉತ್ತಮ ದಿನ, ನಿರ್ವಹಣೆಯು ಕಾರ್ಯವನ್ನು ಹೊಂದಿಸುತ್ತದೆ, ಎಲ್ಲಾ ಸೈಟ್‌ಗಳ ನಡುವಿನ ಚಟುವಟಿಕೆಗಳ ಸಾಮಾನ್ಯ ಕ್ಯಾಲೆಂಡರ್!

ಪೂರ್ವೇತಿಹಾಸದ

ಆರಂಭದಲ್ಲಿ, ಕೆರಿಯೊ ಡಿಸ್ಟ್ರಿಬ್ಯೂಟೆಡ್ ಮೇಲ್ ಡೊಮೇನ್ ಅನ್ನು ಹೆಚ್ಚಿಸುವ ಆಲೋಚನೆ ಇತ್ತು ಮತ್ತು ಅದು ಎಲ್ಲವನ್ನೂ ಸ್ವತಃ ಮಾಡುತ್ತದೆ. ಮುಗಿದ ನಂತರ, ವಿತರಿಸಿದ ಡೊಮೇನ್ ಅನ್ನು ರಚಿಸಲಾಗಿದೆ, ಆದರೆ ಅದು ಹಾಗಲ್ಲ, ಒಂದೇ ಸರ್ವರ್‌ನಲ್ಲಿರುವ ಡೊಮೇನ್‌ಗಳ ನಡುವೆ ಕ್ಯಾಲೆಂಡರ್‌ಗಳು, ಫೋಲ್ಡರ್‌ಗಳು, ಸಂಪರ್ಕಗಳನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು ಸರ್ವರ್ ಸಿದ್ಧವಾಗಿದೆ, ಆದರೆ ಹಲವಾರು ನಡುವೆ ಡೇಟಾವನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು ಹೋಗುತ್ತಿಲ್ಲ ಸರ್ವರ್ಗಳು.

ನಾನು, ಸಹಜವಾಗಿ, ಅಂತಹ ಕ್ಯಾಚ್ ಅನ್ನು ನಿರೀಕ್ಷಿಸಿರಲಿಲ್ಲ ಮತ್ತು ನನಗೆ ಅಗತ್ಯವಿರುವ ಕಾರ್ಯವು ಕಾಣೆಯಾಗಿದೆ ಎಂದು ದೀರ್ಘಕಾಲದವರೆಗೆ ನಂಬಲಾಗಲಿಲ್ಲ. ನಂತರ ನಾನು ಈ ಸತ್ಯದ ಸಾಕ್ಷ್ಯಚಿತ್ರ ಸಾಕ್ಷ್ಯವನ್ನು ಕಂಡುಕೊಂಡೆ. ಇದರಿಂದ ನಾನು ತುಂಬಾ ಗೊಂದಲಕ್ಕೊಳಗಾಗಿದ್ದೇನೆ ಮತ್ತು ನಿರಾಶೆಗೊಂಡಿದ್ದೇನೆ.

ಕಾರ್ಯವು ಸುಗಮವಾಗಿ ಸಮಸ್ಯೆಯಾಗಿ ಬದಲಾಯಿತು.

ಆಯ್ಕೆಗಳು ಯಾವುವು?

• ಕೆಲವು ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಸಾಫ್ಟ್‌ವೇರ್‌ನೊಂದಿಗೆ ಅಗತ್ಯ ಡೇಟಾವನ್ನು ವಿನಿಮಯ ಮಾಡಿಕೊಳ್ಳುವ ವಿಭಿನ್ನ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಎರಡು ಕ್ಲೈಂಟ್‌ಗಳನ್ನು ರಚಿಸಿ. ಈ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಈ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಅಗತ್ಯವಾಗಿತ್ತು - ಅಂತಹ ಕುಂಟೆ ನನಗೆ ಇಷ್ಟವಿಲ್ಲ, ಆದರೆ ಇದು ಏಕೈಕ ತ್ವರಿತ ಪರಿಹಾರವಾಗಿದೆ ಎಂದು ತೋರುತ್ತಿದೆ.
• ಸರ್ವರ್‌ಗಳ ನಡುವೆ ಡೇಟಾ ಸಿಂಕ್ರೊನೈಸೇಶನ್‌ಗಾಗಿ ನಿಮ್ಮ ಸ್ವಂತ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯಿರಿ. ಸಂಗತಿಯೆಂದರೆ, ಕೆರಿಯೊ ಪ್ರತಿಯೊಂದು ವಸ್ತುವನ್ನು ಪ್ರತ್ಯೇಕ ಫೈಲ್ ಆಗಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಫೈಲ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವುದು ಅಗತ್ಯವಾಗಿತ್ತು, ಆದರೆ ಸಾಕಷ್ಟು ಸಂಖ್ಯೆಯ ಮೂಲಗಳ ದೃಷ್ಟಿಯಿಂದ, ಕಾರ್ಯವು ಸ್ವಲ್ಪ ಜಟಿಲವಾಗಿದೆ ಎಂದು ತೋರುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಬಹು ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸುವ ಅಗತ್ಯವಿತ್ತು. ಡೇಟಾದ ನಿಖರತೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಅದೇ ಸಮಯದಲ್ಲಿ ಯಾರಾದರೂ ಕೆಲಸವನ್ನು ರಚಿಸಿದರೆ, ಇತ್ಯಾದಿ.

ಮುಂದೆ ನೋಡುವಾಗ, ಕೆರಿಯೊ ವಸ್ತುವನ್ನು ಪ್ರತ್ಯೇಕ ಫೈಲ್‌ನಂತೆ ಸಂಗ್ರಹಿಸಿದರೂ, ನೀವು ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಪ್ರವೇಶಿಸಿದಾಗಲೆಲ್ಲಾ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಎಂದು ಕೇಳುವಷ್ಟು ಮೂರ್ಖತನವಲ್ಲ ಎಂದು ನಾನು ಹೇಳುತ್ತೇನೆ.

"ಶತ್ರು ಪ್ರದೇಶವನ್ನು ವಶಪಡಿಸಿಕೊಳ್ಳಲು" ಯೋಜನೆಗಳೊಂದಿಗೆ ಕಾಗದದ ತುಂಡುಗಳನ್ನು ಚಿತ್ರಿಸಿ, 6 ಗಂಟೆಗೆ ನಾನು ಎರಡು ಸರಿಯಾದ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಂಡೆ:

• ಮೊದಲ ನಿರ್ಧಾರವೆಂದರೆ ನಿಮ್ಮ ಸ್ವಂತ ಕೆಲಸವನ್ನು ಮಾಡುವುದು ಮತ್ತು ಹೊರಗಿನಿಂದ ಏನನ್ನೂ ಹುಡುಕಬಾರದು.
• ಎರಡನೆಯ ಪರಿಹಾರವೆಂದರೆ ನಿದ್ರೆಗೆ ಹೋಗುವುದು.

ಈಗಾಗಲೇ ಬೆಳಿಗ್ಗೆ ನಾನು ಒಂದೇ ಮತ್ತು ನಿಜವಾದ ಆಲೋಚನೆಯೊಂದಿಗೆ ಎಚ್ಚರವಾಯಿತು, ಅದನ್ನು ಕೆಲವು ಅಕ್ಷರಗಳಿಗೆ ಇಳಿಸಲಾಯಿತು - DFS

ನಿರ್ಧಾರವನ್ನು

ಪರಿಹಾರವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ

• OS ವಿಂಡೋಸ್‌ಗೆ ಸಿಂಕ್ರೊನೈಸೇಶನ್‌ನಲ್ಲಿ ಭಾಗವಹಿಸುವ ಎಲ್ಲಾ ಸರ್ವರ್‌ಗಳನ್ನು ತರಲು. (ಅದರ ಭಾಗವು Linux ನಲ್ಲಿತ್ತು. ಇನ್ನೊಂದು OS ಗೆ ಮೇಲ್ ಡೇಟಾವನ್ನು ಸ್ಥಳಾಂತರಿಸುವ ಅಗತ್ಯವಿದೆ)
• ಸಿಂಕ್ರೊನೈಸೇಶನ್‌ನಲ್ಲಿ ಭಾಗವಹಿಸುವ ಡೈರೆಕ್ಟರಿಗಳ ರಚನೆಯನ್ನು ನಿರ್ಧರಿಸಿ - ಅವು ಒಂದೇ ಆಗಿರಬೇಕು.
• ಎಲ್ಲಾ ಮೇಲ್ ಸರ್ವರ್‌ಗಳನ್ನು ಒಂದೇ ಡೊಮೇನ್‌ನಡಿಯಲ್ಲಿ ಒಂದೇ ಡಿಎಫ್‌ಎಸ್ ಸ್ಥಳದೊಂದಿಗೆ ವಿವರಿಸಿ.
• ಮೇಲೆ ತಿಳಿಸಲಾದ ವಿತರಿಸಲಾದ ಕೆರಿಯೊ ಡೊಮೇನ್ ಅನ್ನು ರಚಿಸಿ, ಏಕೆಂದರೆ ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ ಡೇಟಾ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಅಗತ್ಯವಿರುತ್ತದೆ, ಸರ್ವರ್‌ಗಳ ನಡುವೆ ಮಾತ್ರವಲ್ಲದೆ ಡೊಮೇನ್‌ಗಳ ನಡುವೆಯೂ ಸಹ; ಎರಡನೆಯದನ್ನು ಕೆರಿಯೊ ಸರ್ವರ್ ಸ್ವತಂತ್ರವಾಗಿ ನಿರ್ವಹಿಸಬಹುದು. (ಮೊದಲನೆಯದಕ್ಕಿಂತ ಭಿನ್ನವಾಗಿ)
• ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಿದ ಡೈರೆಕ್ಟರಿಗಳನ್ನು DFS ಸ್ಪೇಸ್‌ಗೆ ಹೊಂದಿಸಿ.
• ಕೆಲವು ರೀತಿಯ ಊರುಗೋಲುಗಳೊಂದಿಗೆ ಬನ್ನಿ (ಎಲ್ಲಾ ನಂತರ, ನೀವು ಊರುಗೋಲು ಇಲ್ಲದೆ ಬದುಕಲು ಸಾಧ್ಯವಿಲ್ಲ)

Реализация

ಎರಡು ಮೇಲ್ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಉದಾಹರಣೆ (ಬಹುಶಃ ಹೆಚ್ಚು)

1. ಕೆರಿಯೊ ಡಿಸ್ಟ್ರಿಬ್ಯೂಟೆಡ್ ಡೊಮೇನ್

ಮಾಸ್ಟರ್ ಸಿಂಕ್ರೊನೈಸೇಶನ್‌ನಲ್ಲಿ ಭಾಗವಹಿಸುವುದಿಲ್ಲ, ಆದರೆ ಇದು ಪೂರ್ವಾಪೇಕ್ಷಿತವಲ್ಲ.

ಕೆರಿಯೊ ವಿತರಿಸಿದ ಡೊಮೇನ್ ಅನ್ನು ಹೇಗೆ ಹೆಚ್ಚಿಸುವುದು ಎಂದು ನಾನು ವಿವರಿಸುವುದಿಲ್ಲ, ಅದರಲ್ಲಿ ಏನೂ ಸಂಕೀರ್ಣವಾಗಿಲ್ಲ, ನೀವು ಅಧಿಕೃತವನ್ನು ಅಧ್ಯಯನ ಮಾಡಬಹುದು ಮ್ಯಾನುಲ್

ಅಂತಿಮವಾಗಿ, ನೀವು ಆಡಳಿತ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಈ ಕೆಳಗಿನ ಚಿತ್ರವನ್ನು ನೋಡಬೇಕು:

ಮುಂದೆ ನಾನು ಹಂಚಿದ ಫೋಲ್ಡರ್‌ಗಳಲ್ಲಿ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೇನೆ; ಮಾಸ್ಟರ್ ಸರ್ವರ್‌ನಲ್ಲಿ ನೀವು ಈ ಕೆಳಗಿನ ಆಯ್ಕೆಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು:

ಪ್ರತಿ ಡೊಮೇನ್‌ಗೆ ನಿರ್ದಿಷ್ಟ - ಸರ್ವರ್ ಡೊಮೇನ್‌ಗಳ ನಡುವೆ ಸಾರ್ವಜನಿಕ ಫೋಲ್ಡರ್‌ಗಳನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುವುದಿಲ್ಲ

ಎಲ್ಲಾ ಡೊಮೇನ್‌ಗಳಿಗೆ ಸಾಮಾನ್ಯವಾಗಿದೆ - ಎಲ್ಲಾ ಸರ್ವರ್‌ಗಳು ಪ್ರತಿ ಡೊಮೇನ್‌ನಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಸಾರ್ವಜನಿಕ ಫೋಲ್ಡರ್‌ಗಳನ್ನು ತ್ಯಜಿಸುತ್ತವೆ ಮತ್ತು ಪ್ರತಿ ಮೇಲ್ ಸರ್ವರ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಡೊಮೇನ್‌ಗಳಿಗೆ ಹೊಸ ಸಿಂಗಲ್ ಫೋಲ್ಡರ್‌ಗಳನ್ನು ರಚಿಸುತ್ತವೆ.

ಎಚ್ಚರಿಕೆ ಈ ಆಯ್ಕೆಯು ಎಲ್ಲಾ ಸರ್ವರ್‌ಗಳಲ್ಲಿನ ಕಾನ್ಫಿಗರೇಶನ್ ನೀತಿಯನ್ನು ಬದಲಾಯಿಸಿದರೂ, ಇದು ಪ್ರತಿ ಸರ್ವರ್‌ನಿಂದ ಪ್ರತ್ಯೇಕವಾಗಿ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುತ್ತದೆ (ಅಂದರೆ, ಒಂದೇ ಸಾಮಾನ್ಯ ಸ್ಥಳವಿಲ್ಲದೆ)

ನಿರ್ವಾಹಕರು ಇನ್ನೂ ಬಳಕೆದಾರರ ನಡುವೆ ಪ್ರವೇಶವನ್ನು ವಿತರಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿರುತ್ತಾರೆ.
ನನ್ನ ವಿಷಯದಲ್ಲಿ, ಅವೆಲ್ಲವೂ ನನ್ನದೇ ಮತ್ತು ನನಗೆ ಸಂಪೂರ್ಣ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಅಗತ್ಯವಿದೆ (ನಿಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಪರಿಹಾರವು ವಿಭಿನ್ನವಾಗಿರಬಹುದು) ಪ್ರತಿ ಸರ್ವರ್‌ನಲ್ಲಿ ನೀವು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಬೇಕಾದ ಒಂದೇ ರೀತಿಯ ಡೊಮೇನ್‌ಗಳನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ.

2. ಕೆರಿಯೊ ಡೇಟಾ ಡೈರೆಕ್ಟರಿಗಳು

ಈಗ ನೀವು ಪ್ರತಿಯೊಂದು ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಬೇಕಾದ ಒಂದೇ ರೀತಿಯ ಹಂಚಿಕೆಯ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ. ಫೋಲ್ಡರ್‌ಗಳು, ಕ್ಯಾಲೆಂಡರ್‌ಗಳು, ಸಂಪರ್ಕಗಳು.

ಸಲಹೆ - ಇಂಗ್ಲಿಷ್‌ನಲ್ಲಿ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ರಚಿಸಿ, ನೀವು ಅವುಗಳನ್ನು ಲ್ಯಾಟಿನ್‌ನಲ್ಲಿ ರಚಿಸಿದರೆ, ಡೈರೆಕ್ಟರಿಯು ಕೆಲವು ಗ್ರಹಿಸಲಾಗದ ಎನ್‌ಕೋಡಿಂಗ್‌ನಲ್ಲಿ ಹೆಸರನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಇದು ಕನಿಷ್ಠ ಅನಾನುಕೂಲವಾಗಿದೆ.

ಈಗ ನೀವು ಪ್ರತಿ ಸರ್ವರ್‌ನಲ್ಲಿ ಮೇಲ್ ಫೋಲ್ಡರ್‌ಗಳ ಭೌತಿಕ ಮಾರ್ಗಗಳನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು.

ಎಲ್ಲಾ ಡೊಮೇನ್‌ಗಳಿಗೆ ಸಾಮಾನ್ಯವಾಗಿದೆ ~DataMailmail#publicСинхронизируемый каталог#msgs
ಪ್ರತಿ ಡೊಮೇನ್‌ಗೆ ನಿರ್ದಿಷ್ಟ ~DataMailmail**Domain**#publicСинхронизируемый каталог#msgs

ನಾವು ಸಂಪೂರ್ಣ ಡೈರೆಕ್ಟರಿಯನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುವುದಿಲ್ಲ, ಆದರೆ ಡೇಟಾದೊಂದಿಗೆ ಕಂಟೇನರ್ ಅನ್ನು ಮಾತ್ರ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುತ್ತೇವೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ #ಸಂದೇಶಗಳು — ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಇಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ, ಎಲ್ಲಾ ಇತರ ಡೇಟಾವು ಪ್ರತಿ ಸರ್ವರ್‌ಗೆ ಪ್ರತ್ಯೇಕವಾಗಿರಬೇಕು.

3.DFS

DFS ಅನ್ನು ಹೇಗೆ ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕೆಂದು ನಾನು ವಿವರವಾಗಿ ವಿವರಿಸುವುದಿಲ್ಲ, ಈ ಸಮಸ್ಯೆಯ ಬಗ್ಗೆ ಸಾಕಷ್ಟು ಮಾಹಿತಿ ಇದೆ.

ವಿಂಡೋಸ್ ಸರ್ವರ್‌ನಲ್ಲಿ ಡಿಎಫ್‌ಎಸ್ ಒಂದು ಪಾತ್ರ ಸೇವೆಯಾಗಿದ್ದು ಅದು ವಿಭಿನ್ನ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಇರುವ ಹಂಚಿದ ಫೋಲ್ಡರ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ.
MS DFS ಡಾಕ್ಯುಮೆಂಟ್‌ಗೆ ಲಿಂಕ್ ಮಾಡಿ

DFS ಅನ್ನು ಹೊಂದಿಸುವ ಮೊದಲು, ಡೇಟಾ ಸಿಂಕ್ರೊನೈಸೇಶನ್‌ನಲ್ಲಿ ಭಾಗವಹಿಸುವ ಎಲ್ಲಾ ಮೇಲ್ ಸರ್ವರ್‌ಗಳನ್ನು ನೀವು ನಿಲ್ಲಿಸಬೇಕು.

ಸೆಟಪ್ ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಿದ ಪ್ರತಿಯೊಂದು ಫೋಲ್ಡರ್‌ಗಳಿಗೆ ನೀವು ಈ ಕೆಳಗಿನ ಚಿತ್ರವನ್ನು ಸ್ವೀಕರಿಸಬೇಕು

ಸ್ವಾಭಾವಿಕವಾಗಿ, ನಾವು ಪುನರಾವರ್ತಿಸಿದ ಫೋಲ್ಡರ್‌ಗಳನ್ನು ಪ್ರಕಟಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.

ನಕಲು ಸಂಭವಿಸಿದ ನಂತರ (ಮತ್ತು ಅಲ್ಲಿ ಪುನರಾವರ್ತಿಸಲು ವಿಶೇಷ ಏನೂ ಇಲ್ಲ - ಫೋಲ್ಡರ್‌ಗಳು ಖಾಲಿಯಾಗಿವೆ), ಮೇಲ್ ಸರ್ವರ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು.

ಮುಂದೆ, ನೀವು ಮೇಲ್ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಒಂದನ್ನು ಡೇಟಾದೊಂದಿಗೆ ಭರ್ತಿ ಮಾಡಬಹುದು ಮತ್ತು ಡೇಟಾವನ್ನು ಸರಿಯಾಗಿ ಪುನರಾವರ್ತಿಸಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಬಹುದು.

4. ಊರುಗೋಲು

ಪ್ರತಿಬಿಂಬದ ವಿವರಣೆ

ಡೇಟಾ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು (DFS) ಪ್ರಾರಂಭಿಸಿದ ನಂತರ ನೀವು ನೋಡುವಂತೆ, ನೀವು ಮೊದಲ ಸರ್ವರ್‌ನಲ್ಲಿ ಏನನ್ನಾದರೂ ರಚಿಸಿದರೆ, ಹೇಗಾದರೂ ಎರಡನೇ ಸರ್ವರ್‌ನಲ್ಲಿ ಏನೂ ಕಾಣಿಸುವುದಿಲ್ಲ, ಅಥವಾ ಅದು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಆದರೆ ಹೇಗಾದರೂ ಯಾವಾಗಲೂ ಅಲ್ಲ.

ಹತಾಶೆ ಮಾಡಬೇಡಿ; ಸಹಜವಾಗಿ, ಅದು ಬೇಗ ಅಥವಾ ನಂತರ ಅಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ, ಆದರೆ ನಂತರದಕ್ಕಿಂತ ಬೇಗ ಉತ್ತಮವಾಗಿರುತ್ತದೆ. ಏಕೆಂದರೆ ಇದು 6 - 12 ಗಂಟೆಗಳಲ್ಲಿ ತುಂಬಾ ತಡವಾಗಿರುತ್ತದೆ.

ವಿಷಯವೆಂದರೆ ನೀವು ಮೊದಲ ಸರ್ವರ್‌ನಲ್ಲಿ ಏನನ್ನಾದರೂ ರಚಿಸಿದ ತಕ್ಷಣ, ಎರಡನೆಯ ಮತ್ತು ನಂತರದ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಫೈಲ್ ತಕ್ಷಣವೇ ಡಿಎಫ್‌ಎಸ್ ಸಿಸ್ಟಮ್‌ಗೆ ಧನ್ಯವಾದಗಳು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ, ಆದರೆ ಈ ಮೇಲ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ಈಗಾಗಲೇ ಯಾರಾದರೂ ಓದಿದ್ದರೆ ಮತ್ತು ಮತ್ತೊಮ್ಮೆ ವಿನಂತಿಸಲಾಗಿದೆ, ಸರ್ವರ್ #msgs ಫೋಲ್ಡರ್ ಅನ್ನು ಮರು-ಓದುವುದಿಲ್ಲ ಆದರೆ ಅದರ ಸ್ವಂತ ಸೂಚ್ಯಂಕದಿಂದ ಡೇಟಾವನ್ನು ಉಗುಳುತ್ತದೆ, ಅದು ಇನ್ನು ಮುಂದೆ ನಮ್ಮ ನೈಜತೆಗೆ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ.

ಕೆರಿಯೊ ಸೂಚ್ಯಂಕವನ್ನು ಮರು-ಓದಲು ಕಾರ್ಯವಿಧಾನವನ್ನು ಹೊಂದಿದೆ, ಆದರೆ ಇದು ಸುಮಾರು ಆರು ಗಂಟೆಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡಬಹುದು, ಮತ್ತು ಈ 6 ಗಂಟೆಗಳಲ್ಲಿ ಕ್ಯಾಲೆಂಡರ್‌ನಲ್ಲಿನ ಕಾರ್ಯದ ಪ್ರಸ್ತುತತೆ ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ಕಳೆದುಹೋಗಬಹುದು.
ಇದೀಗ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು, ಮೇಲ್ ಸರ್ವರ್‌ನಲ್ಲಿ ಫೋಲ್ಡರ್ ಅನ್ನು ಮರು-ಪ್ರವೇಶಿಸಿದ ನಂತರ ನೀವು ಅನುಗುಣವಾದ ಸಿಂಕ್ರೊನೈಸ್ ಡೈರೆಕ್ಟರಿ index.fld ನಲ್ಲಿ ಫೈಲ್ ಅನ್ನು ಅಳಿಸಬಹುದು ಮತ್ತು ಈ ಫೈಲ್ ಕಾಣೆಯಾಗಿದ್ದರೆ, ಕೆರಿಯೊ ಡೈರೆಕ್ಟರಿ ಮತ್ತು ಡೇಟಾವನ್ನು ಮರು-ಓದುತ್ತದೆ ಕಾಣಿಸುತ್ತದೆ. ಇದು ಪರಿಹಾರವಾಗಿದೆ ಎಂದು ತೋರುತ್ತದೆ, ಡೇಟಾ ಬದಲಾದಾಗ ಫೈಲ್ ಅನ್ನು ಅಳಿಸಿ, ಆದರೆ ಇದು ಪ್ರತಿ ಬಾರಿಯೂ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ, ಆದರೆ ಮೊದಲ ಬಾರಿಗೆ ಮಾತ್ರ, ನಂತರ ಕೆರಿಯೊ ಕೆಲವು ಕಾರಣಗಳಿಂದ index.fld ನಲ್ಲಿ ಎಲ್ಲಾ ಆಸಕ್ತಿಯನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತಾನೆ.
ಇದು ಬಳಕೆದಾರರಿಗೆ ಗ್ರಹಿಸಲಾಗದ ಸಂದೇಶಗಳನ್ನು ಹೊರಹಾಕಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ - ಕೆಲವು ರೀತಿಯ ಸೂಚ್ಯಂಕದ ಬಗ್ಗೆ ಮತ್ತು ಅದು ಈಗಾಗಲೇ ಅಲ್ಲಿ ಏನನ್ನಾದರೂ ಮಾಡುತ್ತಿದೆ.

ಏನನ್ನಾದರೂ ರಚಿಸಲು ಮತ್ತೊಂದು ಆಯ್ಕೆ ಇದೆ - ಹೊಸ ವಸ್ತುವನ್ನು ರಚಿಸುವ ಕ್ಷಣದಲ್ಲಿ, ಸರ್ವರ್ ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಅದು ನಿಯೋಜಿಸಲು ಬಯಸಿದ ಫೈಲ್ ಹೆಸರನ್ನು ಈಗಾಗಲೇ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ ಎಂದು ಅರಿತುಕೊಳ್ಳುತ್ತದೆ, ಆದರೆ ಇದು ಸ್ನೋಬಾಲ್ಸ್ ಮತ್ತು ಇದು ಡೆಡ್-ಎಂಡ್ ಆಯ್ಕೆಯಾಗಿದೆ.

ಹೇಗೆ ಇರಬೇಕು?

ನಮಗೆ ಈಗಾಗಲೇ ಪರಿಚಿತವಾಗಿರುವ ಚಿತ್ರದತ್ತ ಮತ್ತೊಮ್ಮೆ ಗಮನ ಹರಿಸಿದರೆ.

ಆದರೆ ಇನ್ನೊಂದು ವಿಮಾನದಲ್ಲಿ, ನಮಗೆ ಈಗ ಅಗತ್ಯವಿರುವ ಅತ್ಯಂತ ಆಸಕ್ತಿದಾಯಕ ಗುಂಡಿಯನ್ನು ನೀವು ನೋಡಬಹುದು - ರೀಇಂಡೆಕ್ಸ್ ಫೋಲ್ಡರ್‌ಗಳು

ಮತ್ತು ವಾಸ್ತವವಾಗಿ. ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಿದ #msgs ನಲ್ಲಿ ಈಗಾಗಲೇ ಏನಾದರೂ ಬದಲಾವಣೆಯಾಗಿದೆ ಎಂದು ತಿಳಿಯದ ಮೇಲ್ ಸರ್ವರ್‌ನಲ್ಲಿ ನಾವು ಈ ಬಟನ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿದರೆ, ನಾವು ಸ್ಥಿರವಾದ, ವೇಗದ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯುತ್ತೇವೆ. ಅಡಗಿರುವ ಎಲ್ಲವೂ ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ.

ಈ ಪ್ರಕ್ರಿಯೆಯು ಎಷ್ಟು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಎಂಬುದನ್ನು ಲಾಗ್‌ನಲ್ಲಿ ನೀವು ನೋಡಬಹುದು; ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ ಹಲವಾರು ಸಾವಿರ (15 ಸಾವಿರ) ದಾಖಲೆಗಳೊಂದಿಗೆ ಇದು ಸುಮಾರು 3-4 ನಿಮಿಷಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

ನಾವು ಮಾಡಬೇಕಾಗಿರುವುದು ನಮಗೆ ಅಗತ್ಯವಿರುವಾಗ ಈ ಬಟನ್ ಅನ್ನು ಹೇಗೆ ಒತ್ತುವುದು ಎಂಬುದನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು.

ಇದು ತಿರುಗುತ್ತದೆ ಕೆರಿಯೊ ತಮ್ಮದೇ ಆದ ಹೊಂದಿವೆ ಎಪಿಐ

ವಿವರಣೆ
ದಾಖಲೆ

ನಮ್ಮ ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸುವ ಕಾರ್ಯವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
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 ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಡಂಪ್ ಮಾಡಲಾಗುತ್ತದೆ.

ಇಂಡೆಕ್ಸಿಂಗ್ ಪ್ರಕ್ರಿಯೆ
ಇಂಡೆಕ್ಸಿಂಗ್ ಪ್ರಕ್ರಿಯೆಯು ಕೆರಿಯೊ 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 ಅಗತ್ಯವಿದ್ದರೆ, ಪೈಥಾನ್ ಕೆರಿಯೊ ಪ್ರಮಾಣಪತ್ರವನ್ನು ನಂಬಬೇಕು.

ಫೈಲ್ನಲ್ಲಿ ನೀವು ಮೇಲ್ ಸರ್ವರ್ನ ಈ ಕಾರ್ಯವನ್ನು (Adm - ಸಾರ್ವಜನಿಕ ಮೇಲ್ ಫೋಲ್ಡರ್ಗಳು) ನಿರ್ವಹಿಸಲು ಹಕ್ಕುಗಳೊಂದಿಗೆ ಖಾತೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು.

ನನ್ನ ಲೇಖನ ಕೆರಿಯೊ ಕನೆಕ್ಟ್ ನಿರ್ವಾಹಕರಿಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

ಮೂಲ: www.habr.com