Fix: make thumbnails processor to work with spaces

Author: jessegeens

thumbnails/handler.go

@@ -26,6 +26,7 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"path"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -45,6 +46,7 @@ import (
 	"github.com/cs3org/reva/v3/pkg/rhttp/global"
 	"github.com/cs3org/reva/v3/pkg/rhttp/router"
 	"github.com/cs3org/reva/v3/pkg/sharedconf"
+	"github.com/cs3org/reva/v3/pkg/spaces"
 	"github.com/cs3org/reva/v3/pkg/storage/utils/downloader"
 	"github.com/cs3org/reva/v3/pkg/utils/cfg"
 	"github.com/pkg/errors"
@@ -143,22 +145,53 @@ func New(ctx context.Context, m map[string]interface{}) (global.Service, error)
 	return s, nil
 }
 
+func (s *Thumbnails) Handler() http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var head string
+
+		head, r.URL.Path = router.ShiftPath(r.URL.Path)
+		switch head {
+		case "files":
+			if !checkMethods(r, http.MethodGet) {
+				w.WriteHeader(http.StatusNotFound)
+				return
+			}
+			s.davUserContext(s.Thumbnail(w, r)).ServeHTTP(w, r)
+		case "public-files":
+			if !checkMethods(r, http.MethodGet, http.MethodHead) {
+				w.WriteHeader(http.StatusNotFound)
+				return
+			}
+			s.davPublicContext(s.Thumbnail(w, r)).ServeHTTP(w, r)
+		}
+	})
+}
+
 func (s *Thumbnails) davUserContext(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		ctx := r.Context()
+		log := appctx.GetLogger(ctx)
 
-		path := r.URL.Path
-		path, _ = url.PathUnescape(path)
+		urlPath, _ := url.PathUnescape(r.URL.Path)
+
+		storageSpaceID, resourcePath := router.ShiftPath(urlPath)
+		_, spacePath, ok := spaces.DecodeStorageSpaceID(storageSpaceID)
+		if !ok {
+			s.writeHTTPError(w, errtypes.NotFound(""))
+			return
+		}
+		resourcePath = path.Join(spacePath, resourcePath)
 
 		res, err := s.statRes(ctx, &provider.Reference{
-			Path: path,
+			Path: resourcePath,
 		})
 		if err != nil {
 			s.writeHTTPError(w, err)
 			return
 		}
 
 		ctx = ContextSetResource(ctx, res)
+		log.Info().Msgf("FindMe - set resource %s", res.Path)
 
 		next.ServeHTTP(w, r.WithContext(ctx))
 	})
@@ -365,12 +398,16 @@ func parseDimension(d, name string, defaultValue int) (int, error) {
 func (s *Thumbnails) Thumbnail(w http.ResponseWriter, r *http.Request) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		thumbReq, err := s.parseThumbnailRequest(r)
+		log := appctx.GetLogger(r.Context())
+		log.Info().Msgf("FindMe - Handling thumbnail request %s", thumbReq.File)
 		if err != nil {
 			s.writeHTTPError(w, err)
 			return
 		}
 
 		data, mimetype, err := s.thumbnail.GetThumbnail(r.Context(), thumbReq.File, thumbReq.ETag, thumbReq.Width, thumbReq.Height, thumbReq.OutputType)
+		log.Info().Msgf("FindMe - Got thumbnail for %s", thumbReq.File)
+
 		if err != nil {
 			s.writeHTTPError(w, err)
 			return
@@ -402,29 +439,6 @@ func (s *Thumbnails) writeHTTPError(w http.ResponseWriter, err error) {
 	_, _ = w.Write([]byte(err.Error()))
 }
 
-func (s *Thumbnails) Handler() http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		var head string
-
-		head, r.URL.Path = router.ShiftPath(r.URL.Path)
-		switch head {
-		case "files":
-			if !checkMethods(r, http.MethodGet) {
-				w.WriteHeader(http.StatusNotFound)
-				return
-			}
-			s.davUserContext(s.Thumbnail(w, r)).ServeHTTP(w, r)
-			return
-		case "public-files":
-			if !checkMethods(r, http.MethodGet, http.MethodHead) {
-				w.WriteHeader(http.StatusNotFound)
-				return
-			}
-			s.davPublicContext(s.Thumbnail(w, r)).ServeHTTP(w, r)
-		}
-	})
-}
-
 func checkMethods(r *http.Request, methods ...string) bool {
 	for _, m := range methods {
 		if r.Method == m {

thumbnails/manager/thumbnail.go

@@ -23,6 +23,8 @@ import (
 	"context"
 	"fmt"
 	"image"
+	"io"
+	"time"
 
 	"github.com/cernbox/reva-plugins/thumbnails/cache"
 	"github.com/cernbox/reva-plugins/thumbnails/cache/registry"
@@ -35,6 +37,10 @@ import (
 
 	// load all the cache drivers
 	_ "github.com/cernbox/reva-plugins/thumbnails/cache/loader"
+
+	_ "image/gif"
+	_ "image/jpeg"
+	_ "image/png"
 )
 
 // FileType is the output format of the thumbnail
@@ -99,30 +105,45 @@ func (t *Thumbnail) GetThumbnail(ctx context.Context, file, etag string, width,
 	log.Debug().Msg("thumbnails: cache miss")
 
 	// the thumbnail was not found in the cache
+	log.Debug().Msgf("thumbnails: starting download %s", file)
 	r, err := t.downloader.Download(ctx, file, "")
+	log.Debug().Msgf("thumbnails: finished download %s", file)
 	if err != nil {
 		return nil, "", errors.Wrap(err, "thumbnails: error downloading file "+file)
 	}
 	defer r.Close()
+	imgBody, err := io.ReadAll(r)
+	log.Debug().Msgf("thumbnails: finished read %s", file)
+
+	if err != nil {
+		log.Error().Err(err).Msg("Failed to read IO")
+		return nil, "", errors.Wrap(err, "thumbnails: failed to read file "+file)
+
+	}
+	img, err := decodeWithTimeout(ctx, imgBody, 2)
+	log.Debug().Err(err).Msgf("thumbnails: finished decoding %s", file)
 
-	img, _, err := image.Decode(r)
 	if err != nil {
 		return nil, "", errors.Wrap(err, "thumbnails: error decoding file "+file)
 	}
 
 	resolution := image.Rect(0, 0, width, height)
 	match := t.fixedResolutions.MatchOrResize(resolution, img.Bounds())
 	thumb := imaging.Thumbnail(img, match.Dx(), match.Dy(), imaging.Linear)
+	log.Debug().Msgf("thumbnails: finished resize %s", file)
 
 	var buf bytes.Buffer
 	format, opts := t.getEncoderFormat(outType)
 	err = imaging.Encode(&buf, thumb, format, opts...)
 	if err != nil {
 		return nil, "", errors.Wrap(err, "thumbnails: error encoding image")
 	}
+	log.Debug().Msgf("thumbnails: finished re-encoding %s", file)
 
 	data := buf.Bytes()
 	err = t.cache.Set(file, etag, width, height, data)
+	log.Debug().Msgf("thumbnails: set cache %s", file)
+
 	if err != nil {
 		log.Warn().Msg("failed to save data into the cache")
 	} else {
@@ -132,6 +153,38 @@ func (t *Thumbnail) GetThumbnail(ctx context.Context, file, etag string, width,
 	return data, getMimeType(outType), nil
 }
 
+func decodeWithTimeout(ctx context.Context, imgBody []byte, timeoutSec time.Duration) (image.Image, error) {
+	ctx, cancel := context.WithTimeout(ctx, timeoutSec*time.Second)
+	defer cancel()
+
+	resultCh := make(chan image.Image, 1)
+	errCh := make(chan error, 1)
+
+	go func() {
+		_, _, err := image.DecodeConfig(bytes.NewReader(imgBody))
+		if err != nil {
+			errCh <- err
+			return
+		}
+
+		img, _, err := image.Decode(bytes.NewReader(imgBody))
+		if err != nil {
+			errCh <- err
+			return
+		}
+		resultCh <- img
+	}()
+
+	select {
+	case <-ctx.Done():
+		return nil, ctx.Err() // context deadline exceeded
+	case err := <-errCh:
+		return nil, err
+	case img := <-resultCh:
+		return img, nil
+	}
+}
+
 func getMimeType(ttype FileType) string {
 	switch ttype {
 	case PNGType: