类：Mongo::Cluster

继承：
对象
  • 对象
显示全部
扩展方式：
可转发
包括：
Mongo::ClusterTime::Consumer 、 Event::Subscriber 、 Loggable 、 Monitoring::Publishable
定义于：
lib/ Mongo/
集群、lib/ Mongo/
集群/ 拓扑结构、lib/ Mongo/ 集群/ 拓扑结构、lib/

Mongo/ 集群/sdam_flow.rb、lib/
Mongo/ 集群/ 拓扑结构/base.rb、
lib/ Mongo/ 集群/ 拓扑结构/single.rb、lib/
Mongo/ 集群/ 拓扑结构/ 分片的、lib/ Mongo/ 集群/ 拓扑结构/unknown.rb、lib/

Mongo/ 集群/ periodic_executor.rb、lib/
Mongo/ 集群/reapers/cursor_reaper.rb,
lib/ Mongo/ 集群/reapers/socket_reaper.rb,
lib/ Mongo/ 集群/ 拓扑结构/load_balanced.rb,
lib/ Mongo/ 集群/ 拓扑结构/no_replica_set_options.rb, lib/ Mongo/ 集群/拓扑结构/replica_set_no_primary.rb, lib/
Mongo/ 集群/ 拓扑结构/replica_set_with_primary.rb

Overview

版权所有 (C) 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_sdam_event

构造函数详情

#初始化(seeds, Monitoring, options = Options::Redacted.new) ⇒集群

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

注意：

切勿在客户端之外直接实例化集群。

注意：

连接到 mongodb+srv:// URI 时，客户端会将此类 URI 扩展为服务器列表，并将该列表传递给集群构造函数。 当连接到独立运行运行的mongod时，集群构造函数会接收一个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 ) —

    仅供内部驱动程序使用。 设置为 false 可防止此集群或其下的服务器执行与 SDAM 相关的 I/O。 注意：将此选项设置为 false 将使集群无法运行。 它适用于手动调用 SDAM 状态转换的测试。

  • :cleanup ( true | false ) —

    仅供内部驱动程序使用。 设置为 false 可防止在集群断开连接时向服务器发送 endSessions 命令以清理服务器会话，并且不启动定期执行程序。 如果 :monitoring_io 为 false，则 :cleanup 也会自动默认为 false。

  • :heartbeat_Frequency （浮点） —

    服务器监视器通过 hello 刷新其描述的时间间隔（以秒为单位）。

  • :resolv_options （哈希） —

    仅供内部驱动程序使用。 传递给 Resolv::DNS 构造函数以进行 SRV 查找的选项。

  • :server_api （哈希） —

    请求的服务器 API 版本。 此哈希可以包含以下项目：

    • :version -- string
    • :strict -- 布尔值
    • :deprecation_errors -- 布尔值

引发：

  • ( ArgumentError )

由于：

  • 2.0.0



118
119
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
 
# File 'lib/ Mongo/ 集群.rb', 第 118 行

def 初始化(种子, 监控, 选项 = 选项::已编辑.new)
  提高 ArgumentError, '种子不能为 nil ' if 种子.nil?

  选项 = 选项.dup
  选项[:cleanup] = false if 选项[:monitoring_io] == false && !选项.键？(:cleanup)
  @tracer = 选项.删除(:tracer)
  @options = 选项.冻结

  # @update_lock 涵盖 @servers、@connecting、@connected、@topology 和
  # @sessions_supported. 通常没有
  # 为它们指定的锁只能在更新锁下进行修改。
  # 请注意，拓扑结构更改由 @update_lock 锁定，而不是
  # @sdam_flow_lock.
  @update_lock = 互斥锁.new
  @servers = []
  @monitoring = 监控
  @event_listeners = 事件::监听器.new
  @app_metadata = 服务器::AppMetadata.new(@options.合并(merge)(目的： ：应用程序))
  @monitor_app_metadata = 服务器::监控::AppMetadata.new(@options.合并(merge)(目的： :monitor))
  @push_monitor_app_metadata = 服务器::监控::AppMetadata.new(@options.合并(merge)(目的： :push_monitor))
  @cluster_time_lock = 互斥锁.new
  @cluster_time = nil
  @srv_monitor_lock = 互斥锁.new
  @srv_monitor = nil
  @server_selection_semaphore = 信号量.new
  @topology = 拓扑结构.初始(self, 监控, 选项)
  # 状态变更锁与 sdam 流锁类似，但设计为
  # 用于序列化集群消费者发起的状态变更
  #（例如 连接或断开集群的应用程序），以便
  # 例如，应用程序快速调用断开连接
  # 不会将集群置于不一致状态。
  # 监控驱动程序内部执行的更新不会占用
  # 状态变更锁。
  @state_change_lock = 互斥锁.new
  # @sdam_flow_lock 仅涵盖 sdam 流。 请注意，它不适用
  # 到拓扑结构的替换，这是在 @update_lock 下完成的。
  @sdam_flow_lock = 互斥锁.new
  @session_pool = 会话::SessionPool.new(self)

  提高 ArgumentError, “禁止使用没有种子的负载均衡集群” if 种子.空？ && load_balanced?

  # 在没有服务器的情况下，开放拓扑始终未知。
  # https://github.com/mongodb/specifications/pull/388
  Opening_Topology = 拓扑结构::未知.new(选项, 监控, self)

  publish_sdam_event(
    监控::TOPOLOGY_OPENING,
    监控::事件::TopologyOpening.new(Opening_Topology)
  )

  @seeds = 种子 = 种子.uniq
  服务器 = 种子.map do |种子轮|
    # MongoDB Server打开事件必须在拓扑更改事件之后发送。
    # 因此，在拓扑结构更改之前，单独添加服务器
    # 事件发布后，从开始监控服务器
    # 稍后完成。
    添加(种子轮, 监控： false)
  end

  if 种子.size >= 1
    # 重新创建拓扑，将当前服务器列表放入其中
    recreate_topology(拓扑结构, Opening_Topology)
  end

  possible_warn_about_compatibility!

  if load_balanced?
    # 规范要求我们生成某些 SDAM 事件
    # 处于负载均衡拓扑结构时。
    # 从以下方面来看，这些事件没有多大意义：
    # 驱动程序的 SDAM 实现，也不从
    # 驱动程序的负载负载均衡器实施。
    # 它们只是必需的样板文件。
    #
    # 请注意，此调用必须在 Monitoring_io 检查之上完成
    # 因为这会使构造函数的其余部分短路。
    fabricate_lb_sdam_events_and_set_server_type
  end

  if 选项[:monitoring_io] == false
    # 省略定期执行程序构建，因为没有服务器
    # 任何命令都不能发送到集群，也不应该
    # 可以是任何需要清理的内容。
    #
    # 省略对单个服务器和传统单轮
    # 主线程上的 SDAM，因为它会与模拟的测试争用
    # SDAM 响应。
    @connecting = @connected = false
    return
  end

  # 在启动监控线程之前更新实例变量。
  @connecting = false
  @connected = true

  if 选项[:cleanup] != false
    @cursor_reaper = CursorReaper.new(self)
    @socket_reaper = SocketReaper.new(self)
    @periodic_executor = periodicexecutor.new([
                                                @cursor_reaper, @socket_reaper,
                                              ], 选项)

    @periodic_executor.运行！
  end

  return if load_balanced?

  # 在开始监控之前需要记录开始时间
  start_monotime = Utils.monotic_time

  服务器.每 do |server|
    server.start_monitoring
  end

  if 选项[:scan] != false
    server_selection_timeout = 选项[:server_selection_timeout] || ServerSelector::SERVER_SELECTION_TIMEOUT
    # 服务器选择超时可以非常短，尤其是在
    # 测试，当客户端在此之前等待同步扫描时
    # 开始选择服务器。 限制扫描到服务器选择的时间
    # 然后在扫描本地服务器之前就中止扫描。
    # 因此，此处至少允许3秒进行扫描。
    server_selection_timeout = 3 if server_selection_timeout < 3
    截止日期 = start_monotime + server_selection_timeout
    # 等待每个服务器的第一次扫描完成，对于
    # 向后兼容性。
    # 如果在此 SDAM 轮次中发现任何服务器，我们将
    # 等待这些服务器也被查询，依此类推，直到
    # 服务器选择超时或最小值为3秒。
    循环 do
      # 确保在 SDAM 运行时不会尝试读取服务器列表
      服务器 = @sdam_flow_lock.同步 do
        server_list.dup
      end
      中断 if 服务器.全部？ { |server| server.last_scan_monotime && server.last_scan_monotime >= start_monotime }
      if (time_remaining = 截止日期 - Utils.monotic_time) <= 0
        中断
      end

      log_debug("等待#{ ' %. 2 f ' % time_remaining }秒，用于扫描服务器： #{ summary } ")
      # 由于信号量可能已在我们之间发出
      # 上面的服务器列表和下面的等待调用，我们不应该
      # 等待完整的剩余时间 - 最多等待0.5秒，然后
      # 重新检查状态。
      开始
        server_selection_semaphore.wait([ time_remaining, 0.5 ].min)
      救援 ::超时::错误
        # 什么都没有
      end
    end
  end

  start_stop_srv_monitor
end

实例属性详细信息

# app_metadata ⇒ Mongo::Server::AppMetadata （只读）

返回用于连接握手的应用程序元数据。

返回：

由于：

  • 2.4.0



311
312
313
 
# File 'lib/ Mongo/ 集群.rb', 第 311 行

def app_metadata
  @app_metadata
end

#monitor_app_metadata ⇒对象（只读）

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

由于：

  • 2.0.0



314
315
316
 
# File 'lib/ Mongo/ 集群.rb', 第 314 行

def Monitor_app_metadata
  @monitor_app_metadata
end

# Monitoring ⇒监控（只读）

返回监控 监控。

返回：

  • (监控) —

    监控 监控。

由于：

  • 2.0.0



300
301
302
 
# File 'lib/ Mongo/ 集群.rb', 第 300 行

def 监控
  @monitoring
end

# options ⇒哈希（只读）

返回选项哈希值。

返回：

  • (哈希) —

    选项哈希。

由于：

  • 2.0.0



297
298
299
 
# File 'lib/ Mongo/ 集群.rb', 第 297 行

def 选项
  @options
end

# push_monitor_app_metadata ⇒对象（只读）

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

由于：

  • 2.0.0



317
318
319
 
# File 'lib/ Mongo/ 集群.rb', 第 317 行

def push_monitor_app_metadata
  @push_monitor_app_metadata
end

#种子⇒ Array<String> （只读）

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

返回种子服务器的地址。 包含实例化集群时提供给集群的地址，而不是集群由于 SDAM 而使用的当前地址。

返回：

  • ( Array<String> ) —

    种子服务器的地址。 包含实例化集群时提供给集群的地址，而不是集群由于 SDAM 而使用的当前地址。

由于：

  • 2.7.0



325
326
327
 
# File 'lib/ Mongo/ 集群.rb', 第 325 行

def 种子
  @seeds
end

# server_selection_semaphore ⇒对象（只读）

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

由于：

  • 2.0.0



482
483
484
 
# File 'lib/ Mongo/ 集群.rb', 第 482 行

def server_selection_semaphore
  @server_selection_semaphore
end

# session_pool ⇒对象（只读）

由于：

  • 2.5.1



330
331
332
 
# File 'lib/ Mongo/ 集群.rb', 第 330 行

def session_pool
  @session_pool
end

# srv_monitor ⇒对象（只读）

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

由于：

  • 2.0.0



352
353
354
 
# File 'lib/ Mongo/ 集群.rb', 第 352 行

def srv_monitor
  @srv_monitor
end

# topology =" Integer ? （只读）

逻辑会话超时值（以分钟为单位）。

例子：

获取逻辑会话超时（以分钟为单位）。

cluster.logical_session_timeout

返回：

  • ( Integer , nil ) —

    逻辑会话超时。

由于：

  • 2.5.0



305
306
307
 
# File 'lib/ Mongo/ 集群.rb', 第 305 行

def 拓扑结构
  @topology
end

#跟踪器 ⇒ 对象 （只读）

由于：

  • 2.0.0



302
303
304
 
# File 'lib/ Mongo/ 集群.rb', 第 302 行

def 追踪器
  @tracer
end

类方法详细信息

。 create (client, Monitoring: nil) ⇒集群

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

为提供的客户端创建一个集群，以在不希望客户端的原始集群实例相同时使用。

例子：

为客户端创建集群。

Cluster.create(client)

参数：

  • 客户端 (客户端) —

    要在其上创建的客户端。

  • 监控。 (监控| nil ) —

    用于新集群的监控实例。 如果为零，则将创建一个新的监控实例。

返回：

由于：

  • 2.0.0



287
288
289
290
291
292
293
294
 
# File 'lib/ Mongo/ 集群.rb', 第 287 行

def self.创建(客户端, 监控： nil)
  集群 = 集群.new(
    客户端.集群.地址.map(和:to_s),
    监控 || 监控.new,
    客户端.cluster_options
  )
  客户端.instance_variable_set(:@cluster, 集群)
end

实例方法详细信息

# == (other) ⇒ true , false

确定此服务器集群是否等于另一个对象。 检查集群中当前的服务器，而不是已配置的服务器。

例子：

集群是否等于对象？

cluster == other

参数：

  • 其他 ( Object ) —

    要比较的对象。

返回：

  • ( true , false ) —

    如果对象相等。

由于：

  • 2.0.0



721
722
723
724
725
 
# File 'lib/ Mongo/ 集群.rb', 第 721 行

def ==(其他)
  return false 除非 其他.is_a?(集群)

  地址 == 其他.地址 && 选项 == 其他.选项
end

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

使用提供的地址向集群添加服务器。 当现有服务器执行 hello 并且包括可能未配置的服务器时，在自动发现新服务器时非常有用。

例子：

将该地址的服务器添加到集群。

cluster.add('127.0.0.1:27018')

参数：

  • 主机 ( string ) —

    要添加的服务器的地址。

  • 选项 (哈希) —

    一组可自定义的选项

返回：

  • ( MongoDB Server ) —

    新添加的服务器（如果尚不存在）。

由于：

  • 2.0.0



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
 
# File 'lib/ Mongo/ 集群.rb', 第 827 行

def 添加(主机, add_options = nil)
  地址 = 地址.new(主机, 选项)
  return if 地址.包括？(地址)

  opts = 选项.合并(merge)(监控： false)
  # 如果我们不启动监控线程，我们也不希望
  # 启动池的填充器线程。
  opts.合并！(Populator_io: false) 除非 选项.获取(:monitoring_io, true)
  # 请注意，在负载均衡拓扑中，每台服务器都必须是
  # 负载负载均衡器（在选项中指定 load_balancer: true）
  # 但此处未设置此选项，因为我们需要
  # 假装服务器以未知身份启动的规范
  # 并将服务器描述更改事件发布到负载负载均衡器
  # one. 该服务器的实际正确描述将被设置
  # 通过 Manufacturing_lb_sdam_events_and_set_server_type 方法。
  server = 服务器.new(地址, self, @monitoring, event_listeners, opts)
  @update_lock.同步 do
    # 需要重新检查服务器是否存在于 @servers 中，因为
    # 之前的检查没有受到锁定。
    # 由于此处处于更新锁状态，因此无法调用servers_list。
    return if @servers.map(和:address).包括？(地址)

    @servers.推动(server)
  end
  server.start_monitoring if add_options.nil? || add_options[:monitor] != false
  server
end

#addresses ⇒ Array< Mongo::Address >

集群中的地址。

例子：

获取集群中的地址。

cluster.addresses

返回：

由于：

  • 2.0.6



445
446
447
 
# File 'lib/ Mongo/ 集群.rb', 第 445 行

def 地址
  server_list.map(和:address)
end

# close ⇒ nil

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

注意：

应用程序应调用 Client#close 来断开连接

关闭集群。

集群，而不是调用此方法。 此方法仅供内部驱动程序使用。

断开集群中所有服务器的连接，在此过程中发布相应的 SDAM 事件。 如果 SRV 监控处于活动状态，则停止该监控。 将集群标记为已断开连接。

关闭的集群不再可用。 如果客户端重新连接，它将创建一个新的集群实例。

返回：

  • ( nil ) —

    始终为零。

由于：

  • 2.0.0



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
 
# File 'lib/ Mongo/ 集群.rb', 第 500 行

def 关闭
  @state_change_lock.同步 do
    return nil 除非 正在连接？ || 已连接？

    if 选项[:cleanup] != false
      session_pool.end_sessions
      @periodic_executor.停止！
    end
    @srv_monitor_lock.同步 do
      @srv_monitor.停止！ if @srv_monitor
    end
    @servers.每 do |server|
      来年 除非 server.已连接？

      server.关闭
      publish_sdam_event(
        监控::SERVER_CLOSED,
        监控::事件::ServerClosed.new(server.地址, 拓扑结构)
      )
    end
    publish_sdam_event(
      监控::TOPOLOGY_CLOSED,
      监控::事件::TopologyClosed.new(拓扑结构)
    )
    @update_lock.同步 do
      @connecting = @connected = false
    end
  end
  nil
end

#已连接？ ⇒ true|false

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

集群对象是否已连接到其集群。

返回：

  • ( true|false ) —

    集群是否已连接。

由于：

  • 2.7.0



418
419
420
421
422
 
# File 'lib/ Mongo/ 集群.rb', 第 418 行

def 已连接？
  @update_lock.同步 do
    !!@connected
  end
end

#正在连接？ ⇒ true|false

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

集群对象是否正在连接到其集群。

返回：

  • ( true|false ) —

    集群是否正在连接。

由于：

  • 2.0.0



406
407
408
409
410
 
# File 'lib/ Mongo/ 集群.rb', 第 406 行

def 正在连接？
  @update_lock.同步 do
    !!@connecting
  end
end

#disconnect_server_if_connected (server) ⇒对象

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

由于：

  • 2.0.0



931
932
933
934
935
936
937
938
939
940
 
# File 'lib/ Mongo/ 集群.rb', 第 931 行

def connect_server_if_connected(server)
  return 除非 server.已连接？

  server.clear_description
  server.断开连接！
  publish_sdam_event(
    监控::SERVER_CLOSED,
    监控::事件::ServerClosed.new(server.地址, 拓扑结构)
  )
end

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

确定集群是否会为提供的读取偏好（read preference）选择可读服务器。

例子：

是否存在可读服务器？

topology.has_readable_server?(server_selector)

参数：

  • server_selector ( ServerSelector ) （默认为： nil ） —

    服务器选择器。

返回：

  • ( true , false ) —

    如果存在可读服务器。

由于：

  • 2.4.0



739
740
741
 
# File 'lib/ Mongo/ 集群.rb', 第 739 行

def has_read_server?(server_selector = nil)
  拓扑结构.has_read_server?(self, server_selector)
end

# has_writable_server? ⇒ true , false

确定集群是否会选择可写入的服务器。

例子：

是否存在可写服务器？

topology.has_writable_server?

返回：

  • ( true , false ) —

    如果存在可写服务器。

由于：

  • 2.4.0



751
752
753
 
# File 'lib/ Mongo/ 集群.rb', 第 751 行

def has_writable_server?
  拓扑结构.has_writable_server?(self)
end

# heartbeat_interval ⇒ Float

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

获取服务器的刷新间隔。 这将通过选项定义或默认为10 。

返回：

  • (浮点) —

    心跳间隔，以秒为单位。

由于：

  • 2.10.0



397
398
399
 
# File 'lib/ Mongo/ 集群.rb', 第 397 行

def heartbeat_interval
  选项[:heartbeat_Frequency] || 服务器::监控::DEFAULT_HEARTBEAT_INTERVAL
end

#检查⇒ string

获取格式更好的string以用于检查。

例子：

检查集群。

cluster.inspect

返回：

  • ( string ) —

    集群检查。

由于：

  • 2.0.0



467
468
469
 
# File 'lib/ Mongo/ 集群.rb', 第 467 行

def 检查
  " #<Mongo::Cluster:0 x #{ object_id } servers= #{ servers } topology = #{ topology.summary } } > "
end

# load_balanced? ⇒ true | false

返回集群是否配置为负载均衡拓扑结构。

返回：

  • ( true | false ) —

    拓扑结构是否负载均衡。

由于：

  • 2.0.0



339
340
341
 
# File 'lib/ Mongo/ 集群.rb', 第 339 行

def load_balanced?
  拓扑结构.is_a?(拓扑结构::LoadBalanced)
end

# max_read_retries ⇒整数

已弃用。
注意：

max_read_retries 应从客户端实例而不是集群实例中检索，因为集群可能在具有不同最大读取重试值的客户端之间共享。

获取使用传统读取重试时客户端可以重试读取操作的最大次数。

例子：

获取最大读取重试次数。

cluster.max_read_retries

返回：

  • ( Integer ) —

    最大重试次数。

由于：

  • 2.1.1



368
369
370
 
# File 'lib/ Mongo/ 集群.rb', 第 368 行

def max_read_retries
  选项[:max_read_retries] || MAX_READ_RETRIES
end

#next_primary(_ping = nil, session = nil, timeout: nil) ⇒ Mongo::服务器

获取我们可以向其发送操作的下一个主节点 (primary node in the replica set)服务器。

例子：

获取下一个主服务器。

cluster.next_primary

参数：

  • ping ( true , false ) —

    是否在选择之前对服务器进行 ping 操作。 已弃用并忽略。

  • 会话 (会话| nil ) （默认为： nil ） —

    考虑 mongos 固定的可选会话。

  • :timeout ( Float | nil ) —

    操作超时（以秒为单位）（如有）。

返回：

由于：

  • 2.0.0



770
771
772
773
774
775
776
777
 
# File 'lib/ Mongo/ 集群.rb', 第 770 行

def next_primary(网络探测（ping） = nil, 会话 = nil, timeout: nil)
  ServerSelector.主节点.select_server(
    self,
    nil,
    会话,
    timeout: 超时
  )
end

# pool (服务器) ⇒ Server::ConnectionPool

已弃用。

获取服务器的连接池。

例子：

获取连接池。

cluster.pool(server)

参数：

返回：

由于：

  • 2.2.0



790
791
792
 
# File 'lib/ Mongo/ 集群.rb', 第 790 行

def 池(server)
  server.池
end

# read_retry_interval ⇒浮点

已弃用。
注意：

read_retry_interval 应从客户端实例而不是集群实例中检索，因为集群可能在具有不同读取重试间隔值的客户端之间共享。

获取使用传统读取重试时读取重试的时间间隔（以秒为单位）。

例子：

获取读取重试间隔。

cluster.read_retry_interval

返回：

  • (浮点) —

    间隔。

由于：

  • 2.1.1



386
387
388
 
# File 'lib/ Mongo/ 集群.rb', 第 386 行

def read_retry_interval
  选项[:read_retry_interval] || READ_RETRY_INTERVAL
end

#重新连接！ ⇒ true

已弃用。

使用 Client#reconnect 重新连接到集群，而不是调用此方法。 此方法不发送 SDAM 事件。

重新连接所有服务器。

例子：

重新连接集群的服务器。

cluster.reconnect!

返回：

  • ( true ) —

    始终为 true。

由于：

  • 2.1.0



541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
 
# File 'lib/ Mongo/ 集群.rb', 第 541 行

def 重新连接！
  @state_change_lock.同步 do
    @update_lock.同步 do
      @connecting = true
    end
    scan!
    服务器.每 do |server|
      server.重新连接！
    end
    @periodic_executor.重新启动！
    @srv_monitor_lock.同步 do
      @srv_monitor.运行！ if @srv_monitor
    end
    @update_lock.同步 do
      @connecting = false
      @connected = true
    end
  end
end

# 删除 (托管,disconnect: true) ⇒ Array< Server > | true | true false

注意：

此方法的返回值不是驱动程序的公共API的一部分。

从所提供地址的集群中删除服务器（如果存在）。

例子：

从集群中删除服务器。

server.remove('127.0.0.1:27017')

参数：

  • 主机 ( string ) —

    托管/端口或套接字解决。

  • 断开连接 ( true | false ) （默认为： true ） —

    是否断开与正在删除的服务器的连接。 仅供内部驱动程序使用。

返回：

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

    如果 connect 为 false 以外的任何值（包括 nil），则返回是否删除了任何服务器。 如果断开连接为 false，则返回已删除（应由调用者断开连接）的服务器数组。

由于：

  • 2.0.0



874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
 
# File 'lib/ Mongo/ 集群.rb', 第 874 行

def 删除(主机, 断开连接： true)
  地址 = 地址.new(主机)
  remove_servers = []
  @update_lock.同步 do
    @servers.delete_if do |server|
      (server.地址 == 地址).点击 do |删除|
        remove_servers << server if 删除
      end
    end
  end
  if 断开连接 != false
    remove_servers.每 do |server|
      connect_server_if_connected(server)
    end
  end
  if 断开连接 == false
    remove_servers
  else
    remove_servers.任何？
  end
end

# run_sdam_flow (previous_desc, updated_desc, options = {}) ⇒对象

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

在集群上运行 SDAM flow。

可以调用此方法来处理服务器在监控或非监控连接上返回的新服务器描述，也可以调用此方法来处理驱动程序在由于（网络）错误而将服务器标记为未知时返回的新服务器描述。

参数：

  • previous_desc ( Server::Description ) —

    上一个服务器描述。

  • updated_desc ( Server::Description ) —

    更改后的描述。

  • 选项 （哈希） （默认为： {} ） —

    选项。

选项哈希 ( 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



625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
 
# File 'lib/ Mongo/ 集群.rb', 第 625 行

def run_sdam_flow(previous_desc, updated_desc, 选项 = {})
  if load_balanced?
    if updated_desc.config.空？ && !选项[:keep_connection_pool]
      server_list.每 do |server|
        # TODO：是否应从 updated_desc 中删除服务 ID？
        # 我们还可以断言
        # options[:service_id] == updated_desc.service_id
        err = 选项[:scan_error]
        中断 = err && (err.is_a?(错误::SocketError) || err.is_a?(错误::SocketTimeoutError))
        server.clear_connection_pool(service_id: 选项[:service_id], Interrupt_in_use_connections: 中断)
      end
    end
    return
  end

  @sdam_flow_lock.同步 do
    flow = SdamFlow.new(self, previous_desc, updated_desc,
                        等待： 选项[:awaited])
    flow.server_description_changed

    # SDAM 流可能会改变更新后的描述 — 获取最终
    # 用于在服务器可用时进行广播的版本
    updated_desc = flow.updated_desc

    if !选项[:keep_connection_pool] && flow.completed_unknown?
      server_list.每 do |server|
        来年 除非 server.地址 == updated_desc.地址

        err = 选项[:scan_error]
        中断 = err && (err.is_a?(错误::SocketError) || err.is_a?(错误::SocketTimeoutError))
        server.clear_connection_pool(Interrupt_in_use_connections: 中断)
      end
    end

    start_stop_srv_monitor
  end

  # 一些更新的描述，例如与我描述不匹配的描述，会导致
  # 我们正在处理的服务器描述已从中删除
  # 拓扑结构。 发生这种情况时，服务器的监控线程会
  # 被杀。 因此，流程调用之后的任何代码都可能无法运行
  # 一个特定的监控实例，因此一般不应
  # 此方法中流程调用之后的任何代码。
  #
  # 但是，此广播调用可以位于此处，因为如果监控
  # 线程被终止，服务器本应关闭，且没有客户端
  # 当前应该正在等待它，因此不会发出信号量
  # 应该不会导致任何问题。
  return if updated_desc.未知？

  server_selection_semaphore.广播
end

# scan! (sync = true) ⇒ true

注意：

在同步和异步扫描中，每个监视器线程在扫描之间保持最小间隔，这意味着调用此方法可能不会立即在特定服务器上启动扫描。

强制扫描集群中的所有已知服务器。

如果 sync 参数为 true（默认值），则扫描将在调用此方法的线程中同步执行。 按顺序检查集群中的每个服务器。 如果集群中有很多服务器或者它们响应缓慢，则这可能是一项长时间运行的操作。

如果同步参数为 false，则此方法指示所有服务器监控线程执行立即扫描并返回，而不等待扫描结果。

例子：

强制执行全集群扫描。

cluster.scan!

返回：

  • ( true ) —

    始终为 true。

由于：

  • 2.0.0



584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
 
# File 'lib/ Mongo/ 集群.rb', 第 584 行

def scan!(同步 = true)
  if 同步
    server_list.每 do |server|
      if server.监控
        server.监控.scan!
      else
        log_warn(“对集群#{ Summary }请求同步扫描，但服务器#{ server }没有监视器”)
      end
    end
  else
    server_list.每 do |server|
      server.scan_semaphore.信号
    end
  end
  true
end

#servers ⇒数组 < MongoDB Server >

从集群中获取可以对其执行操作的候选服务器列表。

例子：

获取操作的候选服务器。

cluster.servers

返回：

由于：

  • 2.0.0



433
434
435
 
# File 'lib/ Mongo/ 集群.rb', 第 433 行

def 服务器
  拓扑结构.服务器(server_list)
end

#servers_list ⇒对象

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

由于：

  • 2.0.0



924
925
926
927
928
 
# File 'lib/ Mongo/ 集群.rb', 第 924 行

def server_list
  @update_lock.同步 do
    @servers.dup
  end
end

# set_server_list (server_address_strs) ⇒对象

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

将服务器列表设置为所提供的地址字符串列表中的地址。

SRV 监控器在收到受监控主机名的新 DNS 记录后调用此方法。

删除集群中地址不在传递的服务器地址列表中的服务器，并为参数中的任何地址添加尚不在集群中的服务器。

参数：

  • server_address_strs ( Array<String> ) —

    要同步集群服务器的服务器地址列表。

由于：

  • 2.0.0



692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
 
# File 'lib/ Mongo/ 集群.rb', 第 692 行

def set_server_list(server_address_strs)
  @sdam_flow_lock.同步 do
    # 如果其中一个新地址不在当前服务器列表中，
    # 将其添加到服务器列表中。
    server_address_strs.每 do |Address_str|
      添加(Address_str) 除非 server_list.任何？ { |server| server.地址.种子轮 == Address_str }
    end

    # 如果其中一个服务器的地址不在新解决列表中，
    # 从服务器列表中删除该服务器。
    server_list.每 do |server|
      除非 server_address_strs.任何？ { |Address_str| server.地址.种子轮 == Address_str }
        删除(server.地址.种子轮)
      end
    end
  end
end

#摘要⇒对象

注意：

此方法是实验性的，可能会发生变化。

由于：

  • 2.7.0



475
476
477
478
479
 
# File 'lib/ Mongo/ 集群.rb', 第 475 行

def 总结
  '#<Cluster ' +
    "拓扑= #{拓扑。摘要} " +
    " Servers=[ #{ servers_list .map ( & : summary ) . join ( ' , ' ) } } ] > "
end

# update_cluster_time (result) ⇒对象

更新响应中显示的最大集群时间。

例子：

更新集群时间。

cluster.update_cluster_time(result)

参数：

返回：

  • ( Object ) —

    集群时间。

由于：

  • 2.5.0



804
805
806
807
808
809
810
 
# File 'lib/ Mongo/ 集群.rb', 第 804 行

def update_cluster_time(结果)
  return 除非 cluster_time_doc = 结果.cluster_time

  @cluster_time_lock.同步 do
    advance_cluster_time(cluster_time_doc)
  end
end

# update_topology (new_topology) ⇒对象

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

由于：

  • 2.0.0



897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
 
# File 'lib/ Mongo/ 集群.rb', 第 897 行

def update_topology(new_topology)
  old_topology = nil
  @update_lock.同步 do
    old_topology = 拓扑结构
    @topology = new_topology
  end

  # 如果新的拓扑结构有数据承载服务器，我们可以确定是否
  支持 # 个会话 -更新我们的缓存值。
  # 如果新拓扑结构没有数据承载服务器，则保留旧值
  # 保持原样，sessions_supported? 方法将执行服务器选择
  # 尝试准确确定会话支持，回退到
  # 最后一个已知值。
  if 拓扑结构.data_ Bearing_servers?
    session_supported = !!拓扑结构.logic_session_timeout
    @update_lock.同步 do
      @sessions_supported = session_supported
    end
  end

  publish_sdam_event(
    监控::TOPOLOGY_CHANGED,
    监控::事件::TopologyChanged.new(old_topology, 拓扑结构)
  )
end

# validate_session_support! (timeout: nil) ⇒ 对象

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

如果驱动程序连接到的部署不支持会话，则引发 Error::SessionsNotAvailable。

会话支持可能会随着时间的推移而变化，示例由于部署中的服务器升级或降级。如果客户端未连接到任何服务器，并且在服务器选择超时时间内未找到任何服务器，则此方法将引发 NoServerAvailable。此方法是从操作执行流中调用的，如果它引发 NoServerAvailable，则整个操作将失败并出现该异常，因为操作执行已等待服务器选择超时，以使任何服务器变为可用（这将是服务器的超集）适合正在尝试的操作），但没有实现。

参数：

  • :timeout ( Float | nil ) —

    验证超时。 由于验证进程涉及服务器选择，

引发：

  • ( Error::SessionsNotAvailable ) —

    如果驱动程序连接到的部署不支持会话。

  • ( Error::NoServerAvailable ) —

    如果客户端未连接到任何服务器，也未在服务器选择超时时间内找到任何服务器。

由于：

  • 2.0.0



966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
 
# File 'lib/ Mongo/ 集群.rb', 第 966 行

def validate_session_support!(timeout: nil)
  return if 拓扑结构.is_a?(拓扑结构::LoadBalanced)

  @state_change_lock.同步 do
    @sdam_flow_lock.同步 do
      Raise_sessions_not_supported if 拓扑结构.data_ Bearing_servers? && !拓扑结构.logic_session_timeout
    end
  end

  # 没有已知的数据承载服务器 - 执行服务器选择以尝试
  # 至少从其中一个获取响应，以返回准确的
  # 评估当前是否支持会话。
  ServerSelector.获取(模式： :primary_preferred).select_server(self, timeout: 超时)
  @state_change_lock.同步 do
    @sdam_flow_lock.同步 do
      Raise_sessions_not_supported 除非 拓扑结构.logic_session_timeout
    end
  end
end