Clase: Mongo::clúster

Hereda:
Objeto
  • Objeto
Mostrar todo
Ampliado por:
Reenviable
Incluye:
Mongo::ClusterTime::Consumer, Event::Subscriber, Loggable, Monitoring::Publishable
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.

Licenciado bajo la Licencia Apache, Versión 2.0 (la “Licencia”); no puedes usar este archivo salvo en cumplimiento 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 bajo Namespace

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

Colapso delresumen constante

MAX_READ_RETRIES =

El número por defecto de reintentos de lectura heredados.

Desde:

  • 2.1.1

1
MAX_WRITE_RETRIES =

El número por defecto de reintentos de guardado para métodos heredados.

Desde:

  • 2.4.2

1
READ_RETRY_INTERVAL =

El intervalo de reintento de lectura por defecto, en segundos, al usar reintentos de lectura heredados.

Desde:

  • 2.1.1

5
IDLE_WRITE_PERIOD_SECONDS =

Con qué frecuencia un nodo primario inactivo escribe una operación nula en el oplog.

Desde:

  • 2.4.0

10
CLUSTER_TIME =
Obsoleto.

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

Desde:

  • 2.5.0

'clusterTime'.freeze

Constantes incluidas desde Loggable

Registrable::PREFIX

Resumen de atributos de la instancia colapsar

Atributos incluidos desde Mongo::ClusterTime::Consumer

#cluster_time

Atributos incluidos de Event::Subscriber

#event_listeners

Resumen del método de clase colapsar

Resumen del método de instancia colapsar

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

#advance_cluster_time

Métodos incluidos desde Registrable

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

Métodos incluidos de Event::Subscriber

#suscríbete a

Métodos incluidos en Monitoring::Publishable

#publicar_evento_cmap, #publicar_evento, #publicar_evento_sdam

Detalles del constructor

#initialize(seeds, supervisión, options = Options::Redacted.new) ⇒ 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.

Nota:

El clúster nunca debe ser instanciado directamente fuera de un Cliente.

Nota:

Al conectar a un URI mongodb+srv://, el cliente expande dicho URI en una lista de servidores y pasa esa lista al constructor de Clúster. Al conectarse a un mongod autónomo, el constructor de clúster recibe la dirección correspondiente como un arreglo de una sola string.

Cree el nuevo clúster.

Ejemplos:

Instanciar el clúster.

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

Parámetros:

  • semillas (arreglo<String>) —

    Las direcciones de los servidores configurados

  • Monitoring (supervisión) —

    La supervisión.

  • opciones (Hash) (por defecto: 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 (options):

  • conexión_directa (true | false) —

    Si se debe conectar 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 set de réplicas al que se desea conectar. Se ignorarán los servidores que no estén en este set de réplicas.

  • :escanear (true | false) —

    Si se desea escanear todas las semillas en el constructor. El valor por defecto en la versión 2.x del driver es hacerlo; la versión 3.x del driver no escaneará semillas en el constructor. Opta por el nuevo comportamiento configurando esta opción en 'falso'. Nota: establecer esta opción en nil permite escanear semillas en el constructor en la versión 2.x del driver. La versión 3.x del driver reconocerá esta opción, pero la ignorará y nunca escaneará semillas en el constructor.

  • :monitoring_io (true | false) —

    Solo para uso interno por parte de driver. Establecer en falso para evitar que este clúster o sus servidores realicen operaciones de E/S relacionadas con SDAM. Nota: si se establece esta opción en falso, el clúster no funcionará. Se pretende utilizar en pruebas que invoquen 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 (Flotante) —

    El intervalo, en segundos, para que el monitor del servidor refresque su descripción a través de hello.

  • :resolv_opciones (Hash) —

    Para uso interno de conductores solamente. Opciones para pasar al constructor de Resolv::DNS para búsquedas SRV.

  • API del servidor (Hash) —

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

    • :version – string

    • :estricto – booleano

    • :deprecation_errors – 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, Monitoring, opciones = opciones::Redactado.Nuevo)
  si semillas.nil?
    propagar ArgumentError, 'Las semillas no pueden ser nulas'
  end

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

  # @update_lock cubre @servers, @connecting, @connected, @topology y
  # @sessions_supported. Por lo general, las variables de instancia que no tienen un
  # designada para ellos, el bloqueo sólo 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 (exclusión mutua).Nuevo
  @servers = []
  @monitoring = Monitoring
  @event_listeners = Evento::Oyentes.Nuevo
  @app_metadata = Server::Metadatos de la aplicación.Nuevo(@options.fusionar(objetivo: aplicación))
  @monitor_app_metadata = Server::Supervisar::Metadatos de la aplicación.Nuevo(@options.fusionar(objetivo: supervisar))
  @push_monitor_app_metadata = Server::Supervisar::Metadatos de la aplicación.Nuevo(@options.fusionar(objetivo: :monitor_de_empuje))
  @cluster_time_lock = Mutex (exclusión mutua).Nuevo
  @cluster_time = nulo
  @srv_monitor_lock = Mutex (exclusión mutua).Nuevo
  @srv_monitor = nulo
  @server_selection_semaphore = Semáforo.Nuevo
  @topology = topología.inicial(sí mismo, Monitoring, opciones)
  # El bloqueo de cambio de estado es similar al bloqueo de flujo de sdam, pero está diseñado
  # para serializar los cambios de estado iniciados por los consumidores del Cluster
  # (por ejemplo, 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 deja el clúster en un estado inconsistente.
  # Las actualizaciones de monitoreo realizadas internamente por el controlador no toman
  # el bloqueo de cambio de estado.
  @bloqueo_de_cambio_de_estado = Mutex (exclusión mutua).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 (exclusión mutua).Nuevo
  @session_pool = sesión::SessionPool.Nuevo(sí mismo)

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

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

  evento publicar_sdam(
    Monitoring::TOPLOGÍA_APERTURA,
    Monitoring::Evento::Apertura de topología.Nuevo(topología de apertura)
  )

  @seeds = 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
    recreate_topology(topología, topología de apertura)
  end

  possibly_warn_about_compatibility!

  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 driver.
    # Son simplemente un formulario obligatorio.
    #
    # Ten en cuenta que esta llamada debe hacerse por encima de la verificació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 puede enviar ningún comando al clúster y no debería haber
    # ser cualquier cosa que necesite ser limpiada.
    #
    # Omite la supervisión de servidores individuales y la única ronda heredada
    # de SDAM en el hilo principal, ya que podría estar en conflicto con pruebas que simulan
    # Respuestas SDAM.
    @conectando = @conectado = false
    return
  end

  # Actualizar las variables de instancia antes de iniciar los hilos de supervisión.
  @conectando = false
  @conectado = true

  si opciones[:limpieza] != false
    @cursor_reaper = CursorReaper.Nuevo(sí mismo)
    @socket_reaper = SocketReaper.Nuevo(sí mismo)
    @periodic_executor = PeriodicExecutor.Nuevo([
      @cursor_reaper, @socket_reaper,
    ], opciones)

    @periodic_executor.ejecutar!
  end

  a menos que ¿carga equilibrada?
    # Se necesita registrar la hora de inicio antes de comenzar la supervisión
    start_monotime = Utils.monotonic_time

    servidores.cada hacer |Server|
      Server.Comenzar monitoreo
    end

    si opciones[:escanear] != false
      tiempo de espera de selección de servidor = opciones[:server_selection_timeout] || ServerSelector::SERVER_SELECTION_TIMEOUT
      # 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 escaneo al tiempo de selección del servidor
      # luego aborta el escaneo antes de que pueda procesar incluso servidores locales.
      # Por lo tanto, se debe permitir al menos 3 segundos para que se realice el escaneo aquí.
      si tiempo de espera de selección de servidor < 3
        tiempo de espera de selección de servidor = 3
      end
      fecha límite = start_monotime + tiempo de espera de selección de servidor
      # Espera a que se complete el primer escaneo de cada servidor, para
      # compatibilidad hacia atrás.
      # 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 intentamos leer la lista de servidores mientras SDAM se está ejecutando
        servidores = @sdam_flow_lock.sincronizar hacer
          servers_list.dup
        end
        si servidores.¿todos? { |Server| Server.last_scan_monotime && Server.last_scan_monotime >= start_monotime }
          break
        end
        si (tiempo_restante = fecha límite - Utils.monotonic_time) <= 0
          break
        end
        log_debug("Esperando hasta #{'%.2f' % tiempo_restante} segundos para que los servidores sean escaneados: #{resumen}")
        # Dado que el semáforo puede haber sido activado entre la comprobación
        # 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
        # volver a comprobar el estado.
        begin
          server_selection_semaphore.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::servidor::AppMetadata (solo lectura)

Devuelve la metadatos de la aplicación, utilizada para los handshakes 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)

Supervisión de devoluciones La supervisión.

Devuelve:

Desde:

  • 2.0.0



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

def Monitoring
  @monitoring
end

#opciones ⇒ Hash (solo lectura)

Devuelve el hash de opciones.

Devuelve:

  • (encriptada) —

    El hash de opciones.

Desde:

  • 2.0.0



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

def opciones
  @options
end

#push_monitor_app_metadata ⇒ Object (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

#seeds ⇒ arreglo<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.

DevuelveLas direcciones de los servidores seed. Contiene las direcciones que se dieron al clúster cuando se instanció, no las direcciones actuales que el clúster está usando como resultado de SDAM.

Devuelve:

  • (arreglo<String>) —

    Las direcciones de los servidores semilla. Contiene las direcciones que se dieron al clúster cuando se instanció, no las direcciones actuales que el clúster está usando como resultado de SDAM.

Desde:

  • 2.7.0



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

def semillas
  @seeds
end

#semaforo_seleccion_servidor ⇒ 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 server_selection_semaphore
  @server_selection_semaphore
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 ⇒ Object (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 de tiempo de espera de la sesión lógica en minutos.

Ejemplos:

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

cluster.logical_session_timeout

Devuelve:

  • (Integer, nil) —

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

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

.create(cliente, supervisión: nil) ⇒ 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.

Crear un clúster para el cliente proporcionado, para usar cuando no quieres que la instancia original del clúster del cliente sea la misma.

Ejemplos:

Crear un clúster para el cliente.

Cluster.create(client)

Parámetros:

  • Cliente (cliente) —

    El cliente a crear.

  • supervisión. (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 sí mismo.Cree(Cliente, supervisión: nulo)
  clúster = clúster.Nuevo(
    Cliente.clúster.direcciones.map(Yto_s),
    Monitoring || Monitoring.Nuevo,
    Cliente.cluster_options,
  )
  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. Verifica los servidores que están actualmente en el clúster, y no los que se configuraron.

Ejemplos:

¿El clúster es igual al objeto?

cluster == other

Parámetros:

  • Otros (objeto) —

    El objeto con el que 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 menos que Otros.is_a?(clúster)
  direcciones == Otros.direcciones && opciones == Otros.opciones
end

#add(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 (string) —

    La dirección del servidor a agregar.

  • opciones (encriptada) —

    un conjunto personalizable de opciones

Devuelve:

  • (Servidor) —

    El servidor recién añadido, 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.fusionar(monitor: false)
    # Si no estamos iniciando los hilos de monitoreo, tampoco queremos
    # iniciar el hilo de poblador del pool.
    opta.¡unir!(populator_io: false) a menos que opciones.obtener(:monitoring_io, true)
    # Tenga en cuenta que en una topología balanceada en cargas, cada servidor debe ser un
    # balanceador de carga (se especifica load_balancer: true en las opciones)
    # pero esta opción no se establece aquí porque es requerida por la
    # 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
    # uno. Se establecerá la descripción realmente correcta para este servidor
    # por el método fabricate_lb_sdam_events_and_set_server_type.
    Server = Server.Nuevo(dirección, sí mismo, @monitoring, event_listeners, opta)
    @update_lock.sincronizar hacer
      # Es necesario volver a verificar si el servidor está presente en @servers, porque
      # la comprobación anterior no estaba bajo un bloqueo.
      # Dado que estamos bajo el bloqueo de actualización aquí, no podemos llamar a servers_list.
      return si @servers.map(Y:address).incluir?(dirección)

      @servers.push(Server)
    end
    si add_options.nil? || add_options[supervisar] != false
      Server.Comenzar monitoreo
    end
    Server
  end
end

#direcciones ⇒ Matriz

Las direcciones en el clúster.

Ejemplos:

Obtén las direcciones del clúster.

cluster.addresses

Devuelve:

Desde:

  • 2.0.6



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

def direcciones
  servers_list.map(Y:address)
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.

Cierras el clúster.

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

Desconecta todos los servidores en el clúster, publicando los eventos SDAM apropiados durante el proceso. Detiene la supervisión SRV si está activa. Marca el clúster como desconectado.

Un clúster cerrado ya no es utilizable. Si el cliente se vuelve a conectar, 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 menos 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
    @servers.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::TOPOLOGY_CLOSED,
      Monitoring::Evento::T opologíacerrada.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 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? ⇒ true|false

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

#disconnect_servidor_if_connected(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.clear_description
    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

Determina 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:

  • selector_de_servidor (ServerSelector) (predeterminado: nulo) —

    El selector de servidor.

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?(sí mismo, 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 con permisos de escritura.

Desde:

  • 2.4.0



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

def ¿tiene_servidor_escribible?
  topología.¿tiene_servidor_escribible?(sí mismo)
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:

  • (Float) —

    El intervalo del latido, en segundos.

Desde:

  • 2.10.0



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

def intervalo_latido
  opciones[:frecuencia_del_latido] || Server::Supervisar::DEFAULT_HEARTBEAT_INTERVAL
end

#inspect ⇒ String

Obtenga la string con formato más agradable para usar en la inspección.

Ejemplos:

Inspecciona el clúster.

cluster.inspect

Devuelve:

  • (string) —

    La inspección del clúster.

Desde:

  • 2.0.0



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

def inspeccionar
  "#<Mongo::Clúster: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 equilibrada de carga.

Devuelve:

  • (true | false) —

    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::loadBalanced)
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:

  • (Número 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[:max_read_retries] || MAX_READ_RETRIES
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:

Obtén el siguiente 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 existen.

Devuelve:

Desde:

  • 2.0.0



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

def siguiente_principal(ping = nulo, sesión = nulo, timeout: nulo)
  ServerSelector.primario.seleccionar_servidor(
    sí mismo,
    nulo,
    sesión,
    timeout: tiempo de espera
  )
end

#pool(servidor) ⇒ Servidor::ConnectionPool

Obsoleto.

Obtenga el grupo de conexiones para el servidor.

Ejemplos:

Obtén el pool de conexiones.

cluster.pool(server)

Parámetros:

  • Server (Servidor) —

    El servidor.

Devuelve:

Desde:

  • 2.2.0



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

def group(Server)
  Server.group
end

#read_retry_interval ⇒ Float

Obsoleto.
Nota:

read_retry_interval debe recuperarse desde la instancia Client, no desde una instancia Cluster, porque los clústeres pueden ser compartidos 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:

Obtener el intervalo de reintento de lectura.

cluster.read_retry_interval

Devuelve:

  • (Float) —

    El intervalo.

Desde:

  • 2.1.1



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

def read_retry_interval
  opciones[:intervalo de reintento de lectura] || READ_RETRY_INTERVAL
end

#¡reconectar! ⇒ verdadero

Obsoleto.

Usa cliente#reconnect para reconectar al clúster en lugar de llamar a este método. Este método no envía eventos SDAM.

Reconecte todos los servidores.

Ejemplos:

Vuelva a conectar los servidores del clúster.

cluster.reconnect!

Devuelve:

  • (cierto) —

    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.¡reiniciar!
    @srv_monitor_lock.sincronizar hacer
      si @srv_monitor
        @srv_monitor.ejecutar!
      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 forma parte de la API pública del controlador.

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

Ejemplos:

Remover el servidor del clúster.

server.remove('127.0.0.1:27017')

Parámetros:

  • host (string) —

    El host/puerto o dirección de socket.

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

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

Devuelve:

  • (Array | verdadero |falso) —

    Si disconnect es cualquier valor que no sea false, incluyendo nil, devuelve si se eliminaron algunos servidores. Si disconnect es falso, devuelve un arreglo de servidores que fueron eliminados (y que deben ser desconectados por el llamador).

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
    @servers.delete_if hacer |Server|
      (Server.dirección == dirección).tocar 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 puede ser invocado para procesar una nueva descripción del servidor devuelta por el servidor en una conexión de supervisión o no de supervisión, y también por el driver cuando marca un servidor como desconocido como resultado de un error (de red).

Parámetros:

  • previous_desc (Servidor::Descripción) —

    Descripción anterior del servidor.

  • updated_desc (Servidor::Descripción) —

    La descripción cambiada.

  • opciones (Hash) (por defecto: {}) —

    Opciones.

Opciones Hash (options):

  • :keep_connection_pool (true | false) —

    Por lo general, cuando la nueva descripción del servidor es desconocida, el pool de conexiones en el respectivo servidor se limpia. Configure esta opción como 'Verdadero' para mantener el pool de conexiones existente (requerido cuando se manejan errores no master en servidores 4.2+).

  • :esperado (true | false) —

    Si la descripción actualizada fue el resultado de procesamiento una bienvenida esperada.

  • :id_de_servicio (Objeto) —

    Cambie 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 run_sdam_flow(previous_desc, updated_desc, opciones = {})
  si ¿carga equilibrada?
    si updated_desc.config.¿vacío?
      a menos que opciones[:keep_connection_pool]
        servers_list.cada hacer |Server|
          # TODO ¿debe sacarse el ID de servicio de updated_desc?
          # También podríamos establecer que
          # options[:service_id] == updated_desc.service_id
          err = opciones[:error de escaneo]
          interrumpir = err && (err.is_a?(Error::Error de socket) || err.is_a?(Error::SocketTimeoutError))
          Server.clear_connection_pool(service_id: opciones[:id_de_servicio], interrupt_in_use_connections: interrumpir)
        end
      end
    end
    return
  end

  @sdam_flow_lock.sincronizar hacer
    flujo = SdamFlow.Nuevo(sí mismo, previous_desc, updated_desc,
      esperado: opciones[:esperado])
    flujo.server_description_changed

    # El flujo SDAM puede alterar la descripción actualizada: toma la final
    # una versión para los fines de transmisión si un servidor está disponible
    updated_desc = flujo.updated_desc

    a menos 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::SocketTimeoutError))
            Server.clear_connection_pool(interrupt_in_use_connections: interrumpir)
          end
        end
      end
    end

    monitor de inicio y parada del sistema
  end

  # Algunas descripciones actualizadas, por ejemplo, una mía desajustada, resultan en la
  # servidor cuya descripción estamos procesamiento siendo retirada de
  # la topología. Cuando esto ocurre, el hilo de supervisión del servidor obtiene
  # matado. Como resultado, cualquier código después de la invocación del flujo podría no ejecutarse
  # una instancia particular del monitor, por lo que 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 la supervisión
  # el hilo se mató, el servidor debería haberse cerrado y ningún 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 menos que updated_desc.¿desconocido?
    server_selection_semaphore.transmisión
  end
end

#¡escanear!(sync = true) ⇒ true

Nota:

Tanto en los escaneos sincrónicos como en los asincrónicos, cada hilo de supervisión mantiene un intervalo mínimo entre escaneos, lo que significa que llamar a este método puede que no inicie un escaneo en un servidor particular al instante siguiente.

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

Si el parámetro de sincronización es verdadero, que es el valor por defecto, el escaneo se realiza de manera sincrónica en el hilo que llamó a este método. Cada servidor del clúster se comprueba secuencialmente. Si hay muchos servidores en el clúster o son lentos para responder, esto puede ser una operación 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:

  • (cierto) —

    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>

Obtén una lista de candidatos a servidores del clúster en los que se pueden ejecutar operaciones.

Ejemplos:

Obtenga los servidores candidatos para una operación.

cluster.servers

Devuelve:

  • (Array) —

    Los servidores candidatos.

Desde:

  • 2.0.0



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

def servidores
  topología.servidores(servers_list)
end

#servers_list ⇒ 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
    @servers.dup
  end
end

#set_server_list(server_address_strs) ⇒ 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.

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

Este método se llama por el monitor SRV después de recibir nuevos registros DNS para el nombre de host monitorizado.

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

Parámetros:

  • server_address_strs (arreglo<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(server_address_strs)
  @sdam_flow_lock.sincronizar hacer
    # Si una de las nuevas direcciones no está en la lista actual de servidores,
    # añadirlo a la lista de servidores.
    server_address_strs.cada hacer |address_str|
      a menos que servers_list.any? { |Server| Server.dirección.semillas == address_str }
        add(address_str)
      end
    end

    # Si una de las direcciones de los servidores no está en la nueva lista de direcciones,
    # remueva ese servidor de la lista de servidores.
    servers_list.cada hacer |Server|
      a menos que server_address_strs.any? { |address_str| Server.dirección.semillas == address_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=[#{servers_list.map(&:summary).join(',')}]>"
end

#update_cluster_time(result) ⇒ Object

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

Ejemplos:

Actualiza la hora del clúster.

cluster.update_cluster_time(result)

Parámetros:

  • Resultado (Operation::Result) —

    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
      advance_cluster_time(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(new_topology)
  old_topology = nulo
  @update_lock.sincronizar hacer
    old_topology = topología
    @topology = new_topology
  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 portadores de datos, deja 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 al
  # último valor conocido.
  si topología.¿servidores_de_datos?
    sesiones_apoyadas = !!topología.logical_session_timeout
    @update_lock.sincronizar hacer
      @sesiones_soportadas = sesiones_apoyadas
    end
  end

  evento publicar_sdam(
    Monitoring::TOPOLOGY_CHANGED,
    Monitoring::Evento::TopologyChanged.Nuevo(old_topology, 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 el error Error::SessionsNotAvailable si la implementación al que está conectado el driver 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,

Aumenta:

  • (Error::SessionsNotAvailable) —

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

  • (Error::NoServerAvailable) —

    Si el cliente no está conectado a ninguno de los servidores y no encuentra ningún servidor durante el tiempo de espera de selección del 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::loadBalanced)
    return
  end

  @bloqueo_de_cambio_de_estado.sincronizar hacer
    @sdam_flow_lock.sincronizar hacer
      si topología.¿servidores_de_datos?
        a menos que topología.logical_session_timeout
          raise_sessions_not_supported
        end
      end
    end
  end

  # No se conocen servidores portadores de datos, realice la selección de servidor para intentar
  # obtén una respuesta de al menos uno de ellos para devolver un resultado preciso
  # evaluación de si las sesiones están actualmente soportadas.
  ServerSelector.Obtener(moda: :primary_preferred).seleccionar_servidor(sí mismo, timeout: tiempo de espera)
  @bloqueo_de_cambio_de_estado.sincronizar hacer
    @sdam_flow_lock.sincronizar hacer
      a menos que topología.logical_session_timeout
        raise_sessions_not_supported
      end
    end
  end
end