Clase: Mongo::Session

Hereda:
Objeto
  • Objeto
Mostrar todo
Ampliado por:
Reenviable
Incluye:
ClusterTime::Consumer, Registrable, Reintentable
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 solo puede usar una sesión de un subproceso 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 en el espacio de nombres

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 esa' +
del cliente propietario de esta operación. Utilice 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 utilizar porque ya ha finalizado.

Desde:

  • 2.5.0

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

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

Desde:

  • 2.5.0

'Las sesiones no son compatibles con los servidores conectados.'.freeze
SIN_ESTADO_DE_TRANSACCIÓN =

El estado de una sesión en la que la última operación no estuvo relacionada con ninguna transacción o aún no se han producido operaciones.

Desde:

  • 2.6.0

:sin_transacción
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 producido operaciones dentro de las transacciones.

Desde:

  • 2.6.0

:transacción_inicial
ESTADO DE TRANSACCIÓN EN CURSO =

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 cancelado.

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
ESTADO DE TRANSACCIÓN ABORTADA =

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

:transacción_abortada
CÓDIGOS DE PREOCUPACIÓN DE ESCRITURA SIN ETIQUETA =

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,  # Preocupación desconocida de escritura de respuesta
  100, # No se puede satisfacer la preocupación de escritura,
].freeze

Constantes incluidas desde Loggable

Registrable::PREFIX

Colapso delresumen de atributos de instancia

Atributos incluidos de ClusterTime::Consumer

#cluster_time

Colapso del resumen del método de instancia

Métodos incluidos desde ClusterTime::Consumer

#tiempo_de_avanzado_del_cluster

Métodos incluidos en Loggable

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

Métodos incluidos en Retryable

#trabajador_de_lectura, #servidor_de_selección, #trabajador_de_escritura

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 usar Client#start_session para iniciar una sesión. Este constructor es solo para uso interno del controlador.

Inicializar 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.

Al crear una sesión implícita, no puede tener una sesión de servidor asociada. La sesión de servidor se extraerá del grupo de sesiones cuando se ejecute una operación que la utilice. Al crear una sesión explícita, debe hacer referencia a una sesión de servidor ya asignada.

Parámetros:

  • sesión_del_servidor (Sesiónde servidor | nulo) —

    La sesión del servidor a la que está asociada esta sesión. Si la opción :implicit es verdadera, debe ser nula.

  • Cliente (Cliente) -

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

  • opciones (Hash) (predeterminado: {}) —

    Las opciones para esta sesión.

Opciones Hash(opciones):

  • :consistencia_causal (verdadero|falso) —

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

  • :tiempo de espera predeterminado_ms (Entero) —

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

    • commitTransaction

    • abortarTransacción

    • conTransacción

    • endSession

  • :opciones_de_transacción_predeterminadas (Hash) —

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

  • :implicit (verdadero|falso) —

    Solo para uso interno del controlador: especifica si la sesión es implícita. Si es verdadera, server_session será nula. Esto se hace para que la sesión del servidor solo se desconecte después de desconectar 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.

  • :instantánea (true | false) —

    Configurar la sesión para lecturas de instantáneas.

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[:instantánea]
    propagar ArgumentError, 'Las opciones :causal_consistency y :snapshot no se pueden configurar ambas en una sesión'
  end

  Si opciones[:implicit]
    a no ser 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.uso(:administración)
  @opciones = opciones.dup.freeze
  @cluster_time = nulo
  @estado = SIN ESTADO DE TRANSACCIÓN
  @con fecha límite de transacción = 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) —

    La última hora de operación vista 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:

  • (Hash) —

    Las opciones para esta sesión.

Desde:

  • 2.5.0



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

def opciones
  @opciones
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 está anclada esta sesión, si existe alguno.

Desde:

  • 2.5.0



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

def pinned_connection_global_id
  @conexión fijada_id_global
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 debe ser un mongos) al que está anclada esta sesión, si hay alguno.

Devuelve:

  • (Server | nil) —

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

Desde:

  • 2.5.0



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

def servidor fijado
  @servidor_fijado
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 ejecuta en esta sesión, si la hay.

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 token de recuperación
  @token_de_recuperación
end

#snapshot_timestamp ⇒ 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.

Desde:

  • 2.5.0



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

def marca de tiempo de la instantánea
  @snapshot_timestamp
end

#with_transaction_deadline ⇒ Objeto (solo lectura)

Desde:

  • 2.5.0



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

def con fecha límite de transacción
  @con fecha límite de transacción
end

Detalles del método de instancia

#abort_transaction(opciones = nulo) ⇒ Objeto

Abortar la transacción actualmente activa 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(opciones):

  • :tiempo de espera_ms (Entero) —

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

Aumentos:

  • (Error::Operaciónde transacción no válida) —

    Si no hay ninguna transacción activa.

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

  ¡comprobar si terminó!
  check_if_no_transaction!

  Si ¿dentro_de_los_estados?(ESTADO DE TRANSACCIÓN COMPROMETIDA)
    propagar Mongo::Error::Operación de transacción no válida.Nuevo(
      Mongo::Error::Operación de transacción no válida.cannot_call_after_msg(
        :confirmarTransacción, :abortarTransacción))
  end

  Si ¿dentro_de_los_estados?(ESTADO DE TRANSACCIÓN ABORTADA)
    propagar Mongo::Error::Operación de transacción no válida.Nuevo(
      Mongo::Error::Operación de transacción no válida.mensaje no se puede llamar dos veces(:abortarTransacción))
  end

  opciones ||= {}

  begin
    a no ser que ¿transacción_inicial?
      @aborting_transaction = true
      context = Operación::Context.Nuevo(
        cliente: @cliente,
        sesión: yo,
        tiempos de espera de operación: tiempos de espera de operación(opciones)
      )
      escribir_con_reintentar(opciones_txn[:escribir_preocupación],
        transacción_final: true, context: context,
      ) hacer |conexión, txn_num, context|
        begin
          Operación::Comando.Nuevo(
            selector: { abortarTransacción: 1 },
            nombre_base_datos: 'administrador',
            sesión: yo,
            txn_num: txn_num
          ).ejecutar_con_conexión(conexión, context: context)
        asegurar
          unpin
        end
      end
    end

    @estado = ESTADO DE TRANSACCIÓN ABORTADA
  rescate Mongo::Error::Operación de transacción no válida
    propagar
  rescate Mongo::Error
    @estado = ESTADO DE TRANSACCIÓN ABORTADA
  rescate Excepción
    @estado = ESTADO DE TRANSACCIÓN ABORTADA
    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

#¿abortando_transacción? ⇒ 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.

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

Devuelve:

  • (verdadero | falso) —

    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 ¿abortando_transacción?
  !!@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.

Agregue el campo de confirmación automática 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.grifo hacer |C|
    C[:autocommit] = false Si ¿en_transacción?
  end
end

#¡add_start_transaction!(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.

Agregue el campo startTransaction a un documento de comando si corresponde.

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 ¡añadir_inicio_transacción!(Comando)
  Comando.grifo hacer |C|
    Si ¿transacción_inicial?
      C[:iniciarTransacción] = 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.

Agregue 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.grifo hacer |C|
    C[:txnNúmero] = BSON::Entero64.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 ¡añadir_txn_opts!(Comando, Lea, context)
  Comando.grifo hacer |C|
    # La preocupación de lectura debe agregarse a cualquier comando que inicie una transacción.
    Si ¿transacción_inicial?
      # https://jira.mongodb.org/browse/SPEC-1161: transacción
      # La preocupación de lectura anula las preocupaciones de lectura de colección/base de datos/cliente,
      # incluso si la preocupación de lectura de la transacción no está establecida.
      # Lea la preocupación aquí es la que se envía al servidor y puede
      # incluir afterClusterTime.
      Si rc = C[:leerPreocupación]
        rc = rc.dup
        rc.borrar(:nivel)
      end
      Si preocupación de lectura de txn
        Si rc
          rc.update(preocupación de lectura de txn)
        else
          rc = preocupación de lectura de txn.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[:confirmarTransacción]
      Si tiempo máximo_ms = opciones_txn[:tiempo máximo de confirmación_ms]
        C[:tiempo máximo MS] = tiempo máximo_ms
      end
    end

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

    # Una preocupación de escritura no numérica cuyo valor w debe enviarse como una cadena 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].a_s
    end

    # Ignore wtimeout if csot
    Si context&.csot?
      C[:writeConcern]&.borrar(:tiempo de espera)
    end

    # No debemos enviar una preocupación de escritura vacía (predeterminada 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 tiempo de operación en caché para esta sesión.

Ejemplos:

Adelantar el tiempo de operación.

session.advance_operation_time(timestamp)

Parámetros:

  • nuevo_tiempo_de_operación (BSON::Timestamp) —

    El nuevo tiempo de operación.

Devuelve:

  • (BSON::Timestamp) —

    El tiempo máximo de funcionamiento, considerando el horario actual y el nuevo.

Desde:

  • 2.5.0



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

def tiempo_de_operación_avanzada(nuevo_tiempo_de_operación)
  Si @tiempo_de_operación
    @tiempo_de_operación = [ @tiempo_de_operación, nuevo_tiempo_de_operación ].máximo
  else
    @tiempo_de_operación = nuevo_tiempo_de_operación
  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 = nulo) ⇒ Objeto

Confirmar la transacción actualmente activa 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(opciones):

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

    La escritura se refiere a utilizar para esta operación.

  • :tiempo de espera_ms (Entero) —

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

Aumentos:

  • (Error::Operaciónde transacción no válida) —

    Si no hay ninguna transacción activa.

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 transacción de confirmación(opciones=nulo)
  Caché de consultas.borrar
  ¡comprobar si terminó!
  check_if_no_transaction!

  Si ¿dentro_de_los_estados?(ESTADO DE TRANSACCIÓN ABORTADA)
    propagar Mongo::Error::Operación de transacción no válida.Nuevo(
      Mongo::Error::Operación de transacción no válida.cannot_call_after_msg(
        :abortarTransacción, :confirmarTransacción))
  end

  opciones ||= {}

  begin
    # Si se llama a commitTransaction dos veces, debemos ejecutar la misma confirmación
    # operación nuevamente, por lo que revertimos la sesión al estado anterior.
    Si ¿dentro_de_los_estados?(ESTADO DE TRANSACCIÓN COMPROMETIDA)
      @estado = @last_commit_skipped ? STARTING_TRANSACTION_STATE : ESTADO DE TRANSACCIÓN EN CURSO
      @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] || opciones_txn[:escribir_preocupación]
      Si escribir_preocupación && !escribir_preocupación.is_a?(Escribir preocupación::Base)
        escribir_preocupación = Escribir preocupación.Obtener(escribir_preocupación)
      end

      context = Operación::Context.Nuevo(
        cliente: @cliente,
        sesión: yo,
        tiempos de espera de operación: tiempos de espera de operación(opciones)
      )
      escribir_con_reintentar(escribir_preocupación, transacción_final: true,
        context: context,
      ) hacer |conexión, txn_num, context|
        Si context.¿rever?
          Si escribir_preocupación
            oma = escribir_preocupación.opciones.unir(w: :mayoría)
            oma[:tiempo de espera] ||= 10000
            escribir_preocupación = Escribir preocupación.Obtener(oma)
          else
            escribir_preocupación = Escribir preocupación.Obtener(w: :mayoría, wtimeout: 10000)
          end
        end
        especulación = {
          selector: { confirmarTransacción: 1 },
          nombre_base_datos: 'administrador',
          sesión: yo,
          txn_num: txn_num,
          escribir_preocupación: escribir_preocupación,
        }
        Operación::Comando.Nuevo(especulación).ejecutar_con_conexión(conexión, context: context)
      end
    end
  asegurar
    @estado = 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

#¿confirmando_transacción? ⇒ 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.

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

Devuelve:

  • (verdadero | falso) —

    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 ¿confirmando_transacción?
  !!@transacción_comprometida
end

#¡sucio!(marca = verdadero) ⇒ Objeto

Establece el estado "sucio" en el valor dado para la sesión del servidor subyacente. Si no hay sesión, no se realiza ningún cambio.

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

#¿sucio? ⇒ verdadero | falso | nulo

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

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

Devuelve:

  • (verdadero | falso | nulo) —

    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

Finalizar esta sesión.

Si hay una transacción en curso en esta sesión, se cancela. La sesión de servidor asociada se devuelve al grupo de sesiones de servidor. Finalmente, la sesión se marca como finalizada y ya no se puede utilizar.

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

Tenga en cuenta que este método no emite directamente un comando endSessions a este servidor, contrariamente 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 !¿Terminó? && @cliente
    Si ¿dentro_de_los_estados?(ESTADO DE TRANSACCIÓN EN CURSO)
      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
  @finalizado = true
end

#¿terminó? ⇒ verdadero, falso

Si esta sesión ha finalizado.

Ejemplos:

session.ended?

Devuelve:

  • (verdadero,falso) —

    Si la sesión ha finalizado.

Desde:

  • 2.5.0



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

def ¿Terminó?
  !!@finalizado
end

#¿explícito? ⇒ true, false

¿Esta sesión es explícita (es decir, creada 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 ||= !!(@opciones.key?(:implicit) && @opciones[:implicit] == true)
end

#en_transacción? ⇒ verdadero | falso

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

Ejemplos:

¿La sesión está en una transacción?

session.in_transaction?

Devuelve:

  • (verdadero | falso) —

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

Desde:

  • 2.6.0



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

def ¿en_transacción?
  ¿dentro_de_los_estados?(STARTING_TRANSACTION_STATE, ESTADO DE TRANSACCIÓN EN CURSO)
end

#inspeccionar ⇒ Cadena

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

Ejemplos:

Inspeccionar el objeto de sesión.

session.inspect

Devuelve:

  • (Cadena) -

    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#{id_objeto} id_sesión=#{id_sesión} opciones=#{@opciones}>"
end

#materializar_si_es_necesario ⇒ 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, complete el server_session de un objeto de sesión extrayendo 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 materializarse_si_es_necesario
  Si ¿Terminó?
    propagar Error::Sesión finalizada
  end

  return a no ser que implicit? && !@servidor_sesión

  @servidor_sesión = clúster.session_pool.pago y envío

  yo
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 ¿Terminó?
    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:

  • (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 siguiente_transacción_num
  Si ¿Terminó?
    propagar Error::Sesión finalizada
  end

  @servidor_sesión.siguiente_transacción_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.

Fija esta sesión a la conexión especificada.

Esta sesión también.

Parámetros:

  • id_global_de_conexión (Entero) —

    El identificador global de la conexión al pin

Desde:

  • 2.5.0



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

def pin_a_conexión(id_global_de_conexión)
  Si id_global_de_conexión.nil?
    propagar ArgumentError, 'Nose puede anclar a un ID de conexión nulo'
  end
  @conexión fijada_id_global = id_global_de_conexión
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_al_servidor(Server)
  Si Server.nil?
    propagar ArgumentError, 'Nose puede anclar a un servidor nulo'
  end
  Si Lint.¿activado?
    a no ser que Server.mongos?
      propagar Error::LintError, "Seintentó anclar la sesión al servidor #{server.summary} que no es unmongos"
    end
  end
  @servidor_fijado = 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:

  • resultado (Operación::Resultado) —

    El resultado de la operación.

Devuelve:

  • (Operación::Resultado) —

    El resultado.

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 no ser que implicit?
    establecer_tiempo_de_operación(resultado)
    Si cluster_time_doc = resultado.cluster_time
      avance_del_tiempo_del_cluster(cluster_time_doc)
    end
  end
  @servidor_sesión.set_last_use!

  Si doc = resultado.respuesta && resultado.respuesta.Documentos.primera
    Si doc[:recoveryToken]
      yo.token de recuperación = doc[:recoveryToken]
    end
  end

  resultado
end

#retry_reads? ⇒ 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 volver a intentar de acuerdo con la especificación moderna de lecturas reintentables.

Si este método devuelve verdadero, 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 modernas reintentables, la lectura no se reintentará.

Si este método devuelve falso, la aplicación ha solicitado lecturas reintentables heredadas. Se utilizará la lógica de lecturas reintentables heredadas independientemente de la versión del servidor al que esté conectado el cliente. El número de reintentos de lectura se indica mediante la opción de cliente :max_read_retries, que es 1 por defecto y se puede configurar en 0 para deshabilitar las lecturas reintentadas heredadas.

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 al menos 3.6 y con clústeres fragmentados, conjuntos de réplicas o topologías con equilibrio de carga.

¿Se volverán a intentar las escrituras ejecutadas con esta sesión?

Ejemplos:

¿Se volverán a intentar las escrituras?

session.retry_writes?

Devuelve:

  • (verdadero,falso) —

    Si se vuelve a intentar escribir, se volverá a intentar.

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

Obtiene el ID de la sesión del servidor si esta no ha finalizado. Si ya se ha finalizado, se genera el error Error::SessionEnded.

Devuelve:

  • (BSON::Documento) —

    El identificador de sesión del servidor.

Aumentos:

  • (Error::Sesiónfinalizada) —

    Si la sesión hubiera finalizado.

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 id de sesión
  Si ¿Terminó?
    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á un session_id hasta que se materialice, 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 para las aplicaciones debido a que su vida útil está restringida a
  # ejecución de la operación, que es realizada íntegramente por el controlador.
  a no ser que ¿materializado?
    propagar Error::Sesión no materializada
  end

  @servidor_sesión.id de sesión
end

#instantánea? ⇒ verdadero | falso

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

Devuelve:

  • (verdadero | falso) —

    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[:instantánea]
end

#start_transaction(opciones = nulo) ⇒ Objeto

Coloca 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:

Iniciar 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(opciones):

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

    El tiempo máximo que se permite ejecutar un comando commitTransaction, en milisegundos. Esta opción está obsoleta; utilice :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 escritura pueden ser: :w => Entero|Cadena, :fsync => Booleano, :j => Booleano.

  • :leer (Hash) —

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

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

  • :tiempo de espera_ms (Entero) —

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

Aumentos:

  • (Error::Operaciónde transacción no válida) —

    Si ya hay una transacción en curso o si no se reconoce el problema de escritura.

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ás podamos hacer esto cuando el modo pelusa esté activado.
    modo = opciones[:leer] && opciones[:leer][:modo].to_s
    si modo && modo != 'primario'
      raise Mongo::Error::InvalidTransactionOperation.new(
        "La preferencia de lectura en una transacción debe ser principal (solicitado: #{mode})"
      )
    end
=end
  end

  Si ¿instantánea?
    propagar Mongo::Error::Transacción de sesión de instantánea prohibida
  end

  ¡comprobar si terminó!

  Si ¿dentro_de_los_estados?(STARTING_TRANSACTION_STATE, ESTADO DE TRANSACCIÓN EN CURSO)
    propagar Mongo::Error::Operación de transacción no válida.Nuevo(
      Mongo::Error::Operación de transacción no válida::TRANSACCIÓN YA EN CURSO)
  end

  unpin

  siguiente_transacción_num
  @txn_options = (@opciones[:opciones_de_transacción_predeterminadas] || {}).unir(opciones || {})

  Si preocupación de escritura de transacción && !Escribir preocupación.Obtener(preocupación de escritura de transacción).¿admitido?
    propagar Mongo::Error::Operación de transacción no válida.Nuevo(
      Mongo::Error::Operación de transacción no válida::PREOCUPACIÓN DE ESCRITURA NO RECONOCIDA)
  end

  @estado = STARTING_TRANSACTION_STATE
  @ya_comprometido = false

  # Este método no tiene un valor de retorno explícito.
  # Podríamos devolver nil aquí, pero true indica al usuario que el
  # Operación exitosa. Este código está diseñado para 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?
  ¿dentro_de_los_estados?(STARTING_TRANSACTION_STATE)
end

#¡Suprimir preocupación por lecturay escritura! (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.

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 la preocupación de lectura y escritura!(Comando)
  Comando.grifo hacer |C|
    siguiente a no ser que ¿en_transacción?

    C.borrar(:leerPreocupación) a no ser que ¿transacción_inicial?
    C.borrar(:writeConcern) a no ser que C[:confirmarTransacción] || C[:abortarTransacción]
  end
end

#txn_num ⇒ Integer

Obtenga el número de transacción actual.

Ejemplos:

Obtenga el número de transacción actual.

session.txn_num

Devuelve:

  • (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 ¿Terminó?
    propagar Error::Sesión finalizada
  end

  @servidor_sesión.txn_num
end

#txn_options ⇒ Hash

en esta sesión.

Devuelve:

  • (Hash) —

    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 opciones_txn
  @txn_options or propagar ArgumentError, "Nohay ninguna transacciónactiva"
end

#txn_read_preference ⇒ Hash

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

Este es un hash de estilo controlador con teclas de subrayado.

Ejemplos:

Obtener la preferencia de lectura de la transacción

session.txn_read_preference

Devuelve:

  • (Hash) —

    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 de txn
  rp = opciones_txn[: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 | nula) (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)
  @servidor_fijado = nulo
  @conexión fijada_id_global = nulo
  conexión.unpin a no ser que conexión.nil?
end

#unpin_maybe(error, 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 fue anclada y la instancia de excepción especificada y el estado de transacción de la sesión requieren que se desancle.

La instancia de excepción ya debería tener todas las etiquetas configuradas (las generadas por el lado del cliente y del servidor).

Parámetros:

  • Error (Error) -

    La instancia de excepción para procesar.

  • conexión (Conexión | nula) (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 desfijar_tal vez(Error, conexión = nulo)
  Si !¿dentro_de_los_estados?(Sesión::SIN ESTADO DE TRANSACCIÓN) &&
    Error.¿etiqueta?('TransientTransactionError')
  entonces
    unpin(conexión)
  end

  Si ¿confirmando_transacción? &&
    Error.¿etiqueta?('Resultado deconfirmación de transacción desconocida')
  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 @estado
  Cuando STARTING_TRANSACTION_STATE
    @estado = ESTADO DE TRANSACCIÓN EN CURSO
  Cuando ESTADO DE TRANSACCIÓN COMPROMETIDA, ESTADO DE TRANSACCIÓN ABORTADA
    @estado = SIN ESTADO DE TRANSACCIÓN
  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 finalizarse y debe haber sido creada por un cliente con el mismo clúster que el cliente con el que se utilizará la sesión.

Parámetros:

  • Cliente (Cliente) -

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

Devuelve:

  • (Sesión) -

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

Aumentos:

Desde:

  • 2.5.0



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

def validate!(Cliente)
  ¡comprueba el clúster coincidente!(Cliente)
  ¡comprobar si terminó!
  yo
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 principal.

Ejemplos:

session.validate_read_preference!(command)

Aumentos:

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 no ser que ¿en_transacción?
  return a no ser que Comando[' $readPreference ']

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

  Si moda && moda != 'primario '
    propagar Mongo::Error::Operación de transacción no válida.Nuevo(
      "Lapreferencia de lectura en una transacción debe ser principal (solicitado: #{mode} )"
    )
  end
end

#con_transacción(opciones = nula) ⇒ Objeto

Nota:

with_transaction contiene un bucle; por lo tanto, si with_transaction se coloca en un bucle, su bloque no debería llamar a next ni a break para controlar el bucle externo, ya que esto afectaría al bucle de 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 su fecha de ejecución son detalles de implementación del controlador; el bloque proporcionado debe ser idempotente y estar preparado para ser llamado más de una vez. El controlador puede reintentar el comando de confirmación dentro de una transacción activa o puede repetir la transacción e invocar el bloque de nuevo, dependiendo del error encontrado, si lo hubiera. Tenga en cuenta también que los reintentos pueden ejecutarse en 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 se derivan de Mongo::Error detienen el procesamiento, abortan la transacción y se propagan fuera de with_transaction. Las excepciones derivadas de Mongo::Error pueden ser gestionadas por with_transaction, lo que resulta 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

Ejecutar una declaració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.

Aumentos:

  • (Error::Operaciónde transacción no válida) —

    Si ya hay una transacción en curso o si no se reconoce el problema de escritura.

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 tiempo de espera_ms = (opciones || {})[:tiempo de espera_ms]
    tiempo de espera_seg = tiempo de espera_ms / 1_000.0
    fecha tope = Utils.monotonic_time + tiempo de espera_seg
    @con fecha límite de transacción = fecha tope
  elsif tiempo de espera predeterminado_ms = @opciones[:tiempo de espera predeterminado_ms]
    tiempo de espera_seg = tiempo de espera predeterminado_ms / 1_000.0
    fecha tope = Utils.monotonic_time + tiempo de espera_seg
    @con fecha límite de transacción = fecha tope
  elsif @cliente.tiempo de espera_seg
    fecha tope = Utils.monotonic_time + @cliente.tiempo de espera_seg
    @con fecha límite de transacción = fecha tope
  else
    fecha tope = Utils.monotonic_time + 120
  end
  transacción_en_progreso = 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)
    transacción_en_progreso = true
    begin
      rv = rendimiento yo
    rescate Excepción => e
      Si ¿dentro_de_los_estados?(STARTING_TRANSACTION_STATE, ESTADO DE TRANSACCIÓN EN CURSO)
        advertencia de registro("Abortandotransacción debido a #{e.class}: #{e}")
        @con fecha límite de transacción = nulo
        abortar_transacción
        transacción_en_progreso = false
      end

      Si Utils.monotonic_time >= fecha tope
        transacción_en_progreso = false
        propagar
      end

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

      propagar
    else
      Si ¿dentro_de_los_estados?(ESTADO DE TRANSACCIÓN ABORTADA, SIN ESTADO DE TRANSACCIÓN, ESTADO DE TRANSACCIÓN COMPROMETIDA)
        transacción_en_progreso = false
        return rv
      end

      begin
        transacción de confirmación(opciones de confirmación)
        transacción_en_progreso = false
        return rv
      rescate Mongo::Error => e
        Si e.¿etiqueta?('Resultado deconfirmación de transacción desconocida')
          Si Utils.monotonic_time >= fecha tope ||
            e.is_a?(Error::Operación fallida::Familia) && e.¿max_time_ms_expired?
          entonces
            transacción_en_progreso = false
            propagar
          end
          opciones_wc = caso v = opciones de confirmación[:escribir_preocupación]
            Cuando Escribir preocupación::Base
              v.opciones
            Cuando nulo
              {}
            else
              v
            end
          opciones de confirmación[:escribir_preocupación] = opciones_wc.unir(w: :mayoría)
          reintentar
        elsif e.¿etiqueta?('TransientTransactionError')
          Si Utils.monotonic_time >= fecha tope
            transacción_en_progreso = false
            propagar
          end
          @estado = SIN ESTADO DE TRANSACCIÓN
          siguiente
        else
          transacción_en_progreso = false
          propagar
        end
      rescate Error::AuthError
        transacción_en_progreso = 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 transacción_en_progreso
    advertencia de registro('La devolución de llamada with_transaction interrumpió el bucle with_transaction y canceló la transacción')
    begin
      abortar_transacción
    rescate Error::Operación fallida::Familia, Error::Operación de transacción no válida
    end
  end
  @con fecha límite de transacción = nulo
end