Classe: Mongo::Server::ConnectionPool

Herda:
Objeto
  • Objeto
mostrar tudo
Estendido por:
Encaminhável
Inclui:
Loggable, Monitoramento::publicável
Definido em:
build/ruby-driver-v2.19/lib/mongo/server/connection_pool.rb,
build/ruby-driver-v2.19/lib/mongo/server/connection_pool/populator.rb,
build/ruby-driver-v2.19/lib/mongo/server/connection_pool/generation_manager.rb

Visão geral

Representa um pool de conexões para conexões de servidor.

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0

Definido sob namespace

Classes: GeraçãoManager, Populator

Colapsode resumo constante

DEFAULT_MAX_SIZE =

O tamanho máximo padrão para o pool de conexões.

Desde:

  • 2.9.0

20.congelar
DEFAULT_MIN_SIZE =

O tamanho mínimo padrão para o pool de conexões.

Desde:

  • 2.9.0

0.congelar
DEFAULT_WAIT_TIMEOUT =

O tempo limite padrão, em segundos, para aguardar uma conexão.

Esse tempo limite se aplica enquanto os threads de fluxo aguardam que os threads de background estabeleçam conexões (e, portanto, eles devem se conectar, fazer handshake e autenticar no tempo alocado).

No momento, está definido para 10 segundos. O tempo limite de conexão padrão é 10 segundos por si só, mas definir tempos limite grandes pode colocar problemas nos aplicativos se suas solicitações atingirem o tempo limite pelo proxy reverso, portanto, qualquer coisa acima 15 segundos é potencialmente perigoso.

Desde:

  • 2.9.0

10.congelar

Constantes incluídas do Loggable

Loggable::Prefix

Recolhimento do Resumo do atributo de instância

Atributos incluídos no Monitoramento::publicável

#monitoring

Recolhimento do Resumo do método de classe

Recolhimento do Resumo do método de instância

Métodos incluídos do monitoramento::publicável

#publish_cmap_event, #publish_event, #publish_sdam_event

Métodos incluídos no Loggable

#log_debug, #log_error, #log_fatal, #log_info, #log_WARN, #logger

Detalhes do construtor

#initialize(servidor, options = {}) ➤ ConnectionPool

Crie o novo pool de conexões.

Observação: além disso, as opções para conexões criadas por esse pool devem

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

Parâmetros:

  • Servidor (Servidor MongoDB) —

    O servidor para o qual este pool de conexões é.

  • opções (Hash) (padrão para: {}) —

    As opções do pool de conexões .

Hash de opções (opções):

  • :max_size (Inteiro) —

    O tamanho máximo do conjunto. Definir esta opção como zero cria um pool de conexões ilimitado .

  • :max_pool_size (Inteiro) —

    Obsoleto. O tamanho máximo do conjunto. Se max_size também for fornecido, max_size e max_pool_size deverão ser idênticos.

  • :min_size (Inteiro) —

    O tamanho mínimo do conjunto.

  • :min_pool_size (Inteiro) —

    Obsoleto. O tamanho mínimo do conjunto. Se min_size também for fornecido, min_size e min_pool_size deverão ser idênticos.

  • :wait_timeout (Flutuante) —

    O tempo de espera, em segundos, por uma conexão gratuita.

  • :wait_queue_timeout (Flutuante) —

    Obsoleto. Alias para :wait_timeout. Se wait_timeout e wait_queue_timeout forem fornecidos, seus valores deverão ser idênticos.

  • :max_idle_time (Flutuante) —

    O tempo, em segundos, após o qual as conexões ociosas devem ser fechadas pelo pool.

  • :populator_io (verdadeiro, falso) —

    Somente para uso interno do driver. Defina como false para evitar que os threads de preenchimento sejam criados e iniciados no pool de conexões do servidor. Destina-se ao uso em testes que também desativam o monitoring_io, a menos que o populator seja explicitamente necessário. Se monitoring_io estiver desativado, mas o populator_io estiver ativado, o populator precisará ser fechado manualmente no final do teste, pois um cluster sem monitoramento é considerado não conectado e, portanto, não limpará os threads do populator do pool de conexões no fechamento.

Desde:

  • 2.0.0, API alterada em 2.9.0



92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 92

def inicializar(Servidor, opções = {})
  a menos que Servidor.is_a?(Servidor)
    aumentar ArgumentError, ' Oprimeiro argumento deve ser uma instância do servidor'
  end
  opções = opções.dup
  se opções[:min_size] && opções[:min_pool_size] && opções[:min_size] != opções[:min_pool_size]
    aumentar ArgumentError, "Otamanho mínimo de opções#{options[:min_size]} não é idêntico ao tamanho mínimo do pool #{options[:min_pool_size]}"
  end
  se opções[:max_size] && opções[:max_pool_size] && opções[:max_size] != opções[:max_pool_size]
    aumentar ArgumentError, "O tamanho máximo do conjunto#{opções[:max_size]} não é idêntico ao tamanho máximo do conjunto #{opções[:max_pool_size]}"
  end
  se opções[:wait_timeout] && opções[:wait_queue_timeout] && opções[:wait_timeout] != opções[:wait_queue_timeout]
    aumentar ArgumentError, "O tempo limite deespera #{options[:wait_timeout]} não é idêntico ao tempo limite da fila de espera #{options[:wait_queue_timeout]}"
  end
  opções[:min_size] ||= opções[:min_pool_size]
  opções.excluir(:min_pool_size)
  opções[:max_size] ||= opções[:max_pool_size]
  opções.excluir(:max_pool_size)
  se opções[:min_size] && opções[:max_size] &&
    (opções[:max_size] != 0 && opções[:min_size] > opções[:max_size])
  então
    aumentar ArgumentError, "Não é possível fazer com que o tamanho mínimo #{opções[:min_size]} exceda o tamanho máximo #{opções[:max_size]}"
  end
  se opções[:wait_queue_timeout]
    opções[:wait_timeout] ||= opções[:wait_queue_timeout]
  end
  opções.excluir(:wait_queue_timeout)

  @server = Servidor
  @opções = opções.congelar

  @generation_manager = GeraçãoManager.Novo(servidor: Servidor)
  @ready = false
  @closed = false

  # Uma conexão pertencente a esse pool deve estar na
  # array de conexões disponível (que é usada como uma pilha)
  # ou no conjunto de conexões verificadas.
  @available_connections = available_connections = []
  @checked_out_connections = definir.Novo
  @pending_connections = definir.Novo
  @interrupt_connections = []

  # Mutex usado para sincronizar o acesso a @available_connections e
  # @checked_out_connections. O objeto de pool é seguro para thread, portanto
  # todos os métodos que recuperam ou modificam variáveis de instância em geral
  # deve fazer isso sob esta trava.
  @ bloqueio = Mutex.Novo

  # Thread de background responsável por manter o tamanho de
  # o pool para pelo menos min_size
  @populator = Populator.Novo(auto, opções)
  @populate_semafore = Semáforo.Novo

  # Variável de condição para impor o primeiro check-in check_out: max_pool_size.
  # Esta variável de condição deve ser sinalizada quando o número de
  O número de conexões indisponíveis diminui (pending + pending_connections +
  # available_connections).
  @size_cv = mongo::CondiçãoVariável.Novo(@ bloqueio)
  # Isso representa o número de threads que ultrapassaram o size_cv
  # gate , mas não adquiriram uma conexão para adicionar às pending_connections
  #set.
  @connection_requests = 0

  # Variável de condição para impor o segundo check-in check_out: max_connecting.
  # A variável de condição I deve ser sinalizada quando o número de pendentes
  # conexões diminui.
  @max_connecting_cv = mongo::CondiçãoVariável.Novo(@ bloqueio)
  @max_connecting = opções.buscar(:max_connecting, 2)

  ObjectSpace.define_finalizer(auto, auto.classe.finalizar(@available_connections, @pending_connections, @populator))

  publish_cmap_event(
    Monitoramento::Evento::Cmap::PoolCreated.Novo(@server.endereço, opções, auto)
  )
end

Detalhes do atributo da instância

#geration_manager ➤ inteiro (somente leitura)

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna a geração de conexões atualmente em uso pela fila.

Retorna:

  • (Inteiro) —

    geração Geração de conexões atualmente sendo usadas pela fila.

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



216
217
218
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 216

def geration_manager
  @generation_manager
end

#max_connecting ➤ Objeto (somente leitura)

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



325
326
327
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 325

def max_connecting
  @max_connecting
end

#opções ➤ Hash (somente leitura)

Retorna opções As opções do pool.

Retorna:

  • (Hash) —

    options As opções do pool.

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



170
171
172
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 170

def opções
  @opções
end

#populate_semafore ➤ Object (somente leitura)

Variável de condição transmitida quando o tamanho do grupo muda para ativar o preenchedor

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



55
56
57
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 55

def preenchimento_semafore
  @populate_semafore
end

#populator ➤ Objeto (somente leitura)

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



322
323
324
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 322

def populator
  @populator
end

#server ➤ Object (somente leitura)

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



173
174
175
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 173

def Servidor
  @server
end

Detalhes do método de classe

.finalize(available_connections, pending_connections, populator) ➤ Proc

Finalize o pool de conexões para a coleta de lixo.

Parâmetros:

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

    As conexões disponíveis.

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

    As conexões pendentes.

  • populator (Preenchimento) —

    O preenchedor.

Retorna:

  • (Proc) —

    O Finalizador.

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 787

def auto.finalizar(available_connections, pending_connections, populator)
  proc fazer
    available_connections.cada fazer |Conexão|
      Conexão.desconecte-se!(razão: :pool_closed)
    end
    available_connections.Limpar

    pending_connections.cada fazer |Conexão|
      Conexão.desconecte-se!(razão: :pool_closed)
    end
    pending_connections.Limpar

    # O finalizador não fecha as conexões com check-out.
    # Esses teriam que ser coletados por conta própria
    # e isso deve fechá-los.
  end
end

Detalhes do método de instância

#available_count ➤ Inteiro

Número de conexões disponíveis no pool.

Retorna:

  • (Inteiro) —

    Número de conexões disponíveis.

Desde:

  • 2.9.0



274
275
276
277
278
279
280
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 274

def available_count
  create_if_closed!

  @ bloqueio.sincronizar fazer
    @available_connections.Tamanho
  end
end

#check_in(connection) ➤ Object

Verifique uma conexão de volta ao pool.

A conexão deve ter sido criada anteriormente por esse pool.

Parâmetros:

Desde:

  • 2.9.0



379
380
381
382
383
384
385
386
387
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 379

def check_in(Conexão)
  check_invariants

  @ bloqueio.sincronizar fazer
    do_check_in(Conexão)
  end
garantir
  check_invariants
end

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

Verifica uma conexão fora do pool.

Se houver conexões ativas no pool, a conexão usada mais recentemente será retornada. Caso contrário, se o tamanho do pool de conexões for menor que o tamanho máximo, crie uma nova conexão e a retorne. Caso contrário, aguarda até o tempo limite de espera e aumenta o Tempo limite::Error se ainda não houver conexões ativas e o pool estiver no tamanho máximo.

A conexão retornada conta para o tamanho máximo do pool. Quando o chamador terminar de usar a conexão, a conexão deve ser verificada novamente por meio do método check_in.

Retorna:

Aumenta:

  • (Erro::PoolClosedError) —

    Se o pool tiver sido fechado.

  • (Timeout::Error) —

    Se o pool de conexões estiver no tamanho máximo e permanecer assim por mais tempo do que o tempo limite de espera.

Desde:

  • 2.9.0



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

def check_out(connection_global_id: nada)
  check_invariants

  publish_cmap_event(
    Monitoramento::Evento::Cmap::connectionCheckOutStarted.Novo(@server.endereço)
  )

  create_if_pool_closed!
  create_if_pool_paused_locked!

  Conexão = retrieve_and_connect_connection(connection_global_id)

  publish_cmap_event(
    Monitoramento::Evento::Cmap::connectionCheckedOut.Novo(@server.endereço, Conexão.id, auto),
  )

  se Lint.habilitado?
    a menos que Conexão.conectado?
      aumentar Erro::LintError, "O pool de conexões para #{endereço} verificou uma conexão desconectada #{conexão.geração}:#{conexão.ID}"
    end
  end

  Conexão
garantir
  check_invariants
end

#clear(options = nil) ➤ true

Fecha todas as conexões ociosas no pool e agenda as conexões atualmente verificadas para serem fechadas quando forem verificadas novamente no pool. O pool está pausado, ele não criará novas conexões em segundo plano e falhará nas solicitações de checkout até ser marcado como pronto.

Parâmetros:

  • opções (Hash) (padrão para: nil) —

    um conjunto personalizável de opções

Hash de opções (opções):

  • :lazy (verdadeiro | falso) —

    Se verdadeiro, não feche nenhuma das conexões ociosas e, em vez disso, permita que sejam fechadas durante uma operação de verificação subsequente. O padrão é falso.

  • :interrupt_in_use_connections (verdadeiro | falso) —

    Se verdadeiro, feche todas as conexões com check-out imediatamente. Se for falso, não feche nenhuma das conexões verificadas. O padrão é verdadeiro.

  • :service_id (Objeto) —

    Limpe as conexões somente com o ID de serviço especificado.

Retorna:

  • (verdadeiro) —

    verdadeiro.

Desde:

  • 2.1.0



497
498
499
500
501
502
503
504
505
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 497

def Limpar(opções = nada)
  create_if_closed!

  se Lint.habilitado? && !@server.desconhecido?
    aumentar Erro::LintError, "Tentando limpar o pool do servidor #{@ servidor.resume} que é conhecido"
  end

  do_clear(opções)
end

#close(options = nil) ➤ true

Marca o pool como fechado, fecha todas as conexões ociosas no pool e agenda as conexões atualmente verificadas para serem fechadas quando forem verificadas novamente no pool. Se a opção force for verdadeira, as conexões verificadas também serão fechadas. As tentativas de usar o pool depois que ele for fechado aumentarão o Error::PoolClosedError.

Parâmetros:

  • opções (Hash) (padrão para: nil) —

    um conjunto personalizável de opções

Hash de opções (opções):

  • :force (verdadeiro | falso) —

    Feche também todas as conexões verificadas.

  • :stay_ready (verdadeiro | falso) —

    Somente para uso interno do driver. Se deve ou não marcar o pool como fechado.

Retorna:

  • (verdadeiro) —

    Sempre verdadeiro.

Desde:

  • 2.9.0



621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 621

def Fechar(opções = nada)
  Método se fechado?

  opções ||= {}

  stop_populator

  @ bloqueio.sincronizar fazer
    até que @available_connections.vazio?
      Conexão = @available_connections.Pop
      Conexão.desconecte-se!(razão: :pool_closed)
    end

    se opções[:force]
      até que @checked_out_connections.vazio?
        Conexão = @checked_out_connections.levar(1).primeiro
        Conexão.desconecte-se!(razão: :pool_closed)
        @checked_out_connections.excluir(Conexão)
      end
    end

    a menos que opções && opções[:stay_ready]
      # marcar o pool como fechado antes de liberar a bloqueio então
      # nenhuma conexão pode ser criada, fazer check-in ou check-out
      @closed = true
      @ready = false
    end

    @max_connecting_cv.transmissão
    @size_cv.transmissão
  end

  publish_cmap_event(
    Monitoramento::Evento::Cmap::PoolClosed.Novo(@server.endereço, auto)
  )

  true
end

#close_idle_sockets ➤ Objeto

Feche os soquetes que estão abertos há mais tempo do que o tempo ocioso máximo,

if the option is set.

Desde:

  • 2.5.0



708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 708

def close_idle_sockets
  Método se fechado?
  Método a menos que max_idle_time

  @ bloqueio.sincronizar fazer
    i = 0
    enquanto i < @available_connections.Tamanho
      Conexão = @available_connections[i]
      se last_checkin = Conexão.last_checkin
        se (Hora.agora - last_checkin) > max_idle_time
          Conexão.desconecte-se!(razão: :idle)
          @available_connections.delete_at(i)
          @populate_semafore.sinal
          próximo
        end
      end
      i += 1
    end
  end
end

#fechado? ➤ verdadeiro | false

Se o pool foi fechado.

Retorna:

  • (verdadeiro | falso) —

    Se o pool está fechado.

Desde:

  • 2.9.0



287
288
289
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 287

def fechado?
  !!@closed
end

#desconectar!(options = nil) ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Desconecta o pool.

Faz tudo o que clear faz, exceto se o pool estiver fechado que esse método não faça nada além clear aumentaria PoolClosedError.

Desde:

  • 2.1.0



514
515
516
517
518
519
520
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 514

def desconecte-se!(opções = nada)
  do_clear(opções)
salvar Erro::PoolClosedError
  # O estado "desconectado" está entre fechado e pausado.
  # Quando estivermos tentando desconectar o pool, permita que o pool seja
  # já fechado.
end

#do_check_in(connection) ➤ Object

Executa o check-in depois de já ter adquirido a trava.

Parâmetros:

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



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

def do_check_in(Conexão)
  # Quando uma conexão é interrompida, ela é verificada novamente no pool
  # e fechado. A operação que estava usando a conexão antes de ser
  # interrompido tentará verificá-lo novamente no pool e nós
  # deve ignorá-lo, pois ele já foi fechado e removido do pool.
  Método se Conexão.fechado? && Conexão.interrompido?

  a menos que Conexão.connection_pool == auto
    aumentar ArgumentError, "Tentando fazer check-in de uma conexão que não foi verificada por este pool: #{connection} fez check-out do pool #{connection.connection_pool} (para #{self})"
  end

  a menos que @checked_out_connections.incluir?(Conexão)
    aumentar ArgumentError, "Tentando fazer check-in de uma conexão que não está atualmente em check-out por este pool: #{connection} (for #{self})"
  end

  # Observação: se um manipulador de evento gerar um alerta, o recurso não será sinalizado.
  # Isso significa que threads esperando uma conexão para liberar quando
  # o pool está no tamanho máximo pode atingir o tempo limite.
  # Threads que começam a esperar após a conclusão deste método (com
  # a exceção) deve funcionar bem.

  @checked_out_connections.excluir(Conexão)
  @size_cv.sinal

  publish_cmap_event(
    Monitoramento::Evento::Cmap::connectionCheckedIn.Novo(@server.endereço, Conexão.id, auto)
  )

  se Conexão.interrompido?
    Conexão.desconecte-se!(razão: :stale)
    Método
  end

  se Conexão.erro?
    Conexão.desconecte-se!(razão: :error)
    Método
  end

  se fechado?
    Conexão.desconecte-se!(razão: :pool_closed)
    Método
  end

  se Conexão.fechado?
    # A conexão foi fechada , por exemplo, porque sofria
    # um erro de rede. Nada mais precisa ser feito aqui.
    @populate_semafore.sinal
  elsif Conexão.geração != geração(service_id: Conexão.service_id) && !Conexão.fixado?
    # Se a conexão estiver marcada como fixada, ela será usada por uma transação
    # ou uma série de operações do cursor em uma configuração de carga balanceada.
    # Nesse caso, a conexão não deve ser desconectada até
    # desafixado.
    Conexão.desconecte-se!(razão: :stale)
    @populate_semafore.sinal
  mais
    Conexão.record_checkin!
    @available_connections << Conexão

    @max_connecting_cv.sinal
  end
end

#do_clear(options = nil) ➤ Objeto

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 522

def do_clear(opções = nada)
  check_invariants

  service_id = opções && opções[:service_id]

  @ bloqueio.sincronizar fazer
    # A geração deve ser aumentada antes de emitir um evento de limpeza do pool.
    @generation_manager.bump(service_id: service_id)

    a menos que opções && opções[:lazy]
      close_available_connections(service_id)
    end

    se opções && opções[:interrupt_in_use_connections]
      agendamento_for_interruption(@checked_out_connections, service_id)
      agendamento_for_interruption(@pending_connections, service_id)
    end

    se @ready
      publish_cmap_event(
        Monitoramento::Evento::Cmap::PoolLimpo.Novo(
          @server.endereço,
          service_id: service_id,
          interrupt_in_use_connections: opções&.[](:interrupt_in_use_connections)
        )
      )
      # Pause o pool de conexões apenas se o servidor estiver marcado como desconhecido,
      # caso contrário, permitir que a nova tentativa seja tentada com um pool pronto.
      do_pause se !@server.load_balancer? && @server.desconhecido?
    end

    # Transmitir aqui para fazer com que todos os threads que aguardam no máximo
    # conectando para sair do loop de espera e erro.
    @max_connecting_cv.transmissão
    # Transmitir aqui para fazer com que todos os threads que aguardam o tamanho do pool
    # para sair do loop de espera e erro.
    @size_cv.transmissão
  end

  # "Agende o thread em segundo plano" após a limpeza. Isto é responsável
  # para limpar threads obsoletos e interromper conexões em uso.
  @populate_semafore.sinal
  true
garantir
  check_invariants
end

#do_pause ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Marque o pool de conexões como pausado sem adquirir a trava.

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



470
471
472
473
474
475
476
477
478
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 470

def do_pause
  se Lint.habilitado? && !@server.desconhecido?
    aumentar Erro::LintError, "Tentando pausar o pool do servidor #{@server.resume} que é conhecido"
  end

  Método se !@ready

  @ready = false
end

#inspecionar ➤ string

Obtenha uma inspeção de string bem impressa para a pool.

Exemplos:

Inspecione a pool.

pool.inspect

Retorna:

  • (string) —

    A inspeção da piscina.

Desde:

  • 2.0.0



668
669
670
671
672
673
674
675
676
677
678
679
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 668

def inspecionar
  se fechado?
    "#<Mongo::Server::ConnectionPool:0x#{object_id} min_size=#{min_size} max_size=#{max_size} " +
      "wait_timeout=#{wait_timeout} fechado>"
  elsif !pronto?
    "#<Mongo::Server::ConnectionPool:0x#{object_id} min_size=#{min_size} max_size=#{max_size} " +
      "wait_timeout=#{wait_timeout} pausado>"
  mais
    "#<Mongo::Server::ConnectionPool:0x#{object_id} min_size=#{min_size} max_size=#{max_size} " +
      "wait_timeout=#{wait_timeout} current_size=#{tamanho} disponível=#{available_count}>"
  end
end

#max_idle_time ➤ Flutuante | nada

O máximo de segundos que um soquete pode permanecer inativo desde que fez check-in no pool, se definido.

Retorna:

  • (Flutuante | nulo) —

    O tempo máximo ocioso do soquete em segundos.

Desde:

  • 2.9.0



211
212
213
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 211

def max_idle_time
  @max_idle_time ||= opções[:max_idle_time]
end

#max_size ⇒ Integer

Obtenha o tamanho máximo do pool de conexões.

Retorna:

  • (Inteiro) —

    O tamanho máximo do pool de conexões.

Desde:

  • 2.9.0



183
184
185
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 183

def max_size
  @max_size ||= opções[:max_size] || [DEFAULT_MAX_SIZE, min_size].max
end

#min_size ⇒ Integer

Obtenha o tamanho mínimo do pool de conexões.

Retorna:

  • (Inteiro) —

    O tamanho mínimo do pool de conexões.

Desde:

  • 2.9.0



192
193
194
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 192

def min_size
  @min_size ||= opções[:min_size] || DEFAULT_MIN_SIZE
end

#pausa ➤ Objeto

Marque o pool de conexões como pausado.

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



455
456
457
458
459
460
461
462
463
464
465
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 455

def pausa
  create_if_closed!

  check_invariants

  @ bloqueio.sincronizar fazer
    do_pause
  end
garantir
  check_invariants
end

#pausado? ➤ verdadeiro | false

Um pool de conexões será pausado se não estiver fechado e não estiver pronto.

Retorna:

  • (verdadeiro | falso) —

    se o pool de conexões está pausado.

Aumenta:

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



229
230
231
232
233
234
235
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 229

def pausado?
  create_if_closed!

  @ bloqueio.sincronizar fazer
    !@ready
  end
end

#preencher ➤ verdadeiro | false

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Este método faz três coisas:

  1. Cria e adiciona uma conexão ao pool, se o tamanho do pool estiver abaixo de min_size. Tenta novamente uma vez se um erro relacionado ao soquete for encontrado durante esse processo e aumenta se ocorrer um segundo erro ou se ocorrer um erro não relacionado ao soquete.

  2. Remove conexões obsoletas do pool de conexões.

  3. Interrompe conexões marcadas para interrupção.

Usado pelo thread de background do pool populator.

ocorreu, ou o erro não relacionado ao soquete

Retorna:

  • (verdadeiro | falso) —

    Se este método deve ser chamado novamente para criar mais conexões.

Aumenta:

  • (Erro::AuthError, Erro) —

    O segundo erro relacionado ao soquete gerado se uma nova tentativa

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



766
767
768
769
770
771
772
773
774
775
776
777
778
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 766

def preencher
  Método false se fechado?

  começar
    Método create_and_add_connection
  salvar Erro::Erro de soquete, Erro::SocketTimeoutError => e
    # foi encontrado um erro ao conectar a conexão,
    # ignore este primeiro erro e tente novamente.
    log_service("O preenchimento falhou ao conectar uma conexão para #{endereço}: #{e.classe}: #{e}. Ele tentará novamente.")
  end

  Método create_and_add_connection
end

#pronto ➤ Objeto

Instrui o pool a criar e retornar conexões.

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 570

def pronto
  create_if_closed!

  # TODO: Adicione isto de volta no RUBY-3174.
  # se Lint.enabled?
  # a menos que o servidor.connected?
  # create Error::LintError, "Tentando preparar um pool para o servidor #{@ servidor.summary} que está desconectado"
  # end
  # end

  @ bloqueio.sincronizar fazer
    Método se @ready

    @ready = true
  end

  # Observe que a especificação do CMAP exige serialização de eventos do CMAP para um
  # pool. Para implementar isso, a publicação de eventos deve ser feita em
  # uma fila que é sincronizada, em vez de assinantes serem invocados
  # do método de trigger como este aqui in-line. Na MRI, assumindo
  # os threads rendem a outros quando param de ter trabalho a fazer, é
  # provável que os eventos, na prática, sempre sejam publicados no
  # pedido necessário. JRuby, sendo realmente simultâneo com threads do sistema operacional,
  # não ofereceria essa garantia.
  publish_cmap_event(
    Monitoramento::Evento::Cmap::PoolReady.Novo(@server.endereço, opções, auto)
  )

  se opções.buscar(:populator_io, true)
    se @populator.executando?
      @populate_semafore.sinal
    mais
      @populator.corra!
    end
  end
end

#pronto? ➤ verdadeiro | false

Se o pool está pronto.

Retorna:

  • (verdadeiro | falso) —

    Se o pool está pronto.

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



294
295
296
297
298
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 294

def pronto?
  @ bloqueio.sincronizar fazer
    @ready
  end
end

#tamanho ➤ Inteiro

Tamanho do pool de conexões.

Inclui conexões disponíveis e verificadas.

Retorna:

  • (Inteiro) —

    Tamanho do pool de conexões.

Desde:

  • 2.9.0



244
245
246
247
248
249
250
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 244

def Tamanho
  create_if_closed!

  @ bloqueio.sincronizar fazer
    unsynchronized_size
  end
end

#stop_populator ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Pare o thread do preenchedor em segundo plano e limpe todas as conexões criadas que ainda não foram conectadas.

Usado ao fechar o pool ou ao encerrar o thread bg para fins de teste. No último caso, este método deve ser chamado antes do pool ser usado, para garantir que nenhuma conexão em pending_connections tenha sido criada em fluxo pelo método check_out.

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



738
739
740
741
742
743
744
745
746
747
748
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 738

def stop_populator
  @populator.pare!

  @ bloqueio.sincronizar fazer
    # Se stop_populator for chamado enquanto o preenchimento estiver em execução, pode haver
    # conexões esperando para serem conectadas, conexões que ainda não foram
    # foi movido para available_connections ou conexões movidas para available_connections
    # mas não excluído de pending_connections. Estes devem ser limpos.
    clear_pending_connections
  end
end

#resumo ➤ Objeto

Observação:

Este método é experimental e sujeito a alterações.

Desde:

  • 2.11.0



304
305
306
307
308
309
310
311
312
313
314
315
316
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 304

def Resumo
  @ bloqueio.sincronizar fazer
    state = se fechado?
      'fechado'
    elsif !@ready
      'pausa'
    mais
      'pronto'
    end
    "#<ConnectionPool size=#{unsynchronized_size} (#{min_size}-#{max_size}) " +
      "usado=#{@checked_out_connections.comprimento} aproveitar=#{@available_connections.comprimento} pending=#{@pending_connections.comprimento} #{estado}>"
  end
end

#unavailable_connections ➤ Inteiro

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna o número de conexões indisponíveis no pool. Usado para calcular se atingimos max_pool_size.

Retorna:

  • (Inteiro) —

    O número de conexões indisponíveis no pool. Usado para calcular se atingimos max_pool_size.

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



265
266
267
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 265

def unavailable_connections
  @checked_out_connections.Tamanho + @pending_connections.Tamanho + @connection_requests
end

#wait_timeout ➤ Flutuante

O tempo de espera, em segundos, para que uma conexão fique disponível.

Retorna:

  • (Flutuante) —

    O tempo limite de espera da fila.

Desde:

  • 2.9.0



201
202
203
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 201

def wait_timeout
  @wait_timeout ||= opções[:wait_timeout] || DEFAULT_WAIT_TIMEOUT
end

#with_connection(connection_global_id: nil) ➤ Objeto

Entregue o bloco a uma conexão enquanto lida com a lógica de check-in/check-out.

Exemplos:

Execute com uma conexão.

pool.with_connection do |connection|
  connection.read
end

Retorna:

  • (Objeto) —

    O resultado do bloqueio.

Desde:

  • 2.0.0



691
692
693
694
695
696
697
698
699
700
701
702
 
# File 'build/ruby-driver-v2.19/lib/mongo/ servidor/connection_pool.rb', linha 691

def with_connection(connection_global_id: nada)
  create_if_closed!

  Conexão = check_out(connection_global_id: connection_global_id)
  rendimento(Conexão)
salvar Erro::Erro de soquete, Erro::SocketTimeoutError, Erro::ConnectionPerished => e
  talvez_raise_pool_cleared!(Conexão, e)
garantir
  se Conexão
    check_in(Conexão)
  end
end