Function NewServerContext

rest/server_context.go:164–212

(ctx context.Context, config *StartupConfig, persistentConfig bool)

}

func NewServerContext(ctx context.Context, config *StartupConfig, persistentConfig bool) *ServerContext {

	sc := &ServerContext{
		Config:              config,
		persistentConfig:    persistentConfig,
		_dbRegistry:         map[string]struct{}{},
		_collectionRegistry: map[string]string{},
		_dbConfigs:          map[string]*RuntimeDatabaseConfig{},
		_databases:          map[string]*db.DatabaseContext{},
		DatabaseInitManager: &DatabaseInitManager{},
		HTTPClient:          http.DefaultClient,
		statsContext:        &statsContext{heapProfileEnabled: !config.HeapProfileDisableCollection},
		BootstrapContext:    &bootstrapContext{sgVersion: *base.ProductVersion},
		hasStarted:          make(chan struct{}),
		_httpServers:        map[serverType]*serverInfo{},
		SGCollect:           newSGCollect(ctx),
	}
	sc.invalidDatabaseConfigTracking = invalidDatabaseConfigs{
		dbNames: map[string]*invalidConfigInfo{},
	}

	if base.ServerIsWalrus(sc.Config.Bootstrap.Server) {
		// Disable Admin API authentication when running as walrus on the default admin interface to support dev
		// environments.
		if sc.Config.API.AdminInterface == DefaultAdminInterface {
			sc.Config.API.AdminInterfaceAuthentication = base.Ptr(false)
			sc.Config.API.MetricsInterfaceAuthentication = base.Ptr(false)
		}
	}
	if config.Replicator.MaxConcurrentReplications != 0 {
		sc.ActiveReplicationsCounter.activeReplicatorLimit = config.Replicator.MaxConcurrentReplications
	}

	if config.HeapProfileCollectionThreshold != nil {
		sc.statsContext.heapProfileCollectionThreshold = *config.HeapProfileCollectionThreshold
	} else {
		memoryTotal := getTotalMemory(ctx)
		if memoryTotal != 0 {
			sc.statsContext.heapProfileCollectionThreshold = uint64(float64(memoryTotal) * 0.85)
		} else {
			base.WarnfCtx(ctx, "Could not determine system memory, disabling automatic heap profile collection")
			sc.statsContext.heapProfileEnabled = false
		}
	}

	sc.startStatsLogger(ctx)

	return sc
}

func (sc *ServerContext) WaitForRESTAPIs(ctx context.Context) error {
	timeout := 30 * time.Second