server

Documentation

Index

• Variables

Variables

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

	if logrus.GetLevel() == logrus.TraceLevel {
		logConfig(l)
	}

	l.Infof("starting")

	endpointURL, err := url.Parse(viper.GetString(config.Keys.ExternalEndpoint))
	if err != nil {
		return fmt.Errorf("parsing endpoint: %s", err.Error())
	}

	uptrace.ConfigureOpentelemetry(
		uptrace.WithServiceName(viper.GetString(config.Keys.ApplicationName)),
		uptrace.WithServiceVersion(viper.GetString(config.Keys.SoftwareVersion)),
	)
	defer func() {
		l.Info("closing uptrace")
		err := uptrace.Shutdown(context.Background())
		if err != nil {
			l.Errorf("closing uptrace: %s", err.Error())
		}
	}()

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

	metricsServer := metrics.New(viper.GetString(config.Keys.MetricsHTTPBind))

	httpClient := bhttp.NewClient(
		viper.GetString(config.Keys.ApplicationName),
		viper.GetString(config.Keys.SoftwareVersion),
		viper.GetString(config.Keys.ExternalEndpoint),
	)

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

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

	cacheClient := memory.New(ctx)

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

		return err
	}

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

		return err
	}

	logicMod := logic.New(&logic.Config{
		Cache: cacheClient,
		DB:    dbClient,
		HTTP:  httpClient,
		Tokz:  tokz,

		AppName:      viper.GetString(config.Keys.ApplicationName),
		AppWebsite:   viper.GetString(config.Keys.ApplicationWebsite),
		ServerSchema: endpointURL.Scheme,
		ServerHost:   endpointURL.Host,
	})

	l.Debug("creating http server")
	httpServer, err := bhttp.NewServer(ctx, viper.GetString(config.Keys.HTTPBind), viper.GetString(config.Keys.ApplicationName))
	if err != nil {
		l.Errorf("http server: %s", err.Error())

		return err
	}

	// create web modules
	var webModules []bhttp.Module

	l.Info("adding webapp module")
	apMod, err := webapp.New(
		ctx,
		languageMod,
		logicMod,
		kvClient.RedisClient(),
		tokz,
		endpointURL.Host,
	)
	if err != nil {
		return fmt.Errorf("webapp: %s", err.Error())
	}
	webModules = append(webModules, apMod)

	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(m *metrics.Module, errChan chan error) {
		l.Debug("starting metrics server")
		err := m.Start()
		if err != nil {
			errChan <- fmt.Errorf("metrics server: %s", err.Error())
		}
	}(metricsServer, errChan)

	go func(s *bhttp.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.