Classe: Mongo::Session

Herda:
Objeto
  • Objeto
mostrar tudo
Estendido por:
Encaminhável
Inclui:
ClusterTime::Consumer, Loggable, Retryable
Definido em:
lib/mongo/session.rb,
lib/mongo/session/session_pool.rb,
lib/mongo/session/server_session.rb,
lib/mongo/session/server_session/dirtyable.rb

Visão geral

Observação:

Objetos de sessão não são seguros para threads. Um aplicação pode usar uma sessão de apenas um thread ou processo por vez.

Uma sessão lógica que representa um conjunto de operações sequenciais executadas por um aplicação relacionado de alguma forma.

Desde:

  • 2.5.0

Definido sob namespace

Classes: ServerSession, SessionPool

Colapsode resumo constante

MISMATCHED_CLUSTER_ERROR_MSG =

Mensagem de erro indicando que a sessão foi recuperada de um cliente com um cluster diferente do cliente por meio do qual ela está sendo usada no momento.

Desde:

  • 2.5.0

'A configuração do cliente usada para criar esta sessão não corresponde a isso ' +
'do cliente proprietário desta operação. Use esta sessão somente para operações por meio de sua sessão principal +
'cliente.'.congelar
SESSION_ENDED_ERROR_MSG =

Mensagem de erro descrevendo que a sessão não pode ser usada porque já foi encerrada.

Desde:

  • 2.5.0

'Esta sessão terminou e não pode ser usada. Crie um novo.'.congelar
SESSIONS_NOT_SUPPORTED =
Obsoleto.

Mensagem de erro descrevendo que as sessões não são suportadas pela versão do servidor .

Desde:

  • 2.5.0

' Assessões não são suportadas pelos servidores conectados.'.congelar
NO_TRANSACTION_STATE =

O estado de uma sessão em que a última operação não estava relacionada a nenhuma transação ou nenhuma operação ocorreu ainda.

Desde:

  • 2.6.0

:no_transaction
STARTING_TRANSACTION_STATE =

O estado de uma sessão em que um usuário iniciou uma transação, mas nenhuma operação dentro das transações ocorreu ainda.

Desde:

  • 2.6.0

:starting_transaction
Transaction_in_progress_state =

O estado de uma sessão em que uma transação foi iniciada e pelo menos uma operação ocorreu, mas a transação ainda não foi confirmada ou cancelada.

Desde:

  • 2.6.0

:transaction_in_progress
Transaction_committed_state =

O estado de uma sessão em que a última operação executada foi uma confirmação de transação.

Desde:

  • 2.6.0

:transaction_committed
Transaction_ABORTED_STATE =

O estado de uma sessão em que a última operação executada foi uma anulação de transação.

Desde:

  • 2.6.0

:transaction_aborted
UNLABELED_WRITE_CONCERN_CODES =

Essa constante faz parte de uma API privada. Você deve evitar usar essa constante, se possível, pois ela pode ser removida ou alterada no futuro.

Desde:

  • 2.5.0

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

Constantes incluídas do Loggable

Loggable::Prefix

Recolhimento do Resumo do atributo de instância

Atributos incluídos do ClusterTime::Consumer

#cluster_time

Recolhimento do Resumo do método de instância

Métodos incluídos do ClusterTime::Consumer

#advance_cluster_time

Métodos incluídos no Loggable

#log_debug, #log_error, #log_fatal, #log_info, #log_WARN, #logger

Métodos incluídos no Retryable

#read_worker, #select_server, #write_worker

Detalhes do construtor

#initialize(server_session, client, options = {}) ➤ Session

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Observação:

Os aplicativos devem utilizar Client#start_session para iniciar uma sessão. Este construtor é apenas para uso interno do driver.

Inicialize uma sessão.

Uma sessão pode ser explícita ou implícita. A vida útil das sessões explícitas é gerenciada pelo aplicativo - os aplicativos criam explicitamente essas sessões e as encerram explicitamente. As sessões implícitas são criadas automaticamente pelo driver ao enviar operações para servidores que suportam sessões (3.6+), e sua vida útil é gerenciada pelo driver.

Quando uma sessão implícita é criada, ela não pode ter uma sessão de servidor associada a ela. A sessão do servidor será verificada no pool de sessões quando uma operação usando esta sessão for realmente executada. Quando uma sessão explícita é criada, ela deve fazer referência a uma sessão do servidor que já está alocada.

Parâmetros:

  • server_session (ServerSession | nil) —

    A sessão do servidor à qual esta sessão está associada. Se a opção :implicit for verdadeira, isto deverá ser nulo.

  • Cliente (Cliente) —

    O cliente através do qual esta sessão é criada.

  • opções (Hash) (padrão para: {}) —

    As opções para esta sessão.

Hash de opções (opções):

  • :causal_consistency (true|false) —

    Se ativar a consistência causal para esta sessão.

  • :default_timeout_ms (Inteiro) —

    O valor de timeoutMS para as seguintes operações executadas na sessão:

    • commitTransaction

    • abortTransaction

    • withTransaction

    • endSession

  • :default_transaction_options (Hash) —

    As opções a serem passadas para start_transaction por padrão podem conter qualquer uma das opções que start_transaction aceita.

  • :implicit (true|false) —

    Somente para uso do driver interno - especifica se a sessão é implícita. Se isso for verdade, server_session será nulo. Isso é feito para que a sessão do servidor só seja verificada depois que a conexão for verificada.

  • :read_preference (Hash) —

    O hash das opções de preferência de leitura, com as seguintes chaves opcionais:

    • : modo – a preferência de leitura como uma string ou símbolo; Os valores válidos são :primary, :primary_preferred, :secondary, :secondary_preferred e :nearest.

  • :snapshot (verdadeiro | falso) —

    Configure a sessão para leituras de snapshots.

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
 
# Arquivo 'lib/mongo/session.rb', linha 83

def inicializar(server_session, Cliente, opções = {})
  se opções[:causal_consistency] && opções[:snapshot]
    aumentar ArgumentError, ':causal_consistency e :snapshot não podem ser definidas em uma sessão'
  end

  se opções[:implicit]
    a menos que server_session.nada?
      aumentar ArgumentError, 'A sessão implícita não pode fazer referência à sessão do servidor durante a construção'
    end
  mais
    se server_session.nada?
      aumentar ArgumentError, ' Asessão explícita deve fazer referência à sessão do servidor durante a construção'
    end
  end

  @server_session = server_session
  opções = opções.dup

  @cliente = Cliente.Usar(: admin)
  @opções = opções.dup.congelar
  @cluster_time = nada
  @state = NO_TRANSACTION_STATE
  @with_transaction_deadline = nada
end

Detalhes do atributo da instância

#cliente ➤ Cliente (somente leitura)

Retorna O cliente através do qual esta sessão foi criada.

Retorna:

  • (Cliente) —

    O cliente através do qual esta sessão foi criada.

Desde:

  • 2.5.1



116
117
118
 
# Arquivo 'lib/mongo/session.rb', linha 116

def Cliente
  @cliente
end

#operation_time ➤ BSON::Timestamp (readonly)

Retorna o último optime visto para esta sessão.

Retorna:

  • (BSON::Timestamp) —

    O último optime visto para esta sessão.

Desde:

  • 2.5.0



131
132
133
 
# Arquivo 'lib/mongo/session.rb', linha 131

def operation_time
  @operation_time
end

#opções ➤ Hash (somente leitura)

Retorna As opções para esta sessão.

Retorna:

  • (Hash) —

    As opções para esta sessão.

Desde:

  • 2.5.0



111
112
113
 
# Arquivo 'lib/mongo/session.rb', linha 111

def opções
  @opções
end

#pinned_connection_global_id ➤ Inteiro | nil (somente leitura)

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna o ID global da conexão à qual esta sessão está fixada, se houver.

Retorna:

  • (Inteiro | nil) —

    O ID global da conexão à qual esta sessão está fixada, se houver.

Desde:

  • 2.5.0



284
285
286
 
# Arquivo 'lib/mongo/session.rb', linha 284

def pinned_connection_global_id
  @pinned_connection_global_id
end

#pinned_server ➤ MongoDB Server | nil (somente leitura)

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna o servidor (que deve ser um mongos) em que esta sessão está fixada, se houver.

Retorna:

  • (Servidor MongoDB | nil) —

    O servidor (que deve ser um mongos) ao qual esta sessão está fixada, se houver.

Desde:

  • 2.5.0



278
279
280
 
# Arquivo 'lib/mongo/session.rb', linha 278

def pinned_server
  @pinned_server
end

#recovery_token ➤ BSON::Document | nada

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna o token de recuperação para a transação fragmentada que está sendo executada nesta sessão, se houver.

Retorna:

  • (BSON::Document | nil) —

    Token de recuperação para a transação fragmentada que está sendo executada nesta sessão, se houver.

Desde:

  • 2.5.0



290
291
292
 
# Arquivo 'lib/mongo/session.rb', linha 290

def recovery_token
  @recovery_token
end

#snapshot_timestamp ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Desde:

  • 2.5.0



1192
1193
1194
 
# Arquivo 'lib/mongo/session.rb', linha 1192

def snapshot_timestamp
  @snapshot_timestamp
end

#with_transaction_deadline ➤ Objeto (somente leitura)

Desde:

  • 2.5.0



1194
1195
1196
 
# Arquivo 'lib/mongo/session.rb', linha 1194

def with_transaction_deadline
  @with_transaction_deadline
end

Detalhes do método de instância

#abort_transaction(options = nil) ➤ Object

Cancele a transação atualmente ativa sem fazer alterações no banco de banco de dados.

Exemplos:

Abortar a transação.

session.abort_transaction

Parâmetros:

  • opções (Hash) (padrão para: nil) —

    um conjunto personalizável de opções

Hash de opções (opções):

  • :timeout_ms (Inteiro) —

    O tempo limite da operação em milissegundos. Deve ser um número inteiro não negativo. Um valor explícito de 0 significa infinito. O valor padrão não está definido, o que significa que o valor é herdado do 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
 
# Arquivo 'lib/mongo/session.rb', linha 730

def abort_transaction(opções = nada)
  Cache de consulta.Limpar

  check_if_end!
  check_if_no_transaction!

  se dentro de_states?(Transaction_committed_state)
    aumentar mongo::Erro::Operação de transação inválida.Novo(
      mongo::Erro::Operação de transação inválida.not_call_after_msg(
        :commitTransaction, :abortTransaction))
  end

  se dentro de_states?(Transaction_ABORTED_STATE)
    aumentar mongo::Erro::Operação de transação inválida.Novo(
      mongo::Erro::Operação de transação inválida.not_call_twice_msg(:abortTransaction))
  end

  opções ||= {}

  começar
    a menos que initial_transaction?
      @aborting_transaction = true
      Contexto = (operação)::Contexto.Novo(
        cliente: @cliente,
        sessão: auto,
        operation_timeouts: operation_timeouts(opções)
      )
      write_with_retry(txn_options[:write_concern],
        endpoint_transaction: true, contexto: Contexto,
      ) fazer |Conexão, txn_num, Contexto|
        começar
          (operação)::Comando.Novo(
            seletor: { abortar transação: 1 },
            db_name: 'admin',
            sessão: auto,
            txn_num: txn_num
          ).execute_with_connection(Conexão, contexto: Contexto)
        garantir
          desafixar
        end
      end
    end

    @state = Transaction_ABORTED_STATE
  salvar mongo::Erro::Operação de transação inválida
    aumentar
  salvar mongo::Erro
    @state = Transaction_ABORTED_STATE
  salvar Exceção
    @state = Transaction_ABORTED_STATE
    aumentar
  garantir
    @aborting_transaction = false
  end

  # Nenhum valor de retorno oficial, mas retorne verdadeiro para que, em atividades interativas
  # use o método sugere que ele foi bem-sucedido.
  true
end

#aborting_transaction? ➤ verdadeiro | false

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna se a sessão está abortando uma transação no momento.

Retorna:

  • (verdadeiro | falso) —

    Se a sessão está abortando uma transação no momento.

Desde:

  • 2.5.0



819
820
821
 
# Arquivo 'lib/mongo/session.rb', linha 819

def aborting_transaction?
  !!@aborting_transaction
end

#add_autocommit!(comando) ➤ Hash, BSON::Documento

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Adicione o campo de confirmação automática a um documento de comando, se aplicável.

Exemplos:

session.add_autocommit!(cmd)

Retorna:

  • (Hash, BSON::Document) —

    O documento de comando.

Desde:

  • 2.6.0



899
900
901
902
903
 
# Arquivo 'lib/mongo/session.rb', linha 899

def add_autocommit!(comando)
  comando.toque fazer |C|
    C[:autocommit] = false se in_transaction?
  end
end

#add_start_transaction!(comando) ➤ Hash, BSON::Documento

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Adicione o campo startTransaction a um documento de comando, se aplicável.

Exemplos:

session.add_start_transaction!(cmd)

Retorna:

  • (Hash, BSON::Document) —

    O documento de comando.

Desde:

  • 2.6.0



914
915
916
917
918
919
920
 
# Arquivo 'lib/mongo/session.rb', linha 914

def add_start_transaction!(comando)
  comando.toque fazer |C|
    se initial_transaction?
      C[:startTransaction] = true
    end
  end
end

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

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Adicione o número da transação a um documento de comando, se aplicável.

Exemplos:

session.add_txn_num!(cmd)

Retorna:

  • (Hash, BSON::Document) —

    O documento de comando.

Desde:

  • 2.6.0



931
932
933
934
935
 
# Arquivo 'lib/mongo/session.rb', linha 931

def add_txn_num!(comando)
  comando.toque fazer |C|
    C[:txnNumber] = BSON::Int64.Novo(@server_session.txn_num) se in_transaction?
  end
end

#add_txn_opts!(comando, leitura, contexto) ➤ Hash, BSON::Documento

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Adicione as opções de transação, se aplicável.

Exemplos:

session.add_txn_opts!(cmd)

Retorna:

  • (Hash, BSON::Document) —

    O 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
 
# Arquivo 'lib/mongo/session.rb', linha 946

def add_txn_opts!(comando, ler, Contexto)
  comando.toque fazer |C|
    # A read concern deve ser adicionada a qualquer comando que inicie uma transação.
    se initial_transaction?
      # https://jira.mongodb.org/browse/SPEC-1161: da transação
      # a read concern substitui as read concerns da collection/banco de dados/cliente,
      # mesmo que a preocupação de leitura da transação não esteja definida.
      # A preocupação de leitura aqui é a enviada ao servidor e pode
      # include afterClusterTime.
      se rc = C[:readConcern]
        rc = rc.dup
        rc.excluir(:level)
      end
      se txn_read_concern
        se rc
          rc.update(txn_read_concern)
        mais
          rc = txn_read_concern.dup
        end
      end
      se rc.nada? || rc.vazio?
        C.excluir(:readConcern)
      mais
        C[:readConcern ] = Opções::Mapeador.transform_values_to_strings(rc)
      end
    end

    # Precisamos enviar o nível de read concern como uma string em vez de um símbolo.
    se C[:readConcern]
      C[:readConcern] = Opções::Mapeador.transform_values_to_strings(C[:readConcern])
    end

    se C[:commitTransaction]
      se max_time_ms = txn_options[:max_commit_time_ms]
        C[:maxTimeMS] = max_time_ms
      end
    end

    # A preocupação de gravação deve ser adicionada a qualquer comando abortTransaction ou commitTransaction.
    se (C[:abortTransaction] || C[:commitTransaction])
      se @already_committed
        wc = BSON::Documento.Novo(C[:writeConcern] || txn_write_concern || {})
        wc.mesclar!(w: :majority)
        wc[:wtimeout] ||= 10.000
        C[:writeConcern] = wc
      elsif txn_write_concern
        C[:writeConcern] ||= txn_write_concern
      end
    end

    # Um valor w de preocupação de gravação não numérico precisa ser enviado como uma string em vez de um símbolo.
    se 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
    se Contexto&.csot?
      C[:writeConcern]&.excluir(:wtimeout)
    end

    # Não devemos enviar uma preocupação de gravação vazia (padrão do servidor ).
    C.excluir(:writeConcern) se C[:writeConcern]&.vazio?
  end
end

# adiantamento_operation_time ( new_operation_time) ➤ BSON::Timestamp

Avance o optime em cache para esta sessão.

Exemplos:

Avance o optime.

session.advance_operation_time(timestamp)

Parâmetros:

  • new_operation_time (BSON::Timestamp) —

    O novo optime.

Retorna:

  • (BSON::Timestamp) —

    O optime máximo, considerando os horários atuais e novos.

Desde:

  • 2.5.0



1123
1124
1125
1126
1127
1128
1129
 
# Arquivo 'lib/mongo/session.rb', linha 1123

def advanced_operation_time(new_operation_time)
  se @operation_time
    @operation_time = [ @operation_time, new_operation_time ].max
  mais
    @operation_time = new_operation_time
  end
end

#cluster ⇒ Object

Desde:

  • 2.5.0



118
119
120
 
# Arquivo 'lib/mongo/session.rb', linha 118

def cluster
  @cliente.cluster
end

#commit_transaction(options = nil) ➤ Object

Confirme a transação atualmente ativa na sessão.

Exemplos:

Confirma a transação.

session.commit_transaction

Parâmetros:

  • opções (Hash) (padrão para: nil) —

    um conjunto personalizável de opções

Hash de opções (opções):

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

    O write concern a ser usado para esta operação.

  • :timeout_ms (Inteiro) —

    O tempo limite da operação em milissegundos. Deve ser um número inteiro não negativo. Um valor explícito de 0 significa infinito. O valor padrão não está definido, o que significa que o valor é herdado do 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
 
# Arquivo 'lib/mongo/session.rb', linha 648

def commit_transaction(opções=nada)
  Cache de consulta.Limpar
  check_if_end!
  check_if_no_transaction!

  se dentro de_states?(Transaction_ABORTED_STATE)
    aumentar mongo::Erro::Operação de transação inválida.Novo(
      mongo::Erro::Operação de transação inválida.not_call_after_msg(
        :abortTransaction, :commitTransaction))
  end

  opções ||= {}

  começar
    # Se o commitTransaction for chamado duas vezes, precisamos executar o mesmo commit
    # novamente, revertemos a sessão para o estado anterior.
    se dentro de_states?(Transaction_committed_state)
      @state = @last_commit_skipped ? STARTING_TRANSACTION_STATE : Transaction_in_progress_state
      @already_committed = true
    end

    se initial_transaction?
      @last_commit_skipped = true
    mais
      @last_commit_skipped = false
      @committed_transaction = true

      write_concern = opções[:write_concern] || txn_options[:write_concern]
      se write_concern && !write_concern.is_a?(Escreva preocupação::Base)
        write_concern = Escreva preocupação.obter(write_concern)
      end

      Contexto = (operação)::Contexto.Novo(
        cliente: @cliente,
        sessão: auto,
        operation_timeouts: operation_timeouts(opções)
      )
      write_with_retry(write_concern, endpoint_transaction: true,
        contexto: Contexto,
      ) fazer |Conexão, txn_num, Contexto|
        se Contexto.tentar novamente?
          se write_concern
            wco = write_concern.opções.mesclar(w: :majority)
            wco[:wtimeout] ||= 10.000
            write_concern = Escreva preocupação.obter(wco)
          mais
            write_concern = Escreva preocupação.obter(w: :majority, wtimeout: 10.000)
          end
        end
        especificações = {
          seletor: { commitTransaction: 1 },
          db_name: 'admin',
          sessão: auto,
          txn_num: txn_num,
          write_concern: write_concern,
        }
        (operação)::Comando.Novo(especificações).execute_with_connection(Conexão, contexto: Contexto)
      end
    end
  garantir
    @state = Transaction_committed_state
    @committed_transaction = false
  end

  # Nenhum valor de retorno oficial, mas retorne verdadeiro para que, em atividades interativas
  # use o método sugere que ele foi bem-sucedido.
  true
end

#commit_transaction? ➤ verdadeiro | false

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna se a sessão está confirmando uma transação no momento.

Retorna:

  • (verdadeiro | falso) —

    Se a sessão está confirmando uma transação no momento.

Desde:

  • 2.5.0



811
812
813
 
# Arquivo 'lib/mongo/session.rb', linha 811

def commit_transaction?
  !!@committed_transaction
end

#sujo! (mark = true)➤ Objeto

Define o estado sujo para o valor fornecido para a sessão do servidor subjacente. Se não houver sessão no servidor , isso não fará nada.

Parâmetros:

  • marcar (verdadeiro | falso) (padrão para: true) —

    se deve marcar a sessão do servidor como suja ou não.

Desde:

  • 2.5.0



138
139
140
 
# Arquivo 'lib/mongo/session.rb', linha 138

def dirty!(marcar = true)
  @server_session&.dirty!(marcar)
end

#sujo? ➤ verdadeiro | false | nada

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna se a sessão do servidor subjacente está suja. Se não existir nenhuma sessão de servidor para esta sessão, não retornará nenhum valor.

Retorna:

  • (verdadeiro | falso | nulo) —

    se a sessão do servidor subjacente está suja. Se não existir nenhuma sessão de servidor para esta sessão, não retornará nenhum valor.

Desde:

  • 2.5.0



146
147
148
 
# Arquivo 'lib/mongo/session.rb', linha 146

def dirty?
  @server_session&.dirty?
end

#end_session ➤ nil

Encerre esta sessão.

Se houver uma transação em andamento nesta sessão, a transação será cancelada. A sessão do servidor associada a esta sessão é retornada ao pool de sessões do servidor. Finalmente, esta sessão está marcada como encerrada e não pode mais ser usada.

Se esta sessão já estiver encerrada, o método não fará nada.

Observe que esse método não emite diretamente um comando endSessions para esse servidor, ao contrário do que seu nome pode sugerir.

Exemplos:

session.end_session

Retorna:

  • (nil) —

    Sempre nulo.

Desde:

  • 2.5.0



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

def end_session
  se !acabou? && @cliente
    se dentro de_states?(Transaction_in_progress_state)
      começar
        abort_transaction
      salvar mongo::Erro, Erro::AuthError
      end
    end
    se @server_session
      @cliente.cluster.session_pool.checkin(@server_session)
    end
  end
garantir
  @server_session = nada
  @end = true
end

#terminou? ➤ true, false

Se esta sessão terminou.

Exemplos:

session.ended?

Retorna:

  • (verdadeiro, falso) —

    Se a sessão terminou.

Desde:

  • 2.5.0



243
244
245
 
# Arquivo 'lib/mongo/session.rb', linha 243

def acabou?
  !!@end
end

#explícito? ➤ true, false

Esta sessão é explícita (ou seja, usuário criado).

Exemplos:

A sessão é explícita?

session.explicit?

Retorna:

  • (verdadeiro, falso) —

    Se esta sessão é explícita.

Desde:

  • 2.5.2



178
179
180
 
# Arquivo 'lib/mongo/session.rb', linha 178

def explicit?
  !implícito?
end

#implícito? ➤ true, false

Esta sessão é implícita (não criada pelo usuário).

Exemplos:

A sessão é implícita?

session.implicit?

Retorna:

  • (verdadeiro, falso) —

    Se esta sessão é implícita.

Desde:

  • 2.5.1



166
167
168
 
# Arquivo 'lib/mongo/session.rb', linha 166

def implícito?
  @implicit ||= !!(@opções.chave?(:implicit) && @opções[:implicit] == true)
end

#in_transaction? ➤ verdadeiro | false

Se a sessão está ou não atualmente em uma transação.

Exemplos:

A sessão está em uma transação?

session.in_transaction?

Retorna:

  • (verdadeiro | falso) —

    Se a sessão em uma transação ou não.

Desde:

  • 2.6.0



803
804
805
 
# Arquivo 'lib/mongo/session.rb', linha 803

def in_transaction?
  dentro de_states?(STARTING_TRANSACTION_STATE, Transaction_in_progress_state)
end

#inspecionar ➤ string

Obtenha uma string formatada para uso na inspeção.

Exemplos:

Inspecione o objeto de sessão.

session.inspect

Retorna:

  • (string) —

    A inspeção da sessão.

Desde:

  • 2.5.0



355
356
357
 
# Arquivo 'lib/mongo/session.rb', linha 355

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

#materialize_if_needed ➤ Sessão

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Se ainda não estiver definido, preencha o server_session de um objetos de sessão fazendo check-out de uma sessão no pool de sessões.

Retorna:

Desde:

  • 2.5.0



1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
 
# Arquivo 'lib/mongo/session.rb', linha 1137

def materialize_if_needed
  se acabou?
    aumentar Erro::Sessão encerrada
  end

  Método a menos que implícito? && !@server_session

  @server_session = cluster.session_pool.checkout

  auto
end

#materializado? ➤ Booleano

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna:

  • (Booleano)

Desde:

  • 2.5.0



1150
1151
1152
1153
1154
1155
1156
 
# Arquivo 'lib/mongo/session.rb', linha 1150

def materializado?
  se acabou?
    aumentar Erro::Sessão encerrada
  end

  !@server_session.nada?
end

#próximo_txn_num ➤ Inteiro

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Aumentar e retornar o próximo número de transação.

Exemplos:

Obtenha o próximo número de transação.

session.next_txn_num

Retorna:

  • (Inteiro) —

    O próximo número da transação.

Desde:

  • 2.5.0



1167
1168
1169
1170
1171
1172
1173
 
# Arquivo 'lib/mongo/session.rb', linha 1167

def próximo_txn_num
  se acabou?
    aumentar Erro::Sessão encerrada
  end

  @server_session.próximo_txn_num
end

#pin_to_connection(connection_global_id) ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Fixa esta sessão na conexão especificada.

esta sessão para.

Parâmetros:

  • connection_global_id (Inteiro) —

    O ID global da conexão com o pino

Desde:

  • 2.5.0



846
847
848
849
850
851
 
# Arquivo 'lib/mongo/session.rb', linha 846

def pin_to_connection(connection_global_id)
  se connection_global_id.nada?
    aumentar ArgumentError, 'Não é possível fixar um ID de conexão nulo'
  end
  @pinned_connection_global_id = connection_global_id
end

#pin_to_server(servidor) ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Fixa esta sessão no servidor especificado, que deve ser um mongos.

Parâmetros:

Desde:

  • 2.5.0



828
829
830
831
832
833
834
835
836
837
838
 
# Arquivo 'lib/mongo/session.rb', linha 828

def pin_to_server(Servidor)
  se Servidor.nada?
    aumentar ArgumentError, 'Não é possível fixar em um servidor nil'
  end
  se Lint.habilitado?
    a menos que Servidor.mongos?
      aumentar Erro::LintError, "Tentativa de fixar a sessão no servidor #{servidor.resume} que não é um mongos"
    end
  end
  @pinned_server = Servidor
end

#processo(resultado) ➤ Operação::Result

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Processe uma resposta do servidor que usou esta sessão.

Exemplos:

Processe uma resposta do servidor.

session.process(result)

Parâmetros:

Retorna:

Desde:

  • 2.5.0



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

def Processo(Resultado)
  a menos que implícito?
    set_operation_time(Resultado)
    se cluster_time_doc = Resultado.cluster_time
      advanced_cluster_time(cluster_time_doc)
    end
  end
  @server_session.set_last_use!

  se doc = Resultado.responder && Resultado.responder.documentos.primeiro
    se doc[:recoveryToken]
      auto.recovery_token = doc[:recoveryToken]
    end
  end

  Resultado
end

#retry_reads? ➤ Booleano

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Se as leituras executadas com essa sessão podem ser repetidas de acordo com a especificação moderna de leituras repetíveis.

Se esse método retornar true, as leituras com possibilidade de nova tentativa moderna foram solicitadas pelo aplicação. Se o servidor selecionado para uma operação de leitura oferecer suporte a leituras repetíveis modernos, elas serão usadas para essa operação específica. Se o servidor selecionado para uma operação de leitura não suportar leituras repetíveis modernos, a leitura não será repetida.

Se este método retornar falso, leituras repetíveis legadas foram solicitadas pelo aplicativo. A lógica legada de leitura repetível será usada independentemente da versão do servidor(s) ao qual o cliente está conectado. O número de tentativas de leitura é fornecido pela opção do cliente :max_read_retries, que é 1 por padrão e pode ser definida como 0 para desativar as tentativas de leitura herdadas.

Retorna:

  • (Booleano)

Desde:

  • 2.5.0



198
199
200
 
# Arquivo 'lib/mongo/session.rb', linha 198

def retry_reads?
  Cliente.opções[:retry_reads] != false
end

#retry_writes? ➤ true, false

Observação:

As retryable writes só estão disponíveis em versões de servidor pelo menos 3.6 e com clusters fragmentados, conjuntos de réplicas ou topologias com balanceamento de carga.

As escritas executadas com esta sessão serão repetidas.

Exemplos:

As gravações serão repetidas.

session.retry_writes?

Retorna:

  • (verdadeiro, falso) —

    As gravações serão repetidas.

Desde:

  • 2.5.0



213
214
215
 
# Arquivo 'lib/mongo/session.rb', linha 213

def retry_writes?
  !!Cliente.opções[:retry_writes] && (cluster.replica_set? || cluster.fragmentado? || cluster.load_balanced?)
end

#session_id ⇒ BSON::Document

Obtenha a ID da sessão do servidor desta sessão, se a sessão não tiver sido encerrada. Se a sessão tiver sido encerrada, gera Erro::SessionEnded.

Retorna:

  • (BSON::Document) —

    O ID da sessão do servidor .

Aumenta:

Desde:

  • 2.5.0



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

def session_id
  se acabou?
    aumentar Erro::Sessão encerrada
  end

  # Uma sessão explícita sempre terá um session_id, porque durante
  # construção que uma sessão de servidor deve ser fornecida. Uma sessão implícita
  # não terá um session_id até que seja materializado, portanto, as chamadas para
  # session_id pode falhar. Um aplicativo não deve ter a oportunidade
  # para enfrentar essa falha porque uma sessão implícita não deve ser
  # acessível a aplicativos devido à restrição de sua vida útil
  # execução da operação, que é feita inteiramente pelo motorista.
  a menos que materializado?
    aumentar Erro::SessionNotMaterialized
  end

  @server_session.session_id
end

#snapshot? ➤ verdadeiro | false

Retorna se a sessão está configurada para leituras de snapshots.

Retorna:

  • (verdadeiro | falso) —

    Se a sessão está configurada para leituras de snapshots.

Desde:

  • 2.5.0



124
125
126
 
# Arquivo 'lib/mongo/session.rb', linha 124

def snapshot?
  !!opções[:snapshot]
end

#start_transaction(options = nil) ➤ Object

Coloca as operações subsequentes nesta sessão em uma nova transação.

Observe que a transação não será iniciada no servidor até que uma operação seja executada após start_transaction ser chamada.

Exemplos:

Iniciar uma nova transação

session.start_transaction(options)

Parâmetros:

  • opções (Hash) (padrão para: nil) —

    As opções para a transação que está sendo iniciada.

Hash de opções (opções):

  • :max_commit_time_ms (Inteiro) —

    A quantidade máxima de tempo para permitir que um único comando commitTransaction seja executado, em milissegundos. Esta opção está obsoleta, use :timeout_ms em vez disso.

  • :read_concern (Hash) —

    O hash de opções de preocupação de leitura , com as seguintes chaves opcionais:

    • :level – o nível de preferência de leitura como um símbolo; valores válidos

      are *:local*, *:majority*, and *:snapshot*
  • :write_concern (Hash) —

    As opções de preocupação de gravação . Pode ser :w => Inteiro|String, : fsync => Booleano, :j => Booleano.

  • :read (Hash) —

    As opções de read preference. O hash pode ter os seguintes itens:

    • :mode – read preference especificada como um símbolo; o único valor válido é :primary.

  • :timeout_ms (Inteiro) —

    O tempo limite da operação em milissegundos. Deve ser um número inteiro não negativo. Um valor explícito de 0 significa infinito. O valor padrão não está definido, o que significa que o valor é herdado do 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
 
# Arquivo 'lib/mongo/session.rb', linha 583

def start_transaction(opções = nada)
  check_transactions_supported!

  se opções
    Lint.validate_read_concern_option(opções[:read_concern])

=começar
    # Seria útil detectar preferências de leitura inválidas aqui, mas
    # alguns dos testes de especificações exigem detecção posterior de preferências de leitura inválidas.
    # Talvez possamos fazer isso quando o modo lint estiver ativado.
    modo = opções[:read] && opções[:read][:mode].to_s
    se modo && modo != 'primary'
      aumentar Mongo::Error::InvalidTransactionOperation.new(
        "a read preference em uma transação deve ser primary (solicitada: #{mode})"
      )
    end
=end
  end

  se snapshot?
    aumentar mongo::Erro::SnapshotSessionTransactionProhibited
  end

  check_if_end!

  se dentro de_states?(STARTING_TRANSACTION_STATE, Transaction_in_progress_state)
    aumentar mongo::Erro::Operação de transação inválida.Novo(
      mongo::Erro::Operação de transação inválida::Transaction_already_in_progress)
  end

  desafixar

  próximo_txn_num
  @txn_options = (@opções[:default_transaction_options] || {}).mesclar(opções || {})

  se txn_write_concern && !Escreva preocupação.obter(txn_write_concern).reconhecido?
    aumentar mongo::Erro::Operação de transação inválida.Novo(
      mongo::Erro::Operação de transação inválida::UNACKNOWLEDGED_WRITE_CONCERN)
  end

  @state = STARTING_TRANSACTION_STATE
  @already_committed = false

  # Este método não tem valor de retorno explícito.
  # Poderíamos retornar nulo aqui, mas verdadeiro indica ao usuário que o
  # operação bem-sucedida. Destina-se a uso interativo.
  # Observe que o valor de retorno não é documentado.
  true
end

#initial_transaction? ➤ Booleano

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna:

  • (Booleano)

Desde:

  • 2.5.0



791
792
793
 
# Arquivo 'lib/mongo/session.rb', linha 791

def initial_transaction?
  dentro de_states?(STARTING_TRANSACTION_STATE)
end

#suprime_read_write_concern!(comando) ➤ Hash, BSON::Documento

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Remova a read concern e/ou write concern do comando se não for aplicável.

Exemplos:

session.suppress_read_write_concern!(cmd)

Retorna:

  • (Hash, BSON::Document) —

    O documento de comando.

Desde:

  • 2.6.0



1020
1021
1022
1023
1024
1025
1026
1027
 
# Arquivo 'lib/mongo/session.rb', linha 1020

def suprime_read_write_concern!(comando)
  comando.toque fazer |C|
    próximo a menos que in_transaction?

    C.excluir(:readConcern) a menos que initial_transaction?
    C.excluir(:writeConcern) a menos que C[:commitTransaction] || C[:abortTransaction]
  end
end

#txn_num ➤ Inteiro

Obtenha o número da transação atual.

Exemplos:

Obtenha o número da transação atual.

session.txn_num

Retorna:

  • (Inteiro) —

    O número da transação atual.

Desde:

  • 2.6.0



1183
1184
1185
1186
1187
1188
1189
 
# Arquivo 'lib/mongo/session.rb', linha 1183

def txn_num
  se acabou?
    aumentar Erro::Sessão encerrada
  end

  @server_session.txn_num
end

#txn_options ➤ Hash

nesta sessão.

Retorna:

  • (Hash) —

    As opções da transação que está sendo executada atualmente

Desde:

  • 2.6.0



154
155
156
 
# Arquivo 'lib/mongo/session.rb', linha 154

def txn_options
  @txn_options ou aumentar ArgumentError, "Não há transação ativa"
end

#txn_read_preference ➤ Hash

Obtenha a preferência de leitura que a sessão usará na transação ativa atualmente.

Este é um hash de estilo de driver com chaves de sublinhado.

Exemplos:

Obter a preferência de leitura da transação

session.txn_read_preference

Retorna:

  • (Hash) —

    A preferência de leitura da transação.

Desde:

  • 2.6.0



228
229
230
231
232
233
 
# Arquivo 'lib/mongo/session.rb', linha 228

def txn_read_preference
  rp = txn_options[:read] ||
    @cliente.read_preference
  mongo::Lint.validate_subscore_read_preference(rp)
  rp
end

#unpin(connection = nil) ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Desafixa esta sessão do servidor fixado ou da conexão, se a sessão tiver sido fixada.

Parâmetros:

  • Conexão (Conexão | nil) (padrão para: nil) —

    Conexão para desafixar.

Desde:

  • 2.5.0



859
860
861
862
863
 
# Arquivo 'lib/mongo/session.rb', linha 859

def desafixar(Conexão = nada)
  @pinned_server = nada
  @pinned_connection_global_id = nada
  Conexão.desafixar a menos que Conexão.nada?
end

#unpin_ maybe(erro, conexão = nil) ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Libera esta sessão do servidor fixado ou da conexão, se a sessão tiver sido fixada e a instância de exceção especificada e o estado da transação exigirem que ela seja removida.

A instância de exceção já deve ter todos os rótulos definidos nela (ambos os rótulos gerados pelo cliente e pelo servidor).

Parâmetros:

  • Erro (Erro) —

    A instância de exceção a ser processada.

  • Conexão (Conexão | nil) (padrão para: nil) —

    Conexão para desafixar.

Desde:

  • 2.5.0



876
877
878
879
880
881
882
883
884
885
886
887
888
 
# Arquivo 'lib/mongo/session.rb', linha 876

def unpin_ maybe(Erro, Conexão = nada)
  se !dentro de_states?(Sessão::NO_TRANSACTION_STATE) &&
    Erro.rótulo?('TransientTransactionError')
  então
    desafixar(Conexão)
  end

  se commit_transaction? &&
    Erro.rótulo?('UnknownTransactionCommitResult')
  então
    desafixar(Conexão)
  end
end

#update_state! ⇒ Object

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Atualize o estado da sessão devido a uma operação (não confirmação e não interrupção) que está sendo executada.

Desde:

  • 2.6.0



1056
1057
1058
1059
1060
1061
1062
1063
 
# Arquivo 'lib/mongo/session.rb', linha 1056

def update_state!
  caso @state
  quando STARTING_TRANSACTION_STATE
    @state = Transaction_in_progress_state
  quando Transaction_committed_state, Transaction_ABORTED_STATE
    @state = NO_TRANSACTION_STATE
  end
end

#validate!(client) ⇒ Session

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Valide a sessão para uso pelo cliente especificado.

A sessão não deve ser encerrada e deve ter sido criada por um cliente com o mesmo cluster do cliente com o qual a sessão deve ser usada.

Parâmetros:

  • Cliente (Cliente) —

    O cliente com o qual a sessão deve ser usada.

Retorna:

  • (Sessão) —

    self, se a sessão for válida.

Aumenta:

Desde:

  • 2.5.0



1078
1079
1080
1081
1082
 
# Arquivo 'lib/mongo/session.rb', linha 1078

def validar!(Cliente)
  check_matching_cluster!(Cliente)
  check_if_end!
  auto
end

#validate_read_preference!(comando) 3 Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Certifique-se de que a read preference de um comando primary.

Exemplos:

session.validate_read_preference!(command)

Aumenta:

Desde:

  • 2.6.0



1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
 
# Arquivo 'lib/mongo/session.rb', linha 1039

def validate_read_preference!(comando)
  Método a menos que in_transaction?
  Método a menos que comando['$readPreference']

  Modo = comando['$readPreference']['mode'] || comando['$readPreference'][:mode]

  se Modo && Modo != 'primary'
    aumentar mongo::Erro::Operação de transação inválida.Novo(
      "a read preference em uma transação deve ser primary (solicitada: #{modo})"
    )
  end
end

#with_transaction(options = nil) ➤ Object

Observação:

with_transaction contém um loop, portanto, se a própria with_transaction for colocada em um loop, seu bloco não deve chamar próximo ou quebrar para controlar o loop externo, pois isso afetará o loop em with_transaction. O driver avisará e abortará a transação se detetar esta situação.

Executa o bloqueio fornecido em uma transação, tentando novamente conforme necessário.

Retorna o valor de retorno do bloco.

O número exato de tentativas e quando elas são executadas são detalhes de implementação do driver; o bloco fornecido deve ser idempotente e deve estar preparado para ser chamado mais de uma vez. O driver pode tentar novamente o comando de commit dentro de uma transação ativa ou pode repetir a transação e invocar o bloqueio novamente, dependendo do erro encontrado, se houver. Observe também que as novas tentativas podem ser executadas em servidores diferentes.

As transações não podem ser aninhadas - a InvalidTransactionOperation será gerada se esse método for chamado quando a sessão já tiver uma transação ativa.

Exceções geradas pelo bloco que não são derivadas do Mongo::Error interrompe o processamento, aborta a transação e é propagada fora de with_transaction. Exceções derivadas de Mongo::Error podem ser tratadas por with_transaction, resultando em novas tentativas do processo.

No momento, o with_transaction tentará novamente as confirmações e bloqueará as invocações até que pelo menos 120 segundos tenham se passado desde o início da execução do with_transaction. Esse tempo limite não é configurável e pode ser alterado em uma versão futura do driver.

Exemplos:

Executar uma declaração em uma transação

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

end

Executar uma declaração em uma transação, limitando o tempo 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:

  • opções (Hash) (padrão para: nil) —

    As opções para a transação que está sendo iniciada. Estas são as mesmas opções que start_transaction aceita.

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
 
# Arquivo 'lib/mongo/session.rb', linha 448

def with_transaction(opções = nada)
  se timeout_ms = (opções || {})[:timeout_ms]
    timeout_sec = timeout_ms / 1_000.0
    prazo = Utilidades.monotonic_time + timeout_sec
    @with_transaction_deadline = prazo
  elsif default_timeout_ms = @opções[:default_timeout_ms]
    timeout_sec = default_timeout_ms / 1_000.0
    prazo = Utilidades.monotonic_time + timeout_sec
    @with_transaction_deadline = prazo
  elsif @cliente.timeout_sec
    prazo = Utilidades.monotonic_time + @cliente.timeout_sec
    @with_transaction_deadline = prazo
  mais
    prazo = Utilidades.monotonic_time + 120
  end
  transaction_in_progress = false
  loop fazer
    commit_options = {}
    se opções
      commit_options[:write_concern] = opções[:write_concern]
    end
    start_transaction(opções)
    transaction_in_progress = true
    começar
      rv = rendimento auto
    salvar Exceção => e
      se dentro de_states?(STARTING_TRANSACTION_STATE, Transaction_in_progress_state)
        log_service("Cancelando a transação devido a #{e.class}: #{e}")
        @with_transaction_deadline = nada
        abort_transaction
        transaction_in_progress = false
      end

      se Utilidades.monotonic_time >= prazo
        transaction_in_progress = false
        aumentar
      end

      se e.is_a?(mongo::Erro) && e.rótulo?('TransientTransactionError')
        próximo
      end

      aumentar
    mais
      se dentro de_states?(Transaction_ABORTED_STATE, NO_TRANSACTION_STATE, Transaction_committed_state)
        transaction_in_progress = false
        Método rv
      end

      começar
        commit_transaction(commit_options)
        transaction_in_progress = false
        Método rv
      salvar mongo::Erro => e
        se e.rótulo?('UnknownTransactionCommitResult')
          se Utilidades.monotonic_time >= prazo ||
            e.is_a?(Erro::Falha de operação::família) && e.max_time_ms_expired?
          então
            transaction_in_progress = false
            aumentar
          end
          wc_options = caso v = commit_options[:write_concern]
            quando Escreva preocupação::Base
              v.opções
            quando nada
              {}
            mais
              v
            end
          commit_options[:write_concern] = wc_options.mesclar(w: :majority)
          tentar novamente
        elsif e.rótulo?('TransientTransactionError')
          se Utilidades.monotonic_time >= prazo
            transaction_in_progress = false
            aumentar
          end
          @state = NO_TRANSACTION_STATE
          próximo
        mais
          transaction_in_progress = false
          aumentar
        end
      salvar Erro::AuthError
        transaction_in_progress = false
        aumentar
      end
    end
  end

  # Nenhum valor de retorno oficial, mas retorne verdadeiro para que, em atividades interativas
  # use o método sugere que ele foi bem-sucedido.
  true
garantir
  se transaction_in_progress
    log_service('a chamada de resposta with_transaction quebrou o loop with_transaction, abortando a transação')
    começar
      abort_transaction
    salvar Erro::Falha de operação::família, Erro::Operação de transação inválida
    end
  end
  @with_transaction_deadline = nada
end