Clase: Mongo::Cluster

Hereda:
Objeto
  • Objeto
Mostrar todo
Ampliado por:
Reenviable
Incluye:
Mongo::ClusterTime::Consumidor, Evento::Suscriptor, Registrable, Monitoreo::Publicable
Definido en:
lib/mongo/cluster.rb,
lib/mongo/cluster/topology.rb,
lib/mongo/cluster/topology.rb,
lib/mongo/cluster/sdam_flow.rb,
lib/mongo/cluster/topology/base.rb,
lib/mongo/cluster/topology/single.rb,
lib/mongo/cluster/topology/sharded.rb,
lib/mongo/cluster/topology/unknown.rb,
lib/mongo/cluster/periodic_executor.rb,
lib/mongo/cluster/reapers/cursor_reaper.rb,
lib/mongo/cluster/reapers/socket_reaper.rb,
lib/mongo/cluster/topology/load_balanced.rb,
lib/mongo/cluster/topology/no_replica_set_options.rb,
lib/mongo/cluster/topology/replica_set_no_primary.rb,
lib/mongo/cluster/topology/replica_set_with_primary.rb

Overview

Copyright © 2018-2020 MongoDB Inc.

Con licencia Apache, versión 2.0 (la «Licencia»); no puede usar este archivo excepto de conformidad con la Licencia. Puede obtener una copia de la Licencia en

http://www.apache.org/licenses/LICENSE-2.0

Salvo que lo exija la legislación aplicable o se acuerde por escrito, el software distribuido bajo la Licencia se distribuye "TAL CUAL", SIN GARANTÍAS NI CONDICIONES DE NINGÚN TIPO, ni expresas ni implícitas. Consulte la Licencia para conocer el texto específico que rige los permisos y limitaciones de la misma.

Definido en el espacio de nombres

Modules: Topología Clases: CursorReaper, Ejecutor periódico, SdamFlow, SocketReaper

Colapso delresumen constante

MÁXIMO_REINTEGRACIONES_DE_LECTURA =

El número predeterminado de reintentos de lectura heredados.

Desde:

  • 2.1.1

1
MAX_REINTEGRACIONES_DE_ESCRITURA =

El número predeterminado de reintentos de escritura heredados.

Desde:

  • 2.4.2

1
INTERVALO DE REINTENTO DE LECTURA =

El intervalo de reintento de lectura predeterminado, en segundos, cuando se utilizan reintentos de lectura heredados.

Desde:

  • 2.1.1

5
PERIODO DE ESCRITURA INACTIVA EN SEGUNDOS =

Con qué frecuencia un servidor primario inactivo escribe una operación sin efecto en el registro de operaciones.

Desde:

  • 2.4.0

10
CLUSTER_TIME =
Obsoleto.

La clave del tiempo del clúster en las respuestas de los servidores de Mongos.

Desde:

  • 2.5.0

'clusterTime'.freeze

Constantes incluidas desde Loggable

Registrable::PREFIX

Colapso delresumen de atributos de instancia

Atributos incluidos desde Mongo::ClusterTime::Consumer

#cluster_time

Atributos incluidos desde Event::Subscriber

#event_listeners

Colapso delresumen del método de clase

Colapso del resumen del método de instancia

Métodos incluidos desde Mongo::ClusterTime::Consumer

#tiempo_de_avanzado_del_cluster

Métodos incluidos en Loggable

#log_debug, #log_error, #log_fatal, #log_info, #log_warn, #logger

Métodos incluidos desde Event::Subscriber

#suscríbete a

Métodos incluidos en Monitoring::Publishable

#publicar_evento_cmap, #publicar_evento, #publicar_evento_sdam

Detalles del constructor

#inicializar(semillas, monitoreo, opciones = Options::Redacted.new) ⇒ Cluster

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Nota:

Un clúster nunca debe instanciarse directamente fuera de un cliente.

Nota:

Al conectarse a una URI mongodb+srv://, el cliente la expande en una lista de servidores y la pasa al constructor del clúster. Al conectarse a una instancia independiente de mongod, el constructor del clúster recibe la dirección correspondiente como una matriz de una cadena.

Crear una instancia del nuevo clúster.

Ejemplos:

Crear una instancia del clúster.

Mongo::Cluster.new(["127.0.0.1:27017"], monitoring)

Parámetros:

  • semillas (Matriz<String>) —

    Las direcciones de los servidores configurados

  • vigilancia (Monitoreo) —

    El seguimiento.

  • opciones (Hash) (predeterminado: Options::Redacted.new) —

    Opciones. El constructor del cliente envía sus opciones al constructor del clúster, aunque el clúster solo reconoce un subconjunto de las opciones reconocidas por el cliente.

Opciones Hash(opciones):

  • :conexión directa (true | false) —

    Si se conecta directamente a la semilla especificada, omitiendo el descubrimiento de topología. Se debe proporcionar exactamente una semilla.

  • :conectar (Símbolo) —

    Obsoleto: utiliza la opción :direct_connection en lugar de esta opción. El método de conexión a utilizar. Esto obliga al clúster a comportarse de la manera especificada en lugar de autodetectarse. Uno de :direct, :replica_set, :particionado

  • :conjunto de réplicas (Símbolo) —

    El nombre del conjunto de réplicas al que se conectará. Los servidores que no estén en este conjunto serán ignorados.

  • :escanear (true | false) —

    Si se deben analizar todas las semillas en el constructor. La versión del 2 controlador.x lo hace por defecto; la 3 versión.x no analizará las semillas en el constructor. Para activar el nuevo comportamiento, configure esta opción como "false". Nota: Si configura esta opción como "nil", se habilitará el análisis de semillas en el constructor en la 2 versión.x. La 3 versión.x reconocerá esta opción, pero la ignorará y nunca analizará las semillas en el constructor.

  • :monitoring_io (true | false) —

    Solo para uso interno del controlador. Establezca "false" para evitar que este clúster o los servidores que lo controlan realicen E/S relacionadas con SDAM. Nota: Si se establece "false", el clúster dejará de funcionar. Está diseñado para usarse en pruebas que invocan manualmente transiciones de estado de SDAM.

  • :limpieza (true | false) —

    Solo para uso interno del controlador. Establézcalo en falso para evitar que se envíe el comando endSessions al servidor para limpiar las sesiones del servidor cuando el clúster se desconecta y para no iniciar el ejecutor periódico. Si :monitoring_io es falso, :cleanup también se establece automáticamente en falso por defecto.

  • :frecuencia_del_latido (Flotar) —

    El intervalo, en segundos, que tarda el monitor del servidor en actualizar su descripción mediante un saludo.

  • :resolv_opciones (Hash) —

    Solo para uso interno del controlador. Opciones para pasar al constructor Resolv::DNS para búsquedas SRV.

  • :server_api (Hash) —

    La versión de la API del servidor solicitada. Este hash puede contener los siguientes elementos:

    • :versión – cadena

    • :strict – booleano

    • :errores_de_deprecación – booleano

Desde:

  • 2.0.0



120
121
122
123
124
125
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
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
 
# Archivo 'lib/mongo/cluster.rb', línea 120

def inicializar(semillas, vigilancia, opciones = opciones::Redactado.Nuevo)
  Si semillas.nil?
    propagar ArgumentError, 'Lassemillas no pueden ser nulas'
  end

  opciones = opciones.dup
  Si opciones[:monitoring_io] == false && !opciones.key?(:limpieza)
    opciones[:limpieza] = false
  end
  @opciones = opciones.freeze

  # @update_lock cubre @servers, @connecting, @connected, @topology y
  # @sessions_supported. Generalmente, las variables de instancia que no tienen una
  # El bloqueo designado para ellos solo debe modificarse bajo el bloqueo de actualización.
  # Tenga en cuenta que el cambio de topología está bloqueado por @update_lock y no por
  #@sdam_flow_lock.
  @update_lock = Mutex.Nuevo
  @servidores = []
  @monitoring = vigilancia
  @oyentes_de_eventos = Evento::Oyentes.Nuevo
  @app_metadata = Servidor::Metadatos de la aplicación.Nuevo(@opciones.unir(objetivo: :solicitud))
  @monitor_app_metadata = Servidor::Supervisar::Metadatos de la aplicación.Nuevo(@opciones.unir(objetivo: :monitor))
  @push_monitor_app_metadata = Servidor::Supervisar::Metadatos de la aplicación.Nuevo(@opciones.unir(objetivo: :monitor_de_empuje))
  @cluster_time_lock = Mutex.Nuevo
  @cluster_time = nulo
  @srv_monitor_lock = Mutex.Nuevo
  @srv_monitor = nulo
  @semaphore_de_selección_de_servidor = Semáforo.Nuevo
  @topology = Topología.inicial(yo, vigilancia, opciones)
  # El bloqueo de cambio de estado es similar al bloqueo de flujo sdam, pero está diseñado
  # para serializar los cambios de estado iniciados por los consumidores del Cluster
  # (por ejemplo, la aplicación que conecta o desconecta el clúster), de modo que
  # p. ej. una aplicación que llama desconectar-conectar-desconectar rápidamente
  # no pone el clúster en un estado inconsistente.
  # Las actualizaciones de monitoreo realizadas internamente por el controlador no toman
  # el bloqueo del cambio de estado.
  @bloqueo_de_cambio_de_estado = Mutex.Nuevo
  # @sdam_flow_lock solo cubre el flujo de sdam. Tenga en cuenta que no aplica.
  # a los reemplazos de @topology que se realizan bajo @update_lock.
  @sdam_flow_lock = Mutex.Nuevo
  @session_pool = Sesión::SessionPool.Nuevo(yo)

  Si semillas.¿vacío? && ¿carga equilibrada?
    propagar ArgumentError, 'Están prohibidos los clústeres con equilibrio de carga sin semillas'
  end

  # La topología de apertura siempre es desconocida sin servidores.
  # https://github.com/mongodb/specifications/pull/388
  topología de apertura = Topología::Desconocido.Nuevo(opciones, vigilancia, yo)

  evento publicar_sdam(
    Monitoring::APERTURA DE TOPOLOGÍA,
    Monitoring::Evento::Apertura de topología.Nuevo(topología de apertura)
  )

  @semillas = semillas = semillas.único
  servidores = semillas.map hacer |semillas|
    # Los eventos de apertura del servidor deben enviarse después de los eventos de cambio de topología.
    # Por lo tanto, la adición de un servidor independiente se realiza aquí antes del cambio de topología
    # evento se publica, desde el inicio se comienza a monitorear el servidor que es
    # hecho más tarde.
    add(semillas, monitor: false)
  end

  Si semillas.tamaño >= 1
    # Recrear la topología para obtener la lista de servidores actual
    recrear_topología(topología, topología de apertura)
  end

  ¡Posiblemente_advierta_sobre_compatibilidad!

  Si ¿carga equilibrada?
    # Las especificaciones nos exigen que produzcamos determinados eventos SDAM
    # cuando está en una topología de equilibrio de carga.
    # Estos eventos no tienen mucho sentido desde el punto de vista de la
    # implementación SDAM del controlador, ni desde el punto de vista de la
    # Implementación del balanceador de carga del controlador.
    # Son solo texto estándar obligatorio.
    #
    # Tenga en cuenta que esta llamada debe realizarse por encima de la comprobación monitoring_io
    # porque eso cortocircuita el resto del constructor.
    fabricar_eventos_lb_sdam_y_establecer_tipo_de_servidor
  end

  Si opciones[:monitoring_io] == false
    # Omitir la construcción periódica del ejecutor, porque sin servidores
    # No se pueden enviar comandos al clúster y nunca debería haberlos.
    # ser cualquier cosa que necesite limpieza.
    #
    # Omitir la monitorización de servidores individuales y la única ronda heredada de
    # de SDAM en el hilo principal, ya que competiría con pruebas que simulan
    # Respuestas SDAM.
    @conectando = @conectado = false
    return
  end

  # Actualice las variables de instancia antes de comenzar a monitorear los subprocesos.
  @conectando = false
  @conectado = true

  Si opciones[:limpieza] != false
    @cursor_reaper = CursorReaper.Nuevo(yo)
    @socket_reaper = Segador de enchufes.Nuevo(yo)
    @periodic_executor = PeriodicExecutor.Nuevo([
      @cursor_reaper, @socket_reaper,
    ], opciones)

    @periodic_executor.¡correr!
  end

  a no ser que ¿carga equilibrada?
    # Es necesario registrar la hora de inicio antes de comenzar el monitoreo
    inicio_monotime = Utils.monotonic_time

    servidores.cada hacer |Server|
      Server.monitorización de inicio
    end

    Si opciones[:escanear] != false
      tiempo de espera de selección de servidor = opciones[:server_selection_timeout] || Selector de servidor::TIEMPO DE ESPERA DE SELECCIÓN DE SERVIDOR
      # El límite de tiempo para la selección del servidor puede ser muy corto, especialmente en
      # pruebas, cuando el cliente espera un escaneo sincrónico antes
      # Iniciando la selección del servidor. Limitando el tiempo de escaneo al seleccionar el servidor.
      # luego aborta el escaneo antes de que pueda procesar incluso servidores locales.
      # Por lo tanto, espere al menos 3 segundos para el escaneo aquí.
      Si tiempo de espera de selección de servidor < 3
        tiempo de espera de selección de servidor = 3
      end
      fecha tope = inicio_monotime + tiempo de espera de selección de servidor
      # Espere a que se complete el primer escaneo de cada servidor, para
      # compatibilidad con versiones anteriores.
      # Si se descubren servidores durante esta ronda SDAM, vamos a
      # esperar a que estos servidores también sean consultados, y así sucesivamente, hasta el
      # tiempo de espera de selección de servidor o el mínimo de 3 segundos.
      bucle hacer
        # Asegúrese de que no intentemos leer la lista de servidores mientras SDAM se esté ejecutando
        servidores = @sdam_flow_lock.sincronizar hacer
          servers_list.dup
        end
        Si servidores.¿todo? { |Server| Server.último_escaneo_monotime && Server.último_escaneo_monotime >= inicio_monotime }
          break
        end
        Si (tiempo_restante = fecha tope - Utils.monotonic_time) < = 0
          break
        end
        log_debug("Esperandohasta #{ ' %.2f '  % time_remaining} segundos para que se escaneen los servidores: #{summary}")
        # Dado que el semáforo puede haber sido señalado entre nosotros verificando
        # la lista de servidores anterior y la llamada de espera a continuación, no deberíamos
        # esperar el tiempo restante completo - esperar hasta 0.5 segundos, luego
        # vuelva a verificar el estado.
        begin
          semáforo de selección de servidor.esperar([tiempo_restante, 0.5].min)
        rescate ::Se acabó el tiempo::Error
          # nada
        end
      end
    end

    monitor de inicio y parada del sistema
  end
end

Detalles de los atributos de instancia

#app_metadata ⇒ Mongo::Server::AppMetadata (solo lectura)

Devuelve los metadatos de la aplicación, utilizados para los protocolos de conexión.

Devuelve:

Desde:

  • 2.4.0



319
320
321
 
# Archivo 'lib/mongo/cluster.rb', línea 319

def app_metadata
  @app_metadata
end

#monitor_app_metadata ⇒ Objeto (solo lectura)

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Desde:

  • 2.0.0



322
323
324
 
# Archivo 'lib/mongo/cluster.rb', línea 322

def monitor_app_metadata
  @monitor_app_metadata
end

#monitoring ⇒ Monitoring (readonly)

Monitoreo de devoluciones El monitoreo.

Devuelve:

Desde:

  • 2.0.0



310
311
312
 
# Archivo 'lib/mongo/cluster.rb', línea 310

def vigilancia
  @monitoring
end

#opciones ⇒ Hash (solo lectura)

Devuelve el hash de las opciones.

Devuelve:

  • (Hash) —

    El hash de opciones.

Desde:

  • 2.0.0



307
308
309
 
# Archivo 'lib/mongo/cluster.rb', línea 307

def opciones
  @opciones
end

#push_monitor_app_metadata ⇒ Objeto (solo lectura)

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Desde:

  • 2.0.0



325
326
327
 
# Archivo 'lib/mongo/cluster.rb', línea 325

def push_monitor_app_metadata
  @push_monitor_app_metadata
end

#semillas ⇒ Array<String> (solo lectura)

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Devuelve las direcciones de los servidores de inicialización. Contiene las direcciones asignadas al clúster al instanciarlo, no las direcciones actuales que el clúster utiliza como resultado de SDAM.

Devuelve:

  • (Matriz<String>) —

    Las direcciones de los servidores de inicialización. Contienen las direcciones asignadas al clúster al instanciarlo, no las direcciones actuales que el clúster utiliza como resultado de SDAM.

Desde:

  • 2.7.0



333
334
335
 
# Archivo 'lib/mongo/cluster.rb', línea 333

def semillas
  @semillas
end

#server_selection_semaphore ⇒ Objeto (solo lectura)

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Desde:

  • 2.0.0



490
491
492
 
# Archivo 'lib/mongo/cluster.rb', línea 490

def semáforo de selección de servidor
  @semaphore_de_selección_de_servidor
end

#session_pool ⇒ Objeto (solo lectura)

Desde:

  • 2.5.1



338
339
340
 
# Archivo 'lib/mongo/cluster.rb', línea 338

def session_pool
  @session_pool
end

#srv_monitor ⇒ Objeto (solo lectura)

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Desde:

  • 2.0.0



360
361
362
 
# Archivo 'lib/mongo/cluster.rb', línea 360

def monitor_srv
  @srv_monitor
end

#topología ⇒ ¿Entero? (solo lectura)

El valor del tiempo de espera de la sesión lógica en minutos.

Ejemplos:

Obtenga el tiempo de espera de la sesión lógica en minutos.

cluster.logical_session_timeout

Devuelve:

  • (Integer, nil) —

    El tiempo de espera de la sesión lógica.

Desde:

  • 2.5.0



313
314
315
 
# Archivo 'lib/mongo/cluster.rb', línea 313

def topología
  @topology
end

Detalles del método de clase

.crear(cliente, monitorización: nulo) ⇒ Clúster

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Cree un clúster para el cliente proporcionado, para utilizarlo cuando no queremos que la instancia de clúster original del cliente sea la misma.

Ejemplos:

Crear un clúster para el cliente.

Cluster.create(client)

Parámetros:

  • Cliente (Cliente) -

    El cliente a crear.

  • escucha. (Monitoring | nil) —

    La instancia de supervisión que se utilizará con el nuevo clúster. Si es nil, se creará una nueva instancia de supervisión.

Devuelve:

Desde:

  • 2.0.0



297
298
299
300
301
302
303
304
 
# Archivo 'lib/mongo/cluster.rb', línea 297

def yo.Cree(Cliente, escucha: nulo)
  clúster = Clúster.Nuevo(
    Cliente.clúster.direcciones.map(Y:a_s),
    vigilancia || Monitoring.Nuevo,
    Cliente.opciones_de_cluster,
  )
  Cliente.conjunto_de_variables_de_instancia(:@cluster, clúster)
end

Detalles del método de instancia

#==(otro) ⇒ true, false

Determina si este clúster de servidores es igual a otro objeto. Comprueba los servidores que están actualmente en el clúster, no los configurados.

Ejemplos:

¿El cluster es igual al objeto?

cluster == other

Parámetros:

  • otros (Objeto) -

    El objeto a comparar.

Devuelve:

  • (verdadero,falso) —

    Si los objetos son iguales.

Desde:

  • 2.0.0



740
741
742
743
 
# Archivo 'lib/mongo/cluster.rb', línea 740

def ==(otros)
  return false a no ser que otros.is_a?(Clúster)
  direcciones == otros.direcciones && opciones == otros.opciones
end

#agregar(host, add_options = nil) ⇒ Servidor

Agregue un servidor al clúster con la dirección proporcionada. Útil para el descubrimiento automático de nuevos servidores cuando un servidor existente ejecuta un saludo y se incluyen servidores potencialmente no configurados.

Ejemplos:

Agregue el servidor para la dirección al clúster.

cluster.add('127.0.0.1:27018')

Parámetros:

  • host (Cadena) -

    La dirección del servidor a agregar.

  • opciones (Hash) —

    un conjunto personalizable de opciones

Devuelve:

  • (Servidor) —

    El servidor recién agregado, si no está presente ya.

Desde:

  • 2.0.0



845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
 
# Archivo 'lib/mongo/cluster.rb', línea 845

def add(host, add_options=nulo)
  dirección = Dirección.Nuevo(host, opciones)
  Si !direcciones.¿incluir?(dirección)
    opta = opciones.unir(monitor: false)
    # Si no estamos iniciando los hilos de monitoreo, tampoco queremos
    # Iniciar el hilo que llena el pool.
    opta.¡unir!(populator_io: false) a no ser que opciones.Fetch(:monitoring_io, true)
    # Tenga en cuenta que en una topología con equilibrio de carga, cada servidor debe ser un
    # balanceador de carga (load_balancer: true se especifica en las opciones)
    # pero esta opción no está configurada aquí porque así lo requiere el
    # especificaciones para simular que el servidor comenzó como uno desconocido
    # y publicar el evento de cambio de descripción del servidor en el balanceador de carga
    #1. Se establecerá la descripción correcta de este servidor.
    # mediante el método fabricate_lb_sdam_events_and_set_server_type.
    Server = Servidor.Nuevo(dirección, yo, @monitoring, event_listeners, opta)
    @update_lock.sincronizar hacer
      # Es necesario volver a verificar si el servidor está presente en @servers, porque
      # el cheque anterior no estaba bajo llave.
      # Dado que estamos bajo el bloqueo de actualización aquí, no podemos llamar a servers_list.
      return Si @servidores.map(Y:DIRECCIÓN).¿incluir?(dirección)

      @servidores.Push(Server)
    end
    Si add_options.nil? || add_options[:monitor] != false
      Server.monitorización de inicio
    end
    Server
  end
end

#direcciones ⇒ Matriz

Las direcciones en el cluster.

Ejemplos:

Obtén las direcciones del clúster.

cluster.addresses

Devuelve:

  • (Matriz) —

    Las direcciones.

Desde:

  • 2.0.6



453
454
455
 
# Archivo 'lib/mongo/cluster.rb', línea 453

def direcciones
  servers_list.map(Y:DIRECCIÓN)
end

#cerrar ⇒ nulo

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Nota:

Las aplicaciones deben llamar a Client#close para desconectarse.

Cierra el cluster.

el clúster en lugar de llamar a este método. Este método es solo para uso interno del controlador.

Desconecta todos los servidores del clúster y publica los eventos SDAM correspondientes. Detiene la monitorización de SRV si está activa. Marca el clúster como desconectado.

Un clúster cerrado ya no se puede utilizar. Si el cliente se reconecta, se creará una nueva instancia de clúster.

Devuelve:

  • (nil) —

    Siempre nulo.

Desde:

  • 2.0.0



508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
 
# Archivo 'lib/mongo/cluster.rb', línea 508

def cerrar
  @bloqueo_de_cambio_de_estado.sincronizar hacer
    a no ser que ¿Conectando? || ¿conectado?
      return nulo
    end
    Si opciones[:limpieza] != false
      session_pool.fin_sesiones
      @periodic_executor.¡detener!
    end
    @srv_monitor_lock.sincronizar hacer
      Si @srv_monitor
        @srv_monitor.¡detener!
      end
    end
    @servidores.cada hacer |Server|
      Si Server.¿conectado?
        Server.cerrar
        evento publicar_sdam(
          Monitoring::SERVIDOR CERRADO,
          Monitoring::Evento::ServerClosed.Nuevo(Server.dirección, topología)
        )
      end
    end
    evento publicar_sdam(
      Monitoring::TOPOLOGÍA_CERRADA,
      Monitoring::Evento::Topología cerrada.Nuevo(topología)
    )
    @update_lock.sincronizar hacer
      @conectando = @conectado = false
    end
  end
  nulo
end

#¿conectado? ⇒ verdadero|falso

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Si el objeto del clúster está conectado a su clúster.

Devuelve:

  • (verdadero|falso) —

    Si el clúster está conectado.

Desde:

  • 2.7.0



426
427
428
429
430
 
# Archivo 'lib/mongo/cluster.rb', línea 426

def ¿conectado?
  @update_lock.sincronizar hacer
    !!@conectado
  end
end

#¿conectando? ⇒ verdadero|falso

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Si el objeto del clúster está en proceso de conectarse a su clúster.

Devuelve:

  • (verdadero|falso) —

    Si el clúster se está conectando.

Desde:

  • 2.0.0



414
415
416
417
418
 
# Archivo 'lib/mongo/cluster.rb', línea 414

def ¿Conectando?
  @update_lock.sincronizar hacer
    !!@conectando
  end
end

#desconectar_servidor_si_está_conectado(servidor) ⇒ Objeto

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Desde:

  • 2.0.0



953
954
955
956
957
958
959
960
961
962
 
# Archivo 'lib/mongo/cluster.rb', línea 953

def desconectar_servidor_si_está_conectado(Server)
  Si Server.¿conectado?
    Server.descripción clara
    Server.¡desconectar!
    evento publicar_sdam(
      Monitoring::SERVIDOR CERRADO,
      Monitoring::Evento::ServerClosed.Nuevo(Server.dirección, topología)
    )
  end
end

#tiene_servidor_legible?(selector_de_servidor = nulo) ⇒ verdadero, falso

Determine si el clúster seleccionaría un servidor legible para la preferencia de lectura proporcionada.

Ejemplos:

¿Está presente un servidor legible?

topology.has_readable_server?(server_selector)

Parámetros:

Devuelve:

  • (verdadero,falso) —

    Si hay un servidor legible presente.

Desde:

  • 2.4.0



757
758
759
 
# Archivo 'lib/mongo/cluster.rb', línea 757

def ¿tiene_servidor_legible?(selector de servidor = nulo)
  topología.¿tiene_servidor_legible?(yo, selector de servidor)
end

#has_writable_server? ⇒ verdadero, falso

Determina si el clúster seleccionaría un servidor escribible.

Ejemplos:

¿Hay un servidor con permisos de escritura?

topology.has_writable_server?

Devuelve:

  • (verdadero,falso) —

    Si hay un servidor escribible.

Desde:

  • 2.4.0



769
770
771
 
# Archivo 'lib/mongo/cluster.rb', línea 769

def ¿tiene_servidor_escribible?
  topología.¿tiene_servidor_escribible?(yo)
end

#heartbeat_interval ⇒ Float

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Obtén el intervalo de actualización para el servidor. Esto se definirá mediante una opción o tendrá un valor por defecto de 10.

Devuelve:

  • (Flotar) -

    El intervalo entre los latidos del corazón, en segundos.

Desde:

  • 2.10.0



405
406
407
 
# Archivo 'lib/mongo/cluster.rb', línea 405

def intervalo de latidos
  opciones[:frecuencia_del_latido] || Servidor::Supervisar::INTERVALO DE LATIDO PREDETERMINADO
end

#inspeccionar ⇒ Cadena

Obtenga la cadena con un formato más atractivo para usarla en la inspección.

Ejemplos:

Inspeccione el grupo.

cluster.inspect

Devuelve:

  • (Cadena) -

    La inspección del clúster.

Desde:

  • 2.0.0



475
476
477
 
# Archivo 'lib/mongo/cluster.rb', línea 475

def inspeccionar
  "#<Mongo::Cluster:0x#{object_id} servidores=#{servidores} topología=#{topología.resumen}>"
end

#¿carga balanceada? ⇒ verdadero | falso

Devuelve si el clúster está configurado para estar en la topología de equilibrio de carga.

Devuelve:

  • (verdadero | falso) —

    Si la topología está equilibrada en carga.

Desde:

  • 2.0.0



347
348
349
 
# Archivo 'lib/mongo/cluster.rb', línea 347

def ¿carga equilibrada?
  topología.is_a?(Topología::Balance de carga)
end

#max_read_retries ⇒ Entero

Obsoleto.
Nota:

max_read_retries debe recuperarse de la instancia del cliente, no de una instancia del clúster, porque los clústeres pueden compartirse entre clientes con diferentes valores para el máximo de reintentos de lectura.

Obten el número máximo de veces que el cliente puede reintentar una operación de lectura al utilizar reintentos de lectura heredados.

Ejemplos:

Obtenga el máximo de reintentos de lectura.

cluster.max_read_retries

Devuelve:

  • (Entero) —

    La cantidad máxima de reintentos.

Desde:

  • 2.1.1



376
377
378
 
# Archivo 'lib/mongo/cluster.rb', línea 376

def max_read_retries
  opciones[:máximo de reintentos de lectura] || MÁXIMO DE REINTENTOS DE LECTURA
end

#next_primary(ping = nulo, sesión = nulo, tiempo de espera: nulo) ⇒ Mongo::Server

Obtenga el próximo servidor principal al que podemos enviar una operación.

Ejemplos:

Obtenga el próximo servidor principal.

cluster.next_primary

Parámetros:

  • ping (verdadero,falso) (predeterminado: nulo) —

    Indica si se realiza un ping al servidor antes de la selección. Obsoleto e ignorado.

  • sesión (Session | nil) (predeterminado: nulo) —

    Sesión opcional a tener en cuenta para el pinning de mongos.

  • :timeout (Float | nil) —

    Tiempo de espera en segundos para la operación, si la hay.

Devuelve:

  • (Mongo::Servidor) —

    Un servidor primario.

Desde:

  • 2.0.0



788
789
790
791
792
793
794
795
 
# Archivo 'lib/mongo/cluster.rb', línea 788

def siguiente_primaria(ping = nulo, sesión = nulo, timeout: nulo)
  Selector de servidor.primario.seleccionar_servidor(
    yo,
    nulo,
    sesión,
    timeout: tiempo de espera
  )
end

#pool(servidor) ⇒ Servidor::ConnectionPool

Obsoleto.

Obtenga el grupo de conexiones para el servidor.

Ejemplos:

Obtener el pool de conexiones.

cluster.pool(server)

Parámetros:

  • Server (Servidor) —

    El servidor.

Devuelve:

  • (Servidor::Grupo deconexiones) —

    El pool de conexiones.

Desde:

  • 2.2.0



808
809
810
 
# Archivo 'lib/mongo/cluster.rb', línea 808

def Piscina(Server)
  Server.Piscina
end

#intervalo_de_reintentar_lectura ⇒ Flotante

Obsoleto.
Nota:

read_retry_interval debe recuperarse de la instancia del cliente, no de una instancia del clúster, porque los clústeres pueden compartirse entre clientes con diferentes valores para el intervalo de reintento de lectura.

Obtenga el intervalo, en segundos, en el que se reintenta la lectura al utilizar reintentos de lectura heredados.

Ejemplos:

Obtenga el intervalo de reintento de lectura.

cluster.read_retry_interval

Devuelve:

  • (Flotar) -

    El intervalo.

Desde:

  • 2.1.1



394
395
396
 
# Archivo 'lib/mongo/cluster.rb', línea 394

def intervalo de reintento de lectura
  opciones[:intervalo de reintento de lectura] || INTERVALO DE REINTENTO DE LECTURA
end

#¡reconectar! ⇒ verdadero

Obsoleto.

Utilice Client#reconnect para reconectarse al clúster en lugar de llamar a este método. Este método no envía eventos SDAM.

Vuelva a conectar todos los servidores.

Ejemplos:

Vuelva a conectar los servidores del clúster.

cluster.reconnect!

Devuelve:

  • (verdadero) -

    Siempre verdadero.

Desde:

  • 2.1.0



552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
 
# Archivo 'lib/mongo/cluster.rb', línea 552

def ¡Reconectar!
  @bloqueo_de_cambio_de_estado.sincronizar hacer
    @update_lock.sincronizar hacer
      @conectando = true
    end
    ¡escanear!
    servidores.cada hacer |Server|
      Server.¡Reconectar!
    end
    @periodic_executor.¡Reanudar!
    @srv_monitor_lock.sincronizar hacer
      Si @srv_monitor
        @srv_monitor.¡correr!
      end
    end
    @update_lock.sincronizar hacer
      @conectando = false
      @conectado = true
    end
  end
end

#eliminar(host, desconectar: ​​verdadero) ⇒ Array | verdadero |falso

Nota:

El valor de retorno de este método no es parte de la API pública del controlador.

Eliminar el servidor del clúster para la dirección proporcionada, si existe.

Ejemplos:

Eliminar el servidor del clúster.

server.remove('127.0.0.1:27017')

Parámetros:

  • host (Cadena) -

    La dirección del host/puerto o socket.

  • desconectar (true | false) (predeterminado: verdadero)

    Si se deben desconectar los servidores que se están eliminando. Solo para uso interno del controlador.

Devuelve:

  • (Array | verdadero |falso) —

    Si la desconexión es cualquier valor distinto de falso, incluido nulo, devuelve si se eliminaron servidores. Si la desconexión es falso, devuelve una matriz de servidores eliminados (y que el llamador debería desconectar).

Desde:

  • 2.0.0



894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
 
# Archivo 'lib/mongo/cluster.rb', línea 894

def Remover(host, desconectar: true)
  dirección = Dirección.Nuevo(host)
  servidores eliminados = []
  @update_lock.sincronizar hacer
    @servidores.eliminar_si hacer |Server|
      (Server.dirección == dirección).grifo hacer |borrar|
        Si borrar
          servidores eliminados << Server
        end
      end
    end
  end
  Si desconectar != false
    servidores eliminados.cada hacer |Server|
      desconectar_servidor_si_está_conectado(Server)
    end
  end
  Si desconectar != false
    servidores eliminados.any?
  else
    servidores eliminados
  end
end

#run_sdam_flow(desc_anterior, desc_actualizado, opciones = {}) ⇒ Objeto

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Ejecuta el flujo SDAM en el clúster.

Este método se puede invocar para procesar una nueva descripción de servidor devuelta por el servidor en una conexión de monitoreo o no monitoreo, y también por el controlador cuando marca un servidor como desconocido como resultado de un error (de red).

Parámetros:

  • previous_desc (Servidor::Descripción) —

    Descripción del servidor anterior.

  • updated_desc (Servidor::Descripción) —

    La descripción cambiada.

  • opciones (Hash) (predeterminado: {}) —

    Opciones.

Opciones Hash(opciones):

  • :keep_connection_pool (true | false) —

    Normalmente, cuando se desconoce la descripción del nuevo servidor, se borra el grupo de conexiones del servidor correspondiente. Configure esta opción como "true" para conservar el grupo de conexiones existente (necesario para gestionar errores no maestros en servidores 4.2o superiores).

  • :esperado (true | false) —

    Si la descripción actualizada fue el resultado del procesamiento de un saludo esperado.

  • :id_de_servicio (Objeto) —

    Cambiar el estado únicamente para el ID de servicio especificado.

  • :error de escaneo (Mongo::Error | nulo) —

    El error encontrado mientras se escanea, o nulo si no se ha generado ningún error.

Desde:

  • 2.0.0



638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
 
# Archivo 'lib/mongo/cluster.rb', línea 638

def ejecutar_sdam_flow(previous_desc, updated_desc, opciones = {})
  Si ¿carga equilibrada?
    Si updated_desc.config.¿vacío?
      a no ser que opciones[:keep_connection_pool]
        servers_list.cada hacer |Server|
          # TODO ¿debería sacarse el ID del servicio de updated_desc?
          # También podríamos afirmar que
          # opciones[:id_servicio] == desc_actualizado.id_servicio
          err = opciones[:error de escaneo]
          interrumpir = err && (err.is_a?(Error::Error de socket) || err.is_a?(Error::Error de tiempo de espera del socket))
          Server.borrar el grupo de conexiones(id_de_servicio: opciones[:id_de_servicio], conexiones de interrupción en uso: interrumpir)
        end
      end
    end
    return
  end

  @sdam_flow_lock.sincronizar hacer
    flujo = Flujo de Sdam.Nuevo(yo, previous_desc, updated_desc,
      esperado: opciones[:esperado])
    flujo.server_description_changed

    # El flujo de SDAM puede alterar la descripción actualizada: obtenga la versión final
    # versión para fines de difusión si hay un servidor disponible
    updated_desc = flujo.updated_desc

    a no ser que opciones[:keep_connection_pool]
      Si flujo.¿se convirtió en desconocido?
        servers_list.cada hacer |Server|
          Si Server.dirección == updated_desc.dirección
            err = opciones[:error de escaneo]
            interrumpir = err && (err.is_a?(Error::Error de socket) || err.is_a?(Error::Error de tiempo de espera del socket))
            Server.borrar el grupo de conexiones(conexiones de interrupción en uso: interrumpir)
          end
        end
      end
    end

    monitor de inicio y parada del sistema
  end

  # Algunas descripciones actualizadas, por ejemplo, una que no coincide conmigo, dan como resultado
  # servidor cuya descripción estamos procesando será eliminado
  # la topología. Cuando esto ocurre, el hilo de supervisión del servidor obtiene
  # eliminado. Como resultado, cualquier código después de la invocación del flujo podría no ejecutarse.
  # una instancia de monitor particular, por lo tanto, generalmente no debería haber
  # cualquier código en este método más allá de la invocación del flujo.
  #
  # Sin embargo, esta llamada de difusión puede estar aquí porque si el monitoreo
  # El hilo fue eliminado, el servidor debería haberse cerrado y no hay cliente
  # debería estar esperándolo actualmente, por lo que no envía señales al semáforo
  # no debería causar ningún problema.
  a no ser que updated_desc.¿desconocido?
    semáforo de selección de servidor.transmitir
  end
end

#¡escanear!(sync = true) ⇒ true

Nota:

En los escaneos sincrónicos y asincrónicos, cada hilo de monitorización mantiene un intervalo mínimo entre escaneos, lo que significa que llamar a este método puede no iniciar un escaneo en un servidor en particular en el siguiente instante.

Forzar un análisis de todos los servidores conocidos en el clúster.

Si el parámetro sync es verdadero, que es el valor predeterminado, el análisis se realiza sincrónicamente en el subproceso que invocó este método. Cada servidor del clúster se comprueba secuencialmente. Si hay muchos servidores en el clúster o su respuesta es lenta, esta operación puede ser de larga duración.

Si el parámetro de sincronización es falso, este método indica a todos los subprocesos del monitor del servidor que realicen un escaneo inmediato y regresa sin esperar los resultados del escaneo.

Ejemplos:

Forzar un escaneo completo del clúster.

cluster.scan!

Devuelve:

  • (verdadero) -

    Siempre verdadero.

Desde:

  • 2.0.0



597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
 
# Archivo 'lib/mongo/cluster.rb', línea 597

def ¡escanear!(sincronizar=true)
  Si sincronizar
    servers_list.cada hacer |Server|
      Si Server.Supervisar
        Server.Supervisar.¡escanear!
      else
        advertencia de registro("Sesolicitó un escaneo sincrónico en el clúster #{summary} pero el servidor #{server} no tienemonitor")
      end
    end
  else
    servers_list.cada hacer |Server|
      Server.semáforo de escaneo.señal
    end
  end
  true
end

#servers ⇒ Array<Server>

Obtenga una lista de servidores candidatos del clúster en los que se pueden ejecutar operaciones.

Ejemplos:

Obtenga los servidores candidatos para una operación.

cluster.servers

Devuelve:

  • (Array) —

    Los candidatos servidores.

Desde:

  • 2.0.0



441
442
443
 
# Archivo 'lib/mongo/cluster.rb', línea 441

def servidores
  topología.servidores(servers_list)
end

#lista_de_servidores ⇒ Objeto

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Desde:

  • 2.0.0



946
947
948
949
950
 
# Archivo 'lib/mongo/cluster.rb', línea 946

def servers_list
  @update_lock.sincronizar hacer
    @servidores.dup
  end
end

#set_server_list(dirección_servidor_strs) ⇒ Objeto

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Establece la lista de servidores en las direcciones de la lista proporcionada de cadenas de direcciones.

El monitor SRV llama a este método después de recibir nuevos registros DNS para el nombre de host monitoreado.

Elimina servidores del clúster cuyas direcciones no están en la lista pasada de direcciones de servidor y agrega servidores para cualquier dirección en el argumento que aún no esté en el clúster.

Parámetros:

  • dirección_del_servidor_cadenas (Matriz<String>) —

    Lista de direcciones de servidor para sincronizar los servidores del clúster.

Desde:

  • 2.0.0



709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
 
# Archivo 'lib/mongo/cluster.rb', línea 709

def establecer_lista_de_servidores(dirección_del_servidor_cadenas)
  @sdam_flow_lock.sincronizar hacer
    # Si una de las nuevas direcciones no está en la lista de servidores actual,
    # agregarlo a la lista de servidores.
    dirección_del_servidor_cadenas.cada hacer |dirección_str|
      a no ser que servers_list.any? { |Server| Server.dirección.semillas == dirección_str }
        add(dirección_str)
      end
    end

    # Si una de las direcciones de los servidores no está en la nueva lista de direcciones,
    # eliminar ese servidor de la lista de servidores.
    servers_list.cada hacer |Server|
      a no ser que dirección_del_servidor_cadenas.any? { |dirección_str| Server.dirección.semillas == dirección_str }
        Remover(Server.dirección.semillas)
      end
    end
  end
end

#resumen ⇒ Objeto

Nota:

Este método es experimental y está sujeto a cambios.

Desde:

  • 2.7.0



483
484
485
486
487
 
# Archivo 'lib/mongo/cluster.rb', línea 483

def resumen
  "#<Clúster " +
  "topología=#{topología. resumen} "+
  "servidores=[#{lista_servidores.map( &:summary ).join(', ' )}]>"
end

#update_cluster_time(result) ⇒ Object

Actualizar el tiempo máximo de clúster visto en una respuesta.

Ejemplos:

Actualizar la hora del cluster.

cluster.update_cluster_time(result)

Parámetros:

  • resultado (Operación::Resultado) —

    El resultado de la operación que contiene el tiempo del clúster.

Devuelve:

  • (Objeto) -

    El tiempo del cluster.

Desde:

  • 2.5.0



822
823
824
825
826
827
828
 
# Archivo 'lib/mongo/cluster.rb', línea 822

def update_cluster_time(resultado)
  Si cluster_time_doc = resultado.cluster_time
    @cluster_time_lock.sincronizar hacer
      avance_del_tiempo_del_cluster(cluster_time_doc)
    end
  end
end

#update_topology(new_topology) ⇒ Object

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Desde:

  • 2.0.0



919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
 
# Archivo 'lib/mongo/cluster.rb', línea 919

def update_topology(nueva_topología)
  topología antigua = nulo
  @update_lock.sincronizar hacer
    topología antigua = topología
    @topology = nueva_topología
  end

  # Si la nueva topología tiene servidores con datos, sabemos con certeza si
  Se admiten # sesiones: actualice nuestro valor almacenado en caché.
  # Si la nueva topología no tiene servidores que soporten datos, deje el valor anterior
  # tal como está y el método sessions_supported? realizará la selección del servidor
  # para intentar determinar con precisión el soporte de la sesión, recurriendo a la
  # último valor conocido.
  Si topología.¿servidores_de_datos?
    sesiones_apoyadas = !!topología.tiempo de espera de sesión lógica
    @update_lock.sincronizar hacer
      @sesiones_apoyadas = sesiones_apoyadas
    end
  end

  evento publicar_sdam(
    Monitoring::TOPOLOGÍA CAMBIADA,
    Monitoring::Evento::Topología modificada.Nuevo(topología antigua, topología)
  )
end

#validate_session_support!(timeout: nil) ⇒ objeto

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Genera Error::SessionsNotAvailable si la implementación a la que está conectado el controlador no admite sesiones.

La compatibilidad de sesiones puede cambiar con el tiempo, por ejemplo, debido a la actualización o degradación de los servidores de la implementación. Si el cliente no está conectado a ningún servidor y no encuentra ninguno durante el tiempo de espera de selección de servidor, este método generará NoServerAvailable. Este método se llama desde el flujo de ejecución de la operación y, si genera NoServerAvailable, toda la operación fallará con esa excepción, ya que la ejecución de la operación ha esperado a que se agotara el tiempo de espera de selección de servidor para que hubiera algún servidor disponible (lo que correspondería a un superconjunto de los servidores adecuados para la operación que se intenta realizar) y no se ha materializado ninguno.

Parámetros:

  • :timeout (Float | nil) —

    Tiempo de espera para la validación. Dado que el proceso de validación implica la selección del servidor,

Aumentos:

  • (Error::Sesionesno disponibles) —

    Si la implementación a la que está conectado el controlador no admite sesiones.

  • (Error::NoServerAvailable) —

    Si el cliente no está conectado a ningún servidor y no encuentra ninguno durante el tiempo de espera de selección de servidor.

Desde:

  • 2.0.0



988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
 
# Archivo 'lib/mongo/cluster.rb', línea 988

def ¡validar_soporte_de_sesión!(timeout: nulo)
  Si topología.is_a?(Topología::Balance de carga)
    return
  end

  @bloqueo_de_cambio_de_estado.sincronizar hacer
    @sdam_flow_lock.sincronizar hacer
      Si topología.¿servidores_de_datos?
        a no ser que topología.tiempo de espera de sesión lógica
          sesiones de aumento no admitidas
        end
      end
    end
  end

  # No se conocen servidores que contengan datos: realice una selección de servidor para intentar
  # obtener una respuesta de al menos uno de ellos, para devolver una respuesta precisa
  # evaluación de si las sesiones son compatibles actualmente.
  Selector de servidor.Obtener(modo: :primary_preferred).seleccionar_servidor(yo, timeout: tiempo de espera)
  @bloqueo_de_cambio_de_estado.sincronizar hacer
    @sdam_flow_lock.sincronizar hacer
      a no ser que topología.tiempo de espera de sesión lógica
        sesiones de aumento no admitidas
      end
    end
  end
end