Clase: Mongo::Retryable::WriteWorker Privado

Hereda:
BaseWorker Mostrar todo
Definido en:
lib/mongo/retryable/write_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 volver a intentar las operaciones de guardar.

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

#nro_write_with_retry(write_concern, context:) {|conexión, txn_num, 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.

Contenedor de escrituras reintentables 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 driver está configurado para usar escrituras reintentables heredadas, este método delega en legacy_write_with_retry, que realiza reintentos de escritura utilizando la lógica heredada.

Parámetros:

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

    El nivel de confirmación de escritura (write concern).

  • 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, ServerSelector.primario, sesión)
  opciones = sesión&.Cliente&.opciones || {}

  si opciones[retry_writes]
    begin
      Server.with_connection(id_global_de_conexión: context.connection_global_id) hacer |Conexión|
        rendimiento Conexión, nulo, context
      end
    rescate *retryable_exceptions, Error::PoolError, Error::OperationFailure::Familia => e
      e.add_note('reintentos deshabilitados')
      propagar e
    end
  else
    escritura heredada con reintento(Server, context: context, Ybloque)
  end
end

#¿retry_write_allowed?(sesión, write_concern) ⇒ true | false

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 el nivel de confirmación de escritura (write concern) admiten reintentos de escritura.

Parámetros:

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

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

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

    El nivel de confirmación de escritura (write concern).

Devuelve:

  • (true | false) —

    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 menos que sesión&.¿retry_writes?

  si escribir_preocupación.nil?
    true
  else
    Nivel de confirmación de escritura (write concern).Obtener(escribir_preocupación).¿entendido?
  end
end

#write_with_retry(write_concern, ending_transaction: false, context:, &block) {|connection, txn_num, context| ... } ⇒ Result

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 reintenta operaciones en fallos que no sean de maestro, ya que es el único caso en el que podemos estar seguros de que un guardado parcial no ha ocurrido ya.

Implementa la funcionalidad de reintento de escritura cediendo el 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 se está confirmando o abortando una transacción, la operación se ejecuta exactamente una vez. Ten en cuenta que, dado que las transacciones requieren sesiones, este método generará ArgumentError si ending_transaction es verdadero y session es nil.

Ejemplos:

Ejecuta el guardar.

write_with_retry do
  ...
end

Parámetros:

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

    El nivel de confirmación de escritura (write concern).

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

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

  • context (Contexto) -

    El contexto de la operación.

  • bloque (Proc) —

    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 (Número 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_reintento(escribir_preocupación, ending_transaction: false, context:, Ybloque)
  sesión = context.sesión

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

  a menos que ending_transaction || ¿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 sería
  # comprobación failed retry_write_allowed? fallida.

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

  a menos que ending_transaction || Server.¿retry_writes?
    return escritura heredada con reintento(Server, context: context, Ybloque)
  end

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