pass ctx to all New method

cs3org · Jul 3, 2023 · 5521a51 · 5521a51
1 parent e57f98e
commit 5521a51
Show file tree

Hide file tree

Showing 153 changed files with 418 additions and 414 deletions.
diff --git a/cmd/revad/runtime/runtime.go b/cmd/revad/runtime/runtime.go
@@ -19,6 +19,7 @@
 package runtime
 
 import (
+	"context"
 	"fmt"
 	"net"
 	"runtime"
@@ -29,8 +30,10 @@ import (
 
 	"github.com/cs3org/reva/cmd/revad/pkg/config"
 	"github.com/cs3org/reva/cmd/revad/pkg/grace"
+	"github.com/cs3org/reva/pkg/appctx"
 	"github.com/cs3org/reva/pkg/rgrpc"
 	"github.com/cs3org/reva/pkg/rhttp"
+
 	"github.com/cs3org/reva/pkg/rhttp/global"
 	"github.com/cs3org/reva/pkg/rserverless"
 	"github.com/cs3org/reva/pkg/sharedconf"
@@ -57,6 +60,7 @@ type Reva struct {
 
 // Server represents a reva server (grpc or http).
 type Server struct {
+	ctx      context.Context
 	server   grace.Server
 	listener net.Listener
 
@@ -73,6 +77,9 @@ func New(config *config.Config, opt ...Option) (*Reva, error) {
 	opts := newOptions(opt...)
 	log := opts.Logger
 
+	ctx := context.Background()
+	ctx = appctx.WithLogger(ctx, log)
+
 	if err := initCPUCount(config.Core, log); err != nil {
 		return nil, err
 	}
@@ -103,7 +110,7 @@ func New(config *config.Config, opt ...Option) (*Reva, error) {
 
 	grpc := groupGRPCByAddress(config)
 	http := groupHTTPByAddress(config)
-	servers, err := newServers(grpc, http, listeners, log)
+	servers, err := newServers(ctx, grpc, http, listeners, log)
 	if err != nil {
 		watcher.Clean()
 		return nil, err
@@ -357,10 +364,12 @@ func listenerFromAddress(lns map[string]net.Listener, network string, address co
 	panic(fmt.Sprintf("listener not found for address %s:%s", network, address))
 }
 
-func newServers(grpc []*config.GRPC, http []*config.HTTP, lns map[string]net.Listener, log *zerolog.Logger) ([]*Server, error) {
+func newServers(ctx context.Context, grpc []*config.GRPC, http []*config.HTTP, lns map[string]net.Listener, log *zerolog.Logger) ([]*Server, error) {
 	servers := make([]*Server, 0, len(grpc)+len(http))
 	for _, cfg := range grpc {
-		services, err := rgrpc.InitServices(cfg.Services)
+		logger := log.With().Str("pkg", "grpc").Logger()
+		ctx := appctx.WithLogger(ctx, &logger)
+		services, err := rgrpc.InitServices(ctx, cfg.Services)
 		if err != nil {
 			return nil, err
 		}
@@ -371,7 +380,7 @@ func newServers(grpc []*config.GRPC, http []*config.HTTP, lns map[string]net.Lis
 		s, err := rgrpc.NewServer(
 			rgrpc.EnableReflection(cfg.EnableReflection),
 			rgrpc.WithShutdownDeadline(cfg.ShutdownDeadline),
-			rgrpc.WithLogger(log.With().Str("pkg", "grpc").Logger()),
+			rgrpc.WithLogger(logger),
 			rgrpc.WithServices(services),
 			rgrpc.WithUnaryServerInterceptors(unaryChain),
 			rgrpc.WithStreamServerInterceptors(streamChain),
@@ -391,18 +400,19 @@ func newServers(grpc []*config.GRPC, http []*config.HTTP, lns map[string]net.Lis
 		servers = append(servers, server)
 	}
 	for _, cfg := range http {
-		log := log.With().Str("pkg", "http").Logger()
-		services, err := rhttp.InitServices(cfg.Services, &log)
+		logger := log.With().Str("pkg", "http").Logger()
+		ctx := appctx.WithLogger(ctx, &logger)
+		services, err := rhttp.InitServices(ctx, cfg.Services)
 		if err != nil {
 			return nil, err
 		}
-		middlewares, err := initHTTPMiddlewares(cfg.Middlewares, httpUnprotected(services), &log)
+		middlewares, err := initHTTPMiddlewares(cfg.Middlewares, httpUnprotected(services), &logger)
 		if err != nil {
 			return nil, err
 		}
 		s, err := rhttp.New(
 			rhttp.WithServices(services),
-			rhttp.WithLogger(log),
+			rhttp.WithLogger(logger),
 			rhttp.WithCertAndKeyFiles(cfg.CertFile, cfg.KeyFile),
 			rhttp.WithMiddlewares(middlewares),
 		)

diff --git a/internal/grpc/services/applicationauth/applicationauth.go b/internal/grpc/services/applicationauth/applicationauth.go
@@ -56,9 +56,9 @@ func (s *service) Register(ss *grpc.Server) {
 	appauthpb.RegisterApplicationsAPIServer(ss, s)
 }
 
-func getAppAuthManager(c *config) (appauth.Manager, error) {
+func getAppAuthManager(ctx context.Context, c *config) (appauth.Manager, error) {
 	if f, ok := registry.NewFuncs[c.Driver]; ok {
-		return f(c.Drivers[c.Driver])
+		return f(ctx, c.Drivers[c.Driver])
 	}
 	return nil, errtypes.NotFound("driver not found: " + c.Driver)
 }
@@ -73,14 +73,14 @@ func parseConfig(m map[string]interface{}) (*config, error) {
 }
 
 // New creates a app auth provider svc.
-func New(m map[string]interface{}) (rgrpc.Service, error) {
+func New(ctx context.Context, m map[string]interface{}) (rgrpc.Service, error) {
 	c, err := parseConfig(m)
 	if err != nil {
 		return nil, err
 	}
 	c.init()
 
-	am, err := getAppAuthManager(c)
+	am, err := getAppAuthManager(ctx, c)
 	if err != nil {
 		return nil, err
 	}

diff --git a/internal/grpc/services/appprovider/appprovider.go b/internal/grpc/services/appprovider/appprovider.go
@@ -83,7 +83,7 @@ func parseConfig(m map[string]interface{}) (*config, error) {
 }
 
 // New creates a new AppProviderService.
-func New(m map[string]interface{}) (rgrpc.Service, error) {
+func New(ctx context.Context, m map[string]interface{}) (rgrpc.Service, error) {
 	c, err := parseConfig(m)
 	if err != nil {
 		return nil, err
@@ -95,7 +95,7 @@ func New(m map[string]interface{}) (rgrpc.Service, error) {
 		return nil, err
 	}
 
-	provider, err := getProvider(c)
+	provider, err := getProvider(ctx, c)
 	if err != nil {
 		return nil, err
 	}
@@ -196,7 +196,7 @@ func (s *service) Register(ss *grpc.Server) {
 	providerpb.RegisterProviderAPIServer(ss, s)
 }
 
-func getProvider(c *config) (app.Provider, error) {
+func getProvider(ctx context.Context, c *config) (app.Provider, error) {
 	if f, ok := registry.NewFuncs[c.Driver]; ok {
 		driverConf := c.Drivers[c.Driver]
 		if c.MimeTypes != nil {
@@ -206,7 +206,7 @@ func getProvider(c *config) (app.Provider, error) {
 			}
 			driverConf["mime_types"] = c.MimeTypes
 		}
-		return f(driverConf)
+		return f(ctx, driverConf)
 	}
 	return nil, errtypes.NotFound("driver not found: " + c.Driver)
 }

diff --git a/internal/grpc/services/appregistry/appregistry.go b/internal/grpc/services/appregistry/appregistry.go
@@ -63,13 +63,13 @@ func (c *config) init() {
 }
 
 // New creates a new StorageRegistryService.
-func New(m map[string]interface{}) (rgrpc.Service, error) {
+func New(ctx context.Context, m map[string]interface{}) (rgrpc.Service, error) {
 	c, err := parseConfig(m)
 	if err != nil {
 		return nil, err
 	}
 
-	reg, err := getRegistry(c)
+	reg, err := getRegistry(ctx, c)
 	if err != nil {
 		return nil, err
 	}
@@ -90,9 +90,9 @@ func parseConfig(m map[string]interface{}) (*config, error) {
 	return c, nil
 }
 
-func getRegistry(c *config) (app.Registry, error) {
+func getRegistry(ctx context.Context, c *config) (app.Registry, error) {
 	if f, ok := registry.NewFuncs[c.Driver]; ok {
-		return f(c.Drivers[c.Driver])
+		return f(ctx, c.Drivers[c.Driver])
 	}
 	return nil, errtypes.NotFound("appregistrysvc: driver not found: " + c.Driver)
 }

diff --git a/internal/grpc/services/appregistry/appregistry_test.go b/internal/grpc/services/appregistry/appregistry_test.go
@@ -122,7 +122,7 @@ func Test_ListAppProviders(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			rr, err := static.New(map[string]interface{}{"providers": tt.providers, "mime_types": tt.mimeTypes})
+			rr, err := static.New(context.Background(), map[string]interface{}{"providers": tt.providers, "mime_types": tt.mimeTypes})
 			if err != nil {
 				t.Errorf("could not create registry error = %v", err)
 				return
@@ -296,7 +296,7 @@ func Test_GetAppProviders(t *testing.T) {
 		},
 	}
 
-	rr, err := static.New(map[string]interface{}{"providers": providers, "mime_types": mimeTypes})
+	rr, err := static.New(context.Background(), map[string]interface{}{"providers": providers, "mime_types": mimeTypes})
 	if err != nil {
 		t.Errorf("could not create registry error = %v", err)
 		return
@@ -355,7 +355,7 @@ func TestNew(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := New(tt.m)
+			got, err := New(context.Background(), tt.m)
 			if err != nil {
 				assert.Equal(t, tt.wantErr, err.Error())
 				assert.Nil(t, got)

diff --git a/internal/grpc/services/authprovider/authprovider.go b/internal/grpc/services/authprovider/authprovider.go
@@ -72,7 +72,7 @@ func parseConfig(m map[string]interface{}) (*config, error) {
 	return c, nil
 }
 
-func getAuthManager(manager string, m map[string]map[string]interface{}) (auth.Manager, *plugin.RevaPlugin, error) {
+func getAuthManager(ctx context.Context, manager string, m map[string]map[string]interface{}) (auth.Manager, *plugin.RevaPlugin, error) {
 	if manager == "" {
 		return nil, nil, errtypes.InternalError("authsvc: driver not configured for auth manager")
 	}
@@ -90,7 +90,7 @@ func getAuthManager(manager string, m map[string]map[string]interface{}) (auth.M
 		return authManager, p, nil
 	} else if _, ok := err.(errtypes.NotFound); ok {
 		if f, ok := registry.NewFuncs[manager]; ok {
-			authmgr, err := f(m[manager])
+			authmgr, err := f(ctx, m[manager])
 			return authmgr, nil, err
 		}
 	} else {
@@ -100,13 +100,13 @@ func getAuthManager(manager string, m map[string]map[string]interface{}) (auth.M
 }
 
 // New returns a new AuthProviderServiceServer.
-func New(m map[string]interface{}) (rgrpc.Service, error) {
+func New(ctx context.Context, m map[string]interface{}) (rgrpc.Service, error) {
 	c, err := parseConfig(m)
 	if err != nil {
 		return nil, err
 	}
 
-	authManager, plug, err := getAuthManager(c.AuthManager, c.AuthManagers)
+	authManager, plug, err := getAuthManager(ctx, c.AuthManager, c.AuthManagers)
 	if err != nil {
 		return nil, err
 	}

diff --git a/internal/grpc/services/authregistry/authregistry.go b/internal/grpc/services/authregistry/authregistry.go
@@ -66,15 +66,15 @@ func (c *config) init() {
 }
 
 // New creates a new AuthRegistry.
-func New(m map[string]interface{}) (rgrpc.Service, error) {
+func New(ctx context.Context, m map[string]interface{}) (rgrpc.Service, error) {
 	c, err := parseConfig(m)
 	if err != nil {
 		return nil, err
 	}
 
 	c.init()
 
-	reg, err := getRegistry(c)
+	reg, err := getRegistry(ctx, c)
 	if err != nil {
 		return nil, err
 	}
@@ -94,9 +94,9 @@ func parseConfig(m map[string]interface{}) (*config, error) {
 	return c, nil
 }
 
-func getRegistry(c *config) (auth.Registry, error) {
+func getRegistry(ctx context.Context, c *config) (auth.Registry, error) {
 	if f, ok := registry.NewFuncs[c.Driver]; ok {
-		return f(c.Drivers[c.Driver])
+		return f(ctx, c.Drivers[c.Driver])
 	}
 	return nil, errtypes.NotFound("authregistrysvc: driver not found: " + c.Driver)
 }

diff --git a/internal/grpc/services/datatx/datatx.go b/internal/grpc/services/datatx/datatx.go
@@ -64,16 +64,16 @@ func (s *service) Register(ss *grpc.Server) {
 	datatx.RegisterTxAPIServer(ss, s)
 }
 
-func getDatatxManager(c *config) (txdriver.Manager, error) {
+func getDatatxManager(ctx context.Context, c *config) (txdriver.Manager, error) {
 	if f, ok := txregistry.NewFuncs[c.TxDriver]; ok {
-		return f(c.TxDrivers[c.TxDriver])
+		return f(ctx, c.TxDrivers[c.TxDriver])
 	}
 	return nil, errtypes.NotFound("datatx service: driver not found: " + c.TxDriver)
 }
 
-func getStorageManager(c *config) (txdriver.Repository, error) {
+func getStorageManager(ctx context.Context, c *config) (txdriver.Repository, error) {
 	if f, ok := repoRegistry.NewFuncs[c.StorageDriver]; ok {
-		return f(c.StorageDrivers[c.StorageDriver])
+		return f(ctx, c.StorageDrivers[c.StorageDriver])
 	}
 	return nil, errtypes.NotFound("datatx service: driver not found: " + c.StorageDriver)
 }
@@ -88,19 +88,19 @@ func parseConfig(m map[string]interface{}) (*config, error) {
 }
 
 // New creates a new datatx svc.
-func New(m map[string]interface{}) (rgrpc.Service, error) {
+func New(ctx context.Context, m map[string]interface{}) (rgrpc.Service, error) {
 	c, err := parseConfig(m)
 	if err != nil {
 		return nil, err
 	}
 	c.init()
 
-	txManager, err := getDatatxManager(c)
+	txManager, err := getDatatxManager(ctx, c)
 	if err != nil {
 		return nil, err
 	}
 
-	storageDriver, err := getStorageManager(c)
+	storageDriver, err := getStorageManager(ctx, c)
 	if err != nil {
 		return nil, err
 	}

diff --git a/internal/grpc/services/gateway/gateway.go b/internal/grpc/services/gateway/gateway.go
@@ -19,6 +19,7 @@
 package gateway
 
 import (
+	"context"
 	"fmt"
 	"net/url"
 	"strings"
@@ -124,7 +125,7 @@ type svc struct {
 // New creates a new gateway svc that acts as a proxy for any grpc operation.
 // The gateway is responsible for high-level controls: rate-limiting, coordination between svcs
 // like sharing and storage acls, asynchronous transactions, ...
-func New(m map[string]interface{}) (rgrpc.Service, error) {
+func New(ctx context.Context, m map[string]interface{}) (rgrpc.Service, error) {
 	c, err := parseConfig(m)
 	if err != nil {
 		return nil, err

diff --git a/internal/grpc/services/groupprovider/groupprovider.go b/internal/grpc/services/groupprovider/groupprovider.go
@@ -59,22 +59,22 @@ func parseConfig(m map[string]interface{}) (*config, error) {
 	return c, nil
 }
 
-func getDriver(c *config) (group.Manager, error) {
+func getDriver(ctx context.Context, c *config) (group.Manager, error) {
 	if f, ok := registry.NewFuncs[c.Driver]; ok {
-		return f(c.Drivers[c.Driver])
+		return f(ctx, c.Drivers[c.Driver])
 	}
 
 	return nil, errtypes.NotFound(fmt.Sprintf("driver %s not found for group manager", c.Driver))
 }
 
 // New returns a new GroupProviderServiceServer.
-func New(m map[string]interface{}) (rgrpc.Service, error) {
+func New(ctx context.Context, m map[string]interface{}) (rgrpc.Service, error) {
 	c, err := parseConfig(m)
 	if err != nil {
 		return nil, err
 	}
 
-	groupManager, err := getDriver(c)
+	groupManager, err := getDriver(ctx, c)
 	if err != nil {
 		return nil, err
 	}

diff --git a/internal/grpc/services/helloworld/helloworld.go b/internal/grpc/services/helloworld/helloworld.go
@@ -43,7 +43,7 @@ type service struct {
 // New returns a new PreferencesServiceServer
 // It can be tested like this:
 // prototool grpc --address 0.0.0.0:9999 --method 'revad.helloworld.HelloWorldService/Hello' --data '{"name": "Alice"}'.
-func New(m map[string]interface{}) (rgrpc.Service, error) {
+func New(ctx context.Context, m map[string]interface{}) (rgrpc.Service, error) {
 	c := &conf{}
 	if err := mapstructure.Decode(m, c); err != nil {
 		err = errors.Wrap(err, "helloworld: error decoding conf")