server

Documentation

Index

• Variables

Variables

var Start action.Action = func(ctx context.Context) error {
	l := logger.WithField("func", "Start")
	l.Infof("starting")

	metricsCollector, err := statsd.New(
		viper.GetString(config.Keys.MetricsStatsDAddress),
		viper.GetString(config.Keys.MetricsStatsDPrefix),
	)
	if err != nil {
		l.Errorf("metrics: %s", err.Error())

		return err
	}
	defer func() {
		err := metricsCollector.Close()
		if err != nil {
			l.Errorf("closing metrics: %s", err.Error())
		}
	}()

	dbClient, err := bun.New(ctx, metricsCollector)
	if err != nil {
		l.Errorf("db: %s", err.Error())

		return err
	}
	defer func() {
		err := dbClient.Close(ctx)
		if err != nil {
			l.Errorf("closing db: %s", err.Error())
		}
	}()

	redisClient, err := redis.New(ctx)
	if err != nil {
		l.Errorf("redis: %s", err.Error())

		return err
	}
	defer func() {
		err := redisClient.Close(ctx)
		if err != nil {
			l.Errorf("closing redis: %s", err.Error())
		}
	}()

	httpClient, err := http.NewClient(ctx)
	if err != nil {
		l.Errorf("http client: %s", err.Error())

		return err
	}

	tokz, err := token.New()
	if err != nil {
		l.Errorf("create tokenizer: %s", err.Error())

		return err
	}

	languageMod, err := language.New()
	if err != nil {
		l.Errorf("language: %s", err.Error())

		return err
	}

	fediMod, err := fedi.New(dbClient, httpClient, redisClient, tokz)
	if err != nil {
		l.Errorf("fedi: %s", err.Error())

		return err
	}

	// create filestore module
	var fsMod filestore.FileStore

	switch viper.GetString(config.Keys.FileStoreType) {
	case config.FileStoreTypeLocal:
		fsMod, err = fslocal.New(redisClient)
		if err != nil {
			l.Errorf("filestore-local: %s", err.Error())

			return err
		}
	case config.FileStoreTypeMinio:
		fsMod, err = minio.New()
		if err != nil {
			l.Errorf("filestore-minio: %s", err.Error())

			return err
		}
	default:
		err = fmt.Errorf("unknow filestore type: %s", viper.GetString(config.Keys.FileStoreType))
		l.Error(err)

		return err
	}

	l.Debug("creating http server")
	httpServer, err := http.NewServer(ctx, metricsCollector)
	if err != nil {
		l.Errorf("http httpServer: %s", err.Error())

		return err
	}

	webModules := []http.Module{fsMod}
	if lib.ContainsString(viper.GetStringSlice(config.Keys.ServerRoles), config.ServerRoleWebapp) {
		l.Infof("adding webapp module")
		webMod, err := webapp.New(ctx, dbClient, redisClient, fediMod, languageMod, tokz, metricsCollector)
		if err != nil {
			l.Errorf("webapp module: %s", err.Error())

			return err
		}
		webModules = append(webModules, webMod)
	}

	for _, mod := range webModules {
		mod.SetServer(httpServer)
		err := mod.Route(httpServer)
		if err != nil {
			l.Errorf("loading %s module: %s", mod.Name(), err.Error())

			return err
		}
	}

	errChan := make(chan error)

	stopSigChan := make(chan os.Signal, 1)
	signal.Notify(stopSigChan, syscall.SIGINT, syscall.SIGTERM)

	go func(s *http.Server, errChan chan error) {
		l.Debug("starting http server")
		err := s.Start()
		if err != nil {
			errChan <- fmt.Errorf("http server: %s", err.Error())
		}
	}(httpServer, errChan)

	select {
	case sig := <-stopSigChan:
		l.Infof("got sig: %s", sig)
	case err := <-errChan:
		l.Fatal(err.Error())
	}

	l.Infof("done")

	return nil
}

Start starts the server.