Clase: Mongo::Retryable::WriteWorker Privada

Hereda:
Trabajador de base Mostrar todo
Definido en:
lib/mongo/retryable/write_worker.rb

Overview

Esta clase forma parte de una API privada. Debe evitar usarla siempre que sea posible, ya que podría eliminarse o modificarse en el futuro.

Implementa la lógica en torno a volver a intentar operaciones de escritura.

Desde:

  • 2.19.0

Resumen de atributos de instancia

Atributos heredados de BaseWorker

#reintentable

Colapso del resumen del método de instancia

Métodos heredados de BaseWorker

#inicializar

Detalles del constructor

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

Detalles del método de instancia

#nro_write_with_retry(preocupación_de_escritura, contexto:) {|conexión, núm_de_transacción, contexto|... } ⇒ Objeto

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Envoltorio de escrituras reintentable para operaciones que no admiten escrituras reintentables modernas.

Si el controlador está configurado para usar escrituras reintentables modernas, este método cede el bloque pasado exactamente una vez, por lo que no vuelve a intentar ninguna escritura.

Si el controlador está configurado para utilizar escrituras reintentables heredadas, este método delega a legacy_write_with_retry, que realiza reintentos de escritura utilizando lógica heredada.

Parámetros:

  • escribir_preocupación ( nulo| Hash | WriteConcern::Base) —

    La preocupación de escribir.

  • context (Contexto) -

    El contexto de la operación.

Parámetros de rendimiento:

  • conexión (Conexión) —

    La conexión a través de la cual se debe enviar la escritura.

  • txn_num (nil) —

    nulo como número de transacción.

  • context (operación::Context) —

    El contexto de la operación.

Desde:

  • 2.19.0



107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# Archivo 'lib/mongo/retryable/write_worker.rb', línea 107

def nro_write_with_retry(escribir_preocupación, context:, Ybloque)
  sesión = context.sesión
  Server = seleccionar_servidor(clúster, Selector de servidor.primario, sesión)
  opciones = sesión&.Cliente&.opciones || {}

  Si opciones[:retry_writes]
    begin
      Server.con_conexión(id_global_de_conexión: context.id_global_de_conexión) hacer |conexión|
        rendimiento conexión, nulo, context
      end
    rescate *retryable_exceptions, Error::PoolError, Error::Operación fallida::Familia => e
      e.añadir nota('reintentos deshabilitados ')
      propagar e
    end
  else
    escritura heredada con reintento(Server, context: context, Ybloque)
  end
end

#¿retry_write_allowed?(sesión, preocupación de escritura) ⇒ verdadero | falso

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Consulta si la sesión y la preocupación de escritura admiten volver a intentar escrituras.

Parámetros:

  • sesión (Mongo::Sesión) —

    La sesión en la que se ejecuta la operación.

  • escribir_preocupación ( nulo| Hash | WriteConcern::Base) —

    La preocupación de escribir.

Devuelve:

  • (verdadero | falso) —

    Si se permiten reintentos de escritura o no.

Desde:

  • 2.19.0



134
135
136
137
138
139
140
141
142
 
# Archivo 'lib/mongo/retryable/write_worker.rb', línea 134

def ¿Se permite reintentar escritura?(sesión, escribir_preocupación)
  return false a no ser que sesión&.¿retry_writes?

  Si escribir_preocupación.nil?
    true
  else
    Escribir preocupación.Obtener(escribir_preocupación).¿admitido?
  end
end

#escritura_con_reinicio(preocupación_de_escritura, transacción_final: falso, contexto:, &bloque) {|conexión, núm_transacción, contexto|... } ⇒ 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 solo vuelve a intentar operaciones en fallas que no son maestras, ya que es el único caso en el que podemos estar seguros de que no ocurrió una escritura parcial.

Implementa la funcionalidad de reintento de escritura cediendo el paso al bloque pasado una o más veces.

Si se proporciona la sesión (por lo tanto, la implementación admite sesiones) y las escrituras con reintentos modernos están habilitadas en el cliente, se invoca la lógica de reintento moderna. De lo contrario, se invoca la lógica de reintento heredada.

Si el parámetro ending_transaction es verdadero, lo que indica que una transacción se está confirmando o cancelando, la operación se ejecuta una sola vez. Tenga en cuenta que, dado que las transacciones requieren sesiones, este método generará un error de argumento (ArgumentError) si ending_transaction es verdadero y la sesión es nula.

Ejemplos:

Ejecutar la escritura.

write_with_retry do
  ...
end

Parámetros:

  • escribir_preocupación ( nulo| Hash | WriteConcern::Base) —

    La preocupación de escribir.

  • transacción final (true | false) (predeterminado: falso)

    Verdadero si la operación de escritura es abortTransaction o commitTransaction, falso en caso contrario.

  • context (Contexto) -

    El contexto de la operación.

  • bloque (Procedimiento) —

    El bloque a ejecutar.

Parámetros de rendimiento:

  • conexión (Conexión) —

    La conexión a través de la cual se debe enviar la escritura.

  • txn_num (Entero) —

    Número de transacción (NO del tipo ACID).

  • context (operación::Context) —

    El contexto de la operación.

Devuelve:

  • (Result) —

    El resultado de la operación.

Desde:

  • 2.1.0



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# Archivo 'lib/mongo/retryable/write_worker.rb', línea 65

def escribir_con_reintentar(escribir_preocupación, transacción_final: false, context:, Ybloque)
  sesión = context.sesión

  ¡Asegure un estado válido!(transacción final, sesión)

  a no ser que transacción final || ¿Se permite reintentar escritura?(sesión, escribir_preocupación)
    return escritura heredada con reintento(nulo, context: context, Ybloque)
  end

  # Si estamos aquí, la sesión no es nula. Una sesión nula tendría
  # ¿retry_write_allowed falló? comprobar.

  Server = seleccionar_servidor(
    clúster, Selector de servidor.primario,
    sesión,
    timeout: context.remaining_timeout_sec
  )

  a no ser que transacción final || Server.¿retry_writes?
    return escritura heredada con reintento(Server, context: context, Ybloque)
  end

  modern_write_with_retry(sesión, Server, context, Ybloque)
end