lone-services/services/lonelog/lonelog.go

package main

import (
	"flag"
	"lone-services/pkg/discovery"
	"lone-services/pkg/logRedis"
	"lone-services/pkg/modelbase"
	"lone-services/pkg/mysql"
	"lone-services/pkg/utils"
	"lone-services/pkg/validate"
	lonelog "lone-services/rpc/lonelog/pb"
	"lone-services/services/lonelog/internal/config"
	"lone-services/services/lonelog/internal/server"
	service2 "lone-services/services/lonelog/internal/service"
	"lone-services/services/lonelog/internal/svc"
	"net"
	"os"
	"strconv"

	"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/lonelog.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 := logRedis.Init(logRedis.LogRedisConfig{
		Host:     utils.GetConfigString("log-redis.host"),
		Port:     utils.GetConfigInt("log-redis.port"),
		Password: utils.GetConfigString("log-redis.password"),
		DB:       utils.GetConfigInt("log-redis.db"),
	}); err != nil {
		logx.Errorf("log redis init: %v", err)
		os.Exit(1)
	}

	debug := utils.GetConfigBool("mysql.debug")
	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)

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

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

	watcher := service2.NewLogWatcher()
	watcher.StartWatch()
	defer watcher.StopWatch()

	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)
}