Initial commit

.gitignore

@@ -0,0 +1,3 @@
+.idea
+.DS_Store
+images

api/api.go

@@ -0,0 +1,113 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"github.com/gorilla/mux"
+	"image/jpeg"
+	"log"
+	"lorem/image"
+	"lorem/manager"
+	"net/http"
+	"strconv"
+)
+
+type Options struct {
+	MinWidth int
+	MaxWidth int
+	MinHeight int
+	MaxHeight int
+}
+
+const (
+	minSize = 8
+	maxSize = 2000
+)
+
+type API struct {
+	mngr *manager.Manager
+	pr image.Processor
+	opt *Options
+}
+
+func New(manager *manager.Manager, imageProcessor image.Processor, options *Options) *API {
+	if options == nil {
+		options = &Options{
+			MinWidth: minSize,
+			MinHeight: minSize,
+			MaxWidth: maxSize,
+			MaxHeight: maxSize,
+		}
+	}
+
+	return &API{
+		mngr: manager,
+		pr: imageProcessor,
+	}
+}
+
+func (a *API) SizeHandler(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+
+	vars := mux.Vars(r)
+
+	file := a.mngr.Pick(vars["category"])
+	if file == "" {
+		handleError(w, http.StatusNotFound, "category not found")
+		return
+	}
+
+	width, err := strconv.ParseInt(vars["width"], 10, 32)
+	if err != nil || width < 8 {
+		handleError(w, http.StatusBadRequest, "invalid width size")
+		return
+	}
+
+	height, err := strconv.ParseInt(vars["height"], 10, 32)
+	if err != nil || height < 8 {
+		handleError(w, http.StatusBadRequest, "invalid height size")
+		return
+	}
+
+	img, err := image.Decode(file)
+	if err != nil {
+		handleError(w, http.StatusInternalServerError, "internal error")
+		return
+	}
+
+	img = a.pr.CropCenter(*img, int(width), int(height))
+
+
+	buffer := new(bytes.Buffer)
+	if err := jpeg.Encode(buffer, *img, nil); err != nil {
+		log.Println("unable to encode image.")
+		return
+	}
+
+	w.Header().Set("Content-Type", "image/jpeg")
+	w.Header().Set("Content-Length", strconv.Itoa(len(buffer.Bytes())))
+	if _, err := w.Write(buffer.Bytes()); err != nil {
+		log.Println("unable to write image.")
+		return
+	}
+}
+
+func (a *API) NotFound(w http.ResponseWriter, r *http.Request) {
+	handleError(w, http.StatusNotFound, "not found")
+}
+
+func handleError(w http.ResponseWriter, code int, msg string) {
+	b, err := json.Marshal(&Error{
+		Message: msg,
+	})
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		log.Printf("error while marshaling response: %s", err)
+		return
+	}
+
+	w.WriteHeader(code)
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.Write(b)
+	return
+}

api/types.go

@@ -0,0 +1,5 @@
+package api
+
+type Error struct {
+	Message string `json:"message"`
+}

go.mod

@@ -0,0 +1,11 @@
+module lorem
+
+go 1.16
+
+require (
+	github.com/disintegration/imaging v1.6.2
+	github.com/gorilla/handlers v1.5.1
+	github.com/gorilla/mux v1.8.0
+	github.com/spf13/pflag v1.0.5
+	github.com/spf13/viper v1.9.0
+)

image/image.go

@@ -0,0 +1,25 @@
+package image
+
+import (
+	"image"
+	"os"
+)
+
+type Processor interface {
+	CropCenter(img image.Image, width, height int) *image.Image
+}
+
+func Decode(name string) (*image.Image, error) {
+	imagePath, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer imagePath.Close()
+
+	img, _, err := image.Decode(imagePath)
+	if err != nil {
+		return nil, err
+	}
+
+	return &img, nil
+}

image/imaging.go

@@ -0,0 +1,13 @@
+package image
+
+import (
+	"github.com/disintegration/imaging"
+	"image"
+)
+
+type Imaging struct {}
+
+func (i *Imaging) CropCenter(img image.Image, width, height int) *image.Image {
+	img = imaging.Fill(img, width, height, imaging.Center, imaging.Lanczos)
+	return &img
+}

main.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"log"
+	"lorem/api"
+	"lorem/image"
+	"lorem/manager"
+	"net/http"
+	"os"
+	"path"
+
+	"github.com/gorilla/handlers"
+	"github.com/gorilla/mux"
+	"github.com/spf13/pflag"
+	"github.com/spf13/viper"
+)
+
+func init() {
+	flags := pflag.NewFlagSet(path.Base(os.Args[0]), pflag.ContinueOnError)
+
+	flags.String("host", "127.0.0.1:8080", "host:port for the HTTP server")
+	flags.String("dir", "./images", "directory of images")
+
+	err := flags.Parse(os.Args[1:])
+	if err != nil {
+		log.Panic("failed to parse arguments")
+	}
+
+	err = viper.BindPFlags(flags)
+	if err != nil {
+		log.Panic("failed to bind flags")
+	}
+}
+
+func main() {
+	m, err := manager.New(viper.GetString("dir"))
+	if err != nil {
+		log.Panic(err)
+	}
+
+	log.Printf("%d items loaded", m.Total())
+
+	a := api.New(m, &image.Imaging{}, nil)
+
+	r := mux.NewRouter()
+	r.HandleFunc("/{category}/{width:[0-9]+}/{height:[0-9]+}", a.SizeHandler).Methods(http.MethodGet)
+	r.HandleFunc("/{width:[0-9]+}/{height:[0-9]+}", a.SizeHandler).Methods(http.MethodGet)
+	r.PathPrefix("/").HandlerFunc(a.NotFound)
+
+	log.Printf("listening on %s", viper.GetString("host"))
+	err = http.ListenAndServe(viper.GetString("host"), handlers.CORS(
+		handlers.AllowedOrigins([]string{"*"}),
+		handlers.AllowedHeaders([]string{"Content-Type", "X-Requested-With"}),
+	)(r))
+	if err != nil {
+		log.Panic("HTTP server failed to start")
+	}
+}
+

manager/manager.go

@@ -0,0 +1,71 @@
+package manager
+
+import (
+	"math/rand"
+	"strings"
+	"time"
+)
+
+const (
+	defaultDirName = "__root"
+)
+
+type Manager struct {
+	base string
+	ds map[string][]string
+	mc []string // index of categories
+}
+
+func New(dir string) (*Manager, error) {
+	ds, err := scan(dir)
+	if err != nil {
+		return nil, err
+	}
+
+	var mc []string
+	for c, _ := range ds {
+		mc = append(mc, c)
+	}
+
+	return &Manager{
+		base: dir,
+		ds: ds,
+		mc: mc,
+	}, nil
+}
+
+
+func (m *Manager) Pick(cat string) string {
+	if cat == "" {
+		cat = m.randomCategory()
+	}
+	return m.randomEntity(cat)
+}
+
+func (m *Manager) Total() int {
+	var t int
+	for _, d := range m.ds {
+		t += len(d)
+	}
+	return t
+}
+
+func (m *Manager) randomCategory() string {
+	rand.Seed(time.Now().UnixNano())
+	return m.mc[rand.Intn(len(m.mc))]
+}
+
+func (m *Manager) randomEntity(c string) string {
+	rand.Seed(time.Now().UnixNano())
+	if _, ok := m.ds[c]; !ok {
+		return ""
+	}
+
+	names := []string{m.base}
+	if c != defaultDirName {
+		names = append(names, c)
+	}
+	names = append(names, m.ds[c][rand.Intn(len(m.ds[c]))])
+
+	return strings.Join(names, "/")
+}

manager/scan.go

@@ -0,0 +1,33 @@
+package manager
+
+import (
+	"fmt"
+	"io/ioutil"
+)
+
+func scan(d string) (map[string][]string, error) {
+	var ds = make(map[string][]string)
+	files, err := ioutil.ReadDir(d)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, f := range files {
+		if f.IsDir() {
+			dFiles, err := ioutil.ReadDir(fmt.Sprintf("%s/%s", d, f.Name()))
+			if err != nil {
+				return nil, err
+			}
+
+			for _, df := range dFiles {
+				if !df.IsDir() { // ignore nested directories
+					ds[f.Name()] = append(ds[f.Name()], df.Name())
+				}
+			}
+		} else {
+			ds[defaultDirName] = append(ds[defaultDirName], f.Name())
+		}
+	}
+
+	return ds, err
+}