Classificação: Mongo::Cluster

Herda:
Objeto
  • Objeto
mostrar tudo
Estendido por:
Encaminhável
Inclui:
Mongo::ClusterTime::Consumer, Evento::Subscriber, Loggable, Monitoramento::publishable
Definido em:
lib/mongo/cluster.rb,
lib/mongo/cluster/ topologia.rb,
lib/mongo/cluster/ topologia.rb,
lib/mongo/cluster/sdam_flow.rb,
lib/mongo/cluster/ topologia/base.rb,
lib/mongo/cluster/ topologia/single.rb,
lib/mongo/cluster/ topologia/sharded.rb,
lib/mongo/cluster/ topologia/unknown.rb,
lib/mongo/cluster/periodic_executor.rb,
lib/mongo/ cluster/reapers/cursor_reaper.rb,
lib/mongo/cluster/reapers/socket_reaper.rb,
lib/mongo/cluster/ topologia/load_balanced.rb,
lib/mongo/cluster/ topologia/no_replica_set_options.rb,
lib/mongo/cluster/ topologia/replica_set_no_primary.rb,
lib/mongo/cluster/ topologia/replica_set_with_primary.rb

Visão geral

Autor (C) 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'

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 -- booleano
    • :deprecation_errors -- booleano

Aumenta:

  • (ArgumentError)

Desde:

  • 2.0.0



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
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
 
# Arquivo 'lib/mongo/cluster.rb', linha 118

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

  opções = opções.dup
  opções[:cleanup] = false se opções[:monitoring_io] == false && !opções.chave?(:cleanup)
  @tracer = opções.excluir(:tracer)
  @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
  @session_pool = Sessão::Pool de sessões.Novo(auto)

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

  # 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

  possivelmente_aviso_sobre_compatibilidade!

  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

  Método se 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.
    server_selection_timeout = 3 se server_selection_timeout < 3
    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
      intervalo se Servidores.todos? { |Servidor| Servidor.last_scan_monotime && Servidor.last_scan_monotime >= start_monotime }
      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

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



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

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



314
315
316
 
# Arquivo 'lib/mongo/cluster.rb', linha 314

def monitor_app_metadata
  @monitor_app_metadata
end

#Monitoring ➤ Monitoramento (somente leitura)

Monitoramento de retornos O monitoramento.

Retorna:

Desde:

  • 2.0.0



300
301
302
 
# Arquivo 'lib/mongo/cluster.rb', linha 300

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



297
298
299
 
# Arquivo 'lib/mongo/cluster.rb', linha 297

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



317
318
319
 
# Arquivo 'lib/mongo/cluster.rb', linha 317

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



325
326
327
 
# Arquivo 'lib/mongo/cluster.rb', linha 325

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



482
483
484
 
# Arquivo 'lib/mongo/cluster.rb', linha 482

def server_selection_semafore
  @server_selection_semafore
end

#session_pool ➤ Objeto (somente leitura)

Desde:

  • 2.5.1



330
331
332
 
# Arquivo 'lib/mongo/cluster.rb', linha 330

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



352
353
354
 
# Arquivo 'lib/mongo/cluster.rb', linha 352

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



305
306
307
 
# Arquivo 'lib/mongo/cluster.rb', linha 305

def topologia
  @topology
end

#tracer ⇒ objeto (somente leitura)

Desde:

  • 2.0.0



302
303
304
 
# Arquivo 'lib/mongo/cluster.rb', linha 302

def rastreador
  @tracer
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



287
288
289
290
291
292
293
294
 
# Arquivo 'lib/mongo/cluster.rb', linha 287

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



721
722
723
724
725
 
# Arquivo 'lib/mongo/cluster.rb', linha 721

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



827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
 
# Arquivo 'lib/mongo/cluster.rb', linha 827

def adicionar(Anfitrião, add_options = nada)
  endereço = endereço.Novo(Anfitrião, opções)
  Método se Endereços.incluir?(endereço)

  opciona = opções.mesclar(monitorar: false)
  # Se não estivermos iniciando 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 simular 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
  Servidor.start_monitoring se add_options.nada? || add_options[:monitor] != false
  Servidor
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



445
446
447
 
# Arquivo 'lib/mongo/cluster.rb', linha 445

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



500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
 
# Arquivo 'lib/mongo/cluster.rb', linha 500

def Fechar
  @state_change_lock.sincronizar fazer
    Método nada a menos que conectando? || conectado?

    se opções[:cleanup] != false
      session_pool.end_sessions
      @periodic_executor.pare!
    end
    @srv_monitor_lock.sincronizar fazer
      @srv_monitor.pare! se @srv_monitor
    end
    @servidores.cada fazer |Servidor|
      próximo a menos que Servidor.conectado?

      Servidor.Fechar
      publish_sdam_event(
        Monitoramento::SERVER_Closed,
        Monitoramento::Evento::Servidor fechado.Novo(Servidor.endereço, topologia)
      )
    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



418
419
420
421
422
 
# Arquivo 'lib/mongo/cluster.rb', linha 418

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



406
407
408
409
410
 
# Arquivo 'lib/mongo/cluster.rb', linha 406

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



931
932
933
934
935
936
937
938
939
940
 
# Arquivo 'lib/mongo/cluster.rb', linha 931

def connect_server_if_connected(Servidor)
  Método a menos que Servidor.conectado?

  Servidor.clear_description
  Servidor.desconecte-se!
  publish_sdam_event(
    Monitoramento::SERVER_Closed,
    Monitoramento::Evento::Servidor fechado.Novo(Servidor.endereço, topologia)
  )
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



739
740
741
 
# Arquivo 'lib/mongo/cluster.rb', linha 739

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



751
752
753
 
# Arquivo 'lib/mongo/cluster.rb', linha 751

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



397
398
399
 
# Arquivo 'lib/mongo/cluster.rb', linha 397

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



467
468
469
 
# Arquivo 'lib/mongo/cluster.rb', linha 467

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



339
340
341
 
# Arquivo 'lib/mongo/cluster.rb', linha 339

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



368
369
370
 
# Arquivo 'lib/mongo/cluster.rb', linha 368

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

#próximo_primary(_ping = nil, sessão = nil, tempo limite: nil) ⇒ Mongo::servidor

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

    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.

  • :timeout (Flutuante | nulo) —

    Tempo limite em segundos para a operação, se houver.

Retorna:

Desde:

  • 2.0.0



770
771
772
773
774
775
776
777
 
# Arquivo 'lib/mongo/cluster.rb', linha 770

def próximo_primary(ping = nada, session = nada, timeout: nada)
  ServerSelector.Principal.select_server(
    auto,
    nada,
    session,
    timeout: timeout
  )
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



790
791
792
 
# Arquivo 'lib/mongo/cluster.rb', linha 790

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



386
387
388
 
# Arquivo 'lib/mongo/cluster.rb', linha 386

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



541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
 
# Arquivo 'lib/mongo/cluster.rb', linha 541

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
      @srv_monitor.corra! se @srv_monitor
    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



874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
 
# Arquivo 'lib/mongo/cluster.rb', linha 874

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|
        removeu_servers << Servidor se excluir
      end
    end
  end
  se Desconectar != false
    removeu_servers.cada fazer |Servidor|
      connect_server_if_connected(Servidor)
    end
  end
  se Desconectar == false
    removeu_servers
  mais
    removeu_servers.algum?
  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



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
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
 
# Arquivo 'lib/mongo/cluster.rb', linha 625

def run_sdam_flow(anterior_desc, updated_desc, opções = {})
  se load_balanced?
    se updated_desc.config.vazio? && !opções[:keeper_connection_pool]
      server_list.cada fazer |Servidor|
        # TODO: o ID do serviço deve ser retirado de 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
    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

    se !opções[:keeper_connection_pool] && fluxo.tornou-se_unknown?
      server_list.cada fazer |Servidor|
        próximo a menos que 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

    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.
  Método se updated_desc.desconhecido?

  server_selection_semafore.transmissão
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



584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
 
# Arquivo 'lib/mongo/cluster.rb', linha 584

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



433
434
435
 
# Arquivo 'lib/mongo/cluster.rb', linha 433

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



924
925
926
927
928
 
# Arquivo 'lib/mongo/cluster.rb', linha 924

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



692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
 
# Arquivo 'lib/mongo/cluster.rb', linha 692

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|
      adicionar(endereço_str) a menos que server_list.algum? { |Servidor| Servidor.endereço.Semente == endereço_str }
    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



475
476
477
478
479
 
# Arquivo 'lib/mongo/cluster.rb', linha 475

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



804
805
806
807
808
809
810
 
# Arquivo 'lib/mongo/cluster.rb', linha 804

def update_cluster_time(Resultado)
  Método a menos que cluster_time_doc = Resultado.cluster_time

  @cluster_time_lock.sincronizar fazer
    advanced_cluster_time(cluster_time_doc)
  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



897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
 
# Arquivo 'lib/mongo/cluster.rb', linha 897

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!(timeout: 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.

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 na implantação. 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.

Parâmetros:

  • :timeout (Flutuante | nulo) —

    Tempo limite para a validação. Como o processo de validação envolve a seleção do servidor ,

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



966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
 
# Arquivo 'lib/mongo/cluster.rb', linha 966

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

  @state_change_lock.sincronizar fazer
    @sdam_flow_lock.sincronizar fazer
      create_sessions_not_supported se topologia.data_Bearing_Servers? && !topologia.logical_session_timeout
    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, timeout: timeout)
  @state_change_lock.sincronizar fazer
    @sdam_flow_lock.sincronizar fazer
      create_sessions_not_supported a menos que topologia.logical_session_timeout
    end
  end
end