Clase: Mongo::Server::ConnectionPool

Hereda:
Objeto
  • Objeto
Mostrar todo
Ampliado por:
Reenviable
Incluye:
Registrable, supervisión::Publicable
Definido en:
lib/mongo/server/connection_pool.rb,
lib/mongo/server/connection_pool/populator.rb,
lib/mongo/server/connection_pool/generation_manager.rb

Overview

Representa un pool de conexiones para conexiones de servidor.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0

Definido bajo Namespace

clase: GenerationManager, Populator

Resumen de constantes colapsar

DEFAULT_MAX_SIZE =

El tamaño máximo por defecto para el pool de conexiones.

Desde:

  • 2.9.0

20
DEFAULT_MIN_SIZE =

El tamaño mínimo por defecto para el pool de conexiones.

Desde:

  • 2.9.0

0
DEFAULT_MAX_CONNECTING =

El número máximo por defecto de conexiones que pueden estar conectadas en cualquier momento.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0

2
DEFAULT_WAIT_TIMEOUT =

El tiempo de espera por defecto, en segundos, para esperar una conexión.

Este tiempo de espera se aplica mientras los procesos en flujo esperan que los procesos en segundo plano establezcan conexiones (y, por lo tanto, deben conectarse, realizar el apretón de manos y autenticar dentro del tiempo asignado).

Actualmente, está configurado para 10 segundos. El tiempo de espera de conexión predeterminado es 10 segundos por sí solo, pero configurar tiempos de espera largos puede poner en problemas a las aplicaciones si sus solicitudes se agotan por el proxy inverso, por lo que cualquier cosa superior a 15 segundos es potencialmente peligrosa.

Desde:

  • 2.9.0

10

Constantes incluidas desde Loggable

Loggable::PREFIX

Resumen de atributos de la instancia colapsar

Atributos incluidos de supervisión::Publishable

#monitoring

Resumen del método de clase colapsar

Resumen del método de instancia colapsar

Métodos incluidos de Monitoring::Publishable

#publish_cmap_event, #publish_event, #publish_sdam_event

Métodos incluidos desde Registrable

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

Detalles del Constructor

#inicializar(servidor, opciones = {}) ⇒ ConnectionPool

Crea el nuevo pool de conexiones.

Nota: Además, las opciones para las conexiones creadas por este pool deben incluirse en las opciones pasadas aquí, y se reenviarán a cualquier conexión creada por la pool.

Parámetros:

  • Server (servidor) —

    El servidor para el que es este pool de conexiones.

  • opciones (encriptada) (por defecto: {}) —

    Las opciones del pool de conexiones.

Opciones Hash (options):

  • max_size (Integer) —

    El tamaño máximo de la piscina. Configurar esta opción en cero crea un pool de conexiones ilimitado.

  • conexiones máximas (Integer) —

    El número máximo de conexiones que pueden conectarse simultáneamente. Por defecto es 2. Esta opción debe incrementarse si hay muchos hilos que comparten el mismo pool de conexiones y la aplicación está experimentando tiempos de espera mientras espera que se establezcan conexiones.

  • :max_pool_size (Integer) —

    Obsoleto. El tamaño máximo del pool. Si también se proporciona max_size, max_size y max_pool_size deben ser idénticos.

  • tamaño_mínimo (Integer) —

    El tamaño mínimo del grupo.

  • min_pool_size (Integer) —

    Obsoleto. El tamaño mínimo del pool. Si también se proporciona min_size, min_size y min_pool_size deben ser idénticos.

  • `:wait_timeout` (Flotante) —

    El tiempo de espera, en segundos, para una conexión libre.

  • Tiempo de espera de la cola (Flotante) —

    Obsoleto. Alias para :wait_timeout. Si se especifican tanto wait_timeout como wait_queue_timeout, sus valores deben ser idénticos.

  • :max_idle_time (Flotante) —

    El tiempo, en segundos, después del cual el pool debería cerrar las conexiones inactivas.

  • :populator_io (verdadero, falso) —

    Solo para uso interno de driver. Establézcalo en falso para evitar que los hilos de llenado sean creados e iniciados en el pool de conexiones del servidor. Está diseñado para ser utilizado en pruebas que también desactivan monitoring_io, a menos que se requiera explícitamente el generador de datos. Si monitoring_io está desactivado, pero populator_io está activado, el populator debe cerrarse manualmente al final de la prueba, ya que un clúster sin supervisión se considera no conectado, y, por lo tanto, no liberará los subprocesos del pool de conexiones de populator al cerrar.

Aumenta:

  • (ArgumentError)

Desde:

  • 2.0.0, API modificado en 2.9.0



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
168
169
170
171
172
173
174
175
176
177
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 100

def inicializar(Server, opciones = {})
  propagar ArgumentError, 'El primer argumento debe ser una instancia de servidor' a menos que Server.is_a?(Server)

  opciones = opciones.dup
  si opciones[tamaño_mínimo] && opciones[min_pool_size] && opciones[tamaño_mínimo] != opciones[min_pool_size]
    propagar ArgumentError,
          "Tamaño mínimo #{options[:min_size]} no es idéntico al tamaño mínimo del pool #{options[:min_pool_size]}"
  end
  si opciones[max_size] && opciones[:max_pool_size] && opciones[max_size] != opciones[:max_pool_size]
    propagar ArgumentError,
          "Tamaño máximo #{options[:max_size]} no es idéntico al tamaño máximo del pool #{options[:max_pool_size]}"
  end
  si opciones[`:wait_timeout`] && opciones[Tiempo de espera de la cola] && opciones[`:wait_timeout`] != opciones[Tiempo de espera de la cola]
    propagar ArgumentError,
          "Tiempo de espera de espera #{opciones[:wait_timeout]} no es idéntico al tiempo de espera de la cola de espera #{opciones[:wait_queue_timeout]}"
  end

  opciones[tamaño_mínimo] ||= opciones[min_pool_size]
  opciones.borrar(min_pool_size)
  opciones[max_size] ||= opciones[:max_pool_size]
  opciones.borrar(:max_pool_size)
  si opciones[tamaño_mínimo] && opciones[max_size] &&
     opciones[max_size] != 0 && opciones[tamaño_mínimo] > opciones[max_size]
    propagar ArgumentError, "No se puede tener un tamaño mínimo #{options[:min_size]} que supere el tamaño máximo #{options[:max_size]}"
  end

  opciones[`:wait_timeout`] ||= opciones[Tiempo de espera de la cola] si opciones[Tiempo de espera de la cola]
  opciones.borrar(Tiempo de espera de la cola)

  @server = Server
  @options = opciones.freeze

  @generation_manager = GenerationManager.Nuevo(servidor: Server)
  @ready = false
  @closed = false

  # Una conexión de propiedad de este grupo debe estar o en el
  # arreglo de conexiones disponibles (que se utiliza como pila)
  # o en el conjunto de conexiones retiradas.
  @available_connections = []
  @checked_out_connections = Configura.Nuevo
  @pending_connections = Configura.Nuevo
  @interrupt_connections = []

  # Mutex utilizado para sincronizar el acceso a @available_connections y
  # @checked_out_connections. El objeto del pool es seguro para hilos, por lo tanto
  # todos los métodos que recuperan o modifican variables de instancia por lo general
  # debe hacerlo bajo este bloqueo.
  @lock = Mutex (exclusión mutua).Nuevo

  # Subproceso en segundo plano responsable de mantener el tamaño de
  # el pool a al menos min_size
  @populator = Populator.Nuevo(sí mismo, opciones)
  @populate_semaphore = Semáforo.Nuevo

  # Variable de condición para aplicar la primera comprobación en el check_out: max_pool_size.
  # Esta variable de condición debe señalarse cuando el número de
  # las conexiones no disponibles disminuyen (pendientes + conexiones_pendientes +
  # checked_out_connections).
  @size_cv = mongo::ConditionVariable.Nuevo(@lock)
  # Esto representa el número de hilos que han pasado más allá del size_cv
  # puerta, pero no he adquirido una conexión para agregarla a las pending_connections
  # conjunto.
  @connection_requests = 0

  # Variable de condición para aplicar la segunda comprobación en check_out: max_connecting.
  # Esta variable de condición debe ser señalada cuando el número de pendientes
  # conexiones disminuye.
  @max_connecting_cv = mongo::ConditionVariable.Nuevo(@lock)
  @max_connecting = opciones.obtener(conexiones máximas, DEFAULT_MAX_CONNECTING)

  ObjectSpace.define_finalizer(sí mismo,
                               sí mismo.clase.finaliza(@available_connections, @pending_connections, @populator))

  publish_cmap_event(
    Monitoring::Evento::Cmap::PoolCreated.Nuevo(@server.dirección, opciones, sí mismo)
  )
end

Detalles de atributo de instancias

#generation_manager ⇒ Integer (solo lectura)

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Devuelve la generación Generación de conexiones que actualmente está usando la cola.

Devuelve:

  • (Número entero) —

    generación Generación de conexiones que actualmente está utilizando la cola.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



233
234
235
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 233

def generation_manager
  @generation_manager
end

#max_connecting ⇒ Object (solo lectura)

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



342
343
344
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 342

def max_connecting
  @max_connecting
end

#opciones ⇒ Hash (solo lectura)

Devuelve opciones Las opciones del pool.

Devuelve:

  • (encriptada) —

    opciones Las opciones del pool.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



180
181
182
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 180

def opciones
  @options
end

#populate_semaphore ⇒ Object (solo lectura)

Variable de condición broadcast cuando cambia el tamaño de la piscina para despertar al pobledor.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



57
58
59
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 57

def populate_semaphore
  @populate_semaphore
end

#poblador ⇒ Objeto (solo lectura)

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



339
340
341
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 339

def poblador
  @populator
end

#servidor ⇒ objeto (solo lectura)

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



183
184
185
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 183

def Server
  @server
end

Detalles del método de clase

.finalize(available_connections, pending_connections, _populator) ⇒ Proc

Finalice el pool de conexiones para la recolección de basura.

Parámetros:

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

    Las conexiones disponibles.

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

    Las conexiones pendientes.

  • poblador (Populator) —

    El populador.

Devuelve:

  • (Proc) —

    El Finalizador.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 847

def sí mismo.finaliza(available_connections, pending_connections, _populator)
  proc hacer
    available_connections.cada hacer |Conexión|
      Conexión.¡desconectar!(Motivo: La piscina está cerrada)
    end
    available_connections.borrar

    pending_connections.cada hacer |Conexión|
      Conexión.¡desconectar!(Motivo: La piscina está cerrada)
    end
    pending_connections.borrar

    # Finalizer no cierra las conexiones extraídas.
    # Esos tendrían que ser recolectados como basura por sí mismos
    # y eso debería cerrarlas.
  end
end

Detalles del método de instancia

#cantidad disponible ⇒ Entero

Número de conexiones disponibles en el grupo.

Devuelve:

  • (Número entero) —

    Número de conexiones disponibles.

Desde:

  • 2.9.0



291
292
293
294
295
296
297
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 291

def available_count
  raise_if_closed!

  @lock.sincronizar hacer
    @available_connections.longitud
  end
end

#check_in(connection) ⇒ Objeto

Verifique una conexión de regreso a la piscina.

La conexión debe haber sido creada previamente por este pool.

Parámetros:

Desde:

  • 2.9.0



418
419
420
421
422
423
424
425
426
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 418

def registrar(Conexión)
  check_invariants

  @lock.sincronizar hacer
    do_check_in(Conexión)
  end
asegurar
  check_invariants
end

#check_out(connection_global_id: nil, context: nil) ⇒ Mongo::Servidor::Connection

Verifica una conexión fuera del grupo.

Si hay conexiones activas en el pool, se devuelve la conexión utilizada más recientemente. De lo contrario, si el tamaño del pool de conexiones es menor que el tamaño máximo, crea una nueva conexión y la devuelve. Si no, espera hasta el timeout de espera y lanza Timeout::Error si aún no hay conexiones activas y el pool está al tamaño máximo.

La conexión devuelta cuenta para el tamaño máximo del grupo. Cuando el llamante haya terminado de utilizar la conexión, deberá devolverse mediante el método check_in.

Parámetros:

  • connection_global_id (Integer | nil) —

    El id global para la conexión que se debe revisar.

  • :context (Mongo::operación:Context | nil) —

    El contexto de la operación para la que se solicita la conexión, si existe alguno.

Devuelve:

Aumenta:

  • (Error::PoolClosedError) —

    Si la piscina ha sido cerrada.

  • (Timeout::Error) —

    Si el pool de conexiones está al tamaño máximo y permanece así durante más tiempo que el tiempo de espera.

Desde:

  • 2.9.0



366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 366

def check_out(connection_global_id: nulo, context: nulo)
  check_invariants

  publish_cmap_event(
    Monitoring::Evento::Cmap::ConnectionCheckOutStarted.Nuevo(@server.dirección)
  )

  raise_if_pool_closed!
  raise_if_pool_paused_locked!

  Conexión = retrieve_and_connect_connection(
    connection_global_id, context
  )

  publish_cmap_event(
    Monitoring::Evento::Cmap::ConnectionCheckedOut.Nuevo(@server.dirección, Conexión.ID, sí mismo)
  )

  si Lint.¿habilitado? && !Conexión.¿conectado?
    propagar Error::LintError,
          "El pool de conexiones de #{address} revisó una conexión desconectada #{connection.generation}:#{connection.id}"
  end

  Conexión
asegurar
  check_invariants
end

#checkout_pinned_connection(connection_global_id) ⇒ Conexión | nil

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Devuelve una conexión fijada que ya está registrada, si existe una con el ID global dado. Devuelve nil en caso contrario.

Parámetros:

  • connection_global_id (Número entero) —

    El id global de la conexión anclada.

Devuelve:

  • (Conexión | nil) —

    La conexión fija, o nula.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



403
404
405
406
407
408
409
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 403

def echa un vistazo a la conexión fijada(connection_global_id)
  @lock.sincronizar hacer
    @checked_out_connections.detectar hacer |conn|
      conn.global_id == connection_global_id && conn.¿fijado?
    end
  end
end

#clear(options = nil) ⇒ true

Cierra todas las conexiones inactivas en el grupo y programa que las conexiones actualmente retiradas se cierren cuando se vuelvan a registrar en el grupo. El pool está pausado, no creará nuevas conexiones en segundo plano y fallará las solicitudes de checkout hasta que se marque como listo.

Parámetros:

  • opciones (encriptada) (valor por defecto: nil) —

    un conjunto personalizable de opciones

Opciones Hash (options):

  • :lazy (true | false) —

    Si es verdadero, no cierre ninguna de las conexiones inactivas y, en su lugar, permita que se cierren durante una operación de salida posterior. Por defecto es falso.

  • :interrupt_in_use_connections (true | false) —

    Si es verdadero, cierra todas las conexiones marcadas como activas inmediatamente. Si es falso, no cierra ninguna de las conexiones marcadas como activas. Por defecto, es verdadero.

  • :service_id (objeto) —

    Borre las conexiones sólo con el ID de servicio especificado.

Devuelve:

  • (cierto) —

    verdadero.

Desde:

  • 2.1.0



538
539
540
541
542
543
544
545
546
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 538

def borrar(opciones = nulo)
  raise_if_closed!

  si Lint.¿habilitado? && !@server.¿desconocido?
    propagar Error::LintError, "Intentando limpiar el pool para el servidor #{@server.summary} el cual es conocido"
  end

  do_clear(opciones)
end

#close(options = nil) ⇒ true

Marca el pool como cerrado, cierra todas las conexiones inactivas del pool y programa que las conexiones actualmente retiradas sean cerradas cuando se devuelvan al pool. Si la opción force está activada, las conexiones verificadas también se cerrarán. Los intentos de usar el pool después de que esté cerrado generarán Error::PoolClosedError.

Parámetros:

  • opciones (encriptada) (valor por defecto: nil) —

    un conjunto personalizable de opciones

Opciones Hash (options):

  • forzar (true | false) —

    Cierra también todas las conexiones sacadas.

  • esté_listo (true | false) —

    Solo para uso interno del driver. Si marcar la pool como cerrada o no.

Devuelve:

  • (cierto) —

    Siempre verdadero.

Desde:

  • 2.9.0



660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 660

def Cerrar(opciones = nulo)
  return si ¿Cerrado?

  opciones ||= {}

  stop_populator

  @lock.sincronizar hacer
    hasta @available_connections.¿vacío?
      Conexión = @available_connections.pop
      Conexión.¡desconectar!(Motivo: La piscina está cerrada)
    end

    si opciones[forzar]
      hasta @checked_out_connections.¿vacío?
        Conexión = @checked_out_connections.tomar(1).primero
        Conexión.¡desconectar!(Motivo: La piscina está cerrada)
        @checked_out_connections.borrar(Conexión)
      end
    end

    a menos que opciones && opciones[esté_listo]
      # marque el pool como cerrado antes de liberar el bloqueo para que
      # no se pueden crear, registrar ni usar conexiones
      @closed = true
      @ready = false
    end

    @max_connecting_cv.transmisión
    @size_cv.transmisión
    @generation_manager.close_all_pipes
  end

  publish_cmap_event(
    Monitoring::Evento::Cmap::PoolClosed.Nuevo(@server.dirección, sí mismo)
  )

  true
end

#close_idle_sockets ⇒ objeto

Cerrar sockets que hayan estado abiertos durante más tiempo que el máximo tiempo inactivo, si la opción está establecida.

Desde:

  • 2.5.0



770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 770

def close_idle_sockets
  return si ¿Cerrado?
  return a menos que tiempo_máximo_inactivo

  @lock.sincronizar hacer
    i = 0
    mientras i < @available_connections.longitud
      Conexión = @available_connections[i]
      si (last_checkin = Conexión.last_checkin) && ((Tiempo.ahora - last_checkin) > tiempo_máximo_inactivo)
        Conexión.¡desconectar!(Motivo: :inactivo)
        @available_connections.delete_at(i)
        @populate_semaphore.señal
        Next
      end
      i += 1
    end
  end
end

#cerrado? ⇒ verdadero | falso

Si la piscina ha sido cerrada.

Devuelve:

  • (true | false) —

    Si la piscina está cerrada.

Desde:

  • 2.9.0



304
305
306
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 304

def ¿Cerrado?
  !!@closed
end

#¡desconectar!(opciones = nil) ⇒ Objeto

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Desconecta el pool.

Hace todo lo que hace clear, excepto que si el pool está cerrado este método no hace nada pero clear causaría que se eleve PoolClosedError.

Desde:

  • 2.1.0



555
556
557
558
559
560
561
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 555

def ¡desconectar!(opciones = nulo)
  do_clear(opciones)
rescate Error::PoolClosedError
  # El estado "desconectado" está entre cerrado y en pausa.
  # Cuando intentemos desconectar el pool, permitir que el pool sea
  # ya cerrado.
end

#do_check_in(conexión) ⇒ Object

Ejecuta el check-in después de haber adquirido el bloqueo.

Parámetros:

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 431

def do_check_in(Conexión)
  # Cuando se interrumpe una conexión, se vuelve a revisar en el grupo.
  # y cerrado. La operación que estaba utilizando la conexión antes de que fuera
  # la interrupción intentará devolverlo al pool, y nosotros
  #debe ignorarlo, ya que ya ha sido cerrado y retirado del grupo.
  return si Conexión.¿Cerrado? && Conexión.¿interrumpido?

  a menos que Conexión.connection_pool == sí mismo
    propagar ArgumentError,
          "Intentando registrar una conexión que no fue extraída por este pool (conjunto): #{connection} extraído del pool #{connection.connection_pool} (para #{self})"
  end

  a menos que @checked_out_connections.incluir?(Conexión)
    propagar ArgumentError,
          "Intentando registrar una conexión que actualmente no ha sido extraída por este pool: #{conexión} (para #{self})"
  end

  # Nota: si un controlador de eventos se dispara, el recurso no será señalado.
  # Esto significa que los subprocesos están esperando a que se libere una conexión cuando
  # el grupo está al tamaño máximo es posible que se agote el tiempo de espera.
  # Hilos que comienzan a esperar después de que este método se completa (con
  # la excepción) debería estar bien.

  @checked_out_connections.borrar(Conexión)
  @size_cv.señal

  publish_cmap_event(
    Monitoring::Evento::Cmap::ConnectionCheckedIn.Nuevo(@server.dirección, Conexión.ID, sí mismo)
  )

  si Conexión.¿interrumpido?
    Conexión.¡desconectar!(Motivo: :stale)
    return
  end

  si Conexión.error?
    Conexión.¡desconectar!(Motivo: Error)
    return
  end

  si ¿Cerrado?
    Conexión.¡desconectar!(Motivo: La piscina está cerrada)
    return
  end

  si Conexión.¿Cerrado?
    # La conexión fue cerrada, por ejemplo, porque experimentó
    # un error de red. No es necesario realizar nada más aquí.
    @populate_semaphore.señal
  elsif Conexión.Generación != Generación(service_id: Conexión.service_id) && !Conexión.¿fijado?
    # Si la conexión está marcada como anclada, la utiliza una transacción
    # o una serie de operaciones de cursor en una configuración con balanceo de carga.
    # En este caso, la conexión no debe desconectarse hasta
    # sin fijar.
    Conexión.¡desconectar!(Motivo: :stale)
    @populate_semaphore.señal
  else
    Conexión.registro_chequeo!
    @available_connections << Conexión

    @max_connecting_cv.señal
  end
end

#do_clear(opciones = nulo) ⇒ Objeto

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 563

def do_clear(opciones = nulo)
  check_invariants

  service_id = opciones && opciones[:service_id]

  @lock.sincronizar hacer
    # La generación debe aumentarse antes de emitir el evento de limpieza del grupo.
    @generation_manager.esguince(service_id: service_id)

    close_available_connections(service_id) a menos que opciones && opciones[:lazy]

    si opciones && opciones[:interrupt_in_use_connections]
      programar_para_interrupción(@checked_out_connections, service_id)
      programar_para_interrupción(@pending_connections, service_id)
    end

    si @ready
      publish_cmap_event(
        Monitoring::Evento::Cmap::PoolCleared.Nuevo(
          @server.dirección,
          service_id: service_id,
          interrupt_in_use_connections: opciones&.[](:interrupt_in_use_connections)
        )
      )
      # Solo pausar el pool de conexiones si el servidor fue marcado como desconocido,
      # de lo contrario, permite que el reintento se intente con un grupo disponible.
      do_pause si !@server.load_balancer? && @server.¿desconocido?
    end

    # Emitir aquí para hacer que todos los hilos que esperan en el máximo
    # conectarse para salir del ciclo de espera y error.
    @max_connecting_cv.transmisión
    # Difunde aquí para causar que todos los hilos esperando en el tamaño del pool
    # para salir del bucle de espera y provocar un error.
    @size_cv.transmisión
  end

  # "Programe el hilo en segundo plano" después de borrar. Esto es responsable
  # para limpiar hilos obsoletos e interrumpir las conexiones en uso.
  @populate_semaphore.señal
  true
asegurar
  check_invariants
end

#do_pause ⇒ Objeto

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Marque el pool de conexiones como en pausa sin adquirir el bloqueo.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



511
512
513
514
515
516
517
518
519
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 511

def do_pause
  si Lint.¿habilitado? && !@server.¿desconocido?
    propagar Error::LintError, "Intentando pausar el pool para el servidor #{@server.summary} que se sabe"
  end

  return a menos que @ready

  @ready = false
end

#inspect ⇒ String

Obtén una inspección del pool en una string con formato bonito.

Ejemplos:

Inspecciona la piscina.

pool.inspect

Devuelve:

  • (string) —

    La inspección del lote.

Desde:

  • 2.0.0



708
709
710
711
712
713
714
715
716
717
718
719
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 708

def inspeccionar
  si ¿Cerrado?
    "#<Mongo::servidor::ConnectionPool:0x#{object_id} min_size=#{min_size} max_size=#{max_size} " +
      "wait_timeout=#{wait_timeout} cerrado>"
  elsif !¿Listo?
    "#<Mongo::servidor::ConnectionPool:0x#{object_id} min_size=#{min_size} max_size=#{max_size} " +
      "wait_timeout=#{wait_timeout} paused>"
  else
    "#<Mongo::servidor::ConnectionPool:0x#{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

El número máximo de segundos que un socket puede permanecer inactivo desde que ha sido ingresado en el grupo, si se configura.

Devuelve:

  • (Float | nil) —

    El tiempo máximo de inactividad del socket en segundos.

Desde:

  • 2.9.0



228
229
230
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 228

def tiempo_máximo_inactivo
  @max_idle_time ||= opciones[:max_idle_time]
end

#max_size ⇒ Integer

Obtén el tamaño máximo del pool de conexiones.

Devuelve:

  • (Número entero) —

    El tamaño máximo del pool de conexiones.

Desde:

  • 2.9.0



193
194
195
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 193

def max_size
  @max_size ||= opciones[max_size] || [ TAMAÑO_MÁXIMO_PREDERTERMINADO, tamaño_mínimo ].máximo
end

#min_size ⇒ Integer

Obtén el tamaño mínimo del pool de conexiones.

Devuelve:

  • (Número entero) —

    El tamaño mínimo del pool de conexiones.

Desde:

  • 2.9.0



202
203
204
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 202

def tamaño_mínimo
  @min_size ||= opciones[tamaño_mínimo] || DEFAULT_MIN_SIZE
end

#pausa ⇒ Objeto

Marcar el pool de conexiones como pausado.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



496
497
498
499
500
501
502
503
504
505
506
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 496

def pausa
  raise_if_closed!

  check_invariants

  @lock.sincronizar hacer
    do_pause
  end
asegurar
  check_invariants
end

#¿en pausa? ⇒ verdadero | falso

Un pool de conexiones está en pausa si no está cerrado y no está listo.

Devuelve:

  • (true | false) —

    si el pool de conexiones está pausado.

Aumenta:

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



246
247
248
249
250
251
252
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 246

def ¿pausado?
  raise_if_closed!

  @lock.sincronizar hacer
    !@ready
  end
end

#populate ⇒ true | false

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Este método realiza tres cosas:

  1. Crea y añade una conexión al grupo, si el tamaño del grupo está por debajo de min_size. Intenta de nuevo una vez si se encuentra un error relacionado con el socket durante este proceso y genera una excepción si ocurre un segundo error o si el error no está relacionado con el socket.
  2. Remueve las conexiones obsoletas del pool de conexiones.
  3. Interrumpe conexiones marcadas para interrupción.

Usado por el hilo en segundo plano del populador de pools.

ocurrió, o el error no relacionado con el socket

Devuelve:

  • (true | false) —

    Si se debe volver a llamar a este método para crear más conexiones.

Aumenta:

  • (Error::AuthError, Error) —

    El segundo error relacionado con sockets se produce si se vuelve a intentar

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



826
827
828
829
830
831
832
833
834
835
836
837
838
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 826

def poblar
  return false si ¿Cerrado?

  begin
    return create_and_add_connection
  rescate Error::SocketError, Error::SocketTimeoutError => e
    # se encontró un error al conectar la conexión,
    # ignore este primer error e inténtelo de nuevo.
    log_warn("El poblador no pudo conectar una conexión para #{dirección}: #{e.clase}: #{e}. Reintentará nuevamente.")
  end

  create_and_add_connection
end

#listo ⇒ Objeto

Instruye al grupo para crear y devolver conexiones.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 609

def Listo
  raise_if_closed!

  # PENDIENTE: Añadir esto de nuevo en RUBY-3174.
  # si Lint.enabled?
  #   a menos que @server.connected?
  #     raise Error::LintError, "Se intentó preparar un grupo para el servidor #{@server.summary} que está desconectado"
  #   end
  # end

  @lock.sincronizar hacer
    return si @ready

    @ready = true
  end

  # Observa que la especificación CMAP exige la serialización de eventos CMAP para un
  # piscina. Para implementar esto, la publicación del evento debe hacerse en
  # una cola que está sincronizada, en lugar de que se invoque a los suscriptores
  # desde el método activador como este aquí en línea. En MRI, asumiendo
  # los subprocesos ceden a otros cuando dejan de tener trabajo que hacer, es
  # es probable que los eventos en la práctica siempre sean publicados en el
  # orden requerido. JRuby, al ser verdaderamente concurrente con los hilos del sistema operativo,
  # no ofrecería tal garantía.
  publish_cmap_event(
    Monitoring::Evento::Cmap::PoolReady.Nuevo(@server.dirección, opciones, sí mismo)
  )

  return a menos que opciones.obtener(:populator_io, true)

  si @populator.¿corriendo?
    @populate_semaphore.señal
  else
    @populator.ejecutar!
  end
end

#ready? ⇒ true | false

Si el pool está listo.

Devuelve:

  • (true | false) —

    Si el pool está listo.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



311
312
313
314
315
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 311

def ¿Listo?
  @lock.sincronizar hacer
    @ready
  end
end

#size ⇒ Integer

Tamaño del pool de conexiones.

Incluye las conexiones disponibles y las ocupadas.

Devuelve:

  • (Número entero) —

    Tamaño del pool de conexiones.

Desde:

  • 2.9.0



261
262
263
264
265
266
267
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 261

def Tamaño
  raise_if_closed!

  @lock.sincronizar hacer
    unsynchronized_size
  end
end

#detener_poblador ⇒ Objeto

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Detenga el hilo que rellena en segundo plano y limpie cualquier conexión creada que aún no se haya conectado.

Se utiliza al cerrar el pool o al terminar el hilo bg para fines de pruebas. En este último caso, este método debe llamarse antes de usar el pool, para asegurar que no se hayan creado conexiones en pending_connections en flujo por el método check_out.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



798
799
800
801
802
803
804
805
806
807
808
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 798

def stop_populator
  @populator.¡detente!

  @lock.sincronizar hacer
    # Si se llama stop_populator mientras populate está en ejecución, es posible que
    # conexiones esperando para conectarse, conexiones que aún no han
    # se movió a conexiones_disponibles, o conexiones movidas a conexiones_disponibles
    # pero no borrada de pending_connections. Estos deben ser limpiados.
    clear_pending_connections
  end
end

#resumen ⇒ Objeto

Nota:

Este método es experimental y está sujeto a cambios.

Desde:

  • 2.11.0



321
322
323
324
325
326
327
328
329
330
331
332
333
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 321

def Resumen
  @lock.sincronizar hacer
    Estado = si ¿Cerrado?
              'cerrado'
            elsif !@ready
              'pausado'
            else
              'listo'
            end
    "#<ConnectionPool size=#{unsynchronized_size} (#{min_size}-#{max_size}) " +
      "usado=#{@checked_out_connections.length} disponible=#{@available_connections.length} pendiente=#{@pending_connections.length} #{estado}>"
  end
end

#unavailable_connections ⇒ Integer

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Devuelve el número de conexiones no disponibles en el pool. Se utiliza para calcular si hemos alcanzado el max_pool_size.

Devuelve:

  • (Número entero) —

    El número de conexiones no disponibles en el grupo. Se utiliza para calcular si hemos alcanzado max_pool_size.

Desde:

  • 2.0.0, re-escrita en gran medida en 2.9.0



282
283
284
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 282

def conexiones_no_disponibles
  @checked_out_connections.longitud + @pending_connections.longitud + @connection_requests
end

#wait_timeout(context = nil) ⇒ Float

El tiempo de espera, en segundos, para que una conexión esté disponible.

Parámetros:

  • context (Mongo::operación:Context | nil) (valor por defecto: nil) —

    El contexto de la operación para la que se solicita la conexión, si existe alguno.

Devuelve:

  • (Float) —

    El tiempo de espera de la cola.

Desde:

  • 2.9.0



214
215
216
217
218
219
220
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 214

def wait_timeout(context = nulo)
  si context&.remaining_timeout_sec.nil?
    opciones[`:wait_timeout`] || DEFAULT_WAIT_TIMEOUT
  else
    context&.remaining_timeout_sec
  end
end

#with_connection(connection_global_id: nil, context: nil) ⇒ Objeto

Cede el bloque a una conexión, manejando la lógica de check-in/check-out.

Ejemplos:

Ejecute con una conexión.

pool.with_connection do |connection|
  connection.read
end

Devuelve:

  • (objeto) —

    El resultado del bloque.

Desde:

  • 2.0.0



731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 731

def with_connection(connection_global_id: nulo, context: nulo)
  raise_if_closed!

  # Si se solicita una conexión específica y ya está abierta
  # y fijado (por ejemplo, para una transacción o cursor en modo de balanceo de carga),
  # reúsalo directamente sin pasar por el ciclo de check_out/check_in.
  si connection_global_id
    Conexión = @lock.sincronizar hacer
      @checked_out_connections.detectar hacer |conn|
        conn.global_id == connection_global_id && conn.¿fijado?
      end
    end
  end

  Conexión ||= check_out(
    connection_global_id: connection_global_id,
    context: context
  )

  rendimiento(Conexión)
rescate Error::SocketError, Error::SocketTimeoutError, Error::ConnectionPerished => e
  maybe_raise_pool_cleared!(Conexión, e)
asegurar
  si Conexión && !Conexión.¿fijado?
    # No registrarse si la conexión está fijada (la sesión o el cursor
    # lo posee y lo verificará más tarde al desanclarlo). También saltar
    # registro si la conexión ya se registró durante el bloque
    # (por ejemplo, mediante Session#unpin después de un error en la primera operación).
    check out = @lock.sincronizar hacer
      @checked_out_connections.incluir?(Conexión)
    end
    registrar(Conexión) si check out
  end
end