Go ஐப் பயன்படுத்தி தொழில்துறைக்கான Blockchain மேம்பாடு. பகுதி 1

நான்கு மாதங்களாக நான் "பிளாக்செயின் அடிப்படையில் அரசு மற்றும் தொழில்துறை துறைகளில் தரவு பாதுகாப்பு மற்றும் மேலாண்மை கருவிகளை உருவாக்குதல்" என்ற திட்டத்தில் பணியாற்றி வருகிறேன்.
இந்த திட்டத்தை நான் எவ்வாறு தொடங்கினேன் என்பது பற்றி இப்போது நான் உங்களுக்கு சொல்ல விரும்புகிறேன், இப்போது நிரல் குறியீட்டை விரிவாக விவரிக்கிறேன்.

கட்டுரைத் தொடரின் முதல் கட்டுரை இது. இங்கே நான் சர்வர் மற்றும் நெறிமுறையை விவரிக்கிறேன். உண்மையில், இந்த பிளாக்செயின் கூறுகளின் சொந்த பதிப்புகளை வாசகர் எழுதலாம்.

இதோ இரண்டாம் பாகம் — பிளாக்செயின் மற்றும் பரிவர்த்தனை தரவு கட்டமைப்புகள் மற்றும் தரவுத்தளத்துடன் தொடர்புகளை செயல்படுத்தும் தொகுப்பு பற்றி.

கடந்த ஆண்டு, டிஜிட்டல் திருப்புமுனை ஹேக்கத்தானில், விநியோகிக்கப்பட்ட லெட்ஜர் தொழில்நுட்பத்தைப் பயன்படுத்தி தொழில்துறை மற்றும் டிஜிட்டல் பொருளாதாரத்திற்கு பயனுள்ள அமைப்பை உருவாக்க அவர்கள் ஒரு யோசனையை முன்வைத்தனர்; புதுமை உதவி நிதியத்தின் வளர்ச்சிக்காக மானியமும் வழங்கப்பட்டது (நான் தனியாக எழுத வேண்டும். மானியம் பற்றிய கட்டுரை, புதிதாக தொடங்குபவர்களுக்கு, மற்றும் இப்போது வரிசையில்.

வளர்ச்சி கோ மொழியில் நடைபெறுகிறது, மேலும் தொகுதிகள் சேமிக்கப்படும் தரவுத்தளமானது LevelDB ஆகும்.
முக்கிய பகுதிகள் நெறிமுறை, சேவையகம் (இது TCP மற்றும் WebSocket ஐ இயக்குகிறது - பிளாக்செயினை ஒத்திசைக்க முதல், வாடிக்கையாளர்களை இணைப்பதற்கு இரண்டாவது, ஜாவாஸ்கிரிப்டில் இருந்து பரிவர்த்தனைகள் மற்றும் கட்டளைகளை அனுப்புதல், எடுத்துக்காட்டாக.

குறிப்பிட்டுள்ளபடி, இந்த பிளாக்செயின் முதன்மையாக சப்ளையர்கள் மற்றும் வாடிக்கையாளர்களுக்கிடையிலான தயாரிப்புகளின் பரிமாற்றத்தை தானியங்குபடுத்துவதற்கும் பாதுகாப்பதற்கும் அல்லது ஒரு நபருக்கு தேவைப்படுகிறது. இந்த மக்கள் ஒருவருக்கொருவர் நம்புவதற்கு அவசரப்படுவதில்லை. ஆனால் பணியானது ஒரு உள்ளமைக்கப்பட்ட கால்குலேட்டருடன் "செக்புக்" உருவாக்குவது மட்டுமல்ல, தயாரிப்பு வாழ்க்கைச் சுழற்சியுடன் பணிபுரியும் போது எழும் பெரும்பாலான வழக்கமான பணிகளை தானியங்குபடுத்தும் ஒரு அமைப்பு. இந்த விஷயத்திற்கு பொறுப்பான பைட்கோடு, பிளாக்செயின்களில் வழக்கம் போல், பரிவர்த்தனைகளின் உள்ளீடுகள் மற்றும் வெளியீடுகளில் சேமிக்கப்படுகிறது (பரிவர்த்தனைகள் தொகுதிகளில் சேமிக்கப்படுகின்றன, LevelDB இல் உள்ள தொகுதிகள் 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] இதில் ஒன்றை சரிபார்க்கிறது: முடிவு, inv, பிழை மற்றும் ஒரு பிரிவு உள்ளது இயல்புநிலை
• பிரிவில் விளைவாக சுவிட்ச் மதிப்பால் கண்டறியப்படுகிறது intrpr.கட்டளைகள்[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"))

தொகுப்பில் இருந்து செயல்பாடுகளைப் பயன்படுத்தி பெறப்பட்ட தரவை செயலாக்க சேவையக தொகுப்பிலிருந்து முறைகள் கட்டமைக்கப்படுகின்றன நெறிமுறை.

நெறிமுறை

நெட்வொர்க் பரிமாற்றத்தில் தரவைக் குறிக்கும் வழிமுறையாக ஒரு நெறிமுறை செயல்படுகிறது.

தேர்வு(string) (சரம், பிழை) சேவையகத்தால் பெறப்பட்ட தரவின் முதன்மை செயலாக்கத்தைச் செய்கிறது, தரவின் சரம் பிரதிநிதித்துவத்தை உள்ளீடாகப் பெறுகிறது மற்றும் தயாரிக்கப்பட்ட சரத்தை வழங்குகிறது மொழிபெயர்ப்பாளர்:

• உள்ளீட்டு சரம் தலை மற்றும் உடலாகப் பிரிக்கப்பட்டுள்ளது ReqParseN2(str)
• தலை உறுப்புகளாகப் பிரிக்கப்பட்டு, ReqParseHead(head)ஐப் பயன்படுத்தி கட்டளைத் துண்டுகளாக வைக்கப்படுகிறது.
• В மாறு(கட்டளைகள்[0]) பெறப்பட்ட கட்டளையைத் தேர்ந்தெடுக்கவும் (cmd, விசை, முகவரி அல்லது பிரிவு தூண்டப்படுகிறது இயல்புநிலை)
• 2 கட்டளைகள் cmd இல் சரிபார்க்கப்படுகின்றன சுவிட்ச்(கட்டளைகள்[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

இந்த பொருள் பயன்படுத்தப்படுகிறது 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)

இவை அனைத்தும் நெறிமுறையின் கட்டமைப்பைக் காட்டும் எளிமைப்படுத்தப்பட்ட பிரதிநிதித்துவமாகும். வளர்ச்சியின் போது, ​​தேவையான செயல்பாடு அதன் கட்டமைப்பில் சேர்க்கப்படுகிறது.

இரண்டாம் பகுதியில், தொகுதிகள் மற்றும் பரிவர்த்தனைகளுக்கான தரவு கட்டமைப்புகள் பற்றி பேசுவேன், ஜாவாஸ்கிரிப்டிலிருந்து இணைப்பதற்கான WebSocket சேவையகத்தைப் பற்றி 3 இல், 4 இல் நான் ஒத்திசைவு திட்டமிடலைப் பார்ப்பேன், பின்னர் உள்ளீடுகள் மற்றும் வெளியீடுகளிலிருந்து பைட்கோடுகளைச் செயலாக்கும் ஒரு அடுக்கு இயந்திரம், குறியாக்கவியல் மற்றும் வெளியீடுகளுக்கான குளங்கள்.

ஆதாரம்: www.habr.com