Initial QSfera import

Server/services/ocs/pkg/command/health.go

@@ -0,0 +1,54 @@
+package command
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/qsfera/server/pkg/config/configlog"
+	"github.com/qsfera/server/pkg/log"
+	"github.com/qsfera/server/services/ocs/pkg/config"
+	"github.com/qsfera/server/services/ocs/pkg/config/parser"
+
+	"github.com/spf13/cobra"
+)
+
+// Health is the entrypoint for the health command.
+func Health(cfg *config.Config) *cobra.Command {
+	return &cobra.Command{
+		Use:   "health",
+		Short: "check health status",
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			return configlog.ReturnError(parser.ParseConfig(cfg))
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			logger := log.Configure(cfg.Service.Name, cfg.Commons, cfg.LogLevel)
+
+			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 != http.StatusOK {
+				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
+		},
+	}
+}

Server/services/ocs/pkg/command/root.go

@@ -0,0 +1,36 @@
+package command
+
+import (
+	"os"
+
+	"github.com/qsfera/server/pkg/clihelper"
+	"github.com/qsfera/server/services/ocs/pkg/config"
+
+	"github.com/spf13/cobra"
+)
+
+// GetCommands provides all commands for this service
+func GetCommands(cfg *config.Config) []*cobra.Command {
+	return []*cobra.Command{
+		// start this service
+		Server(cfg),
+
+		// interaction with this service
+
+		// infos about this service
+		Health(cfg),
+		Version(cfg),
+	}
+}
+
+// Execute is the entry point for the qsfera-ocs command.
+func Execute(cfg *config.Config) error {
+	app := clihelper.DefaultApp(&cobra.Command{
+		Use:   "ocs",
+		Short: "Serve OCS API for КуСфера",
+	})
+	app.AddCommand(GetCommands(cfg)...)
+	app.SetArgs(os.Args[1:])
+
+	return app.ExecuteContext(cfg.Context)
+}

Server/services/ocs/pkg/command/server.go

@@ -0,0 +1,101 @@
+package command
+
+import (
+	"context"
+	"fmt"
+	"os/signal"
+
+	"github.com/qsfera/server/pkg/config/configlog"
+	"github.com/qsfera/server/pkg/log"
+	"github.com/qsfera/server/pkg/runner"
+	ogrpc "github.com/qsfera/server/pkg/service/grpc"
+	"github.com/qsfera/server/pkg/tracing"
+	"github.com/qsfera/server/pkg/version"
+	"github.com/qsfera/server/services/ocs/pkg/config"
+	"github.com/qsfera/server/services/ocs/pkg/config/parser"
+	"github.com/qsfera/server/services/ocs/pkg/metrics"
+	"github.com/qsfera/server/services/ocs/pkg/server/debug"
+	"github.com/qsfera/server/services/ocs/pkg/server/http"
+
+	"github.com/spf13/cobra"
+)
+
+// Server is the entrypoint for the server command.
+func Server(cfg *config.Config) *cobra.Command {
+	return &cobra.Command{
+		Use:   "server",
+		Short: fmt.Sprintf("start the %s service without runtime (unsupervised mode)", cfg.Service.Name),
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			return configlog.ReturnFatal(parser.ParseConfig(cfg))
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			logger := log.Configure(cfg.Service.Name, cfg.Commons, cfg.LogLevel)
+			traceProvider, err := tracing.GetTraceProvider(cmd.Context(), cfg.Commons.TracesExporter, cfg.Service.Name)
+			if err != nil {
+				return err
+			}
+
+			cfg.GrpcClient, err = ogrpc.NewClient(ogrpc.GetClientOptions(cfg.GRPCClientTLS)...)
+			if err != nil {
+				return err
+			}
+
+			var cancel context.CancelFunc
+			if cfg.Context == nil {
+				cfg.Context, cancel = signal.NotifyContext(context.Background(), runner.StopSignals...)
+				defer cancel()
+			}
+			ctx := cfg.Context
+
+			metrics := metrics.New()
+			metrics.BuildInfo.WithLabelValues(version.GetString()).Set(1)
+
+			gr := runner.NewGroup()
+			{
+				server, err := http.Server(
+					http.Logger(logger),
+					http.Context(ctx),
+					http.Config(cfg),
+					http.Metrics(metrics),
+					http.TraceProvider(traceProvider),
+				)
+
+				if err != nil {
+					logger.Error().
+						Err(err).
+						Str("transport", "http").
+						Msg("Failed to initialize server")
+
+					return err
+				}
+
+				gr.Add(runner.NewGoMicroHttpServerRunner(cfg.Service.Name+".http", server))
+			}
+
+			{
+				debugServer, err := debug.Server(
+					debug.Logger(logger),
+					debug.Context(ctx),
+					debug.Config(cfg),
+				)
+
+				if err != nil {
+					logger.Info().Err(err).Str("transport", "debug").Msg("Failed to initialize server")
+					return err
+				}
+
+				gr.Add(runner.NewGolangHttpServerRunner(cfg.Service.Name+".debug", debugServer))
+			}
+
+			grResults := gr.Run(ctx)
+
+			// return the first non-nil error found in the results
+			for _, grResult := range grResults {
+				if grResult.RunnerError != nil {
+					return grResult.RunnerError
+				}
+			}
+			return nil
+		},
+	}
+}

Server/services/ocs/pkg/command/version.go

@@ -0,0 +1,49 @@
+package command
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/qsfera/server/pkg/registry"
+	"github.com/qsfera/server/pkg/version"
+	"github.com/qsfera/server/services/ocs/pkg/config"
+
+	"github.com/olekukonko/tablewriter"
+	"github.com/olekukonko/tablewriter/tw"
+	"github.com/spf13/cobra"
+)
+
+// Version prints the service versions of all running instances.
+func Version(cfg *config.Config) *cobra.Command {
+	return &cobra.Command{
+		Use:   "version",
+		Short: "print the version of this binary and the running service instances",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			fmt.Println("Version: " + version.GetString())
+			fmt.Printf("Compiled: %s\n", version.Compiled())
+			fmt.Println("")
+
+			reg := registry.GetRegistry()
+			services, err := reg.GetService(cfg.HTTP.Namespace + "." + cfg.Service.Name)
+			if err != nil {
+				fmt.Println(fmt.Errorf("could not get %s services from the registry: %v", cfg.Service.Name, err))
+				return err
+			}
+
+			if len(services) == 0 {
+				fmt.Println("No running " + cfg.Service.Name + " service found.")
+				return nil
+			}
+
+			table := tablewriter.NewTable(os.Stdout, tablewriter.WithHeaderAutoFormat(tw.Off))
+			table.Header([]string{"Version", "Address", "Id"})
+			for _, s := range services {
+				for _, n := range s.Nodes {
+					table.Append([]string{s.Version, n.Address, n.Id})
+				}
+			}
+			table.Render()
+			return nil
+		},
+	}
+}

Server/services/ocs/pkg/config/config.go

@@ -0,0 +1,39 @@
+package config
+
+import (
+	"context"
+	"time"
+
+	"github.com/qsfera/server/pkg/shared"
+	"go-micro.dev/v4/client"
+)
+
+// Config combines all available configuration parts.
+type Config struct {
+	Commons *shared.Commons `yaml:"-"` // don't use this directly as configuration for a service
+
+	Service Service `yaml:"-"`
+
+	LogLevel string `yaml:"loglevel" env:"OC_LOG_LEVEL;OCS_LOG_LEVEL" desc:"The log level. Valid values are: 'panic', 'fatal', 'error', 'warn', 'info', 'debug', 'trace'." introductionVersion:"1.0.0"`
+	Debug    Debug  `yaml:"debug"`
+
+	HTTP HTTP `yaml:"http"`
+
+	GRPCClientTLS *shared.GRPCClientTLS `yaml:"grpc_client_tls"`
+	GrpcClient    client.Client         `yaml:"-"`
+
+	SigningKeys *SigningKeys `yaml:"signing_keys"`
+
+	TokenManager *TokenManager `yaml:"token_manager"`
+
+	Context context.Context `yaml:"-"`
+}
+
+// SigningKeys is a store configuration.
+type SigningKeys struct {
+	Store        string        `yaml:"store" env:"OC_CACHE_STORE;OCS_PRESIGNEDURL_SIGNING_KEYS_STORE" desc:"The type of the signing key store. Supported values are: 'redis-sentinel' and 'nats-js-kv'. See the text description for details." introductionVersion:"1.0.0"`
+	Nodes        []string      `yaml:"addresses" env:"OC_CACHE_STORE_NODES;OCS_PRESIGNEDURL_SIGNING_KEYS_STORE_NODES" desc:"A list of nodes to access the configured store. Note that the behaviour how nodes are used is dependent on the library of the configured store. See the Environment Variable Types description for more details." introductionVersion:"1.0.0"`
+	TTL          time.Duration `yaml:"ttl" env:"OC_CACHE_TTL;OCS_PRESIGNEDURL_SIGNING_KEYS_STORE_TTL" desc:"Default time to live for signing keys. See the Environment Variable Types description for more details." introductionVersion:"1.0.0"`
+	AuthUsername string        `yaml:"username" env:"OC_CACHE_AUTH_USERNAME;OCS_PRESIGNEDURL_SIGNING_KEYS_STORE_AUTH_USERNAME" desc:"The username to authenticate with the store. Only applies when store type 'nats-js-kv' is configured." introductionVersion:"1.0.0"`
+	AuthPassword string        `yaml:"password" env:"OC_CACHE_AUTH_PASSWORD;OCS_PRESIGNEDURL_SIGNING_KEYS_STORE_AUTH_PASSWORD" desc:"The password to authenticate with the store. Only applies when store type 'nats-js-kv' is configured." introductionVersion:"1.0.0"`
+}

Server/services/ocs/pkg/config/debug.go

@@ -0,0 +1,9 @@
+package config
+
+// Debug defines the available debug configuration.
+type Debug struct {
+	Addr   string `yaml:"addr" env:"OCS_DEBUG_ADDR" desc:"Bind address of the debug server, where metrics, health, config and debug endpoints will be exposed." introductionVersion:"1.0.0"`
+	Token  string `yaml:"token" env:"OCS_DEBUG_TOKEN" desc:"Token to secure the metrics endpoint." introductionVersion:"1.0.0"`
+	Pprof  bool   `yaml:"pprof" env:"OCS_DEBUG_PPROF" desc:"Enables pprof, which can be used for profiling." introductionVersion:"1.0.0"`
+	Zpages bool   `yaml:"zpages" env:"OCS_DEBUG_ZPAGES" desc:"Enables zpages, which can be used for collecting and viewing in-memory traces." introductionVersion:"1.0.0"`
+}

Server/services/ocs/pkg/config/defaults/defaultconfig.go

@@ -0,0 +1,79 @@
+package defaults
+
+import (
+	"strings"
+	"time"
+
+	"github.com/qsfera/server/pkg/structs"
+	"github.com/qsfera/server/services/ocs/pkg/config"
+)
+
+// FullDefaultConfig returns a fully initialized default configuration
+func FullDefaultConfig() *config.Config {
+	cfg := DefaultConfig()
+	EnsureDefaults(cfg)
+	Sanitize(cfg)
+	return cfg
+}
+
+// DefaultConfig returns a basic default configuration
+func DefaultConfig() *config.Config {
+	return &config.Config{
+		Debug: config.Debug{
+			Addr:   "127.0.0.1:9114",
+			Token:  "",
+			Pprof:  false,
+			Zpages: false,
+		},
+		HTTP: config.HTTP{
+			Addr:      "127.0.0.1:9110",
+			Root:      "/ocs",
+			Namespace: "qsfera.web",
+			CORS: config.CORS{
+				AllowedOrigins:   []string{"*"},
+				AllowedMethods:   []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"},
+				AllowedHeaders:   []string{"Authorization", "Origin", "Content-Type", "Accept", "X-Requested-With", "X-Request-Id", "Cache-Control"},
+				AllowCredentials: true,
+			},
+		},
+		Service: config.Service{
+			Name: "ocs",
+		},
+		SigningKeys: &config.SigningKeys{
+			Store: "nats-js-kv", // signing keys are read by proxy, so we cannot use memory. It is not shared.
+			Nodes: []string{"127.0.0.1:9233"},
+			TTL:   time.Hour * 24,
+		},
+	}
+}
+
+// EnsureDefaults adds default values to the configuration if they are not set yet
+func EnsureDefaults(cfg *config.Config) {
+	if cfg.LogLevel == "" {
+		cfg.LogLevel = "error"
+	}
+
+	if cfg.TokenManager == nil && cfg.Commons != nil && cfg.Commons.TokenManager != nil {
+		cfg.TokenManager = &config.TokenManager{
+			JWTSecret: cfg.Commons.TokenManager.JWTSecret,
+		}
+	} else if cfg.TokenManager == nil {
+		cfg.TokenManager = &config.TokenManager{}
+	}
+
+	if cfg.Commons != nil {
+		cfg.HTTP.TLS = cfg.Commons.HTTPServiceTLS
+	}
+
+	if cfg.GRPCClientTLS == nil && cfg.Commons != nil {
+		cfg.GRPCClientTLS = structs.CopyOrZeroValue(cfg.Commons.GRPCClientTLS)
+	}
+}
+
+// Sanitize sanitizes the configuration
+func Sanitize(cfg *config.Config) {
+	// sanitize config
+	if cfg.HTTP.Root != "/" {
+		cfg.HTTP.Root = strings.TrimSuffix(cfg.HTTP.Root, "/")
+	}
+}

Server/services/ocs/pkg/config/http.go

@@ -0,0 +1,20 @@
+package config
+
+import "github.com/qsfera/server/pkg/shared"
+
+// HTTP defines the available http configuration.
+type HTTP struct {
+	Addr      string                `yaml:"addr" env:"OCS_HTTP_ADDR" desc:"The bind address of the HTTP service." introductionVersion:"1.0.0"`
+	Root      string                `yaml:"root" env:"OCS_HTTP_ROOT" desc:"Subdirectory that serves as the root for this HTTP service." introductionVersion:"1.0.0"`
+	Namespace string                `yaml:"-"`
+	CORS      CORS                  `yaml:"cors"`
+	TLS       shared.HTTPServiceTLS `yaml:"tls"`
+}
+
+// CORS defines the available cors configuration.
+type CORS struct {
+	AllowedOrigins   []string `yaml:"allow_origins" env:"OC_CORS_ALLOW_ORIGINS;OCS_CORS_ALLOW_ORIGINS" desc:"A list of allowed CORS origins. See following chapter for more details: *Access-Control-Allow-Origin* at https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin. See the Environment Variable Types description for more details." introductionVersion:"1.0.0"`
+	AllowedMethods   []string `yaml:"allow_methods" env:"OC_CORS_ALLOW_METHODS;OCS_CORS_ALLOW_METHODS" desc:"A list of allowed CORS methods. See following chapter for more details: *Access-Control-Request-Method* at https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Request-Method. See the Environment Variable Types description for more details." introductionVersion:"1.0.0"`
+	AllowedHeaders   []string `yaml:"allow_headers" env:"OC_CORS_ALLOW_HEADERS;OCS_CORS_ALLOW_HEADERS" desc:"A list of allowed CORS headers. See following chapter for more details: *Access-Control-Request-Headers* at https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Request-Headers. See the Environment Variable Types description for more details." introductionVersion:"1.0.0"`
+	AllowCredentials bool     `yaml:"allow_credentials" env:"OC_CORS_ALLOW_CREDENTIALS;OCS_CORS_ALLOW_CREDENTIALS" desc:"Allow credentials for CORS.See following chapter for more details: *Access-Control-Allow-Credentials* at https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Credentials." introductionVersion:"1.0.0"`
+}

Server/services/ocs/pkg/config/parser/parse.go

@@ -0,0 +1,43 @@
+package parser
+
+import (
+	"errors"
+
+	"github.com/qsfera/server/services/ocs/pkg/config"
+	"github.com/qsfera/server/services/ocs/pkg/config/defaults"
+
+	occfg "github.com/qsfera/server/pkg/config"
+	"github.com/qsfera/server/pkg/shared"
+
+	"github.com/qsfera/server/pkg/config/envdecode"
+)
+
+// ParseConfig loads configuration from known paths.
+func ParseConfig(cfg *config.Config) error {
+	err := occfg.BindSourcesToStructs(cfg.Service.Name, cfg)
+	if err != nil {
+		return err
+	}
+
+	defaults.EnsureDefaults(cfg)
+
+	// load all env variables relevant to the config in the current context.
+	if err := envdecode.Decode(cfg); err != nil {
+		// no environment variable set for this config is an expected "error"
+		if !errors.Is(err, envdecode.ErrNoTargetFieldsAreSet) {
+			return err
+		}
+	}
+
+	defaults.Sanitize(cfg)
+
+	return Validate(cfg)
+}
+
+func Validate(cfg *config.Config) error {
+	if cfg.TokenManager.JWTSecret == "" {
+		return shared.MissingJWTTokenError(cfg.Service.Name)
+	}
+
+	return nil
+}

Server/services/ocs/pkg/config/reva.go

@@ -0,0 +1,6 @@
+package config
+
+// TokenManager is the config for using the reva token manager
+type TokenManager struct {
+	JWTSecret string `yaml:"jwt_secret" env:"OC_JWT_SECRET;OCS_JWT_SECRET" desc:"The secret to mint and validate jwt tokens." introductionVersion:"1.0.0"`
+}

Server/services/ocs/pkg/config/service.go

@@ -0,0 +1,6 @@
+package config
+
+// Service defines the available service configuration.
+type Service struct {
+	Name string `yaml:"-"`
+}

Server/services/ocs/pkg/metrics/metrics.go

@@ -0,0 +1,45 @@
+package metrics
+
+import "github.com/prometheus/client_golang/prometheus"
+
+var (
+	// Namespace defines the namespace for the defines metrics.
+	Namespace = "qsfera"
+
+	// Subsystem defines the subsystem for the defines metrics.
+	Subsystem = "ocs"
+)
+
+// Metrics defines the available metrics of this service.
+type Metrics struct {
+	// Counter  *prometheus.CounterVec
+	BuildInfo *prometheus.GaugeVec
+}
+
+// New initializes the available metrics.
+func New() *Metrics {
+	m := &Metrics{
+		// Counter: prometheus.NewCounterVec(prometheus.CounterOpts{
+		// 	Namespace: Namespace,
+		// 	Subsystem: Subsystem,
+		// 	Name:      "greet_total",
+		// 	Help:      "How many greeting requests processed",
+		// }, []string{}),
+		BuildInfo: prometheus.NewGaugeVec(prometheus.GaugeOpts{
+			Namespace: Namespace,
+			Subsystem: Subsystem,
+			Name:      "build_info",
+			Help:      "Build Information",
+		}, []string{"version"}),
+	}
+
+	// prometheus.Register(
+	// 	m.Counter,
+	// )
+
+	_ = prometheus.Register(
+		m.BuildInfo,
+	)
+
+	return m
+}

Server/services/ocs/pkg/middleware/format.go

@@ -0,0 +1,24 @@
+package middleware
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/go-chi/render"
+)
+
+// OCSFormatCtx middleware is used to determine the content type from
+// the format URL parameter passed in an ocs request. Defaults to XML
+func OCSFormatCtx(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Query().Get("format") {
+		case "", "xml":
+			r.Header.Set("Accept", "application/xml")
+			r = r.WithContext(context.WithValue(r.Context(), render.ContentTypeCtxKey, render.ContentTypeXML))
+		case "json":
+			r.Header.Set("Accept", "application/json")
+			r = r.WithContext(context.WithValue(r.Context(), render.ContentTypeCtxKey, render.ContentTypeJSON))
+		}
+		next.ServeHTTP(w, r)
+	})
+}

Server/services/ocs/pkg/server/debug/option.go

@@ -0,0 +1,50 @@
+package debug
+
+import (
+	"context"
+
+	"github.com/qsfera/server/pkg/log"
+	"github.com/qsfera/server/services/ocs/pkg/config"
+)
+
+// Option defines a single option function.
+type Option func(o *Options)
+
+// Options defines the available options for this package.
+type Options struct {
+	Logger  log.Logger
+	Context context.Context
+	Config  *config.Config
+}
+
+// newOptions initializes the available default options.
+func newOptions(opts ...Option) Options {
+	opt := Options{}
+
+	for _, o := range opts {
+		o(&opt)
+	}
+
+	return opt
+}
+
+// Logger provides a function to set the logger option.
+func Logger(val log.Logger) Option {
+	return func(o *Options) {
+		o.Logger = val
+	}
+}
+
+// Context provides a function to set the context option.
+func Context(val context.Context) Option {
+	return func(o *Options) {
+		o.Context = val
+	}
+}
+
+// Config provides a function to set the config option.
+func Config(val *config.Config) Option {
+	return func(o *Options) {
+		o.Config = val
+	}
+}

Server/services/ocs/pkg/server/debug/server.go

@@ -0,0 +1,44 @@
+package debug
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/qsfera/server/pkg/checks"
+	"github.com/qsfera/server/pkg/handlers"
+	"github.com/qsfera/server/pkg/service/debug"
+	"github.com/qsfera/server/pkg/version"
+)
+
+// Server initializes the debug service and server.
+func Server(opts ...Option) (*http.Server, error) {
+	options := newOptions(opts...)
+
+	healthHandlerConfiguration := handlers.NewCheckHandlerConfiguration().
+		WithLogger(options.Logger).
+		WithCheck("web reachability", checks.NewHTTPCheck(options.Config.HTTP.Addr))
+
+	readyHandlerConfiguration := healthHandlerConfiguration.
+		WithCheck("nats reachability", func(ctx context.Context) error {
+			if len(options.Config.SigningKeys.Nodes) > 0 {
+				return checks.NewNatsCheck(options.Config.SigningKeys.Nodes[0])(ctx)
+			}
+			return nil
+		})
+
+	return debug.NewService(
+		debug.Logger(options.Logger),
+		debug.Name(options.Config.Service.Name),
+		debug.Version(version.GetString()),
+		debug.Address(options.Config.Debug.Addr),
+		debug.Token(options.Config.Debug.Token),
+		debug.Pprof(options.Config.Debug.Pprof),
+		debug.Zpages(options.Config.Debug.Zpages),
+		debug.Health(handlers.NewCheckHandler(healthHandlerConfiguration)),
+		debug.Ready(handlers.NewCheckHandler(readyHandlerConfiguration)),
+		debug.CorsAllowedOrigins(options.Config.HTTP.CORS.AllowedOrigins),
+		debug.CorsAllowedMethods(options.Config.HTTP.CORS.AllowedMethods),
+		debug.CorsAllowedHeaders(options.Config.HTTP.CORS.AllowedHeaders),
+		debug.CorsAllowCredentials(options.Config.HTTP.CORS.AllowCredentials),
+	), nil
+}

Server/services/ocs/pkg/server/http/option.go

@@ -0,0 +1,86 @@
+package http
+
+import (
+	"context"
+
+	"github.com/qsfera/server/pkg/log"
+	"github.com/qsfera/server/services/ocs/pkg/config"
+	"github.com/qsfera/server/services/ocs/pkg/metrics"
+
+	"github.com/spf13/pflag"
+	"go.opentelemetry.io/otel/trace"
+)
+
+// Option defines a single option function.
+type Option func(o *Options)
+
+// Options defines the available options for this package.
+type Options struct {
+	Namespace     string
+	Logger        log.Logger
+	Context       context.Context
+	Config        *config.Config
+	Metrics       *metrics.Metrics
+	Flags         []pflag.Flag
+	TraceProvider trace.TracerProvider
+}
+
+// newOptions initializes the available default options.
+func newOptions(opts ...Option) Options {
+	opt := Options{}
+
+	for _, o := range opts {
+		o(&opt)
+	}
+
+	return opt
+}
+
+// Logger provides a function to set the logger option.
+func Logger(val log.Logger) Option {
+	return func(o *Options) {
+		o.Logger = val
+	}
+}
+
+// Context provides a function to set the context option.
+func Context(val context.Context) Option {
+	return func(o *Options) {
+		o.Context = val
+	}
+}
+
+// Config provides a function to set the config option.
+func Config(val *config.Config) Option {
+	return func(o *Options) {
+		o.Config = val
+	}
+}
+
+// Metrics provides a function to set the metrics option.
+func Metrics(val *metrics.Metrics) Option {
+	return func(o *Options) {
+		o.Metrics = val
+	}
+}
+
+// Flags provides a function to set the flags option.
+func Flags(flags ...pflag.Flag) Option {
+	return func(o *Options) {
+		o.Flags = append(o.Flags, flags...)
+	}
+}
+
+// Namespace provides a function to set the Namespace option.
+func Namespace(val string) Option {
+	return func(o *Options) {
+		o.Namespace = val
+	}
+}
+
+// TraceProvider provides a function to set the TraceProvider option.
+func TraceProvider(tp trace.TracerProvider) Option {
+	return func(o *Options) {
+		o.TraceProvider = tp
+	}
+}

Server/services/ocs/pkg/server/http/server.go

@@ -0,0 +1,79 @@
+package http
+
+import (
+	"fmt"
+
+	chimiddleware "github.com/go-chi/chi/v5/middleware"
+	"github.com/qsfera/server/pkg/cors"
+	"github.com/qsfera/server/pkg/middleware"
+	"github.com/qsfera/server/pkg/service/http"
+	"github.com/qsfera/server/pkg/version"
+	svc "github.com/qsfera/server/services/ocs/pkg/service/v0"
+	"github.com/opencloud-eu/reva/v2/pkg/store"
+	"go-micro.dev/v4"
+	microstore "go-micro.dev/v4/store"
+	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
+)
+
+// Server initializes the http service and server.
+func Server(opts ...Option) (http.Service, error) {
+	options := newOptions(opts...)
+
+	service, err := http.NewService(
+		http.TLSConfig(options.Config.HTTP.TLS),
+		http.Logger(options.Logger),
+		http.Name(options.Config.Service.Name),
+		http.Version(version.GetString()),
+		http.Namespace(options.Config.HTTP.Namespace),
+		http.Address(options.Config.HTTP.Addr),
+		http.Context(options.Context),
+		http.Flags(options.Flags...),
+		http.TraceProvider(options.TraceProvider),
+	)
+	if err != nil {
+		options.Logger.Error().
+			Err(err).
+			Msg("Error initializing http service")
+		return http.Service{}, fmt.Errorf("could not initialize http service: %w", err)
+	}
+
+	signingKeyStore := store.Create(
+		store.Store(options.Config.SigningKeys.Store),
+		store.TTL(options.Config.SigningKeys.TTL),
+		microstore.Nodes(options.Config.SigningKeys.Nodes...),
+		microstore.Database("proxy"),
+		microstore.Table("signing-keys"),
+		store.Authentication(options.Config.SigningKeys.AuthUsername, options.Config.SigningKeys.AuthPassword),
+	)
+
+	handle := svc.NewService(
+		svc.Logger(options.Logger),
+		svc.Config(options.Config),
+		svc.Middleware(
+			chimiddleware.RealIP,
+			chimiddleware.RequestID,
+			middleware.NoCache,
+			middleware.Cors(
+				cors.Logger(options.Logger),
+				cors.AllowedOrigins(options.Config.HTTP.CORS.AllowedOrigins),
+				cors.AllowedMethods(options.Config.HTTP.CORS.AllowedMethods),
+				cors.AllowedHeaders(options.Config.HTTP.CORS.AllowedHeaders),
+				cors.AllowCredentials(options.Config.HTTP.CORS.AllowCredentials),
+			),
+			middleware.Version(
+				options.Config.Service.Name,
+				version.GetString(),
+			),
+			middleware.Logger(options.Logger),
+			middleware.TraceContext,
+			otelhttp.NewMiddleware(options.Config.Service.Name, otelhttp.WithTracerProvider(options.TraceProvider)),
+		),
+		svc.Store(signingKeyStore),
+	)
+
+	if err := micro.RegisterHandler(service.Server(), handle); err != nil {
+		return http.Service{}, err
+	}
+
+	return service, nil
+}

Server/services/ocs/pkg/service/v0/data/meta.go

@@ -0,0 +1,43 @@
+package data
+
+// Meta holds response metadata
+type Meta struct {
+	Status       string `json:"status" xml:"status"`
+	StatusCode   int    `json:"statuscode" xml:"statuscode"`
+	Message      string `json:"message" xml:"message"`
+	TotalItems   string `json:"totalitems,omitempty" xml:"totalitems,omitempty"`
+	ItemsPerPage string `json:"itemsperpage,omitempty" xml:"itemsperpage,omitempty"`
+}
+
+// MetaOK is the default ok response with code 100
+var MetaOK = Meta{Status: "ok", StatusCode: 100, Message: "OK"}
+
+// MetaFailure is a failure response with code 101
+var MetaFailure = Meta{Status: "", StatusCode: 101, Message: "Failure"}
+
+// MetaInvalidInput is an error response with code 102
+var MetaInvalidInput = Meta{Status: "", StatusCode: 102, Message: "Invalid Input"}
+
+// MetaForbidden is an error response with code 104
+var MetaForbidden = Meta{Status: "", StatusCode: 104, Message: "Forbidden"}
+
+// MetaBadRequest is used for unknown errors
+var MetaBadRequest = Meta{Status: "error", StatusCode: 400, Message: "Bad Request"}
+
+// MetaServerError is returned on server errors
+var MetaServerError = Meta{Status: "error", StatusCode: 996, Message: "Server Error"}
+
+// MetaUnauthorized is returned on unauthorized requests
+var MetaUnauthorized = Meta{Status: "error", StatusCode: 997, Message: "Unauthorised"}
+
+// MetaNotFound is returned when trying to access not existing resources
+var MetaNotFound = Meta{Status: "error", StatusCode: 998, Message: "Not Found"}
+
+// MetaUnknownError is used for unknown errors
+var MetaUnknownError = Meta{Status: "error", StatusCode: 999, Message: "Unknown Error"}
+
+// MessageUserNotFound is  used when a user can not be found
+var MessageUserNotFound = "The requested user could not be found"
+
+// MessageGroupNotFound is used when a group can not be found
+var MessageGroupNotFound = "The requested group could not be found"

Server/services/ocs/pkg/service/v0/data/user.go

@@ -0,0 +1,7 @@
+package data
+
+// SigningKey holds the Payload for a GetSigningKey response
+type SigningKey struct {
+	User       string `json:"user" xml:"user"`
+	SigningKey string `json:"signing-key" xml:"signing-key"`
+}

Server/services/ocs/pkg/service/v0/instrument.go

@@ -0,0 +1,25 @@
+package svc
+
+import (
+	"net/http"
+
+	"github.com/qsfera/server/services/ocs/pkg/metrics"
+)
+
+// NewInstrument returns a service that instruments metrics.
+func NewInstrument(next Service, metrics *metrics.Metrics) Service {
+	return instrument{
+		next:    next,
+		metrics: metrics,
+	}
+}
+
+type instrument struct {
+	next    Service
+	metrics *metrics.Metrics
+}
+
+// ServeHTTP implements the Service interface.
+func (i instrument) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	i.next.ServeHTTP(w, r)
+}

Server/services/ocs/pkg/service/v0/logging.go

@@ -0,0 +1,25 @@
+package svc
+
+import (
+	"net/http"
+
+	"github.com/qsfera/server/pkg/log"
+)
+
+// NewLogging returns a service that logs messages.
+func NewLogging(next Service, logger log.Logger) Service {
+	return logging{
+		next:   next,
+		logger: logger,
+	}
+}
+
+type logging struct {
+	next   Service
+	logger log.Logger
+}
+
+// ServeHTTP implements the Service interface.
+func (l logging) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	l.next.ServeHTTP(w, r)
+}

Server/services/ocs/pkg/service/v0/option.go

@@ -0,0 +1,59 @@
+package svc
+
+import (
+	"net/http"
+
+	"github.com/qsfera/server/pkg/log"
+	"github.com/qsfera/server/services/ocs/pkg/config"
+	"go-micro.dev/v4/store"
+)
+
+// Option defines a single option function.
+type Option func(o *Options)
+
+// Options defines the available options for this package.
+type Options struct {
+	Logger     log.Logger
+	Config     *config.Config
+	Middleware []func(http.Handler) http.Handler
+	Store      store.Store
+}
+
+// newOptions initializes the available default options.
+func newOptions(opts ...Option) Options {
+	opt := Options{}
+
+	for _, o := range opts {
+		o(&opt)
+	}
+
+	return opt
+}
+
+// Logger provides a function to set the logger option.
+func Logger(val log.Logger) Option {
+	return func(o *Options) {
+		o.Logger = val
+	}
+}
+
+// Config provides a function to set the config option.
+func Config(val *config.Config) Option {
+	return func(o *Options) {
+		o.Config = val
+	}
+}
+
+// Middleware provides a function to set the middleware option.
+func Middleware(val ...func(http.Handler) http.Handler) Option {
+	return func(o *Options) {
+		o.Middleware = val
+	}
+}
+
+// Store provides a function to set the store option.
+func Store(s store.Store) Option {
+	return func(o *Options) {
+		o.Store = s
+	}
+}

Server/services/ocs/pkg/service/v0/response/response.go

@@ -0,0 +1,114 @@
+package response
+
+import (
+	"encoding/xml"
+	"net/http"
+	"reflect"
+
+	"github.com/go-chi/render"
+	"github.com/qsfera/server/services/ocs/pkg/service/v0/data"
+)
+
+// Response is the top level response structure
+type Response struct {
+	OCS *Payload `json:"ocs" xml:"ocs"`
+}
+
+var (
+	elementStartElement = xml.StartElement{Name: xml.Name{Local: "element"}}
+	metaStartElement    = xml.StartElement{Name: xml.Name{Local: "meta"}}
+	ocsName             = xml.Name{Local: "ocs"}
+	dataName            = xml.Name{Local: "data"}
+)
+
+// Payload combines response metadata and data
+type Payload struct {
+	Meta data.Meta `json:"meta" xml:"meta"`
+	Data any       `json:"data,omitempty" xml:"data,omitempty"`
+}
+
+// MarshalXML handles ocs specific wrapping of array members in 'element' tags for the data
+func (rsp Response) MarshalXML(e *xml.Encoder, start xml.StartElement) (err error) {
+	// first the easy part
+	// use ocs as the surrounding tag
+	start.Name = ocsName
+	if err = e.EncodeToken(start); err != nil {
+		return
+	}
+
+	// encode the meta tag
+	if err = e.EncodeElement(rsp.OCS.Meta, metaStartElement); err != nil {
+		return
+	}
+
+	// we need to use reflection to determine if p.Data is an array or a slice
+	rt := reflect.TypeOf(rsp.OCS.Data)
+	if rt != nil && (rt.Kind() == reflect.Array || rt.Kind() == reflect.Slice) {
+		// this is how to wrap the data elements in their own <element> tag
+		v := reflect.ValueOf(rsp.OCS.Data)
+		if err = e.EncodeToken(xml.StartElement{Name: dataName}); err != nil {
+			return
+		}
+		for i := 0; i < v.Len(); i++ {
+			if err = e.EncodeElement(v.Index(i).Interface(), elementStartElement); err != nil {
+				return
+			}
+		}
+		if err = e.EncodeToken(xml.EndElement{Name: dataName}); err != nil {
+			return
+		}
+	} else if err = e.EncodeElement(rsp.OCS.Data, xml.StartElement{Name: dataName}); err != nil {
+		return
+	}
+
+	// write the closing <ocs> tag
+	if err = e.EncodeToken(xml.EndElement{Name: start.Name}); err != nil {
+		return
+	}
+	return
+}
+
+// Render sets the status code of the http response, taking the ocs version into account
+func (rsp *Response) Render(w http.ResponseWriter, r *http.Request) error {
+	version := APIVersion(r.Context())
+	m := statusCodeMapper(version)
+	statusCode := m(rsp.OCS.Meta)
+	render.Status(r, statusCode)
+	if version == ocsVersion2 && statusCode == http.StatusOK {
+		rsp.OCS.Meta.StatusCode = statusCode
+	}
+	return nil
+}
+
+// DataRender creates an OK Payload for the given data
+func DataRender(d any) render.Renderer {
+	return &Response{
+		&Payload{
+			Meta: data.MetaOK,
+			Data: d,
+		},
+	}
+}
+
+// ErrRender creates an Error Payload with the given OCS error code and message
+// The httpcode will be determined using the API version stored in the context
+func ErrRender(c int, m string) render.Renderer {
+	return &Response{
+		&Payload{
+			Meta: data.Meta{Status: "error", StatusCode: c, Message: m},
+		},
+	}
+}
+
+func statusCodeMapper(version string) func(data.Meta) int {
+	var mapper func(data.Meta) int
+	switch version {
+	case ocsVersion1:
+		mapper = OcsV1StatusCodes
+	case ocsVersion2:
+		mapper = OcsV2StatusCodes
+	default:
+		mapper = defaultStatusCodeMapper
+	}
+	return mapper
+}

Server/services/ocs/pkg/service/v0/response/version.go

@@ -0,0 +1,92 @@
+package response
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/render"
+	"github.com/qsfera/server/services/ocs/pkg/service/v0/data"
+)
+
+type key int
+
+const (
+	apiVersionKey key = iota
+	ocsVersion1       = "1"
+	ocsVersion2       = "2"
+)
+
+var (
+	defaultStatusCodeMapper = OcsV2StatusCodes
+)
+
+// APIVersion retrieves the api version from the context.
+func APIVersion(ctx context.Context) string {
+	value := ctx.Value(apiVersionKey)
+	if value != nil {
+		return value.(string)
+	}
+	return ""
+}
+
+// OcsV1StatusCodes returns the http status codes for the OCS API v1.
+func OcsV1StatusCodes(meta data.Meta) int {
+	if meta.StatusCode == data.MetaUnauthorized.StatusCode {
+		return http.StatusUnauthorized
+	}
+	return http.StatusOK
+}
+
+// OcsV2StatusCodes maps the OCS codes to http status codes for the ocs API v2.
+// see https://github.com/owncloud/core/blob/c08baf580927ecb8ec179028dda255fdd85b4568/lib/private/legacy/api.php#L528
+// also HTTP status codes for apps are the same as OCS codes
+// see https://github.com/owncloud/core/blob/b9ff4c93e051c94adfb301545098ae627e52ef76/lib/public/AppFramework/OCSController.php#L142-L150
+// I think this is a bug in the ocs v2 api, but since we are going to mimic bugs in КуСфера ... here goes
+func OcsV2StatusCodes(meta data.Meta) int {
+	sc := meta.StatusCode
+	switch sc {
+	case data.MetaNotFound.StatusCode:
+		return http.StatusNotFound
+	case data.MetaUnknownError.StatusCode:
+		fallthrough
+	case data.MetaServerError.StatusCode:
+		return http.StatusInternalServerError
+	case data.MetaUnauthorized.StatusCode:
+		return http.StatusUnauthorized
+	case data.MetaOK.StatusCode:
+		// TODO mustn't data.Meta be a pointer so this assignment has an effect
+		meta.StatusCode = http.StatusOK
+		return http.StatusOK
+	}
+	// any 2xx, 4xx and 5xx will be used as is
+	if sc >= 200 && sc < 600 {
+		return sc
+	}
+
+	// any error codes > 100 are treated as client errors
+	if sc > 100 && sc < 200 {
+		return http.StatusBadRequest
+	}
+
+	// TODO change this status code? yes, align with oc10 core mapStatusCodes
+	return http.StatusOK
+}
+
+// VersionCtx middleware is used to determine the response mapper from
+// the URL parameters passed through as the request. In case
+// the Version is unknown, we stop here and return a 404.
+func VersionCtx(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		version := chi.URLParam(r, "version")
+		if version == "" {
+			_ = render.Render(w, r, ErrRender(data.MetaBadRequest.StatusCode, "unknown ocs api version"))
+			return
+		}
+		w.Header().Set("Ocs-Api-Version", version)
+
+		// store version in context so handlers can access it
+		ctx := context.WithValue(r.Context(), apiVersionKey, version)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}

Server/services/ocs/pkg/service/v0/service.go

@@ -0,0 +1,83 @@
+package svc
+
+import (
+	"net/http"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+	"github.com/go-chi/render"
+
+	"github.com/qsfera/server/pkg/account"
+	"github.com/qsfera/server/pkg/log"
+	opkgm "github.com/qsfera/server/pkg/middleware"
+	"github.com/qsfera/server/services/ocs/pkg/config"
+	ocsm "github.com/qsfera/server/services/ocs/pkg/middleware"
+	"github.com/qsfera/server/services/ocs/pkg/service/v0/data"
+	"github.com/qsfera/server/services/ocs/pkg/service/v0/response"
+	microstore "go-micro.dev/v4/store"
+)
+
+// Service defines the service handlers.
+type Service interface {
+	ServeHTTP(http.ResponseWriter, *http.Request)
+}
+
+// NewService returns a service implementation for Service.
+func NewService(opts ...Option) Service {
+	options := newOptions(opts...)
+
+	m := chi.NewMux()
+	m.Use(options.Middleware...)
+
+	svc := Ocs{
+		config: options.Config,
+		mux:    m,
+		logger: options.Logger,
+		store:  options.Store,
+	}
+
+	m.Route(options.Config.HTTP.Root, func(r chi.Router) {
+		r.NotFound(svc.NotFound)
+		r.Use(middleware.StripSlashes)
+		r.Use(opkgm.ExtractAccountUUID(
+			account.Logger(options.Logger),
+			account.JWTSecret(options.Config.TokenManager.JWTSecret)),
+		)
+		r.Use(ocsm.OCSFormatCtx) // updates request Accept header according to format=(json|xml) query parameter
+		r.Route("/v{version:(1|2)}.php", func(r chi.Router) {
+			r.Use(response.VersionCtx) // stores version in context
+			r.Get("/cloud/user/signing-key", svc.GetSigningKey)
+		})
+	})
+
+	_ = chi.Walk(m, func(method string, route string, handler http.Handler, middlewares ...func(http.Handler) http.Handler) error {
+		options.Logger.Debug().Str("method", method).Str("route", route).Int("middlewares", len(middlewares)).Msg("serving endpoint")
+		return nil
+	})
+
+	return svc
+}
+
+// Ocs defines implements the business logic for Service.
+type Ocs struct {
+	config *config.Config
+	logger log.Logger
+	mux    *chi.Mux
+	store  microstore.Store
+}
+
+// ServeHTTP implements the Service interface.
+func (o Ocs) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	o.mux.ServeHTTP(w, r)
+}
+
+// NotFound uses ErrRender to always return a proper OCS payload
+func (o Ocs) NotFound(w http.ResponseWriter, r *http.Request) {
+	o.mustRender(w, r, response.ErrRender(data.MetaNotFound.StatusCode, "not found"))
+}
+
+func (o Ocs) mustRender(w http.ResponseWriter, r *http.Request, renderer render.Renderer) {
+	if err := render.Render(w, r, renderer); err != nil {
+		o.logger.Err(err).Msgf("failed to write response for ocs request %s on %s", r.Method, r.URL)
+	}
+}

Server/services/ocs/pkg/service/v0/tracing.go

@@ -0,0 +1,23 @@
+package svc
+
+import (
+	"net/http"
+
+	"github.com/qsfera/server/pkg/middleware"
+)
+
+// NewTracing returns a service that instruments traces.
+func NewTracing(next Service) Service {
+	return tracing{
+		next: next,
+	}
+}
+
+type tracing struct {
+	next Service
+}
+
+// ServeHTTP implements the Service interface.
+func (t tracing) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	middleware.TraceContext(t.next).ServeHTTP(w, r)
+}

Server/services/ocs/pkg/service/v0/users.go

@@ -0,0 +1,66 @@
+package svc
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"net/http"
+
+	"github.com/qsfera/server/services/ocs/pkg/service/v0/data"
+	"github.com/qsfera/server/services/ocs/pkg/service/v0/response"
+	revactx "github.com/opencloud-eu/reva/v2/pkg/ctx"
+	"go-micro.dev/v4/store"
+)
+
+// GetSigningKey returns the signing key for the current user. It will create it on the fly if it does not exist
+// The signing key is part of the user settings and is used by the proxy to authenticate requests
+// Currently, the username is used as the OC-Credential
+func (o Ocs) GetSigningKey(w http.ResponseWriter, r *http.Request) {
+	u, ok := revactx.ContextGetUser(r.Context())
+	if !ok {
+		//o.logger.Error().Msg("missing user in context")
+		o.mustRender(w, r, response.ErrRender(data.MetaBadRequest.StatusCode, "missing user in context"))
+		return
+	}
+
+	// use the user's UUID
+	userID := u.Id.OpaqueId
+
+	res, err := o.store.Read(userID)
+	if err == nil && len(res) > 0 {
+		o.mustRender(w, r, response.DataRender(&data.SigningKey{
+			User:       userID,
+			SigningKey: string(res[0].Value),
+		}))
+		return
+	}
+	if err != nil {
+		if errors.Is(err, store.ErrNotFound) {
+			// not found is ok, so we can continue and generate the key on the fly
+		} else {
+			o.logger.Error().Err(err).Msg("error reading from server")
+			o.mustRender(w, r, response.ErrRender(data.MetaServerError.StatusCode, "error reading from store"))
+			return
+		}
+	}
+
+	// try creating it
+	key := make([]byte, 64)
+	_, err = rand.Read(key[:])
+	if err != nil {
+		o.mustRender(w, r, response.ErrRender(data.MetaServerError.StatusCode, "could not generate signing key"))
+		return
+	}
+	signingKey := hex.EncodeToString(key)
+
+	err = o.store.Write(&store.Record{Key: userID, Value: []byte(signingKey)})
+	if err != nil {
+		o.mustRender(w, r, response.ErrRender(data.MetaServerError.StatusCode, "could not persist signing key"))
+		return
+	}
+
+	o.mustRender(w, r, response.DataRender(&data.SigningKey{
+		User:       userID,
+		SigningKey: signingKey,
+	}))
+}