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 aplicativo - 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 :primário, :primary_preferred, :secundário, :secondary_preferred e :mais próximo.
  • :snapshot (verdadeiro | falso) —

    Configure a sessão para leituras de snapshots.

  • :snapshot_time (BSON::Timestamp) —

    O tempo de snapshot desejado para leituras de snapshots. Válido somente quando :snapshot for verdadeiro.

Desde:

  • 2.5.0



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
108
109
110
111
112
113
114
115
116
117
118
 
# Arquivo 'lib/mongo/session.rb', linha 82

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[:snapshot_time] && !opções[:snapshot]
    aumentar ArgumentError, ':snapshot_time só pode ser definido quando :snapshot for verdadeiro'
  end

  se opções[:snapshot_time] && !opções[:snapshot_time].is_a?(BSON::Timestamp)
    aumentar ArgumentError, ':snapshot_time deve ser um BSON::Timestamp'
  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
  @snapshot_timestamp = opções[:snapshot_time]
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



128
129
130
 
# Arquivo 'lib/mongo/session.rb', linha 128

def Cliente
  @cliente
end

#cluster ➤ Object (somente leitura)

Desde:

  • 2.5.0



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

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



141
142
143
 
# Arquivo 'lib/mongo/session.rb', linha 141

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



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

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



292
293
294
 
# Arquivo 'lib/mongo/session.rb', linha 292

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



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

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



298
299
300
 
# Arquivo 'lib/mongo/session.rb', linha 298

def recovery_token
  @recovery_token
end

#snapshot_timestamp ⇒ BSON::Timestamp | nil

Retorna o tempo de snapshot para esta sessão. nil se a sessão não for uma sessão de snapshot, ou se for uma sessão de snapshot para a qual nenhuma opção :snapshot_time foi fornecida e nenhuma leitura ainda capturou atClusterTime do servidor.

Retorna:

  • (BSON::Timestamp | nil) —

    O tempo de snapshot para esta sessão. nil se a sessão não for uma sessão de snapshot, ou se for uma sessão de snapshot para a qual nenhuma opção :snapshot_time foi fornecida e nenhuma leitura ainda capturou atClusterTime do servidor.

Desde:

  • 2.5.0



1287
1288
1289
 
# Arquivo 'lib/mongo/session.rb', linha 1287

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



1303
1304
1305
 
# Arquivo 'lib/mongo/session.rb', linha 1303

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



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
869
870
871
872
873
874
875
 
# Arquivo 'lib/mongo/session.rb', linha 810

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
        )
        rastreador.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
    rastreador.finish_transaction_span(auto)
    @state = Transaction_ABORTED_STATE
  salvar mongo::Erro::Operação de transação inválida
    aumentar
  salvar mongo::Erro
    rastreador.finish_transaction_span(auto)
    @state = Transaction_ABORTED_STATE
  salvar Exceção
    rastreador.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



906
907
908
 
# Arquivo 'lib/mongo/session.rb', linha 906

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



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

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



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

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



1029
1030
1031
1032
1033
 
# Arquivo 'lib/mongo/session.rb', linha 1029

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



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
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
 
# Arquivo 'lib/mongo/session.rb', linha 1044

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



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

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

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

Retorna o documento de consistência causal se o optime for conhecido e a consistência causal estiver ativada, caso contrário, retorna nulo.

Desde:

  • 2.5.0



1331
1332
1333
1334
1335
 
# Arquivo 'lib/mongo/session.rb', linha 1331

def causal_consistency_doc
  Método a menos que operation_time && causal_consistency?

  { afterClusterTime: operation_time }
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



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
789
790
791
792
793
794
795
 
# Arquivo 'lib/mongo/session.rb', linha 724

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)
        rastreador.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
    rastreador.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



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

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



150
151
152
 
# Arquivo 'lib/mongo/session.rb', linha 150

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



158
159
160
 
# Arquivo 'lib/mongo/session.rb', linha 158

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



385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
 
# Arquivo 'lib/mongo/session.rb', linha 385

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



255
256
257
 
# Arquivo 'lib/mongo/session.rb', linha 255

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



190
191
192
 
# Arquivo 'lib/mongo/session.rb', linha 190

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



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

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



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

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



1307
1308
1309
 
# Arquivo 'lib/mongo/session.rb', linha 1307

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



363
364
365
 
# Arquivo 'lib/mongo/session.rb', linha 363

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



1237
1238
1239
1240
1241
1242
1243
1244
1245
 
# Arquivo 'lib/mongo/session.rb', linha 1237

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



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

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



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

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



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

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



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

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



1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
 
# Arquivo 'lib/mongo/session.rb', linha 1197

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



210
211
212
 
# Arquivo 'lib/mongo/session.rb', linha 210

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

#retry_writes? ➤ true, false

Observação:

As gravações repetíveis só estão disponíveis com clusters, 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



225
226
227
 
# Arquivo 'lib/mongo/session.rb', linha 225

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



1148
1149
1150
1151
1152
 
# Arquivo 'lib/mongo/session.rb', linha 1148

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



267
268
269
270
271
272
273
274
275
276
277
278
279
280
 
# Arquivo 'lib/mongo/session.rb', linha 267

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



134
135
136
 
# Arquivo 'lib/mongo/session.rb', linha 134

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 é :primário.
  • :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



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

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 primário (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
  rastreador.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



878
879
880
 
# Arquivo 'lib/mongo/session.rb', linha 878

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



1112
1113
1114
1115
1116
1117
1118
1119
 
# Arquivo 'lib/mongo/session.rb', linha 1112

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



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

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



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

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

#txn_read_concern ⇒ com hash

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.

Obtenha o read concern que a sessão usará ao iniciar uma transação.

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

Exemplos:

Obtenha o read concern da transação da sessão.

session.txn_read_concern

Retorna:

  • (Hash) —

    O read concern usado para iniciar transações.

Desde:

  • 2.9.0



1322
1323
1324
1325
 
# Arquivo 'lib/mongo/session.rb', linha 1322

def txn_read_concern
  # O read concern é herdado do cliente, mas não do db ou da coleção.
  txn_options[:read_concern] || @cliente.read_concern
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



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

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



945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
 
# Arquivo 'lib/mongo/session.rb', linha 945

def desafixar(Conexão = nada)
  # Idempotente: se não houver estado fixado para limpar, não faça nada. Aninhado
  # unpin_maybe handlers (e.g. in BulkWrite#execute_operation wrapping an
  # Execução do OpMsg que já chama unpin_maybe em seu próprio do_execute)
  # pode chamar este método duas vezes para o mesmo erro; verificando a conexão
  # de volta ao pool uma segunda vez levantaria do pool.
  Método se @pinned_server.nada? && @pinned_connection.nada? && @pinned_connection_global_id.nada?

  @pinned_server = nada
  @pinned_connection_global_id = nada
  conn = Conexão || @pinned_connection
  se conn
    conn.desafixar(transação)
    # 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



978
979
980
981
982
983
984
985
986
987
988
 
# Arquivo 'lib/mongo/session.rb', linha 978

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



1158
1159
1160
1161
1162
1163
1164
1165
 
# Arquivo 'lib/mongo/session.rb', linha 1158

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



1180
1181
1182
1183
1184
 
# Arquivo 'lib/mongo/session.rb', linha 1180

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



1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
 
# Arquivo 'lib/mongo/session.rb', linha 1131

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



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
620
621
622
623
624
625
626
 
# Arquivo 'lib/mongo/session.rb', linha 458

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)
  # Quando o CSOT está ativado, temos um prazo definido pelo cliente; caso contrário
  # Recorrer ao prazo final padrão, 120 segundos.
  prazo = @with_transaction_deadline || (Utilidades.monotonic_time + 120)
  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, 'O tempo limite doCSOT 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, 'O tempo limite doCSOT 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, 'O tempo limite doCSOT 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, 'O tempo limite doCSOT 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, 'O tempo 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, 'O tempo 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, 'O tempo 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