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:



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

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.Campos.cada fazer |Campo|
    se Campo[:multi]
      mensagem.deserialize_array(buffer, Campo, opções)
    mais
      mensagem.deserialize_field(buffer, Campo, opções)
    end
  end
  mensagem.Fix_after_deserialization se mensagem.is_a?(Msg)
  mensagem.talvez_inflate
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.



332
333
334
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 332

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) 


352
353
354
355
356
357
358
359
360
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 352

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



323
324
325
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 323

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.



283
284
285
286
287
288
289
290
291
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 283

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

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

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:

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

  • (Array) —

    O array desserializado.



377
378
379
380
381
382
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 377

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

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

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 nesta mensagem.

Parâmetros:

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

  • (Objeto) —

    O valor do campo desserializado.



395
396
397
398
399
400
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 395

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

#campo ⇒ Array<Hash>

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 obter os campos para uma classe de mensagem

Retorna:

  • (Array<Hash>) —

    os campos para a classe de mensagem



406
407
408
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 406

def Campos
  auto.classe.Campos
end

#hash ➤ Fixnum

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

Retorna:

  • (Fixnum) —

    O código hash da mensagem.



297
298
299
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 297

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) 


171
172
173
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 171

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

def talvez_decrypt(_context)
  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.



162
163
164
165
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 162

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



315
316
317
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 315

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



196
197
198
199
200
201
202
203
204
205
206
207
208
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 196

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

#serialize_fields(buffer, max_bson_size = nil) ⇒ String

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.

Serializa os campos de mensagem em um buffer

Parâmetros:

  • buffer (string) —

    buffer para receber o campo

Retorna:

  • (string) —

    buffer com campo serializado



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

def serialize_fields(buffer, max_bson_size = nada)
  Campos.cada fazer |Campo|
    valor = instance_variable_get(Campo[:name])
    se Campo[:multi]
      valor.cada fazer |item|
        se Campo[:type].respond_to?(:size_limited?)
          Campo[:type].serializar(buffer, item, max_bson_size)
        mais
          Campo[:type].serializar(buffer, item)
        end
      end
    elsif Campo[:type].respond_to?(:size_limited?)
      Campo[:type].serializar(buffer, valor, max_bson_size)
    mais
      Campo[:type].serializar(buffer, valor)
    end
  end
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.



306
307
308
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 306

def set_request_id
  @request_id = auto.classe.Next_id
end