main.go

package main

import (
	"context"
	"flag"
	"log"
	"net/http"
	"time"

	"github.com/a-h/templ"
	"github.com/aws/aws-sdk-go-v2/aws"
	v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/facebookgo/flagenv"
	"github.com/google/uuid"
	_ "github.com/joho/godotenv/autoload"
)

var (
	bind   = flag.String("bind", ":9090", "The address to bind the server to")
	bucket = flag.String("bucket-name", "", "The bucket where images are stored")
)

//go:generate go run github.com/a-h/templ/cmd/templ@latest generate

func main() {
	flagenv.Parse()
	flag.Parse()

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	sdkConfig, err := config.LoadDefaultConfig(ctx)
	if err != nil {
		log.Printf("Couldn't load default configuration. Here's why: %v\n", err)
		return
	}

	svc := s3.NewFromConfig(sdkConfig, func(o *s3.Options) {
		o.BaseEndpoint = aws.String("https://fly.storage.tigris.dev")
		o.Region = "auto"
		o.UsePathStyle = false
	})

	presigner := &Client{PresignClient: s3.NewPresignClient(svc)}

	mux := http.NewServeMux()

	mux.HandleFunc("/{$}", func(w http.ResponseWriter, r *http.Request) {
		var objects []string

		resp, err := svc.ListObjectsV2(r.Context(), &s3.ListObjectsV2Input{
			Bucket: bucket,
		})
		if err != nil {
			log.Printf("can't list objects: %v", err)
			http.Error(w, "internal error", http.StatusInternalServerError)
			return
		}

		for _, obj := range resp.Contents {
			objects = append(objects, *obj.Key)
		}

		templ.Handler(
			Simple("Simple upload", index(objects)),
		).ServeHTTP(w, r)
	})

	mux.HandleFunc("GET /upload", func(w http.ResponseWriter, r *http.Request) {
		templ.Handler(
			Simple("Upload", upload()),
		).ServeHTTP(w, r)
	})

	mux.HandleFunc("POST /upload", func(w http.ResponseWriter, r *http.Request) {
		if err := r.ParseMultipartForm(10 << 20); err != nil {
			log.Printf("can't parse form: %v", err)
			http.Error(w, "internal error", http.StatusInternalServerError)
			return
		}

		file, _, err := r.FormFile("image")
		if err != nil {
			log.Printf("can't get file: %v", err)
			http.Error(w, "internal error", http.StatusInternalServerError)
			return
		}
		defer file.Close()

		keyName := uuid.NewString()

		_, err = svc.PutObject(ctx, &s3.PutObjectInput{
			Bucket: bucket,
			Key:    &keyName,
			Body:   file,
		})
		if err != nil {
			log.Printf("can't put object: %v", err)
			http.Error(w, "internal error", http.StatusInternalServerError)
			return
		}

		http.Redirect(w, r, "/img/"+keyName, http.StatusSeeOther)
	})

	mux.HandleFunc("GET /img/{id}", func(w http.ResponseWriter, r *http.Request) {
		id := r.PathValue("id")

		if _, err := svc.HeadObject(ctx, &s3.HeadObjectInput{
			Bucket: bucket,
			Key:    &id,
		}); err != nil {
			log.Printf("can't head object: %v", err)
			http.Error(w, "internal error", http.StatusInternalServerError)
			return
		}

		psg, err := presigner.GetObject(ctx, *bucket, id, 6*time.Hour)
		if err != nil {
			log.Printf("can't get presigned request: %v", err)
			http.Error(w, "internal error", http.StatusInternalServerError)
			return
		}

		psd, err := presigner.DeleteObject(ctx, *bucket, id, 6*time.Hour)
		if err != nil {
			log.Printf("can't get presigned request: %v", err)
			http.Error(w, "internal error", http.StatusInternalServerError)
			return
		}

		templ.Handler(
			Simple("Image "+id, viewImage(id, psg.URL, psd.URL)),
		).ServeHTTP(w, r)
	})

	log.Printf("Listening on %v", *bind)
	log.Fatal(http.ListenAndServe(*bind, mux))
}

// Client encapsulates the S3 SDK presign client and provides methods to presign requests.
type Client struct {
	PresignClient *s3.PresignClient
}

// GetObject makes a presigned request that can be used to get an object from a bucket.
func (p *Client) GetObject(
	ctx context.Context,
	bucket string,
	key string,
	expiry time.Duration,
) (*v4.PresignedHTTPRequest, error) {
	request, err := p.PresignClient.PresignGetObject(ctx, &s3.GetObjectInput{
		Bucket: aws.String(bucket),
		Key:    aws.String(key),
	}, func(opts *s3.PresignOptions) {
		opts.Expires = expiry
	})
	if err != nil {
		log.Printf("Couldn't get a presigned request to get %v:%v. Here's why: %v\n",
			bucket, key, err)
	}
	return request, err
}

// PutObject makes a presigned request that can be used to put an object in a bucket.
func (p *Client) PutObject(
	ctx context.Context,
	bucket string,
	object string,
	expiry time.Duration,
) (*v4.PresignedHTTPRequest, error) {
	request, err := p.PresignClient.PresignPutObject(ctx, &s3.PutObjectInput{
		Bucket: aws.String(bucket),
		Key:    aws.String(object),
	}, func(opts *s3.PresignOptions) {
		opts.Expires = expiry
	})
	if err != nil {
		log.Printf("Couldn't get a presigned request to put %v:%v. Here's why: %v\n",
			bucket, object, err)
	}
	return request, err
}

// DeleteObject makes a presigned request that can be used to delete an object from a bucket.
func (p *Client) DeleteObject(ctx context.Context, bucket string, object string, expiry time.Duration) (*v4.PresignedHTTPRequest, error) {
	request, err := p.PresignClient.PresignDeleteObject(ctx, &s3.DeleteObjectInput{
		Bucket: aws.String(bucket),
		Key:    aws.String(object),
	}, func(opts *s3.PresignOptions) {
		opts.Expires = expiry
	})
	if err != nil {
		log.Printf("Couldn't get a presigned request to delete object %v. Here's why: %v\n", object, err)
	}
	return request, err
}