Classe: Mongo::ServerSelector::Base

Herda:
Objeto
  • Objeto
mostrar tudo
Definido em:
lib/mongo/server_selector/base.rb

Visão geral

Desde:

  • 2.0.0

Recolhimento do Resumo do atributo de instância

Recolhimento do Resumo do método de instância

Detalhes do construtor

#initialize(options = nil) ⇒ Base

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.

Inicialize o seletor de servidor.

Exemplos:

Inicialize o seletor.

Mongo::ServerSelector::Secondary.new(:tag_sets => [{'dc' => 'nyc'}])

Inicialize a preferência sem opções.

Mongo::ServerSelector::Secondary.new

Parâmetros:

  • opções (Hash) (padrão para: nil) —

    As opções de preferência do servidor .

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

  • :local_threshold (Inteiro) —

    O limite local para a seleção mais próxima em segundos.

  • :max_staleness (Inteiro) —

    O atraso máximo de replicação, em segundos, que um secundário pode sofrer e ainda ser elegível para uma leitura. Um valor de -1 é tratado de forma idêntica a nil, que é não ter uma obsolescência máxima.

  • :hedge (Hash | nulo) —

    Um Hash especificando se as leituras distribuídas devem ser ativadas no servidor. As leituras distribuídas não estão habilitadas por padrão. Ao especificar esta opção, ela deve estar no formato: { habilitado: true }, onde o valor da chave :enabled é um valor booleano.

Aumenta:

Desde:

  • 2.0.0



45
46
47
48
49
50
51
52
53
54
 
# Arquivo 'lib/mongo/server_selector/base.rb', linha 45

def inicializar(opções = nada)
  opções = opções ? opções.dup : {}
  opções.excluir(:max_staleness) se opções[:max_staleness] == -1
  @opções = opções
  @tag_sets = opções[:tag_sets] || []
  @max_staleness = opções[:max_staleness]
  @hedge = opções[:hedge]

  validar!
end

Detalhes do atributo da instância

#hedge ➤ Hash | nil (somente leitura)

Retorna hedge O documento que especifica se deve permitir leituras com hedge.

Retorna:

  • (Hash | nulo) —

    hedge O documento que especifica se deseja habilitar leituras com hedge.

Desde:

  • 2.0.0



70
71
72
 
# Arquivo 'lib/mongo/server_selector/base.rb', linha 70

def sebe
  @hedge
end

#max_staleness ➤ inteiro (somente leitura)

Retorna max_staleness O atraso de replicação, em segundos, que um secundário pode sofrer e ainda ser elegível para uma leitura.

Retorna:

  • (Inteiro) —

    max_staleness O atraso máximo de replicação, em segundos, que um secundário pode sofrer e ainda ser elegível para uma leitura.

Desde:

  • 2.4.0



66
67
68
 
# Arquivo 'lib/mongo/server_selector/base.rb', linha 66

def max_staleness
  @max_staleness
end

#opções ➤ Hash (somente leitura)

Retorna as opções As opções.

Retorna:

  • (Hash) —

    opções As opções.

Desde:

  • 2.0.0



57
58
59
 
# Arquivo 'lib/mongo/server_selector/base.rb', linha 57

def opções
  @opções
end

#tag_sets ➤ Array (somente leitura)

Retorna tag_sets Os conjuntos de tags usados para selecionar servidores.

Retorna:

  • (Array) —

    tag_sets Os conjuntos de tags usados para selecionar servidores.

Desde:

  • 2.0.0



60
61
62
 
# Arquivo 'lib/mongo/server_selector/base.rb', linha 60

def tag_sets
  @tag_sets
end

Detalhes do método de instância

#==(outro) ➤ true, false

Verifique a igualdade de dois seletores de servidor .

Exemplos:

Verifique a igualdade do seletor de servidor .

preference == other

Parâmetros:

  • Outro (Objeto) —

    A outra preferência.

Retorna:

  • (verdadeiro, falso) —

    Se os objetos são iguais.

Desde:

  • 2.0.0



130
131
132
133
 
# Arquivo 'lib/mongo/server_selector/base.rb', linha 130

def ==(Outro)
  name == Outro.name && sebe == Outro.sebe &&
    max_staleness == Outro.max_staleness && tag_sets == Outro.tag_sets
end

#candidatos(cluster, despriorizado = []) ➤ Array

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 servidores de tipos aceitáveis do cluster.

Não executa validação de obsolescência, filtragem de obsolescência ou filtragem de latência.

Parâmetros:

  • cluster (Cluster) —

    O cluster.

  • despriorizado (Array) (padrão para: []) —

    Uma lista de servidores que devem ser selecionados somente se nenhum outro servidor estiver disponível.

Retorna:

Desde:

  • 2.0.0



386
387
388
389
390
391
392
393
394
395
396
397
398
 
# Arquivo 'lib/mongo/server_selector/base.rb', linha 386

def candidatos(cluster, despriorizado = [])
  Servidores = cluster.Servidores.rejeitar { |s| despriorizado.incluir?(s) }
  se cluster.único?
    Servidores
  elsif cluster.fragmentado?
    Servidores
  elsif cluster.replica_set?
    select_in_replica_set(Servidores)
  mais
    # Cluster desconhecido - sem servidores
    []
  end
end

#inspecionar ➤ string

Inspecione o seletor de servidor.

Exemplos:

Inspecione o seletor de servidor.

selector.inspect

Retorna:

  • (string) —

    A inspeção.

Desde:

  • 2.2.0



116
117
118
 
# Arquivo 'lib/mongo/server_selector/base.rb', linha 116

def inspecionar
  "#<#{self.class.name}:0x#{object_id} tag_sets=#{tag_sets.inspect} max_staleness=#{max_staleness.inspect} hedge=#{hedge}>"
end

#local_threshold ➤ Flutuante

Obsoleto.

Essa configuração agora é retirada das opções de cluster quando um servidor é selecionado. Será removido na versão 3.0.

Obtenha o limite local para a seleção mais próxima em segundos.

Exemplos:

Obtenha o limite local.

selector.local_threshold

Retorna:

  • (Flutuante) —

    O limite local.

Desde:

  • 2.0.0



99
100
101
 
# Arquivo 'lib/mongo/server_selector/base.rb', linha 99

def local_threshold
  @local_threshold ||= opções[:local_threshold] || ServerSelector::Local_threshold
end

#local_threshold_with_cluster(cluster) ➤ 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



104
105
106
 
# Arquivo 'lib/mongo/server_selector/base.rb', linha 104

def local_threshold_with_cluster(cluster)
  opções[:local_threshold] || cluster.opções[:local_threshold] || Local_threshold
end

#select_server(cluster, ping = nil, session = nil, write_aggregation: false, depriorized: [], timeout: nil) ➤ Mongo::Server

Selecione um servidor no cluster especificado, levando em conta a fixação do mongos para a sessão especificada.

Se a sessão for fornecida e tiver um servidor fixado, esse servidor será o único servidor considerado para seleção. Se o servidor for do tipo mongos, ele será retornado imediatamente; caso contrário, as verificações de monitoramento nesse servidor são iniciadas para atualizar seu status e, se o servidor se tornar um mongos dentro do tempo limite de seleção do servidor , ele será retornado.

Se nenhuma sessão for fornecida ou se a sessão não tiver um servidor fixado , o processo normal de seleção de servidor será executado entre todos os servidores no cluster especificado que corresponderem à preferência desse objeto seletor de servidor . As verificações de monitoramento são iniciadas nos servidores do cluster até que um servidor adequado seja encontrado, até o tempo limite de seleção do servidor .

Se um servidor adequado não for encontrado dentro do tempo limite de seleção do servidor, esse método gerará o Erro::NoServerAvailable.

Parâmetros:

  • cluster (Mongo::Cluster) —

    O cluster do qual selecionar um servidor qualificado .

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

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

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

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

  • write_aggregation (verdadeiro | falso) (padrão para: false) —

    Se precisamos de um servidor que suporte agregações de gravação (por exemplo, com $merge/$out) em secundários.

  • despriorizado (Array) (padrão para: []) —

    Uma lista de servidores que devem ser selecionados somente se nenhum outro servidor estiver disponível.

  • :timeout (Flutuante | nulo) —

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

Retorna:

  • (Mongo::Server) —

    Um servidor que corresponda à preferência do servidor .

Aumenta:

  • (Erro::NoServerAvailable) —

    Nenhum servidor foi encontrado que corresponda ao requisito de preferência/fixação especificado no tempo limite de seleção do servidor.

  • (Error::LintError) —

    Uma condição inesperada foi detectada e o modo lint está habilitado.

Desde:

  • 2.0.0



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

def select_server(
  cluster,
  Ping = nada,
  session = nada,
  write_aggregation: false,
  despriorizado: [],
  timeout: nada
)
  select_server_impl(cluster, Ping, session, write_aggregation, despriorizado, timeout).toque fazer |Servidor|
    se Lint.habilitado? && !Servidor.pool.pronto?
      aumentar Erro::LintError, 'O seletor de servidor retorna um servidor com um pool que não está pronto'
    end
  end
end

#server_selection_timeout ➤ Flutuante

Obsoleto.

Essa configuração agora é retirada das opções de cluster quando um servidor é selecionado. Será removido na versão 3.0.

Obtenha o tempo limite para a seleção do servidor .

Exemplos:

Obtenha o tempo limite de seleção do servidor, em segundos.

selector.server_selection_timeout

Retorna:

  • (Flutuante) —

    O tempo limite.

Desde:

  • 2.0.0



83
84
85
86
 
# Arquivo 'lib/mongo/server_selector/base.rb', linha 83

def server_selection_timeout
  @server_selection_timeout ||=
    opções[:server_selection_timeout] || ServerSelector::SERVER_SELECTION_TIMEOUT
end

#adequado_servers(cluster, depriorized = []) ➤ Array

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 servidores que satisfazem o seletor de servidor do cluster.

Parâmetros:

  • cluster (Cluster) —

    O cluster.

  • despriorizado (Array) (padrão para: []) —

    Uma lista de servidores que devem ser selecionados somente se nenhum outro servidor estiver disponível.

Retorna:

Desde:

  • 2.0.0



409
410
411
412
413
 
# Arquivo 'lib/mongo/server_selector/base.rb', linha 409

def adequado_servidores(cluster, despriorizado = [])
  Resultado = adequado_servers_impl(cluster, despriorizado)
  Resultado = adequado_servers_impl(cluster, []) se Resultado.vazio? && despriorizado.algum?
  Resultado
end

#try_select_server(cluster, write_aggregation: false, despriorizado: []) ➤ ➤ Servidor | 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.

Tenta encontrar um servidor adequado , retorna o servidor se houver um disponível ou nulo se não houver um servidor adequado .

Parâmetros:

  • cluster (Mongo::Cluster) —

    O cluster do qual selecionar um servidor qualificado .

  • write_aggregation (verdadeiro | falso) (padrão para: false) —

    Se precisamos de um servidor que suporte agregações de gravação (por exemplo, com $merge/$out) em secundários.

  • despriorizado (Array) (padrão para: []) —

    Uma lista de servidores que devem ser selecionados somente se nenhum outro servidor estiver disponível. Isso é usado para evitar selecionar o mesmo servidor duas vezes seguidas ao tentar novamente um comando.

Retorna:

Desde:

  • 2.0.0



337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
 
# Arquivo 'lib/mongo/server_selector/base.rb', linha 337

def try_select_server(cluster, write_aggregation: false, despriorizado: [])
  Servidores = se write_aggregation && cluster.replica_set?
              # 1. Verifique se todos os servidores no cluster oferecem suporte a gravações secundárias.
              is_write_supported = cluster.Servidores.reduzir(true) fazer |res, Servidor|
                res && Servidor.características.mesclar_out_on_secondary_enabled?
              end

              se is_write_supported
                # 2. Se todos os servidores permitirem gravações secundárias, respeitaremos a preferência de leitura.
                adequado_servidores(cluster, despriorizado)
              mais
                # 3. Caso contrário, voltamos ao primário para o conjunto de réplicas.
                [ cluster.Servidores.detectar(&:primary?) ]
              end
            mais
              adequado_servidores(cluster, despriorizado)
            end

  # Esta lista de servidores pode ser ordenada de forma específica
  # pelo seletor (por exemplo, para preferencial secundário, o primeiro
  #servidor pode ser secundário e o segundo servidor pode ser primário)
  # e devemos pegar o primeiro servidor aqui respeitando a ordem
  Servidor = adequado_server(Servidores)

  se Servidor && Lint.habilitado? && Servidor.average_round_trip_time.nada?
    # É possível para um servidor ter um RTT médio nulo aqui
    # porque o artt vem da descrição que pode ser atualizada
    # por um thread em background enquanto a seleção do servidor está em execução.
    # Atualmente, o modo lint não é um recurso público, se/quando isso
    # de alterações (https://jira.mongodb.org/browse/RUBY-{01576) o
    # requisito para que oARTT não seja nulo precisaria ser removido.
    aumentar Erro::LintError, "Servidor MongoDB #{server.endereço} tem nil average rtt"
  end

  Servidor
end