Classe: Mongo::Retryable::WriteWorker Private

Herda:
Baseworker mostrar tudo
Definido em:
build/ruby-driver-v2.19/lib/mongo/retryable/write_worker.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.

Implementa a lógica em torno da repetição de operações de gravação.

Desde:

  • 2.19.0

Resumo do atributo de instância

Atributos herdados do BaseWorker

#retryable

Recolhimento do Resumo do método de instância

Métodos herdados do BaseWorker

#initialize

Detalhes do construtor

Esta classe herda um construtor de Mongo::Retryable::BaseWorker

Detalhes do método de instância

#nro_write_with_retry(write_concern, context:) {|connection, txn_num, context| ... } ➤ 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.

Encapsulador de retryable wrapper para operações que não oferecem suporte a retryable writes modernos.

Se o driver estiver configurado para usar gravações modernas que podem ser repetidas, esse método produzirá o bloco passado exatamente uma vez, portanto, não tentará novamente nenhuma gravação.

Se o driver estiver configurado para usar gravações legado repetíveis, esse método delegará para legacy_write_with_retry que executará novas tentativas de gravação usando lógica legado .

Parâmetros:

  • write_concern (nil | Hash | WriteConcern::Base) —

    A preocupação de gravação.

  • Contexto (Contexto) —

    O contexto da operação.

Parâmetros de rendimento:

  • Conexão (Conexão) —

    A conexão através da qual a escrita deve ser enviada.

  • txn_num (nil) —

    nil como número da transação.

  • Contexto (Operação::Contexto) —

    O contexto da operação.

Desde:

  • 2.19.0



103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'build/ruby-driver-v2.19/lib/mongo/retryable/write_worker.rb', linha 103

def nro_write_with_retry(write_concern, contexto:, &noum: bloco ; verb: bloquear)
  session = Contexto.session
  Servidor = select_server(cluster, ServerSelector.Principal, session)
  
  se session&.Cliente.opções[:retry_writes]
    começar
      Servidor.with_connection(connection_global_id: Contexto.connection_global_id) fazer |Conexão|
        rendimento Conexão, nada, Contexto
      end
    salvar *retryable_exceptions, Erro::PoolError, Erro::Falha de operação => e
      e.add_note('novas tentativas desabilitadas')
      aumentar e
    end
  mais
    legacy_write_with_retry(Servidor, contexto: Contexto, &noum: bloco ; verb: bloquear)
  end
end

#retry_write_allowed?(sessão, write_concern) ➤ 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.

Consulta se a sessão e a preocupação com a gravação suportam a repetição de gravações.

Parâmetros:

  • session (Mongo::Session) —

    A sessão em que a operação está sendo executada.

  • write_concern (nil | Hash | WriteConcern::Base) —

    A preocupação de gravação.

Retorna:

  • (verdadeiro | falso) —

    Se as tentativas de escrita são permitidas ou não.

Desde:

  • 2.19.0



129
130
131
132
133
134
135
136
137
 
# File 'build/ruby-driver-v2.19/lib/mongo/retryable/write_worker.rb', linha 129

def retry_write_allowed?(session, write_concern)
  Método false a menos que session&.retry_writes?

  se write_concern.nada?
    true
  mais
    Escreva preocupação.obter(write_concern).reconhecido?
  end
end

#write_with_retry(write_concern, endpoint_transaction: false, context:, &block) {|connection, txn_num, context| ... } ➤ Resultado

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:

Isso só repete operações em falhas de mestre, pois é o único caso em que podemos ter certeza de que uma escrita parcial ainda não ocorreu.

Implementa a funcionalidade de repetição de gravação cedendo ao bloco passado uma ou mais vezes.

Se a sessão for fornecida (portanto, o sistema suporta sessões) e as escritas de novas tentativas estiverem habilitadas no cliente, a lógica de novas tentativas será invocada. Caso contrário, a lógica de repetição herdada será invocada.

Se o parâmetro endpoint_transaction for verdadeiro, indicando que uma transação está sendo confirmada ou cancelada, a operação será executada exatamente uma vez. Observe que, como as transações exigem sessões, esse método aumentará o ArgumentError se endpoint_transaction for verdadeiro e a sessão for nula.

Exemplos:

Execute a gravação.

write_with_retry do
  ...
end

Parâmetros:

  • write_concern (nil | Hash | WriteConcern::Base) —

    A preocupação de gravação.

  • endpoint_transaction (verdadeiro | falso) (padrão para: false) —

    Verdadeiro se a operação de gravação for abortTransaction ou commitTransaction, caso contrário, falso.

  • Contexto (Contexto) —

    O contexto da operação.

  • noum: bloco ; verb: bloquear (Proc) —

    O bloco a ser executado.

Parâmetros de rendimento:

  • Conexão (Conexão) —

    A conexão através da qual a escrita deve ser enviada.

  • txn_num (Inteiro) —

    Número da transação (NÃO do tipo ACID ).

  • Contexto (Operação::Contexto) —

    O contexto da operação.

Retorna:

  • (Resultado) —

    O resultado da operação.

Desde:

  • 2.1.0



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'build/ruby-driver-v2.19/lib/mongo/retryable/write_worker.rb', linha 65

def write_with_retry(write_concern, endpoint_transaction: false, contexto:, &noum: bloco ; verb: bloquear)
  session = Contexto.session

  ensure_valid_state!(endpoint_transaction, session)

  a menos que endpoint_transaction || retry_write_allowed?(session, write_concern)
    Método legacy_write_with_retry(nada, contexto: Contexto, &noum: bloco ; verb: bloquear)
  end

  # Se estivermos aqui, a sessão não é nula. Uma sessão sendo nula teria
  # failed retry_write_allowed? verificar.

  Servidor = select_server(cluster, ServerSelector.Principal, session)

  a menos que endpoint_transaction || Servidor.retry_writes?
    Método legacy_write_with_retry(Servidor, contexto: Contexto, &noum: bloco ; verb: bloquear)
  end

  mod_write_with_retry(session, Servidor, Contexto, &noum: bloco ; verb: bloquear)
end