类：Mongo::Cluster

继承：
对象
  • 对象
显示全部
扩展方式：
可转发
包括：
Mongo::ClusterTime::Consumer 、 Event::Subscriber 、 Loggable 、 Monitoring::Publishable
定义于：
build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb ,
build/Ruby-driver-v 2.19 /lib/mongo/cluster/topology.rb,
build/Ruby-driver-v 2.19 /lib/mongo/cluster/topology.rb,
build/Ruby-driver-v 2.19 /lib/mongo/cluster/sdam_flow.rb,
build/Ruby-driver-v 2 。 19 /lib/mongo/cluster/topology/base.rb,
build/Ruby-driver-v 2 . 19 /lib/mongo/cluster/topology/single.rb,
build/Ruby-driver-v 2 . 19 /lib/mongo/cluster/topology/sharded.rb,
build/Ruby-driver-v 2 . 19 /lib/mongo/cluster/topology/unknown.rb,
build/Ruby-driver-v 2 . 19 /lib/mongo/cluster/ periodic_executor.rb,
build/Ruby-driver-v 2 . 19 /lib/mongo/cluster/reapers/cursor_reaper.rb,
build/Ruby-driver-v 2 。 19 /lib/mongo/cluster/reapers/socket_reaper.rb,
build/Ruby-driver-v 2 。 19 /lib/mongo/cluster/topology/load_balanced.rb,
build/Ruby-driver-v 2 。 19 /lib/mongo/cluster/topology/no_replica_set_options.rb,
build/Ruby-driver-v 2 。 19 /lib/mongo/cluster/topology/replica_set_no_primary.rb,
build/Ruby-driver-v 2 。 19 /lib/mongo/cluster/topology/replica_set_with_primary.rb

Overview

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_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 – 布尔值

由于：

  • 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
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 120

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

  选项 = 选项.dup
  if 选项[:monitoring_io] == false && !选项.键？(:cleanup)
    选项[:cleanup] = false
  end
  @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
  会话::SessionPool.创建(self)

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

  # 在没有服务器的情况下，开放拓扑始终未知。
  # 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

  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

  除非 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秒进行扫描。
      if 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
        if 服务器.全部？ { |server| server.last_scan_monotime && server.last_scan_monotime >= start_monotime }
          中断
        end
        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
end

实例属性详细信息

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

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

返回：

由于：

  • 2.4.0



317
318
319
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 317

def app_metadata
  @app_metadata
end

#monitor_app_metadata ⇒对象（只读）

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

由于：

  • 2.0.0



320
321
322
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 320

def Monitor_app_metadata
  @monitor_app_metadata
end

# Monitoring ⇒监控（只读）

返回监控 监控。

返回：

  • (监控) —

    监控 监控。

由于：

  • 2.0.0



308
309
310
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 308

def 监控
  @monitoring
end

# options ⇒哈希（只读）

返回选项哈希值。

返回：

  • (哈希) —

    选项哈希。

由于：

  • 2.0.0



305
306
307
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 305

def 选项
  @options
end

# push_monitor_app_metadata ⇒对象（只读）

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

由于：

  • 2.0.0



323
324
325
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 323

def push_monitor_app_metadata
  @push_monitor_app_metadata
end

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

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

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

返回：

  • ( Array<String> ) —

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

由于：

  • 2.7.0



331
332
333
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 331

def 种子
  @seeds
end

# server_selection_semaphore ⇒对象（只读）

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

由于：

  • 2.0.0



488
489
490
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 488

def server_selection_semaphore
  @server_selection_semaphore
end

# session_pool ⇒对象（只读）

由于：

  • 2.5.1



336
337
338
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 336

def session_pool
  @session_pool
end

# srv_monitor ⇒对象（只读）

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

由于：

  • 2.0.0



358
359
360
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 358

def srv_monitor
  @srv_monitor
end

# topology =" Integer ? （只读）

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

例子：

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

cluster.logical_session_timeout

返回：

  • ( Integer , nil ) —

    逻辑会话超时。

由于：

  • 2.5.0



311
312
313
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 311

def 拓扑结构
  @topology
end

类方法详细信息

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

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

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

例子：

为客户端创建集群。

Cluster.create(client)

参数：

  • 客户端 (客户端) —

    要在其上创建的客户端。

  • 监控。 (监控| nil ) —

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

返回：

由于：

  • 2.0.0



295
296
297
298
299
300
301
302
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 295

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



738
739
740
741
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 738

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



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
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 836

def 添加(主机, add_options=nil)
  地址 = 地址.new(主机, 选项)
  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
    if add_options.nil? || add_options[:monitor] != false
      server.start_monitoring
    end
    server
  end
end

#addresses ⇒ Array< Mongo::Address >

集群中的地址。

例子：

获取集群中的地址。

cluster.addresses

返回：

由于：

  • 2.0.6



451
452
453
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 451

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

# close ⇒ nil

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

注意：

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

关闭集群。

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

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

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

返回：

  • ( 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
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 506

def 关闭
  @state_change_lock.同步 do
    除非 正在连接？ || 已连接？
      return nil
    end
    if 选项[:cleanup] != false
      session_pool.end_sessions
      @periodic_executor.停止！
    end
    @srv_monitor_lock.同步 do
      if @srv_monitor
        @srv_monitor.停止！
      end
    end
    @servers.每 do |server|
      if server.已连接？
        server.关闭
        publish_sdam_event(
          监控::SERVER_CLOSED,
          监控::事件::ServerClosed.new(server.地址, 拓扑结构)
        )
      end
    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



424
425
426
427
428
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 424

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

#正在连接？ ⇒ true|false

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

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

返回：

  • ( true|false ) —

    集群是否正在连接。

由于：

  • 2.0.0



412
413
414
415
416
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 412

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

#disconnect_server_if_connected (server) ⇒对象

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

由于：

  • 2.0.0



944
945
946
947
948
949
950
951
952
953
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 944

def connect_server_if_connected(server)
  if server.已连接？
    server.clear_description
    server.断开连接！
    publish_sdam_event(
      监控::SERVER_CLOSED,
      监控::事件::ServerClosed.new(server.地址, 拓扑结构)
    )
  end
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



755
756
757
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 755

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



767
768
769
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 767

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

# heartbeat_interval ⇒ Float

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

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

返回：

  • (浮点) —

    心跳间隔，以秒为单位。

由于：

  • 2.10.0



403
404
405
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 403

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

#检查⇒ string

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

例子：

检查集群。

cluster.inspect

返回：

  • ( string ) —

    集群检查。

由于：

  • 2.0.0



473
474
475
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 473

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

# load_balanced? ⇒ true | false

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

返回：

  • ( true | false ) —

    拓扑结构是否负载均衡。

由于：

  • 2.0.0



345
346
347
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 345

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

# max_read_retries ⇒整数

已弃用。
注意：

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

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

例子：

获取最大读取重试次数。

cluster.max_read_retries

返回：

  • ( Integer ) —

    最大重试次数。

由于：

  • 2.1.1



374
375
376
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 374

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

# next_primary (ping = nil, session = nil) ⇒ Mongo::Server

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

例子：

获取下一个主服务器。

cluster.next_primary

参数：

  • ping ( true , false ) （默认为： nil ） —

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

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

    考虑 mongos 固定的可选会话。

返回：

由于：

  • 2.0.0



784
785
786
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 784

def next_primary(ping = nil, 会话 = nil)
  ServerSelector.主节点.select_server(self, nil, 会话)
end

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

已弃用。

获取服务器的连接池。

例子：

获取连接池。

cluster.pool(server)

参数：

返回：

由于：

  • 2.2.0



799
800
801
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 799

def 池(server)
  server.池
end

# read_retry_interval ⇒浮点

已弃用。
注意：

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

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

例子：

获取读取重试间隔。

cluster.read_retry_interval

返回：

  • (浮点) —

    间隔。

由于：

  • 2.1.1



392
393
394
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 392

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

#重新连接！ ⇒ true

已弃用。

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

重新连接所有服务器。

例子：

重新连接集群的服务器。

cluster.reconnect!

返回：

  • ( true ) —

    始终为 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
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 550

def 重新连接！
  @state_change_lock.同步 do
    @update_lock.同步 do
      @connecting = true
    end
    scan!
    服务器.每 do |server|
      server.重新连接！
    end
    @periodic_executor.重新启动！
    @srv_monitor_lock.同步 do
      if @srv_monitor
        @srv_monitor.运行！
      end
    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



885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 885

def 删除(主机, 断开连接： true)
  地址 = 地址.new(主机)
  remove_servers = []
  @update_lock.同步 do
    @servers.delete_if do |server|
      (server.地址 == 地址).点击 do |删除|
        if 删除
          remove_servers << server
        end
      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



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
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 636

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

    除非 选项[:keep_connection_pool]
      if flow.completed_unknown?
        server_list.每 do |server|
          if 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
      end
    end

    start_stop_srv_monitor
  end

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

# scan! (sync = true) ⇒ true

注意：

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

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

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

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

例子：

强制执行全集群扫描。

cluster.scan!

返回：

  • ( true ) —

    始终为 true。

由于：

  • 2.0.0



595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 595

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



439
440
441
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 439

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

#servers_list ⇒对象

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

由于：

  • 2.0.0



937
938
939
940
941
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 937

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



707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 707

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

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

#摘要⇒对象

注意：

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

由于：

  • 2.7.0



481
482
483
484
485
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 481

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

# update_cluster_time (result) ⇒对象

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

例子：

更新集群时间。

cluster.update_cluster_time(result)

参数：

返回：

  • ( Object ) —

    集群时间。

由于：

  • 2.5.0



813
814
815
816
817
818
819
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 813

def update_cluster_time(结果)
  if cluster_time_doc = 结果.cluster_time
    @cluster_time_lock.同步 do
      advance_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
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 910

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! ⇒对象

此方法是私有 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
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/cluster.rb', line 976

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

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

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