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:) {|connection, txn_num, context| ... } ⇒ 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.

Contenedor de escrituras reintentables para operaciones que no admiten escrituras reintentables modernas.

Si el controlador está configurado para utilizar escrituras modernas que se pueden volver a intentar, este método cede al bloque pasado exactamente una vez, por lo tanto, no reintenta 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:

  • write_concern (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 debe enviarse el guardar.

  • txn_num (nil) —

    nulo como número de transacción.

  • context (operación::Context) —

    El contexto de la operación.

Desde:

  • 2.19.0



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# Archivo 'lib/mongo/retryable/write_worker.rb', línea 105

def nro_write_with_retry(guardar, context:, &bloque)
  sesión = context.sesión
  Server = select_server(clúster, ServerSelector.primario, sesión)
  opciones = sesión&.Cliente&.opciones || {}

  si opciones[retry_writes]
    error_count = 0
    error_to_raise = nulo
    begin
      Server.with_connection(connection_global_id: context.connection_global_id) hacer |Conexión|
        rendimiento Conexión, nulo, context
      end
    rescate Error::TimeoutError
      propagar
    rescate *retryable_exceptions, Error::PoolError, Error::OperationFailure::Familia => e
      si retryable_overload_error?(e)
        error_count += 1
        error_to_raise ||= e
        a menos que e.respond_to?(Etiqueta:) && e.¿etiqueta?('NoSeRealizaronEscrituras')
          error_to_raise = e
        end
        retrasar = retry_policy.retraso_de_respaldo(error_count)
        propagar error_to_raise a menos que retry_policy.should_retry_overload?(error_count, retrasar, context: context)

        reintento_de_registro(e, mensaje: 'Guardar reintento (espera por sobrecarga)')
        sueño(retrasar)
        begin
          Server = select_server(
            clúster, ServerSelector.primario, sesión, Server,
            error: e, timeout: context.remaining_timeout_sec
          )
        rescate Error, Error::AuthError => select_err
          error_to_raise.add_note("el reintento posterior falló: #{select_err.clase}: #{select_err}")
          propagar error_to_raise
        end
        reintentar
      else
        e.add_note('reintentos deshabilitados')
        propagar e
      end
    end
  else
    legacy_write_with_retry(Server, context: context, &bloque)
  end
end

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

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.

Consulta si la sesión y el nivel de confirmación de escritura (write concern) admiten reintentos de escritura.

Parámetros:

  • sesión (Mongo::Session) —

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

  • write_concern (nil | Hash | WriteConcern::Base) —

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

Devuelve:

  • (true | false) —

    Si se permiten o no los reintentos de guardar.

Desde:

  • 2.19.0



159
160
161
162
163
 
# Archivo 'lib/mongo/retryable/write_worker.rb', línea 159

def ¿se_permite_reintentar_escritura?(sesión, write_concern)
  return false a menos que sesión&.¿retry_writes?

  write_concern.nil? || Nivel de confirmación de escritura (write concern).Obtener(write_concern).¿entendido?
end

#escribir_con_reintento(write_concern, context:, ending_transaction: false, &block) {|connection, txn_num, context| ... } ⇒ 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.

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 los reintentos de escritura modernos están habilitados 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:

  • write_concern (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 debe enviarse el guardar.

  • 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



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

def escribir_con_reintento(write_concern, context:, ending_transaction: false, &bloque)
  sesión = context.sesión

  ensure_valid_state!(ending_transaction, sesión)

  a menos que ending_transaction || ¿se_permite_reintentar_escritura?(sesión, write_concern)
    return legacy_write_with_retry(nulo, context: context, &bloque)
  end

  # Si estamos aquí, la sesión no es nula. Una sesión nula sería
  # comprobación failed retry_write_allowed? fallida.

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

  a menos que ending_transaction || Server.¿retry_writes?
    return legacy_write_with_retry(Server, context: context, &bloque)
  end

  modern_write_with_retry(sesión, Server, context, &bloque)
end