Desarrollo de blockchain para la industria en marcha. Parte 1

• Redes (servidor, cliente, protocolo)
• Estructuras de datos almacenados y transmitidos (bloque, transacción)
• (blockchain)
• (consensus)
• (xvm)
• (crypto, types) .

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

• Puerto de red a través del cual se intercambiarán datos
• Archivo de configuración del servidor JSON
• Indicador de ejecución en modo de depuración (blockchain privado)

• Leer la configuración del archivo JSON
• Se marca el indicador de modo de depuración: si está configurado, entonces el programador de sincronización de red no se inicia y la cadena de bloques no se carga
• Inicializando la estructura de datos de configuración e iniciando el servidor

Servidor

• Inicia el servidor TCP y la comunicación de red de acuerdo con el protocolo.
• Tiene una estructura de datos de servicio que consta de un número de puerto, un tamaño de búfer y un puntero a los tipos.
• Run ( , handle )
• handle , protocol.Choice
• protocol.Choice result . result protocol.Interprete, intrpr — InterpreteData,
• Luego, el interruptor es ejecutado por intrpr.Commands [0] en el que se verifica uno de los siguientes: resultado, inv, error y hay una sección predeterminada
• En la sección de resultados , hay un cambio por el valor de intrpr.Commands [1] que verifica los valores de bufferlength y versión (en cada caso se llama a la función correspondiente)

GetVersion(conn net.Conn, version string)

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

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

• Imprime en la consola el tipo de datos especificado en el protocolo que debe aceptarse:
  
  

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

• Lee el intrpr.Body en la variable numérica buf_len
• Crea un búfer newbuf del tamaño especificado:
  
  

  make([]byte, buf_len)

• Envía una respuesta correcta:
  
  

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

• Produce un búfer completo a partir de la secuencia de lectura:
  
  

  io.ReadFull(conn, newbuf)

  .
• Imprime el contenido del búfer en la consola.
  
  

  fmt.Println(string(newbuf))

  
  y el número de bytes leídos
  
  

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

• Envía una respuesta correcta:
  
  

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

Protocolo

• La cadena de entrada se divide en cabeza y cuerpo usando ReqParseN2 (str)
• la cabeza se divide en elementos y se coloca en el segmento de comandos usando ReqParseHead (cabeza)
• En el interruptor (comandos [0]) seleccionamos el comando recibido ( cmd, clave, dirección o se activa la sección predeterminada )
• En cmd, se verifican 2 comandos de cambio (comandos [1]): longitud y getversion .
• length comprueba el tipo de datos en los comandos [2] y los almacena en el tipo de datos
• Comprueba que el cuerpo contiene un valor de cadena
  
  

  len(body) < 1

• Devuelve una cadena de respuesta:
  
  

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

• getversion devuelve una cadena
  
  

  return "result:version/auto"

Interpretar

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

Interprete(str string) (*InterpreteData, error)

• Del mismo modo, Choice recupera la cabeza y el cuerpo usando ReqParseN2 (str)
• la cabeza se divide en elementos usando ReqParseHead (cabeza)
• El objeto InterpreteData se inicializa y se devuelve un puntero al mismo:

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

Cliente

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

• Se realiza una conexión a la conexión especificada en el objeto de configuración transferido
  
  

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

• Los datos pasados ​​en el parámetro de datos se transfieren:
  
  

  conn.Write(data)

• Leer respuesta
  
  

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

  
  e impreso en la consola
  
  

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

• Si la carga útil se transmite, se transmite
  
  

  conn.Write(payload)

  
  y también lee la respuesta del servidor, imprimiéndola en la consola

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

Rutina del cliente

• Obtén la configuración
  
  

  st := types.ParseConfig(*config)

• Si te dan una bandera de la UEM, comienza el programador
• Si se especifica el indicador f que indica la ruta al archivo, cargue sus datos en fdb y envíe el contenido al servidor
  
  

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

• Si no se especifica el archivo, los datos del indicador -d simplemente se envían :
  
  

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