Classe: Mongo::Server::ConnectionPool

Herda:
Objeto
  • Objeto
mostrar tudo
Estendido por:
Encaminhável
Inclui:
Loggable, Monitoramento::publicável
Definido em:
lib/mongo/ servidor/connection_pool.rb,
lib/mongo/ servidor/connection_pool/populator.rb,
lib/mongo/ servidor/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
DEFAULT_MIN_SIZE =

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

Desde:

  • 2.9.0

0
DEFAULT_MAX_CONNECTING =

O número máximo padrão de conexões que podem estar se conectando a qualquer momento.

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0

2
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

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 ser incluídas nas opções passadas aqui e serão encaminhadas para todas as conexões criadas pelo 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_connecting (Inteiro) —

    O número máximo de conexões que podem se conectar simultaneamente. O padrão é 2. Essa opção deve ser aumentada se houver muitos threads compartilhando o mesmo pool de conexões e o aplicação estiver enfrentando tempos limite enquanto aguarda o estabelecimento das conexões.

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

Aumenta:

  • (ArgumentError)

Desde:

  • 2.0.0, API alterada em 2.9.0



100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 100

def inicializar(Servidor, opções = {})
  aumentar ArgumentError, ' Oprimeiro argumento deve ser uma instância do servidor' a menos que Servidor.is_a?(Servidor)

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

  opções[:wait_timeout] ||= opções[:wait_queue_timeout] se opções[:wait_queue_timeout]
  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 = []
  @checked_out_connections = definir.Novo
  @pending_connections = definir.Novo
  @interrupt_connections = []

  # RUBY-3364: contar threads atualmente bloqueadas em size_cv /
  # max_connecting_cv. Quando não for zero, um thread recém-chegado deve
  # entrar na fila de espera mesmo que o predicado do portão esteja atualmente
  # satisfeito, para evitar barging além dos garçons existentes.
  @size_waiters = 0
  @max_connecting_waiters = 0

  # 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 em segundo plano 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 +
  # check_out_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.
  # Essa variável de condição 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, DEFAULT_MAX_CONNECTING)

  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



240
241
242
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 240

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



349
350
351
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 349

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



187
188
189
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 187

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



57
58
59
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 57

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



346
347
348
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 346

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



190
191
192
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 190

def Servidor
  @server
end

Detalhes do método de classe

.finalizar(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



854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 854

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



298
299
300
301
302
303
304
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 298

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



425
426
427
428
429
430
431
432
433
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 425

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, context: 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.

Parâmetros:

  • :connection_global_id (Inteiro | nil) —

    O ID global da conexão a ser verificada.

  • :context (Mongo::Operação:Context | nil) —

    Contexto da operação para a qual a conexão é solicitada, se houver.

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



373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 373

def check_out(connection_global_id: nada, contexto: 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, Contexto
  )

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

  se Lint.habilitado? && !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

  Conexão
garantir
  check_invariants
end

#check_out_pinned_connection(connection_global_id) ⇒ Conexão | nada

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 uma conexão fixada que já foi verificada, se houver com o ID global fornecido. Caso contrário, retorna zero.

Parâmetros:

  • connection_global_id (Inteiro) —

    A ID global da conexão fixada.

Retorna:

  • (Conexão | nil) —

    A conexão fixada ou nil.

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



410
411
412
413
414
415
416
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 410

def check_out_pinned_connection(connection_global_id)
  @ bloqueio.sincronizar fazer
    @checked_out_connections.detectar fazer |conn|
      conn.global_id == connection_global_id && conn.fixado?
    end
  end
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



545
546
547
548
549
550
551
552
553
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 545

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



667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 667

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
    @generation_manager.close_all_pipes
  end

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

  true
end

#close_idle_sockets ➤ Objeto

Feche os soquetes que estiverem abertos por mais tempo do que o tempo ocioso máximo, se a opção estiver definida.

Desde:

  • 2.5.0



777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 777

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



311
312
313
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 311

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



562
563
564
565
566
567
568
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 562

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



438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 438

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



570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 570

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)

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

    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



518
519
520
521
522
523
524
525
526
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 518

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

  Método a menos que @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



715
716
717
718
719
720
721
722
723
724
725
726
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 715

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



235
236
237
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 235

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



200
201
202
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 200

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



209
210
211
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 209

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



503
504
505
506
507
508
509
510
511
512
513
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 503

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



253
254
255
256
257
258
259
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 253

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



833
834
835
836
837
838
839
840
841
842
843
844
845
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 833

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

  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



616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 616

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

  Método a menos que opções.buscar(:populator_io, true)

  se @populator.executando?
    @populate_semafore.sinal
  mais
    @populator.corra!
  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



318
319
320
321
322
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 318

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



268
269
270
271
272
273
274
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 268

def Tamanho
  create_if_closed!

  @ bloqueio.sincronizar fazer
    unsynchronized_size
  end
end

#estado ⇒ Hash

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 estatísticas sobre o estado interno do pool de conexões, principalmente para fins de teste e depuração.

Retorna:

  • (Hash) —

    O estado do pool de conexões

Desde:

  • 2.0.0, amplamente reescrito em 2.9.0



878
879
880
881
882
883
884
885
886
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 878

def state
  @ bloqueio.sincronizar fazer
    { available_connections: @available_connections.Tamanho,
      checked_out_connections: @checked_out_connections.Tamanho,
      pending_connections: @pending_connections.Tamanho,
      interrupt_connections: @interrupt_connections.Tamanho,
      connection_requests: @connection_requests }
  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



805
806
807
808
809
810
811
812
813
814
815
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 805

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



328
329
330
331
332
333
334
335
336
337
338
339
340
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 328

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



289
290
291
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 289

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

#wait_timeout(context = nil) ⇒ Float

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

Parâmetros:

  • Contexto (Mongo::Operação:Context | nil) (padrão para: nil) —

    Contexto da operação para a qual a conexão é solicitada, se houver.

Retorna:

  • (Flutuante) —

    O tempo limite de espera da fila.

Desde:

  • 2.9.0



221
222
223
224
225
226
227
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 221

def wait_timeout(Contexto = nada)
  se Contexto&.remaining_timeout_sec.nada?
    opções[:wait_timeout] || DEFAULT_WAIT_TIMEOUT
  mais
    Contexto&.remaining_timeout_sec
  end
end

#with_connection(connection_global_id: nil, context: 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



738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
 
# Arquivo 'lib/mongo/ servidor/connection_pool.rb', linha 738

def with_connection(connection_global_id: nada, contexto: nada)
  create_if_closed!

  # Se uma conexão específica for solicitada e já estiver verificada
  # e fixado (por exemplo, para uma transação ou cursor no modo de balanceamento de carga),
  # reutilize-o diretamente sem passar pelo ciclo check_out/check_in.
  se connection_global_id
    Conexão = @ bloqueio.sincronizar fazer
      @checked_out_connections.detectar fazer |conn|
        conn.global_id == connection_global_id && conn.fixado?
      end
    end
  end

  Conexão ||= check_out(
    connection_global_id: connection_global_id,
    contexto: Contexto
  )

  rendimento(Conexão)
salvar Erro::Erro de soquete, Erro::SocketTimeoutError, Erro::ConnectionPerished => e
  talvez_raise_pool_cleared!(Conexão, e)
garantir
  se Conexão && !Conexão.fixado?
    # Não faça check-in se a conexão estiver fixada (a sessão ou o cursor
    # é o proprietário e fará o check-in mais tarde ao desafixar). Ignorar também
    # check-in se a conexão já tiver sido verificada durante o bloqueio
    # (por exemplo, por Session#unpin após um erro na primeira operação).
    check_out = @ bloqueio.sincronizar fazer
      @checked_out_connections.incluir?(Conexão)
    end
    check_in(Conexão) se check_out
  end
end