Class: Mongo::Protocol::Message Abstract

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

Overview

Esta clase es abstracta.

Una clase base que proporciona la funcionalidad requerida por todos los mensajes en el protocolo de conexión MongoDB. Proporciona un DSL mínimo para definir campos tipificados y habilitar la serialización y deserialización en la conexió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, Obtener más, KillCursors, Mensaje, Consulta, Responder

Colapso delresumen constante

BATCH_SIZE =

La constante de tamaño del lote.

Desde:

  • 2.2.0

' tamaño dellote '.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 DEL MENSAJE =

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

Desde:

  • 2.2.1

50331648.freeze

Colapso delresumen de atributos de instancia

Colapso delresumen del método de clase

Colapso del resumen del método de instancia

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)

Devuelve 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

.deserializar(io, tamaño máximo del mensaje = TAMAÑO MÁXIMO DEL MENSAJE, respuesta esperada a = nula, opciones = {}) ⇒ 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:

  • tamaño máximo del mensaje (Entero) (predeterminado: MAX_MESSAGE_SIZE)

    El tamaño máximo del mensaje.

  • io (IO) —

    Flujo que contiene un mensaje

  • opciones (Hash) (predeterminado: {})

Opciones Hash(opciones):

  • :deserializar_como_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 yo.deserializar(io,
  tamaño máximo del mensaje = TAMAÑO MÁXIMO DEL MENSAJE,
  respuesta esperada a = nulo,
  opciones = {}
)
  # io suele ser una instancia de Mongo::Socket, que admite el
  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
  # no están vacíos.
  read_options = opciones.segmento(: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::Búfer de bytes.Nuevo(fragmento)
  longitud, _request_id, respuesta_a, _op_code = deserializar_encabezado(buf)

  # Protección contra posibles ataques de denegación de servicio (DOS) de intermediario. Ver
  #CONDUCTORES-276.
  Si longitud > (tamaño máximo del mensaje || TAMAÑO MÁXIMO DEL MENSAJE)
    propagar Error::Tamaño máximo del mensaje.Nuevo(tamaño máximo del mensaje)
  end

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

  Si read_options.¿vacío?
    fragmento = io.Lea(longitud - 16)
  else
    fragmento = io.Lea(longitud - 16, **read_options)
  end
  buf = BSON::Búfer de bytes.Nuevo(fragmento)

  Mensaje = Registro.Obtener(_op_code).asignar
  Mensaje.Enviar(:campos).cada hacer |Campo|
    Si Campo[:multi]
      deserializar_matriz(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(mensaje, io, campo, opciones = {}) ⇒ 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 que contiene la matriz deserializada.

  • io (IO) —

    Flujo que contiene la matriz a deserializar.

  • Campo (Hash) —

    Hash que representa un campo.

  • opciones (Hash) (predeterminado: {})

Opciones Hash(opciones):

  • :deserializar_como_bson (Booleano) —

    Si se debe deserializar cada uno de los elementos de esta matriz utilizando tipos BSON siempre que sea posible.

Devuelve:

  • (Mensaje) —

    Mensaje con matriz deserializada.



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

def yo.deserializar_matriz(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 un solo campo en un mensaje

Parámetros:

  • Mensaje (Mensaje) —

    Mensaje que contendrá el campo deserializado.

  • io (IO) —

    Flujo que contiene el campo a deserializar.

  • Campo (Hash) —

    Hash que representa un campo.

  • opciones (Hash) (predeterminado: {})

Opciones Hash(opciones):

  • :deserializar_como_bson (Booleano) —

    Si se debe deserializar este campo utilizando tipos BSON 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 yo.deserializar_campo(Mensaje, io, Campo, opciones = {})
  Mensaje.conjunto_de_variables_de_instancia(
    Campo[:nombre],
    Campo[:tipo].deserializar(io, opciones)
  )
end

.deserialize_header(io) ⇒ Matriz<Fixnum>

Deserializa el encabezado del mensaje

Parámetros:

  • io (IO) —

    Flujo que contiene el encabezado.

Devuelve:

  • (Matriz<Fixnum>) —

    Encabezado deserializado.



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

def yo.deserializar_encabezado(io)
  Encabezado.deserializar(io)
end

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

Un método para declarar un campo de mensaje

Parámetros:

  • Nombre (Cadena) -

    Nombre del campo

  • tipo (Módulo) —

    Estrategias de serialización específicas de cada tipo

  • multi (verdadero,falso, símbolo) (predeterminado: falso)

    Especifique como true para serializar el valor del campo como una matriz de tipo :type o como un símbolo que describe el campo que tiene la cantidad de elementos en la matriz (usado durante 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 yo.Campo(Nombre, tipo, multi = false)
  campos << {
    :nombre => "@#{name}".interno,
    :tipo => tipo,
    :multi => multi
  }

  lector de atributos Nombre
end

.campos ⇒ Entero

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

Devuelve:

  • (Entero) —

    los campos para la clase de mensaje



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

def yo.campos
  @campos ||= []
end

Detalles del método de instancia

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

Prueba la igualdad entre dos mensajes de protocolo de cable comparando valores de clase y campo.

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 yo.clase != otros.clase
  campos.¿todo? 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

#perhaps_add_server_api(servidor_api) ⇒ Objeto

Aumentos:



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

def tal vez_agregar_api_del_servidor(API del servidor)
  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

#perhaps_compress(compresor, 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 el protocolo de transmisión lo permite y el comando enviado lo permite. De lo contrario, devuelve "self".

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 deberían anular este método.

Desde:

  • 2.5.0



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

def tal vez_comprimir(compresor, zlib_compression_level = nulo)
  yo
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 tal vez_descifrar(context)
  # TODO determinar si deberíamos estar desencriptando datos provenientes de pre-4.2
  # servidores, posiblemente utilizando protocolos de cable heredados. De ser así, necesitamos
  # para implementar descifrado para esos protocolos de conexión como nuestros actuales
  # El código de cifrado/descifrado es específico de OP_MSG.
  yo
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 tal vez_encriptar(conexión, context)
  # No hacer nada si la subclase Message no ha implementado este método
  yo
end

#perhaps_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.

Inflar 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
  yo
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 devuelve 0.

Desde:

  • 2.5.0



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

def número_devuelto; 0; end

#¿respondible? ⇒ falso

El valor predeterminado 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:

  • (FALSO) -

    El valor predeterminado 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

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

Serializa el mensaje en bytes que se pueden enviar por cable.

Parámetros:

  • buffer (Cadena) (predeterminado: BSON::ByteBuffer.new) —

    buffer donde se debe insertar el mensaje

Devuelve:

  • (Cadena) -

    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 fabricar en serie(buffer = BSON::Búfer de bytes.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 incluirá este ID en el campo `response_to` de la respuesta.



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

def set_request_id
  @request_id = yo.clase.siguiente_id
end