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

#lectura_con_un_reintentar(opciones = nula) {... } ⇒ Resultado

Este método forma parte de una API privada. Debe evitarlo 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) (predeterminado: nulo) —

    Opciones.

Opciones Hash (options):

  • :retry_message (Cadena) —

    Mensaje para registro al reintentar.

Rendimientos:

  • Llama al bloque proporcionado sin argumentos

Devuelve:

  • (Result) —

    El resultado de la operación.

Desde:

  • 2.2.6



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

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 forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Ejecuta una operación de lectura con reintentos.

Este método selecciona el servidor para el selector especificado y cede el paso al bloque proporcionado, que debe ejecutar la consulta inicial y devolver su resultado. El bloque recibirá el servidor seleccionado para la operación. Si el bloque genera una excepción, que corresponde a un error de lectura reintentable, y los reintentos de lectura están habilitados para el cliente, este método volverá a seleccionar el servidor y cede el paso al bloque (posiblemente con un servidor diferente). Si el bloque se ejecuta correctamente, se devuelve el resultado.

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::Sesión | nulo) (predeterminado: nulo) —

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

  • selector_de_servidor (Mongo::ServerSelector::Selectable | nil) (predeterminado: nulo) —

    Selector de servidor para la operación.

  • context (Mongo::Operation::Context | nil) (predeterminado: nulo) —

    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



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

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

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

Este método forma parte de una API privada. Debe evitarlo 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::Sesión) —

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

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

    Selector de servidor para la operación.

  • vista (CollectionView) —

    El CollectionView que define la consulta.

  • context (Operation::Context | nil) (predeterminado: nulo) —

    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



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

def leer_con_reintento_cursor(sesión, selector_de_servidor, vista, context: nulo, Ybloque)
  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
    # cursores de caché con resultados de múltiples lotes.
    si Caché de consultas.¿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