shopping-service-service/main.go

package main

import (
	"context"
	"fmt"
	grpcc "github.com/go-micro/plugins/v4/client/grpc"
	"github.com/go-micro/plugins/v4/registry/consul"
	grpcs "github.com/go-micro/plugins/v4/server/grpc"
	"github.com/go-micro/plugins/v4/wrapper/trace/opentelemetry"
	"github.com/google/uuid"
	"github.com/redis/go-redis/v9"
	"github.com/sirupsen/logrus"
	"go-micro.dev/v4"
	"go-micro.dev/v4/auth"
	"go-micro.dev/v4/registry"
	"go-micro.dev/v4/server"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/propagation"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/schema"
	"sghgogs.com/micro/auth-service/utils/tracing"
	"sghgogs.com/micro/shopping-service-service/config"
	req "sghgogs.com/micro/shopping-service-service/domain/model/request"
	"sghgogs.com/micro/shopping-service-service/domain/repository"
	"sghgogs.com/micro/shopping-service-service/domain/service"
	"sghgogs.com/micro/shopping-service-service/handler/admin_user"
	handler_auth "sghgogs.com/micro/shopping-service-service/handler/auth"
	"sghgogs.com/micro/shopping-service-service/handler/category"
	"sghgogs.com/micro/shopping-service-service/handler/health"
	"sghgogs.com/micro/shopping-service-service/handler/order"
	"sghgogs.com/micro/shopping-service-service/handler/permission"
	"sghgogs.com/micro/shopping-service-service/handler/product"
	"sghgogs.com/micro/shopping-service-service/handler/role"
	"sghgogs.com/micro/shopping-service-service/handler/user"
	pb "sghgogs.com/micro/shopping-service-service/proto"
	"sghgogs.com/micro/shopping-service-service/utils/authutil"
	"sghgogs.com/micro/shopping-service-service/utils/middleware"
	"strings"
	"time"
)

var (
	name    = "shoppingservice"
	version = "1.0.0"
)

func main() {
	if err := config.Load(); err != nil {
		logrus.Fatal(err)
	}
	// 1. 连接数据库
	var db *gorm.DB
	if cfg := config.DataBase(); cfg.Enable {
		address := fmt.Sprintf("%v:%v@(%v:%v)/%v?charset=utf8mb4,utf8&parseTime=True&loc=Local", cfg.Mysql.User, cfg.Mysql.Password, cfg.Mysql.Host, cfg.Mysql.Port, cfg.Mysql.DataBase)
		db, _ = gorm.Open(mysql.Open(address), &gorm.Config{
			// Logger: logger.Default.LogMode(logger.Info),
			NamingStrategy: schema.NamingStrategy{
				SingularTable: true,
			}})
	} else {
		// 没有配置数据库
		logrus.Info("There is no database configured")
	}
	fmt.Println("config.ShoppingServiceName()", config.ShoppingServiceName())
	if cfg := config.RedisAddress(); cfg.Enable {
		roles := make([]req.Role, 0)
		db.Model(&req.Role{}).Where("status = ?", pb.StatusEnum_ENABLED).Preload("Permissions", "status = ?", pb.StatusEnum_ENABLED).Find(&roles)
		authutil.NewJWTAuth(redis.NewClient(&redis.Options{
			Addr:     cfg.URL,      // Redis 服务器地址
			Password: cfg.Password, // Redis 密码，如果有的话
			DB:       0,            // 默认数据库
		}), config.ShoppingServiceName(), config.ShoppingTeamName(), cfg.Enable)
		authutil.JWTAuthService.SetRuleItems(UpdateRulesItems(roles))
	}

	// 2. Create service
	srv := micro.NewService(
		micro.Server(grpcs.NewServer()),
		micro.Client(grpcc.NewClient()),
	)
	authService := authutil.JWTAuthService.Auth
	opts := []micro.Option{
		micro.Name(config.ShoppingServiceName()),
		micro.Version(version),
		micro.Address(config.Address()),
		micro.Auth(authService),
	}
	// 3.添加注册中心
	if cfg := config.Registry(); cfg.Enable {
		logrus.Info("添加注册中心")
		consul := consul.NewRegistry(func(options *registry.Options) {
			options.Addrs = []string{
				cfg.Consul.URL,
			}
		})
		opts = append(opts, micro.Registry(consul))
	}
	// 4.添加链路追踪
	if cfg := config.Tracing(); cfg.Enable {
		fmt.Println("加入进来了")
		tp, err := tracing.NewTracerProvider(config.ShoppingServiceName(), version, srv.Server().Options().Id, cfg.Jaeger.URL)
		if err != nil {
			logrus.Fatal(err)
		}
		defer func() {
			ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
			defer cancel()
			if err = tp.Shutdown(ctx); err != nil {
				logrus.Fatal(err)
			}
		}()
		otel.SetTracerProvider(tp)
		otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}))
		traceOpts := []opentelemetry.Option{
			opentelemetry.WithHandleFilter(func(ctx context.Context, r server.Request) bool {
				if e := r.Endpoint(); strings.HasPrefix(e, "Health.") {
					return true
				}
				return false
			}),
		}
		opts = append(opts, micro.WrapHandler(opentelemetry.NewHandlerWrapper(traceOpts...)))
	}
	opts = append(opts, micro.WrapHandler(middleware.NewAuthWrapper(srv, config.ShoppingServiceName())))
	// middleware.NewAuthWrapper(srv))
	srv.Init(opts...)

	newRepository := repository.NewRepository(db)
	newRepository.InitTable()

	newService := service.NewService(newRepository, config.ShoppingServiceName())
	// 注册  Register handler
	pb.RegisterHealthHandler(srv.Server(), &health.Health{})
	// &user.User{Service: newService}
	pb.RegisterShoppingAdminUserServiceHandler(srv.Server(), &admin_user.AdminUser{Service: newService})
	pb.RegisterShoppingRoleServiceHandler(srv.Server(), &role.Role{Service: newService})
	pb.RegisterShoppingPermissionServiceHandler(srv.Server(), &permission.Permission{Service: newService})
	pb.RegisterShoppingUserServiceHandler(srv.Server(), &user.User{Service: newService})
	pb.RegisterShoppingProductServiceHandler(srv.Server(), &product.Product{Service: newService})
	pb.RegisterShoppingCategoryServiceHandler(srv.Server(), &category.Category{Service: newService})
	pb.RegisterShoppingAuthServiceHandler(srv.Server(), &handler_auth.Auth{Service: newService, Namespace: config.ShoppingServiceName()})
	pb.RegisterShoppingOrderServiceHandler(srv.Server(), &order.Order{Service: newService, Namespace: config.ShoppingServiceName()})

	// pb.RegisterUserShoppingServiceHandler(srv.Server(), &user.User{Service: newService})
	// pb.RegisterCategoryShoppingServiceHandler(srv.Server(), &category.Category{Service: newService})
	// pb.RegisterProductShoppingServiceHandler(srv.Server(), &product.Product{Service: newService})
	// pb.RegisterAuthShoppingServiceHandler(srv.Server(), &auth.Auth{Service: newService})
	// pb.RegisterWeChatPhoneLoginServiceHandler(srv.Server(), &auth.Auth{Service: newService})
	// pb.RegisterWeChatLoginServiceHandler(srv.Server(), &auth.Auth{Service: newService})
	// pb.RegisterAlipayLoginServiceHandler(srv.Server(), &auth.Auth{Service: newService})
	logrus.Info("Run service")
	if err := srv.Run(); err != nil {
		logrus.Fatal(err)
	}
}

func UpdateRulesItems(roles []req.Role) []*auth.Rule {
	rules := make([]*auth.Rule, 0)
	for _, role := range roles {
		for _, permission := range role.Permissions {
			rules = append(rules, &auth.Rule{
				Resource: &auth.Resource{
					Name:     permission.Name,
					Type:     "user",
					Endpoint: permission.Endpoint,
				},
				ID:       uuid.New().String(),
				Scope:    role.Name,
				Priority: 1,
			})
		}
	}
	return rules
}