Add delete

Reviewed-on: #6

.woodpecker.yml

@@ -2,8 +2,8 @@ pipeline:
   test:
     image: golang:latest
     commands:
-      - go build ./cmd/client/client.go
-      - go build ./cmd/server/server.go
+      - go build -o gpaste-client ./cmd/client/client.go
+      - go build -o gpaste-server ./cmd/server/server.go
       - go test -v ./...
       - go vet ./...
     when:

api/http.go

@@ -1,4 +1,4 @@
-package gpaste
+package api
 
 import (
 	"encoding/json"
@@ -6,6 +6,9 @@ import (
 	"net/http"
 	"strings"
 
+	"git.t-juice.club/torjus/gpaste"
+	"git.t-juice.club/torjus/gpaste/files"
+	"git.t-juice.club/torjus/gpaste/users"
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
 	"github.com/google/uuid"
@@ -13,28 +16,28 @@ import (
 )
 
 type HTTPServer struct {
-	Files        FileStore
-	Users        UserStore
-	Auth         *AuthService
-	config       *ServerConfig
+	Files        files.FileStore
+	Users        users.UserStore
+	Auth         *gpaste.AuthService
+	config       *gpaste.ServerConfig
 	Logger       *zap.SugaredLogger
 	AccessLogger *zap.SugaredLogger
 	http.Server
 }
 
-func NewHTTPServer(cfg *ServerConfig) *HTTPServer {
+func NewHTTPServer(cfg *gpaste.ServerConfig) *HTTPServer {
 	srv := &HTTPServer{
 		config:       cfg,
 		Logger:       zap.NewNop().Sugar(),
 		AccessLogger: zap.NewNop().Sugar(),
 	}
-	srv.Files = NewMemoryFileStore()
-	srv.Users = NewMemoryUserStore()
-	srv.Auth = NewAuthService(srv.Users, []byte(srv.config.SigningSecret))
+	srv.Files = files.NewMemoryFileStore()
+	srv.Users = users.NewMemoryUserStore()
+	srv.Auth = gpaste.NewAuthService(srv.Users, []byte(srv.config.SigningSecret))
 
 	// Create initial user
 	// TODO: Do properly
-	user := &User{Username: "admin"}
+	user := &users.User{Username: "admin", Role: users.RoleAdmin}
 	user.SetPassword("admin")
 	srv.Users.Store(user)
 
@@ -42,10 +45,13 @@ func NewHTTPServer(cfg *ServerConfig) *HTTPServer {
 	r.Use(middleware.RealIP)
 	r.Use(middleware.RequestID)
 	r.Use(srv.MiddlewareAccessLogger)
+	r.Use(srv.MiddlewareAuthentication)
 	r.Get("/", srv.HandlerIndex)
 	r.Post("/api/file", srv.HandlerAPIFilePost)
 	r.Get("/api/file/{id}", srv.HandlerAPIFileGet)
+	r.Delete("/api/file/{id}", srv.HandlerAPIFileDelete)
 	r.Post("/api/login", srv.HandlerAPILogin)
+	r.Post("/api/user", srv.HandlerAPIUserCreate)
 	srv.Handler = r
 
 	return srv
@@ -56,7 +62,7 @@ func (s *HTTPServer) HandlerIndex(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s *HTTPServer) HandlerAPIFilePost(w http.ResponseWriter, r *http.Request) {
-	f := &File{
+	f := &files.File{
 		ID:   uuid.Must(uuid.NewRandom()).String(),
 		Body: r.Body,
 	}
@@ -112,15 +118,27 @@ func (s *HTTPServer) HandlerAPIFileGet(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (s *HTTPServer) processMultiPartFormUpload(w http.ResponseWriter, r *http.Request) {
-	reqID := middleware.GetReqID(r.Context())
-	type resp struct {
-		Message string `json:"message"`
-		ID      string `json:"id"`
-		URL     string `json:"url"`
+func (s *HTTPServer) HandlerAPIFileDelete(w http.ResponseWriter, r *http.Request) {
+	// TODO: Require auth
+	id := chi.URLParam(r, "id")
+	if id == "" {
+		w.WriteHeader(http.StatusBadRequest)
+		return
 	}
 
-	var responses []resp
+	err := s.Files.Delete(id)
+	if err != nil {
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+	reqID := middleware.GetReqID(r.Context())
+	s.Logger.Infow("Deleted file", "id", id, "req_id", reqID)
+}
+
+func (s *HTTPServer) processMultiPartFormUpload(w http.ResponseWriter, r *http.Request) {
+	reqID := middleware.GetReqID(r.Context())
+
+	var responses []ResponseAPIFilePost
 
 	if err := r.ParseMultipartForm(1024 * 1024 * 10); err != nil {
 		s.Logger.Warnw("Error parsing multipart form.", "req_id", reqID, "err", err)
@@ -131,7 +149,7 @@ func (s *HTTPServer) processMultiPartFormUpload(w http.ResponseWriter, r *http.R
 			s.Logger.Warnw("Error reading file from multipart form.", "req_id", reqID, "error", err)
 			return
 		}
-		f := &File{
+		f := &files.File{
 			ID:               uuid.Must(uuid.NewRandom()).String(),
 			OriginalFilename: fh.Filename,
 			Body:             ff,
@@ -144,7 +162,7 @@ func (s *HTTPServer) processMultiPartFormUpload(w http.ResponseWriter, r *http.R
 		}
 		s.Logger.Infow("Stored file.", "req_id", reqID, "id", f.ID, "filename", f.OriginalFilename, "remote_addr", r.RemoteAddr)
 
-		responses = append(responses, resp{Message: "OK", ID: f.ID, URL: "TODO"})
+		responses = append(responses, ResponseAPIFilePost{Message: "OK", ID: f.ID, URL: "TODO"})
 
 	}
 
@@ -157,10 +175,7 @@ func (s *HTTPServer) processMultiPartFormUpload(w http.ResponseWriter, r *http.R
 
 func (s *HTTPServer) HandlerAPILogin(w http.ResponseWriter, r *http.Request) {
 	reqID := middleware.GetReqID(r.Context())
-	expectedRequest := struct {
-		Username string `json:"username"`
-		Password string `json:"password"`
-	}{}
+	var expectedRequest RequestAPILogin
 	decoder := json.NewDecoder(r.Body)
 	defer r.Body.Close()
 	if err := decoder.Decode(&expectedRequest); err != nil {
@@ -174,9 +189,7 @@ func (s *HTTPServer) HandlerAPILogin(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	response := struct {
-		Token string `json:"token"`
-	}{
+	response := ResponseAPILogin{
 		Token: token,
 	}
 
@@ -187,3 +200,38 @@ func (s *HTTPServer) HandlerAPILogin(w http.ResponseWriter, r *http.Request) {
 		s.Logger.Infow("Error encoding json response to client.", "req_id", reqID, "error", err, "remote_addr", r.RemoteAddr)
 	}
 }
+
+func (s *HTTPServer) HandlerAPIUserCreate(w http.ResponseWriter, r *http.Request) {
+	reqID := middleware.GetReqID(r.Context())
+	defer r.Body.Close()
+
+	role, err := RoleFromRequest(r)
+	if err != nil || role != users.RoleAdmin {
+		w.WriteHeader(http.StatusUnauthorized)
+		return
+	}
+
+	var req RequestAPIUserCreate
+	decoder := json.NewDecoder(r.Body)
+	if err := decoder.Decode(&req); err != nil {
+		s.Logger.Debugw("Error parsing request.", "req_id", reqID, "error", err, "remote_addr", r.RemoteAddr)
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	// TODO: Ensure user does not already exist
+	user := &users.User{Username: req.Username}
+	if err := user.SetPassword(req.Password); err != nil {
+		s.Logger.Warnw("Error setting user password.", "req_id", reqID, "error", err, "remote_addr", r.RemoteAddr)
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	if err := s.Users.Store(user); err != nil {
+		s.Logger.Warnw("Error setting user password.", "req_id", reqID, "error", err, "remote_addr", r.RemoteAddr)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+	w.WriteHeader(http.StatusAccepted)
+	s.Logger.Infow("Created user.", "req_id", reqID, "remote_addr", r.RemoteAddr, "username", req.Username)
+}

api/http_test.go

@@ -1,4 +1,4 @@
-package gpaste_test
+package api_test
 
 import (
 	"bytes"
@@ -8,9 +8,15 @@ import (
 	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
+	"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"
 )
 
 func TestHandlers(t *testing.T) {
@@ -21,7 +27,7 @@ func TestHandlers(t *testing.T) {
 		},
 		URL: "http://localhost:8080",
 	}
-	hs := gpaste.NewHTTPServer(cfg)
+	hs := api.NewHTTPServer(cfg)
 
 	t.Run("HandlerIndex", func(t *testing.T) {
 		rr := httptest.NewRecorder()
@@ -97,11 +103,47 @@ func TestHandlers(t *testing.T) {
 			}
 		})
 	})
+	t.Run("HandlerAPIFileDelete", func(t *testing.T) {
+		cfg := &gpaste.ServerConfig{
+			SigningSecret: "abc123",
+			Store: &gpaste.ServerStoreConfig{
+				Type: "memory",
+			},
+			URL: "http://localhost:8080",
+		}
+		hs := api.NewHTTPServer(cfg)
+		fileBody := io.NopCloser(strings.NewReader("roflcopter"))
+		file := &files.File{
+			ID:               uuid.NewString(),
+			OriginalFilename: "testpls.txt",
+			MaxViews:         9,
+			ExpiresOn:        time.Now().Add(10 * time.Hour),
+			Body:             fileBody,
+		}
+
+		if err := hs.Files.Store(file); err != nil {
+			t.Fatalf("Error storing file: %s", err)
+		}
+
+		rr := httptest.NewRecorder()
+		url := fmt.Sprintf("/api/file/%s", file.ID)
+		req := httptest.NewRequest(http.MethodDelete, url, nil)
+		hs.Handler.ServeHTTP(rr, req)
+
+		if rr.Result().StatusCode != http.StatusOK {
+			t.Fatalf("Delete returned wrong status: %s", rr.Result().Status)
+		}
+
+		if _, err := hs.Files.Get(file.ID); err == nil {
+			t.Errorf("Getting after delete returned no error")
+		}
+
+	})
 	t.Run("HandlerAPILogin", func(t *testing.T) {
 		// TODO: Add test
 		username := "admin"
 		password := "admin"
-		user := &gpaste.User{Username: username}
+		user := &users.User{Username: username}
 		if err := user.SetPassword(password); err != nil {
 			t.Fatalf("Error setting user password: %s", err)
 		}
@@ -137,7 +179,7 @@ func TestHandlers(t *testing.T) {
 			t.Fatalf("Error decoding response: %s", err)
 		}
 
-		if err := hs.Auth.ValidateToken(responseData.Token); err != nil {
+		if _, err := hs.Auth.ValidateToken(responseData.Token); err != nil {
 			t.Fatalf("Unable to validate received token: %s", err)
 		}
 	})

api/json.go

@@ -0,0 +1,20 @@
+package api
+
+type RequestAPIUserCreate struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+type RequestAPILogin struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+type ResponseAPILogin struct {
+	Token string `json:"token"`
+}
+type ResponseAPIFilePost struct {
+	Message string `json:"message"`
+	ID      string `json:"id"`
+	URL     string `json:"url"`
+}

api/middleware.go

@@ -0,0 +1,116 @@
+package api
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"git.t-juice.club/torjus/gpaste"
+	"git.t-juice.club/torjus/gpaste/users"
+	"github.com/go-chi/chi/v5/middleware"
+)
+
+type authCtxKey int
+
+const (
+	authCtxUsername authCtxKey = iota
+	authCtxAuthLevel
+	authCtxClaims
+)
+
+func (s *HTTPServer) MiddlewareAccessLogger(next http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
+		t1 := time.Now()
+
+		reqID := middleware.GetReqID(r.Context())
+
+		defer func() {
+			s.AccessLogger.Infow(r.Method,
+				"path", r.URL.Path,
+				"status", ww.Status(),
+				"written", ww.BytesWritten(),
+				"remote_addr", r.RemoteAddr,
+				"processing_time_ms", time.Since(t1).Milliseconds(),
+				"req_id", reqID)
+		}()
+
+		next.ServeHTTP(ww, r)
+	}
+	return http.HandlerFunc(fn)
+}
+
+func (s *HTTPServer) MiddlewareAuthentication(next http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		reqID := middleware.GetReqID(r.Context())
+		header := r.Header.Get("Authorization")
+		if header == "" {
+			s.Logger.Debugw("Request has no auth header.", "req_id", reqID)
+			next.ServeHTTP(w, r)
+			return
+		}
+
+		splitHeader := strings.Split(header, "Bearer ")
+		if len(splitHeader) != 2 {
+			s.Logger.Debugw("Request has invalid token.", "req_id", reqID)
+			next.ServeHTTP(w, r)
+			return
+		}
+		token := splitHeader[1]
+
+		claims, err := s.Auth.ValidateToken(token)
+		if err != nil {
+			s.Logger.Debugw("Request has invalid token.", "req_id", reqID)
+			next.ServeHTTP(w, r)
+			return
+		}
+
+		ctx := context.WithValue(r.Context(), authCtxUsername, claims.Subject)
+		ctx = context.WithValue(ctx, authCtxAuthLevel, claims.Role)
+		ctx = context.WithValue(ctx, authCtxClaims, claims)
+		withCtx := r.WithContext(ctx)
+		s.Logger.Debugw("Request is authenticated.", "req_id", reqID, "username", claims.Subject, "role", claims.Role)
+
+		next.ServeHTTP(w, withCtx)
+	}
+
+	return http.HandlerFunc(fn)
+}
+
+func UsernameFromRequest(r *http.Request) (string, error) {
+	rawUsername := r.Context().Value(authCtxUsername)
+	if rawUsername == nil {
+		return "", fmt.Errorf("no username")
+	}
+	username, ok := rawUsername.(string)
+	if !ok {
+		return "", fmt.Errorf("no username")
+	}
+	return username, nil
+}
+
+func RoleFromRequest(r *http.Request) (users.Role, error) {
+	rawLevel := r.Context().Value(authCtxAuthLevel)
+	if rawLevel == nil {
+		return users.RoleUnset, fmt.Errorf("no username")
+	}
+	level, ok := rawLevel.(users.Role)
+	if !ok {
+		return users.RoleUnset, fmt.Errorf("no username")
+	}
+	return level, nil
+}
+
+func ClaimsFromRequest(r *http.Request) *gpaste.Claims {
+	rawClaims := r.Context().Value(authCtxAuthLevel)
+	if rawClaims == nil {
+		return nil
+	}
+	claims, ok := rawClaims.(*gpaste.Claims)
+	if !ok {
+		return nil
+	}
+	return claims
+}

auth.go

@@ -4,16 +4,23 @@ import (
 	"fmt"
 	"time"
 
+	"git.t-juice.club/torjus/gpaste/users"
 	"github.com/golang-jwt/jwt"
 	"github.com/google/uuid"
 )
 
 type AuthService struct {
-	users      UserStore
+	users      users.UserStore
 	hmacSecret []byte
 }
 
-func NewAuthService(store UserStore, signingSecret []byte) *AuthService {
+type Claims struct {
+	Role users.Role `json:"role,omitempty"`
+
+	jwt.StandardClaims
+}
+
+func NewAuthService(store users.UserStore, signingSecret []byte) *AuthService {
 	return &AuthService{users: store, hmacSecret: signingSecret}
 }
 
@@ -28,13 +35,13 @@ func (as *AuthService) Login(username, password string) (string, error) {
 	}
 
 	// TODO: Set iss and aud
-	claims := jwt.StandardClaims{
-		Subject:   user.Username,
-		ExpiresAt: time.Now().Add(7 * 24 * time.Hour).Unix(),
-		NotBefore: time.Now().Unix(),
-		IssuedAt:  time.Now().Unix(),
-		Id:        uuid.NewString(),
-	}
+	claims := new(Claims)
+	claims.Subject = user.Username
+	claims.ExpiresAt = time.Now().Add(7 * 24 * time.Hour).Unix()
+	claims.NotBefore = time.Now().Unix()
+	claims.IssuedAt = time.Now().Unix()
+	claims.Id = uuid.NewString()
+	claims.Role = user.Role
 
 	token := jwt.NewWithClaims(jwt.GetSigningMethod("HS256"), claims)
 	signed, err := token.SignedString(as.hmacSecret)
@@ -45,17 +52,17 @@ func (as *AuthService) Login(username, password string) (string, error) {
 	return signed, nil
 }
 
-func (as *AuthService) ValidateToken(rawToken string) error {
-	claims := &jwt.StandardClaims{}
+func (as *AuthService) ValidateToken(rawToken string) (*Claims, error) {
+	claims := &Claims{}
 	token, err := jwt.ParseWithClaims(rawToken, claims, func(t *jwt.Token) (interface{}, error) {
 		return as.hmacSecret, nil
 	})
 	if err != nil {
-		return err
+		return nil, err
 	}
 	if !token.Valid {
-		return fmt.Errorf("invalid token")
+		return nil, fmt.Errorf("invalid token")
 	}
 
-	return nil
+	return claims, nil
 }

auth_test.go

@@ -1,21 +1,24 @@
 package gpaste_test
 
 import (
+	"math/rand"
 	"testing"
 
 	"git.t-juice.club/torjus/gpaste"
+	"git.t-juice.club/torjus/gpaste/users"
+	"github.com/google/go-cmp/cmp"
 )
 
 func TestAuth(t *testing.T) {
 	t.Run("Token", func(t *testing.T) {
-		us := gpaste.NewMemoryUserStore()
+		us := users.NewMemoryUserStore()
 		secret := []byte(randomString(16))
 		as := gpaste.NewAuthService(us, secret)
 
 		username := randomString(8)
 		password := randomString(16)
 
-		user := &gpaste.User{Username: username}
+		user := &users.User{Username: username, Role: users.RoleAdmin}
 		if err := user.SetPassword(password); err != nil {
 			t.Fatalf("error setting user password: %s", err)
 		}
@@ -28,12 +31,26 @@ func TestAuth(t *testing.T) {
 			t.Fatalf("Error creating token: %s", err)
 		}
 
-		if err := as.ValidateToken(token); err != nil {
+		claims, err := as.ValidateToken(token)
+		if err != nil {
 			t.Fatalf("Error validating token: %s", err)
 		}
+		if claims.Role != user.Role {
+			t.Fatalf("Token role is not correct: %s", cmp.Diff(claims.Role, user.Role))
+		}
 		invalidToken := `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE2NDMyMjk3NjMsImp0aSI6ImUzNDk5NWI1LThiZmMtNDQyNy1iZDgxLWFmNmQ3OTRiYzM0YiIsImlhdCI6MTY0MjYyNDk2MywibmJmIjoxNjQyNjI0OTYzLCJzdWIiOiJYdE5Hemt5ZSJ9.VM6dkwSLaBv8cStkWRVVv9ADjdUrHGHrlB7GB7Ly7n8`
-		if err := as.ValidateToken(invalidToken); err == nil {
+		if _, err := as.ValidateToken(invalidToken); err == nil {
 			t.Fatalf("Invalid token passed validation")
 		}
 	})
 }
+
+func randomString(length int) string {
+	const charset = "abcdefghijklmnopqrstabcdefghijklmnopqrstuvwxyz" +
+		"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+	b := make([]byte, length)
+	for i := range b {
+		b[i] = charset[rand.Intn(len(charset))]
+	}
+	return string(b)
+}

client/client.go

@@ -0,0 +1,226 @@
+package client
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"path/filepath"
+	"time"
+
+	"git.t-juice.club/torjus/gpaste/api"
+	"git.t-juice.club/torjus/gpaste/files"
+	"github.com/google/uuid"
+	"github.com/kirsle/configdir"
+)
+
+type Client struct {
+	BaseURL   string `json:"base_url"`
+	AuthToken string `json:"auth_token"`
+
+	httpClient http.Client
+}
+
+func (c *Client) WriteConfigToWriter(w io.Writer) error {
+	encoder := json.NewEncoder(w)
+	return encoder.Encode(c)
+}
+func (c *Client) WriteConfig() error {
+	dir := configdir.LocalConfig("gpaste")
+	// Ensure dir exists
+	err := os.MkdirAll(dir, os.ModePerm)
+	if err != nil {
+		return err
+	}
+	path := filepath.Join(dir, "client.json")
+	f, err := os.Create(path)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	return c.WriteConfigToWriter(f)
+}
+
+func (c *Client) LoadConfig() error {
+	dir := configdir.LocalCache("gpaste")
+	path := filepath.Join(dir, "client.json")
+	f, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	return c.LoadConfigFromReader(f)
+}
+
+func (c *Client) LoadConfigFromReader(r io.Reader) error {
+	decoder := json.NewDecoder(r)
+	return decoder.Decode(c)
+}
+
+func (c *Client) Login(ctx context.Context, username, password string) error {
+	url := fmt.Sprintf("%s/api/login", c.BaseURL)
+	// TODO: Change timeout
+	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
+	defer cancel()
+
+	body := new(bytes.Buffer)
+	requestData := api.RequestAPILogin{
+		Username: username,
+		Password: password,
+	}
+	encoder := json.NewEncoder(body)
+	if err := encoder.Encode(&requestData); err != nil {
+		return fmt.Errorf("error encoding response: %w", err)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, body)
+	if err != nil {
+		return fmt.Errorf("error creating request: %w", err)
+	}
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("unable to perform request: %s", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("got non-ok response from server: %s", resp.Status)
+	}
+
+	var responseData api.ResponseAPILogin
+
+	decoder := json.NewDecoder(resp.Body)
+	if err := decoder.Decode(&responseData); err != nil {
+		return fmt.Errorf("unable to parse response: %s", err)
+	}
+	c.AuthToken = responseData.Token
+
+	return nil
+}
+
+func (c *Client) UserCreate(ctx context.Context, username, password string) error {
+	url := fmt.Sprintf("%s/api/user", c.BaseURL)
+	body := new(bytes.Buffer)
+
+	requestData := &api.RequestAPIUserCreate{
+		Username: username,
+		Password: password,
+	}
+	encoder := json.NewEncoder(body)
+	if err := encoder.Encode(requestData); err != nil {
+		return fmt.Errorf("error encoding response: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, body)
+	if err != nil {
+		return fmt.Errorf("error creating request: %w", err)
+	}
+
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.AuthToken))
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("unable to perform request: %s", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusAccepted {
+		return fmt.Errorf("got non-ok response from server: %s", resp.Status)
+	}
+
+	return nil
+}
+
+func (c *Client) Download(ctx context.Context, id string) (io.ReadCloser, error) {
+	url := fmt.Sprintf("%s/api/file/%s", c.BaseURL, id)
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request: %w", err)
+	}
+
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.AuthToken))
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("unable to perform request: %s", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("got non-ok response from server: %s", resp.Status)
+	}
+
+	return resp.Body, nil
+}
+
+func (c *Client) Upload(ctx context.Context, files ...*files.File) ([]api.ResponseAPIFilePost, error) {
+	url := fmt.Sprintf("%s/api/file", c.BaseURL)
+	client := &http.Client{}
+
+	// TODO: Change timeout
+	ctx, cancel := context.WithTimeout(ctx, 10*time.Minute)
+	defer cancel()
+
+	// TODO: Improve buffering
+	buf := &bytes.Buffer{}
+	mw := multipart.NewWriter(buf)
+
+	for _, file := range files {
+		fw, err := mw.CreateFormFile(uuid.Must(uuid.NewRandom()).String(), file.OriginalFilename)
+		if err != nil {
+			return nil, err
+		}
+		if _, err := io.Copy(fw, file.Body); err != nil {
+			return nil, err
+		}
+		file.Body.Close()
+	}
+	mw.Close()
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, buf)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Add("Content-Type", mw.FormDataContentType())
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	var expectedResp []api.ResponseAPIFilePost
+
+	decoder := json.NewDecoder(resp.Body)
+	if err := decoder.Decode(&expectedResp); err != nil {
+		return nil, fmt.Errorf("error decoding response: %w", err)
+	}
+
+	return expectedResp, nil
+}
+
+func (c *Client) Delete(ctx context.Context, id string) error {
+	url := fmt.Sprintf("%s/api/file/%s", c.BaseURL, id)
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodDelete, url, nil)
+	if err != nil {
+		return fmt.Errorf("error creating request: %w", err)
+	}
+
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.AuthToken))
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("unable to perform request: %s", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("got non-ok response from server: %s", resp.Status)
+	}
+
+	return nil
+}

client/client_test.go

@@ -0,0 +1,194 @@
+package client_test
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net"
+	"strings"
+	"testing"
+	"time"
+
+	"git.t-juice.club/torjus/gpaste"
+	"git.t-juice.club/torjus/gpaste/api"
+	"git.t-juice.club/torjus/gpaste/client"
+	"git.t-juice.club/torjus/gpaste/files"
+	"git.t-juice.club/torjus/gpaste/users"
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+	"github.com/google/uuid"
+)
+
+func TestClient(t *testing.T) {
+	listener, err := net.Listen("tcp", ":0")
+	if err != nil {
+		panic(err)
+	}
+
+	port := listener.Addr().(*net.TCPAddr).Port
+	cfg := &gpaste.ServerConfig{
+		LogLevel:      "ERROR",
+		URL:           fmt.Sprintf("http://localhost:%d", port),
+		SigningSecret: "TEST",
+		Store:         &gpaste.ServerStoreConfig{Type: "memory"},
+	}
+
+	srv := api.NewHTTPServer(cfg)
+
+	go func() {
+		srv.Serve(listener)
+	}()
+
+	t.Cleanup(func() {
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+		srv.Shutdown(ctx)
+		listener.Close()
+	})
+
+	// Add users
+	username := "admin"
+	password := "admin"
+	user := &users.User{
+		Username: username,
+		Role:     users.RoleAdmin,
+	}
+	if err := user.SetPassword(password); err != nil {
+		t.Fatalf("Error setting password: %s", err)
+	}
+	if err := srv.Users.Store(user); err != nil {
+		t.Fatalf("Error storing user: %s", err)
+	}
+
+	t.Run("Login", func(t *testing.T) {
+		client := client.Client{BaseURL: cfg.URL}
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		if err := client.Login(ctx, username, password); err != nil {
+			t.Fatalf("Error logging in: %s", err)
+		}
+
+		claims, err := srv.Auth.ValidateToken(client.AuthToken)
+		if err != nil {
+			t.Errorf("unable to get claims from token: %s", err)
+		}
+
+		if claims.Role != user.Role {
+			t.Errorf("Claims have wrong role: %s", cmp.Diff(claims.Role, user.Role))
+		}
+		if claims.Subject != username {
+			t.Errorf("Claims have wrong role: %s", cmp.Diff(claims.Subject, username))
+		}
+
+		t.Run("UserCreate", func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			username := "user"
+			password := "user"
+
+			if err := client.UserCreate(ctx, username, password); err != nil {
+				t.Fatalf("Error creating user: %s", err)
+			}
+
+			user, err := srv.Users.Get(username)
+			if err != nil {
+				t.Fatalf("Error getting new user: %s", err)
+			}
+
+			if user.Username != username {
+				t.Errorf("Username does not match.")
+			}
+			if err := user.ValidatePassword(password); err != nil {
+				t.Errorf("Unable to validate password: %s", err)
+			}
+		})
+	})
+	t.Run("Upload", func(t *testing.T) {
+		client := client.Client{BaseURL: cfg.URL}
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		fileContents := "this is the test file"
+		fileBody := io.NopCloser(strings.NewReader(fileContents))
+		file := &files.File{
+			OriginalFilename: "filename.txt",
+			Body:             fileBody,
+		}
+
+		resp, err := client.Upload(ctx, file)
+		if err != nil {
+			t.Fatalf("Error uploading: %s", err)
+		}
+
+		retrieved, err := srv.Files.Get(resp[0].ID)
+		if err != nil {
+			t.Fatalf("Error getting uploaded file from store: %s", err)
+		}
+		defer retrieved.Body.Close()
+
+		buf := new(strings.Builder)
+		if _, err := io.Copy(buf, retrieved.Body); err != nil {
+			t.Fatalf("error reading body from store: %s", err)
+		}
+		if buf.String() != fileContents {
+			t.Errorf("File contents does not match: %s", cmp.Diff(buf.String(), fileContents))
+		}
+	})
+	t.Run("Download", func(t *testing.T) {
+		client := client.Client{BaseURL: cfg.URL}
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		fileContents := "this is the test file"
+		fileBody := io.NopCloser(strings.NewReader(fileContents))
+		file := &files.File{
+			ID:               uuid.NewString(),
+			OriginalFilename: "filename.txt",
+			Body:             fileBody,
+		}
+
+		if err := srv.Files.Store(file); err != nil {
+			t.Fatalf("Error putting file in store: %s", err)
+		}
+
+		body, err := client.Download(ctx, file.ID)
+		if err != nil {
+			t.Fatalf("Error uploading: %s", err)
+		}
+		defer body.Close()
+
+		buf := new(strings.Builder)
+		if _, err := io.Copy(buf, body); err != nil {
+			t.Fatalf("error reading body from store: %s", err)
+		}
+		if buf.String() != fileContents {
+			t.Errorf("File contents does not match: %s", cmp.Diff(buf.String(), fileContents))
+		}
+	})
+	t.Run("Save", func(t *testing.T) {
+		c := client.Client{BaseURL: "http://example.org/gpaste", AuthToken: "tokenpls"}
+		expectedConfig := "{\"base_url\":\"http://example.org/gpaste\",\"auth_token\":\"tokenpls\"}\n"
+		buf := new(bytes.Buffer)
+		err := c.WriteConfigToWriter(buf)
+		if err != nil {
+			t.Fatalf("Error writing config: %s", err)
+		}
+
+		if diff := cmp.Diff(buf.String(), expectedConfig); diff != "" {
+			t.Errorf("Written config does not match expected: %s", diff)
+		}
+	})
+	t.Run("Load", func(t *testing.T) {
+		c := client.Client{}
+		config := "{\"base_url\":\"http://pasta.example.org\",\"auth_token\":\"tokenpls\"}\n"
+		expectedClient := client.Client{BaseURL: "http://pasta.example.org", AuthToken: "tokenpls"}
+		sr := strings.NewReader(config)
+		if err := c.LoadConfigFromReader(sr); err != nil {
+			t.Fatalf("Error reading config: %s", err)
+		}
+
+		if diff := cmp.Diff(c, expectedClient, cmpopts.IgnoreUnexported(client.Client{})); diff != "" {
+			t.Errorf("Client does not match expected: %s", diff)
+		}
+
+	})
+}

cmd/client/actions/actions.go

@@ -0,0 +1,140 @@
+package actions
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"os"
+	"strings"
+	"syscall"
+	"time"
+
+	"git.t-juice.club/torjus/gpaste/client"
+	"git.t-juice.club/torjus/gpaste/files"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/term"
+)
+
+func ActionUpload(c *cli.Context) error {
+	clnt := client.Client{
+		BaseURL: c.String("url"),
+	}
+	for _, arg := range c.Args().Slice() {
+		f, err := os.Open(arg)
+		if err != nil {
+			return err
+		}
+		defer f.Close()
+		file := &files.File{
+			OriginalFilename: arg,
+			Body:             f,
+		}
+		resp, err := clnt.Upload(c.Context, file)
+		if err != nil {
+			errmsg := fmt.Sprintf("Error uploading file: %s", err)
+			return cli.Exit(errmsg, 1)
+		}
+		fmt.Printf("Uploaded file %s - %s", file.OriginalFilename, resp[0].URL)
+	}
+	return nil
+}
+
+func ActionDelete(c *cli.Context) error {
+	clnt := client.Client{
+		BaseURL: c.String("url"),
+	}
+	for _, arg := range c.Args().Slice() {
+		ctx, cancel := context.WithTimeout(c.Context, 5*time.Second)
+		defer cancel()
+		if err := clnt.Delete(ctx, arg); err != nil {
+			fmt.Printf("Error deleting file %s\n", arg)
+			fmt.Printf("%s\n", err)
+		}
+		fmt.Printf("Deleted %s\n", arg)
+	}
+	return nil
+}
+
+func ActionLogin(c *cli.Context) error {
+	username := c.Args().First()
+	if username == "" {
+		return cli.Exit("USERNAME not supplied.", 1)
+	}
+	password, err := readPassword()
+	if err != nil {
+		return fmt.Errorf("error reading password: %w", err)
+	}
+
+	clnt := client.Client{
+		BaseURL: c.String("url"),
+	}
+	if err := clnt.Login(c.Context, username, password); err != nil {
+		errmsg := fmt.Sprintf("Error logging in: %s", err)
+		return cli.Exit(errmsg, 1)
+	}
+	if err := clnt.WriteConfig(); err != nil {
+		errMsg := fmt.Sprintf("Failed to write config: %s", err)
+		return cli.Exit(errMsg, 1)
+	}
+	// TODO: Store this somewhere, so we don't need to log in each time
+	fmt.Println("Successfully logged in.")
+
+	return nil
+}
+
+func ActionUserCreate(c *cli.Context) error {
+	// TODO: Needs to supply auth token to actually work
+	fmt.Println("Need to be logged in to create user")
+	username := readString("Enter username: ")
+	password, err := readPassword()
+	if err != nil {
+		return fmt.Errorf("error reading password: %w", err)
+	}
+
+	clnt := client.Client{
+		BaseURL: c.String("url"),
+	}
+	ctx, cancel := context.WithTimeout(c.Context, 10*time.Second)
+	defer cancel()
+
+	if err := clnt.Login(ctx, username, password); err != nil {
+		errmsg := fmt.Sprintf("Error logging in: %s", err)
+		return cli.Exit(errmsg, 1)
+	}
+
+	fmt.Println("User to create:")
+	username = readString("Enter username: ")
+	password, err = readPassword()
+	if err != nil {
+		return fmt.Errorf("error reading password: %w", err)
+	}
+
+	if err := clnt.UserCreate(ctx, username, password); err != nil {
+		errmsg := fmt.Sprintf("Error creating user: %s", err)
+		return cli.Exit(errmsg, 1)
+	}
+
+	fmt.Printf("Created user %s\n", username)
+
+	return nil
+}
+
+func readPassword() (string, error) {
+	fmt.Print("Enter Password: ")
+	bytePassword, err := term.ReadPassword(int(syscall.Stdin))
+	if err != nil {
+		return "", err
+	}
+
+	password := string(bytePassword)
+	return strings.TrimSpace(password), nil
+}
+
+func readString(prompt string) string {
+	fmt.Print(prompt)
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		return scanner.Text()
+	}
+	return ""
+}

cmd/client/client.go

@@ -1,21 +1,11 @@
 package main
 
 import (
-	"bytes"
-	"context"
-	"encoding/json"
 	"fmt"
-	"io"
-	"mime/multipart"
-	"net/http"
 	"os"
-	"strings"
-	"syscall"
-	"time"
 
-	"github.com/google/uuid"
+	"git.t-juice.club/torjus/gpaste/cmd/client/actions"
 	"github.com/urfave/cli/v2"
-	"golang.org/x/term"
 )
 
 var (
@@ -45,138 +35,34 @@ func main() {
 				Name:      "upload",
 				Usage:     "Upload file(s)",
 				ArgsUsage: "FILE [FILE]...",
-				Action:    ActionUpload,
+				Action:    actions.ActionUpload,
+			},
+			{
+				Name:      "delete",
+				Usage:     "Delete file(s)",
+				ArgsUsage: "FILE [FILE]...",
+				Action:    actions.ActionDelete,
 			},
 			{
 				Name:      "login",
 				Usage:     "Login to gpaste server",
 				ArgsUsage: "USERNAME",
-				Action:    ActionLogin,
+				Action:    actions.ActionLogin,
+			},
+			{
+				Name:  "admin",
+				Usage: "Admin related commands",
+				Subcommands: []*cli.Command{
+					{
+						Name:      "create-user",
+						Usage:     "Create a new user",
+						ArgsUsage: "USERNAME",
+						Action:    actions.ActionUserCreate,
+					},
+				},
 			},
 		},
 	}
 
 	app.Run(os.Args)
 }
-
-func ActionUpload(c *cli.Context) error {
-	url := fmt.Sprintf("%s/api/file", c.String("url"))
-	client := &http.Client{}
-	// TODO: Change timeout
-	ctx, cancel := context.WithTimeout(c.Context, 10*time.Minute)
-	defer cancel()
-
-	buf := &bytes.Buffer{}
-	mw := multipart.NewWriter(buf)
-
-	for _, arg := range c.Args().Slice() {
-		f, err := os.Open(arg)
-		if err != nil {
-			return err
-		}
-		defer f.Close()
-		fw, err := mw.CreateFormFile(uuid.Must(uuid.NewRandom()).String(), arg)
-		if err != nil {
-			return err
-		}
-		if _, err := io.Copy(fw, f); err != nil {
-			return err
-		}
-	}
-	mw.Close()
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, buf)
-	if err != nil {
-		return err
-	}
-	req.Header.Add("Content-Type", mw.FormDataContentType())
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	var expectedResp []struct {
-		Message string `json:"message"`
-		ID      string `json:"id"`
-		URL     string `json:"url"`
-	}
-
-	decoder := json.NewDecoder(resp.Body)
-	if err := decoder.Decode(&expectedResp); err != nil {
-		return fmt.Errorf("error decoding response: %w", err)
-	}
-
-	for _, r := range expectedResp {
-		fmt.Printf("Uploaded file %s\n", r.ID)
-	}
-	return nil
-}
-
-func ActionLogin(c *cli.Context) error {
-	username := c.Args().First()
-	if username == "" {
-		return cli.Exit("USERNAME not supplied.", 1)
-	}
-	password, err := readPassword()
-	if err != nil {
-		return fmt.Errorf("error reading password: %w", err)
-	}
-
-	url := fmt.Sprintf("%s/api/login", c.String("url"))
-	client := &http.Client{}
-	// TODO: Change timeout
-	ctx, cancel := context.WithTimeout(c.Context, 10*time.Second)
-	defer cancel()
-
-	body := new(bytes.Buffer)
-	requestData := struct {
-		Username string `json:"username"`
-		Password string `json:"password"`
-	}{
-		Username: username,
-		Password: password,
-	}
-	encoder := json.NewEncoder(body)
-	if err := encoder.Encode(&requestData); err != nil {
-		return fmt.Errorf("error encoding response: %w", err)
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, body)
-	if err != nil {
-		return fmt.Errorf("error creating request: %w", err)
-	}
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return fmt.Errorf("unable to perform request: %s", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return cli.Exit("got non-ok response from server", 0)
-	}
-
-	responseData := struct {
-		Token string `json:"token"`
-	}{}
-
-	decoder := json.NewDecoder(resp.Body)
-	if err := decoder.Decode(&responseData); err != nil {
-		return fmt.Errorf("unable to parse response: %s", err)
-	}
-
-	fmt.Printf("Token: %s", responseData.Token)
-
-	return nil
-}
-
-func readPassword() (string, error) {
-	fmt.Print("Enter Password: ")
-	bytePassword, err := term.ReadPassword(int(syscall.Stdin))
-	if err != nil {
-		return "", err
-	}
-
-	password := string(bytePassword)
-	return strings.TrimSpace(password), nil
-}

cmd/server/actions/actions.go

@@ -0,0 +1,105 @@
+package actions
+
+import (
+	"context"
+	"net/http"
+	"os"
+	"os/signal"
+	"strings"
+	"time"
+
+	"git.t-juice.club/torjus/gpaste"
+	"git.t-juice.club/torjus/gpaste/api"
+	"github.com/urfave/cli/v2"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+func ActionServe(c *cli.Context) error {
+	configPath := "gpaste-server.toml"
+	if c.IsSet("config") {
+		configPath = c.String("config")
+	}
+
+	f, err := os.Open(configPath)
+	if err != nil {
+		return cli.Exit(err, 1)
+	}
+	defer f.Close()
+	cfg, err := gpaste.ServerConfigFromReader(f)
+	if err != nil {
+		return cli.Exit(err, 1)
+	}
+	// Setup loggers
+	rootLogger := getRootLogger(cfg.LogLevel)
+	serverLogger := rootLogger.Named("SERV")
+	accessLogger := rootLogger.Named("ACCS")
+
+	// Setup contexts for clean shutdown
+	rootCtx, rootCancel := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer rootCancel()
+	httpCtx, httpCancel := context.WithCancel(rootCtx)
+	defer httpCancel()
+	httpShutdownCtx, httpShutdownCancel := context.WithCancel(context.Background())
+	defer httpShutdownCancel()
+
+	go func() {
+		srv := api.NewHTTPServer(cfg)
+		srv.Addr = cfg.ListenAddr
+		srv.Logger = serverLogger
+		srv.AccessLogger = accessLogger
+
+		// Wait for cancel
+		go func() {
+			<-httpCtx.Done()
+			timeoutCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+			defer cancel()
+			srv.Shutdown(timeoutCtx)
+		}()
+		serverLogger.Infow("Starting HTTP server.", "addr", cfg.ListenAddr)
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			serverLogger.Errorw("Error during shutdown.", "error", err)
+		}
+		serverLogger.Infow("HTTP server shutdown complete.", "addr", cfg.ListenAddr)
+		httpShutdownCancel()
+	}()
+	<-httpShutdownCtx.Done()
+
+	return nil
+}
+
+func getRootLogger(level string) *zap.SugaredLogger {
+	logEncoderConfig := zap.NewProductionEncoderConfig()
+	logEncoderConfig.EncodeCaller = zapcore.ShortCallerEncoder
+	logEncoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
+	logEncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
+	logEncoderConfig.EncodeDuration = zapcore.StringDurationEncoder
+
+	rootLoggerConfig := &zap.Config{
+		Level:            zap.NewAtomicLevelAt(zap.DebugLevel),
+		OutputPaths:      []string{"stdout"},
+		ErrorOutputPaths: []string{"stdout"},
+		Encoding:         "console",
+		EncoderConfig:    logEncoderConfig,
+		DisableCaller:    true,
+	}
+
+	switch strings.ToUpper(level) {
+	case "DEBUG":
+		rootLoggerConfig.DisableCaller = false
+		rootLoggerConfig.Level = zap.NewAtomicLevelAt(zap.DebugLevel)
+	case "INFO":
+		rootLoggerConfig.Level = zap.NewAtomicLevelAt(zap.InfoLevel)
+	case "WARN", "WARNING":
+		rootLoggerConfig.Level = zap.NewAtomicLevelAt(zap.WarnLevel)
+	case "ERR", "ERROR":
+		rootLoggerConfig.Level = zap.NewAtomicLevelAt(zap.ErrorLevel)
+	}
+
+	rootLogger, err := rootLoggerConfig.Build()
+	if err != nil {
+		panic(err)
+	}
+
+	return rootLogger.Sugar()
+}

cmd/server/server.go

@@ -1,18 +1,11 @@
 package main
 
 import (
-	"context"
 	"fmt"
-	"net/http"
 	"os"
-	"os/signal"
-	"strings"
-	"time"
 
-	"git.t-juice.club/torjus/gpaste"
+	"git.t-juice.club/torjus/gpaste/cmd/server/actions"
 	"github.com/urfave/cli/v2"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
 )
 
 var (
@@ -33,97 +26,8 @@ func main() {
 				Usage: "Path to config-file.",
 			},
 		},
-		Action: ActionServe,
+		Action: actions.ActionServe,
 	}
 
 	app.Run(os.Args)
 }
-
-func ActionServe(c *cli.Context) error {
-	configPath := "gpaste-server.toml"
-	if c.IsSet("config") {
-		configPath = c.String("config")
-	}
-
-	f, err := os.Open(configPath)
-	if err != nil {
-		return cli.Exit(err, 1)
-	}
-	defer f.Close()
-	cfg, err := gpaste.ServerConfigFromReader(f)
-	if err != nil {
-		return cli.Exit(err, 1)
-	}
-	// Setup loggers
-	rootLogger := getRootLogger(cfg.LogLevel)
-	serverLogger := rootLogger.Named("SERV")
-	accessLogger := rootLogger.Named("ACCS")
-
-	// Setup contexts for clean shutdown
-	rootCtx, rootCancel := signal.NotifyContext(context.Background(), os.Interrupt)
-	defer rootCancel()
-	httpCtx, httpCancel := context.WithCancel(rootCtx)
-	defer httpCancel()
-	httpShutdownCtx, httpShutdownCancel := context.WithCancel(context.Background())
-	defer httpShutdownCancel()
-
-	go func() {
-		srv := gpaste.NewHTTPServer(cfg)
-		srv.Addr = cfg.ListenAddr
-		srv.Logger = serverLogger
-		srv.AccessLogger = accessLogger
-
-		// Wait for cancel
-		go func() {
-			<-httpCtx.Done()
-			timeoutCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-			defer cancel()
-			srv.Shutdown(timeoutCtx)
-		}()
-		serverLogger.Infow("Starting HTTP server.", "addr", cfg.ListenAddr)
-		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			serverLogger.Errorw("Error during shutdown.", "error", err)
-		}
-		serverLogger.Infow("HTTP server shutdown complete.", "addr", cfg.ListenAddr)
-		httpShutdownCancel()
-	}()
-	<-httpShutdownCtx.Done()
-
-	return nil
-}
-
-func getRootLogger(level string) *zap.SugaredLogger {
-	logEncoderConfig := zap.NewProductionEncoderConfig()
-	logEncoderConfig.EncodeCaller = zapcore.ShortCallerEncoder
-	logEncoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
-	logEncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
-	logEncoderConfig.EncodeDuration = zapcore.StringDurationEncoder
-
-	rootLoggerConfig := &zap.Config{
-		Level:            zap.NewAtomicLevelAt(zap.DebugLevel),
-		OutputPaths:      []string{"stdout"},
-		ErrorOutputPaths: []string{"stdout"},
-		Encoding:         "console",
-		EncoderConfig:    logEncoderConfig,
-		DisableCaller:    true,
-	}
-
-	switch strings.ToUpper(level) {
-	case "DEBUG":
-		rootLoggerConfig.DisableCaller = false
-		rootLoggerConfig.Level = zap.NewAtomicLevelAt(zap.DebugLevel)
-	case "INFO":
-		rootLoggerConfig.Level = zap.NewAtomicLevelAt(zap.InfoLevel)
-	case "WARN", "WARNING":
-		rootLoggerConfig.Level = zap.NewAtomicLevelAt(zap.WarnLevel)
-	case "ERR", "ERROR":
-		rootLoggerConfig.Level = zap.NewAtomicLevelAt(zap.ErrorLevel)
-	}
-
-	rootLogger, err := rootLoggerConfig.Build()
-	if err != nil {
-		panic(err)
-	}
-
-	return rootLogger.Sugar()
-}

files/filestore.go

@@ -1,4 +1,4 @@
-package gpaste
+package files
 
 import (
 	"io"

files/filestore_fs.go

@@ -1,4 +1,4 @@
-package gpaste
+package files
 
 import (
 	"encoding/json"

files/filestore_fs_test.go

@@ -1,22 +1,22 @@
-package gpaste_test
+package files_test
 
 import (
 	"testing"
 
-	"git.t-juice.club/torjus/gpaste"
+	"git.t-juice.club/torjus/gpaste/files"
 )
 
 func TestFSFileStore(t *testing.T) {
 	dir := t.TempDir()
-	s, err := gpaste.NewFSFileStore(dir)
+	s, err := files.NewFSFileStore(dir)
 	if err != nil {
 		t.Fatalf("Error creating store: %s", err)
 	}
 
 	RunFilestoreTest(s, t)
 	persistentDir := t.TempDir()
-	newFunc := func() gpaste.FileStore {
-		s, err := gpaste.NewFSFileStore(persistentDir)
+	newFunc := func() files.FileStore {
+		s, err := files.NewFSFileStore(persistentDir)
 		if err != nil {
 			t.Fatalf("Error creating store: %s", err)
 		}

files/filestore_memory.go

@@ -1,4 +1,4 @@
-package gpaste
+package files
 
 import (
 	"bytes"

files/filestore_memory_test.go

@@ -1,13 +1,13 @@
-package gpaste_test
+package files_test
 
 import (
 	"testing"
 
-	"git.t-juice.club/torjus/gpaste"
+	"git.t-juice.club/torjus/gpaste/files"
 )
 
 func TestMemoryFileStore(t *testing.T) {
-	s := gpaste.NewMemoryFileStore()
+	s := files.NewMemoryFileStore()
 
 	RunFilestoreTest(s, t)
 }

files/filestore_test.go

@@ -1,4 +1,4 @@
-package gpaste_test
+package files_test
 
 import (
 	"bytes"
@@ -7,12 +7,12 @@ import (
 	"testing"
 	"time"
 
-	"git.t-juice.club/torjus/gpaste"
+	"git.t-juice.club/torjus/gpaste/files"
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/uuid"
 )
 
-func RunFilestoreTest(s gpaste.FileStore, t *testing.T) {
+func RunFilestoreTest(s files.FileStore, t *testing.T) {
 	t.Run("Basic", func(t *testing.T) {
 		// Create
 		dataString := "TEST_LOL_OMG"
@@ -20,7 +20,7 @@ func RunFilestoreTest(s gpaste.FileStore, t *testing.T) {
 		bodyBuf := &bytes.Buffer{}
 		bodyBuf.Write([]byte(dataString))
 		body := io.NopCloser(bodyBuf)
-		f := &gpaste.File{
+		f := &files.File{
 			ID:       id,
 			MaxViews: 0,
 			Body:     body,
@@ -78,15 +78,15 @@ func RunFilestoreTest(s gpaste.FileStore, t *testing.T) {
 	})
 }
 
-func RunPersistentFilestoreTest(newStoreFunc func() gpaste.FileStore, t *testing.T) {
+func RunPersistentFilestoreTest(newStoreFunc func() files.FileStore, t *testing.T) {
 	s := newStoreFunc()
 
 	files := []struct {
-		File         *gpaste.File
+		File         *files.File
 		ExpectedData string
 	}{
 		{
-			File: &gpaste.File{
+			File: &files.File{
 				ID:               uuid.NewString(),
 				OriginalFilename: "testfile.txt",
 				MaxViews:         5,
@@ -96,7 +96,7 @@ func RunPersistentFilestoreTest(newStoreFunc func() gpaste.FileStore, t *testing
 			ExpectedData: "cocks!",
 		},
 		{
-			File: &gpaste.File{
+			File: &files.File{
 				ID:               uuid.NewString(),
 				OriginalFilename: "testfile2.txt",
 				MaxViews:         5,

go.mod

@@ -9,6 +9,7 @@ require github.com/go-chi/chi/v5 v5.0.7
 require (
 	github.com/golang-jwt/jwt v3.2.2+incompatible
 	github.com/google/go-cmp v0.5.6
+	github.com/kirsle/configdir v0.0.0-20170128060238-e45d2f54772f
 	github.com/pelletier/go-toml v1.9.4
 	github.com/urfave/cli/v2 v2.3.0
 	go.etcd.io/bbolt v1.3.6
@@ -23,4 +24,5 @@ require (
 	go.uber.org/atomic v1.9.0 // indirect
 	go.uber.org/multierr v1.7.0 // indirect
 	golang.org/x/sys v0.0.0-20220114195835-da31bd327af9 // indirect
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 )

go.sum

@@ -15,6 +15,8 @@ github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
 github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/kirsle/configdir v0.0.0-20170128060238-e45d2f54772f h1:dKccXx7xA56UNqOcFIbuqFjAWPVtP688j5QMgmo6OHU=
+github.com/kirsle/configdir v0.0.0-20170128060238-e45d2f54772f/go.mod h1:4rEELDSfUAlBSyUjPG0JnaNGjf13JySHFeRdD/3dLP0=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=

gpaste-server.toml

@@ -1,4 +1,4 @@
-LogLevel = "INFO"
+LogLevel = "DEBUG"
 URL = "http://paste.example.org"
 ListenAddr = ":8080"
 

middleware.go

@@ -1,30 +0,0 @@
-package gpaste
-
-import (
-	"net/http"
-	"time"
-
-	"github.com/go-chi/chi/v5/middleware"
-)
-
-func (s *HTTPServer) MiddlewareAccessLogger(next http.Handler) http.Handler {
-	fn := func(w http.ResponseWriter, r *http.Request) {
-		ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
-		t1 := time.Now()
-
-		reqID := middleware.GetReqID(r.Context())
-
-		defer func() {
-			s.AccessLogger.Infow(r.Method,
-				"path", r.URL.Path,
-				"status", ww.Status(),
-				"written", ww.BytesWritten(),
-				"remote_addr", r.RemoteAddr,
-				"processing_time_ms", time.Since(t1).Milliseconds(),
-				"req_id", reqID)
-		}()
-
-		next.ServeHTTP(ww, r)
-	}
-	return http.HandlerFunc(fn)
-}

users/user.go

@@ -1,10 +1,19 @@
-package gpaste
+package users
 
 import "golang.org/x/crypto/bcrypt"
 
+type Role string
+
+const (
+	RoleUnset Role = ""
+	RoleUser  Role = "user"
+	RoleAdmin Role = "admin"
+)
+
 type User struct {
 	Username       string `json:"username"`
 	HashedPassword []byte `json:"hashed_password"`
+	Role           Role   `json:"role"`
 }
 
 type UserStore interface {

users/user_test.go

@@ -1,10 +1,10 @@
-package gpaste_test
+package users_test
 
 import (
 	"math/rand"
 	"testing"
 
-	"git.t-juice.club/torjus/gpaste"
+	"git.t-juice.club/torjus/gpaste/users"
 )
 
 func TestUser(t *testing.T) {
@@ -15,7 +15,7 @@ func TestUser(t *testing.T) {
 		}
 
 		for username, password := range userMap {
-			user := &gpaste.User{Username: username}
+			user := &users.User{Username: username}
 			if err := user.SetPassword(password); err != nil {
 				t.Fatalf("Error setting password: %s", err)
 			}

users/userstore_bolt.go

@@ -1,4 +1,4 @@
-package gpaste
+package users
 
 import (
 	"encoding/json"

users/userstore_bolt_test.go

@@ -1,18 +1,18 @@
-package gpaste_test
+package users_test
 
 import (
 	"path/filepath"
 	"testing"
 
-	"git.t-juice.club/torjus/gpaste"
+	"git.t-juice.club/torjus/gpaste/users"
 )
 
 func TestBoltUserStore(t *testing.T) {
 	tmpDir := t.TempDir()
-	newFunc := func() (func(), gpaste.UserStore) {
+	newFunc := func() (func(), users.UserStore) {
 		tmpFile := filepath.Join(tmpDir, randomString(8))
 
-		store, err := gpaste.NewBoltUserStore(tmpFile)
+		store, err := users.NewBoltUserStore(tmpFile)
 		if err != nil {
 			t.Fatalf("Error creating store: %s", err)
 		}

users/userstore_memory.go

@@ -1,4 +1,4 @@
-package gpaste
+package users
 
 import (
 	"fmt"

users/userstore_memory_test.go

@@ -0,0 +1,15 @@
+package users_test
+
+import (
+	"testing"
+
+	"git.t-juice.club/torjus/gpaste/users"
+)
+
+func TestMemoryUserStore(t *testing.T) {
+	newFunc := func() (func(), users.UserStore) {
+		return func() {}, users.NewMemoryUserStore()
+	}
+
+	RunUserStoreTest(newFunc, t)
+}

users/userstore_test.go

@@ -0,0 +1,51 @@
+package users_test
+
+import (
+	"testing"
+
+	"git.t-juice.club/torjus/gpaste/users"
+	"github.com/google/go-cmp/cmp"
+)
+
+func RunUserStoreTest(newFunc func() (func(), users.UserStore), t *testing.T) {
+	t.Run("Basics", func(t *testing.T) {
+		cleanup, s := newFunc()
+		t.Cleanup(cleanup)
+
+		userMap := make(map[string]*users.User)
+		passwordMap := make(map[string]string)
+		for i := 0; i < 10; i++ {
+			username := randomString(8)
+			password := randomString(16)
+			passwordMap[username] = password
+			user := &users.User{
+				Username: username,
+				Role:     users.RoleAdmin,
+			}
+			if err := user.SetPassword(password); err != nil {
+				t.Fatalf("Error setting password: %s", err)
+			}
+			userMap[username] = user
+		}
+
+		for _, user := range userMap {
+			if err := s.Store(user); err != nil {
+				t.Fatalf("Error storing user: %s", err)
+			}
+		}
+
+		for k := range userMap {
+			user, err := s.Get(k)
+			if err != nil {
+				t.Errorf("Error getting user: %s", err)
+			}
+			if err := user.ValidatePassword(passwordMap[user.Username]); err != nil {
+				t.Errorf("Error verifying password: %s", err)
+			}
+
+			if !cmp.Equal(user, userMap[k]) {
+				t.Errorf("User mismatch: %s", cmp.Diff(user, userMap[k]))
+			}
+		}
+	})
+}

userstore_memory_test.go

@@ -1,15 +0,0 @@
-package gpaste_test
-
-import (
-	"testing"
-
-	"git.t-juice.club/torjus/gpaste"
-)
-
-func TestMemoryUserStore(t *testing.T) {
-	newFunc := func() (func(), gpaste.UserStore) {
-		return func() {}, gpaste.NewMemoryUserStore()
-	}
-
-	RunUserStoreTest(newFunc, t)
-}

userstore_test.go

@@ -1,41 +0,0 @@
-package gpaste_test
-
-import (
-	"testing"
-
-	"git.t-juice.club/torjus/gpaste"
-)
-
-func RunUserStoreTest(newFunc func() (func(), gpaste.UserStore), t *testing.T) {
-	t.Run("Basics", func(t *testing.T) {
-		cleanup, s := newFunc()
-		t.Cleanup(cleanup)
-
-		userMap := make(map[string]string)
-		for i := 0; i < 10; i++ {
-			userMap[randomString(8)] = randomString(16)
-		}
-
-		for k, v := range userMap {
-			user := &gpaste.User{
-				Username: k,
-			}
-			if err := user.SetPassword(v); err != nil {
-				t.Fatalf("Error setting password: %s", err)
-			}
-			if err := s.Store(user); err != nil {
-				t.Fatalf("Error storing user: %s", err)
-			}
-		}
-
-		for k, v := range userMap {
-			user, err := s.Get(k)
-			if err != nil {
-				t.Errorf("Error getting user: %s", err)
-			}
-			if err := user.ValidatePassword(v); err != nil {
-				t.Errorf("Error verifying password: %s", err)
-			}
-		}
-	})
-}