ਗੋ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਉਦਯੋਗ ਲਈ ਬਲਾਕਚੈਨ ਵਿਕਾਸ। ਭਾਗ 1

ਹੁਣ ਮੈਂ ਚਾਰ ਮਹੀਨਿਆਂ ਤੋਂ "ਬਲਾਕਚੇਨ 'ਤੇ ਆਧਾਰਿਤ ਸਰਕਾਰੀ ਅਤੇ ਉਦਯੋਗਿਕ ਖੇਤਰਾਂ ਵਿੱਚ ਡਾਟਾ ਸੁਰੱਖਿਆ ਅਤੇ ਪ੍ਰਬੰਧਨ ਸਾਧਨਾਂ ਦਾ ਵਿਕਾਸ" ਨਾਮਕ ਇੱਕ ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਕੰਮ ਕਰ ਰਿਹਾ ਹਾਂ।
ਹੁਣ ਮੈਂ ਤੁਹਾਨੂੰ ਇਹ ਦੱਸਣਾ ਚਾਹਾਂਗਾ ਕਿ ਮੈਂ ਇਸ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਕਿਵੇਂ ਸ਼ੁਰੂ ਕੀਤਾ, ਅਤੇ ਹੁਣ ਮੈਂ ਪ੍ਰੋਗਰਾਮ ਦੇ ਕੋਡ ਦਾ ਵਿਸਥਾਰ ਵਿੱਚ ਵਰਣਨ ਕਰਾਂਗਾ।

ਲੇਖਾਂ ਦੀ ਲੜੀ ਵਿੱਚ ਇਹ ਪਹਿਲਾ ਲੇਖ ਹੈ। ਇੱਥੇ ਮੈਂ ਸਰਵਰ ਅਤੇ ਪ੍ਰੋਟੋਕੋਲ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹਾਂ. ਵਾਸਤਵ ਵਿੱਚ, ਪਾਠਕ ਇਹਨਾਂ ਬਲਾਕਚੈਨ ਤੱਤਾਂ ਦੇ ਆਪਣੇ ਸੰਸਕਰਣ ਵੀ ਲਿਖ ਸਕਦਾ ਹੈ.

ਅਤੇ ਇੱਥੇ ਦੂਜਾ ਭਾਗ ਹੈ — ਬਲਾਕਚੈਨ ਅਤੇ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਡੇਟਾ ਸਟ੍ਰਕਚਰ ਬਾਰੇ, ਨਾਲ ਹੀ ਉਸ ਪੈਕੇਜ ਬਾਰੇ ਜੋ ਡੇਟਾਬੇਸ ਨਾਲ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।

ਪਿਛਲੇ ਸਾਲ, ਡਿਜੀਟਲ ਬ੍ਰੇਕਥਰੂ ਹੈਕਾਥਨ ਵਿੱਚ, ਉਹਨਾਂ ਨੇ ਡਿਸਟ੍ਰੀਬਿਊਟਡ ਲੇਜ਼ਰ ਤਕਨਾਲੋਜੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਉਦਯੋਗ ਅਤੇ ਡਿਜੀਟਲ ਅਰਥਵਿਵਸਥਾ ਲਈ ਇੱਕ ਉਪਯੋਗੀ ਪ੍ਰਣਾਲੀ ਬਣਾਉਣ ਲਈ ਇੱਕ ਵਿਚਾਰ ਲਿਆਇਆ; ਇਨੋਵੇਸ਼ਨ ਅਸਿਸਟੈਂਸ ਫੰਡ ਦੁਆਰਾ ਵਿਕਾਸ ਲਈ ਇੱਕ ਗ੍ਰਾਂਟ ਵੀ ਜਾਰੀ ਕੀਤੀ ਗਈ ਸੀ (ਮੈਨੂੰ ਇੱਕ ਵੱਖਰਾ ਲਿਖਣਾ ਚਾਹੀਦਾ ਹੈ। ਗ੍ਰਾਂਟ ਬਾਰੇ ਲੇਖ, ਉਹਨਾਂ ਲਈ ਜੋ ਹੁਣੇ ਹੀ ਸਟਾਰਟਅੱਪ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਰਹੇ ਹਨ ), ਅਤੇ ਹੁਣ ਕ੍ਰਮ ਵਿੱਚ।

ਵਿਕਾਸ ਗੋ ਭਾਸ਼ਾ ਵਿੱਚ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਡੇਟਾਬੇਸ ਜਿਸ ਵਿੱਚ ਬਲਾਕ ਸਟੋਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ LevelDB ਹੈ।
ਮੁੱਖ ਹਿੱਸੇ ਪ੍ਰੋਟੋਕੋਲ ਹਨ, ਸਰਵਰ (ਜੋ TCP ਅਤੇ WebSocket ਚਲਾਉਂਦਾ ਹੈ - ਬਲਾਕਚੈਨ ਨੂੰ ਸਮਕਾਲੀ ਕਰਨ ਲਈ ਪਹਿਲਾ, ਦੂਸਰਾ ਗਾਹਕਾਂ ਨੂੰ ਜੋੜਨ ਲਈ, ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਤੋਂ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਅਤੇ ਕਮਾਂਡਾਂ ਭੇਜਣ ਲਈ, ਉਦਾਹਰਨ ਲਈ।

ਜਿਵੇਂ ਕਿ ਜ਼ਿਕਰ ਕੀਤਾ ਗਿਆ ਸੀ, ਇਸ ਬਲਾਕਚੈਨ ਦੀ ਲੋੜ ਮੁੱਖ ਤੌਰ 'ਤੇ ਸਪਲਾਇਰਾਂ ਅਤੇ ਗਾਹਕਾਂ, ਜਾਂ ਇੱਕ ਵਿਅਕਤੀ ਵਿੱਚ ਦੋਵਾਂ ਵਿਚਕਾਰ ਉਤਪਾਦਾਂ ਦੇ ਆਦਾਨ-ਪ੍ਰਦਾਨ ਨੂੰ ਸਵੈਚਾਲਤ ਅਤੇ ਸੁਰੱਖਿਆ ਲਈ ਹੈ। ਇਹ ਲੋਕ ਇਕ-ਦੂਜੇ 'ਤੇ ਭਰੋਸਾ ਕਰਨ ਦੀ ਕੋਈ ਕਾਹਲੀ ਵਿਚ ਨਹੀਂ ਹਨ। ਪਰ ਕੰਮ ਸਿਰਫ ਇੱਕ ਬਿਲਟ-ਇਨ ਕੈਲਕੁਲੇਟਰ ਨਾਲ "ਚੈੱਕਬੁੱਕ" ਬਣਾਉਣਾ ਨਹੀਂ ਹੈ, ਪਰ ਇੱਕ ਸਿਸਟਮ ਜੋ ਉਤਪਾਦ ਦੇ ਜੀਵਨ ਚੱਕਰ ਨਾਲ ਕੰਮ ਕਰਨ ਵੇਲੇ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਜ਼ਿਆਦਾਤਰ ਰੁਟੀਨ ਕੰਮਾਂ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਦਾ ਹੈ। ਬਾਈਟਕੋਡ ਜੋ ਇਸ ਮਾਮਲੇ ਲਈ ਜਿੰਮੇਵਾਰ ਹੈ, ਜਿਵੇਂ ਕਿ ਬਲਾਕਚੈਨ ਦੇ ਨਾਲ ਰਿਵਾਜ ਹੈ, ਲੈਣ-ਦੇਣ ਦੇ ਇਨਪੁਟਸ ਅਤੇ ਆਉਟਪੁੱਟਾਂ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ (ਲੈਣ-ਦੇਣ ਖੁਦ ਬਲਾਕਾਂ ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਲੈਵਲਡੀਬੀ ਵਿੱਚ ਬਲਾਕ GOB ਫਾਰਮੈਟ ਵਿੱਚ ਪ੍ਰੀ-ਏਨਕੋਡ ਕੀਤੇ ਜਾਂਦੇ ਹਨ)। ਪਹਿਲਾਂ, ਆਓ ਪ੍ਰੋਟੋਕੋਲ ਅਤੇ ਸਰਵਰ (ਉਰਫ਼ ਨੋਡ) ਬਾਰੇ ਗੱਲ ਕਰੀਏ।

ਪ੍ਰੋਟੋਕੋਲ ਗੁੰਝਲਦਾਰ ਨਹੀਂ ਹੈ, ਇਸਦਾ ਪੂਰਾ ਬਿੰਦੂ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਕਮਾਂਡ ਲਾਈਨ ਦੇ ਜਵਾਬ ਵਿੱਚ ਕੁਝ ਡੇਟਾ ਲੋਡ ਕਰਨ ਦੇ ਮੋਡ ਵਿੱਚ ਸਵਿਚ ਕਰਨਾ ਹੈ, ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਬਲਾਕ ਜਾਂ ਟ੍ਰਾਂਜੈਕਸ਼ਨ, ਅਤੇ ਇਹ ਵਸਤੂਆਂ ਦਾ ਆਦਾਨ-ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਵੀ ਲੋੜੀਂਦਾ ਹੈ, ਤਾਂ ਜੋ ਨੋਡ ਜਾਣ ਸਕੇ ਕਿ ਇਹ ਕੌਣ ਹੈ। ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ ਅਤੇ ਉਹਨਾਂ ਦਾ ਕਾਰੋਬਾਰ ਕਿਵੇਂ ਕਰਨਾ ਹੈ (ਸਿੰਕਰੋਨਾਈਜ਼ੇਸ਼ਨ ਸੈਸ਼ਨ ਲਈ ਕਨੈਕਟ ਕੀਤੇ ਨੋਡਸ ਨੂੰ "ਨੇਬਰਿੰਗ" ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਉਹਨਾਂ ਦਾ IP ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਦਾ ਸਟੇਟ ਡੇਟਾ ਮੈਮੋਰੀ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ)।

ਫੋਲਡਰ (ਡਾਇਰੈਕਟਰੀਆਂ ਜਿਵੇਂ ਕਿ ਉਹਨਾਂ ਨੂੰ ਲੀਨਕਸ ਕਹਿੰਦੇ ਹਨ) ਨੂੰ ਗੋ ਪ੍ਰੋਗਰਾਮਰ ਦੀ ਸਮਝ ਵਿੱਚ ਪੈਕੇਜ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਇਸ ਲਈ ਇਸ ਡਾਇਰੈਕਟਰੀ ਦੇ ਗੋ ਕੋਡ ਵਾਲੀ ਹਰੇਕ ਫਾਈਲ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਉਹ ਪੈਕੇਜ ਫੋਲਡਰ_ਨਾਮ_where_this_file ਸਥਿਤ ਹੈ ਲਿਖਦੇ ਹਨ। ਨਹੀਂ ਤਾਂ, ਤੁਸੀਂ ਕੰਪਾਈਲਰ ਨੂੰ ਪੈਕੇਜ ਫੀਡ ਕਰਨ ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਵੋਗੇ. ਖੈਰ, ਇਹ ਉਨ੍ਹਾਂ ਲਈ ਕੋਈ ਰਾਜ਼ ਨਹੀਂ ਹੈ ਜੋ ਇਸ ਭਾਸ਼ਾ ਨੂੰ ਜਾਣਦੇ ਹਨ. ਇਹ ਪੈਕੇਜ ਹਨ:

• ਨੈੱਟਵਰਕ ਸੰਚਾਰ (ਸਰਵਰ, ਕਲਾਇੰਟ, ਪ੍ਰੋਟੋਕੋਲ)
• ਸਟੋਰ ਕੀਤੇ ਅਤੇ ਪ੍ਰਸਾਰਿਤ ਕੀਤੇ ਡੇਟਾ ਦੇ ਢਾਂਚੇ (ਬਲਾਕ, ਲੈਣ-ਦੇਣ)
• ਡਾਟਾਬੇਸ (ਬਲਾਕਚੈਨ)
• ਸਹਿਮਤੀ
• ਸਟੈਕਡ ਵਰਚੁਅਲ ਮਸ਼ੀਨ (xvm)
• ਸਹਾਇਕ (ਕ੍ਰਿਪਟੋ, ਕਿਸਮਾਂ) ਬੱਸ ਹੁਣੇ ਹੀ ਹੈ।

ਇੱਥੇ github ਦਾ ਲਿੰਕ ਹੈ

ਇਹ ਇੱਕ ਵਿਦਿਅਕ ਸੰਸਕਰਣ ਹੈ, ਇਸ ਵਿੱਚ ਅੰਤਰ-ਪ੍ਰਕਿਰਿਆ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਅਤੇ ਕਈ ਪ੍ਰਯੋਗਾਤਮਕ ਭਾਗਾਂ ਦੀ ਘਾਟ ਹੈ, ਪਰ ਢਾਂਚਾ ਉਸ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ ਜਿਸ 'ਤੇ ਵਿਕਾਸ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ। ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਸੁਝਾਅ ਦੇਣ ਲਈ ਕੁਝ ਹੈ, ਤਾਂ ਮੈਂ ਇਸਨੂੰ ਹੋਰ ਵਿਕਾਸ ਵਿੱਚ ਧਿਆਨ ਵਿੱਚ ਰੱਖ ਕੇ ਖੁਸ਼ ਹੋਵਾਂਗਾ. ਅਤੇ ਹੁਣ ਸਰਵਰ ਦੀ ਵਿਆਖਿਆ ਲਈ ਅਤੇ ਪ੍ਰੋਟੋਕੋਲ.

ਆਓ ਪਹਿਲਾਂ ਸਰਵਰ ਨੂੰ ਵੇਖੀਏ.

ਸਰਵਰ ਸਬਰੂਟੀਨ ਇੱਕ ਡੇਟਾ ਸਰਵਰ ਦੇ ਤੌਰ ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ ਜੋ ਪ੍ਰੋਟੋਕੋਲ ਪੈਕੇਜ ਤੋਂ ਡੇਟਾ ਢਾਂਚੇ ਦੀ ਵਰਤੋਂ ਕਰਕੇ TCP ਪ੍ਰੋਟੋਕੋਲ ਦੇ ਸਿਖਰ 'ਤੇ ਚੱਲਦਾ ਹੈ।

ਰੁਟੀਨ ਹੇਠ ਦਿੱਤੇ ਪੈਕੇਜਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ: ਸਰਵਰ, ਪ੍ਰੋਟੋਕੋਲ, ਕਿਸਮ. ਪੈਕੇਜ ਵਿੱਚ ਹੀ tcp_server.go ਡਾਟਾ ਬਣਤਰ ਸ਼ਾਮਿਲ ਹੈ ਸੇਵਾ.

type Serve struct {
	Port string
	BufSize int
	ST *types.Settings
}

ਇਹ ਹੇਠ ਦਿੱਤੇ ਮਾਪਦੰਡਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰ ਸਕਦਾ ਹੈ:

• ਨੈੱਟਵਰਕ ਪੋਰਟ ਜਿਸ ਰਾਹੀਂ ਡੇਟਾ ਦਾ ਆਦਾਨ-ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਵੇਗਾ
• JSON ਫਾਰਮੈਟ ਵਿੱਚ ਸਰਵਰ ਸੰਰੂਪਣ ਫ਼ਾਈਲ
• ਡੀਬੱਗ ਮੋਡ (ਨਿੱਜੀ ਬਲਾਕਚੈਨ) ਵਿੱਚ ਚੱਲਣ ਲਈ ਫਲੈਗ ਕਰੋ

ਤਰੱਕੀ:

• JSON ਫਾਈਲ ਤੋਂ ਸੰਰਚਨਾ ਪੜ੍ਹਦਾ ਹੈ
• ਡੀਬੱਗ ਮੋਡ ਫਲੈਗ ਦੀ ਜਾਂਚ ਕੀਤੀ ਗਈ ਹੈ: ਜੇਕਰ ਇਹ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਨੈੱਟਵਰਕ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਸ਼ਡਿਊਲਰ ਲਾਂਚ ਨਹੀਂ ਹੁੰਦਾ ਹੈ ਅਤੇ ਬਲਾਕਚੈਨ ਲੋਡ ਨਹੀਂ ਹੁੰਦਾ ਹੈ
• ਸੰਰਚਨਾ ਡੇਟਾ ਢਾਂਚੇ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨਾ ਅਤੇ ਸਰਵਰ ਸ਼ੁਰੂ ਕਰਨਾ

ਸਰਵਰ

• ਪ੍ਰੋਟੋਕੋਲ ਦੇ ਅਨੁਸਾਰ TCP ਸਰਵਰ ਅਤੇ ਨੈੱਟਵਰਕ ਇੰਟਰੈਕਸ਼ਨ ਦੀ ਸ਼ੁਰੂਆਤ ਕਰਦਾ ਹੈ।
• ਇਸ ਵਿੱਚ ਇੱਕ ਸਰਵਵ ਡੇਟਾ ਢਾਂਚਾ ਹੈ ਜਿਸ ਵਿੱਚ ਇੱਕ ਪੋਰਟ ਨੰਬਰ, ਇੱਕ ਬਫਰ ਆਕਾਰ ਅਤੇ ਢਾਂਚੇ ਲਈ ਇੱਕ ਪੁਆਇੰਟਰ ਸ਼ਾਮਲ ਹੈ ਕਿਸਮਾਂ। ਸੈਟਿੰਗਾਂ
• ਰਨ ਵਿਧੀ ਨੈੱਟਵਰਕ ਇੰਟਰਐਕਸ਼ਨ ਸ਼ੁਰੂ ਕਰਦੀ ਹੈ (ਕਿਸੇ ਦਿੱਤੇ ਪੋਰਟ 'ਤੇ ਆਉਣ ਵਾਲੇ ਕਨੈਕਸ਼ਨਾਂ ਨੂੰ ਸੁਣਨਾ, ਜਦੋਂ ਇੱਕ ਨਵਾਂ ਕਨੈਕਸ਼ਨ ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ, ਇਸਦੀ ਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਇੱਕ ਨਵੇਂ ਥ੍ਰੈਡ ਵਿੱਚ ਪ੍ਰਾਈਵੇਟ ਹੈਂਡਲ ਵਿਧੀ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ)
• В ਹੈਂਡਲ ਕੁਨੈਕਸ਼ਨ ਤੋਂ ਡੇਟਾ ਨੂੰ ਇੱਕ ਬਫਰ ਵਿੱਚ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ, ਇੱਕ ਸਟ੍ਰਿੰਗ ਪ੍ਰਤੀਨਿਧਤਾ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ protocol.Choice
• protocol.Choice ਵਾਪਸੀ ਇਸ ਦਾ ਨਤੀਜਾ ਜਾਂ ਇੱਕ ਗਲਤੀ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ। ਇਸ ਦਾ ਨਤੀਜਾ ਫਿਰ ਵਿੱਚ ਤਬਦੀਲ ਕੀਤਾ ਗਿਆ ਹੈ protocol.Interpreteਜੋ ਵਾਪਸ ਆਉਂਦਾ ਹੈ intrpr - ਕਿਸਮ ਦੀ ਵਸਤੂ ਵਿਆਖਿਆ ਡੇਟਾ, ਜਾਂ ਚੋਣ ਨਤੀਜੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਵਿੱਚ ਇੱਕ ਤਰੁੱਟੀ ਦਾ ਕਾਰਨ ਬਣਦੀ ਹੈ
• ਫਿਰ ਸਵਿੱਚ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ intrpr.commands[0] ਜੋ ਇਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ: ਨਤੀਜਾ, inv, ਗਲਤੀ ਅਤੇ ਇੱਕ ਭਾਗ ਹੈ ਮੂਲ
• ਭਾਗ ਵਿੱਚ ਇਸ ਦਾ ਨਤੀਜਾ ਸਵਿੱਚ ਮੁੱਲ ਦੁਆਰਾ ਪਾਇਆ ਜਾਂਦਾ ਹੈ intrpr.commands[1] ਜੋ ਮੁੱਲਾਂ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ ਬਫਰ ਲੰਬਾਈ и ਵਰਜਨ (ਹਰੇਕ ਕੇਸ ਵਿੱਚ ਅਨੁਸਾਰੀ ਫੰਕਸ਼ਨ ਕਿਹਾ ਜਾਂਦਾ ਹੈ)

ਫੰਕਸ਼ਨ GetVersion и ਬਫਰ ਲੰਬਾਈ ਫਾਈਲ ਵਿੱਚ ਹਨ 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.ਸਰੀਰ ਇੱਕ ਸੰਖਿਆਤਮਕ ਵੇਰੀਏਬਲ ਲਈ buf_len
• ਇੱਕ ਬਫਰ ਬਣਾਉਂਦਾ ਹੈ newbuf ਨਿਰਧਾਰਤ ਆਕਾਰ:

  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"))

ਸਰਵਰ ਪੈਕੇਜ ਤੋਂ ਵਿਧੀਆਂ ਨੂੰ ਪੈਕੇਜ ਤੋਂ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤੇ ਡੇਟਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਲਈ ਸੰਰਚਿਤ ਕੀਤਾ ਗਿਆ ਹੈ ਪ੍ਰੋਟੋਕੋਲ.

ਪਰੋਟੋਕਾਲ

ਇੱਕ ਪ੍ਰੋਟੋਕੋਲ ਇੱਕ ਸਾਧਨ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ ਜੋ ਨੈਟਵਰਕ ਐਕਸਚੇਂਜ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।

ਚੋਣ(str ਸਤਰ) (ਸਟਰਿੰਗ, ਤਰੁੱਟੀ) ਸਰਵਰ ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤੇ ਡੇਟਾ ਦੀ ਪ੍ਰਾਇਮਰੀ ਪ੍ਰੋਸੈਸਿੰਗ ਕਰਦਾ ਹੈ, ਇਨਪੁਟ ਦੇ ਰੂਪ ਵਿੱਚ ਡੇਟਾ ਦੀ ਇੱਕ ਸਟ੍ਰਿੰਗ ਪ੍ਰਤੀਨਿਧਤਾ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸ ਲਈ ਤਿਆਰ ਕੀਤੀ ਇੱਕ ਸਤਰ ਵਾਪਸ ਕਰਦਾ ਹੈ ਦੁਭਾਸ਼ੀਏ:

• ਇਨਪੁਟ ਸਤਰ ਨੂੰ ਸਿਰ ਅਤੇ ਸਰੀਰ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ ReqParseN2(str)
• ਸਿਰ ਨੂੰ ਤੱਤਾਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ReqParseHead (ਸਿਰ) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਮਾਂਡਾਂ ਦੇ ਟੁਕੜੇ ਵਿੱਚ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ।
• В ਸਵਿੱਚ(ਕਮਾਂਡ[0]) ਪ੍ਰਾਪਤ ਕਮਾਂਡ ਦੀ ਚੋਣ ਕਰੋ (cmd, ਕੁੰਜੀ, ਪਤਾ ਜਾਂ ਸੈਕਸ਼ਨ ਨੂੰ ਚਾਲੂ ਕੀਤਾ ਗਿਆ ਹੈ ਮੂਲ)
• cmd ਵਿੱਚ 2 ਕਮਾਂਡਾਂ ਦੀ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਸਵਿੱਚ(ਕਮਾਂਡਸ[1]) — ਲੰਬਾਈ и getversion.
• ਲੰਬਾਈ ਵਿੱਚ ਡਾਟਾ ਕਿਸਮ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ ਹੁਕਮ[2] ਅਤੇ ਇਸ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਦਾ ਹੈ ਡੈਟਾ ਟਾਈਪ
• ਇਸਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ ਸਰੀਰ ਨੂੰ ਇੱਕ ਸਤਰ ਮੁੱਲ ਸ਼ਾਮਿਲ ਹੈ

  len(body) < 1

• ਜਵਾਬ ਸਤਰ ਵਾਪਸ ਕਰਦਾ ਹੈ:

  "result:bufferlength:" + datatype + "/" + body

• getversion ਇੱਕ ਸਤਰ ਵਾਪਸ ਕਰਦਾ ਹੈ

  return "result:version/auto"

ਦੁਭਾਸ਼ੀਏ

InterpreteData ਢਾਂਚਾ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸ ਤੋਂ ਵਾਪਸ ਕੀਤੇ ਡੇਟਾ ਦੀ ਸੈਕੰਡਰੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ ਚੋਣ ਤਾਰਾਂ ਅਤੇ ਵਸਤੂ ਦਾ ਗਠਨ ਵਿਆਖਿਆ ਡੇਟਾ.

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

ਇਸ ਵਸਤੂ ਵਿੱਚ ਵਰਤਿਆ ਗਿਆ ਹੈ server.go ਪੈਕੇਜ ਮੁੱਖ.

ਕਲਾਇੰਟ

ਕਲਾਇੰਟ ਪੈਕੇਜ ਵਿੱਚ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਹਨ 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 ਵਿੱਚ JavaScript ਤੋਂ ਜੁੜਨ ਲਈ WebSocket ਸਰਵਰ ਬਾਰੇ, 4 ਵਿੱਚ ਮੈਂ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਸ਼ਡਿਊਲਰ ਨੂੰ ਦੇਖਾਂਗਾ, ਫਿਰ ਇੱਕ ਸਟੈਕ ਮਸ਼ੀਨ ਜੋ ਇਨਪੁਟਸ ਅਤੇ ਆਉਟਪੁੱਟਾਂ ਤੋਂ ਬਾਈਟਕੋਡ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦੀ ਹੈ, ਕ੍ਰਿਪਟੋਗ੍ਰਾਫੀ ਅਤੇ ਆਉਟਪੁੱਟ ਲਈ ਪੂਲ.

ਸਰੋਤ: www.habr.com