ბლოკჩეინის განვითარება ინდუსტრიისთვის Go-ს გამოყენებით. Ნაწილი 1

უკვე ოთხი თვეა ვმუშაობ პროექტზე სახელწოდებით „მონაცემთა დაცვისა და მართვის ინსტრუმენტების შემუშავება სამთავრობო და ინდუსტრიულ სექტორებში ბლოკჩეინზე დაფუძნებული“.
ახლა მინდა გითხრათ როგორ დავიწყე ეს პროექტი და ახლა დეტალურად აღვწერ პროგრამის კოდს.

ეს არის სტატიების სერიის პირველი სტატია. აქ მე აღვწერ სერვერს და პროტოკოლს. სინამდვილეში, მკითხველს შეუძლია დაწეროს ამ ბლოკჩეინის ელემენტების საკუთარი ვერსიებიც.

და აი მეორე ნაწილი — ბლოკჩეინისა და ტრანზაქციის მონაცემთა სტრუქტურების შესახებ, ასევე პაკეტის შესახებ, რომელიც ახორციელებს მონაცემთა ბაზასთან ინტერაქციას.

გასულ წელს, Digital Breakthrough-ის ჰაკათონზე, მათ გაუჩნდათ იდეა, შეექმნათ სასარგებლო სისტემა ინდუსტრიისთვის და ციფრული ეკონომიკისთვის, განაწილებული წიგნის ტექნოლოგიის გამოყენებით; ასევე გაცემული იყო გრანტი განვითარებისთვის ინოვაციების დახმარების ფონდის მიერ (ცალკე უნდა დავწერო. სტატია გრანტის შესახებ, მათთვის, ვინც ახლახან იწყებს სტარტაპების კეთებას) და ახლა წესრიგში.

განვითარება ხდება Go ენაზე და მონაცემთა ბაზა, რომელშიც ბლოკები ინახება არის LevelDB.
ძირითადი ნაწილებია პროტოკოლი, სერვერი (რომელიც მუშაობს TCP და WebSocket - პირველი ბლოკჩეინის სინქრონიზაციისთვის, მეორე კლიენტების დასაკავშირებლად, ტრანზაქციების და ბრძანებების გაგზავნისთვის, მაგალითად, JavaScript-დან.

როგორც აღვნიშნეთ, ეს ბლოკჩეინი პირველ რიგში საჭიროა მომწოდებლებსა და მომხმარებლებს შორის პროდუქციის გაცვლის ავტომატიზაციისა და დასაცავად, ან ორივე ერთ ადამიანში. ეს ხალხი არ ჩქარობს ერთმანეთის ნდობას. მაგრამ ამოცანა არ არის მხოლოდ "ჩეკის წიგნის" შექმნა ჩაშენებული კალკულატორით, არამედ სისტემა, რომელიც ავტომატიზირებს რუტინული ამოცანების უმეტესობას, რომლებიც წარმოიქმნება პროდუქტის სასიცოცხლო ციკლთან მუშაობისას. ბაიტეკოდი, რომელიც პასუხისმგებელია ამ საკითხზე, როგორც ჩვეული ბლოკჩეინებისთვის, ინახება ტრანზაქციების შეყვანებსა და გამომავალებში (თვითონ ტრანზაქციები ინახება ბლოკებში, LevelDB ბლოკები წინასწარ დაშიფრულია GOB ფორმატში). პირველ რიგში, მოდით ვისაუბროთ პროტოკოლზე და სერვერზე (aka node).

პროტოკოლი არ არის რთული, მისი მთელი მიზანია გადავიდეს გარკვეული მონაცემების ჩატვირთვის რეჟიმში, როგორც წესი, ბლოკი ან ტრანზაქცია, სპეციალური ბრძანების ხაზის საპასუხოდ, ასევე საჭიროა ინვენტარის გაცვლისთვის, რათა კვანძმა იცოდეს ვინ არის. არის დაკავშირებული და როგორ უნდა გააკეთონ ისინი (სინქრონიზაციის სესიისთვის დაკავშირებულ კვანძებს ასევე უწოდებენ "მეზობელს", რადგან მათი IP ცნობილია და მათი მდგომარეობის მონაცემები ინახება მეხსიერებაში).

საქაღალდეებს (საქაღალდეებს, როგორც ლინუქსი უწოდებს მათ) 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 ფაილიდან
• გამართვის რეჟიმის დროშა მოწმდება: თუ ის დაყენებულია, ქსელის სინქრონიზაციის გრაფიკი არ არის გაშვებული და ბლოკჩეინი არ იტვირთება
• კონფიგურაციის მონაცემთა სტრუქტურის ინიცირება და სერვერის გაშვება

Server

• ახორციელებს TCP სერვერის გაშვებას და ქსელურ ინტერაქციას პროტოკოლის შესაბამისად.
• მას აქვს Serve მონაცემთა სტრუქტურა, რომელიც შედგება პორტის ნომრისგან, ბუფერის ზომისა და სტრუქტურის მაჩვენებლისგან ტიპები.პარამეტრები
• Run მეთოდი იწყებს ქსელის ურთიერთქმედებას (მომავალი კავშირების მოსმენა მოცემულ პორტზე, როდესაც ახალი კავშირი მიიღება, მისი დამუშავება გადადის კერძო სახელურის მეთოდზე ახალ თემაში)
• В გაუმკლავდეს კავშირიდან მიღებული მონაცემები იკითხება ბუფერში, გარდაიქმნება სტრიქონში და გადაეცემა პროტოკოლი.არჩევანი
• პროტოკოლი.არჩევანი ბრუნდება შედეგად ან იწვევს შეცდომას. შედეგად შემდეგ გადაეცა პროტოკოლი.ინტერპრეტაციარომელიც ბრუნდება intrpr - ტიპის ობიექტი InterpreteData, ან იწვევს შეცდომას შერჩევის შედეგის დამუშავებისას
• შემდეგ გადართვა შესრულებულია 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)

• აგზავნის OK პასუხს:

  conn.Write([]byte("result:ok"))

• სრულად ავსებს ბუფერს წაკითხული ნაკადიდან:

  io.ReadFull(conn, newbuf)

  .

• ბეჭდავს ბუფერის შიგთავსს კონსოლზე

  fmt.Println(string(newbuf))

  და წაკითხული ბაიტების რაოდენობა

  fmt.Println("Bytes length:", n)

• აგზავნის OK პასუხს:

  conn.Write([]byte("result:ok"))

სერვერის პაკეტის მეთოდები კონფიგურირებულია მიღებული მონაცემების დასამუშავებლად პაკეტიდან ფუნქციების გამოყენებით ოქმი.

ოქმი

პროტოკოლი ემსახურება როგორც საშუალებას, რომელიც წარმოადგენს მონაცემებს ქსელის გაცვლაში.

არჩევანი (str string) (სტრიქონი, შეცდომა) ასრულებს სერვერის მიერ მიღებული მონაცემების პირველად დამუშავებას, იღებს მონაცემების სტრიქონულ წარმოდგენას, როგორც შეყვანის სახით და აბრუნებს ამისთვის მომზადებულ სტრიქონს თარჯიმანი:

• შეყვანის სტრიქონი იყოფა თავსა და სხეულზე გამოყენებით ReqParseN2(str)
• თავი იყოფა ელემენტებად და მოთავსებულია ბრძანებების ნაწილად ReqParseHead(ხელმძღვანელის) გამოყენებით
• В შეცვლა (ბრძანებები[0]) აირჩიეთ მიღებული ბრძანება (cmd, გასაღები, მისამართი ან განყოფილება გააქტიურებულია პოსტი)
• 2 ბრძანება შემოწმებულია cmd-ში შეცვლა (ბრძანებები[1]) - სიგრძე и გადაქცევა.
• სიგრძე ამოწმებს მონაცემთა ტიპს ბრძანებები[2] და ინახავს მას მონაცემთა ტიპი
• ამოწმებს ამას სხეულის შეიცავს სტრიქონის მნიშვნელობას

  len(body) < 1

• აბრუნებს პასუხის სტრიქონს:

  "result:bufferlength:" + datatype + "/" + body

• გადაქცევა აბრუნებს სტრიქონს

  return "result:version/auto"

თარჯიმანი

შეიცავს InterpreteData სტრუქტურას და ახორციელებს დაბრუნებული მონაცემების მეორად დამუშავებას არჩევანი სიმები და ობიექტის ფორმირება InterpreteData.

type InterpreteData struct {
	Head string
	Commands []string
	Body string
	IsErr bool
	ErrCode int 
	ErrMessage string
}

ფუნქცია

Interprete(str string) (*InterpreteData, error)

იღებს სტრიქონს შედეგად და ქმნის და აბრუნებს მინიშნებას ობიექტზე InterpreteData.

პროგრესი:

• ანალოგიურად არჩევანი თავი და სხეული ამოღებულია გამოყენებით ReqParseN2(str)
• თავი იყოფა ელემენტებად გამოყენებით ReqParseHead(ხელმძღვანელი)
• ობიექტი დაწყებულია InterpreteData და მასზე მითითება ბრუნდება:

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]))

• თუ გადატანილია payload შემდეგ გადასცემს მას

  conn.Write(payload)

  და ასევე კითხულობს სერვერის პასუხს, ბეჭდავს მას კონსოლში

ფუნქცია

 TCPResponseData(conn net.Conn, bufsiz int) ([]byte, int, error)

ქმნის მითითებული ზომის ბუფერს, კითხულობს იქ სერვერის პასუხს და აბრუნებს ამ ბუფერს და წაკითხული ბაიტების რაოდენობას, ასევე შეცდომის ობიექტს.

კლიენტის ქვეპროგრამა

ემსახურება კვანძების სერვერებზე ბრძანებების გაგზავნას, ასევე მოკლე სტატისტიკას და ტესტირებას.

შეუძლია შემდეგი პარამეტრების მიღება: კონფიგურაციის ფაილი JSON ფორმატში, მონაცემები სერვერზე სტრიქონის სახით გასაგზავნად, ფაილში გასაგზავნად გასაგზავნად, კვანძების განრიგის ემულაციის დროშა, რიცხვითი მნიშვნელობის სახით გადაცემული მონაცემების ტიპი.

• კონფიგურაციის მიღება

  st := types.ParseConfig(*config)

• თუ emu დროშა გადაცემულია, ის იწყება დამლაგებელი
• თუ მოწოდებულია f დროშა, რომელიც მიუთითებს ფაილის გზაზე, მაშინ ჩვენ ვტვირთავთ მის მონაცემებს fdb და შინაარსი იგზავნება სერვერზე

  client.TCPConnect(st, []byte(CMD_BUFFER_LENGTH + ":" + strconv.Itoa(*t) + "/" + strconv.Itoa(fdblen)), fdb)

• თუ ფაილი არ არის მითითებული, მაშინ დროშის მონაცემები უბრალოდ იგზავნება -d:

  client.TCPConnect(st, []byte(*data), nil)

ეს ყველაფერი არის გამარტივებული წარმოდგენა, რომელიც აჩვენებს პროტოკოლის სტრუქტურას. განვითარების დროს მის სტრუქტურას ემატება საჭირო ფუნქციონირება.

მეორე ნაწილში ვისაუბრებ მონაცემთა სტრუქტურებზე ბლოკებისა და ტრანზაქციებზე, 3-ში WebSocket სერვერზე JavaScript-დან დასაკავშირებლად, 4-ში შევხედავ სინქრონიზაციის განრიგს, შემდეგ სტეკის მანქანას, რომელიც ამუშავებს ბაიტეკოდს შეყვანიდან და გამომავალებიდან, კრიპტოგრაფია და აუზები გამოსავლებისთვის.

წყარო: www.habr.com