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

Colapso delresumen constante

BATCH_SIZE =

La constante de tamaño de lote.

Desde:

  • 2.2.0

'batchSize'.freeze
colección =

La constante de colección.

Desde:

  • 2.2.0

'recopilación '.freeze
LIMIT =

La constante límite.

Desde:

  • 2.2.0

'limit'.freeze
ORDENADO =

La constante ordenada.

Desde:

  • 2.2.0

'ordenado'.freeze
Q =

La constante q.

Desde:

  • 2.2.0

'q'.freeze
TAMAÑO_MÁXIMO_MENSAJE =

Tamaño máximo de mensaje predeterminado de 48MB.

Desde:

  • 2.2.1

50331648.freeze

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

#inicializar(*args) ⇒ Mensaje

:nodoc:



79
80
81
 
# Archivo 'lib/mongo/protocol/message.rb', línea 79

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

Detalles de los atributos de instancia

#request_id ⇒ Fixnum (solo lectura)

Retorna el ID de solicitud para el mensaje

Devuelve:

  • (Fixnum) —

    El ID de solicitud para este mensaje



86
87
88
 
# Archivo 'lib/mongo/protocol/message.rb', línea 86

def id de solicitud
  @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 forma parte de una API privada. Debe evitarlo 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 (es decir, si el mensaje en el cable era 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 (Entero) (por defecto a: MAX_MESSAGE_SIZE) —

    El tamaño máximo del mensaje.

  • io (IO) —

    Flujo que contiene un mensaje

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

Opciones Hash (options):

  • :deserialize_as_bson (booleano) —

    Si se debe deserializar este mensaje utilizando tipos BSON en lugar de tipos nativos de Ruby siempre que sea posible.

  • :tiempo de espera del socket (Numérico) —

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

Devuelve:

  • (Mensaje) —

    Instancia de una clase Message



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
281
282
283
284
285
286
287
288
 
# Archivo 'lib/mongo/protocol/message.rb', línea 238

def sí mismo.deserializar(io,
  max_message_size = TAMAÑO MÁXIMO DEL MENSAJE,
  expected_response_to = nulo,
  opciones = {}
)
  # io suele ser una instancia de Mongo::Socket, que es compatible con la
  Opción de tiempo de espera. Para compatibilidad con quienquiera que llame 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, :tiempo de espera del socket)

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

  # Protección contra posibles ataques de intermediario (MITM) de denegación de servicio (DOS). Ver
  # DRIVERS-276.
  si longitud > (max_message_size || TAMAÑO MÁXIMO DEL MENSAJE)
    propagar Error::MaxMessageSize.Nuevo(max_message_size)
  end

  # 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

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

  mensaje = Registro.Obtener(_op_code).asignar
  mensaje.enviar(campo).cada hacer |Campo|
    si Campo[:multi]
      deserializar_array(mensaje, buf, Campo, opciones)
    else
      deserializar_campo(mensaje, buf, Campo, opciones)
    end
  end
  si mensaje.is_a?(Msg)
    mensaje.corrección después de la deserialización
  end
  mensaje.tal_vez_inflar
end

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

Deserializa un arreglo de campos en un mensaje

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

Parámetros:

  • mensaje (Mensaje) —

    Mensaje para contener el arreglo deserializado.

  • io (IO) —

    Flujo que contiene la matriz a deserializar.

  • Campo (encriptada) —

    Hash que representa un campo.

  • opciones (Hash) (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.



432
433
434
435
436
437
 
# Archivo 'lib/mongo/protocol/message.rb', línea 432

def sí mismo.deserializar_array(mensaje, io, Campo, opciones = {})
  elementos = []
  count = mensaje.obtención de variable de instancia(Campo[:multi])
  count.veces { elementos << Campo[Tipo].deserializar(io, opciones) }
  mensaje.conjunto_de_variables_de_instancia(Campo[nombre], elementos)
end

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

Deserializa una sola campo en un mensaje

Parámetros:

  • mensaje (Mensaje) —

    Mensaje para contener el campo deserializado.

  • io (IO) —

    Flujo que contiene el campo a deserializar.

  • Campo (encriptada) —

    Hash que representa un campo.

  • opciones (Hash) (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.



450
451
452
453
454
455
 
# Archivo 'lib/mongo/protocol/message.rb', línea 450

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

.deserialize_header(io) ⇒ Array<Fixnum>

Deserializa el encabezado del mensaje

Parámetros:

  • io (IO) —

    Flujo que contiene el encabezado.

Devuelve:

  • (arreglo<Fixnum>) —

    Cabecera deserializada.



388
389
390
 
# Archivo 'lib/mongo/protocol/message.rb', línea 388

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

.campo(nombre, tipo, multi = falso) ⇒ NilClass

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 de tipo :type o como un símbolo que describe que el campo posee el número de elementos en el arreglo (utilizado 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) 


407
408
409
410
411
412
413
414
415
 
# Archivo 'lib/mongo/protocol/message.rb', línea 407

def sí mismo.Campo(Nombre, tipo, multi = false)
  campos << {
    nombre => "@#{name}".interno,
    Tipo => tipo,
    :multi => multi
  }

  attr_reader Nombre
end

.campos ⇒ entero

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



340
341
342
 
# Archivo 'lib/mongo/protocol/message.rb', línea 340

def sí mismo.campos
  @campos ||= []
end

Detalles del método de instancia

#==(otro) ⇒ 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:

  • (verdadero,falso) —

    La igualdad de los mensajes.



295
296
297
298
299
300
301
302
 
# Archivo 'lib/mongo/protocol/message.rb', línea 295

def ==(Otros)
  return false si sí mismo.clase != Otros.clase
  campos.¿todos? hacer |Campo|
    Nombre = Campo[nombre]
    obtención de variable de instancia(Nombre) ==
      Otros.obtención de variable de instancia(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.



308
309
310
 
# Archivo 'lib/mongo/protocol/message.rb', línea 308

def hash
  campos.map { |Campo| obtención de variable de instancia(Campo[nombre]) }.hash
end

#maybe_add_server_api(server_api) ⇒ objeto

Aumenta:



173
174
175
 
# Archivo 'lib/mongo/protocol/message.rb', línea 173

def maybe_add_server_api(server_api)
  propagar Error::ServerApiNotSupported, Los parámetros de la API del servidor no se pueden enviar a3.6 servidores MongoDB anteriores a. Elimine el parámetro :server_api de las opciones del cliente o utilice MongoDB 3.6 o una versión posterior.
end

#maybe_compress(compressor, zlib_compression_level = nil) ⇒ self

Este método forma parte de una API privada. Debe evitarlo 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 (Cadena,Símbolo) —

    El compresor a utilizar.

  • zlib_compression_level (Entero) (predeterminado: nulo) —

    El nivel de compresión zlib a utilizar.

Devuelve:

  • (ser) -

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

Desde:

  • 2.5.0



112
113
114
 
# Archivo 'lib/mongo/protocol/message.rb', línea 112

def maybe_compress(compresor, zlib_compression_level = nulo)
  sí mismo
end

#maybe_decrypt(context) ⇒ Mongo::Protocol::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.



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

def maybe_decrypt(context)
  # TODO determinar si deberíamos estar desencriptando datos provenientes de pre-4.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 cifre 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.



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

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

#maybe_inflate ⇒ Protocolo::Mensaje

Este método forma parte de una API privada. Debe evitarlo 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 anular este método según sea necesario.

Desde:

  • 2.5.0



142
143
144
 
# Archivo 'lib/mongo/protocol/message.rb', línea 142

def tal_vez_inflar
  sí mismo
end

#número_devuelto ⇒ 0

Valor devuelto por número predeterminado para los mensajes de protocolo.

Devuelve:

  • (0) —

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

Desde:

  • 2.5.0



326
 
# Archivo 'lib/mongo/protocol/message.rb', línea 326

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



97
98
99
 
# Archivo 'lib/mongo/protocol/message.rb', línea 97

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 (Cadena) (por defecto: BSON::ByteBuffer.new) —

    búfer donde debe insertarse el mensaje

Devuelve:

  • (string) —

    búfer que contiene el mensaje serializado



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

def serializar(buffer = BSON::ByteBuffer.Nuevo, tamaño máximo de bson = nulo, bson_overhead = nulo)
  tamaño máximo =
    si tamaño máximo de bson && bson_overhead
      tamaño máximo de bson + bson_overhead
    elsif tamaño máximo de bson
      tamaño máximo de bson
    else
      nulo
    end

  Inicio = buffer.longitud
  serializar_encabezado(buffer)
  campos_serializados(buffer, tamaño máximo)
  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.



317
318
319
 
# Archivo 'lib/mongo/protocol/message.rb', línea 317

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