Reject unknown DB versions

Avoid disaster with DB migrations
Improve formatting of durations
2025-09-06 09:12:27 +02:00 · 2025-09-04 10:38:31 +02:00 · 2025-01-02 00:36:03 +01:00 · 2024-12-28 00:27:46 +01:00 · 2024-12-27 02:16:14 +01:00 · 2024-12-27 00:25:49 +01:00
5 changed files with 375 additions and 73 deletions
--- a/acid.adoc
+++ b/acid.adoc
@@ -67,6 +67,17 @@ which has the following fields:
 *RunnerName*::
 	Descriptive name of the runner.

+// Intentionally not documenting CreatedUnix, ChangedUnix, DurationSeconds,
+// which can be derived from the objects.
+*Created*, *Changed*::
+	`*time.Time` of task creation and last task state change respectively,
+	or nil if not known.
+*CreatedAgo*, *ChangedAgo*::
+	Abbreviated human-friendly relative elapsed time duration
+	since *Created* and *Changed* respectively.
+*Duration*::
+	`*time.Duration` of the last run in seconds, or nil if not known.
+
 *URL*::
 	*acid* link to the task, where its log output can be seen.
 *RepoURL*::
--- a/acid.go
+++ b/acid.go
@@ -153,6 +153,14 @@ var shellFuncs = ttemplate.FuncMap{

 // --- Utilities ---------------------------------------------------------------

+func localShell() string {
+	if shell := os.Getenv("SHELL"); shell != "" {
+		return shell
+	}
+	// The os/user package doesn't store the parsed out shell field.
+	return "/bin/sh"
+}
+
 func giteaSign(b []byte) string {
 	payloadHmac := hmac.New(sha256.New, []byte(getConfig().Secret))
 	payloadHmac.Write(b)
@@ -173,6 +181,7 @@ func giteaNewRequest(ctx context.Context, method, path string, body io.Reader) (
 func getTasks(ctx context.Context, query string, args ...any) ([]Task, error) {
 	rows, err := gDB.QueryContext(ctx, `
 		SELECT id, owner, repo, hash, runner,
+			created, changed, duration,
 			state, detail, notified,
 			runlog, tasklog, deploylog FROM task `+query, args...)
 	if err != nil {
@@ -184,11 +193,13 @@ func getTasks(ctx context.Context, query string, args ...any) ([]Task, error) {
 	for rows.Next() {
 		var t Task
 		err := rows.Scan(&t.ID, &t.Owner, &t.Repo, &t.Hash, &t.Runner,
+			&t.CreatedUnix, &t.ChangedUnix, &t.DurationSeconds,
 			&t.State, &t.Detail, &t.Notified,
 			&t.RunLog, &t.TaskLog, &t.DeployLog)
 		if err != nil {
 			return nil, err
 		}
+		// We could also update some fields from gRunning.
 		tasks = append(tasks, t)
 	}
 	return tasks, rows.Err()
@@ -209,6 +220,8 @@ var templateTasks = template.Must(template.New("tasks").Parse(`
 <thead>
 	<tr>
 		<th>ID</th>
+		<th>Created</th>
+		<th>Changed</th>
 		<th>Repository</th>
 		<th>Hash</th>
 		<th>Runner</th>
@@ -221,6 +234,8 @@ var templateTasks = template.Must(template.New("tasks").Parse(`
 {{range .}}
 	<tr>
 		<td><a href="task/{{.ID}}">{{.ID}}</a></td>
+		<td align="right"><span title="{{.Created}}">{{.CreatedAgo}}</span></td>
+		<td align="right"><span title="{{.Changed}}">{{.ChangedAgo}}</span></td>
 		<td><a href="{{.RepoURL}}">{{.FullName}}</a></td>
 		<td><a href="{{.CommitURL}}">{{.Hash}}</a></td>
 		<td>{{.RunnerName}}</td>
@@ -236,7 +251,7 @@ var templateTasks = template.Must(template.New("tasks").Parse(`
 `))

 func handleTasks(w http.ResponseWriter, r *http.Request) {
-	tasks, err := getTasks(r.Context(), `ORDER BY id DESC`)
+	tasks, err := getTasks(r.Context(), `ORDER BY changed DESC, id DESC`)
 	if err != nil {
 		http.Error(w,
 			"Error retrieving tasks: "+err.Error(),
@@ -255,41 +270,179 @@ var templateTask = template.Must(template.New("tasks").Parse(`
 <head>
 <title>Task {{.ID}}</title>
 <meta charset="utf-8">
-{{if .IsRunning}}
-<meta http-equiv="refresh" content="5">
-{{end}}
 </head>
 <body>
 <h1><a href="..">Tasks</a> &raquo; {{.ID}}</h1>
 <dl>
+<!-- Remember to synchronise these lists with Javascript updates. -->
+{{if .Created -}}
+<dt>Created</dt>
+	<dd><span id="created" title="{{.Created}}">{{.CreatedAgo}} ago</span></dd>
+{{end -}}
+{{if .Changed -}}
+<dt>Changed</dt>
+	<dd><span id="changed" title="{{.Changed}}">{{.ChangedAgo}} ago</span></dd>
+{{end -}}
 <dt>Project</dt>
-	<dd><a href="{{.RepoURL}}">{{.FullName}}</a></dd>
+	<dd id="project"><a href="{{.RepoURL}}">{{.FullName}}</a></dd>
 <dt>Commit</dt>
-	<dd><a href="{{.CommitURL}}">{{.Hash}}</a></dd>
+	<dd id="commit"><a href="{{.CommitURL}}">{{.Hash}}</a></dd>
 <dt>Runner</dt>
-	<dd>{{.RunnerName}}</dd>
+	<dd id="runner">{{.RunnerName}}</dd>
 <dt>State</dt>
-	<dd>{{.State}}{{if .Detail}} ({{.Detail}}){{end}}</dd>
+	<dd id="state">{{.State}}{{if .Detail}} ({{.Detail}}){{end}}</dd>
 <dt>Notified</dt>
-	<dd>{{.Notified}}</dd>
+	<dd id="notified">{{.Notified}}</dd>
+<dt>Duration</dt>
+	<dd id="duration">{{if .Duration}}{{.Duration}}{{else}}&mdash;{{end}}</dd>
 </dl>
-{{if .RunLog}}
-<h2>Runner log</h2>
-<pre>{{printf "%s" .RunLog}}</pre>
-{{end}}
-{{if .TaskLog}}
-<h2>Task log</h2>
-<pre>{{printf "%s" .TaskLog}}</pre>
-{{end}}
-{{if .DeployLog}}
-<h2>Deploy log</h2>
-<pre>{{printf "%s" .DeployLog}}</pre>
-{{end}}
-</table>
+
+<h2 id="run"{{if not .RunLog}} hidden{{end}}>Runner log</h2>
+<pre id="runlog"{{if not .RunLog}} hidden{{
+end}}>{{printf "%s" .RunLog}}</pre>
+<h2 id="task"{{if not .TaskLog}} hidden{{end}}>Task log</h2>
+<pre id="tasklog"{{if not .TaskLog}} hidden{{
+end}}>{{printf "%s" .TaskLog}}</pre>
+<h2 id="deploy"{{if not .DeployLog}} hidden{{end}}>Deploy log</h2>
+<pre id="deploylog"{{if not .DeployLog}} hidden{{
+end}}>{{printf "%s" .DeployLog}}</pre>
+
+{{if .IsRunning -}}
+<script>
+function get(id) {
+	return document.getElementById(id)
+}
+function getLog(id) {
+	const header = get(id), log = get(id + 'log'), text = log.textContent
+	// lines[-1] is an implementation detail of terminalWriter.Serialize,
+	// lines[-2] is the actual last line.
+	const last = Math.max(0, text.split('\n').length - 2)
+	return {header, log, text, last}
+}
+function refreshLog(log, top, changed) {
+	if (top <= 0)
+		log.log.textContent = changed
+	else
+		log.log.textContent =
+			log.text.split('\n').slice(0, top).join('\n') + '\n' + changed
+
+	const empty = log.log.textContent === ''
+	log.header.hidden = empty
+	log.log.hidden = empty
+}
+let refresher = setInterval(() => {
+	const run = getLog('run'), task = getLog('task'), deploy = getLog('deploy')
+    const url = new URL(window.location.href)
+	url.search = ''
+	url.searchParams.set('json', '')
+	url.searchParams.set('run', run.last)
+	url.searchParams.set('task', task.last)
+	url.searchParams.set('deploy', deploy.last)
+    fetch(url.toString()).then(response => {
+		if (!response.ok)
+			throw response.statusText
+		return response.json()
+	}).then(data => {
+		const scroll = window.scrollY + window.innerHeight
+			>= document.documentElement.scrollHeight
+		if (data.Created) {
+			get('created').title = data.Created
+			get('created').textContent = data.CreatedAgo + " ago"
+		}
+		if (data.Changed) {
+			get('changed').title = data.Changed
+			get('changed').textContent = data.ChangedAgo + " ago"
+		}
+		get('state').textContent = data.State
+		if (data.Detail !== '')
+			get('state').textContent += " (" + data.Detail + ")"
+		get('notified').textContent = String(data.Notified)
+		if (data.Duration)
+			get('duration').textContent = data.Duration
+
+		refreshLog(run, data.RunLogTop, data.RunLog)
+		refreshLog(task, data.TaskLogTop, data.TaskLog)
+		refreshLog(deploy, data.DeployLogTop, data.DeployLog)
+
+		if (scroll)
+			document.documentElement.scrollTop =
+				document.documentElement.scrollHeight
+		if (!data.IsRunning)
+			clearInterval(refresher)
+	}).catch(error => {
+		clearInterval(refresher)
+		alert(error)
+	})
+}, 1000 /* For faster updates than this, we should use WebSockets. */)
+</script>
+{{end -}}
+
 </body>
 </html>
 `))

+// handlerTask serves as the data for JSON encoding and the task HTML template.
+// It needs to explicitly include many convenience method results.
+type handlerTask struct {
+	Task
+	IsRunning bool
+
+	Created      *string // Task.Created?.String()
+	Changed      *string // Task.Changed?.String()
+	CreatedAgo   string  // Task.CreatedAgo()
+	ChangedAgo   string  // Task.ChangedAgo()
+	Duration     *string // Task.Duration?.String()
+	State        string  // Task.State.String()
+	RunLog       string
+	RunLogTop    int
+	TaskLog      string
+	TaskLogTop   int
+	DeployLog    string
+	DeployLogTop int
+}
+
+func toNilableString[T fmt.Stringer](stringer *T) *string {
+	if stringer == nil {
+		return nil
+	}
+	s := (*stringer).String()
+	return &s
+}
+
+func newHandlerTask(task Task) handlerTask {
+	return handlerTask{
+		Task:      task,
+		RunLog:    string(task.RunLog),
+		TaskLog:   string(task.TaskLog),
+		DeployLog: string(task.DeployLog),
+
+		Created:    toNilableString(task.Created()),
+		Changed:    toNilableString(task.Changed()),
+		CreatedAgo: task.CreatedAgo(),
+		ChangedAgo: task.ChangedAgo(),
+		Duration:   toNilableString(task.Duration()),
+		State:      task.State.String(),
+	}
+}
+
+func (ht *handlerTask) updateFromRunning(
+	rt *RunningTask, lastRun, lastTask, lastDeploy int) {
+	ht.IsRunning = true
+	ht.Task.DurationSeconds = rt.elapsed()
+	ht.Duration = toNilableString(ht.Task.Duration())
+
+	rt.RunLog.Lock()
+	defer rt.RunLog.Unlock()
+	rt.TaskLog.Lock()
+	defer rt.TaskLog.Unlock()
+	rt.DeployLog.Lock()
+	defer rt.DeployLog.Unlock()
+
+	ht.RunLog, ht.RunLogTop = rt.RunLog.SerializeUpdates(lastRun)
+	ht.TaskLog, ht.TaskLogTop = rt.TaskLog.SerializeUpdates(lastTask)
+	ht.DeployLog, ht.DeployLogTop = rt.DeployLog.SerializeUpdates(lastDeploy)
+}
+
 func handleTask(w http.ResponseWriter, r *http.Request) {
 	id, err := strconv.Atoi(r.PathValue("id"))
 	if err != nil {
@@ -310,34 +463,32 @@ func handleTask(w http.ResponseWriter, r *http.Request) {
 		return
 	}

-	task := struct {
-		Task
-		IsRunning bool
-	}{Task: tasks[0]}
+	// These are intended for running tasks,
+	// so don't reprocess DB logs, which would only help the last update.
+	q := r.URL.Query()
+	lastRun, _ := strconv.Atoi(q.Get("run"))
+	lastTask, _ := strconv.Atoi(q.Get("task"))
+	lastDeploy, _ := strconv.Atoi(q.Get("deploy"))
+
+	task := newHandlerTask(tasks[0])
 	func() {
 		gRunningMutex.Lock()
 		defer gRunningMutex.Unlock()

-		rt, ok := gRunning[task.ID]
-		task.IsRunning = ok
-		if !ok {
-			return
+		if rt, ok := gRunning[task.ID]; ok {
+			task.updateFromRunning(
+				rt, int(lastRun), int(lastTask), int(lastDeploy))
 		}
-
-		rt.RunLog.Lock()
-		defer rt.RunLog.Unlock()
-		rt.TaskLog.Lock()
-		defer rt.TaskLog.Unlock()
-		rt.DeployLog.Lock()
-		defer rt.DeployLog.Unlock()
-
-		task.RunLog = rt.RunLog.Serialize(0)
-		task.TaskLog = rt.TaskLog.Serialize(0)
-		task.DeployLog = rt.DeployLog.Serialize(0)
 	}()

-	if err := templateTask.Execute(w, &task); err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
+	if q.Has("json") {
+		w.Header().Set("Content-Type", "application/json")
+		err = json.NewEncoder(w).Encode(&task)
+	} else {
+		err = templateTask.Execute(w, &task)
+	}
+	if err != nil {
+		log.Println(err)
 	}
 }

@@ -364,8 +515,9 @@ func createTasks(ctx context.Context,
 	}
 	defer tx.Rollback()

-	stmt, err := tx.Prepare(`INSERT INTO task(owner, repo, hash, runner)
-		VALUES (?, ?, ?, ?)`)
+	stmt, err := tx.Prepare(
+		`INSERT INTO task(owner, repo, hash, runner, created, changed)
+		VALUES (?, ?, ?, ?, unixepoch('now'), unixepoch('now'))`)
 	if err != nil {
 		return err
 	}
@@ -446,8 +598,11 @@ func rpcRestartOne(ctx context.Context, id int64) error {

 	// The executor bumps to "running" after inserting into gRunning,
 	// so we should not need to exclude that state here.
-	result, err := gDB.ExecContext(ctx, `UPDATE task
-		SET state = ?, detail = '', notified = 0 WHERE id = ?`,
+	//
+	// We deliberately do not clear previous run data (duration, *log).
+	result, err := gDB.ExecContext(ctx,
+		`UPDATE task SET changed = unixepoch('now'),
+		state = ?, detail = '', notified = 0 WHERE id = ?`,
 		taskStateNew, id)
 	if err != nil {
 		return fmt.Errorf("%d: %w", id, err)
@@ -691,7 +846,7 @@ func notifierRunCommand(ctx context.Context, task Task) {
 		return
 	}

-	cmd := exec.CommandContext(ctx, "sh")
+	cmd := exec.CommandContext(ctx, localShell())
 	cmd.Stdin = script
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
@@ -840,6 +995,9 @@ func newRunningTask(task Task) (*RunningTask, error) {
 	rt := &RunningTask{DB: task}
 	config := getConfig()

+	// This is for our own tracking, not actually written to database.
+	rt.DB.ChangedUnix = time.Now().Unix()
+
 	var ok bool
 	rt.Runner, ok = config.Runners[rt.DB.Runner]
 	if !ok {
@@ -935,6 +1093,10 @@ func (rt *RunningTask) localEnv() []string {
 	)
 }

+func (rt *RunningTask) elapsed() int64 {
+	return int64(time.Since(time.Unix(rt.DB.ChangedUnix, 0)).Seconds())
+}
+
 // update stores the running task's state in the database.
 func (rt *RunningTask) update() error {
 	for _, i := range []struct {
@@ -951,6 +1113,7 @@ func (rt *RunningTask) update() error {
 			*i.log = []byte{}
 		}
 	}
+	rt.DB.DurationSeconds = rt.elapsed()
 	return rt.DB.update()
 }

@@ -1007,14 +1170,6 @@ func executorDownload(client *ssh.Client, remoteRoot, localRoot string) error {
 	return nil
 }

-func executorLocalShell() string {
-	if shell := os.Getenv("SHELL"); shell != "" {
-		return shell
-	}
-	// The os/user package doesn't store the parsed out shell field.
-	return "/bin/sh"
-}
-
 func executorTmpDir(fallback string) string {
 	// See also: https://systemd.io/TEMPORARY_DIRECTORIES/
 	if tmp := os.Getenv("TMPDIR"); tmp != "" {
@@ -1050,9 +1205,10 @@ func executorDeploy(
 		return err
 	}

-	cmd := exec.CommandContext(ctx, executorLocalShell(), "-c", script.String())
+	cmd := exec.CommandContext(ctx, localShell())
 	cmd.Env = rt.localEnv()
 	cmd.Dir = dir
+	cmd.Stdin = script
 	cmd.Stdout = &rt.DeployLog
 	cmd.Stderr = &rt.DeployLog
 	return cmd.Run()
@@ -1175,6 +1331,7 @@ func executorConnect(
 func executorRunTask(ctx context.Context, task Task) error {
 	rt, err := newRunningTask(task)
 	if err != nil {
+		task.DurationSeconds = 0
 		task.State, task.Detail = taskStateError, "Misconfigured"
 		task.Notified = 0
 		task.RunLog = []byte(err.Error())
@@ -1194,6 +1351,7 @@ func executorRunTask(ctx context.Context, task Task) error {
 		f()
 	}
 	locked(func() {
+		rt.DB.DurationSeconds = 0
 		rt.DB.State, rt.DB.Detail = taskStateRunning, ""
 		rt.DB.Notified = 0
 		rt.DB.RunLog = []byte{}
@@ -1281,19 +1439,20 @@ func executorRunTask(ctx context.Context, task Task) error {
 	defer client.Close()

 	var (
-		ee1 *ssh.ExitError
-		ee2 *executorError
+		eeSSH  *ssh.ExitError
+		eeExec *exec.ExitError
+		ee3    *executorError
 	)

 	err = executorBuild(ctxRunner, client, rt)
 	if err != nil {
 		locked(func() {
-			if errors.As(err, &ee1) {
+			if errors.As(err, &eeSSH) {
 				rt.DB.State, rt.DB.Detail = taskStateFailed, "Scripts failed"
 				fmt.Fprintf(&rt.TaskLog, "\n%s\n", err)
-			} else if errors.As(err, &ee2) {
-				rt.DB.State, rt.DB.Detail = taskStateError, ee2.Detail
-				fmt.Fprintf(&rt.TaskLog, "\n%s\n", ee2.Err)
+			} else if errors.As(err, &ee3) {
+				rt.DB.State, rt.DB.Detail = taskStateError, ee3.Detail
+				fmt.Fprintf(&rt.TaskLog, "\n%s\n", ee3.Err)
 			} else {
 				rt.DB.State, rt.DB.Detail = taskStateError, ""
 				fmt.Fprintf(&rt.TaskLog, "\n%s\n", err)
@@ -1313,12 +1472,12 @@ func executorRunTask(ctx context.Context, task Task) error {
 	locked(func() {
 		if err == nil {
 			rt.DB.State, rt.DB.Detail = taskStateSuccess, ""
-		} else if errors.As(err, &ee1) {
+		} else if errors.As(err, &eeExec) {
 			rt.DB.State, rt.DB.Detail = taskStateFailed, "Deployment failed"
 			fmt.Fprintf(&rt.DeployLog, "\n%s\n", err)
-		} else if errors.As(err, &ee2) {
-			rt.DB.State, rt.DB.Detail = taskStateError, ee2.Detail
-			fmt.Fprintf(&rt.DeployLog, "\n%s\n", ee2.Err)
+		} else if errors.As(err, &ee3) {
+			rt.DB.State, rt.DB.Detail = taskStateError, ee3.Detail
+			fmt.Fprintf(&rt.DeployLog, "\n%s\n", ee3.Err)
 		} else {
 			rt.DB.State, rt.DB.Detail = taskStateError, ""
 			fmt.Fprintf(&rt.DeployLog, "\n%s\n", err)
@@ -1402,6 +1561,11 @@ type Task struct {
 	Hash   string
 	Runner string

+	// True database names for these are occupied by accessors.
+	CreatedUnix     int64
+	ChangedUnix     int64
+	DurationSeconds int64
+
 	State     taskState
 	Detail    string
 	Notified  int64
@@ -1437,10 +1601,61 @@ func (t *Task) CloneURL() string {
 	return fmt.Sprintf("%s/%s/%s.git", getConfig().Gitea, t.Owner, t.Repo)
 }

+func shortDurationString(d time.Duration) string {
+	if d.Abs() >= 24*time.Hour {
+		return strconv.FormatInt(int64(d/time.Hour/24), 10) + "d"
+	} else if d.Abs() >= time.Hour {
+		return strconv.FormatInt(int64(d/time.Hour), 10) + "h"
+	} else if d.Abs() >= time.Minute {
+		return strconv.FormatInt(int64(d/time.Minute), 10) + "m"
+	} else {
+		return strconv.FormatInt(int64(d/time.Second), 10) + "s"
+	}
+}
+
+func (t *Task) Created() *time.Time {
+	if t.CreatedUnix == 0 {
+		return nil
+	}
+	tt := time.Unix(t.CreatedUnix, 0)
+	return &tt
+}
+func (t *Task) Changed() *time.Time {
+	if t.ChangedUnix == 0 {
+		return nil
+	}
+	tt := time.Unix(t.ChangedUnix, 0)
+	return &tt
+}
+
+func (t *Task) CreatedAgo() string {
+	if t.CreatedUnix == 0 {
+		return ""
+	}
+	return shortDurationString(time.Since(*t.Created()))
+}
+
+func (t *Task) ChangedAgo() string {
+	if t.ChangedUnix == 0 {
+		return ""
+	}
+	return shortDurationString(time.Since(*t.Changed()))
+}
+
+func (t *Task) Duration() *time.Duration {
+	if t.DurationSeconds == 0 {
+		return nil
+	}
+	td := time.Duration(t.DurationSeconds * int64(time.Second))
+	return &td
+}
+
 func (t *Task) update() error {
-	_, err := gDB.ExecContext(context.Background(), `UPDATE task
-		SET state = ?, detail = ?, notified = ?,
+	_, err := gDB.ExecContext(context.Background(),
+		`UPDATE task SET changed = unixepoch('now'), duration = ?,
+		state = ?, detail = ?, notified = ?,
 		runlog = ?, tasklog = ?, deploylog = ? WHERE id = ?`,
+		t.DurationSeconds,
 		t.State, t.Detail, t.Notified,
 		t.RunLog, t.TaskLog, t.DeployLog, t.ID)
 	if err == nil {
@@ -1462,6 +1677,10 @@ CREATE TABLE IF NOT EXISTS task(
 	hash      TEXT NOT NULL,     -- commit hash
 	runner    TEXT NOT NULL,     -- the runner to use

+	created   INTEGER NOT NULL DEFAULT 0,    -- creation timestamp
+	changed   INTEGER NOT NULL DEFAULT 0,    -- last state change timestamp
+	duration  INTEGER NOT NULL DEFAULT 0,    -- duration of last run
+
 	state     INTEGER NOT NULL DEFAULT 0,    -- task state
 	detail    TEXT    NOT NULL DEFAULT '',   -- task state detail
 	notified  INTEGER NOT NULL DEFAULT 0,    -- Gitea knows the state
@@ -1519,13 +1738,28 @@ func dbOpen(path string) error {
 			`task`, `deploylog`, `BLOB NOT NULL DEFAULT x''`); err != nil {
 			return err
 		}
-		break
 	case 1:
+		if err = dbEnsureColumn(tx,
+			`task`, `created`, `INTEGER NOT NULL DEFAULT 0`); err != nil {
+			return err
+		}
+		if err = dbEnsureColumn(tx,
+			`task`, `changed`, `INTEGER NOT NULL DEFAULT 0`); err != nil {
+			return err
+		}
+		if err = dbEnsureColumn(tx,
+			`task`, `duration`, `INTEGER NOT NULL DEFAULT 0`); err != nil {
+			return err
+		}
+		fallthrough
+	case 2:
 		// The next migration goes here, remember to increment the number below.
+	default:
+		return fmt.Errorf("unsupported database version: %d", version)
 	}

 	if _, err = tx.Exec(
-		`PRAGMA user_version = ` + strconv.Itoa(1)); err != nil {
+		`PRAGMA user_version = ` + strconv.Itoa(2)); err != nil {
 		return err
 	}
 	return tx.Commit()
--- a/acid_test.go
+++ b/acid_test.go
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"testing"
 	ttemplate "text/template"
+	"time"
 )

 func TestTemplateQuote(t *testing.T) {
@@ -30,3 +31,19 @@ func TestTemplateQuote(t *testing.T) {
 		}
 	}
 }
+
+func TestShortDurationString(t *testing.T) {
+	for _, test := range []struct {
+		d      time.Duration
+		expect string
+	}{
+		{72 * time.Hour, "3d"},
+		{-3 * time.Hour, "-3h"},
+		{12 * time.Minute, "12m"},
+		{time.Millisecond, "0s"},
+	} {
+		if sd := shortDurationString(test.d); sd != test.expect {
+			t.Errorf("%s = %s; want %s\n", test.d, sd, test.expect)
+		}
+	}
+}
--- a/terminal.go
+++ b/terminal.go
@@ -47,6 +47,16 @@ func (tw *terminalWriter) log(format string, v ...interface{}) {
 	}
 }

+// SerializeUpdates returns an update block for a client with a given last line,
+// and the index of the first line in the update block.
+func (tw *terminalWriter) SerializeUpdates(last int) (string, int) {
+	if last < 0 || last >= len(tw.lines) {
+		return "", last
+	}
+	top := tw.lines[last].updateGroup
+	return string(tw.Serialize(top)), top
+}
+
 func (tw *terminalWriter) Serialize(top int) []byte {
 	var b bytes.Buffer
 	for i := top; i < len(tw.lines); i++ {
@@ -104,7 +114,7 @@ func (tw *terminalWriter) processPrint(r rune) {
 	// Refresh update trackers, if necessary.
 	if tw.lines[len(tw.lines)-1].updateGroup > tw.line {
 		for i := tw.line; i < len(tw.lines); i++ {
-			tw.lines[i].updateGroup = tw.line
+			tw.lines[i].updateGroup = min(tw.lines[i].updateGroup, tw.line)
 		}
 	}

--- a/terminal_test.go
+++ b/terminal_test.go
@@ -1,6 +1,9 @@
 package main

-import "testing"
+import (
+	"slices"
+	"testing"
+)

 // This could be way more extensive, but we're not aiming for perfection.
 var tests = []struct {
@@ -68,3 +71,30 @@ Loop:
 		}
 	}
 }
+
+func TestTerminalUpdateGroups(t *testing.T) {
+	tw := terminalWriter{}
+	collect := func() (have []int) {
+		for _, line := range tw.lines {
+			have = append(have, line.updateGroup)
+		}
+		return
+	}
+
+	// 0: A      0 0 0
+	// 1: B X    1 1 1
+	// 2: C Y 1  2 1 1
+	// 3:   Z 2    3 2
+	// 4:     3      4
+	tw.Write([]byte("A\nB\nC\x1b[FX\nY\nZ"))
+	have, want := collect(), []int{0, 1, 1, 3}
+	if !slices.Equal(want, have) {
+		t.Errorf("update groups: %+v; want: %+v", have, want)
+	}
+
+	tw.Write([]byte("\x1b[F1\n2\n3"))
+	have, want = collect(), []int{0, 1, 1, 2, 4}
+	if !slices.Equal(want, have) {
+		t.Errorf("update groups: %+v; want: %+v", have, want)
+	}
+}
Author	SHA1	Message	Date
Přemysl Eric Janouch	6868bde5e6	Reject unknown DB versions All checks were successful Alpine 3.21 Success Details	2025-09-06 09:12:27 +02:00
Přemysl Eric Janouch	d3a046d85d	Avoid disaster with DB migrations All checks were successful Alpine 3.21 Success Details	2025-09-04 10:38:31 +02:00
Přemysl Eric Janouch	6622ea0e1c	Improve formatting of durations All checks were successful Alpine 3.20 Success Details Since "m" could stand for both "minute" and "month", and months vary in length, let's stop at days.	2025-01-02 00:36:03 +01:00
Přemysl Eric Janouch	a492b3b668	Clean up	2024-12-28 00:27:46 +01:00
Přemysl Eric Janouch	280114a5d3	Unify our usage of the local shell	2024-12-27 02:16:14 +01:00
Přemysl Eric Janouch	d83517f67b	Refresh task view dynamically with Javascript All checks were successful Alpine 3.20 Success Details This is more efficient, responsive, and user friendly.	2024-12-27 00:25:49 +01:00
Přemysl Eric Janouch	4f2c2dc8da	Order tasks by change date first All checks were successful Alpine 3.20 Success Details The user presumably does not want to look everywhere for recent tasks.	2024-12-26 16:24:54 +01:00
Přemysl Eric Janouch	55a6693942	Fix deployment error processing	2024-12-26 16:18:37 +01:00
Přemysl Eric Janouch	d5981249b1	Add time information	2024-12-26 16:17:45 +01:00