Merge branch 'master' into config-doc-descriptions

services/thumbnails/pkg/command/health.go

@@ -0,0 +1,57 @@
+package command
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config/parser"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/logging"
+	"github.com/urfave/cli/v2"
+)
+
+// Health is the entrypoint for the health command.
+func Health(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:     "health",
+		Usage:    "check health status",
+		Category: "info",
+		Before: func(c *cli.Context) error {
+			err := parser.ParseConfig(cfg)
+			if err != nil {
+				fmt.Printf("%v", err)
+			}
+			return err
+		},
+		Action: func(c *cli.Context) error {
+			logger := logging.Configure(cfg.Service.Name, cfg.Log)
+
+			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
+		},
+	}
+}

services/thumbnails/pkg/command/root.go

@@ -0,0 +1,64 @@
+package command
+
+import (
+	"context"
+	"os"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/clihelper"
+	ociscfg "github.com/owncloud/ocis/v2/ocis-pkg/config"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+	"github.com/thejerf/suture/v4"
+	"github.com/urfave/cli/v2"
+)
+
+// GetCommands provides all commands for this service
+func GetCommands(cfg *config.Config) cli.Commands {
+	return []*cli.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 ocis-thumbnails command.
+func Execute(cfg *config.Config) error {
+	app := clihelper.DefaultApp(&cli.App{
+		Name:     "thumbnails",
+		Usage:    "Example usage",
+		Commands: GetCommands(cfg),
+	})
+
+	cli.HelpFlag = &cli.BoolFlag{
+		Name:  "help,h",
+		Usage: "Show the help",
+	}
+
+	return app.Run(os.Args)
+}
+
+// SutureService allows for the thumbnails command to be embedded and supervised by a suture supervisor tree.
+type SutureService struct {
+	cfg *config.Config
+}
+
+// NewSutureService creates a new thumbnails.SutureService
+func NewSutureService(cfg *ociscfg.Config) suture.Service {
+	cfg.Thumbnails.Commons = cfg.Commons
+	return SutureService{
+		cfg: cfg.Thumbnails,
+	}
+}
+
+func (s SutureService) Serve(ctx context.Context) error {
+	s.cfg.Context = ctx
+	if err := Execute(s.cfg); err != nil {
+		return err
+	}
+
+	return nil
+}

services/thumbnails/pkg/command/server.go

@@ -0,0 +1,112 @@
+package command
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/oklog/run"
+	"github.com/owncloud/ocis/v2/ocis-pkg/version"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config/parser"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/logging"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/metrics"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/server/debug"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/server/grpc"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/server/http"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/tracing"
+	"github.com/urfave/cli/v2"
+)
+
+// Server is the entrypoint for the server command.
+func Server(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:     "server",
+		Usage:    fmt.Sprintf("start %s extension without runtime (unsupervised mode)", cfg.Service.Name),
+		Category: "server",
+		Before: func(c *cli.Context) error {
+			err := parser.ParseConfig(cfg)
+			if err != nil {
+				fmt.Printf("%v", err)
+				os.Exit(1)
+			}
+			return err
+		},
+		Action: func(c *cli.Context) error {
+			logger := logging.Configure(cfg.Service.Name, cfg.Log)
+			err := tracing.Configure(cfg)
+			if err != nil {
+				return err
+			}
+
+			var (
+				gr          = run.Group{}
+				ctx, cancel = func() (context.Context, context.CancelFunc) {
+					if cfg.Context == nil {
+						return context.WithCancel(context.Background())
+					}
+					return context.WithCancel(cfg.Context)
+				}()
+				metrics = metrics.New()
+			)
+
+			defer cancel()
+
+			metrics.BuildInfo.WithLabelValues(version.GetString()).Set(1)
+
+			service := grpc.NewService(
+				grpc.Logger(logger),
+				grpc.Context(ctx),
+				grpc.Config(cfg),
+				grpc.Name(cfg.Service.Name),
+				grpc.Namespace(cfg.GRPC.Namespace),
+				grpc.Address(cfg.GRPC.Addr),
+				grpc.Metrics(metrics),
+			)
+
+			gr.Add(service.Run, func(_ error) {
+				fmt.Println("shutting down grpc server")
+				cancel()
+			})
+
+			server, err := debug.Server(
+				debug.Logger(logger),
+				debug.Config(cfg),
+			)
+
+			if err != nil {
+				logger.Info().Err(err).Str("transport", "debug").Msg("Failed to initialize server")
+				return err
+			}
+
+			gr.Add(server.ListenAndServe, func(_ error) {
+				_ = server.Shutdown(ctx)
+				cancel()
+			})
+
+			httpServer, err := http.Server(
+				http.Logger(logger),
+				http.Context(ctx),
+				http.Config(cfg),
+				http.Metrics(metrics),
+				http.Namespace(cfg.HTTP.Namespace),
+			)
+
+			if err != nil {
+				logger.Info().
+					Err(err).
+					Str("transport", "http").
+					Msg("Failed to initialize server")
+
+				return err
+			}
+
+			gr.Add(httpServer.Run, func(_ error) {
+				logger.Info().Str("server", "http").Msg("shutting down server")
+				cancel()
+			})
+
+			return gr.Run()
+		},
+	}
+}

services/thumbnails/pkg/command/version.go

@@ -0,0 +1,50 @@
+package command
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/registry"
+	"github.com/owncloud/ocis/v2/ocis-pkg/version"
+
+	tw "github.com/olekukonko/tablewriter"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+	"github.com/urfave/cli/v2"
+)
+
+// Version prints the service versions of all running instances.
+func Version(cfg *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:     "version",
+		Usage:    "print the version of this binary and the running extension instances",
+		Category: "info",
+		Action: func(c *cli.Context) error {
+			fmt.Println("Version: " + version.GetString())
+			fmt.Printf("Compiled: %s\n", version.Compiled())
+			fmt.Println("")
+
+			reg := registry.GetRegistry()
+			services, err := reg.GetService(cfg.GRPC.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 := tw.NewWriter(os.Stdout)
+			table.SetHeader([]string{"Version", "Address", "Id"})
+			table.SetAutoFormatHeaders(false)
+			for _, s := range services {
+				for _, n := range s.Nodes {
+					table.Append([]string{s.Version, n.Address, n.Id})
+				}
+			}
+			table.Render()
+			return nil
+		},
+	}
+}

services/thumbnails/pkg/config/config.go

@@ -0,0 +1,42 @@
+package config
+
+import (
+	"context"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/shared"
+)
+
+// 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:"-"`
+
+	Tracing *Tracing `yaml:"tracing"`
+	Log     *Log     `yaml:"log"`
+	Debug   Debug    `yaml:"debug"`
+
+	GRPC GRPC `yaml:"grpc"`
+	HTTP HTTP `yaml:"http"`
+
+	Thumbnail Thumbnail `yaml:"thumbnail"`
+
+	Context context.Context `yaml:"-"`
+}
+
+// FileSystemStorage defines the available filesystem storage configuration.
+type FileSystemStorage struct {
+	RootDirectory string `yaml:"root_directory" env:"THUMBNAILS_FILESYSTEMSTORAGE_ROOT" desc:"The directory where the filesystem storage will store the thumbnails."`
+}
+
+// Thumbnail defines the available thumbnail related configuration.
+type Thumbnail struct {
+	Resolutions         []string          `yaml:"resolutions" env:"THUMBNAILS_RESOLUTIONS" desc:"The supported target resolutions in the format WidthxHeight e.g. 32x32. You can provide multiple resolutions seperated by a comma."`
+	FileSystemStorage   FileSystemStorage `yaml:"filesystem_storage"`
+	WebdavAllowInsecure bool              `yaml:"webdav_allow_insecure" env:"OCIS_INSECURE;THUMBNAILS_WEBDAVSOURCE_INSECURE" desc:"Ignore untrusted SSL certificates when connecting to the webdav source."`
+	CS3AllowInsecure    bool              `yaml:"cs3_allow_insecure" env:"OCIS_INSECURE;THUMBNAILS_CS3SOURCE_INSECURE" desc:"Ignore untrusted SSL certificates when connecting to the CS3 source."`
+	RevaGateway         string            `yaml:"reva_gateway" env:"REVA_GATEWAY" desc:"The CS3 gateway endpoint."` //TODO: use REVA config
+	FontMapFile         string            `yaml:"font_map_file" env:"THUMBNAILS_TXT_FONTMAP_FILE" desc:"The path to a font file for txt thumbnails."`
+	TransferSecret      string            `yaml:"transfer_secret" env:"THUMBNAILS_TRANSFER_TOKEN" desc:"The secret to sign JWT to download the actual thumbnail file."`
+	DataEndpoint        string            `yaml:"data_endpoint" env:"THUMBNAILS_DATA_ENDPOINT" desc:"The HTTP endpoint where the actual thumbnail file can be downloaded."`
+}

services/thumbnails/pkg/config/debug.go

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

services/thumbnails/pkg/config/defaults/defaultconfig.go

@@ -0,0 +1,81 @@
+package defaults
+
+import (
+	"path"
+	"strings"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/config/defaults"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+)
+
+func FullDefaultConfig() *config.Config {
+	cfg := DefaultConfig()
+	EnsureDefaults(cfg)
+	Sanitize(cfg)
+	return cfg
+}
+
+func DefaultConfig() *config.Config {
+	return &config.Config{
+		Debug: config.Debug{
+			Addr:   "127.0.0.1:9189",
+			Token:  "",
+			Pprof:  false,
+			Zpages: false,
+		},
+		GRPC: config.GRPC{
+			Addr:      "127.0.0.1:9185",
+			Namespace: "com.owncloud.api",
+		},
+		HTTP: config.HTTP{
+			Addr:      "127.0.0.1:9186",
+			Root:      "/thumbnails",
+			Namespace: "com.owncloud.web",
+		},
+		Service: config.Service{
+			Name: "thumbnails",
+		},
+		Thumbnail: config.Thumbnail{
+			Resolutions: []string{"16x16", "32x32", "64x64", "128x128", "1920x1080", "3840x2160", "7680x4320"},
+			FileSystemStorage: config.FileSystemStorage{
+				RootDirectory: path.Join(defaults.BaseDataPath(), "thumbnails"),
+			},
+			WebdavAllowInsecure: false,
+			RevaGateway:         "127.0.0.1:9142",
+			CS3AllowInsecure:    false,
+			DataEndpoint:        "http://127.0.0.1:9186/thumbnails/data",
+		},
+	}
+}
+
+func EnsureDefaults(cfg *config.Config) {
+	// provide with defaults for shared logging, since we need a valid destination address for BindEnv.
+	if cfg.Log == nil && cfg.Commons != nil && cfg.Commons.Log != nil {
+		cfg.Log = &config.Log{
+			Level:  cfg.Commons.Log.Level,
+			Pretty: cfg.Commons.Log.Pretty,
+			Color:  cfg.Commons.Log.Color,
+			File:   cfg.Commons.Log.File,
+		}
+	} else if cfg.Log == nil {
+		cfg.Log = &config.Log{}
+	}
+	// provide with defaults for shared tracing, since we need a valid destination address for BindEnv.
+	if cfg.Tracing == nil && cfg.Commons != nil && cfg.Commons.Tracing != nil {
+		cfg.Tracing = &config.Tracing{
+			Enabled:   cfg.Commons.Tracing.Enabled,
+			Type:      cfg.Commons.Tracing.Type,
+			Endpoint:  cfg.Commons.Tracing.Endpoint,
+			Collector: cfg.Commons.Tracing.Collector,
+		}
+	} else if cfg.Tracing == nil {
+		cfg.Tracing = &config.Tracing{}
+	}
+}
+
+func Sanitize(cfg *config.Config) {
+	// nothing to sanitize here atm
+	if len(cfg.Thumbnail.Resolutions) == 1 && strings.Contains(cfg.Thumbnail.Resolutions[0], ",") {
+		cfg.Thumbnail.Resolutions = strings.Split(cfg.Thumbnail.Resolutions[0], ",")
+	}
+}

services/thumbnails/pkg/config/grpc.go

@@ -0,0 +1,7 @@
+package config
+
+// GRPC defines the available grpc configuration.
+type GRPC struct {
+	Addr      string `yaml:"addr" env:"THUMBNAILS_GRPC_ADDR" desc:"The address off the grpc service."`
+	Namespace string `yaml:"-"`
+}

services/thumbnails/pkg/config/http.go

@@ -0,0 +1,8 @@
+package config
+
+// HTTP defines the available http configuration.
+type HTTP struct {
+	Addr      string `yaml:"addr" env:"THUMBNAILS_HTTP_ADDR" desc:"The bind address of the HTTP service."`
+	Root      string `yaml:"root" env:"THUMBNAILS_HTTP_ROOT" desc:"The root path of the HTTP service."`
+	Namespace string `yaml:"-"`
+}

services/thumbnails/pkg/config/log.go

@@ -0,0 +1,9 @@
+package config
+
+// Log defines the available log configuration.
+type Log struct {
+	Level  string `mapstructure:"level" env:"OCIS_LOG_LEVEL;THUMBNAILS_LOG_LEVEL" desc:"The log level. Valid values are: \"panic\", \"fatal\", \"error\", \"warn\", \"info\", \"debug\", \"trace\"."`
+	Pretty bool   `mapstructure:"pretty" env:"OCIS_LOG_PRETTY;THUMBNAILS_LOG_PRETTY" desc:"Activates pretty log output."`
+	Color  bool   `mapstructure:"color" env:"OCIS_LOG_COLOR;THUMBNAILS_LOG_COLOR" desc:"Activates colorized log output."`
+	File   string `mapstructure:"file" env:"OCIS_LOG_FILE;THUMBNAILS_LOG_FILE" desc:"The path to the log file. Activates logging to this file if set."`
+}

services/thumbnails/pkg/config/parser/parse.go

@@ -0,0 +1,38 @@
+package parser
+
+import (
+	"errors"
+
+	ociscfg "github.com/owncloud/ocis/v2/ocis-pkg/config"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config/defaults"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/config/envdecode"
+)
+
+// ParseConfig loads configuration from known paths.
+func ParseConfig(cfg *config.Config) error {
+	_, err := ociscfg.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
+		}
+	}
+
+	// sanitize config
+	defaults.Sanitize(cfg)
+
+	return Validate(cfg)
+}
+
+func Validate(cfg *config.Config) error {
+	return nil
+}

services/thumbnails/pkg/config/service.go

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

services/thumbnails/pkg/config/tracing.go

@@ -0,0 +1,9 @@
+package config
+
+// Tracing defines the available tracing configuration.
+type Tracing struct {
+	Enabled   bool   `yaml:"enabled" env:"OCIS_TRACING_ENABLED;THUMBNAILS_TRACING_ENABLED" desc:"Activates tracing."`
+	Type      string `yaml:"type" env:"OCIS_TRACING_TYPE;THUMBNAILS_TRACING_TYPE" desc:"The type of tracing. Defaults to \"\", which is the same as \"jaeger\". Allowed tracing types are \"jaeger\" and \"\" as of now."`
+	Endpoint  string `yaml:"endpoint" env:"OCIS_TRACING_ENDPOINT;THUMBNAILS_TRACING_ENDPOINT" desc:"The endpoint of the tracing agent."`
+	Collector string `yaml:"collector" env:"OCIS_TRACING_COLLECTOR;THUMBNAILS_TRACING_COLLECTOR" desc:"The HTTP endpoint for sending spans directly to a collector, i.e. http://jaeger-collector:14268/api/traces. Only used if the tracing endpoint is unset."`
+}

services/thumbnails/pkg/logging/logging.go

@@ -0,0 +1,17 @@
+package logging
+
+import (
+	"github.com/owncloud/ocis/v2/ocis-pkg/log"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+)
+
+// LoggerFromConfig initializes a service-specific logger instance.
+func Configure(name string, cfg *config.Log) log.Logger {
+	return log.NewLogger(
+		log.Name(name),
+		log.Level(cfg.Level),
+		log.Pretty(cfg.Pretty),
+		log.Color(cfg.Color),
+		log.File(cfg.File),
+	)
+}

services/thumbnails/pkg/metrics/metrics.go

@@ -0,0 +1,67 @@
+package metrics
+
+import "github.com/prometheus/client_golang/prometheus"
+
+var (
+	// Namespace defines the namespace for the defines metrics.
+	Namespace = "ocis"
+
+	// Subsystem defines the subsystem for the defines metrics.
+	Subsystem = "thumbnails"
+)
+
+// Metrics defines the available metrics of this service.
+type Metrics struct {
+	Counter   *prometheus.CounterVec
+	Latency   *prometheus.SummaryVec
+	Duration  *prometheus.HistogramVec
+	BuildInfo *prometheus.GaugeVec
+}
+
+// New initializes the available metrics.
+func New() *Metrics {
+	m := &Metrics{
+		Counter: prometheus.NewCounterVec(prometheus.CounterOpts{
+			Namespace: Namespace,
+			Subsystem: Subsystem,
+			Name:      "getthumbnail_total",
+			Help:      "How many GetThumbnail requests processed",
+		}, []string{}),
+		Latency: prometheus.NewSummaryVec(prometheus.SummaryOpts{
+			Namespace: Namespace,
+			Subsystem: Subsystem,
+			Name:      "getthumbnail_latency_microseconds",
+			Help:      "GetThumbnail request latencies in microseconds",
+		}, []string{}),
+		Duration: prometheus.NewHistogramVec(prometheus.HistogramOpts{
+			Namespace: Namespace,
+			Subsystem: Subsystem,
+			Name:      "getthumbnail_duration_seconds",
+			Help:      "GetThumbnail method requests time in seconds",
+		}, []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.Latency,
+	)
+
+	_ = prometheus.Register(
+		m.Duration,
+	)
+
+	_ = prometheus.Register(
+		m.BuildInfo,
+	)
+
+	return m
+}

services/thumbnails/pkg/preprocessor/fontloader.go

@@ -0,0 +1,188 @@
+package preprocessor
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/sync"
+	"golang.org/x/image/font"
+	"golang.org/x/image/font/gofont/goregular"
+	"golang.org/x/image/font/opentype"
+)
+
+// FontMap maps a script with the target font to be used for that script
+// It also uses a DefaultFont in case there isn't a matching script in the map
+//
+// For cases like Japanese where multiple scripts are used, we rely on the text
+// analyzer to use the script which is unique to japanese (Hiragana or Katakana)
+// even if it has to overwrite the "official" detected script (Han). This means
+// that "Han" should be used just for chinese while "Hiragana" and "Katakana"
+// should be used for japanese
+type FontMap struct {
+	FontMap     map[string]string `json:"fontMap"`
+	DefaultFont string            `json:"defaultFont"`
+}
+
+// It contains the location of the loaded file (in FLoc) and the FontMap loaded
+// from the file
+type FontMapData struct {
+	FMap *FontMap
+	FLoc string
+}
+
+// It contains the location of the font used, and the loaded face (font.Face)
+// ready to be used
+type LoadedFace struct {
+	FontFile string
+	Face     font.Face
+}
+
+// Represents a FontLoader. Use the "NewFontLoader" to get a instance
+type FontLoader struct {
+	faceCache   sync.Cache
+	fontMapData *FontMapData
+	faceOpts    *opentype.FaceOptions
+}
+
+// Create a new FontLoader based on the fontMapFile. The FaceOptions will
+// be the same for all the font loaded by this instance.
+// Note that only the fonts described in the fontMapFile will be used.
+//
+// The fontMapFile has the following structure
+//	{
+//		"fontMap": {
+//			"Han": "packaged/myFont-CJK.otf",
+//			"Arabic": "packaged/myFont-Arab.otf",
+//			"Latin": "/fonts/regular/myFont.otf"
+//		}
+//		"defaultFont": "/fonts/regular/myFont.otf"
+//	}
+//
+// The fontMapFile contains paths to where the fonts are located in the FS.
+// Absolute paths can be used as shown above. If a relative path is used,
+// it will be relative to the fontMapFile location. This should make the
+// packaging easier since all the fonts can be placed in the same directory
+// where the fontMapFile is, or in inner directories.
+func NewFontLoader(fontMapFile string, faceOpts *opentype.FaceOptions) (*FontLoader, error) {
+	fontMap := &FontMap{}
+
+	if fontMapFile != "" {
+		file, err := os.Open(fontMapFile)
+		if err != nil {
+			return nil, err
+		}
+		defer file.Close()
+
+		parser := json.NewDecoder(file)
+		if err = parser.Decode(fontMap); err != nil {
+			return nil, err
+		}
+	}
+
+	return &FontLoader{
+		faceCache: sync.NewCache(5),
+		fontMapData: &FontMapData{
+			FMap: fontMap,
+			FLoc: fontMapFile,
+		},
+		faceOpts: faceOpts,
+	}, nil
+}
+
+// Load and return the font face to be used for that script according to the
+// FontMap set when the FontLoader was created. If the script doesn't have
+// an associated font, a default font will be used. Note that the default font
+// might not be able to handle properly the script
+func (fl *FontLoader) LoadFaceForScript(script string) (*LoadedFace, error) {
+	var parsedFont *opentype.Font
+	var parsingError error
+
+	fontFile := fl.fontMapData.FMap.DefaultFont
+	if val, ok := fl.fontMapData.FMap.FontMap[script]; ok {
+		fontFile = val
+	}
+
+	if fontFile != "" && !filepath.IsAbs(fontFile) {
+		fontFile = filepath.Join(filepath.Dir(fl.fontMapData.FLoc), fontFile)
+	}
+
+	// if the face for the script isn't cached, load the font file and create a new face
+	cachedFace := fl.faceCache.Load(fontFile)
+	if cachedFace != nil {
+		return cachedFace.V.(*LoadedFace), nil
+	}
+
+	if fontFile == "" {
+		parsedFont, parsingError = opentype.Parse(goregular.TTF)
+		if parsingError != nil {
+			return nil, parsingError
+		}
+	} else {
+		// opentype.ParseReaderAt seems to require to keep the file opened
+		// so read the font file into memory
+		data, err := os.ReadFile(fontFile)
+		if err != nil {
+			return nil, err
+		}
+		parsedFont, parsingError = opentype.Parse(data)
+		if parsingError != nil {
+			return nil, parsingError
+		}
+	}
+
+	face, err := opentype.NewFace(parsedFont, fl.faceOpts)
+	if err != nil {
+		return nil, err
+	}
+
+	loadedFace := &LoadedFace{
+		FontFile: fontFile,
+		Face:     face,
+	}
+	fl.faceCache.Store(fontFile, loadedFace, time.Now().Add(10*time.Minute))
+	return loadedFace, nil
+}
+
+func (fl *FontLoader) GetFaceOptSize() float64 {
+	return fl.faceOpts.Size
+}
+
+func (fl *FontLoader) GetFaceOptDPI() float64 {
+	return fl.faceOpts.DPI
+}
+
+func (fl *FontLoader) GetScriptList() []string {
+	fontMap := fl.fontMapData.FMap.FontMap
+
+	arePresent := map[string]bool{
+		"Common":    false,
+		"Inherited": false,
+	}
+	listSize := len(fontMap)
+
+	for key := range arePresent {
+		if _, inFontMap := fontMap[key]; inFontMap {
+			arePresent[key] = true
+		} else {
+			listSize++
+		}
+	}
+
+	keys := make([]string, listSize)
+
+	i := 0
+	for k := range fontMap {
+		keys[i] = k
+		i++
+	}
+
+	for script, isPresent := range arePresent {
+		if !isPresent {
+			keys[i] = script
+			i++
+		}
+	}
+	return keys
+}

services/thumbnails/pkg/preprocessor/preprocessor.go

@@ -0,0 +1,202 @@
+package preprocessor
+
+import (
+	"bufio"
+	"image"
+	"image/draw"
+	"image/gif"
+	"io"
+	"math"
+	"mime"
+	"strings"
+
+	"github.com/pkg/errors"
+	"golang.org/x/image/font"
+	"golang.org/x/image/font/opentype"
+	"golang.org/x/image/math/fixed"
+)
+
+type FileConverter interface {
+	Convert(r io.Reader) (interface{}, error)
+}
+
+type ImageDecoder struct{}
+
+func (i ImageDecoder) Convert(r io.Reader) (interface{}, error) {
+	img, _, err := image.Decode(r)
+	if err != nil {
+		return nil, errors.Wrap(err, `could not decode the image`)
+	}
+	return img, nil
+}
+
+type GifDecoder struct{}
+
+func (i GifDecoder) Convert(r io.Reader) (interface{}, error) {
+	img, err := gif.DecodeAll(r)
+	if err != nil {
+		return nil, errors.Wrap(err, `could not decode the image`)
+	}
+	return img, nil
+}
+
+type TxtToImageConverter struct {
+	fontLoader *FontLoader
+}
+
+func (t TxtToImageConverter) Convert(r io.Reader) (interface{}, error) {
+	img := image.NewRGBA(image.Rect(0, 0, 640, 480))
+
+	imgBounds := img.Bounds()
+	draw.Draw(img, imgBounds, image.White, image.Point{}, draw.Src)
+
+	fontSizeAsInt := int(math.Ceil(t.fontLoader.GetFaceOptSize()))
+	margin := 10
+	minX := fixed.I(imgBounds.Min.X + margin)
+	maxX := fixed.I(imgBounds.Max.X - margin)
+	maxY := fixed.I(imgBounds.Max.Y - margin)
+	initialPoint := fixed.P(imgBounds.Min.X+margin, imgBounds.Min.Y+margin+fontSizeAsInt)
+	canvas := &font.Drawer{
+		Dst: img,
+		Src: image.Black,
+		Dot: initialPoint,
+	}
+
+	scriptList := t.fontLoader.GetScriptList()
+	textAnalyzer := NewTextAnalyzer(scriptList)
+	taOpts := AnalysisOpts{
+		UseMergeMap: true,
+		MergeMap:    DefaultMergeMap,
+	}
+
+	scanner := bufio.NewScanner(r)
+Scan: // Label for the scanner loop, so we can break it easily
+	for scanner.Scan() {
+		txt := scanner.Text()
+		height := fixed.I(fontSizeAsInt) // reset to default height
+
+		textResult := textAnalyzer.AnalyzeString(txt, taOpts)
+		textResult.MergeCommon(DefaultMergeMap)
+
+		for _, sRange := range textResult.ScriptRanges {
+			targetFontFace, _ := t.fontLoader.LoadFaceForScript(sRange.TargetScript)
+			// if the target script is "_unknown" it's expected that the loaded face
+			// uses the default font
+			faceHeight := targetFontFace.Face.Metrics().Height
+			if faceHeight > height {
+				height = faceHeight
+			}
+
+			canvas.Face = targetFontFace.Face
+			initialByte := sRange.Low
+			for _, sRangeSpace := range sRange.Spaces {
+				if canvas.Dot.Y > maxY {
+					break Scan
+				}
+				drawWord(canvas, textResult.Text[initialByte:sRangeSpace], minX, maxX, height, maxY, true)
+				initialByte = sRangeSpace
+			}
+			if initialByte <= sRange.High {
+				// some bytes left to be written
+				if canvas.Dot.Y > maxY {
+					break Scan
+				}
+				drawWord(canvas, textResult.Text[initialByte:sRange.High+1], minX, maxX, height, maxY, len(sRange.Spaces) > 0)
+			}
+		}
+
+		canvas.Dot.X = minX
+		canvas.Dot.Y += height.Mul(fixed.Int26_6(1<<6 + 1<<5)) // height * 1.5
+
+		if canvas.Dot.Y > maxY {
+			break
+		}
+	}
+	return img, scanner.Err()
+}
+
+// Draw the word in the canvas. The mixX and maxX defines the drawable range
+// (X axis) where the word can be drawn (in case the word is too big and doesn't
+// fit in the canvas), and the incY defines the increment in the Y axis if we
+// need to draw the word in a new line
+//
+// Note that the word will likely start with a white space char
+func drawWord(canvas *font.Drawer, word string, minX, maxX, incY, maxY fixed.Int26_6, goToNewLine bool) {
+	bbox, _ := canvas.BoundString(word)
+	if bbox.Max.X <= maxX {
+		// word fits in the current line
+		canvas.DrawString(word)
+	} else {
+		// word doesn't fit -> retry in a new line
+		trimmedWord := strings.TrimSpace(word)
+		oldDot := canvas.Dot
+
+		canvas.Dot.X = minX
+		canvas.Dot.Y += incY
+		bbox2, _ := canvas.BoundString(trimmedWord)
+		if goToNewLine && bbox2.Max.X <= maxX {
+			if canvas.Dot.Y > maxY {
+				// Don't draw if we're over the Y limit
+				return
+			}
+			canvas.DrawString(trimmedWord)
+		} else {
+			// word doesn't fit in a new line -> draw as many chars as possible
+			canvas.Dot = oldDot
+			for _, char := range trimmedWord {
+				charBytes := []byte(string(char))
+				bbox3, _ := canvas.BoundBytes(charBytes)
+				if bbox3.Max.X > maxX {
+					canvas.Dot.X = minX
+					canvas.Dot.Y += incY
+					if canvas.Dot.Y > maxY {
+						// Don't draw if we're over the Y limit
+						return
+					}
+				}
+				canvas.DrawBytes(charBytes)
+			}
+		}
+	}
+}
+
+func ForType(mimeType string, opts map[string]interface{}) FileConverter {
+	// We can ignore the error here because we parse it in IsMimeTypeSupported before and if it fails
+	// return the service call. So we should only get here when the mimeType parses fine.
+	mimeType, _, _ = mime.ParseMediaType(mimeType)
+	switch mimeType {
+	case "text/plain":
+		fontFileMap := ""
+		fontFaceOpts := &opentype.FaceOptions{
+			Size:    12,
+			DPI:     72,
+			Hinting: font.HintingNone,
+		}
+
+		if optedFontFileMap, ok := opts["fontFileMap"]; ok {
+			if stringFontFileMap, ok := optedFontFileMap.(string); ok {
+				fontFileMap = stringFontFileMap
+			}
+		}
+
+		if optedFontFaceOpts, ok := opts["fontFaceOpts"]; ok {
+			if typedFontFaceOpts, ok := optedFontFaceOpts.(*opentype.FaceOptions); ok {
+				fontFaceOpts = typedFontFaceOpts
+			}
+		}
+
+		fontLoader, err := NewFontLoader(fontFileMap, fontFaceOpts)
+		if err != nil {
+			// if couldn't create the FontLoader with the specified fontFileMap,
+			// try to use the default font
+			fontLoader, _ = NewFontLoader("", fontFaceOpts)
+		}
+		return TxtToImageConverter{
+			fontLoader: fontLoader,
+		}
+	case "image/gif":
+		return GifDecoder{}
+	default:
+		return ImageDecoder{}
+	}
+}

services/thumbnails/pkg/preprocessor/textanalyzer.go

@@ -0,0 +1,309 @@
+package preprocessor
+
+import (
+	"unicode"
+	"unicode/utf8"
+)
+
+// Default list of scripts to be analyzed within the string.
+//
+// Scripts that aren't present in the list will be considered as part
+// of the last "known" script. For example, if "Avestan" script (which isn't
+// present) is preceeded by "Arabic" script, then the "Avestan" script will
+// be considered as "Arabic"
+//
+// Punctuation symbols are usually considered part of the "Common" script
+var DefaultScripts = []string{
+	"Arabic",
+	"Common",
+	"Devanagari",
+	"Han",
+	"Hangul",
+	"Hiragana",
+	"Inherited",
+	"Katakana",
+	"Latin",
+}
+
+// Convenient map[string]map[string]string type used to merge multiple
+// scripts into one. This is mainly used for japanese language which uses
+// "Han", "Hiragana" and "Katakana" scripts.
+//
+// The map contains the expected previous script as first key, the expected
+// current script as second key, and the resulting script (if both keys
+// match) as value
+type MergeMap map[string]map[string]string
+
+// The default mergeMap containing info for the japanese scripts
+var DefaultMergeMap = MergeMap{
+	"Han": map[string]string{
+		"Hiragana": "Hiragana",
+		"Katakana": "Katakana",
+	},
+	"Hiragana": map[string]string{
+		"Han":      "Hiragana",
+		"Katakana": "Hiragana",
+	},
+	"Katakana": map[string]string{
+		"Han":      "Katakana",
+		"Hiragana": "Hiragana",
+	},
+}
+
+// Analysis options.
+type AnalysisOpts struct {
+	UseMergeMap bool
+	MergeMap    MergeMap
+}
+
+// A script range. The range should be attached to a string which could contain
+// multiple scripts. The "TargetScript" will go from bytes "Low" to "High"
+// (both inclusive), and contains a "RuneCount" number of runes or chars
+// (mostly for debugging purposes).
+// The Space contains the bytes (inside the range) that are considered as
+// white space.
+type ScriptRange struct {
+	Low, High    int
+	Spaces       []int
+	TargetScript string
+	RuneCount    int
+}
+
+// The result of a text analysis. It contains the analyzed text, a list of
+// script ranges (see the ScriptRange type) and a map containing how many
+// runes have been detected for a particular script.
+type TextAnalysis struct {
+	ScriptRanges []ScriptRange
+	RuneCount    map[string]int
+	Text         string
+}
+
+// The TextAnalyzer object contains private members. It should be created via
+// "NewTextAnalyzer" function.
+type TextAnalyzer struct {
+	scripts         map[string]*unicode.RangeTable
+	scriptListCache []string
+}
+
+// Create a new TextAnalyzer. A list of scripts must be provided.
+// You can use the "DefaultScripts" variable for a default list,
+// although it doesn't contain all the available scripts.
+// See the unicode.Scripts variable (in the unicode package) for a
+// full list. Note that using invalid scripts will cause an undefined
+// behavior
+func NewTextAnalyzer(scriptList []string) TextAnalyzer {
+	scriptRanges := make(map[string]*unicode.RangeTable, len(scriptList))
+	for _, script := range scriptList {
+		scriptRanges[script] = unicode.Scripts[script]
+	}
+	return TextAnalyzer{
+		scripts:         scriptRanges,
+		scriptListCache: scriptList,
+	}
+}
+
+// Analyze the target string using the specified options.
+// A TextAnalysis will be returned with the result of the analysis.
+func (ta *TextAnalyzer) AnalyzeString(word string, opts AnalysisOpts) TextAnalysis {
+	analysis := TextAnalysis{
+		ScriptRanges: []ScriptRange{},
+		RuneCount:    make(map[string]int),
+		Text:         word,
+	}
+
+	if len(word) < 1 {
+		return analysis
+	}
+
+	firstRune, runeLen := utf8.DecodeRuneInString(word)
+
+	lastRange := &ScriptRange{
+		Low:          0,
+		Spaces:       make([]int, 0),
+		TargetScript: ta.chooseScriptFor(firstRune),
+	}
+	firstRuneIsWhiteSpace := unicode.Is(unicode.White_Space, firstRune)
+	if firstRuneIsWhiteSpace {
+		lastRange.Spaces = append(lastRange.Spaces, 0)
+	}
+
+	runeCount := 1
+	for wordIndex, char := range word[runeLen:] {
+		wordIndex += runeLen // shifted from the original string
+		script := ta.chooseScriptFor(char)
+
+		isWhiteSpace := unicode.Is(unicode.White_Space, char)
+		if script != lastRange.TargetScript {
+			if mapScript, isOk := ta.getMergeMapValue(opts, lastRange.TargetScript, script); isOk {
+				lastRange.TargetScript = mapScript
+				if isWhiteSpace {
+					// TODO: Check if this is dead code.
+					// whitespace should be part of the "Common" script, and the Common
+					// script shouldn't be part of a mergeMap
+					lastRange.Spaces = append(lastRange.Spaces, wordIndex)
+				}
+				runeCount++
+				continue
+			}
+
+			lastRange.High = wordIndex - 1
+			lastRange.RuneCount = runeCount
+			analysis.ScriptRanges = append(analysis.ScriptRanges, *lastRange)
+			if _, exists := analysis.RuneCount[lastRange.TargetScript]; !exists {
+				analysis.RuneCount[lastRange.TargetScript] = 0
+			}
+			analysis.RuneCount[lastRange.TargetScript] += runeCount
+			lastRange = &ScriptRange{
+				Low:          wordIndex,
+				Spaces:       make([]int, 0),
+				TargetScript: script,
+			}
+			runeCount = 0
+		}
+		runeCount++
+		if isWhiteSpace {
+			lastRange.Spaces = append(lastRange.Spaces, wordIndex)
+		}
+	}
+
+	// close the last range
+	lastRange.High = len(word) - 1
+	lastRange.RuneCount = runeCount
+	analysis.RuneCount[lastRange.TargetScript] += runeCount
+	analysis.ScriptRanges = append(analysis.ScriptRanges, *lastRange)
+
+	return analysis
+}
+
+func (ta *TextAnalyzer) chooseScriptFor(char rune) string {
+	script := "_unknown"
+	for scriptIndex, scriptFound := range ta.scriptListCache {
+		// if we can't match with a known script, do nothing and jump to the next char
+		if unicode.Is(ta.scripts[scriptFound], char) {
+			if scriptIndex > 3 {
+				// we might expect more chars with the same script
+				// so move the script first to match it faster next time
+				ta.reorderScriptList(scriptFound)
+			}
+			return scriptFound
+		}
+	}
+	return script
+}
+
+// Reorder the scriptListCache in the TextAnalyzer in order to speed up
+// the next script searches. A "Latin" script is expected to be surrounded
+// by "Latin" chars, although "Common" script chars might be present too
+func (ta *TextAnalyzer) reorderScriptList(matchedScript string) {
+	for index, script := range ta.scriptListCache {
+		if script == matchedScript {
+			if index != 0 {
+				// move the script to the first position for a faster matching
+				newList := append([]string{script}, ta.scriptListCache[:index]...)
+				ta.scriptListCache = append(newList, ta.scriptListCache[index+1:]...)
+			}
+			// if index == 0 there is nothing to do: the element is already the first
+			break
+		}
+	}
+}
+
+// Get the value from the merge map based on the previous and current scripts.
+// The information about using the merge map and the actual merge map will be
+// gotten from the AnalysisOpts passed as parameter
+func (ta *TextAnalyzer) getMergeMapValue(opts AnalysisOpts, previous, current string) (string, bool) {
+	if opts.UseMergeMap {
+		// This option mainly target japanese chars; multiple scripts can be used
+		// in the same piece of text (Han, Hiragana and Katakana)
+		// Instead of starting a new range, adjust the target script of the last range
+		if expCurrent, currentOk := opts.MergeMap[previous]; currentOk {
+			if expFinal, finalOk := expCurrent[current]; finalOk {
+				return expFinal, finalOk
+			}
+		}
+	}
+	return "", false
+}
+
+// Change the "Common" script to the one used in the previous script range.
+// The ranges will be readjusted and merged if they're adjacent.
+// This naive approach should be good enough for normal use cases
+//
+// The MergeMap is needed in case of the japanese language: the ranges
+// "Han"-"Common"-"Katakana" might be replaced to "Han"-"Hiragana"-"Katakana"
+// However, the ranges should be merged together into a big "Hiragana" range.
+// If the MergeMap isn't needed, use an empty one
+func (tr *TextAnalysis) MergeCommon(mergeMap MergeMap) {
+	var finalRanges []ScriptRange
+
+	if len(tr.ScriptRanges) < 1 {
+		// no ranges -> nothing to do
+		return
+	}
+
+	previousRange := &ScriptRange{}
+	*previousRange = tr.ScriptRanges[0]
+	for _, sRange := range tr.ScriptRanges[1:] {
+		if previousRange.TargetScript == sRange.TargetScript {
+			previousRange.High = sRange.High
+			previousRange.Spaces = append(previousRange.Spaces, sRange.Spaces...)
+			previousRange.RuneCount += sRange.RuneCount
+		} else if sRange.TargetScript == "Common" || sRange.TargetScript == "Inherited" {
+			// new range will be absorbed into the previous one
+			previousRange.High = sRange.High
+			previousRange.Spaces = append(previousRange.Spaces, sRange.Spaces...)
+			previousRange.RuneCount += sRange.RuneCount
+			tr.RuneCount[previousRange.TargetScript] += sRange.RuneCount
+			tr.RuneCount[sRange.TargetScript] -= sRange.RuneCount
+		} else if previousRange.TargetScript == "Common" || previousRange.TargetScript == "Inherited" {
+			// might happen if the text starts with a Common script
+			previousRange.High = sRange.High
+			previousRange.Spaces = append(previousRange.Spaces, sRange.Spaces...)
+			tr.RuneCount[sRange.TargetScript] += previousRange.RuneCount
+			tr.RuneCount[previousRange.TargetScript] -= previousRange.RuneCount
+			previousRange.RuneCount += sRange.RuneCount
+			previousRange.TargetScript = sRange.TargetScript
+		} else {
+			if mapScript, isOk := tr.getMergeMapValue(mergeMap, previousRange.TargetScript, sRange.TargetScript); isOk {
+				if sRange.TargetScript == mapScript {
+					// the previous range has changed the target script
+					tr.RuneCount[previousRange.TargetScript] -= previousRange.RuneCount
+					tr.RuneCount[sRange.TargetScript] += previousRange.RuneCount
+				} else {
+					// new range has been absorbed
+					tr.RuneCount[sRange.TargetScript] -= sRange.RuneCount
+					tr.RuneCount[previousRange.TargetScript] += sRange.RuneCount
+				}
+				previousRange.TargetScript = mapScript
+				previousRange.High = sRange.High
+				previousRange.Spaces = append(previousRange.Spaces, sRange.Spaces...)
+				previousRange.RuneCount += sRange.RuneCount
+				continue
+			}
+			finalRanges = append(finalRanges, *previousRange)
+			*previousRange = sRange
+		}
+	}
+
+	finalRanges = append(finalRanges, *previousRange)
+	tr.ScriptRanges = finalRanges
+	delete(tr.RuneCount, "Common")
+	delete(tr.RuneCount, "Inherited")
+	for index, rCount := range tr.RuneCount {
+		if rCount == 0 {
+			delete(tr.RuneCount, index)
+		}
+	}
+}
+
+func (tr *TextAnalysis) getMergeMapValue(mMap MergeMap, previous, current string) (string, bool) {
+	// This option mainly target japanese chars; multiple scripts can be used
+	// in the same piece of text (Han, Hiragana and Katakana)
+	// Instead of starting a new range, adjust the target script of the last range
+	if expCurrent, currentOk := mMap[previous]; currentOk {
+		if expFinal, finalOk := expCurrent[current]; finalOk {
+			return expFinal, finalOk
+		}
+	}
+	return "", false
+}

services/thumbnails/pkg/preprocessor/textanalyzer_test.go

@@ -0,0 +1,614 @@
+package preprocessor
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var (
+	inputs = [18]string{
+		"basic latin",
+		"trailing tab	",
+		"Small text. \"$\", \"£\" and \"¥\" are currencies.",
+		"latin with 🖖",
+		"기본 한국어",
+		"基本的な日本語",
+		"ウーロン茶",
+		"私はエンジニアです",
+		"ティー私はエンジニアです",
+		"私はエンジニアです ティー",
+		"आधारभूत देवनागरी",
+		"mixed 언어 传入 🚀!",
+		"/k͜p/",
+		// ä and a + ¨
+		"ä ä",
+		"базовый русский", // cyrillic script isn't part of our default
+		"latin русский",   // latin + cyrillic (cyrillic not supported)
+		" space justified ",
+		"",
+	}
+)
+
+func TestAnalyzeString(t *testing.T) {
+	defaultOpts := AnalysisOpts{
+		UseMergeMap: true,
+		MergeMap:    DefaultMergeMap,
+	}
+
+	tables := []struct {
+		input string
+		opts  AnalysisOpts
+		eOut  TextAnalysis
+	}{
+		{
+			input: inputs[0],
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 10, Spaces: []int{5}, TargetScript: "Latin", RuneCount: 11},
+				},
+				RuneCount: map[string]int{
+					"Latin": 11,
+				},
+				Text: inputs[0],
+			},
+		},
+		{
+			input: inputs[1],
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 12, Spaces: []int{8, 12}, TargetScript: "Latin", RuneCount: 13},
+				},
+				RuneCount: map[string]int{
+					"Latin": 13,
+				},
+				Text: inputs[1],
+			},
+		},
+		{
+			input: inputs[2],
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 45, Spaces: []int{5, 11, 16, 21, 25, 30, 34}, TargetScript: "Latin", RuneCount: 44},
+				},
+				RuneCount: map[string]int{
+					"Latin": 44,
+				},
+				Text: inputs[2],
+			},
+		},
+		{
+			input: inputs[3],
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 14, Spaces: []int{5, 10}, TargetScript: "Latin", RuneCount: 12},
+				},
+				RuneCount: map[string]int{
+					"Latin": 12,
+				},
+				Text: inputs[3],
+			},
+		},
+		{
+			input: inputs[4],
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 15, Spaces: []int{6}, TargetScript: "Hangul", RuneCount: 6},
+				},
+				RuneCount: map[string]int{
+					"Hangul": 6,
+				},
+				Text: inputs[4],
+			},
+		},
+		{
+			input: inputs[5],
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 20, Spaces: []int{}, TargetScript: "Hiragana", RuneCount: 7},
+				},
+				RuneCount: map[string]int{
+					"Hiragana": 7,
+				},
+				Text: inputs[5],
+			},
+		},
+		{
+			input: inputs[6],
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 14, Spaces: []int{}, TargetScript: "Katakana", RuneCount: 5},
+				},
+				RuneCount: map[string]int{
+					"Katakana": 5,
+				},
+				Text: inputs[6],
+			},
+		},
+		{
+			input: inputs[7],
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 26, Spaces: []int{}, TargetScript: "Hiragana", RuneCount: 9},
+				},
+				RuneCount: map[string]int{
+					"Hiragana": 9,
+				},
+				Text: inputs[7],
+			},
+		},
+		{
+			input: inputs[8],
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 35, Spaces: []int{}, TargetScript: "Hiragana", RuneCount: 12},
+				},
+				RuneCount: map[string]int{
+					"Hiragana": 12,
+				},
+				Text: inputs[8],
+			},
+		},
+		{
+			input: inputs[9],
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 36, Spaces: []int{27}, TargetScript: "Hiragana", RuneCount: 13},
+				},
+				RuneCount: map[string]int{
+					"Hiragana": 13,
+				},
+				Text: inputs[9],
+			},
+		},
+		{
+			input: inputs[10],
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 45, Spaces: []int{21}, TargetScript: "Devanagari", RuneCount: 16},
+				},
+				RuneCount: map[string]int{
+					"Devanagari": 16,
+				},
+				Text: inputs[10],
+			},
+		},
+		{
+			input: inputs[11],
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 5, Spaces: []int{5}, TargetScript: "Latin", RuneCount: 6},
+					ScriptRange{Low: 6, High: 12, Spaces: []int{12}, TargetScript: "Hangul", RuneCount: 3},
+					ScriptRange{Low: 13, High: 24, Spaces: []int{19}, TargetScript: "Han", RuneCount: 5}, // 🚀 and ! are "Common" script and will be merged with "Han"
+				},
+				RuneCount: map[string]int{
+					"Latin":  6,
+					"Hangul": 3,
+					"Han":    5,
+				},
+				Text: inputs[11],
+			},
+		},
+		{
+			input: inputs[12],
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 5, Spaces: []int{}, TargetScript: "Latin", RuneCount: 5},
+				},
+				RuneCount: map[string]int{
+					"Latin": 5,
+				},
+				Text: inputs[12],
+			},
+		},
+		{
+			input: inputs[13], // ä and a + ¨
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 5, Spaces: []int{2}, TargetScript: "Latin", RuneCount: 4},
+				},
+				RuneCount: map[string]int{
+					"Latin": 4,
+				},
+				Text: inputs[13],
+			},
+		},
+		{
+			input: inputs[14], // cyrillic script isn't part of our default
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 28, Spaces: []int{14}, TargetScript: "_unknown", RuneCount: 15},
+				},
+				RuneCount: map[string]int{
+					"_unknown": 15,
+				},
+				Text: inputs[14],
+			},
+		},
+		{
+			input: inputs[15], // latin + cyrillic (cyrillic script isn't part of our default)
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 5, Spaces: []int{5}, TargetScript: "Latin", RuneCount: 6},
+					ScriptRange{Low: 6, High: 19, Spaces: []int{}, TargetScript: "_unknown", RuneCount: 7},
+				},
+				RuneCount: map[string]int{
+					"Latin":    6,
+					"_unknown": 7,
+				},
+				Text: inputs[15],
+			},
+		},
+		{
+			input: inputs[16], // latin + cyrillic (cyrillic script isn't part of our default)
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 16, Spaces: []int{0, 6, 16}, TargetScript: "Latin", RuneCount: 17},
+				},
+				RuneCount: map[string]int{
+					"Latin": 17,
+				},
+				Text: inputs[16],
+			},
+		},
+		{
+			input: inputs[17], // latin + cyrillic (cyrillic script isn't part of our default)
+			opts:  defaultOpts,
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{},
+				RuneCount:    map[string]int{},
+				Text:         inputs[17],
+			},
+		},
+	}
+
+	for _, table := range tables {
+		testname := fmt.Sprintf("Analyzing \"%s\" string", table.input)
+		t.Run(testname, func(t *testing.T) {
+			ta := NewTextAnalyzer(DefaultScripts)
+			result := ta.AnalyzeString(table.input, table.opts)
+			if table.opts.UseMergeMap {
+				result.MergeCommon(table.opts.MergeMap)
+			} else {
+				result.MergeCommon(MergeMap{})
+			}
+			assert.Equal(t, table.eOut, result)
+		})
+	}
+}
+
+func TestAnalyzeStringRaw(t *testing.T) {
+	tables := []struct {
+		input string
+		eOut  TextAnalysis
+	}{
+		{
+			input: inputs[0],
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 4, Spaces: []int{}, TargetScript: "Latin", RuneCount: 5},
+					ScriptRange{Low: 5, High: 5, Spaces: []int{5}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 6, High: 10, Spaces: []int{}, TargetScript: "Latin", RuneCount: 5},
+				},
+				RuneCount: map[string]int{
+					"Latin":  10,
+					"Common": 1,
+				},
+				Text: inputs[0],
+			},
+		},
+		{
+			input: inputs[1],
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 7, Spaces: []int{}, TargetScript: "Latin", RuneCount: 8},
+					ScriptRange{Low: 8, High: 8, Spaces: []int{8}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 9, High: 11, Spaces: []int{}, TargetScript: "Latin", RuneCount: 3},
+					ScriptRange{Low: 12, High: 12, Spaces: []int{12}, TargetScript: "Common", RuneCount: 1},
+				},
+				RuneCount: map[string]int{
+					"Latin":  11,
+					"Common": 2,
+				},
+				Text: inputs[1],
+			},
+		},
+		{
+			input: inputs[2],
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 4, Spaces: []int{}, TargetScript: "Latin", RuneCount: 5},
+					ScriptRange{Low: 5, High: 5, Spaces: []int{5}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 6, High: 9, Spaces: []int{}, TargetScript: "Latin", RuneCount: 4},
+					ScriptRange{Low: 10, High: 21, Spaces: []int{11, 16, 21}, TargetScript: "Common", RuneCount: 11}, // £ takes 2 bytes
+					ScriptRange{Low: 22, High: 24, Spaces: []int{}, TargetScript: "Latin", RuneCount: 3},
+					ScriptRange{Low: 25, High: 30, Spaces: []int{25, 30}, TargetScript: "Common", RuneCount: 5}, // ¥ takes 2 bytes
+					ScriptRange{Low: 31, High: 33, Spaces: []int{}, TargetScript: "Latin", RuneCount: 3},
+					ScriptRange{Low: 34, High: 34, Spaces: []int{34}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 35, High: 44, Spaces: []int{}, TargetScript: "Latin", RuneCount: 10},
+					ScriptRange{Low: 45, High: 45, Spaces: []int{}, TargetScript: "Common", RuneCount: 1},
+				},
+				RuneCount: map[string]int{
+					"Latin":  25,
+					"Common": 19,
+				},
+				Text: inputs[2],
+			},
+		},
+		{
+			input: inputs[3],
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 4, Spaces: []int{}, TargetScript: "Latin", RuneCount: 5},
+					ScriptRange{Low: 5, High: 5, Spaces: []int{5}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 6, High: 9, Spaces: []int{}, TargetScript: "Latin", RuneCount: 4},
+					ScriptRange{Low: 10, High: 14, Spaces: []int{10}, TargetScript: "Common", RuneCount: 2},
+				},
+				RuneCount: map[string]int{
+					"Latin":  9,
+					"Common": 3,
+				},
+				Text: inputs[3],
+			},
+		},
+		{
+			input: inputs[4],
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 5, Spaces: []int{}, TargetScript: "Hangul", RuneCount: 2},
+					ScriptRange{Low: 6, High: 6, Spaces: []int{6}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 7, High: 15, Spaces: []int{}, TargetScript: "Hangul", RuneCount: 3},
+				},
+				RuneCount: map[string]int{
+					"Hangul": 5,
+					"Common": 1,
+				},
+				Text: inputs[4],
+			},
+		},
+		{
+			input: inputs[5],
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 8, Spaces: []int{}, TargetScript: "Han", RuneCount: 3},
+					ScriptRange{Low: 9, High: 11, Spaces: []int{}, TargetScript: "Hiragana", RuneCount: 1},
+					ScriptRange{Low: 12, High: 20, Spaces: []int{}, TargetScript: "Han", RuneCount: 3},
+				},
+				RuneCount: map[string]int{
+					"Hiragana": 1,
+					"Han":      6,
+				},
+				Text: inputs[5],
+			},
+		},
+		{
+			input: inputs[6],
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 2, Spaces: []int{}, TargetScript: "Katakana", RuneCount: 1},
+					ScriptRange{Low: 3, High: 5, Spaces: []int{}, TargetScript: "Common", RuneCount: 1}, // ー U+30FC (KATAKANA-HIRAGANA PROLONGED SOUND MARK) seems to be counted as Common
+					ScriptRange{Low: 6, High: 11, Spaces: []int{}, TargetScript: "Katakana", RuneCount: 2},
+					ScriptRange{Low: 12, High: 14, Spaces: []int{}, TargetScript: "Han", RuneCount: 1},
+				},
+				RuneCount: map[string]int{
+					"Katakana": 3,
+					"Common":   1,
+					"Han":      1,
+				},
+				Text: inputs[6],
+			},
+		},
+		{
+			input: inputs[7],
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 2, Spaces: []int{}, TargetScript: "Han", RuneCount: 1},
+					ScriptRange{Low: 3, High: 5, Spaces: []int{}, TargetScript: "Hiragana", RuneCount: 1},
+					ScriptRange{Low: 6, High: 20, Spaces: []int{}, TargetScript: "Katakana", RuneCount: 5},
+					ScriptRange{Low: 21, High: 26, Spaces: []int{}, TargetScript: "Hiragana", RuneCount: 2},
+				},
+				RuneCount: map[string]int{
+					"Han":      1,
+					"Hiragana": 3,
+					"Katakana": 5,
+				},
+				Text: inputs[7],
+			},
+		},
+		{
+			input: inputs[8],
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 5, Spaces: []int{}, TargetScript: "Katakana", RuneCount: 2},
+					ScriptRange{Low: 6, High: 8, Spaces: []int{}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 9, High: 11, Spaces: []int{}, TargetScript: "Han", RuneCount: 1},
+					ScriptRange{Low: 12, High: 14, Spaces: []int{}, TargetScript: "Hiragana", RuneCount: 1},
+					ScriptRange{Low: 15, High: 29, Spaces: []int{}, TargetScript: "Katakana", RuneCount: 5},
+					ScriptRange{Low: 30, High: 35, Spaces: []int{}, TargetScript: "Hiragana", RuneCount: 2},
+				},
+				RuneCount: map[string]int{
+					"Han":      1,
+					"Hiragana": 3,
+					"Katakana": 7,
+					"Common":   1,
+				},
+				Text: inputs[8],
+			},
+		},
+		{
+			input: inputs[9],
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 2, Spaces: []int{}, TargetScript: "Han", RuneCount: 1},
+					ScriptRange{Low: 3, High: 5, Spaces: []int{}, TargetScript: "Hiragana", RuneCount: 1},
+					ScriptRange{Low: 6, High: 20, Spaces: []int{}, TargetScript: "Katakana", RuneCount: 5},
+					ScriptRange{Low: 21, High: 26, Spaces: []int{}, TargetScript: "Hiragana", RuneCount: 2},
+					ScriptRange{Low: 27, High: 27, Spaces: []int{27}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 28, High: 33, Spaces: []int{}, TargetScript: "Katakana", RuneCount: 2},
+					ScriptRange{Low: 34, High: 36, Spaces: []int{}, TargetScript: "Common", RuneCount: 1},
+				},
+				RuneCount: map[string]int{
+					"Han":      1,
+					"Hiragana": 3,
+					"Katakana": 7,
+					"Common":   2,
+				},
+				Text: inputs[9],
+			},
+		},
+		{
+			input: inputs[10],
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 20, Spaces: []int{}, TargetScript: "Devanagari", RuneCount: 7},
+					ScriptRange{Low: 21, High: 21, Spaces: []int{21}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 22, High: 45, Spaces: []int{}, TargetScript: "Devanagari", RuneCount: 8},
+				},
+				RuneCount: map[string]int{
+					"Devanagari": 15,
+					"Common":     1,
+				},
+				Text: inputs[10],
+			},
+		},
+		{
+			input: inputs[11],
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 4, Spaces: []int{}, TargetScript: "Latin", RuneCount: 5},
+					ScriptRange{Low: 5, High: 5, Spaces: []int{5}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 6, High: 11, Spaces: []int{}, TargetScript: "Hangul", RuneCount: 2},
+					ScriptRange{Low: 12, High: 12, Spaces: []int{12}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 13, High: 18, Spaces: []int{}, TargetScript: "Han", RuneCount: 2},
+					ScriptRange{Low: 19, High: 24, Spaces: []int{19}, TargetScript: "Common", RuneCount: 3},
+				},
+				RuneCount: map[string]int{
+					"Latin":  5,
+					"Hangul": 2,
+					"Han":    2,
+					"Common": 5,
+				},
+				Text: inputs[11],
+			},
+		},
+		{
+			input: inputs[12],
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 0, Spaces: []int{}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 1, High: 1, Spaces: []int{}, TargetScript: "Latin", RuneCount: 1},
+					ScriptRange{Low: 2, High: 3, Spaces: []int{}, TargetScript: "Inherited", RuneCount: 1},
+					ScriptRange{Low: 4, High: 4, Spaces: []int{}, TargetScript: "Latin", RuneCount: 1},
+					ScriptRange{Low: 5, High: 5, Spaces: []int{}, TargetScript: "Common", RuneCount: 1},
+				},
+				RuneCount: map[string]int{
+					"Latin":     2,
+					"Common":    2,
+					"Inherited": 1,
+				},
+				Text: inputs[12],
+			},
+		},
+		{
+			input: inputs[13], // ä and a + ¨
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 1, Spaces: []int{}, TargetScript: "Latin", RuneCount: 1},
+					ScriptRange{Low: 2, High: 2, Spaces: []int{2}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 3, High: 3, Spaces: []int{}, TargetScript: "Latin", RuneCount: 1},
+					ScriptRange{Low: 4, High: 5, Spaces: []int{}, TargetScript: "Inherited", RuneCount: 1},
+				},
+				RuneCount: map[string]int{
+					"Latin":     2,
+					"Common":    1,
+					"Inherited": 1,
+				},
+				Text: inputs[13],
+			},
+		},
+		{
+			input: inputs[14], // cyrillic script isn't part of our default
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 13, Spaces: []int{}, TargetScript: "_unknown", RuneCount: 7},
+					ScriptRange{Low: 14, High: 14, Spaces: []int{14}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 15, High: 28, Spaces: []int{}, TargetScript: "_unknown", RuneCount: 7},
+				},
+				RuneCount: map[string]int{
+					"_unknown": 14,
+					"Common":   1,
+				},
+				Text: inputs[14],
+			},
+		},
+		{
+			input: inputs[15], // latin + cyrillic (cyrillic script isn't part of our default)
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 4, Spaces: []int{}, TargetScript: "Latin", RuneCount: 5},
+					ScriptRange{Low: 5, High: 5, Spaces: []int{5}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 6, High: 19, Spaces: []int{}, TargetScript: "_unknown", RuneCount: 7},
+				},
+				RuneCount: map[string]int{
+					"Latin":    5,
+					"Common":   1,
+					"_unknown": 7,
+				},
+				Text: inputs[15],
+			},
+		},
+		{
+			input: inputs[16],
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{
+					ScriptRange{Low: 0, High: 0, Spaces: []int{0}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 1, High: 5, Spaces: []int{}, TargetScript: "Latin", RuneCount: 5},
+					ScriptRange{Low: 6, High: 6, Spaces: []int{6}, TargetScript: "Common", RuneCount: 1},
+					ScriptRange{Low: 7, High: 15, Spaces: []int{}, TargetScript: "Latin", RuneCount: 9},
+					ScriptRange{Low: 16, High: 16, Spaces: []int{16}, TargetScript: "Common", RuneCount: 1},
+				},
+				RuneCount: map[string]int{
+					"Latin":  14,
+					"Common": 3,
+				},
+				Text: inputs[16],
+			},
+		},
+		{
+			input: inputs[17], // empty string
+			eOut: TextAnalysis{
+				ScriptRanges: []ScriptRange{},
+				RuneCount:    map[string]int{},
+				Text:         inputs[17],
+			},
+		},
+	}
+
+	for _, table := range tables {
+		testname := fmt.Sprintf("Raw-Analyzing \"%s\" string", table.input)
+		t.Run(testname, func(t *testing.T) {
+			ta := NewTextAnalyzer(DefaultScripts)
+			result := ta.AnalyzeString(table.input, AnalysisOpts{})
+
+			assert.Equal(t, table.eOut, result)
+		})
+	}
+}

services/thumbnails/pkg/server/debug/option.go

@@ -0,0 +1,42 @@
+package debug
+
+import (
+	"github.com/owncloud/ocis/v2/ocis-pkg/log"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+)
+
+// Option defines a single option function.
+type Option func(o *Options)
+
+// Options defines the available options for this package.
+type Options struct {
+	Name    string
+	Address string
+	Logger  log.Logger
+	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
+	}
+}
+
+// Config provides a function to set the config option.
+func Config(val *config.Config) Option {
+	return func(o *Options) {
+		o.Config = val
+	}
+}

services/thumbnails/pkg/server/debug/server.go

@@ -0,0 +1,59 @@
+package debug
+
+import (
+	"io"
+	"net/http"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/service/debug"
+	"github.com/owncloud/ocis/v2/ocis-pkg/version"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+)
+
+// Server initializes the debug service and server.
+func Server(opts ...Option) (*http.Server, error) {
+	options := newOptions(opts...)
+
+	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(health(options.Config)),
+		debug.Ready(ready(options.Config)),
+	), nil
+}
+
+// health implements the health check.
+func health(cfg *config.Config) func(http.ResponseWriter, *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/plain")
+		w.WriteHeader(http.StatusOK)
+
+		// TODO: check if services are up and running
+
+		_, err := io.WriteString(w, http.StatusText(http.StatusOK))
+		// io.WriteString should not fail but if it does we want to know.
+		if err != nil {
+			panic(err)
+		}
+	}
+}
+
+// ready implements the ready check.
+func ready(cfg *config.Config) func(http.ResponseWriter, *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/plain")
+		w.WriteHeader(http.StatusOK)
+
+		// TODO: check if services are up and running
+
+		_, err := io.WriteString(w, http.StatusText(http.StatusOK))
+		// io.WriteString should not fail but if it does we want to know.
+		if err != nil {
+			panic(err)
+		}
+	}
+}

services/thumbnails/pkg/server/grpc/option.go

@@ -0,0 +1,92 @@
+package grpc
+
+import (
+	"context"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/log"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/metrics"
+	"github.com/urfave/cli/v2"
+)
+
+// Option defines a single option function.
+type Option func(o *Options)
+
+// Options defines the available options for this package.
+type Options struct {
+	Name      string
+	Address   string
+	Logger    log.Logger
+	Context   context.Context
+	Config    *config.Config
+	Metrics   *metrics.Metrics
+	Namespace string
+	Flags     []cli.Flag
+}
+
+// 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
+	}
+}
+
+// Name provides a name for the service.
+func Name(val string) Option {
+	return func(o *Options) {
+		o.Name = val
+	}
+}
+
+// Address provides an address for the service.
+func Address(val string) Option {
+	return func(o *Options) {
+		o.Address = 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
+	}
+}
+
+// Namespace provides a function to set the namespace option.
+func Namespace(val string) Option {
+	return func(o *Options) {
+		o.Namespace = val
+	}
+}
+
+// Flags provides a function to set the flags option.
+func Flags(flags []cli.Flag) Option {
+	return func(o *Options) {
+		o.Flags = append(o.Flags, flags...)
+	}
+}

services/thumbnails/pkg/server/grpc/server.go

@@ -0,0 +1,60 @@
+package grpc
+
+import (
+	"github.com/cs3org/reva/v2/pkg/rgrpc/todo/pool"
+	"github.com/owncloud/ocis/v2/ocis-pkg/service/grpc"
+	"github.com/owncloud/ocis/v2/ocis-pkg/version"
+	thumbnailssvc "github.com/owncloud/ocis/v2/protogen/gen/ocis/services/thumbnails/v0"
+	svc "github.com/owncloud/ocis/v2/services/thumbnails/pkg/service/grpc/v0"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/service/grpc/v0/decorators"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/thumbnail/imgsource"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/thumbnail/storage"
+)
+
+// NewService initializes the grpc service and server.
+func NewService(opts ...Option) grpc.Service {
+	options := newOptions(opts...)
+
+	service := grpc.NewService(
+		grpc.Logger(options.Logger),
+		grpc.Namespace(options.Namespace),
+		grpc.Name(options.Name),
+		grpc.Version(version.GetString()),
+		grpc.Address(options.Address),
+		grpc.Context(options.Context),
+		grpc.Flags(options.Flags...),
+		grpc.Version(version.GetString()),
+	)
+	tconf := options.Config.Thumbnail
+	gc, err := pool.GetGatewayServiceClient(tconf.RevaGateway)
+	if err != nil {
+		options.Logger.Error().Err(err).Msg("could not get gateway client")
+		return grpc.Service{}
+	}
+	var thumbnail decorators.DecoratedService
+	{
+		thumbnail = svc.NewService(
+			svc.Config(options.Config),
+			svc.Logger(options.Logger),
+			svc.ThumbnailSource(imgsource.NewWebDavSource(tconf)),
+			svc.ThumbnailStorage(
+				storage.NewFileSystemStorage(
+					tconf.FileSystemStorage,
+					options.Logger,
+				),
+			),
+			svc.CS3Source(imgsource.NewCS3Source(tconf, gc)),
+			svc.CS3Client(gc),
+		)
+		thumbnail = decorators.NewInstrument(thumbnail, options.Metrics)
+		thumbnail = decorators.NewLogging(thumbnail, options.Logger)
+		thumbnail = decorators.NewTracing(thumbnail)
+	}
+
+	_ = thumbnailssvc.RegisterThumbnailServiceHandler(
+		service.Server(),
+		thumbnail,
+	)
+
+	return service
+}

services/thumbnails/pkg/server/http/option.go

@@ -0,0 +1,69 @@
+package http
+
+import (
+	"context"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/log"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/metrics"
+	"github.com/urfave/cli/v2"
+)
+
+// 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     []cli.Flag
+}
+
+// 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
+	}
+}
+
+// Namespace provides a function to set the Namespace option.
+func Namespace(val string) Option {
+	return func(o *Options) {
+		o.Namespace = val
+	}
+}

services/thumbnails/pkg/server/http/server.go

@@ -0,0 +1,58 @@
+package http
+
+import (
+	"github.com/go-chi/chi/v5/middleware"
+	ocismiddleware "github.com/owncloud/ocis/v2/ocis-pkg/middleware"
+	"github.com/owncloud/ocis/v2/ocis-pkg/service/http"
+	"github.com/owncloud/ocis/v2/ocis-pkg/version"
+	svc "github.com/owncloud/ocis/v2/services/thumbnails/pkg/service/http/v0"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/thumbnail/storage"
+	"go-micro.dev/v4"
+)
+
+// Server initializes the http service and server.
+func Server(opts ...Option) (http.Service, error) {
+	options := newOptions(opts...)
+
+	service := http.NewService(
+		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),
+	)
+
+	handle := svc.NewService(
+		svc.Logger(options.Logger),
+		svc.Config(options.Config),
+		svc.Middleware(
+			middleware.RealIP,
+			middleware.RequestID,
+			// ocismiddleware.Secure,
+			ocismiddleware.Version(
+				options.Config.Service.Name,
+				version.GetString(),
+			),
+			ocismiddleware.Logger(options.Logger),
+		),
+		svc.ThumbnailStorage(
+			storage.NewFileSystemStorage(
+				options.Config.Thumbnail.FileSystemStorage,
+				options.Logger,
+			),
+		),
+	)
+
+	{
+		handle = svc.NewInstrument(handle, options.Metrics)
+		handle = svc.NewLogging(handle, options.Logger)
+		handle = svc.NewTracing(handle)
+	}
+
+	if err := micro.RegisterHandler(service.Server(), handle); err != nil {
+		return http.Service{}, err
+	}
+
+	return service, nil
+}

services/thumbnails/pkg/service/grpc/v0/decorators/base.go

@@ -0,0 +1,59 @@
+package decorators
+
+import (
+	"context"
+
+	thumbnailssvc "github.com/owncloud/ocis/v2/protogen/gen/ocis/services/thumbnails/v0"
+)
+
+// Interface acting as facade, holding all the interfaces that this
+// thumbnails microservice is expecting to implement.
+// For now, only the thumbnailssvc.ThumbnailServiceHandler is present,
+// but a future configsvc.ConfigServiceHandler is expected to be added here
+//
+// This interface will also act as the base interface to implement
+// a decorator pattern.
+type DecoratedService interface {
+	thumbnailssvc.ThumbnailServiceHandler
+}
+
+// Base type to implement the decorators. It will provide a basic implementation
+// by delegating to the decoratedService
+//
+// Expected implementations will be like:
+// ```
+// type MyDecorator struct {
+//   Decorator
+//   myCustomOpts *opts
+//   additionalSrv *srv
+// }
+//
+// func NewMyDecorator(next DecoratedService, customOpts *customOpts) DecoratedService {
+//   .....
+//   return MyDecorator{
+//     Decorator: Decorator{next: next},
+//     myCustomOpts: opts,
+//     additionalSrv: srv,
+//   }
+// }
+// ```
+type Decorator struct {
+	next DecoratedService
+}
+
+// Base implementation for the GetThumbnail (for the thumbnailssvc).
+// It will just delegate to the underlying decoratedService
+//
+// Your custom decorator is expected to overwrite this function,
+// but it MUST call the underlying decoratedService at some point
+// ```
+// func (d MyDecorator) GetThumbnail(ctx context.Context, req *thumbnailssvc.GetThumbnailRequest, resp *thumbnailssvc.GetThumbnailResponse) error {
+//   doSomething()
+//   err := d.next.GetThumbnail(ctx, req, resp)
+//   doAnotherThing()
+//   return err
+// }
+// ```
+func (deco Decorator) GetThumbnail(ctx context.Context, req *thumbnailssvc.GetThumbnailRequest, resp *thumbnailssvc.GetThumbnailResponse) error {
+	return deco.next.GetThumbnail(ctx, req, resp)
+}

services/thumbnails/pkg/service/grpc/v0/decorators/instrument.go

@@ -0,0 +1,39 @@
+package decorators
+
+import (
+	"context"
+
+	thumbnailssvc "github.com/owncloud/ocis/v2/protogen/gen/ocis/services/thumbnails/v0"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/metrics"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+// NewInstrument returns a service that instruments metrics.
+func NewInstrument(next DecoratedService, metrics *metrics.Metrics) DecoratedService {
+	return instrument{
+		Decorator: Decorator{next: next},
+		metrics:   metrics,
+	}
+}
+
+type instrument struct {
+	Decorator
+	metrics *metrics.Metrics
+}
+
+// GetThumbnail implements the ThumbnailServiceHandler interface.
+func (i instrument) GetThumbnail(ctx context.Context, req *thumbnailssvc.GetThumbnailRequest, rsp *thumbnailssvc.GetThumbnailResponse) error {
+	timer := prometheus.NewTimer(prometheus.ObserverFunc(func(v float64) {
+		us := v * 1000_000
+		i.metrics.Latency.WithLabelValues().Observe(us)
+		i.metrics.Duration.WithLabelValues().Observe(v)
+	}))
+	defer timer.ObserveDuration()
+
+	err := i.next.GetThumbnail(ctx, req, rsp)
+
+	if err != nil {
+		i.metrics.Counter.WithLabelValues().Inc()
+	}
+	return err
+}

services/thumbnails/pkg/service/grpc/v0/decorators/logging.go

@@ -0,0 +1,53 @@
+package decorators
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/log"
+	thumbnailssvc "github.com/owncloud/ocis/v2/protogen/gen/ocis/services/thumbnails/v0"
+	merrors "go-micro.dev/v4/errors"
+)
+
+// NewLogging returns a service that logs messages.
+func NewLogging(next DecoratedService, logger log.Logger) DecoratedService {
+	return logging{
+		Decorator: Decorator{next: next},
+		logger:    logger,
+	}
+}
+
+type logging struct {
+	Decorator
+	logger log.Logger
+}
+
+// GetThumbnail implements the ThumbnailServiceHandler interface.
+func (l logging) GetThumbnail(ctx context.Context, req *thumbnailssvc.GetThumbnailRequest, rsp *thumbnailssvc.GetThumbnailResponse) error {
+	start := time.Now()
+	err := l.next.GetThumbnail(ctx, req, rsp)
+
+	logger := l.logger.With().
+		Str("method", "Thumbnails.GetThumbnail").
+		Dur("duration", time.Since(start)).
+		Logger()
+
+	if err != nil {
+		merror := merrors.FromError(err)
+		switch merror.Code {
+		case http.StatusNotFound:
+			logger.Debug().
+				Str("error_detail", merror.Detail).
+				Msg("no thumbnail found")
+		default:
+			logger.Warn().
+				Err(err).
+				Msg("Failed to execute")
+		}
+	} else {
+		logger.Debug().
+			Msg("")
+	}
+	return err
+}

services/thumbnails/pkg/service/grpc/v0/decorators/tracing.go

@@ -0,0 +1,42 @@
+package decorators
+
+import (
+	"context"
+
+	"go.opentelemetry.io/otel/trace"
+
+	thumbnailssvc "github.com/owncloud/ocis/v2/protogen/gen/ocis/services/thumbnails/v0"
+	thumbnailsTracing "github.com/owncloud/ocis/v2/services/thumbnails/pkg/tracing"
+	"go.opentelemetry.io/otel/attribute"
+)
+
+// NewTracing returns a service that instruments traces.
+func NewTracing(next DecoratedService) DecoratedService {
+	return tracing{
+		Decorator: Decorator{next: next},
+	}
+}
+
+type tracing struct {
+	Decorator
+}
+
+// GetThumbnail implements the ThumbnailServiceHandler interface.
+func (t tracing) GetThumbnail(ctx context.Context, req *thumbnailssvc.GetThumbnailRequest, rsp *thumbnailssvc.GetThumbnailResponse) error {
+	var span trace.Span
+
+	if thumbnailsTracing.TraceProvider != nil {
+		tracer := thumbnailsTracing.TraceProvider.Tracer("thumbnails")
+		ctx, span = tracer.Start(ctx, "Thumbnails.GetThumbnail")
+		defer span.End()
+
+		span.SetAttributes(
+			attribute.KeyValue{Key: "filepath", Value: attribute.StringValue(req.Filepath)},
+			attribute.KeyValue{Key: "thumbnail_type", Value: attribute.StringValue(req.ThumbnailType.String())},
+			attribute.KeyValue{Key: "width", Value: attribute.IntValue(int(req.Width))},
+			attribute.KeyValue{Key: "height", Value: attribute.IntValue(int(req.Height))},
+		)
+	}
+
+	return t.next.GetThumbnail(ctx, req, rsp)
+}

services/thumbnails/pkg/service/grpc/v0/option.go

@@ -0,0 +1,84 @@
+package svc
+
+import (
+	"net/http"
+
+	gateway "github.com/cs3org/go-cs3apis/cs3/gateway/v1beta1"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/log"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/thumbnail/imgsource"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/thumbnail/storage"
+)
+
+// 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
+	ThumbnailStorage storage.Storage
+	ImageSource      imgsource.Source
+	CS3Source        imgsource.Source
+	CS3Client        gateway.GatewayAPIClient
+}
+
+// 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
+	}
+}
+
+// ThumbnailStorage provides a function to set the thumbnail storage option.
+func ThumbnailStorage(val storage.Storage) Option {
+	return func(o *Options) {
+		o.ThumbnailStorage = val
+	}
+}
+
+// ThumbnailSource provides a function to set the image source option.
+func ThumbnailSource(val imgsource.Source) Option {
+	return func(o *Options) {
+		o.ImageSource = val
+	}
+}
+
+func CS3Source(val imgsource.Source) Option {
+	return func(o *Options) {
+		o.CS3Source = val
+	}
+}
+
+func CS3Client(c gateway.GatewayAPIClient) Option {
+	return func(o *Options) {
+		o.CS3Client = c
+	}
+}

services/thumbnails/pkg/service/grpc/v0/service.go

@@ -0,0 +1,295 @@
+package svc
+
+import (
+	"context"
+	"image"
+	"net/url"
+	"path"
+	"strings"
+	"time"
+
+	gateway "github.com/cs3org/go-cs3apis/cs3/gateway/v1beta1"
+	rpc "github.com/cs3org/go-cs3apis/cs3/rpc/v1beta1"
+	provider "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1"
+	revactx "github.com/cs3org/reva/v2/pkg/ctx"
+	"github.com/cs3org/reva/v2/pkg/storagespace"
+	"github.com/golang-jwt/jwt/v4"
+	"github.com/owncloud/ocis/v2/ocis-pkg/log"
+	thumbnailsmsg "github.com/owncloud/ocis/v2/protogen/gen/ocis/messages/thumbnails/v0"
+	thumbnailssvc "github.com/owncloud/ocis/v2/protogen/gen/ocis/services/thumbnails/v0"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/preprocessor"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/service/grpc/v0/decorators"
+	tjwt "github.com/owncloud/ocis/v2/services/thumbnails/pkg/service/jwt"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/thumbnail"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/thumbnail/imgsource"
+	"github.com/pkg/errors"
+	merrors "go-micro.dev/v4/errors"
+	"google.golang.org/grpc/metadata"
+)
+
+// NewService returns a service implementation for Service.
+func NewService(opts ...Option) decorators.DecoratedService {
+	options := newOptions(opts...)
+	logger := options.Logger
+	resolutions, err := thumbnail.ParseResolutions(options.Config.Thumbnail.Resolutions)
+	if err != nil {
+		logger.Fatal().Err(err).Msg("resolutions not configured correctly")
+	}
+	svc := Thumbnail{
+		serviceID: options.Config.GRPC.Namespace + "." + options.Config.Service.Name,
+		manager: thumbnail.NewSimpleManager(
+			resolutions,
+			options.ThumbnailStorage,
+			logger,
+		),
+		webdavSource: options.ImageSource,
+		cs3Source:    options.CS3Source,
+		logger:       logger,
+		cs3Client:    options.CS3Client,
+		preprocessorOpts: PreprocessorOpts{
+			TxtFontFileMap: options.Config.Thumbnail.FontMapFile,
+		},
+		dataEndpoint:   options.Config.Thumbnail.DataEndpoint,
+		transferSecret: options.Config.Thumbnail.TransferSecret,
+	}
+
+	return svc
+}
+
+// Thumbnail implements the GRPC handler.
+type Thumbnail struct {
+	serviceID        string
+	dataEndpoint     string
+	transferSecret   string
+	manager          thumbnail.Manager
+	webdavSource     imgsource.Source
+	cs3Source        imgsource.Source
+	logger           log.Logger
+	cs3Client        gateway.GatewayAPIClient
+	preprocessorOpts PreprocessorOpts
+}
+
+type PreprocessorOpts struct {
+	TxtFontFileMap string
+}
+
+// GetThumbnail retrieves a thumbnail for an image
+func (g Thumbnail) GetThumbnail(ctx context.Context, req *thumbnailssvc.GetThumbnailRequest, rsp *thumbnailssvc.GetThumbnailResponse) error {
+	tType, ok := thumbnailsmsg.ThumbnailType_name[int32(req.ThumbnailType)]
+	if !ok {
+		g.logger.Debug().Str("thumbnail_type", tType).Msg("unsupported thumbnail type")
+		return nil
+	}
+	generator, err := thumbnail.GeneratorForType(tType)
+	if err != nil {
+		g.logger.Debug().Str("thumbnail_type", tType).Msg("unsupported thumbnail type")
+		return nil
+	}
+	encoder, err := thumbnail.EncoderForType(tType)
+	if err != nil {
+		g.logger.Debug().Str("thumbnail_type", tType).Msg("unsupported thumbnail type")
+		return nil
+	}
+
+	var key string
+	switch {
+	case req.GetWebdavSource() != nil:
+		key, err = g.handleWebdavSource(ctx, req, generator, encoder)
+	case req.GetCs3Source() != nil:
+		key, err = g.handleCS3Source(ctx, req, generator, encoder)
+	default:
+		g.logger.Error().Msg("no image source provided")
+		return merrors.BadRequest(g.serviceID, "image source is missing")
+	}
+	if err != nil {
+		return err
+	}
+
+	claims := tjwt.ThumbnailClaims{
+		Key: key,
+		RegisteredClaims: jwt.RegisteredClaims{
+			IssuedAt:  jwt.NewNumericDate(time.Now()),
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(1 * time.Minute)),
+		},
+	}
+
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	transferToken, err := token.SignedString([]byte(g.transferSecret))
+	if err != nil {
+		g.logger.Error().
+			Err(err).
+			Msg("GetThumbnail: failed to sign token")
+		return merrors.InternalServerError(g.serviceID, "couldn't finish request")
+	}
+	rsp.DataEndpoint = g.dataEndpoint
+	rsp.TransferToken = transferToken
+	rsp.Mimetype = encoder.MimeType()
+	return nil
+}
+
+func (g Thumbnail) handleCS3Source(ctx context.Context,
+	req *thumbnailssvc.GetThumbnailRequest,
+	generator thumbnail.Generator,
+	encoder thumbnail.Encoder) (string, error) {
+	src := req.GetCs3Source()
+	sRes, err := g.stat(src.Path, src.Authorization)
+	if err != nil {
+		return "", err
+	}
+
+	tr := thumbnail.Request{
+		Resolution: image.Rect(0, 0, int(req.Width), int(req.Height)),
+		Generator:  generator,
+		Encoder:    encoder,
+		Checksum:   sRes.GetInfo().GetChecksum().GetSum(),
+	}
+
+	if key, exists := g.manager.CheckThumbnail(tr); exists {
+		return key, nil
+	}
+
+	ctx = imgsource.ContextSetAuthorization(ctx, src.Authorization)
+	r, err := g.cs3Source.Get(ctx, src.Path)
+	if err != nil {
+		return "", merrors.InternalServerError(g.serviceID, "could not get image from source: %s", err.Error())
+	}
+	defer r.Close() // nolint:errcheck
+	ppOpts := map[string]interface{}{
+		"fontFileMap": g.preprocessorOpts.TxtFontFileMap,
+	}
+	pp := preprocessor.ForType(sRes.GetInfo().GetMimeType(), ppOpts)
+	img, err := pp.Convert(r)
+	if img == nil || err != nil {
+		return "", merrors.InternalServerError(g.serviceID, "could not get image")
+	}
+
+	key, err := g.manager.Generate(tr, img)
+	if err != nil {
+		return "", err
+	}
+	return key, nil
+}
+
+func (g Thumbnail) handleWebdavSource(ctx context.Context,
+	req *thumbnailssvc.GetThumbnailRequest,
+	generator thumbnail.Generator,
+	encoder thumbnail.Encoder) (string, error) {
+	src := req.GetWebdavSource()
+	imgURL, err := url.Parse(src.Url)
+	if err != nil {
+		return "", errors.Wrap(err, "source url is invalid")
+	}
+
+	var auth, statPath string
+
+	if src.IsPublicLink {
+		q := imgURL.Query()
+		var rsp *gateway.AuthenticateResponse
+		if q.Get("signature") != "" && q.Get("expiration") != "" {
+			// Handle pre-signed public links
+			sig := q.Get("signature")
+			exp := q.Get("expiration")
+			rsp, err = g.cs3Client.Authenticate(ctx, &gateway.AuthenticateRequest{
+				Type:         "publicshares",
+				ClientId:     src.PublicLinkToken,
+				ClientSecret: strings.Join([]string{"signature", sig, exp}, "|"),
+			})
+		} else {
+			rsp, err = g.cs3Client.Authenticate(ctx, &gateway.AuthenticateRequest{
+				Type:     "publicshares",
+				ClientId: src.PublicLinkToken,
+				// We pass an empty password because we expect non pre-signed public links
+				// to not be password protected
+				ClientSecret: "password|",
+			})
+		}
+
+		if err != nil {
+			return "", merrors.InternalServerError(g.serviceID, "could not authenticate: %s", err.Error())
+		}
+		auth = rsp.Token
+		statPath = path.Join("/public", src.PublicLinkToken, req.Filepath)
+	} else {
+		auth = src.RevaAuthorization
+		statPath = req.Filepath
+	}
+	sRes, err := g.stat(statPath, auth)
+	if err != nil {
+		return "", err
+	}
+	tr := thumbnail.Request{
+		Resolution: image.Rect(0, 0, int(req.Width), int(req.Height)),
+		Generator:  generator,
+		Encoder:    encoder,
+		Checksum:   sRes.GetInfo().GetChecksum().GetSum(),
+	}
+
+	if key, exists := g.manager.CheckThumbnail(tr); exists {
+		return key, nil
+	}
+
+	if src.WebdavAuthorization != "" {
+		ctx = imgsource.ContextSetAuthorization(ctx, src.WebdavAuthorization)
+	}
+	imgURL.RawQuery = ""
+	r, err := g.webdavSource.Get(ctx, imgURL.String())
+	if err != nil {
+		return "", merrors.InternalServerError(g.serviceID, "could not get image from source: %s", err.Error())
+	}
+	defer r.Close() // nolint:errcheck
+	ppOpts := map[string]interface{}{
+		"fontFileMap": g.preprocessorOpts.TxtFontFileMap,
+	}
+	pp := preprocessor.ForType(sRes.GetInfo().GetMimeType(), ppOpts)
+	img, err := pp.Convert(r)
+	if img == nil || err != nil {
+		return "", merrors.InternalServerError(g.serviceID, "could not get image")
+	}
+
+	key, err := g.manager.Generate(tr, img)
+	if err != nil {
+		return "", err
+	}
+	return key, nil
+}
+
+func (g Thumbnail) stat(path, auth string) (*provider.StatResponse, error) {
+	ctx := metadata.AppendToOutgoingContext(context.Background(), revactx.TokenHeader, auth)
+
+	ref, err := storagespace.ParseReference(path)
+	if err != nil {
+		// If the path is not a spaces reference try to handle it like a plain
+		// path reference.
+		ref = provider.Reference{
+			Path: path,
+		}
+	}
+
+	req := &provider.StatRequest{Ref: &ref}
+	rsp, err := g.cs3Client.Stat(ctx, req)
+	if err != nil {
+		g.logger.Error().Err(err).Str("path", path).Msg("could not stat file")
+		return nil, merrors.InternalServerError(g.serviceID, "could not stat file: %s", err.Error())
+	}
+
+	if rsp.Status.Code != rpc.Code_CODE_OK {
+		switch rsp.Status.Code {
+		case rpc.Code_CODE_NOT_FOUND:
+			return nil, merrors.NotFound(g.serviceID, "could not stat file: %s", rsp.Status.Message)
+		default:
+			g.logger.Error().Str("status_message", rsp.Status.Message).Str("path", path).Msg("could not stat file")
+			return nil, merrors.InternalServerError(g.serviceID, "could not stat file: %s", rsp.Status.Message)
+		}
+	}
+	if rsp.Info.Type != provider.ResourceType_RESOURCE_TYPE_FILE {
+		return nil, merrors.BadRequest(g.serviceID, "Unsupported file type")
+	}
+	if rsp.Info.GetChecksum().GetSum() == "" {
+		g.logger.Error().Msg("resource info is missing checksum")
+		return nil, merrors.NotFound(g.serviceID, "resource info is missing a checksum")
+	}
+	if !thumbnail.IsMimeTypeSupported(rsp.Info.MimeType) {
+		return nil, merrors.NotFound(g.serviceID, "Unsupported file type")
+	}
+	return rsp, nil
+}

services/thumbnails/pkg/service/http/v0/instrument.go

@@ -0,0 +1,30 @@
+package svc
+
+import (
+	"net/http"
+
+	"github.com/owncloud/ocis/v2/services/thumbnails/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)
+}
+
+// GetThumbnail implements the Service interface.
+func (i instrument) GetThumbnail(w http.ResponseWriter, r *http.Request) {
+	i.next.GetThumbnail(w, r)
+}

services/thumbnails/pkg/service/http/v0/logging.go

@@ -0,0 +1,30 @@
+package svc
+
+import (
+	"net/http"
+
+	"github.com/owncloud/ocis/v2/ocis-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)
+}
+
+// GetThumbnail implements the Service interface.
+func (l logging) GetThumbnail(w http.ResponseWriter, r *http.Request) {
+	l.next.GetThumbnail(w, r)
+}

services/thumbnails/pkg/service/http/v0/option.go

@@ -0,0 +1,59 @@
+package svc
+
+import (
+	"net/http"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/log"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/thumbnail/storage"
+)
+
+// 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
+	ThumbnailStorage storage.Storage
+}
+
+// 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
+	}
+}
+
+// ThumbnailStorage provides a function to set the ThumbnailStorage option.
+func ThumbnailStorage(storage storage.Storage) Option {
+	return func(o *Options) {
+		o.ThumbnailStorage = storage
+	}
+}

services/thumbnails/pkg/service/http/v0/service.go

@@ -0,0 +1,123 @@
+package svc
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/golang-jwt/jwt/v4"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/log"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+	tjwt "github.com/owncloud/ocis/v2/services/thumbnails/pkg/service/jwt"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/thumbnail"
+)
+
+type contextKey string
+
+const (
+	keyContextKey contextKey = "key"
+)
+
+// Service defines the extension handlers.
+type Service interface {
+	ServeHTTP(http.ResponseWriter, *http.Request)
+	GetThumbnail(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...)
+
+	logger := options.Logger
+	resolutions, err := thumbnail.ParseResolutions(options.Config.Thumbnail.Resolutions)
+	if err != nil {
+		logger.Fatal().Err(err).Msg("resolutions not configured correctly")
+	}
+	svc := Thumbnails{
+		config: options.Config,
+		mux:    m,
+		logger: options.Logger,
+		manager: thumbnail.NewSimpleManager(
+			resolutions,
+			options.ThumbnailStorage,
+			logger,
+		),
+	}
+
+	m.Route(options.Config.HTTP.Root, func(r chi.Router) {
+		r.Use(svc.TransferTokenValidator)
+		r.Get("/data", svc.GetThumbnail)
+	})
+
+	return svc
+}
+
+// Thumbnails implements the business logic for Service.
+type Thumbnails struct {
+	config  *config.Config
+	logger  log.Logger
+	mux     *chi.Mux
+	manager thumbnail.Manager
+}
+
+// ServeHTTP implements the Service interface.
+func (s Thumbnails) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	s.mux.ServeHTTP(w, r)
+}
+
+// GetThumbnail implements the Service interface.
+func (s Thumbnails) GetThumbnail(w http.ResponseWriter, r *http.Request) {
+	key := r.Context().Value(keyContextKey).(string)
+
+	thumbnail, err := s.manager.GetThumbnail(key)
+	if err != nil {
+		s.logger.Error().
+			Err(err).
+			Str("key", key).
+			Msg("could not get the thumbnail")
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	w.Header().Set("Content-Length", strconv.Itoa(len(thumbnail)))
+	if _, err = w.Write(thumbnail); err != nil {
+		s.logger.Error().
+			Err(err).
+			Str("key", key).
+			Msg("could not write the thumbnail response")
+	}
+}
+
+func (s Thumbnails) TransferTokenValidator(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		tokenString := r.Header.Get("Transfer-Token")
+		token, err := jwt.ParseWithClaims(tokenString, &tjwt.ThumbnailClaims{}, func(token *jwt.Token) (interface{}, error) {
+			if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+				return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
+			}
+			return []byte(s.config.Thumbnail.TransferSecret), nil
+		})
+		if err != nil {
+			s.logger.Error().
+				Err(err).
+				Str("transfer-token", tokenString).
+				Msg("failed to parse transfer token")
+			w.WriteHeader(http.StatusUnauthorized)
+			return
+		}
+
+		if claims, ok := token.Claims.(*tjwt.ThumbnailClaims); ok && token.Valid {
+			ctx := context.WithValue(r.Context(), keyContextKey, claims.Key)
+			next.ServeHTTP(w, r.WithContext(ctx))
+			return
+		}
+		w.WriteHeader(http.StatusUnauthorized)
+	})
+}

services/thumbnails/pkg/service/http/v0/tracing.go

@@ -0,0 +1,28 @@
+package svc
+
+import (
+	"net/http"
+
+	"github.com/owncloud/ocis/v2/ocis-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)
+}
+
+// GetThumbnail implements the Service interface.
+func (t tracing) GetThumbnail(w http.ResponseWriter, r *http.Request) {
+	t.next.GetThumbnail(w, r)
+}

services/thumbnails/pkg/service/jwt/jwt.go

@@ -0,0 +1,8 @@
+package jwt
+
+import "github.com/golang-jwt/jwt/v4"
+
+type ThumbnailClaims struct {
+	jwt.RegisteredClaims
+	Key string `json:"key"`
+}

services/thumbnails/pkg/thumbnail/encoding.go

@@ -0,0 +1,112 @@
+package thumbnail
+
+import (
+	"errors"
+	"image"
+	"image/gif"
+	"image/jpeg"
+	"image/png"
+	"io"
+	"strings"
+)
+
+const (
+	typePng  = "png"
+	typeJpg  = "jpg"
+	typeJpeg = "jpeg"
+	typeGif  = "gif"
+)
+
+var (
+	// ErrInvalidType represents the error when a type can't be encoded.
+	ErrInvalidType = errors.New("can't encode this type")
+	// ErrNoEncoderForType represents the error when an encoder couldn't be found for a type.
+	ErrNoEncoderForType = errors.New("no encoder for this type found")
+)
+
+// Encoder encodes the thumbnail to a specific format.
+type Encoder interface {
+	// Encode encodes the image to a format.
+	Encode(io.Writer, interface{}) error
+	// Types returns the formats suffixes.
+	Types() []string
+	// MimeType returns the mimetype used by the encoder.
+	MimeType() string
+}
+
+// PngEncoder encodes to png
+type PngEncoder struct{}
+
+// Encode encodes to png format
+func (e PngEncoder) Encode(w io.Writer, img interface{}) error {
+	m, ok := img.(image.Image)
+	if !ok {
+		return ErrInvalidType
+	}
+	return png.Encode(w, m)
+}
+
+// Types returns the png suffix
+func (e PngEncoder) Types() []string {
+	return []string{typePng}
+}
+
+// MimeType returns the mimetype for png files.
+func (e PngEncoder) MimeType() string {
+	return "image/png"
+}
+
+// JpegEncoder encodes to jpg.
+type JpegEncoder struct{}
+
+// Encode encodes to jpg
+func (e JpegEncoder) Encode(w io.Writer, img interface{}) error {
+	m, ok := img.(image.Image)
+	if !ok {
+		return ErrInvalidType
+	}
+	return jpeg.Encode(w, m, nil)
+}
+
+// Types returns the jpg suffixes.
+func (e JpegEncoder) Types() []string {
+	return []string{typeJpeg, typeJpg}
+}
+
+// MimeType returns the mimetype for jpg files.
+func (e JpegEncoder) MimeType() string {
+	return "image/jpeg"
+}
+
+type GifEncoder struct{}
+
+func (e GifEncoder) Encode(w io.Writer, img interface{}) error {
+	g, ok := img.(*gif.GIF)
+	if !ok {
+		return ErrInvalidType
+	}
+	return gif.EncodeAll(w, g)
+}
+
+func (e GifEncoder) Types() []string {
+	return []string{typeGif}
+}
+
+func (e GifEncoder) MimeType() string {
+	return "image/gif"
+}
+
+// EncoderForType returns the encoder for a given file type
+// or nil if the type is not supported.
+func EncoderForType(fileType string) (Encoder, error) {
+	switch strings.ToLower(fileType) {
+	case typePng:
+		return PngEncoder{}, nil
+	case typeJpg, typeJpeg:
+		return JpegEncoder{}, nil
+	case typeGif:
+		return GifEncoder{}, nil
+	default:
+		return nil, ErrNoEncoderForType
+	}
+}

services/thumbnails/pkg/thumbnail/encoding_test.go

@@ -0,0 +1,22 @@
+package thumbnail
+
+import "testing"
+
+func TestEncoderForType(t *testing.T) {
+	table := map[string]Encoder{
+		"jpg":     JpegEncoder{},
+		"JPG":     JpegEncoder{},
+		"jpeg":    JpegEncoder{},
+		"JPEG":    JpegEncoder{},
+		"png":     PngEncoder{},
+		"PNG":     PngEncoder{},
+		"invalid": nil,
+	}
+
+	for k, v := range table {
+		e, _ := EncoderForType(k)
+		if e != v {
+			t.Fail()
+		}
+	}
+}

services/thumbnails/pkg/thumbnail/generator.go

@@ -0,0 +1,88 @@
+package thumbnail
+
+import (
+	"errors"
+	"image"
+	"image/color"
+	"image/draw"
+	"image/gif"
+	"strings"
+
+	"github.com/disintegration/imaging"
+)
+
+var (
+	// ErrInvalidType represents the error when a type can't be encoded.
+	ErrInvalidType2 = errors.New("can't encode this type")
+	// ErrNoGeneratorForType represents the error when no generator could be found for a type.
+	ErrNoGeneratorForType = errors.New("no generator for this type found")
+)
+
+type Generator interface {
+	GenerateThumbnail(image.Rectangle, interface{}) (interface{}, error)
+}
+
+type SimpleGenerator struct{}
+
+func (g SimpleGenerator) GenerateThumbnail(size image.Rectangle, img interface{}) (interface{}, error) {
+	m, ok := img.(image.Image)
+	if !ok {
+		return nil, ErrInvalidType2
+	}
+
+	return imaging.Thumbnail(m, size.Dx(), size.Dy(), imaging.Lanczos), nil
+}
+
+type GifGenerator struct{}
+
+func (g GifGenerator) GenerateThumbnail(size image.Rectangle, img interface{}) (interface{}, error) {
+	// Code inspired by https://github.com/willnorris/gifresize/blob/db93a7e1dcb1c279f7eeb99cc6d90b9e2e23e871/gifresize.go
+
+	m, ok := img.(*gif.GIF)
+	if !ok {
+		return nil, ErrInvalidType2
+	}
+	// Create a new RGBA image to hold the incremental frames.
+	srcX, srcY := m.Config.Width, m.Config.Height
+	b := image.Rect(0, 0, srcX, srcY)
+	tmp := image.NewRGBA(b)
+
+	for i, frame := range m.Image {
+		bounds := frame.Bounds()
+		prev := tmp
+		draw.Draw(tmp, bounds, frame, bounds.Min, draw.Over)
+		scaled := imaging.Resize(tmp, size.Dx(), size.Dy(), imaging.Lanczos)
+		m.Image[i] = g.imageToPaletted(scaled, frame.Palette)
+
+		switch m.Disposal[i] {
+		case gif.DisposalBackground:
+			tmp = image.NewRGBA(b)
+		case gif.DisposalPrevious:
+			tmp = prev
+		}
+	}
+	m.Config.Width = size.Dx()
+	m.Config.Height = size.Dy()
+
+	return m, nil
+}
+
+func (g GifGenerator) imageToPaletted(img image.Image, p color.Palette) *image.Paletted {
+	b := img.Bounds()
+	pm := image.NewPaletted(b, p)
+	draw.FloydSteinberg.Draw(pm, b, img, image.Point{})
+	return pm
+}
+
+// GeneratorForType returns the generator for a given file type
+// or nil if the type is not supported.
+func GeneratorForType(fileType string) (Generator, error) {
+	switch strings.ToLower(fileType) {
+	case typePng, typeJpg, typeJpeg:
+		return SimpleGenerator{}, nil
+	case typeGif:
+		return GifGenerator{}, nil
+	default:
+		return nil, ErrNoEncoderForType
+	}
+}

services/thumbnails/pkg/thumbnail/imgsource/cs3.go

@@ -0,0 +1,97 @@
+package imgsource
+
+import (
+	"context"
+	"crypto/tls"
+	"fmt"
+	"io"
+	"net/http"
+
+	gateway "github.com/cs3org/go-cs3apis/cs3/gateway/v1beta1"
+	rpc "github.com/cs3org/go-cs3apis/cs3/rpc/v1beta1"
+	provider "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1"
+	revactx "github.com/cs3org/reva/v2/pkg/ctx"
+	"github.com/cs3org/reva/v2/pkg/rhttp"
+	"github.com/cs3org/reva/v2/pkg/storagespace"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+	"github.com/pkg/errors"
+	"google.golang.org/grpc/metadata"
+)
+
+const (
+	// "github.com/cs3org/reva/v2/internal/http/services/datagateway" is internal so we redeclare it here
+	// TokenTransportHeader holds the header key for the reva transfer token
+	TokenTransportHeader = "X-Reva-Transfer"
+)
+
+type CS3 struct {
+	client   gateway.GatewayAPIClient
+	insecure bool
+}
+
+func NewCS3Source(cfg config.Thumbnail, c gateway.GatewayAPIClient) CS3 {
+	return CS3{
+		client:   c,
+		insecure: cfg.CS3AllowInsecure,
+	}
+}
+
+// Get downloads the file from a cs3 service
+// The caller MUST make sure to close the returned ReadCloser
+func (s CS3) Get(ctx context.Context, path string) (io.ReadCloser, error) {
+	auth, ok := ContextGetAuthorization(ctx)
+	if !ok {
+		return nil, errors.New("cs3source: authorization missing")
+	}
+	ref, err := storagespace.ParseReference(path)
+	if err != nil {
+		// If the path is not a spaces reference try to handle it like a plain
+		// path reference.
+		ref = provider.Reference{
+			Path: path,
+		}
+	}
+	ctx = metadata.AppendToOutgoingContext(context.Background(), revactx.TokenHeader, auth)
+	rsp, err := s.client.InitiateFileDownload(ctx, &provider.InitiateFileDownloadRequest{Ref: &ref})
+
+	if err != nil {
+		return nil, err
+	}
+
+	if rsp.Status.Code != rpc.Code_CODE_OK {
+		return nil, fmt.Errorf("could not load image: %s", rsp.Status.Message)
+	}
+	var ep, tk string
+	for _, p := range rsp.Protocols {
+		if p.Protocol == "spaces" {
+			ep, tk = p.DownloadEndpoint, p.Token
+			break
+		}
+	}
+	if (ep == "" || tk == "") && len(rsp.Protocols) > 0 {
+		ep, tk = rsp.Protocols[0].DownloadEndpoint, rsp.Protocols[0].Token
+	}
+
+	httpReq, err := rhttp.NewRequest(ctx, "GET", ep, nil)
+	if err != nil {
+		return nil, err
+	}
+	httpReq.Header.Set(revactx.TokenHeader, auth)
+	httpReq.Header.Set(TokenTransportHeader, tk)
+
+	http.DefaultTransport.(*http.Transport).TLSClientConfig = &tls.Config{
+		InsecureSkipVerify: s.insecure, //nolint:gosec
+	}
+	client := &http.Client{}
+
+	resp, err := client.Do(httpReq) // nolint:bodyclose
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("could not get the image \"%s\". Request returned with statuscode %d ", path, resp.StatusCode)
+	}
+
+	return resp.Body, nil
+}

services/thumbnails/pkg/thumbnail/imgsource/imgsource.go

@@ -0,0 +1,31 @@
+package imgsource
+
+import (
+	"context"
+	"io"
+)
+
+type key int
+
+const (
+	auth key = iota
+)
+
+// Source defines the interface for image sources
+type Source interface {
+	Get(ctx context.Context, path string) (io.ReadCloser, error)
+}
+
+// ContextSetAuthorization puts the authorization in the context.
+func ContextSetAuthorization(parent context.Context, authorization string) context.Context {
+	return context.WithValue(parent, auth, authorization)
+}
+
+// ContextGetAuthorization gets the authorization from the context.
+func ContextGetAuthorization(ctx context.Context) (string, bool) {
+	val := ctx.Value(auth)
+	if val == nil {
+		return "", false
+	}
+	return val.(string), true
+}

services/thumbnails/pkg/thumbnail/imgsource/webdav.go

@@ -0,0 +1,54 @@
+package imgsource
+
+import (
+	"context"
+	"crypto/tls"
+	"fmt"
+	_ "image/gif"  // Import the gif package so that image.Decode can understand gifs
+	_ "image/jpeg" // Import the jpeg package so that image.Decode can understand jpegs
+	_ "image/png"  // Import the png package so that image.Decode can understand pngs
+	"io"
+	"net/http"
+
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+	"github.com/pkg/errors"
+)
+
+// NewWebDavSource creates a new webdav instance.
+func NewWebDavSource(cfg config.Thumbnail) WebDav {
+	return WebDav{
+		insecure: cfg.WebdavAllowInsecure,
+	}
+}
+
+// WebDav implements the Source interface for webdav services
+type WebDav struct {
+	insecure bool
+}
+
+// Get downloads the file from a webdav service
+// The caller MUST make sure to close the returned ReadCloser
+func (s WebDav) Get(ctx context.Context, url string) (io.ReadCloser, error) {
+	req, err := http.NewRequest(http.MethodGet, url, nil)
+	if err != nil {
+		return nil, errors.Wrapf(err, `could not get the image "%s"`, url)
+	}
+
+	http.DefaultTransport.(*http.Transport).TLSClientConfig = &tls.Config{InsecureSkipVerify: s.insecure} //nolint:gosec
+
+	if auth, ok := ContextGetAuthorization(ctx); ok {
+		req.Header.Add("Authorization", auth)
+	}
+
+	client := &http.Client{}
+	resp, err := client.Do(req) // nolint:bodyclose
+	if err != nil {
+		return nil, errors.Wrapf(err, `could not get the image "%s"`, url)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("could not get the image \"%s\". Request returned with statuscode %d ", url, resp.StatusCode)
+	}
+
+	return resp.Body, nil
+}

services/thumbnails/pkg/thumbnail/resolutions.go

@@ -0,0 +1,101 @@
+package thumbnail
+
+import (
+	"fmt"
+	"image"
+	"math"
+	"strconv"
+	"strings"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_resolutionSeparator = "x"
+)
+
+// ParseResolution returns an image.Rectangle representing the resolution given as a string
+func ParseResolution(s string) (image.Rectangle, error) {
+	parts := strings.Split(s, _resolutionSeparator)
+	if len(parts) != 2 {
+		return image.Rectangle{}, fmt.Errorf("failed to parse resolution: %s. Expected format <width>x<height>", s)
+	}
+	width, err := strconv.Atoi(parts[0])
+	if err != nil {
+		return image.Rectangle{}, fmt.Errorf("width: %s has an invalid value. Expected an integer", parts[0])
+	}
+	height, err := strconv.Atoi(parts[1])
+	if err != nil {
+		return image.Rectangle{}, fmt.Errorf("height: %s has an invalid value. Expected an integer", parts[1])
+	}
+	return image.Rect(0, 0, width, height), nil
+}
+
+// Resolutions is a list of image.Rectangle representing resolutions.
+type Resolutions []image.Rectangle
+
+// ParseResolutions creates an instance of Resolutions from resolution strings.
+func ParseResolutions(strs []string) (Resolutions, error) {
+	rs := make(Resolutions, 0, len(strs))
+	for _, s := range strs {
+		r, err := ParseResolution(s)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not parse resolutions")
+		}
+		rs = append(rs, r)
+	}
+	return rs, nil
+}
+
+// ClosestMatch returns the resolution which is closest to the provided resolution.
+// If there is no exact match the resolution will be the next higher one.
+// If the given resolution is bigger than all available resolutions the biggest available one is used.
+func (rs Resolutions) ClosestMatch(requested image.Rectangle, sourceSize image.Rectangle) image.Rectangle {
+	isLandscape := sourceSize.Dx() > sourceSize.Dy()
+	sourceLen := dimensionLength(sourceSize, isLandscape)
+	requestedLen := dimensionLength(requested, isLandscape)
+	isSourceSmaller := sourceLen < requestedLen
+
+	// We don't want to scale images up.
+	if isSourceSmaller {
+		return sourceSize
+	}
+
+	if len(rs) == 0 {
+		return requested
+	}
+
+	var match image.Rectangle
+	// Since we want to search for the smallest difference we start with the highest possible number
+	minDiff := math.MaxInt32
+
+	for _, current := range rs {
+		cLen := dimensionLength(current, isLandscape)
+		diff := requestedLen - cLen
+		if diff > 0 {
+			// current is smaller
+			continue
+		}
+
+		// Convert diff to positive value
+		// Multiplying by -1 is safe since we aren't getting positive numbers here
+		// because of the check above
+		absDiff := diff * -1
+		if absDiff < minDiff {
+			minDiff = absDiff
+			match = current
+		}
+	}
+
+	if (match == image.Rectangle{}) {
+		match = rs[len(rs)-1]
+	}
+	return match
+}
+
+func dimensionLength(rect image.Rectangle, isLandscape bool) int {
+	if isLandscape {
+		return rect.Dx()
+	}
+	return rect.Dy()
+}

services/thumbnails/pkg/thumbnail/resolutions_test.go

@@ -0,0 +1,121 @@
+package thumbnail
+
+import (
+	"image"
+	"testing"
+)
+
+func TestInitWithEmptyArray(t *testing.T) {
+	rs, err := ParseResolutions([]string{})
+	if err != nil {
+		t.Errorf("Init with an empty array should not fail. Error: %s.\n", err.Error())
+	}
+	if len(rs) != 0 {
+		t.Error("Init with an empty array should return an empty Resolutions instance.\n")
+	}
+}
+
+func TestInitWithNil(t *testing.T) {
+	rs, err := ParseResolutions(nil)
+	if err != nil {
+		t.Errorf("Init with nil parameter should not fail. Error: %s.\n", err.Error())
+	}
+	if len(rs) != 0 {
+		t.Error("Init with nil parameter should return an empty Resolutions instance.\n")
+	}
+}
+
+func TestInitWithInvalidValuesInArray(t *testing.T) {
+	_, err := ParseResolutions([]string{"invalid"})
+	if err == nil {
+		t.Error("Init with invalid parameter should fail.\n")
+	}
+}
+
+func TestInit(t *testing.T) {
+	rs, err := ParseResolutions([]string{"16x16"})
+	if err != nil {
+		t.Errorf("Init with valid parameter should not fail. Error: %s.\n", err.Error())
+	}
+	if len(rs) != 1 {
+		t.Errorf("resolutions has size %d, expected size %d.\n", len(rs), 1)
+	}
+}
+
+func TestInitWithMultipleResolutions(t *testing.T) {
+	rStrs := []string{"16x16", "32x32", "64x64", "128x128"}
+	rs, err := ParseResolutions(rStrs)
+	if err != nil {
+		t.Errorf("Init with valid parameter should not fail. Error: %s.\n", err.Error())
+	}
+	if len(rs) != len(rStrs) {
+		t.Errorf("resolutions has size %d, expected size %d.\n", len(rs), len(rStrs))
+	}
+}
+
+func TestClosestMatchWithEmptyResolutions(t *testing.T) {
+	rs, _ := ParseResolutions(nil)
+	want := image.Rect(0, 0, 24, 24)
+	imgSize := image.Rect(0, 0, 24, 24)
+
+	r := rs.ClosestMatch(want, imgSize)
+	if r.Dx() != want.Dx() || r.Dy() != want.Dy() {
+		t.Errorf("ClosestMatch from empty resolutions should return the given resolution")
+	}
+}
+
+func TestClosestMatch(t *testing.T) {
+	rs, _ := ParseResolutions([]string{"16x16", "24x24", "32x32", "64x64", "128x128"})
+
+	testData := [][]image.Rectangle{
+		{image.Rect(0, 0, 17, 17), image.Rect(0, 0, 1920, 1080), image.Rect(0, 0, 24, 24)},
+		{image.Rect(0, 0, 12, 17), image.Rect(0, 0, 1080, 1920), image.Rect(0, 0, 24, 24)},
+		{image.Rect(0, 0, 24, 24), image.Rect(0, 0, 1920, 1080), image.Rect(0, 0, 24, 24)},
+		{image.Rect(0, 0, 20, 20), image.Rect(0, 0, 1920, 1080), image.Rect(0, 0, 24, 24)},
+		{image.Rect(0, 0, 20, 80), image.Rect(0, 0, 1080, 1920), image.Rect(0, 0, 128, 128)},
+		{image.Rect(0, 0, 80, 20), image.Rect(0, 0, 1920, 1080), image.Rect(0, 0, 128, 128)},
+		{image.Rect(0, 0, 48, 48), image.Rect(0, 0, 1920, 1080), image.Rect(0, 0, 64, 64)},
+		{image.Rect(0, 0, 1024, 1024), image.Rect(0, 0, 1920, 1080), image.Rect(0, 0, 128, 128)},
+		{image.Rect(0, 0, 1920, 1080), image.Rect(0, 0, 256, 36), image.Rect(0, 0, 256, 36)},
+	}
+
+	for _, row := range testData {
+		given := row[0]
+		imgSize := row[1]
+		expected := row[2]
+
+		match := rs.ClosestMatch(given, imgSize)
+
+		if match != expected {
+			t.Errorf("Expected resolution %dx%d got %dx%d", expected.Dx(), expected.Dy(), match.Dx(), match.Dy())
+		}
+	}
+}
+
+func TestParseWithEmptyString(t *testing.T) {
+	if _, err := ParseResolution(""); err == nil {
+		t.Error("Parse with empty string should return an error.")
+	}
+}
+
+func TestParseWithInvalidWidth(t *testing.T) {
+	_, err := ParseResolution("invalidx42")
+	if err == nil {
+		t.Error("Parse with invalid width should return an error.")
+	}
+}
+
+func TestParseWithInvalidHeight(t *testing.T) {
+	_, err := ParseResolution("42xinvalid")
+	if err == nil {
+		t.Error("Parse with invalid height should return an error.")
+	}
+}
+
+func TestParseResolution(t *testing.T) {
+	rStr := "42x23"
+	r, _ := ParseResolution(rStr)
+	if r.Dx() != 42 || r.Dy() != 23 {
+		t.Errorf("Expected resolution %s got %s", rStr, r.String())
+	}
+}

services/thumbnails/pkg/thumbnail/storage/filesystem.go

@@ -0,0 +1,88 @@
+package storage
+
+import (
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strconv"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/log"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+	"github.com/pkg/errors"
+)
+
+const (
+	filesDir = "files"
+)
+
+// NewFileSystemStorage creates a new instance of FileSystem
+func NewFileSystemStorage(cfg config.FileSystemStorage, logger log.Logger) FileSystem {
+	return FileSystem{
+		root:   cfg.RootDirectory,
+		logger: logger,
+	}
+}
+
+// FileSystem represents a storage for the thumbnails using the local file system.
+type FileSystem struct {
+	root   string
+	logger log.Logger
+}
+
+func (s FileSystem) Stat(key string) bool {
+	img := filepath.Join(s.root, filesDir, key)
+	if _, err := os.Stat(img); err != nil {
+		return false
+	}
+	return true
+}
+
+func (s FileSystem) Get(key string) ([]byte, error) {
+	img := filepath.Join(s.root, filesDir, key)
+	content, err := os.ReadFile(img)
+	if err != nil {
+		if !errors.Is(err, fs.ErrNotExist) {
+			s.logger.Debug().Str("err", err.Error()).Str("key", key).Msg("could not load thumbnail from store")
+		}
+		return nil, err
+	}
+	return content, nil
+}
+
+func (s FileSystem) Put(key string, img []byte) error {
+	imgPath := filepath.Join(s.root, filesDir, key)
+	dir := filepath.Dir(imgPath)
+	if err := os.MkdirAll(dir, 0700); err != nil {
+		return errors.Wrapf(err, "error while creating directory %s", dir)
+	}
+
+	if _, err := os.Stat(imgPath); os.IsNotExist(err) {
+		f, err := os.Create(imgPath)
+		if err != nil {
+			return errors.Wrapf(err, "could not create file \"%s\"", key)
+		}
+		defer f.Close()
+
+		if _, err = f.Write(img); err != nil {
+			return errors.Wrapf(err, "could not write to file \"%s\"", key)
+		}
+	}
+
+	return nil
+}
+
+// BuildKey generate the unique key for a thumbnail.
+// The key is structure as follows:
+//
+// <first two letters of checksum>/<next two letters of checksum>/<rest of checksum>/<width>x<height>.<filetype>
+//
+// e.g. 97/9f/4c8db98f7b82e768ef478d3c8612/500x300.png
+//
+// The key also represents the path to the thumbnail in the filesystem under the configured root directory.
+func (s FileSystem) BuildKey(r Request) string {
+	checksum := r.Checksum
+	filetype := r.Types[0]
+	filename := strconv.Itoa(r.Resolution.Dx()) + "x" + strconv.Itoa(r.Resolution.Dy()) + "." + filetype
+
+	return filepath.Join(checksum[:2], checksum[2:4], checksum[4:], filename)
+}

services/thumbnails/pkg/thumbnail/storage/inmemory.go

@@ -0,0 +1,44 @@
+package storage
+
+import (
+	"strings"
+)
+
+// NewInMemoryStorage creates a new InMemory instance.
+func NewInMemoryStorage() InMemory {
+	return InMemory{
+		store: make(map[string][]byte),
+	}
+}
+
+// InMemory represents an in memory storage for thumbnails
+// Can be used during development
+type InMemory struct {
+	store map[string][]byte
+}
+
+func (s InMemory) Stat(key string) bool {
+	_, exists := s.store[key]
+	return exists
+}
+
+// Get loads the thumbnail from memory.
+func (s InMemory) Get(key string) ([]byte, error) {
+	return s.store[key], nil
+}
+
+// Set stores the thumbnail in memory.
+func (s InMemory) Put(key string, thumbnail []byte) error {
+	s.store[key] = thumbnail
+	return nil
+}
+
+// BuildKey generates a unique key to store and retrieve the thumbnail.
+func (s InMemory) BuildKey(r Request) string {
+	parts := []string{
+		r.Checksum,
+		r.Resolution.String(),
+		strings.Join(r.Types, ","),
+	}
+	return strings.Join(parts, "+")
+}

services/thumbnails/pkg/thumbnail/storage/storage.go

@@ -0,0 +1,26 @@
+package storage
+
+import (
+	"image"
+)
+
+// Request combines different attributes needed for storage operations.
+type Request struct {
+	// The checksum of the source file
+	// Will be used to determine if a thumbnail exists
+	Checksum string
+	// Types provided by the encoder.
+	// Contains the mimetypes of the thumbnail.
+	// In case of jpg/jpeg it will contain both.
+	Types []string
+	// The resolution of the thumbnail
+	Resolution image.Rectangle
+}
+
+// Storage defines the interface for a thumbnail store.
+type Storage interface {
+	Stat(string) bool
+	Get(string) ([]byte, error)
+	Put(string, []byte) error
+	BuildKey(Request) string
+}

services/thumbnails/pkg/thumbnail/thumbnail.go

@@ -0,0 +1,111 @@
+package thumbnail
+
+import (
+	"bytes"
+	"image"
+	"image/gif"
+	"mime"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/log"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/thumbnail/storage"
+)
+
+var (
+	// SupportedMimeTypes contains a all mimetypes which are supported by the thumbnailer.
+	SupportedMimeTypes = map[string]struct{}{
+		"image/png":  {},
+		"image/jpg":  {},
+		"image/jpeg": {},
+		"image/gif":  {},
+		"text/plain": {},
+	}
+)
+
+// Request bundles information needed to generate a thumbnail for afile
+type Request struct {
+	Resolution image.Rectangle
+	Encoder    Encoder
+	Generator  Generator
+	Checksum   string
+}
+
+// Manager is responsible for generating thumbnails
+type Manager interface {
+	// Generate creates a thumbnail and stores it.
+	// The function returns a key with which the actual file can be retrieved.
+	Generate(Request, interface{}) (string, error)
+	// CheckThumbnail checks if a thumbnail with the requested attributes exists.
+	// The function will return a status if the file exists and the key to the file.
+	CheckThumbnail(Request) (string, bool)
+	// GetThumbnail will load the thumbnail from the storage and return its content.
+	GetThumbnail(key string) ([]byte, error)
+}
+
+// NewSimpleManager creates a new instance of SimpleManager
+func NewSimpleManager(resolutions Resolutions, storage storage.Storage, logger log.Logger) SimpleManager {
+	return SimpleManager{
+		storage:     storage,
+		logger:      logger,
+		resolutions: resolutions,
+	}
+}
+
+// SimpleManager is a simple implementation of Manager
+type SimpleManager struct {
+	storage     storage.Storage
+	logger      log.Logger
+	resolutions Resolutions
+}
+
+func (s SimpleManager) Generate(r Request, img interface{}) (string, error) {
+	var match image.Rectangle
+	switch m := img.(type) {
+	case *gif.GIF:
+		match = s.resolutions.ClosestMatch(r.Resolution, m.Image[0].Bounds())
+	case image.Image:
+		match = s.resolutions.ClosestMatch(r.Resolution, m.Bounds())
+	}
+
+	thumbnail, err := r.Generator.GenerateThumbnail(match, img)
+	if err != nil {
+		return "", err
+	}
+
+	buf := new(bytes.Buffer)
+	if err := r.Encoder.Encode(buf, thumbnail); err != nil {
+		return "", err
+	}
+
+	k := s.storage.BuildKey(mapToStorageRequest(r))
+	if err := s.storage.Put(k, buf.Bytes()); err != nil {
+		s.logger.Error().Err(err).Msg("could not store thumbnail")
+		return "", err
+	}
+	return k, nil
+}
+
+func (s SimpleManager) CheckThumbnail(r Request) (string, bool) {
+	k := s.storage.BuildKey(mapToStorageRequest(r))
+	return k, s.storage.Stat(k)
+}
+
+func (s SimpleManager) GetThumbnail(key string) ([]byte, error) {
+	return s.storage.Get(key)
+}
+
+func mapToStorageRequest(r Request) storage.Request {
+	return storage.Request{
+		Checksum:   r.Checksum,
+		Resolution: r.Resolution,
+		Types:      r.Encoder.Types(),
+	}
+}
+
+func IsMimeTypeSupported(m string) bool {
+	mimeType, _, err := mime.ParseMediaType(m)
+	if err != nil {
+		return false
+	}
+	_, supported := SupportedMimeTypes[mimeType]
+	return supported
+}

services/thumbnails/pkg/thumbnail/thumbnail_test.go

@@ -0,0 +1,47 @@
+package thumbnail
+
+import (
+	"image"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/owncloud/ocis/v2/ocis-pkg/log"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/thumbnail/storage"
+)
+
+type NoOpManager struct {
+	storage.Storage
+}
+
+func (m NoOpManager) BuildKey(r storage.Request) string {
+	return ""
+}
+
+func (m NoOpManager) Set(username, key string, thumbnail []byte) error {
+	return nil
+}
+
+func BenchmarkGet(b *testing.B) {
+
+	sut := NewSimpleManager(
+		Resolutions{},
+		NoOpManager{},
+		log.NewLogger(),
+	)
+
+	res, _ := ParseResolution("32x32")
+	req := Request{
+		Resolution: res,
+		Checksum:   "1872ade88f3013edeb33decd74a4f947",
+	}
+	cwd, _ := os.Getwd()
+	p := filepath.Join(cwd, "../../testdata/oc.png")
+	f, _ := os.Open(p)
+	defer f.Close()
+	img, ext, _ := image.Decode(f)
+	req.Encoder, _ = EncoderForType(ext)
+	for i := 0; i < b.N; i++ {
+		_, _ = sut.Generate(req, img)
+	}
+}

services/thumbnails/pkg/tracing/tracing.go

@@ -0,0 +1,23 @@
+package tracing
+
+import (
+	pkgtrace "github.com/owncloud/ocis/v2/ocis-pkg/tracing"
+	"github.com/owncloud/ocis/v2/services/thumbnails/pkg/config"
+	"go.opentelemetry.io/otel/trace"
+)
+
+var (
+	// TraceProvider is the global trace provider for the thumbnails service.
+	TraceProvider = trace.NewNoopTracerProvider()
+)
+
+func Configure(cfg *config.Config) error {
+	var err error
+	if cfg.Tracing.Enabled {
+		if TraceProvider, err = pkgtrace.GetTraceProvider(cfg.Tracing.Endpoint, cfg.Tracing.Collector, cfg.Service.Name, cfg.Tracing.Type); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}