update

cmd/server/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"flag"
 	"os"
 
@@ -39,7 +40,7 @@ func init() {
 	flag.StringVar(&namespace, "namespace", "c8bf0196-4a26-4b07-b09e-9f49b7e1a241", "service namespace, eg: -group test")
 }
 
-func newApp(logger log.Logger, r *registry.Registry, hs *http.Server, gs *grpc.Server) *kratos.App {
+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),
@@ -49,6 +50,7 @@ func newApp(logger log.Logger, r *registry.Registry, hs *http.Server, gs *grpc.S
 			hs,
 			gs,
 		),
+		kratos.Context(ctx),
 	}
 	if r != nil {
 		opts = append(opts, kratos.Registrar(r))
@@ -60,6 +62,7 @@ func newApp(logger log.Logger, r *registry.Registry, hs *http.Server, gs *grpc.S
 }
 
 func main() {
+	ctx := context.Background()
 	flag.Parse()
 	logger := log.NewStdLogger(os.Stdout)
 	logger = log.With(logger, "caller", log.Caller(5), "ts", log.DefaultTimestamp)
@@ -107,7 +110,7 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
-	app, err := initApp(bc.Server, bc.Data, logger)
+	app, err := initApp(ctx, &bc, logger)
 	if err != nil {
 		panic(err)
 	}

cmd/server/wire.go

@@ -5,6 +5,8 @@
 package main
 
 import (
+	"context"
+
 	"github.com/go-kratos/kratos-layout/internal/conf"
 	"github.com/go-kratos/kratos-layout/internal/data"
 	"github.com/go-kratos/kratos-layout/internal/server"
@@ -15,6 +17,6 @@ import (
 )
 
 // initApp init kratos application.
-func initApp(*conf.Server, *conf.Data, log.Logger) (*kratos.App, error) {
+func initApp(context.Context, *conf.Bootstrap, log.Logger) (*kratos.App, error) {
 	panic(wire.Build(server.ProviderSet, data.ProviderSet, service.ProviderSet, newApp))
 }

cmd/server/wire_gen.go

@@ -6,6 +6,7 @@
 package main
 
 import (
+	"context"
 	"github.com/go-kratos/kratos-layout/internal/conf"
 	"github.com/go-kratos/kratos-layout/internal/data"
 	"github.com/go-kratos/kratos-layout/internal/server"
@@ -17,15 +18,16 @@ import (
 // Injectors from wire.go:
 
 // initApp init kratos application.
-func initApp(confServer *conf.Server, confData *conf.Data, logger log.Logger) (*kratos.App, error) {
-	registry := server.NewRegistrar(confServer)
-	dataData, err := data.NewData(confData, logger)
+func initApp(contextContext context.Context, bootstrap *conf.Bootstrap, logger log.Logger) (*kratos.App, error) {
+	registry := server.NewRegistrar(bootstrap)
+	client := data.NewRedis(bootstrap)
+	dataData, err := data.NewData(bootstrap, client, logger)
 	if err != nil {
 		return nil, err
 	}
 	greeterServer := service.NewGreeterService(logger, dataData)
-	httpServer := server.NewHTTPServer(confServer, greeterServer)
-	grpcServer := server.NewGRPCServer(confServer)
-	app := newApp(logger, registry, httpServer, grpcServer)
+	httpServer := server.NewHTTPServer(bootstrap, greeterServer)
+	grpcServer := server.NewGRPCServer(bootstrap)
+	app := newApp(contextContext, logger, registry, httpServer, grpcServer)
 	return app, nil
 }

internal/data/data.go

@@ -9,7 +9,7 @@ import (
 )
 
 // ProviderSet is data providers.
-var ProviderSet = wire.NewSet(NewData)
+var ProviderSet = wire.NewSet(NewRedis, NewData)
 
 // Data .
 type Data struct {
@@ -19,32 +19,35 @@ type Data struct {
 }
 
 // NewData .
-func NewData(c *conf.Data, logger log.Logger) (*Data, error) {
-
+func NewData(c *conf.Bootstrap, rdb *redis.Client, logger log.Logger) (*Data, error) {
 	data := &Data{
 		log: log.NewHelper("data/data", logger),
 	}
 	var err error
-	if c.Database != nil {
-		data.Mysql, err = models.NewMysql(c.Database.Source, logger)
+	if c.Data.Database != nil {
+		data.Mysql, err = models.NewMysql(c.Data.Database.Source, logger)
 		if err != nil {
 			return nil, err
 		}
-		data.Mysql.XDB.SetMaxIdleConns(int(c.Database.MaxIdleConns))
-		data.Mysql.XDB.SetMaxOpenConns(int(c.Database.MaxOpenConns))
+		data.Mysql.XDB.SetMaxIdleConns(int(c.Data.Database.MaxIdleConns))
+		data.Mysql.XDB.SetMaxOpenConns(int(c.Data.Database.MaxOpenConns))
 	}
+	data.rdb = rdb
+	return data, nil
+}
 
-	if c.Redis != nil {
-		data.rdb = redis.NewClient(&redis.Options{
-			Addr:         c.Redis.Addr,
-			DB:           int(c.Redis.Db),
-			DialTimeout:  c.Redis.DialTimeout.AsDuration(),
-			WriteTimeout: c.Redis.WriteTimeout.AsDuration(),
-			ReadTimeout:  c.Redis.ReadTimeout.AsDuration(),
-			PoolSize:     int(c.Redis.PoolSize),
-			MinIdleConns: int(c.Redis.MinIdleConns),
-		})
+func NewRedis(c *conf.Bootstrap) *redis.Client {
+	if c.Data.Redis == nil {
+		return nil
 	}
-
-	return data, nil
+	rdb := redis.NewClient(&redis.Options{
+		Addr:         c.Data.Redis.Addr,
+		DB:           int(c.Data.Redis.Db),
+		DialTimeout:  c.Data.Redis.DialTimeout.AsDuration(),
+		WriteTimeout: c.Data.Redis.WriteTimeout.AsDuration(),
+		ReadTimeout:  c.Data.Redis.ReadTimeout.AsDuration(),
+		PoolSize:     int(c.Data.Redis.PoolSize),
+		MinIdleConns: int(c.Data.Redis.MinIdleConns),
+	})
+	return rdb
 }

internal/server/grpc.go

@@ -10,7 +10,7 @@ import (
 )
 
 // NewGRPCServer new a gRPC server.
-func NewGRPCServer(c *conf.Server) *grpc.Server {
+func NewGRPCServer(c *conf.Bootstrap) *grpc.Server {
 	var opts = []grpc.ServerOption{
 		grpc.Middleware(
 			middleware.Chain(
@@ -20,14 +20,14 @@ func NewGRPCServer(c *conf.Server) *grpc.Server {
 			),
 		),
 	}
-	if c.Grpc.Network != "" {
-		opts = append(opts, grpc.Network(c.Grpc.Network))
+	if c.Server.Grpc.Network != "" {
+		opts = append(opts, grpc.Network(c.Server.Grpc.Network))
 	}
-	if c.Grpc.Addr != "" {
-		opts = append(opts, grpc.Address(c.Grpc.Addr))
+	if c.Server.Grpc.Addr != "" {
+		opts = append(opts, grpc.Address(c.Server.Grpc.Addr))
 	}
-	if c.Grpc.Timeout != nil {
-		opts = append(opts, grpc.Timeout(c.Grpc.Timeout.AsDuration()))
+	if c.Server.Grpc.Timeout != nil {
+		opts = append(opts, grpc.Timeout(c.Server.Grpc.Timeout.AsDuration()))
 	}
 	srv := grpc.NewServer(opts...)
 	return srv

internal/server/http.go

@@ -12,16 +12,16 @@ import (
 )
 
 // NewHTTPServer new a HTTP server.
-func NewHTTPServer(c *conf.Server, s1 v1.GreeterServer) *http.Server {
+func NewHTTPServer(c *conf.Bootstrap, s1 v1.GreeterServer) *http.Server {
 	var opts = []http.ServerOption{}
-	if c.Http.Network != "" {
-		opts = append(opts, http.Network(c.Http.Network))
+	if c.Server.Http.Network != "" {
+		opts = append(opts, http.Network(c.Server.Http.Network))
 	}
-	if c.Http.Addr != "" {
-		opts = append(opts, http.Address(c.Http.Addr))
+	if c.Server.Http.Addr != "" {
+		opts = append(opts, http.Address(c.Server.Http.Addr))
 	}
-	if c.Http.Timeout != nil {
-		opts = append(opts, http.Timeout(c.Http.Timeout.AsDuration()))
+	if c.Server.Http.Timeout != nil {
+		opts = append(opts, http.Timeout(c.Server.Http.Timeout.AsDuration()))
 	}
 	srv := http.NewServer(opts...)
 	m := http.Middleware(

internal/server/registrar.go

@@ -5,9 +5,9 @@ import (
 	"github.com/go-kratos/kratos-layout/internal/conf"
 )
 
-func NewRegistrar(c *conf.Server) *registry.Registry {
-	if c.Registrar.Group != "" {
-		r, err := registry.New("http://config.airdropin.com:80", c.Registrar.Namespace, registry.Group(c.Registrar.Group))
+func NewRegistrar(c *conf.Bootstrap) *registry.Registry {
+	if c.Server.Registrar.Group != "" {
+		r, err := registry.New("http://config.airdropin.com:80", c.Server.Registrar.Namespace, registry.Group(c.Server.Registrar.Group))
 		if err != nil {
 			panic(err)
 		}