adyxax/tfstated
1
0
Fork 0
Code Issues 48 Pull requests Releases Packages Wiki Activity Actions

chore(tfstated): refactor backend code to a dedicated package

Browse source
This commit is contained in:
Julien Dessaux 2024-12-30 23:07:00 +01:00
parent 1dbb1b9ee7
commit 36e3d473f2
Signed by: adyxax
GPG key ID: F92E51B86E07177E
9 changed files with 60 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files

28
cmd/tfstated/delete.go
View file

@ -1,28 +0,0 @@
package main
import (
"fmt"
"net/http"
"git.adyxax.org/adyxax/tfstated/pkg/database"
"git.adyxax.org/adyxax/tfstated/pkg/helpers"
)
func handleDelete(db *database.DB) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/" {
helpers.ErrorResponse(w, http.StatusBadRequest,
fmt.Errorf("no state path provided, cannot DELETE /"))
return
}
if success, err := db.DeleteState(r.URL.Path); err != nil {
helpers.ErrorResponse(w, http.StatusInternalServerError, err)
} else if success {
w.WriteHeader(http.StatusOK)
} else {
helpers.ErrorResponse(w, http.StatusNotFound,
fmt.Errorf("state path not found: %s", r.URL.Path))
}
})
}

28
cmd/tfstated/get.go
View file

@ -1,28 +0,0 @@
package main
import (
"fmt"
"net/http"
"git.adyxax.org/adyxax/tfstated/pkg/database"
"git.adyxax.org/adyxax/tfstated/pkg/helpers"
)
func handleGet(db *database.DB) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Cache-Control", "no-store, no-cache")
if r.URL.Path == "/" {
helpers.ErrorResponse(w, http.StatusBadRequest,
fmt.Errorf("no state path provided, cannot GET /"))
return
}
if data, err := db.GetState(r.URL.Path); err != nil {
helpers.ErrorResponse(w, http.StatusInternalServerError, err)
} else {
w.WriteHeader(http.StatusOK)
_, _ = w.Write(data)
}
})
}

12
cmd/tfstated/healthz.go
View file

@ -1,12 +0,0 @@
package main
import "net/http"
func handleHealthz() http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Cache-Control", "no-store, no-cache")
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte("{}"))
})
}

61
cmd/tfstated/lock.go
View file

@ -1,61 +0,0 @@
package main
import (
"fmt"
"net/http"
"regexp"
"time"
"git.adyxax.org/adyxax/tfstated/pkg/database"
"git.adyxax.org/adyxax/tfstated/pkg/helpers"
)
type lockRequest struct {
Created time.Time `json:"Created"`
ID string `json:"ID"`
Info string `json:"Info"`
Operation string `json:"Operation"`
Path string `json:"Path"`
Version string `json:"Version"`
Who string `json:"Who"`
}
var (
validID = regexp.MustCompile("[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}")
)
func (l *lockRequest) valid() []error {
err := make([]error, 0)
if !validID.MatchString(l.ID) {
err = append(err, fmt.Errorf("invalid ID"))
}
return err
}
func handleLock(db *database.DB) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/" {
_ = helpers.Encode(w, http.StatusBadRequest,
fmt.Errorf("no state path provided, cannot LOCK /"))
return
}
var lock lockRequest
if err := helpers.Decode(r, &lock); err != nil {
_ = helpers.Encode(w, http.StatusBadRequest, err)
return
}
if errs := lock.valid(); len(errs) > 0 {
_ = helpers.Encode(w, http.StatusBadRequest,
fmt.Errorf("invalid lock: %+v", errs))
return
}
if success, err := db.SetLockOrGetExistingLock(r.URL.Path, &lock); err != nil {
helpers.ErrorResponse(w, http.StatusInternalServerError, err)
} else if success {
w.WriteHeader(http.StatusOK)
} else {
_ = helpers.Encode(w, http.StatusConflict, lock)
}
})
}

31
cmd/tfstated/main.go
View file

@ -4,17 +4,14 @@ import (
"context"
"fmt"
"io"
"log"
"log/slog"
"net"
"net/http"
"os"
"os/signal"
"sync"
"time"
"git.adyxax.org/adyxax/tfstated/pkg/backend"
"git.adyxax.org/adyxax/tfstated/pkg/database"
"git.adyxax.org/adyxax/tfstated/pkg/logger"
)
func run(
@ -33,31 +30,7 @@ func run(
return err
}
mux := http.NewServeMux()
addRoutes(
mux,
db,
)
host := getenv("TFSTATED_HOST")
if host == "" {
host = "127.0.0.1"
}
port := getenv("TFSTATED_PORT")
if port == "" {
port = "8080"
}
httpServer := &http.Server{
Addr: net.JoinHostPort(host, port),
Handler: logger.Middleware(mux, false),
}
go func() {
log.Printf("listening on %s\n", httpServer.Addr)
if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
_, _ = fmt.Fprintf(stderr, "error listening and serving: %+v\n", err)
}
}()
httpServer := backend.Run(ctx, db, getenv, stderr)
var wg sync.WaitGroup
wg.Add(1)
go func() {

40
cmd/tfstated/post.go
View file

@ -1,40 +0,0 @@
package main
import (
"fmt"
"io"
"net/http"
"git.adyxax.org/adyxax/tfstated/pkg/database"
"git.adyxax.org/adyxax/tfstated/pkg/helpers"
"git.adyxax.org/adyxax/tfstated/pkg/model"
)
func handlePost(db *database.DB) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/" {
helpers.ErrorResponse(w, http.StatusBadRequest,
fmt.Errorf("no state path provided, cannot POST /"),
)
return
}
id := r.URL.Query().Get("ID")
data, err := io.ReadAll(r.Body)
if err != nil || len(data) == 0 {
helpers.ErrorResponse(w, http.StatusBadRequest, err)
return
}
account := r.Context().Value(model.AccountContextKey{}).(*model.Account)
if idMismatch, err := db.SetState(r.URL.Path, account.Id, data, id); err != nil {
if idMismatch {
helpers.ErrorResponse(w, http.StatusConflict, err)
} else {
helpers.ErrorResponse(w, http.StatusInternalServerError, err)
}
} else {
w.WriteHeader(http.StatusOK)
}
})
}

22
cmd/tfstated/routes.go
View file

@ -1,22 +0,0 @@
package main
import (
"net/http"
"git.adyxax.org/adyxax/tfstated/pkg/basic_auth"
"git.adyxax.org/adyxax/tfstated/pkg/database"
)
func addRoutes(
mux *http.ServeMux,
db *database.DB,
) {
mux.Handle("GET /healthz", handleHealthz())
basicAuth := basic_auth.Middleware(db)
mux.Handle("DELETE /", basicAuth(handleDelete(db)))
mux.Handle("GET /", basicAuth(handleGet(db)))
mux.Handle("LOCK /", basicAuth(handleLock(db)))
mux.Handle("POST /", basicAuth(handlePost(db)))
mux.Handle("UNLOCK /", basicAuth(handleUnlock(db)))
}

32
cmd/tfstated/unlock.go
View file

@ -1,32 +0,0 @@
package main
import (
"fmt"
"net/http"
"git.adyxax.org/adyxax/tfstated/pkg/database"
"git.adyxax.org/adyxax/tfstated/pkg/helpers"
)
func handleUnlock(db *database.DB) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/" {
_ = helpers.Encode(w, http.StatusBadRequest,
fmt.Errorf("no state path provided, cannot LOCK /"))
return
}
var lock lockRequest
if err := helpers.Decode(r, &lock); err != nil {
_ = helpers.Encode(w, http.StatusBadRequest, err)
return
}
if success, err := db.Unlock(r.URL.Path, &lock); err != nil {
helpers.ErrorResponse(w, http.StatusInternalServerError, err)
} else if success {
w.WriteHeader(http.StatusOK)
} else {
_ = helpers.Encode(w, http.StatusConflict, lock)
}
})
}