pkgdash/service/service.go

package service

import (
	"context"
	cmsstorage "go.unistack.org/cms-service/storage"
	intcfg "go.unistack.org/unistack-org/pkgdash/config"
	"go.unistack.org/unistack-org/pkgdash/handler"
	"go.unistack.org/unistack-org/pkgdash/handler/encoders"
	"go.unistack.org/unistack-org/pkgdash/service/client_git"
	"net/http"

	//pbmicro "go.unistack.org/unistack-org/pkgdash/proto/micro"
	"go.unistack.org/unistack-org/pkgdash/storage"

	cmsservice "go.unistack.org/cms-service"
	"go.unistack.org/micro/v3"
	"go.unistack.org/micro/v3/config"
	"go.unistack.org/micro/v3/logger"
	"go.unistack.org/micro/v3/register"
	microuter "go.unistack.org/micro/v3/router"
	"go.unistack.org/micro/v3/server"
)

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

	if ctx == nil {
		ctx = context.Background()
	}

	cfg := intcfg.NewConfig()
	cs := cmsservice.NewConfigLocal(cfg)

	if r, ok := register.FromContext(ctx); ok && r != nil {
		reg = r
	} else {
		reg = register.NewRegister()
	}
	if r, ok := microuter.FromContext(ctx); ok && r != nil {
		router = r
	} else {
		router = microuter.NewRouter()
	}

	svc := micro.NewService(
		micro.Register(reg),
		micro.Router(router),
		micro.Config(cs...),
	)

	writer, err := handler.NewWriter(encoders.NewJSONProto())
	if err != nil {
		logger.Fatalf(ctx, "failed init writer: %v", err)
	}

	h := handler.NewHandler(svc, writer, 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, cs, config.LoadOverride(true)); err != nil {
				return err
			}
			if err = config.Validate(ctx, cfg); err != nil {
				return err
			}

			if err = svc.Init(
				micro.Name(cfg.Service.Name),
				micro.Version(cfg.Service.Version),
			); err != nil {
				return err
			}

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

			return nil
		}),
		micro.BeforeStart(func(_ context.Context) error {
			level := logger.InfoLevel
			if v, ok := cfg.Logger.Level[cfg.Service.Name]; ok {
				level = logger.ParseLevel(v)
			} else if v, ok = cfg.Logger.Level["all"]; ok {
				level = logger.ParseLevel(v)
			}
			log := logger.NewLogger(
				logger.WithLevel(level),
				logger.WithCallerSkipCount(3),
			)
			return svc.Init(micro.Logger(log))
		}),
		micro.BeforeStart(func(_ context.Context) error {
			var connstr string
			if v, ok := cfg.Storage.DSN[cfg.Service.Name]; ok {
				connstr = v
			} else if v, ok = cfg.Storage.DSN["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 = svc.Server().Handle(svc.Server().NewHandler(mux)); err != nil {
		logger.Fatalf(ctx, "failed to register handler: %v", err)
	}

	return svc, nil
}