Classe: Mongo::Protocol::Msg Private

Herda:
mensagem mostrar tudo
Inclui:
Monitoramento::Evento::Seguro
Definido em:
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.

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'
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

Constantes incluídas dos serializadores

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

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, deserialize_array, deserialize_field, deserialize_header, campo, campos, #hash, #maybe_inflate, #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



62
63
64
65
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
 
# File 'lib/mongo/protocol/msg.rb', linha 62

def inicializar(flags, opções, main_document, *sequências)
  se flags
    flags.cada fazer |flag|
      aumentar ArgumentError, "Unknown flag: #{flag.inspect}" a menos que KNOWN_FLAGS.chave?(flag)
    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



264
265
266
267
268
269
270
271
272
273
274
 
# File 'lib/mongo/protocol/msg.rb', linha 264

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



192
193
194
 
# File 'lib/mongo/protocol/msg.rb', linha 192

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.

Aumenta:

  • (NotImplementedError)

Desde:

  • 2.5.0



179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/mongo/protocol/msg.rb', linha 179

def Fix_after_deserialization
  aumentar NotImplementedError, 'Após as desserializações, @sections deveriam ter sido inicializadas ' se @sections.nada?

  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



276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
 
# File 'lib/mongo/protocol/msg.rb', linha 276

def talvez_add_server_api(server_api)
  conflitos = {}
  %i[apiVersion apiStrict apiDeprecationErrors].cada fazer |chave|
    conflitos[chave] = @main_document[chave] se @main_document.chave?(chave)
    conflitos[chave] = @main_document[chave.to_s] se @main_document.chave?(chave.to_s)
  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



169
170
171
 
# File 'lib/mongo/protocol/msg.rb', linha 169

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



243
244
245
246
247
248
249
250
251
 
# File 'lib/mongo/protocol/msg.rb', linha 243

def talvez_decrypt(Contexto)
  se Contexto.descriptografar?
    cmd = mesclar seções
    enc_cmd = Contexto.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



210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
 
# File 'lib/mongo/protocol/msg.rb', linha 210

def talvez_encrypt(Conexão, Contexto)
  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 de fio inferior 8 a). 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 4.2 de) '
      )
    end

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

    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



300
301
302
303
304
305
306
 
# File 'lib/mongo/protocol/msg.rb', linha 300

def number_returned
  se (doc = documentos.primeiro) && (cursor = doc['cursor']) && (lote = cursor['firstBatch'] || cursor['próximoBatch'])
    Método lote.Tamanho
  end

  aumentar NotImplementedError, 'number_returned só é 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



115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
# File 'lib/mongo/protocol/msg.rb', linha 115

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



103
104
105
 
# File 'lib/mongo/protocol/msg.rb', linha 103

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



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

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