Blockchain-kehitys teollisuudelle Golla. Osa 1

Olen nyt neljän kuukauden ajan työskennellyt projektin parissa nimeltä "Tietosuoja- ja hallintatyökalujen kehittäminen valtion ja teollisuuden sektoreilla lohkoketjuun perustuen".
Nyt haluaisin kertoa teille, kuinka aloitin tämän projektin, ja nyt kuvailen ohjelmakoodia yksityiskohtaisesti.

Tämä on ensimmäinen artikkeli artikkelisarjassa. Tässä kuvailen palvelinta ja protokollaa. Itse asiassa lukija voi jopa kirjoittaa omia versioitaan näistä lohkoketjuelementeistä.

Ja tässä on toinen osa — lohkoketju- ja tapahtumatietorakenteista sekä paketista, joka toteuttaa vuorovaikutuksen tietokannan kanssa.

Viime vuonna Digital Breakthrough -hackathonissa keksittiin idea tehdä teollisuudelle ja digitaloudelle hyödyllinen järjestelmä hajautetun reskontrateknologian avulla, kehittämiseen myönnettiin myös Innovation Assistance Foundation -säätiön apuraha (pitäisi kirjoittaa erillinen artikkeli apurahasta, niille, jotka ovat vasta aloittamassa startup-toimintaa ), ja nyt järjestyksessä.

Kehitys tapahtuu Go-kielellä ja tietokanta, johon lohkot tallennetaan, on LevelDB.
Pääosat ovat protokolla, palvelin (joka käyttää TCP:tä ja WebSocketia - ensimmäinen lohkoketjun synkronointiin, toinen asiakkaiden yhdistämiseen, tapahtumien ja komentojen lähettämiseen esimerkiksi JavaScriptistä.

Kuten mainittiin, tätä lohkoketjua tarvitaan ensisijaisesti automatisoimaan ja suojaamaan tuotteiden vaihto toimittajien ja asiakkaiden välillä tai molempien välillä yhdessä henkilössä. Näillä ihmisillä ei ole kiirettä luottaa toisiinsa. Mutta tehtävänä ei ole vain luoda "checkbook" sisäänrakennetulla laskimella, vaan järjestelmä, joka automatisoi useimmat rutiinitehtävät, jotka syntyvät työskenneltäessä tuotteen elinkaaren kanssa. Tästä asiasta vastaava tavukoodi, kuten lohkoketjuissa on tapana, tallennetaan tapahtumien tuloihin ja ulostuloihin (itse tapahtumat tallennetaan lohkoihin, LevelDB:n lohkot on esikoodattu GOB-muotoon). Puhutaan ensin protokollasta ja palvelimesta (alias solmu).

Protokolla ei ole monimutkainen, sen tarkoitus on siirtyä tietyn tiedon, yleensä lohkon tai tapahtuman, lataustilaan vastauksena erityiseen komentoriville, ja sitä tarvitaan myös varaston vaihtoon, jotta solmu tietää kuka se on on yhteydessä ja miten heillä on tekemistä (synkronointiistuntoon kytkettyjä solmuja kutsutaan myös "naapuriksi", koska niiden IP tunnetaan ja niiden tilatiedot on tallennettu muistiin).

Kansioita (hakemistoja, kuten Linux niitä kutsuu) kutsutaan Go-ohjelmoijien ymmärryksessä paketeiksi, joten jokaisen tämän hakemiston Go-koodin tiedoston alkuun he kirjoittavat paketin kansion_nimi_missä_tämä_tiedosto sijaitsee. Muuten et voi syöttää pakettia kääntäjälle. No, tämä ei ole salaisuus niille, jotka osaavat tämän kielen. Nämä ovat paketit:

• Verkkoviestintä (palvelin, asiakas, protokolla)
• Tallennettujen ja siirrettävien tietojen rakenteet (lohko, tapahtuma)
• Tietokanta (lohkoketju)
• Yhteisymmärrys
• Pinottu virtuaalikone (xvm)
• Apuohjelma (crypto, tyypit) siinä kaikki toistaiseksi.

Tässä linkki githubiin

Tämä on koulutusversio, josta puuttuu prosessien välinen vuorovaikutus ja useita kokeellisia komponentteja, mutta rakenne vastaa sitä, jolla kehitetään. Jos sinulla on jotain ehdotettavaa kommenteissa, otan sen mielelläni huomioon jatkokehityksessä. Ja nyt selitys palvelimesta ja protokolla.

Katsotaanpa ensin palvelinta.

Palvelimen aliohjelma toimii tietopalvelimena, joka toimii TCP-protokollan päällä käyttämällä protokollapaketin tietorakenteita.

Rutiini käyttää seuraavia paketteja: palvelin, protokolla, tyypit. Itse paketissa tcp_server.go sisältää tietorakenteen Palvella.

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

Se voi hyväksyä seuraavat parametrit:

• Verkkoportti, jonka kautta tietoja vaihdetaan
• Palvelimen määritystiedosto JSON-muodossa
• Lippu käytettäväksi virheenkorjaustilassa (yksityinen lohkoketju)

Edistyminen:

• Lukee määritykset JSON-tiedostosta
• Virheenkorjaustilan lippu on tarkistettu: jos se on asetettu, verkon synkronoinnin ajastinta ei käynnistetä eikä lohkoketjua ladata
• Konfigurointitietorakenteen alustaminen ja palvelimen käynnistäminen

Server

• Suorittaa TCP-palvelimen käynnistämisen ja verkkovuorovaikutuksen protokollan mukaisesti.
• Siinä on Serve-tietorakenne, joka koostuu portin numerosta, puskurin koosta ja osoittimesta rakenteeseen tyypit. Asetukset
• Suorita-menetelmä käynnistää verkkovuorovaikutuksen (saapuvien yhteyksien kuunteleminen tietyssä portissa, kun uusi yhteys vastaanotetaan, sen käsittely siirretään uudessa säikeessä private hand -menetelmään)
• В kahva yhteyden tiedot luetaan puskuriin, muunnetaan merkkijonoesitykseen ja välitetään protokolla. Valinta
• protokolla. Valinta palaa johtua tai aiheuttaa virheen. johtua sitten siirrettiin protokolla. Tulkitajoka palaa intrpr - tyyppinen kohde InterpreteData, tai aiheuttaa virheen valintatuloksen käsittelyssä
• Sitten kytkin suoritetaan intrpr.Commands[0] joka tarkistaa yhden seuraavista: tulos, lasku, virhe ja siellä on osasto oletusarvo
• osiossa johtua kytkin löytyy arvon mukaan intrpr.Commands[1] joka tarkistaa arvot puskurin pituus и versio (jokaisessa tapauksessa kutsutaan vastaava funktio)

Tehtävät Hanki Version и Puskurin pituus ovat tiedostossa srvlib.go palvelinpaketti

GetVersion(conn net.Conn, version string)

se yksinkertaisesti tulostaa konsoliin ja lähettää parametrissa välitetyn version asiakkaalle:

conn.Write([]byte("result:" + version))

.
Toiminto

BufferLength(conn net.Conn, intrpr *protocol.InterpreteData)

lataa lohkon, tapahtuman tai muita erityisiä tietoja seuraavasti:

• Tulostaa konsoliin protokollassa määritetyt tiedot, jotka on hyväksyttävä:

  fmt.Println("DataType:", intrpr.Commands[2])

• Lukee arvon intrpr.Body numeeriseen muuttujaan buf_len
• Luo puskurin newbuf määritetty koko:

  make([]byte, buf_len)

• Lähettää ok vastauksen:

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

• Täyttää puskurin kokonaan lukuvirrasta:

  io.ReadFull(conn, newbuf)

  .

• Tulostaa puskurin sisällön konsoliin

  fmt.Println(string(newbuf))

  ja luettujen tavujen määrä

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

• Lähettää ok vastauksen:

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

Palvelinpaketin menetelmät on määritetty käsittelemään vastaanotetut tiedot paketin toimintojen avulla protokolla.

Protokolla

Protokolla toimii välineenä, joka edustaa dataa verkkovaihdossa.

Vaihtoehto(merkkijono) (merkkijono, virhe) suorittaa palvelimen vastaanottamien tietojen ensisijaisen käsittelyn, vastaanottaa syötteenä tiedoista merkkijonoesityksen ja palauttaa merkkijonon, joka on valmis Tulkki:

• Syöttömerkkijono jaetaan päähän ja vartaloon käyttämällä ReqParseN2(str)
• head jaetaan elementeiksi ja sijoitetaan komentolohkoksi käyttämällä ReqParseHead(head)
• В kytkin (komennot[0]) valitse vastaanotettu komento (cmd, avain, osoite tai osio laukeaa oletusarvo)
• 2 komentoa tarkistetaan cmd:ssä kytkin(komennot[1]) — pituus и getversio.
• pituus tarkistaa tietotyypin komennot[2] ja tallentaa sen tietotyyppi
• Tarkistaa sen elin sisältää merkkijonoarvon

  len(body) < 1

• Palauttaa vastausmerkkijonon:

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

• getversio palauttaa merkkijonon

  return "result:version/auto"

Tulkki

Sisältää InterpreteData-rakenteen ja suorittaa palautettujen tietojen toissijaisen käsittelyn Valinta merkkijonot ja objektinmuodostus InterpreteData.

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

Toiminto

Interprete(str string) (*InterpreteData, error)

hyväksyy merkkijonon johtua ja luo ja palauttaa viittauksen objektiin InterpreteData.

Edistyminen:

• samoin Valinta pää ja vartalo poistetaan käyttämällä ReqParseN2(str)
• pää jaetaan elementeiksi käyttämällä ReqParseHead(pää)
• Objekti alustetaan InterpreteData ja osoitin siihen palautetaan:

res := &InterpreteData{
	Head: head,
	Commands: commands,
	Body: body,
}
return res, nil

Tätä objektia käytetään mm server.go paketin pääasiallinen.

Asiakas

Asiakaspaketti sisältää toiminnot TCPConnect и TCPResponseData.

Toiminto

TCPConnect(s *types.Settings, data []byte, payload []byte)

toimii näin:

• Yhteys muodostetaan läpäistyssä asetusobjektissa määritettyyn yhteyteen

  net.Dial("tcp", s.Host + ":" + s.Port)

• Dataparametrissa välitetyt tiedot lähetetään:

  conn.Write(data)

• Vastaus luetaan

  resp, n, _ := TCPResponseData(conn, s.BufSize)

  ja tulostettu konsoliin

  fmt.Println(string(resp[:n]))

• Jos siirretään hyötykuorma sitten välittää sen eteenpäin

  conn.Write(payload)

  ja myös lukee palvelimen vastauksen ja tulostaa sen konsoliin

Toiminto

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

luo määritetyn kokoisen puskurin, lukee sieltä palvelimen vastauksen ja palauttaa tämän puskurin ja luettujen tavujen määrän sekä virheobjektin.

Asiakas-alirutiini

Toimii komentojen lähettämiseen solmupalvelimille sekä lyhyiden tilastojen ja testauksen hankkimiseen.

Voi hyväksyä seuraavat parametrit: konfiguraatiotiedosto JSON-muodossa, palvelimelle merkkijonona lähetettävä data, hyötykuormaan lähetettävän tiedoston polku, solmun ajoittimen emulointilippu, numeroarvona siirrettävän tiedon tyyppi.

• Määrityksen hakeminen

  st := types.ParseConfig(*config)

• Jos emu-lippu ohitetaan, se käynnistyy sheduler
• Jos f-lippu, joka osoittaa tiedoston polun, syötetään, lataamme sen tiedot fdb ja sisältö lähetetään palvelimelle

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

• Jos tiedostoa ei ole määritetty, lipun tiedot yksinkertaisesti lähetetään -d:

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

Kaikki tämä on yksinkertaistettu esitys, joka näyttää protokollan rakenteen. Kehityksen aikana sen rakenteeseen lisätään tarvittavat toiminnallisuudet.

Toisessa osassa puhun lohkojen ja tapahtumien tietorakenteista, 3:ssa WebSocket-palvelimesta JavaScript-yhteyden muodostamista varten, 4:ssä tarkastelen synkronoinnin ajoitinta, sitten pinokonetta, joka käsittelee tavukoodia tuloista ja lähdöistä, kryptografiasta ja altaat lähtöjä varten.

Lähde: will.com