గోను ఉపయోగించి పరిశ్రమ కోసం బ్లాక్‌చెయిన్ అభివృద్ధి. 1 వ భాగము

నాలుగు నెలలుగా నేను "బ్లాక్‌చెయిన్ ఆధారంగా ప్రభుత్వ మరియు పారిశ్రామిక రంగాలలో డేటా రక్షణ మరియు నిర్వహణ సాధనాల అభివృద్ధి" అనే ప్రాజెక్ట్‌పై పని చేస్తున్నాను.
ఇప్పుడు నేను ఈ ప్రాజెక్ట్‌ను ఎలా ప్రారంభించాను అనే దాని గురించి మీకు చెప్పాలనుకుంటున్నాను మరియు ఇప్పుడు నేను ప్రోగ్రామ్ కోడ్‌ను వివరంగా వివరిస్తాను.

వ్యాసాల పరంపరలో ఇది మొదటి వ్యాసం. ఇక్కడ నేను సర్వర్ మరియు ప్రోటోకాల్ గురించి వివరిస్తాను. వాస్తవానికి, రీడర్ ఈ బ్లాక్‌చెయిన్ మూలకాల యొక్క తన స్వంత సంస్కరణలను కూడా వ్రాయవచ్చు.

మరియు ఇక్కడ రెండవ భాగం — బ్లాక్‌చెయిన్ మరియు లావాదేవీల డేటా నిర్మాణాల గురించి, అలాగే డేటాబేస్‌తో పరస్పర చర్యను అమలు చేసే ప్యాకేజీ గురించి.

గత సంవత్సరం, డిజిటల్ బ్రేక్‌త్రూ హ్యాకథాన్‌లో, పంపిణీ చేయబడిన లెడ్జర్ సాంకేతికతను ఉపయోగించి పరిశ్రమ మరియు డిజిటల్ ఆర్థిక వ్యవస్థకు ఉపయోగకరమైన వ్యవస్థను రూపొందించాలనే ఆలోచనతో వారు ముందుకు వచ్చారు; ఇన్నోవేషన్ అసిస్టెన్స్ ఫండ్ ద్వారా అభివృద్ధి కోసం గ్రాంట్ కూడా జారీ చేయబడింది (నేను ప్రత్యేకంగా వ్రాయాలి ఇప్పుడే స్టార్టప్‌లను ప్రారంభించే వారికి మంజూరు గురించి కథనం ), మరియు ఇప్పుడు క్రమంలో.

అభివృద్ధి గో భాషలో జరుగుతుంది మరియు బ్లాక్‌లు నిల్వ చేయబడిన డేటాబేస్ LevelDB.
ప్రధాన భాగాలు ప్రోటోకాల్, సర్వర్ (ఇది TCP మరియు WebSocketని అమలు చేస్తుంది - మొదటిది బ్లాక్‌చెయిన్‌ను సమకాలీకరించడానికి, రెండవది క్లయింట్‌లను కనెక్ట్ చేయడానికి, జావాస్క్రిప్ట్ నుండి లావాదేవీలు మరియు ఆదేశాలను పంపడానికి, ఉదాహరణకు.

పేర్కొన్నట్లుగా, ఈ బ్లాక్‌చెయిన్ ప్రధానంగా సరఫరాదారులు మరియు కస్టమర్‌ల మధ్య ఉత్పత్తుల మార్పిడిని ఆటోమేట్ చేయడానికి మరియు రక్షించడానికి లేదా ఇద్దరికీ ఒక వ్యక్తిలో అవసరం. ఈ వ్యక్తులు ఒకరినొకరు విశ్వసించటానికి తొందరపడరు. కానీ పని అంతర్నిర్మిత కాలిక్యులేటర్‌తో "చెక్‌బుక్" ను సృష్టించడం మాత్రమే కాదు, ఉత్పత్తి జీవిత చక్రంతో పనిచేసేటప్పుడు ఉత్పన్నమయ్యే చాలా సాధారణ పనులను ఆటోమేట్ చేసే వ్యవస్థ. ఈ విషయానికి బాధ్యత వహించే బైట్‌కోడ్, బ్లాక్‌చెయిన్‌లతో ఆచారం వలె, లావాదేవీల ఇన్‌పుట్‌లు మరియు అవుట్‌పుట్‌లలో నిల్వ చేయబడుతుంది (లావాదేవీలు బ్లాక్‌లలో నిల్వ చేయబడతాయి, LevelDBలోని బ్లాక్‌లు GOB ఆకృతిలో ముందే ఎన్‌కోడ్ చేయబడతాయి). ముందుగా, ప్రోటోకాల్ మరియు సర్వర్ (అకా నోడ్) గురించి మాట్లాడుకుందాం.

ప్రోటోకాల్ సంక్లిష్టంగా లేదు, ప్రత్యేక కమాండ్ లైన్‌కు ప్రతిస్పందనగా కొంత డేటా, సాధారణంగా బ్లాక్ లేదా లావాదేవీని లోడ్ చేసే మోడ్‌కు మారడం దాని మొత్తం పాయింట్, మరియు ఇన్వెంటరీని మార్పిడి చేయడానికి కూడా ఇది అవసరం, తద్వారా నోడ్ అది ఎవరో తెలుసుకుంటుంది. కనెక్ట్ చేయబడింది మరియు వారు ఎలా వ్యాపారం చేయాలి (సింక్రొనైజేషన్ సెషన్ కోసం కనెక్ట్ చేయబడిన నోడ్‌లను "పొరుగు" అని కూడా పిలుస్తారు, ఎందుకంటే వాటి IP తెలిసినది మరియు వారి స్టేట్ డేటా మెమరీలో నిల్వ చేయబడుతుంది).

Go ప్రోగ్రామర్‌ల అవగాహనలో ఉన్న ఫోల్డర్‌లను (డైరెక్టరీలను Linux పిలుస్తుంది) ప్యాకేజీలు అని పిలుస్తారు, కాబట్టి ఈ డైరెక్టరీ నుండి Go కోడ్‌తో ప్రతి ఫైల్ ప్రారంభంలో వారు ప్యాకేజీ 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.Choice
• protocol.Choice తిరిగి ఫలితంగా లేదా దోషాన్ని కలిగిస్తుంది. ఫలితంగా తర్వాత బదిలీ చేయబడింది ప్రోటోకాల్. ఇంటర్‌ప్రెట్ఇది తిరిగి వస్తుంది 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
• బఫర్‌ను సృష్టిస్తుంది న్యూబఫ్ పేర్కొన్న పరిమాణం:

  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, కీ, చిరునామా లేదా విభాగం ట్రిగ్గర్ చేయబడింది డిఫాల్ట్)
• 2 ఆదేశాలు cmdలో తనిఖీ చేయబడ్డాయి స్విచ్(కమాండ్స్[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లో జావాస్క్రిప్ట్ నుండి కనెక్ట్ చేయడానికి వెబ్‌సాకెట్ సర్వర్ గురించి, 4లో నేను సింక్రొనైజేషన్ షెడ్యూలర్‌ని చూస్తాను, ఆపై ఇన్‌పుట్‌లు మరియు అవుట్‌పుట్‌ల నుండి బైట్‌కోడ్‌ను ప్రాసెస్ చేసే స్టాక్ మెషిన్, క్రిప్టోగ్రఫీ మరియు అవుట్‌పుట్‌ల కోసం పూల్స్.

మూలం: www.habr.com