클래스: Mongo::Session

상속:
객체
  • 객체
모두 표시
확장자:
전달 가능
다음을 포함합니다.
ClusterTime::Consumer, Loggable, Retryable
다음에 정의됨:
lib/ Mongo/session.rb,
lib/ Mongo/session/session_pool.rb,
lib/ Mongo/session/server_session.rb,
lib/ Mongo/session/server_session/dirtyable.rb

개요

참고:

세션 객체는 스레드로부터 안전하지 않습니다. 애플리케이션 은 한 번에 하나의 스레드 또는 프로세스 의 세션만 사용할 수 있습니다.

어떤 방식으로든 관련된 애플리케이션 에서 실행되는 설정하다 의 순차적 작업을 나타내는 논리적 세션입니다.

이후:

  • 2.5.0

네임스페이스 아래에 정의됨

클래스: ServerSession, SessionPool

상수 요약 접기

MISMATCHED_CLUSTER_ERROR_MSG =

현재 사용 중인 클라이언트 와 다른 클러스터 를 가진 클라이언트 에서 세션을 조회했음을 나타내는 오류 메시지입니다.

이후:

  • 2.5.0

'이 세션을 생성하는 데 사용된 클라이언트 의 구성이 ' +
'이 작업을 소유한 클라이언트의 입니다. 이 세션은 상위 ' +
'클라이언트.'
SESSION_ENDED_ERROR_MSG =

세션이 이미 종료되었기 때문에 사용할 수 없음을 설명하는 오류 메시지입니다.

이후:

  • 2.5.0

'이 세션이 종료되어 사용할 수 없습니다. 새로 생성하세요.'
SESSIONS_NOT_SUPPORTED =
더 이상 사용되지 않습니다.

서버 버전에서 세션을 지원하지 않는다는 내용의 오류 메시지입니다.

이후:

  • 2.5.0

'연결된 서버에서 세션을 지원하지 않습니다.'
NO_TRANSACTION_STATE =

마지막 작업이 트랜잭션과 관련이 없거나 아직 작업이 발생하지 않은 세션의 상태입니다.

이후:

  • 2.6.0

:no_transaction
STARTING_TRANSACTION_STATE =

사용자가 트랜잭션 을 시작했지만 트랜잭션 내에서 아직 작업이 발생하지 않은 세션 상태 입니다.

이후:

  • 2.6.0

:starting_transaction
TRANSACTION_IN_PROGRESS_STATE =

트랜잭션 이 시작되었고 하나 이상의 작업이 발생했지만 트랜잭션 이 아직 커밋되거나 중단되지 않은 세션 상태 입니다.

이후:

  • 2.6.0

:transaction_in_progress
TRANSACTION_COMMITTED_STATE =

마지막으로 실행된 작업이 트랜잭션 커밋인 세션의 상태입니다.

이후:

  • 2.6.0

:transaction_committed
TRANSACTION_ABORTED_STATE =

마지막으로 실행된 작업이 트랜잭션 중단이었던 세션의 상태입니다.

이후:

  • 2.6.0

:transaction_aborted
UNLABELED_WRITE_CONCERN_CODES =

이 상수는 비공개 API의 일부입니다. 이 상수는 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

이후:

  • 2.5.0

[
  79,  # UnknownReplWriteConcern
  100, #CanCanSatisfyWriteConcern,
].동결

Loggable에서 포함된 상수

Loggable::prefix

인스턴스 속성 요약 접기

ClusterTime::Consumer에 포함된 속성

#cluster_time

인스턴스 메서드 요약 접기

ClusterTime::Consumer에 포함된 메서드

#advance_cluster_time

Loggable에 포함된 메서드

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

Retryable에 포함된 메서드

#read_Worker, #select_server, #with_overload_retry, #write_Worker

생성자 세부 정보

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

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

참고:

애플리케이션은 Client#start_session을 사용하여 세션을 시작해야 합니다. 이 생성자는 내부 운전자 전용입니다.

세션을 초기화합니다.

세션은 명시적 또는 암시적일 수 있습니다. 명시적 세션의 수명은 애플리케이션 에서 managed 하며, 애플리케이션은 이러한 세션을 명시적으로 생성하고 종료합니다. 암시적 세션은 드라이버 에 의해 자동으로 생성되며, 세션의 수명은 드라이버 에 의해 managed 됩니다.

암시적 세션이 생성되면 해당 세션과 연결된 서버 세션을 가질 수 없습니다. 이 세션을 사용하는 작업이 실제로 실행되면 서버 세션이 세션 풀에서 체크아웃됩니다. 명시적 세션이 생성될 때는 이미 할당된 서버 세션을 참조해야 합니다.

매개변수:

  • server_session (ServerSession | nil) —

    이 세션과 연결된 서버 세션입니다. :implicit 옵션이 true이면 이 값은 nil이어야 합니다.

  • 고객 (클라이언트) —

    이 세션이 생성되는 데 사용되는 클라이언트 입니다.

  • 옵션 (해시) (기본값: {}) —

    이 세션의 옵션입니다.

옵션 해시(options):

  • :causal_consistency (true|false) —

    이 세션에 인과적 일관성을 활성화할지 여부입니다.

  • :default_timeout_ms (정수) —

    세션에서 실행된 다음 작업에 대한 timeoutMS 값입니다.

    • commitTransaction()
    • abortTransaction
    • withTransaction
    • endSession
  • :default_transaction_options (해시) —

    기본적으로 start_transaction에 전달할 옵션에는 start_transaction이 허용하는 모든 옵션이 포함될 수 있습니다.

  • :implicit (true|false) —

    내부 운전자 전용 - 세션이 암시적인지 여부를 지정합니다. 이 경우 server_session은 nil이 됩니다. 이는 연결이 체크아웃된 후에만 서버 세션이 체크아웃되도록 하기 위한 것입니다.

  • :read_preference (해시) —

    다음과 같은 선택적 키가 포함된 읽기 설정 옵션 해시:

    • :모드 -- **string** 또는 기호로 읽기 설정 (read preference). 유효한 값은 :프라이머리, :primary_preferred, :세컨더리, :secondary_preferred 및 :nearest입니다.
  • : 스냅샷 (true | false) —

    스냅샷 읽기를 위한 세션을 설정합니다.

이후:

  • 2.5.0



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

def 초기화(server_session, 고객, 옵션 = {})
  만약 옵션[:causal_consistency] && 옵션[: 스냅샷]
    올리다 ArgumentError, ':causal_consistency 및 :snapshot 옵션을 둘 다 설정할 수 없습니다.
  end

  만약 옵션[:implicit]
    하지 않는 한 server_session.nil?
      올리다 ArgumentError, '암시적 세션은 구성 중에 서버 세션을 참조할 수 없습니다. '
    end
  elsif server_session.nil?
    올리다 ArgumentError, '명시적 세션은 구성 중에 서버 세션을 참조해야 합니다. '
  end

  @server_session = server_session
  옵션 = 옵션.dup

  # 암시적 세션에는 클러스터 및 클라이언트 옵션만 필요합니다( 실행 하지 않음
  트랜잭션 #개)이므로 Mongo::Client 복제본을 생성하지 않도록
  # 메모리 누수: 대신 원래 클라이언트 직접 사용합니다.
  @client = 옵션[:implicit] ? 고객 : 고객.메서드를(: admin)
  @cluster = @client.cluster
  @options = 옵션.dup.동결
  @cluster_time = nil
  @ 상태 = NO_TRANSACTION_STATE
  @with_transaction_deadline = nil
  @with_transaction_timeout_ms = nil
  @inside_with_transaction = 거짓
end

인스턴스 속성 세부 정보

#클라이언트 ⇒ 클라이언트 (읽기 전용)

이 세션이 생성된 클라이언트를 반환합니다.

반환합니다:

이후:

  • 2.5.1



117
118
119
 
# 파일 'lib/ Mongo/session.rb', 117줄

def 고객
  @client
end

#cluster ⇒ 객체 (읽기 전용)

이후:

  • 2.5.0



119
120
121
 
# 파일 'lib/ Mongo/session.rb', 119줄

def cluster
  @cluster
end

#operation_time ⇒ BSON::Timestamp (읽기 전용)

이 세션에 대해 가장 최근에 본 optime 을 반환합니다.

반환합니다:

  • (BSON::Timestamp) —

    이 세션의 가장 최근에 본 optime 입니다.

이후:

  • 2.5.0



130
131
132
 
# 파일 'lib/ Mongo/session.rb', 130줄

def operation_time
  @operation_time
end

#options ⇒ 해시 (읽기 전용)

이 세션에 대한 옵션을 반환합니다.

반환합니다:

  • (해시) —

    이 세션의 옵션입니다.

이후:

  • 2.5.0



112
113
114
 
# 파일 'lib/ Mongo/session.rb', 112줄

def 옵션
  @options
end

#pinned_connection_global_id ⇒ 정수 | nil (읽기 전용)

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

이 세션이 고정된 연결 글로벌 ID(있는 경우)를 반환합니다.

반환합니다:

  • (정수 | nil) —

    이 세션이 고정되는 연결 전역 ID(있는 경우)입니다.

이후:

  • 2.5.0



281
282
283
 
# 파일 'lib/ Mongo/session.rb', 281줄

def pinned_connection_global_id
  @pinned_connection_global_id
end

#pinned_server ⇒ MongoDB 서버 | nil (읽기 전용)

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

이 세션이 고정된 서버 ( mongos)를 반환합니다(있는 경우).

반환합니다:

  • (MongoDB Server | nil) —

    이 세션이 고정되는 서버 ( mongos)입니다(있는 경우).

이후:

  • 2.5.0



275
276
277
 
# 파일 'lib/ Mongo/session.rb', 275줄

def pinned_server
  @pinned_server
end

#recovery_token ⇒ BSON::Document | nil

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

이 세션에서 실행 중인 샤딩된 트랜잭션 에 대한 복구 토큰을 반환합니다(있는 경우).

반환합니다:

  • (BSON::Document | nil) —

    이 세션에서 실행 중인 샤드 트랜잭션에 대한 복구 토큰(있는 경우)입니다.

이후:

  • 2.5.0



287
288
289
 
# 파일 'lib/ Mongo/session.rb', 287줄

def recovery_token
  @recovery_token
end

#snapshot_timestamp ⇒ 객체

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

이후:

  • 2.5.0



1270
1271
1272
 
# 파일 'lib/ Mongo/session.rb', 1270줄

def snapshot_timestamp
  @snapshot_timestamp
end

#with_transaction_deadline ⇒ 정수 | nil (읽기 전용)

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

현재 트랜잭션 의 기한(있는 경우)을 반환합니다.

반환합니다:

  • (정수 | nil) —

    현재 트랜잭션 의 기한(있는 경우)입니다.

이후:

  • 2.5.0



1274
1275
1276
 
# 파일 'lib/ Mongo/session.rb', 1274줄

def with_transaction_deadline
  @with_transaction_deadline
end

인스턴스 메서드 세부 정보

#abort_transaction(options = nil) ⇒ 객체

데이터베이스 를 변경하지 않고 현재 활성 트랜잭션 을 중단합니다.

예시:

트랜잭션 을 중단합니다.

session.abort_transaction

매개변수:

  • 옵션 (해시) (기본값: nil) —

    사용자 지정 가능한 옵션 세트

옵션 해시(options):

  • :timeout_ms (정수) —

    작업 시간 제한(밀리초)입니다. 음수가 아닌 정수여야 합니다. 0 의 명시적 값은 무한대를 의미합니다. 기본값 은 설정되지 않았으며, 이는 값이 클라이언트 로부터 상속됨을 의미합니다.

다음을 발생시킵니다.

이후:

  • 2.6.0



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

def abort_transaction(옵션 = nil)
  쿼리 캐시.지우기

  check_if_ended!
  check_if_no_transaction!

  만약 into_states?(TRANSACTION_COMMITTED_STATE)
    올리다 mongo::오류::InvalidTransactionOperation.신규(
      mongo::오류::InvalidTransactionOperation.can_call_after_msg(
        :commitTransaction, :abortTransaction
      )
    )
  end

  만약 into_states?(TRANSACTION_ABORTED_STATE)
    올리다 mongo::오류::InvalidTransactionOperation.신규(
      mongo::오류::InvalidTransactionOperation.can_call_twice_msg(:abortTransaction)
    )
  end

  옵션 ||= {}

  시작
    하지 않는 한 startup_transaction?
      @aborting_transaction = true
      컨텍스트 = 작업::Context.신규(
        클라이언트: @client,
        세션: self,
        operation_timeout: operation_timeout(옵션)
      )
      write_with_retry(txn_options[:write_concern],
                       end_transaction: true, 컨텍스트: 컨텍스트) do |연결, txn_num, 컨텍스트|
        작업 = 작업::명령.신규(
          선택기: { abortTransaction: 1 },
          db_name: 'admin',
          세션: self,
          txn_num: txn_num
        )
        추적 프로그램.trace_operation(작업, 컨텍스트, op_name: 'abortTransaction') do
          작업.execution_with_connection(연결, 컨텍스트: 컨텍스트)
        end
      보장
        고정 해제
      end
    end

    # 상태 변경하기 전에 트랜잭션 범위를 완료합니다.
    추적 프로그램.finish_transaction_span(self)
    @ 상태 = TRANSACTION_ABORTED_STATE
  구출 mongo::오류::InvalidTransactionOperation
    올리다
  구출 mongo::오류
    추적 프로그램.finish_transaction_span(self)
    @ 상태 = TRANSACTION_ABORTED_STATE
  구출 예외
    추적 프로그램.finish_transaction_span(self)
    @ 상태 = TRANSACTION_ABORTED_STATE
    올리다
  보장
    @aborting_transaction = 거짓
  end

  # 공식 반환 값은 없지만 true를 반환하므로 인터랙티브
  # 성공했음을 알리는 메서드 힌트를 사용합니다.
  true
end

#aborting_transaction? ⇒ true | false

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

반환값 세션이 현재 트랜잭션을 중단하고 있는지 여부를 반환합니다.

반환합니다:

  • (true | false) —

    세션이 현재 트랜잭션 을 중단하고 있는지 여부입니다.

이후:

  • 2.5.0



899
900
901
 
# 파일 'lib/ Mongo/session.rb', 899줄

def aborting_transaction?
  !!@aborting_transaction
end

#add_autocommit!(명령) ⇒ 해시, BSON::Document

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

해당하는 경우 명령 문서에 자동 커밋 필드를 추가합니다.

예시:

session.add_autocommit!(cmd)

반환합니다:

  • (Hash, BSON::Document) —

    명령 문서.

이후:

  • 2.6.0



985
986
987
988
989
 
# 파일 'lib/ Mongo/session.rb', 985줄

def add_autocommit!(명령)
  명령.탭 do |C|
    C[:autocommit] = 거짓 만약 in_transaction?
  end
end

#add_start_transaction!(명령) ⇒ 해시, BSON::Document

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

해당하는 경우 명령 문서에 startTransaction 필드를 추가합니다.

예시:

session.add_start_transaction!(cmd)

반환합니다:

  • (Hash, BSON::Document) —

    명령 문서.

이후:

  • 2.6.0



1000
1001
1002
1003
1004
 
# 파일 'lib/ Mongo/session.rb', 1000줄

def add_start_transaction!(명령)
  명령.탭 do |C|
    C[:startTransaction] = true 만약 startup_transaction?
  end
end

#add_txn_num!(명령) ⇒ 해시, BSON::Document

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

해당하는 경우 명령 문서에 트랜잭션 번호를 추가합니다.

예시:

session.add_txn_num!(cmd)

반환합니다:

  • (Hash, BSON::Document) —

    명령 문서.

이후:

  • 2.6.0



1015
1016
1017
1018
1019
 
# 파일 'lib/ Mongo/session.rb', 1015줄

def add_txn_num!(명령)
  명령.탭 do |C|
    C[:txnNumber] = BSON::Int64.신규(@server_session.txn_num) 만약 in_transaction?
  end
end

#add_txn_opts!(명령, _read, 컨텍스트) ⇒ 해시, BSON::Document

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

해당하는 경우 트랜잭션 옵션을 추가합니다.

예시:

session.add_txn_opts!(cmd)

반환합니다:

  • (Hash, BSON::Document) —

    명령 문서.

이후:

  • 2.6.0



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

def add_txn_opts!(명령, _read, 컨텍스트)
  명령.탭 do |C|
    # 트랜잭션을 시작하는 모든 명령에 읽기 고려를 추가해야 합니다.
    만약 startup_transaction?
      # https://jira.mongodb.org/browse/spec-1161: 트랜잭션의
      # 읽기 고려는 컬렉션/데이터베이스/클라이언트 읽기 고려를 재정의합니다.
      # 트랜잭션의 읽기 고려가 설정되지 않은 경우에도 마찬가지입니다.
      # 여기서 읽기 고려는 서버 로 전송되는 고려이며
      # afterClusterTime을 포함합니다.
      만약 rc = C[:readConcern]
        rc = rc.dup
        rc.삭제(:level)
      end
      만약 txn_read_concern
        만약 rc
          rc.update(txn_read_concern)
        other
          rc = txn_read_concern.dup
        end
      end
      만약 rc.nil? || rc.비어 있나요?
        C.삭제(:readConcern)
      other
        C[:readConcern] = 옵션::매퍼.transform_values_to_strings(rc)
      end
    end

    # 읽기 고려 수준을 기호가 아닌 string 로 보내야 합니다.
    C[:readConcern] = 옵션::매퍼.transform_values_to_strings(C[:readConcern]) 만약 C[:readConcern]

    만약 C[:commitTransaction] && (max_time_ms = txn_options[:max_commit_time_ms])
      C[:maxTimeMS] = max_time_ms
    end

    # 쓰기 고려 (write concern) 고려는 모든 abortTransaction 또는 commitTransaction 명령에 추가되어야 합니다.
    만약 C[:abortTransaction] || C[:commitTransaction]
      만약 @already_committed
        wc = BSON::문서.신규(C[:writeConcern] || txn_write_concern || {})
        wc.병합!(w: :majority)
        wc[:wtimeout] ||= 10_000
        C[:writeConcern] = wc
      elsif txn_write_concern
        C[:writeConcern] ||= txn_write_concern
      end
    end

    # 숫자가 아닌 쓰기 고려 w 값은 기호가 아닌 string 로 전송되어야 합니다.
    만약 C[:writeConcern] && C[:writeConcern][:w] && C[:writeConcern][:w].is_a?(기호)
      C[:writeConcern][:w] = C[:writeConcern][:w].to_s
    end

    # Ignore wtimeout if csot
    C[:writeConcern]&.삭제(:wtimeout) 만약 컨텍스트&.csot?

    # 빈(서버 기본값) 쓰기 고려 (write concern) 보내지 않아야 합니다.
    C.삭제(:writeConcern) 만약 C[:writeConcern] && C[:writeConcern].비어 있나요?
  end
end

#advanced_operation_time(new_operation_time) ⇒ BSON::Timestamp

이 세션의 캐시된 optime을 앞당깁니다.

예시:

optime을 앞당깁니다.

session.advance_operation_time(timestamp)

매개변수:

  • new_operation_time (BSON::Timestamp) —

    새 optime.

반환합니다:

  • (BSON::Timestamp) —

    현재 시간과 새 시간을 고려한 최대 optime 입니다.

이후:

  • 2.5.0



1209
1210
1211
1212
1213
1214
1215
 
# 파일 'lib/ Mongo/session.rb', 1209줄

def advanced_operation_time(new_operation_time)
  @operation_time = 만약 @operation_time
                      [ @operation_time, new_operation_time ].최대
                    other
                      new_operation_time
                    end
end

#commit_transaction(options = nil) ⇒ 객체

세션에서 현재 활성 트랜잭션 을 커밋합니다.

예시:

트랜잭션을 커밋합니다.

session.commit_transaction

매개변수:

  • 옵션 (해시) (기본값: nil) —

    사용자 지정 가능한 옵션 세트

옵션 해시(options):

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

    이 작업에 사용할 쓰기 고려입니다.

  • :timeout_ms (정수) —

    작업 시간 제한(밀리초)입니다. 음수가 아닌 정수여야 합니다. 0 의 명시적 값은 무한대를 의미합니다. 기본값 은 설정되지 않았으며, 이는 값이 클라이언트 로부터 상속됨을 의미합니다.

다음을 발생시킵니다.

이후:

  • 2.6.0



717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
 
# 파일 'lib/ Mongo/session.rb', 717줄

def commit_transaction(옵션 = nil)
  쿼리 캐시.지우기
  check_if_ended!
  check_if_no_transaction!

  만약 into_states?(TRANSACTION_ABORTED_STATE)
    올리다 mongo::오류::InvalidTransactionOperation.신규(
      mongo::오류::InvalidTransactionOperation.can_call_after_msg(
        :abortTransaction, :commitTransaction
      )
    )
  end

  옵션 ||= {}

  시작
    # commitTransaction이 두 번 호출되면 동일한 커밋 을 실행 해야 합니다.
    # 작업을 다시 수행하므로 세션을 이전 상태 로 되돌립니다.
    만약 into_states?(TRANSACTION_COMMITTED_STATE)
      @ 상태 = @last_commit_skiped ? STARTING_TRANSACTION_STATE : TRANSACTION_IN_PROGRESS_STATE
      @already_committed = true
    end

    만약 startup_transaction?
      @last_commit_skiped = true
    other
      @last_commit_skiped = 거짓
      @committing_transaction = true

      write_concern = 옵션[:write_concern] || txn_options[:write_concern]
      write_concern = writeConcern.get(write_concern) 만약 write_concern && !write_concern.is_a?(writeConcern::Base)

      컨텍스트 = 작업::Context.신규(
        클라이언트: @client,
        세션: self,
        operation_timeout: operation_timeout(옵션)
      )
      write_with_retry(write_concern, end_transaction: true,
                                      컨텍스트: 컨텍스트) do |연결, txn_num, 컨텍스트|
        만약 컨텍스트.재시도? && !컨텍스트.overload_only_retry?
          만약 write_concern
            wco = write_concern.옵션.merge(w: :majority)
            wco[:wtimeout] ||= 10_000
            write_concern = writeConcern.get(wco)
          other
            write_concern = writeConcern.get(w: :majority, wtimeout: 10_000)
          end
        end
        사양 = {
          선택기: { commitTransaction: 1 },
          db_name: 'admin',
          세션: self,
          txn_num: txn_num,
          write_concern: write_concern,
        }
        작업 = 작업::명령.신규(사양)
        추적 프로그램.trace_operation(작업, 컨텍스트, op_name: 'commitTransaction') do
          작업.execution_with_connection(연결, 컨텍스트: 컨텍스트)
        end
      end
    end
    # 상태 변경하기 전에 트랜잭션 범위를 완료합니다.
    추적 프로그램.finish_transaction_span(self)
  보장
    @ 상태 = TRANSACTION_COMMITTED_STATE
    @committing_transaction = 거짓
  end

  # 공식 반환 값은 없지만 true를 반환하므로 인터랙티브
  # 성공했음을 알리는 메서드 힌트를 사용합니다.
  true
end

#committing_transaction? ⇒ true | false

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

세션이 현재 트랜잭션을 커밋하고 있는지 여부를 반환합니다.

반환합니다:

  • (true | false) —

    세션이 현재 트랜잭션 을 커밋하고 있는지 여부입니다.

이후:

  • 2.5.0



891
892
893
 
# 파일 'lib/ Mongo/session.rb', 891줄

def committing_transaction?
  !!@committing_transaction
end

#더티!(mark = true) ⇒ 객체

더티 상태 기본 서버 세션에 지정된 값으로 설정합니다. 서버 세션이 없으면 아무 작업도 수행하지 않습니다.

매개변수:

  • 표시 (true | false) (기본값: true) —

    서버 세션을 더티로 표시할지 여부를 지정합니다.

이후:

  • 2.5.0



139
140
141
 
# 파일 'lib/ Mongo/session.rb', 139줄

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

#더티? ⇒ true | false | nil

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

기본 서버 세션이 더티인지 여부를 반환합니다. 이 세션에 대한 서버 세션이 없으면 nil을 반환합니다.

반환합니다:

  • (true | false | nil) —

    기본 서버 세션이 더티인지 여부. 이 세션에 대한 서버 세션이 없으면 nil을 반환합니다.

이후:

  • 2.5.0



147
148
149
 
# 파일 'lib/ Mongo/session.rb', 147줄

def dirty?
  @server_session&.dirty?
end

#end_session ⇒ nil

이 세션을 종료합니다.

이 세션에서 진행 중인 트랜잭션이 있는 경우 트랜잭션이 중단됩니다. 이 세션과 연결된 서버 세션이 서버 세션 풀로 반환됩니다. 마지막으로 이 세션은 종료됨으로 표시되어 더 이상 사용할 수 없습니다.

이 세션이 이미 종료된 경우 이 메서드는 아무 작업도 수행하지 않습니다.

이 메서드는 이름에서 알 수 있듯이 이 서버에 endSessions 명령을 직접 실행하지 않습니다.

예시:

session.end_session

반환합니다:

  • (nil) —

    항상 nil입니다.

이후:

  • 2.5.0



374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
 
# 파일 'lib/ Mongo/session.rb', 374줄

def end_session
  만약 !종료? && @client
    만약 into_states?(TRANSACTION_IN_PROGRESS_STATE)
      시작
        abort_transaction
      구출 mongo::오류, 오류::AuthError
      end
    end
    # 고정된 연결을 모두 해제합니다(예: 커밋된 트랜잭션 후
    # 로드 밸런싱 모드).
    고정 해제 만약 pinned_connection_global_id
    cluster.session_pool.checkin(@server_session) 만약 @server_session
  end
보장
  @server_session = nil
  @ended = true
  @client = nil
end

#종료되었나요? ⇒ true, false

이 세션이 종료되었는지 여부입니다.

예시:

session.ended?

반환합니다:

  • (true, false) —

    세션이 종료되었는지 여부입니다.

이후:

  • 2.5.0



244
245
246
 
# 파일 'lib/ Mongo/session.rb', 244줄

def 종료?
  !!@ended
end

#명시적? ⇒ true, false

이 세션이 명시적 세션입니까(예: 사용자 생성).

예시:

세션이 명시적인가요?

session.explicit?

반환합니다:

  • (true, false) —

    이 세션이 명시적인지 여부입니다.

이후:

  • 2.5.2



179
180
181
 
# 파일 'lib/ Mongo/session.rb', 179줄

def explicit?
  !암시적?
end

#암시적? ⇒ true, false

이 세션이 암시적 세션입니까(사용자가 생성하지 않음).

예시:

세션이 암시적인가요?

session.implicit?

반환합니다:

  • (true, false) —

    이 세션이 암시적인지 여부입니다.

이후:

  • 2.5.1



167
168
169
 
# 파일 'lib/ Mongo/session.rb', 167줄

def 암시적?
  @implicit ||= !!(@options.키?(:implicit) && @options[:implicit] == true)
end

#in_transaction? ⇒ true | false

세션이 현재 트랜잭션 중인지 여부입니다.

예시:

세션이 트랜잭션 에 포함되어 있나요?

session.in_transaction?

반환합니다:

  • (true | false) —

    트랜잭션의 세션 여부입니다.

이후:

  • 2.6.0



883
884
885
 
# 파일 'lib/ Mongo/session.rb', 883줄

def in_transaction?
  into_states?(STARTING_TRANSACTION_STATE, TRANSACTION_IN_PROGRESS_STATE)
end

#inside_with_transaction? ⇒ Boolean

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

반환값 현재 with_transaction 차단 안에 있는지 여부를 반환합니다.

반환합니다:

  • (부울) —

    현재 with_transaction 차단 안에 있는지 여부.

이후:

  • 2.5.0



1278
1279
1280
 
# 파일 'lib/ Mongo/session.rb', 1278줄

def Inside_with_transaction?
  @inside_with_transaction
end

#검사 ⇒ string

검사에 사용할 형식이 지정된 string 을 가져옵니다.

예시:

세션 객체를 검사합니다.

session.inspect

반환합니다:

  • (string) —

    세션 검사.

이후:

  • 2.5.0



352
353
354
 
# 파일 'lib/ Mongo/session.rb', 352줄

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

#materialize_if_needed ⇒ 세션

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

아직 설정하다 되지 않은 경우 세션 풀에서 세션을 체크아웃하여 세션 객체의 server_session을 채웁니다.

반환합니다:

다음을 발생시킵니다.

이후:

  • 2.5.0



1223
1224
1225
1226
1227
1228
1229
1230
1231
 
# 파일 'lib/ Mongo/session.rb', 1223줄

def Materialize_if_needed
  올리다 오류::SessionEnded 만약 종료?

  반환 하지 않는 한 암시적? && !@server_session

  @server_session = cluster.session_pool.결제

  self
end

#구체화되었나요? ⇒ 부울

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

반환합니다:

  • (부울)

다음을 발생시킵니다.

이후:

  • 2.5.0



1234
1235
1236
1237
1238
 
# 파일 'lib/ Mongo/session.rb', 1234줄

def 구체화?
  올리다 오류::SessionEnded 만약 종료?

  !@server_session.nil?
end

#Next_txn_num ⇒ 정수

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

다음 트랜잭션 번호를 증가시키고 반환합니다.

예시:

다음 트랜잭션 번호를 가져옵니다.

session.next_txn_num

반환합니다:

  • (정수) —

    다음 트랜잭션 번호입니다.

다음을 발생시킵니다.

이후:

  • 2.5.0



1249
1250
1251
1252
1253
 
# 파일 'lib/ Mongo/session.rb', 1249줄

def Next_txn_num
  올리다 오류::SessionEnded 만약 종료?

  @server_session.Next_txn_num
end

#pin_to_connection(connection_global_id, connection: nil) ⇒ 객체

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

이 세션을 지정된 연결에 고정합니다.

이 세션을 대상으로 합니다.

매개변수:

  • connection_global_id (정수) —

    고정할 연결의 전역 ID입니다.

  • 연결 (Connection | nil) (기본값: nil) —

    고정할 연결 객체 .

다음을 발생시킵니다.

  • (ArgumentError)

이후:

  • 2.5.0



925
926
927
928
929
930
 
# 파일 'lib/ Mongo/session.rb', 925줄

def pin_to_connection(connection_global_id, 연결: nil)
  올리다 ArgumentError, 'nil 연결 ID에 고정할 수 없습니다.' 만약 connection_global_id.nil?

  @pinned_connection_global_id = connection_global_id
  @pinned_connection = 연결
end

#pin_to_server(서버) ⇒ 객체

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

이 세션을 지정된 서버( mongos 여야 함)에 고정합니다.

매개변수:

  • 서버 (MongoDB 서버) —

    이 세션을 고정할 서버 입니다.

다음을 발생시킵니다.

  • (ArgumentError)

이후:

  • 2.5.0



908
909
910
911
912
913
914
915
916
 
# 파일 'lib/ Mongo/session.rb', 908줄

def pin_to_server(서버)
  올리다 ArgumentError, 'nil 서버에 고정할 수 없습니다.' 만약 서버.nil?

  만약 Lint.활성화? && !서버.mongos?
    올리다 오류::LintError, " Mongos가서버 #{server .summary}에 세션을 고정하려고 시도했습니다 .mongos"
  end

  @pinned_server = 서버
end

#프로세스(결과) ⇒ Operation::Result

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

이 세션을 사용한 서버의 응답을 처리합니다.

예시:

서버 의 응답을 처리합니다.

session.process(result)

매개변수:

반환합니다:

이후:

  • 2.5.0



1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
 
# 파일 'lib/ Mongo/session.rb', 1183줄

def 프로세스(결과)
  하지 않는 한 암시적?
    set_operation_time(결과)
    만약 cluster_time_doc = 결과.cluster_time
      advanced_cluster_time(cluster_time_doc)
    end
  end
  @server_session.set_last_use!

  만약 (doc = 결과.회신 && 결과.회신.문서.first) && doc[:recoveryToken]
    self.recovery_token = doc[:recoveryToken]
  end

  결과
end

#retry_reads? ⇒ 부울

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

최신 재시도 가능 읽기 사양에 따라 이 세션에서 실행된 읽기를 재시도할 수 있는지 여부입니다.

이 메서드가 true를 반환하면 애플리케이션 에서 최신 재시도 가능 읽기를 요청한 것입니다. 읽기 작업을 위해 선택한 서버 가 최신 재시도 가능 읽기를 지원하는 경우 해당 서버가 특정 작업에 사용됩니다. 읽기 작업을 위해 선택한 서버 가 최신 재시도 가능 읽기를 지원 하지 않는 경우 읽기가 재시도되지 않습니다.

이 메서드가 false를 반환하면 애플리케이션에서 레거시 재시도 가능 읽기를 요청한 것입니다. 레거시 재시도 가능 읽기 로직은 클라이언트가 연결된 서버의 서버 버전에 관계없이 사용됩니다. 읽기 재시도 횟수는 :max_read_retries 클라이언트 옵션에 의해 지정되며, 이 값은 기본적으로 1 이며 0 으)로 설정하여 레거시 읽기 재시도를 비활성화할 수 있습니다.

반환합니다:

  • (부울)

이후:

  • 2.5.0



199
200
201
 
# 파일 'lib/ Mongo/session.rb', 199줄

def retry_reads?
  고객.옵션[:retry_reads] != 거짓
end

#retry_writes? ⇒ true, false

참고:

재시도 가능 쓰기는 샤딩된 클러스터, 복제본 세트 또는 로드 밸런싱된 토폴로지에서만 사용할 수 있습니다.

이 세션으로 실행된 쓰기가 재시도됩니다.

예시:

쓰기가 다시 시도됩니다.

session.retry_writes?

반환합니다:

  • (true, false) —

    쓰기가 다시 시도되는 경우.

이후:

  • 2.5.0



214
215
216
 
# 파일 'lib/ Mongo/session.rb', 214줄

def retry_writes?
  !!고객.옵션[:retry_writes] && (cluster.replica_set? || cluster.? || cluster.load_balancing?)
end

#revert_to_starting_transaction! ⇒ 객체

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

세션 상태 STARTING_TRANSACTION_STATE로 되돌립니다. 트랜잭션 에서 첫 번째 명령을 재시도하기 전에 호출되어 재시도 시 startTransaction: true가 유지됩니다.

이후:

  • 2.5.0



1134
1135
1136
1137
1138
 
# 파일 'lib/ Mongo/session.rb', 1134줄

def revert_to_starting_transaction!
  반환 하지 않는 한 into_states?(TRANSACTION_IN_PROGRESS_STATE)

  @ 상태 = STARTING_TRANSACTION_STATE
end

#session_id ⇒ BSON::Document

세션이 종료되지 않은 경우 이 세션의 서버 세션 ID를 가져옵니다. 세션이 종료된 경우 Error::SessionEnded가 발생합니다.

반환합니다:

  • (BSON::Document) —

    서버 세션 ID입니다.

다음을 발생시킵니다.

이후:

  • 2.5.0



256
257
258
259
260
261
262
263
264
265
266
267
268
269
 
# 파일 'lib/ Mongo/session.rb', 256줄

def session_id
  올리다 오류::SessionEnded 만약 종료?

  # 명시적 세션에는 항상 session_id가 있습니다.
  # 구성 서버 세션을 제공해야 합니다. 암시적 세션
  # 구체화될 때까지 session_id가 없으므로 다음을 호출합니다.
  # session_id가 실패할 수 있습니다. 애플리케이션에 기회가 없어야 함
  # 암시적 세션이 활성화되어서는 안 되므로 이 실패가 발생합니다.
  # 수명이 다음으로 제한되어 애플리케이션에서 액세스할 수 있습니다.
  # 작업 실행은 전적으로 운전자 에 의해 수행됩니다.
  올리다 오류::SessionNotMaterialized 하지 않는 한 구체화?

  @server_session.session_id
end

스냅샷 #개? ⇒ true | false

반환값 세션이 스냅샷 읽기에 대해 구성되었는지 여부를 반환합니다.

반환합니다:

  • (true | false) —

    세션이 스냅샷 읽기에 대해 구성되었는지 여부입니다.

이후:

  • 2.5.0



123
124
125
 
# 파일 'lib/ Mongo/session.rb', 123줄

def 스냅샷?
  !!옵션[: 스냅샷]
end

#start_transaction(options = nil) ⇒ 객체

이 세션의 후속 작업을 새 트랜잭션 에 배치합니다.

start_transaction이 호출된 후 작업이 수행될 때까지 서버에서 트랜잭션이 시작되지 않습니다.

예시:

새 트랜잭션 시작

session.start_transaction(options)

매개변수:

  • 옵션 (해시) (기본값: nil) —

    시작 중인 트랜잭션 에 대한 옵션입니다.

옵션 해시(options):

  • :max_commit_time_ms (정수) —

    단일 commitTransaction 명령이 실행 되도록 허용하는 최대 시간(밀리초)입니다. 이 옵션은 더 이상 사용되지 않으므로 대신 :timeout_ms를 사용하세요.

  • :read_concern (해시) —

    다음과 같은 선택적 키가 있는 읽기 고려 (read concern) 옵션 해시입니다.

    • :level -- 읽기 설정 (read preference) 레벨을 기호로 표시합니다. 유효한 값은 :local, :과반수 및 :스냅샷입니다.
  • :write_concern (해시) —

    쓰기 고려 (write concern) 옵션. :w => Integer|String, : fsync => Boolean, :j => Boolean일 수 있습니다.

  • :read (해시) —

    읽기 설정 옵션. 해시에는 다음과 같은 항목이 있을 수 있습니다.

    • :모드 -- 기호로 지정된 읽기 설정 (read preference). 유일한 유효한 값은 프라이머리입니다.
  • :timeout_ms (정수) —

    작업 시간 제한(밀리초)입니다. 음수가 아닌 정수여야 합니다. 0 의 명시적 값은 무한대를 의미합니다. 기본값 은 설정되지 않았으며, 이는 값이 클라이언트 로부터 상속됨을 의미합니다.

다음을 발생시킵니다.

이후:

  • 2.6.0



653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
 
# 파일 'lib/ Mongo/session.rb', 653줄

def start_transaction(옵션 = nil)
  check_transactions_supported!

  만약 옵션
    Lint.validate_read_concern_option(옵션[:read_concern])

    # # 여기서 잘못된 읽기 설정 (read preference)을 감지하면 편리하지만
    # # 일부 사양 테스트에서는 나중에 잘못된 읽기 설정을 감지해야 합니다.
    # # 린트 모드 켜져 있을 때 이 작업을 수행할 수 있습니다.
    # 모드 = options[:read] && options[:read][: 모드].to_s
    # if 모드 && 모드 != ' 프라이머리'
    # Mongo::Error::InvalidTransactionOperation.new(
    # " 트랜잭션 의 읽기 설정 (read preference) 프라이머리 여야 합니다(요청: #{모드})"
    #           )
    #         end
  end

  올리다 mongo::오류::SnapshotSessionTransactionProhibited 만약 스냅샷?

  check_if_ended!

  만약 into_states?(STARTING_TRANSACTION_STATE, TRANSACTION_IN_PROGRESS_STATE)
    올리다 mongo::오류::InvalidTransactionOperation.신규(
      mongo::오류::InvalidTransactionOperation::TRANSACTION_ALREADY_IN_PROGRESS
    )
  end

  고정 해제

  Next_txn_num
  @txn_options = (@options[:default_transaction_options] || {}).merge(옵션 || {})

  만약 txn_write_concern && !writeConcern.get(txn_write_concern).인정?
    올리다 mongo::오류::InvalidTransactionOperation.신규(
      mongo::오류::InvalidTransactionOperation::UNACKNOWLEDGED_WRITE_CONCERN
    )
  end

  @ 상태 = STARTING_TRANSACTION_STATE
  @already_committed = 거짓
  추적 프로그램.start_transaction_span(self)

  # 이 메서드에는 명시적인 반환 값이 없습니다.
  # 여기서 nil을 반환할 수 있지만 true는 사용자에게 다음을 나타냅니다.
  작업 #개가 성공했습니다. 이는 대화형으로 사용하기 위한 것입니다.
  # 반환 값은 문서화되어 있지 않습니다.
  true
end

#startup_transaction? ⇒ 부울

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

반환합니다:

  • (부울)

이후:

  • 2.5.0



871
872
873
 
# 파일 'lib/ Mongo/session.rb', 871줄

def startup_transaction?
  into_states?(STARTING_TRANSACTION_STATE)
end

#Suppress_read_write_concern!(명령) ⇒ 해시, BSON::Document

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

해당 사항이 없는 경우 명령에서 읽기 고려 및/또는 쓰기 고려를 제거합니다.

예시:

session.suppress_read_write_concern!(cmd)

반환합니다:

  • (Hash, BSON::Document) —

    명령 문서.

이후:

  • 2.6.0



1098
1099
1100
1101
1102
1103
1104
1105
 
# 파일 'lib/ Mongo/session.rb', 1098줄

def Suppress_read_write_concern!(명령)
  명령.탭 do |C|
    다음 하지 않는 한 in_transaction?

    C.삭제(:readConcern) 하지 않는 한 startup_transaction?
    C.삭제(:writeConcern) 하지 않는 한 C[:commitTransaction] || C[:abortTransaction]
  end
end

#txn_num ⇒ 정수

현재 트랜잭션 번호를 가져옵니다.

예시:

현재 트랜잭션 번호를 가져옵니다.

session.txn_num

반환합니다:

  • (정수) —

    현재 트랜잭션 번호입니다.

다음을 발생시킵니다.

이후:

  • 2.6.0



1263
1264
1265
1266
1267
 
# 파일 'lib/ Mongo/session.rb', 1263줄

def txn_num
  올리다 오류::SessionEnded 만약 종료?

  @server_session.txn_num
end

#txn_options ⇒ 해시

이 세션에서.

반환합니다:

  • (해시) —

    현재 실행 중인 트랜잭션에 대한 옵션

이후:

  • 2.6.0



155
156
157
 
# 파일 'lib/ Mongo/session.rb', 155줄

def txn_options
  @txn_options or 올리다 ArgumentError, '활성 트랜잭션 없습니다. '
end

#txn_read_preference ⇒ 해시

세션이 현재 활성 트랜잭션 에서 사용할 읽기 설정 (read preference) 을 가져옵니다.

밑줄 키가 있는 운전자 스타일 해시입니다.

예시:

트랜잭션의 읽기 설정 (read preference) 가져오기

session.txn_read_preference

반환합니다:

  • (해시) —

    트랜잭션의 읽기 설정입니다.

이후:

  • 2.6.0



229
230
231
232
233
234
 
# 파일 'lib/ Mongo/session.rb', 229줄

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

#unpin(connection = nil) ⇒ 객체

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

세션이 고정된 경우 고정된 서버 또는 연결에서 이 세션의 고정을 해제합니다.

매개변수:

  • 연결 (Connection | nil) (기본값: nil) —

    고정을 해제할 연결입니다.

이후:

  • 2.5.0



938
939
940
941
942
943
944
945
946
947
948
949
950
951
 
# 파일 'lib/ Mongo/session.rb', 938줄

def 고정 해제(연결 = nil)
  @pinned_server = nil
  @pinned_connection_global_id = nil
  conn = 연결 || @pinned_connection
  만약 conn
    conn.고정 해제(트랜잭션)
    # 다른 것이 없는 경우에만 풀로의 연결을 다시 확인합니다.
    # 여전히 핀을 들고 있습니다(예: 열린 커서).
    하지 않는 한 conn.고정?
      conn.connection_pool.check_in(conn)
    end
  end
  @pinned_connection = nil
end

#unpin_maybe(오류, 연결 = nil) ⇒ 객체

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

세션이 고정되었고 지정된 예외 인스턴스 및 세션의 트랜잭션 상태 에 따라 고정을 해제해야 하는 경우 고정된 서버 또는 연결에서 이 세션의 고정을 해제합니다.

예외 인스턴스 에는 이미 모든 레이블이 설정하다 되어 있어야 합니다( 클라이언트 및 서버 측에서 생성된 레이블 모두).

매개변수:

  • 오류 (오류) —

    프로세스 할 예외 인스턴스 입니다.

  • 연결 (Connection | nil) (기본값: nil) —

    고정을 해제할 연결입니다.

이후:

  • 2.5.0



964
965
966
967
968
969
970
971
972
973
974
 
# 파일 'lib/ Mongo/session.rb', 964줄

def unpin_maybe(오류, 연결 = nil)
  만약 !into_states?(Session::NO_TRANSACTION_STATE) &&
     오류.레이블?('TransientTransactionError')
    고정 해제(연결)
  end

  만약 committing_transaction? &&
     오류.레이블?('UnknownTransactionCommitResult')
    고정 해제(연결)
  end
end

#update_state! ⇒ Object

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

(비커밋 및 비중단) 작업 실행 으로 인한 세션 상태 를 업데이트합니다.

이후:

  • 2.6.0



1144
1145
1146
1147
1148
1149
1150
1151
 
# 파일 'lib/ Mongo/session.rb', 1144줄

def update_state!
  case @ 상태
  when STARTING_TRANSACTION_STATE
    @ 상태 = TRANSACTION_IN_PROGRESS_STATE
  when TRANSACTION_COMMITTED_STATE, TRANSACTION_ABORTED_STATE
    @ 상태 = NO_TRANSACTION_STATE
  end
end

#validate!(client) ⇒ Session

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

지정된 클라이언트 에서 사용할 세션의 유효성을 검사합니다.

세션은 종료되지 않아야 하며 세션과 함께 사용할 클라이언트 와 동일한 클러스터 를 가진 클라이언트 가 생성한 것이어야 합니다.

매개변수:

  • 고객 (클라이언트) —

    세션과 함께 사용할 클라이언트 입니다.

반환합니다:

  • (세션) —

    세션이 유효한 경우 self.

다음을 발생시킵니다.

이후:

  • 2.5.0



1166
1167
1168
1169
1170
 
# 파일 'lib/ Mongo/session.rb', 1166줄

def 유효성을 검사합니다!(고객)
  check_if_ended!
  check_matting_cluster!(고객)
  self
end

#validate_read_preference!(명령) ⇒ 객체

이 메서드는 비공개 API의 일부입니다. 이 방법은 향후 제거되거나 변경될 수 있으므로 가능하면 사용하지 않는 것이 좋습니다.

명령의 읽기 설정 (read preference) 프라이머리 인지 확인합니다.

예시:

session.validate_read_preference!(command)

다음을 발생시킵니다.

이후:

  • 2.6.0



1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
 
# 파일 'lib/ Mongo/session.rb', 1117줄

def validate_read_preference!(명령)
  반환 하지 않는 한 in_transaction?
  반환 하지 않는 한 명령['$readPreference']

  모드 = 명령['$readPreference']['mode'] || 명령['$readPreference'][:mode]

  반환 하지 않는 한 모드 && 모드 != '프라이머리'

  올리다 mongo::오류::InvalidTransactionOperation.신규(
    "트랜잭션의 읽기 설정은 프라이머리여야 합니다(요청: #{모드})"
  )
end

#with_transaction(options = nil) ⇒ 객체

참고:

with_transaction에 루프가 포함되어 있으므로 with_transaction 자체가 루프에 배치된 경우 해당 블록은 외부 루프를 제어하기 위해 다음 또는 중단을 호출해서는 안 됩니다. 이는 대신 with_transaction의 루프에 영향을 미치기 때문입니다. 드라이버는 이러한 상황을 감지하면 경고를 보내고 트랜잭션을 중단합니다.

트랜잭션 에서 제공된 차단 을 실행하고 필요에 따라 다시 시도합니다.

차단 의 반환 값을 반환합니다.

정확한 재시도 횟수와 수행 시점은 드라이버의 구현 세부 정보입니다. 제공된 블록은 멱등성이 있어야 하며 두 번 이상 호출될 수 있도록 준비해야 합니다. 발생한 오류에 따라 드라이버는 활성 트랜잭션 내에서 커밋 명령을 다시 시도하거나 트랜잭션을 반복하고 차단을 다시 호출할 수 있습니다. 재시도는 다른 서버에 대해 실행될 수 있습니다.

트랜잭션을 중첩할 수 없음 - 세션에 이미 활성 트랜잭션이 있을 때 이 메서드를 호출하면 InvalidTransactionOperation이 발생합니다.

Mongo::Error에서 파생되지 않은 차단 에서 발생한 예외는 처리 를 중지하고 트랜잭션 을 중단하며 with_transaction 밖으로 전파됩니다. Mongo::Error 에서 파생된 예외는 with_transaction으로 처리되어 프로세스 가 재시도될 수 있습니다.

현재 with_transaction은 with_transaction이 실행되기 시작한 후 최소 120 초가 경과할 때까지 커밋을 재시도하고 호출을 차단합니다. 이 시간 제한은 구성할 수 없으며 향후 드라이버 버전에서 변경될 수 있습니다.

예시:

트랜잭션 에서 성명서 실행

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

end

트랜잭션 에서 성명서 를 실행하여 총 소요 시간을 제한합니다.

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

  end
end

매개변수:

  • 옵션 (해시) (기본값: nil) —

    시작 중인 트랜잭션 에 대한 옵션입니다. 이는 start_transaction이 허용하는 것과 동일한 옵션입니다.

다음을 발생시킵니다.

이후:

  • 2.7.0



447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
 
# 파일 'lib/ Mongo/session.rb', 447줄

def with_transaction(옵션 = nil)
  @inside_with_transaction = true
  @with_transaction_timeout_ms = 옵션&.dig(:timeout_ms) || @options[:default_timeout_ms] || @client.timeout_ms
  @with_transaction_deadline = compute_with_transaction_deadline(옵션)
  마감일 = 만약 @with_transaction_deadline
               # CSOT가 활성화되어 고객이 기한을 지정합니다.
               @with_transaction_deadline
             other
               # CSOT가 활성화되지 않았으므로 기본값 기한인 120 초를 사용합니다.
               Utils.단조적 시간 + 120
             end
  transaction_in_progress = 거짓
  transaction_attempt = 0
  last_error = nil
  overload_error_count = 0
  과부하_발생 = 거짓

  루프 do
    만약 transaction_attempt > 0
      만약 과부하_발생
        지연 = @client.retry_policy.backoff_delay(overload_error_count)
        만약 backoff_would_exceed_deadline?(마감일, 지연)
          make_timeout_error_from(last_error, 'CSOT 시간 제한이 만료되어 withTransaction 재시도 대기 중')
        end
        올리다(last_error) 하지 않는 한 @client.retry_policy.should_retry_overload?(overload_error_count, 지연)

        sleep(지연)
      other
        백오프 = backoff_seconds_for_retry(transaction_attempt)
        만약 backoff_would_exceed_deadline?(마감일, 백오프)
          make_timeout_error_from(last_error, 'CSOT 시간 제한이 만료되어 withTransaction 재시도 대기 중')
        end

        sleep(백오프)
      end
    end

    commit_options = {}
    commit_options[:write_concern] = 옵션[:write_concern] 만약 옵션
    start_transaction(옵션)
    transaction_in_progress = true
    transaction_attempt += 1

    시작
      rv = yield self
    구출 예외 => e
      만약 into_states?(STARTING_TRANSACTION_STATE, TRANSACTION_IN_PROGRESS_STATE)
        log_warn("#{e.class}로 인해 트랜잭션이 중단되었습니다: #{e}")
        # CSOT: 기한이 이미 만료된 경우 삭제합니다.
        # abort_transaction은 새로운 제한 시간(만료 기한이 아님)을 사용합니다.
        # 기한이 아직 만료되지 않은 경우 중단 시 남은 시간을 사용하도록 유지합니다.
        @with_transaction_deadline = nil 만약 @with_transaction_deadline && Deadline_expired?(마감일)
        abort_transaction
        transaction_in_progress = 거짓
      end

      만약 Deadline_expired?(마감일)
        transaction_in_progress = 거짓
        make_timeout_error_from(e, 'withTransaction 콜백 중CSOT 시간 초과가 만료되었습니다.')
      end

      만약 e.is_a?(mongo::오류) && e.레이블?('TransientTransactionError')
        last_error = e
        만약 e.레이블?('SystemOverloadedError')
          과부하_발생 = true
          overload_error_count += 1
        elsif 과부하_발생
          overload_error_count += 1
        end
        다음
      end

      올리다
    other
      만약 into_states?(TRANSACTION_ABORTED_STATE, NO_TRANSACTION_STATE, TRANSACTION_COMMITTED_STATE)
        transaction_in_progress = 거짓
        반환 rv
      end

      # CSOT: 커밋 하기 전에 제한 시간이 만료된 경우 중단합니다.
      # 트랜잭션 호출하고 클라이언트 사이드 시간 초과 오류를 발생시킵니다.
      만약 @with_transaction_deadline && Deadline_expired?(마감일)
        transaction_in_progress = 거짓
        @with_transaction_deadline = nil
        abort_transaction
        올리다 mongo::오류::시간 초과 오류, '트랜잭션 커밋되기 전에 CSOT 시간 초과가 만료되었습니다.'
      end

      시작
        commit_transaction(commit_options)
        transaction_in_progress = 거짓
        반환 rv
      구출 mongo::오류 => e
        만약 e.레이블?('UnknownTransactionCommitResult')
          만약 Deadline_expired?(마감일) ||
             (e.is_a?(오류::OperationFailure::패밀리) && e.max_time_ms_expired?)
            transaction_in_progress = 거짓

            올리다 하지 않는 한 @with_transaction_timeout_ms && Deadline_expired?(마감일)

            make_timeout_error_from(e, 'withTransaction 커밋 중 CSOT 시간 초과가 만료되었습니다.')
          end

          만약 e.레이블?('SystemOverloadedError')
            과부하_발생 = true
            overload_error_count += 1
          elsif 과부하_발생
            overload_error_count += 1
          end

          만약 과부하_발생
            지연 = @client.retry_policy.backoff_delay(overload_error_count)
            만약 backoff_would_exceed_deadline?(마감일, 지연)
              transaction_in_progress = 거짓
              make_timeout_error_from(e, 'withTransaction 커밋 중 CSOT 시간 초과가 만료되었습니다.')
            end
            하지 않는 한 @client.retry_policy.should_retry_overload?(overload_error_count, 지연)
              transaction_in_progress = 거짓
              올리다
            end
            sleep(지연)
          end

          wc_options = case v = commit_options[:write_concern]
                       when writeConcern::Base
                         v.옵션
                       when nil
                         {}
                       other
                         v
                       end
          commit_options[:write_concern] = wc_options.merge(w: :majority)
          재시도
        elsif e.레이블?('TransientTransactionError')
          만약 Utils.단조적 시간 >= 마감일
            transaction_in_progress = 거짓
            make_timeout_error_from(e, 'withTransaction 커밋 중 CSOT 시간 초과가 만료되었습니다.')
          end
          last_error = e
          만약 e.레이블?('SystemOverloadedError')
            과부하_발생 = true
            overload_error_count += 1
          elsif 과부하_발생
            overload_error_count += 1
          end
          @ 상태 = NO_TRANSACTION_STATE
          다음
        other
          transaction_in_progress = 거짓
          올리다
        end
      구출 오류::AuthError
        transaction_in_progress = 거짓
        올리다
      end
    end
  end

  # 공식 반환 값은 없지만 true를 반환하므로 인터랙티브
  # 성공했음을 알리는 메서드 힌트를 사용합니다.
  true
보장
  만약 transaction_in_progress
    log_warn('with_transaction 콜백이 with_transaction 루프에서 벗어나 트랜잭션을 중단하는 중')
    시작
      abort_transaction
    구출 오류::OperationFailure::패밀리, 오류::InvalidTransactionOperation
    end
  end
  @with_transaction_deadline = nil
  @with_transaction_timeout_ms = nil
  @inside_with_transaction = 거짓
end