गो वापरून उद्योगासाठी ब्लॉकचेन विकास. भाग 1

आता चार महिन्यांपासून मी "ब्लॉकचेनवर आधारित सरकारी आणि औद्योगिक क्षेत्रातील डेटा संरक्षण आणि व्यवस्थापन साधनांचा विकास" नावाच्या प्रकल्पावर काम करत आहे.
आता मी तुम्हाला हा प्रकल्प कसा सुरू केला याबद्दल सांगू इच्छितो आणि आता मी प्रोग्राम कोडचे तपशीलवार वर्णन करेन.

लेखांच्या मालिकेतील हा पहिला लेख आहे. येथे मी सर्व्हर आणि प्रोटोकॉलचे वर्णन करतो. खरं तर, वाचक या ब्लॉकचेन घटकांच्या स्वतःच्या आवृत्त्या देखील लिहू शकतात.

आणि हा दुसरा भाग आहे — ब्लॉकचेन आणि ट्रान्झॅक्शन डेटा स्ट्रक्चर्सबद्दल, तसेच डेटाबेसशी परस्परसंवाद लागू करणाऱ्या पॅकेजबद्दल.

गेल्या वर्षी, डिजिटल ब्रेकथ्रू हॅकाथॉनमध्ये, त्यांनी वितरित खातेवही तंत्रज्ञानाचा वापर करून उद्योग आणि डिजिटल अर्थव्यवस्थेसाठी उपयुक्त प्रणाली बनवण्याची कल्पना मांडली; इनोव्हेशन सहाय्यता निधीद्वारे विकासासाठी अनुदान देखील जारी केले गेले (मी स्वतंत्रपणे लिहावे अनुदानाबद्दल लेख, जे नुकतेच स्टार्टअप सुरू करत आहेत त्यांच्यासाठी ), आणि आता क्रमाने.

विकास गो भाषेत होतो आणि ज्या डेटाबेसमध्ये ब्लॉक्स साठवले जातात ते लेव्हलडीबी आहे.
मुख्य भाग म्हणजे प्रोटोकॉल, सर्व्हर (जे TCP आणि WebSocket चालवतात - पहिला ब्लॉकचेन सिंक्रोनाइझ करण्यासाठी, दुसरा क्लायंट कनेक्ट करण्यासाठी, JavaScript वरून व्यवहार आणि आदेश पाठवण्यासाठी, उदाहरणार्थ.

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

प्रोटोकॉल क्लिष्ट नाही, त्याचा संपूर्ण मुद्दा म्हणजे काही डेटा लोड करण्याच्या मोडवर स्विच करणे, सामान्यत: ब्लॉक किंवा व्यवहार, विशेष कमांड लाइनच्या प्रतिसादात, आणि इन्व्हेंटरीची देवाणघेवाण करण्यासाठी देखील आवश्यक आहे, जेणेकरून नोडला कळेल की ते कोण आहे. शी जोडलेले आहे आणि त्यांचा व्यवसाय कसा करायचा आहे (सिंक्रोनाइझेशन सत्रासाठी जोडलेल्या नोड्सना "शेजारी" देखील म्हटले जाते कारण त्यांचा आयपी ज्ञात आहे आणि त्यांचा स्टेट डेटा मेमरीमध्ये संग्रहित केला जातो).

गो प्रोग्रामरच्या समजुतीनुसार फोल्डर्स (डिरेक्टरीज ज्यांना लिनक्स म्हणतात) त्यांना पॅकेजेस म्हणतात, म्हणून या निर्देशिकेतील गो कोड असलेल्या प्रत्येक फाईलच्या सुरुवातीला ते पॅकेजfolder_name_where_this_file स्थित आहे असे लिहितात. अन्यथा, तुम्ही कंपाइलरला पॅकेज फीड करू शकणार नाही. बरं, ही भाषा जाणणार्‍यांसाठी हे रहस्य नाही. ही पॅकेजेस आहेत:

• नेटवर्क कम्युनिकेशन (सर्व्हर, क्लायंट, प्रोटोकॉल)
• संग्रहित आणि प्रसारित डेटाची संरचना (ब्लॉक, व्यवहार)
• डेटाबेस (ब्लॉकचेन)
• एकमत
• स्टॅक केलेले आभासी मशीन (xvm)
• सहाय्यक (क्रिप्टो, प्रकार) आतासाठी एवढेच.

येथे github ची लिंक आहे

ही एक शैक्षणिक आवृत्ती आहे, त्यात आंतर-प्रक्रिया परस्परसंवाद आणि अनेक प्रायोगिक घटकांचा अभाव आहे, परंतु रचना ज्यावर विकास केला जात आहे त्याच्याशी सुसंगत आहे. तुमच्याकडे टिप्पण्यांमध्ये काही सुचवायचे असल्यास, पुढील विकासामध्ये ते विचारात घेण्यास मला आनंद होईल. आणि आता सर्व्हरच्या स्पष्टीकरणासाठी आणि प्रोटोकॉल.

प्रथम सर्व्हर पाहू.

सर्व्हर सबरूटीन डेटा सर्व्हर म्हणून कार्य करते जे प्रोटोकॉल पॅकेजमधील डेटा स्ट्रक्चर्स वापरून TCP प्रोटोकॉलच्या वर चालते.

दिनचर्या खालील पॅकेजेस वापरते: सर्व्हर, प्रोटोकॉल, प्रकार. पॅकेजमध्येच tcp_server.go डेटा संरचना समाविष्टीत आहे सर्व्ह करावे.

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

हे खालील पॅरामीटर्स स्वीकारू शकते:

• नेटवर्क पोर्ट ज्याद्वारे डेटाची देवाणघेवाण केली जाईल
• JSON फॉरमॅटमध्ये सर्व्हर कॉन्फिगरेशन फाइल
• डीबग मोडमध्ये चालण्यासाठी ध्वजांकित करा (खाजगी ब्लॉकचेन)

प्रगती:

• JSON फाइलमधून कॉन्फिगरेशन वाचते
• डीबग मोड ध्वज तपासला आहे: जर तो सेट केला असेल तर, नेटवर्क सिंक्रोनाइझेशन शेड्यूलर लॉन्च केले जात नाही आणि ब्लॉकचेन लोड केलेले नाही
• कॉन्फिगरेशन डेटा स्ट्रक्चर सुरू करणे आणि सर्व्हर सुरू करणे

सर्व्हर

• प्रोटोकॉलनुसार TCP सर्व्हर आणि नेटवर्क संवादाचे प्रक्षेपण करते.
• यात सर्व्ह डेटा स्ट्रक्चर आहे ज्यामध्ये पोर्ट नंबर, बफर साइज आणि स्ट्रक्चरला पॉइंटर आहे प्रकार.सेटिंग्ज
• रन पद्धत नेटवर्क परस्परसंवाद सुरू करते (दिलेल्या पोर्टवर इनकमिंग कनेक्शन ऐकणे, नवीन कनेक्शन प्राप्त झाल्यावर, त्याची प्रक्रिया नवीन थ्रेडमध्ये खाजगी हँडल पद्धतीमध्ये हस्तांतरित केली जाते)
• В हाताळू कनेक्शनमधील डेटा बफरमध्ये वाचला जातो, स्ट्रिंग प्रतिनिधित्वामध्ये रूपांतरित केला जातो आणि पास केला जातो प्रोटोकॉल.निवड
• प्रोटोकॉल.निवड परतावा परिणाम किंवा त्रुटी निर्माण करते. परिणाम नंतर हस्तांतरित केले 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.Body अंकीय व्हेरिएबलला 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(head) वापरून कमांड स्लाइसमध्ये ठेवले जाते.
• В स्विच (आदेश[0]) प्राप्त आदेश निवडा (cmd, की, पत्ता किंवा विभाग ट्रिगर केला आहे डीफॉल्ट)
• cmd मध्ये 2 कमांड तपासल्या जातात स्विच(आदेश[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 मध्ये JavaScript वरून कनेक्ट होण्यासाठी वेबसॉकेट सर्व्हरबद्दल, 4 मध्ये मी सिंक्रोनाइझेशन शेड्यूलर, नंतर एक स्टॅक मशीन जे इनपुट आणि आउटपुट, क्रिप्टोग्राफी आणि आउटपुटमधून बायकोडवर प्रक्रिया करते. आउटपुटसाठी पूल.

स्त्रोत: www.habr.com