Class: Mongo::Protocol::Message Abstract

Herda:
Objeto
  • Objeto
mostrar tudo
Inclui:
ID, Serializadores
Definido em:
build/ruby-driver-v2.19/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
 
# File 'build/ruby-driver-v2.19/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
 
# File 'build/ruby-driver-v2.19/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
289
290
291
 
# File 'build/ruby-driver-v2.19/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 = {}
  se timeout = opções[:socket_timeout]
    read_options[:timeout] = timeout
  end

  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

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.



298
299
300
301
302
303
304
305
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/message.rb', linha 298

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.



311
312
313
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/message.rb', linha 311

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

#may_add_server_api(server_api) ➤ Objeto

Aumenta:



173
174
175
 
# File 'build/ruby-driver-v2.19/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
 
# File 'build/ruby-driver-v2.19/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
 
# File 'build/ruby-driver-v2.19/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
 
# File 'build/ruby-driver-v2.19/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
 
# File 'build/ruby-driver-v2.19/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



329
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/message.rb', linha 329

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
 
# File 'build/ruby-driver-v2.19/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
 
# File 'build/ruby-driver-v2.19/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.



320
321
322
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/message.rb', linha 320

def set_request_id
  @request_id = auto.classe.Next_id
end