145 lines
3.2 KiB
Go
145 lines
3.2 KiB
Go
package contented
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"code.ivysaur.me/thumbnail"
|
|
)
|
|
|
|
func getThumbnailerConfig(t byte) (*thumbnail.Config, error) {
|
|
// Modelled on what imgur.com offers
|
|
// @ref https://api.imgur.com/models/image#thumbs
|
|
|
|
opts := thumbnail.Config{
|
|
Aspect: thumbnail.FitOutside,
|
|
Output: thumbnail.Jpeg,
|
|
Scale: thumbnail.Bicubic,
|
|
}
|
|
|
|
switch t {
|
|
case 's':
|
|
opts.Width = 90
|
|
opts.Height = 90
|
|
case 'b':
|
|
opts.Width = 160
|
|
opts.Height = 160
|
|
case 't':
|
|
opts.Width = 160
|
|
opts.Height = 160
|
|
// thumbnail.ASPECT_RESPECT_MAX_DIMENSION_ONLY
|
|
case 'm':
|
|
opts.Width = 340
|
|
opts.Height = 340
|
|
// thumbnail.ASPECT_RESPECT_MAX_DIMENSION_ONLY
|
|
case 'l':
|
|
opts.Width = 640
|
|
opts.Height = 640
|
|
// thumbnail.ASPECT_RESPECT_MAX_DIMENSION_ONLY
|
|
case 'h':
|
|
opts.Width = 1024
|
|
opts.Height = 1024
|
|
// thumbnail.ASPECT_RESPECT_MAX_DIMENSION_ONLY
|
|
default:
|
|
return nil, errors.New("Unsupported thumbnail type (should be s/b/t/m/l/h)")
|
|
}
|
|
|
|
return &opts, nil
|
|
}
|
|
|
|
func (this *Server) handleThumb(w http.ResponseWriter, r *http.Request, thumbnailType byte, fileId string) {
|
|
ctx := r.Context()
|
|
|
|
opts, err := getThumbnailerConfig(thumbnailType)
|
|
if err != nil {
|
|
log.Printf("%s Thumbnail failed: %s\n", this.remoteIP(r), err.Error())
|
|
http.Error(w, err.Error(), 400)
|
|
return
|
|
}
|
|
|
|
// Only a limited number of thumbnails can be generated concurrently
|
|
select {
|
|
case <-this.thumbnailSem:
|
|
case <-r.Context().Done():
|
|
http.Error(w, r.Context().Err().Error(), 400) // probably won't be delivered anyway
|
|
return
|
|
}
|
|
defer func() { this.thumbnailSem <- struct{}{} }()
|
|
|
|
if ctx.Err() != nil {
|
|
// The request was already cancelled
|
|
return
|
|
}
|
|
|
|
t := thumbnail.NewThumbnailerEx(opts)
|
|
|
|
err = this.handleThumbInternal(ctx, w, t, fileId)
|
|
if err != nil {
|
|
log.Printf("%s Thumbnail failed: %s\n", this.remoteIP(r), err.Error())
|
|
|
|
w.Header().Set(`Location`, fmt.Sprintf(`/nothumb_%d.png`, opts.Height))
|
|
w.WriteHeader(302)
|
|
}
|
|
}
|
|
|
|
func (this *Server) handleThumbInternal(ctx context.Context, w http.ResponseWriter, t thumbnail.Thumbnailer, fileId string) error {
|
|
|
|
// Load metadata
|
|
m, err := this.Metadata(fileId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if m.FileSize > this.opts.MaxThumbSizeBytes {
|
|
return errors.New("Don't want to thumbnail very large files, sorry")
|
|
}
|
|
|
|
var filePath string
|
|
|
|
if this.opts.StorageType == STORAGE_LOCAL {
|
|
filePath = filepath.Join(this.opts.DataDirectory, m.FileHash)
|
|
|
|
} else if this.opts.StorageType == STORAGE_S3 {
|
|
// Need to temporarily download it for thumbnailing (slow and costs money)
|
|
|
|
destFh, err := os.CreateTemp("", "contented-thumbcache-*")
|
|
defer os.Remove(destFh.Name())
|
|
|
|
srcFh, err := this.ReadFile(ctx, m.FileHash)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
_, err = io.CopyN(destFh, srcFh, m.FileSize)
|
|
srcFh.Close()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
destFh.Seek(0, io.SeekStart)
|
|
filePath = destFh.Name()
|
|
|
|
} else {
|
|
panic("bad StorageType")
|
|
}
|
|
|
|
thumb, err := t.RenderFileAs(filePath, m.MimeType)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
w.Header().Set(`Cache-Control`, `max-age=31536000, immutable`)
|
|
w.Header().Set(`Content-Length`, fmt.Sprintf("%d", len(thumb)))
|
|
w.Header().Set(`Content-Type`, `image/jpeg`)
|
|
w.WriteHeader(200)
|
|
w.Write(thumb)
|
|
|
|
return nil
|
|
}
|