Classe: Mongo::Protocol::Msg Private

Herda:
mensagem mostrar tudo
Inclui:
Monitoramento::Evento::Seguro
Definido em:
build/ruby-driver-v2.19/lib/mongo/protocol/msg.rb

Visão geral

Esta classe faz parte de uma API privada. Evite usar essa classe, se possível, pois ela pode ser removida ou alterada no futuro.

MongoDB Wire protocol Msg message (OP_MSG), um opcode de protocolo de conexão bidirecional.

O OP_MSG só está disponível no MongoDB 3.6 (maxWireVersion >= 6) e posterior.

Desde:

  • 2.5.0

Definido sob namespace

Classes: Seção 1

Colapsode resumo constante

DATABASE_IDENTIFIER =

Essa constante faz parte de uma API privada. Você deve evitar usar essa constante, se possível, pois ela pode ser removida ou alterada no futuro.

O identificador do nome do banco de dados de dados no qual executar o comando.

Desde:

  • 2.5.0

'$db'.congelar
Internal_keys =

Essa constante faz parte de uma API privada. Você deve evitar usar essa constante, se possível, pois ela pode ser removida ou alterada no futuro.

Chaves que o driver adiciona aos comandos. Eles serão movidos para o final do hash para melhor registro.

Desde:

  • 2.5.0

definir.Novo(%w($clusterTime $db lsid assinatura txnNumber)).congelar

Constantes incluídas no Monitoring::Event::Secure

Monitoramento::Evento::Secure::REDACTED_COMMANDS

Constantes herdadas de Mensagem

Mongo::Protocol::Message::BATCH_SIZE, Mongo::Protocol::Message::COLLECTION, Mongo::Protocol::Message::LIMIT, Mongo::Protocol::Message::MAX_MSSAGE_SIZE, Mongo::Protocol:: Mensagem::ORDERED, Mongo::Protocol::Message::Q

Resumo do atributo de instância

Atributos herdados de Mensagem

#request_id

Recolhimento do Resumo do método de instância

Métodos incluídos do Monitoring::Event::Secure

#compression_allowed?, #editado, #sensitive?

Métodos herdados de Mensagem

#==, deserialize, #hash, # maybe_inflete, #set_request_id

Métodos incluídos do ID

incluído

Detalhes do construtor

. _

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.

Cria uma nova mensagem de protocolo OP_MSG

Exemplos:

Criar uma mensagem de protocolo de fio OP_MSG

Msg.new([:more_to_come], {}, { hello: 1 },
        { type: 1, payload: { identifier: 'documents', sequence: [..] } })

Parâmetros:

  • flags (Array <Símbolo>) —

    Os bits da bandeira. Os valores atualmente suportados são :more_to_come e :checksum_present.

  • opções (Hash) —

    As opções.

  • main_document (BSON::Document, Hash) —

    O documento que se tornará a seção do tipo de carga útil 0 . Pode conter argumentos globais conforme definidos na especificação OP_MSG.

  • sequências (Protocol::Msg::Section1) —

    Zero ou mais seções do tipo de carga útil 1 .

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

  • validate_keys (verdadeiro, falso) —

    Se as chaves devem ser validadas como chaves de documentos válidas (ou seja, não comece com $ e não contenha pontos). Esta opção é preterida e não será utilizada. Ele será removido na versão 3.0.

Desde:

  • 2.5.0



66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/msg.rb', linha 66

def inicializar(flags, opções, main_document, *sequências)
  se flags
    flags.cada fazer |flag|
      a menos que KNOWN_FLAGS.chave?(flag)
        aumentar ArgumentError, "Unknown flag: #{flag.inspect}"
      end
    end
  end
  @flags = flags || []
  @opções = opções
  a menos que main_document.is_a?(Hash)
    aumentar ArgumentError, "O documento principal deve ser um Hash, dado: #{main_document.classe}"
  end
  @main_document = main_document
  sequências.cada_com_index fazer |Seção, index|
    a menos que Seção.is_a?(Seção 1)
      aumentar ArgumentError, "Todas as sequências devem ser instâncias da Seção1 , tem: #{seção} no índice #{índice}"
    end
  end
  @sequences = sequências
  @sections = [
    {tipo: 0, carga útil: @main_document}
  ] + @sequences.map fazer |Seção|
    {tipo: 1, carga útil: {
      identifier: Seção.identificador,
      sequência: Seção.documentos.map fazer |doc|
        CacheingHash.Novo(doc)
      end,
    }}
  end
  @request_id = nada
  super
end

Detalhes do método de instância

#bulk_write? ➤ Booleano

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.

Observação:

Este método foi escrito para oferecer suporte à funcionalidade de criptografia do lado do cliente . Não é recomendável que esse método seja usado a serviço de qualquer outra funcionalidade ou comportamento.

Se esta mensagem representa uma escrita em massa. Uma escrita em massa é uma operação de inserção, atualização ou exclusão que engloba várias operações do mesmo tipo.

Retorna:

  • (Booleano) —

    Se esta mensagem representa uma escrita em massa.

Desde:

  • 2.5.0



272
273
274
275
276
277
278
279
280
281
282
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/msg.rb', linha 272

def bulk_write?
  Inserções = @main_document['documents']
  Atualizações = @main_document['updates']
  exclui = @main_document['deletes']

  num_inserts = Inserções && Inserções.Tamanho || 0
  num_updates = Atualizações && Atualizações.Tamanho || 0
  num_deletes = exclui && exclui.Tamanho || 0

  num_inserts > 1  || num_updates > 1 || num_deletes > 1
end

#documentos ➤ 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.

Desde:

  • 2.5.0



196
197
198
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/msg.rb', linha 196

def documentos
  [@main_document]
end

#prefix_after_deserialization ➤ 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.

Preenche de forma reversa as variáveis de instância depois que a desserialização define a variável de instância @sections para a lista de documentos.

TODO corrige a desserialização para que esse método não seja necessário.

Desde:

  • 2.5.0



184
185
186
187
188
189
190
191
192
193
194
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/msg.rb', linha 184

def Fix_after_deserialization
  se @sections.nada?
    aumentar NotImplementedError, "Após as desserializações, @sections deveriam ter sido inicializadas"
  end
  se @sections.Tamanho != 1
    aumentar NotImplementedError, "A desserialização deve ter produzido exatamente uma seção, mas ela produz #{seções.comprimento} seções"
  end
  @main_document = @sections.primeiro
  @sequences = []
  @sections = [{tipo: 0, carga útil: @main_document}]
end

#may_add_server_api(server_api) ➤ 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.

Desde:

  • 2.5.0



284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/msg.rb', linha 284

def talvez_add_server_api(server_api)
  conflitos = {}
  %i(apiVersion apiStrict apiDeprecationErrors).cada fazer |chave|
    se @main_document.chave?(chave)
      conflitos[chave] = @main_document[chave]
    end
    se @main_document.chave?(chave.to_s)
      conflitos[chave] = @main_document[chave.to_s]
    end
  end
  a menos que conflitos.vazio?
    aumentar Erro::ServerApiConflict, "O cliente está configurado com a opção :server_api , mas a operação forneceu os seguintes parâmetros conflitantes: #{conflitos.inspect}"
  end

  main_document = @main_document.mesclar(
    Utilidades.transform_server_api(server_api)
  )
  Msg.Novo(@flags, @opções, main_document, *@sequences)
end

#may_compress(compressor, zlib_compression_level = nil) ➤ 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.

Compacte a mensagem se o comando que está sendo enviado permitir a compressã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:

  • (Mensagem) —

    Uma mensagem de Protocolo::Comprimida ou auto, dependendo se esta mensagem pode ser comprimida.

Desde:

  • 2.5.0



174
175
176
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/msg.rb', linha 174

def talvez_compress(compressor, compressor, zlib_compression_level = nada)
  compressor_if_possível(comando.keys.primeiro, compressor, compressor, zlib_compression_level)
end

#maybe_decrypt(context) ⇒ Mongo::Protocol::Msg

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.

Possivelmente descriptografe esta mensagem com libmongocrypt. A mensagem só será descriptografada se o cliente especificado existir, se esse cliente tiver recebido opções de criptografia automática e essa mensagem for elegível para descriptografia. Uma mensagem é elegível para descriptografia se representar um dos tipos de comando permitidos listados por libmongocrypt e contiver dados que devem ser criptografados por um JSON schema local ou remoto.

Parâmetros:

Retorna:

  • (Mongo::Protocol::Msg) —

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

Desde:

  • 2.5.0



251
252
253
254
255
256
257
258
259
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/msg.rb', linha 251

def talvez_decrypt(Contexto)
  se Contexto.descriptografar?
    cmd = mesclar seções
    enc_cmd = Contexto.criptografador.Descriptografar(cmd)
    Msg.Novo(@flags, @opções, enc_cmd)
  mais
    auto
  end
end

#maybe_encrypt(connection, context) ⇒ Mongo::Protocol::Msg

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.

Possivelmente, criptografe esta mensagem com libmongocrypt. A mensagem só será criptografada se o cliente especificado existir, se esse cliente tiver recebido opções de criptografia automática e não tiver sido instruído a ignorar a criptografia automática e o cliente determinar que essa mensagem é elegível para criptografia. Uma mensagem é elegível para criptografia se representar um dos tipos de comando permitidos listados por libmongocrypt e contiver dados que devem ser criptografados por um JSON schema local ou remoto.

Parâmetros:

Retorna:

  • (Mongo::Protocol::Msg) —

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

Desde:

  • 2.5.0



214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/msg.rb', linha 214

def talvez_encrypt(Conexão, Contexto)
  # A compactação de verificação TODO acontece mais tarde, ou seja, quando esse método é executado
  # a mensagem não é compactada.
  se Contexto.criptografar?
    se Conexão.Descrição.max_wire_version < 8
      aumentar Erro::Criptografia de erro.Novo(
        "Não é possível executar criptografia em um servidor MongoDB com mais de " +
        "4.2 (versão com fio inferior a 8). Atualmente conectado ao servidor " +
        "com a versão max wire #{connection.descrição.max_wire_version}} " +
        "(A criptografia automática requer uma versão mínima do MongoDB de 4.2)"
      )
    end

    db_name = @main_document[DATABASE_IDENTIFIER]
    cmd = mesclar seções
    enc_cmd = Contexto.criptografador.criptografar(db_name, cmd)
    se cmd.chave?('$db') && !enc_cmd.chave?('$db')
      enc_cmd['$db'] = cmd['$db']
    end

    Msg.Novo(@flags, @opções, enc_cmd)
  mais
    auto
  end
end

#number_returned ⇒ 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.

Retorna o número de documentos retornados do servidor.

A instância Msg deve ser para uma resposta do servidor e a resposta deve retornar um cursor ativo (um recém-criado ou um cuja iteração continue via getMore).

Retorna:

  • (Inteiro) —

    Número de documentos devolvidos.

Aumenta:

  • (NotImplementedError)

Desde:

  • 2.5.0



311
312
313
314
315
316
317
318
319
320
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/msg.rb', linha 311

def number_returned
  se doc = documentos.primeiro
    se cursor = doc['cursor']
      se lote = cursor['firstBatch'] || cursor['próximoBatch']
        Método lote.Tamanho
      end
    end
  end
  aumentar NotImplementedError, "number_returned só está definido para respostas de cursor"
end

#payload ➤ BSON::Document

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.

Retorne a carga útil do evento para monitoramento.

Exemplos:

Retorne a carga útil do evento.

message.payload

Retorna:

  • (BSON::Document) —

    A carga útil do evento.

Desde:

  • 2.5.0



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/msg.rb', linha 120

def Carga útil
  # Reordenar chaves em principal_documento para melhor registro - consulte
  # https://jira.mongodb.org/browse/RUBY-{01591.
  # Observe que, mesmo sem a reordenação, a carga útil não é exata
  # corresponde ao que é enviado pela rede, pois o comando conforme usado em
  # o evento publicado combina chaves de várias seções do
  # payload enviada pela transferência.
  ordered_command = {}
  skipped_command = {}
  comando.cada fazer |k, v|
    se Internal_keys.membro?(k.to_s)
      skipped_command[k] = v
    mais
      ordered_command[k] = v
    end
  end
  ordered_command.update(skipped_command)

  BSON::Documento.Novo(
    command_name: ordered_command.keys.primeiro.to_s,
    database_name: @main_document[DATABASE_IDENTIFIER],
    comando: ordered_command,
    request_id: request_id,
    resposta: @main_document,
  )
end

#respondível? ➤ true, false

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.

Se a mensagem espera uma resposta do banco de banco de dados.

Exemplos:

A mensagem exige uma resposta?

message.replyable?

Retorna:

  • (verdadeiro, falso) —

    Se a mensagem espera uma resposta.

Desde:

  • 2.5.0



108
109
110
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/msg.rb', linha 108

def respondível?
  @replyable ||= !flags.incluir?(:more_to_come)
end

#serialize(buffer = BSON::ByteBuffer.new, max_bson_size = nil, bson_overhead = nil) ➤ BSON::ByteBuffer

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 a mensagem em bytes que podem ser enviados na transferência.

Parâmetros:

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

    onde a mensagem deve ser inserida.

  • max_bson_size (Inteiro) (padrão para: nil) —

    O tamanho máximo do objeto BSON .

Retorna:

  • (BSON::ByteBuffer) —

    buffer contendo a mensagem serializada.

Desde:

  • 2.5.0



155
156
157
158
159
160
161
 
# File 'build/ruby-driver-v2.19/lib/mongo/protocol/msg.rb', linha 155

def serializar(buffer = BSON::ByteBuffer.Novo, max_bson_size = nada, bson_overhead = nada)
  validate_document_size!(max_bson_size)

  super
  add_check_sum(buffer)
  buffer
end