lone-services/services/chore/chore.go

package main

import (
	"flag"
	"net"
	"os"
	"strconv"

	"lone-services/pkg/discovery"
	"lone-services/pkg/redis"
	"lone-services/pkg/utils"
	"lone-services/pkg/validate"
	chore "lone-services/rpc/chore/pb"
	"lone-services/services/chore/internal/config"
	"lone-services/services/chore/internal/server"
	"lone-services/services/chore/internal/svc"

	"github.com/zeromicro/go-zero/core/conf"
	"github.com/zeromicro/go-zero/core/logx"
	"github.com/zeromicro/go-zero/core/service"
	"github.com/zeromicro/go-zero/zrpc"
	"google.golang.org/grpc"
	"google.golang.org/grpc/reflection"
)

var configFile = flag.String("f", "etc/chore.yaml", "the config file")

func main() {
	flag.Parse()
	var c config.Config
	conf.MustLoad(*configFile, &c)

	nacosParam := utils.NacosConfig{
		Hosts:       c.Nacos.Hosts,
		NamespaceId: c.Nacos.NamespaceId,
		Group:       c.Nacos.Group,
		ConfigID:    c.Nacos.ConfigID,
	}
	utils.InitConfig(nacosParam)

	logConf := logx.LogConf{
		ServiceName: utils.GetConfigString("log.serviceName"),
		Mode:        utils.GetConfigString("log.mode"),
		Encoding:    utils.GetConfigString("log.encoding"),
		Level:       utils.GetConfigString("log.level"),
		Path:        utils.GetConfigString("log.path"),
		KeepDays:    utils.GetConfigInt("log.keepDays"),
		MaxSize:     utils.GetConfigInt("log.maxSize"),
		MaxBackups:  utils.GetConfigInt("log.maxBackups"),
		Compress:    utils.GetConfigBool("log.compress"),
	}
	logx.SetUp(logConf)
	logx.AddWriter(logx.NewWriter(os.Stdout))

	listenOn := utils.GetConfigString("base.listenOn")
	mode := utils.GetConfigString("base.mode")
	serviceName := utils.GetConfigString("base.name")

	if err := discovery.Init(discovery.Config{
		Hosts:       c.Nacos.Hosts,
		NamespaceId: c.Nacos.NamespaceId,
		Group:       c.Nacos.Group,
	}); err != nil {
		logx.Errorf("nacos init: %v", err)
		os.Exit(1)
	}

	port, err := listenPort(listenOn)
	if err != nil {
		logx.Errorf("parse ListenOn: %v", err)
		os.Exit(1)
	}

	if err := discovery.Register(discovery.Instance{
		ServiceName: serviceName,
		IP:          c.Nacos.RegisterIP,
		Port:        port,
		Group:       c.Nacos.Group,
	}); err != nil {
		logx.Errorf("nacos register: %v", err)
		os.Exit(1)
	}
	logx.Infof("服务注册成功: %s:%d", c.Nacos.RegisterIP, port)

	defer func() {
		if err := discovery.Deregister(); err != nil {
			logx.Errorf("nacos deregister: %v", err)
		}
	}()

	// db, err := mysql.New(mysql.Config{
	// 	Host:         utils.GetConfigString("mysql.host"),
	// 	Port:         utils.GetConfigInt("mysql.port"),
	// 	User:         utils.GetConfigString("mysql.user"),
	// 	Password:     utils.GetConfigString("mysql.password"),
	// 	Database:     utils.GetConfigString("mysql.database"),
	// 	Charset:      utils.GetConfigString("mysql.charset"),
	// 	Prefix:       utils.GetConfigString("mysql.prefix"),
	// 	ReadHost:     utils.GetConfigString("mysql_read.host"),
	// 	ReadPort:     utils.GetConfigInt("mysql_read.port"),
	// 	ReadUser:     utils.GetConfigString("mysql_read.user"),
	// 	ReadPassword: utils.GetConfigString("mysql_read.password"),
	// 	ReadDatabase: utils.GetConfigString("mysql_read.database"),
	// })
	// if err != nil {
	// 	logx.Errorf("mysql init: %v", err)
	// 	os.Exit(1)
	// }

	if err := redis.Init(redis.Config{
		Host:     utils.GetConfigString("redis.host"),
		Port:     utils.GetConfigInt("redis.port"),
		Password: utils.GetConfigString("redis.password"),
		DB:       utils.GetConfigInt("redis.db"),
	}); err != nil {
		logx.Errorf("redis init: %v", err)
		os.Exit(1)
	}

	// debug := utils.GetConfigBool("mysql.debug")test
	// modelbase.Init(db, modelbase.Config{Prefix: utils.GetConfigString("mysql.prefix"), Debug: debug})

	rpcConf := zrpc.RpcServerConf{
		ListenOn: listenOn,
	}
	rpcConf.Mode = mode

	// ctx := svc.NewServiceContext(c, db)
	ctx := svc.NewServiceContext(c)

	s := zrpc.MustNewServer(rpcConf, func(grpcServer *grpc.Server) {
		chore.RegisterChoreServer(grpcServer, server.NewChoreServer(ctx))
		if mode == service.DevMode || mode == service.TestMode {
			reflection.Register(grpcServer)
		}
	})
	defer s.Stop()

	s.AddUnaryInterceptors(validate.UnaryServerInterceptor(validate.MustNew()))

	logx.Infof("Starting rpc server at %s...", listenOn)
	s.Start()
}

func listenPort(listenOn string) (uint64, error) {
	_, portStr, err := net.SplitHostPort(listenOn)
	if err != nil {
		return 0, err
	}
	return strconv.ParseUint(portStr, 10, 64)
}