ನಾಲ್ಕು ತಿಂಗಳಿನಿಂದ ನಾನು "ಬ್ಲಾಕ್‌ಚೈನ್ ಆಧಾರಿತ ಸರ್ಕಾರಿ ಮತ್ತು ಕೈಗಾರಿಕಾ ವಲಯಗಳಲ್ಲಿ ಡೇಟಾ ರಕ್ಷಣೆ ಮತ್ತು ನಿರ್ವಹಣಾ ಸಾಧನಗಳ ಅಭಿವೃದ್ಧಿ" ಎಂಬ ಯೋಜನೆಯಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೇನೆ.
ನಾನು ಈ ಯೋಜನೆಯನ್ನು ಹೇಗೆ ಪ್ರಾರಂಭಿಸಿದೆ ಎಂಬುದರ ಕುರಿತು ಈಗ ನಾನು ನಿಮಗೆ ಹೇಳಲು ಬಯಸುತ್ತೇನೆ ಮತ್ತು ಈಗ ನಾನು ಪ್ರೋಗ್ರಾಂ ಕೋಡ್ ಅನ್ನು ವಿವರವಾಗಿ ವಿವರಿಸುತ್ತೇನೆ.
ಲೇಖನಗಳ ಸರಣಿಯಲ್ಲಿ ಇದು ಮೊದಲ ಲೇಖನವಾಗಿದೆ. ಇಲ್ಲಿ ನಾನು ಸರ್ವರ್ ಮತ್ತು ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ವಿವರಿಸುತ್ತೇನೆ. ವಾಸ್ತವವಾಗಿ, ಓದುಗರು ಈ ಬ್ಲಾಕ್‌ಚೈನ್ ಅಂಶಗಳ ಸ್ವಂತ ಆವೃತ್ತಿಗಳನ್ನು ಸಹ ಬರೆಯಬಹುದು.
— ಬ್ಲಾಕ್‌ಚೈನ್ ಮತ್ತು ವಹಿವಾಟು ಡೇಟಾ ರಚನೆಗಳ ಬಗ್ಗೆ, ಹಾಗೆಯೇ ಡೇಟಾಬೇಸ್‌ನೊಂದಿಗೆ ಸಂವಹನವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಪ್ಯಾಕೇಜ್ ಬಗ್ಗೆ.
ಕಳೆದ ವರ್ಷ, ಡಿಜಿಟಲ್ ಬ್ರೇಕ್‌ಥ್ರೂ ಹ್ಯಾಕಥಾನ್‌ನಲ್ಲಿ, ಅವರು ವಿತರಿಸಿದ ಲೆಡ್ಜರ್ ತಂತ್ರಜ್ಞಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಉದ್ಯಮ ಮತ್ತು ಡಿಜಿಟಲ್ ಆರ್ಥಿಕತೆಗೆ ಉಪಯುಕ್ತವಾದ ವ್ಯವಸ್ಥೆಯನ್ನು ಮಾಡುವ ಕಲ್ಪನೆಯನ್ನು ಮಾಡಿದರು; ಇನ್ನೋವೇಶನ್ ಅಸಿಸ್ಟೆನ್ಸ್ ಫಂಡ್‌ನಿಂದ ಅಭಿವೃದ್ಧಿಗೆ ಅನುದಾನವನ್ನು ಸಹ ನೀಡಲಾಯಿತು (ನಾನು ಪ್ರತ್ಯೇಕ ಬರೆಯಬೇಕು ಕೇವಲ ಸ್ಟಾರ್ಟ್‌ಅಪ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತಿರುವವರಿಗೆ ಅನುದಾನದ ಕುರಿತು ಲೇಖನ ), ಮತ್ತು ಈಗ ಕ್ರಮವಾಗಿ.
ಅಭಿವೃದ್ಧಿಯು ಗೋ ಭಾಷೆಯಲ್ಲಿ ನಡೆಯುತ್ತದೆ ಮತ್ತು ಬ್ಲಾಕ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿರುವ ಡೇಟಾಬೇಸ್ LevelDB ಆಗಿದೆ.
ಮುಖ್ಯ ಭಾಗಗಳೆಂದರೆ ಪ್ರೋಟೋಕಾಲ್, ಸರ್ವರ್ (ಇದು TCP ಮತ್ತು WebSocket ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ - ಮೊದಲನೆಯದು ಬ್ಲಾಕ್‌ಚೈನ್ ಅನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು, ಎರಡನೆಯದು ಕ್ಲೈಂಟ್‌ಗಳನ್ನು ಸಂಪರ್ಕಿಸಲು, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಿಂದ ವಹಿವಾಟುಗಳು ಮತ್ತು ಆಜ್ಞೆಗಳನ್ನು ಕಳುಹಿಸಲು, ಉದಾಹರಣೆಗೆ.
ಹೇಳಿದಂತೆ, ಈ ಬ್ಲಾಕ್‌ಚೈನ್ ಪ್ರಾಥಮಿಕವಾಗಿ ಪೂರೈಕೆದಾರರು ಮತ್ತು ಗ್ರಾಹಕರ ನಡುವೆ ಉತ್ಪನ್ನಗಳ ವಿನಿಮಯವನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಮತ್ತು ರಕ್ಷಿಸಲು ಅಥವಾ ಒಬ್ಬ ವ್ಯಕ್ತಿಯಲ್ಲಿ ಅಗತ್ಯವಿದೆ. ಈ ಜನರು ಪರಸ್ಪರ ನಂಬಲು ಯಾವುದೇ ಆತುರವಿಲ್ಲ. ಆದರೆ ಕಾರ್ಯವು ಅಂತರ್ನಿರ್ಮಿತ ಕ್ಯಾಲ್ಕುಲೇಟರ್ನೊಂದಿಗೆ "ಚೆಕ್ಬುಕ್" ಅನ್ನು ರಚಿಸುವುದು ಮಾತ್ರವಲ್ಲ, ಆದರೆ ಉತ್ಪನ್ನ ಜೀವನ ಚಕ್ರದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಉಂಟಾಗುವ ಹೆಚ್ಚಿನ ಸಾಮಾನ್ಯ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ. ಬ್ಲಾಕ್‌ಚೈನ್‌ಗಳೊಂದಿಗೆ ವಾಡಿಕೆಯಂತೆ ಈ ವಿಷಯಕ್ಕೆ ಜವಾಬ್ದಾರರಾಗಿರುವ ಬೈಟ್‌ಕೋಡ್ ಅನ್ನು ವಹಿವಾಟುಗಳ ಇನ್‌ಪುಟ್ ಮತ್ತು ಔಟ್‌ಪುಟ್‌ಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ (ವಹಿವಾಟುಗಳನ್ನು ಸ್ವತಃ ಬ್ಲಾಕ್‌ಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ, ಲೆವೆಲ್‌ಡಿಬಿಯಲ್ಲಿನ ಬ್ಲಾಕ್‌ಗಳನ್ನು GOB ಸ್ವರೂಪದಲ್ಲಿ ಮೊದಲೇ ಎನ್‌ಕೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ). ಮೊದಲಿಗೆ, ಪ್ರೋಟೋಕಾಲ್ ಮತ್ತು ಸರ್ವರ್ (ಅಕಾ ನೋಡ್) ಬಗ್ಗೆ ಮಾತನಾಡೋಣ.
ಪ್ರೋಟೋಕಾಲ್ ಸಂಕೀರ್ಣವಾಗಿಲ್ಲ, ವಿಶೇಷ ಆಜ್ಞಾ ಸಾಲಿಗೆ ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ ಕೆಲವು ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡುವ ವಿಧಾನಕ್ಕೆ ಬದಲಾಯಿಸುವುದು, ಸಾಮಾನ್ಯವಾಗಿ ಬ್ಲಾಕ್ ಅಥವಾ ವಹಿವಾಟು, ಮತ್ತು ದಾಸ್ತಾನು ವಿನಿಮಯಕ್ಕಾಗಿ ಇದು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ, ಇದರಿಂದ ನೋಡ್ ಅದು ಯಾರೆಂದು ತಿಳಿಯುತ್ತದೆ. ಸಂಪರ್ಕಿಸಲಾಗಿದೆ ಮತ್ತು ಅವರು ಹೇಗೆ ವ್ಯವಹಾರವನ್ನು ಮಾಡುತ್ತಾರೆ (ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಸೆಷನ್‌ಗಾಗಿ ಸಂಪರ್ಕಗೊಂಡಿರುವ ನೋಡ್‌ಗಳನ್ನು "ನೆರೆಹೊರೆಯ" ಎಂದೂ ಕರೆಯುತ್ತಾರೆ ಏಕೆಂದರೆ ಅವರ ಐಪಿ ತಿಳಿದಿದೆ ಮತ್ತು ಅವರ ರಾಜ್ಯದ ಡೇಟಾವನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ).
ಗೋ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳ ತಿಳುವಳಿಕೆಯಲ್ಲಿ ಫೋಲ್ಡರ್‌ಗಳು (ಡೈರೆಕ್ಟರಿಗಳು ಅವುಗಳನ್ನು ಲಿನಕ್ಸ್ ಎಂದು ಕರೆಯುತ್ತವೆ) ಪ್ಯಾಕೇಜ್‌ಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಈ ಡೈರೆಕ್ಟರಿಯಿಂದ ಗೋ ಕೋಡ್‌ನೊಂದಿಗೆ ಪ್ರತಿ ಫೈಲ್‌ನ ಪ್ರಾರಂಭದಲ್ಲಿ ಅವರು ಪ್ಯಾಕೇಜ್ folder_name_where_this_file ಇದೆ ಎಂದು ಬರೆಯುತ್ತಾರೆ. ಇಲ್ಲದಿದ್ದರೆ, ಕಂಪೈಲರ್‌ಗೆ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಫೀಡ್ ಮಾಡಲು ನಿಮಗೆ ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ. ಸರಿ, ಈ ಭಾಷೆ ತಿಳಿದಿರುವವರಿಗೆ ಇದು ರಹಸ್ಯವಲ್ಲ. ಇವು ಪ್ಯಾಕೇಜ್‌ಗಳು:
- ನೆಟ್ವರ್ಕ್ ಸಂವಹನ (ಸರ್ವರ್, ಕ್ಲೈಂಟ್, ಪ್ರೋಟೋಕಾಲ್)
- ಸಂಗ್ರಹಿಸಿದ ಮತ್ತು ರವಾನೆಯಾದ ಡೇಟಾದ ರಚನೆಗಳು (ಬ್ಲಾಕ್, ವಹಿವಾಟು)
- ಡೇಟಾಬೇಸ್ (ಬ್ಲಾಕ್‌ಚೈನ್)
- ಒಮ್ಮತ
- ಜೋಡಿಸಲಾದ ವರ್ಚುವಲ್ ಯಂತ್ರ (xvm)
- ಸಹಾಯಕ (ಕ್ರಿಪ್ಟೋ, ಪ್ರಕಾರಗಳು) ಸದ್ಯಕ್ಕೆ ಅಷ್ಟೆ.
ಇದು ಶೈಕ್ಷಣಿಕ ಆವೃತ್ತಿಯಾಗಿದೆ, ಇದು ಅಂತರ್-ಪ್ರಕ್ರಿಯೆಯ ಸಂವಹನ ಮತ್ತು ಹಲವಾರು ಪ್ರಾಯೋಗಿಕ ಘಟಕಗಳನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ, ಆದರೆ ರಚನೆಯು ಅಭಿವೃದ್ಧಿಯನ್ನು ಕೈಗೊಳ್ಳುವ ಒಂದಕ್ಕೆ ಅನುರೂಪವಾಗಿದೆ. ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ಸಲಹೆ ನೀಡಲು ನೀವು ಏನನ್ನಾದರೂ ಹೊಂದಿದ್ದರೆ, ಮುಂದಿನ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಅದನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಲು ನಾನು ಸಂತೋಷಪಡುತ್ತೇನೆ. ಮತ್ತು ಈಗ ಸರ್ವರ್ನ ವಿವರಣೆಗಾಗಿ ಮತ್ತು ಪ್ರೋಟೋಕಾಲ್.
ಮೊದಲು ಸರ್ವರ್ ಅನ್ನು ನೋಡೋಣ.
ಪ್ರೋಟೋಕಾಲ್ ಪ್ಯಾಕೇಜ್‌ನಿಂದ ಡೇಟಾ ರಚನೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು TCP ಪ್ರೋಟೋಕಾಲ್ನ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಚಲಿಸುವ ಡೇಟಾ ಸರ್ವರ್ ಆಗಿ ಸರ್ವರ್ ಸಬ್ರುಟೀನ್ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
ದಿನಚರಿಯು ಈ ಕೆಳಗಿನ ಪ್ಯಾಕೇಜುಗಳನ್ನು ಬಳಸುತ್ತದೆ: ಸರ್ವರ್, ಪ್ರೋಟೋಕಾಲ್, ರೀತಿಯ. ಪ್ಯಾಕೇಜ್ನಲ್ಲಿಯೇ tcp_server.go ಡೇಟಾ ರಚನೆಯನ್ನು ಒಳಗೊಂಡಿದೆ ಸೇವೆ ಮಾಡಿ.
type Serve struct {
Port string
BufSize int
ST *types.Settings
}ಇದು ಕೆಳಗಿನ ನಿಯತಾಂಕಗಳನ್ನು ಸ್ವೀಕರಿಸಬಹುದು:
- ನೆಟ್ವರ್ಕ್ ಪೋರ್ಟ್ ಮೂಲಕ ಡೇಟಾವನ್ನು ವಿನಿಮಯ ಮಾಡಿಕೊಳ್ಳಲಾಗುತ್ತದೆ
- JSON ಸ್ವರೂಪದಲ್ಲಿ ಸರ್ವರ್ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್
- ಡೀಬಗ್ ಮೋಡ್‌ನಲ್ಲಿ ಚಾಲನೆ ಮಾಡಲು ಫ್ಲ್ಯಾಗ್ ಮಾಡಿ (ಖಾಸಗಿ ಬ್ಲಾಕ್‌ಚೈನ್)
ಪ್ರಗತಿ:
- JSON ಫೈಲ್‌ನಿಂದ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಓದುತ್ತದೆ
- ಡೀಬಗ್ ಮೋಡ್ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲಾಗಿದೆ: ಅದನ್ನು ಹೊಂದಿಸಿದ್ದರೆ, ನೆಟ್ವರ್ಕ್ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿಲ್ಲ ಮತ್ತು ಬ್ಲಾಕ್‌ಚೈನ್ ಲೋಡ್ ಆಗುವುದಿಲ್ಲ
- ಕಾನ್ಫಿಗರೇಶನ್ ಡೇಟಾ ರಚನೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವುದು ಮತ್ತು ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವುದು
ಸರ್ವರ್
- ಪ್ರೋಟೋಕಾಲ್ಗೆ ಅನುಗುಣವಾಗಿ TCP ಸರ್ವರ್ ಮತ್ತು ನೆಟ್ವರ್ಕ್ ಸಂವಹನದ ಉಡಾವಣೆಯನ್ನು ಕೈಗೊಳ್ಳುತ್ತದೆ.
- ಇದು ಪೋರ್ಟ್ ಸಂಖ್ಯೆ, ಬಫರ್ ಗಾತ್ರ ಮತ್ತು ರಚನೆಗೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಸರ್ವ್ ಡೇಟಾ ರಚನೆಯನ್ನು ಹೊಂದಿದೆ ಪ್ರಕಾರಗಳು.ಸೆಟ್ಟಿಂಗ್‌ಗಳು
- ರನ್ ವಿಧಾನವು ನೆಟ್ವರ್ಕ್ ಸಂವಹನವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ (ಕೊಟ್ಟಿರುವ ಪೋರ್ಟ್‌ನಲ್ಲಿ ಒಳಬರುವ ಸಂಪರ್ಕಗಳನ್ನು ಆಲಿಸುವುದು, ಹೊಸ ಸಂಪರ್ಕವನ್ನು ಸ್ವೀಕರಿಸಿದಾಗ, ಅದರ ಸಂಸ್ಕರಣೆಯನ್ನು ಹೊಸ ಥ್ರೆಡ್‌ನಲ್ಲಿ ಖಾಸಗಿ ಹ್ಯಾಂಡಲ್ ವಿಧಾನಕ್ಕೆ ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ)
- В ನಿರ್ವಹಿಸು ಸಂಪರ್ಕದಿಂದ ಡೇಟಾವನ್ನು ಬಫರ್ ಆಗಿ ಓದಲಾಗುತ್ತದೆ, ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯಕ್ಕೆ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ರವಾನಿಸಲಾಗುತ್ತದೆ ಪ್ರೋಟೋಕಾಲ್.ಆಯ್ಕೆ
- ಪ್ರೋಟೋಕಾಲ್.ಆಯ್ಕೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಫಲಿತಾಂಶ ಅಥವಾ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಫಲಿತಾಂಶ ನಂತರ ವರ್ಗಾಯಿಸಲಾಯಿತು ಪ್ರೋಟೋಕಾಲ್. ವ್ಯಾಖ್ಯಾನಹಿಂದಿರುಗಿಸುತ್ತದೆ intrpr - ಪ್ರಕಾರದ ವಸ್ತು ಇಂಟರ್ಪ್ರಿಟೆಡೇಟಾ, ಅಥವಾ ಆಯ್ಕೆಯ ಫಲಿತಾಂಶವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಲ್ಲಿ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ
- ನಂತರ ಸ್ವಿಚ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ intrpr.ಕಮಾಂಡ್‌ಗಳು[0] ಇವುಗಳಲ್ಲಿ ಒಂದನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ: ಫಲಿತಾಂಶ, ಇನ್ವಿ, ದೋಷ ಮತ್ತು ಒಂದು ವಿಭಾಗವಿದೆ ಡೀಫಾಲ್ಟ್
- ವಿಭಾಗದಲ್ಲಿ ಫಲಿತಾಂಶ ಸ್ವಿಚ್ ಮೌಲ್ಯದಿಂದ ಕಂಡುಬರುತ್ತದೆ intrpr.ಕಮಾಂಡ್‌ಗಳು[1] ಇದು ಮೌಲ್ಯಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಬಫರ್ ಉದ್ದ и ಆವೃತ್ತಿ (ಪ್ರತಿ ಸಂದರ್ಭದಲ್ಲಿ ಅನುಗುಣವಾದ ಕಾರ್ಯವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ)
ಕಾರ್ಯಗಳು ಗೆಟ್ ಆವೃತ್ತಿ и ಬಫರ್ ಉದ್ದ ಕಡತದಲ್ಲಿದೆ srvlib.go ಸರ್ವರ್ ಪ್ಯಾಕೇಜ್
GetVersion(conn net.Conn, version string)ಇದು ಸರಳವಾಗಿ ಕನ್ಸೋಲ್‌ಗೆ ಮುದ್ರಿಸುತ್ತದೆ ಮತ್ತು ಪ್ಯಾರಾಮೀಟರ್‌ನಲ್ಲಿ ರವಾನಿಸಲಾದ ಆವೃತ್ತಿಯನ್ನು ಕ್ಲೈಂಟ್‌ಗೆ ಕಳುಹಿಸುತ್ತದೆ:
conn.Write([]byte("result:" + version)).
ಕಾರ್ಯ
BufferLength(conn net.Conn, intrpr *protocol.InterpreteData)ಬ್ಲಾಕ್, ವಹಿವಾಟು ಅಥವಾ ಇತರ ನಿರ್ದಿಷ್ಟ ಡೇಟಾವನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಲೋಡ್ ಮಾಡುತ್ತದೆ:
- ಅಂಗೀಕರಿಸಬೇಕಾದ ಪ್ರೋಟೋಕಾಲ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಮುದ್ರಿಸುತ್ತದೆ:
fmt.Println("DataType:", intrpr.Commands[2]) - ಮೌಲ್ಯವನ್ನು ಓದುತ್ತದೆ intrpr.ದೇಹ ಸಂಖ್ಯಾತ್ಮಕ ವೇರಿಯಬಲ್‌ಗೆ ಬಫ್_ಲೆನ್
- ಬಫರ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ ಹೊಸಬಫ್ ನಿಗದಿತ ಗಾತ್ರ:
make([]byte, buf_len) - ಸರಿ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಕಳುಹಿಸುತ್ತದೆ:
conn.Write([]byte("result:ok")) - ಓದುವ ಸ್ಟ್ರೀಮ್‌ನಿಂದ ಬಫರ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತುಂಬುತ್ತದೆ:
io.ReadFull(conn, newbuf).
- ಬಫರ್‌ನ ವಿಷಯಗಳನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಮುದ್ರಿಸುತ್ತದೆ
fmt.Println(string(newbuf))ಮತ್ತು ಓದುವ ಬೈಟ್‌ಗಳ ಸಂಖ್ಯೆ
fmt.Println("Bytes length:", n) - ಸರಿ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಕಳುಹಿಸುತ್ತದೆ:
conn.Write([]byte("result:ok"))
ಪ್ಯಾಕೇಜಿನಿಂದ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ವೀಕರಿಸಿದ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸರ್ವರ್ ಪ್ಯಾಕೇಜ್‌ನಿಂದ ವಿಧಾನಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ ಪ್ರೋಟೋಕಾಲ್.
ಪ್ರೋಟೋಕಾಲ್
ಪ್ರೋಟೋಕಾಲ್ ನೆಟ್ವರ್ಕ್ ವಿನಿಮಯದಲ್ಲಿ ಡೇಟಾವನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಸಾಧನವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
ಆಯ್ಕೆ(ಸ್ಟ್ರಿಂಗ್) (ಸ್ಟ್ರಿಂಗ್, ದೋಷ) ಸರ್ವರ್ ಸ್ವೀಕರಿಸಿದ ಡೇಟಾದ ಪ್ರಾಥಮಿಕ ಸಂಸ್ಕರಣೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ, ಡೇಟಾದ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಇನ್‌ಪುಟ್ ಆಗಿ ಸ್ವೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಸಿದ್ಧಪಡಿಸಿದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಇಂಟರ್ಪ್ರಿಟರ್:
- ಇನ್‌ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ತಲೆ ಮತ್ತು ದೇಹವಾಗಿ ವಿಭಜಿಸಲಾಗಿದೆ ReqParseN2(str)
- ತಲೆಯನ್ನು ಅಂಶಗಳಾಗಿ ವಿಭಜಿಸಲಾಗಿದೆ ಮತ್ತು ReqParseHead(ಹೆಡ್) ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕಮಾಂಡ್ಸ್ ಸ್ಲೈಸ್ ಆಗಿ ಇರಿಸಲಾಗುತ್ತದೆ
- В ಸ್ವಿಚ್ (ಆಜ್ಞೆಗಳು[0]) ಸ್ವೀಕರಿಸಿದ ಆಜ್ಞೆಯನ್ನು ಆಯ್ಕೆಮಾಡಿ (cmd, ಕೀ, ವಿಳಾಸ ಅಥವಾ ವಿಭಾಗವನ್ನು ಪ್ರಚೋದಿಸಲಾಗಿದೆ ಡೀಫಾಲ್ಟ್)
- 2 ಆಜ್ಞೆಗಳನ್ನು cmd ನಲ್ಲಿ ಪರಿಶೀಲಿಸಲಾಗಿದೆ ಸ್ವಿಚ್ (ಆಜ್ಞೆಗಳು[1]) - ಉದ್ದ и ಪಡೆಯುವಿಕೆ.
- ಉದ್ದ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಆಜ್ಞೆಗಳು[2] ಮತ್ತು ಅದನ್ನು ಉಳಿಸುತ್ತದೆ ಡೇಟಾಟೈಪ್
- ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ದೇಹದ ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯವನ್ನು ಒಳಗೊಂಡಿದೆ
len(body) < 1 - ಪ್ರತಿಕ್ರಿಯೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ:
"result:bufferlength:" + datatype + "/" + body - ಪಡೆಯುವಿಕೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
return "result:version/auto"
ಇಂಟರ್ಪ್ರಿಟರ್
ಇಂಟರ್‌ಪ್ರೆಟ್‌ಡೇಟಾ ರಚನೆಯನ್ನು ಒಳಗೊಂಡಿದೆ ಮತ್ತು ಹಿಂತಿರುಗಿದ ಡೇಟಾದ ದ್ವಿತೀಯ ಸಂಸ್ಕರಣೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಚಾಯ್ಸ್ ತಂತಿಗಳು ಮತ್ತು ವಸ್ತುವಿನ ರಚನೆ ಇಂಟರ್ಪ್ರಿಟೆಡೇಟಾ.
type InterpreteData struct {
Head string
Commands []string
Body string
IsErr bool
ErrCode int
ErrMessage string
}ಕಾರ್ಯ
Interprete(str string) (*InterpreteData, error)ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ ಫಲಿತಾಂಶ ಮತ್ತು ವಸ್ತುವಿನ ಉಲ್ಲೇಖವನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಇಂಟರ್ಪ್ರಿಟೆಡೇಟಾ.
ಪ್ರಗತಿ:
- ಹಾಗೆಯೇ ಚಾಯ್ಸ್ ತಲೆ ಮತ್ತು ದೇಹವನ್ನು ಬಳಸಿ ಹೊರತೆಗೆಯಲಾಗುತ್ತದೆ ReqParseN2(str)
- ತಲೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಅಂಶಗಳಾಗಿ ವಿಭಜಿಸಲಾಗಿದೆ ReqParseHead(ತಲೆ)
- ವಸ್ತುವನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ ಇಂಟರ್ಪ್ರಿಟೆಡೇಟಾ ಮತ್ತು ಅದರ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ:
res := &InterpreteData{
Head: head,
Commands: commands,
Body: body,
}
return res, nilಈ ವಸ್ತುವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಸರ್ವರ್.ಗೋ ಪ್ಯಾಕೇಜ್ ಮುಖ್ಯ.
ಕ್ಲೈಂಟ್
ಕ್ಲೈಂಟ್ ಪ್ಯಾಕೇಜ್ ಕಾರ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ TCPConnect и TCPResponseData.
ಕಾರ್ಯ
TCPConnect(s *types.Settings, data []byte, payload []byte)ಈ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ:
- ರವಾನಿಸಲಾದ ಸೆಟ್ಟಿಂಗ್‌ಗಳ ವಸ್ತುವಿನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸಂಪರ್ಕಕ್ಕೆ ಸಂಪರ್ಕವನ್ನು ಮಾಡಲಾಗಿದೆ
net.Dial("tcp", s.Host + ":" + s.Port) - ಡೇಟಾ ಪ್ಯಾರಾಮೀಟರ್‌ನಲ್ಲಿ ರವಾನಿಸಲಾದ ಡೇಟಾವನ್ನು ರವಾನಿಸಲಾಗುತ್ತದೆ:
conn.Write(data) - ಉತ್ತರವನ್ನು ಓದಲಾಗಿದೆ
resp, n, _ := TCPResponseData(conn, s.BufSize)ಮತ್ತು ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಮುದ್ರಿಸಲಾಗಿದೆ
fmt.Println(string(resp[:n])) - ವರ್ಗಾವಣೆ ಮಾಡಿದರೆ ಪೇಲೋಡ್ ನಂತರ ಅದನ್ನು ಹಾದುಹೋಗುತ್ತದೆ
conn.Write(payload)ಮತ್ತು ಸರ್ವರ್ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಓದುತ್ತದೆ, ಅದನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಮುದ್ರಿಸುತ್ತದೆ
ಕಾರ್ಯ
TCPResponseData(conn net.Conn, bufsiz int) ([]byte, int, error)ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಗಾತ್ರದ ಬಫರ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಸರ್ವರ್ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಓದುತ್ತದೆ ಮತ್ತು ಈ ಬಫರ್ ಮತ್ತು ಓದುವ ಬೈಟ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಜೊತೆಗೆ ದೋಷ ವಸ್ತುವನ್ನು ನೀಡುತ್ತದೆ.
ಕ್ಲೈಂಟ್ ಸಬ್ರುಟೀನ್
ನೋಡ್ ಸರ್ವರ್‌ಗಳಿಗೆ ಆಜ್ಞೆಗಳನ್ನು ಕಳುಹಿಸಲು, ಹಾಗೆಯೇ ಸಂಕ್ಷಿಪ್ತ ಅಂಕಿಅಂಶಗಳು ಮತ್ತು ಪರೀಕ್ಷೆಯನ್ನು ಪಡೆಯಲು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
ಕೆಳಗಿನ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸಬಹುದು: JSON ಸ್ವರೂಪದಲ್ಲಿ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್, ಸ್ಟ್ರಿಂಗ್‌ನಂತೆ ಸರ್ವರ್‌ಗೆ ಕಳುಹಿಸಬೇಕಾದ ಡೇಟಾ, ಪೇಲೋಡ್‌ಗೆ ಕಳುಹಿಸಬೇಕಾದ ಫೈಲ್‌ಗೆ ಮಾರ್ಗ, ನೋಡ್ ಶೆಡ್ಯೂಲರ್ ಎಮ್ಯುಲೇಶನ್ ಫ್ಲ್ಯಾಗ್, ಸಂಖ್ಯಾ ಮೌಲ್ಯವಾಗಿ ವರ್ಗಾಯಿಸಲಾದ ಡೇಟಾದ ಪ್ರಕಾರ.
- ಸಂರಚನೆಯನ್ನು ಪಡೆಯಲಾಗುತ್ತಿದೆ
st := types.ParseConfig(*config) - ಎಮು ಧ್ವಜವನ್ನು ರವಾನಿಸಿದರೆ, ಅದು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಶೆಡ್ಯೂಲರ್
- ಫೈಲ್‌ಗೆ ಮಾರ್ಗವನ್ನು ಸೂಚಿಸುವ f ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಒದಗಿಸಿದರೆ, ನಾವು ಅದರ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡುತ್ತೇವೆ fdb ಮತ್ತು ವಿಷಯವನ್ನು ಸರ್ವರ್‌ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ
client.TCPConnect(st, []byte(CMD_BUFFER_LENGTH + ":" + strconv.Itoa(*t) + "/" + strconv.Itoa(fdblen)), fdb) - ಫೈಲ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, ನಂತರ ಫ್ಲ್ಯಾಗ್ನಿಂದ ಡೇಟಾವನ್ನು ಸರಳವಾಗಿ ಕಳುಹಿಸಲಾಗುತ್ತದೆ -d:
client.TCPConnect(st, []byte(*data), nil)
ಇದೆಲ್ಲವೂ ಪ್ರೋಟೋಕಾಲ್ನ ರಚನೆಯನ್ನು ತೋರಿಸುವ ಸರಳೀಕೃತ ಪ್ರಾತಿನಿಧ್ಯವಾಗಿದೆ. ಅಭಿವೃದ್ಧಿಯ ಸಮಯದಲ್ಲಿ, ಅದರ ರಚನೆಗೆ ಅಗತ್ಯವಾದ ಕಾರ್ಯವನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ.
ಎರಡನೇ ಭಾಗದಲ್ಲಿ ನಾನು ಬ್ಲಾಕ್‌ಗಳು ಮತ್ತು ವಹಿವಾಟುಗಳಿಗಾಗಿ ಡೇಟಾ ರಚನೆಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇನೆ, 3 ರಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಿಂದ ಸಂಪರ್ಕಿಸಲು ವೆಬ್‌ಸಾಕೆಟ್ ಸರ್ವರ್ ಬಗ್ಗೆ, 4 ರಲ್ಲಿ ನಾನು ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ನೋಡುತ್ತೇನೆ, ನಂತರ ಇನ್‌ಪುಟ್ ಮತ್ತು ಔಟ್‌ಪುಟ್‌ಗಳಿಂದ ಬೈಟ್‌ಕೋಡ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಸ್ಟಾಕ್ ಯಂತ್ರ, ಕ್ರಿಪ್ಟೋಗ್ರಫಿ ಮತ್ತು ಔಟ್ಪುಟ್ಗಳಿಗಾಗಿ ಪೂಲ್ಗಳು.
ಮೂಲ: www.habr.com