diff --git a/ocis-reva/pkg/command/root.go b/ocis-reva/pkg/command/root.go index 82bd6ebc4..add5d853f 100644 --- a/ocis-reva/pkg/command/root.go +++ b/ocis-reva/pkg/command/root.go @@ -85,6 +85,7 @@ func Execute() error { StorageHomeData(cfg), StoragePublicLink(cfg), StorageOC(cfg), + StorageMetadata(cfg), StorageOCData(cfg), StorageEOS(cfg), StorageEOSData(cfg), diff --git a/ocis-reva/pkg/command/storagemetadata.go b/ocis-reva/pkg/command/storagemetadata.go new file mode 100644 index 000000000..95a172cc9 --- /dev/null +++ b/ocis-reva/pkg/command/storagemetadata.go @@ -0,0 +1,195 @@ +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", + 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() + }, + } +} diff --git a/ocis-reva/pkg/flagset/storagemetadata.go b/ocis-reva/pkg/flagset/storagemetadata.go new file mode 100644 index 000000000..0f817e734 --- /dev/null +++ b/ocis-reva/pkg/flagset/storagemetadata.go @@ -0,0 +1,72 @@ +package flagset + +import ( + "github.com/micro/cli/v2" + "github.com/owncloud/ocis/ocis-reva/pkg/config" +) + +// StorageMetadata applies cfg to the root flagset +func StorageMetadata(cfg *config.Config) []cli.Flag { + flags := []cli.Flag{ + &cli.StringFlag{ + Name: "debug-addr", + Value: "0.0.0.0:9184", + Usage: "Address to bind debug server", + EnvVars: []string{"REVA_STORAGE_METADATA_DEBUG_ADDR"}, + Destination: &cfg.Reva.StorageMetadata.DebugAddr, + }, + &cli.StringFlag{ + Name: "network", + Value: "tcp", + Usage: "Network to use for the reva service, can be 'tcp', 'udp' or 'unix'", + EnvVars: []string{"REVA_STORAGE_METADATA_NETWORK"}, + Destination: &cfg.Reva.StorageMetadata.Network, + }, + &cli.StringFlag{ + Name: "provider-addr", + Value: "0.0.0.0:9185", + Usage: "Address to bind reva service", + EnvVars: []string{"REVA_STORAGE_METADATA_PROVIDER_ADDR"}, + Destination: &cfg.Reva.StorageMetadata.Addr, + }, + &cli.StringFlag{ + Name: "data-server-url", + Value: "http://localhost:9187", + Usage: "URL of the data-server the storage-provider uses", + EnvVars: []string{"REVA_STORAGE_METADATA_DATA_SERVER_URL"}, + Destination: &cfg.Reva.StorageMetadata.DataServerURL, + }, + &cli.StringFlag{ + Name: "data-server-addr", + Value: "0.0.0.0:9187", + Usage: "Address to bind the metadata data-server to", + EnvVars: []string{"REVA_STORAGE_METADATA_DATA_SERVER_ADDR"}, + Destination: &cfg.Reva.StorageMetadataData.Addr, + }, + &cli.StringFlag{ + Name: "storage-provider-driver", + Value: "local", + Usage: "storage driver for metadata mount: eg. local, eos, owncloud, ocis or s3", + EnvVars: []string{"REVA_STORAGE_METADATA_PROVIDER_DRIVER"}, + Destination: &cfg.Reva.StorageMetadata.Driver, + }, + &cli.StringFlag{ + Name: "data-provider-driver", + Value: "local", + Usage: "storage driver for data-provider mount: eg. local, eos, owncloud, ocis or s3", + EnvVars: []string{"REVA_STORAGE_METADATA_DATA_PROVIDER_DRIVER"}, + Destination: &cfg.Reva.StorageMetadata.Driver, + }, + } + + flags = append(flags, TracingWithConfig(cfg)...) + flags = append(flags, DebugWithConfig(cfg)...) + flags = append(flags, SecretWithConfig(cfg)...) + flags = append(flags, DriverEOSWithConfig(cfg)...) + flags = append(flags, DriverLocalWithConfig(cfg)...) + flags = append(flags, DriverOwnCloudWithConfig(cfg)...) + flags = append(flags, DriverOCISWithConfig(cfg)...) + + return flags + +}