Classe: Mongo::Retryable::WriteWorker Private

Herda:
Baseworker mostrar tudo
Definido em:
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|... } ⇒ Object

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



105
106
107
108
109
110
111
112
113
114
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
141
142
143
144
145
146
147
148
149
 
# Arquivo 'lib/mongo/retryable/write_worker.rb', linha 105

def nro_write_with_retry(_write_concern, contexto:, &noum: bloco ; verb: bloquear)
  session = Contexto.session
  Servidor = select_server(cluster, ServerSelector.Principal, session)
  opções = session&.Cliente&.opções || {}

  se opções[:retry_writes]
    error_count = 0
    error_to_raise = nada
    começar
      Servidor.with_connection(connection_global_id: Contexto.connection_global_id) fazer |Conexão|
        rendimento Conexão, nada, Contexto
      end
    salvar Erro::Erro de tempo limite
      aumentar
    salvar *retryable_exceptions, Erro::PoolError, Erro::Falha de operação::família => e
      se retryable_overload_error?(e)
        error_count += 1
        error_to_raise ||= e
        a menos que e.respond_to?(:label?) && e.rótulo?('NoWritesPermitted ')
          error_to_raise = e
        end
        atrasar = retry_policy.backoff_delay(error_count)
        aumentar error_to_raise a menos que retry_policy.should_retry_overload?(error_count, atrasar, contexto: Contexto)

        log_retry(e, Mensagem: 'Repetição de gravação (backoff de sobrecarga) ')
        sono(atrasar)
        começar
          Servidor = select_server(
            cluster, ServerSelector.Principal, session, Servidor,
            erro: e, timeout: Contexto.remaining_timeout_sec
          )
        salvar Erro, Erro::AuthError => select_err
          error_to_raise.add_note("falha na nova tentativa posterior: #{select_err. classe }: #{select_err}")
          aumentar error_to_raise
        end
        tentar novamente
      mais
        e.add_note('novas tentativas desabilitadas')
        aumentar e
      end
    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



159
160
161
162
163
 
# Arquivo 'lib/mongo/retryable/write_worker.rb', linha 159

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

  write_concern.nada? || Escreva preocupação.obter(write_concern).reconhecido?
end

#write_with_retry(write_concern, context:, Ending_transaction: false, &block) {|connection, txn_num, context|... } ⇒ Result

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



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# Arquivo 'lib/mongo/retryable/write_worker.rb', linha 63

def write_with_retry(write_concern, contexto:, endpoint_transaction: false, &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,
    timeout: Contexto.remaining_timeout_sec
  )

  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