Clase: Mongo::Server

Hereda:
Objeto
  • Objeto
Mostrar todo
Ampliado por:
Reenviable
Incluye:
evento::Publisher, supervisión::Publishable
Definido en:
lib/mongo/server.rb,
lib/mongo/server/monitor.rb,
lib/mongo/server/connection.rb,
lib/mongo/server/description.rb,
lib/mongo/server/app_metadata.rb,
lib/mongo/server/push_monitor.rb,
lib/mongo/server/connection_base.rb,
lib/mongo/server/connection_pool.rb,
lib/mongo/server/connection_common.rb,
lib/mongo/server/monitor/connection.rb,
lib/mongo/server/pending_connection.rb,
lib/mongo/server/description/features.rb,
lib/mongo/server/monitor/app_metadata.rb,
lib/mongo/server/app_metadata/platform.rb,
lib/mongo/server/app_metadata/truncator.rb,
lib/mongo/server/push_monitor/connection.rb,
lib/mongo/server/app_metadata/environment.rb,
lib/mongo/server/connection_pool/populator.rb,
lib/mongo/server/description/load_balancer.rb,
lib/mongo/server/round_trip_time_calculator.rb,
lib/mongo/server/connection_pool/generation_manager.rb

Overview

Representa un único servidor en el lado del servidor que puede ser autónomo, parte de un set de réplicas o un mongos.

Desde:

  • 2.0.0

Definido bajo Namespace

clase: AppMetadata, Connection, ConnectionBase, ConnectionCommon, ConnectionPool, Descripción, Supervisar, PendingConnection, PushMonitor, RoundTripTimeCalculator

Resumen de constantes colapsar

CONNECT_TIMEOUT =

El tiempo por defecto en segundos para agotar el tiempo de espera de un intento de conexión.

Desde:

  • 2.4.3

10

Constantes incluidas desde Loggable

Loggable::PREFIX

Resumen de atributos de la instancia colapsar

Atributos incluidos de Event::Publisher

#event_listeners

Resumen del método de instancia colapsar

Métodos incluidos de Event::Publisher

#publicar

Métodos incluidos de Monitoring::Publishable

#publish_cmap_event, #publish_event, #publish_sdam_event

Métodos incluidos desde Registrable

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

Detalles del Constructor

#inicializar(dirección, clúster, supervisión, event_listeners, opciones = {}) ⇒ Servidor

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 servidor nunca debe ser instanciado directamente fuera de un clúster.

Instancias un nuevo objeto servidor. Iniciará la actualización en segundo plano y se suscribirá a los eventos correspondientes.

Ejemplos:

Inicia el servidor.

Mongo::Server.new('127.0.0.1:27017', cluster, monitoring, listeners)

Parámetros:

  • dirección (Dirección) —

    La dirección host:port a la que conectarse.

  • clúster (clúster) —

    El clúster al que pertenece el servidor.

  • Monitoring (supervisión) —

    La supervisión.

  • event_listeners (Event::Listeners) —

    Los evento listeners.

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

    Las opciones del servidor.

Opciones Hash (options):

  • supervisar (booleano) —

    Para uso interno del driver únicamente: si se va a supervisar el servidor después de instanciarlo.

  • :monitoring_io (verdadero, falso) —

    Solo para uso interno por parte de driver. Configura en falso para evitar que este servidor realice I/O relacionado con SDAM. Nota: si se configura esta opción como falso, el servidor dejará de funcionar. Se pretende utilizar en pruebas que invoquen manualmente transiciones de estado de SDAM.

  • :populator_io (verdadero, falso) —

    Solo para uso interno de driver. Establézcalo en falso para evitar que los hilos de llenado sean creados e iniciados en el pool de conexiones del servidor. Está diseñado para ser utilizado en pruebas que también desactivan monitoring_io, a menos que se requiera explícitamente el generador de datos. Si monitoring_io está desactivado, pero populator_io está activado, el populator debe cerrarse manualmente al final de la prueba, ya que un clúster sin supervisión se considera no conectado, y, por lo tanto, no liberará los subprocesos del pool de conexiones de populator al cerrar.

  • balanceador_de_carga (true | false) —

    Si este servidor es un balanceador de carga.

  • Conectar (string) —

    El modo de conexión del cliente.

Desde:

  • 2.0.0



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# Archivo 'lib/mongo/server.rb', línea 69

def inicializar(dirección, clúster, Monitoring, event_listeners, opciones = {})
  @address = dirección
  @cluster = clúster
  @monitoring = Monitoring
  opciones = opciones.dup
  _monitor = opciones.borrar(supervisar)
  @options = opciones.freeze
  @event_listeners = event_listeners
  @connection_id_gen = clase.Nuevo hacer
    Incluir ID
  end
  @scan_semaphore = DistinguishingSemaphore.Nuevo
  @round_trip_time_calculator = RoundTripTimeCalculator.Nuevo
  @descripción = Descripción.Nuevo(dirección, {},
                                 equilibrador_de_carga: !!@options[balanceador_de_carga],
                                 force_load_balancer: forzar_balanceador_de_carga?)
  @last_scan = nulo
  @last_scan_monotime = nulo
  a menos que opciones[:monitoring_io] == false
    @monitor = Supervisar.Nuevo(sí mismo, event_listeners, Monitoring,
                           opciones.fusionar(
                             app_metadata: clúster.monitor_app_metadata,
                             push_monitor_app_metadata: clúster.push_monitor_app_metadata,
                             intervalo_heartbeat: clúster.intervalo_latido
                           ))
    Comenzar monitoreo a menos que _monitor == false
  end
  @conectado = true
  @pool_lock = Mutex (exclusión mutua).Nuevo
end

Detalles de atributo de instancias

#dirección ⇒ String (solo lectura)

Devuelve la dirección configurada para el servidor.

Devuelve:

  • (string) —

    La dirección configurada para el servidor.

Desde:

  • 2.0.0



101
102
103
 
# Archivo 'lib/mongo/server.rb', línea 101

def dirección
  @address
end

#clúster ⇒ Clúster (solo lectura)

Devuelve el clúster El clúster del servidor.

Devuelve:

  • (clúster) —

    clúster El clúster del servidor.

Desde:

  • 2.0.0



104
105
106
 
# Archivo 'lib/mongo/server.rb', línea 104

def clúster
  @cluster
end

#descripción ⇒ Server::Description (solo lectura)

Devuelve una descripción. La descripción del servidor que el supervisar actualiza.

Devuelve:

Desde:

  • 2.0.0



118
119
120
 
# Archivo 'lib/mongo/server.rb', línea 118

def Descripción
  @descripción
end

#monitor ⇒ nulo | Monitor (solo lectura)

Devuelve el monitor El monitor del servidor. nil si el servidor se creó con la opción monitoring_io: false.

Devuelve:

  • (nil | supervisar) —

    monitor El monitor del servidor. nil si el servidor se creó con la opción monitoring_io: false.

Desde:

  • 2.0.0



108
109
110
 
# Archivo 'lib/mongo/server.rb', línea 108

def Supervisar
  @monitor
end

#monitoring ⇒ Monitoring (readonly)

Supervisión de devoluciones La supervisión.

Devuelve:

Desde:

  • 2.0.0



114
115
116
 
# Archivo 'lib/mongo/server.rb', línea 114

def Monitoring
  @monitoring
end

#opciones ⇒ Hash (solo lectura)

Devuelve el hash de opciones.

Devuelve:

  • (encriptada) —

    El hash de opciones.

Desde:

  • 2.0.0



111
112
113
 
# Archivo 'lib/mongo/server.rb', línea 111

def opciones
  @options
end

#round_trip_time_calculator ⇒ RoundTripTimeCalculator (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.

Devuelve el objeto calculador de tiempo de ida y vuelta.

Devuelve:

Desde:

  • 2.0.0



227
228
229
 
# Archivo 'lib/mongo/server.rb', línea 227

def calculadora_de_tiempo_de_viaje_redondo
  @round_trip_time_calculator
end

#scan_semaphore ⇒ Semaphore (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.

Devuelve Semaphore para señalar la solicitud de un análisis inmediato de este servidor por parte de su monitor, si hay uno en ejecución.

Devuelve:

  • (Semáforo) —

    Semáforo para señalar la solicitud de un escaneo inmediato de este servidor por su supervisor, si hay uno en ejecución.

Desde:

  • 2.0.0



223
224
225
 
# Archivo 'lib/mongo/server.rb', línea 223

def scan_semaphore
  @scan_semaphore
end

Detalles del método de instancia

#==(otro) ⇒ true, false

¿Este servidor es igual a otro?

Ejemplos:

¿Es el servidor igual al otro?

server == other

Parámetros:

  • Otros (objeto) —

    El objeto con el que comparar.

Devuelve:

  • (true, false) —

    Si los servidores son iguales.

Desde:

  • 2.0.0



239
240
241
242
243
 
# Archivo 'lib/mongo/server.rb', línea 239

def ==(Otros)
  return false a menos que Otros.is_a?(Server)

  dirección == Otros.dirección
end

#clear_connection_pool(service_id: nil, interrupt_in_use_connections: false) ⇒ 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.

Parámetros:

  • :service_id (objeto) —

    Cerrar exclusivamente las conexiones con el id de servicio especificado.

  • :interrupt_in_use_connections (true | false) —

    Si también se deben interrumpir las conexiones despejadas.

Desde:

  • 2.0.0



642
643
644
645
646
647
648
649
650
651
652
 
# Archivo 'lib/mongo/server.rb', línea 642

def clear_connection_pool(service_id: nulo, interrupt_in_use_connections: false)
  @pool_lock.sincronizar hacer
    # Un servidor que se marca como desconocido después de cerrarse es técnicamente
    # incorrecto pero no altera significativamente ningún estado.
    Porque históricamente el driver permitía que los servidores fueran marcados
    # desconocido en cualquier momento, continúa haciéndolo incluso si la piscina está cerrada.
    si @pool && !@pool.¿Cerrado?
      @pool.¡desconectar!(service_id: service_id, interrupt_in_use_connections: interrupt_in_use_connections)
    end
  end
end

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

Borra la descripción de los servidores para que se considere desconocida y pueda desconectarse de manera segura.

Desde:

  • 2.0.0



632
633
634
 
# Archivo 'lib/mongo/server.rb', línea 632

def clear_description
  @descripción = mongo::Server::Descripción.Nuevo(dirección, {})
end

#cerrar ⇒ Objeto

Desde:

  • 2.0.0



287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
 
# Archivo 'lib/mongo/server.rb', línea 287

def Cerrar
  Supervisar.¡detente! si Supervisar

  @conectado = false

  _pool = nulo
  @pool_lock.sincronizar hacer
    _pool, @pool = @pool, nulo
  end

  # TODO: cambia esto a _pool.close en RUBY-3174.
  # Despeje la piscina. Si el servidor no es desconocido, entonces el
  # pool permanecerá listo. Detener el hilo de poblamiento en segundo plano.
  _pool&.Cerrar(permanecer_listo: true)

  nulo
end

#compressor ⇒ String | nil

Obsoleto.
Nota:

La compresión se negocia para cada conexión por separado.

El compresor negociado por el monitor del servidor, si lo hay.

Este atributo es nulo si aún no se ha completado ninguna revisión del servidor y si no se ha negociado ninguna compresión.

Devuelve:

  • (String | nil) —

    El compresor negociado.

Desde:

  • 2.0.0



175
176
177
178
179
 
# Archivo 'lib/mongo/server.rb', línea 175

def compresor
  return a menos que Supervisar

  Supervisar.compresor
end

#¿conectable? ⇒ true, false

Obsoleto.

Ya no es necesario con la especificación de Selección de Servidor.

Determina si es posible establecer una conexión con el servidor y enviarle mensajes.

Ejemplos:

¿El servidor es conectable?

server.connectable?

Devuelve:

  • (true, false) —

    Si el servidor es conectable.

Desde:

  • 2.1.0



256
 
# Archivo 'lib/mongo/server.rb', línea 256

def ¿connectable?; 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 servidor está conectado.

Devuelve:

  • (verdadero|falso) —

    Si el servidor está conectado.

Desde:

  • 2.7.0



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

def ¿conectado?
  @conectado
end

#¡desconectar! ⇒ true

Desconecte el controlador de este servidor.

Desconecta todas las conexiones inactivas a este servidor en su pool de conexiones, si existen. Detiene el generador del pool de conexiones, si se está ejecutando. No cierra inmediatamente las conexiones que están actualmente desactivadas (es decir, en uso); dichas conexiones se cerrarán cuando se devuelvan a sus respectivos grupos de conexiones. Detén el monitor en segundo plano del servidor.

Devuelve:

  • (cierto) —

    Siempre verdadero.

Desde:

  • 2.0.0



270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
 
# Archivo 'lib/mongo/server.rb', línea 270

def ¡desconectar!
  Supervisar.¡detente! si Supervisar

  @conectado = false

  # La especificación actual de CMAP requiere que un pool sea mayormente inutilizable
  # si su servidor es desconocido (o, por tanto, está desconectado).
  # Sin embargo, todas las operaciones pendientes deben completarse,
  # y sus conexiones deben ser registradas en el pool para ser
  # demolido. Debido a este requisito de limpieza, no podemos simplemente
  # cierra el grupo y establécelo en nil aquí, para que se vuelva a crear la próxima vez
  # tiempo en que se descubre el servidor.
  pool_internal&.borrar

  true
end

#force_load_balancer? ⇒ 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.

Devuelve si este servidor se ve obligado a ser un balanceador de carga.

Devuelve:

  • (true | false) —

    Si este servidor debe ser forzado a ser un balanceador de carga.

Desde:

  • 2.0.0



125
126
127
 
# Archivo 'lib/mongo/server.rb', línea 125

def forzar_balanceador_de_carga?
  opciones[Conectar] == :balanceo de carga
end

#manejar_fallo_autenticación! ⇒ Objeto

Gestionar el fallo de autenticación.

Ejemplos:

Gestione posibles fallos de autenticación.

server.handle_auth_failure! do
  Auth.get(user).(self)
end

Devuelve:

  • (objeto) —

    El resultado de la ejecución del bloque.

Aumenta:

Desde:

  • 2.3.0



510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
 
# Archivo 'lib/mongo/server.rb', línea 510

def handle_auth_failure!
  rendimiento
rescate mongo::Error::SocketTimeoutError
  # posiblemente el clúster esté lento, no te rindas
  propagar
rescate mongo::Error::SocketError, Autenticación::No autorizado => e
  # error de red sin tiempo de espera o error de autenticación, borrar el grupo y marcar el
  # topología como desconocida
  ¡desconocido!(
    generación: e.Generación,
    service_id: e.service_id,
    detener_push_monitor: true
  )
  propagar
end

#handle_handshake_failure! ⇒ 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.

Gestionar el fallo de apretón de manos.

Desde:

  • 2.7.0



485
486
487
488
489
490
491
492
493
494
495
496
 
# Archivo 'lib/mongo/server.rb', línea 485

def handle_handshake_failure!
  rendimiento
rescate mongo::Error::SocketError, mongo::Error::SocketTimeoutError => e
  a menos que e.¿etiqueta?('SystemOverloadedError')
    ¡desconocido!(
      generación: e.Generación,
      service_id: e.service_id,
      detener_push_monitor: true
    )
  end
  propagar
end

#heartbeat_frequency ⇒ Object También conocido como: heartbeat_frequency_seconds

Obsoleto.

Desde:

  • 2.0.0



153
154
155
 
# Archivo 'lib/mongo/server.rb', línea 153

def frecuencia del latido del corazón
  clúster.intervalo_latido
end

#inspect ⇒ String

Consigue una inspección del servidor con una impresión bonita.

Ejemplos:

Obtén la inspección del servidor.

server.inspect

Devuelve:

  • (string) —

    La bonita cadena de inspección.

Desde:

  • 2.0.0



346
347
348
 
# Archivo 'lib/mongo/server.rb', línea 346

def inspeccionar
  "#<Mongo::servidor:0x#{object_id} dirección=#{dirección.host}:#{dirección.puerto} #{estado}>"
end

#last_scan ⇒ Time | nil

Devuelve last_scan La fecha en que se completó el último análisis del servidor, o nulo si el servidor aún no ha sido analizado.

Devuelve:

  • (Time | nil) —

    last_scan La hora en que se completó el escaneo del servidor más reciente, o nil si el servidor no ha sido escaneado todavía.

Desde:

  • 2.4.0



133
134
135
136
137
138
139
 
# Archivo 'lib/mongo/server.rb', línea 133

def last_scan
  si Descripción && !Descripción.config.¿vacío?
    Descripción.last_update_time
  else
    @last_scan
  end
end

#last_scan_monotime ⇒ Float | 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.

Devuelve last_scan_monotime El tiempo monotónico cuando se completó el último escaneo del servidor, o nil si el servidor aún no ha sido escaneado.

Devuelve:

  • (Float | nil) —

    last_scan_monotime El tiempo monotónico en que se completó la última exploración del servidor, o nil si el servidor no ha sido escaneado aún.

Desde:

  • 2.0.0



144
145
146
147
148
149
150
 
# Archivo 'lib/mongo/server.rb', línea 144

def last_scan_monotime
  si Descripción && !Descripción.config.¿vacío?
    Descripción.last_update_monotime
  else
    @last_scan_monotime
  end
end

#matches_tag_set?(tag_set) ⇒ true, false

Determina si las etiquetas proporcionadas son un subconjunto de las etiquetas del servidor.

Ejemplos:

¿Son las etiquetas proporcionadas un subconjunto de las etiquetas del servidor?

server.matches_tag_set?({ 'rack' => 'a', 'dc' => 'nyc' })

Parámetros:

  • tag_set (encriptada) —

    El conjunto de etiquetas para comparar con las etiquetas del servidor.

Devuelve:

  • (true, false) —

    Si las etiquetas proporcionadas son un subconjunto de las etiquetas del servidor.

Desde:

  • 2.0.0



443
444
445
446
447
 
# Archivo 'lib/mongo/server.rb', línea 443

def matches_tag_set?(tag_set)
  tag_set.claves.¿todos? hacer |k|
    etiqueta[k] && etiqueta[k] == tag_set[k]
  end
end

#next_connection_id ⇒ Object

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

Desde:

  • 2.0.0



655
656
657
 
# Archivo 'lib/mongo/server.rb', línea 655

def next_connection_id
  @connection_id_gen.next_id
end

#pool ⇒ Mongo::Servidor::ConnectionPool

Obtén el pool de conexiones para este servidor.

Ejemplos:

Obtenga el pool de conexiones para el servidor.

server.pool

Devuelve:

Aumenta:

Desde:

  • 2.0.0



408
409
410
411
412
413
414
415
416
417
 
# Archivo 'lib/mongo/server.rb', línea 408

def group
  propagar Error::ServerNotUsable, dirección si ¿desconocido?

  @pool_lock.sincronizar hacer
    opciones = ¿conectado? ? opciones : opciones.fusionar(populator_io: false)
    @pool ||= Pool de conexiones.Nuevo(sí mismo, opciones).tocar hacer |group|
      group.Listo
    end
  end
end

#pool_internal ⇒ Servidor::ConnectionPool | 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.

Método interno del driver para recuperar el pool de conexiones de este servidor.

A diferencia de pool, pool_internal no creará una pool si aún no existe.

Devuelve:

Desde:

  • 2.0.0



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

def pool_internal
  @pool_lock.sincronizar hacer
    @pool
  end
end

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

Publica el evento de apertura del servidor.

Desde:

  • 2.0.0



331
332
333
334
335
336
 
# Archivo 'lib/mongo/server.rb', línea 331

def publish_opening_event
  publish_sdam_event(
    Monitoring::APERTURA DEL SERVIDOR,
    Monitoring::Evento::ServerOpening.Nuevo(dirección, clúster.topología)
  )
end

#¡reconectar! ⇒ true

Reinicie el monitor del servidor.

Ejemplos:

Reinicie el monitor del servidor.

server.reconnect!

Devuelve:

  • (cierto) —

    Siempre verdadero.

Desde:

  • 2.1.0



457
458
459
460
 
# Archivo 'lib/mongo/server.rb', línea 457

def ¡Reconectar!
  Supervisar.¡reiniciar! si opciones[:monitoring_io] != false
  @conectado = true
end

#reintentar_lecturas? ⇒ booleano

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 servidor admite modernas reintentos de lectura.

Devuelve:

  • (booleano)

Desde:

  • 2.0.0



529
530
531
 
# Archivo 'lib/mongo/server.rb', línea 529

def retry_reads?
  !!logical_session_timeout
end

#retry_writes? ⇒ true, false

Nota:

Las escrituras reintentables solo están disponibles con clúster o set de réplicas.

Nota:

Algunas de las condiciones en este método devuelven automáticamente un valor falso para las topologías equilibradas. Las condiciones en este método siempre deben ser verdaderas, ya que las topologías con balanceo de carga solo están disponibles en MongoDB 5.0+, y no para topologías independientes. Por lo tanto, podemos asumir que los reintentos de guardar están habilitados.

¿Se reintentarán las operaciones de guardar enviadas a este servidor?

Ejemplos:

¿Se volverán a intentar los guardados?

server.retry_writes?

Devuelve:

  • (true, false) —

    Si se reintentarán los guardados.

Desde:

  • 2.5.0



549
550
551
 
# Archivo 'lib/mongo/server.rb', línea 549

def ¿retry_writes?
  !!((logical_session_timeout && !autónomo?) || load_balancer?)
end

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

Empieza la supervisión del servidor.

Usado internamente por el driver para agregar un servidor a un clúster mientras retrasa la supervisión hasta que el servidor esté en el clúster.

Desde:

  • 2.0.0



321
322
323
324
325
326
 
# Archivo 'lib/mongo/server.rb', línea 321

def Comenzar monitoreo
  publish_opening_event
  return a menos que opciones[:monitoring_io] != false

  Supervisar.ejecutar!
end

#status ⇒ String

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.

Devuelve una String que representa el estado del servidor (por ejemplo primario/a).

Devuelve:

  • (string) —

    string que representa el estado del servidor (por ejemplo, primario/a).

Desde:

  • 2.0.0



353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
 
# Archivo 'lib/mongo/server.rb', línea 353

def Estado
  si load_balancer?
    'LB'
  elsif primario/a?
    'primario/a'
  elsif secundario?
    'secundario'
  elsif autónomo?
    'STANDALONE'
  elsif árbitro?
    'ARBITER'
  elsif ghost?
    'GHOST'
  elsif ¿otro?
    'OTHER'
  elsif mongos?
    'MONGOS'
  elsif ¿desconocido?
    'DESCONOCIDO'
  else
    # Dado que el método de resumen se usa a menudo para la depuración, no levantar
    # una excepción en caso de que ninguno de los tipos esperados coincida
    nulo
  end
end

#resumen ⇒ Objeto

Nota:

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

Desde:

  • 2.7.0



383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
 
# Archivo 'lib/mongo/server.rb', línea 383

def Resumen
  Estado = sí mismo.Estado || ''
  Estado += " replica_set=#{replica_set_name}" si nombre_conjunto_replicación

  Estado += ' NO-MONITORING' a menos que Supervisar&.¿corriendo?

  Estado += " pool=#{@pool.summary}" si @pool

  address_bit = si dirección
                  "#{dirección.host}:#{dirección.puerto}"
                else
                  'nil'
                end

  "#<Dirección del servidor=#{bit_de_dirección} #{estado}>"
end

#¡desconocido!(opciones = {}) ⇒ Objeto

Marca el servidor como desconocido y publica el evento SDAM asociado (cambio en la descripción del servidor).

Si la generación se pasa en las opciones, el servidor solo se marcará como desconocido si la generación pasada no es más antigua que la generación actual del pool de conexiones del servidor.

Parámetros:

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

    Opciones.

Opciones Hash (options):

  • :generación (Integer) —

    Generación del pool de conexiones de la conexión que se utilizó para la operación que produjo el error.

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

  • versión_topológica (TopologyVersion) —

    Versión de topología de la respuesta de error que causa que el servidor sea marcado como desconocido.

  • :stop_push_monitor (true | false) —

    Si se debe detener el PushMonitor asociado con el servidor, si existe.

  • :service_id (objeto) —

    Descartar el estado solo para el ID del servicio especificado.

Desde:

  • 2.4.0, Los eventos SDAM se envían desde la versión 2.7.0



577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
 
# Archivo 'lib/mongo/server.rb', línea 577

def ¡desconocido!(opciones = {})
  group = pool_internal

  si load_balancer?
    # Cuando el cliente está en una topología equilibrada en la carga, los servidores (el uno y el
    # sólo lo que puede ser) comienza como un balanceador de carga y permanece como un
    # balanceador de carga indefinidamente. Por lo tanto, no está marcado como desconocido.
    #
    # Sin embargo, este método también borra el pool de conexiones para el servidor
    # cuando el último se marca como desconocido, y esta parte necesita suceder
    # cuando el servidor actúa como equilibrador de carga.
    #
    # Es posible que un servidor balanceador de carga no tenga un ID de servicio,
    # por ejemplo, si aún no ha habido ninguna conexión exitosa a
    # este servidor, pero el servidor aún puede marcarse como desconocido si uno
    # de dichas conexiones ha fallado a la mitad de su establecimiento.
    si service_id = opciones[:service_id]
      group&.¡desconectar!(service_id: service_id)
    end
    return
  end

  # NOTA: No puedes usar la navegación segura aquí porque si pool es nulo, terminas
  # intentando evaluar Integer < nil lo cual es inválido.
  return si opciones[:generación] && group && opciones[:generación] < group.Generación

  si opciones[versión_topológica] && Descripción.topology_version &&
     !opciones[versión_topológica].gt?(Descripción.topology_version)
    return
  end

  Supervisar&.stop_push_monitor! si opciones[:stop_push_monitor]

  # El flujo SDAM actualizará la descripción en el servidor sin hacerlo en el lugar.
  # mutaciones e invocar transiciones SDAM según sea necesario.
  config = {}
  config['serviceId'] = opciones[:service_id] si opciones[:service_id]
  config['topologyVersion'] = opciones[versión_topológica] si opciones[versión_topológica]
  new_description = Descripción.Nuevo(dirección, config,
                                    equilibrador_de_carga: load_balancer?,
                                    force_load_balancer: opciones[Conectar] == :balanceo de carga)
  clúster.run_sdam_flow(Descripción, new_description, opciones)
end

#update_descripción(descripción) ⇒ 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



622
623
624
625
626
 
# Archivo 'lib/mongo/server.rb', línea 622

def update_description(Descripción)
  group = pool_internal
  group.Listo si group && !Descripción.¿desconocido?
  @descripción = Descripción
end

#update_last_scan ⇒ 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



660
661
662
663
 
# Archivo 'lib/mongo/server.rb', línea 660

def update_last_scan
  @last_scan = Tiempo.ahora
  @last_scan_monotime = Utils.monotonic_time
end

#with_connection(connection_global_id: nil, context: nil, &block) ⇒ Objeto

Ejecutar un bloque de código con una conexión, que se extrae del grupo del servidor y luego se vuelve a ingresar.

Ejemplos:

Enviar un mensaje con la conexión.

server.with_connection do |connection|
  connection.dispatch([ command ])
end

Devuelve:

  • (objeto) —

    El resultado de la ejecución del bloque.

Desde:

  • 2.3.0



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

def with_connection(connection_global_id: nulo, context: nulo, &bloque)
  group.with_connection(
    connection_global_id: connection_global_id,
    context: context,
    &bloque
  )
end