Use configured store

.goreleaser.yaml

@@ -49,12 +49,12 @@ changelog:
       - '^test:'
 
 scoop:
-  # Default for gitea is "https://gitea.com/<repo_owner>/<repo_name>/releases/download/{{ .Tag }}/{{ .ArtifactName }}"
+  url_template: "https://git.t-juice.club/torjus/gpaste/releases/download/{{ .Tag }}/{{ .ArtifactName }}"
-  url_template: "https://git.t-juice.club/torjus/scoop-tjuice/releases/download/{{ .Tag }}/{{ .ArtifactName }}"
   bucket:
     owner: torjus
     name: scoop-tjuice
     branch: master
+  folder: bucket
   commit_author:
     name: ci.t-juice.club
     email: ci@t-juice.club

api/http.go

@@ -35,16 +35,11 @@ func NewHTTPServer(cfg *gpaste.ServerConfig) *HTTPServer {
 		config:       cfg,
 		Logger:       zap.NewNop().Sugar(),
 		AccessLogger: zap.NewNop().Sugar(),
+		Files:        files.NewMemoryFileStore(),
+		Users:        users.NewMemoryUserStore(),
 	}
-	srv.Files = files.NewMemoryFileStore()
+	signingSecret, _ := uuid.Must(uuid.NewRandom()).MarshalBinary()
-	srv.Users = users.NewMemoryUserStore()
+	srv.Auth = gpaste.NewAuthService(srv.Users, signingSecret)
-	srv.Auth = gpaste.NewAuthService(srv.Users, []byte(srv.config.SigningSecret))
-
-	// Create initial user
-	// TODO: Do properly
-	user := &users.User{Username: "admin", Role: users.RoleAdmin}
-	_ = user.SetPassword("admin")
-	_ = srv.Users.Store(user)
 
 	r := chi.NewRouter()
 	r.Use(middleware.RealIP)

api/middleware.go

@@ -10,6 +10,7 @@ import (
 	"git.t-juice.club/torjus/gpaste"
 	"git.t-juice.club/torjus/gpaste/users"
 	"github.com/go-chi/chi/v5/middleware"
+	"go.uber.org/zap"
 )
 
 type authCtxKey int
@@ -27,14 +28,38 @@ func (s *HTTPServer) MiddlewareAccessLogger(next http.Handler) http.Handler {
 
 		reqID := middleware.GetReqID(r.Context())
 
+		// TODO: Maybe desugar in HTTPServer to avoid doing for all requests
+		logger := s.AccessLogger.Desugar()
+
 		defer func() {
-			s.AccessLogger.Infow(r.Method,
+			// DEBUG level
-				"path", r.URL.Path,
+			if ce := logger.Check(zap.DebugLevel, r.Method); ce != nil {
-				"status", ww.Status(),
+				ct := r.Header.Get("Content-Type")
-				"written", ww.BytesWritten(),
+				ce.Write(
-				"remote_addr", r.RemoteAddr,
+					zap.String("req_id", reqID),
-				"processing_time_ms", time.Since(t1).Milliseconds(),
+					zap.String("path", r.URL.Path),
-				"req_id", reqID)
+					zap.Int("status", ww.Status()),
+					zap.String("remote_addr", r.RemoteAddr),
+					zap.Int("bytes_written", ww.BytesWritten()),
+					zap.Duration("processing_time", time.Since(t1)),
+					zap.String("content_type", ct),
+					zap.Any("headers", r.Header),
+				)
+			} else {
+				// INFO level
+				if ce := logger.Check(zap.InfoLevel, r.Method); ce != nil {
+					ce.Write(
+						zap.String("req_id", reqID),
+						zap.String("path", r.URL.Path),
+						zap.Int("status", ww.Status()),
+						zap.String("remote_addr", r.RemoteAddr),
+						zap.Int("bytes_written", ww.BytesWritten()),
+						zap.Duration("processing_time", time.Since(t1)),
+					)
+				}
+			}
+
+			_ = logger.Sync()
 		}()
 
 		next.ServeHTTP(ww, r)

cmd/server/actions/actions.go

@@ -6,11 +6,15 @@ import (
 	"net/http"
 	"os"
 	"os/signal"
+	"path/filepath"
 	"strings"
 	"time"
 
 	"git.t-juice.club/torjus/gpaste"
 	"git.t-juice.club/torjus/gpaste/api"
+	"git.t-juice.club/torjus/gpaste/files"
+	"git.t-juice.club/torjus/gpaste/users"
+	"github.com/google/uuid"
 	"github.com/urfave/cli/v2"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
@@ -62,11 +66,49 @@ func ActionServe(c *cli.Context) error {
 	httpShutdownCtx, httpShutdownCancel := context.WithCancel(context.Background())
 	defer httpShutdownCancel()
 
+	// Setup stores
+	// Files
+	fileStore, fileClose, err := getFileStore(cfg)
+	if err != nil {
+		return err
+	}
+
+	defer fileClose() // nolint: errcheck
+
+	// Users
+	userStore, userClose, err := getUserStore(cfg)
+	if err != nil {
+		return err
+	}
+
+	defer userClose() // nolint: errcheck
+
+	if userList, err := userStore.List(); err != nil {
+		serverLogger.Panicw("Error checking userstore for users.", "error", err)
+	} else if len(userList) < 1 {
+		admin := users.User{
+			Username: "admin",
+			Role:     users.RoleAdmin,
+		}
+		password := uuid.NewString()
+		if err := admin.SetPassword(password); err != nil {
+			serverLogger.DPanic("Error setting admin-user password.", "error", err)
+		}
+
+		serverLogger.Warnw("Created admin-user.", "username", admin.Username, "password", password)
+	}
+
+	// Auth
+	auth := gpaste.NewAuthService(userStore, []byte(cfg.SigningSecret))
+
 	go func() {
 		srv := api.NewHTTPServer(cfg)
+		srv.Users = userStore
+		srv.Files = fileStore
 		srv.Addr = cfg.ListenAddr
 		srv.Logger = serverLogger
 		srv.AccessLogger = accessLogger
+		srv.Auth = auth
 
 		// Wait for cancel
 		go func() {
@@ -126,3 +168,48 @@ func getRootLogger(level string) *zap.SugaredLogger {
 
 	return rootLogger.Sugar()
 }
+
+// nolint: ireturn
+func getUserStore(cfg *gpaste.ServerConfig) (users.UserStore, func() error, error) {
+	closer := func() error { return nil }
+
+	switch cfg.Store.Type {
+	case "memory":
+		return users.NewMemoryUserStore(), closer, nil
+
+	case "fs":
+		path := filepath.Join(cfg.Store.FS.Dir, "gpaste-users.db")
+
+		bs, err := users.NewBoltUserStore(path)
+		if err != nil {
+			return nil, closer, cli.Exit("error setting up user store", 1)
+		}
+
+		return bs, bs.Close, nil
+
+	default:
+		return nil, closer, cli.Exit("no userstore configured", 1)
+	}
+}
+
+// nolint: ireturn
+func getFileStore(cfg *gpaste.ServerConfig) (files.FileStore, func() error, error) {
+	closer := func() error { return nil }
+
+	switch cfg.Store.Type {
+	case "memory":
+		return files.NewMemoryFileStore(), closer, nil
+
+	case "fs":
+		var err error
+
+		s, err := files.NewFSFileStore(cfg.Store.FS.Dir)
+		if err != nil {
+			return nil, closer, cli.Exit("error setting up filestore", 1)
+		}
+
+		return s, closer, nil
+	default:
+		return nil, closer, cli.Exit("No store configured", 1)
+	}
+}

files/filestore_fs_test.go

@@ -7,20 +7,23 @@ import (
 )
 
 func TestFSFileStore(t *testing.T) {
+	newFunc := func() files.FileStore {
 		dir := t.TempDir()
 		s, err := files.NewFSFileStore(dir)
 		if err != nil {
 			t.Fatalf("Error creating store: %s", err)
 		}
+		return s
+	}
 
-	RunFilestoreTest(s, t)
+	RunFilestoreTest(newFunc, t)
 	persistentDir := t.TempDir()
-	newFunc := func() files.FileStore {
+	persistentFunc := func() files.FileStore {
 		s, err := files.NewFSFileStore(persistentDir)
 		if err != nil {
 			t.Fatalf("Error creating store: %s", err)
 		}
 		return s
 	}
-	RunPersistentFilestoreTest(newFunc, t)
+	RunPersistentFilestoreTest(persistentFunc, t)
 }

files/filestore_memory.go

@@ -57,11 +57,16 @@ func (s *MemoryFileStore) Get(id string) (*File, error) {
 		return nil, fmt.Errorf("no such item")
 	}
 
+	body := new(bytes.Buffer)
+	if _, err := body.Write(fd.Body.Bytes()); err != nil {
+		return nil, err
+	}
+
 	f := &File{
 		ID:        fd.ID,
 		MaxViews:  fd.MaxViews,
 		ExpiresOn: fd.ExpiresOn,
-		Body:      io.NopCloser(&fd.Body),
+		Body:      io.NopCloser(body),
 		FileSize:  fd.FileSize,
 	}
 

files/filestore_memory_test.go

@@ -7,7 +7,9 @@ import (
 )
 
 func TestMemoryFileStore(t *testing.T) {
-	s := files.NewMemoryFileStore()
+	newFunc := func() files.FileStore {
-
+		return files.NewMemoryFileStore()
-	RunFilestoreTest(s, t)
+	}
+
+	RunFilestoreTest(newFunc, t)
 }

files/filestore_test.go

@@ -12,8 +12,11 @@ import (
 	"github.com/google/uuid"
 )
 
-func RunFilestoreTest(s files.FileStore, t *testing.T) {
+var ignoreBody = cmp.FilterPath(func(p cmp.Path) bool { return p.String() == "Body" }, cmp.Ignore())
+
+func RunFilestoreTest(newStoreFunc func() files.FileStore, t *testing.T) {
 	t.Run("Basic", func(t *testing.T) {
+		s := newStoreFunc()
 		// Create
 		dataString := "TEST_LOL_OMG"
 		id := uuid.Must(uuid.NewRandom()).String()
@@ -58,7 +61,6 @@ func RunFilestoreTest(s files.FileStore, t *testing.T) {
 			FileSize:  int64(len(dataString)),
 		}
 
-		ignoreBody := cmp.FilterPath(func(p cmp.Path) bool { return p.String() == "Body" }, cmp.Ignore())
 		if diff := cmp.Diff(retrieved, expected, ignoreBody); diff != "" {
 			t.Errorf("File comparison failed: %s", diff)
 		}
@@ -88,9 +90,54 @@ func RunFilestoreTest(s files.FileStore, t *testing.T) {
 			t.Fatalf("List after delete has wrong length: %d", len(ids))
 		}
 	})
+	t.Run("MultipleGet", func(t *testing.T) {
+		s := newStoreFunc()
+
+		fileContents := "multiple get test !"
+		body := io.NopCloser(strings.NewReader(fileContents))
+		file := &files.File{
+			ID:               uuid.NewString(),
+			OriginalFilename: "multiple.txt",
+			MaxViews:         999,
+			ExpiresOn:        time.Now().Add(1 * time.Hour),
+			Body:             body,
+			FileSize:         int64(len(fileContents)),
+		}
+
+		if err := s.Store(file); err != nil {
+			t.Fatalf("Error storing file: %s", err)
+		}
+
+		first, err := s.Get(file.ID)
+		if err != nil {
+			t.Errorf("Error retrieving first file: %s", err)
+		}
+
+		firstBody := new(bytes.Buffer)
+		io.Copy(firstBody, first.Body)
+		first.Body.Close()
+
+		if diff := cmp.Diff(firstBody.String(), fileContents); diff != "" {
+			t.Fatalf("File contents mismatch: %s", diff)
+		}
+
+		second, err := s.Get(file.ID)
+		if err != nil {
+			t.Errorf("Error retrieving first file: %s", err)
+		}
+
+		secondBody := new(bytes.Buffer)
+		io.Copy(secondBody, second.Body)
+		first.Body.Close()
+
+		if diff := cmp.Diff(secondBody.String(), fileContents); diff != "" {
+			t.Fatalf("File contents mismatch: %s", diff)
+		}
+	})
 }
 
 func RunPersistentFilestoreTest(newStoreFunc func() files.FileStore, t *testing.T) {
+	t.Run("Basics", func(t *testing.T) {
 		s := newStoreFunc()
 
 		files := []struct {
@@ -133,7 +180,6 @@ func RunPersistentFilestoreTest(newStoreFunc func() files.FileStore, t *testing.
 				t.Fatalf("Unable to retrieve file: %s", err)
 			}
 
-		ignoreBody := cmp.FilterPath(func(p cmp.Path) bool { return p.String() == "Body" }, cmp.Ignore())
 			if !cmp.Equal(retrieved, f.File, ignoreBody) {
 				t.Errorf("Mismatch: %s", cmp.Diff(retrieved, f.File))
 			}
@@ -155,7 +201,6 @@ func RunPersistentFilestoreTest(newStoreFunc func() files.FileStore, t *testing.
 				t.Fatalf("Unable to retrieve file: %s", err)
 			}
 
-		ignoreBody := cmp.FilterPath(func(p cmp.Path) bool { return p.String() == "Body" }, cmp.Ignore())
 			if !cmp.Equal(retrieved, f.File, ignoreBody) {
 				t.Errorf("Mismatch: %s", cmp.Diff(retrieved, f.File))
 			}
@@ -168,4 +213,5 @@ func RunPersistentFilestoreTest(newStoreFunc func() files.FileStore, t *testing.
 				t.Fatalf("Data does not match. %s", cmp.Diff(buf.String(), f.ExpectedData))
 			}
 		}
+	})
 }