Classificação: Mongo::Cluster

Herda:
Objeto
  • Objeto
mostrar tudo
Estendido por:
Encaminhável
Inclui:
Mongo::ClusterTime::Consumer, Evento::Subscriber, Loggable, Monitoramento::publishable
Definido em:
build/ruby-driver-v2.19/lib/mongo/cluster.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/topology.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/topology.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/sdam_flow.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/topology/base.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/topology/single.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/topology/sharded.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/topology/unknown.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/p eriodic_executor.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/reapers/cursor_reaper.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/reapers/socket_reaper.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/topology/load_balanced.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/topology/no_replica_set_options.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/topology/replica_set_no_primary.rb,
build/ruby-driver-v2.19/lib/mongo/cluster/topology/replica_set_with_primary.rb

Visão geral

Copyright © 2018-2020 MongoDB Inc.

Licenciado sob a Licença Apache, Versão 2.0 (a "License"); você não pode usar este arquivo, exceto em conformidade com a Licença. Você pode obter uma cópia da Licença em

http://www.apache.org/licenses/LICENSE-2.0

A menos que exigido pela lei aplicável ou aceito por escrito, o software distribuído sob a Licença é distribuído “como está”, sem garantias ou condições de qualquer tipo, Express ou implícitas. Consulte a Licença para obter as permissões e limitações específicas de governo do idioma nos termos da Licença.

Definido sob namespace

Módulos: topologia Classes: CursorReaper, PeriodicExecutor, SdamFlow, SocketReaper

Colapsode resumo constante

MAX_READ_RETRIES =

O número padrão de tentativas de leitura legadas.

Desde:

  • 2.1.1

1
MAX_WRITE_RETRIES =

O número padrão de tentativas de gravação herdadas.

Desde:

  • 2.4.2

1
READ_RETRY_INTERVAL =

O intervalo de repetição de leitura padrão, em segundos, ao usar novas tentativas de leitura legadas.

Desde:

  • 2.1.1

5
IDLE_WRITE_PERIOD_SECONDS =

Com que frequência um primary ocioso grava um no-op no oplog.

Desde:

  • 2.4.0

10
CLUSTER_TIME =
Obsoleto.

A chave de tempo do cluster em respostas de servidores mongos.

Desde:

  • 2.5.0

'clusterTime'.congelar

Constantes incluídas do Loggable

Loggable::Prefix

Recolhimento do Resumo do atributo de instância

Atributos incluídos do Mongo::ClusterTime::Consumer

#cluster_time

Atributos incluídos do Evento::Subscriber

#event_listeners

Recolhimento do Resumo do método de classe

Recolhimento do Resumo do método de instância

Métodos incluídos do Mongo::ClusterTime::Consumer

#advance_cluster_time

Métodos incluídos no Loggable

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

Métodos incluídos do Event::Subscriber

#subscribe_to

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

#publish_cmap_event, #publish_event, #publish_sdam_event

Detalhes do construtor

#initialize(seeds, monitoramento, opções = Options::Redacted.new) ➤ Cluster

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.

Observação:

O cluster nunca deve ser instanciado diretamente fora de um cliente.

Observação:

Ao se conectar a um URI mongodb+srv://, o cliente expande esse URI em uma lista de servidores e passa essa lista para o construtor de Cluster. Ao se conectar a um mongod autônomo , o construtor do Cluster recebe o endereço correspondente como uma array de uma string.

Instancie o novo cluster.

Exemplos:

Instancie o cluster.

Mongo::Cluster.new(["127.0.0.1:27017"], monitoring)

Parâmetros:

  • sementes (Array<String>) —

    Os endereços dos servidores configurados

  • Monitoramento (Monitoramento) —

    O monitoramento.

  • opções (Hash) (padrão para: Options::Redacted.new) —

    Opções. O construtor do cliente encaminha suas opções para o construtor do Cluster, embora o Cluster reconheça apenas um subconjunto das opções reconhecidas pelo cliente.

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

  • :direct_connection (verdadeiro | falso) —

    Se deve se conectar diretamente à semente especificada, ignorando a descoberta da topologia. Exatamente uma semente deve ser fornecida.

  • :connect (Símbolo) —

    Obsoleto - use a opção :direct_connection em vez desta opção. O método de conexão a ser usado. Isso força o cluster a se comportar da maneira especificada em vez de fazer a descoberta automaticamente. Um dos :direct, :replica_set, :sharded

  • :replica_set (Símbolo) —

    O nome do conjunto de réplicas ao qual se conectar. Os servidores que não estejam neste conjunto de réplicas serão ignorados.

  • :scan (verdadeiro | falso) —

    Se todas as sementes devem ser verificadas no construtor. O padrão na versão do driver 2.x é fazer isso; versão do driver 3.x não verificará sementes no construtor. Opte pelo novo comportamento definindo esta opção como false. Observação: definir essa opção como nulo habilita a digitalização de sementes no construtor na versão do driver 2.x. Versão do driver 3.x reconhecerá esta opção, mas a ignorará e nunca verificará sementes no construtor.

  • :monitoring_io (verdadeiro | falso) —

    Somente para uso interno do driver. Defina como falso para evitar que a E/S relacionada ao SDAM seja feita por esse cluster ou servidores abaixo dele. Observação: definir essa opção como falso tornará o cluster não funcional. Destina-se ao uso em testes que invocam manualmente transições de estado SDAM.

  • :cleanup (verdadeiro | falso) —

    Somente para uso interno do driver. Defina como false para evitar que o comando endSessions seja enviado ao servidor para limpar as sessões do servidor quando o cluster for desconectado e para não iniciar o executor periódico. Se :monitoring_io for falso, :cleanup automaticamente padronizará para falso também.

  • : heartbeat_frequency (Flutuante) —

    O intervalo, em segundos, para o monitor do servidor atualizar sua descrição por meio de hello.

  • :resolv_options (Hash) —

    Somente para uso interno do driver. Opções a serem passadas para o construtor Resolv::DNS para pesquisas SRV.

  • :server_api (Hash) —

    A versão da API do servidor solicitado. Esse hash pode ter os seguintes itens:

    • :version – string

    • :strict – boolean

    • :deprecation_errors – boolean

Desde:

  • 2.0.0



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
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 120

def inicializar(sementes, Monitoramento, opções = Opções::Editado.Novo)
  se sementes.nada?
    aumentar ArgumentError, 'As sementes não podem ser nulas'
  end

  opções = opções.dup
  se opções[:monitoring_io] == false && !opções.chave?(:cleanup)
    opções[:cleanup] = false
  end
  @opções = opções.congelar

  # @update_lock abrange @servers, @connecting, @connected, @topology e
  # @sessions_supported. Geralmente, variáveis de instância que não têm um
  # O bloqueio designado para eles só deve ser modificado sob o bloqueio de atualização.
  # Observe que a alteração de topologia é bloqueada por @update_lock e não por
  # @sdam_flow_lock.
  @update_lock = Mutex.Novo
  @servidores = []
  @monitoring = Monitoramento
  @event_listeners = Evento::ouvintes.Novo
  @app_metadata = Servidor::AppMetadata.Novo(@opções.mesclar(finalidade: : aplicação))
  @monitor_app_metadata = Servidor::Monitorar::AppMetadata.Novo(@opções.mesclar(finalidade: :monitor))
  @push_monitor_app_metadata = Servidor::Monitorar::AppMetadata.Novo(@opções.mesclar(finalidade: :push_monitor))
  @cluster_time_lock = Mutex.Novo
  @cluster_time = nada
  @srv_monitor_lock = Mutex.Novo
  @srv_monitor = nada
  @server_selection_semafore = Semáforo.Novo
  @topology = topologia.inicial(auto, Monitoramento, opções)
  # A bloqueio de alteração de estado é semelhante à trava de fluxo bloqueio, mas foi projetada
  # para serializar alterações de estado iniciadas pelos consumidores do cluster
  # (por exemplo aplicativo que está conectando ou desconectando o cluster), para que
  # por exemplo, um aplicação chamando desconectar-conectar-desconectar rapidamente
  # não coloca o cluster em um estado inconsistente.
  # As atualizações de monitoramento realizadas internamente pelo driver não levam
  # o bloqueio de alteração de estado.
  @state_change_lock = Mutex.Novo
  # @sdam_flow_lock abrange apenas o fluxo sdam. Observe que não se aplica
  # para substituições de topologia que são feitas em @update_lock.
  @sdam_flow_lock = Mutex.Novo
  Sessão::Pool de sessões.criar(auto)

  se sementes.vazio? && load_balanced?
    aumentar ArgumentError, 'Clusters com balanceamento de carga sem sementes são proibidos'
  end

  # A topologia de abertura é sempre desconhecida sem servidores.
  # https://github.com/mongodb/specifications/pull/388
  Opening_topology = topologia::Desconhecido.Novo(opções, Monitoramento, auto)

  publish_sdam_event(
    Monitoramento::TOPOLOGY_OPENING,
    Monitoramento::Evento::Abertura de topologia.Novo(Opening_topology)
  )

  @seeds = sementes = sementes.uniq
  Servidores = sementes.map fazer |Semente|
    # Os eventos de abertura do servidor MongoDB devem ser enviados após os eventos de alteração de topologia.
    # Portanto, adição de servidor separada, feita aqui antes da alteração de topologia
    # evento é publicado, desde o início do monitoramento do servidor que é
    # feito mais tarde.
    adicionar(Semente, monitorar: false)
  end

  se sementes.Tamanho >= 1
    # Recriar a topologia para obter a lista de servidores atual nela
    recriar_topologia(topologia, Opening_topology)
  end

  se load_balanced?
    # As especificações exigem que produzamos determinados eventos SDAM
    # quando estiver em topologia com balanceamento de carga.
    # Esses eventos não fazem muito sentido do ponto de vista do
    implementação de SDAM do driver #, nem do ponto de vista do
    implementação do balanceador de carga do driver #.
    # Eles são apenas um código padrão necessário.
    #
    # Observe que esta chamada deve ser feita acima da verificação monitoring_io
    # porque isso causa um curto-circuito no resto do construtor.
    fabricate_lib_sdam_events_and_set_server_type
  end

  se opções[:monitoring_io] == false
    # Omitir a construção periódica de executores, porque sem servidores
    # nenhum comando pode ser enviado para o cluster e nunca deve
    # seja qualquer coisa que precise ser limpa.
    #
    # Omitir o monitoramento de servidores individuais e a rodada única herdada de
    # de SDAM na thread principal, pois ela correria com testes que simulam
    # Respostas SDAM.
    @connecting = @connected = false
    Método
  end

  # Atualizar variáveis de instância antes de iniciar threads de monitoramento.
  @connecting = false
  @connected = true

  se opções[:cleanup] != false
    @cursor_reaper = CursorReaper.Novo(auto)
    @socket_reaper = SocketReaper.Novo(auto)
    @periodic_executor = PeriodicExecutor.Novo([
      @cursor_reaper, @socket_reaper,
    ], opções)

    @periodic_executor.corra!
  end

  a menos que load_balanced?
    # É necessário registrar o tempo de início antes de iniciar o monitoramento
    start_monotime = Utilidades.monotonic_time

    Servidores.cada fazer |Servidor|
      Servidor.start_monitoring
    end

    se opções[:scan] != false
      server_selection_timeout = opções[:server_selection_timeout] || ServerSelector::SERVER_SELECTION_TIMEOUT
      # O tempo limite de seleção do servidor pode ser muito curto, especialmente em
      # testes, quando o cliente aguarda uma verificação síncrona antes
      # iniciando a seleção do servidor . Limitando a verificação ao tempo de seleção do servidor
      # então cancela a verificação antes que ela possa processar até mesmo servidores locais.
      # Portanto, aguarde pelo menos 3 segundos para a verificação aqui.
      se server_selection_timeout < 3
        server_selection_timeout = 3
      end
      prazo = start_monotime + server_selection_timeout
      # Aguarde a conclusão da primeira verificação de cada servidor, para
      # compatibilidade com versões anteriores.
      # Se algum servidor for descoberto durante esta rodada de SDAM, vamos
      # espera que esses servidores também sejam consultados, e assim por diante, até o
      # timeout de seleção de servidor ou o mínimo de 3 segundos.
      loop fazer
        # Certifique-se de que não tentamos ler a lista de servidores enquanto o SDAM está em execução
        Servidores = @sdam_flow_lock.sincronizar fazer
          server_list.dup
        end
        se Servidores.todos? { |Servidor| Servidor.last_scan_monotime && Servidor.last_scan_monotime >= start_monotime }
          intervalo
        end
        se (time_remaining = prazo - Utilidades.monotonic_time) <= 0
          intervalo
        end
        log_debug("Aguardando até #{'%.2f' % time_remaining} segundos para servidores a serem verificados: #{resumo}")
        # Como o semáforo pode ter sido sinalizado entre nós, verificando
        # a lista de servidores acima e a chamada de espera abaixo, não devemos
        # aguarde todo o tempo restante - aguarde até 0.5 segundo e, em seguida,
        # verifique novamente o estado.
        começar
          server_selection_semafore.esperar([time_remaining, 0.5].min)
        salvar ::Tempo-limite::Erro
          #nada
        end
      end
    end

    start_stop_srv_monitor
  end
end

Detalhes do atributo da instância

#app_metadata ➤ Mongo::Server::AppMetadata (readonly)

Retorna Os metadados do aplicativo, usados para negociações de conexão.

Retorna:

Desde:

  • 2.4.0



317
318
319
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 317

def app_metadata
  @app_metadata
end

#monitor_app_metadata ➤ 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



320
321
322
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 320

def monitor_app_metadata
  @monitor_app_metadata
end

#Monitoring ➤ Monitoramento (somente leitura)

Monitoramento de retornos O monitoramento.

Retorna:

Desde:

  • 2.0.0



308
309
310
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 308

def Monitoramento
  @monitoring
end

#opções ➤ Hash (somente leitura)

Retorna o hash de opções.

Retorna:

  • (Hash) —

    O hash de opções.

Desde:

  • 2.0.0



305
306
307
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 305

def opções
  @opções
end

#push_monitor_app_metadata ➤ 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



323
324
325
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 323

def push_monitor_app_metadata
  @push_monitor_app_metadata
end

#seed s Array<String> (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 Os endereços dos servidores de sementes. Contém endereços que foram fornecidos ao cluster quando ele foi instanciado, não endereços atuais que o cluster está usando como resultado do SDAM.

Retorna:

  • (Array<String>) —

    Os endereços dos servidores de sementes. Contém endereços que foram fornecidos ao cluster quando ele foi instanciado, não endereços atuais que o cluster está usando como resultado do SDAM.

Desde:

  • 2.7.0



331
332
333
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 331

def sementes
  @seeds
end

#server_selection_semafore ➤ 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



488
489
490
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 488

def server_selection_semafore
  @server_selection_semafore
end

#session_pool ➤ Objeto (somente leitura)

Desde:

  • 2.5.1



336
337
338
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 336

def session_pool
  @session_pool
end

#srv_monitor ➤ 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



358
359
360
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 358

def srv_monitor
  @srv_monitor
end

#topology ➤ Inteiro? (somente leitura)

O valor lógico de tempo limite da sessão em minutos.

Exemplos:

Obtenha o tempo limite lógico da sessão em minutos.

cluster.logical_session_timeout

Retorna:

  • (Inteiro, zero) —

    O tempo limite lógico da sessão.

Desde:

  • 2.5.0



311
312
313
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 311

def topologia
  @topology
end

Detalhes do método de classe

.create(cliente, monitoramento: nil) ➤ Cluster

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.

Criar um cluster para o cliente fornecido, para uso quando não quisermos que a instância do cluster original do cliente seja a mesma.

Exemplos:

Criar um cluster para o cliente.

Cluster.create(client)

Parâmetros:

  • Cliente (Cliente) —

    O cliente para criar.

  • monitoramento. (Monitoramento | nulo) —

    A instância de monitoramento a ser usada com o novo cluster. Se não houver valor, será criada uma nova instância de monitoramento.

Retorna:

Desde:

  • 2.0.0



295
296
297
298
299
300
301
302
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 295

def auto.criar(Cliente, monitoramento: nada)
  cluster = cluster.Novo(
    Cliente.cluster.Endereços.map(&:to_s),
    Monitoramento || Monitoramento.Novo,
    Cliente.cluster_options,
  )
  Cliente.instance_variable_set(:@cluster, cluster)
end

Detalhes do método de instância

#==(outro) ➤ true, false

Determine se esse cluster de servidores é igual a outro objeto. Verifica os servidores atualmente no cluster, não o que foi configurado.

Exemplos:

O cluster é igual ao objeto?

cluster == other

Parâmetros:

  • Outro (Objeto) —

    O objeto com o qual comparar.

Retorna:

  • (verdadeiro, falso) —

    Se os objetos forem iguais.

Desde:

  • 2.0.0



738
739
740
741
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 738

def ==(Outro)
  Método false a menos que Outro.is_a?(cluster)
  Endereços == Outro.Endereços && opções == Outro.opções
end

#add(host, add_options = nil) ➤ MongoDB Server

Adicione um servidor ao cluster com o endereço fornecido. Útil na descoberta automática de novos servidores quando um servidor existente executa um hello e servidores potencialmente não configurados foram incluídos.

Exemplos:

Adicione o servidor do endereço ao cluster.

cluster.add('127.0.0.1:27018')

Parâmetros:

  • Anfitrião (string) —

    O endereço do servidor a ser adicionado.

  • opções (Hash) —

    um conjunto personalizável de opções

Retorna:

  • (Servidor MongoDB) —

    O servidor recém-adicionado, se ainda não estiver presente.

Desde:

  • 2.0.0



836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 836

def adicionar(Anfitrião, add_options=nada)
  endereço = endereço.Novo(Anfitrião, opções)
  se !Endereços.incluir?(endereço)
    opciona = opções.mesclar(monitorar: false)
    # Se não estivermos iniciando os threads de monitoramento, também não queremos
    # iniciar a thread de preenchimento do pool.
    opciona.mesclar!(populator_io: false) a menos que opções.buscar(:monitoring_io, true)
    # Observe que em uma topologia com balanceamento de carga, cada servidor deve ser um
    # balanceador de carga (load_balancer: true é especificado nas opções)
    # mas esta opção não está definida aqui porque somos exigidos pelo
    # especificações para presumir que o servidor começou como desconhecido
    # e publicar o evento de alteração da descrição do servidor no balanceador de carga
    # um. A descrição correta real para este servidor será definida
    # pelo fabricate_lib_sdam_events_and_set_server_type.
    Servidor = Servidor.Novo(endereço, auto, @monitoring, event_listeners, opciona)
    @update_lock.sincronizar fazer
      # É necessário verificar novamente se o servidor está presente em @servidores, porque
      # a verificação anterior não estava bloqueada.
      # Como estamos sob o bloqueio de atualização aqui, não podemos chamar server_list.
      Método se @servidores.map(&:address).incluir?(endereço)

      @servidores.push(Servidor)
    end
    se add_options.nada? || add_options[:monitor] != false
      Servidor.start_monitoring
    end
    Servidor
  end
end

# deendereços ➤ Array<Mongo::Endereço>

Os endereços no cluster.

Exemplos:

Obtenha os endereços no cluster.

cluster.addresses

Retorna:

Desde:

  • 2.0.6



451
452
453
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 451

def Endereços
  server_list.map(&:address)
end

#close ➤ nil

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.

Observação:

Os aplicativos devem ligar para o Client#close para se desconectar do

Fecha o cluster.

o cluster em vez de chamar esse método. Este método é somente para uso interno do driver.

Desconecta todos os servidores no cluster, publicando eventos SDAM apropriados no processo. Interrompe o monitoramento SRV se ele estiver ativo. Marca o cluster desconectado.

Um cluster fechado não pode mais ser usado. Se o cliente for reconectado, ele criará uma nova instância de cluster.

Retorna:

  • (nil) —

    Sempre nulo.

Desde:

  • 2.0.0



506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 506

def Fechar
  @state_change_lock.sincronizar fazer
    a menos que conectando? || conectado?
      Método nada
    end
    se opções[:cleanup] != false
      session_pool.end_sessions
      @periodic_executor.pare!
    end
    @srv_monitor_lock.sincronizar fazer
      se @srv_monitor
        @srv_monitor.pare!
      end
    end
    @servidores.cada fazer |Servidor|
      se Servidor.conectado?
        Servidor.Fechar
        publish_sdam_event(
          Monitoramento::SERVER_Closed,
          Monitoramento::Evento::Servidor fechado.Novo(Servidor.endereço, topologia)
        )
      end
    end
    publish_sdam_event(
      Monitoramento::Topology_Closed,
      Monitoramento::Evento::Topologia fechada.Novo(topologia)
    )
    @update_lock.sincronizar fazer
      @connecting = @connected = false
    end
  end
  nada
end

#conectado? ➤ true|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.

Se o objeto de cluster está conectado ao seu cluster.

Retorna:

  • (true|false) —

    Se o cluster está conectado.

Desde:

  • 2.7.0



424
425
426
427
428
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 424

def conectado?
  @update_lock.sincronizar fazer
    !!@connected
  end
end

#conectando? ➤ true|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.

Se o objeto de cluster está em processo de conexão com seu cluster.

Retorna:

  • (true|false) —

    Se o cluster está se conectando.

Desde:

  • 2.0.0



412
413
414
415
416
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 412

def conectando?
  @update_lock.sincronizar fazer
    !!@connecting
  end
end

#connected_server_if_connected(server) ➤ 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.

Desde:

  • 2.0.0



944
945
946
947
948
949
950
951
952
953
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 944

def connect_server_if_connected(Servidor)
  se Servidor.conectado?
    Servidor.clear_description
    Servidor.desconecte-se!
    publish_sdam_event(
      Monitoramento::SERVER_Closed,
      Monitoramento::Evento::Servidor fechado.Novo(Servidor.endereço, topologia)
    )
  end
end

#has_readable_server?(server_selector = nil) ➤ true, false

Determine se o cluster selecionaria um servidor legível para a preferência de leitura fornecida.

Exemplos:

Um servidor legível está presente?

topology.has_readable_server?(server_selector)

Parâmetros:

  • server_selector (ServerSelector) (padrão para: nil) —

    O seletor de servidor.

Retorna:

  • (verdadeiro, falso) —

    Se um servidor legível estiver presente.

Desde:

  • 2.4.0



755
756
757
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 755

def has_readable_server?(server_selector = nada)
  topologia.has_readable_server?(auto, server_selector)
end

#has_writeable_server? ➤ true, false

Determine se o cluster selecionaria um servidor gravável.

Exemplos:

Um servidor gravável está presente?

topology.has_writable_server?

Retorna:

  • (verdadeiro, falso) —

    Se houver um servidor gravável.

Desde:

  • 2.4.0



767
768
769
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 767

def has_writeable_server?
  topologia.has_writeable_server?(auto)
end

#heartbeat_interval ➤ Flutuante

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.

Obtenha o intervalo de atualização do servidor. Isso será definido por meio de uma opção ou será padronizado como 10.

Retorna:

  • (Flutuante) —

    O intervalo de pulsação, em segundos.

Desde:

  • 2.10.0



403
404
405
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 403

def heartbeat_interval
  opções[: heartbeat_frequency] || Servidor::Monitorar::DEFAULT_HEARTBEAD_INTERVAL
end

#inspecionar ➤ string

Obtenha a string formatada melhor para uso na inspeção.

Exemplos:

Inspecione o cluster.

cluster.inspect

Retorna:

  • (string) —

    A inspeção do cluster.

Desde:

  • 2.0.0



473
474
475
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 473

def inspecionar
  "#<Mongo::Cluster:0x#{object_id} servidores=#{servidores} topology=#{topologia.resumo}>"
end

#load_balanced? ➤ verdadeiro | false

Retorna se o cluster está configurado para estar na topologia com balanceamento de carga.

Retorna:

  • (verdadeiro | falso) —

    Se a topologia tem balanceamento de carga.

Desde:

  • 2.0.0



345
346
347
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 345

def load_balanced?
  topologia.is_a?(topologia::loadBalanced)
end

#max_read_retry ➤ Inteiro

Obsoleto.
Observação:

max_read_retries devem ser recuperados da instância do cliente e não de uma instância do cluster, pois os clusters podem ser compartilhados entre clientes com valores diferentes para tentativas máximas de leitura.

Obtenha o número máximo de vezes que o cliente pode tentar novamente uma operação de leitura ao usar novas tentativas de leitura legado .

Exemplos:

Obtenha o máximo de tentativas de leitura.

cluster.max_read_retries

Retorna:

  • (Inteiro) —

    O número máximo de tentativas.

Desde:

  • 2.1.1



374
375
376
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 374

def max_read_retry
  opções[:max_read_retry] || MAX_READ_RETRIES
end

#próximo_primary(ping = nil, session = nil) ➤ Mongo::Server

Obtenha o próximo servidor primário para o qual podemos enviar uma operação.

Exemplos:

Obtenha o próximo servidor principal.

cluster.next_primary

Parâmetros:

  • Ping (verdadeiro, falso) (padrão para: nil) —

    Se deve ser feito ping no servidor antes da seleção. Obsoleto e ignorado.

  • session (Sessão | nulo) (padrão para: nil) —

    Sessão opcional a ter em conta para a fixação de mongos.

Retorna:

Desde:

  • 2.0.0



784
785
786
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 784

def próximo_primary(Ping = nada, session = nada)
  ServerSelector.Principal.select_server(auto, nada, session)
end

#pool(servidor) ➤ Server::ConnectionPool

Obsoleto.

Obtenha o pool de conexões do servidor.

Exemplos:

Obtenha o pool de conexões.

cluster.pool(server)

Parâmetros:

Retorna:

Desde:

  • 2.2.0



799
800
801
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 799

def pool(Servidor)
  Servidor.pool
end

#read_retry_interval ➤ Flutuante

Obsoleto.
Observação:

read_retry_interval deve ser recuperado da instância do cliente e não de uma instância do cluster, pois os clusters podem ser compartilhados entre clientes com valores diferentes para o intervalo de repetição de leitura.

Obtenha o intervalo, em segundos, em que as tentativas de leitura ao usar tentativas de leitura herdadas.

Exemplos:

Obtenha o intervalo de repetição de leitura.

cluster.read_retry_interval

Retorna:

  • (Flutuante) —

    O intervalo.

Desde:

  • 2.1.1



392
393
394
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 392

def read_retry_interval
  opções[:read_retry_interval] || READ_RETRY_INTERVAL
end

#reconectar! ➤ verdadeiro

Obsoleto.

Use Client#reconnect para se reconectar ao cluster em vez de chamar esse método. Este método não envia eventos SDAM.

Reconecte todos os servidores.

Exemplos:

Reconecte os servidores do cluster.

cluster.reconnect!

Retorna:

  • (verdadeiro) —

    Sempre verdadeiro.

Desde:

  • 2.1.0



550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 550

def reconecte-se!
  @state_change_lock.sincronizar fazer
    @update_lock.sincronizar fazer
      @connecting = true
    end
    digitalizar!
    Servidores.cada fazer |Servidor|
      Servidor.reconecte-se!
    end
    @periodic_executor.reinicie!
    @srv_monitor_lock.sincronizar fazer
      se @srv_monitor
        @srv_monitor.corra!
      end
    end
    @update_lock.sincronizar fazer
      @connecting = false
      @connected = true
    end
  end
end

#remove(host, desconexão: true) ➤ Array{Server> | true | false

Observação:

O valor de retorno deste método não faz parte da API pública do driver.

Remova o servidor do cluster para o endereço fornecido, se ele existir.

Exemplos:

Remova o servidor do cluster.

server.remove('127.0.0.1:27017')

Parâmetros:

  • Anfitrião (string) —

    O host/porta ou endereço de soquete.

  • Desconectar (verdadeiro | falso) (padrão para: true) —

    Se desconectar os servidores que estão sendo removidos. Somente para uso interno do driver.

Retorna:

  • (Array <Servidor> | verdadeiro | falso) —

    Se desconectar for qualquer valor diferente de falso, incluindo nulo, retornará se algum servidor foi removido. Se desconectar for falso, retornará uma array de servidores que foram removidos (e devem ser desconectados pelo chamador).

Desde:

  • 2.0.0



885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 885

def remover(Anfitrião, desconectar: true)
  endereço = endereço.Novo(Anfitrião)
  removeu_servers = []
  @update_lock.sincronizar fazer
    @servidores.delete_if fazer |Servidor|
      (Servidor.endereço == endereço).toque fazer |excluir|
        se excluir
          removeu_servers << Servidor
        end
      end
    end
  end
  se Desconectar != false
    removeu_servers.cada fazer |Servidor|
      connect_server_if_connected(Servidor)
    end
  end
  se Desconectar != false
    removeu_servers.algum?
  mais
    removeu_servers
  end
end

#run_sdam_flow(previous_desc, updated_desc, options = {}) ⇒ Object

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.

Executa o fluxo SDAM no cluster.

Esse método pode ser invocado para processar uma nova descrição de servidor retornada pelo servidor em uma conexão monitorada ou não monitorada e também pelo driver quando ele marca um servidor desconhecido como resultado de um erro (rede).

Parâmetros:

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

  • :keeper_connection_pool (verdadeiro | falso) —

    Normalmente, quando a nova descrição do servidor é desconhecida, o pool de conexões no respectivo servidor é limpo. Defina esta opção como verdadeiro para manter o pool de conexões existente (necessário ao lidar com erros não mestres em 4.2+ servidores).

  • :waited (verdadeiro | falso) —

    Se a descrição atualizada foi o resultado do processamento de uma saudação aguardada.

  • :service_id (Objeto) —

    Altere o estado apenas para o ID de serviço especificado.

  • :scan_error (Mongo::Error | nil) —

    O erro encontrado durante a digitalização ou nulo se nenhum erro foi gerado.

Desde:

  • 2.0.0



636
637
638
639
640
641
642
643
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
683
684
685
686
687
688
689
690
691
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 636

def run_sdam_flow(anterior_desc, updated_desc, opções = {})
  se load_balanced?
    se updated_desc.config.vazio?
      a menos que opções[:keeper_connection_pool]
        server_list.cada fazer |Servidor|
          # TODO deve ser retirado o ID do serviço updated_desc?
          # Também podemos afirmar que
          # options[:service_id] == updated_desc.service_id
          err = opções[:scan_error]
          interromper = err && (err.is_a?(Erro::Erro de soquete) || err.is_a?(Erro::SocketTimeoutError))
          Servidor.clear_connection_pool(service_id: opções[:service_id], interrupt_in_use_connections: interromper)
        end
      end
    end
    Método
  end

  @sdam_flow_lock.sincronizar fazer
    fluxo = SdamFlow.Novo(auto, anterior_desc, updated_desc,
      esperado: opções[:waited])
    fluxo.server_description_changed

    # O fluxo de SDAM pode alterar a descrição atualizada - pegue a final
    # versão para fins de transmissão se um servidor estiver disponível
    updated_desc = fluxo.updated_desc

    a menos que opções[:keeper_connection_pool]
      se fluxo.tornou-se_unknown?
        server_list.cada fazer |Servidor|
          se Servidor.endereço == updated_desc.endereço
            err = opções[:scan_error]
            interromper = err && (err.is_a?(Erro::Erro de soquete) || err.is_a?(Erro::SocketTimeoutError))
            Servidor.clear_connection_pool(interrupt_in_use_connections: interromper)
          end
        end
      end
    end

    start_stop_srv_monitor
  end

  # Algumas descrições atualizadas, por exemplo, uma que não corresponde a nós, resultam no
  # servidor cuja descrição estamos processando sendo removida
  # a topologia. Quando isso acontece, o thread de monitoramento do servidor fica
  # morto. Como resultado, qualquer código após a invocação de fluxo pode não ser executado
  # uma instância de monitor específica; portanto, geralmente não deve haver
  # qualquer código neste método após a invocação de fluxo.
  #
  # No entanto, essa chamada de transmissão pode estar aqui porque, se o monitoramento
  # thread foi eliminado, o servidor deveria ter sido fechado e nenhum cliente
  # deve estar esperando por ele, não sinalizando assim o semáforo
  # não deve causar problemas.
  a menos que updated_desc.desconhecido?
    server_selection_semafore.transmissão
  end
end

#scan!(sync = true) ➤ true

Observação:

Em verificações síncronas e assíncronas, cada thread de monitor mantém um intervalo mínimo entre as verificações, o que significa que chamar esse método pode não iniciar uma verificação em um servidor específico no instante seguinte.

Forçar uma verificação de todos os servidores conhecidos no cluster.

Se o parâmetro de sincronização for verdadeiro, que é o padrão, a verificação será executada de forma síncrona no thread que chamou esse método. Cada servidor no cluster é verificado sequencialmente. Se houver muitos servidores no cluster ou se eles demorarem para responder, essa pode ser uma operação de longa duração.

Se o parâmetro sync for falso, esse método instruirá todos os threads do monitor de servidor a executar uma verificação imediata e retornará sem aguardar os resultados da verificação.

Exemplos:

Forçar uma verificação completa do cluster.

cluster.scan!

Retorna:

  • (verdadeiro) —

    Sempre verdadeiro.

Desde:

  • 2.0.0



595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 595

def digitalizar!(sincronizar=true)
  se sincronizar
    server_list.cada fazer |Servidor|
      se Servidor.monitorar
        Servidor.monitorar.digitalizar!
      mais
        log_service("A verificação síncrona solicitada no cluster #{resumo} mas o servidor #{servidor} não tem monitor")
      end
    end
  mais
    server_list.cada fazer |Servidor|
      Servidor.varredura_semafore.sinal
    end
  end
  true
end

#servidores ➤ Array <Servidor MongoDB>

Obtenha uma lista de candidatos a servidor do cluster que podem ter operações executadas neles.

Exemplos:

Obtenha os candidatos do servidor para uma operação.

cluster.servers

Retorna:

Desde:

  • 2.0.0



439
440
441
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 439

def Servidores
  topologia.Servidores(server_list)
end

#server_list ➤ 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.

Desde:

  • 2.0.0



937
938
939
940
941
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 937

def server_list
  @update_lock.sincronizar fazer
    @servidores.dup
  end
end

#set_server_list(server_address_strs) ➤ 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.

Define a lista de servidores para os endereços na lista fornecida de strings de endereços.

Este método é chamado pelo monitor SRV após receber novos registros DNS para o nome de host monitorado.

Remove servidores no cluster cujos endereços não estão na lista passada de endereços de servidor e adiciona servidores para quaisquer endereços no argumento que ainda não estejam no cluster.

Parâmetros:

  • server_address_strs (Array<String>) —

    Lista de endereços de servidor para sincronizar os servidores de cluster.

Desde:

  • 2.0.0



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

def set_server_list(server_address_strs)
  @sdam_flow_lock.sincronizar fazer
    # Se um dos novos endereços não estiver na lista de servidores atual,
    # adicione-o à lista de servidores.
    server_address_strs.cada fazer |endereço_str|
      a menos que server_list.algum? { |Servidor| Servidor.endereço.Semente == endereço_str }
        adicionar(endereço_str)
      end
    end

    # Se um dos endereços do servidor não estiver na nova lista de endereços,
    # remova esse servidor da lista de servidores.
    server_list.cada fazer |Servidor|
      a menos que server_address_strs.algum? { |endereço_str| Servidor.endereço.Semente == endereço_str }
        remover(Servidor.endereço.Semente)
      end
    end
  end
end

#resumo ➤ Objeto

Observação:

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

Desde:

  • 2.7.0



481
482
483
484
485
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 481

def Resumo
  "#<Cluster " +
  "topology=#{topologia.resumo} "+
  "server=[#{server_list.map(&:summary).join(',')}]>"
end

#update_cluster_time(result) ➤ Objeto

Atualize o tempo máximo de cluster visto em uma resposta.

Exemplos:

Atualize o tempo de agrupamento.

cluster.update_cluster_time(result)

Parâmetros:

Retorna:

  • (Objeto) —

    O tempo de agrupamento.

Desde:

  • 2.5.0



813
814
815
816
817
818
819
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 813

def update_cluster_time(Resultado)
  se cluster_time_doc = Resultado.cluster_time
    @cluster_time_lock.sincronizar fazer
      advanced_cluster_time(cluster_time_doc)
    end
  end
end

#update_topology(new_topology) ➤ 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.

Desde:

  • 2.0.0



910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 910

def update_topology(new_topology)
  old_topology = nada
  @update_lock.sincronizar fazer
    old_topology = topologia
    @topology = new_topology
  end

  # Se a nova topologia tiver servidores com dados, saberemos com certeza se
  # sessões são suportadas - atualize nosso valor em cache.
  # Se a nova topologia não tiver servidores portadores de dados, deixe o valor antigo
  # como está e session_supported? o método executará a seleção do servidor
  # para tentar determinar o suporte da sessão com precisão, retornando ao
  # último valor conhecido.
  se topologia.data_Bearing_Servers?
    Sessions_supported = !!topologia.logical_session_timeout
    @update_lock.sincronizar fazer
      @sessions_supported = Sessions_supported
    end
  end

  publish_sdam_event(
    Monitoramento::TOPOLOGY_CHANGED,
    Monitoramento::Evento::Topologia alterada.Novo(old_topology, topologia)
  )
end

#validate_session_support! ➤ 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.

Gera erro::SessionsNotAvailable se a implantação à qual o driver está conectado não oferecer suporte a sessões.

O suporte à sessão pode mudar com o tempo, por exemplo, devido à atualização ou desatualização dos servidores no sistema. Se o cliente não estiver conectado a nenhum servidor e não encontrar nenhum servidor durante o tempo limite de seleção do servidor, esse método gerará NoServerAvailable. Esse método é chamado a partir do fluxo de execução da operação e, se ele gerar NoServerAvailable, toda a operação falhará com essa exceção, pois a execução da operação esperou o tempo limite de seleção do servidor para que qualquer servidor fique disponível (que seria um superconjunto dos servidores adequado para a operação que está sendo tentada) e nenhum materializado.

Aumenta:

  • (Erro::SessionsNotAvailable) —

    Se a implantação à qual o driver está conectado não suportar sessões.

  • (Erro::NoServerAvailable) —

    Se o cliente não estiver conectado a nenhum servidor e não encontrar nenhum servidor durante o tempo limite de seleção do servidor .

Desde:

  • 2.0.0



976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster.rb', linha 976

def validate_session_support!
  se topologia.is_a?(topologia::loadBalanced)
    Método
  end

  @state_change_lock.sincronizar fazer
    @sdam_flow_lock.sincronizar fazer
      se topologia.data_Bearing_Servers?
        a menos que topologia.logical_session_timeout
          create_sessions_not_supported
        end
      end
    end
  end

  # Nenhum servidor portador de dados conhecido - realize a seleção do servidor para tentar
  # obtenha uma resposta de pelo menos um deles, para retornar uma resposta precisa
  # avaliação sobre se as sessões são atualmente suportadas.
  ServerSelector.obter(modo: :primary_preferred).select_server(auto)
  @state_change_lock.sincronizar fazer
    @sdam_flow_lock.sincronizar fazer
      a menos que topologia.logical_session_timeout
        create_sessions_not_supported
      end
    end
  end
end