Clase: Mongo::Retryable::ReadWorker Privado

Hereda:
BaseWorker Mostrar todo
Definido en:
lib/mongo/retryable/read_worker.rb

Overview

Esta clase forma parte de una API privada. Evita usar esta clase si es posible, ya que puede ser eliminada o modificada en el futuro.

Implementa la lógica relacionada con reintentos en operaciones de lectura.

Desde:

  • 2.19.0

Resumen del atributo de la instancia

Atributos heredados de BaseWorker

#retryable

Resumen del método de instancia colapsar

Métodos heredados de BaseWorker

#initialice

Detalles del Constructor

Esta clase hereda un constructor de Mongo::Retryable::BaseWorker

Detalles del método de instancia

#read_with_one_retry(options = nil) { ... } ⇒ Result

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:

Esto sólo reintenta operaciones de lectura en caso de errores de socket.

Ejecute una operación de lectura con un único reintento en caso de errores de red.

Este método es utilizado por el controlador para algunas de las operaciones internas de mantenimiento. Las lecturas solicitadas por la aplicación deben usar read_with_retry en lugar de este método.

Ejemplos:

Ejecuta la lectura.

read_with_one_retry do
  ...
end

Parámetros:

  • opciones (Hash | nil) (valor por defecto: nil) —

    Opciones.

Opciones Hash (options):

  • :retry_message (string) —

    Mensaje para registro al reintentar.

Rendimientos:

  • Llama al bloque proporcionado sin argumentos

Devuelve:

  • (Result) —

    El resultado de la operación.

Desde:

  • 2.2.6



151
152
153
154
155
156
157
158
159
 
# Archivo 'lib/mongo/retryable/read_worker.rb', línea 151

def read_with_one_retry(opciones = nulo)
  rendimiento
rescate *retryable_exceptions, Error::PoolError => e
  propagar e a menos que e.write_retryable?

  retry_message = opciones && opciones[:retry_message]
  reintento_de_registro(e, mensaje: retry_message)
  rendimiento
end

#read_with_retry(session = nil, server_selector = nil, context = nil, &block) ⇒ Resultado

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.

Ejecuta una operación de lectura con reintentos.

Este método realiza la selección del servidor para el selector de servidor especificado y produce el bloque proporcionado, que debe ejecutar la operación de query inicial y devolver su resultado. Se pasará el bloque al servidor seleccionado para la operación. Si el bloque genera una excepción, y esta excepción corresponde a un error de reintento de lectura, y los reintentos de lectura están habilitados para el cliente, este método realizará la selección del servidor nuevamente y cederá al bloque nuevamente (posiblemente con un servidor diferente). Si el bloque se devuelve correctamente, se retorna el resultado del bloque.

Si las lecturas modernas de reintentos están activadas (que es por defecto), la operación de lectura inicial se volverá a intentar una vez. Si las relecturas heredadas están activadas, la operación de lectura inicial se reintentará cero o más veces según la configuración del cliente :max_read_retries, cuyo valor por defecto es 1. Para deshabilitar los reintentos de lectura, desactive los reintentos de lectura modernos configurando retry_reads: false y establezca :max_read_retries en 0 en el cliente.

Ejemplos:

Ejecuta la lectura.

read_with_retry(session, server_selector) do |server|
  ...
end

Parámetros:

  • sesión (Mongo::Session | nil) (valor por defecto: nil) —

    La sesión en la que se está ejecutando la operación.

  • selector_de_servidor (Mongo::ServerSelector::Selectable | nil) (valor por defecto: nil) —

    Selector de servidor para la operación.

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

    Contexto para la operación de lectura.

  • bloque (Proc) —

    El bloque a ejecutar.

Devuelve:

  • (Result) —

    El resultado de la operación.

Desde:

  • 2.19.0



115
116
117
118
119
120
121
122
123
124
125
 
# Archivo 'lib/mongo/retryable/read_worker.rb', línea 115

def read_with_retry(sesión = nulo, selector_de_servidor = nulo, context = nulo, &bloque)
  si sesión.nil? && selector_de_servidor.nil?
    deprecated_legacy_read_with_retry(&bloque)
  elsif sesión&.retry_reads?
    modern_read_with_retry(sesión, selector_de_servidor, context, &bloque)
  elsif Cliente.max_read_retries > 0
    legacy_read_with_retry(sesión, selector_de_servidor, context, &bloque)
  else
    read_without_retry(sesión, selector_de_servidor, &bloque)
  end
end

#read_with_retry_cursor(session, server_selector, view, context: nil) ⇒ Cursor

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.

Ejecuta una operación de lectura que devuelve un cursor con reintentos.

Este método realiza la selección del servidor para el selector de servidor especificado y cede al bloque proporcionado, el cual debe ejecutar la operación de query inicial y devolver su resultado. Al bloque se le pasará el servidor seleccionado para la operación. Si el bloque genera una excepción, y esta excepción corresponde a un error de lectura reintento y se han habilitado reintentos de lectura para el cliente, este método realizará la selección de servidor nuevamente y volverá a ceder el control al bloque (posiblemente con un servidor diferente). Si el bloque retorna exitosamente, el resultado del bloque (que debe ser un Mongo::operación::Result) se usa para construir un objeto Mongo::cursor para el conjunto de resultados. Luego, el cursor es devuelto.

Si las lecturas modernas de reintentos están activadas (que es por defecto), la operación de lectura inicial se volverá a intentar una vez. Si las relecturas heredadas están activadas, la operación de lectura inicial se reintentará cero o más veces según la configuración del cliente :max_read_retries, cuyo valor por defecto es 1. Para deshabilitar los reintentos de lectura, desactive los reintentos de lectura modernos configurando retry_reads: false y establezca :max_read_retries en 0 en el cliente.

Ejemplos:

Ejecutar una lectura que devuelva un cursor.

cursor = read_with_retry_cursor(session, server_selector, view) do |server|
  # return a Mongo::Operation::Result
  ...
end

Parámetros:

  • sesión (Mongo::Session) —

    La sesión en la que se está ejecutando la operación.

  • selector_de_servidor (Mongo::ServerSelector::Selectable) —

    Selector de servidor para la operación.

  • vista (CollectionView) —

    El CollectionView que define la query.

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

    el contexto de operación a utilizar con el cursor.

  • bloque (Proc) —

    El bloque a ejecutar.

Devuelve:

  • (Cursor) —

    El cursor para el conjunto de resultados.

Desde:

  • 2.19.0



66
67
68
69
70
71
72
73
74
75
76
77
78
 
# Archivo 'lib/mongo/retryable/read_worker.rb', línea 66

def leer_con_reintento_cursor(sesión, selector_de_servidor, vista, context: nulo)
  read_with_retry(sesión, selector_de_servidor, context) hacer |Server|
    Resultado = rendimiento Server

    # RUBY-2367: Esto se actualizará para permitir que la caché de query
    # caché cursores con resultados de múltiples lotes.
    si QueryCache.¿habilitado? && !vista.Colección.system_collection?
      CachingCursor.Nuevo(vista, Resultado, Server, sesión: sesión, context: context)
    else
      Cursor.Nuevo(vista, Resultado, Server, sesión: sesión, context: context)
    end
  end
end