Clase: Mongo::Session

Hereda:
Objeto
  • Objeto
Mostrar todo
Ampliado por:
Reenviable
Incluye:
ClusterTime::Consumer, Loggable, Retryable
Definido en:
lib/mongo/session.rb,
lib/mongo/session/session_pool.rb,
lib/mongo/session/server_session.rb,
lib/mongo/session/server_session/dirtyable.rb

Overview

Nota:

Los objetos de sesión no son seguros para subprocesos. Una aplicación puede usar una sesión desde un solo hilo o proceso a la vez.

Una sesión lógica que representa un conjunto de operaciones secuenciales ejecutadas por una aplicación que están relacionadas de alguna manera.

Desde:

  • 2.5.0

Definido bajo Namespace

Clases: ServerSession, SessionPool

Colapso delresumen constante

MISMATCHED_CLUSTER_ERROR_MSG =

Mensaje de error que indica que la sesión se recuperó de un cliente con un clúster diferente al del cliente a través del cual se está utilizando actualmente.

Desde:

  • 2.5.0

'La configuración del cliente utilizada para crear esta sesión no coincide con aquella ' +
'del cliente propietario de esta operación. Por favor, use esta sesión únicamente para operaciones a través de su padre ' +
'cliente.'.freeze
SESSION_ENDED_ERROR_MSG =

Mensaje de error que describe que la sesión no se puede usar porque ya ha terminado.

Desde:

  • 2.5.0

'Esta sesión ha finalizado y no se puede utilizar. Por favor, cree una nueva.'.freeze
SESSIONS_NOT_SUPPORTED =
Obsoleto.

Mensaje de error que describe que las sesiones no son soportadas por la versión del servidor.

Desde:

  • 2.5.0

'Las sesiones no son compatibles con los servidores conectados.'.freeze
NO_TRANSACTION_STATE =

El estado de una sesión en la que la última operación no estaba relacionada con ninguna transacción o aún no se había producido ninguna operación.

Desde:

  • 2.6.0

no transaction
ESTADO_INICIO_TRANSACCIÓN =

El estado de una sesión en la que un usuario ha iniciado una transacción, pero aún no se han realizado operaciones dentro de la transacción.

Desde:

  • 2.6.0

:starting_transaction
TRANSACTION_IN_PROGRESS_STATE =

El estado de una sesión en la que se ha iniciado una transacción y se ha producido al menos una operación, pero la transacción aún no se ha confirmado ni abortado.

Desde:

  • 2.6.0

:transaction_in_progress
ESTADO_COMPROMETIDO_DE_TRANSACCIÓN =

El estado de una sesión en la que la última operación ejecutada fue la confirmación de una transacción.

Desde:

  • 2.6.0

:transacción_confirmada
TRANSACTION_ABORTED_STATE =

El estado de una sesión en la que la última operación ejecutada fue la cancelación de una transacción.

Desde:

  • 2.6.0

:transaction_aborted
UNLABELED_WRITE_CONCERN_CODES =

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

Desde:

  • 2.5.0

[
  79,  # UnknownReplWriteConcern
  100, # CannotSatisfyWriteConcern,
].freeze

Constantes incluidas desde Loggable

Registrable::PREFIX

Resumen de atributos de la instancia colapsar

Atributos incluidos de ClusterTime::Consumer

#cluster_time

Resumen del método de instancia colapsar

Métodos incluidos de ClusterTime::Consumer

#advance_cluster_time

Métodos incluidos desde Registrable

#log_debug, #log_error, #log_fatal, #log_info, #log_warn, #logger

Métodos incluidos en Retryable

#read_worker, #select_server, #write_worker

Detalles del constructor

#inicializar(servidor_sesión, cliente, opciones = {}) ⇒ Sesión

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:

Las aplicaciones deben utilizar Client#start_session para iniciar una sesión. Este constructor es solo para uso interno del controlador.

Iniciar una sesión.

Una sesión puede ser explícita o implícita. La duración de las sesiones explícitas es gestionada por la aplicación: las aplicaciones crean explícitamente dichas sesiones y las terminan explícitamente. Las sesiones implícitas son creadas automáticamente por el driver al enviar operaciones a servidores que admiten sesiones (3.6+), y su duración es gestionada por el driver.

Cuando se crea una sesión implícita, no se puede asociar una sesión de servidor con ella. La sesión del servidor se retirará del pool de sesiones cuando realmente se ejecute una operación que utilice esta sesión. Cuando se crea una sesión explícita, esta debe hacer referencia a una sesión de servidor que ya está asignada.

Parámetros:

  • sesión_del_servidor (SesiónServidor | nil) —

    La sesión del servidor con la que se asocia esta sesión. Si la opción :implicit es verdadera, esto debe ser nulo.

  • Cliente (cliente) —

    El cliente a través del cual se crea esta sesión.

  • opciones (Hash) (por defecto: {}) —

    Las opciones para esta sesión.

Opciones Hash (options):

  • :consistencia_causal (true|false) —

    Si se debe habilitar la coherencia causal para esta sesión.

  • :default_timeout_ms (Entero) —

    El valor timeoutMS para las siguientes operaciones ejecutadas en la sesión:

    • commitTransaction

    • abortarTransacción

    • withTransaction

    • endSession

  • :default_transaction_options (Hash) —

    Opciones que se pasan a start_transaction por defecto; pueden contener cualquiera de las opciones que start_transaction acepte.

  • :implicit (true|false) —

    Solo para uso interno de drivers: especifica si la sesión es implícita. Si esto es cierto, server_session será nil. Esto se hace para que la sesión del servidor solo se consulte después de consultar la conexión.

  • :preferencia de lectura (Hash) —

    El hash de opciones de preferencia de lectura, con las siguientes claves opcionales:

    • :mode – la preferencia de lectura como una cadena o símbolo; los valores válidos son :primary, :primary_preferred, :secondary, :secondary_preferred y :nearest.

  • snapshot (true | false) —

    Configura la sesión para lecturas de snapshot.

Desde:

  • 2.5.0



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# Archivo 'lib/mongo/session.rb', línea 83

def inicializar(sesión_del_servidor, Cliente, opciones = {})
  si opciones[:consistencia_causal] && opciones[snapshot]
    propagar ArgumentError, ':las opciones :causal_consistency y :snapshot no pueden configurarse ambas en una sesión'
  end

  si opciones[:implicit]
    a menos que sesión_del_servidor.nil?
      propagar ArgumentError, 'La sesión implícita no puede hacer referencia a la sesión del servidor durante la construcción'
    end
  else
    si sesión_del_servidor.nil?
      propagar ArgumentError, 'La sesión explícita debe hacer referencia a la sesión del servidor durante la construcción'
    end
  end

  @servidor_sesión = sesión_del_servidor
  opciones = opciones.dup

  @cliente = Cliente.Usar(Administrador)
  @options = opciones.dup.freeze
  @cluster_time = nulo
  @state = NO_TRANSACTION_STATE
  @with_transaction_deadline = nulo
end

Detalles de los atributos de instancia

#cliente ⇒ Cliente (solo lectura)

Devuelve El cliente a través del cual se creó esta sesión.

Devuelve:

  • (cliente) —

    El cliente a través del cual se creó esta sesión.

Desde:

  • 2.5.1



116
117
118
 
# Archivo 'lib/mongo/session.rb', línea 116

def Cliente
  @cliente
end

#operation_time ⇒ BSON::Timestamp (solo lectura)

Devuelve la última hora de operación vista para esta sesión.

Devuelve:

  • (BSON::Timestamp) —

    El último operation time visto para esta sesión.

Desde:

  • 2.5.0



131
132
133
 
# Archivo 'lib/mongo/session.rb', línea 131

def tiempo_de_operación
  @tiempo_de_operación
end

#opciones ⇒ Hash (solo lectura)

Devuelve las opciones para esta sesión.

Devuelve:

  • (encriptada) —

    Las opciones para esta sesión.

Desde:

  • 2.5.0



111
112
113
 
# Archivo 'lib/mongo/session.rb', línea 111

def opciones
  @options
end

#pinned_connection_global_id ⇒ Entero | nulo (solo lectura)

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

Devuelve El id global de conexión al que está fijada esta sesión, si lo hay.

Devuelve:

  • (Integer | nil) —

    El ID global de conexión al que esta sesión está fijada, si corresponde.

Desde:

  • 2.5.0



284
285
286
 
# Archivo 'lib/mongo/session.rb', línea 284

def pinned_connection_global_id
  @pinned_connection_global_id
end

#pinned_server ⇒ Servidor | nil (solo lectura)

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

Devuelve el servidor (que debería ser un mongos) al que está fijada esta sesión, si la hay.

Devuelve:

  • (Server | nil) —

    El servidor (que debe ser un mongos) al que está fijada esta sesión, si existe.

Desde:

  • 2.5.0



278
279
280
 
# Archivo 'lib/mongo/session.rb', línea 278

def servidor fijado
  @pinned_server
end

#recovery_token ⇒ BSON::Document | nil

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

Devuelve el token de recuperación para la transacción fragmentada que se está ejecutando en esta sesión, si es que hay alguna.

Devuelve:

  • (BSON::Document | nil) —

    Token de recuperación para la transacción fragmentada que se ejecuta en esta sesión, si la hay.

Desde:

  • 2.5.0



290
291
292
 
# Archivo 'lib/mongo/session.rb', línea 290

def recovery_token
  @recovery_token
end

#snapshot_timestamp ⇒ Object

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

Desde:

  • 2.5.0



1192
1193
1194
 
# Archivo 'lib/mongo/session.rb', línea 1192

def timestamp_de_captura
  @snapshot_timestamp
end

#with_transaction_deadline ⇒ Object (solo lectura)

Desde:

  • 2.5.0



1194
1195
1196
 
# Archivo 'lib/mongo/session.rb', línea 1194

def with_transaction_deadline
  @with_transaction_deadline
end

Detalles del método de instancia

#abort_transaction(options = nil) ⇒ Object

Aborta la transacción activa actualmente sin realizar ningún cambio en la base de datos.

Ejemplos:

Abortar la transacción.

session.abort_transaction

Parámetros:

  • opciones (Hash) (predeterminado: nulo) —

    un conjunto personalizable de opciones

Opciones Hash (options):

  • :timeout_ms (Entero) —

    El tiempo de espera de la operación en milisegundos. Debe ser un número entero no negativo. Un valor explícito de 0 significa infinito. El valor por defecto no está definido, lo que significa que se hereda del cliente.

Aumenta:

Desde:

  • 2.6.0



730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
 
# Archivo 'lib/mongo/session.rb', línea 730

def abortar_transacción(opciones = nulo)
  Caché de consultas.borrar

  check_if_ended!
  check_if_no_transaction!

  si within_states?(ESTADO DE TRANSACCIÓN COMPROMETIDA)
    propagar Mongo::Error::OperaciónTransacciónInválida.Nuevo(
      Mongo::Error::OperaciónTransacciónInválida.cannot_call_after_msg(
        :commitTransaction, abortTransaction))
  end

  si within_states?(TRANSACTION_ABORTED_STATE)
    propagar Mongo::Error::OperaciónTransacciónInválida.Nuevo(
      Mongo::Error::OperaciónTransacciónInválida.cannot_call_twice_msg(abortTransaction))
  end

  opciones ||= {}

  begin
    a menos que ¿transacción_inicial?
      @aborting_transaction = true
      context = Operación::Context.Nuevo(
        cliente: @cliente,
        sesión: sí mismo,
        operation_timeouts: tiempos de espera de operación(opciones)
      )
      escribir_con_reintento(txn_options[:escribir_preocupación],
        ending_transaction: true, context: context,
      ) hacer |Conexión, txn_num, context|
        begin
          Operación::Comando.Nuevo(
            selector: { abortTransaction: 1 },
            nombre_base_datos: 'admin',
            sesión: sí mismo,
            txn_num: txn_num
          ).ejecutar_con_conexión(Conexión, context: context)
        asegurar
          unpin
        end
      end
    end

    @state = TRANSACTION_ABORTED_STATE
  rescate Mongo::Error::OperaciónTransacciónInválida
    propagar
  rescate Mongo::Error
    @state = TRANSACTION_ABORTED_STATE
  rescate Excepción
    @state = TRANSACTION_ABORTED_STATE
    propagar
  asegurar
    @aborting_transaction = false
  end

  # No hay valor de retorno oficial, pero devuelve verdadero para que en la interacción
  # utilice el método para indicar que tuvo éxito.
  true
end

#aborting_transaction? ⇒ 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.

Devuelve si la sesión está actualmente cancelando una transacción.

Devuelve:

  • (true | false) —

    Si la sesión está actualmente abortando una transacción.

Desde:

  • 2.5.0



819
820
821
 
# Archivo 'lib/mongo/session.rb', línea 819

def aborting_transaction?
  !!@aborting_transaction
end

#add_autocommit!(command) ⇒ Hash, BSON::documento

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

Agregar el campo de autocommit a un documento de comando si corresponde.

Ejemplos:

session.add_autocommit!(cmd)

Devuelve:

  • (Hash, BSON::Documento) —

    El documento de comando.

Desde:

  • 2.6.0



899
900
901
902
903
 
# Archivo 'lib/mongo/session.rb', línea 899

def ¡añadir_autocommit!(Comando)
  Comando.tocar hacer |C|
    C[:autocommit] = false si en_transacción?
  end
end

#add_start_transaction!(comando) ⇒ Hash, BSON::Document

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

Agregar el campo startTransaction a un documento de comando si es aplicable.

Ejemplos:

session.add_start_transaction!(cmd)

Devuelve:

  • (Hash, BSON::Documento) —

    El documento de comando.

Desde:

  • 2.6.0



914
915
916
917
918
919
920
 
# Archivo 'lib/mongo/session.rb', línea 914

def add_start_transaction!(Comando)
  Comando.tocar hacer |C|
    si ¿transacción_inicial?
      C[:startTransaction] = true
    end
  end
end

#add_txn_num!(comando) ⇒ Hash, BSON::Documento

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

Agrega el número de transacción a un documento de comando si corresponde.

Ejemplos:

session.add_txn_num!(cmd)

Devuelve:

  • (Hash, BSON::Documento) —

    El documento de comando.

Desde:

  • 2.6.0



931
932
933
934
935
 
# Archivo 'lib/mongo/session.rb', línea 931

def add_txn_num!(Comando)
  Comando.tocar hacer |C|
    C[Número de transacción] = BSON::Int64.Nuevo(@servidor_sesión.txn_num) si en_transacción?
  end
end

#add_txn_opts!(comando, lectura, contexto) ⇒ Hash, BSON::Documento

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

Agregue las opciones de transacciones si corresponde.

Ejemplos:

session.add_txn_opts!(cmd)

Devuelve:

  • (Hash, BSON::Documento) —

    El documento de comando.

Desde:

  • 2.6.0



946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
 
# Archivo 'lib/mongo/session.rb', línea 946

def add_txn_opts!(Comando, Lea, context)
  Comando.tocar hacer |C|
    # El nivel de consistencia de lectura debe añadirse a cualquier comando que inicie una transacción.
    si ¿transacción_inicial?
      # https://jira.mongodb.org/browse/SPEC-1161: de transacción
      # la anulación de nivel de consistencia de lectura reemplaza los niveles de consistencia de lectura de la colección, base de datos o cliente,
      # incluso si no se establece el nivel de consistencia de lectura de la transacción.
      # nivel de consistencia de lectura aquí es la enviada al servidor y puede
      # incluir afterClusterTime.
      si rc = C[:leerPreocupación]
        rc = rc.dup
        rc.borrar(Nivel)
      end
      si txn_read_concern
        si rc
          rc.update(txn_read_concern)
        else
          rc = txn_read_concern.dup
        end
      end
      si rc.nil? || rc.¿vacío?
        C.borrar(:leerPreocupación)
      else
        C[:leerPreocupación ] = opciones::Mapeador.transform_values_to_strings(rc)
      end
    end

    # Necesitamos enviar el nivel de preocupación de lectura como una cadena en lugar de un símbolo.
    si C[:leerPreocupación]
      C[:leerPreocupación] = opciones::Mapeador.transform_values_to_strings(C[:leerPreocupación])
    end

    si C[:commitTransaction]
      si tiempo máximo_ms = txn_options[:tiempo máximo de confirmación_ms]
        C[Tiempo máximo en milisegundos (:maxTimeMS)] = tiempo máximo_ms
      end
    end

    # La preocupación de escritura debe agregarse a cualquier comando abortTransaction o commitTransaction.
    si (C[abortTransaction] || C[:commitTransaction])
      si @ya_comprometido
        wc = BSON::Documento.Nuevo(C[:writeConcern] || txn_write_concern || {})
        wc.¡unir!(w: mayoría)
        wc[:wtimeout] ||= 10000
        C[:writeConcern] = wc
      elsif txn_write_concern
        C[:writeConcern] ||= txn_write_concern
      end
    end

    # Un valor de nivel de confirmación de escritura (write concern) w no numérico debe enviarse como una string en lugar de un símbolo.
    si C[:writeConcern] && C[:writeConcern][:w] && C[:writeConcern][:w].is_a?(Símbolo)
      C[:writeConcern][:w] = C[:writeConcern][:w].to_s
    end

    # Ignore wtimeout if csot
    si context&.csot?
      C[:writeConcern]&.borrar(:wtimeout)
    end

    # No debemos enviar un nivel de confirmación de escritura (write concern) vacío (por defecto del servidor).
    C.borrar(:writeConcern) si C[:writeConcern]&.¿vacío?
  end
end

#tiempo_de_operación_avanzado(nuevo_tiempo_de_operación) ⇒ BSON::Timestamp

Avanza el operation time en caché para esta sesión.

Ejemplos:

Adelantar el tiempo de operación.

session.advance_operation_time(timestamp)

Parámetros:

  • new_operation_time (BSON::Timestamp) —

    La nueva hora de la operación.

Devuelve:

  • (BSON::Timestamp) —

    El max operation time, considerando las horas actuales y las nuevas.

Desde:

  • 2.5.0



1123
1124
1125
1126
1127
1128
1129
 
# Archivo 'lib/mongo/session.rb', línea 1123

def advance_operation_time(new_operation_time)
  si @tiempo_de_operación
    @tiempo_de_operación = [ @tiempo_de_operación, new_operation_time ].máximo
  else
    @tiempo_de_operación = new_operation_time
  end
end

#cluster ⇒ Object

Desde:

  • 2.5.0



118
119
120
 
# Archivo 'lib/mongo/session.rb', línea 118

def clúster
  @cliente.clúster
end

#commit_transaction(opciones = nil) ⇒ objeto

Confirma la transacción activa actual en la sesión.

Ejemplos:

Confirma la transacción.

session.commit_transaction

Parámetros:

  • opciones (Hash) (predeterminado: nulo) —

    un conjunto personalizable de opciones

Opciones Hash (options):

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

    La nivel de confirmación de escritura (write concern) a usar para esta operación.

  • :timeout_ms (Entero) —

    El tiempo de espera de la operación en milisegundos. Debe ser un número entero no negativo. Un valor explícito de 0 significa infinito. El valor por defecto no está definido, lo que significa que se hereda del cliente.

Aumenta:

Desde:

  • 2.6.0



648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
 
# Archivo 'lib/mongo/session.rb', línea 648

def commit_transaction(opciones=nulo)
  Caché de consultas.borrar
  check_if_ended!
  check_if_no_transaction!

  si within_states?(TRANSACTION_ABORTED_STATE)
    propagar Mongo::Error::OperaciónTransacciónInválida.Nuevo(
      Mongo::Error::OperaciónTransacciónInválida.cannot_call_after_msg(
        abortTransaction, :commitTransaction))
  end

  opciones ||= {}

  begin
    # Si se llama a commitTransaction dos veces, necesitamos ejecutar el mismo commit
    # operación de nuevo, así que revertimos la sesión al estado anterior.
    si within_states?(ESTADO DE TRANSACCIÓN COMPROMETIDA)
      @state = @last_commit_skipped ? STARTING_TRANSACTION_STATE : TRANSACTION_IN_PROGRESS_STATE
      @ya_comprometido = true
    end

    si ¿transacción_inicial?
      @last_commit_skipped = true
    else
      @last_commit_skipped = false
      @transacción_comprometida = true

      escribir_preocupación = opciones[:escribir_preocupación] || txn_options[:escribir_preocupación]
      si escribir_preocupación && !escribir_preocupación.is_a?(Nivel de confirmación de escritura (write concern)::Base)
        escribir_preocupación = Nivel de confirmación de escritura (write concern).Obtener(escribir_preocupación)
      end

      context = Operación::Context.Nuevo(
        cliente: @cliente,
        sesión: sí mismo,
        operation_timeouts: tiempos de espera de operación(opciones)
      )
      escribir_con_reintento(escribir_preocupación, ending_transaction: true,
        context: context,
      ) hacer |Conexión, txn_num, context|
        si context.¿rever?
          si escribir_preocupación
            wco = escribir_preocupación.opciones.fusionar(w: mayoría)
            wco[:wtimeout] ||= 10000
            escribir_preocupación = Nivel de confirmación de escritura (write concern).Obtener(wco)
          else
            escribir_preocupación = Nivel de confirmación de escritura (write concern).Obtener(w: mayoría, wtimeout: 10000)
          end
        end
        especulación = {
          selector: { commitTransaction: 1 },
          nombre_base_datos: 'admin',
          sesión: sí mismo,
          txn_num: txn_num,
          write_concern: escribir_preocupación,
        }
        Operación::Comando.Nuevo(especulación).ejecutar_con_conexión(Conexión, context: context)
      end
    end
  asegurar
    @state = ESTADO DE TRANSACCIÓN COMPROMETIDA
    @transacción_comprometida = false
  end

  # No hay valor de retorno oficial, pero devuelve verdadero para que en la interacción
  # utilice el método para indicar que tuvo éxito.
  true
end

#committing_transaction? ⇒ 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.

Devuelve si la sesión está actualmente confirmando una transacción.

Devuelve:

  • (true | false) —

    Si la sesión está actualmente realizando una transacción.

Desde:

  • 2.5.0



811
812
813
 
# Archivo 'lib/mongo/session.rb', línea 811

def guardando_transacción?
  !!@transacción_comprometida
end

#¡sucio!( marcar = true) ⇒ objeto

Establece el estado "dirty" (modificado) en el valor dado para la sesión subyacente del servidor. Si no hay una sesión de servidor, esto no hace nada.

Parámetros:

  • marca (true | false) (predeterminado: verdadero)

    si marcar la sesión del servidor como sucia o no.

Desde:

  • 2.5.0



138
139
140
 
# Archivo 'lib/mongo/session.rb', línea 138

def dirty!(marca = true)
  @servidor_sesión&.dirty!(marca)
end

#dirty? ⇒ true | false | nil

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

Devuelve si la sesión de servidor subyacente está sucia. Si no existe una sesión de servidor para esta sesión, se devuelve nil.

Devuelve:

  • (true | false | nil) —

    Si la sesión del servidor subyacente está sucia. Si no existe ninguna sesión de servidor para esta sesión, devuelve nulo.

Desde:

  • 2.5.0



146
147
148
 
# Archivo 'lib/mongo/session.rb', línea 146

def dirty?
  @servidor_sesión&.dirty?
end

#end_session ⇒ nil

Finaliza esta sesión.

Si hay una transacción en curso en esta sesión, la transacción se aborta. La sesión del servidor asociada a esta sesión se devuelve al grupo de sesiones del servidor. Por último, esta sesión está marcada como finalizada y ya no se puede utilizar.

Si esta sesión ya ha finalizado, este método no hace nada.

Ten en cuenta que este método no emite directamente un comando endSessions a este servidor, contrario a lo que su nombre podría sugerir.

Ejemplos:

session.end_session

Devuelve:

  • (nil) —

    Siempre nulo.

Desde:

  • 2.5.0



377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
 
# Archivo 'lib/mongo/session.rb', línea 377

def fin_sesión
  si !¿terminado? && @cliente
    si within_states?(TRANSACTION_IN_PROGRESS_STATE)
      begin
        abortar_transacción
      rescate Mongo::Error, Error::AuthError
      end
    end
    si @servidor_sesión
      @cliente.clúster.session_pool.checkin(@servidor_sesión)
    end
  end
asegurar
  @servidor_sesión = nulo
  @se terminó = true
end

#¿terminó? ⇒ verdadero, falso

Si esta sesión ha finalizado.

Ejemplos:

session.ended?

Devuelve:

  • (verdadero,falso) —

    Si la sesión ha terminado.

Desde:

  • 2.5.0



243
244
245
 
# Archivo 'lib/mongo/session.rb', línea 243

def ¿terminado?
  !!@se terminó
end

#¿explícito? ⇒ true, false

¿Es esta una sesión explícita (es decir, creado por el usuario).

Ejemplos:

¿La sesión es explícita?

session.explicit?

Devuelve:

  • (verdadero,falso) —

    Si esta sesión es explícita.

Desde:

  • 2.5.2



178
179
180
 
# Archivo 'lib/mongo/session.rb', línea 178

def explicit?
  !implicit?
end

#¿implícito? ⇒ verdadero, falso

¿Esta sesión es implícita (no creada por el usuario)?.

Ejemplos:

¿La sesión es implícita?

session.implicit?

Devuelve:

  • (verdadero,falso) —

    Si esta sesión es implícita.

Desde:

  • 2.5.1



166
167
168
 
# Archivo 'lib/mongo/session.rb', línea 166

def implicit?
  @implicit ||= !!(@options.key?(:implicit) && @options[:implicit] == true)
end

#en_transacción? ⇒ verdadero | falso

Si la sesión está o no actualmente en una transacción.

Ejemplos:

¿Está la sesión en una transacción?

session.in_transaction?

Devuelve:

  • (true | false) —

    Si la sesión en una transacción se realiza o no.

Desde:

  • 2.6.0



803
804
805
 
# Archivo 'lib/mongo/session.rb', línea 803

def en_transacción?
  within_states?(STARTING_TRANSACTION_STATE, TRANSACTION_IN_PROGRESS_STATE)
end

#inspect ⇒ String

Obtenga una cadena formateada para usar en la inspección.

Ejemplos:

Inspecciona el objeto de sesión.

session.inspect

Devuelve:

  • (string) —

    La inspección de la sesión.

Desde:

  • 2.5.0



355
356
357
 
# Archivo 'lib/mongo/session.rb', línea 355

def inspeccionar
  "#<Mongo::Session:0x#{object_id} session_id=#{session_id} options=#{@options}>"
end

#materialize_if_needed ⇒ Sesión

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

Si aún no está configurado, rellena el server_session de los objetos de sesión obteniendo una sesión del grupo de sesiones.

Devuelve:

Desde:

  • 2.5.0



1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
 
# Archivo 'lib/mongo/session.rb', línea 1137

def materialize_if_needed
  si ¿terminado?
    propagar Error::Sesión finalizada
  end

  return a menos que implicit? && !@servidor_sesión

  @servidor_sesión = clúster.session_pool.checkout

  sí mismo
end

#¿materializado? ⇒ Booleano

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

Devuelve:

  • (booleano)

Desde:

  • 2.5.0



1150
1151
1152
1153
1154
1155
1156
 
# Archivo 'lib/mongo/session.rb', línea 1150

def ¿materializado?
  si ¿terminado?
    propagar Error::Sesión finalizada
  end

  !@servidor_sesión.nil?
end

#next_txn_num ⇒ Entero

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

Incrementa y devuelve el siguiente número de transacción.

Ejemplos:

Obtenga el próximo número de transacción.

session.next_txn_num

Devuelve:

  • (Número entero) —

    El siguiente número de transacción.

Desde:

  • 2.5.0



1167
1168
1169
1170
1171
1172
1173
 
# Archivo 'lib/mongo/session.rb', línea 1167

def next_txn_num
  si ¿terminado?
    propagar Error::Sesión finalizada
  end

  @servidor_sesión.next_txn_num
end

#pin_to_connection(id_global_de_conexión) ⇒ 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.

Fijar esta sesión en la conexión especificada.

esta sesión a.

Parámetros:

  • connection_global_id (Número entero) —

    El id global de la conexión para fijar

Desde:

  • 2.5.0



846
847
848
849
850
851
 
# Archivo 'lib/mongo/session.rb', línea 846

def pin_a_conexión(connection_global_id)
  si connection_global_id.nil?
    propagar ArgumentError, 'No se puede fijar en una id de conexión nula'
  end
  @pinned_connection_global_id = connection_global_id
end

#pin_to_server(servidor) ⇒ 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.

Ancla esta sesión al servidor especificado, que debería ser un mongos.

Parámetros:

  • Server (Servidor) —

    El servidor al que fijar esta sesión.

Desde:

  • 2.5.0



828
829
830
831
832
833
834
835
836
837
838
 
# Archivo 'lib/mongo/session.rb', línea 828

def pin_to_server(Server)
  si Server.nil?
    propagar ArgumentError, 'Nose puede anclar a un servidor nulo'
  end
  si Lint.¿habilitado?
    a menos que Server.mongos?
      propagar Error::LintError, "Intentó vincular la sesión al servidor #{servidor.resumen} que no es un mongos"
    end
  end
  @pinned_server = Server
end

#proceso(resultado) ⇒ Operación::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.

Procesar una respuesta del servidor que utilizó esta sesión.

Ejemplos:

Procesar una respuesta del servidor.

session.process(result)

Parámetros:

Devuelve:

Desde:

  • 2.5.0



1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
 
# Archivo 'lib/mongo/session.rb', línea 1095

def Proceso(Resultado)
  a menos que implicit?
    set_operation_time(Resultado)
    si cluster_time_doc = Resultado.cluster_time
      advance_cluster_time(cluster_time_doc)
    end
  end
  @servidor_sesión.set_last_use!

  si doc = Resultado.respuesta && Resultado.respuesta.Documentos.primero
    si doc[:recoveryToken]
      sí mismo.recovery_token = doc[:recoveryToken]
    end
  end

  Resultado
end

#reintentar_lecturas? ⇒ booleano

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

Si las lecturas ejecutadas con esta sesión se pueden reintentar de acuerdo con la especificación moderna de lecturas reintentables.

Si este método devuelve true, la aplicación ha solicitado las lecturas modernas reintentables. Si el servidor seleccionado para una operación de lectura admite lecturas modernas reintentables, se utilizarán para esa operación en particular. Si el servidor seleccionado para una operación de lectura no admite lecturas reintentables modernas, la lectura no se reintentará.

Si este método devuelve falso, la aplicación ha solicitado lecturas repetibles heredadas. La lógica heredada de lectura reintentable se utilizará independientemente de la versión del servidor al que esté conectado el cliente. El número de reintentos de lectura está determinado por la opción del cliente :max_read_retries, que por defecto es 1 y puede establecerse en 0 para desactivar los reintentos de lectura legados.

Devuelve:

  • (booleano)

Desde:

  • 2.5.0



198
199
200
 
# Archivo 'lib/mongo/session.rb', línea 198

def retry_reads?
  Cliente.opciones[:retry_reads] != false
end

#retry_writes? ⇒ verdadero, falso

Nota:

Las escrituras reintentables solo están disponibles en versiones de servidor de al menos 3.6 y con clústeres, sets de réplicas o topologías con balanceo de carga.

¿Se reintentarán los guardados ejecutados con esta sesión?

Ejemplos:

¿Se volverán a intentar los guardados?

session.retry_writes?

Devuelve:

  • (verdadero,falso) —

    Si se reintentarán los guardados.

Desde:

  • 2.5.0



213
214
215
 
# Archivo 'lib/mongo/session.rb', línea 213

def ¿retry_writes?
  !!Cliente.opciones[retry_writes] && (clúster.replica_set? || clúster.¿fragmentado? || clúster.¿carga equilibrada?)
end

#session_id ⇒ BSON::Document

Obtén el ID de sesión del servidor para esta sesión, si la sesión no se ha terminado. Si la sesión había terminado, genera Error::SessionEnded.

Devuelve:

  • (BSON::Document) —

    El id de la sesión del servidor.

Aumenta:

  • (Error::Sesiónfinalizada) —

    Si la sesión hubiera terminado.

Desde:

  • 2.5.0



255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
 
# Archivo 'lib/mongo/session.rb', línea 255

def session_id
  si ¿terminado?
    propagar Error::Sesión finalizada
  end

  # Una sesión explícita siempre tendrá un session_id, porque durante
  # construcción Se debe proporcionar una sesión de servidor. Una sesión implícita
  # no tendría un session_id hasta materializarse, por lo tanto las llamadas a
  # session_id podría fallar. Una aplicación no debería tener la oportunidad
  # experimentar este fallo porque una sesión implícita no debería ser
  # accesible a las aplicaciones debido a que su tiempo de vida está restringido a
  # ejecución de la operación, que se realiza íntegramente por el driver.
  a menos que ¿materializado?
    propagar Error::Sesión no materializada
  end

  @servidor_sesión.session_id
end

#snapshot? ⇒ true | false

Devuelve si la sesión está configurada para lecturas de snapshot.

Devuelve:

  • (true | false) —

    Si la sesión está configurada para lecturas de instantáneas.

Desde:

  • 2.5.0



124
125
126
 
# Archivo 'lib/mongo/session.rb', línea 124

def ¿instantánea?
  !!opciones[snapshot]
end

#start_transaction(opciones = nulo) ⇒ Objeto

Ubica las operaciones posteriores en esta sesión en una nueva transacción.

Tenga en cuenta que la transacción no se iniciará en el servidor hasta que se realice una operación después de llamar a start_transaction.

Ejemplos:

Inicia una nueva transacción

session.start_transaction(options)

Parámetros:

  • opciones (Hash) (predeterminado: nulo) —

    Las opciones para la transacción que se está iniciando.

Opciones Hash (options):

  • :tiempo máximo de confirmación_ms (Entero) —

    El tiempo máximo permitido para que se ejecute un solo comando commitTransaction, en milisegundos. Esta opción está obsoleta, use :timeout_ms en su lugar.

  • :read_concern (Hash) —

    El hash de opciones de lectura se refiere a, con las siguientes claves opcionales:

    • :level: el nivel de preferencia de lectura como símbolo; valores válidos

      are *:local*, *:majority*, and *:snapshot*
  • :escribir_preocupación (Hash) —

    Las opciones de nivel de confirmación de escritura (write concern). Puede ser :w => Integer | String, :fsync => booleano, :j => booleano.

  • :leer (Hash) —

    Las opciones de preferencia de lectura. El hash puede tener los siguientes elementos:

    • :mode – preferencia de lectura especificada como un símbolo; el único valor válido es:primary.

  • :timeout_ms (Entero) —

    El tiempo de espera de la operación en milisegundos. Debe ser un número entero no negativo. Un valor explícito de 0 significa infinito. El valor por defecto no está definido, lo que significa que se hereda del cliente.

Aumenta:

Desde:

  • 2.6.0



583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
 
# Archivo 'lib/mongo/session.rb', línea 583

def iniciar_transacción(opciones = nulo)
  ¡Verifique que las transacciones sean compatibles!

  si opciones
    Lint.validate_read_concern_option(opciones[:read_concern])

=begin
    # Sería útil detectar preferencias de lectura no válidas aquí, pero
    # algunas de las pruebas de especificaciones requieren una detección posterior de preferencias de lectura inválidas.
    # Quizá podamos hacer esto cuando el modo lint esté activado.
    mode = options[:read] && options[:read][:mode].to_s
    if mode && mode != 'primary'
      raise Mongo::Error::InvalidTransactionOperation.new(
        "la preferencia de lectura en una transacción debe ser primaria (se solicitó: #{mode})"
      )
    end
=end
  end

  si ¿instantánea?
    propagar Mongo::Error::SnapshotSessionTransactionProhibited
  end

  check_if_ended!

  si within_states?(STARTING_TRANSACTION_STATE, TRANSACTION_IN_PROGRESS_STATE)
    propagar Mongo::Error::OperaciónTransacciónInválida.Nuevo(
      Mongo::Error::OperaciónTransacciónInválida::TRANSACCIÓN YA EN CURSO)
  end

  unpin

  next_txn_num
  @txn_options = (@options[:default_transaction_options] || {}).fusionar(opciones || {})

  si txn_write_concern && !Nivel de confirmación de escritura (write concern).Obtener(txn_write_concern).¿entendido?
    propagar Mongo::Error::OperaciónTransacciónInválida.Nuevo(
      Mongo::Error::OperaciónTransacciónInválida::UNACKNOWLEDGED_WRITE_CONCERN)
  end

  @state = STARTING_TRANSACTION_STATE
  @ya_comprometido = false

  # Este método no tiene un valor de retorno explícito.
  # Aquí podríamos devolver nil, pero true indica al usuario que el
  # operación exitosa. Esto está destinado al uso interactivo.
  # Tenga en cuenta que el valor de retorno no está documentado.
  true
end

#transacción_inicial? ⇒ Booleano

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

Devuelve:

  • (booleano)

Desde:

  • 2.5.0



791
792
793
 
# Archivo 'lib/mongo/session.rb', línea 791

def ¿transacción_inicial?
  within_states?(STARTING_TRANSACTION_STATE)
end

#suppress_read_write_concern!(comando) ⇒ Hash, BSON::Document

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

Elimine la preocupación de lectura y/o la preocupación de escritura del comando si no corresponde.

Ejemplos:

session.suppress_read_write_concern!(cmd)

Devuelve:

  • (Hash, BSON::Documento) —

    El documento de comando.

Desde:

  • 2.6.0



1020
1021
1022
1023
1024
1025
1026
1027
 
# Archivo 'lib/mongo/session.rb', línea 1020

def suprimir_nivel_lectura_escritura!(Comando)
  Comando.tocar hacer |C|
    siguiente a menos que en_transacción?

    C.borrar(:leerPreocupación) a menos que ¿transacción_inicial?
    C.borrar(:writeConcern) a menos que C[:commitTransaction] || C[abortTransaction]
  end
end

#txn_num ⇒ Integer

Obtén el número de transacción actual.

Ejemplos:

Obtén el número de transacción actual.

session.txn_num

Devuelve:

  • (Número entero) —

    El número de transacción actual.

Desde:

  • 2.6.0



1183
1184
1185
1186
1187
1188
1189
 
# Archivo 'lib/mongo/session.rb', línea 1183

def txn_num
  si ¿terminado?
    propagar Error::Sesión finalizada
  end

  @servidor_sesión.txn_num
end

#txn_options ⇒ Hash

en esta sesión.

Devuelve:

  • (encriptada) —

    Las opciones para la transacción que se está ejecutando actualmente

Desde:

  • 2.6.0



154
155
156
 
# Archivo 'lib/mongo/session.rb', línea 154

def txn_options
  @txn_options or propagar ArgumentError, "No hay ninguna transacción activa"
end

#txn_read_preference ⇒ Hash

Obtenga la preferencia de lectura que la sesión usará en la transacción actualmente activa.

Esto es un hash de estilo de controlador con claves de guion bajo.

Ejemplos:

Obtener la preferencia de lectura de la transacción

session.txn_read_preference

Devuelve:

  • (encriptada) —

    La preferencia de lectura de la transacción.

Desde:

  • 2.6.0



228
229
230
231
232
233
 
# Archivo 'lib/mongo/session.rb', línea 228

def preferencia_de_lectura_txn
  rp = txn_options[:leer] ||
    @cliente.read_preference
  Mongo::Lint.validar_preferencia_de_lectura_de_subrayado(rp)
  rp
end

#desanclar(conexión = nula) ⇒ 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.

Desancla esta sesión del servidor o conexión anclada, si la sesión estaba anclada.

Parámetros:

  • Conexión (Conexión | nil) (predeterminado: nulo) —

    Conexión para desanclar.

Desde:

  • 2.5.0



859
860
861
862
863
 
# Archivo 'lib/mongo/session.rb', línea 859

def unpin(Conexión = nulo)
  @pinned_server = nulo
  @pinned_connection_global_id = nulo
  Conexión.unpin a menos que Conexión.nil?
end

#unpin_maybe(error, conexión = nil) ⇒ 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.

Desancla esta sesión del servidor o conexión anclada, si la sesión estaba anclada y la instancia de excepción especificada y el estado de transacción de la sesión requieren que se desanclen.

La instancia de excepción ya debería tener todas las etiquetas establecidas (tanto las generadas por el cliente como las generadas por el servidor).

Parámetros:

  • Error (Error) -

    La instancia de excepción para procesar.

  • Conexión (Conexión | nil) (predeterminado: nulo) —

    Conexión para desanclar.

Desde:

  • 2.5.0



876
877
878
879
880
881
882
883
884
885
886
887
888
 
# Archivo 'lib/mongo/session.rb', línea 876

def desanclar_posiblemente(Error, Conexión = nulo)
  si !within_states?(sesión::NO_TRANSACTION_STATE) &&
    Error.¿etiqueta?('TransientTransactionError')
  entonces
    unpin(Conexión)
  end

  si guardando_transacción? &&
    Error.¿etiqueta?('UnknownTransactionCommitResult')
  entonces
    unpin(Conexión)
  end
end

#update_state! ⇒ Object

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

Actualiza el estado de la sesión debido a la ejecución de una operación (ni confirmación ni abortar).

Desde:

  • 2.6.0



1056
1057
1058
1059
1060
1061
1062
1063
 
# Archivo 'lib/mongo/session.rb', línea 1056

def update_state!
  caso @state
  Cuando STARTING_TRANSACTION_STATE
    @state = TRANSACTION_IN_PROGRESS_STATE
  Cuando ESTADO DE TRANSACCIÓN COMPROMETIDA, TRANSACTION_ABORTED_STATE
    @state = NO_TRANSACTION_STATE
  end
end

#validate!(client) ⇒ Session

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

Valida la sesión para que la use el cliente especificado.

La sesión no debe terminarse y debe haber sido creada por un cliente que pertenezca al mismo clúster que el cliente con el que se va a usar la sesión.

Parámetros:

  • Cliente (cliente) —

    El cliente con el que debe usarse la sesión.

Devuelve:

  • (Sesión) —

    yo, si la sesión es válida.

Aumenta:

Desde:

  • 2.5.0



1078
1079
1080
1081
1082
 
# Archivo 'lib/mongo/session.rb', línea 1078

def validate!(Cliente)
  check_matching_cluster!(Cliente)
  check_if_ended!
  sí mismo
end

#validate_read_preference!(comando) ⇒ 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.

Asegúrese de que la preferencia de lectura de un comando sea primaria.

Ejemplos:

session.validate_read_preference!(command)

Aumenta:

Desde:

  • 2.6.0



1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
 
# Archivo 'lib/mongo/session.rb', línea 1039

def validate_read_preference!(Comando)
  return a menos que en_transacción?
  return a menos que Comando['$readPreference']

  moda = Comando['$readPreference']['mode'] || Comando['$readPreference'][moda]

  si moda && moda != 'primario '
    propagar Mongo::Error::OperaciónTransacciónInválida.Nuevo(
      "la preferencia de lectura en una transacción debe ser primaria (solicitada: #{modo})"
    )
  end
end

#with_transaction(opciones = nil) ⇒ Objeto

Nota:

with_transaction contiene un bucle, por lo tanto, si with_transaction en sí mismo se coloca en un bucle, su bloque no debe llamar a siguiente o break para controlar el bucle externo porque esto, en cambio, afectará al bucle en with_transaction. El controlador advertirá y abortará la transacción si detecta esta situación.

Ejecuta el bloque proporcionado en una transacción y vuelve a intentarlo según sea necesario.

Devuelve el valor de retorno del bloque.

El número exacto de reintentos y cuándo se realizan son detalles de implementación del controlador; el bloque proporcionado debe ser idempotente y debe estar preparado para ser llamado más de una vez. El driver puede reintentar el comando de confirmación dentro de una transacción activa o puede repetir la transacción e invocar el bloque nuevamente, dependiendo del error encontrado, si lo hubiera. Tenga en cuenta también que los reintentos pueden ejecutarse contra diferentes servidores.

Las transacciones no se pueden anidar: se generará InvalidTransactionOperation si se llama a este método cuando la sesión ya tiene una transacción activa.

Las excepciones generadas por el bloque que no derivan de Mongo::Error detienen el procesamiento, cancelan la transacción y se propagan fuera de with_transaction. Las excepciones derivadas de Mongo::Error pueden ser gestionadas por with_transaction, resultando en reintentos del proceso.

Actualmente, with_transaction reintentará las confirmaciones y bloqueará las invocaciones hasta que transcurran al menos 120 segundos desde que se inició la ejecución. Este tiempo de espera no es configurable y podría cambiar en una futura versión del controlador.

Ejemplos:

Ejecución de una instrucción en una transacción

session.with_transaction(write_concern: {w: :majority}) do
  collection.update_one({ id: 3 }, { '$set' => { status: 'Inactive'} },
                        session: session)

end

Ejecuta una instrucción en una transacción, limitando el tiempo total consumido

Timeout.timeout(5) do
  session.with_transaction(write_concern: {w: :majority}) do
    collection.update_one({ id: 3 }, { '$set' => { status: 'Inactive'} },
                          session: session)

  end
end

Parámetros:

  • opciones (Hash) (predeterminado: nulo) —

    Las opciones para la transacción que se está iniciando. Son las mismas que acepta start_transaction.

Aumenta:

Desde:

  • 2.7.0



448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
 
# Archivo 'lib/mongo/session.rb', línea 448

def con_transacción(opciones = nulo)
  si timeout_ms = (opciones || {})[:timeout_ms]
    tiempo_límite_seg = timeout_ms / 1_000.0
    fecha límite = Utils.monotonic_time + tiempo_límite_seg
    @with_transaction_deadline = fecha límite
  elsif default_timeout_ms = @options[:default_timeout_ms]
    tiempo_límite_seg = default_timeout_ms / 1_000.0
    fecha límite = Utils.monotonic_time + tiempo_límite_seg
    @with_transaction_deadline = fecha límite
  elsif @cliente.tiempo_límite_seg
    fecha límite = Utils.monotonic_time + @cliente.tiempo_límite_seg
    @with_transaction_deadline = fecha límite
  else
    fecha límite = Utils.monotonic_time + 120
  end
  operación en curso = false
  bucle hacer
    opciones de confirmación = {}
    si opciones
      opciones de confirmación[:escribir_preocupación] = opciones[:escribir_preocupación]
    end
    iniciar_transacción(opciones)
    operación en curso = true
    begin
      rv = rendimiento sí mismo
    rescate Excepción => e
      si within_states?(STARTING_TRANSACTION_STATE, TRANSACTION_IN_PROGRESS_STATE)
        advertencia de registro("Abortandotransacción debido a #{e.class}: #{e}")
        @with_transaction_deadline = nulo
        abortar_transacción
        operación en curso = false
      end

      si Utils.monotonic_time >= fecha límite
        operación en curso = false
        propagar
      end

      si e.is_a?(Mongo::Error) && e.¿etiqueta?('TransientTransactionError')
        siguiente
      end

      propagar
    else
      si within_states?(TRANSACTION_ABORTED_STATE, NO_TRANSACTION_STATE, ESTADO DE TRANSACCIÓN COMPROMETIDA)
        operación en curso = false
        return rv
      end

      begin
        commit_transaction(opciones de confirmación)
        operación en curso = false
        return rv
      rescate Mongo::Error => e
        si e.¿etiqueta?('UnknownTransactionCommitResult')
          si Utils.monotonic_time >= fecha límite ||
            e.is_a?(Error::OperationFailure::Familia) && e.¿max_time_ms_expired?
          entonces
            operación en curso = false
            propagar
          end
          wc_options = caso v = opciones de confirmación[:escribir_preocupación]
            Cuando Nivel de confirmación de escritura (write concern)::Base
              v.opciones
            Cuando nulo
              {}
            else
              v
            end
          opciones de confirmación[:escribir_preocupación] = wc_options.fusionar(w: mayoría)
          reintentar
        elsif e.¿etiqueta?('TransientTransactionError')
          si Utils.monotonic_time >= fecha límite
            operación en curso = false
            propagar
          end
          @state = NO_TRANSACTION_STATE
          siguiente
        else
          operación en curso = false
          propagar
        end
      rescate Error::AuthError
        operación en curso = false
        propagar
      end
    end
  end

  # No hay valor de retorno oficial, pero devuelve verdadero para que en la interacción
  # utilice el método para indicar que tuvo éxito.
  true
asegurar
  si operación en curso
    advertencia de registro('La función de retorno with_transaction salió del bucle with_transaction, abortando la transacción')
    begin
      abortar_transacción
    rescate Error::OperationFailure::Familia, Error::OperaciónTransacciónInválida
    end
  end
  @with_transaction_deadline = nulo
end