गो का उपयोग करके उद्योग के लिए ब्लॉकचेन विकास। भाग ---- पहला

अब चार महीने से मैं "ब्लॉकचेन पर आधारित सरकारी और औद्योगिक क्षेत्रों में डेटा सुरक्षा और प्रबंधन उपकरणों का विकास" नामक एक परियोजना पर काम कर रहा हूं।
अब मैं आपको बताना चाहूंगा कि मैंने यह प्रोजेक्ट कैसे शुरू किया, और अब मैं प्रोग्राम कोड का विस्तार से वर्णन करूंगा।

लेखों की शृंखला में यह पहला लेख है। यहां मैं सर्वर और प्रोटोकॉल का वर्णन करता हूं। वास्तव में, पाठक इन ब्लॉकचेन तत्वों का अपना संस्करण भी लिख सकता है।

और यहाँ दूसरा भाग है - ब्लॉकचेन और लेनदेन डेटा संरचनाओं के बारे में, साथ ही उस पैकेज के बारे में जो डेटाबेस के साथ इंटरैक्शन लागू करता है।

पिछले साल, डिजिटल ब्रेकथ्रू हैकथॉन में, वे वितरित लेजर तकनीक का उपयोग करके उद्योग और डिजिटल अर्थव्यवस्था के लिए एक उपयोगी प्रणाली बनाने का विचार लेकर आए; इनोवेशन असिस्टेंस फंड द्वारा विकास के लिए एक अनुदान भी जारी किया गया था (मुझे एक अलग लिखना चाहिए) अनुदान के बारे में लेख, उन लोगों के लिए जो अभी स्टार्टअप शुरू कर रहे हैं), और अब क्रम में।

विकास गो भाषा में होता है, और जिस डेटाबेस में ब्लॉक संग्रहीत होते हैं वह लेवलडीबी है।
मुख्य भाग प्रोटोकॉल हैं, सर्वर (जो टीसीपी और वेबसॉकेट चलाता है - पहला ब्लॉकचेन को सिंक्रोनाइज़ करने के लिए, दूसरा क्लाइंट को जोड़ने के लिए, उदाहरण के लिए जावास्क्रिप्ट से लेनदेन और कमांड भेजने के लिए।

जैसा कि उल्लेख किया गया था, इस ब्लॉकचेन की आवश्यकता मुख्य रूप से आपूर्तिकर्ताओं और ग्राहकों, या दोनों के बीच एक ही व्यक्ति में उत्पादों के आदान-प्रदान को स्वचालित और संरक्षित करने के लिए है। ये लोग एक-दूसरे पर भरोसा करने की जल्दी में नहीं होते। लेकिन कार्य केवल अंतर्निहित कैलकुलेटर के साथ "चेकबुक" बनाना नहीं है, बल्कि एक ऐसी प्रणाली है जो उत्पाद जीवन चक्र के साथ काम करते समय उत्पन्न होने वाले अधिकांश नियमित कार्यों को स्वचालित करती है। इस मामले के लिए जिम्मेदार बाइटकोड, जैसा कि ब्लॉकचेन के साथ प्रथागत है, लेनदेन के इनपुट और आउटपुट में संग्रहीत किया जाता है (लेनदेन स्वयं ब्लॉक में संग्रहीत होते हैं, लेवलडीबी में ब्लॉक जीओबी प्रारूप में पूर्व-एन्कोडेड होते हैं)। सबसे पहले, प्रोटोकॉल और सर्वर (उर्फ नोड) के बारे में बात करते हैं।

प्रोटोकॉल जटिल नहीं है, इसका पूरा उद्देश्य एक विशेष कमांड लाइन के जवाब में कुछ डेटा, आमतौर पर एक ब्लॉक या लेनदेन को लोड करने के मोड पर स्विच करना है, और यह इन्वेंट्री के आदान-प्रदान के लिए भी आवश्यक है, ताकि नोड को पता चले कि यह कौन है से जुड़ा है और उन्हें कैसे व्यवसाय करना है (सिंक्रनाइज़ेशन सत्र के लिए जुड़े नोड्स को "पड़ोसी" भी कहा जाता है क्योंकि उनका आईपी ज्ञात है और उनका राज्य डेटा मेमोरी में संग्रहीत है)।

गो प्रोग्रामर्स की समझ में फ़ोल्डर्स (निर्देशिकाओं को लिनक्स उन्हें कहता है) को पैकेज कहा जाता है, इसलिए इस निर्देशिका से गो कोड के साथ प्रत्येक फ़ाइल की शुरुआत में वे पैकेज फ़ोल्डर_नाम_जहां_यह_फ़ाइल स्थित है लिखते हैं। अन्यथा, आप कंपाइलर को पैकेज फ़ीड नहीं कर पाएंगे। खैर, यह भाषा जानने वालों के लिए यह कोई रहस्य नहीं है। ये पैकेज हैं:

• नेटवर्क संचार (सर्वर, क्लाइंट, प्रोटोकॉल)
• संग्रहीत और प्रसारित डेटा की संरचनाएं (ब्लॉक, लेनदेन)
• डेटाबेस (ब्लॉकचेन)
• सर्वसम्मति
• स्टैक्ड वर्चुअल मशीन (xvm)
• सहायक (क्रिप्टो, प्रकार) अभी के लिए बस इतना ही।

यहाँ github का लिंक है

यह एक शैक्षिक संस्करण है, इसमें अंतर-प्रक्रिया सहभागिता और कई प्रयोगात्मक घटकों का अभाव है, लेकिन संरचना उसी से मेल खाती है जिस पर विकास किया जा रहा है। यदि आपके पास टिप्पणियों में सुझाव देने के लिए कुछ है, तो मुझे आगे के विकास में इसे ध्यान में रखने में खुशी होगी। और अब सर्वर के स्पष्टीकरण के लिए और प्रोटोकॉल.

आइए पहले सर्वर को देखें।

सर्वर सबरूटीन एक डेटा सर्वर के रूप में कार्य करता है जो प्रोटोकॉल पैकेज से डेटा संरचनाओं का उपयोग करके टीसीपी प्रोटोकॉल के शीर्ष पर चलता है।

रूटीन निम्नलिखित पैकेजों का उपयोग करता है: सर्वर, प्रोटोकॉल, प्रकार. पैकेज में ही tcp_server.go डेटा संरचना शामिल है परोसें.

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

यह निम्नलिखित मापदंडों को स्वीकार कर सकता है:

• नेटवर्क पोर्ट जिसके माध्यम से डेटा का आदान-प्रदान किया जाएगा
• JSON प्रारूप में सर्वर कॉन्फ़िगरेशन फ़ाइल
• डिबग मोड में चलने के लिए फ़्लैग करें (निजी ब्लॉकचेन)

प्रगति:

• JSON फ़ाइल से कॉन्फ़िगरेशन पढ़ता है
• डिबग मोड फ़्लैग की जाँच की जाती है: यदि यह सेट है, तो नेटवर्क सिंक्रोनाइज़ेशन शेड्यूलर लॉन्च नहीं होता है और ब्लॉकचेन लोड नहीं होता है
• कॉन्फ़िगरेशन डेटा संरचना प्रारंभ करना और सर्वर प्रारंभ करना

सर्वर

• प्रोटोकॉल के अनुसार टीसीपी सर्वर और नेटवर्क इंटरैक्शन का लॉन्च करता है।
• इसमें एक सर्व डेटा संरचना है जिसमें एक पोर्ट नंबर, एक बफर आकार और संरचना के लिए एक संकेतक शामिल है प्रकार.सेटिंग्स
• रन विधि नेटवर्क इंटरेक्शन शुरू करती है (किसी दिए गए पोर्ट पर आने वाले कनेक्शन को सुनना, जब एक नया कनेक्शन प्राप्त होता है, तो इसकी प्रोसेसिंग एक नए थ्रेड में निजी हैंडल विधि में स्थानांतरित हो जाती है)
• В संभालना कनेक्शन से डेटा को एक बफर में पढ़ा जाता है, एक स्ट्रिंग प्रतिनिधित्व में परिवर्तित किया जाता है और पास किया जाता है प्रोटोकॉल.विकल्प
• प्रोटोकॉल.विकल्प रिटर्न परिणाम या त्रुटि उत्पन्न करता है. परिणाम फिर स्थानांतरित कर दिया गया प्रोटोकॉल.व्याख्याजो वापस आता है 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])

• मान पढ़ता है इंट्रप्र.बॉडी एक संख्यात्मक चर के लिए buf_len
• एक बफ़र बनाता है न्यूबफ निर्दिष्ट आकार:

  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(head) का उपयोग करके कमांड स्लाइस में रखा गया है
• В स्विच(आदेश[0]) प्राप्त आदेश का चयन करें (सीएमडी, कुंजी, पता या अनुभाग चालू हो गया है चूक)
• Cmd में 2 कमांड चेक किए गए हैं स्विच(कमांड[1])- लंबाई и संस्करण प्राप्त करें.
• लंबाई में डेटा प्रकार की जाँच करता है आदेश[2] और इसे सेव करता है डाटा प्रकार
• उसकी जांच करता है परिवर्तन एक स्ट्रिंग मान शामिल है

  len(body) < 1

• प्रतिक्रिया स्ट्रिंग लौटाता है:

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

• संस्करण प्राप्त करें एक स्ट्रिंग लौटाता है

  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

इस ऑब्जेक्ट का उपयोग किया जाता है सर्वर.गो पैकेज मुख्य.

ग्राहक

क्लाइंट पैकेज में फ़ंक्शन शामिल हैं टीसीपीकनेक्ट и टीसीपीरेस्पॉन्सडेटा.

समारोह

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