Classe: Mongo::Cluster::CursorReaper Privado

Herda:
Objeto
  • Objeto
mostrar tudo
Inclui:
Repetitivo
Definido em:
build/ruby-driver-v2.19/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.congelar

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



42
43
44
45
46
47
48
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster/reapers/cursor_reaper.rb', linha 42

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



50
51
52
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster/reapers/cursor_reaper.rb', linha 50

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



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
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster/reapers/cursor_reaper.rb', linha 133

def kill_cursors
  # TODO otimizar 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
      # TODO Atualmente, não temos um servidor para o endereço que o
      # cursor está associado. Devemos deixar o cursor no
      # fila a ser eliminada posteriormente (quando o servidor voltar).
      próximo
    end

    opções = {
      server_api: Servidor.opções[:server_api],
      connection_global_id: kill_spec.connection_global_id,
    }
    op.executar, executar(Servidor, contexto: (operação)::Contexto.Novo(opções: opções))

    se session = kill_spec.session
      se session.implícito?
        session.end_session
      end
    end
  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 altera variáveis de instância sem bloqueio, portanto, não é seguro para thread. Geralmente, ele não deve ser chamado a si mesmo, é um auxiliar para o método 'kill_cursor'.

Desde:

  • 2.3.0



114
115
116
117
118
119
120
121
122
123
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster/reapers/cursor_reaper.rb', linha 114

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

Desde:

  • 2.3.0



71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster/reapers/cursor_reaper.rb', linha 71

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

  @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



57
58
59
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster/reapers/cursor_reaper.rb', linha 57

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.

Desde:

  • 2.3.0



94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'build/ruby-driver-v2.19/lib/mongo/cluster/reapers/cursor_reaper.rb', linha 94

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

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