Módulo: Mongo::Retryable

Ampliado por:
Reenviable
Incluido en:
Clúster::CursorReaper, Colección, Colección::View::Aggregation::Behavior, Colección::View::ChangeStream, Colección::View::MapReduce, Cursor, Base de datos, Base de datos::View, Índice::View, SearchIndex::View, Servidor::Connection, Session
Definido en:
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

Overview

Define el comportamiento básico en torno a la reintento de operaciones.

Desde:

  • 2.1.0

Definido bajo Namespace

Modules: Contrapresión clase: BaseWorker, ReadWorker, RetryPolicy, WriteWorker

Resumen del método de instancia colapsar

Detalles del método de instancia

#read_worker ⇒ objeto

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Nota:

este es solo un método público para que las pruebas puedan agregar expectativas basadas en él.

Devuelve el trabajador de lectura para manejar lecturas reiterables.

Desde:

  • 2.1.0



86
87
88
 
# Archivo 'lib/mongo/retryable.rb', línea 86

def read_worker
  @read_worker ||= ReadWorker.Nuevo(sí mismo)
end

#select_server(cluster, server_selector, session, failed_server = nil, error: nil, timeout: nil) ⇒ Mongo::Server

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Este es un método separado para hacer posible que el paquete de prueba pueda asegurar que la selección del servidor se realiza durante los intentos de reintento.

Este es un método público para que pueda ser accedido vía los delegados de trabajadores de lectura y guardado, según se necesite.

Devuelve:

  • (Mongo::servidor)  —

    Un servidor que coincida con la preferencia del servidor.

Desde:

  • 2.1.0



49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# Archivo 'lib/mongo/retryable.rb', línea 49

def select_server(clúster, selector_de_servidor, sesión, failed_server = nulo, error: nulo, timeout: nulo)
  rebajado de prioridad = si failed_server && ¿despriorizar_servidor?(clúster, Error)
                    [ failed_server ]
                  else
                    []
                  end
  selector_de_servidor.select_server(
    clúster,
    nulo,
    sesión,
    con menor prioridad: rebajado de prioridad,
    timeout: tiempo de espera
  )
end

#with_overload_retry(contexto: nil, retry_enabled: true) ⇒ Objeto

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Envuelve una operación con la lógica de reintento por sobrecarga. En caso de errores de sobrecarga (SystemOverloadedError + RetryableError), se reintenta el bloque con retroceso exponencial hasta MAX_RETRIES veces.

El bloque debe incluir la selección del servidor para que se vuelva a realizar en caso de reintento. Para las operaciones de cursor (getMore), el mismo servidor se reutiliza ya que el cursor está fijado.

Parámetros:

  • context (Operation::Context | nil) (valor por defecto: nil) —

    El contexto de operación para la verificación de plazos de CSOT.

  • retry_enabled (true | false) (por defecto: true) —

    Si se permiten los intentos de sobrecarga. Cuando es falso, los errores de sobrecarga se notifican de inmediato sin reintentos (se utiliza cuando retryReads/retryWrites está deshabilitado).

Devuelve:

  • (objeto) —

    El resultado del bloque.

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
 
# Archivo 'lib/mongo/retryable.rb', línea 117

def con_reintento_por_sobrecarga(context: nulo, retry_enabled: true)
  return rendimiento a menos que retry_enabled

  error_count = 0
  bucle hacer
    Resultado = rendimiento

    return Resultado
  rescate Error::TimeoutError
    propagar
  rescate Error::OperationFailure::Familia => e
    propagar e a menos que e.¿etiqueta?('SystemOverloadedError') && e.¿etiqueta?('RetryableError')

    error_count += 1
    policy = Cliente.retry_policy
    retrasar = policy.retraso_de_respaldo(error_count)
    propagar e a menos que policy.should_retry_overload?(error_count, retrasar, context: context)

    Logger.logger.advertencia("Reintento de sobrecarga debido a: #{e.clase.name}: #{e.message}")
    sueño(retrasar)
  end
end

#write_worker ⇒ objeto

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Nota:

este es solo un método público para que las pruebas puedan agregar expectativas basadas en él.

Devuelve el trabajador de escritura para gestionar escrituras reintentables.

Desde:

  • 2.1.0



96
97
98
 
# Archivo 'lib/mongo/retryable.rb', línea 96

def write_worker
  @write_worker ||= WriteWorker.Nuevo(sí mismo)
end