Classe: Mongo::Cluster::CursorReaper Privado

Herda:
Objeto
  • Objeto
mostrar tudo
Inclui:
Repetitivo
Definido em:
lib/mongo/cluster/reapers/cursor_reaper.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.

Um gerenciador que envia operações de cursores de eliminação em intervalos regulares para fechar cursores que foram coletados sem esgotamento.

Desde:

  • 2.3.0

Colapsode resumo constante

FREQUENCY =

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 de tempo padrão para o reaper do cursor enviar operações de cursor de eliminação pendentes.

Desde:

  • 2.3.0

1

Recolhimento do Resumo do atributo de instância

Recolhimento do Resumo do método de instância

Métodos incluídos no Retryable

#read_worker, #select_server, #with_overload_retry, #write_worker

Detalhes do construtor

#initialize(cluster) ➤ CursorReaper

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.

Crie um reaper de cursor.

Parâmetros:

Desde:

  • 2.3.0



39
40
41
42
43
44
45
 
# File 'lib/mongo/cluster/reapers/cursor_reaper.rb', linha 39

def inicializar(cluster)
  @cluster = cluster
  @to_kill = {}
  @active_cursor_ids = definir.Novo
  @mutex = Mutex.Novo
  @kill_spec_queue = Fila.Novo
end

Detalhes do atributo da instância

#cluster ➤ 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.3.0



47
48
49
 
# File 'lib/mongo/cluster/reapers/cursor_reaper.rb', linha 47

def cluster
  @cluster
end

Detalhes do método de instância

#kill_cursors ➤ Objeto Também conhecido como: execute, flush

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 todas as operações de cursores de eliminação pendentes.

Exemplos:

Execute operações pendentes de cursores de eliminação.

cursor_reaper.kill_cursors

Desde:

  • 2.3.0



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
 
# File 'lib/mongo/cluster/reapers/cursor_reaper.rb', linha 126

def kill_cursors
  # TODO: otimize isso para operações de cursor de kill em lote para o mesmo
  # servidor/ banco de dados de dados/coleção em vez de matar cada cursor
  # individualmente.
  loop fazer
    server_address = nada

    kill_spec = @mutex.sincronizar fazer
      read_scheduled_kill_specs
      # Encontre um servidor que tenha algum cursor programado para destruição.
      server_address, especificações =
        @to_kill.detectar { |_, especificações| especificações.algum? }

      se especificações.nada?
        # Todos os servidores têm especificações vazias, nada para fazer.
        Método
      end

      # Observe que isso altera a especificação na fila.
      # Se a operação do cursor de eliminação falhar, não tentaremos
      # mata esse cursor novamente.
      especificações = especificações.levar(1).toque fazer |arre|
        especificações.subtrair(arre)
      end.primeiro

      a menos que @active_cursor_ids.incluir?(especificações.cursor_id)
        # O cursor já foi eliminado, normalmente porque tem
        # foi iterado para conclusão. Remova a especificação de eliminação de
        # nossos registros sem fazer mais nenhum trabalho.
        especificações = nada
      end

      especificações
    end

    # Se houver uma especificação para eliminar, mas seu cursor já tiver sido eliminado,
    # procure outra especificação.
    próximo a menos que kill_spec

    # Também podemos passar kill_spec diretamente para os KillCursors
    # operação, embora isso faça com que essa operação tenha um
    # API diferente de todas as outras que aceitam hashes.
    especificações = {
      cursor_ids: [ kill_spec.cursor_id ],
      coll_name: kill_spec.coll_name,
      db_name: kill_spec.db_name,
    }
    op = (operação)::matarCursores.Novo(especificações)

    Servidor = cluster.Servidores.detectar fazer |Servidor|
      Servidor.endereço == server_address
    end

    a menos que Servidor
      # O servidor deste cursor foi embora — talvez temporariamente,
      # talvez permanentemente, mas não podemos saber. Para evitar que conexões
      # vazando no caso de uma falha permanente, vamos apenas silenciosamente
      # solte este killspec e siga em frente.
      próximo
    end

    opções = {
      server_api: Servidor.opções[:server_api],
      connection_global_id: kill_spec.connection_global_id,
    }
    se Conexão = kill_spec.Conexão
      op.execute_with_connection(Conexão, contexto: (operação)::Contexto.Novo(opções: opções))
      Conexão.connection_pool.check_in(Conexão)
    mais
      op.executar, executar(Servidor, contexto: (operação)::Contexto.Novo(opções: opções))
    end

    próximo a menos que session = kill_spec.session

    session.end_session se session.implícito?
  end
end

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

Ler e decodificar operações programadas de cursores de eliminação.

Esse método muta variáveis de instância sem travar, portanto, não é seguro para threads. Geralmente, não deve ser chamado a si mesmo, este é um assistente para o método kill_cursor.

Desde:

  • 2.3.0



103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/mongo/cluster/reapers/cursor_reaper.rb', linha 103

def read_scheduled_kill_specs
  enquanto kill_spec = @kill_spec_queue.Pop(true)
    se @active_cursor_ids.incluir?(kill_spec.cursor_id)
      @to_kill[kill_spec.server_address] ||= definir.Novo
      @to_kill[kill_spec.server_address] << kill_spec
    elsif (session = kill_spec.session) && session.implícito?
      # O cursor já estava fechado; encerre a sessão imediatamente para liberar
      # referências em vez de esperar que o kill_spec saia do escopo.
      session.end_session
    end
  end
salvar ThreadError
  # Fila vazia, nada para fazer.
end

#registrar_cursor(ID) ➤ 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.

Registre um ID de cursor como ativo.

Exemplos:

Registre um cursor como ativo.

cursor_reaper.register_cursor(id)

Parâmetros:

  • id (Inteiro) —

    A ID do cursor a ser registrado como ativo.

Aumenta:

  • (ArgumentError)

Desde:

  • 2.3.0



68
69
70
71
72
73
74
75
 
# File 'lib/mongo/cluster/reapers/cursor_reaper.rb', linha 68

def register_cursor(id)
  aumentar ArgumentError, 'registrar_cursor chamado com cursor_id nulo' se id.nada?
  aumentar ArgumentError, 'registrar_cursor chamado com cursor_id=0' se id == 0

  @mutex.sincronizar fazer
    @active_cursor_ids << id
  end
end

#scheduled_kill_cursor(kill_spec) ➤ 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.

Agende uma operação de eliminação de cursores para ser executada eventualmente.

Parâmetros:

Desde:

  • 2.3.0



54
55
56
 
# File 'lib/mongo/cluster/reapers/cursor_reaper.rb', linha 54

def agendamento_kill_cursor(kill_spec)
  @kill_spec_queue << kill_spec
end

#unregister_cursor(id) ⇒ 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 o registro de um ID de cursor, indicando que ele não está mais ativo.

Exemplos:

Unregister a cursor.

cursor_reaper.unregister_cursor(id)

Parâmetros:

  • id (Inteiro) —

    A ID do cursor para cancelar o registro.

Aumenta:

  • (ArgumentError)

Desde:

  • 2.3.0



87
88
89
90
91
92
93
94
 
# File 'lib/mongo/cluster/reapers/cursor_reaper.rb', linha 87

def unregister_cursor(id)
  aumentar ArgumentError, 'unregister_cursor chamado com cursor_id nulo' se id.nada?
  aumentar ArgumentError, 'unregister_cursor chamado com cursor_id=0' se id == 0

  @mutex.sincronizar fazer
    @active_cursor_ids.excluir(id)
  end
end