server

var Start action.GTSAction = func(ctx context.Context) error {
	if _, err := maxprocs.Set(maxprocs.Logger(nil)); err != nil {
		log.Infof(ctx, "could not set CPU limits from cgroup: %s", err)
	}

	var state state.State

	state.Caches.Init()
	state.Caches.Start()
	defer state.Caches.Stop()

	if err := tracing.Initialize(); err != nil {
		return fmt.Errorf("error initializing tracing: %w", err)
	}

	dbService, err := bundb.NewBunDBService(ctx, &state)
	if err != nil {
		return fmt.Errorf("error creating dbservice: %s", err)
	}

	state.DB = dbService

	if err := dbService.CreateInstanceAccount(ctx); err != nil {
		return fmt.Errorf("error creating instance account: %s", err)
	}

	if err := dbService.CreateInstanceInstance(ctx); err != nil {
		return fmt.Errorf("error creating instance instance: %s", err)
	}

	instanceAccount, err := dbService.GetInstanceAccount(ctx, "")
	if err != nil {
		return fmt.Errorf("error retrieving instance account: %w", err)
	}

	storage, err := gtsstorage.AutoConfig()
	if err != nil {
		return fmt.Errorf("error creating storage backend: %w", err)
	}

	state.Storage = storage

	client := httpclient.New(httpclient.Config{
		AllowRanges:           config.MustParseIPPrefixes(config.GetHTTPClientAllowIPs()),
		BlockRanges:           config.MustParseIPPrefixes(config.GetHTTPClientBlockIPs()),
		Timeout:               config.GetHTTPClientTimeout(),
		TLSInsecureSkipVerify: config.GetHTTPClientTLSInsecureSkipVerify(),
	})

	state.Workers.Start()
	defer state.Workers.Stop()

	_ = state.Workers.Scheduler.AddRecurring(
		"@cachesweep",
		time.Time{},
		time.Minute,
		func(context.Context, time.Time) {
			state.Caches.Sweep(60)
		},
	)

	mediaManager := media.NewManager(&state)
	oauthServer := oauth.New(ctx, dbService)
	typeConverter := typeutils.NewConverter(&state)
	visFilter := visibility.NewFilter(&state)
	spamFilter := spam.NewFilter(&state)
	federatingDB := federatingdb.New(&state, typeConverter, visFilter, spamFilter)
	transportController := transport.NewController(&state, federatingDB, &federation.Clock{}, client)
	federator := federation.NewFederator(&state, federatingDB, transportController, typeConverter, visFilter, mediaManager)

	// Decide whether to create a noop email
	// sender (won't send emails) or a real one.
	var emailSender email.Sender
	if smtpHost := config.GetSMTPHost(); smtpHost != "" {

		emailSender, err = email.NewSender()
		if err != nil {
			return fmt.Errorf("error creating email sender: %s", err)
		}
	} else {

		emailSender, err = email.NewNoopSender(nil)
		if err != nil {
			return fmt.Errorf("error creating noop email sender: %s", err)
		}
	}

	state.Timelines.Home = timeline.NewManager(
		tlprocessor.HomeTimelineGrab(&state),
		tlprocessor.HomeTimelineFilter(&state, visFilter),
		tlprocessor.HomeTimelineStatusPrepare(&state, typeConverter),
		tlprocessor.SkipInsert(),
	)
	if err := state.Timelines.Home.Start(); err != nil {
		return fmt.Errorf("error starting home timeline: %s", err)
	}

	state.Timelines.List = timeline.NewManager(
		tlprocessor.ListTimelineGrab(&state),
		tlprocessor.ListTimelineFilter(&state, visFilter),
		tlprocessor.ListTimelineStatusPrepare(&state, typeConverter),
		tlprocessor.SkipInsert(),
	)
	if err := state.Timelines.List.Start(); err != nil {
		return fmt.Errorf("error starting list timeline: %s", err)
	}

	cleaner := cleaner.New(&state)

	processor := processing.NewProcessor(
		cleaner,
		typeConverter,
		federator,
		oauthServer,
		mediaManager,
		&state,
		emailSender,
	)

	state.Workers.EnqueueClientAPI = processor.Workers().EnqueueClientAPI
	state.Workers.EnqueueFediAPI = processor.Workers().EnqueueFediAPI

	state.Workers.ProcessFromClientAPI = processor.Workers().ProcessFromClientAPI
	state.Workers.ProcessFromFediAPI = processor.Workers().ProcessFromFediAPI

	if err := processor.Polls().ScheduleAll(ctx); err != nil {
		return fmt.Errorf("error scheduling poll expiries: %w", err)
	}

	if err := metrics.Initialize(state.DB); err != nil {
		return fmt.Errorf("error initializing metrics: %w", err)
	}

	router, err := router.New(ctx)
	if err != nil {
		return fmt.Errorf("error creating router: %s", err)
	}

	middlewares := make([]gin.HandlerFunc, 1)

	middlewares[0] = middleware.AddRequestID(config.GetRequestIDHeader())

	if config.GetTracingEnabled() {
		middlewares = append(middlewares, tracing.InstrumentGin())
	}

	if config.GetMetricsEnabled() {
		middlewares = append(middlewares, metrics.InstrumentGin())
	}

	middlewares = append(middlewares, []gin.HandlerFunc{

		middleware.Logger(config.GetLogClientIP()),
		middleware.HeaderFilter(&state),
		middleware.UserAgent(),
		middleware.CORS(),
		middleware.ExtraHeaders(),
	}...)

	cspExtraURIs := make([]string, 0)

	storageCSPUri, err := state.Storage.ProbeCSPUri(ctx)
	if err != nil {
		return fmt.Errorf("error deriving Content-Security-Policy uri from storage: %w", err)
	}

	if storageCSPUri != "" {
		cspExtraURIs = append(cspExtraURIs, storageCSPUri)
	}

	cspExtraURIs = append(cspExtraURIs, config.GetAdvancedCSPExtraURIs()...)

	middlewares = append(middlewares, middleware.ContentSecurityPolicy(cspExtraURIs...))

	router.AttachGlobalMiddleware(middlewares...)

	router.AttachNoRouteHandler(func(c *gin.Context) {
		apiutil.ErrorHandler(c, gtserror.NewErrorNotFound(errors.New(http.StatusText(http.StatusNotFound))), processor.InstanceGetV1)
	})

	// build router modules
	var idp oidc.IDP
	if config.GetOIDCEnabled() {
		idp, err = oidc.NewIDP(ctx)
		if err != nil {
			return fmt.Errorf("error creating oidc idp: %w", err)
		}
	}

	routerSession, err := dbService.GetSession(ctx)
	if err != nil {
		return fmt.Errorf("error retrieving router session for session middleware: %w", err)
	}

	sessionName, err := middleware.SessionName()
	if err != nil {
		return fmt.Errorf("error generating session name for session middleware: %w", err)
	}

	var (
		authModule        = api.NewAuth(dbService, processor, idp, routerSession, sessionName) // auth/oauth paths
		clientModule      = api.NewClient(dbService, processor)                                // api client endpoints
		metricsModule     = api.NewMetrics()                                                   // Metrics endpoints
		healthModule      = api.NewHealth(dbService.Ready)                                     // Health check endpoints
		fileserverModule  = api.NewFileserver(processor)                                       // fileserver endpoints
		wellKnownModule   = api.NewWellKnown(processor)                                        // .well-known endpoints
		nodeInfoModule    = api.NewNodeInfo(processor)                                         // nodeinfo endpoint
		activityPubModule = api.NewActivityPub(dbService, processor)                           // ActivityPub endpoints
		webModule         = web.New(dbService, processor)                                      // web pages + user profiles + settings panels etc
	)

	rlLimit := config.GetAdvancedRateLimitRequests()
	rlExceptions := config.GetAdvancedRateLimitExceptions()
	clLimit := middleware.RateLimit(rlLimit, rlExceptions)
	s2sLimit := middleware.RateLimit(rlLimit, rlExceptions)
	fsMainLimit := middleware.RateLimit(rlLimit, rlExceptions)
	fsEmojiLimit := middleware.RateLimit(rlLimit*2, rlExceptions)

	cpuMultiplier := config.GetAdvancedThrottlingMultiplier()
	retryAfter := config.GetAdvancedThrottlingRetryAfter()
	clThrottle := middleware.Throttle(cpuMultiplier, retryAfter)
	s2sThrottle := middleware.Throttle(cpuMultiplier, retryAfter)
	fsThrottle := middleware.Throttle(cpuMultiplier, retryAfter)
	pkThrottle := middleware.Throttle(cpuMultiplier, retryAfter)

	gzip := middleware.Gzip()

	authModule.Route(router, clLimit, clThrottle, gzip)
	clientModule.Route(router, clLimit, clThrottle, gzip)
	metricsModule.Route(router, clLimit, clThrottle, gzip)
	healthModule.Route(router, clLimit, clThrottle)
	fileserverModule.Route(router, fsMainLimit, fsThrottle)
	fileserverModule.RouteEmojis(router, instanceAccount.ID, fsEmojiLimit, fsThrottle)
	wellKnownModule.Route(router, gzip, s2sLimit, s2sThrottle)
	nodeInfoModule.Route(router, s2sLimit, s2sThrottle, gzip)
	activityPubModule.Route(router, s2sLimit, s2sThrottle, gzip)
	activityPubModule.RoutePublicKey(router, s2sLimit, pkThrottle, gzip)
	webModule.Route(router, fsMainLimit, fsThrottle, gzip)

	server := gotosocial.NewServer(dbService, router, cleaner)
	if err := server.Start(ctx); err != nil {
		return fmt.Errorf("error starting gotosocial service: %s", err)
	}

	sigs := make(chan os.Signal, 1)
	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
	sig := <-sigs
	log.Infof(ctx, "received signal %s, shutting down", sig)

	if err := server.Stop(ctx); err != nil {
		return fmt.Errorf("error closing gotosocial service: %s", err)
	}

	log.Info(ctx, "done! exiting...")
	return nil
}