Method fetchAndLoadConfigs

rest/config.go:1650–1711

fetchAndLoadConfigs retrieves all database configs from the ServerContext's bootstrapConnection, and loads them into the ServerContext. It will remove any databases currently running that are not found in the bucket.

(ctx context.Context, isInitialStartup bool)

// fetchAndLoadConfigs retrieves all database configs from the ServerContext's bootstrapConnection, and loads them into the ServerContext.
// It will remove any databases currently running that are not found in the bucket.
func (sc *ServerContext) fetchAndLoadConfigs(ctx context.Context, isInitialStartup bool) (count int, err error) {
	fetchedConfigs, err := sc.FetchConfigs(ctx, isInitialStartup)
	if err != nil {
		return 0, err
	}

	// Check if we need to update the set of databases before we have to acquire the write lock to do so
	// we don't need to do this two-stage lock on initial startup as the REST APIs aren't even online yet.
	var deletedDatabases []string
	if !isInitialStartup {
		sc._databasesLock.RLock()
		for dbName, _ := range sc._dbRegistry {
			if _, foundMatchingDb := fetchedConfigs[dbName]; !foundMatchingDb {
				deletedDatabases = append(deletedDatabases, dbName)
				delete(fetchedConfigs, dbName)
			}
		}
		for dbName, fetchedConfig := range fetchedConfigs {
			if dbConfig, ok := sc._dbConfigs[dbName]; ok && dbConfig.cfgCas >= fetchedConfig.cfgCas {
				sc.invalidDatabaseConfigTracking.remove(dbName)
				base.DebugfCtx(ctx, base.KeyConfig, "Database %q bucket %q config has not changed since last update", fetchedConfig.Name, *fetchedConfig.Bucket)
				delete(fetchedConfigs, dbName)
			}
		}
		sc._databasesLock.RUnlock()

		// nothing to do, we can bail out without needing the write lock
		if len(deletedDatabases) == 0 && len(fetchedConfigs) == 0 {
			base.TracefCtx(ctx, base.KeyConfig, "No persistent config changes to make")
			return 0, nil
		}
	}

	// we have databases to update/remove
	sc._databasesLock.Lock()
	defer sc._databasesLock.Unlock()
	for _, dbName := range deletedDatabases {
		dbc, ok := sc._databases[dbName]
		if !ok {
			base.DebugfCtx(ctx, base.KeyConfig, "Database %q already removed from server context after acquiring write lock - do not need to remove not removing database", base.MD(dbName))
			continue
		}
		// It's possible that the "deleted" database was not written to the server until after sc.FetchConfigs had returned...
		// we'll need to pay for the cost of getting the config again now that we've got the write lock to double-check this db is definitely ok to remove...
		found, _, getConfigErr := sc._fetchDatabaseFromBucket(ctx, dbc.Bucket.GetName(), dbName)
		if found && getConfigErr == nil {
			base.DebugfCtx(ctx, base.KeyConfig, "Found config for database %q after acquiring write lock - not removing database", base.MD(dbName))
			continue
		}
		if base.IsTemporaryKvError(getConfigErr) {
			base.InfofCtx(ctx, base.KeyConfig, "Transient error fetching config for database %q to check whether we need to remove it, will not be removed: %v", base.MD(dbName), getConfigErr)
			continue
		}

		if !found {
			base.InfofCtx(ctx, base.KeyConfig, "Database %q was running on this node, but config was not found on the server - removing database (%v)", base.MD(dbName), getConfigErr)
			sc._removeDatabase(ctx, dbName)
		}