פיתוח בלוקצ'יין לתעשייה באמצעות Go. חלק 1

כבר ארבעה חודשים שאני עובד על פרויקט שנקרא "פיתוח כלי הגנת מידע וניהול במגזרים ממשלתיים ותעשייתיים על בסיס בלוקצ'יין".
עכשיו אני רוצה לספר לכם על איך התחלתי את הפרויקט הזה, ועכשיו אתאר את קוד התוכנית בפירוט.

זהו המאמר הראשון בסדרת מאמרים. כאן אני מתאר את השרת והפרוטוקול. למעשה, הקורא יכול אפילו לכתוב גרסאות משלו למרכיבי הבלוקצ'יין הללו.

והנה החלק השני - על בלוקצ'יין ומבני נתונים של עסקאות, כמו גם על החבילה המיישמת אינטראקציה עם מסד הנתונים.

בשנה שעברה, בהאקתון פריצת דרך דיגיטלית, הם העלו רעיון ליצור מערכת שימושית לתעשייה ולכלכלה הדיגיטלית באמצעות טכנולוגיית ספרי חשבונות מבוזרים; כמו כן הונפק מענק לפיתוח על ידי קרן הסיוע לחדשנות (אני צריך לכתוב נפרד מאמר על המענק, למי שרק מתחיל לעשות סטארטאפים), ועכשיו בסדר.

הפיתוח מתבצע בשפת Go, ומסד הנתונים בו מאוחסנים הבלוקים הוא LevelDB.
החלקים העיקריים הם הפרוטוקול, השרת (שמריץ TCP ו-WebSocket - הראשון לסנכרון הבלוקצ'יין, השני לחיבור לקוחות, שליחת עסקאות ופקודות מ-JavaScript, למשל.

כאמור, הבלוקצ'יין הזה נחוץ בעיקר כדי למכן ולהגן על החלפת מוצרים בין ספקים ללקוחות, או שניהם באדם אחד. האנשים האלה לא ממהרים לסמוך זה על זה. אבל המשימה היא לא רק ליצור "פנקס צ'קים" עם מחשבון מובנה, אלא מערכת שממכנת את רוב המשימות השגרתיות שעולות בעבודה עם מחזור חיי המוצר. ה-bytecode שאחראי לעניין זה, כמקובל בבלוקצ'יין, נשמר בכניסות וביציאות של טרנזקציות (העסקאות עצמן מאוחסנות בבלוקים, הבלוקים ב-LevelDB מקודדים מראש בפורמט GOB). ראשית, בואו נספר לכם על הפרוטוקול והשרת (המכונה גם צומת).

הפרוטוקול לא מסובך, כל הקטע שלו הוא לעבור למצב של טעינת נתונים מסוימים, בדרך כלל בלוק או טרנזקציה, בתגובה לשורת פקודה מיוחדת, והוא נחוץ גם להחלפת מלאי, כדי שהצומת יידע מי הוא. מחובר ואיך יש להם עסקים לעשות (הצמתים המחוברים לסשן הסנכרון נקראים גם "שכנים" מכיוון שה-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
• דגל מצב ניפוי באגים מסומן: אם הוא מוגדר, מתזמן הסנכרון של הרשת לא מופעל וה- blockchain לא נטען
• אתחול מבנה נתוני התצורה והפעלת השרת

שרת

• מבצע את השקת שרת ה-TCP והאינטראקציה ברשת בהתאם לפרוטוקול.
• יש לו מבנה נתונים של Serve המורכב ממספר יציאה, גודל מאגר ומצביע למבנה סוגים.הגדרות
• שיטת ההפעלה מתחילה אינטראקציה ברשת (האזנה לחיבורים נכנסים בפורט נתון, כאשר מתקבל חיבור חדש, העיבוד שלו מועבר לשיטת הטיפול הפרטי בשרשור חדש)
• В לטפל נתונים מהחיבור נקראים למאגר, מומרים לייצוג מחרוזת ומועברים אל פרוטוקול.בחירה
• פרוטוקול.בחירה החזרות תוצאה או גורם לשגיאה. תוצאה לאחר מכן הועבר ל פרוטוקול.לפרששמחזירה intrpr - אובייקט מסוג InterpreteData, או גורם לשגיאה בעיבוד תוצאת הבחירה
• לאחר מכן המעבר מתבצע intrpr.Commands[0] שבודק אחד מ: תוצאה, inv, error ויש קטע ברירת מחדל
• בקטע תוצאה מתג נמצא לפי ערך 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])

• קורא את הערך intrpr.Body למשתנה מספרי 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"))

שיטות מחבילת השרת מוגדרות לעיבוד נתונים שהתקבלו באמצעות פונקציות מהחבילה פרוטוקול.

פרוטוקול

פרוטוקול משמש כאמצעי המייצג נתונים בחילופי רשתות.

Choice(str string) (מחרוזת, שגיאה) מבצע עיבוד ראשוני של נתונים המתקבלים על ידי השרת, מקבל ייצוג מחרוזת של הנתונים כקלט ומחזיר מחרוזת שהוכנה עבור מְתוּרגְמָן:

• מחרוזת הקלט מפוצלת לראש ולגוף באמצעות ReqParseN2(str)
• head מפוצל לאלמנטים וממוקם לפרוסת פקודות באמצעות ReqParseHead(head)
• В switch(פקודות[0]) בחר את הפקודה שהתקבלה (cmd, מפתח, כתובת או שהקטע מופעל ברירת מחדל)
• 2 פקודות מסומנות ב-cmd switch(פקודות[1]) - אורך и getversion.
• אורך בודק את סוג הנתונים פקודות[2] ושומר אותו פנימה סוג מידע
• בודק את זה גוּף מכיל ערך מחרוזת

  len(body) < 1

• מחזירה את מחרוזת התגובה:

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

• getversion מחזיר מחרוזת

  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(head)
• האובייקט מאותחל 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]))

• אם מועבר מטען ואז מעביר את זה הלאה

  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 על שרת WebSocket לחיבור מ-JavaScript, ב-4 אסתכל על מתזמן הסנכרון, ואז מכונת מחסנית שמעבדת קוד בתים מכניסות ויציאות, קריפטוגרפיה ו בריכות לתפוקות.

מקור: www.habr.com