类：Mongo::Server::ConnectionPool

继承：
对象
  • 对象
显示全部
扩展方式：
可转发
包括：
Loggable , Monitoring::Publishable
定义于：
build/Ruby-driver-v 2.19 /lib/mongo/server/connection_pool.rb ,
build/Ruby-driver-v 2.19 /lib/mongo/server/connection_pool/populator.rb,
build/Ruby-driver-v 2.19 /lib/mongo/server/connection_pool/Generation_manager.rb

Overview

表示服务器连接的连接池。

由于：

  • 2.0.0 、 在2.9.0中大部分被重写

在命名空间下定义

类： GenerationManager , Populator

常量摘要折叠

DEFAULT_MAX_SIZE =

连接池的默认最大大小。

由于：

  • 2.9.0

20.冻结
DEFAULT_MIN_SIZE =

连接池的默认最小大小。

由于：

  • 2.9.0

0.冻结
DEFAULT_WAIT_TIMEOUT =

等待连接的默认超时时间（以秒为单位）。

此超时适用于流中线程等待后台线程建立连接（因此它们必须在分配的时间内进行连接、握手和身份验证）的情况。

目前设置为10秒。 默认连接超时为10秒，但设置较大的超时可能会给应用程序带来麻烦，如果反向代理导致应用程序的请求超时，因此超过15秒的任何操作都存在潜在危险。

由于：

  • 2.9.0

10.冻结

Loggable中包含的常量

Loggable::PREFIX

实例属性摘要折叠

包含在Monitoring::Publishable 中的属性

#monitoring

类方法摘要折叠

实例方法摘要折叠

Monitoring::Publishable 中包含的方法

#publish_cmap_event 、 #publish_event 、 #publish_sdam_event

Loggable中包含的方法

#log_debug 、 #log_error 、 #log_ Fatal 、 #log_info 、 #log_warn 、 #logger

构造函数详情

#initialize (服务器, options = {}) ⇒ ConnectionPool

创建新的连接池。

注意：此外，此池创建的连接的选项应

be included in the options passed here, and they will be forwarded to
any connections created by the pool.

参数：

  • server ( MongoDB Server ) —

    此连接池所属的服务器。

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

    连接池选项。

选项哈希 ( options )：

  • :max_size （整数） —

    最大池大小。 将此选项设置为零可创建无限制的连接池。

  • :max_pool_size （整数） —

    已弃用。 最大池大小。 如果同时给出了 max_size，则 max_size 和 max_pool_size 必须相同。

  • :min_size （整数） —

    最小池大小。

  • :min_pool_size （整数） —

    已弃用。 最小池大小。 如果同时给出了 min_size，则 min_size 和 min_pool_size 必须相同。

  • :wait_timeout （浮点） —

    等待空闲连接的时间（以秒为单位）。

  • :wait_queue_timeout （浮点） —

    已弃用。 :wait_timeout 的别名。 如果同时给出了 wait_timeout 和 wait_queue_timeout，则它们的值必须相同。

  • :max_idle_time （浮点） —

    以秒为单位的时间，经过该时间后，池应关闭空闲连接。

  • :populator_io ( true , false ) —

    仅供内部驾驶员使用。 设置为 false 可防止在服务器的连接池创建和启动填充器线程。 它用于同时关闭 Monitoring_io 的测试，除非明确需要填充器。 如果 Monitoring_io 关闭，但 Populator_io 打开，则需要在测试结束时手动关闭 Populator，因为没有监控的集群被视为未连接，因此在关闭时不会清理连接池Populator 线程。

由于：

  • 2.0.0 、 API 在2.9.0中进行了更改



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
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
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第92行

def 初始化(server, 选项 = {})
  除非 server.is_a?(服务器)
    提高 ArgumentError, '第一个参数必须是服务器实例'
  end
  选项 = 选项.dup
  if 选项[:min_size] && 选项[:min_pool_size] && 选项[:min_size] != 选项[:min_pool_size]
    提高 ArgumentError, "最小大小#{ options [ :min_size ] }与最小池大小#{ options [ :min_pool_size ] }不同"
  end
  if 选项[:max_size] && 选项[:max_pool_size] && 选项[:max_size] != 选项[:max_pool_size]
    提高 ArgumentError, " Max size #{ options [ :max_size ] }与 max pool size #{ options [ :max_pool_size ] }不同"
  end
  if 选项[:wait_timeout] && 选项[:wait_queue_timeout] && 选项[:wait_timeout] != 选项[:wait_queue_timeout]
    提高 ArgumentError, "等待超时#{ options [ :wait_timeout ] }与等待队列超时#{ options [ :wait_queue_timeout ] }不同"
  end
  选项[:min_size] ||= 选项[:min_pool_size]
  选项.删除(:min_pool_size)
  选项[:max_size] ||= 选项[:max_pool_size]
  选项.删除(:max_pool_size)
  if 选项[:min_size] && 选项[:max_size] &&
    (选项[:max_size] != 0 && 选项[:min_size] > 选项[:max_size])
  then
    提高 ArgumentError, "最小大小#{ options [ :min_size ] }不能超过最大大小#{ options [ :max_size ] } "
  end
  if 选项[:wait_queue_timeout]
    选项[:wait_timeout] ||= 选项[:wait_queue_timeout]
  end
  选项.删除(:wait_queue_timeout)

  @server = server
  @options = 选项.冻结

  @generation_manager = GenerationManager.new(服务器: server)
  @ready = false
  @close = false

  # 此池拥有的连接应位于
  # available 连接大量（用作堆栈）
  # 或在已签出的连接设立。
  @available_connections = available_connections = []
  @checked_out_connections = 集.new
  @pending_connections = 集.new
  @interrupt_connections = []

  # 用于同步访问 @available_connections 和
  # @checked_out_connections. 池对象是线程安全的，因此
  # 通常检索或修改实例变量的所有方法
  # 必须在此锁下执行此操作。
  锁 = 互斥锁.new

  # 后台线程负责维护
  # 池化至少为 min_size
  @populator = 填充器.new(self, 选项)
  @populate_semaphore = 信号量.new

  # 在 check_out: max_pool_size 中实施首次检查的条件变量。
  # 该条件变量应在以下情况下发出信号：
  # 不可用连接数减少 (pending + pending_connections +
  # available_connections）。
  @size_cv = mongo::ConditionVariable.new(锁)
  # 这表示已超过 size_cv 的线程数
  # Gate，但尚未获取可添加到待连接的连接
  # 设立.
  @connection_requests = 0

  # 在 check_out: max_connecting 中执行第二次检查的条件变量。
  # 当待处理的数量达到
  # 个连接减少。
  @max_connecting_cv = mongo::ConditionVariable.new(锁)
  @max_connecting = 选项.获取(:max_connecting, 2)

  ObjectSpace.define_finalizer(self, self.class.finalize(@available_connections, @pending_connections, @populator))

  publish_cmap_event(
    监控::事件::Cmap::PoolCreated.new(@server.地址, 选项, self)
  )
end

实例属性详细信息

#Generation_manager ⇒整数（只读）

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

返回生成队列当前使用的连接的生成数。

返回：

  • ( Integer ) —

    队列当前使用的连接的生成。

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



216
217
218
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第216行

def Generation_manager
  @generation_manager
end

# max_connecting ⇒对象（只读）

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

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



325
326
327
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第325行

def max_connecting
  @max_connecting
end

# options ⇒哈希（只读）

返回 options 池选项。

返回：

  • (哈希) —

    options 池选项。

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



170
171
172
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第170行

def 选项
  @options
end

#populate_semaphore ⇒对象（只读）

条件变量在池大小发生变化时进行广播，以唤醒填充器

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



55
56
57
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第55行

def 填充信号量
  @populate_semaphore
end

#填充器⇒对象（只读）

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

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



322
323
324
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第322行

def 填充器
  @populator
end

# server ⇒对象（只读）

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

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



173
174
175
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第173行

def server
  @server
end

类方法详细信息

。 finalize (available_connections,pending_connections,populator) ⇒ Proc

完成用于垃圾收集的连接池。

参数：

  • available_connections ( List<Mongo::Connection> ) —

    可用连接。

  • 挂起的连接 ( List<Mongo::Connection> ) —

    待处理的连接。

  • 填充器 ( Populator ) —

    填充器。

返回：

  • ( Proc ) —

    终结器。

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第787行

def self.finalize(available_connections, 挂起的连接, 填充器)
  proc do
    available_connections.每 do |连接|
      连接.断开连接！(原因： :pool_close)
    end
    available_connections.清除

    挂起的连接.每 do |连接|
      连接.断开连接！(原因： :pool_close)
    end
    挂起的连接.清除

    # 终结器不会关闭已检出的连接。
    # 这些必须自行进行垃圾收集
    # 这应该会关闭它们。
  end
end

实例方法详细信息

# available_count ⇒整数

池中的可用连接数。

返回：

  • ( Integer ) —

    可用连接数。

由于：

  • 2.9.0



274
275
276
277
278
279
280
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第274行

def available_count
  ise_if_close!

  锁.同步 do
    @available_connections.长度
  end
end

# check_in (connection) ⇒对象

将连接重新签入池中。

该连接必须是该连接池之前创建的。

参数：

由于：

  • 2.9.0



379
380
381
382
383
384
385
386
387
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第379行

def check_in(连接)
  check_invariants

  锁.同步 do
    do_check_in(连接)
  end
确保
  check_invariants
end

# check_out (connection_global_id: nil) ⇒ Mongo::Server::Connection

从池中检查连接。

如果池中有活动连接，则返回最近使用的连接。 否则，如果连接池大小小于最大大小，则创建一个新连接并将其返回。 否则，等待直至等待超时，如果仍然没有活动连接并且连接池达到最大大小，则引发 Timeout::Error。

返回的连接计入池的最大大小。 当调用者使用完连接后，应通过 check_in 方法重新签入连接。

返回：

引发：

  • ( Error::PoolClosedError ) —

    如果池已关闭。

  • (Timeout::Error) —

    如果连接池处于最大大小且保持这种状态的时间超过等待超时时间。

由于：

  • 2.9.0



345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第345行

def check_out(connection_global_id: nil)
  check_invariants

  publish_cmap_event(
    监控::事件::Cmap::connectionCheckOutStarted.new(@server.地址)
  )

  Raise_if_Pool_Closed!
  Raise_if_pool_paused_locked!

  连接 = retrieve_and_connect_connection(connection_global_id)

  publish_cmap_event(
    监控::事件::Cmap::connectionCheckedOut.new(@server.地址, 连接.id, self),
  )

  if Lint.已启用？
    除非 连接.已连接？
      提高 错误::LintError, " #{ 解决} 的 连接池已 签出断开连接 #{ connection.Generation}: #{ IDconnection.} "
    end
  end

  连接
确保
  check_invariants
end

# clear (options = nil) ⇒ true

关闭池中的所有空闲连接，并安排在当前检出的连接重新检入池中时将其关闭。 池已暂停，不会在背景创建新连接，并且在标记为就绪之前，检出请求将失败。

参数：

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

    一组可自定义的选项

选项哈希 ( options )：

  • :lazy ( true | false ) —

    如果为 true，则不要关闭任何空闲连接，而是在后续签出操作期间关闭这些连接。 默认为 false。

  • :interrupt_in_use_connections ( true | false ) —

    如果为 true，则立即关闭所有签出的连接。 如果为 false，请勿关闭任何已检出的连接。 默认为 true。

  • :service_id （对象） —

    仅清除具有指定服务 ID 的连接。

返回：

  • ( true ) —

    true。

由于：

  • 2.1.0



497
498
499
500
501
502
503
504
505
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第497行

def 清除(选项 = nil)
  ise_if_close!

  if Lint.已启用？ && !@server.未知？
    提高 错误::LintError, “ 正在尝试服务器 已知 的服务器 #{ @ 服务器.summary} 的池”
  end

  do_clear(选项)
end

# close (options = nil) ⇒ true

将池标记为已关闭，关闭池中的所有空闲连接，并安排在当前签出的连接重新签入池中时将其关闭。 如果 force 选项为 true，则签出的连接也会关闭。 在池关闭后尝试使用池将引发 Error::PoolClosedError。

参数：

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

    一组可自定义的选项

选项哈希 ( options )：

  • :force ( true | false ) —

    同时关闭所有签出的连接。

  • :stay_ready ( true | false ) —

    仅供内部驱动程序使用。 是否将池标记为已关闭。

返回：

  • ( true ) —

    始终为 true。

由于：

  • 2.9.0



621
622
623
624
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
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第621行

def 关闭(选项 = nil)
  return if 已关闭？

  选项 ||= {}

  stop_populator

  锁.同步 do
    直到 @available_connections.空？
      连接 = @available_connections.Pop
      连接.断开连接！(原因： :pool_close)
    end

    if 选项[:force]
      直到 @checked_out_connections.空？
        连接 = @checked_out_connections.采取(1).first
        连接.断开连接！(原因： :pool_close)
        @checked_out_connections.删除(连接)
      end
    end

    除非 选项 && 选项[:stay_ready]
      # 在释放锁之前将池标记为已关闭，因此
      # 无法创建、签入或签出任何连接
      @close = true
      @ready = false
    end

    @max_connecting_cv.广播
    @size_cv.广播
  end

  publish_cmap_event(
    监控::事件::Cmap::PoolClosed.new(@server.地址, self)
  )

  true
end

# close_idle_sockets ⇒对象

关闭打开时间超过最大空闲时间的套接字，

if the option is set.

由于：

  • 2.5.0



708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第708行

def close_idle_sockets
  return if 已关闭？
  return 除非 max_idle_time

  锁.同步 do
    i = 0
    while i < @available_connections.长度
      连接 = @available_connections[i]
      if last_checkin = 连接.last_checkin
        if (时间.now - last_checkin) > max_idle_time
          连接.断开连接！(原因： :idle)
          @available_connections.delete_at(i)
          @populate_semaphore.信号
          来年
        end
      end
      i += 1
    end
  end
end

#已关闭？ ⇒ true | false

池是否已关闭。

返回：

  • ( true | false ) —

    池是否已关闭。

由于：

  • 2.9.0



287
288
289
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第287行

def 已关闭？
  !!@close
end

#断开连接！ (options = nil) ⇒对象

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

断开与池的连接。

执行clear执行的所有操作，但如果池已关闭，则此方法不执行任何操作，但clear会引发 PoolClosedError。

由于：

  • 2.1.0



514
515
516
517
518
519
520
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第514行

def 断开连接！(选项 = nil)
  do_clear(选项)
救援 错误::PoolClosedError
  # “断开连接”状态介于关闭和暂停之间。
  # 当我们尝试断开与池的连接时，允许池
  # 已经关闭。
end

# do_check_in (connection) ⇒对象

在获取锁后执行签入。

参数：

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第392行

def do_check_in(连接)
  # 当连接中断时，会重新签入连接池
  # 并关闭。 在该连接被删除之前正在使用该连接的操作
  # 中断将尝试将其重新签入池中，并且我们
  # 应忽略它，因为它已被关闭并从池中删除。
  return if 连接.已关闭？ && 连接.中断？

  除非 连接.connection_pool == self
    提高 ArgumentError, "正在尝试签入未由此池签出的连接： #{ connection }从池中签出#{ connection . connection_pool } (for #{ self } ) "
  end

  除非 @checked_out_connections.包括？(连接)
    提高 ArgumentError, "正在尝试签入此池当前未签出的连接： #{ connection } (for #{ self } ) "
  end

  # 注意：如果引发事件处理程序，则不会向资源发出信号。
  # 这意味着线程等待连接释放
  # 池大小达到最大可能会超时。
  # 在此方法完成后开始等待的线程（使用
  # 异常）应该没问题。

  @checked_out_connections.删除(连接)
  @size_cv.信号

  publish_cmap_event(
    监控::事件::Cmap::connectionCheckedIn.new(@server.地址, 连接.id, self)
  )

  if 连接.中断？
    连接.断开连接！(原因： :stale)
    return
  end

  if 连接.错误？
    连接.断开连接！(原因： :error)
    return
  end

  if 已关闭？
    连接.断开连接！(原因： :pool_close)
    return
  end

  if 连接.已关闭？
    # 连接已关闭 -示例，因为它经历
    # 网络错误。 这里不需要执行任何其他操作。
    @populate_semaphore.信号
  elsif 连接.生成 != 生成(service_id: 连接.service_id) && !连接.已固定？
    # 如果连接被标记为固定，则由ACID 事务使用
    # 或负载均衡设置中的一系列游标操作。
    # 在这种情况下，不应断开连接，直到
    # 取消固定。
    连接.断开连接！(原因： :stale)
    @populate_semaphore.信号
  else
    连接.record_checkin!
    @available_connections << 连接

    @max_connecting_cv.信号
  end
end

# do_clear (options = nil) ⇒对象

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



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
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第522行

def do_clear(选项 = nil)
  check_invariants

  service_id = 选项 && 选项[:service_id]

  锁.同步 do
    # 在发出池清除事件之前，必须先更新生成。
    @generation_manager.碰撞(service_id: service_id)

    除非 选项 && 选项[:lazy]
      close_available_connections(service_id)
    end

    if 选项 && 选项[:interrupt_in_use_connections]
      schedule_for_interruption(@checked_out_connections, service_id)
      schedule_for_interruption(@pending_connections, service_id)
    end

    if @ready
      publish_cmap_event(
        监控::事件::Cmap::PoolCleared.new(
          @server.地址,
          service_id: service_id,
          Interrupt_in_use_connections: 选项&。[ ](:interrupt_in_use_connections)
        )
      )
      # 仅当服务器被标记为未知时才暂停连接池，
      # 否则，允许使用就绪池尝试重试。
      do_pause if !@server.load_balancer？ && @server.未知？
    end

    # 在此处进行广播以使所有线程在 max
    # 连接以跳出等待循环和错误。
    @max_connecting_cv.广播
    # 在此处进行广播以使所有线程等待大小池
    # 跳出等待循环和错误。
    @size_cv.广播
  end

  # 清除后“安排后台线程”。 这是负责
  # 用于清理过时的线程，并中断正在使用的连接。
  @populate_semaphore.信号
  true
确保
  check_invariants
end

# do_pause ⇒对象

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

在不获取锁的情况下将连接池标记为已暂停。

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



470
471
472
473
474
475
476
477
478
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第470行

def do_pause
  if Lint.已启用？ && !@server.未知？
    提高 错误::LintError, " 正在尝试暂停 已知 的服务器 #{ @server .summary } } 的 池 "
  end

  return if !@ready

  @ready = false
end

#检查⇒ string

为池获取打印美观的string检查。

例子：

检查水池。

pool.inspect

返回：

  • ( string ) —

    池检查。

由于：

  • 2.0.0



668
669
670
671
672
673
674
675
676
677
678
679
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第668行

def 检查
  if 已关闭？
    " #<Mongo::Server::ConnectionPool: 0 x #{ object_id } min_size= #{ min_size } max_size= #{ max_size } " +
      " wait_timeout= #{ wait_timeout } completed > "
  elsif !准备好了吗？
    " #<Mongo::Server::ConnectionPool: 0 x #{ object_id } min_size= #{ min_size } max_size= #{ max_size } " +
      " wait_timeout= #{ wait_timeout } Paused> "
  else
    " #<Mongo::Server::ConnectionPool: 0 x #{ object_id } min_size= #{ min_size } max_size= #{ max_size } " +
      " wait_timeout= #{ wait_timeout } current_size= #{ size } available= #{ available_count } > "
  end
end

# max_idle_time ⇒ Float | nil

套接字自签入池以来可以保持空闲状态的最大秒数（如果已设置）。

返回：

  • ( Float | nil ) —

    套接字最大空闲时间（以秒为单位）。

由于：

  • 2.9.0



211
212
213
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第211行

def max_idle_time
  @max_idle_time ||= 选项[:max_idle_time]
end

#max_size ⇒ Integer

获取连接池的最大大小。

返回：

  • ( Integer ) —

    连接池的最大大小。

由于：

  • 2.9.0



183
184
185
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第183行

def max_size
  @max_size ||= 选项[:max_size] || [DEFAULT_MAX_SIZE, min_size].Max
end

#min_size ⇒ Integer

获取连接池的最小大小。

返回：

  • ( Integer ) —

    连接池的最小大小。

由于：

  • 2.9.0



192
193
194
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第192行

def min_size
  @min_size ||= 选项[:min_size] || DEFAULT_MIN_SIZE
end

# pause ⇒对象

将连接池标记为已暂停。

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



455
456
457
458
459
460
461
462
463
464
465
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第455行

def 暂停
  ise_if_close!

  check_invariants

  锁.同步 do
    do_pause
  end
确保
  check_invariants
end

#已暂停？ ⇒ true | false

如果连接池未关闭且未准备就绪，则连接池将暂停。

返回：

  • ( true | false ) —

    连接池是否已暂停。

引发：

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



229
230
231
232
233
234
235
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第229行

def 已暂停？
  ise_if_close!

  锁.同步 do
    !@ready
  end
end

#填充=" true" | false

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

此方法执行三件事：

  1. 如果池的大小低于 min_size，则创建连接并将其添加到池中。 如果在此进程中遇到与套接字相关的错误，则重试一次；如果出现第二个错误或与套接字无关的错误，则引发此错误。

  2. 从连接池中删除过时的连接。

  3. 中断标记为中断的连接。

由池填充器后台线程使用。

发生，或非套接字相关错误

返回：

  • ( true | false ) —

    是否应再次调用此方法以创建更多连接。

引发：

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



766
767
768
769
770
771
772
773
774
775
776
777
778
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第766行

def 填充
  return false if 已关闭？

  开始
    return create_and_add_connection
  救援 错误::SocketError, 错误::SocketTimeoutError => e
    # 连接时遇到错误，
    # 忽略第一个错误，然后重试。
    log_warn(" Populator 无法为#{ 解决 } : #{ e . class } : #{ e }连接。它将重试。 ")
  end

  return create_and_add_connection
end

#准备就绪⇒对象

指示池创建并返回连接。

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



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
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第570行

def 准备就绪
  ise_if_close!

  # TODO：将其重新添加到 RUBY- 3174中。
  # if Lint.enabled?
  #除非@ 服务器.connected?
  #引发错误::LintError，“尝试为服务器#{@ 服务器.summary}准备一个池 已断开连接”
  # end
  # end

  锁.同步 do
    return if @ready

    @ready = true
  end

  # 请注意，CMAP 规范要求对 CMAP 事件进行序列化
  # 池。 为此，必须将事件发布到
  # 一个同步的队列，而不是调用订阅者
  # 来自像这样的trigger方法 inline。 在 MRI 上，假设
  # 当这些线程不再有工作要做时，就会让位于其他线程，即
  # 实际上，事件很可能始终发布在
  # 所需顺序。 JRuby 真正与操作系统线程并发，
  # 不会提供这样的保证。
  publish_cmap_event(
    监控::事件::Cmap::PoolReady.new(@server.地址, 选项, self)
  )

  if 选项.获取(:populator_io, true)
    if @populator.运行?
      @populate_semaphore.信号
    else
      @populator.运行！
    end
  end
end

#准备好了吗？ ⇒ true | false

池是否已准备就绪。

返回：

  • ( true | false ) —

    池是否已准备就绪。

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



294
295
296
297
298
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第294行

def 准备好了吗？
  锁.同步 do
    @ready
  end
end

# size =" Integer "（整数）

连接池的大小。

包括可用连接和已签出连接。

返回：

  • ( Integer ) —

    连接池的大小。

由于：

  • 2.9.0



244
245
246
247
248
249
250
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第244行

def size
  ise_if_close!

  锁.同步 do
    unsynchronized_size
  end
end

# stop_populator ⇒对象

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

停止后台填充器线程并清理已创建但尚未连接的所有连接。

在关闭池或出于测试目的而终止背景线程时使用。 在后一种情况下，必须在使用池之前调用此方法，以确保未决连接中的连接不是由 check_out 方法创建的。

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



738
739
740
741
742
743
744
745
746
747
748
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第738行

def stop_populator
  @populator.停止！

  锁.同步 do
    # 如果在填充运行时调用 stop_populator，则可能会
    # 等待连接的连接数、尚未连接的连接数
    #被移动到available_connections，或连接移动到available_connections
    # 但不会从挂起的连接中删除。 这些应该被清理掉。
    clear_pending_connections
  end
end

#摘要⇒对象

注意：

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

由于：

  • 2.11.0



304
305
306
307
308
309
310
311
312
313
314
315
316
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第304行

def 总结
  锁.同步 do
    州 = if 已关闭？
      '已关闭'
    elsif !@ready
      ' paused '
    else
      ' ready '
    end
    " #<ConnectionPool size= #{ { unsynchronized_size } } ( #{ min_size } - #{ max_size } ) " +
      " used= #{ @checked_out_connections . length } available = #{ @available_connections . length } ending = #{ @pending_connections . length } #{ state } > "
  end
end

# Unavailable_connections =" Integer "（整数）

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

返回 池中不可用连接的数量。 用于计算是否已达到 max_pool_size。

返回：

  • ( Integer ) —

    池中不可用连接的数量。 用于计算是否已达到 max_pool_size。

由于：

  • 2.0.0 、 在2.9.0中大部分被重写



265
266
267
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第265行

def Unavailable_connections
  @checked_out_connections.长度 + @pending_connections.长度 + @connection_requests
end

# wait_timeout ⇒浮点

等待连接变为可用的时间（以秒为单位）。

返回：

  • (浮点) —

    队列等待超时。

由于：

  • 2.9.0



201
202
203
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第201行

def wait_timeout
  @wait_timeout ||= 选项[:wait_timeout] || DEFAULT_WAIT_TIMEOUT
end

# with_connection (connection_global_id: nil) ⇒对象

在处理签入/签出逻辑时，将区块让出给连接。

例子：

使用连接执行。

pool.with_connection do |connection|
  connection.read
end

返回：

  • ( Object ) —

    区块的结果。

由于：

  • 2.0.0



691
692
693
694
695
696
697
698
699
700
701
702
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 服务器/connection_pool.rb', 第691行

def with_connection(connection_global_id: nil)
  ise_if_close!

  连接 = check_out(connection_global_id: connection_global_id)
  产量(连接)
救援 错误::SocketError, 错误::SocketTimeoutError, 错误::ConnectionPershed => e
  也许_引发_池_清除！(连接, e)
确保
  if 连接
    check_in(连接)
  end
end