Class: Mongo::Protocol::Message Abstract

Hereda:
Objeto
  • Objeto
Mostrar todo
Incluye:
Id, Serializadores
Definido en:
lib/mongo/protocolo/message.rb

Overview

Esta clase es abstracta.

Una clase base que proporciona la funcionalidad requerida por todos los mensajes en el protocolo de conexión de MongoDB. Proporciona un DSL mínimo para definir campos tipados que permitan la serialización y deserialización a través del canal de comunicación.

Ejemplos:

class WireProtocolMessage < Message

  private

  def op_code
    1234
  end

  FLAGS = [:first_bit, :bit_two]

  # payload
  field :flags, BitVector.new(FLAGS)
  field :namespace, CString
  field :document, Document
  field :documents, Document, true
end

Subclases conocidas directas

Comprimido, GetMore, KillCursors, Mensaje, query, Respuesta

Resumen de constantes colapsar

BATCH_SIZE =

La constante de tamaño de lote.

Desde:

  • 2.2.0

'batchSize'
colección =

La constante de colección.

Desde:

  • 2.2.0

'Colección'
LIMIT =

La constante límite.

Desde:

  • 2.2.0

'limit'
ORDENADO =

La constante ordenada.

Desde:

  • 2.2.0

'ordenado'
Q =

La constante q.

Desde:

  • 2.2.0

'q'
TAMAÑO_MÁXIMO_MENSAJE =

Tamaño máximo de mensaje por defecto de 48MB.

Desde:

  • 2.2.1

50_331_648

Constantes incluidas de Serializadores

Serializers::HEADER_PACK, Serializers::INT32_PACK, Serializers::INT64_PACK, Serializers::NULL, Serializers::ZERO

Resumen de atributos de la instancia colapsar

Resumen del método de clase colapsar

Resumen del método de instancia colapsar

Métodos incluidos de Id

incluido

Detalles del Constructor

#initialize(*_args) ⇒ Mensaje

:nodoc:



77
78
79
 
# Archivo 'lib/mongo/protocol/message.rb', línea 77

def inicializar(*_args) # :nodoc:
  set_request_id
end

Detalles de atributo de instancias

#request_id ⇒ Fixnum (solo lectura)

Retorna el ID de solicitud para el mensaje

Devuelve:

  • (Fixnum) —

    La solicitud de id para este mensaje



84
85
86
 
# Archivo 'lib/mongo/protocol/message.rb', línea 84

def request_id
  @request_id
end

Detalles del método de clase

.deserialize(io, max_message_size = MAX_MESSAGE_SIZE, expected_response_to = nil, options = {}) ⇒ Mensaje

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Desserializa mensagens de um fluxo de E/S.

Este método devuelve mensajes descomprimidos (por ejemplo, si el mensaje en la red fue OP_COMPRESSED, este método normalmente devolvería el mensaje OP_MSG que es el resultado de la descompresión).

Parámetros:

  • max_message_size (Integer) (por defecto a: MAX_MESSAGE_SIZE) —

    El tamaño máximo del mensaje.

  • io (IO) —

    Flujo que contiene un mensaje

  • opciones (encriptada) (por defecto a: {})

Opciones Hash (options):

  • :deserialize_as_bson (booleano) —

    Si deseas deserializar este mensaje usando BSON types en lugar de los tipos nativos de Ruby siempre que sea posible.

  • timeout_del_socket (Numérico) —

    El tiempo de espera que se utilizará para cada operación de lectura.

Devuelve:

  • (Mensaje) —

    Instancia de una clase Message

Aumenta:



235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
 
# Archivo 'lib/mongo/protocol/message.rb', línea 235

def sí mismo.deserializar(io,
                     max_message_size = MAX_MESSAGE_SIZE,
                     expected_response_to = nulo,
                     opciones = {})
  # io suele ser una instancia de Mongo::Socket, que es compatible con la
  # opción de tiempo de espera. Por compatibilidad con cualquiera que pueda llamar a esto
  # método con algún otro objeto similar a IO, pasa opciones solo cuando ellos
  # no están vacíos.
  read_options = opciones.rebanada(:timeout, timeout_del_socket)

  fragmento = si read_options.¿vacío?
            io.Lea(16)
          else
            io.Lea(16, **read_options)
          end
  buffer = BSON::ByteBuffer.Nuevo(fragmento)
  longitud, _request_id, respuesta_a, _op_code = deserialize_header(buffer)

  # Protección contra posibles ataques de intermediario (MITM) de denegación de servicio (DOS). Ver
  # DRIVERS-276.
  propagar Error::MaxMessageSize.Nuevo(max_message_size) si longitud > (max_message_size || MAX_MESSAGE_SIZE)

  # Protección contra devolver la respuesta a una solicitud anterior. Consultá
  # RUBY-1117
  si expected_response_to && respuesta_a != expected_response_to
    propagar Error::UnexpectedResponse.Nuevo(expected_response_to, respuesta_a)
  end

  fragmento = si read_options.¿vacío?
            io.Lea(longitud - 16)
          else
            io.Lea(longitud - 16, **read_options)
          end
  buffer = BSON::ByteBuffer.Nuevo(fragmento)

  mensaje = Registro.Obtener(_op_code).asignar
  mensaje.enviar(campo).cada hacer |Campo|
    si Campo[:multi]
      deserializar_array(mensaje, buffer, Campo, opciones)
    else
      deserialize_field(mensaje, buffer, Campo, opciones)
    end
  end
  mensaje.arreglar_después_de_deserialización si mensaje.is_a?(Msg)
  mensaje.tal_vez_inflar
end

.deserialize_array(message, io, field, options = {}) ⇒ Mensaje

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Deserializa un arreglo de campos en un mensaje

El número de elementos en el arreglo debe ser descrito por un campo previamente deserializado especificado en la clase mediante el dsl de campo bajo la clave :multi

Parámetros:

  • mensaje (Mensaje) —

    Mensaje para contener el arreglo deserializado.

  • io (IO) —

    Flujo que contiene el arreglo a deserializar.

  • Campo (encriptada) —

    Hash que representa un campo.

  • opciones (encriptada) (por defecto a: {})

Opciones Hash (options):

  • :deserialize_as_bson (booleano) —

    Si se debe deserializar cada uno de los elementos de este arreglo usando los BSON types siempre que sea posible.

Devuelve:

  • (Mensaje) —

    Mensaje con un arreglo deserializado.



382
383
384
385
386
387
 
# Archivo 'lib/mongo/protocol/message.rb', línea 382

def sí mismo.deserializar_array(mensaje, io, Campo, opciones = {})
  elementos = []
  count = mensaje.instance_variable_get(Campo[:multi])
  count.veces { elementos << Campo[Tipo].deserializar(io, opciones) }
  mensaje.instance_variable_set(Campo[nombre], elementos)
end

.deserialize_field(mensaje, io, campo, opciones = {}) ⇒ Mensaje

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Deserializa una sola campo en un mensaje

Parámetros:

  • mensaje (Mensaje) —

    Mensaje para contener el campo deserializado.

  • io (IO) —

    Stream que contiene el campo a deserializar.

  • Campo (encriptada) —

    Hash que representa un campo.

  • opciones (encriptada) (por defecto a: {})

Opciones Hash (options):

  • :deserialize_as_bson (booleano) —

    Si se debe deserializar este campo utilizando BSON types siempre que sea posible.

Devuelve:

  • (Mensaje) —

    Mensaje con campo deserializado.



401
402
403
404
405
406
 
# Archivo 'lib/mongo/protocol/message.rb', línea 401

def sí mismo.deserialize_field(mensaje, io, Campo, opciones = {})
  mensaje.instance_variable_set(
    Campo[nombre],
    Campo[Tipo].deserializar(io, opciones)
  )
end

.deserialize_header(io) ⇒ Array<Fixnum>

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Deserializa el encabezado del mensaje

Parámetros:

  • io (IO) —

    Flujo que contiene el encabezado.

Devuelve:

  • (arreglo<Fixnum>) —

    Cabecera deserializada.



336
337
338
 
# Archivo 'lib/mongo/protocol/message.rb', línea 336

def sí mismo.deserialize_header(io)
  Encabezado.deserializar(io)
end

.campo(name, type, multi = false) ⇒ NilClass

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Un método para declarar un campo de mensaje

Parámetros:

  • Nombre (string) —

    Nombre del campo

  • tipo (Módulo) —

    Escribe estrategias de serialización específicas

  • multi (true, false, Símbolo) (por defecto: false) —

    Especifica como true para serializar el valor del campo como un arreglo del tipo :type o como un símbolo que describe que el campo tiene el número de elementos en el arreglo (usado en la deserialización).

    Note: In fields where multi is a symbol representing the field
containing number items in the repetition, the field containing
that information *must* be deserialized prior to deserializing
fields that use the number.

Devuelve:

  • (NilClass) 


356
357
358
359
360
361
362
363
364
 
# Archivo 'lib/mongo/protocol/message.rb', línea 356

def sí mismo.Campo(Nombre, tipo, multi = false)
  Campos << {
    nombre: :”@#{Nombre}",
    tipo: tipo,
    multi: multi
  }

  attr_reader Nombre
end

.campos ⇒ entero

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Un método de clase para obtener los campos de una clase de mensaje

Devuelve:

  • (Número entero) —

    los campos para la clase de mensaje



327
328
329
 
# Archivo 'lib/mongo/protocol/message.rb', línea 327

def sí mismo.Campos
  @fields ||= []
end

Detalles del método de instancia

#==(other) ⇒ verdadero, falso También conocido como: eql?

Pruebas de igualdad entre dos mensajes de protocolo de conexión comparando valores de clase y campos.

Parámetros:

Devuelve:

  • (true, false) —

    La igualdad de los mensajes.



287
288
289
290
291
292
293
294
295
 
# Archivo 'lib/mongo/protocol/message.rb', línea 287

def ==(Otros)
  return false si sí mismo.clase != Otros.clase

  Campos.¿todos? hacer |Campo|
    Nombre = Campo[nombre]
    instance_variable_get(Nombre) ==
      Otros.instance_variable_get(Nombre)
  end
end

#hash ⇒ Fixnum

Crea un hash a partir de los valores de los campos de un mensaje.

Devuelve:

  • (Fixnum) —

    El código hash del mensaje.



301
302
303
 
# Archivo 'lib/mongo/protocol/message.rb', línea 301

def hash
  Campos.map { |Campo| instance_variable_get(Campo[nombre]) }.hash
end

#maybe_add_server_api(server_api) ⇒ objeto

Las subclases de mensajes de protocolo que admiten la opción de API de servidor deben sobrescribir este método para añadir el documento de API de servidor al mensaje.

Parámetros:

  • server_api (encriptada) —

    El documento de la API del servidor para añadir al mensaje.

Aumenta:

  • (NotImplementedError) 


175
176
177
 
# Archivo 'lib/mongo/protocol/message.rb', línea 175

def maybe_add_server_api(server_api)
  propagar NotImplementedError
end

#maybe_compress(_compressor, _zlib_compression_level = nil) ⇒ self

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Comprime el mensaje, si es compatible con el protocolo de conexión utilizado y si el comando que se envía permite la compresión. En caso contrario, devuelve uno mismo.

Parámetros:

  • compresor (String, Símbolo) —

    El compresor a utilizar.

  • zlib_compression_level (Número entero) —

    El nivel de compresión de zlib que se debe usar.

Devuelve:

  • (self) —

    Siempre devuelve self. Otros tipos de mensajes deben anular este método.

Desde:

  • 2.5.0



110
111
112
 
# Archivo 'lib/mongo/protocol/message.rb', línea 110

def maybe_compress(_compressor, compresión = nulo)
  sí mismo
end

#maybe_decrypt(_context) ⇒ Mongo::protocolo::Msg

Posiblemente descifre este mensaje con libmongocrypt.

Parámetros:

Devuelve:

  • (Mongo::Protocol::Msg) —

    El mensaje descifrado, o el mensaje original si el descifrado no fue posible o necesario.



150
151
152
153
154
155
156
 
# Archivo 'lib/mongo/protocol/message.rb', línea 150

def maybe_decrypt(_contexto)
  # POR HACER: determinar si deberíamos descifrar datos provenientes de antes del4.2
  # servidores, potencialmente utilizando protocolos de conexión heredados. Si es así, necesitamos
  # para implementar descifrado para esos protocolos de conexión como nuestros actuales
  # El código de cifrado/desencriptación es específico de OP_MSG.
  sí mismo
end

#maybe_encrypt(_connection, _context) ⇒ Mongo::Protocol::Msg

Posiblemente cifrar este mensaje con libmongocrypt.

Parámetros:

Devuelve:

  • (Mongo::Protocol::Msg) —

    El mensaje cifrado, o el mensaje original si no fue posible o necesario el cifrado.



166
167
168
169
 
# Archivo 'lib/mongo/protocol/message.rb', línea 166

def maybe_encrypt(_connection, _contexto)
  # No hacer nada si la subclase Message no ha implementado este método
  sí mismo
end

#maybe_inflate ⇒ Protocolo::Mensaje

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Expande un mensaje si está comprimido.

Devuelve:

  • (Protocol::Message) —

    Siempre devuelve self. Las subclases deben sobrescribir este método según sea necesario.

Desde:

  • 2.5.0



140
141
142
 
# Archivo 'lib/mongo/protocol/message.rb', línea 140

def tal_vez_inflar
  sí mismo
end

#number_returned ⇒ 0

Valor de retorno por defecto para mensajes de protocolo.

Devuelve:

  • (0) —

    Este método debe anularse; de lo contrario, siempre devolverá 0.

Desde:

  • 2.5.0



319
320
321
 
# Archivo 'lib/mongo/protocol/message.rb', línea 319

def number_returned
  0
end

#replyable? ⇒ false

La opción por defecto para los mensajes es no requerir una respuesta después de enviar un mensaje al servidor.

Ejemplos:

¿El mensaje requiere una respuesta?

message.replyable?

Devuelve:

  • (false) —

    La configuración por defecto es no requerir una respuesta.

Desde:

  • 2.0.0



95
96
97
 
# Archivo 'lib/mongo/protocol/message.rb', línea 95

def ¿respondible?
  false
end

#serializa(buffer = BSON::ByteBuffer.new, max_bson_size = nil, bson_overhead = nil) ⇒ String También conocido como: to_s

serializa el mensaje en bytes que pueden enviarse a través de la red

Parámetros:

  • buffer (string) (por defecto: BSON::ByteBuffer.new) —

    búfer donde debe insertarse el mensaje

Devuelve:

  • (string) —

    búfer que contiene el mensaje serializado



200
201
202
203
204
205
206
207
208
209
210
211
212
 
# Archivo 'lib/mongo/protocol/message.rb', línea 200

def serializar(buffer = BSON::ByteBuffer.Nuevo, tamaño_máximo_bson = nulo, bson_overhead = nulo)
  max_size =
    si tamaño_máximo_bson && bson_overhead
      tamaño_máximo_bson + bson_overhead
    elsif tamaño_máximo_bson
      tamaño_máximo_bson
    end

  Inicio = buffer.longitud
  serialize_header(buffer)
  serializar_campos(buffer, max_size)
  buffer.reemplazar_int32(Inicio, buffer.longitud - Inicio)
end

#set_request_id ⇒ Fixnum

Genera un id de solicitud para un mensaje

Devuelve:

  • (Fixnum) —

    un ID de solicitud utilizado para enviar un mensaje al servidor. El servidor pondrá este id en el campo response_to de una respuesta.



310
311
312
 
# Archivo 'lib/mongo/protocol/message.rb', línea 310

def set_request_id
  @request_id = sí mismo.clase.next_id
end