12 |
12 |
13 |
14 | ## License
15 | MIT. See [LICENSE](./LICENSE.md)
16 |
--------------------------------------------------------------------------------
/internal/image/mock/mock.go:
--------------------------------------------------------------------------------
1 | package mock
2 |
3 | import (
4 | "context"
5 | "fmt"
6 |
7 | "github.com/DMarby/picsum-photos/internal/image"
8 | )
9 |
10 | // Processor implements a mock image processor
11 | type Processor struct {
12 | }
13 |
14 | // ProcessImage returns an error instead of process an image
15 | func (p *Processor) ProcessImage(ctx context.Context, task *image.Task) (processedImage []byte, err error) {
16 | return nil, fmt.Errorf("processing error")
17 | }
18 |
--------------------------------------------------------------------------------
/internal/tracing/test/tracing.go:
--------------------------------------------------------------------------------
1 | package test
2 |
3 | import (
4 | "context"
5 |
6 | "github.com/DMarby/picsum-photos/internal/logger"
7 | "github.com/DMarby/picsum-photos/internal/tracing"
8 | "go.opentelemetry.io/otel/trace"
9 | )
10 |
11 | func Tracer(log *logger.Logger) *tracing.Tracer {
12 | tp := trace.NewNoopTracerProvider()
13 | return &tracing.Tracer{
14 | ServiceName: "test",
15 | Log: log,
16 | TracerProvider: tp,
17 | ShutdownFunc: func(context.Context) error {
18 | return nil
19 | },
20 | TracerInstance: tp.Tracer("test"),
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
1 | {
2 | "version": "0.2.0",
3 | "configurations": [
4 | {
5 | "name": "Attach to picsum",
6 | "type": "go",
7 | "request": "attach",
8 | "mode": "remote",
9 | "port": 2345,
10 | "host": "127.0.0.1",
11 | "showLog": true
12 | },
13 | {
14 | "name": "Attach to image-service",
15 | "type": "go",
16 | "request": "attach",
17 | "mode": "remote",
18 | "port": 2346,
19 | "host": "127.0.0.1",
20 | "showLog": true
21 | }
22 | ]
23 | }
24 |
--------------------------------------------------------------------------------
/internal/hmac/hmac_test.go:
--------------------------------------------------------------------------------
1 | package hmac_test
2 |
3 | import (
4 | "testing"
5 |
6 | "github.com/DMarby/picsum-photos/internal/hmac"
7 | )
8 |
9 | var key = []byte("foobar")
10 | var message = "test"
11 |
12 | func TestHMAC(t *testing.T) {
13 | h := &hmac.HMAC{
14 | Key: key,
15 | }
16 |
17 | mac, err := h.Create(message)
18 | if err != nil {
19 | t.Fatal(err)
20 | }
21 |
22 | matches, err := h.Validate(message, mac)
23 | if err != nil {
24 | t.Fatal(err)
25 | }
26 |
27 | if !matches {
28 | t.Error("hmac does not match")
29 | }
30 |
31 | matches, err = h.Validate("doesnotmatch", mac)
32 | if err != nil {
33 | t.Fatal(err)
34 | }
35 |
36 | if matches {
37 | t.Error("hmac matches when it should not")
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/internal/image/cache.go:
--------------------------------------------------------------------------------
1 | package image
2 |
3 | import (
4 | "context"
5 |
6 | "github.com/DMarby/picsum-photos/internal/cache"
7 | "github.com/DMarby/picsum-photos/internal/storage"
8 | "github.com/DMarby/picsum-photos/internal/tracing"
9 | )
10 |
11 | // Cache is an image cache
12 | type Cache = cache.Auto
13 |
14 | // NewCache instantiates a new cache
15 | func NewCache(tracer *tracing.Tracer, cacheProvider cache.Provider, storageProvider storage.Provider) *Cache {
16 | return &Cache{
17 | Tracer: tracer,
18 | Provider: cacheProvider,
19 | Loader: func(ctx context.Context, key string) (data []byte, err error) {
20 | ctx, span := tracer.Start(ctx, "image.Cache.Loader")
21 | defer span.End()
22 |
23 | return storageProvider.Get(ctx, key)
24 | },
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/internal/handler/recovery.go:
--------------------------------------------------------------------------------
1 | package handler
2 |
3 | import (
4 | "net/http"
5 | "runtime/debug"
6 |
7 | "github.com/DMarby/picsum-photos/internal/logger"
8 | "github.com/DMarby/picsum-photos/internal/tracing"
9 | )
10 |
11 | // Recovery is a handler for handling panics
12 | func Recovery(log *logger.Logger, next http.Handler) http.Handler {
13 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
14 | defer func() {
15 | if err := recover(); err != nil {
16 | w.WriteHeader(http.StatusInternalServerError)
17 | ctx := r.Context()
18 | traceID, spanID := tracing.TraceInfo(ctx)
19 | log.Errorw("panic handling request",
20 | "trace-id", traceID,
21 | "span-id", spanID,
22 | "stacktrace", string(debug.Stack()),
23 | )
24 | }
25 | }()
26 |
27 | next.ServeHTTP(w, r)
28 | })
29 | }
30 |
--------------------------------------------------------------------------------
/internal/handler/recovery_test.go:
--------------------------------------------------------------------------------
1 | package handler_test
2 |
3 | import (
4 | "net/http"
5 | "net/http/httptest"
6 | "testing"
7 |
8 | "github.com/DMarby/picsum-photos/internal/handler"
9 | "github.com/DMarby/picsum-photos/internal/logger"
10 | "go.uber.org/zap"
11 | )
12 |
13 | func TestRecovery(t *testing.T) {
14 | log := logger.New(zap.FatalLevel)
15 | defer log.Sync()
16 |
17 | ts := httptest.NewServer(handler.Recovery(log, http.HandlerFunc(panicHandler)))
18 | defer ts.Close()
19 |
20 | res, err := http.Get(ts.URL)
21 | if err != nil {
22 | t.Fatal(err)
23 | }
24 | defer res.Body.Close()
25 |
26 | if res.StatusCode != http.StatusInternalServerError {
27 | t.Errorf("wrong status code %#v", res.StatusCode)
28 | }
29 | }
30 |
31 | func panicHandler(rw http.ResponseWriter, req *http.Request) {
32 | panic("panicking handler")
33 | }
34 |
--------------------------------------------------------------------------------
/internal/database/database.go:
--------------------------------------------------------------------------------
1 | package database
2 |
3 | import (
4 | "context"
5 | "errors"
6 | )
7 |
8 | // Image contains metadata about an image
9 | type Image struct {
10 | ID string `json:"id"`
11 | Author string `json:"author"`
12 | Width int `json:"width"`
13 | Height int `json:"height"`
14 | URL string `json:"url"`
15 | }
16 |
17 | // Provider is an interface for listing and retrieving images
18 | type Provider interface {
19 | Get(ctx context.Context, id string) (i *Image, err error)
20 | GetRandom(ctx context.Context) (i *Image, err error)
21 | GetRandomWithSeed(ctx context.Context, seed int64) (i *Image, err error)
22 | ListAll(ctx context.Context) ([]Image, error)
23 | List(ctx context.Context, offset, limit int) ([]Image, error)
24 | }
25 |
26 | // Errors
27 | var (
28 | ErrNotFound = errors.New("Image does not exist")
29 | )
30 |
--------------------------------------------------------------------------------
/internal/cache/mock/mock.go:
--------------------------------------------------------------------------------
1 | package mock
2 |
3 | import (
4 | "context"
5 | "fmt"
6 |
7 | "github.com/DMarby/picsum-photos/internal/cache"
8 | )
9 |
10 | // Provider is a mock cache
11 | type Provider struct{}
12 |
13 | // Get returns an object from the cache if it exists
14 | func (p *Provider) Get(ctx context.Context, key string) (data []byte, err error) {
15 | if key == "notfound" || key == "notfounderr" || key == "seterror" {
16 | return nil, cache.ErrNotFound
17 | }
18 |
19 | if key == "error" {
20 | return nil, fmt.Errorf("error")
21 | }
22 |
23 | return []byte("foo"), nil
24 | }
25 |
26 | // Set adds an object to the cache
27 | func (p *Provider) Set(ctx context.Context, key string, data []byte) (err error) {
28 | if key == "seterror" {
29 | return fmt.Errorf("seterror")
30 | }
31 |
32 | return nil
33 | }
34 |
35 | // Shutdown shuts down the cache
36 | func (p *Provider) Shutdown() {}
37 |
--------------------------------------------------------------------------------
/internal/handler/tracing.go:
--------------------------------------------------------------------------------
1 | package handler
2 |
3 | import (
4 | "net/http"
5 |
6 | "github.com/DMarby/picsum-photos/internal/tracing"
7 | "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
8 | "go.opentelemetry.io/otel/propagation"
9 | )
10 |
11 | // Tracer is a handler that adds tracing for handlers
12 | func Tracer(tracer *tracing.Tracer, h http.Handler, routeMatcher RouteMatcher) http.Handler {
13 | traceHandler := otelhttp.NewHandler(
14 | h,
15 | "http",
16 | otelhttp.WithTracerProvider(tracer),
17 | otelhttp.WithPropagators(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{})),
18 | otelhttp.WithSpanNameFormatter(func(operation string, r *http.Request) string {
19 | return routeMatcher.Match(r)
20 | }),
21 | )
22 |
23 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
24 | traceHandler.ServeHTTP(w, r)
25 | })
26 | }
27 |
--------------------------------------------------------------------------------
/internal/handler/health.go:
--------------------------------------------------------------------------------
1 | package handler
2 |
3 | import (
4 | "encoding/json"
5 | "net/http"
6 |
7 | "github.com/DMarby/picsum-photos/internal/health"
8 | )
9 |
10 | // Health is a handler for health check status
11 | func Health(healthChecker *health.Checker) Handler {
12 | return Handler(newHandler(healthChecker))
13 | }
14 |
15 | func newHandler(healthChecker *health.Checker) func(w http.ResponseWriter, r *http.Request) *Error {
16 | return func(w http.ResponseWriter, r *http.Request) *Error {
17 | status := healthChecker.Status()
18 |
19 | if !status.Healthy {
20 | w.WriteHeader(http.StatusInternalServerError)
21 | }
22 |
23 | w.Header().Set("Cache-Control", "private, no-cache, no-store, must-revalidate")
24 | w.Header().Set("Content-Type", "application/json")
25 | if err := json.NewEncoder(w).Encode(status); err != nil {
26 | return InternalServerError()
27 | }
28 |
29 | return nil
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/internal/hmac/hmac.go:
--------------------------------------------------------------------------------
1 | package hmac
2 |
3 | import (
4 | cryptoHMAC "crypto/hmac"
5 | "crypto/sha256"
6 | "encoding/base64"
7 | )
8 |
9 | // HMAC is a utility for creating and verifying HMACs
10 | type HMAC struct {
11 | Key []byte
12 | }
13 |
14 | // Create creates a HMAC based on the parameter values, encoded as urlsafe base64
15 | func (h *HMAC) Create(message string) (string, error) {
16 | mac := cryptoHMAC.New(sha256.New, h.Key)
17 |
18 | _, err := mac.Write([]byte(message))
19 | if err != nil {
20 | return "", err
21 | }
22 |
23 | return base64.RawURLEncoding.EncodeToString(mac.Sum(nil)), nil
24 | }
25 |
26 | // Validate validates that the parameter values matches a given HMAC
27 | func (h *HMAC) Validate(message, mac string) (bool, error) {
28 | expectedMAC, err := h.Create(message)
29 | if err != nil {
30 | return false, err
31 | }
32 |
33 | return cryptoHMAC.Equal([]byte(mac), []byte(expectedMAC)), nil
34 | }
35 |
--------------------------------------------------------------------------------
/internal/storage/file/file.go:
--------------------------------------------------------------------------------
1 | package file
2 |
3 | import (
4 | "context"
5 | "errors"
6 | "fmt"
7 | "os"
8 | "path/filepath"
9 |
10 | "github.com/DMarby/picsum-photos/internal/storage"
11 | )
12 |
13 | // Provider implements a file-based image storage
14 | type Provider struct {
15 | path string
16 | }
17 |
18 | // New returns a new Provider instance
19 | func New(path string) (*Provider, error) {
20 | if _, err := os.Stat(path); err != nil {
21 | return nil, err
22 | }
23 |
24 | return &Provider{
25 | path,
26 | }, nil
27 | }
28 |
29 | // Get returns the image data for an image id
30 | func (p *Provider) Get(ctx context.Context, id string) ([]byte, error) {
31 | imageData, err := os.ReadFile(filepath.Join(p.path, fmt.Sprintf("%s.jpg", id)))
32 | if err != nil {
33 | if errors.Is(err, os.ErrNotExist) {
34 | return nil, storage.ErrNotFound
35 | }
36 |
37 | return nil, err
38 | }
39 |
40 | return imageData, nil
41 | }
42 |
--------------------------------------------------------------------------------
/internal/handler/route_matcher.go:
--------------------------------------------------------------------------------
1 | package handler
2 |
3 | import (
4 | "net/http"
5 |
6 | "github.com/gorilla/mux"
7 | )
8 |
9 | // RouteMatcher matches routes
10 | type RouteMatcher interface {
11 | Match(r *http.Request) string
12 | }
13 |
14 | // MuxRouteMatcher maxes routes for a mux router
15 | type MuxRouteMatcher struct {
16 | Router *mux.Router
17 | }
18 |
19 | // Match returns the mux route name of a given request, falling back to the path template if not set
20 | func (m *MuxRouteMatcher) Match(r *http.Request) string {
21 | var routeMatch mux.RouteMatch
22 | // The Route can be nil even on a Match, if a NotFoundHandler is specified
23 | if m.Router.Match(r, &routeMatch) && routeMatch.Route != nil {
24 | if routeName := routeMatch.Route.GetName(); routeName != "" {
25 | return routeName
26 | }
27 |
28 | if tmpl, err := routeMatch.Route.GetPathTemplate(); err == nil {
29 | return tmpl
30 | }
31 | }
32 |
33 | return "unknown"
34 | }
35 |
--------------------------------------------------------------------------------
/internal/vips/vips-bridge.h:
--------------------------------------------------------------------------------
1 | #include 
45 | Here you can view all the images Lorem Picsum provides.
60 |Get a specific image by adding /id/{image} to the start of the url.
https://picsum.photos/id/1/200/300More detailed instructions can be found on the main page.
63 |
44 | Just add your desired image size (width & height) after our URL, and you'll get a random image.
59 |https://picsum.photos/200/300To get a square image, just add the size.
61 |https://picsum.photos/200Get a specific image by adding /id/{image} to the start of the url.
https://picsum.photos/id/237/200/300You can find a list of all the images here.
74 |Get the same random image every time based on a seed, by adding /seed/{seed} to the start of the url.
https://picsum.photos/seed/picsum/200/300Get a grayscale image by appending ?grayscale to the end of the url.
https://picsum.photos/200/300?grayscaleGet a blurred image by appending ?blur to the end of the url.
https://picsum.photos/200/300/?blurYou can adjust the amount of blur by providing a number between 1 and 10.
https://picsum.photos/200/300/?blur=2You may combine any of the options above.
127 |For example, to get a specific image that is grayscale and blurred.
128 |https://picsum.photos/id/870/200/300?grayscale&blur=2To request multiple images of the same size in your browser, add the random query param to prevent the images from being cached:
<img src="https://picsum.photos/200/300?random=1">
131 | <img src="https://picsum.photos/200/300?random=2">If you need a file ending, you can add .jpg to the end of the url.
https://picsum.photos/200/300.jpgTo get an image in the WebP format, you can add .webp to the end of the url.
https://picsum.photos/200/300.webpGet a list of images by using the /v2/list endpoint.
https://picsum.photos/v2/listThe API will return 30 items per page by default.
150 |To request another page, use the ?page parameter.
To change the amount of items per page, use the ?limit parameter.
https://picsum.photos/v2/list?page=2&limit=100The Link header includes pagination information about the next/previous pages
[
157 | {
158 | "id": "0",
159 | "author": "Alejandro Escamilla",
160 | "width": 5616,
161 | "height": 3744,
162 | "url": "https://unsplash.com/...",
163 | "download_url": "https://picsum.photos/..."
164 | }
165 | ]Get information about a specific image by using the /id/{id}/info and /seed/{seed}/info endpoints.
https://picsum.photos/id/0/info
176 | https://picsum.photos/seed/picsum/infoYou can find out the ID of an image by looking at the Picsum-ID header, or the User Comment field in the EXIF metadata.
{
181 | "id": "0",
182 | "author": "Alejandro Escamilla",
183 | "width": 5616,
184 | "height": 3744,
185 | "url": "https://unsplash.com/...",
186 | "download_url": "https://picsum.photos/..."
187 | }