Go નો ઉપયોગ કરીને ઉદ્યોગ માટે બ્લોકચેન વિકાસ. ભાગ 1

ચાર મહિનાથી હું "બ્લોકચેન પર આધારિત સરકારી અને ઔદ્યોગિક ક્ષેત્રોમાં ડેટા પ્રોટેક્શન અને મેનેજમેન્ટ ટૂલ્સનો વિકાસ" નામના પ્રોજેક્ટ પર કામ કરી રહ્યો છું.
હવે હું તમને જણાવવા માંગુ છું કે મેં આ પ્રોજેક્ટ કેવી રીતે શરૂ કર્યો, અને હવે હું પ્રોગ્રામ કોડનું વિગતવાર વર્ણન કરીશ.

લેખોની શ્રેણીમાં આ પહેલો લેખ છે. અહીં હું સર્વર અને પ્રોટોકોલનું વર્ણન કરું છું. વાસ્તવમાં, રીડર આ બ્લોકચેન તત્વોના પોતાના વર્ઝન પણ લખી શકે છે.

અને અહીં બીજો ભાગ છે — બ્લોકચેન અને ટ્રાન્ઝેક્શન ડેટા સ્ટ્રક્ચર્સ વિશે, તેમજ ડેટાબેઝ સાથે ક્રિયાપ્રતિક્રિયાને અમલમાં મૂકતા પેકેજ વિશે.

ગયા વર્ષે, ડિજિટલ બ્રેકથ્રુ હેકાથોનમાં, તેઓ ડિસ્ટ્રિબ્યુટેડ લેજર ટેક્નોલોજીનો ઉપયોગ કરીને ઉદ્યોગ અને ડિજિટલ અર્થતંત્ર માટે ઉપયોગી સિસ્ટમ બનાવવાનો વિચાર લઈને આવ્યા હતા; ઇનોવેશન આસિસ્ટન્સ ફંડ દ્વારા વિકાસ માટે ગ્રાન્ટ પણ જારી કરવામાં આવી હતી (મારે અલગથી લખવું જોઈએ. અનુદાન વિશે લેખ, જેઓ હમણાં જ સ્ટાર્ટઅપ કરવાનું શરૂ કરી રહ્યા છે ), અને હવે ક્રમમાં.

વિકાસ ગો ભાષામાં થાય છે, અને ડેટાબેઝ જેમાં બ્લોક્સ સંગ્રહિત થાય છે તે લેવલડીબી છે.
મુખ્ય ભાગો પ્રોટોકોલ છે, સર્વર (જે TCP અને WebSocket ચલાવે છે - પ્રથમ બ્લોકચેનને સિંક્રનાઇઝ કરવા માટે, બીજો ક્લાયંટને કનેક્ટ કરવા માટે, વ્યવહારો અને JavaScript પરથી આદેશો મોકલવા માટે, ઉદાહરણ તરીકે.

ઉલ્લેખ કર્યો છે તેમ, આ બ્લોકચેન મુખ્યત્વે સપ્લાયર્સ અને ગ્રાહકો વચ્ચે અથવા બંને એક વ્યક્તિમાં ઉત્પાદનોના વિનિમયને સ્વચાલિત અને સુરક્ષિત કરવા માટે જરૂરી છે. આ લોકોને એકબીજા પર વિશ્વાસ કરવાની કોઈ ઉતાવળ નથી. પરંતુ કાર્ય ફક્ત બિલ્ટ-ઇન કેલ્ક્યુલેટર સાથે "ચેકબુક" બનાવવાનું નથી, પરંતુ એક સિસ્ટમ કે જે ઉત્પાદન જીવન ચક્ર સાથે કામ કરતી વખતે ઉદ્ભવતા મોટાભાગના નિયમિત કાર્યોને સ્વચાલિત કરે છે. બાયટેકોડ કે જે આ બાબત માટે જવાબદાર છે, જેમ કે બ્લોકચેન સાથે રૂઢિગત છે, તે વ્યવહારોના ઇનપુટ્સ અને આઉટપુટમાં સંગ્રહિત થાય છે (વ્યવહારો પોતે બ્લોક્સમાં સંગ્રહિત થાય છે, લેવલડીબીમાંના બ્લોક્સ GOB ફોર્મેટમાં પ્રી-એનકોડેડ હોય છે). પ્રથમ, ચાલો પ્રોટોકોલ અને સર્વર (ઉર્ફ નોડ) વિશે વાત કરીએ.

પ્રોટોકોલ જટિલ નથી, તેનો આખો મુદ્દો અમુક ડેટા લોડ કરવાના મોડ પર સ્વિચ કરવાનો છે, સામાન્ય રીતે બ્લોક અથવા ટ્રાન્ઝેક્શન, ખાસ કમાન્ડ લાઇનના પ્રતિભાવમાં, અને તે ઇન્વેન્ટરીની આપલે માટે પણ જરૂરી છે, જેથી નોડને ખબર પડે કે તે કોણ છે. સાથે જોડાયેલ છે અને તેઓ કેવી રીતે વ્યવસાય કરે છે (સિંક્રોનાઇઝેશન સત્ર માટે જોડાયેલા ગાંઠોને "પડોશી" પણ કહેવામાં આવે છે કારણ કે તેમનો IP જાણીતો છે અને તેમનો સ્ટેટ ડેટા મેમરીમાં સંગ્રહિત છે).

ગો પ્રોગ્રામર્સની સમજમાં ફોલ્ડર્સ (ડિરેક્ટરીઝ જેને Linux કહે છે)ને પેકેજ કહેવામાં આવે છે, તેથી આ ડિરેક્ટરીમાંથી Go કોડ સાથે દરેક ફાઇલની શરૂઆતમાં તેઓ પેકેજ ફોલ્ડર_નામ_where_this_file સ્થિત છે લખે છે. નહિંતર, તમે કમ્પાઇલરને પેકેજ ફીડ કરી શકશો નહીં. ઠીક છે, જેઓ આ ભાષા જાણે છે તેમના માટે આ કોઈ રહસ્ય નથી. આ પેકેજો છે:

• નેટવર્ક સંચાર (સર્વર, ક્લાયંટ, પ્રોટોકોલ)
• સંગ્રહિત અને પ્રસારિત ડેટાનું માળખું (બ્લોક, ટ્રાન્ઝેક્શન)
• ડેટાબેઝ (બ્લોકચેન)
• સર્વસંમતિ
• સ્ટેક્ડ વર્ચ્યુઅલ મશીન (xvm)
• સહાયક (ક્રિપ્ટો, પ્રકારો) હમણાં માટે એટલું જ છે.

અહીં ગીથબની લિંક છે

આ એક શૈક્ષણિક સંસ્કરણ છે, તેમાં આંતર-પ્રક્રિયા ક્રિયાપ્રતિક્રિયા અને કેટલાક પ્રાયોગિક ઘટકોનો અભાવ છે, પરંતુ માળખું તેના પર વિકાસ કરવામાં આવી રહ્યું છે તેને અનુરૂપ છે. જો તમારી પાસે ટિપ્પણીઓમાં સૂચન કરવા માટે કંઈપણ હોય, તો મને વધુ વિકાસમાં તેને ધ્યાનમાં લેવામાં આનંદ થશે. અને હવે સર્વરની સમજૂતી માટે અને પ્રોટોકોલ.

ચાલો પહેલા સર્વર જોઈએ.

સર્વર સબરૂટિન ડેટા સર્વર તરીકે કાર્ય કરે છે જે પ્રોટોકોલ પેકેજમાંથી ડેટા સ્ટ્રક્ચરનો ઉપયોગ કરીને 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])

• મૂલ્ય વાંચે છે શરીર સંખ્યાત્મક ચલ માટે 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]) — લંબાઈ и પ્રાપ્તિ.
• લંબાઈ ડેટા પ્રકાર તપાસે છે આદેશો[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 и 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