Rename folder and root command

storage/pkg/command/authbasic.go

@@ -0,0 +1,191 @@
+package command
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"path"
+	"time"
+
+	"github.com/cs3org/reva/cmd/revad/runtime"
+	"github.com/gofrs/uuid"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/server/debug"
+)
+
+// AuthBasic is the entrypoint for the auth-basic command.
+func AuthBasic(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "auth-basic",
+		Usage: "Start reva authprovider for basic auth",
+		Flags: flagset.AuthBasicWithConfig(cfg),
+		Before: func(c *cli.Context) error {
+			cfg.Reva.AuthBasic.Services = c.StringSlice("service")
+
+			return nil
+		},
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				case "jaeger":
+					logger.Info().
+						Str("type", t).
+						Msg("configuring reva to use the jaeger tracing backend")
+
+				case "zipkin":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				//metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+
+				uuid := uuid.Must(uuid.NewV4())
+				pidFile := path.Join(os.TempDir(), "revad-"+c.Command.Name+"-"+uuid.String()+".pid")
+
+				rcfg := map[string]interface{}{
+					"core": map[string]interface{}{
+						"max_cpus":             cfg.Reva.Users.MaxCPUs,
+						"tracing_enabled":      cfg.Tracing.Enabled,
+						"tracing_endpoint":     cfg.Tracing.Endpoint,
+						"tracing_collector":    cfg.Tracing.Collector,
+						"tracing_service_name": "auth-basic",
+					},
+					"shared": map[string]interface{}{
+						"jwt_secret": cfg.Reva.JWTSecret,
+					},
+					"grpc": map[string]interface{}{
+						"network": cfg.Reva.AuthBasic.Network,
+						"address": cfg.Reva.AuthBasic.Addr,
+						// TODO build services dynamically
+						"services": map[string]interface{}{
+							"authprovider": map[string]interface{}{
+								"auth_manager": cfg.Reva.AuthProvider.Driver,
+								"auth_managers": map[string]interface{}{
+									"json": map[string]interface{}{
+										"users": cfg.Reva.AuthProvider.JSON,
+									},
+									"ldap": map[string]interface{}{
+										"hostname":      cfg.Reva.LDAP.Hostname,
+										"port":          cfg.Reva.LDAP.Port,
+										"base_dn":       cfg.Reva.LDAP.BaseDN,
+										"loginfilter":   cfg.Reva.LDAP.LoginFilter,
+										"bind_username": cfg.Reva.LDAP.BindDN,
+										"bind_password": cfg.Reva.LDAP.BindPassword,
+										"idp":           cfg.Reva.LDAP.IDP,
+										"schema": map[string]interface{}{
+											"dn":          "dn",
+											"uid":         cfg.Reva.LDAP.Schema.UID,
+											"mail":        cfg.Reva.LDAP.Schema.Mail,
+											"displayName": cfg.Reva.LDAP.Schema.DisplayName,
+											"cn":          cfg.Reva.LDAP.Schema.CN,
+										},
+									},
+								},
+							},
+						},
+					},
+				}
+
+				gr.Add(func() error {
+					runtime.RunWithOptions(
+						rcfg,
+						pidFile,
+						runtime.WithLogger(&logger.Logger),
+					)
+					return nil
+				}, func(_ error) {
+					logger.Info().
+						Str("server", c.Command.Name).
+						Msg("Shutting down server")
+
+					cancel()
+				})
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Name(c.Command.Name+"-debug"),
+					debug.Addr(cfg.Reva.AuthBasic.DebugAddr),
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("server", "debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("server", "debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("server", "debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}

storage/pkg/command/authbearer.go

@@ -0,0 +1,179 @@
+package command
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"path"
+	"time"
+
+	"github.com/cs3org/reva/cmd/revad/runtime"
+	"github.com/gofrs/uuid"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/server/debug"
+)
+
+// AuthBearer is the entrypoint for the auth-bearer command.
+func AuthBearer(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "auth-bearer",
+		Usage: "Start reva authprovider for bearer auth",
+		Flags: flagset.AuthBearerWithConfig(cfg),
+		Before: func(c *cli.Context) error {
+			cfg.Reva.AuthBearer.Services = c.StringSlice("service")
+
+			return nil
+		},
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				case "jaeger":
+					logger.Info().
+						Str("type", t).
+						Msg("configuring reva to use the jaeger tracing backend")
+
+				case "zipkin":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				//metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+
+				uuid := uuid.Must(uuid.NewV4())
+				pidFile := path.Join(os.TempDir(), "revad-"+c.Command.Name+"-"+uuid.String()+".pid")
+
+				rcfg := map[string]interface{}{
+					"core": map[string]interface{}{
+						"max_cpus":             cfg.Reva.Users.MaxCPUs,
+						"tracing_enabled":      cfg.Tracing.Enabled,
+						"tracing_endpoint":     cfg.Tracing.Endpoint,
+						"tracing_collector":    cfg.Tracing.Collector,
+						"tracing_service_name": "auth-bearer",
+					},
+					"shared": map[string]interface{}{
+						"jwt_secret": cfg.Reva.JWTSecret,
+					},
+					"grpc": map[string]interface{}{
+						"network": cfg.Reva.AuthBearer.Network,
+						"address": cfg.Reva.AuthBearer.Addr,
+						// TODO build services dynamically
+						"services": map[string]interface{}{
+							"authprovider": map[string]interface{}{
+								"auth_manager": "oidc",
+								"auth_managers": map[string]interface{}{
+									"oidc": map[string]interface{}{
+										"issuer":    cfg.Reva.OIDC.Issuer,
+										"insecure":  cfg.Reva.OIDC.Insecure,
+										"id_claim":  cfg.Reva.OIDC.IDClaim,
+										"uid_claim": cfg.Reva.OIDC.UIDClaim,
+										"gid_claim": cfg.Reva.OIDC.GIDClaim,
+									},
+								},
+							},
+						},
+					},
+				}
+
+				gr.Add(func() error {
+					runtime.RunWithOptions(
+						rcfg,
+						pidFile,
+						runtime.WithLogger(&logger.Logger),
+					)
+					return nil
+				}, func(_ error) {
+					logger.Info().
+						Str("server", c.Command.Name).
+						Msg("Shutting down server")
+
+					cancel()
+				})
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Name(c.Command.Name+"-debug"),
+					debug.Addr(cfg.Reva.AuthBearer.DebugAddr),
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("server", "debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("server", "debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("server", "debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}

storage/pkg/command/drivers.go

@@ -0,0 +1,104 @@
+package command
+
+import (
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+)
+
+func drivers(cfg *config.Config) map[string]interface{} {
+	return map[string]interface{}{
+		"eos": map[string]interface{}{
+			"namespace":              cfg.Reva.Storages.EOS.Root,
+			"shadow_namespace":       cfg.Reva.Storages.EOS.ShadowNamespace,
+			"uploads_namespace":      cfg.Reva.Storages.EOS.UploadsNamespace,
+			"share_folder":           cfg.Reva.Storages.EOS.ShareFolder,
+			"eos_binary":             cfg.Reva.Storages.EOS.EosBinary,
+			"xrdcopy_binary":         cfg.Reva.Storages.EOS.XrdcopyBinary,
+			"master_url":             cfg.Reva.Storages.EOS.MasterURL,
+			"slave_url":              cfg.Reva.Storages.EOS.SlaveURL,
+			"cache_directory":        cfg.Reva.Storages.EOS.CacheDirectory,
+			"sec_protocol":           cfg.Reva.Storages.EOS.SecProtocol,
+			"keytab":                 cfg.Reva.Storages.EOS.Keytab,
+			"single_username":        cfg.Reva.Storages.EOS.SingleUsername,
+			"enable_logging":         cfg.Reva.Storages.EOS.EnableLogging,
+			"show_hidden_sys_files":  cfg.Reva.Storages.EOS.ShowHiddenSysFiles,
+			"force_single_user_mode": cfg.Reva.Storages.EOS.ForceSingleUserMode,
+			"use_keytab":             cfg.Reva.Storages.EOS.UseKeytab,
+			"gatewaysvc":             cfg.Reva.Storages.EOS.GatewaySVC,
+		},
+		"eoshome": map[string]interface{}{
+			"namespace":              cfg.Reva.Storages.EOS.Root,
+			"shadow_namespace":       cfg.Reva.Storages.EOS.ShadowNamespace,
+			"uploads_namespace":      cfg.Reva.Storages.EOS.UploadsNamespace,
+			"share_folder":           cfg.Reva.Storages.EOS.ShareFolder,
+			"eos_binary":             cfg.Reva.Storages.EOS.EosBinary,
+			"xrdcopy_binary":         cfg.Reva.Storages.EOS.XrdcopyBinary,
+			"master_url":             cfg.Reva.Storages.EOS.MasterURL,
+			"slave_url":              cfg.Reva.Storages.EOS.SlaveURL,
+			"cache_directory":        cfg.Reva.Storages.EOS.CacheDirectory,
+			"sec_protocol":           cfg.Reva.Storages.EOS.SecProtocol,
+			"keytab":                 cfg.Reva.Storages.EOS.Keytab,
+			"single_username":        cfg.Reva.Storages.EOS.SingleUsername,
+			"user_layout":            cfg.Reva.Storages.EOS.UserLayout,
+			"enable_logging":         cfg.Reva.Storages.EOS.EnableLogging,
+			"show_hidden_sys_files":  cfg.Reva.Storages.EOS.ShowHiddenSysFiles,
+			"force_single_user_mode": cfg.Reva.Storages.EOS.ForceSingleUserMode,
+			"use_keytab":             cfg.Reva.Storages.EOS.UseKeytab,
+			"gatewaysvc":             cfg.Reva.Storages.EOS.GatewaySVC,
+		},
+		"eosgrpc": map[string]interface{}{
+			"namespace":              cfg.Reva.Storages.EOS.Root,
+			"shadow_namespace":       cfg.Reva.Storages.EOS.ShadowNamespace,
+			"share_folder":           cfg.Reva.Storages.EOS.ShareFolder,
+			"eos_binary":             cfg.Reva.Storages.EOS.EosBinary,
+			"xrdcopy_binary":         cfg.Reva.Storages.EOS.XrdcopyBinary,
+			"master_url":             cfg.Reva.Storages.EOS.MasterURL,
+			"master_grpc_uri":        cfg.Reva.Storages.EOS.GrpcURI,
+			"slave_url":              cfg.Reva.Storages.EOS.SlaveURL,
+			"cache_directory":        cfg.Reva.Storages.EOS.CacheDirectory,
+			"sec_protocol":           cfg.Reva.Storages.EOS.SecProtocol,
+			"keytab":                 cfg.Reva.Storages.EOS.Keytab,
+			"single_username":        cfg.Reva.Storages.EOS.SingleUsername,
+			"user_layout":            cfg.Reva.Storages.EOS.UserLayout,
+			"enable_logging":         cfg.Reva.Storages.EOS.EnableLogging,
+			"show_hidden_sys_files":  cfg.Reva.Storages.EOS.ShowHiddenSysFiles,
+			"force_single_user_mode": cfg.Reva.Storages.EOS.ForceSingleUserMode,
+			"use_keytab":             cfg.Reva.Storages.EOS.UseKeytab,
+			"enable_home":            cfg.Reva.Storages.EOS.EnableHome,
+			"gatewaysvc":             cfg.Reva.Storages.EOS.GatewaySVC,
+		},
+		"local": map[string]interface{}{
+			"root":         cfg.Reva.Storages.Local.Root,
+			"share_folder": cfg.Reva.Storages.Local.ShareFolder,
+		},
+		"localhome": map[string]interface{}{
+			"root":         cfg.Reva.Storages.Local.Root,
+			"share_folder": cfg.Reva.Storages.Local.ShareFolder,
+			"user_layout":  cfg.Reva.Storages.Local.UserLayout,
+		},
+		"owncloud": map[string]interface{}{
+			"datadirectory":   cfg.Reva.Storages.OwnCloud.Root,
+			"upload_info_dir": cfg.Reva.Storages.OwnCloud.UploadInfoDir,
+			"sharedirectory":  cfg.Reva.Storages.OwnCloud.ShareFolder,
+			"user_layout":     cfg.Reva.Storages.OwnCloud.UserLayout,
+			"redis":           cfg.Reva.Storages.OwnCloud.Redis,
+			"enable_home":     cfg.Reva.Storages.OwnCloud.EnableHome,
+			"scan":            cfg.Reva.Storages.OwnCloud.Scan,
+			"userprovidersvc": cfg.Reva.Users.URL,
+		},
+		"ocis": map[string]interface{}{
+			"root":                cfg.Reva.Storages.Common.Root,
+			"enable_home":         cfg.Reva.Storages.Common.EnableHome,
+			"user_layout":         cfg.Reva.Storages.Common.UserLayout,
+			"treetime_accounting": true,
+			"treesize_accounting": true,
+		},
+		"s3": map[string]interface{}{
+			"region":     cfg.Reva.Storages.S3.Region,
+			"access_key": cfg.Reva.Storages.S3.AccessKey,
+			"secret_key": cfg.Reva.Storages.S3.SecretKey,
+			"endpoint":   cfg.Reva.Storages.S3.Endpoint,
+			"bucket":     cfg.Reva.Storages.S3.Bucket,
+			"prefix":     cfg.Reva.Storages.S3.Root,
+		},
+	}
+}

storage/pkg/command/frontend.go

@@ -0,0 +1,310 @@
+package command
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"path"
+	"strings"
+	"time"
+
+	"github.com/cs3org/reva/cmd/revad/runtime"
+	"github.com/gofrs/uuid"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/server/debug"
+)
+
+// Frontend is the entrypoint for the frontend command.
+func Frontend(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "frontend",
+		Usage: "Start reva frontend service",
+		Flags: flagset.FrontendWithConfig(cfg),
+		Before: func(c *cli.Context) error {
+			cfg.Reva.Frontend.Services = c.StringSlice("service")
+
+			return nil
+		},
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				case "jaeger":
+					logger.Info().
+						Str("type", t).
+						Msg("configuring reva to use the jaeger tracing backend")
+
+				case "zipkin":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				//metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+				uuid := uuid.Must(uuid.NewV4())
+				pidFile := path.Join(os.TempDir(), "revad-"+c.Command.Name+"-"+uuid.String()+".pid")
+
+				// pregenerate list of valid localhost ports for the desktop redirect_uri
+				// TODO use custom scheme like "owncloud://localhost/user/callback" tracked in
+				var desktopRedirectURIs [65535 - 1024]string
+				for port := 0; port < len(desktopRedirectURIs); port++ {
+					desktopRedirectURIs[port] = fmt.Sprintf("http://localhost:%d", (port + 1024))
+				}
+
+				filesCfg := map[string]interface{}{
+					"private_links":     false,
+					"bigfilechunking":   false,
+					"blacklisted_files": []string{},
+					"undelete":          true,
+					"versioning":        true,
+				}
+
+				if !cfg.Reva.UploadDisableTus {
+					filesCfg["tus_support"] = map[string]interface{}{
+						"version":              "1.0.0",
+						"resumable":            "1.0.0",
+						"extension":            "creation,creation-with-upload",
+						"http_method_override": cfg.Reva.UploadHTTPMethodOverride,
+						"max_chunk_size":       int(cfg.Reva.UploadMaxChunkSize),
+					}
+				}
+
+				rcfg := map[string]interface{}{
+					"core": map[string]interface{}{
+						"max_cpus":             cfg.Reva.Users.MaxCPUs,
+						"tracing_enabled":      cfg.Tracing.Enabled,
+						"tracing_endpoint":     cfg.Tracing.Endpoint,
+						"tracing_collector":    cfg.Tracing.Collector,
+						"tracing_service_name": "frontend",
+					},
+					"shared": map[string]interface{}{
+						"jwt_secret": cfg.Reva.JWTSecret,
+						"gatewaysvc": cfg.Reva.Gateway.URL, // Todo or address?
+					},
+					"http": map[string]interface{}{
+						"network": cfg.Reva.Frontend.Network,
+						"address": cfg.Reva.Frontend.Addr,
+						"middlewares": map[string]interface{}{
+							"cors": map[string]interface{}{
+								"allow_credentials": true,
+							},
+						},
+						// TODO build services dynamically
+						"services": map[string]interface{}{
+							"datagateway": map[string]interface{}{
+								"prefix":                 cfg.Reva.Frontend.DatagatewayPrefix,
+								"transfer_shared_secret": cfg.Reva.TransferSecret,
+								"timeout":                86400,
+								"insecure":               true,
+							},
+							"ocdav": map[string]interface{}{
+								"prefix":           cfg.Reva.Frontend.OCDavPrefix,
+								"chunk_folder":     "/var/tmp/reva/chunks",
+								"files_namespace":  cfg.Reva.OCDav.DavFilesNamespace,
+								"webdav_namespace": cfg.Reva.OCDav.WebdavNamespace,
+								"timeout":          86400,
+								"insecure":         true,
+								"disable_tus":      cfg.Reva.UploadDisableTus,
+							},
+							"ocs": map[string]interface{}{
+								"prefix": cfg.Reva.Frontend.OCSPrefix,
+								"config": map[string]interface{}{
+									"version": "1.8",
+									"website": "reva",
+									"host":    urlWithScheme(cfg.Reva.Frontend.URL),
+									"contact": "admin@localhost",
+									"ssl":     "false",
+								},
+								"disable_tus": cfg.Reva.UploadDisableTus,
+								"capabilities": map[string]interface{}{
+									"capabilities": map[string]interface{}{
+										"core": map[string]interface{}{
+											"poll_interval": 60,
+											"webdav_root":   "remote.php/webdav",
+											"status": map[string]interface{}{
+												"installed":      true,
+												"maintenance":    false,
+												"needsDbUpgrade": false,
+												"version":        "10.0.11.5",
+												"versionstring":  "10.0.11",
+												"edition":        "community",
+												"productname":    "reva",
+												"hostname":       "",
+											},
+											"support_url_signing": true,
+										},
+										"checksums": map[string]interface{}{
+											"supported_types":       []string{"SHA256"},
+											"preferred_upload_type": "SHA256",
+										},
+										"files": filesCfg,
+										"dav":   map[string]interface{}{},
+										"files_sharing": map[string]interface{}{
+											"api_enabled":                       true,
+											"resharing":                         true,
+											"group_sharing":                     true,
+											"auto_accept_share":                 true,
+											"share_with_group_members_only":     true,
+											"share_with_membership_groups_only": true,
+											"default_permissions":               22,
+											"search_min_length":                 3,
+											"public": map[string]interface{}{
+												"enabled":              true,
+												"send_mail":            true,
+												"social_share":         true,
+												"upload":               true,
+												"multiple":             true,
+												"supports_upload_only": true,
+												"password": map[string]interface{}{
+													"enforced": true,
+													"enforced_for": map[string]interface{}{
+														"read_only":   true,
+														"read_write":  true,
+														"upload_only": true,
+													},
+												},
+												"expire_date": map[string]interface{}{
+													"enabled": true,
+												},
+											},
+											"user": map[string]interface{}{
+												"send_mail": true,
+											},
+											"user_enumeration": map[string]interface{}{
+												"enabled":            true,
+												"group_members_only": true,
+											},
+											"federation": map[string]interface{}{
+												"outgoing": true,
+												"incoming": true,
+											},
+										},
+										"notifications": map[string]interface{}{
+											"endpoints": []string{"disable"},
+										},
+									},
+									"version": map[string]interface{}{
+										"edition": "reva",
+										"major":   10,
+										"minor":   0,
+										"micro":   11,
+										"string":  "10.0.11",
+									},
+								},
+							},
+						},
+					},
+				}
+
+				gr.Add(func() error {
+					runtime.RunWithOptions(
+						rcfg,
+						pidFile,
+						runtime.WithLogger(&logger.Logger),
+					)
+					return nil
+				}, func(_ error) {
+					logger.Info().
+						Str("server", c.Command.Name).
+						Msg("Shutting down server")
+
+					cancel()
+				})
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Name(c.Command.Name+"-debug"),
+					debug.Addr(cfg.Reva.Frontend.DebugAddr),
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("server", "debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("server", "debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("server", "debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}
+
+// urlWithScheme checks if the given string is prefixed with "http". If it is not, "http://" will be added as prefix.
+// As we can't tell if http or https should be the preferred scheme, the correct approach would be to fail on urls
+// without scheme. As long as we have default urls in our flagsets which don't have a scheme, this is a feasible workaround.
+func urlWithScheme(str string) string {
+	if !strings.HasPrefix(str, "http") {
+		str = "http://" + str
+	}
+	return str
+}

storage/pkg/command/gateway.go

@@ -0,0 +1,259 @@
+package command
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"path"
+	"strings"
+	"time"
+
+	"github.com/cs3org/reva/cmd/revad/runtime"
+	"github.com/gofrs/uuid"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/server/debug"
+	"github.com/owncloud/ocis/ocis-reva/pkg/service/external"
+)
+
+// Gateway is the entrypoint for the gateway command.
+func Gateway(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "gateway",
+		Usage: "Start reva gateway",
+		Flags: flagset.GatewayWithConfig(cfg),
+		Before: func(c *cli.Context) error {
+			cfg.Reva.Gateway.Services = c.StringSlice("service")
+			cfg.Reva.StorageRegistry.Rules = c.StringSlice("storage-registry-rule")
+
+			return nil
+		},
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				case "jaeger":
+					logger.Info().
+						Str("type", t).
+						Msg("configuring reva to use the jaeger tracing backend")
+
+				case "zipkin":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				//metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+
+				uuid := uuid.Must(uuid.NewV4())
+				pidFile := path.Join(os.TempDir(), "revad-"+c.Command.Name+"-"+uuid.String()+".pid")
+
+				rcfg := map[string]interface{}{
+					"core": map[string]interface{}{
+						"max_cpus":             cfg.Reva.Users.MaxCPUs,
+						"tracing_enabled":      cfg.Tracing.Enabled,
+						"tracing_endpoint":     cfg.Tracing.Endpoint,
+						"tracing_collector":    cfg.Tracing.Collector,
+						"tracing_service_name": "gateway",
+					},
+					"shared": map[string]interface{}{
+						"jwt_secret": cfg.Reva.JWTSecret,
+						"gatewaysvc": cfg.Reva.Gateway.URL, // Todo or address?
+					},
+					"grpc": map[string]interface{}{
+						"network": cfg.Reva.Gateway.Network,
+						"address": cfg.Reva.Gateway.Addr,
+						// TODO build services dynamically
+						"services": map[string]interface{}{
+							"gateway": map[string]interface{}{
+								// registries is located on the gateway
+								"authregistrysvc":    cfg.Reva.Gateway.URL,
+								"storageregistrysvc": cfg.Reva.Gateway.URL,
+								"appregistrysvc":     cfg.Reva.Gateway.URL,
+								// user metadata is located on the users services
+								"preferencessvc":  cfg.Reva.Users.URL,
+								"userprovidersvc": cfg.Reva.Users.URL,
+								// sharing is located on the sharing service
+								"usershareprovidersvc":          cfg.Reva.Sharing.URL,
+								"publicshareprovidersvc":        cfg.Reva.Sharing.URL,
+								"ocmshareprovidersvc":           cfg.Reva.Sharing.URL,
+								"commit_share_to_storage_grant": cfg.Reva.Gateway.CommitShareToStorageGrant,
+								"commit_share_to_storage_ref":   cfg.Reva.Gateway.CommitShareToStorageRef,
+								"share_folder":                  cfg.Reva.Gateway.ShareFolder, // ShareFolder is the location where to create shares in the recipient's storage provider.
+								// other
+								"disable_home_creation_on_login": cfg.Reva.Gateway.DisableHomeCreationOnLogin,
+								"datagateway":                    urlWithScheme(cfg.Reva.DataGateway.URL),
+								"transfer_shared_secret":         cfg.Reva.TransferSecret,
+								"transfer_expires":               cfg.Reva.TransferExpires,
+							},
+							"authregistry": map[string]interface{}{
+								"driver": "static",
+								"drivers": map[string]interface{}{
+									"static": map[string]interface{}{
+										"rules": map[string]interface{}{
+											"basic":        cfg.Reva.AuthBasic.URL,
+											"bearer":       cfg.Reva.AuthBearer.URL,
+											"publicshares": cfg.Reva.StoragePublicLink.URL,
+										},
+									},
+								},
+							},
+							"storageregistry": map[string]interface{}{
+								"driver": cfg.Reva.StorageRegistry.Driver,
+								"drivers": map[string]interface{}{
+									"static": map[string]interface{}{
+										"home_provider": cfg.Reva.StorageRegistry.HomeProvider,
+										"rules":         rules(cfg),
+									},
+								},
+							},
+						},
+					},
+				}
+
+				gr.Add(func() error {
+					err := external.RegisterGRPCEndpoint(
+						ctx,
+						"com.owncloud.reva",
+						uuid.String(),
+						cfg.Reva.Gateway.Addr,
+						logger,
+					)
+
+					if err != nil {
+						return err
+					}
+
+					runtime.RunWithOptions(
+						rcfg,
+						pidFile,
+						runtime.WithLogger(&logger.Logger),
+					)
+					return nil
+				}, func(_ error) {
+					logger.Info().
+						Str("server", c.Command.Name).
+						Msg("Shutting down server")
+
+					cancel()
+				})
+
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Name(c.Command.Name+"-debug"),
+					debug.Addr(cfg.Reva.Gateway.DebugAddr),
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("server", "debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("server", "debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("server", "debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}
+
+func rules(cfg *config.Config) map[string]interface{} {
+
+	// if a list of rules is given it overrides the generated rules from below
+	if len(cfg.Reva.StorageRegistry.Rules) > 0 {
+		rules := map[string]interface{}{}
+		for i := range cfg.Reva.StorageRegistry.Rules {
+			parts := strings.SplitN(cfg.Reva.StorageRegistry.Rules[i], "=", 2)
+			rules[parts[0]] = parts[1]
+		}
+		return rules
+	}
+
+	// generate rules based on default config
+	return map[string]interface{}{
+		cfg.Reva.StorageRoot.MountPath:       cfg.Reva.StorageRoot.URL,
+		cfg.Reva.StorageRoot.MountID:         cfg.Reva.StorageRoot.URL,
+		cfg.Reva.StorageHome.MountPath:       cfg.Reva.StorageHome.URL,
+		cfg.Reva.StorageHome.MountID:         cfg.Reva.StorageHome.URL,
+		cfg.Reva.StorageEOS.MountPath:        cfg.Reva.StorageEOS.URL,
+		cfg.Reva.StorageEOS.MountID:          cfg.Reva.StorageEOS.URL,
+		cfg.Reva.StorageOC.MountPath:         cfg.Reva.StorageOC.URL,
+		cfg.Reva.StorageOC.MountID:           cfg.Reva.StorageOC.URL,
+		cfg.Reva.StorageS3.MountPath:         cfg.Reva.StorageS3.URL,
+		cfg.Reva.StorageS3.MountID:           cfg.Reva.StorageS3.URL,
+		cfg.Reva.StorageWND.MountPath:        cfg.Reva.StorageWND.URL,
+		cfg.Reva.StorageWND.MountID:          cfg.Reva.StorageWND.URL,
+		cfg.Reva.StorageCustom.MountPath:     cfg.Reva.StorageCustom.URL,
+		cfg.Reva.StorageCustom.MountID:       cfg.Reva.StorageCustom.URL,
+		cfg.Reva.StoragePublicLink.MountPath: cfg.Reva.StoragePublicLink.URL,
+		// public link storage returns the mount id of the actual storage
+	}
+}

storage/pkg/command/health.go

@@ -0,0 +1,49 @@
+package command
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/micro/cli/v2"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+)
+
+// Health is the entrypoint for the health command.
+func Health(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "health",
+		Usage: "Check health status",
+		Flags: flagset.HealthWithConfig(cfg),
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			resp, err := http.Get(
+				fmt.Sprintf(
+					"http://%s/healthz",
+					cfg.Debug.Addr,
+				),
+			)
+
+			if err != nil {
+				logger.Fatal().
+					Err(err).
+					Msg("Failed to request health check")
+			}
+
+			defer resp.Body.Close()
+
+			if resp.StatusCode != 200 {
+				logger.Fatal().
+					Int("code", resp.StatusCode).
+					Msg("Health seems to be in bad state")
+			}
+
+			logger.Debug().
+				Int("code", resp.StatusCode).
+				Msg("Health got a good state")
+
+			return nil
+		},
+	}
+}

storage/pkg/command/root.go

@@ -0,0 +1,117 @@
+package command
+
+import (
+	"os"
+	"strings"
+
+	"github.com/micro/cli/v2"
+	"github.com/owncloud/ocis/ocis-pkg/log"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/version"
+	"github.com/spf13/viper"
+)
+
+// Execute is the entry point for the ocis-reva command.
+func Execute() error {
+	cfg := config.New()
+
+	app := &cli.App{
+		Name:     "storage",
+		Version:  version.String,
+		Usage:    "Example service for Reva/oCIS",
+		Compiled: version.Compiled(),
+
+		Authors: []*cli.Author{
+			{
+				Name:  "ownCloud GmbH",
+				Email: "support@owncloud.com",
+			},
+		},
+
+		Flags: flagset.RootWithConfig(cfg),
+
+		Before: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
+			viper.SetEnvPrefix("STORAGE")
+			viper.AutomaticEnv()
+
+			if c.IsSet("config-file") {
+				viper.SetConfigFile(c.String("config-file"))
+			} else {
+				viper.SetConfigName("reva")
+
+				viper.AddConfigPath("/etc/ocis")
+				viper.AddConfigPath("$HOME/.ocis")
+				viper.AddConfigPath("./config")
+			}
+
+			if err := viper.ReadInConfig(); err != nil {
+				switch err.(type) {
+				case viper.ConfigFileNotFoundError:
+					logger.Info().
+						Msg("Continue without config")
+				case viper.UnsupportedConfigError:
+					logger.Fatal().
+						Err(err).
+						Msg("Unsupported config type")
+				default:
+					logger.Fatal().
+						Err(err).
+						Msg("Failed to read config")
+				}
+			}
+
+			if err := viper.Unmarshal(&cfg); err != nil {
+				logger.Fatal().
+					Err(err).
+					Msg("Failed to parse config")
+			}
+
+			return nil
+		},
+
+		Commands: []*cli.Command{
+			Frontend(cfg),
+			Gateway(cfg),
+			Users(cfg),
+			AuthBasic(cfg),
+			AuthBearer(cfg),
+			Sharing(cfg),
+			StorageRoot(cfg),
+			StorageHome(cfg),
+			StorageHomeData(cfg),
+			StoragePublicLink(cfg),
+			StorageOC(cfg),
+			StorageMetadata(cfg),
+			StorageOCData(cfg),
+			StorageEOS(cfg),
+			StorageEOSData(cfg),
+			Health(cfg),
+		},
+	}
+
+	cli.HelpFlag = &cli.BoolFlag{
+		Name:  "help,h",
+		Usage: "Show the help",
+	}
+
+	cli.VersionFlag = &cli.BoolFlag{
+		Name:  "version,v",
+		Usage: "Print the version",
+	}
+
+	return app.Run(os.Args)
+}
+
+// NewLogger initializes a service-specific logger instance.
+func NewLogger(cfg *config.Config) log.Logger {
+	return log.NewLogger(
+		log.Name("reva"),
+		log.Level(cfg.Log.Level),
+		log.Pretty(cfg.Log.Pretty),
+		log.Color(cfg.Log.Color),
+	)
+}

storage/pkg/command/sharing.go

@@ -0,0 +1,178 @@
+package command
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"path"
+	"time"
+
+	"github.com/cs3org/reva/cmd/revad/runtime"
+	"github.com/gofrs/uuid"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/server/debug"
+)
+
+// Sharing is the entrypoint for the sharing command.
+func Sharing(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "sharing",
+		Usage: "Start reva sharing service",
+		Flags: flagset.SharingWithConfig(cfg),
+		Before: func(c *cli.Context) error {
+			cfg.Reva.Sharing.Services = c.StringSlice("service")
+
+			return nil
+		},
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				case "jaeger":
+					logger.Info().
+						Str("type", t).
+						Msg("configuring reva to use the jaeger tracing backend")
+
+				case "zipkin":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				//metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+
+				uuid := uuid.Must(uuid.NewV4())
+				pidFile := path.Join(os.TempDir(), "revad-"+c.Command.Name+"-"+uuid.String()+".pid")
+
+				rcfg := map[string]interface{}{
+					"core": map[string]interface{}{
+						"max_cpus":             cfg.Reva.Users.MaxCPUs,
+						"tracing_enabled":      cfg.Tracing.Enabled,
+						"tracing_endpoint":     cfg.Tracing.Endpoint,
+						"tracing_collector":    cfg.Tracing.Collector,
+						"tracing_service_name": "sharing",
+					},
+					"shared": map[string]interface{}{
+						"jwt_secret": cfg.Reva.JWTSecret,
+					},
+					"grpc": map[string]interface{}{
+						"network": cfg.Reva.Sharing.Network,
+						"address": cfg.Reva.Sharing.Addr,
+						// TODO build services dynamically
+						"services": map[string]interface{}{
+							"usershareprovider": map[string]interface{}{
+								"driver": cfg.Reva.Sharing.UserDriver,
+								"drivers": map[string]interface{}{
+									"json": map[string]interface{}{
+										"file": cfg.Reva.Sharing.UserJSONFile,
+									},
+								},
+							},
+							"publicshareprovider": map[string]interface{}{
+								"driver": cfg.Reva.Sharing.PublicDriver,
+							},
+						},
+					},
+				}
+
+				gr.Add(func() error {
+					runtime.RunWithOptions(
+						rcfg,
+						pidFile,
+						runtime.WithLogger(&logger.Logger),
+					)
+					return nil
+				}, func(_ error) {
+					logger.Info().
+						Str("server", c.Command.Name).
+						Msg("Shutting down server")
+
+					cancel()
+				})
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Name(c.Command.Name+"-debug"),
+					debug.Addr(cfg.Reva.Sharing.DebugAddr),
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("server", c.Command.Name+"-debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("server", c.Command.Name+"-debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("server", c.Command.Name+"-debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}

storage/pkg/command/storageeos.go

@@ -0,0 +1,175 @@
+package command
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"path"
+	"time"
+
+	"github.com/cs3org/reva/cmd/revad/runtime"
+	"github.com/gofrs/uuid"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/server/debug"
+)
+
+// StorageEOS is the entrypoint for the storage-eos command.
+func StorageEOS(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "storage-eos",
+		Usage: "Start reva storage-eos service",
+		Flags: flagset.StorageEOSWithConfig(cfg),
+		Before: func(c *cli.Context) error {
+			cfg.Reva.StorageEOS.Services = c.StringSlice("service")
+
+			return nil
+		},
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				case "jaeger":
+					logger.Info().
+						Str("type", t).
+						Msg("configuring reva to use the jaeger tracing backend")
+
+				case "zipkin":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				//metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+				uuid := uuid.Must(uuid.NewV4())
+				pidFile := path.Join(os.TempDir(), "revad-"+c.Command.Name+"-"+uuid.String()+".pid")
+
+				rcfg := map[string]interface{}{
+					"core": map[string]interface{}{
+						"max_cpus":             cfg.Reva.StorageEOS.MaxCPUs,
+						"tracing_enabled":      cfg.Tracing.Enabled,
+						"tracing_endpoint":     cfg.Tracing.Endpoint,
+						"tracing_collector":    cfg.Tracing.Collector,
+						"tracing_service_name": "storage-eos",
+					},
+					"shared": map[string]interface{}{
+						"jwt_secret": cfg.Reva.JWTSecret,
+					},
+					"grpc": map[string]interface{}{
+						"network": cfg.Reva.StorageEOS.Network,
+						"address": cfg.Reva.StorageEOS.Addr,
+						// TODO build services dynamically
+						"services": map[string]interface{}{
+							"storageprovider": map[string]interface{}{
+								"driver":             cfg.Reva.StorageEOS.Driver,
+								"drivers":            drivers(cfg),
+								"mount_path":         cfg.Reva.StorageEOS.MountPath,
+								"mount_id":           cfg.Reva.StorageEOS.MountID,
+								"expose_data_server": cfg.Reva.StorageEOS.ExposeDataServer,
+								// TODO use cfg.Reva.SStorageEOSData.URL, ?
+								"data_server_url": cfg.Reva.StorageEOS.DataServerURL,
+							},
+						},
+					},
+				}
+
+				gr.Add(func() error {
+					runtime.RunWithOptions(
+						rcfg,
+						pidFile,
+						runtime.WithLogger(&logger.Logger),
+					)
+					return nil
+				}, func(_ error) {
+					logger.Info().
+						Str("server", c.Command.Name).
+						Msg("Shutting down server")
+
+					cancel()
+				})
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Name(c.Command.Name+"-debug"),
+					debug.Addr(cfg.Reva.StorageEOS.DebugAddr),
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("server", c.Command.Name+"-debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("server", c.Command.Name+"-debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("server", c.Command.Name+"-debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}

storage/pkg/command/storageeosdata.go

@@ -0,0 +1,175 @@
+package command
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"path"
+	"time"
+
+	"github.com/cs3org/reva/cmd/revad/runtime"
+	"github.com/gofrs/uuid"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/server/debug"
+)
+
+// StorageEOSData is the entrypoint for the storage-oc-data command.
+func StorageEOSData(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "storage-eos-data",
+		Usage: "Start reva storage-eos-data service",
+		Flags: flagset.StorageEOSDataWithConfig(cfg),
+		Before: func(c *cli.Context) error {
+			cfg.Reva.StorageEOSData.Services = c.StringSlice("service")
+
+			return nil
+		},
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				case "jaeger":
+					logger.Info().
+						Str("type", t).
+						Msg("configuring reva to use the jaeger tracing backend")
+
+				case "zipkin":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				//metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+				uuid := uuid.Must(uuid.NewV4())
+				pidFile := path.Join(os.TempDir(), "revad-"+c.Command.Name+"-"+uuid.String()+".pid")
+
+				rcfg := map[string]interface{}{
+					"core": map[string]interface{}{
+						"max_cpus":             cfg.Reva.StorageEOSData.MaxCPUs,
+						"tracing_enabled":      cfg.Tracing.Enabled,
+						"tracing_endpoint":     cfg.Tracing.Endpoint,
+						"tracing_collector":    cfg.Tracing.Collector,
+						"tracing_service_name": "storage-eos-data",
+					},
+					"shared": map[string]interface{}{
+						"jwt_secret": cfg.Reva.JWTSecret,
+						"gatewaysvc": cfg.Reva.Gateway.URL, // Todo or address?
+					},
+					"http": map[string]interface{}{
+						"network": cfg.Reva.StorageEOSData.Network,
+						"address": cfg.Reva.StorageEOSData.Addr,
+						// TODO build services dynamically
+						"services": map[string]interface{}{
+							"dataprovider": map[string]interface{}{
+								"prefix":      cfg.Reva.StorageEOSData.Prefix,
+								"driver":      cfg.Reva.StorageEOSData.Driver,
+								"drivers":     drivers(cfg),
+								"timeout":     86400,
+								"insecure":    true,
+								"disable_tus": false,
+							},
+						},
+					},
+				}
+
+				gr.Add(func() error {
+					runtime.RunWithOptions(
+						rcfg,
+						pidFile,
+						runtime.WithLogger(&logger.Logger),
+					)
+					return nil
+				}, func(_ error) {
+					logger.Info().
+						Str("server", c.Command.Name).
+						Msg("Shutting down server")
+
+					cancel()
+				})
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Name(c.Command.Name+"-debug"),
+					debug.Addr(cfg.Reva.StorageEOSData.DebugAddr),
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("server", c.Command.Name+"-debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("server", c.Command.Name+"-debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("server", c.Command.Name+"-debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}

storage/pkg/command/storagehome.go

@@ -0,0 +1,183 @@
+package command
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"path"
+	"time"
+
+	"github.com/cs3org/reva/cmd/revad/runtime"
+	"github.com/gofrs/uuid"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/server/debug"
+)
+
+// StorageHome is the entrypoint for the storage-home command.
+func StorageHome(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "storage-home",
+		Usage: "Start reva storage-home service",
+		Flags: flagset.StorageHomeWithConfig(cfg),
+		Before: func(c *cli.Context) error {
+			cfg.Reva.StorageHome.Services = c.StringSlice("service")
+
+			return nil
+		},
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				case "jaeger":
+					logger.Info().
+						Str("type", t).
+						Msg("configuring reva to use the jaeger tracing backend")
+
+				case "zipkin":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				//metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+				uuid := uuid.Must(uuid.NewV4())
+				pidFile := path.Join(os.TempDir(), "revad-"+c.Command.Name+"-"+uuid.String()+".pid")
+
+				// override driver enable home option with home config
+				if cfg.Reva.Storages.Home.EnableHome {
+					cfg.Reva.Storages.Common.EnableHome = true
+					cfg.Reva.Storages.EOS.EnableHome = true
+					cfg.Reva.Storages.Local.EnableHome = true
+					cfg.Reva.Storages.OwnCloud.EnableHome = true
+					cfg.Reva.Storages.S3.EnableHome = true
+				}
+				rcfg := map[string]interface{}{
+					"core": map[string]interface{}{
+						"max_cpus":             cfg.Reva.Users.MaxCPUs,
+						"tracing_enabled":      cfg.Tracing.Enabled,
+						"tracing_endpoint":     cfg.Tracing.Endpoint,
+						"tracing_collector":    cfg.Tracing.Collector,
+						"tracing_service_name": "storage-home",
+					},
+					"shared": map[string]interface{}{
+						"jwt_secret": cfg.Reva.JWTSecret,
+					},
+					"grpc": map[string]interface{}{
+						"network": cfg.Reva.StorageHome.Network,
+						"address": cfg.Reva.StorageHome.Addr,
+						// TODO build services dynamically
+						"services": map[string]interface{}{
+							"storageprovider": map[string]interface{}{
+								"driver":             cfg.Reva.StorageHome.Driver,
+								"drivers":            drivers(cfg),
+								"mount_path":         cfg.Reva.StorageHome.MountPath,
+								"mount_id":           cfg.Reva.StorageHome.MountID,
+								"expose_data_server": cfg.Reva.StorageHome.ExposeDataServer,
+								// TODO use cfg.Reva.StorageHomeData.URL, ?
+								"data_server_url": cfg.Reva.StorageHome.DataServerURL,
+							},
+						},
+					},
+				}
+
+				gr.Add(func() error {
+					runtime.RunWithOptions(
+						rcfg,
+						pidFile,
+						runtime.WithLogger(&logger.Logger),
+					)
+					return nil
+				}, func(_ error) {
+					logger.Info().
+						Str("server", c.Command.Name).
+						Msg("Shutting down server")
+
+					cancel()
+				})
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Name(c.Command.Name+"-debug"),
+					debug.Addr(cfg.Reva.StorageHome.DebugAddr),
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("server", c.Command.Name+"-debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("server", c.Command.Name+"-debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("server", c.Command.Name+"-debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}

storage/pkg/command/storagehomedata.go

@@ -0,0 +1,183 @@
+package command
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"path"
+	"time"
+
+	"github.com/cs3org/reva/cmd/revad/runtime"
+	"github.com/gofrs/uuid"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/server/debug"
+)
+
+// StorageHomeData is the entrypoint for the storage-home-data command.
+func StorageHomeData(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "storage-home-data",
+		Usage: "Start reva storage-home-data service",
+		Flags: flagset.StorageHomeDataWithConfig(cfg),
+		Before: func(c *cli.Context) error {
+			cfg.Reva.StorageHomeData.Services = c.StringSlice("service")
+
+			return nil
+		},
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				case "jaeger":
+					logger.Info().
+						Str("type", t).
+						Msg("configuring reva to use the jaeger tracing backend")
+
+				case "zipkin":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				//metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+				uuid := uuid.Must(uuid.NewV4())
+				pidFile := path.Join(os.TempDir(), "revad-"+c.Command.Name+"-"+uuid.String()+".pid")
+
+				// override driver enable home option with home config
+				if cfg.Reva.Storages.Home.EnableHome {
+					cfg.Reva.Storages.Common.EnableHome = true
+					cfg.Reva.Storages.EOS.EnableHome = true
+					cfg.Reva.Storages.Local.EnableHome = true
+					cfg.Reva.Storages.OwnCloud.EnableHome = true
+					cfg.Reva.Storages.S3.EnableHome = true
+				}
+				rcfg := map[string]interface{}{
+					"core": map[string]interface{}{
+						"max_cpus":             cfg.Reva.Users.MaxCPUs,
+						"tracing_enabled":      cfg.Tracing.Enabled,
+						"tracing_endpoint":     cfg.Tracing.Endpoint,
+						"tracing_collector":    cfg.Tracing.Collector,
+						"tracing_service_name": "storage-home-data",
+					},
+					"shared": map[string]interface{}{
+						"jwt_secret": cfg.Reva.JWTSecret,
+						"gatewaysvc": cfg.Reva.Gateway.URL, // Todo or address?
+					},
+					"http": map[string]interface{}{
+						"network": cfg.Reva.StorageHomeData.Network,
+						"address": cfg.Reva.StorageHomeData.Addr,
+						// TODO build services dynamically
+						"services": map[string]interface{}{
+							"dataprovider": map[string]interface{}{
+								"prefix":      cfg.Reva.StorageHomeData.Prefix,
+								"driver":      cfg.Reva.StorageHomeData.Driver,
+								"drivers":     drivers(cfg),
+								"timeout":     86400,
+								"insecure":    true,
+								"disable_tus": false,
+							},
+						},
+					},
+				}
+
+				gr.Add(func() error {
+					runtime.RunWithOptions(
+						rcfg,
+						pidFile,
+						runtime.WithLogger(&logger.Logger),
+					)
+					return nil
+				}, func(_ error) {
+					logger.Info().
+						Str("server", c.Command.Name).
+						Msg("Shutting down server")
+
+					cancel()
+				})
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Name(c.Command.Name+"-debug"),
+					debug.Addr(cfg.Reva.StorageHomeData.DebugAddr),
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("server", c.Command.Name+"-debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("server", c.Command.Name+"-debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("server", c.Command.Name+"-debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}

storage/pkg/command/storagemetadata.go

@@ -0,0 +1,205 @@
+package command
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"path"
+	"time"
+
+	"github.com/cs3org/reva/cmd/revad/runtime"
+	"github.com/gofrs/uuid"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/server/debug"
+)
+
+// StorageMetadata the entrypoint for the reva-storage-metadata command.
+//
+// It provides a ocis-specific storage store metadata (shares,account,settings...)
+func StorageMetadata(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:     "reva-storage-metadata",
+		Usage:    "Start reva storage-metadata service",
+		Flags:    flagset.StorageMetadata(cfg),
+		Category: "Extensions",
+		Before: func(c *cli.Context) error {
+			storageRoot := c.String("storage-root")
+
+			cfg.Reva.Storages.OwnCloud.Root = storageRoot
+			cfg.Reva.Storages.EOS.Root = storageRoot
+			cfg.Reva.Storages.Local.Root = storageRoot
+			cfg.Reva.Storages.S3.Root = storageRoot
+			cfg.Reva.Storages.Home.Root = storageRoot
+
+			return nil
+		},
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				case "jaeger":
+					logger.Info().
+						Str("type", t).
+						Msg("configuring reva to use the jaeger tracing backend")
+
+				case "zipkin":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				//metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+				uuid := uuid.Must(uuid.NewV4())
+				pidFile := path.Join(os.TempDir(), "revad-"+c.Command.Name+"-"+uuid.String()+".pid")
+
+				// Disable home because the metadata is stored independently
+				// of the user. This also means that a valid-token without any user-id
+				// is allowed to write to the metadata-storage.
+				cfg.Reva.Storages.Common.EnableHome = false
+				cfg.Reva.Storages.EOS.EnableHome = false
+				cfg.Reva.Storages.Local.EnableHome = false
+				cfg.Reva.Storages.OwnCloud.EnableHome = false
+				cfg.Reva.Storages.S3.EnableHome = false
+
+				rcfg := map[string]interface{}{
+					"core": map[string]interface{}{
+						"max_cpus":             "100",
+						"tracing_enabled":      false,
+						"tracing_endpoint":     cfg.Tracing.Endpoint,
+						"tracing_collector":    cfg.Tracing.Collector,
+						"tracing_service_name": "storage-metadata",
+					},
+					"shared": map[string]interface{}{
+						"jwt_secret": cfg.Reva.JWTSecret,
+					},
+					"grpc": map[string]interface{}{
+						"network": cfg.Reva.StorageMetadata.Network,
+						"address": cfg.Reva.StorageMetadata.Addr,
+						"interceptors": map[string]interface{}{
+							"log": map[string]interface{}{},
+						},
+						"services": map[string]interface{}{
+							"storageprovider": map[string]interface{}{
+								"mount_path":      "/meta",
+								"data_server_url": cfg.Reva.StorageMetadataData.URL,
+								"driver":          cfg.Reva.StorageMetadata.Driver,
+								"drivers":         drivers(cfg),
+							},
+						},
+					},
+					"http": map[string]interface{}{
+						"network": cfg.Reva.StorageMetadataData.Network,
+						"address": cfg.Reva.StorageMetadataData.Addr,
+						// TODO build services dynamically
+						"services": map[string]interface{}{
+							"dataprovider": map[string]interface{}{
+								"prefix":      "data",
+								"driver":      cfg.Reva.StorageMetadataData.Driver,
+								"drivers":     drivers(cfg),
+								"timeout":     86400,
+								"insecure":    true,
+								"disable_tus": true,
+							},
+						},
+					},
+				}
+
+				gr.Add(func() error {
+					runtime.RunWithOptions(
+						rcfg,
+						pidFile,
+						runtime.WithLogger(&logger.Logger),
+					)
+					return nil
+				}, func(_ error) {
+					logger.Info().
+						Str("server", c.Command.Name).
+						Msg("Shutting down server")
+
+					cancel()
+				})
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Name(c.Command.Name+"-debug"),
+					debug.Addr(cfg.Reva.StorageMetadata.DebugAddr),
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("server", c.Command.Name+"-debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("server", c.Command.Name+"-debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("server", c.Command.Name+"-debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}

storage/pkg/command/storageoc.go

@@ -0,0 +1,175 @@
+package command
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"path"
+	"time"
+
+	"github.com/cs3org/reva/cmd/revad/runtime"
+	"github.com/gofrs/uuid"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/server/debug"
+)
+
+// StorageOC is the entrypoint for the storage-oc command.
+func StorageOC(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "storage-oc",
+		Usage: "Start reva storage-oc service",
+		Flags: flagset.StorageOCWithConfig(cfg),
+		Before: func(c *cli.Context) error {
+			cfg.Reva.StorageOC.Services = c.StringSlice("service")
+
+			return nil
+		},
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				case "jaeger":
+					logger.Info().
+						Str("type", t).
+						Msg("configuring reva to use the jaeger tracing backend")
+
+				case "zipkin":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				//metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+				uuid := uuid.Must(uuid.NewV4())
+				pidFile := path.Join(os.TempDir(), "revad-"+c.Command.Name+"-"+uuid.String()+".pid")
+
+				rcfg := map[string]interface{}{
+					"core": map[string]interface{}{
+						"max_cpus":             cfg.Reva.StorageOC.MaxCPUs,
+						"tracing_enabled":      cfg.Tracing.Enabled,
+						"tracing_endpoint":     cfg.Tracing.Endpoint,
+						"tracing_collector":    cfg.Tracing.Collector,
+						"tracing_service_name": "storage-oc",
+					},
+					"shared": map[string]interface{}{
+						"jwt_secret": cfg.Reva.JWTSecret,
+					},
+					"grpc": map[string]interface{}{
+						"network": cfg.Reva.StorageOC.Network,
+						"address": cfg.Reva.StorageOC.Addr,
+						// TODO build services dynamically
+						"services": map[string]interface{}{
+							"storageprovider": map[string]interface{}{
+								"driver":             cfg.Reva.StorageOC.Driver,
+								"drivers":            drivers(cfg),
+								"mount_path":         cfg.Reva.StorageOC.MountPath,
+								"mount_id":           cfg.Reva.StorageOC.MountID,
+								"expose_data_server": cfg.Reva.StorageOC.ExposeDataServer,
+								// TODO use cfg.Reva.SStorageOCData.URL, ?
+								"data_server_url": cfg.Reva.StorageOC.DataServerURL,
+							},
+						},
+					},
+				}
+
+				gr.Add(func() error {
+					runtime.RunWithOptions(
+						rcfg,
+						pidFile,
+						runtime.WithLogger(&logger.Logger),
+					)
+					return nil
+				}, func(_ error) {
+					logger.Info().
+						Str("server", c.Command.Name).
+						Msg("Shutting down server")
+
+					cancel()
+				})
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Name(c.Command.Name+"-debug"),
+					debug.Addr(cfg.Reva.StorageOC.DebugAddr),
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("server", c.Command.Name+"-debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("server", c.Command.Name+"-debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("server", c.Command.Name+"-debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}

storage/pkg/command/storageocdata.go

@@ -0,0 +1,175 @@
+package command
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"path"
+	"time"
+
+	"github.com/cs3org/reva/cmd/revad/runtime"
+	"github.com/gofrs/uuid"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/server/debug"
+)
+
+// StorageOCData is the entrypoint for the storage-oc-data command.
+func StorageOCData(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "storage-oc-data",
+		Usage: "Start reva storage-oc-data service",
+		Flags: flagset.StorageOCDataWithConfig(cfg),
+		Before: func(c *cli.Context) error {
+			cfg.Reva.StorageOCData.Services = c.StringSlice("service")
+
+			return nil
+		},
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				case "jaeger":
+					logger.Info().
+						Str("type", t).
+						Msg("configuring reva to use the jaeger tracing backend")
+
+				case "zipkin":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				//metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+				uuid := uuid.Must(uuid.NewV4())
+				pidFile := path.Join(os.TempDir(), "revad-"+c.Command.Name+"-"+uuid.String()+".pid")
+
+				rcfg := map[string]interface{}{
+					"core": map[string]interface{}{
+						"max_cpus":             cfg.Reva.StorageOCData.MaxCPUs,
+						"tracing_enabled":      cfg.Tracing.Enabled,
+						"tracing_endpoint":     cfg.Tracing.Endpoint,
+						"tracing_collector":    cfg.Tracing.Collector,
+						"tracing_service_name": "storage-oc-data",
+					},
+					"shared": map[string]interface{}{
+						"jwt_secret": cfg.Reva.JWTSecret,
+						"gatewaysvc": cfg.Reva.Gateway.URL, // Todo or address?
+					},
+					"http": map[string]interface{}{
+						"network": cfg.Reva.StorageOCData.Network,
+						"address": cfg.Reva.StorageOCData.Addr,
+						// TODO build services dynamically
+						"services": map[string]interface{}{
+							"dataprovider": map[string]interface{}{
+								"prefix":      cfg.Reva.StorageOCData.Prefix,
+								"driver":      cfg.Reva.StorageOCData.Driver,
+								"drivers":     drivers(cfg),
+								"timeout":     86400,
+								"insecure":    true,
+								"disable_tus": false,
+							},
+						},
+					},
+				}
+
+				gr.Add(func() error {
+					runtime.RunWithOptions(
+						rcfg,
+						pidFile,
+						runtime.WithLogger(&logger.Logger),
+					)
+					return nil
+				}, func(_ error) {
+					logger.Info().
+						Str("server", c.Command.Name).
+						Msg("Shutting down server")
+
+					cancel()
+				})
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Name(c.Command.Name+"-debug"),
+					debug.Addr(cfg.Reva.StorageOCData.DebugAddr),
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("server", c.Command.Name+"-debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("server", c.Command.Name+"-debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("server", c.Command.Name+"-debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}

storage/pkg/command/storagepubliclink.go

@@ -0,0 +1,176 @@
+package command
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"path"
+	"time"
+
+	"github.com/cs3org/reva/cmd/revad/runtime"
+	"github.com/gofrs/uuid"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/server/debug"
+)
+
+// StoragePublicLink is the entrypoint for the reva-storage-public-link command.
+func StoragePublicLink(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:     "reva-storage-public-link",
+		Usage:    "Start reva storage-public-link service",
+		Flags:    flagset.StoragePublicLink(cfg),
+		Category: "Extensions",
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				case "jaeger":
+					logger.Info().
+						Str("type", t).
+						Msg("configuring reva to use the jaeger tracing backend")
+
+				case "zipkin":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				//metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+				uuid := uuid.Must(uuid.NewV4())
+				pidFile := path.Join(os.TempDir(), "revad-"+c.Command.Name+"-"+uuid.String()+".pid")
+
+				rcfg := map[string]interface{}{
+					"core": map[string]interface{}{
+						"max_cpus":             cfg.Reva.StoragePublicLink.MaxCPUs,
+						"tracing_enabled":      cfg.Tracing.Enabled,
+						"tracing_endpoint":     cfg.Tracing.Endpoint,
+						"tracing_collector":    cfg.Tracing.Collector,
+						"tracing_service_name": "storage-public-link",
+					},
+					"shared": map[string]interface{}{
+						"jwt_secret": cfg.Reva.JWTSecret,
+					},
+					"grpc": map[string]interface{}{
+						"network": cfg.Reva.StoragePublicLink.Network,
+						"address": cfg.Reva.StoragePublicLink.Addr,
+						"interceptors": map[string]interface{}{
+							"log": map[string]interface{}{},
+						},
+						"services": map[string]interface{}{
+							"publicstorageprovider": map[string]interface{}{
+								"mount_path":   cfg.Reva.StoragePublicLink.MountPath,
+								"gateway_addr": cfg.Reva.Gateway.URL,
+							},
+							"authprovider": map[string]interface{}{
+								"auth_manager": "publicshares",
+								"auth_managers": map[string]interface{}{
+									"publicshares": map[string]interface{}{
+										"gateway_addr": cfg.Reva.Gateway.URL,
+									},
+								},
+							},
+						},
+					},
+				}
+
+				gr.Add(func() error {
+					runtime.RunWithOptions(
+						rcfg,
+						pidFile,
+						runtime.WithLogger(&logger.Logger),
+					)
+					return nil
+				}, func(_ error) {
+					logger.Info().
+						Str("server", c.Command.Name).
+						Msg("Shutting down server")
+
+					cancel()
+				})
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Name(c.Command.Name+"-debug"),
+					debug.Addr(cfg.Reva.StoragePublicLink.DebugAddr),
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("server", c.Command.Name+"-debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("server", c.Command.Name+"-debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("server", c.Command.Name+"-debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}

storage/pkg/command/storageroot.go

@@ -0,0 +1,174 @@
+package command
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"path"
+	"time"
+
+	"github.com/cs3org/reva/cmd/revad/runtime"
+	"github.com/gofrs/uuid"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/server/debug"
+)
+
+// StorageRoot is the entrypoint for the storage-root command.
+func StorageRoot(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "storage-root",
+		Usage: "Start reva storage-root service",
+		Flags: flagset.StorageRootWithConfig(cfg),
+		Before: func(c *cli.Context) error {
+			cfg.Reva.StorageRoot.Services = c.StringSlice("service")
+
+			return nil
+		},
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				case "jaeger":
+					logger.Info().
+						Str("type", t).
+						Msg("configuring reva to use the jaeger tracing backend")
+
+				case "zipkin":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				//metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+				uuid := uuid.Must(uuid.NewV4())
+				pidFile := path.Join(os.TempDir(), "revad-"+c.Command.Name+"-"+uuid.String()+".pid")
+
+				rcfg := map[string]interface{}{
+					"core": map[string]interface{}{
+						"max_cpus":             cfg.Reva.StorageRoot.MaxCPUs,
+						"tracing_enabled":      cfg.Tracing.Enabled,
+						"tracing_endpoint":     cfg.Tracing.Endpoint,
+						"tracing_collector":    cfg.Tracing.Collector,
+						"tracing_service_name": "storage-root",
+					},
+					"shared": map[string]interface{}{
+						"jwt_secret": cfg.Reva.JWTSecret,
+					},
+					"grpc": map[string]interface{}{
+						"network": cfg.Reva.StorageRoot.Network,
+						"address": cfg.Reva.StorageRoot.Addr,
+						// TODO build services dynamically
+						"services": map[string]interface{}{
+							"storageprovider": map[string]interface{}{
+								"driver":             cfg.Reva.StorageRoot.Driver,
+								"drivers":            drivers(cfg),
+								"mount_path":         cfg.Reva.StorageRoot.MountPath,
+								"mount_id":           cfg.Reva.StorageRoot.MountID,
+								"expose_data_server": cfg.Reva.StorageRoot.ExposeDataServer,
+								"data_server_url":    cfg.Reva.StorageRoot.DataServerURL,
+							},
+						},
+					},
+				}
+
+				gr.Add(func() error {
+					runtime.RunWithOptions(
+						rcfg,
+						pidFile,
+						runtime.WithLogger(&logger.Logger),
+					)
+					return nil
+				}, func(_ error) {
+					logger.Info().
+						Str("server", c.Command.Name).
+						Msg("Shutting down server")
+
+					cancel()
+				})
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Name(c.Command.Name+"-debug"),
+					debug.Addr(cfg.Reva.StorageRoot.DebugAddr),
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("server", c.Command.Name+"-debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("server", c.Command.Name+"-debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("server", c.Command.Name+"-debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}

storage/pkg/command/users.go

@@ -0,0 +1,207 @@
+package command
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"path"
+	"time"
+
+	"github.com/cs3org/reva/cmd/revad/runtime"
+	"github.com/gofrs/uuid"
+	"github.com/micro/cli/v2"
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/ocis-reva/pkg/config"
+	"github.com/owncloud/ocis/ocis-reva/pkg/flagset"
+	"github.com/owncloud/ocis/ocis-reva/pkg/server/debug"
+)
+
+// Users is the entrypoint for the sharing command.
+func Users(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "users",
+		Usage: "Start reva users service",
+		Flags: flagset.UsersWithConfig(cfg),
+		Before: func(c *cli.Context) error {
+			cfg.Reva.Users.Services = c.StringSlice("service")
+
+			return nil
+		},
+		Action: func(c *cli.Context) error {
+			logger := NewLogger(cfg)
+
+			if cfg.Tracing.Enabled {
+				switch t := cfg.Tracing.Type; t {
+				case "agent":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				case "jaeger":
+					logger.Info().
+						Str("type", t).
+						Msg("configuring reva to use the jaeger tracing backend")
+
+				case "zipkin":
+					logger.Error().
+						Str("type", t).
+						Msg("Reva only supports the jaeger tracing backend")
+
+				default:
+					logger.Warn().
+						Str("type", t).
+						Msg("Unknown tracing backend")
+				}
+
+			} else {
+				logger.Debug().
+					Msg("Tracing is not enabled")
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = context.WithCancel(context.Background())
+				//metrics     = metrics.New()
+			)
+
+			defer cancel()
+
+			{
+				uuid := uuid.Must(uuid.NewV4())
+				pidFile := path.Join(os.TempDir(), "revad-"+c.Command.Name+"-"+uuid.String()+".pid")
+
+				rcfg := map[string]interface{}{
+					"core": map[string]interface{}{
+						"max_cpus":             cfg.Reva.Users.MaxCPUs,
+						"tracing_enabled":      cfg.Tracing.Enabled,
+						"tracing_endpoint":     cfg.Tracing.Endpoint,
+						"tracing_collector":    cfg.Tracing.Collector,
+						"tracing_service_name": "users",
+					},
+					"shared": map[string]interface{}{
+						"jwt_secret": cfg.Reva.JWTSecret,
+					},
+					"grpc": map[string]interface{}{
+						"network": cfg.Reva.Users.Network,
+						"address": cfg.Reva.Users.Addr,
+						// TODO build services dynamically
+						"services": map[string]interface{}{
+							"userprovider": map[string]interface{}{
+								"driver": cfg.Reva.Users.Driver,
+								"drivers": map[string]interface{}{
+									"json": map[string]interface{}{
+										"users": cfg.Reva.Users.JSON,
+									},
+									"ldap": map[string]interface{}{
+										"hostname":        cfg.Reva.LDAP.Hostname,
+										"port":            cfg.Reva.LDAP.Port,
+										"base_dn":         cfg.Reva.LDAP.BaseDN,
+										"userfilter":      cfg.Reva.LDAP.UserFilter,
+										"attributefilter": cfg.Reva.LDAP.AttributeFilter,
+										"findfilter":      cfg.Reva.LDAP.FindFilter,
+										"groupfilter":     cfg.Reva.LDAP.GroupFilter,
+										"bind_username":   cfg.Reva.LDAP.BindDN,
+										"bind_password":   cfg.Reva.LDAP.BindPassword,
+										"idp":             cfg.Reva.LDAP.IDP,
+										"schema": map[string]interface{}{
+											"dn":          "dn",
+											"uid":         cfg.Reva.LDAP.Schema.UID,
+											"mail":        cfg.Reva.LDAP.Schema.Mail,
+											"displayName": cfg.Reva.LDAP.Schema.DisplayName,
+											"cn":          cfg.Reva.LDAP.Schema.CN,
+											"uidNumber":   cfg.Reva.LDAP.Schema.UIDNumber,
+											"gidNumber":   cfg.Reva.LDAP.Schema.GIDNumber,
+										},
+									},
+									"rest": map[string]interface{}{
+										"client_id":                    cfg.Reva.UserRest.ClientID,
+										"client_secret":                cfg.Reva.UserRest.ClientSecret,
+										"redis_address":                cfg.Reva.UserRest.RedisAddress,
+										"redis_username":               cfg.Reva.UserRest.RedisUsername,
+										"redis_password":               cfg.Reva.UserRest.RedisPassword,
+										"user_groups_cache_expiration": cfg.Reva.UserRest.UserGroupsCacheExpiration,
+										"id_provider":                  cfg.Reva.UserRest.IDProvider,
+										"api_base_url":                 cfg.Reva.UserRest.APIBaseURL,
+										"oidc_token_endpoint":          cfg.Reva.UserRest.OIDCTokenEndpoint,
+										"target_api":                   cfg.Reva.UserRest.TargetAPI,
+									},
+								},
+							},
+						},
+					},
+				}
+
+				gr.Add(func() error {
+					runtime.RunWithOptions(
+						rcfg,
+						pidFile,
+						runtime.WithLogger(&logger.Logger),
+					)
+					return nil
+				}, func(_ error) {
+					logger.Info().
+						Str("server", c.Command.Name).
+						Msg("Shutting down server")
+
+					cancel()
+				})
+			}
+
+			{
+				server, err := debug.Server(
+					debug.Name(c.Command.Name+"-debug"),
+					debug.Addr(cfg.Reva.Users.DebugAddr),
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().
+						Err(err).
+						Str("server", c.Command.Name+"-debug").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(func() error {
+					return server.ListenAndServe()
+				}, func(_ error) {
+					ctx, timeout := context.WithTimeout(ctx, 5*time.Second)
+
+					defer timeout()
+					defer cancel()
+
+					if err := server.Shutdown(ctx); err != nil {
+						logger.Info().
+							Err(err).
+							Str("server", c.Command.Name+"-debug").
+							Msg("Failed to shutdown server")
+					} else {
+						logger.Info().
+							Str("server", c.Command.Name+"-debug").
+							Msg("Shutting down server")
+					}
+				})
+			}
+
+			{
+				stop := make(chan os.Signal, 1)
+
+				gr.Add(func() error {
+					signal.Notify(stop, os.Interrupt)
+
+					<-stop
+
+					return nil
+				}, func(err error) {
+					close(stop)
+					cancel()
+				})
+			}
+
+			return gr.Run()
+		},
+	}
+}