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

Clases: GenerationManager, Populator

Colapso delresumen constante

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

Constantes incluidas desde Loggable

Registrable::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 en Monitoring::Publishable

#publicar_evento_cmap, #publicar_evento, #publicar_evento_sdam

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 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 para el que es este pool de conexiones.

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

    Las opciones del pool de conexiones.

Opciones Hash (options):

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

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

  • :max_conectando (Entero) —

    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 (Entero) —

    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 (Entero) —

    El tamaño mínimo de la piscina.

  • min_pool_size (Entero) —

    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.

  • :tiempo de espera (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 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 modificado 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 menos que Server.is_a?(Server)
    propagar ArgumentError, 'El primer argumento debe ser una instancia de servidor'
  end
  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[:tamaño máximo] && opciones[:max_pool_size] && opciones[:tamaño máximo] != 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[:tiempo de espera] && opciones[Tiempo de espera de la cola] && opciones[:tiempo de espera] != 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[:tamaño máximo] ||= opciones[:max_pool_size]
  opciones.borrar(:max_pool_size)
  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 supere el tamaño máximo #{options[:max_size]}"
  end
  si opciones[Tiempo de espera de la cola]
    opciones[:tiempo de espera] ||= opciones[Tiempo de espera de la cola]
  end
  opciones.borrar(Tiempo de espera de la cola)

  @server = Server
  @options = opciones.freeze

  @generation_manager = Gerente de Generación.Nuevo(servidor: Server)
  @listo = 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.
  @conexiones_disponibles = 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 en general
  # debe hacerlo bajo este bloqueo.
  @lock = Mutex (exclusión mutua).Nuevo

  # Hilo 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
  # conexiones no disponibles disminuye (pendiente + conexiones_pendientes +
  #conexiones_desprotegidas).
  @size_cv = Mongo::Variable de condición.Nuevo(@lock)
  # Esto representa el número de subprocesos que han superado el size_cv
  # puerta, pero no he adquirido una conexión para agregarla a las pending_connections
  # colocar.
  @connection_requests = 0

  # Variable de condición para aplicar la segunda comprobación en check_out: max_connecting.
  # La variable de condición de Thei debe ser señalada cuando el número de pendientes
  # Las conexiones disminuyen.
  @max_connecting_cv = Mongo::Variable de condición.Nuevo(@lock)
  @max_connecting = opciones.obtener(:max_conectando, DEFAULT_MAX_CONNECTING)

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

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

Detalles de los atributos de instancia

#generation_manager ⇒ Integer (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 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 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, 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)

Opciones de retorno 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 ⇒ Objeto (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



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

def populate_semaphore
  @populate_semaphore
end

#poblador ⇒ 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, 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 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, 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

.finalizar(available_connections, pending_connections, populator) ⇒ Proc

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

Parámetros:

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

    Las conexiones disponibles.

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

    Las conexiones pendientes.

  • poblador (Populador) —

    El populador.

Devuelve:

  • (Proc) —

    El finalizador.

Desde:

  • 2.0.0, re-escrita en gran medida 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 sí mismo.finaliza(available_connections, pending_connections, poblador)
  proc hacer
    available_connections.cada hacer |Conexión|
      Conexión.¡desconectar!(Motivo: :piscina cerrada)
    end
    available_connections.borrar

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

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

Detalles del método de instancia

#número_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
    @conexiones_disponibles.longitud
  end
end

#check_in(conexión) ⇒ 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



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

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

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

  • connection_global_id (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:

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

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

  publish_cmap_event(
    Monitoring::Evento::Cmap::ConnectionCheckOutStarted.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(
    connection_global_id, context
  )

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

  si Lint.¿habilitado?
    a menos 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(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 (Hash) (predeterminado: nulo) —

    un conjunto personalizable de opciones

Opciones Hash (options):

  • :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.

  • :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.

  • :id_de_servicio (Objeto) —

    Borrar conexiones únicamente con el ID de servicio especificado.

Devuelve:

  • (cierto) —

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

  hacer_borrar(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 (Hash) (predeterminado: nulo) —

    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 conductor. Indica si se debe marcar o no el grupo como cerrado.

Devuelve:

  • (cierto) —

    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 ||= {}

  stop_populator

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

    si opciones[forzar]
      hasta @checked_out_connections.¿vacío?
        Conexión = @checked_out_connections.tomar(1).primero
        Conexión.¡desconectar!(Motivo: :piscina 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
      @listo = false
    end

    @max_connecting_cv.transmisión
    @size_cv.transmisión
    @generation_manager.cerrar_todas_las_tuberías
  end

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

  true
end

#close_idle_sockets ⇒ 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 close_idle_sockets
  return si ¿Cerrado?
  return a menos que tiempo_máximo_inactivo

  @lock.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_inactivo
          Conexión.¡desconectar!(Motivo: :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:

  • (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 = 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 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



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 intentemos desconectar el pool, permitir que el pool sea
  # 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, re-escrita en gran medida 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 vuelve a revisar en el grupo.
  # y cerrado. La operación que estaba usando la conexión antes de que se cerrara.
  # la interrupción 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 menos que Conexión.grupo de conexiones == sí mismo
    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 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 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á al tamaño máximo es posible que se agote el tiempo de espera.
  # 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

  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: :piscina cerrada)
    return
  end

  si Conexión.¿Cerrado?
    # La conexión fue cerrada, 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(service_id: Conexión.service_id) && !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
    # sin fijar.
    Conexión.¡desconectar!(Motivo: :stale)
    @populate_semaphore.señal
  else
    Conexión.registro_chequeo!
    @conexiones_disponibles << 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



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

  service_id = opciones && opciones[:id_de_servicio]

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

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

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

  # "Programar 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 forma parte de una API privada. Debe evitarlo 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



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

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 si !@listo

  @listo = false
end

#inspect ⇒ String

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

Ejemplos:

Inspecciona la piscina.

pool.inspect

Devuelve:

  • (string) —

    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} " +
      "wait_timeout=#{wait_timeout} paused>"
  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_inactivo
  @max_idle_time ||= opciones[:max_idle_time]
end

#max_size ⇒ Integer

Obtenga el tamaño máximo del grupo 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 tamaño máximo
  @max_size ||= opciones[:tamaño máximo] || [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] || TAMAÑO MÍNIMO PREDETERMINADO
end

#pausa ⇒ Objeto

Marcar el pool de conexiones como pausado.

Desde:

  • 2.0.0, re-escrita en gran medida 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
  raise_if_closed!

  check_invariants

  @lock.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:

  • (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
    !@listo
  end
end

#populate ⇒ true | false

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 realiza 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. 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 sockets

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 el socket se produce si se realiza un reintento.

Desde:

  • 2.0.0, re-escrita en gran medida 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 create_and_add_connection
  rescate Error::Error de socket, Error::SocketTimeoutError => e
    # se encontró un error al conectar la conexión,
    # ignore este primer error e inténtelo de nuevo.
    advertencia de registro("El poblador no pudo conectar una conexión para #{dirección}: #{e.clase}: #{e}. Reintentará nuevamente.")
  end

  return 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



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

  # TODO: Agregar esto nuevamente 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 @listo

    @listo = 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 invocar 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 subprocesos del sistema operativo,
  # no ofrecería tal garantía.
  publish_cmap_event(
    Monitoring::Evento::Cmap::PoolReady.Nuevo(@server.dirección, opciones, sí mismo)
  )

  si opciones.obtener(:populator_io, true)
    si @populator.¿correr?
      @populate_semaphore.señal
    else
      @populator.ejecutar!
    end
  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
    @listo
  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 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 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



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

def stop_populator
  @populator.¡detener!

  @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 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.
    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 !@listo
      'pausa '
    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 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 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) (predeterminado: nulo) —

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

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

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



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 with_connection(id_global_de_conexión: nulo, context: nulo)
  raise_if_closed!

  Conexión = check_out(
    id_global_de_conexión: connection_global_id,
    context: context
  )
  rendimiento(Conexión)
rescate Error::Error de socket, Error::SocketTimeoutError, Error::Conexión Perecida => e
  maybe_raise_pool_cleared!(Conexión, e)
asegurar
  si Conexión
    registrar(Conexión)
  end
end