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:



231
232
233
234
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
 
# Archivo 'lib/mongo/protocol/message.rb', línea 231

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.Campos.cada hacer |Campo|
    si Campo[:multi]
      mensaje.deserializar_array(buffer, Campo, opciones)
    else
      mensaje.deserialize_field(buffer, Campo, opciones)
    end
  end
  mensaje.arreglar_después_de_deserialización si mensaje.is_a?(Msg)
  mensaje.tal_vez_inflar
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.



332
333
334
 
# Archivo 'lib/mongo/protocol/message.rb', línea 332

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) 


352
353
354
355
356
357
358
359
360
 
# Archivo 'lib/mongo/protocol/message.rb', línea 352

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



323
324
325
 
# Archivo 'lib/mongo/protocol/message.rb', línea 323

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.



283
284
285
286
287
288
289
290
291
 
# Archivo 'lib/mongo/protocol/message.rb', línea 283

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

#deserialize_array(io, campo, options = {}) ⇒ Arreglo

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:

  • 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:

  • (arreglo) —

    El arreglo deserializado.



377
378
379
380
381
382
 
# Archivo 'lib/mongo/protocol/message.rb', línea 377

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

#deserialize_field(io, campo, opciones = {}) ⇒ Objeto

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 solo campo en este mensaje.

Parámetros:

  • 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:

  • (objeto) —

    El valor del campo deserializado.



395
396
397
398
399
400
 
# Archivo 'lib/mongo/protocol/message.rb', línea 395

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

#campos ⇒ Arreglo<Hash>

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 obtener los campos de una clase de mensaje

Devuelve:

  • (arreglo<Hash>) —

    los campos para la clase de mensaje



406
407
408
 
# Archivo 'lib/mongo/protocol/message.rb', línea 406

def Campos
  sí mismo.clase.Campos
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.



297
298
299
 
# Archivo 'lib/mongo/protocol/message.rb', línea 297

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) 


171
172
173
 
# Archivo 'lib/mongo/protocol/message.rb', línea 171

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
 
# Archivo 'lib/mongo/protocol/message.rb', línea 150

def maybe_decrypt(_contexto)
  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.



162
163
164
165
 
# Archivo 'lib/mongo/protocol/message.rb', línea 162

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



315
316
317
 
# Archivo 'lib/mongo/protocol/message.rb', línea 315

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



196
197
198
199
200
201
202
203
204
205
206
207
208
 
# Archivo 'lib/mongo/protocol/message.rb', línea 196

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

#serialize_fields(buffer, max_bson_size = nil) ⇒ string

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.

Serializa los campos de mensaje en un búfer

Parámetros:

  • buffer (string) —

    búfer para recibir el campo

Devuelve:

  • (string) —

    búfer con campo serializado



415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
 
# Archivo 'lib/mongo/protocol/message.rb', línea 415

def serializar_campos(buffer, tamaño_máximo_bson = nulo)
  Campos.cada hacer |Campo|
    Valor = instance_variable_get(Campo[nombre])
    si Campo[:multi]
      Valor.cada hacer |item|
        si Campo[Tipo].respond_to?(:size_limited?)
          Campo[Tipo].serializar(buffer, item, tamaño_máximo_bson)
        else
          Campo[Tipo].serializar(buffer, item)
        end
      end
    elsif Campo[Tipo].respond_to?(:size_limited?)
      Campo[Tipo].serializar(buffer, Valor, tamaño_máximo_bson)
    else
      Campo[Tipo].serializar(buffer, Valor)
    end
  end
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.



306
307
308
 
# Archivo 'lib/mongo/protocol/message.rb', línea 306

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