Go ഉപയോഗിച്ച് വ്യവസായത്തിനുള്ള ബ്ലോക്ക്ചെയിൻ വികസനം. ഭാഗം 1

നാല് മാസമായി ഞാൻ "ബ്ലോക്ക്ചെയിൻ അടിസ്ഥാനമാക്കി ഗവൺമെന്റ്, വ്യാവസായിക മേഖലകളിലെ ഡാറ്റാ പ്രൊട്ടക്ഷൻ ആൻഡ് മാനേജ്മെന്റ് ടൂളുകളുടെ വികസനം" എന്ന പേരിൽ ഒരു പ്രോജക്റ്റിൽ പ്രവർത്തിക്കുന്നു.
ഈ പ്രോജക്റ്റ് ഞാൻ എങ്ങനെ ആരംഭിച്ചു എന്നതിനെക്കുറിച്ച് ഇപ്പോൾ നിങ്ങളോട് പറയാൻ ഞാൻ ആഗ്രഹിക്കുന്നു, ഇപ്പോൾ ഞാൻ പ്രോഗ്രാം കോഡ് വിശദമായി വിവരിക്കും.

ലേഖന പരമ്പരയിലെ ആദ്യ ലേഖനമാണിത്. ഇവിടെ ഞാൻ സെർവറും പ്രോട്ടോക്കോളും വിവരിക്കുന്നു. വാസ്തവത്തിൽ, ഈ ബ്ലോക്ക്ചെയിൻ ഘടകങ്ങളുടെ സ്വന്തം പതിപ്പുകൾ പോലും വായനക്കാരന് എഴുതാൻ കഴിയും.

പിന്നെ ഇതാ രണ്ടാം ഭാഗം — ബ്ലോക്ക്ചെയിൻ, ട്രാൻസാക്ഷൻ ഡാറ്റാ ഘടനകൾ, ഡാറ്റാബേസുമായുള്ള ഇടപെടൽ നടപ്പിലാക്കുന്ന പാക്കേജ് എന്നിവയെക്കുറിച്ചും.

കഴിഞ്ഞ വർഷം, ഡിജിറ്റൽ ബ്രേക്ക്‌ത്രൂ ഹാക്കത്തോണിൽ, ഡിസ്ട്രിബ്യൂട്ടഡ് ലെഡ്ജർ സാങ്കേതികവിദ്യ ഉപയോഗിച്ച് വ്യവസായത്തിനും ഡിജിറ്റൽ സമ്പദ്‌വ്യവസ്ഥയ്ക്കും ഉപയോഗപ്രദമായ ഒരു സംവിധാനം ഉണ്ടാക്കാനുള്ള ഒരു ആശയം അവർ കൊണ്ടുവന്നു; ഇന്നൊവേഷൻ അസിസ്റ്റൻസ് ഫൗണ്ടേഷന്റെ വികസനത്തിന് ഗ്രാന്റും നൽകി (ഞാൻ പ്രത്യേകം എഴുതണം. ഗ്രാന്റിനെക്കുറിച്ചുള്ള ലേഖനം, സ്റ്റാർട്ടപ്പുകൾ ചെയ്യാൻ തുടങ്ങുന്നവർക്കായി ), ഇപ്പോൾ ക്രമത്തിൽ.

വികസനം ഗോ ഭാഷയിൽ നടക്കുന്നു, ബ്ലോക്കുകൾ സംഭരിച്ചിരിക്കുന്ന ഡാറ്റാബേസ് LevelDB ആണ്.
പ്രധാന ഭാഗങ്ങൾ പ്രോട്ടോക്കോൾ, സെർവർ (ടിസിപിയും വെബ്‌സോക്കറ്റും പ്രവർത്തിപ്പിക്കുന്നവയാണ് - ബ്ലോക്ക്ചെയിൻ സമന്വയിപ്പിക്കുന്നതിനുള്ള ആദ്യത്തേത്, ക്ലയന്റുകളെ ബന്ധിപ്പിക്കുന്നതിന് രണ്ടാമത്തേത്, ജാവാസ്ക്രിപ്റ്റിൽ നിന്ന് ഇടപാടുകളും കമാൻഡുകളും അയയ്ക്കുന്നതിന്, ഉദാഹരണത്തിന്.

സൂചിപ്പിച്ചതുപോലെ, ഈ ബ്ലോക്ക്ചെയിൻ പ്രാഥമികമായി വിതരണക്കാരും ഉപഭോക്താക്കളും തമ്മിലുള്ള ഉൽപ്പന്നങ്ങളുടെ കൈമാറ്റം ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനും പരിരക്ഷിക്കുന്നതിനും അല്ലെങ്കിൽ ഒരു വ്യക്തിയിൽ ആവശ്യമാണ്. ഈ ആളുകൾ പരസ്പരം വിശ്വസിക്കാൻ തിടുക്കം കാണിക്കുന്നില്ല. എന്നാൽ ചുമതല ഒരു ബിൽറ്റ്-ഇൻ കാൽക്കുലേറ്റർ ഉപയോഗിച്ച് ഒരു "ചെക്ക്ബുക്ക്" സൃഷ്ടിക്കുക മാത്രമല്ല, ഉൽപ്പന്ന ജീവിത ചക്രത്തിൽ പ്രവർത്തിക്കുമ്പോൾ ഉണ്ടാകുന്ന മിക്ക പതിവ് ജോലികളും ഓട്ടോമേറ്റ് ചെയ്യുന്ന ഒരു സിസ്റ്റം. ബ്ലോക്ക്‌ചെയിനുകളിൽ പതിവുള്ളതുപോലെ, ഈ കാര്യത്തിന് ഉത്തരവാദിയായ ബൈറ്റ്കോഡ് ഇടപാടുകളുടെ ഇൻപുട്ടുകളിലും ഔട്ട്‌പുട്ടുകളിലും സംഭരിച്ചിരിക്കുന്നു (ഇടപാടുകൾ ബ്ലോക്കുകളിൽ സംഭരിച്ചിരിക്കുന്നു, ലെവൽഡിബിയിലെ ബ്ലോക്കുകൾ GOB ഫോർമാറ്റിൽ മുൻകൂട്ടി എൻകോഡ് ചെയ്തിരിക്കുന്നു). ആദ്യം, നമുക്ക് പ്രോട്ടോക്കോൾ, സെർവർ (നോഡ്) എന്നിവയെക്കുറിച്ച് സംസാരിക്കാം.

പ്രോട്ടോക്കോൾ സങ്കീർണ്ണമല്ല, ഒരു പ്രത്യേക കമാൻഡ് ലൈനിന് പ്രതികരണമായി ചില ഡാറ്റ, സാധാരണയായി ഒരു ബ്ലോക്ക് അല്ലെങ്കിൽ ഇടപാട് ലോഡ് ചെയ്യുന്ന രീതിയിലേക്ക് മാറുക എന്നതാണ് അതിന്റെ മുഴുവൻ പോയിന്റും, കൂടാതെ ഇൻവെന്ററി കൈമാറ്റത്തിനും ഇത് ആവശ്യമാണ്, അതിനാൽ ഇത് ആരാണെന്ന് നോഡിന് അറിയാം. എന്നതുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു, അവർക്ക് എങ്ങനെ ബിസിനസ്സ് ചെയ്യാനുണ്ട് (സിൻക്രൊണൈസേഷൻ സെഷനുമായി ബന്ധിപ്പിച്ചിട്ടുള്ള നോഡുകളെ "അയൽക്കാരൻ" എന്നും വിളിക്കുന്നു, കാരണം അവരുടെ ഐപി അറിയപ്പെടുന്നതും അവരുടെ സ്റ്റേറ്റ് ഡാറ്റ മെമ്മറിയിൽ സൂക്ഷിക്കുന്നതുമാണ്).

Go പ്രോഗ്രാമർമാരുടെ ധാരണയിലെ ഫോൾഡറുകളെ (ലിനക്സ് വിളിക്കുന്ന ഡയറക്‌ടറികൾ) പാക്കേജുകൾ എന്ന് വിളിക്കുന്നു, അതിനാൽ ഈ ഡയറക്ടറിയിൽ നിന്നുള്ള Go കോഡ് ഉള്ള ഓരോ ഫയലിന്റെയും തുടക്കത്തിൽ അവർ പാക്കേജ് folder_name_where_this_file എന്ന് എഴുതുന്നു. അല്ലെങ്കിൽ, നിങ്ങൾക്ക് കംപൈലറിലേക്ക് പാക്കേജ് നൽകാനാവില്ല. ശരി, ഈ ഭാഷ അറിയുന്നവർക്ക് ഇത് രഹസ്യമല്ല. ഇവയാണ് പാക്കേജുകൾ:

• നെറ്റ്‌വർക്ക് ആശയവിനിമയം (സെർവർ, ക്ലയന്റ്, പ്രോട്ടോക്കോൾ)
• സംഭരിച്ചതും കൈമാറിയതുമായ ഡാറ്റയുടെ ഘടനകൾ (ബ്ലോക്ക്, ഇടപാട്)
• ഡാറ്റാബേസ് (ബ്ലോക്ക്ചെയിൻ)
• സമവായം
• അടുക്കിയ വെർച്വൽ മെഷീൻ (xvm)
• ഓക്സിലറി (ക്രിപ്റ്റോ, തരങ്ങൾ) ഇപ്പോൾ അത്രമാത്രം.

github-ലേക്കുള്ള ലിങ്ക് ഇതാ

ഇതൊരു വിദ്യാഭ്യാസ പതിപ്പാണ്, ഇതിന് ഇന്റർ-പ്രോസസ് ഇന്ററാക്ഷനും നിരവധി പരീക്ഷണാത്മക ഘടകങ്ങളും ഇല്ല, പക്ഷേ ഘടന വികസനം നടപ്പിലാക്കുന്ന ഒന്നിനോട് യോജിക്കുന്നു. അഭിപ്രായങ്ങളിൽ നിങ്ങൾക്ക് എന്തെങ്കിലും നിർദ്ദേശിക്കാനുണ്ടെങ്കിൽ, കൂടുതൽ വികസനത്തിൽ അത് കണക്കിലെടുക്കുന്നതിൽ എനിക്ക് സന്തോഷമുണ്ട്. ഇപ്പോൾ സെർവറിന്റെ വിശദീകരണത്തിനായി പ്രോട്ടോകോൾ.

ആദ്യം നമുക്ക് സെർവർ നോക്കാം.

പ്രോട്ടോക്കോൾ പാക്കേജിൽ നിന്നുള്ള ഡാറ്റാ ഘടനകൾ ഉപയോഗിച്ച് TCP പ്രോട്ടോക്കോളിനു മുകളിൽ പ്രവർത്തിക്കുന്ന ഒരു ഡാറ്റ സെർവറായി സെർവർ സബ്റൂട്ടീൻ പ്രവർത്തിക്കുന്നു.

പതിവ് ഇനിപ്പറയുന്ന പാക്കേജുകൾ ഉപയോഗിക്കുന്നു: സെർവർ, പ്രോട്ടോകോൾ, തരം. പാക്കേജിൽ തന്നെ tcp_server.go ഡാറ്റ ഘടന അടങ്ങിയിരിക്കുന്നു സേവിക്കുക.

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

ഇതിന് ഇനിപ്പറയുന്ന പാരാമീറ്ററുകൾ സ്വീകരിക്കാൻ കഴിയും:

• ഡാറ്റ കൈമാറ്റം ചെയ്യപ്പെടുന്ന നെറ്റ്‌വർക്ക് പോർട്ട്
• JSON ഫോർമാറ്റിലുള്ള സെർവർ കോൺഫിഗറേഷൻ ഫയൽ
• ഡീബഗ് മോഡിൽ പ്രവർത്തിക്കുന്നതിനുള്ള ഫ്ലാഗ് (സ്വകാര്യ ബ്ലോക്ക്ചെയിൻ)

പുരോഗതി:

• JSON ഫയലിൽ നിന്നുള്ള കോൺഫിഗറേഷൻ വായിക്കുന്നു
• ഡീബഗ് മോഡ് ഫ്ലാഗ് പരിശോധിച്ചു: ഇത് സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, നെറ്റ്‌വർക്ക് സിൻക്രൊണൈസേഷൻ ഷെഡ്യൂളർ സമാരംഭിക്കില്ല, ബ്ലോക്ക്ചെയിൻ ലോഡുചെയ്യില്ല
• കോൺഫിഗറേഷൻ ഡാറ്റാ ഘടന ആരംഭിക്കുകയും സെർവർ ആരംഭിക്കുകയും ചെയ്യുന്നു

സെർവർ

• പ്രോട്ടോക്കോൾ അനുസരിച്ച് ടിസിപി സെർവറിന്റെ സമാരംഭവും നെറ്റ്‌വർക്ക് ഇടപെടലും നടത്തുന്നു.
• ഇതിന് ഒരു പോർട്ട് നമ്പർ, ബഫർ വലുപ്പം, ഘടനയിലേക്കുള്ള ഒരു പോയിന്റർ എന്നിവ അടങ്ങുന്ന ഒരു സെർവ് ഡാറ്റാ ഘടനയുണ്ട് തരങ്ങൾ.ക്രമീകരണങ്ങൾ
• റൺ രീതി നെറ്റ്‌വർക്ക് ഇന്ററാക്ഷൻ ആരംഭിക്കുന്നു ( തന്നിരിക്കുന്ന പോർട്ടിൽ ഇൻകമിംഗ് കണക്ഷനുകൾക്കായി ശ്രദ്ധിക്കുന്നു, ഒരു പുതിയ കണക്ഷൻ ലഭിക്കുമ്പോൾ, അതിന്റെ പ്രോസസ്സിംഗ് ഒരു പുതിയ ത്രെഡിലെ സ്വകാര്യ ഹാൻഡിൽ രീതിയിലേക്ക് മാറ്റുന്നു)
• В കൈകാര്യം ചെയ്യുക കണക്ഷനിൽ നിന്നുള്ള ഡാറ്റ ഒരു ബഫറിലേക്ക് റീഡ് ചെയ്യുകയും ഒരു സ്ട്രിംഗ് പ്രാതിനിധ്യത്തിലേക്ക് പരിവർത്തനം ചെയ്യുകയും കൈമാറുകയും ചെയ്യുന്നു പ്രോട്ടോക്കോൾ. ചോയ്സ്
• പ്രോട്ടോക്കോൾ. ചോയ്സ് മടങ്ങുന്നു ഫലം അല്ലെങ്കിൽ ഒരു പിശകിന് കാരണമാകുന്നു. ഫലം പിന്നീട് മാറ്റി പ്രോട്ടോക്കോൾ.വ്യാഖ്യാനംഅത് തിരികെ നൽകുന്നു 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.ശരീരം ഒരു സംഖ്യാ വേരിയബിളിലേക്ക് ബഫ്_ലെൻ
• ഒരു ബഫർ സൃഷ്ടിക്കുന്നു ന്യൂബഫ് നിർദ്ദിഷ്ട വലുപ്പം:

  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, കീ, വിലാസം അല്ലെങ്കിൽ വിഭാഗം പ്രവർത്തനക്ഷമമാണ് സ്ഥിരസ്ഥിതി)
• 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

ഈ വസ്തു ഉപയോഗിക്കുന്നത് 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)

• എമു പതാക പാസാക്കിയാൽ, അത് ആരംഭിക്കുന്നു ഷെഡ്യൂളർ
• ഫയലിലേക്കുള്ള പാത സൂചിപ്പിക്കുന്ന എഫ് ഫ്ലാഗ് നൽകിയിട്ടുണ്ടെങ്കിൽ, ഞങ്ങൾ അതിന്റെ ഡാറ്റ ലോഡുചെയ്യുന്നു 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