start

Documentation

Index

• Variables

Variables

var Start action.Action = func(topCtx context.Context, args []string) error {
	l := logger.WithField("func", "Start")
	l.Info("starting")
	l.Infof("args: %+v", args)

	roleList, err := gatherRoles(args)
	if err != nil {
		return err
	}

	ctx, cancel := context.WithCancel(topCtx)

	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 clock")
	clockMod := clock.NewClock()

	l.Debug("creating database client")
	dbClient, err := bun.New(ctx)
	if err != nil {
		l.Errorf("db: %s", err.Error())
		cancel()

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

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

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

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

		return err
	}

	l.Debug("creating logic module")
	logicMod, err := v1.New(ctx, clockMod, dbClient, kvClient, tokz)
	if err != nil {
		l.Errorf("logic: %s", err.Error())
		cancel()

		return err
	}

	l.Debug("creating runner module")
	runnerMod, err := faktory.New(logicMod)
	if err != nil {
		l.Errorf("runner: %s", err.Error())
		cancel()

		return err
	}
	logicMod.SetRunner(runnerMod)

	// create gemini server
	var geminiMod *gemini.Server
	if shouldStart(roleList, roleGemini) {
		l.Debug("creating gemini server")

		var err error
		geminiMod, err = newGemini(ctx, logicMod, tokz)
		if err != nil {
			l.Errorf("gemini: %s", err.Error())
			cancel()

			return err
		}
	}

	// create gemini server
	var httpServer *ihttp.Server
	if shouldStart(roleList, roleActivityPub) {
		l.Debug("creating http server")

		var err error
		httpServer, err = newHttpServer(
			ctx,
			logicMod,
			runnerMod,
		)
		if err != nil {
			l.Errorf("http server: %s", err.Error())
			cancel()

			return err
		}
	}

	errChan := make(chan error)

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

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

	if shouldStart(roleList, roleActivityPub) {
		go func(s *ihttp.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)
	}

	if shouldStart(roleList, roleWorker) {
		go func(c context.Context, s *faktory.Runner, errChan chan error) {
			l.Debug("starting worker")
			err := s.Start(c)
			if err != nil {
				errChan <- fmt.Errorf("worker: %s", err.Error())
			}
		}(ctx, runnerMod, errChan)
	}

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

	<-ctx.Done()
	l.Infof("done")

	return nil
}

Start starts the server.