Classe: Mongo::Session

Herda:
Objeto
  • Objeto
mostrar tudo
Estendido por:
Encaminhável
Inclui:
ClusterTime::Consumer, Loggable, Retryable
Definido em:
build/ruby-driver-v2.19/lib/mongo/session.rb,
build/ruby-driver-v2.19/lib/mongo/session/session_pool.rb,
build/ruby-driver-v2.19/lib/mongo/session/server_session.rb

Visão geral

Observação:

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

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

Desde:

  • 2.5.0

Definido sob namespace

Classes: ServerSession, SessionPool

Colapsode resumo constante

MISMATCHED_CLUSTER_ERROR_MSG =

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

Desde:

  • 2.5.0

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

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

Desde:

  • 2.5.0

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

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

Desde:

  • 2.5.0

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

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

Desde:

  • 2.6.0

:no_transaction
STARTING_TRANSACTION_STATE =

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

Desde:

  • 2.6.0

:starting_transaction
Transaction_in_progress_state =

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

Desde:

  • 2.6.0

:transaction_in_progress
Transaction_committed_state =

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

Desde:

  • 2.6.0

:transaction_committed
Transaction_ABORTED_STATE =

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

Desde:

  • 2.6.0

:transaction_aborted
UNLABELED_WRITE_CONCERN_CODES =

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

Desde:

  • 2.5.0

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

Constantes incluídas do Loggable

Loggable::Prefix

Recolhimento do Resumo do atributo de instância

Atributos incluídos do ClusterTime::Consumer

#cluster_time

Recolhimento do Resumo do método de instância

Métodos incluídos do ClusterTime::Consumer

#advance_cluster_time

Métodos incluídos no Loggable

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

Métodos incluídos no Retryable

#read_worker, #select_server, #write_worker

Detalhes do construtor

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

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

Observação:

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

Inicialize uma sessão.

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

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

Parâmetros:

  • server_session (ServerSession | nil) —

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

  • Cliente (Cliente) —

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

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

    As opções para esta sessão.

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

  • :causal_consistency (true|false) —

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

  • :default_transaction_options (Hash) —

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

  • :implicit (true|false) —

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

  • :read_preference (Hash) —

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

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

  • :snapshot (verdadeiro | falso) —

    Configure a sessão para leituras de snapshots.

Desde:

  • 2.5.0



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 77

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

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

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

  @cliente = Cliente.Usar(: admin)
  @opções = opções.dup.congelar
  @cluster_time = nada
  @state = NO_TRANSACTION_STATE
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



109
110
111
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 109

def Cliente
  @cliente
end

#operation_time ➤ BSON::Timestamp (readonly)

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

Retorna:

  • (BSON::Timestamp) —

    O último optime visto para esta sessão.

Desde:

  • 2.5.0



124
125
126
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 124

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



104
105
106
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 104

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



260
261
262
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 260

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



254
255
256
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 254

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



266
267
268
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 266

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



1120
1121
1122
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 1120

def snapshot_timestamp
  @snapshot_timestamp
end

Detalhes do método de instância

#abort_transaction ➤ Objeto

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

Exemplos:

Abortar a transação.

session.abort_transaction

Aumenta:

Desde:

  • 2.6.0



672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 672

def abort_transaction
  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

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

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

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

#aborting_transaction? ➤ verdadeiro | false

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

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

Retorna:

  • (verdadeiro | falso) —

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

Desde:

  • 2.5.0



755
756
757
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 755

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



835
836
837
838
839
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 835

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



850
851
852
853
854
855
856
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 850

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

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

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

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

Exemplos:

session.add_txn_num!(cmd)

Retorna:

  • (Hash, BSON::Document) —

    O documento de comando.

Desde:

  • 2.6.0



867
868
869
870
871
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 867

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

#add_txn_opts!(comando, leitura) ➤ 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



882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 882

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

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

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

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

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



1051
1052
1053
1054
1055
1056
1057
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 1051

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

#cluster ⇒ Object

Desde:

  • 2.5.0



111
112
113
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 111

def cluster
  @cliente.cluster
end

#commit_transaction(options = nil) ➤ Object

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

Exemplos:

Confirma a transação.

session.commit_transaction

Parâmetros:

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

    um conjunto personalizável de opções

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

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

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

Aumenta:

Desde:

  • 2.6.0



599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 599

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

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

  opções ||= {}

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

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

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

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

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

#commit_transaction? ➤ verdadeiro | false

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

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

Retorna:

  • (verdadeiro | falso) —

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

Desde:

  • 2.5.0



747
748
749
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 747

def commit_transaction?
  !!@committed_transaction
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



353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 353

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

#terminou? ➤ true, false

Se esta sessão terminou.

Exemplos:

session.ended?

Retorna:

  • (verdadeiro, falso) —

    Se a sessão terminou.

Desde:

  • 2.5.0



219
220
221
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 219

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



154
155
156
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 154

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



142
143
144
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 142

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



739
740
741
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 739

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

#inspecionar ➤ string

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

Exemplos:

Inspecione o objeto de sessão.

session.inspect

Retorna:

  • (string) —

    A inspeção da sessão.

Desde:

  • 2.5.0



331
332
333
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 331

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

#materialize_if_needed ➤ Sessão

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

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

Retorna:

Desde:

  • 2.5.0



1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 1065

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

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

  @server_session = cluster.session_pool.checkout

  auto
end

#materializado? ➤ Booleano

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

Retorna:

  • (Booleano)

Desde:

  • 2.5.0



1078
1079
1080
1081
1082
1083
1084
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 1078

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

  !@server_session.nada?
end

#próximo_txn_num ➤ Inteiro

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

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

Exemplos:

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

session.next_txn_num

Retorna:

  • (Inteiro) —

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

Desde:

  • 2.5.0



1095
1096
1097
1098
1099
1100
1101
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 1095

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

  @server_session.próximo_txn_num
end

#pin_to_connection(connection_global_id) ➤ Objeto

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

Fixa esta sessão na conexão especificada.

esta sessão para.

Parâmetros:

  • connection_global_id (Inteiro) —

    O ID global da conexão com o pino

Desde:

  • 2.5.0



782
783
784
785
786
787
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 782

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

#pin_to_server(servidor) ➤ Objeto

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

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

Parâmetros:

Desde:

  • 2.5.0



764
765
766
767
768
769
770
771
772
773
774
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 764

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

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

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

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

Exemplos:

Processe uma resposta do servidor.

session.process(result)

Parâmetros:

Retorna:

Desde:

  • 2.5.0



1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 1023

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

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

  Resultado
end

#retry_reads? ➤ Booleano

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

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

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

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

Retorna:

  • (Booleano)

Desde:

  • 2.5.0



174
175
176
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 174

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

#retry_writes? ➤ true, false

Observação:

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

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

Exemplos:

As gravações serão repetidas.

session.retry_writes?

Retorna:

  • (verdadeiro, falso) —

    As gravações serão repetidas.

Desde:

  • 2.5.0



189
190
191
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 189

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

#session_id ⇒ BSON::Document

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

Retorna:

  • (BSON::Document) —

    O ID da sessão do servidor .

Aumenta:

Desde:

  • 2.5.0



231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 231

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

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

  @server_session.session_id
end

#snapshot? ➤ verdadeiro | false

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

Retorna:

  • (verdadeiro | falso) —

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

Desde:

  • 2.5.0



117
118
119
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 117

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.

  • :read_concern (Hash) —

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

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

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

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

  • :read (Hash) —

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

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

Aumenta:

Desde:

  • 2.6.0



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
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 540

def start_transaction(opções = nada)
  se opções
    Lint.validate_read_concern_option(opções[:read_concern])

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

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

  check_if_end!

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

  desafixar

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

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

  @state = STARTING_TRANSACTION_STATE
  @already_committed = false

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

#initial_transaction? ➤ Booleano

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

Retorna:

  • (Booleano)

Desde:

  • 2.5.0



727
728
729
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 727

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



948
949
950
951
952
953
954
955
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 948

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

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

#txn_num ➤ Inteiro

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

Exemplos:

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

session.txn_num

Retorna:

  • (Inteiro) —

    O número da transação atual.

Desde:

  • 2.6.0



1111
1112
1113
1114
1115
1116
1117
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 1111

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

  @server_session.txn_num
end

#txn_options ➤ Hash

nesta sessão.

Retorna:

  • (Hash) —

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

Desde:

  • 2.6.0



130
131
132
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 130

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



204
205
206
207
208
209
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 204

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



795
796
797
798
799
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 795

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

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

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

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

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

Parâmetros:

  • Erro (Erro) —

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

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

    Conexão para desafixar.

Desde:

  • 2.5.0



812
813
814
815
816
817
818
819
820
821
822
823
824
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 812

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

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

#update_state! ⇒ Object

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

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

Desde:

  • 2.6.0



984
985
986
987
988
989
990
991
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 984

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



1006
1007
1008
1009
1010
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 1006

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

#validate_read_preference!(comando) 3 Objeto

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

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

Exemplos:

session.validate_read_preference!(command)

Aumenta:

Desde:

  • 2.6.0



967
968
969
970
971
972
973
974
975
976
977
978
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 967

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

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

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

#with_transaction(options = nil) ➤ Object

Observação:

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

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

Retorna o valor de retorno do bloco.

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

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

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

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

Exemplos:

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

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

end

Executar uma declaração em uma transação, limitando o tempo total consumido

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

  end
end

Parâmetros:

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

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

Aumenta:

Desde:

  • 2.7.0



424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
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
 
# File 'build/ruby-driver-v2.19/lib/mongo/session.rb', linha 424

def with_transaction(opções=nada)
  # Não configurável 120 segundo tempo limite para toda a operação
  prazo = Utilidades.monotonic_time + 120
  transaction_in_progress = false
  loop fazer
    commit_options = {}
    se opções
      commit_options[:write_concern] = opções[:write_concern]
    end
    start_transaction(opções)
    transaction_in_progress = true
    começar
      rv = rendimento auto
    salvar Exceção => e
      se dentro de_states?(STARTING_TRANSACTION_STATE, Transaction_in_progress_state)
        log_service("Cancelando a transação devido a #{e.class}: #{e}")
        abort_transaction
        transaction_in_progress = false
      end

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

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

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

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

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