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

'As sessões não são suportadas pelos servidores conectados.'
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, #with_overload_retry, #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 aplicação - os aplicativos criam explicitamente essas sessões e as encerram explicitamente. As sessões implícitas são criadas automaticamente pelo driver, e sua duração é 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; Valores válidos são:primary,:primary_preferred,:secondary,:secondary_preferred e:mais próximo.
  • :snapshot (verdadeiro | falso) —

    Configure a sessão para leituras de snapshots.

Desde:

  • 2.5.0



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# Arquivo 'lib/mongo/session.rb', linha 80

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
  elsif server_session.nada?
    aumentar ArgumentError, ' Asessão explícita deve fazer referência à sessão do servidor durante a construção'
  end

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

  # As sessões implícitas só precisam das opções do cluster e do cliente (nunca execute
  # transações), portanto, evite criar um clone Mongo::Client para evitar
  # vazamentos de memória: use o cliente original diretamente.
  @cliente = opções[:implicit] ? Cliente : Cliente.Usar(: admin)
  @cluster = @cliente.cluster
  @opções = opções.dup.congelar
  @cluster_time = nada
  @state = NO_TRANSACTION_STATE
  @with_transaction_deadline = nada
  @with_transaction_timeout_ms = nada
  @inside_with_transaction = false
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



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

def Cliente
  @cliente
end

#cluster ➤ Object (somente leitura)

Desde:

  • 2.5.0



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

def cluster
  @cluster
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



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

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



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

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



281
282
283
 
# Arquivo 'lib/mongo/session.rb', linha 281

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



275
276
277
 
# Arquivo 'lib/mongo/session.rb', linha 275

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



287
288
289
 
# Arquivo 'lib/mongo/session.rb', linha 287

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



1270
1271
1272
 
# Arquivo 'lib/mongo/session.rb', linha 1270

def snapshot_timestamp
  @snapshot_timestamp
end

#with_transaction_deadline ➤ 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 prazo da transação atual, se houver.

Retorna:

  • (Inteiro | nil) —

    O prazo para a transação atual, se houver.

Desde:

  • 2.5.0



1274
1275
1276
 
# Arquivo 'lib/mongo/session.rb', linha 1274

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



803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
 
# Arquivo 'lib/mongo/session.rb', linha 803

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|
        operação = (operação)::Comando.Novo(
          seletor: { abortar transação: 1 },
          db_name: 'admin',
          sessão: auto,
          txn_num: txn_num
        )
        tracer.rastreamento_operação(operação, Contexto, op_name: 'abortTransaction') fazer
          operação.execute_with_connection(Conexão, contexto: Contexto)
        end
      garantir
        desafixar
      end
    end

    # Conclua a extensão da transação antes de alterar o estado
    tracer.finish_transaction_span(auto)
    @state = Transaction_ABORTED_STATE
  salvar mongo::Erro::Operação de transação inválida
    aumentar
  salvar mongo::Erro
    tracer.finish_transaction_span(auto)
    @state = Transaction_ABORTED_STATE
  salvar Exceção
    tracer.finish_transaction_span(auto)
    @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



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

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



985
986
987
988
989
 
# Arquivo 'lib/mongo/session.rb', linha 985

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



1000
1001
1002
1003
1004
 
# Arquivo 'lib/mongo/session.rb', linha 1000

def add_start_transaction!(comando)
  comando.toque fazer |C|
    C[:startTransaction] = true se initial_transaction?
  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



1015
1016
1017
1018
1019
 
# Arquivo 'lib/mongo/session.rb', linha 1015

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, _read, 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



1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
 
# Arquivo 'lib/mongo/session.rb', linha 1030

def add_txn_opts!(comando, _read, 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.
    C[:readConcern] = Opções::Mapeador.transform_values_to_strings(C[:readConcern]) se C[:readConcern]

    se C[:commitTransaction] && (max_time_ms = txn_options[:max_commit_time_ms])
      C[:maxTimeMS] = max_time_ms
    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
    C[:writeConcern]&.excluir(:wtimeout) se Contexto&.csot?

    # Não devemos enviar uma preocupação de gravação vazia (padrão do servidor ).
    C.excluir(:writeConcern) se C[:writeConcern] && 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



1209
1210
1211
1212
1213
1214
1215
 
# Arquivo 'lib/mongo/session.rb', linha 1209

def advanced_operation_time(new_operation_time)
  @operation_time = se @operation_time
                      [ @operation_time, new_operation_time ].max
                    mais
                      new_operation_time
                    end
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



717
718
719
720
721
722
723
724
725
726
727
728
729
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 717

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]
      write_concern = Escreva preocupação.obter(write_concern) se write_concern && !write_concern.is_a?(Escreva preocupação::Base)

      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? && !Contexto.overload_only_retry?
          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 = (operação)::Comando.Novo(especificações)
        tracer.rastreamento_operação(operação, Contexto, op_name: ' commitTransaction ') fazer
          operação.execute_with_connection(Conexão, contexto: Contexto)
        end
      end
    end
    # Conclua a extensão da transação antes de alterar o estado
    tracer.finish_transaction_span(auto)
  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



891
892
893
 
# Arquivo 'lib/mongo/session.rb', linha 891

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



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

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



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

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



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

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
    # Liberar qualquer conexão fixada (por exemplo, após uma transação confirmada
    # no modo de carga balanceada ).
    desafixar se pinned_connection_global_id
    cluster.session_pool.checkin(@server_session) se @server_session
  end
garantir
  @server_session = nada
  @end = true
  @cliente = nada
end

#terminou? ➤ true, false

Se esta sessão terminou.

Exemplos:

session.ended?

Retorna:

  • (verdadeiro, falso) —

    Se a sessão terminou.

Desde:

  • 2.5.0



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

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



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

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



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

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



883
884
885
 
# Arquivo 'lib/mongo/session.rb', linha 883

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

#inside_with_transaction? ⇒ Boolean

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 estamos atualmente dentro de um bloqueio with_transaction.

Retorna:

  • (Booleano) —

    Se estamos atualmente dentro de um bloqueio with_transaction.

Desde:

  • 2.5.0



1278
1279
1280
 
# Arquivo 'lib/mongo/session.rb', linha 1278

def dentro_com_transação?
  @inside_with_transaction
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



352
353
354
 
# Arquivo 'lib/mongo/session.rb', linha 352

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:

Aumenta:

Desde:

  • 2.5.0



1223
1224
1225
1226
1227
1228
1229
1230
1231
 
# Arquivo 'lib/mongo/session.rb', linha 1223

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

  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)

Aumenta:

Desde:

  • 2.5.0



1234
1235
1236
1237
1238
 
# Arquivo 'lib/mongo/session.rb', linha 1234

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

  !@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.

Aumenta:

Desde:

  • 2.5.0



1249
1250
1251
1252
1253
 
# Arquivo 'lib/mongo/session.rb', linha 1249

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

  @server_session.próximo_txn_num
end

#pin_to_connection(connection_global_id, 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.

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

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

    O objeto de conexão ao qual fixar.

Aumenta:

  • (ArgumentError)

Desde:

  • 2.5.0



925
926
927
928
929
930
 
# Arquivo 'lib/mongo/session.rb', linha 925

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

  @pinned_connection_global_id = connection_global_id
  @pinned_connection = Conexão
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:

Aumenta:

  • (ArgumentError)

Desde:

  • 2.5.0



908
909
910
911
912
913
914
915
916
 
# Arquivo 'lib/mongo/session.rb', linha 908

def pin_to_server(Servidor)
  aumentar ArgumentError, 'Não é possível fixar em um servidor nil' se Servidor.nada?

  se Lint.habilitado? && !Servidor.mongos?
    aumentar Erro::LintError, "Tentativa de fixar a sessão no servidor #{servidor.resume} que não é um mongos"
  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



1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
 
# Arquivo 'lib/mongo/session.rb', linha 1183

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) && doc[:recoveryToken]
    auto.recovery_token = doc[:recoveryToken]
  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



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

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

#retry_writes? ➤ true, false

Observação:

As retryable writes só estão disponíveis 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



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

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

#revert_to_starting_transaction! ➤ 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.

Reverte o estado da sessão para STARTING_TRANSACTION_STATE. Chamado antes de tentar novamente o primeiro comando em uma transação para que startTransaction: true seja preservado na nova tentativa.

Desde:

  • 2.5.0



1134
1135
1136
1137
1138
 
# Arquivo 'lib/mongo/session.rb', linha 1134

def revert_to_starting_transaction!
  Método a menos que dentro de_states?(Transaction_in_progress_state)

  @state = STARTING_TRANSACTION_STATE
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



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

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

  # 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.
  aumentar Erro::SessionNotMaterialized a menos que materializado?

  @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



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

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 são:local,:majority e: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:

    • : modo -- preferência de leitura 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



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

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

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

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

  aumentar mongo::Erro::SnapshotSessionTransactionProhibited se snapshot?

  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
  tracer.start_transaction_span(auto)

  # 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



871
872
873
 
# Arquivo 'lib/mongo/session.rb', linha 871

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



1098
1099
1100
1101
1102
1103
1104
1105
 
# Arquivo 'lib/mongo/session.rb', linha 1098

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.

Aumenta:

Desde:

  • 2.6.0



1263
1264
1265
1266
1267
 
# Arquivo 'lib/mongo/session.rb', linha 1263

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

  @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



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

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



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

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



938
939
940
941
942
943
944
945
946
947
948
949
950
951
 
# Arquivo 'lib/mongo/session.rb', linha 938

def desafixar(Conexão = nada)
  @pinned_server = nada
  @pinned_connection_global_id = nada
  conn = Conexão || @pinned_connection
  se conn
    conn.desafixar(:transaction)
    # Apenas verifique a conexão de volta ao pool se nada mais
    # ainda mantém um pino nele (por exemplo, um cursor aberto).
    a menos que conn.fixado?
      conn.connection_pool.check_in(conn)
    end
  end
  @pinned_connection = 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



964
965
966
967
968
969
970
971
972
973
974
 
# Arquivo 'lib/mongo/session.rb', linha 964

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

  se commit_transaction? &&
     Erro.rótulo?('UnknownTransactionCommitResult')
    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



1144
1145
1146
1147
1148
1149
1150
1151
 
# Arquivo 'lib/mongo/session.rb', linha 1144

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



1166
1167
1168
1169
1170
 
# Arquivo 'lib/mongo/session.rb', linha 1166

def validar!(Cliente)
  check_if_end!
  check_matching_cluster!(Cliente)
  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 preferência de leitura de um comando seja primária.

Exemplos:

session.validate_read_preference!(command)

Aumenta:

Desde:

  • 2.6.0



1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
 
# Arquivo 'lib/mongo/session.rb', linha 1117

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]

  Método a menos que 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

#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



447
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
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
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
 
# Arquivo 'lib/mongo/session.rb', linha 447

def with_transaction(opções = nada)
  @inside_with_transaction = true
  @with_transaction_timeout_ms = opções&.dig(:timeout_ms) || @opções[:default_timeout_ms] || @cliente.timeout_ms
  @with_transaction_deadline = calcular_with_transaction_deadline(opções)
  prazo = se @with_transaction_deadline
               # CSOT ativado, então temos um prazo definido cliente .
               @with_transaction_deadline
             mais
               # CSOT não ativado, então usamos o prazo padrão, 120 segundos.
               Utilidades.monotonic_time + 120
             end
  transaction_in_progress = false
  transaction_attempt = 0
  last_error = nada
  overload_error_count = 0
  overflow_encountered = false

  loop fazer
    se transaction_attempt > 0
      se overflow_encountered
        atrasar = @cliente.retry_policy.backoff_delay(overload_error_count)
        se backoff_would_exceed_deadline?(prazo, atrasar)
          get_timeout_error_from(last_error, ' Otempo limite do CSOT expirou aguardando para tentar novamente com a Transação ')
        end
        aumentar(last_error) a menos que @cliente.retry_policy.should_retry_overload?(overload_error_count, atrasar)

        sono(atrasar)
      mais
        backoff = backoff_seconds_for_retry(transaction_attempt)
        se backoff_would_exceed_deadline?(prazo, backoff)
          get_timeout_error_from(last_error, ' Otempo limite do CSOT expirou aguardando para tentar novamente com a Transação ')
        end

        sono(backoff)
      end
    end

    commit_options = {}
    commit_options[:write_concern] = opções[:write_concern] se opções
    start_transaction(opções)
    transaction_in_progress = true
    transaction_attempt += 1

    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}")
        # CSOT: se o prazo já tiver expirado, limpe-o para que
        # abort_transaction usa um novo tempo limite (não o prazo expirado).
        # Se o prazo ainda não tiver expirado, mantenha-o para que o cancelamento use o tempo restante.
        @with_transaction_deadline = nada se @with_transaction_deadline && deadline_expired?(prazo)
        abort_transaction
        transaction_in_progress = false
      end

      se deadline_expired?(prazo)
        transaction_in_progress = false
        get_timeout_error_from(e, ' Otempo limite do CSOT expirou durante a chamada de resposta withTransaction ')
      end

      se e.is_a?(mongo::Erro) && e.rótulo?('TransientTransactionError')
        last_error = e
        se e.rótulo?('SystemOverloadedError')
          overflow_encountered = true
          overload_error_count += 1
        elsif overflow_encountered
          overload_error_count += 1
        end
        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

      # CSOT: se o tempo limite expirou antes de podermos confirmar, interrompa o
      # transação em vez disso e gere um erro de tempo limite do lado do cliente .
      se @with_transaction_deadline && deadline_expired?(prazo)
        transaction_in_progress = false
        @with_transaction_deadline = nada
        abort_transaction
        aumentar mongo::Erro::Erro de tempo limite, ' Otempo limite do CSOT expirou antes que a transação pudesse ser confirmada '
      end

      começar
        commit_transaction(commit_options)
        transaction_in_progress = false
        Método rv
      salvar mongo::Erro => e
        se e.rótulo?('UnknownTransactionCommitResult')
          se deadline_expired?(prazo) ||
             (e.is_a?(Erro::Falha de operação::família) && e.max_time_ms_expired?)
            transaction_in_progress = false

            aumentar a menos que @with_transaction_timeout_ms && deadline_expired?(prazo)

            get_timeout_error_from(e, ' Otempo limite de CSOT expirou durante o commit do withTransaction ')
          end

          se e.rótulo?('SystemOverloadedError')
            overflow_encountered = true
            overload_error_count += 1
          elsif overflow_encountered
            overload_error_count += 1
          end

          se overflow_encountered
            atrasar = @cliente.retry_policy.backoff_delay(overload_error_count)
            se backoff_would_exceed_deadline?(prazo, atrasar)
              transaction_in_progress = false
              get_timeout_error_from(e, ' Otempo limite de CSOT expirou durante o commit do withTransaction ')
            end
            a menos que @cliente.retry_policy.should_retry_overload?(overload_error_count, atrasar)
              transaction_in_progress = false
              aumentar
            end
            sono(atrasar)
          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
            get_timeout_error_from(e, ' Otempo limite de CSOT expirou durante o commit do withTransaction ')
          end
          last_error = e
          se e.rótulo?('SystemOverloadedError')
            overflow_encountered = true
            overload_error_count += 1
          elsif overflow_encountered
            overload_error_count += 1
          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
  @with_transaction_timeout_ms = nada
  @inside_with_transaction = false
end