Clase: Mongo::Server::ConnectionPool

Hereda:
Objeto
  • Objeto
Mostrar todo
Ampliado por:
Reenviable
Incluye:
Registrable, Monitoreo::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 grupo de conexiones para conexiones de servidor.

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0

Definido en el espacio de nombres

Clases: Administrador de generación, Poblador

Colapso delresumen constante

DEFAULT_MAX_SIZE =

El tamaño máximo predeterminado para el grupo de conexiones.

Desde:

  • 2.9.0

20
TAMAÑO MÍNIMO PREDETERMINADO =

El tamaño mínimo predeterminado para el grupo de conexiones.

Desde:

  • 2.9.0

0
CONEXIÓN MÁXIMA PREDETERMINADA =

El número máximo predeterminado de conexiones que pueden conectarse en un momento dado.

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0

2
TIEMPO DE ESPERA PREDETERMINADO =

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

Este tiempo de espera se aplica mientras los subprocesos en flujo están esperando que los subprocesos en segundo plano establezcan conexiones (y, por lo tanto, deben conectarse, realizar el protocolo de enlace y autenticarse en el tiempo asignado).

Actualmente está configurado en 10 segundos. El tiempo de espera de conexión predeterminado es de 10 segundos, pero establecer tiempos de espera largos puede causar problemas a las aplicaciones si el proxy inverso agota el tiempo de espera de sus solicitudes. Por lo tanto, cualquier tiempo superior a 15 segundos es potencialmente peligroso.

Desde:

  • 2.9.0

10.freeze

Constantes incluidas desde Loggable

Registrable::PREFIX

Colapso delresumen de atributos de instancia

Atributos incluidos de Monitoring::Publishable

#monitoring

Colapso delresumen del método de clase

Colapso del resumen del método de instancia

Métodos incluidos en Monitoring::Publishable

#publicar_evento_cmap, #publicar_evento, #publicar_evento_sdam

Métodos incluidos en Loggable

#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 grupo deben

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

Parámetros:

  • Server (Servidor) —

    El servidor al que va dirigido este grupo de conexiones.

  • opciones (Hash) (predeterminado: {}) —

    Las opciones del pool de conexiones.

Opciones Hash(opciones):

  • :tamaño máximo (Entero) —

    El tamaño máximo del grupo. Si se establece esta opción en cero, se crea un grupo de conexiones ilimitado.

  • :max_conectando (Entero) —

    El número máximo de conexiones que pueden conectarse simultáneamente. El valor predeterminado es 2. Esta opción debe aumentarse si hay muchos subprocesos que comparten el mismo grupo de conexiones y la aplicación experimenta tiempos de espera mientras espera que se establezcan las conexiones.

  • :tamaño máximo de la piscina (Entero) —

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

  • :tamaño mínimo (Entero) —

    El tamaño mínimo de la piscina.

  • :tamaño mínimo de la piscina (Entero) —

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

  • :tiempo de espera (Flotar) —

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

  • :tiempo de espera de la cola de espera (Flotar) —

    Obsoleto. Alias ​​de :wait_timeout. Si se especifican wait_timeout y wait_queue_timeout, sus valores deben ser idénticos.

  • :max_idle_time (Flotar) —

    El tiempo, en segundos, después del cual el grupo debe cerrar las conexiones inactivas.

  • :populator_io (verdadero,falso) —

    Solo para uso interno del controlador. Establézcalo en "false" para evitar que los subprocesos de rellenado se creen e inicien en el pool de conexiones del servidor. Está diseñado para usarse en pruebas que también desactivan monitoring_io, a menos que el rellenador se necesite explícitamente. Si monitoring_io está desactivado, pero populator_io está activado, el rellenador debe cerrarse manualmente al final de la prueba, ya que un clúster sin monitorización se considera no conectado y, por lo tanto, no limpiará los subprocesos de rellenado del pool de conexiones al cerrarlo.

Desde:

  • 2.0.0, API cambiada en 2.9.0



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 102

def inicializar(Server, opciones = {})
  a no ser que Server.is_a?(Servidor)
    propagar ArgumentError, 'El primer argumento debe ser una instancia de servidor'
  end
  opciones = opciones.dup
  Si opciones[:tamaño mínimo] && opciones[:tamaño mínimo de la piscina] && opciones[:tamaño mínimo] != opciones[:tamaño mínimo de la piscina]
    propagar ArgumentError, "Eltamaño mínimo #{options[:min_size ]} no es idéntico al tamaño mínimo del grupo #{options[:min_pool_size ] }"
  end
  Si opciones[:tamaño máximo] && opciones[:tamaño máximo de la piscina] && opciones[:tamaño máximo] != opciones[:tamaño máximo de la piscina]
    propagar ArgumentError, "Eltamaño máximo #{options[:max_size ]} no es idéntico al tamaño máximo del grupo #{options[:max_pool_size ] }"
  end
  Si opciones[:tiempo de espera] && opciones[:tiempo de espera de la cola de espera] && opciones[:tiempo de espera] != opciones[:tiempo de espera de la cola de espera]
    propagar ArgumentError, "Eltiempo de espera #{options[:wait_timeout ]} no es idéntico al tiempo de espera de la cola #{options[:wait_queue_timeout ] }"
  end
  opciones[:tamaño mínimo] ||= opciones[:tamaño mínimo de la piscina]
  opciones.borrar(:tamaño mínimo de la piscina)
  opciones[:tamaño máximo] ||= opciones[:tamaño máximo de la piscina]
  opciones.borrar(:tamaño máximo de la piscina)
  Si opciones[:tamaño mínimo] && opciones[:tamaño máximo] &&
    (opciones[:tamaño máximo] != 0 && opciones[:tamaño mínimo] > opciones[:tamaño máximo])
  entonces
    propagar ArgumentError, "No se puede tener un tamaño mínimo #{options[:min_size ]} que exceda el tamaño máximo #{options[:max_size ]}"
  end
  Si opciones[:tiempo de espera de la cola de espera]
    opciones[:tiempo de espera] ||= opciones[:tiempo de espera de la cola de espera]
  end
  opciones.borrar(:tiempo de espera de la cola de espera)

  @server = Server
  @opciones = opciones.freeze

  @generation_manager = Gerente de Generación.Nuevo(servidor: Server)
  @listo = false
  @cerrado = false

  # Una conexión propiedad de este grupo debe estar en el
  # matriz de conexiones disponibles (que se utiliza como pila)
  # o en el conjunto de conexiones verificadas.
  @conexiones_disponibles = conexiones disponibles = []
  @checked_out_connections = Configura.Nuevo
  @conexiones_pendientes = 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 en general
  # debe hacerlo bajo este bloqueo.
  @cerrar = Mutex.Nuevo

  # Hilo de fondo responsable de mantener el tamaño de
  # el grupo al menos al tamaño mínimo
  @populator = Poblador.Nuevo(yo, 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
  # conexiones no disponibles disminuye (pendiente + conexiones_pendientes +
  #conexiones_desprotegidas).
  @size_cv = Mongo::Variable de condición.Nuevo(@cerrar)
  # Esto representa el número de subprocesos que han superado el size_cv
  # puerta pero no ha adquirido una conexión para agregarla a las conexiones pendientes
  # colocar.
  @solicitudes_de_conexión = 0

  # Variable de condición para forzar el segundo check en check_out: max_connecting.
  # La variable de condición debe señalarse cuando el número de pendientes
  # Las conexiones disminuyen.
  @max_conectando_cv = Mongo::Variable de condición.Nuevo(@cerrar)
  @max_connecting = opciones.Fetch(:max_conectando, DEFAULT_MAX_CONNECTING)

  ObjectSpace.define_finalizador(yo, yo.clase.finaliza(@conexiones_disponibles, @conexiones_pendientes, @populator))

  evento_publicar_cmap(
    Monitoring::Evento::Cmap::PoolCreated.Nuevo(@server.dirección, opciones, yo)
  )
end

Detalles de los atributos de instancia

#generation_manager ⇒ Entero (solo lectura)

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

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

Devuelve:

  • (Entero) —

    generación Generación de conexiones que actualmente están siendo utilizadas por la cola.

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0



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

def gerente de generación
  @generation_manager
end

#max_connecting ⇒ Objeto (solo lectura)

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0



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

def conexión máxima
  @max_connecting
end

#opciones ⇒ Hash (solo lectura)

Opciones de retorno Las opciones del pool.

Devuelve:

  • (Hash) —

    opciones Las opciones de la piscina.

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0



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

def opciones
  @opciones
end

#populate_semaphore ⇒ Objeto (solo lectura)

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

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0



59
60
61
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 59

def semáforo de población
  @populate_semaphore
end

#populator ⇒ Objeto (solo lectura)

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Desde:

  • 2.0.0, en gran parte reescrito 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 forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Desde:

  • 2.0.0, en gran parte reescrito 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

.finalizar(conexiones_disponibles, conexiones_pendientes, rellenador) ⇒ Proc

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

Parámetros:

  • conexiones disponibles (Lista<Mongo::Connection>) —

    Las conexiones disponibles.

  • conexiones pendientes (Lista<Mongo::Connection>) —

    Las conexiones pendientes.

  • poblador (Populador) —

    El populador.

Devuelve:

  • (Procedimiento) —

    El finalizador.

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0



814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 814

def yo.finaliza(conexiones disponibles, conexiones pendientes, poblador)
  proc hacer
    conexiones disponibles.cada hacer |conexión|
      conexión.¡desconectar!(razón: :piscina cerrada)
    end
    conexiones disponibles.borrar

    conexiones pendientes.cada hacer |conexión|
      conexión.¡desconectar!(razón: :piscina cerrada)
    end
    conexiones pendientes.borrar

    # Finalizador no cierra las conexiones extraídas.
    #Esos tendrían que ser recolectados por su propia cuenta.
    # y eso debería cerrarlos.
  end
end

Detalles del método de instancia

#número_disponible ⇒ Entero

Número de conexiones disponibles en el pool.

Devuelve:

  • (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 recuento_disponible
  ¡subir si está cerrado!

  @cerrar.sincronizar hacer
    @conexiones_disponibles.longitud
  end
end

#check_in(conexión) ⇒ Objeto

Verifique la conexión nuevamente a la piscina.

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

Parámetros:

Desde:

  • 2.9.0



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

def registrarse(conexión)
  check_invariants

  @cerrar.sincronizar hacer
    do_check_in(conexión)
  end
asegurar
  check_invariants
end

#check_out(id_global_de_conexión: nulo, contexto: nulo) ⇒ Mongo::Servidor::Conexión

Comprueba una conexión fuera del pool.

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 máximo, se crea una nueva conexión y se devuelve. De lo contrario, se espera hasta el tiempo de espera y se genera un error Timeout::Error si aún no hay conexiones activas y el pool ha alcanzado su tamaño máximo.

La conexión devuelta se contabiliza para el tamaño máximo del pool. Cuando el usuario que llama termina de usar la conexión, esta debe volver a registrarse mediante el método check_in.

Parámetros:

  • :id_global_de_conexión (Integer | nil) —

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

  • :context (Mongo::Operación:Contexto | nulo) —

    Contexto de la operación para la que se solicita la conexión, si la hay.

Devuelve:

Aumentos:

  • (Error::PoolClosedError) —

    Si la piscina ha sido cerrada.

  • (Timeout::Error) —

    Si el grupo de conexiones ha alcanzado su 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
393
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 366

def verificar(id_global_de_conexión: nulo, context: nulo)
  check_invariants

  evento_publicar_cmap(
    Monitoring::Evento::Cmap::Conexión verificada iniciada.Nuevo(@server.dirección)
  )

  ¡Aumentar si el pool está cerrado!
  ¡Subir si el pool está en pausa y bloqueado!

  conexión = recuperar_y_conectar_conexión(
    id_global_de_conexión, context
  )

  evento_publicar_cmap(
    Monitoring::Evento::Cmap::Conexión verificada.Nuevo(@server.dirección, conexión.ID., yo),
  )

  Si Lint.¿activado?
    a no ser que conexión.¿conectado?
      propagar Error::LintError, "Elgrupo de conexiones para #{address} extrajo una conexión desconectada #{connection.generation}: #{connection.id }"
    end
  end

  conexión
asegurar
  check_invariants
end

#clear(opciones = nulo) ⇒ verdadero

Cierra todas las conexiones inactivas del pool y programa las conexiones actualmente extraídas para que se cierren al reingresarlas al pool. El pool está en pausa, no creará nuevas conexiones en segundo plano y rechazará las solicitudes de extracción hasta que se marque como listo.

Parámetros:

  • opciones (Hash) (predeterminado: nulo) —

    un conjunto personalizable de opciones

Opciones Hash(opciones):

  • :lazy (true | false) —

    Si es verdadero, no se cierra ninguna conexión inactiva y, en su lugar, se permite que se cierren durante una operación de verificación posterior. El valor predeterminado es falso.

  • :interrupción_en_uso_de_conexiones (true | false) —

    Si es verdadero, cierra todas las conexiones extraídas inmediatamente. Si es falso, no cierra ninguna. El valor predeterminado es verdadero.

  • :id_de_servicio (Objeto) —

    Borrar conexiones únicamente con el ID de servicio especificado.

Devuelve:

  • (verdadero) -

    verdadero.

Desde:

  • 2.1.0



520
521
522
523
524
525
526
527
528
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 520

def borrar(opciones = nulo)
  ¡subir si está cerrado!

  Si Lint.¿activado? && !@server.¿desconocido?
    propagar Error::LintError, "Intentandoborrar el grupo del servidor #{@server.summary} que seconoce"
  end

  hacer_borrar(opciones)
end

#cerrar(opciones = nulo) ⇒ verdadero

Marca el pool como cerrado, cierra todas las conexiones inactivas y programa el cierre de las conexiones actualmente extraídas al reingresarlas. Si la opción "force" es verdadera, las conexiones extraídas también se cierran. Intentar usar el pool después de su cierre generará el error "Error::PoolClosedError".

Parámetros:

  • opciones (Hash) (predeterminado: nulo) —

    un conjunto personalizable de opciones

Opciones Hash(opciones):

  • :fuerza (true | false) —

    Cierre también todas las conexiones verificadas.

  • :mantente listo (true | false) —

    Solo para uso interno del conductor. Indica si se debe marcar o no el grupo como cerrado.

Devuelve:

  • (verdadero) -

    Siempre verdadero.

Desde:

  • 2.9.0



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
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 644

def cerrar(opciones = nulo)
  return Si ¿cerrado?

  opciones ||= {}

  detener_populador

  @cerrar.sincronizar hacer
    hasta @conexiones_disponibles.¿vacío?
      conexión = @conexiones_disponibles.pop
      conexión.¡desconectar!(razón: :piscina cerrada)
    end

    Si opciones[:fuerza]
      hasta @checked_out_connections.¿vacío?
        conexión = @checked_out_connections.tomar(1).primera
        conexión.¡desconectar!(razón: :piscina cerrada)
        @checked_out_connections.borrar(conexión)
      end
    end

    a no ser que opciones && opciones[:mantente listo]
      # marque el pool como cerrado antes de liberar el bloqueo para que
      # No se pueden crear, registrar ni retirar conexiones
      @cerrado = true
      @listo = false
    end

    @max_conectando_cv.transmitir
    @size_cv.transmitir
    @generation_manager.cerrar_todas_las_tuberías
  end

  evento_publicar_cmap(
    Monitoring::Evento::Cmap::Piscina cerrada.Nuevo(@server.dirección, yo)
  )

  true
end

#cerrar_sockets_idle ⇒ Objeto

Cierre los sockets que hayan estado abiertos durante más tiempo que el tiempo máximo de inactividad.

if the option is set.

Desde:

  • 2.5.0



735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 735

def cerrar_tomas_inactivas
  return Si ¿cerrado?
  return a no ser que tiempo máximo de inactividad

  @cerrar.sincronizar hacer
    i = 0
    mientras i < @conexiones_disponibles.longitud
      conexión = @conexiones_disponibles[i]
      Si last_checkin = conexión.last_checkin
        Si (Tiempo.ahora - last_checkin) > tiempo máximo de inactividad
          conexión.¡desconectar!(razón: :inactivo)
          @conexiones_disponibles.eliminar_en(i)
          @populate_semaphore.señal
          siguiente
        end
      end
      i += 1
    end
  end
end

#cerrado? ⇒ verdadero | falso

Si la piscina ha sido cerrada.

Devuelve:

  • (verdadero | falso) —

    Si la piscina está cerrada.

Desde:

  • 2.9.0



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

def ¿cerrado?
  !!@cerrado
end

#¡desconectar!(opciones = nulo) ⇒ Objeto

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Desconecta la piscina.

Hace todo lo que hace clear, excepto que si el grupo está cerrado, este método no hace nada, pero clear generaría PoolClosedError.

Desde:

  • 2.1.0



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

def ¡desconectar!(opciones = nulo)
  hacer_borrar(opciones)
rescate Error::Error de piscina cerrada
  # El estado "desconectado" está entre cerrado y en pausa.
  # Cuando intentamos desconectar el pool, permitir que el pool esté
  # ya cerrado.
end

#do_check_in(conexión) ⇒ Objeto

Ejecuta el check in luego de haber adquirido ya el bloqueo.

Parámetros:

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0



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
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 415

def do_check_in(conexión)
  # Cuando se interrumpe una conexión, se devuelve al pool.
  # y cerrado. La operación que estaba usando la conexión antes de que se cerrara.
  # interrumpido intentará devolverlo al pool y nosotros
  # debe ignorarlo ya que ya ha sido cerrado y eliminado del grupo.
  return Si conexión.¿cerrado? && conexión.¿interrumpido?

  a no ser que conexión.grupo de conexiones == yo
    propagar ArgumentError, "Intentandoregistrar una conexión que no fue registrada por este grupo: #{connection} registrada desde el grupo #{connection.connection_pool} (para #{self})"
  end

  a no ser que @checked_out_connections.¿incluir?(conexión)
    propagar ArgumentError, "Intentandoregistrar una conexión que actualmente no está registrada en este grupo: #{connection} (para #{self})"
  end

  # Nota: si se activa un controlador de eventos, no se señalizará el recurso.
  # Esto significa que los subprocesos están esperando que se libere una conexión cuando
  # el grupo está en su tamaño máximo, puede que se agote el tiempo.
  # Hilos que comienzan a esperar después de que se complete este método (con
  # la excepción) debería estar bien.

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

  evento_publicar_cmap(
    Monitoring::Evento::Cmap::Conexión registrada.Nuevo(@server.dirección, conexión.ID., yo)
  )

  Si conexión.¿interrumpido?
    conexión.¡desconectar!(razón: :stale)
    return
  end

  Si conexión.error?
    conexión.¡desconectar!(razón: :error)
    return
  end

  Si ¿cerrado?
    conexión.¡desconectar!(razón: :piscina cerrada)
    return
  end

  Si conexión.¿cerrado?
    # La conexión se cerró, por ejemplo, porque experimentó
    # Un error de red. No es necesario hacer nada más.
    @populate_semaphore.señal
  elsif conexión.generación != generación(id_de_servicio: conexión.id_de_servicio) && !conexión.¿fijado?
    # Si la conexión está marcada como anclada, es utilizada por una transacción
    # o una serie de operaciones de cursor en una configuración de carga equilibrada.
    # En este caso la conexión no debe desconectarse hasta
    # desanclado.
    conexión.¡desconectar!(razón: :stale)
    @populate_semaphore.señal
  else
    conexión.¡registro_comprobación!
    @conexiones_disponibles << conexión

    @max_conectando_cv.señal
  end
end

#do_clear(opciones = nil) ⇒ Objeto

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0



545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
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
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 545

def hacer_borrar(opciones = nulo)
  check_invariants

  id_de_servicio = opciones && opciones[:id_de_servicio]

  @cerrar.sincronizar hacer
    # La generación debe aumentarse antes de emitir el evento de limpieza del grupo.
    @generation_manager.rugosidad(id_de_servicio: id_de_servicio)

    a no ser que opciones && opciones[:lazy]
      cerrar_conexiones_disponibles(id_de_servicio)
    end

    Si opciones && opciones[:interrupción_en_uso_de_conexiones]
      horario_para_interrupción(@checked_out_connections, id_de_servicio)
      horario_para_interrupción(@conexiones_pendientes, id_de_servicio)
    end

    Si @listo
      evento_publicar_cmap(
        Monitoring::Evento::Cmap::Piscina despejada.Nuevo(
          @server.dirección,
          id_de_servicio: id_de_servicio,
          conexiones de interrupción en uso: opciones&.[](:interrupción_en_uso_de_conexiones)
        )
      )
      # Solo pause el grupo de conexiones si el servidor fue marcado como desconocido,
      # de lo contrario, permita que el reintento se realice con un grupo listo.
      do_pause Si !@server.¿equilibrador de carga? && @server.¿desconocido?
    end

    # Transmite aquí para hacer que todos los subprocesos esperen al máximo
    # conectando para salir del bucle de espera y del error.
    @max_conectando_cv.transmitir
    # Difunde aquí para causar que todos los hilos esperando en el tamaño del pool
    # para salir del bucle de espera y del error.
    @size_cv.transmitir
  end

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

#do_pause ⇒ Objeto

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Marcar el grupo de conexiones como en pausa sin adquirir el bloqueo.

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0



493
494
495
496
497
498
499
500
501
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 493

def do_pause
  Si Lint.¿activado? && !@server.¿desconocido?
    propagar Error::LintError, "Intentandopausar el grupo para el servidor #{@server.summary} que seconoce"
  end

  return Si !@listo

  @listo = false
end

#inspeccionar ⇒ Cadena

Obtenga una bonita inspección de cuerda impresa para la piscina.

Ejemplos:

Inspeccione la piscina.

pool.inspect

Devuelve:

  • (Cadena) -

    La inspección del lote.

Desde:

  • 2.0.0



692
693
694
695
696
697
698
699
700
701
702
703
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 692

def inspeccionar
  Si ¿cerrado?
    "#<Mongo::Server::ConnectionPool:0x#{object_id} tamaño mínimo=#{tamaño mínimo} tamaño máximo=#{tamaño máximo} " +
      "tiempo_de_espera=#{tiempo_de_espera} cerrado>"
  elsif !¿listo?
    "#<Mongo::Server::ConnectionPool:0x#{object_id} tamaño mínimo=#{tamaño mínimo} tamaño máximo=#{tamaño máximo} " +
      "tiempo_de_espera=#{tiempo_de_espera} pausado>"
  else
    "#<Mongo::Server::ConnectionPool:0x#{object_id} tamaño mínimo=#{tamaño mínimo} tamaño máximo=#{tamaño máximo} " +
      "tiempo_de_espera=#{tiempo_de_espera} tamaño_actual=#{tamaño} disponible=#{número_disponible}>"
  end
end

#max_idle_time ⇒ Float | nil

El máximo de segundos que un socket puede permanecer inactivo desde que se registró en el grupo, si está configurado.

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 de inactividad
  @max_idle_time ||= opciones[:max_idle_time]
end

#max_size ⇒ Integer

Obtenga el tamaño máximo del grupo de conexiones.

Devuelve:

  • (Entero) —

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

Desde:

  • 2.9.0



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

def tamaño máximo
  @max_size ||= opciones[:tamaño máximo] || [TAMAÑO MÁXIMO PREDETERMINADO, tamaño mínimo].máximo
end

#min_size ⇒ Integer

Obtenga el tamaño mínimo del grupo de conexiones.

Devuelve:

  • (Entero) —

    El tamaño mínimo del grupo 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] || TAMAÑO MÍNIMO PREDETERMINADO
end

#pausa ⇒ Objeto

Marcar el grupo de conexiones como en pausa.

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0



478
479
480
481
482
483
484
485
486
487
488
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 478

def pausa
  ¡subir si está cerrado!

  check_invariants

  @cerrar.sincronizar hacer
    do_pause
  end
asegurar
  check_invariants
end

# ¿enpausa? ⇒ verdadero | falso

Un grupo de conexiones se pausa si no está cerrado y no está listo.

Devuelve:

  • (verdadero | falso) —

    si el grupo de conexiones está en pausa.

Aumentos:

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0



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

def ¿en pausa?
  ¡subir si está cerrado!

  @cerrar.sincronizar hacer
    !@listo
  end
end

#rellenar ⇒ verdadero | falso

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Este método hace tres cosas:

  1. Crea y agrega una conexión al pool, si el tamaño del pool está por debajo de min_size. Vuelve a intentarlo una vez si se encuentra un error relacionado con el socket durante este proceso, y se produce un error si ocurre un segundo o un error no relacionado con el socket.

  2. Elimina las conexiones obsoletas del grupo de conexiones.

  3. Interrumpe las conexiones marcadas para interrupción.

Utilizado por el hilo de fondo del rellenador del grupo.

ocurrió, o el error no relacionado con sockets

Devuelve:

  • (verdadero | falso) —

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

Aumentos:

  • (Error::AuthError, Error) —

    El segundo error relacionado con el socket se produce si se realiza un reintento.

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0



793
794
795
796
797
798
799
800
801
802
803
804
805
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 793

def poblar
  return false Si ¿cerrado?

  begin
    return crear_y_agregar_conexión
  rescate Error::Error de socket, Error::Error de tiempo de espera del socket => e
    # Se encontró un error al conectar la conexión,
    # Ignore este primer error e inténtelo de nuevo.
    advertencia de registro("Elpopulator no pudo conectar una conexión para #{address}: #{e.class}: #{e}. Lo intentará nuevamente.")
  end

  return crear_y_agregar_conexión
end

#listo ⇒ Objeto

Indica al grupo que cree y devuelva conexiones.

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0



593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 593

def listo
  ¡subir si está cerrado!

  # TODO: Agregar esto nuevamente en RUBY-3174.
  # si Lint.enabled?
  # a menos que @server.connected?
  # generar Error::LintError, "Intentando preparar un grupo para el servidor #{@server.summary} que está desconectado"
  #   end
  # end

  @cerrar.sincronizar hacer
    return Si @listo

    @listo = true
  end

  # Tenga en cuenta que la especificación CMAP exige la serialización de eventos CMAP para un
  # pool. Para implementar esto, la publicación de eventos debe realizarse en
  # una cola que está sincronizada, en lugar de invocar suscriptores
  # del método de activación como este en línea. En la resonancia magnética, suponiendo
  # los hilos ceden el paso a otros cuando dejan de tener trabajo que hacer, es
  # Es probable que en la práctica los eventos siempre se publiquen en el
  # orden requerido. JRuby, al ser verdaderamente concurrente con los subprocesos del sistema operativo,
  # no ofrecería tal garantía.
  evento_publicar_cmap(
    Monitoring::Evento::Cmap::Listo para la piscina.Nuevo(@server.dirección, opciones, yo)
  )

  Si opciones.Fetch(:populator_io, true)
    Si @populator.¿correr?
      @populate_semaphore.señal
    else
      @populator.¡correr!
    end
  end
end

#¿listo? ⇒ verdadero | falso

Si la piscina está lista.

Devuelve:

  • (verdadero | falso) —

    Si la piscina está lista.

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0



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

def ¿listo?
  @cerrar.sincronizar hacer
    @listo
  end
end

#size ⇒ Integer

Tamaño del pool de conexiones.

Incluye las conexiones disponibles y las ocupadas.

Devuelve:

  • (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
  ¡subir si está cerrado!

  @cerrar.sincronizar hacer
    tamaño no sincronizado
  end
end

#stop_populator ⇒ Objeto

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Detenga el hilo que llena el fondo y limpie todas las conexiones creadas que aún no se hayan conectado.

Se utiliza al cerrar el pool o al finalizar el subproceso bg para realizar pruebas. En este último caso, este método debe llamarse antes de usar el pool para garantizar que el método check_out no haya creado conexiones en pending_connections durante el flujo.

Desde:

  • 2.0.0, en gran parte reescrito en 2.9.0



765
766
767
768
769
770
771
772
773
774
775
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 765

def detener_populador
  @populator.¡detener!

  @cerrar.sincronizar hacer
    # Si se llama a stop_populator mientras se ejecuta populate, puede haber
    # conexiones en espera de ser conectadas, conexiones que aún no lo han sido
    # se ha movido a conexiones_disponibles, o las conexiones se han movido a conexiones_disponibles
    # pero no se eliminaron de las conexiones pendientes. Deberían limpiarse.
    borrar conexiones pendientes
  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
  @cerrar.sincronizar hacer
    Estado = Si ¿cerrado?
      'cerrado '
    elsif !@listo
      'pausa '
    else
      ' listo'
    end
    "#<Tamaño del ConnectionPool=#{tamaño_no_sincronizado} (#{tamaño_mín}-#{tamaño_máx}) " +
      "usado=#{@checked_out_connections. length} disponible=#{@available_connections.length} pendiente=#{@pending_connections.length} #{estado}>"
  end
end

#conexiones_no_disponibles ⇒ Entero

Este método forma parte de una API privada. Debe evitarlo 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 se ha alcanzado el tamaño máximo del pool.

Devuelve:

  • (Entero) —

    Número de conexiones no disponibles en el pool. Se utiliza para calcular si se ha alcanzado el tamaño máximo del pool.

Desde:

  • 2.0.0, en gran parte reescrito 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 + @conexiones_pendientes.longitud + @solicitudes_de_conexión
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) (predeterminado: nulo) —

    Contexto de la operación para la que se solicita la conexión, si la hay.

Devuelve:

  • (Flotar) -

    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 tiempo de espera(context = nulo)
  Si context&.remaining_timeout_sec.nil?
    opciones[:tiempo de espera] || TIEMPO DE ESPERA PREDETERMINADO
  else
    context&.remaining_timeout_sec
  end
end

#con_conexión(id_global_de_conexión: nulo, contexto: nulo) ⇒ Objeto

Ceder el bloque a una conexión, mientras se maneja la lógica de entrada/salida.

Ejemplos:

Ejecutar con una conexión.

pool.with_connection do |connection|
  connection.read
end

Devuelve:

  • (Objeto) -

    El resultado del bloque.

Desde:

  • 2.0.0



715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
 
# Archivo 'lib/mongo/server/connection_pool.rb', línea 715

def con_conexión(id_global_de_conexión: nulo, context: nulo)
  ¡subir si está cerrado!

  conexión = verificar(
    id_global_de_conexión: id_global_de_conexión,
    context: context
  )
  rendimiento(conexión)
rescate Error::Error de socket, Error::Error de tiempo de espera del socket, Error::Conexión Perecida => e
  ¡Tal vez el fondo común esté despejado!(conexión, e)
asegurar
  Si conexión
    registrarse(conexión)
  end
end