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/clúster.rb,
lib/mongo/clúster/topología.rb,
lib/mongo/clúster/topología.rb,
lib/mongo/clúster/sdam_flow.rb,
lib/mongo/clúster/topología/base.rb,
lib/mongo/clúster/topología/single.rb,
lib/mongo/clúster/topología/particionado.rb,
lib/mongo/clúster/topología/unknown.rb,
lib/mongo/clúster/periodic_executor.rb,
lib/mongo/clúster/reapers/cursor_reaper.rb,
lib/mongo/clúster/reapers/socket_reaper.rb,
lib/mongo/clúster/topología/load_balanced.rb,
lib/mongo/clúster/topología/no_replica_set_options.rb,
lib/mongo/clúster/topología/replica_set_no_primary.rb,
lib/mongo/clúster/topología/replica_set_with_primary.rb

Overview

Derechos de autor (C) 2018-2020 MongoDB Inc.

Licenciado bajo Apache License, Version 2.0 (la “Licencia”); no puede utilizar este archivo excepto en cumplimiento con la Licencia. Puede obtener una copia de la Licencia en

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

A menos 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, ya sean Express o implícitas. Consulta la Licencia para obtener los permisos específicos del lenguaje y las limitaciones según la Licencia.

Definido bajo Namespace

Modules: topología clase: CursorReaper, PeriodicExecutor, SdamFlow, SocketReaper

Resumen de constantes colapsar

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'

Constantes incluidas desde Loggable

Loggable::PREFIX

Resumen de atributos de la instancia colapsar

Atributos incluidos de 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 de 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

#subscribirse_a

Métodos incluidos de Monitoring::Publishable

#publish_cmap_event, #publish_event, #publish_sdam_event

Detalles del Constructor

#initialize(seeds, supervisión, options = Options::Redacted.new) ⇒ clúster

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.

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 (encriptada) (por defecto: Options::Redacted.new) —

    Opciones. El constructor de Cliente envía sus opciones al constructor de Clúster, aunque Clúster solo reconoce un subconjunto de las opciones reconocidas por 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 driver. Configúrelo en falso para evitar que se envíe el comando endSessions al servidor para limpiar las sesiones del servidor cuando el clúster esté desconectado, y para no iniciar el ejecutor periódico. Si :monitoring_io es falso, :cleanup también se establece por defecto en falso.

  • frecuency_de_los_latidos (Flotante) —

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

  • resolv_options (encriptada) —

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

  • API del servidor (encriptada) —

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

    • :version -- string
    • :estricto -- booleano
    • :deprecation_errors -- booleano

Aumenta:

  • (ArgumentError)

Desde:

  • 2.0.0



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

def inicializar(semillas, Monitoring, opciones = opciones::Redactado.Nuevo)
  propagar ArgumentError, 'Las semillas no pueden ser nulas' si semillas.nil?

  opciones = opciones.dup
  opciones[:limpieza] = false si opciones[:monitoring_io] == false && !opciones.key?(:limpieza)
  @tracer = opciones.borrar(trazador)
  @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.
  # Ten 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::Destinatarios.Nuevo
  @app_metadata = Server::AppMetadata.Nuevo(@options.fusionar(propósito: aplicación))
  @monitor_app_metadata = Server::Supervisar::AppMetadata.Nuevo(@options.fusionar(propósito: supervisar))
  @push_monitor_app_metadata = Server::Supervisar::AppMetadata.Nuevo(@options.fusionar(propósito: :push_monitor))
  @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 de clúster
  # (por ejemplo, aplicación que conecta o desconecta el clúster), de modo que
  # p. ej., una aplicación que llama a desconectar-conectar-desconectar rápidamente
  # no deja el clúster en un estado inconsistente.
  # La supervisión de las actualizaciones realizadas internamente por el driver no toma
  # el bloqueo de cambio de estado.
  @state_change_lock = Mutex (exclusión mutua).Nuevo
  # @sdam_flow_lock cubre solo el flujo 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)

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

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

  publish_sdam_event(
    Monitoring::TOPLOGÍA_APERTURA,
    Monitoring::Evento::TopologyOpening.Nuevo(opening_topology)
  )

  @seeds = semillas = semillas.uniq
  servidor = semillas.map hacer |Semilla|
    # 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 por separado, se realiza aquí antes de cambiar la topología
    # El evento se publica, comenzando a supervisar el servidor que está
    # hecho más tarde.
    add(Semilla, supervisar: false)
  end

  si semillas.Tamaño >= 1
    # Vuelve a crear la topología para obtener la lista actual de servidores en ella
    recreate_topology(topología, opening_topology)
  end

  possibly_warn_about_compatibility!

  si balanceo_de_carga?
    # Las especificaciones nos exigen que produzcamos determinados eventos SDAM
    # cuando en la topología equilibrada por carga.
    # Estos eventos no tienen mucho sentido desde el punto de vista de la
    # implementación SDAM del controlador, ni desde la perspectiva del
    # 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 interrumpe el resto del constructor.
    fabricate_lb_sdam_events_and_set_server_type
  end

  si opciones[:monitoring_io] == false
    # Omitir la construcción del ejecutor periódico, 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

  return si balanceo_de_carga?

  # Se necesita registrar la hora de inicio antes de comenzar la supervisión
  start_monotime = Utils.monotonic_time

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

  si opciones[:escanear] != false
    server_selection_timeout = 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 por un escaneo síncrono antes de
    # 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í.
    server_selection_timeout = 3 si server_selection_timeout < 3
    fecha límite = start_monotime + server_selection_timeout
    # Espera a que se complete el primer escaneo de cada servidor, para
    # compatibilidad hacia atrás.
    # Si se detectan servidores durante esta ronda de SDAM, vamos a
    # esperar a que estos servidores también sean consultados, y así sucesivamente, hasta el
    # tiempo de espera de selección del 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
      servidor = @sdam_flow_lock.sincronizar hacer
        servers_list.dup
      end
      break si servidor.¿todos? { |Server| Server.last_scan_monotime && Server.last_scan_monotime >= start_monotime }
      si (time_remaining = 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
      # espera el tiempo restante completo - espera hasta 0.5 segundos, luego
      # volver a comprobar el estado.
      begin
        server_selection_semaphore.esperar([ time_remaining, 0.5 ].min)
      rescate ::Tiempo de espera::Error
        # nada
      end
    end
  end

  start_stop_srv_monitor
end

Detalles de atributo de instancias

#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



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

def app_metadata
  @app_metadata
end

#monitor_app_metadata ⇒ Object (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.0.0



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

def monitor_app_metadata
  @monitor_app_metadata
end

#monitoring ⇒ Monitoring (readonly)

Supervisión de devoluciones La supervisión.

Devuelve:

Desde:

  • 2.0.0



300
301
302
 
# Archivo 'lib/mongo/cluster.rb', línea 300

def Monitoring
  @monitoring
end

#opciones ⇒ Hash (solo lectura)

Devuelve el hash de opciones.

Devuelve:

  • (encriptada) —

    El hash de opciones.

Desde:

  • 2.0.0



297
298
299
 
# Archivo 'lib/mongo/cluster.rb', línea 297

def opciones
  @options
end

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



317
318
319
 
# Archivo 'lib/mongo/cluster.rb', línea 317

def push_monitor_app_metadata
  @push_monitor_app_metadata
end

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

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



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

def semillas
  @seeds
end

#semaforo_seleccion_servidor ⇒ 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.0.0



482
483
484
 
# Archivo 'lib/mongo/cluster.rb', línea 482

def server_selection_semaphore
  @server_selection_semaphore
end

#session_pool ⇒ Objeto (solo lectura)

Desde:

  • 2.5.1



330
331
332
 
# Archivo 'lib/mongo/cluster.rb', línea 330

def session_pool
  @session_pool
end

#srv_monitor ⇒ Object (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.0.0



352
353
354
 
# Archivo 'lib/mongo/cluster.rb', línea 352

def srv_monitor
  @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



305
306
307
 
# Archivo 'lib/mongo/cluster.rb', línea 305

def topología
  @topology
end

#trazador ⇒ Objeto (solo lectura)

Desde:

  • 2.0.0



302
303
304
 
# Archivo 'lib/mongo/cluster.rb', línea 302

def trazador
  @tracer
end

Detalles del método de clase

.create(cliente, supervisión: nil) ⇒ clúster

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 clúster para el cliente proporcionado, para usarlo cuando no queramos que la instancia original del clúster del cliente sea la misma.

Ejemplos:

Cree un clúster para el cliente.

Cluster.create(client)

Parámetros:

  • Cliente (cliente) —

    El cliente para 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



287
288
289
290
291
292
293
294
 
# Archivo 'lib/mongo/cluster.rb', línea 287

def sí mismo.Cree(Cliente, supervisión: nulo)
  clúster = clúster.Nuevo(
    Cliente.clúster.direcciones.map(&to_s),
    Monitoring || Monitoring.Nuevo,
    Cliente.cluster_options
  )
  Cliente.instance_variable_set(:@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:

  • (true, false) —

    Si los objetos son iguales.

Desde:

  • 2.0.0



721
722
723
724
725
 
# Archivo 'lib/mongo/cluster.rb', línea 721

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

Agrega un servidor al clúster con la dirección proporcionada. Útil en el descubrimiento automático de nuevos servidores cuando un servidor existente ejecuta un hola y potencialmente se incluyeron servidores 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



827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
 
# Archivo 'lib/mongo/cluster.rb', línea 827

def add(host, add_options = nulo)
  dirección = Dirección.Nuevo(host, opciones)
  return si direcciones.incluir?(dirección)

  opciones = opciones.fusionar(supervisar: false)
  # Si no iniciamos los hilos de supervisión, tampoco queremos
  # iniciar el hilo de poblador del pool.
  opciones.¡Actualizar!(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, opciones)
  @update_lock.sincronizar hacer
    # Es necesario volver a comprobar 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(&:address).incluir?(dirección)

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

#direcciones ⇒ arreglo<Mongo::Address>

Las direcciones en el clúster.

Ejemplos:

Obtén las direcciones del clúster.

cluster.addresses

Devuelve:

Desde:

  • 2.0.6



445
446
447
 
# Archivo 'lib/mongo/cluster.rb', línea 445

def direcciones
  servers_list.map(&:address)
end

#cerrar ⇒ nil

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.

Nota:

Las aplicaciones deben llamar a Client#close para desconectarse de

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



500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
 
# Archivo 'lib/mongo/cluster.rb', línea 500

def Cerrar
  @state_change_lock.sincronizar hacer
    return nulo a menos que ¿Conectando? || ¿conectado?

    si opciones[:limpieza] != false
      session_pool.end_sessions
      @periodic_executor.¡detente!
    end
    @srv_monitor_lock.sincronizar hacer
      @srv_monitor.¡detente! si @srv_monitor
    end
    @servers.cada hacer |Server|
      Next a menos que Server.¿conectado?

      Server.Cerrar
      publish_sdam_event(
        Monitoring::SERVIDOR_CERRADO,
        Monitoring::Evento::ServerClosed.Nuevo(Server.dirección, topología)
      )
    end
    publish_sdam_event(
      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 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.

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

Devuelve:

  • (verdadero|falso) —

    Si el clúster está conectado.

Desde:

  • 2.7.0



418
419
420
421
422
 
# Archivo 'lib/mongo/cluster.rb', línea 418

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

#¿conectando? ⇒ true|false

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.

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



406
407
408
409
410
 
# Archivo 'lib/mongo/cluster.rb', línea 406

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

#disconnect_servidor_if_connected(servidor) ⇒ 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.

Desde:

  • 2.0.0



931
932
933
934
935
936
937
938
939
940
 
# Archivo 'lib/mongo/cluster.rb', línea 931

def disconnect_server_if_connected(Server)
  return a menos que Server.¿conectado?

  Server.clear_description
  Server.¡desconectar!
  publish_sdam_event(
    Monitoring::SERVIDOR_CERRADO,
    Monitoring::Evento::ServerClosed.Nuevo(Server.dirección, topología)
  )
end

#has_readable_server?(server_selector = nil) ⇒ true, false

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) (valor por defecto: nil) —

    El selector de servidor.

Devuelve:

  • (true, false) —

    Si hay un servidor legible presente.

Desde:

  • 2.4.0



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

def has_readable_server?(selector_de_servidor = nulo)
  topología.has_readable_server?(sí mismo, selector_de_servidor)
end

#has_writable_server? ⇒ verdadero, falso

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

Ejemplos:

¿Está presente un servidor con permisos de escritura?

topology.has_writable_server?

Devuelve:

  • (true, false) —

    Si hay un servidor con permisos de escritura.

Desde:

  • 2.4.0



751
752
753
 
# Archivo 'lib/mongo/cluster.rb', línea 751

def ¿tiene_servidor_escribible?
  topología.¿tiene_servidor_escribible?(sí mismo)
end

#heartbeat_interval ⇒ Float

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.

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



397
398
399
 
# Archivo 'lib/mongo/cluster.rb', línea 397

def intervalo_latido
  opciones[frecuency_de_los_latidos] || 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



467
468
469
 
# Archivo 'lib/mongo/cluster.rb', línea 467

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

#¿balanceado_carga? ⇒ true | false

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



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

def balanceo_de_carga?
  topología.is_a?(topología::loadBalanced)
end

#max_read_retries ⇒ Entero

Obsoleto.
Nota:

max_read_retries debe recuperarse de la instancia Cliente, no de una instancia Cluster, porque los clústeres pueden compartirse entre clientes con diferentes valores para máx. 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



368
369
370
 
# Archivo 'lib/mongo/cluster.rb', línea 368

def max_read_retries
  opciones[:max_read_retries] || MAX_READ_RETRIES
end

#next_primary(_ping = nil, session = nil, timeout: nil) ⇒ Mongo::Server

Obtén el siguiente servidor principal al que se le puede enviar una operación.

Ejemplos:

Obtén el siguiente servidor principal.

cluster.next_primary

Parámetros:

  • ping (true, false) —

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

  • sesión (Session | nil) (valor por defecto: nil) —

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

  • :timeout (Float | nil) —

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

Devuelve:

Desde:

  • 2.0.0



770
771
772
773
774
775
776
777
 
# Archivo 'lib/mongo/cluster.rb', línea 770

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

#pool(servidor) ⇒ Server::ConnectionPool

Obsoleto.

Obtenga el pool de conexiones para el servidor.

Ejemplos:

Obtén el pool de conexiones.

cluster.pool(server)

Parámetros:

Devuelve:

Desde:

  • 2.2.0



790
791
792
 
# Archivo 'lib/mongo/cluster.rb', línea 790

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



386
387
388
 
# Archivo 'lib/mongo/cluster.rb', línea 386

def read_retry_interval
  opciones[intervalo_de_nueva_lectura] || READ_RETRY_INTERVAL
end

#¡reconectar! ⇒ true

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



541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
 
# Archivo 'lib/mongo/cluster.rb', línea 541

def ¡Reconectar!
  @state_change_lock.sincronizar hacer
    @update_lock.sincronizar hacer
      conectando = true
    end
    ¡escanear!
    servidor.cada hacer |Server|
      Server.¡Reconectar!
    end
    @periodic_executor.¡reiniciar!
    @srv_monitor_lock.sincronizar hacer
      @srv_monitor.ejecutar! si @srv_monitor
    end
    @update_lock.sincronizar hacer
      conectando = false
      @conectado = true
    end
  end
end

#remover(host, disconnect: true) ⇒ arreglo<servidor> | true | false

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) (por defecto: true) —

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

Devuelve:

  • (arreglo<Servidor> | 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



874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
 
# Archivo 'lib/mongo/cluster.rb', línea 874

def Remover(host, desconectar: true)
  dirección = Dirección.Nuevo(host)
  removed_servers = []
  @update_lock.sincronizar hacer
    @servers.delete_if hacer |Server|
      (Server.dirección == dirección).tocar hacer |borrar|
        removed_servers << Server si borrar
      end
    end
  end
  si Desconectar != false
    removed_servers.cada hacer |Server|
      disconnect_server_if_connected(Server)
    end
  end
  si Desconectar == false
    removed_servers
  else
    removed_servers.any?
  end
end

#run_sdam_flow(previous_desc, updated_desc, options = {}) ⇒ 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.

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:

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

  • :awaited (true | false) —

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

  • :service_id (objeto) —

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

  • Scan error (Mongo::Error | nulo) —

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

Desde:

  • 2.0.0



625
626
627
628
629
630
631
632
633
634
635
636
637
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
 
# Archivo 'lib/mongo/cluster.rb', línea 625

def run_sdam_flow(previous_desc, updated_desc, opciones = {})
  si balanceo_de_carga?
    si updated_desc.config.¿vacío? && !opciones[:keep_connection_pool]
      servers_list.cada hacer |Server|
        # TODO: ¿deberá el ID del servicio ser eliminado de updated_desc?
        # También podríamos establecer que
        # options[:service_id] == updated_desc.service_id
        err = opciones[Scan error]
        interrumpir = err && (err.is_a?(Error::SocketError) || err.is_a?(Error::SocketTimeoutError))
        Server.clear_connection_pool(service_id: opciones[:service_id], interrupt_in_use_connections: interrumpir)
      end
    end
    return
  end

  @sdam_flow_lock.sincronizar hacer
    flujo = SdamFlow.Nuevo(sí mismo, previous_desc, updated_desc,
                        esperado: opciones[:awaited])
    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

    si !opciones[:keep_connection_pool] && flujo.se_volvió_desconocido?
      servers_list.cada hacer |Server|
        Next a menos que Server.dirección == updated_desc.dirección

        err = opciones[Scan error]
        interrumpir = err && (err.is_a?(Error::SocketError) || err.is_a?(Error::SocketTimeoutError))
        Server.clear_connection_pool(interrupt_in_use_connections: interrumpir)
      end
    end

    start_stop_srv_monitor
  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 después 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 esperando actualmente, por lo tanto no debe señalizar el semáforo
  # no debería causar ningún problema.
  return si updated_desc.¿desconocido?

  server_selection_semaphore.transmisión
end

#escaneo!(sincronizar = 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 sync es falso, este método instruye a todos los hilos de monitorización del servidor para 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



584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
 
# Archivo 'lib/mongo/cluster.rb', línea 584

def ¡escanear!(sincronizar = true)
  si sincronizar
    servers_list.cada hacer |Server|
      si Server.Supervisar
        Server.Supervisar.¡escanear!
      else
        log_warn("Escaneo síncrono solicitado en el clúster #{resumen} pero el servidor #{servidor} no tiene monitor")
      end
    end
  else
    servers_list.cada hacer |Server|
      Server.scan_semaphore.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 candidatos de servidor para una operación.

cluster.servers

Devuelve:

  • (Array<servidor>) —

    Los servidores candidatos.

Desde:

  • 2.0.0



433
434
435
 
# Archivo 'lib/mongo/cluster.rb', línea 433

def servidor
  topología.servidor(servers_list)
end

#servers_list ⇒ 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.

Desde:

  • 2.0.0



924
925
926
927
928
 
# Archivo 'lib/mongo/cluster.rb', línea 924

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

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

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



692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
 
# Archivo 'lib/mongo/cluster.rb', línea 692

def set_server_list(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|
      add(address_str) a menos que servers_list.any? { |Server| Server.dirección.Semilla == address_str }
    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.Semilla == address_str }
        Remover(Server.dirección.Semilla)
      end
    end
  end
end

#resumen ⇒ Objeto

Nota:

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

Desde:

  • 2.7.0



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

def Resumen
  '#<Cluster ' +
    "topología=#{topología.resumen} " +
    "servidores=[#{servers_list.map(&:summary).join(',')}]>"
end

#update_cluster_time(result) ⇒ Object

Actualiza el tiempo máximo de clúster observado 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 la hora del clúster.

Devuelve:

  • (objeto) —

    El tiempo del clúster.

Desde:

  • 2.5.0



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

def update_cluster_time(Resultado)
  return a menos que cluster_time_doc = Resultado.cluster_time

  @cluster_time_lock.sincronizar hacer
    advance_cluster_time(cluster_time_doc)
  end
end

#update_topology(new_topology) ⇒ 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.

Desde:

  • 2.0.0



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

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
  # sesiones son compatibles - actualiza nuestro valor almacenado en caché.
  # Si la nueva topología no tiene servidores portadores de datos, deja el valor anterior
  # tal cual y sessions_supported? El método realizará la selección de servidores
  # para intentar determinar con precisión el soporte de la sesión, recurriendo al
  # último valor conocido.
  si topología.¿servidores portadores de datos?
    sesiones admitidas = !!topología.logical_session_timeout
    @update_lock.sincronizar hacer
      @sesiones_soportadas = sesiones admitidas
    end
  end

  publish_sdam_event(
    Monitoring::TOPOLOGY_CHANGED,
    Monitoring::Evento::TopologyChanged.Nuevo(old_topology, topología)
  )
end

#validate_session_support!(timeout: nil) ⇒ 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.

Genera el error Error::SessionsNotAvailable si la implementación al que está conectado el driver no admite sesiones.

El soporte de sesión puede cambiar con el tiempo, por ejemplo, debido a actualizaciones o retrocesos de servidores en la implementación. Si el cliente no está conectado a ningún servidor y no encuentra ningún servidor 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 se genera la excepción NoServerAvailable, toda la operación fallará con esa excepción, ya que la ejecución de la operación ha esperado hasta que expire el tiempo de espera de selección del servidor para que cualquier servidor esté disponible (lo cual sería un conjunto que incluye a todos los servidores adecuados para la operación que se está intentando) y ninguno se materializó.

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 ningún servidor y no encuentra ninguno durante el tiempo de espera de la selección del servidor.

Desde:

  • 2.0.0



966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
 
# Archivo 'lib/mongo/cluster.rb', línea 966

def validate_session_support!(timeout: nulo)
  return si topología.is_a?(topología::loadBalanced)

  @state_change_lock.sincronizar hacer
    @sdam_flow_lock.sincronizar hacer
      raise_sessions_not_supported si topología.¿servidores portadores de datos? && !topología.logical_session_timeout
    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).select_server(sí mismo, timeout: tiempo de espera)
  @state_change_lock.sincronizar hacer
    @sdam_flow_lock.sincronizar hacer
      raise_sessions_not_supported a menos que topología.logical_session_timeout
    end
  end
end