pkgdash/service/service.go

package service

import (
	"context"
	cmsstorage "go.unistack.org/cms-service/storage" // TODO
	httpsrv "go.unistack.org/micro-server-http/v3"
	"go.unistack.org/micro/v4"
	"go.unistack.org/micro/v4/config"
	microcfg "go.unistack.org/micro/v4/config"
	"go.unistack.org/micro/v4/logger"
	"go.unistack.org/micro/v4/options"
	"go.unistack.org/micro/v4/register"
	"go.unistack.org/micro/v4/server"
	intcfg "go.unistack.org/unistack-org/pkgdash/config"
	"go.unistack.org/unistack-org/pkgdash/handler"
	pb "go.unistack.org/unistack-org/pkgdash/proto"
	"go.unistack.org/unistack-org/pkgdash/service/client_git"
	"go.unistack.org/unistack-org/pkgdash/storage"
)

func NewService(ctx context.Context) (micro.Service, error) {
	var reg register.Register

	cfg := intcfg.NewConfig()

	cs := microcfg.NewConfig(config.Struct(cfg))

	// TODO
	mgsrv := httpsrv.NewServer(
		options.Register(reg),
	)

	svc := micro.NewService(
		micro.Config(cs),
	)

	h := handler.NewHandler(svc, client_git.NewClient(5))

	if err := svc.Init(
		micro.AfterStart(func(_ context.Context) error {
			return h.Init(svc.Options().Context)
		}),
		micro.BeforeStart(func(ctx context.Context) error {
			if err := config.Load(ctx, []config.Config{cs}, config.LoadOverride(true)); err != nil {
				return err
			}
			if err := config.Validate(ctx, cfg); err != nil {
				return err
			}

			if err := svc.Init(
				micro.Name(intcfg.ServiceName),
				micro.Version(intcfg.ServiceVersion),
			); err != nil {
				return err
			}

			if err := svc.Server("http").Init(
				options.Address(cfg.Address),
				options.Name(cfg.App.Name),
				server.Version(cfg.App.Version),
			); err != nil {
				return err
			}

			return nil
		}),
		micro.BeforeStart(func(_ context.Context) error {
			log := logger.NewLogger(
				logger.WithLevel(logger.ParseLevel(cfg.LogLevel)),
				logger.WithCallerSkipCount(3),
			)
			return svc.Init(micro.Logger(log))
		}),
		micro.BeforeStart(func(_ context.Context) error { // TODO
			var connstr string
			if v, ok := cfg.StorageDSN[cfg.App.Name]; ok {
				connstr = v
			} else if v, ok = cfg.StorageDSN["all"]; ok {
				connstr = v
			}
			scheme, dsn, err := cmsstorage.StorageOptions(connstr)
			if err != nil {
				return err
			}
			db, dbok := cmsstorage.FromContext(svc.Options().Context)
			if !dbok {
				db, err = cmsstorage.NewStorage(scheme, dsn)
				if err != nil {
					return err
				}
			}
			store, err := storage.NewStorage(scheme, db)
			if err != nil {
				return err
			}
			return svc.Init(micro.Context(cmsstorage.InterfaceNewContext(svc.Options().Context, store)))
		}),
	); err != nil {
		return nil, err
	}

	//mux := http.NewServeMux()

	//mux.HandleFunc("/listPackage", handler.Methods(http.MethodGet, h.ListPackage))
	//mux.HandleFunc("/updatePackage", handler.Methods(http.MethodPost, h.UpdatePackage))
	//mux.HandleFunc("/addComment", handler.Methods(http.MethodPut, h.AddComment))
	//mux.HandleFunc("/addPackage", handler.Methods(http.MethodPost, h.AddPackage))
	//mux.HandleFunc("/getModule", handler.Methods(http.MethodGet, h.GetModule))

	if err := pb.RegisterPkgdashServiceServer(mgsrv, h); err != nil {
		logger.Fatalf(ctx, "failed to register handler: %v", err)
	}

	return svc, nil
}