Módulo: Mongo::Retryable

Estendido por:
Encaminhável
Incluído em:
Cluster::CursorReaper, Collection, Collection::View::aggregation::Behavior, Collection::View::ChangeStream, Collection::View::MapReduce, Cursor, Banco de dados , Banco de dados::View , Index::View, SearchIndex: :Visualizar ,Servidor::Conexão , Sessão
Definido em:

lib/mongo/retryable.rb, lib/mongo/retryable/base_worker.rb,
lib/mongo/retryable/read_worker.rb,
lib/mongo/retryable/backpressure.rb,
lib/mongo/retryable/retry_policy.rb,
lib/ mongo/retryable/write_worker.rb

Visão geral

Define o comportamento básico em torno da repetição de operações.

Desde:

  • 2.1.0

Definido sob namespace

Módulos: Backpressure Classes: BaseWorker, ReadWorker, RetryPolicy, WriteWorker

Recolhimento do Resumo do método de instância

Detalhes do método de instância

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

Observação:

este é apenas um método público para que os testes possam adicionar expectativas com base nele.

Retorna o trabalhador de leitura para lidar com leituras repetíveis.

Desde:

  • 2.1.0



86
87
88
 
# Arquivo 'lib/mongo/retryable.rb', linha 86

def read_worker
  @read_worker ||= Read Worker.Novo(auto)
end

#select_server(cluster, server_selector, sessão, failed_server = nil, error: nil, timeout: nil) ➤Mongo::Server

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.

Este é um método separado para possibilitar que o conjunto de testes afirme que a seleção do servidor é executada durante tentativas de repetição.

Este é um método público para que ele possa ser acessado por meio dos delegados de trabalho de leitura e escrita, conforme necessário.

Retorna:

  • (Mongo::Server) —

    Um servidor que corresponda à preferência do servidor .

Desde:

  • 2.1.0



49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# Arquivo 'lib/mongo/retryable.rb', linha 49

def select_server(cluster, server_selector, session, failed_server = nada, erro: nada, timeout: nada)
  despriorizado = se failed_server && depriorize_server?(cluster, Erro)
                    [ failed_server ]
                  mais
                    []
                  end
  server_selector.select_server(
    cluster,
    nada,
    session,
    despriorizado: despriorizado,
    timeout: timeout
  )
end

#with_overload_retry(context: nil, retry_enabled: true) ➤ 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.

Envolve uma operação com lógica de repetição de sobrecarga. Em erros de sobrecarga (SystemOverloadedError + RetryableError), tenta novamente o bloco com backoff exponencial até MAX_RETRIES vezes.

O bloqueio deve incluir a seleção do servidor para que seja refeito na nova tentativa. Para operações de cursor (getMore), o mesmo servidor é reutilizado desde que o cursor esteja fixado.

Parâmetros:

  • Contexto (Operação::Contexto | nil) (padrão para: nil) —

    O contexto da operação para a verificação de prazo do CSOT.

  • retry_enabled (verdadeiro | falso) (padrão para: true) —

    Se as tentativas de sobrecarga são permitidas. Quando falso, os erros de sobrecarga são gerados imediatamente sem tentar novamente (usado quando retryReads/retryWrites está desabilitado).

Retorna:

  • (Objeto) —

    O resultado do bloqueio.

Desde:

  • 2.1.0



117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# Arquivo 'lib/mongo/retryable.rb', linha 117

def with_overload_retry(contexto: nada, retry_enabled: true)
  Método rendimento a menos que retry_enabled

  error_count = 0
  loop fazer
    Resultado = rendimento

    Método Resultado
  salvar Erro::Erro de tempo limite
    aumentar
  salvar Erro::Falha de operação::família => e
    aumentar e a menos que e.rótulo?('SystemOverloadedError') && e.rótulo?('RetryableError')

    error_count += 1
    política = Cliente.retry_policy
    atrasar = política.backoff_delay(error_count)
    aumentar e a menos que política.should_retry_overload?(error_count, atrasar, contexto: Contexto)

    Logger.logger.AVISAR("Sobrecarregar nova tentativa devido a: #{e.classe.name}: #{e.message}")
    sono(atrasar)
  end
end

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

Observação:

este é apenas um método público para que os testes possam adicionar expectativas com base nele.

Retorna o trabalhador de gravação para lidar com gravações repetíveis.

Desde:

  • 2.1.0



96
97
98
 
# Arquivo 'lib/mongo/retryable.rb', linha 96

def write_worker
  @write_worker ||= Write Worker.Novo(auto)
end