Class: Mongo::Protocol::Message Abstract

Herda:
Objeto
  • Objeto
mostrar tudo
Inclui:
ID, Serializadores
Definido em:
lib/mongo/protocol/message.rb

Visão geral

Esta classe é abstrata.

Uma classe de base que fornece a funcionalidade exigida por todas as mensagens no protocolo de conexão do MongoDB . Ele fornece um DSL mínimo para definir campos digitados para permitir a serialização e a desserialização pela rede.

Exemplos:

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

Subclasses conhecidas diretas

Compressed, GetMore, KillCursors, Msg, Query, Reply

Colapsode resumo constante

BATCH_SIZE =

A constante de tamanho do lote .

Desde:

  • 2.2.0

'batchSize'
collection =

A constante da collection.

Desde:

  • 2.2.0

'collection'
LIMIT =

O limite constante.

Desde:

  • 2.2.0

'limit'
ORDENADO =

A constante ordenada.

Desde:

  • 2.2.0

'encomendado'
Q =

A constante q.

Desde:

  • 2.2.0

'q'
MAX_MSSAGE_SIZE =

Tamanho máximo padrão da mensagem de 48MB.

Desde:

  • 2.2.1

50_331_648

Constantes incluídas dos serializadores

Serializadores::HEADER_PACK, Serializadores::INT32_PACK, Serializadores::INT64_PACK, Serializadores::NULL, Serializadores::Zero

Recolhimento do Resumo do atributo de instância

Recolhimento do Resumo do método de classe

Recolhimento do Resumo do método de instância

Métodos incluídos do ID

incluído

Detalhes do construtor

#initialize(*_args) ➤ Mensagem

:nodoc:



77
78
79
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 77

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

Detalhes do atributo da instância

#request_id ➤ Fixnum (somente leitura)

Retorna a ID de solicitação da mensagem

Retorna:

  • (Fixnum) —

    A ID da solicitação para esta mensagem



84
85
86
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 84

def request_id
  @request_id
end

Detalhes do método de classe

.deserialize(io, max_message_size = MAX_message_SIZE, expected_response_to = nil, options = {}) ➤ Mensagem

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Deserializa mensagens de um fluxo IO.

Esse método retorna mensagens descompactadas (ou seja, se a mensagem no fio fosse OP_COMPRESSED, esse método normalmente retornaria a mensagem OP_MSG que é o resultado da descompactação).

Parâmetros:

  • max_message_size (Inteiro) (padrão para: MAX_MSSAGE_SIZE) —

    O tamanho máximo da mensagem.

  • io (IO) —

    Fluxo contendo uma mensagem

  • opções (Hash) (padrão para: {})

Hash de opções (opções):

  • :deserialize_as_bson (Booleano) —

    Se deve desserializar esta mensagem usando BSON types em vez de tipos Ruby nativos sempre que possível.

  • :socket_timeout (Numérico) —

    O tempo limite a ser usado para cada operação de leitura.

Retorna:

  • (Mensagem) —

    Instância de uma classe de mensagem

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
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 235

def auto.desserializar(io,
                     max_message_size = MAX_message_SIZE,
                     expected_response_to = nada,
                     opções = {})
  # io geralmente é uma instância Mongo::Socket, que suporta o
  # opção de tempo limite. Para compatibilidade com quem pode chamar isso
  método # com algum outro objeto semelhante a IO , passe opções somente quando elas
  # não estão vazios.
  read_options = opções.fatia(:timeout, :socket_timeout)

  chunk = se read_options.vazio?
            io.ler(16)
          mais
            io.ler(16, **read_options)
          end
  buffer = BSON::ByteBuffer.Novo(chunk)
  Tamanho, _request_id, response_to, _op_code = deserialize_header(buffer)

  # Proteção contra possíveis ataques do tipo man-in-the-middle do OS. Ver
  # DRIVER-276.
  aumentar Erro::MaxMessageSize.Novo(max_message_size) se Tamanho > (max_message_size || MAX_message_SIZE)

  # Proteção contra o retorno da resposta a uma solicitação anterior. Ver
  # RUBI-1117
  se expected_response_to && response_to != expected_response_to
    aumentar Erro::Resposta inesperada.Novo(expected_response_to, response_to)
  end

  chunk = se read_options.vazio?
            io.ler(Tamanho - 16)
          mais
            io.ler(Tamanho - 16, **read_options)
          end
  buffer = BSON::ByteBuffer.Novo(chunk)

  mensagem = Registro.obter(_op_code).alocar
  mensagem.enviar(:fields).cada fazer |Campo|
    se Campo[:multi]
      deserialize_array(mensagem, buffer, Campo, opções)
    mais
      deserialize_field(mensagem, buffer, Campo, opções)
    end
  end
  mensagem.Fix_after_deserialization se mensagem.is_a?(Msg)
  mensagem.talvez_inflate
end

.deserialize_array(message, io, campo, options = {}) ⇒ Mensagem

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Deserializa uma array de campos em uma mensagem

O número de itens na array deve ser descrito por um campo desserializado anteriormente especificado na classe pelo campo dsl na chave :multi

Parâmetros:

  • mensagem (Mensagem) —

    Mensagem para conter a array desserializada.

  • io (IO) —

    Fluxo contendo a array para desserializar.

  • Campo (Hash) —

    Hash representando um campo.

  • opções (Hash) (padrão para: {})

Hash de opções (opções):

  • :deserialize_as_bson (Booleano) —

    Se deve desserializar cada um dos elementos nesta array usando BSON types sempre que possível.

Retorna:

  • (Mensagem) —

    Mensagem com array desserializada.



382
383
384
385
386
387
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 382

def auto.deserialize_array(mensagem, io, Campo, opções = {})
  Elementos = []
  contar = mensagem.instance_variable_get(Campo[:multi])
  contar.vezes { Elementos << Campo[:type].desserializar(io, opções) }
  mensagem.instance_variable_set(Campo[:name], Elementos)
end

.deserialize_field(message, io, campo, options = {}) ⇒ Mensagem

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Deserializa um único campo em uma mensagem

Parâmetros:

  • mensagem (Mensagem) —

    Mensagem para conter o campo desserializado.

  • io (IO) —

    Fluxo contendo o campo para desserializar.

  • Campo (Hash) —

    Hash representando um campo.

  • opções (Hash) (padrão para: {})

Hash de opções (opções):

  • :deserialize_as_bson (Booleano) —

    Se deve desserializar este campo usando tipos BSON sempre que possível.

Retorna:

  • (Mensagem) —

    Mensagem com campo desserializado.



401
402
403
404
405
406
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 401

def auto.deserialize_field(mensagem, io, Campo, opções = {})
  mensagem.instance_variable_set(
    Campo[:name],
    Campo[:type].desserializar(io, opções)
  )
end

.deserialize_header(io) ➤ Array<Fixnum>

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Deserializa o cabeçalho da mensagem

Parâmetros:

  • io (IO) —

    Fluxo contendo o cabeçalho.

Retorna:

  • (Array<Fixnum>) —

    Cabeçalho desserializado.



336
337
338
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 336

def auto.deserialize_header(io)
  Cabeçalho.desserializar(io)
end

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

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Um método para declarar um campo de mensagem

Parâmetros:

  • name (string) —

    Nome do campo

  • type (Módulo) —

    Tipo estratégias de serialização específicas

  • multi (verdadeiro, falso, símbolo) (padrão para: false) —

    Especifique como true para serializar o valor do campo como uma array do tipo :type ou como um símbolo que descreve o campo com o número de itens na array (usado na desserialização)

    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.

Retorna:

  • (NilClass) 


356
357
358
359
360
361
362
363
364
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 356

def auto.Campo(name, type, multi = false)
  Campos << {
    nome: :"@#{name}",
    tipo: type,
    multi: multi
  }

  attr_reader name
end

.campos ➤ Inteiro

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Um método de classe para obter os campos para uma classe de mensagem

Retorna:

  • (Inteiro) —

    os campos para a classe de mensagem



327
328
329
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 327

def auto.Campos
  @fields ||= []
end

Detalhes do método de instância

#==(outro) ➤ true, false Também conhecido como: eql?

Testa a igualdade entre duas mensagens de protocolo de fio comparando valores de classe e campo.

Parâmetros:

Retorna:

  • (verdadeiro, falso) —

    A igualdade das mensagens.



287
288
289
290
291
292
293
294
295
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 287

def ==(Outro)
  Método false se auto.classe != Outro.classe

  Campos.todos? fazer |Campo|
    name = Campo[:name]
    instance_variable_get(name) ==
      Outro.instance_variable_get(name)
  end
end

#hash ➤ Fixnum

Cria um hash a partir dos valores dos campos de uma mensagem.

Retorna:

  • (Fixnum) —

    O código hash da mensagem.



301
302
303
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 301

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

#may_add_server_api(server_api) ➤ Objeto

As subclasses de mensagens de protocolo que suportam a opção api do servidor devem substituir esse método para adicionar o documento da api do servidor à mensagem.

Parâmetros:

  • server_api (Hash) —

    O documento da API do servidor a ser adicionado à mensagem.

Aumenta:

  • (NotImplementedError) 


175
176
177
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 175

def talvez_add_server_api(server_api)
  aumentar NotImplementedError
end

#may_compress(_compressor, _zlib_compression_level = nil) ➤ self

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Compacte a mensagem, se suportado pelo protocolo de conexão usado e se o comando que está sendo enviado permitir a compactação. Caso contrário, retorna auto.

Parâmetros:

  • compressor, compressor (string, símbolo) —

    O compressor a ser usado.

  • zlib_compression_level (Inteiro) —

    O nível de compressão zlib a ser usado.

Retorna:

  • (self) —

    Sempre retorna a si mesmo. Outros tipos de mensagem devem substituir este método.

Desde:

  • 2.5.0



110
111
112
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 110

def talvez_compress(_compressor, compactação = nada)
  auto
end

#may_decrypt(_context) ➤ Mongo::Protocol::Msg

Possivelmente descriptografe esta mensagem com libmongocrypt.

Parâmetros:

Retorna:

  • (Mongo::Protocol::Msg) —

    A mensagem descriptografada ou a mensagem original se a descriptografia não for possível ou necessária.



150
151
152
153
154
155
156
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 150

def talvez_decrypt(_context)
  # TODO: determinar se devemos descriptografar dados provenientes da pré-4.2
  # servidores, potencialmente usando protocolos de fio legados. Se sim, precisamos
  # para implementar descriptografia para esses protocolos de fio como nossos atuais
  # o código de criptografia/descriptografia é específico do OP_MSG.
  auto
end

#may_encrypt(_connection, _context) ➤ Mongo::Protocol::Msg

Possivelmente, criptografe esta mensagem com libmongocrypt.

Parâmetros:

Retorna:

  • (Mongo::Protocol::Msg) —

    A mensagem criptografada ou a mensagem original se a criptografia não for possível ou necessária.



166
167
168
169
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 166

def talvez_encrypt(_connection, _context)
  # Não faça nada se a subclasse Mensagem não tiver implementado este método
  auto
end

#may_inflate ➤ Protocol::Message

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Infle uma mensagem se ela for comprimida.

Retorna:

  • (Protocol::Message) —

    Sempre retorna a si mesmo. As subclasses devem substituir este método conforme necessário.

Desde:

  • 2.5.0



140
141
142
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 140

def talvez_inflate
  auto
end

#number_returned ⇒ 0

Valor retornado número padrão para mensagens de protocolo.

Retorna:

  • (0) —

    Este método deve ser substituído, caso contrário, sempre retorna 0.

Desde:

  • 2.5.0



319
320
321
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 319

def number_returned
  0
end

#respondível? ➤ false

O padrão para mensagens não é exigir uma resposta após enviar uma mensagem para o servidor.

Exemplos:

A mensagem exige uma resposta?

message.replyable?

Retorna:

  • (falso) —

    O padrão é não exigir uma resposta.

Desde:

  • 2.0.0



95
96
97
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 95

def respondível?
  false
end

#serialize(buffer = BSON::ByteBuffer.new, max_bson_size = nil, bson_overhead = nil) ➤ string Também conhecido como: to_s

Serializa mensagem em bytes que podem ser enviados no fio

Parâmetros:

  • buffer (string) (padrão para: BSON::ByteBuffer.new) —

    buffer onde a mensagem deve ser inserida

Retorna:

  • (string) —

    buffer contendo a mensagem serializada



200
201
202
203
204
205
206
207
208
209
210
211
212
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 200

def serializar(buffer = BSON::ByteBuffer.Novo, max_bson_size = nada, bson_overhead = nada)
  max_size =
    se max_bson_size && bson_overhead
      max_bson_size + bson_overhead
    elsif max_bson_size
      max_bson_size
    end

  iniciar = buffer.Tamanho
  serialize_header(buffer)
  serialize_fields(buffer, max_size)
  buffer.replace_int32(iniciar, buffer.Tamanho - iniciar)
end

#set_request_id ⇒ Fixnum

Gera uma ID de solicitação para uma mensagem

Retorna:

  • (Fixnum) —

    uma ID de solicitação usada para enviar uma mensagem para o servidor. O servidor colocará esse ID no campo response_to de uma resposta.



310
311
312
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 310

def set_request_id
  @request_id = auto.classe.Next_id
end