maps-service/pkg/cmds/serve.go

package cmds

import (
	"fmt"
	"net"
	"net/http"

	"git.itzana.me/strafesnet/go-grpc/auth"
	"git.itzana.me/strafesnet/go-grpc/maps"
	"git.itzana.me/strafesnet/go-grpc/maps_extended"
	"git.itzana.me/strafesnet/go-grpc/users"
	"git.itzana.me/strafesnet/go-grpc/validator"
	"git.itzana.me/strafesnet/maps-service/pkg/api"
	"git.itzana.me/strafesnet/maps-service/pkg/controller"
	"git.itzana.me/strafesnet/maps-service/pkg/datastore/gormstore"
	"git.itzana.me/strafesnet/maps-service/pkg/roblox"
	"git.itzana.me/strafesnet/maps-service/pkg/service"
	"git.itzana.me/strafesnet/maps-service/pkg/validator_controller"
	"git.itzana.me/strafesnet/maps-service/pkg/web_api"
	"github.com/nats-io/nats.go"
	log "github.com/sirupsen/logrus"
	"github.com/urfave/cli/v2"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func NewServeCommand() *cli.Command {
	return &cli.Command{
		Name:   "serve",
		Usage:  "Run maps service",
		Action: serve,
		Flags: []cli.Flag{
			&cli.StringFlag{
				Name:     "pg-host",
				Usage:    "Host of postgres database",
				EnvVars:  []string{"PG_HOST"},
				Required: true,
			},
			&cli.IntFlag{
				Name:     "pg-port",
				Usage:    "Port of postgres database",
				EnvVars:  []string{"PG_PORT"},
				Required: true,
			},
			&cli.StringFlag{
				Name:     "pg-db",
				Usage:    "Name of database to connect to",
				EnvVars:  []string{"PG_DB"},
				Required: true,
			},
			&cli.StringFlag{
				Name:     "pg-user",
				Usage:    "User to connect with",
				EnvVars:  []string{"PG_USER"},
				Required: true,
			},
			&cli.StringFlag{
				Name:     "pg-password",
				Usage:    "Password to connect with",
				EnvVars:  []string{"PG_PASSWORD"},
				Required: true,
			},
			&cli.BoolFlag{
				Name:    "migrate",
				Usage:   "Run database migrations",
				Value:   true,
				EnvVars: []string{"MIGRATE"},
			},
			&cli.IntFlag{
				Name:    "port",
				Usage:   "Port to listen on",
				Value:   8080,
				EnvVars: []string{"PORT"},
			},
			&cli.IntFlag{
				Name:    "port-internal",
				Usage:   "Port to listen on for internal api",
				Value:   8081,
				EnvVars: []string{"PORT_INTERNAL"},
			},
			&cli.StringFlag{
				Name:    "auth-rpc-host",
				Usage:   "Host of auth rpc",
				EnvVars: []string{"AUTH_RPC_HOST"},
				Value:   "auth-service:8090",
			},
			&cli.StringFlag{
				Name:    "data-rpc-host",
				Usage:   "Host of data rpc",
				EnvVars: []string{"DATA_RPC_HOST"},
				Value:   "data-service:9000",
			},
			&cli.StringFlag{
				Name:    "nats-host",
				Usage:   "Host of nats",
				EnvVars: []string{"NATS_HOST"},
				Value:   "nats:4222",
			},
			&cli.StringFlag{
				Name:     "rbx-api-key",
				Usage:    "API Key for downloading asset locations",
				EnvVars:  []string{"RBX_API_KEY"},
				Required: true,
			},
		},
	}
}

func serve(ctx *cli.Context) error {
	db, err := gormstore.New(ctx)
	if err != nil {
		log.WithError(err).Fatal("failed to connect database")
	}
	nc, err := nats.Connect(ctx.String("nats-host"))
	if err != nil {
		log.WithError(err).Fatal("failed to connect nats")
	}
	js, err := nc.JetStream()
	if err != nil {
		log.WithError(err).Fatal("failed to start jetstream")
	}

	_, err = js.AddStream(&nats.StreamConfig{
		Name:      "maptest",
		Subjects:  []string{"maptest.>"},
		Retention: nats.WorkQueuePolicy,
	})
	if err != nil {
		log.WithError(err).Fatal("failed to add stream")
	}

	// connect to main game database
	conn, err := grpc.Dial(ctx.String("data-rpc-host"), grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatal(err)
	}
	svc_inner := service.NewService(
		db,
		js,
		maps.NewMapsServiceClient(conn),
		users.NewUsersServiceClient(conn),
	)

	svc_external := web_api.NewService(
		&svc_inner,
		roblox.Client{
			HttpClient: http.DefaultClient,
			ApiKey: ctx.String("rbx-api-key"),
		},
	)

	conn, err = grpc.Dial(ctx.String("auth-rpc-host"), grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatal(err)
	}
	sec := web_api.SecurityHandler{
		Client: auth.NewAuthServiceClient(conn),
	}

	srv_external, err := api.NewServer(&svc_external, sec, api.WithPathPrefix("/v1"))
	if err != nil {
		log.WithError(err).Fatal("failed to initialize api server")
	}

	grpcServer := grpc.NewServer()

	maps_controller := controller.NewMapsController(&svc_inner)
	maps_extended.RegisterMapsServiceServer(grpcServer,&maps_controller)

	mapfix_controller := validator_controller.NewMapfixesController(&svc_inner)
	operation_controller := validator_controller.NewOperationsController(&svc_inner)
	script_controller := validator_controller.NewScriptsController(&svc_inner)
	script_policy_controller := validator_controller.NewScriptPolicyController(&svc_inner)
	submission_controller := validator_controller.NewSubmissionsController(&svc_inner)

	validator.RegisterValidatorMapfixServiceServer(grpcServer,&mapfix_controller)
	validator.RegisterValidatorOperationServiceServer(grpcServer,&operation_controller)
	validator.RegisterValidatorScriptServiceServer(grpcServer,&script_controller)
	validator.RegisterValidatorScriptPolicyServiceServer(grpcServer,&script_policy_controller)
	validator.RegisterValidatorSubmissionServiceServer(grpcServer,&submission_controller)

	port := ctx.Int("port-internal")
	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
	if err != nil {
		log.WithField("error", err).Fatalln("failed to net.Listen")
	}
	// Channel to collect errors
	errChan := make(chan error, 2)

	// First server
	go func(errChan chan error) {
		errChan <- grpcServer.Serve(lis)
	}(errChan)

	// Second server
	go func(errChan chan error) {
		errChan <- http.ListenAndServe(fmt.Sprintf(":%d", ctx.Int("port")), srv_external)
	}(errChan)

	// Wait for the first error or completion of both tasks
	for i := 0; i < 2; i++ {
		err := <-errChan
		if err != nil {
			fmt.Println("Exiting due to:", err)
			return err
		}
	}
	log.Println("Both servers have stopped.")

	return nil
}