Classe: Mongo::Servidor::Monitor Privado

Herda:
Objeto
  • Objeto
mostrar tudo
Estendido por:
Encaminhável
Inclui:
BackgroundThread, Evento::editor, Loggable
Definido em:
lib/mongo/ servidor/monitor.rb,
lib/mongo/ servidor/monitor/connection.rb,
lib/mongo/ servidor/monitor/app_metadata.rb

Visão geral

Esta classe faz parte de uma API privada. Evite usar essa classe, se possível, pois ela pode ser removida ou alterada no futuro.

Responsáveis por pesquisar periodicamente um servidor por meio de comandos hello para manter o status do servidor atualizado.

Tudo funciona em um thread em background para não interferir em outras operações realizadas pelo driver.

Desde:

  • 2.0.0

Definido sob namespace

Classes: AppMetadata, Conexão

Colapsode resumo constante

DEFAULT_HEARTBEAD_INTERVAL =

Essa constante faz parte de uma API privada. Você deve evitar usar essa constante, se possível, pois ela pode ser removida ou alterada no futuro.

O intervalo padrão entre as atualizações de status do servidor é de 10 segundos.

Desde:

  • 2.0.0

10
MIN_SCAN_INTERVAL =

Essa constante faz parte de uma API privada. Você deve evitar usar essa constante, se possível, pois ela pode ser removida ou alterada no futuro.

O tempo mínimo entre as verificações forçadas do servidor . É minHeartbeatFrequencyMS na especificação SDAM.

Desde:

  • 2.0.0

0.5
RTT_WEight_FACTOR =

Essa constante faz parte de uma API privada. Você deve evitar usar essa constante, se possível, pois ela pode ser removida ou alterada no futuro.

Obsoleto.

Será removido na versão 3.0.

O fator de ponderação (alfa) para calcular o tempo médio de ida e volta em movimento.

Desde:

  • 2.0.0

0.2

Constantes incluídas do Loggable

Loggable::Prefix

Recolhimento do Resumo do atributo de instância

Atributos incluídos do Evento::editor

#event_listeners

Recolhimento do Resumo do método de instância

Métodos incluídos do BackgroundThread

#run!, #correndo?

Métodos incluídos no Loggable

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

Métodos incluídos do Event::publisher

#publish

Detalhes do construtor

#initialize(servidor, event_listeners, monitoramento, opções = {}) ➤ Monitorar

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 Monitor nunca deve ser diretamente instanciado fora de um Servidor.

Crie o novo monitor de servidor .

Exemplos:

Crie o monitor do servidor .

Mongo::Server::Monitor.new(address, listeners, monitoring)

Parâmetros:

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

  • :connect_timeout (Flutuante) —

    O tempo limite, em segundos, a ser usado ao estabelecer a conexão de monitoramento.

  • : heartbeat_interval (Flutuante) —

    O intervalo entre verificações regulares do servidor .

  • :logger (Registrador) —

    Um registrador personalizado para usar.

  • :monitor_app_metadata (Mongo::Server::Monitor::AppMetadata) —

    Os metadados a serem usados para conexão de monitoramento regular.

  • :push_monitor_app_metadata (Mongo::Server::Monitor::AppMetadata) —

    Os metadados a serem usados na conexão do monitor de push.

  • :socket_timeout (Flutuante) —

    O timeout, em segundos, para executar operações na conexão de monitoramento.

Aumenta:

  • (ArgumentError)

Desde:

  • 2.0.0



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 76

def inicializar(Servidor, event_listeners, Monitoramento, opções = {})
  aumentar ArgumentError, "Tipo de monitoramento incorreto: #{monitoring.inspect}" a menos que Monitoramento.is_a?(Monitoramento)
  aumentar ArgumentError, ' Osmetadados do aplicativo são obrigatórios' a menos que opções[:app_metadata]
  aumentar ArgumentError, ' Osmetadados do aplicativo de monitoramento são necessários' a menos que opções[:push_monitor_app_metadata]

  @server = Servidor
  @event_listeners = event_listeners
  @monitoring = Monitoramento
  @opções = opções.congelar
  @mutex = Mutex.Novo
  @sdam_mutex = Mutex.Novo
  @next_earlyest_scan = @next_Quered_scan = Hora.agora
  @update_mutex = Mutex.Novo
  # Protege leituras e gravações de @connection para que a conexão de pesquisa possa
  # ser cancelado de outro thread. De acordo com a especificação de monitoramento do servidor,
  # pseudocódigo cancelCheck, o bloqueio é mantido apenas o tempo suficiente para copiar ou
  # atribua a referência - nunca através da verificação de bloqueio.
  @connection_lock = Mutex.Novo
end

Detalhes do atributo da instância

#Monitoring ➤ Monitoramento (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.

Monitoramento de retornos O monitoramento.

Retorna:

Desde:

  • 2.0.0



127
128
129
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 127

def Monitoramento
  @monitoring
end

#opções ➤ Hash (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 opções As opções do servidor .

Retorna:

  • (Hash) —

    options As opções do servidor .

Desde:

  • 2.0.0



108
109
110
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 108

def opções
  @opções
end

#servidor ➤ Servidor (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 servidor O servidor que este monitor está monitorando.

Retorna:

  • (Servidor MongoDB) —

    servidor O servidor que este monitor está monitorando.

Desde:

  • 2.0.0



98
99
100
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 98

def Servidor
  @server
end

Detalhes do método de instância

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

Cancele a verificação em andamento e feche a conexão de monitoramento.

Chamado quando o servidor é marcado como Desconhecido devido a um erro de rede, de acordo com a especificação de monitoramento do servidor ("hello ou cancelamento de hello legado"). Interrompe o PushMonitor de streaming (interrompendo sua leitura de hello aguardada) e fecha a conexão de pesquisa, de modo que a próxima verificação deve estabelecer uma nova em vez de revalidar o servidor em um soquete possivelmente inativo.

Desde:

  • 2.0.0



210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 210

def cancel_check!
  stop_push_monitor!

  # Copie a referência de conexão sob o bloqueio e, em seguida, interrompa e feche
  # fora do bloqueio. Fechar o socket interrompe qualquer processo em andamento
  # ler no tópico do monitorar; nil-ing a referência força o próximo
  # verificar para reconectar. O thread do monitorar é o único gravador de um novo
  # connection, portanto, é seguro para este thread limpá-lo.
  Conexão = @connection_lock.sincronizar fazer
    conn = @connection
    @connection = nada
    conn
  end
  Conexão&.desconecte-se!
end

#conexão ⇒ Mongo::servidor::monitorar::Connection | 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.

Retorna A conexão a ser usada, lida em @connection_lock para que os chamadores nunca observem uma referência obsoleta após um cancel_check! simultâneo limpa-o.

Retorna:

  • (Mongo::servidor::monitorar::Connection | nil) —

    A conexão a ser usada, lida em @connection_lock para que os chamadores nunca observem uma referência obsoleta após um cancel_check! limpa-o.

Desde:

  • 2.0.0



103
104
105
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 103

def Conexão
  @connection_lock.sincronizar { @connection }
end

#create_push_monitor!(topology_version, connection) ⇒ 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.

Parâmetros:

  • Conexão (Mongo::Servidor::Monitor::Conexão) —

    A conexão de monitoramento recém-estabelecida. Passado explicitamente (em vez de lido em @connection) para que um cancel_check! simultâneo não possa anulá-lo entre estabelecê-lo e construir o PushMonitor.

Desde:

  • 2.0.0



175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 175

def create_push_monitor!(topology_version, Conexão)
  @update_mutex.sincronizar fazer
    @push_monitor = nada se @push_monitor && !@push_monitor.executando?

    @push_monitor ||= PushMonitor.Novo(
      auto,
      topology_version,
      Monitoramento,
      **Utilidades.raso_symbolize_keys(opções.mesclar(
                                       socket_timeout: heartbeat_interval + Conexão.socket_timeout,
                                       app_metadata: opções[:push_monitor_app_metadata],
                                       check_document: Conexão.check_document
                                     ))
    )
  end
end

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

Execute uma verificação do servidor.

Desde:

  • 2.0.0



140
141
142
143
144
145
146
147
148
149
150
151
152
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 140

def do_work
  digitalizar!
  # @next_Quered_scan pode ser atualizado pelo monitor de push.
  # No entanto, precisamos verificar se há sinalizador de encerramento para que o monitor
  # thread é encerrado quando solicitado.
  loop fazer
    delta, delta = @next_Quered_scan - Hora.agora
    intervalo a menos que delta, delta > 0

    sinalizado = Servidor.varredura_semafore.esperar(delta, delta)
    intervalo se sinalizado || @stop_requested
  end
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.

O intervalo entre verificações regulares do servidor .

Retorna:

  • (Flutuante) —

    O intervalo de pulsação, em segundos.

Desde:

  • 2.0.0



113
114
115
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 113

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

#push_monitor ➤ Servidor::PushMonitor | nada

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

Retorna o monitor de push, se houver um sendo usado.

Retorna:

Desde:

  • 2.0.0



131
132
133
134
135
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 131

def push_monitor
  @update_mutex.sincronizar fazer
    @push_monitor
  end
end

#reiniciar! ➤ Thread

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.

Reinicia o monitor do servidor , a menos que o thread atual esteja vivo.

Exemplos:

Reinicie o monitor.

monitor.restart!

Retorna:

  • (Thread) —

    O thread em que o monitor é executado.

Desde:

  • 2.1.0



308
309
310
311
312
313
314
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 308

def reinicie!
  se @thread && @thread.alive?
    @thread
  mais
    corra!
  end
end

#run_sdam_flow(result, awaited: false, scan_error: nil, rtt_only: false) ⇒ 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



268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 268

def run_sdam_flow(Resultado, esperado: false, varredura_error: nada, rtt_only: false)
  @sdam_mutex.sincronizar fazer
    old_description = Servidor.Descrição

    # Uma medição somente RTT (protocolo de streaming ativo) não deve ser atualizada
    # a topologia ou publicar eventos SDAM. O RTT que ele coletou é
    # incorporado à próxima descrição de streaming-hello via
    # calculadora RTT compartilhada. O agendar abaixo ainda é executado, então o
    # monitorar continua ritmando suas verificações.
    a menos que rtt_only
      new_description = Descrição.Novo(
        Servidor.endereço,
        Resultado,
        average_round_trip_time: Servidor.round_trip_time_calculator.average_round_trip_time,
        minimum_round_trip_time: Servidor.round_trip_time_calculator.minimum_round_trip_time
      )
      Servidor.cluster.run_sdam_flow(Servidor.Descrição, new_description, esperado: esperado, varredura_error: varredura_error)
    end

    Servidor.Descrição.toque fazer |new_description|
      a menos que esperado
        se new_description.desconhecido? && !old_description.desconhecido?
          @next_earlyest_scan = @next_Quered_scan = Hora.agora
        mais
          @next_earlyest_scan = Hora.agora + MIN_SCAN_INTERVAL
          @next_Quered_scan = Hora.agora + heartbeat_interval
        end
      end
    end
  end
end

#scan! ➤ Descrição

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:

Se o relógio do sistema se mover para trás, esse método poderá adormecido por um longo tempo.

Observação:

O valor de retorno deste método é preterido. Na versão 3.0.0 , este método não terá um valor de retorno.

Execute uma verificação do servidor com limitação e atualize a descrição do servidor e o tempo médio de ida e volta.

Se o servidor foi verificado há menos de MIN_SCAN_INTERVAL segundos, durma até que MIN_SCAN_INTERVAL segundos tenham se passado desde a última verificação. Em seguida, execute a verificação que envolve executar hello no servidor que está sendo monitorado e atualizar a descrição do servidor como resultado.

Retorna:

Desde:

  • 2.0.0



244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 244

def digitalizar!
  # Normalmente, o thread do background invocaria esse método.
  # Mas também é possível invocar varredura! diretamente em um monitor.
  # Permitir que apenas uma verificação seja realizada de cada vez.
  @mutex.sincronizar fazer
    acelerador_scan_frequency!

    # Quando o protocolo de streaming está ativo, o PushMonitor é o
    # fonte SDAM autoritativa e esta varredura só mede RTT no
    # conexão dedicada. De acordo com a especificação de monitoramento do servidor, um RTT
    # o comando NÃO DEVE publicar eventos ou atualizar a topologia. Computar
    # isso antes de do_scan, que pode (re)conectar e alterar o estado.
    rtt_only = rtt_measurement_only?

    começar
      Resultado = do_scan(publish_heartbeat: !rtt_only)
    salvar StandardError => e
      run_sdam_flow({}, varredura_error: e, rtt_only: rtt_only)
    mais
      run_sdam_flow(Resultado, rtt_only: rtt_only)
    end
  end
end

#pare! ➤ verdadeiro | false

Interrompa o thread em background e aguarde até que ele encerre por um período de tempo razoável.

Retorna:

  • (verdadeiro | falso) —

    Se a conversa foi encerrada.

Desde:

  • 2.0.0



160
161
162
163
164
165
166
167
168
169
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 160

def pare!
  stop_push_monitor!

  # Encaminhar valor de retorno de super
  super.toque fazer
    # Importante: a desconexão deve ocorrer após a thread no background
    # termina.
    Conexão&.desconecte-se!
  end
end

#stop_push_monitor! ➤ 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



192
193
194
195
196
197
198
199
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 192

def stop_push_monitor!
  @update_mutex.sincronizar fazer
    se @push_monitor
      @push_monitor.pare!
      @push_monitor = nada
    end
  end
end

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



316
317
318
 
# Arquivo 'lib/mongo/ servidor/monitor.rb', linha 316

def to_s
  "#<#{self.classe.name}:#{object_id} #{servidor.endereço}>"
end