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



287
288
289
 
# Arquivo 'lib/mongo/cluster.rb', linha 287

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



290
291
292
 
# Arquivo 'lib/mongo/cluster.rb', linha 290

def monitor_app_metadata
  @monitor_app_metadata
end

#Monitoring ➤ Monitoramento (somente leitura)

Monitoramento de retornos O monitoramento.

Retorna:

Desde:

  • 2.0.0



276
277
278
 
# Arquivo 'lib/mongo/cluster.rb', linha 276

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



273
274
275
 
# Arquivo 'lib/mongo/cluster.rb', linha 273

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



293
294
295
 
# Arquivo 'lib/mongo/cluster.rb', linha 293

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



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

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



456
457
458
 
# Arquivo 'lib/mongo/cluster.rb', linha 456

def server_selection_semafore
  @server_selection_semafore
end

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



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

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



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

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



281
282
283
 
# Arquivo 'lib/mongo/cluster.rb', linha 281

def topologia
  @topology
end

#tracer ⇒ objeto (somente leitura)

Desde:

  • 2.0.0



278
279
280
 
# Arquivo 'lib/mongo/cluster.rb', linha 278

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



695
696
697
698
699
 
# Arquivo 'lib/mongo/cluster.rb', linha 695

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



801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
 
# Arquivo 'lib/mongo/cluster.rb', linha 801

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



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

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



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
501
502
503
 
# Arquivo 'lib/mongo/cluster.rb', linha 474

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



392
393
394
395
396
 
# Arquivo 'lib/mongo/cluster.rb', linha 392

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



380
381
382
383
384
 
# Arquivo 'lib/mongo/cluster.rb', linha 380

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



905
906
907
908
909
910
911
912
913
914
 
# Arquivo 'lib/mongo/cluster.rb', linha 905

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



713
714
715
 
# Arquivo 'lib/mongo/cluster.rb', linha 713

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



725
726
727
 
# Arquivo 'lib/mongo/cluster.rb', linha 725

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



371
372
373
 
# Arquivo 'lib/mongo/cluster.rb', linha 371

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



441
442
443
 
# Arquivo 'lib/mongo/cluster.rb', linha 441

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



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

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



342
343
344
 
# Arquivo 'lib/mongo/cluster.rb', linha 342

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



744
745
746
747
748
749
750
751
 
# Arquivo 'lib/mongo/cluster.rb', linha 744

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



764
765
766
 
# Arquivo 'lib/mongo/cluster.rb', linha 764

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



360
361
362
 
# Arquivo 'lib/mongo/cluster.rb', linha 360

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



515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
 
# Arquivo 'lib/mongo/cluster.rb', linha 515

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



848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
 
# Arquivo 'lib/mongo/cluster.rb', linha 848

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



599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
 
# Arquivo 'lib/mongo/cluster.rb', linha 599

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



558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
 
# Arquivo 'lib/mongo/cluster.rb', linha 558

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



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

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



898
899
900
901
902
 
# Arquivo 'lib/mongo/cluster.rb', linha 898

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



666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
 
# Arquivo 'lib/mongo/cluster.rb', linha 666

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



449
450
451
452
453
 
# Arquivo 'lib/mongo/cluster.rb', linha 449

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

#trigger_periodic_executor! ⇒ 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.

Força o executor periódico do cluster a ser executado imediatamente. Se o cluster não tiver um executor periódico, esse método não fará nada.

Desde:

  • 2.0.0



964
965
966
967
968
 
# Arquivo 'lib/mongo/cluster.rb', linha 964

def trigger_periodic_executor!
  Método a menos que @periodic_executor

  @periodic_executor.executar, executar
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



778
779
780
781
782
783
784
 
# Arquivo 'lib/mongo/cluster.rb', linha 778

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



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

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



940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
 
# Arquivo 'lib/mongo/cluster.rb', linha 940

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