kq-layout/cmd/server/main.go

package main

import (
	"context"
	"flag"
	"os"

	nacosConfig "git.ikuban.com/server/kratos-nacos/config"
	"git.ikuban.com/server/kratos-nacos/registry"

	"github.com/go-kratos/kratos/v2/config/file"

	"git.ikuban.com/server/yaml"
	"github.com/go-kratos/kratos-layout/internal/conf"
	"github.com/go-kratos/kratos/v2"
	"github.com/go-kratos/kratos/v2/config"
	"github.com/go-kratos/kratos/v2/log"
	"github.com/go-kratos/kratos/v2/transport/grpc"
	"github.com/go-kratos/kratos/v2/transport/http"
)

// go build -ldflags "-X main.Version=x.y.z"
var (
	// Name is the name of the compiled software.
	name string
	// Version is the version of the compiled software.
	Version string
	// flagconf is the config flag.
	flagconf string

	group     string
	namespace string

	configSource string
)

func init() {
	flag.StringVar(&flagconf, "f", "", "config path, eg: -f configs/config.yaml")
	if group == "" {
		group = "kq"
	}
	if os.Getenv("KQ_GROUP") != "" {
		group = os.Getenv("KQ_GROUP")
	}
	if namespace == "" {
		namespace = "bb20f160-702c-4ffa-8b5f-9d13ddd70178"
	}
	if os.Getenv("KQ_NAMESPACE") != "" {
		namespace = os.Getenv("KQ_NAMESPACE")
	}

	if os.Getenv("KQ_CONFIG_SOURCE") != "" {
		configSource = os.Getenv("KQ_CONFIG_SOURCE")
	}
}

func newApp(ctx context.Context, logger log.Logger, r *registry.Registry, hs *http.Server, gs *grpc.Server) *kratos.App {
	opts := []kratos.Option{
		kratos.Name(name),
		kratos.Version(Version),
		kratos.Metadata(map[string]string{}),
		kratos.Logger(logger),
		kratos.Server(
			hs,
			gs,
		),
		kratos.Context(ctx),
	}
	if r != nil {
		opts = append(opts, kratos.Registrar(r))
	}
	err := postInitService()
	if err != nil {
		panic(err)
	}
	return kratos.New(
		opts...,
	)
}

func main() {
	flag.Parse()
	ctx := context.Background()
	logger := log.NewStdLogger(os.Stdout)
	logger = log.With(logger, "caller", log.Caller(4), "ts", log.DefaultTimestamp)
	var confSource config.Source
	if flagconf != "" {
		confSource = file.NewSource(flagconf)
	} else {
		confSource = nacosConfig.NewSource(configSource,
			namespace,
			nacosConfig.Group(group),
			nacosConfig.DataID(name),
		)
	}

	bc := new(conf.Bootstrap)
	c := config.New(
		config.WithSource(
			confSource,
		),
		config.WithDecoder(func(kv *config.KeyValue, v map[string]interface{}) error {
			return yaml.Unmarshal(kv.Value, bc)
		}),
	)
	if err := c.Load(); err != nil {
		panic(err)
	}

	if bc.Server.Registrar == nil {
		bc.Server.Registrar = &conf.Registrar{}
	}

	if bc.Server.Registrar.Namespace == "" {
		bc.Server.Registrar.Namespace = namespace
	}

	if bc.Server.Registrar.Group == "" {
		bc.Server.Registrar.Group = group
	}

	if bc.Server.Registrar.Endpoint == "" {
		bc.Server.Registrar.Endpoint = configSource
	}

	if bc.TraceConf == nil {
		bc.TraceConf = new(conf.TraceConf)
	}

	app, cleanup, err := initApp(ctx, bc, logger)
	if err != nil {
		panic(err)
	}
	defer cleanup()
	// start and wait for stop signal
	if err = app.Run(); err != nil {
		panic(err)
	}
}

// postInitService 在data和service初始化的之后的执行的方法
func postInitService() error {
	return nil
}