Claustrum evolutionis industriae utens Go. Pars I

Quattuor menses iam laboravi in ​​incepto nomine "Evolutionis instrumentorum tutelae et administrationis datarum in re publica et sectorum industrialium secundum impedimentum".
Nunc vellem tibi narrare quomodo inceptum hoc inceptum sit, nunc programmatis codicem singillatim describam.

Primus articulus est in serie capitulorum. Hic servo et protocollo describam. Re quidem vera, lector potest etiam proprias versiones harum impedimentorum elementorum versiones scribere.

Et hic est secunda pars — de impedimento et transactione datarum structurarum, tum de sarcina quae commercium cum datorum instrumentis conficit.

Ultimo anno, in hackathon Digital Breakthrough, accesserunt cum idea ad utilem rationem industriae et oeconomiae digitalis utentes technologias distributas distributas, concessio etiam pro evolutione Fundi Innovationis ab Auxiliaris (singularis scriberem) articulus de cessione, pro iis qui incipit incipit) et nunc in ordine.

Progressio fit in lingua Go, et datorum, in quo caudices reponuntur, est LevelDB.
Partes principales sunt protocollum, serviens (quae TCP et WebSocket fugit - prima ad synchronum claustrum, secunda pro clientibus connectendis, negotia et mandata mittens a JavaScript, exempli gratia.

Hoc impedimentum, ut supra dictum est, opus est imprimis automate ac tuenda commutatione productorum inter victuarios et clientes, vel utrumque in una persona. Non properant hi homines se invicem credere. Negotium autem est non solum "checkbook" cum calculatore aedificato creare, sed systema quod automates maxime laboris exercitationis oriuntur in operando cum cyclo vitae producto. In bytecode, qui ad hanc rem pertinet, sicut in clausulis consuetum est, in initibus et outputibus negotiorum reponitur (res ipsae in caudices repositae sunt, caudices in LevelDB in forma GOB praenotati sunt). Primum de protocollo et de servo fama (aka node).

Protocollum non perplexum est, totum eius punctum ad modum onerationis aliquas notitias, plerumque truncum vel negotium, in responsione ad lineam mandatum specialem flectendum, et ad inventarium commutandum etiam opus est, ut nodi quis cognoscat. iunctus est et quomodo negotium ad faciendum habent (nodos ad synchronization connexos sessiones vocantur etiam "propinquus" quia eorum IP cognoscitur et eorum status notitia in memoria reponitur).

Folders (directiones quas Linux vocat) in intellectu Go programmatores fasciculi vocantur, in principio cuiusque fasciculi cum Go codice ex hoc indice scribunt sarcina folder_name_where_this_file sita est. Alioquin sarcinam compilator alere non poteris. Bene, hoc est occultum iis qui hanc linguam noverunt. Hae sunt fasciculi:

• Communicatio retis (servo, clienti, protocollo)
• Structurae repositae et transmissae datae (obstructionum, transactionem)
• Database (blockchain)
• Consensus
• Machina virtualis reclinans (xvin)
• Auxilia (crypto, types) quae nunc omnia sunt.

Hic est nexus cum github

Haec versio scholastica est, sine commercio inter- cessu et pluribus experimentis, sed structura respondet illi in quo explicatio exercetur. Si quid habes in commentis suggerere, laetus ero in ulteriori progressione rationem considerare. Nunc ad explicationem servo and protocol.

Intueamur primum servo.

Minister subroutine agit ut servo notitiae quae super TCP protocollo decurrit utens structurarum notitiarum e sarcina protocollo.

In exercitatione fasciculis his utitur: Server, protocol, generibus. In tellus ipsum tcp_server.go continet notitia compages Serve.

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

Potest parametri sequentis accipere:

• Portus Network per quem notitia commutabitur
• Servo configuration file in JSON format
• Vexillum ad currit in lusione (privata blockchain)

Progredior:

• Configuratione legit ex file JSON
• Vexillum modo debug reprimitur: si positum est, retis synchronisation schedula immissa non est, et impedimentum non oneratur.
• Initialising cum configuratione notitia structuram et incipiens a servo

servo

• Lorem de TCP servientis et network commercium peragit secundum protocollum.
• Ministerium notitiarum structuram habet constans numerus portus, magnitudo quiddam et structurae monstratorem types.Settings
• Curri modus incipit commercium retis (auscultatio ad hospites advenientes in portu dato, cum nova connexio recipitur, processus eius transfertur ad methodum ansam privatam in novo filo)
• В capulus notitia ex nexu legitur in quiddam, conversum ad chordas repraesentativum et transvectum to . protocol.Choice
• protocol.Choice redit exitum vel errorem facit. exitum et translatum est protocol.Interpretequae redit intrpr - object of type InterpreteDataaut errorem facit in processu electionis
• Tum switch fit intrpr.Commands[0] quae unum coercet; result, inv, error et ibi est sectionem default
• In sectione exitum switch est inventus valorem intrpr.Commands[1] quae coercet values bufferlength и versionem (Utrobique munus respondente dicitur)

munera GetVersion и BufferLength in tabella srvlib.go server sarcina

GetVersion(conn net.Conn, version string)

simpliciter imprimit ad consolatorium et versionem in parametro ad clientem mittit;

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

.
munus

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

onerat scandalum, transactionem vel alia notitia specifica, ut sequitur:

• Maps ad consolandum typum notitiae in protocollo determinatum quod recipiendum est:

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

• Legit valorem intrpr.body ad numerum variabilis buf_len
• Facit quiddam newbuf certa magnitudine:

  make([]byte, buf_len)

• An ok misit responsum:

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

• Implet quiddam ex lectione amnis:

  io.ReadFull(conn, newbuf)

  .

• Prints contenta quiddam ad consolatorium

  fmt.Println(string(newbuf))

  et numerus bytes legitur

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

• An ok misit responsum:

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

Modi a servo sarcina configurantur ad processum recipiendum data utendi munera ex sarcina protocol.

Protocol

Protocollum est medium repraesentans notitias in retis commutationibus.

Electio (sp filum) (nervum, error) primarium facit processus notitiarum a servo receptarum, chorda repraesentationem notitiarum initus accipit et chorda parata reddit interpres:

• Filum input scinditur in caput et corpus utens ReqParseN2(str)
• Caput in elementa scinditur et in imperata scalpere utens ReqParseHead (caput)
• В switch (imperat [0]) eligere receptum imperium (cmd, key, oratio aut sectione Urguet default)
• 2 mandata deprimuntur in cmd switch (imperat [1]) - longitudo и getversion.
• tandem Promittimus notitia genus in * imperata[2] et salvet eam in ezwebin
• Checks quod corporis filum contineat valorem

  len(body) < 1

• Responsum refert filum:

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

• getversion refert ad filum

  return "result:version/auto"

interpres

InterpreteData structuram continet, ac secundarium processus notitiarum e reditu suo perficit arbitrio chordarum objectum formatione InterpreteData.

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

munus

Interprete(str string) (*InterpreteData, error)

accipit filum exitum et creat redit ad objectum InterpreteData.

Progredior:

• Et similiter arbitrio capite et corpore extrahuntur usura ReqParseN2(str)
• Caput scinditur in elementis utens ReqParseHead (caput)
• Obiectum initialized InterpreteData et monstrator redditur;

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

Hoc adhibetur in server.go sarcina principalis.

Client

Cliens sarcina munera continet TCPConnect и TCPResponseData.

munus

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

sic operatur;

• Connexio fit ad nexum certa in transeundo occasus objectum

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

• Notitia lata in parametri notitia traducitur;

  conn.Write(data)

• Responsum legitur

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

  et in typis console

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

• Si transferri payload deinde transit

  conn.Write(payload)

  et etiam responsionem servo legit, eam ad consolatorium excudendi

munus

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

gignit quiddam magnitudinis certae, responsum ministrantis ibi legit et redit quiddam et numerus bytes legit, necnon obiectum erroris.

Clientem integer

Militat ut mandata nodi servientibus mittant, necnon breves statisticas obtineant et experiantur.

Recipere possunt sequentes parametri: lima in forma JSON conformatio, data mittendi servo ut chorda, iter ad tabella mittenda ad solvendum, vexillum nodi emulationis schedula, genus notitiae ad valorem numericum translatum.

• Questus est configuratione

  st := types.ParseConfig(*config)

• Si vexillum emu fertur, incipit sheduler
• Si vexillum significans viam tabellae suppletur, eius notitias onerant fdb et contentum esse missum est in calculonis servi

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

• Si tabella non specificata est, notitia ex vexillo simpliciter missa est -d:

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

Haec omnia simplicior repraesentatio structurae protocoli ostendens est. In evolutione, necessaria functionality ad eius structuram accedit.

In secunda parte loquar de structuris notitiarum pro stipitibus et transactionibus, in 3 de servo WebSocket connectendi ab JavaScript, in 4 videbo synchronizationem schedulam, deinde machinam acervam quae processus bytecode ab inputs et outputs, cryptographiam et lacus outputs.

Source: www.habr.com