Field Detail

• public static final java.lang.String CODEC_ENGINE

• public static final java.lang.String INDEX_ATTRIBUTES

• public static final java.lang.String INDEX_EXPIRE_AFTER_SECONDS

  TTL index attribute. MongoDB's IndexOptions#expireAfter(Long, TimeUnit)#expireAfter(Long, TimeUnit) is the only way to set a TTL, but it is a two-argument setter that MongoConstants.mapToObject cannot reach (that helper only invokes single-argument setters). So expireAfterSeconds is pulled out of the index attributes and applied explicitly. TTL indexes are single-field only — MongoDB silently ignores the option on a compound index.

• public static final java.lang.String INDEX_RECREATE_ON_CONFLICT

  Opt-in index attribute: when an index already exists on the same keys with conflicting options that cannot be reconciled in place (i.e. anything other than a TTL change), or the declared name is taken by an index on other keys, drop the existing index and recreate it with the declared options instead of just logging the conflict.

• public static final int LIFECYCLE_PHASE

  Below the web server's phase so the client outlives the requests using it, and above EmbeddedMongoLifecycle.PHASE so an embedded server outlives this client: Spring starts in ascending phase order and stops in descending.

• public static final java.lang.String SETTING_CONNECTION_STRING

• public static final java.lang.String SETTING_DATABASE_NAME

• public static final java.lang.String SETTING_DEFAULT_MAPPING

• public static final java.lang.String SETTING_ENGINE

• public static final java.lang.String SETTING_HOST

• public static final java.lang.String SETTING_OPTIONS

• public static final java.lang.String SETTING_PASSWORD

• public static final java.lang.String SETTING_PORT

• public static final java.lang.String SETTING_STATELESS

• public static final java.lang.String SETTING_URL

• public static final java.lang.String SETTING_USERNAME

• protected final AutoTimestampEventListener autoTimestampEventListener

• protected final boolean buildIndexes

• protected final boolean buildIndexesAsync

• protected final boolean codecEngine

• protected CodecRegistry codecRegistry

• protected final ConnectionSources<MongoClient, MongoConnectionSourceSettings> connectionSources

• protected final java.util.Map<java.lang.String, MongoDatastore> datastoresByConnectionSource

  Concurrent because it is written by the connection sources listener, which can add a child for a connection registered at runtime, while close() may be iterating it.

• protected final java.lang.String defaultDatabase

• protected final jakarta.persistence.FlushModeType defaultFlushMode

• protected final ConfigurableApplicationEventPublisher eventPublisher

• protected final GormEnhancer gormEnhancer

• protected MongoClient mongo

  Not final because start() replaces it after a CRaC restore when it is not a RestartableMongoClient, which is restarted in place instead. Everything other than construction reaches it through getMongoClient(), so a replacement is picked up without anything else having to be told.

• protected final java.util.Map<PersistentEntity, java.lang.String> mongoCollections

• protected final java.util.Map<PersistentEntity, java.lang.String> mongoDatabases

• protected final MultiTenancyMode multiTenancyMode

• protected final boolean stateless

• protected final TenantResolver tenantResolver

• protected final org.springframework.transaction.PlatformTransactionManager transactionManager

• protected final boolean transactionsEnabled

Constructor Detail

• public MongoDatastore(ConnectionSources<MongoClient, MongoConnectionSourceSettings> connectionSources, MongoMappingContext mappingContext, ConfigurableApplicationEventPublisher eventPublisher)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  connectionSources - The ConnectionSources to use

  eventPublisher - The Spring ApplicationContext

  mappingContext - The mapping context

• public MongoDatastore(ConnectionSources<MongoClient, MongoConnectionSourceSettings> connectionSources, ConfigurableApplicationEventPublisher eventPublisher, java.lang.Class classes)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  connectionSources - The ConnectionSources to use

  eventPublisher - The Spring ApplicationContext

  classes - The persistent classes

• public MongoDatastore(MongoClient mongoClient, org.springframework.core.env.PropertyResolver configuration, MongoMappingContext mappingContext, ConfigurableApplicationEventPublisher eventPublisher)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  mongoClient - The MongoClient instance

  eventPublisher - The Spring ApplicationContext

  mappingContext - The mapping context

• public MongoDatastore(MongoClient mongoClient, org.springframework.core.env.PropertyResolver configuration, ConfigurableApplicationEventPublisher eventPublisher, java.lang.Class classes)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  mongoClient - The MongoClient instance

  eventPublisher - The Spring ApplicationContext

  classes - The persistent classes

• public MongoDatastore(java.util.function.Supplier<MongoClient> clientSupplier, org.springframework.core.env.PropertyResolver configuration, ConfigurableApplicationEventPublisher eventPublisher, java.lang.Package packages)

  Configures a new MongoDatastore around the clients a supplier builds, which GORM owns: it builds one the first time the client is needed, closes it when the datastore is stopped for a checkpoint, and builds the one the restore needs from the same supplier. Use this where the client cannot be rebuilt from grails.mongodb settings, such as one built from Spring Boot's own MongoClientSettings.

  Parameters:

  clientSupplier - Builds a MongoClient, whenever the datastore needs one

  configuration - The configuration

  eventPublisher - The Spring ApplicationContext

  packages - The packages to scan

  Since:

  8.0

• public MongoDatastore(java.util.function.Supplier<MongoClient> clientSupplier, org.springframework.core.env.PropertyResolver configuration, MongoMappingContext mappingContext, ConfigurableApplicationEventPublisher eventPublisher)

  Configures a new MongoDatastore around the clients a supplier builds; see MongoDatastore(Supplier, PropertyResolver, ConfigurableApplicationEventPublisher, Package...).

  Parameters:

  clientSupplier - Builds a MongoClient, whenever the datastore needs one

  configuration - The configuration

  mappingContext - The mapping context

  eventPublisher - The Spring ApplicationContext

  Since:

  8.0

• public MongoDatastore(MongoClient mongoClient, org.springframework.core.env.PropertyResolver configuration, ConfigurableApplicationEventPublisher eventPublisher, java.lang.Package packages)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  mongoClient - The MongoClient instance

  eventPublisher - The Spring ApplicationContext

  packages - The packages to scan

• public MongoDatastore(MongoClient mongoClient, org.springframework.core.env.PropertyResolver configuration, java.lang.Class classes)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  mongoClient - The MongoClient instance

  classes - The persistent classes

• public MongoDatastore(MongoClient mongoClient, org.springframework.core.env.PropertyResolver configuration, java.lang.Package packages)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  mongoClient - The MongoClient instance

  packages - The packages to scan

• public MongoDatastore(MongoClient mongoClient, java.lang.Class classes)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  mongoClient - The MongoClient instance

  classes - The persistent classes

• public MongoDatastore(Builder clientOptions, org.springframework.core.env.PropertyResolver configuration, MongoMappingContext mappingContext, ConfigurableApplicationEventPublisher eventPublisher)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  clientOptions - The MongoClientSettings instance

  configuration - The configuration

  eventPublisher - The Spring ApplicationContext

  mappingContext - The mapping context

• public MongoDatastore(Builder clientOptions, org.springframework.core.env.PropertyResolver configuration, MongoMappingContext mappingContext)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  clientOptions - The MongoClientSettings instance

  configuration - The configuration

  mappingContext - The mapping context

• public MongoDatastore(org.springframework.core.env.PropertyResolver configuration, MongoMappingContext mappingContext, ConfigurableApplicationEventPublisher eventPublisher)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  configuration - The configuration for the datastore

  eventPublisher - The Spring ApplicationContext

  mappingContext - The mapping context

• public MongoDatastore(org.springframework.core.env.PropertyResolver configuration, MongoConnectionSourceFactory connectionSourceFactory, ConfigurableApplicationEventPublisher eventPublisher, java.lang.Class classes)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  configuration - The configuration for the datastore

  eventPublisher - The Spring ApplicationContext

  connectionSourceFactory - The connection source factory to use

  classes - The persistent classes

• public MongoDatastore(org.springframework.core.env.PropertyResolver configuration, ConfigurableApplicationEventPublisher eventPublisher, java.lang.Class classes)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  configuration - The configuration for the datastore

  eventPublisher - The Spring ApplicationContext

  classes - The persistent classes

• public MongoDatastore(org.springframework.core.env.PropertyResolver configuration, MongoMappingContext mappingContext)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  configuration - The configuration for the datastore

  mappingContext - The mapping context

• public MongoDatastore(org.springframework.core.env.PropertyResolver configuration, java.lang.Class classes)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  configuration - The configuration for the datastore

  classes - The persistent classes

• public MongoDatastore(java.util.Map<java.lang.String, java.lang.Object> configuration, ConfigurableApplicationEventPublisher eventPublisher, java.lang.Class classes)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  configuration - The configuration

  eventPublisher - The event publisher

  classes - The persistent classes

• public MongoDatastore(java.util.Map<java.lang.String, java.lang.Object> configuration, java.lang.Class classes)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  configuration - The configuration

  classes - The persistent classes

• public MongoDatastore(java.util.Map<java.lang.String, java.lang.Object> configuration)

  Creates a MongoDatastore with the given configuration

  Parameters:

  configuration - The configuration

• public MongoDatastore(java.util.Map<java.lang.String, java.lang.Object> configuration, MongoMappingContext mappingContext)

• public MongoDatastore(MongoMappingContext mappingContext)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  mappingContext - The MongoMappingContext

• public MongoDatastore(java.lang.Class classes)

  Configures a new MongoDatastore for the given arguments

  Parameters:

  classes - The persistent classes

• public MongoDatastore(java.lang.Package packagesToScan)

  Construct a Mongo datastore scanning the given packages

  Parameters:

  packagesToScan - The packages to scan

• public MongoDatastore(java.lang.Package packageToScan)

  Construct a Mongo datastore scanning the given package

  Parameters:

  packageToScan - The packages to scan

• public MongoDatastore(org.springframework.core.env.PropertyResolver configuration, java.lang.Package packagesToScan)

  Construct a Mongo datastore scanning the given packages

  Parameters:

  configuration - The configuration

  packagesToScan - The packages to scan

• public MongoDatastore(java.util.Map<java.lang.String, java.lang.Object> configuration, java.lang.Package packagesToScan)

  Construct a Mongo datastore scanning the given packages

  Parameters:

  configuration - The configuration

  packagesToScan - The packages to scan

• public MongoDatastore(org.springframework.core.env.PropertyResolver configuration, ConfigurableApplicationEventPublisher eventPublisher, java.lang.Package packagesToScan)

  Construct a Mongo datastore scanning the given packages

  Parameters:

  configuration - The configuration

  eventPublisher - The event publisher

  packagesToScan - The packages to scan

Method Detail

• public void buildIndex()

  Creates and reconciles the indexes declared by the domain classes mapped to this datastore's connection.

  GORM calls this itself when the datastore starts, unless grails.mongodb.buildIndexes is false; that setting only stops GORM building by itself, so an application that leaves indexes alone at startup can call this when it chooses to build them. Each named connection builds its own domain classes: call it on getDatastoreForConnection(String) for those.

  Each index is created by a command that the server answers only once the index has been built, so this blocks the calling thread for as long as MongoDB takes to build every declared index. With grails.mongodb.buildIndexesAsync enabled the work goes to a background thread and this returns immediately instead. buildIndexAsync() runs it in the background whatever the setting, and reports the outcome to its caller. Builds on a connection run one at a time, wherever they run: a build on the calling thread first waits for one running in the background, and the other way round, and a domain class registered after startup is indexed once neither is running.

• public java.util.concurrent.CompletableFuture<IndexBuildResult> buildIndexAsync()

  Runs the same build as buildIndex() on this connection's background index build thread, whatever grails.mongodb.buildIndexesAsync says, and returns at once with a handle on its outcome.

  The future completes with the build's IndexBuildResult once every declaration has been applied, including when some of them failed: those are counted in IndexBuildResult.failures and logged as they happen. It completes exceptionally with the exception that stopped the build partway, such as a lost connection or a write concern the server could not satisfy. Created and already-present indexes are always told apart, whatever the log level.

  Builds on a connection run one at a time, so a build requested while another is running waits for it, including one running on a caller's thread with buildIndex(), or one indexing a domain class registered after startup. Cancelling the future does not stop the build. If the datastore is stopped or closed, the future completes exceptionally at once, and a build that stopping or closing the datastore cuts short completes exceptionally too; a restart runs the cut-short build again, without a future. Each named connection builds its own domain classes: call this on getDatastoreForConnection(String) for those.

  Returns:

  the outcome of the build

• @java.lang.Override
  @jakarta.annotation.PreDestroy
  public void close()

• protected static ConnectionSources<MongoClient, MongoConnectionSourceSettings> createDefaultConnectionSources(MongoClient mongoClient, org.springframework.core.env.PropertyResolver configuration, MongoMappingContext mappingContext, boolean closeable)

  Creates the connection sources for a MongoClient.

  Parameters:

  mongoClient - The MongoClient

  configuration - The configuration

  mappingContext - The MongoMappingContext

  closeable - whether GORM owns the client and should close it on shutdown. Pass false for an externally-supplied client (its lifecycle is owned by the caller, e.g. a Spring-managed bean) and true for a client GORM created itself, so it is not leaked.

  Returns:

  The ConnectionSources

• protected static MongoMappingContext createMappingContext(ConnectionSources<MongoClient, MongoConnectionSourceSettings> connectionSources, java.lang.Class classes)

• protected static MongoMappingContext createMappingContext(org.springframework.core.env.PropertyResolver configuration, java.lang.Class classes)

• protected static MongoClient createMongoClient(org.springframework.core.env.PropertyResolver configuration, Builder mongoOptions, MongoMappingContext mappingContext)

• @java.lang.Override
  protected Session createSession(org.springframework.core.env.PropertyResolver connDetails)

• @java.lang.Override
  protected Session createStatelessSession(org.springframework.core.env.PropertyResolver connectionDetails)

• public java.util.List<UndeclaredIndex> dropUndeclaredIndexes()

  Drops every index that findUndeclaredIndexes() reports.

  Run this deliberately, once every instance of the application runs the release whose domain classes declare the indexes to keep. An instance still on an earlier release does not declare what a later release added, nor an index created by hand ahead of a deployment, so to it those indexes are undeclared and this drops them.

  Returns:

  the indexes dropped

• public java.util.List<UndeclaredIndex> dropUndeclaredIndexes(java.util.List<UndeclaredIndex> indexes)

  Drops the given indexes: those findUndeclaredIndexes() reported, once they have been reviewed.

  Each index is checked again before it is dropped, since the reviewed list can be older than what is on the server: one is dropped only while the index of that name is on the keys reviewed, its collection is mapped on this datastore's connection, and no domain class mapped to it declares those keys. An index that no longer exists, or whose collection no longer does, is skipped, and so is one that fails a check, which is logged at WARN.

  Parameters:

  indexes - the indexes to drop

  Returns:

  the indexes dropped

• public java.util.List<MissingIndex> findMissingIndexes()

  Lists the indexes the domain classes declare that their collections do not have, on the collections whose declared indexes buildIndex() builds for this datastore's connection.

  A declared index is present when its collection has an index on the same key pattern, the same fields in the same order, whatever its name and options: an option that differs is the build's to reconcile. A text index is present when one indexes the same text fields, in any order, with the same keys before and after them, whatever its weights. Keys that several classes mapped to one collection declare are reported once. Nothing is changed: buildIndex() or buildIndexAsync() creates them. Each named connection has its own domain classes, so call this on getDatastoreForConnection(String) for those.

  Returns:

  the missing indexes, collection by collection, in the order the domain classes declare them

• public java.util.List<UndeclaredIndex> findUndeclaredIndexes()

  Lists the indexes that no domain class declares, on the collections whose declared indexes buildIndex() builds for this datastore's connection.

  An index is declared when a domain class mapped to the same collection declares its key pattern, the same fields in the same order, with compoundIndex, index or a property's index: true. Its name and options do not matter. A text index is declared when a class declares text on the same fields, in any order, with the same keys before and after them; its weights do not matter. The _id index is never reported, and neither is any index on a collection that no domain class maps. An index that an initializeIndices(PersistentEntity) override creates by itself is not a declaration, so it is reported.

  Nothing is changed: see dropUndeclaredIndexes(). Each named connection has its own domain classes, so call this on getDatastoreForConnection(String) for those.

  Returns:

  the undeclared indexes, collection by collection, in the order the server lists them

• @java.lang.Override
  public ConfigurableApplicationEventPublisher getApplicationEventPublisher()

  Returns:

  The ConfigurableApplicationEventPublisher instance used by this datastore

• public AutoTimestampEventListener getAutoTimestampEventListener()

• public CodecRegistry getCodecRegistry()

  Returns:

  The CodecRegistry

• public com.mongodb.client.MongoCollection<Document> getCollection(PersistentEntity entity)

  Obtain the raw com.mongodb.client.MongoCollection for the given entity

  Parameters:

  entity - The entity

  Returns:

  The Mongo collection

• public java.lang.String getCollectionName(PersistentEntity entity)

  Gets the default collection name for the given entity

  Parameters:

  entity - The entity

  Returns:

  The collection name

• public ConnectionSources<MongoClient, MongoConnectionSourceSettings> getConnectionSources()

  Returns:

  The ConnectionSources for this datastore

• public java.lang.String getDatabaseName(PersistentEntity entity)

• @java.lang.Override
  public MongoDatastore getDatastoreForConnection(java.lang.String connectionName)

• @java.lang.Override
  public Datastore getDatastoreForConnection(java.lang.String connectionName)

• @java.lang.Override
  public MongoDatastore getDatastoreForTenantId(java.io.Serializable tenantId)

• public java.lang.String getDefaultDatabase()

  Returns:

  The default database name

• public jakarta.persistence.FlushModeType getDefaultFlushMode()

  Returns:

  The default flush mode

• <D> @java.lang.Override
  protected GormInstanceApi<D> getInstanceApi(java.lang.Class<D> cls, java.lang.String qualifier)

• @java.lang.Override
  public MongoMappingContext getMappingContext()

  Returns:

  The mapping context

• public MongoClient getMongoClient()

  Returns:

  The MongoClient instance

• @java.lang.Override
  public MultiTenancyMode getMultiTenancyMode()

• public PersistentEntityCodec getPersistentEntityCodec(PersistentEntity entity)

  Obtains a PersistentEntityCodec for the given entity

  Parameters:

  entity - The entity

  Returns:

  The PersistentEntityCodec

• public PersistentEntityCodec getPersistentEntityCodec(java.lang.Class entityClass)

  Obtains a PersistentEntityCodec for the given entity

  Parameters:

  entityClass - The entity class

  Returns:

  The PersistentEntityCodec

• @java.lang.Override
  public int getPhase()

• <D> @java.lang.Override
  protected MongoStaticApi<D> getStaticApi(java.lang.Class<D> cls, java.lang.String qualifier)

• @java.lang.Override
  public TenantResolver getTenantResolver()

• public org.springframework.transaction.PlatformTransactionManager getTransactionManager()

  Returns:

  The transaction manager

• <D> @java.lang.Override
  protected GormValidationApi<D> getValidationApi(java.lang.Class<D> cls, java.lang.String qualifier)

• @java.lang.Override
  protected MongoGormEnhancer initialize(MongoConnectionSourceSettings settings)

• protected MongoGormEnhancer initialize(MongoConnectionSourceSettings settings)

  Runs the initialization sequence

  Parameters:

  settings

• protected void initializeIndices(PersistentEntity entity)

  Indexes any properties that are mapped with index:true. Called for both startup builds and entities registered later, so subclasses can customise index creation on either path.

  With grails.mongodb.buildIndexesAsync enabled the startup build calls this on a background thread, and it can do so before the constructor of a subclass has finished. An override must not depend on state that its own constructor or field initializers set up.

  Parameters:

  entity - The entity

• public boolean isBuildIndexes()

  Whether GORM creates and reconciles the indexes declared in the domain class mapping blocks by itself: when the datastore starts, and for connections and domain classes added later. Disabled with grails.mongodb.buildIndexes = false, which leaves the indexes on the server as they are until buildIndex() is called.

  Returns:

  true if GORM builds the declared indexes by itself

  Since:

  8.0

• public boolean isBuildIndexesAsync()

  Whether index builds run on a background thread instead of blocking the thread that starts them - the one GORM starts on startup, and any buildIndex() the application calls. Enabled with grails.mongodb.buildIndexesAsync = true.

  Returns:

  true if declared indexes are built asynchronously

  Since:

  8.0

• @java.lang.Override
  public boolean isRunning()

• @java.lang.Override
  public boolean isSchemaless()

• public boolean isTransactionsEnabled()

  Whether GORM should use real MongoDB multi-document transactions (a server-side ClientSession) for transactional operations. This is opt-in via grails.mongodb.transactional and additionally requires a replica set or sharded cluster; if a standalone topology is positively detected the feature is disabled (with a one-time warning) and GORM falls back to the legacy client-side flush behavior.

  Returns:

  true if server-side transactions should be used

  Since:

  8.0

• public void newConnectionSource(ConnectionSource<MongoClient, MongoConnectionSourceSettings> connectionSource)

• @java.lang.Override
  public void persistentEntityAdded(PersistentEntity entity)

• public void persistentEntityAdded(PersistentEntity entity)

• protected void registerAllEntitiesWithEnhancer()

• protected void registerEntity(PersistentEntity entity)

• protected void registerEventListeners(ConfigurableApplicationEventPublisher eventPublisher)

• @java.lang.Override
  public java.io.Serializable resolveTenantIdentifier()

• @java.lang.Override
  public java.lang.Iterable<java.io.Serializable> resolveTenantIds()

• @org.springframework.beans.factory.annotation.Autowired(required = false)
  public void setCodecProviders(java.util.List<CodecProvider> codecProviders)

  Sets any additional codec providers

  Parameters:

  codecProviders - The CodecProvider instances

• @org.springframework.beans.factory.annotation.Autowired(required = false)
  public void setCodecRegistries(java.util.List<CodecRegistry> codecRegistries)

  Sets any additional codec registries

  Parameters:

  codecRegistries - The CodecRegistry instances

• @org.springframework.beans.factory.annotation.Autowired(required = false)
  public void setCodecs(java.util.List<Codec<?>> codecs)

  Sets any additional codecs

  Parameters:

  codecs - The Codec instances

• @org.springframework.beans.factory.annotation.Autowired(required = false)
  public void setMessageSource(java.util.List<org.springframework.context.MessageSource> messageSources)

  The message source used for validation messages

  Parameters:

  messageSources - The message source

• public void setMessageSource(org.springframework.context.MessageSource messageSource)

• @java.lang.Override
  public void start()

  Connects the datastore, which is the first point at which it opens a socket.

  The first start connects the client of every connection GORM owns and builds the indexes the domain classes declare, unless grails.mongodb.buildIndexes is false. Nothing before it connects: the clients GORM creates are RestartableMongoClients, which connect when first used, and building the datastore builds no index. So a datastore created while an application context refreshes holds no socket until Spring starts it in LIFECYCLE_PHASE, which is what lets the process be checkpointed with CRaC as the context refreshes (spring.context.checkpoint=onRefresh). Spring starts it before it publishes ContextRefreshedEvent, so the indexes are in place before BootStrap runs and before the web server accepts a request. A datastore that nothing starts - one built outside an application context - starts itself the first time a session is opened on it.

  Starting after stop() brings back each MongoClient it stopped: a RestartableMongoClient builds a new driver client and stays the one handed out, and any other client is replaced by one built by the same factory the original was built with, so settings applied at startup still apply. A replacement is handed out by the connection's ConnectionSource as well as by this datastore, when that is a MongoConnectionSource. The indexes are not built again, since they outlive a checkpoint on the server, but a background index build that stop() cut short, or that was requested while stopped, runs again on a fresh executor, on every connection. A connection added while the datastore was stopped is connected and has its indexes built here.

  A connection registered while this runs is not left out. One registered by another thread waits for it to finish and is then connected and built as the running datastore's connections are; one registered by this thread, from an index build hook, is taken up by another pass before this returns.

• @java.lang.Override
  public void stop()

  Stops the MongoClient of every connection, so the process can be checkpointed.

  CRaC refuses to checkpoint a process holding open sockets, and a connected driver holds one per pooled connection plus its server monitors. Closing the driver client shuts the monitor threads down and releases every socket, which nothing else in the driver offers: draining the pool leaves the monitors connected. Each connection declared under grails.mongodb.connections, or added at runtime, has a client of its own, and each is stopped.

  A RestartableMongoClient, which is what GORM creates, closes its driver client and stays the client the datastore hands out, so whatever holds it - the mongo bean among them - works again once start() has restarted it. Any other client GORM owns is closed, and start() builds a replacement.

  Every client is stopped whether or not the datastore has started: one used before it was started, or connected by a start() that then failed, holds sockets as much as one the datastore started. Until start() is called again the clients refuse to be used, and using the datastore does not start it.

  A client the application supplied is left alone. Its lifecycle belongs to whoever created it, and start() does not replace it. A datastore that owns none of its clients stays running.

  A background index build still running, on this connection or any other, is interrupted first rather than left to fail against a closed client, and start() runs it again.

• <T1> @java.lang.Override
  public T1 withNewSession(java.io.Serializable tenantId, groovy.lang.Closure<T1> callable)