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'.congelar
collection =

A constante da collection.

Desde:

  • 2.2.0

'collection'.congelar
LIMIT =

O limite constante.

Desde:

  • 2.2.0

'limit'.congelar
ORDENADO =

A constante ordenada.

Desde:

  • 2.2.0

'ordenado'.congelar
Q =

A constante q.

Desde:

  • 2.2.0

'q'.congelar
MAX_MSSAGE_SIZE =

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

Desde:

  • 2.2.1

50331648.congelar

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:



79
80
81
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 79

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



86
87
88
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 86

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



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

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)

  se read_options.vazio?
    chunk = io.ler(16)
  mais
    chunk = 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.
  se Tamanho > (max_message_size || MAX_message_SIZE)
    aumentar Erro::MaxMessageSize.Novo(max_message_size)
  end

  # 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

  se read_options.vazio?
    chunk = io.ler(Tamanho - 16)
  mais
    chunk = 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
  se mensagem.is_a?(Msg)
    mensagem.Fix_after_deserialization
  end
  mensagem.talvez_inflate
end

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

Deserializes an array of fields in a message

The number of items in the array must be described by a previously deserialized field specified in the class by the field dsl under the key :multi

Parâmetros:

  • mensagem (Mensagem) —

    Message to contain the deserialized array.

  • io (IO) —

    Stream containing the array to deserialize.

  • Campo (Hash) —

    Hash representing a field.

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

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

  • :deserialize_as_bson (Booleano) —

    Whether to deserialize each of the elements in this array using BSON types wherever possible.

Retorna:

  • (Mensagem) —

    Message with deserialized array.



432
433
434
435
436
437
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 432

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, field, options = {}) ⇒ Message

Deserializes a single field in a message

Parâmetros:

  • mensagem (Mensagem) —

    Message to contain the deserialized field.

  • io (IO) —

    Stream containing the field to deserialize.

  • Campo (Hash) —

    Hash representing a field.

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

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

  • :deserialize_as_bson (Booleano) —

    Whether to deserialize this field using BSON types wherever possible.

Retorna:

  • (Mensagem) —

    Message with deserialized field.



450
451
452
453
454
455
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 450

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>

Deserializes the header of the message

Parâmetros:

  • io (IO) —

    Stream containing the header.

Retorna:

  • (Array<Fixnum>) —

    Deserialized header.



388
389
390
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 388

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

.field(name, type, multi = false) ⇒ NilClass

A method for declaring a message field

Parâmetros:

  • name (string) —

    Name of the field

  • type (Módulo) —

    Type specific serialization strategies

  • multi (true, false, Symbol) (padrão para: false) —

    Specify as true to serialize the field’s value as an array of type :type or as a symbol describing the field having the number of items in the array (used upon deserialization)

    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) 


407
408
409
410
411
412
413
414
415
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 407

def auto.Campo(name, type, multi = false)
  Campos << {
    :name => "@#{name}".estagiário,
    :type => type,
    :multi => multi
  }

  attr_reader name
end

.fields ⇒ Integer

A class method for getting the fields for a message class

Retorna:

  • (Inteiro) —

    the fields for the message class



340
341
342
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 340

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.



295
296
297
298
299
300
301
302
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 295

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.



308
309
310
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 308

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

#may_add_server_api(server_api) ➤ Objeto

Aumenta:



173
174
175
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 173

def talvez_add_server_api(server_api)
  aumentar Erro::ServerApiNotSupported, "Os parâmetros da API do servidor não podem ser enviados para servidores pré-3.6 MongoDB . Remova o parâmetro :server_api das Opções do cliente ou use o MongoDB 3.6 ou mais recente"
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) (padrão para: nil) —

    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



112
113
114
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 112

def talvez_compress(compressor, compressor, zlib_compression_level = nada)
  auto
end

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



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

def talvez_decrypt(Contexto)
  # TODO para determinar se devemos descriptografar os 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

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



168
169
170
171
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 168

def talvez_encrypt(Conexão, Contexto)
  # 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



142
143
144
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 142

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



326
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 326

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



97
98
99
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 97

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



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

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
    mais
      nada
    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.



317
318
319
 
# Arquivo 'lib/mongo/protocol/message.rb', linha 317

def set_request_id
  @request_id = auto.classe.Next_id
end