클래스: 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) —

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

  • :snapshot_time (BSON::Timestamp) —

    스냅샷 읽기에 대한 원하는 스냅샷 시간입니다. :snapshot이 true일 때에만 유효합니다.

이후:

  • 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
 
# 파일 'lib/ Mongo/session.rb', 82줄

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

  만약 옵션[:snapshot_time] && !옵션[: 스냅샷]
    올리다 ArgumentError, ':snapshot_time은 :snapshot이 true일 때에만 설정할 수 있습니다.'
  end

  만약 옵션[:snapshot_time] && !옵션[:snapshot_time].is_a?(BSON::타임스탬프)
    올리다 ArgumentError, ':snapshot_time은 BSON::Timestamp여야 합니다.'
  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 = 거짓
  @snapshot_timestamp = 옵션[:snapshot_time]
end

인스턴스 속성 세부 정보

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

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

반환합니다:

이후:

  • 2.5.1



128
129
130
 
# 파일 'lib/ Mongo/session.rb', 128줄

def 고객
  @client
end

#cluster ⇒ 객체 (읽기 전용)

이후:

  • 2.5.0



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

def cluster
  @cluster
end

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

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

반환합니다:

  • (BSON::Timestamp) —

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

이후:

  • 2.5.0



141
142
143
 
# 파일 'lib/ Mongo/session.rb', 141줄

def operation_time
  @operation_time
end

#options ⇒ 해시 (읽기 전용)

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

반환합니다:

  • (해시) —

    이 세션의 옵션입니다.

이후:

  • 2.5.0



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

def 옵션
  @options
end

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

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

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

반환합니다:

  • (정수 | nil) —

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

이후:

  • 2.5.0



292
293
294
 
# 파일 'lib/ Mongo/session.rb', 292줄

def pinned_connection_global_id
  @pinned_connection_global_id
end

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

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

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

반환합니다:

  • (MongoDB Server | nil) —

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

이후:

  • 2.5.0



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

def pinned_server
  @pinned_server
end

#recovery_token ⇒ BSON::Document | nil

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

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

반환합니다:

  • (BSON::Document | nil) —

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

이후:

  • 2.5.0



298
299
300
 
# 파일 'lib/ Mongo/session.rb', 298줄

def recovery_token
  @recovery_token
end

#snapshot_timestamp ⇒ BSON::Timestamp | nil

이 세션의 스냅샷 시간을 반환합니다. 세션이 스냅샷 세션이 아니거나 :snapshot_time 옵션이 제공되지 않은 스냅샷 세션이고 아직 서버에서 atClusterTime을 읽지 않은 경우 nil을 반환합니다.

반환합니다:

  • (BSON::Timestamp | nil) —

    이 세션의 스냅샷 시간입니다. 세션이 스냅샷 세션이 아니거나 :snapshot_time 옵션이 제공되지 않은 스냅샷 세션이고 아직 서버에서 atClusterTime을 캡처한 읽기 작업이 없는 경우 nil입니다.

이후:

  • 2.5.0



1287
1288
1289
 
# 파일 'lib/ Mongo/session.rb', 1287줄

def snapshot_timestamp
  @snapshot_timestamp
end

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

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

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

반환합니다:

  • (정수 | nil) —

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

이후:

  • 2.5.0



1303
1304
1305
 
# 파일 'lib/ Mongo/session.rb', 1303줄

def with_transaction_deadline
  @with_transaction_deadline
end

인스턴스 메서드 세부 정보

#abort_transaction(options = nil) ⇒ 객체

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

예시:

트랜잭션 을 중단합니다.

session.abort_transaction

매개변수:

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

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

옵션 해시(options):

  • :timeout_ms (정수) —

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

다음을 발생시킵니다.

이후:

  • 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
 
# 파일 'lib/ Mongo/session.rb', 810줄

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



906
907
908
 
# 파일 'lib/ Mongo/session.rb', 906줄

def aborting_transaction?
  !!@aborting_transaction
end

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

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

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

예시:

session.add_autocommit!(cmd)

반환합니다:

  • (Hash, BSON::Document) —

    명령 문서.

이후:

  • 2.6.0



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

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



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

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



1029
1030
1031
1032
1033
 
# 파일 'lib/ Mongo/session.rb', 1029줄

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



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
 
# 파일 'lib/ Mongo/session.rb', 1044줄

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



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

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

#causal_consistency_doc ⇒ 객체

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

마지막 작업 시간을 알고 인과적 일관성이 활성화되어 있는 경우 인과적 일관성 문서를 반환하고, 그렇지 않으면 nil을 반환합니다.

이후:

  • 2.5.0



1331
1332
1333
1334
1335
 
# 파일 'lib/ Mongo/session.rb', 1331줄

def causal_consistency_doc
  반환 하지 않는 한 operation_time && causal_consistency?

  { afterClusterTime: operation_time }
end

#commit_transaction(options = nil) ⇒ 객체

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

예시:

트랜잭션을 커밋합니다.

session.commit_transaction

매개변수:

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

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

옵션 해시(options):

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

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

  • :timeout_ms (정수) —

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

다음을 발생시킵니다.

이후:

  • 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
 
# 파일 'lib/ Mongo/session.rb', 724줄

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



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

def committing_transaction?
  !!@committing_transaction
end

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

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

매개변수:

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

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

이후:

  • 2.5.0



150
151
152
 
# 파일 'lib/ Mongo/session.rb', 150줄

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

#더티? ⇒ true | false | nil

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

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

반환합니다:

  • (true | false | nil) —

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

이후:

  • 2.5.0



158
159
160
 
# 파일 'lib/ Mongo/session.rb', 158줄

def dirty?
  @server_session&.dirty?
end

#end_session ⇒ nil

이 세션을 종료합니다.

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

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

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

예시:

session.end_session

반환합니다:

  • (nil) —

    항상 nil입니다.

이후:

  • 2.5.0



385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
 
# 파일 'lib/ Mongo/session.rb', 385줄

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



255
256
257
 
# 파일 'lib/ Mongo/session.rb', 255줄

def 종료?
  !!@ended
end

#명시적? ⇒ true, false

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

예시:

세션이 명시적인가요?

session.explicit?

반환합니다:

  • (true, false) —

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

이후:

  • 2.5.2



190
191
192
 
# 파일 'lib/ Mongo/session.rb', 190줄

def explicit?
  !암시적?
end

#암시적? ⇒ true, false

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

예시:

세션이 암시적인가요?

session.implicit?

반환합니다:

  • (true, false) —

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

이후:

  • 2.5.1



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

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

#in_transaction? ⇒ true | false

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

예시:

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

session.in_transaction?

반환합니다:

  • (true | false) —

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

이후:

  • 2.6.0



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

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



1307
1308
1309
 
# 파일 'lib/ Mongo/session.rb', 1307줄

def Inside_with_transaction?
  @inside_with_transaction
end

#검사 ⇒ string

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

예시:

세션 객체를 검사합니다.

session.inspect

반환합니다:

  • (string) —

    세션 검사.

이후:

  • 2.5.0



363
364
365
 
# 파일 'lib/ Mongo/session.rb', 363줄

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

#materialize_if_needed ⇒ 세션

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

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

반환합니다:

다음을 발생시킵니다.

이후:

  • 2.5.0



1237
1238
1239
1240
1241
1242
1243
1244
1245
 
# 파일 'lib/ Mongo/session.rb', 1237줄

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

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

  @server_session = cluster.session_pool.결제

  self
end

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

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

반환합니다:

  • (부울)

다음을 발생시킵니다.

이후:

  • 2.5.0



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

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

  !@server_session.nil?
end

#Next_txn_num ⇒ 정수

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

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

예시:

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

session.next_txn_num

반환합니다:

  • (정수) —

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

다음을 발생시킵니다.

이후:

  • 2.5.0



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

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



932
933
934
935
936
937
 
# 파일 'lib/ Mongo/session.rb', 932줄

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



915
916
917
918
919
920
921
922
923
 
# 파일 'lib/ Mongo/session.rb', 915줄

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



1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
 
# 파일 'lib/ Mongo/session.rb', 1197줄

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



210
211
212
 
# 파일 'lib/ Mongo/session.rb', 210줄

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

#retry_writes? ⇒ true, false

참고:

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

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

예시:

쓰기가 다시 시도됩니다.

session.retry_writes?

반환합니다:

  • (true, false) —

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

이후:

  • 2.5.0



225
226
227
 
# 파일 'lib/ Mongo/session.rb', 225줄

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



1148
1149
1150
1151
1152
 
# 파일 'lib/ Mongo/session.rb', 1148줄

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



267
268
269
270
271
272
273
274
275
276
277
278
279
280
 
# 파일 'lib/ Mongo/session.rb', 267줄

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

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

  @server_session.session_id
end

스냅샷 #개? ⇒ true | false

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

반환합니다:

  • (true | false) —

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

이후:

  • 2.5.0



134
135
136
 
# 파일 'lib/ Mongo/session.rb', 134줄

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



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
 
# 파일 'lib/ Mongo/session.rb', 660줄

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



878
879
880
 
# 파일 'lib/ Mongo/session.rb', 878줄

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



1112
1113
1114
1115
1116
1117
1118
1119
 
# 파일 'lib/ Mongo/session.rb', 1112줄

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



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

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

  @server_session.txn_num
end

#txn_options ⇒ 해시

이 세션에서.

반환합니다:

  • (해시) —

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

이후:

  • 2.6.0



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

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

#txn_read_concern ⇒ Hash

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

트랜잭션을 시작할 때 세션이 사용할 읽기 고려 (read concern)을 가져옵니다.

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

예시:

세션의 트랜잭션 읽기 고려 (read concern)를 가져옵니다.

session.txn_read_concern

반환합니다:

  • (해시) —

    트랜잭션 시작에 사용되는 읽기 고려 (read concern)입니다.

이후:

  • 2.9.0



1322
1323
1324
1325
 
# 파일 'lib/ Mongo/session.rb', 1322줄

def txn_read_concern
  # 읽기 고려 (read concern)는 클라이언트에서 상속되지만 db 또는 컬렉션에서는 상속되지 않습니다.
  txn_options[:read_concern] || @client.read_concern
end

#txn_read_preference ⇒ 해시

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

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

예시:

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

session.txn_read_preference

반환합니다:

  • (해시) —

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

이후:

  • 2.6.0



240
241
242
243
244
245
 
# 파일 'lib/ Mongo/session.rb', 240줄

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



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

def 고정 해제(연결 = nil)
  # 멱등: 지우기 위한 고정된 상태가 없으면 아무 작업도 실행하지 않습니다. 중청
  # unpin_maybe 핸들러(예: BulkWrite#execute_operation 랩핑에서의
  # 작업의 do_execute에서 이미 unpin_maybe를 호출하는 OpMsg 실행)
  # 동일한 오류에 대해 이 메서드를 두 번 호출할 수 있습니다. 연결 확인
  # 푸를 두 번째 다시 넣으면 푸에서 오류가 발생합니다.
  반환 만약 @pinned_server.nil? && @pinned_connection.nil? && @pinned_connection_global_id.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



978
979
980
981
982
983
984
985
986
987
988
 
# 파일 'lib/ Mongo/session.rb', 978줄

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

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

#update_state! ⇒ Object

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

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

이후:

  • 2.6.0



1158
1159
1160
1161
1162
1163
1164
1165
 
# 파일 'lib/ Mongo/session.rb', 1158줄

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



1180
1181
1182
1183
1184
 
# 파일 'lib/ Mongo/session.rb', 1180줄

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

#validate_read_preference!(명령) ⇒ 객체

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

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

예시:

session.validate_read_preference!(command)

다음을 발생시킵니다.

이후:

  • 2.6.0



1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
 
# 파일 'lib/ Mongo/session.rb', 1131줄

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



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
 
# 파일 'lib/ Mongo/session.rb', 458줄

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(옵션)
  # CSOT가 활성화되면 고객이 정의한 마감 일자가 있지만 그렇지 않으면
  # 기본값 마감 시간인 120 초로 돌아가닙니다.
  마감일 = @with_transaction_deadline || (Utils.단조적 시간 + 120)
  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