클래스: Mongo::Cluster

상속:
객체
  • 객체
모두 표시
확장자:
전달 가능
다음을 포함합니다.
Mongo::ClusterTime::Consumer, Event::Subscriber, Loggable, Monitoring::Publishable
다음에 정의됨:
build/ruby-driver-v2.19/lib/mongo/cluster.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/topology.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/topology.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/sdam_flow.rb,
빌드/루비 드라이버-v2.19/lib/mongo/cluster/topology/base.rb,
빌드/루비 드라이버-v2.19/lib/mongo/cluster/topology/single.rb,
빌드/루비 드라이버-v2.19/lib/mongo/cluster/topology/sharded.rb,
빌드/루비 드라이버-v2.19/lib/mongo/cluster/topology/unknown.rb,
빌드/루비 드라이버-v2.19/lib/mongo/cluster/periodic_executor.rb,
build/ Ruby-driver-v2.19/lib/mongo/cluster/reapers/cursor_reaper.rb,
빌드/루비 드라이버-v2.19/lib/mongo/cluster/reapers/socket_reaper.rb,
빌드/루비 드라이버-v2.19/lib/mongo/cluster/topology/load_balancing.rb,
빌드/루비 드라이버-v2.19/lib/mongo/cluster/topology/no_replica_set_options.rb,
빌드/루비 드라이버-v2.19/lib/mongo/cluster/topology/replica_set_no_primary.rb,
빌드/루비 드라이버-v2.19/lib/mongo/cluster/topology/replica_set_with_primary.rb

개요

Copyright © 2018-2020 MongoDB Inc.

Apache 라이선스, 버전 2.0 ('라이선스')에 따라 라이선스가 부여됩니다. 라이선스를 준수하지 않는 한 이 파일을 사용할 수 없습니다. 다음에서 라이선스 사본을 얻을 수 있습니다.

http://www.apache.org/licenses/LICENSE-2.0

해당 법률에서 요구하거나 문서로 동의하지 않는 한, 라이선스에 따라 배포되는 소프트웨어는 명시적이든 Express 이든 어떤 종류의 보증이나 조건 없이 "있는 그대로" 배포됩니다. 라이선스에 따른 권한 및 제한 사항을 적용하는 특정 언어는 라이선스를 참조하세요.

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

모듈: 토폴로지 클래스: CursorReaper, PeriodicExecutor, SdamFlow, SocketReaper

상수 요약 접기

MAX_READ_RETRIES =

레거시 읽기 재시도의 기본 횟수입니다.

이후:

  • 2.1.1

1
MAX_WRITE_RETRIES =

레거시 쓰기 재시도의 기본 횟수입니다.

이후:

  • 2.4.2

1
READ_RETRY_INTERVAL =

레거시 읽기 재시도를 사용할 때의 기본 읽기 재시도 간격(초)입니다.

이후:

  • 2.1.1

5
IDLE_WRITE_PERIOD_SECONDS =

유휴 프라이머리가 oplog에 no-op을 기록하는 빈도입니다.

이후:

  • 2.4.0

10
CLUSTER_TIME =
더 이상 사용되지 않습니다.

mongos 서버의 응답에 포함된 클러스터 시간 키입니다.

이후:

  • 2.5.0

'clusterTime'.동결

Loggable에서 포함된 상수

Loggable::prefix

인스턴스 속성 요약 접기

Mongo::ClusterTime::Consumer에 포함된 속성

#cluster_time

Event::Subscriber에 포함된 속성

#event_listeners

클래스 메서드 요약 접기

인스턴스 메서드 요약 접기

Mongo::ClusterTime::Consumer에 포함된 메서드

#advance_cluster_time

Loggable에 포함된 메서드

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

Event::Subscriber에 포함된 메서드

#subscribe_to

Monitoring::Publishable에 포함된 메서드

#publish_cmap_event, #publish_event, #publish_s담_event

생성자 세부 정보

#initialize(seed, monitoring, options = Options::Redacted.new) ⇒ 클러스터

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

참고:

클러스터는 클라이언트 외부에서 직접 인스턴스화해서는 안 됩니다.

참고:

mongodb+srv:// URI에 연결할 때 클라이언트 는 해당 URI를 서버 목록으로 확장하고 해당 목록을 클러스터 생성자에 전달합니다. 독립형 mongod 에 연결할 때 Cluster 생성자는 해당 주소 를 하나의 string 배열 로 수신합니다.

새 클러스터를 인스턴스화합니다.

예시:

클러스터를 인스턴스화합니다.

Mongo::Cluster.new(["127.0.0.1:27017"], monitoring)

매개변수:

  • 시드 (Array<String>) —

    구성된 서버의 주소

  • 모니터링 (모니터링) —

    모니터링.

  • 옵션 (해시) (기본값: Options::Redacted.new) —

    옵션. 클라이언트 생성자는 옵션을 클러스터 생성자에 전달하지만, 클러스터는 클라이언트가 인식하는 옵션의 하위 집합만 인식합니다.

옵션 해시(options):

  • :direct_connection (true | false) —

    토폴로지 검색을 우회하여 지정된 시드에 직접 연결할지 여부입니다. 정확히 하나의 시드를 제공해야 합니다.

  • :connect (기호) —

    더 이상 사용되지 않음 - 이 옵션 대신 :direct_connection 옵션을 사용합니다. 사용할 연결 메서드입니다. 이렇게 하면 클러스터가 자동 검색 대신 지정된 방식으로 작동합니다. :direct, :replica_set, :sharded 중 하나

  • :replica_set (기호) —

    연결할 복제본 세트의 이름입니다. 이 복제본 세트에 없는 서버는 무시됩니다.

  • :scan (true | false) —

    생성자의 모든 시드를 스캔할지 여부입니다. 드라이버 버전 2.x의 기본값은 이렇게 하는 것입니다. 드라이버 버전 3.x는 생성자에서 시드를 스캔하지 않습니다. 이 옵션을 false로 설정하여 새 동작을 사용하도록 선택합니다. 참고: 이 옵션을 nil로 설정하면 드라이버 버전 2.x의 생성자에서 시드를 스캔할 수 있습니다. 드라이버 버전 3.x는 이 옵션을 인식하지만 무시하며 생성자에서 시드를 스캔하지 않습니다.

  • :monitoring_io (true | false) —

    내부 드라이버 전용입니다. 이 클러스터 또는 그 하위 서버에서 SDAM 관련 I/O를 수행하지 않으려면 false로 설정합니다. 참고: 이 옵션을 false로 설정하면 클러스터가 작동하지 않습니다. SDAM 상태 전환을 수동으로 호출하는 테스트에 사용하기 위한 것입니다.

  • :cleanup (true | false) —

    내부 드라이버 전용입니다. 클러스터 연결이 끊어졌을 때 서버 세션을 정리하기 위해 endSessions 명령이 서버로 전송되지 않도록 하고 주기적 실행기를 시작하지 않으려면 false로 설정합니다. :monitoring_io가 false인 경우 :cleanup도 자동으로 false로 기본 설정됩니다.

  • :하트비트_빈도 (Float) —

    서버 모니터가 hello를 통해 설명을 새로 고치는 간격(초)입니다.

  • :resolv_options (해시) —

    내부 드라이버 전용입니다. SRV 조회를 위해 Resolve::DNS 생성자에 전달할 옵션입니다.

  • :server_api (해시) —

    요청된 서버 API 버전입니다. 이 해시에는 다음 항목이 포함될 수 있습니다.

    • :version - string

    • :strict - 부울

    • :deprecation_errors - 부울

이후:

  • 2.0.0



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 120

def 초기화(시드, 모니터링, 옵션 = 옵션::편집됨.신규)
  만약 시드.nil?
    올리다 ArgumentError, 'seeds는 nil일 수 없습니다.'
  end

  옵션 = 옵션.dup
  만약 옵션[:monitoring_io] == 거짓 && !옵션.키?(:cleanup)
    옵션[:cleanup] = 거짓
  end
  @options = 옵션.동결

  # @update_lock은 @servers, @connecting, @connected, @topology 및
  # @sessions_supported. 일반적으로 다음 값이 없는 인스턴스 변수는
  잠금을 위해 # 지정된 잠금은 업데이트 잠금에서만 수정해야 합니다.
  # 토폴로지 변경은 다음이 아닌 @update_lock에 의해 잠깁니다.
  # @sdam_flow_lock.
  @update_lock = 뮤텍스.신규
  @servers = []
  @monitoring = 모니터링
  @event_listeners = 이벤트::리스너.신규
  @app_metadata = 서버::AppMetadata.신규(@options.merge(목적: : 애플리케이션))
  @monitor_app_metadata = 서버::모니터::AppMetadata.신규(@options.merge(목적: :monitor))
  @push_monitor_app_metadata = 서버::모니터::AppMetadata.신규(@options.merge(목적: :push_monitor))
  @cluster_time_lock = 뮤텍스.신규
  @cluster_time = nil
  @srv_monitor_lock = 뮤텍스.신규
  @srv_monitor = nil
  @server_selection_semapher = 세마포어.신규
  @topology = 토폴로지.이니셜(self, 모니터링, 옵션)
  # 상태 변경 락 은 s담 흐름 락 과 유사하지만 다음과 같이 설계되었습니다.
  # 클러스터 소비자가 시작한 상태 변경을 직렬화합니다.
  # (예 클러스터를 연결하거나 연결 해제하는 애플리케이션),
  # 예: 애플리케이션 이 연결 해제-연결-연결 해제를 빠르게 호출하는 경우
  # 클러스터를 일관성 없는 상태로 만들지 않습니다.
  # 드라이버에서 내부적으로 수행하는 모니터링 업데이트는 다음 작업을 수행하지 않습니다.
  # 상태 변경 잠금.
  @state_change_lock = 뮤텍스.신규
  # @sdam_flow_lock은 s담 흐름만 다룹니다. 참고로 적용되지 않습니다.
  # to @ 토폴로지 교체는 @update_lock에서 수행됩니다.
  @sdam_flow_lock = 뮤텍스.신규
  Session::SessionPool.create(self)

  만약 시드.비어 있나요? && load_balancing?
    올리다 ArgumentError, '시드가 없는 부하 분산 클러스터는 금지되어 있습니다. '
  end

  # 시작 토폴로지는 서버가 없으면 항상 알 수 없습니다.
  # https://github.com/mongodb/specations/pull/388
  opening_topology = 토폴로지::알 수 없음.신규(옵션, 모니터링, self)

  publish_sdam_event(
    모니터링::TOPOLOGY_OPENING,
    모니터링::이벤트::토폴로지 열기.신규(opening_topology)
  )

  @seeds = 시드 = 시드.uniq
  서버 = 시드.map do |시드|
    # MongoDB Server 열기 이벤트는 토폴로지 변경 이벤트 후에 전송되어야 합니다.
    # 따라서 토폴로지 변경 전에 별도의 서버 추가를 수행합니다.
    # 이벤트가 게시되면 시작부터 서버 모니터링까지
    # 나중에 완료.
    추가(시드, 모니터: 거짓)
  end

  만약 시드.size >= 1
    # 토폴로지를 다시 생성하여 현재 서버 목록을 가져옵니다.
    recreate_topology(토폴로지, opening_topology)
  end

  만약 load_balancing?
    # 사양에 따라 특정 SDAM 이벤트를 생성해야 합니다.
    # 로드 밸런싱 토폴로지에 있는 경우.
    # 이러한 이벤트는
    # 드라이버의 SDAM 구현뿐만 아니라
    # 드라이버의 로드 밸런서 구현.
    # 이는 필수 상용구일 뿐입니다.
    #
    # 이 호출은 monitoring_io 검사 위에 수행되어야 합니다.
    # 나머지 생성자가 단락되기 때문입니다.
    fabrate_lb_s담_events_and_set_server_type
  end

  만약 옵션[:monitoring_io] == 거짓
    # 서버가 없기 때문에 주기적인 실행기 구성을 생략합니다.
    # 클러스터에 명령을 보낼 수 없으며,
    # 정리해야 하는 모든 것.
    #
    # 개별 서버 및 레거시 단일 라운드 모니터링 생략
    모의 테스트와 경쟁할 메인 스레드의 SDAM 수
    # SDAM 응답.
    @connecting = @connected = 거짓
    반환
  end

  # 스레드 모니터링을 시작하기 전에 인스턴스 변수를 업데이트합니다.
  @connecting = 거짓
  @connected = true

  만약 옵션[:cleanup] != 거짓
    @cursor_reaper = CursorReaper.신규(self)
    @socket_reaper = SocketReaper.신규(self)
    @periodic_executor = 주기적 실행기.신규([
      @cursor_reaper, @socket_reaper,
    ], 옵션)

    @periodic_executor.실행!
  end

  하지 않는 한 load_balancing?
    # 모니터링을 시작하기 전에 시작 시간을 기록해야 합니다.
    start_monotime = Utils.단조적 시간

    서버.각 do |서버|
      서버.start_monitoring
    end

    만약 옵션[:scan] != 거짓
      server_selection_timeout = 옵션[:server_selection_timeout] || ServerSelector::SERVER_SELECTION_TIMEOUT
      # 서버 선택 시간 제한은 특히 다음과 같은 경우 매우 짧을 수 있습니다.
      # 테스트, 클라이언트가 다음 전에 동기 스캔을 기다리는 경우
      # 서버 선택을 시작합니다. 서버 로 스캔 선택 시간 제한
      # 그런 다음 로컬 서버도 처리하기 전에 스캔을 중단합니다.
      # 따라서 여기에서 스캔하는 데 최소 3 초의 시간을 허용합니다.
      만약 server_selection_timeout < 3
        server_selection_timeout = 3
      end
      마감일 = start_monotime + server_selection_timeout
      # 각 서버의 첫 번째 스캔이 완료될 때까지 기다립니다.
      # 이전 버전과의 호환성.
      # 이 SDAM 라운드 중에 서버가 발견되면
      # 이러한 서버도 쿼리될 때까지 기다리는 등
      # 서버 선택 시간 초과 또는 최소 3 초입니다.
      루프 do
        # SDAM이 실행되는 동안 서버 목록을 읽으려고 시도하지 않도록 합니다.
        서버 = @sdam_flow_lock.동기화 do
          server_list.dup
        end
        만약 서버.모두? { |서버| 서버.last_scan_monotime && 서버.last_scan_monotime >= start_monotime }
          휴식
        end
        만약 (time_remaining = 마감일 - Utils.단조적 시간) <= 0
          휴식
        end
        log_debug("최대 #{'%.2f' 스캔할 서버의 % time_remaining} 초: #{요약}")
        # 세마포어가 우리 사이에 신호를 받았을 수 있으므로
        # 위의 서버 목록과 아래의 대기 호출, 우리는
        # 남은 전체 시간 동안 대기 - 최대 0.5 초 동안 기다린 다음
        # 상태 를 다시 확인합니다.
        시작
          server_selection_semapher.wait([time_remaining, 0.5].min)
        구출 ::시간 초과::오류
          # 아무것도
        end
      end
    end

    start_stop_srv_monitor
  end
end

인스턴스 속성 세부 정보

#app_metadata ⇒ Mongo::Server::AppMetadata (읽기 전용)

연결 핸드셰이크에 사용되는 애플리케이션 메타데이터를 반환합니다.

반환합니다:

이후:

  • 2.4.0



317
318
319
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 317

def app_metadata
  @app_metadata
end

#monitor_app_metadata ⇒ 객체 (읽기 전용)

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

이후:

  • 2.0.0



320
321
322
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 320

def monitor_app_metadata
  @monitor_app_metadata
end

#모니터링 ⇒ 모니터링 (읽기 전용)

모니터링을 반환합니다.

반환합니다:

이후:

  • 2.0.0



308
309
310
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 308

def 모니터링
  @monitoring
end

#options ⇒ 해시 (읽기 전용)

옵션 해시를 반환합니다.

반환합니다:

  • (해시) —

    옵션 해시입니다.

이후:

  • 2.0.0



305
306
307
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 305

def 옵션
  @options
end

#push_monitor_app_metadata ⇒ 객체 (읽기 전용)

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

이후:

  • 2.0.0



323
324
325
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 323

def push_monitor_app_metadata
  @push_monitor_app_metadata
end

#시드 ⇒ Array<String> (읽기 전용)

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

시드 서버의 주소를 반환합니다. 클러스터가 SDAM의 결과로 사용 중인 현재 주소가 아니라 인스턴스화될 때 클러스터에 제공된 주소를 포함합니다.

반환합니다:

  • (Array<String>) —

    시드 서버의 주소입니다. 클러스터가 SDAM의 결과로 사용 중인 현재 주소가 아니라 인스턴스화될 때 클러스터에 제공된 주소를 포함합니다.

이후:

  • 2.7.0



331
332
333
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 331

def 시드
  @seeds
end

#서버_선택_세마포어 ⇒ 객체 (읽기 전용)

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

이후:

  • 2.0.0



488
489
490
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 488

def server_selection_semapher
  @server_selection_semapher
end

#session_pool ⇒ 객체 (읽기 전용)

이후:

  • 2.5.1



336
337
338
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 336

def session_pool
  @session_pool
end

#srv_monitor ⇒ 객체 (읽기 전용)

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

이후:

  • 2.0.0



358
359
360
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 358

def srv_monitor
  @srv_monitor
end

#topology ⇒ 정수? (읽기 전용)

논리적 세션 시간 초과 값(분)입니다.

예시:

논리적 세션 시간 제한을 분 단위로 가져옵니다.

cluster.logical_session_timeout

반환합니다:

  • (정수, nil) —

    논리적 세션 시간 초과입니다.

이후:

  • 2.5.0



311
312
313
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 311

def 토폴로지
  @topology
end

클래스 메서드 세부 정보

.create(클라이언트, 모니터링: nil) ⇒ 클러스터

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

클라이언트의 원래 클러스터 인스턴스가 동일하지 않도록 하는 데 사용할 수 있도록 제공된 클라이언트에 대한 클러스터를 생성합니다.

예시:

클라이언트에 대한 클러스터를 만듭니다.

Cluster.create(client)

매개변수:

  • 고객 (클라이언트) —

    생성할 클라이언트입니다.

  • 모니터링. (모니터링 | nil) —

    새 클러스터와 함께 사용할 모니터링 인스턴스입니다. nil인 경우 새 모니터링 인스턴스가 생성됩니다.

반환합니다:

이후:

  • 2.0.0



295
296
297
298
299
300
301
302
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 295

def self.create(고객, 모니터링: nil)
  cluster = 클러스터.신규(
    고객.cluster.주소.map(&:to_s),
    모니터링 || 모니터링.신규,
    고객.cluster_options,
  )
  고객.instance_variable_set(:@cluster, cluster)
end

인스턴스 메서드 세부 정보

#==(기타) ⇒ true, false

이 서버 클러스터 가 다른 객체 와 동일한지 확인합니다. 구성된 서버가 아닌 현재 클러스터 에 있는 서버를 확인합니다.

예시:

클러스터가 객체와 동일합니까?

cluster == other

매개변수:

  • 기타 (객체) —

    비교할 객체입니다.

반환합니다:

  • (true, false) —

    객체가 동일한 경우.

이후:

  • 2.0.0



738
739
740
741
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 738

def ==(기타)
  반환 거짓 하지 않는 한 기타.is_a?(클러스터)
  주소 == 기타.주소 && 옵션 == 기타.옵션
end

#add(host, add_options = nil) ⇒ MongoDB Server

제공된 주소를 사용하여 클러스터에 서버를 추가합니다. 기존 서버가 hello를 실행하고 잠재적으로 구성되지 않은 서버가 포함된 경우 새 서버를 자동으로 검색하는 데 유용합니다.

예시:

해당 주소에 대한 서버를 클러스터에 추가합니다.

cluster.add('127.0.0.1:27018')

매개변수:

  • 호스트 (string) —

    추가할 서버의 주소입니다.

  • 옵션 (해시) —

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

반환합니다:

  • (MongoDB 서버) —

    새로 추가된 서버(아직 없는 경우)입니다.

이후:

  • 2.0.0



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
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 836

def 추가(호스트, add_options=nil)
  주소 = 주소.신규(호스트, 옵션)
  만약 !주소.포함?(주소)
    opts = 옵션.merge(모니터: 거짓)
    # 모니터링 스레드를 시작하지 않는 경우,
    # 풀의 채우기 스레드를 시작합니다.
    opts.병합!(populator_io: 거짓) 하지 않는 한 옵션.가져오기(:monitoring_io, true)
    # 부하가 분산된 토폴로지에서는 모든 서버가 다음과 같아야 합니다.
    # 로드 밸런서 (load_balancer: true가 옵션에 지정됨)
    # 하지만 이 옵션은
    # 서버가 알 수 없는 서버로 시작된 척하는 사양
    # 로드 밸런서 에 서버 설명 변경 이벤트 게시
    하나. 이 서버에 대한 실제 올바른 설명이 설정됩니다.
    # fabrication_lb_sdam_events_and_set_server_type 메서드를 사용합니다.
    서버 = 서버.신규(주소, self, @monitoring, event_listeners, opts)
    @update_lock.동기화 do
      # 서버가 @servers에 있는지 다시 확인해야 합니다.
      # 이전 수표는 잠금 상태가 아닙니다.
      # 여기서는 업데이트 잠금 상태이므로 server_list를 호출할 수 없습니다.
      반환 만약 @servers.map(&:address).포함?(주소)

      @servers.push(서버)
    end
    만약 add_options.nil? || add_options[:monitor] != 거짓
      서버.start_monitoring
    end
    서버
  end
end

주소 # ⇒ Array<Mongo::Address>

클러스터의 주소입니다.

예시:

클러스터의 주소를 가져옵니다.

cluster.addresses

반환합니다:

이후:

  • 2.0.6



451
452
453
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 451

def 주소
  server_list.map(&:address)
end

#close ⇒ nil

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

참고:

애플리케이션은 Client#close를 호출하여 연결을 해제해야 합니다.

클러스터를 닫습니다.

이 메서드를 호출하는 대신 클러스터를 호출합니다. 이 메서드는 내부 드라이버 전용입니다.

클러스터의 모든 서버 연결을 해제하고 프로세스에서 적절한 SDAM 이벤트를 게시합니다. SRV 모니터링이 활성화된 경우 중지합니다. 클러스터의 연결이 끊어진 것으로 표시합니다.

비공개 클러스터는 더 이상 사용할 수 없습니다. 클라이언트가 다시 연결되면 새 클러스터 인스턴스가 생성됩니다.

반환합니다:

  • (nil) —

    항상 nil입니다.

이후:

  • 2.0.0



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
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 506

def 닫기
  @state_change_lock.동기화 do
    하지 않는 한 연결 중? || 연결됨?
      반환 nil
    end
    만약 옵션[:cleanup] != 거짓
      session_pool.end_sessions
      @periodic_executor.중지!
    end
    @srv_monitor_lock.동기화 do
      만약 @srv_monitor
        @srv_monitor.중지!
      end
    end
    @servers.각 do |서버|
      만약 서버.연결됨?
        서버.닫기
        publish_sdam_event(
          모니터링::SERVER_CLOSED,
          모니터링::이벤트::ServerClosed.신규(서버.주소, 토폴로지)
        )
      end
    end
    publish_sdam_event(
      모니터링::TOPOLOGY_CLOSED,
      모니터링::이벤트::토폴로지 닫힘.신규(토폴로지)
    )
    @update_lock.동기화 do
      @connecting = @connected = 거짓
    end
  end
  nil
end

#연결되었나요? ⇒ true|false

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

클러스터 객체 가 클러스터 에 연결되어 있는지 여부입니다.

반환합니다:

  • (true|false) —

    클러스터 연결 여부.

이후:

  • 2.7.0



424
425
426
427
428
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 424

def 연결됨?
  @update_lock.동기화 do
    !!@connected
  end
end

#연결 중이세요? ⇒ true|false

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

클러스터 객체가 해당 클러스터에 연결 중인 상태인지 여부입니다.

반환합니다:

  • (true|false) —

    클러스터 연결 여부.

이후:

  • 2.0.0



412
413
414
415
416
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 412

def 연결 중?
  @update_lock.동기화 do
    !!@connecting
  end
end

#disable_server_if_connected(서버) ⇒ 객체

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

이후:

  • 2.0.0



944
945
946
947
948
949
950
951
952
953
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 944

def connect_server_if_connected(서버)
  만약 서버.연결됨?
    서버.clear_description
    서버.연결 해제!
    publish_sdam_event(
      모니터링::SERVER_CLOSED,
      모니터링::이벤트::ServerClosed.신규(서버.주소, 토폴로지)
    )
  end
end

#has_readable_server?(server_selector = nil) ⇒ true, false

클러스터 가 제공된 읽기 설정 (read preference) 에 대해 읽기 가능 서버 를 선택할지 결정합니다.

예시:

읽을 수 있는 서버가 있나요?

topology.has_readable_server?(server_selector)

매개변수:

  • server_selector (ServerSelector) (기본값: nil) —

    서버 선택기.

반환합니다:

  • (true, false) —

    읽기 가능한 서버가 있는 경우.

이후:

  • 2.4.0



755
756
757
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 755

def has_readable_server?(server_selector = nil)
  토폴로지.has_readable_server?(self, server_selector)
end

#has_writeable_server? ⇒ true, false

클러스터가 쓰기 가능한 서버를 선택할지 결정합니다.

예시:

쓰기 가능한 서버가 있나요?

topology.has_writable_server?

반환합니다:

  • (true, false) —

    쓰기 가능한 서버가 있는 경우.

이후:

  • 2.4.0



767
768
769
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 767

def has_writeable_server?
  토폴로지.has_writeable_server?(self)
end

#heartbeat_interval ⇒ Float

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

서버 의 새로 고침 간격을 가져옵니다. 이는 옵션을 통해 정의되거나 기본값 은 10 입니다.

반환합니다:

  • (Float) —

    하트비트 간격(초)입니다.

이후:

  • 2.10.0



403
404
405
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 403

def heartbeat_interval
  옵션[:하트비트_빈도] || 서버::모니터::DEFAULT_HEARTBEAT_INTERVAL
end

#검사 ⇒ string

검사에 사용할 수 있도록 더 멋진 형식의 string 을 가져옵니다.

예시:

클러스터를 검사합니다.

cluster.inspect

반환합니다:

  • (string) —

    클러스터 검사.

이후:

  • 2.0.0



473
474
475
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 473

def 검사
  "#<Mongo::Cluster:0x#{object_id} 서버=#{서버} 토폴로지=#{토폴로지.요약}>"
end

#load_balancing? ⇒ true | false

클러스터 가 로드 밸런싱된 토폴로지 에 구성되었는지 여부를 반환합니다.

반환합니다:

  • (true | false) —

    토폴로지의 로드 밸런싱 여부입니다.

이후:

  • 2.0.0



345
346
347
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 345

def load_balancing?
  토폴로지.is_a?(토폴로지::로드 밸런싱)
end

#max_read_retries ⇒ 정수

더 이상 사용되지 않습니다.
참고:

max_read_retries는 클러스터 인스턴스 가 아닌 클라이언트 인스턴스 에서 검색해야 하며, 이는 클러스터가 최대 읽기 재시도 횟수에 대해 서로 다른 값을 가진 클라이언트 간에 공유될 수 있기 때문입니다.

레거시 읽기 재시도를 사용할 때 클라이언트 가 읽기 작업을 재시도할 수 있는 최대 횟수를 가져옵니다.

예시:

최대 읽기 재시도를 가져옵니다.

cluster.max_read_retries

반환합니다:

  • (정수) —

    최대 재시도 횟수입니다.

이후:

  • 2.1.1



374
375
376
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 374

def max_read_retries
  옵션[:max_read_retries] || MAX_READ_RETRIES
end

#Next_primary(ping = nil, 세션 = nil) ⇒ Mongo::Server

작업을 보낼 수 있는 다음 프라이머리 서버 를 가져옵니다.

예시:

다음 프라이머리 서버를 가져옵니다.

cluster.next_primary

매개변수:

  • ping (true, false) (기본값: nil) —

    선택하기 전에 서버를 핑할지 여부입니다. 더 이상 사용되지 않으며 무시됩니다.

  • Session (Session | nil) (기본값: nil) —

    mongos 고정을 위해 고려해야 할 선택적 세션입니다.

반환합니다:

이후:

  • 2.0.0



784
785
786
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 784

def Next_primary(ping = nil, Session = nil)
  ServerSelector.기본.select_server(self, nil, Session)
end

#풀(서버) ⇒ Server::ConnectionPool

더 이상 사용되지 않습니다.

서버의 연결 풀을 가져옵니다.

예시:

연결 풀을 가져옵니다.

cluster.pool(server)

매개변수:

반환합니다:

이후:

  • 2.2.0



799
800
801
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 799

def 풀(서버)
  서버.풀
end

#read_retry_interval ⇒ Float

더 이상 사용되지 않습니다.
참고:

read_retry_interval은 클러스터 인스턴스가 아닌 클라이언트 인스턴스에서 검색해야 하는데, 이는 읽기 재시도 간격에 대해 서로 다른 값을 가진 클라이언트 간에 클러스터를 공유할 수 있기 때문입니다.

레거시 읽기 재시도를 사용할 때 읽기를 재시도하는 간격(초)을 가져옵니다.

예시:

읽기 재시도 간격을 가져옵니다.

cluster.read_retry_interval

반환합니다:

  • (Float) —

    간격입니다.

이후:

  • 2.1.1



392
393
394
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 392

def read_retry_interval
  옵션[:read_retry_interval] || READ_RETRY_INTERVAL
end

#다시 연결하세요! ⇒ true

더 이상 사용되지 않습니다.

이 메서드를 호출하는 대신 Client#reconnect를 사용하여 클러스터에 다시 연결합니다. 이 메서드는 SDAM 이벤트를 전송하지 않습니다.

모든 서버를 다시 연결합니다.

예시:

클러스터의 서버를 다시 연결합니다.

cluster.reconnect!

반환합니다:

  • (true) —

    항상 사실입니다.

이후:

  • 2.1.0



550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 550

def 다시 연결합니다!
  @state_change_lock.동기화 do
    @update_lock.동기화 do
      @connecting = true
    end
    스캔!
    서버.각 do |서버|
      서버.다시 연결합니다!
    end
    @periodic_executor.다시 시작!
    @srv_monitor_lock.동기화 do
      만약 @srv_monitor
        @srv_monitor.실행!
      end
    end
    @update_lock.동기화 do
      @connecting = 거짓
      @connected = true
    end
  end
end

#제거(호스팅하다, 연결 해제: true) ⇒ Array<Server> | true | false

참고:

이 메서드의 반환 값은 드라이버의 공개 API에 포함되어 있지 않습니다.

제공된 주소에 해당하는 서버가 있는 경우 클러스터에서 제거합니다.

예시:

클러스터에서 서버를 제거합니다.

server.remove('127.0.0.1:27017')

매개변수:

  • 호스트 (string) —

    호스팅하다/포트 또는 소켓 주소 입니다.

  • 연결 해제 (true | false) (기본값: true) —

    제거 중인 서버의 연결을 끊을지 여부입니다. 내부 드라이버 전용입니다.

반환합니다:

  • (Array<Server> | true | false) —

    nil을 포함하여 연결 해제가 false가 아닌 다른 값이면 제거된 서버가 있는지 여부를 반환합니다. 연결 해제가 거짓인 경우, 제거된(그리고 호출자가 연결을 해제해야 하는) 서버의 배열을 반환합니다.

이후:

  • 2.0.0



885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 885

def 제거(호스트, 연결 해제: true)
  주소 = 주소.신규(호스트)
  Removed_servers = []
  @update_lock.동기화 do
    @servers.delete_if do |서버|
      (서버.주소 == 주소).탭 do |삭제|
        만약 삭제
          Removed_servers << 서버
        end
      end
    end
  end
  만약 연결 해제 != 거짓
    Removed_servers.각 do |서버|
      connect_server_if_connected(서버)
    end
  end
  만약 연결 해제 != 거짓
    Removed_servers.어떤?
  other
    Removed_servers
  end
end

#run_sdam_flow(previous_desc, updated_desc, options = {}) ⇒ 객체

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

클러스터에서 SDAM 흐름을 실행합니다.

이 메서드는 모니터링 또는 비모니터링 연결에서 서버가 반환한 새 서버 설명을 처리하기 위해 호출할 수 있으며, (네트워크) 오류의 결과로 서버를 알 수 없음으로 표시할 때 드라이버에 의해 호출될 수 있습니다.

매개변수:

옵션 해시(options):

  • :keep_connection_pool (true | false) —

    일반적으로 새 서버 설명을 알 수 없는 경우 해당 서버의 연결 풀이 지워집니다. 기존 연결 풀을 유지하려면 이 옵션을 true로 설정합니다( 4.2+ 서버에서 마스터가 아닌 오류를 처리할 때 필요).

  • :awaited (true | false) —

    업데이트된 설명이 대기 중인 hello를 처리한 결과인지 여부입니다.

  • :service_id (객체) —

    지정된 서비스 ID에 대해서만 상태를 변경합니다.

  • :scan_error (Mongo::Error | nil) —

    스캔하는 동안 발생한 오류이며, 오류가 발생하지 않은 경우 nil입니다.

이후:

  • 2.0.0



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
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
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 636

def run_sdam_flow(이전_설명, updated_desc, 옵션 = {})
  만약 load_balancing?
    만약 updated_desc.config.비어 있나요?
      하지 않는 한 옵션[:keep_connection_pool]
        server_list.각 do |서버|
          # TODO는 updated_desc에서 서비스 ID를 제거해야 하나요?
          # 다음과 같이 단언할 수도 있습니다.
          # options[:service_id] == updated_desc.service_id
          오류 = 옵션[:scan_error]
          인터럽트 = 오류 && (오류.is_a?(오류::SocketError) || 오류.is_a?(오류::SocketTimeoutError))
          서버.clear_connection_pool(service_id: 옵션[:service_id], interrupt_in_use_connections: 인터럽트)
        end
      end
    end
    반환
  end

  @sdam_flow_lock.동기화 do
    flow = S담플로우.신규(self, 이전_설명, updated_desc,
      awaited: 옵션[:awaited])
    flow.server_description_changed

    # SDAM 흐름은 업데이트된 설명을 변경할 수 있습니다.
    서버를 사용할 수 있는 경우 # 브로드캐스트 목적의 버전
    updated_desc = flow.updated_desc

    하지 않는 한 옵션[:keep_connection_pool]
      만약 flow.created_unknown?
        server_list.각 do |서버|
          만약 서버.주소 == updated_desc.주소
            오류 = 옵션[:scan_error]
            인터럽트 = 오류 && (오류.is_a?(오류::SocketError) || 오류.is_a?(오류::SocketTimeoutError))
            서버.clear_connection_pool(interrupt_in_use_connections: 인터럽트)
          end
        end
      end
    end

    start_stop_srv_monitor
  end

  # 일부 업데이트된 설명(예: 일치하지 않는 설명)으로 인해
  설명을 처리 중인 # 서버가 제거되고 있습니다.
  # 토폴로지. 이 경우 서버의 모니터링 스레드는
  # 죽었습니다. 결과적으로 흐름 호출 이후의 코드는 실행되지 않을 수 있습니다.
  # 특정 모니터 인스턴스 이므로 일반적으로 다음이 없어야 합니다.
  # 플로우 호출 이후 이 메서드의 모든 코드입니다.
  #
  # 그러나 이 브로드캐스트 호출은 모니터링이
  # 스레드가 종료되었습니다.
  # 현재 대기 중이어야 하므로 세마포어에 신호를 보내지 않습니다.
  # 문제를 일으키지 않아야 합니다.
  하지 않는 한 updated_desc.알 수 없음?
    server_selection_semapher.브로드캐스트
  end
end

#스캔!(sync = true) ⇒ true

참고:

동기 및 비동기 스캔 모두에서 각 모니터 스레드는 스캔 사이의 최소 간격을 유지하므로 이 메서드를 호출해도 다음 순간에 특정 서버에서 스캔이 시작되지 않을 수 있습니다.

클러스터의 알려진 모든 서버를 강제로 스캔합니다.

기본값인 sync 매개변수가 true인 경우, 이 메서드를 호출한 스레드에서 스캔이 동기적으로 수행됩니다. 클러스터의 각 서버는 순차적으로 검사됩니다. 클러스터에 서버가 많거나 응답 속도가 느린 경우 작업이 오래 실행될 수 있습니다.

동기화 매개 변수가 false이면 이 메서드는 모든 서버 모니터 스레드에 즉시 스캔을 수행하도록 지시하고 스캔 결과를 기다리지 않고 반환됩니다.

예시:

전체 클러스터 스캔을 강제 실행합니다.

cluster.scan!

반환합니다:

  • (true) —

    항상 사실입니다.

이후:

  • 2.0.0



595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 595

def 스캔!(동기화=true)
  만약 동기화
    server_list.각 do |서버|
      만약 서버.모니터
        서버.모니터.스캔!
      other
        log_warn("클러스터 #{요약}에서 동기 스캔이 요청 되었지만 서버 #{서버} 에 모니터가 없습니다. ")
      end
    end
  other
    server_list.각 do |서버|
      서버.scan_semapher.신호
    end
  end
  true
end

#서버 ⇒ 배열<MongoDB 서버>

클러스터에서 작업을 실행할 수 있는 서버 후보 목록을 가져옵니다.

예시:

작업에 대한 서버 후보를 가져옵니다.

cluster.servers

반환합니다:

이후:

  • 2.0.0



439
440
441
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 439

def 서버
  토폴로지.서버(server_list)
end

#server_list ⇒ 객체

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

이후:

  • 2.0.0



937
938
939
940
941
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 937

def server_list
  @update_lock.동기화 do
    @servers.dup
  end
end

#set_server_list(server_address_strs) ⇒ 객체

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

서버 목록을 제공된 주소 문자열 목록의 주소로 설정합니다.

이 메서드는 모니터링되는 호스트 이름에 대한 새 DNS 레코드를 수신한 후 SRV 모니터에 의해 호출됩니다.

전달된 서버 주소 목록에 주소가 없는 클러스터의 서버를 제거하고 인수에 아직 클러스터에 없는 주소에 대한 서버를 추가합니다.

매개변수:

  • server_address_strs (Array<String>) —

    클러스터 서버를 동기화할 서버 주소 목록입니다.

이후:

  • 2.0.0



707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 707

def set_server_list(server_address_strs)
  @sdam_flow_lock.동기화 do
    # 새 주소 중 하나가 현재 서버 목록에 없는 경우,
    # 서버 목록에 추가합니다.
    server_address_strs.각 do |주소_str|
      하지 않는 한 server_list.어떤? { |서버| 서버.주소.시드 == 주소_str }
        추가(주소_str)
      end
    end

    # 서버 주소 중 하나가 새 주소 목록에 없는 경우,
    # 서버 목록에서 해당 서버를 제거합니다.
    server_list.각 do |서버|
      하지 않는 한 server_address_strs.어떤? { |주소_str| 서버.주소.시드 == 주소_str }
        제거(서버.주소.시드)
      end
    end
  end
end

#요약 ⇒ 객체

참고:

이 방법은 실험적이며 변경될 수 있습니다.

이후:

  • 2.7.0



481
482
483
484
485
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 481

def 요약
  "#<Cluster " +
  "topology=#{topology.요약} "+
  "server=[#{server_list.map(&:summary).join(',')}]>"
end

#update_cluster_time(result) ⇒ 객체

응답에 표시되는 최대 클러스터 시간을 업데이트합니다.

예시:

클러스터 시간을 업데이트합니다.

cluster.update_cluster_time(result)

매개변수:

  • 결과 (Operation::Result) —

    클러스터 시간이 포함된 작업 결과입니다.

반환합니다:

  • (객체) —

    클러스터 시간입니다.

이후:

  • 2.5.0



813
814
815
816
817
818
819
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 813

def update_cluster_time(결과)
  만약 cluster_time_doc = 결과.cluster_time
    @cluster_time_lock.동기화 do
      advanced_cluster_time(cluster_time_doc)
    end
  end
end

#update_topology(new_topology) ⇒ 객체

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

이후:

  • 2.0.0



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
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 910

def update_topology(new_topology)
  old_topology = nil
  @update_lock.동기화 do
    old_topology = 토폴로지
    @topology = new_topology
  end

  # 새 토폴로지에 데이터 보유 서버가 있는 경우 다음 여부를 확실히 알 수 있습니다.
  # 세션이 지원됩니다 - 캐시된 값을 업데이트 하세요.
  # 새 토폴로지 에 데이터 보유 서버가 없는 경우 이전 값을 그대로 둡니다.
  # 있는 그대로의 세션_지원되나요? 메서드가 서버 선택을 수행합니다.
  # 세션 지원 을 정확하게 결정하려고 시도합니다.
  # 마지막으로 알려진 값입니다.
  만약 토폴로지.data_bearing_servers?
    세션_지원 = !!토폴로지.logical_session_timeout
    @update_lock.동기화 do
      @sessions_supported = 세션_지원
    end
  end

  publish_sdam_event(
    모니터링::TOPOLOGY_CHANGED,
    모니터링::이벤트::토폴로지 변경됨.신규(old_topology, 토폴로지)
  )
end

#validate_session_support! ⇒ 객체

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

운전자 가 연결된 배포서버 가 세션을 지원 하지 않는 경우 Error::SessionsNotAvailable이 발생합니다.

세션 지원은 시간이 지남에 따라 변경될 수 있습니다(예: 배포서버의 업그레이드 또는 다운그레이드). 클라이언트가 서버에 연결되어 있지 않고 서버 선택 시간 초과 기간 동안 서버를 찾지 못하면 이 메서드는 NoServerAvailable을 발생시킵니다. 이 메서드는 작업 실행 흐름에서 호출되며, NoServerAvailable을 발생시키면 해당 예외와 함께 전체 작업이 실패하게 됩니다. 시도 중인 작업에 적합함)이(가) 구체화되지 않았습니다.

다음을 발생시킵니다.

  • (Error::SessionsNotAvailable) —

    드라이버가 연결된 배포가 세션을 지원하지 않는 경우.

  • (Error::NoServerAvailable) —

    클라이언트 가 어떤 서버에도 연결되어 있지 않고 서버 선택 시간 동안 서버를 찾지 못하는 경우 제한 시간이 초과됩니다.

이후:

  • 2.0.0



976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
 
# 파일 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', 줄 976

def validate_session_support!
  만약 토폴로지.is_a?(토폴로지::로드 밸런싱)
    반환
  end

  @state_change_lock.동기화 do
    @sdam_flow_lock.동기화 do
      만약 토폴로지.data_bearing_servers?
        하지 않는 한 토폴로지.logical_session_timeout
          raise_sessions_not_supported
        end
      end
    end
  end

  # 알려진 데이터 보유 서버 없음 - 서버 선택을 수행하여 다음을 시도합니다.
  # 그 중 하나 이상으로부터 응답을 받아 정확한 값을 반환합니다.
  # 세션이 현재 지원되는지 여부를 평가합니다.
  ServerSelector.get(모드: :primary_preferred).select_server(self)
  @state_change_lock.동기화 do
    @sdam_flow_lock.동기화 do
      하지 않는 한 토폴로지.logical_session_timeout
        raise_sessions_not_supported
      end
    end
  end
end