summaryrefslogtreecommitdiff
path: root/pkg
diff options
context:
space:
mode:
Diffstat (limited to 'pkg')
-rw-r--r--pkg/database/db.go5
-rw-r--r--pkg/database/locks.go9
-rw-r--r--pkg/database/sql/000_init.sql6
-rw-r--r--pkg/database/states.go77
-rw-r--r--pkg/database/versions.go7
-rw-r--r--pkg/model/state.go4
-rw-r--r--pkg/model/version.go6
-rw-r--r--pkg/webui/html/login.html2
-rw-r--r--pkg/webui/html/states.html99
-rw-r--r--pkg/webui/html/states_new.html33
-rw-r--r--pkg/webui/routes.go3
-rw-r--r--pkg/webui/state.go7
-rw-r--r--pkg/webui/states.go73
-rw-r--r--pkg/webui/states_new.go84
-rw-r--r--pkg/webui/version.go11
15 files changed, 212 insertions, 214 deletions
diff --git a/pkg/database/db.go b/pkg/database/db.go
index eac31eb..c155ecc 100644
--- a/pkg/database/db.go
+++ b/pkg/database/db.go
@@ -104,7 +104,10 @@ func (db *DB) Close() error {
_ = db.writeDB.Close()
return fmt.Errorf("failed to close read database connection: %w", err)
}
- return db.writeDB.Close()
+ if err := db.writeDB.Close(); err != nil {
+ return fmt.Errorf("failed to close write database connection: %w", err)
+ }
+ return nil
}
func (db *DB) Exec(query string, args ...any) (sql.Result, error) {
diff --git a/pkg/database/locks.go b/pkg/database/locks.go
index e78fd0c..6c0bdfb 100644
--- a/pkg/database/locks.go
+++ b/pkg/database/locks.go
@@ -4,6 +4,9 @@ import (
"database/sql"
"encoding/json"
"errors"
+ "fmt"
+
+ "go.n16f.net/uuid"
)
// Atomically check the lock status of a state and lock it if unlocked. Returns
@@ -18,7 +21,11 @@ func (db *DB) SetLockOrGetExistingLock(path string, lock any) (bool, error) {
if lockData, err = json.Marshal(lock); err != nil {
return err
}
- _, err = tx.ExecContext(db.ctx, `INSERT INTO states(path, lock) VALUES (?, json(?))`, path, lockData)
+ var stateId uuid.UUID
+ if err := stateId.Generate(uuid.V7); err != nil {
+ return fmt.Errorf("failed to generate state id: %w", err)
+ }
+ _, err = tx.ExecContext(db.ctx, `INSERT INTO states(id, path, lock) VALUES (?, ?, json(?))`, stateId, path, lockData)
ret = true
return err
} else {
diff --git a/pkg/database/sql/000_init.sql b/pkg/database/sql/000_init.sql
index 3530e52..0e52c60 100644
--- a/pkg/database/sql/000_init.sql
+++ b/pkg/database/sql/000_init.sql
@@ -24,7 +24,7 @@ CREATE TABLE sessions (
) STRICT;
CREATE TABLE states (
- id INTEGER PRIMARY KEY,
+ id TEXT PRIMARY KEY,
path TEXT NOT NULL,
lock TEXT,
created INTEGER DEFAULT (unixepoch()),
@@ -33,9 +33,9 @@ CREATE TABLE states (
CREATE UNIQUE INDEX states_path on states(path);
CREATE TABLE versions (
- id INTEGER PRIMARY KEY,
+ id TEXT PRIMARY KEY,
account_id TEXT NOT NULL,
- state_id INTEGER,
+ state_id TEXT,
data BLOB,
lock TEXT,
created INTEGER DEFAULT (unixepoch()),
diff --git a/pkg/database/states.go b/pkg/database/states.go
index 75af2e5..d637b14 100644
--- a/pkg/database/states.go
+++ b/pkg/database/states.go
@@ -9,6 +9,7 @@ import (
"git.adyxax.org/adyxax/tfstated/pkg/model"
"github.com/mattn/go-sqlite3"
+ "go.n16f.net/uuid"
)
func (db *DB) CreateState(path string, accountId string, data []byte) (*model.Version, error) {
@@ -16,11 +17,21 @@ func (db *DB) CreateState(path string, accountId string, data []byte) (*model.Ve
if err != nil {
return nil, fmt.Errorf("failed to encrypt state data: %w", err)
}
+ var stateId uuid.UUID
+ if err := stateId.Generate(uuid.V7); err != nil {
+ return nil, fmt.Errorf("failed to generate state id: %w", err)
+ }
+ var versionId uuid.UUID
+ if err := versionId.Generate(uuid.V7); err != nil {
+ return nil, fmt.Errorf("failed to generate version id: %w", err)
+ }
version := &model.Version{
AccountId: accountId,
+ Id: versionId,
+ StateId: stateId,
}
return version, db.WithTransaction(func(tx *sql.Tx) error {
- result, err := tx.ExecContext(db.ctx, `INSERT INTO states(path) VALUES (?)`, path)
+ _, err := tx.ExecContext(db.ctx, `INSERT INTO states(id, path) VALUES (?, ?)`, stateId, path)
if err != nil {
var sqliteErr sqlite3.Error
if errors.As(err, &sqliteErr) {
@@ -31,25 +42,16 @@ func (db *DB) CreateState(path string, accountId string, data []byte) (*model.Ve
}
return fmt.Errorf("failed to insert new state: %w", err)
}
- stateId, err := result.LastInsertId()
- if err != nil {
- return fmt.Errorf("failed to get last insert id for new state: %w", err)
- }
- version.StateId = int(stateId)
- result, err = tx.ExecContext(db.ctx,
- `INSERT INTO versions(account_id, data, state_id)
- VALUES (:accountID, :data, :stateID)`,
+ _, err = tx.ExecContext(db.ctx,
+ `INSERT INTO versions(id, account_id, data, state_id)
+ VALUES (:id, :accountID, :data, :stateID)`,
sql.Named("accountID", accountId),
sql.Named("data", encryptedData),
+ sql.Named("id", versionId),
sql.Named("stateID", stateId))
if err != nil {
return fmt.Errorf("failed to insert new state version: %w", err)
}
- versionId, err := result.LastInsertId()
- if err != nil {
- return fmt.Errorf("failed to get last insert id for new version of the state: %w", err)
- }
- version.Id = int(versionId)
return nil
})
}
@@ -89,7 +91,7 @@ func (db *DB) GetState(path string) ([]byte, error) {
return db.dataEncryptionKey.DecryptAES256(encryptedData)
}
-func (db *DB) LoadStateById(stateId int) (*model.State, error) {
+func (db *DB) LoadStateById(stateId uuid.UUID) (*model.State, error) {
state := model.State{
Id: stateId,
}
@@ -104,7 +106,7 @@ func (db *DB) LoadStateById(stateId int) (*model.State, error) {
if errors.Is(err, sql.ErrNoRows) {
return nil, nil
}
- return nil, fmt.Errorf("failed to load state id %d from database: %w", stateId, err)
+ return nil, fmt.Errorf("failed to load state id %s from database: %w", stateId, err)
}
state.Created = time.Unix(created, 0)
state.Updated = time.Unix(updated, 0)
@@ -139,8 +141,8 @@ func (db *DB) LoadStates() ([]model.State, error) {
return states, nil
}
-// returns true in case of id mismatch
-func (db *DB) SetState(path string, accountID string, data []byte, lockID string) (bool, error) {
+// returns true in case of lock mismatch
+func (db *DB) SetState(path string, accountId string, data []byte, lock string) (bool, error) {
encryptedData, err := db.dataEncryptionKey.EncryptAES256(data)
if err != nil {
return false, fmt.Errorf("failed to encrypt state data: %w", err)
@@ -148,45 +150,50 @@ func (db *DB) SetState(path string, accountID string, data []byte, lockID string
ret := false
return ret, db.WithTransaction(func(tx *sql.Tx) error {
var (
- stateID int64
+ stateId string
lockData []byte
)
- if err = tx.QueryRowContext(db.ctx, `SELECT id, lock->>'ID' FROM states WHERE path = ?;`, path).Scan(&stateID, &lockData); err != nil {
+ if err = tx.QueryRowContext(db.ctx, `SELECT id, lock->>'ID' FROM states WHERE path = ?;`, path).Scan(&stateId, &lockData); err != nil {
if errors.Is(err, sql.ErrNoRows) {
- var result sql.Result
- result, err = tx.ExecContext(db.ctx, `INSERT INTO states(path) VALUES (?)`, path)
- if err != nil {
- return fmt.Errorf("failed to insert new state: %w", err)
+ var stateUUID uuid.UUID
+ if err := stateUUID.Generate(uuid.V7); err != nil {
+ return fmt.Errorf("failed to generate state id: %w", err)
}
- stateID, err = result.LastInsertId()
+ _, err = tx.ExecContext(db.ctx, `INSERT INTO states(id, path) VALUES (?, ?)`, stateUUID, path)
if err != nil {
- return fmt.Errorf("failed to get last insert id for new state: %w", err)
+ return fmt.Errorf("failed to insert new state: %w", err)
}
+ stateId = stateUUID.String()
} else {
return err
}
}
- if lockID != "" && slices.Compare([]byte(lockID), lockData) != 0 {
- err = fmt.Errorf("failed to update state, lock ID does not match")
+ if lock != "" && slices.Compare([]byte(lock), lockData) != 0 {
+ err = fmt.Errorf("failed to update state: lock ID mismatch")
ret = true
return err
}
+ var versionId uuid.UUID
+ if err := versionId.Generate(uuid.V7); err != nil {
+ return fmt.Errorf("failed to generate version id: %w", err)
+ }
_, err = tx.ExecContext(db.ctx,
- `INSERT INTO versions(account_id, state_id, data, lock)
- SELECT :accountID, :stateID, :data, lock
+ `INSERT INTO versions(id, account_id, state_id, data, lock)
+ SELECT :versionId, :accountId, :stateId, :data, lock
FROM states
- WHERE states.id = :stateID;`,
- sql.Named("accountID", accountID),
- sql.Named("stateID", stateID),
- sql.Named("data", encryptedData))
+ WHERE states.id = :stateId;`,
+ sql.Named("accountId", accountId),
+ sql.Named("data", encryptedData),
+ sql.Named("stateId", stateId),
+ sql.Named("versionId", versionId))
if err != nil {
return fmt.Errorf("failed to insert new state version: %w", err)
}
_, err = tx.ExecContext(db.ctx,
`UPDATE states SET updated = ? WHERE id = ?;`,
time.Now().UTC().Unix(),
- stateID)
+ stateId)
if err != nil {
return fmt.Errorf("failed to touch updated for state: %w", err)
}
diff --git a/pkg/database/versions.go b/pkg/database/versions.go
index f05d230..d636b6b 100644
--- a/pkg/database/versions.go
+++ b/pkg/database/versions.go
@@ -7,9 +7,10 @@ import (
"time"
"git.adyxax.org/adyxax/tfstated/pkg/model"
+ "go.n16f.net/uuid"
)
-func (db *DB) LoadVersionById(id int) (*model.Version, error) {
+func (db *DB) LoadVersionById(id uuid.UUID) (*model.Version, error) {
version := model.Version{
Id: id,
}
@@ -29,12 +30,12 @@ func (db *DB) LoadVersionById(id int) (*model.Version, error) {
if errors.Is(err, sql.ErrNoRows) {
return nil, nil
}
- return nil, fmt.Errorf("failed to load version id %d from database: %w", id, err)
+ return nil, fmt.Errorf("failed to load version id %s from database: %w", id, err)
}
version.Created = time.Unix(created, 0)
version.Data, err = db.dataEncryptionKey.DecryptAES256(encryptedData)
if err != nil {
- return nil, fmt.Errorf("failed to decrypt version %d data: %w", id, err)
+ return nil, fmt.Errorf("failed to decrypt version %s data: %w", id, err)
}
return &version, nil
}
diff --git a/pkg/model/state.go b/pkg/model/state.go
index 8e1c277..12f9e83 100644
--- a/pkg/model/state.go
+++ b/pkg/model/state.go
@@ -2,11 +2,13 @@ package model
import (
"time"
+
+ "go.n16f.net/uuid"
)
type State struct {
Created time.Time
- Id int
+ Id uuid.UUID
Lock *string
Path string
Updated time.Time
diff --git a/pkg/model/version.go b/pkg/model/version.go
index f07db45..1d15bd1 100644
--- a/pkg/model/version.go
+++ b/pkg/model/version.go
@@ -3,13 +3,15 @@ package model
import (
"encoding/json"
"time"
+
+ "go.n16f.net/uuid"
)
type Version struct {
AccountId string
Created time.Time
Data json.RawMessage
- Id int
+ Id uuid.UUID
Lock *string
- StateId int
+ StateId uuid.UUID
}
diff --git a/pkg/webui/html/login.html b/pkg/webui/html/login.html
index deb6d4a..bdc8fa7 100644
--- a/pkg/webui/html/login.html
+++ b/pkg/webui/html/login.html
@@ -2,7 +2,7 @@
<main class="responsive">
<form action="/login" method="post">
<fieldset>
- <div class="field border label{{ if .Forbidden }} invalid{{ end}}">
+ <div class="field border label{{ if .Forbidden }} invalid{{ end }}">
<input autofocus
id="username"
name="username"
diff --git a/pkg/webui/html/states.html b/pkg/webui/html/states.html
index 37d80cf..be8329a 100644
--- a/pkg/webui/html/states.html
+++ b/pkg/webui/html/states.html
@@ -1,38 +1,71 @@
{{ define "main" }}
<main class="responsive" id="main">
- <a href="/states/new">
- <button class="small-round">
- <i>add</i>
- <span>New</span>
- </button>
- </a>
- <table class="clickable-rows no-space">
- <thead>
- <tr>
- <th>Path</th>
- <th>Updated</th>
- <th>Locked</th>
- </tr>
- </thead>
- <tbody>
- {{ range .States }}
- <tr>
- <td><a href="/state/{{ .Id }}">{{ .Path }}</a></td>
- <td><a href="/state/{{ .Id }}">{{ .Updated }}</a></td>
- <td>
- <a href="/state/{{ .Id }}">
- {{ if eq .Lock nil }}no{{ else }}
- <span>yes</span>
- <div class="tooltip left max">
- <b>Lock</b>
- <p>{{ .Lock }}</p>
- </div>
+ <div>
+ <div class="tabs">
+ <a data-ui="#explorer"{{ if eq .ActiveTab 0 }} class="active"{{ end }}>States</a>
+ <a data-ui="#new"{{ if eq .ActiveTab 1 }} class="active"{{ end }}>Create New State</a>
+ </div>
+ <div id="explorer" class="page padding{{ if eq .ActiveTab 0 }} active{{ end }}">
+ <table class="clickable-rows no-space">
+ <thead>
+ <tr>
+ <th>Path</th>
+ <th>Updated</th>
+ <th>Locked</th>
+ </tr>
+ </thead>
+ <tbody>
+ {{ range .States }}
+ <tr>
+ <td><a href="/state/{{ .Id }}">{{ .Path }}</a></td>
+ <td><a href="/state/{{ .Id }}">{{ .Updated }}</a></td>
+ <td>
+ <a href="/state/{{ .Id }}">
+ {{ if eq .Lock nil }}no{{ else }}
+ <span>yes</span>
+ <div class="tooltip left max">
+ <b>Lock</b>
+ <p>{{ .Lock }}</p>
+ </div>
+ {{ end }}
+ </a>
+ </td>
+ </tr>
+ {{ end }}
+ </tbody>
+ </table>
+ </div>
+ <div id="new" class="page padding{{ if eq .ActiveTab 1 }} active{{ end }}">
+ <form action="/states" enctype="multipart/form-data" method="post">
+ <fieldset>
+ <div class="field border label{{ if .PathError }} invalid{{ end }}">
+ <input autofocus
+ id="path"
+ name="path"
+ required
+ type="text"
+ value="{{ .Path }}">
+ <label for="path">Path</label>
+ {{ if .PathDuplicate }}
+ <span class="error">This path already exist</span>
+ {{ else if .PathError }}
+ <span class="error">Invalid path</span>
+ {{ else }}
+ <span class="helper">Valid URL path beginning with a /</span>
{{ end }}
- </a>
- </td>
- </tr>
- {{ end }}
- </tbody>
- </table>
+ </div>
+ <div class="field label border">
+ <input name="file"
+ required
+ type="file">
+ <input type="text">
+ <label>File</label>
+ <span class="helper">JSON state file</span>
+ </div>
+ <button class="small-round" type="submit" value="submit">New</button>
+ </fieldset>
+ </form>
+ </div>
+ </div>
</main>
{{ end }}
diff --git a/pkg/webui/html/states_new.html b/pkg/webui/html/states_new.html
deleted file mode 100644
index 68facc7..0000000
--- a/pkg/webui/html/states_new.html
+++ /dev/null
@@ -1,33 +0,0 @@
-{{ define "main" }}
-<main class="responsive">
- <form action="/states/new" enctype="multipart/form-data" method="post">
- <fieldset>
- <div class="field border label{{ if .PathError }} invalid{{ end }}">
- <input autofocus
- id="path"
- name="path"
- required
- type="text"
- value="{{ .Path }}">
- <label for="path">Path</label>
- {{ if .PathDuplicate }}
- <span class="error">This path already exist</span>
- {{ else if .PathError }}
- <span class="error">Invalid path</span>
- {{ else }}
- <span class="helper">Valid URL path beginning with a /</span>
- {{ end }}
- </div>
- <div class="field label border">
- <input name="file"
- required
- type="file">
- <input type="text">
- <label>File</label>
- <span class="helper">JSON state file</span>
- </div>
- <button class="small-round" type="submit" value="submit">New</button>
- </fieldset>
- </form>
-</main>
-{{ end }}
diff --git a/pkg/webui/routes.go b/pkg/webui/routes.go
index 7ee7841..5c500d2 100644
--- a/pkg/webui/routes.go
+++ b/pkg/webui/routes.go
@@ -19,8 +19,7 @@ func addRoutes(
mux.Handle("GET /settings", requireLogin(handleSettingsGET(db)))
mux.Handle("POST /settings", requireLogin(handleSettingsPOST(db)))
mux.Handle("GET /states", requireLogin(handleStatesGET(db)))
- mux.Handle("GET /states/new", requireLogin(handleStatesNewGET(db)))
- mux.Handle("POST /states/new", requireLogin(handleStatesNewPOST(db)))
+ mux.Handle("POST /states", requireLogin(handleStatesPOST(db)))
mux.Handle("GET /state/{id}", requireLogin(handleStateGET(db)))
mux.Handle("GET /static/", cache(http.FileServer(http.FS(staticFS))))
mux.Handle("GET /version/{id}", requireLogin(handleVersionGET(db)))
diff --git a/pkg/webui/state.go b/pkg/webui/state.go
index 2ad1597..c12ee03 100644
--- a/pkg/webui/state.go
+++ b/pkg/webui/state.go
@@ -3,10 +3,10 @@ package webui
import (
"html/template"
"net/http"
- "strconv"
"git.adyxax.org/adyxax/tfstated/pkg/database"
"git.adyxax.org/adyxax/tfstated/pkg/model"
+ "go.n16f.net/uuid"
)
var stateTemplate = template.Must(template.ParseFS(htmlFS, "html/base.html", "html/state.html"))
@@ -19,9 +19,8 @@ func handleStateGET(db *database.DB) http.Handler {
Versions []model.Version
}
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- stateIdStr := r.PathValue("id")
- stateId, err := strconv.Atoi(stateIdStr)
- if err != nil {
+ var stateId uuid.UUID
+ if err := stateId.Parse(r.PathValue("id")); err != nil {
errorResponse(w, http.StatusBadRequest, err)
return
}
diff --git a/pkg/webui/states.go b/pkg/webui/states.go
index a0d16ca..c68b2c9 100644
--- a/pkg/webui/states.go
+++ b/pkg/webui/states.go
@@ -1,29 +1,92 @@
package webui
import (
+ "fmt"
"html/template"
+ "io"
"net/http"
+ "net/url"
+ "path"
"git.adyxax.org/adyxax/tfstated/pkg/database"
"git.adyxax.org/adyxax/tfstated/pkg/model"
)
+type StatesPage struct {
+ ActiveTab int
+ Page *Page
+ Path string
+ PathError bool
+ PathDuplicate bool
+ States []model.State
+}
+
var statesTemplates = template.Must(template.ParseFS(htmlFS, "html/base.html", "html/states.html"))
func handleStatesGET(db *database.DB) http.Handler {
- type StatesData struct {
- Page *Page
- States []model.State
- }
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
states, err := db.LoadStates()
if err != nil {
errorResponse(w, http.StatusInternalServerError, err)
return
}
- render(w, statesTemplates, http.StatusOK, StatesData{
+ render(w, statesTemplates, http.StatusOK, StatesPage{
Page: makePage(r, &Page{Title: "States", Section: "states"}),
States: states,
})
})
}
+
+func handleStatesPOST(db *database.DB) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ // file upload limit of 20MB
+ if err := r.ParseMultipartForm(20 << 20); err != nil {
+ errorResponse(w, http.StatusBadRequest, err)
+ return
+ }
+ file, _, err := r.FormFile("file")
+ if err != nil {
+ errorResponse(w, http.StatusBadRequest, err)
+ return
+ }
+ defer file.Close()
+ statePath := r.FormValue("path")
+ parsedStatePath, err := url.Parse(statePath)
+ if err != nil || path.Clean(parsedStatePath.Path) != statePath || statePath[0] != '/' {
+ render(w, statesTemplates, http.StatusBadRequest, StatesPage{
+ ActiveTab: 1,
+ Page: makePage(r, &Page{Title: "New State", Section: "states"}),
+ Path: statePath,
+ PathError: true,
+ })
+ return
+ }
+ data, err := io.ReadAll(file)
+ if err != nil {
+ errorResponse(w, http.StatusBadRequest, fmt.Errorf("failed to read uploaded file: %w", err))
+ return
+ }
+ fileType := http.DetectContentType(data)
+ if fileType != "text/plain; charset=utf-8" {
+ errorResponse(w, http.StatusBadRequest, fmt.Errorf("invalid file type: expected \"text/plain; charset=utf-8\" but got \"%s\"", fileType))
+ return
+ }
+ account := r.Context().Value(model.AccountContextKey{}).(*model.Account)
+ version, err := db.CreateState(statePath, account.Id, data)
+ if err != nil {
+ errorResponse(w, http.StatusInternalServerError, err)
+ return
+ }
+ if version == nil {
+ render(w, statesTemplates, http.StatusBadRequest, StatesPage{
+ ActiveTab: 1,
+ Page: makePage(r, &Page{Title: "New State", Section: "states"}),
+ Path: statePath,
+ PathDuplicate: true,
+ })
+ return
+ }
+ destination := path.Join("/version", version.Id.String())
+ http.Redirect(w, r, destination, http.StatusFound)
+ })
+}
diff --git a/pkg/webui/states_new.go b/pkg/webui/states_new.go
deleted file mode 100644
index 8551191..0000000
--- a/pkg/webui/states_new.go
+++ /dev/null
@@ -1,84 +0,0 @@
-package webui
-
-import (
- "fmt"
- "html/template"
- "io"
- "net/http"
- "net/url"
- "path"
- "strconv"
-
- "git.adyxax.org/adyxax/tfstated/pkg/database"
- "git.adyxax.org/adyxax/tfstated/pkg/model"
-)
-
-type StatesNewPage struct {
- Page *Page
- fileError bool
- Path string
- PathDuplicate bool
- PathError bool
-}
-
-var statesNewTemplates = template.Must(template.ParseFS(htmlFS, "html/base.html", "html/states_new.html"))
-
-func handleStatesNewGET(db *database.DB) http.Handler {
- return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- render(w, statesNewTemplates, http.StatusOK, StatesNewPage{
- Page: makePage(r, &Page{Title: "New State", Section: "states"}),
- })
- })
-}
-
-func handleStatesNewPOST(db *database.DB) http.Handler {
- return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- // file upload limit of 20MB
- if err := r.ParseMultipartForm(20 << 20); err != nil {
- errorResponse(w, http.StatusBadRequest, err)
- return
- }
- file, _, err := r.FormFile("file")
- if err != nil {
- errorResponse(w, http.StatusBadRequest, err)
- return
- }
- defer file.Close()
- statePath := r.FormValue("path")
- parsedStatePath, err := url.Parse(statePath)
- if err != nil || path.Clean(parsedStatePath.Path) != statePath || statePath[0] != '/' {
- render(w, statesNewTemplates, http.StatusBadRequest, StatesNewPage{
- Page: makePage(r, &Page{Title: "New State", Section: "states"}),
- Path: statePath,
- PathError: true,
- })
- return
- }
- data, err := io.ReadAll(file)
- if err != nil {
- errorResponse(w, http.StatusBadRequest, fmt.Errorf("failed to read uploaded file: %w", err))
- return
- }
- fileType := http.DetectContentType(data)
- if fileType != "text/plain; charset=utf-8" {
- errorResponse(w, http.StatusBadRequest, fmt.Errorf("invalid file type: expected \"text/plain; charset=utf-8\" but got \"%s\"", fileType))
- return
- }
- account := r.Context().Value(model.AccountContextKey{}).(*model.Account)
- version, err := db.CreateState(statePath, account.Id, data)
- if err != nil {
- errorResponse(w, http.StatusInternalServerError, err)
- return
- }
- if version == nil {
- render(w, statesNewTemplates, http.StatusBadRequest, StatesNewPage{
- Page: makePage(r, &Page{Title: "New State", Section: "states"}),
- Path: statePath,
- PathDuplicate: true,
- })
- return
- }
- destination := path.Join("/version", strconv.Itoa(version.Id))
- http.Redirect(w, r, destination, http.StatusFound)
- })
-}
diff --git a/pkg/webui/version.go b/pkg/webui/version.go
index a577d5f..62a0e22 100644
--- a/pkg/webui/version.go
+++ b/pkg/webui/version.go
@@ -1,13 +1,13 @@
package webui
import (
- "fmt"
"html/template"
"net/http"
- "strconv"
+ "path"
"git.adyxax.org/adyxax/tfstated/pkg/database"
"git.adyxax.org/adyxax/tfstated/pkg/model"
+ "go.n16f.net/uuid"
)
var versionTemplate = template.Must(template.ParseFS(htmlFS, "html/base.html", "html/version.html"))
@@ -21,9 +21,8 @@ func handleVersionGET(db *database.DB) http.Handler {
VersionData string
}
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- versionIdStr := r.PathValue("id")
- versionId, err := strconv.Atoi(versionIdStr)
- if err != nil {
+ var versionId uuid.UUID
+ if err := versionId.Parse(r.PathValue("id")); err != nil {
errorResponse(w, http.StatusBadRequest, err)
return
}
@@ -49,7 +48,7 @@ func handleVersionGET(db *database.DB) http.Handler {
versionData := string(version.Data[:])
render(w, versionTemplate, http.StatusOK, VersionsData{
Page: makePage(r, &Page{
- Precedent: fmt.Sprintf("/state/%d", state.Id),
+ Precedent: path.Join("/state/", state.Id.String()),
Section: "states",
Title: state.Path,
}),
generated by cgit v1.2.3 (git 2.39.1) at 2025-02-22 21:23:07 +0000