Clase: Mongo::clúster::CursorReaper Privado

Hereda:
Objeto
  • Objeto
Mostrar todo
Incluye:
Reintentar
Definido en:
lib/mongo/clúster/reapers/cursor_reaper.rb

Overview

Esta clase forma parte de una API privada. Evita usar esta clase si es posible, ya que puede ser eliminada o modificada en el futuro.

Un administrador que envía operaciones de kill cursor a intervalos regulares para cerrar los cursores que han sido recolectados como basura sin agotarse.

Desde:

  • 2.3.0

Resumen de constantes colapsar

FRECUENCIA =

Esta constante es parte de una API privada. Deberías evitar usar esta constante si es posible, ya que podría ser retirada o cambiada en el futuro.

El intervalo de tiempo por defecto para que el limpiador de cursor envíe operaciones pendientes para terminar cursores.

Desde:

  • 2.3.0

1

Resumen de atributos de la instancia colapsar

Resumen del método de instancia colapsar

Métodos incluidos de Retryable

#read_worker, #select_server, #with_overload_retry, #write_worker

Detalles del Constructor

#initialize(cluster) ⇒ CursorReaper

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Crea un recolector de cursor.

Parámetros:

Desde:

  • 2.3.0



39
40
41
42
43
44
45
 
# Archivo 'lib/mongo/cluster/reapers/cursor_reaper.rb', línea 39

def inicializar(clúster)
  @cluster = clúster
  @to_kill = {}
  @active_cursor_ids = Configura.Nuevo
  @mutex = Mutex (exclusión mutua).Nuevo
  @kill_spec_queue = Queue.Nuevo
end

Detalles de atributo de instancias

#clúster ⇒ Objeto (solo lectura)

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Desde:

  • 2.3.0



47
48
49
 
# Archivo 'lib/mongo/cluster/reapers/cursor_reaper.rb', línea 47

def clúster
  @cluster
end

Detalles del método de instancia

#kill_cursors ⇒ objeto También conocido como: execute, flush

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Ejecutar todas las operaciones pendientes de cierre de cursores.

Ejemplos:

Ejecuta las operaciones pendientes para terminar los cursores.

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
 
# Archivo 'lib/mongo/cluster/reapers/cursor_reaper.rb', línea 126

def kill_cursors
  # TODO: optimizar esto para operaciones batch kill cursor para el mismo
  # servidor/base de datos/colección en lugar de terminar cada cursor
  # individualmente.
  bucle hacer
    server_address = nulo

    kill_spec = @mutex.sincronizar hacer
      read_scheduled_kill_specs
      # Encuentra un servidor que tenga cualquier cursor programado para destrucción.
      server_address, especificaciones =
        @to_kill.detectar { |_, especificaciones| especificaciones.any? }

      si especificaciones.nil?
        # Todos los servidores tienen especificaciones vacías, nada que hacer.
        return
      end

      # Ten en cuenta que esto muta el spec en la cola.
      # Si la operación kill cursor falla, no intentamos
      # mata ese cursor de nuevo.
      especificación = especificaciones.tomar(1).tocar hacer |arr|
        especificaciones.sustraer(arr)
      end.primero

      a menos que @active_cursor_ids.incluir?(especificación.cursor_id)
        # El cursor ya se ha eliminado, generalmente porque ha
        # se ha iterado hasta completarse. Remover la especificación kill de
        # nuestros registros sin realizar ningún trabajo adicional.
        especificación = nulo
      end

      especificación
    end

    # Si había una especificación a eliminar pero ya se había eliminado su cursor,
    # busca otra especificación.
    Next a menos que kill_spec

    # También podríamos pasar kill_spec directamente a KillCursors
    # operación, aunque esto haría que dicha operación tenga un
    # API diferente a todas las demás que aceptan hashes.
    especificación = {
      cursor_ids: [ kill_spec.cursor_id ],
      coll_name: kill_spec.coll_name,
      db_name: kill_spec.db_name,
    }
    op = Operación::killCursors.Nuevo(especificación)

    Server = clúster.servidor.detectar hacer |Server|
      Server.dirección == server_address
    end

    a menos que Server
      # El servidor para este cursor se ha desconectado --- quizás temporalmente,
      # tal vez permanentemente, pero no lo podemos saber. Para evitar conexiones desde
      # fuga en caso de una falla permanente, simplemente lo haremos en silencio
      # descarta esta especificación de eliminación y sigue adelante.
      Next
    end

    opciones = {
      server_api: Server.opciones[API del servidor],
      connection_global_id: kill_spec.connection_global_id,
    }
    si Conexión = kill_spec.Conexión
      op.execute_with_connection(Conexión, context: Operación::Context.Nuevo(opciones: opciones))
      Conexión.connection_pool.registrar(Conexión)
    else
      op.ejecutar(Server, context: Operación::Context.Nuevo(opciones: opciones))
    end

    Next a menos que sesión = kill_spec.sesión

    sesión.end_session si sesión.implicit?
  end
end

#read_scheduled_kill_specs ⇒ objeto

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Leer y decodificar las operaciones de cierre de cursores programadas.

Este método manipula variables de instancia sin bloqueo, por lo que no es seguro para hilos. En general, no debería llamarse a sí mismo, esto es un asistente para el método kill_cursor.

Desde:

  • 2.3.0



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

def read_scheduled_kill_specs
  mientras kill_spec = @kill_spec_queue.pop(true)
    si @active_cursor_ids.incluir?(kill_spec.cursor_id)
      @to_kill[kill_spec.server_address] ||= Configura.Nuevo
      @to_kill[kill_spec.server_address] << kill_spec
    elsif (sesión = kill_spec.sesión) && sesión.implicit?
      # El cursor ya estaba cerrado; terminar la sesión inmediatamente para liberar
      # referencias en lugar de esperar que kill_spec quede fuera de alcance.
      sesión.end_session
    end
  end
rescate ErrorDeHilo
  # Cola vacía, nada que hacer.
end

#register_cursor(id) ⇒ objeto

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Registrar un ID de cursor como activo.

Ejemplos:

Registra un cursor como activo.

cursor_reaper.register_cursor(id)

Parámetros:

  • ID (Número entero) —

    El id del cursor que se registrará como activo.

Aumenta:

  • (ArgumentError)

Desde:

  • 2.3.0



68
69
70
71
72
73
74
75
 
# Archivo 'lib/mongo/cluster/reapers/cursor_reaper.rb', línea 68

def register_cursor(ID)
  propagar ArgumentError, 'register_cursor llamado con cursor_id nulo' si ID.nil?
  propagar ArgumentError, 'register_cursor llamado con cursor_id=0' si ID == 0

  @mutex.sincronizar hacer
    @active_cursor_ids << ID
  end
end

#schedule_kill_cursor(kill_spec) ⇒ Object

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Programar una operación de kill cursors para que se ejecute eventualmente.

Parámetros:

Desde:

  • 2.3.0



54
55
56
 
# Archivo 'lib/mongo/cluster/reapers/cursor_reaper.rb', línea 54

def schedule_kill_cursor(kill_spec)
  @kill_spec_queue << kill_spec
end

#unregister_cursor(id) ⇒ Object

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Darse de baja de un id de cursor, indicando que ya no está activo.

Ejemplos:

Unregister a cursor.

cursor_reaper.unregister_cursor(id)

Parámetros:

  • ID (Número entero) —

    El ID del cursor para cancelar el registro.

Aumenta:

  • (ArgumentError)

Desde:

  • 2.3.0



87
88
89
90
91
92
93
94
 
# Archivo 'lib/mongo/cluster/reapers/cursor_reaper.rb', línea 87

def unregister_cursor(ID)
  propagar ArgumentError, 'unregister_cursor se llamó con un cursor_id nulo' si ID.nil?
  propagar ArgumentError, 'unregister_cursor llamado con cursor_id=0' si ID == 0

  @mutex.sincronizar hacer
    @active_cursor_ids.borrar(ID)
  end
end