summaryrefslogtreecommitdiff
path: root/vrsite/serve.go
diff options
context:
space:
mode:
Diffstat (limited to 'vrsite/serve.go')
-rw-r--r--vrsite/serve.go253
1 files changed, 198 insertions, 55 deletions
diff --git a/vrsite/serve.go b/vrsite/serve.go
index c73630c..c6e1ef1 100644
--- a/vrsite/serve.go
+++ b/vrsite/serve.go
@@ -1,10 +1,24 @@
// serve.go — vrsite as a live web application.
//
-// The log is the only state: it is re-read whenever it grows, notes written
-// from the browser are appended to it, and the repository is only ever read
-// (see jj.go). Pages are rendered per request from the same templates the
-// static export uses; htmx swaps the parts that change on their own —
-// filtered note lists, the activity of agents currently reading, jj queries.
+// The server owns nothing. Three rules keep it that way, and app_test.go holds
+// each of them:
+//
+// - The log is the only thing written. Notes typed in the browser are
+// appended to it exactly as vr appends them; the repository is only ever
+// read (see jj.go), and no file of the app's own is ever created.
+// - Memory is a cache, never a source. The model, the per-change
+// projections, file lists and rendered pages are all derived from the log
+// and the repo, so a restart changes nothing anyone can see.
+// - What is cached is keyed by what it was derived from: the log's
+// generation, and the commit id — not the change id, which is a pointer
+// that moves whenever the change is edited.
+//
+// What a reader chose lives in the URL (which change, how wide the view) or in
+// their own browser (theme, focus, which folders are open). None of it is here.
+//
+// Pages are rendered per request from the same templates the static export
+// uses; htmx swaps the parts that change on their own — filtered note lists,
+// the activity of agents currently reading, jj queries.
package main
import (
@@ -33,6 +47,7 @@ type server struct {
tpl *template.Template
hl *highlighter
theme, light *Theme
+ tx *transcripts
mu sync.Mutex
site *Site
@@ -41,14 +56,19 @@ type server struct {
state logState
gen int
def string // resolved change the log points at
- trees map[string][]*File // change -> file list
- rendered map[string]*File // gen|change|path -> rendered file
+ models map[string]*Site // scope key -> the log projected onto it
+ trees map[string][]*File // scope key|change -> file list
+ rendered map[string]*File // gen|scope|change|path -> rendered file
}
+// scopeAll is the key of the unscoped model — the whole log, every change.
+const scopeAll = "*"
+
func newServer(logPath, repo, title, user string, theme, light *Theme) *server {
sv := &server{logPath: logPath, repo: repo, title: title, user: user,
session: "web:" + user, theme: theme, light: light,
- tpl: newTemplates(), trees: map[string][]*File{}, rendered: map[string]*File{}}
+ tpl: newTemplates(), models: map[string]*Site{}, trees: map[string][]*File{},
+ rendered: map[string]*File{}, tx: newTranscripts(defaultTranscriptRoots())}
sv.hl = newHighlighter(theme, light)
sv.reload(true)
return sv
@@ -63,8 +83,7 @@ func (sv *server) reload(force bool) {
}
if err != nil {
if sv.site == nil {
- sv.site = buildModel(sv.title, nil)
- sv.site.Theme, sv.site.Light = sv.theme, sv.light
+ sv.site = sv.dress(buildModel(sv.title, nil, ""))
}
return
}
@@ -84,61 +103,108 @@ func (sv *server) reload(force bool) {
sv.entries = append(sv.entries, parseLog(buf[:i+1])...)
}
sv.state = st
- sv.site = buildModel(sv.title, sv.entries)
- sv.site.Theme, sv.site.Light, sv.site.Repo = sv.theme, sv.light, sv.repo
+ sv.site = sv.dress(buildModel(sv.title, sv.entries, ""))
sv.gen++
sv.def = ""
+ sv.models = map[string]*Site{}
sv.trees = map[string][]*File{}
sv.rendered = map[string]*File{}
}
-// snap returns the current model, its generation, and the change the log
-// points at (falling back to the working copy when that change is unknown to
-// this repo).
+func (sv *server) dress(s *Site) *Site {
+ s.Theme, s.Light, s.Repo = sv.theme, sv.light, sv.repo
+ return s
+}
+
+// snap returns the whole-log model, its generation, and the change the log
+// points at: the most-logged change this repo actually has, since a log can
+// carry entries from several repos, falling back to the working copy.
func (sv *server) snap() (*Site, int, string) {
sv.mu.Lock()
defer sv.mu.Unlock()
sv.reload(false)
if sv.def == "" {
- def := sv.site.Change
- if def == "" {
- def = "@"
+ for i, c := range sv.site.Ranked {
+ if i == 5 {
+ break // a log with many foreign changes is not worth probing
+ }
+ if id, err := resolveChange(sv.repo, c); err == nil {
+ sv.def = id
+ break
+ }
}
- if id, err := resolveChange(sv.repo, def); err == nil {
- sv.def = id
- } else if id, err := resolveChange(sv.repo, "@"); err == nil {
- sv.def = id
- } else {
- sv.def = def
+ if sv.def == "" {
+ if id, err := resolveChange(sv.repo, "@"); err == nil {
+ sv.def = id
+ } else {
+ sv.def = sv.site.Change
+ }
}
- sv.site.All = sv.filesLocked(sv.site, sv.def)
}
return sv.site, sv.gen, sv.def
}
-func (sv *server) filesLocked(site *Site, change string) []*File {
- if f, ok := sv.trees[change]; ok {
+// modelFor returns the log projected onto one change, or the whole log when
+// change is "". Built once per generation, since the projection is pure.
+func (sv *server) modelFor(change string) *Site {
+ key := change
+ if key == "" {
+ key = scopeAll
+ }
+ sv.mu.Lock()
+ defer sv.mu.Unlock()
+ if s, ok := sv.models[key]; ok {
+ return s
+ }
+ s := sv.site
+ if change != "" {
+ s = sv.dress(buildModel(sv.title, sv.entries, change))
+ }
+ sv.models[key] = s
+ return s
+}
+
+func scopeKey(site *Site) string {
+ if site.Only == "" {
+ return scopeAll
+ }
+ return site.Only
+}
+
+func (sv *server) filesLocked(site *Site, commit, change string) []*File {
+ key := scopeKey(site) + "|" + commit
+ if f, ok := sv.trees[key]; ok {
return f
}
- paths, err := fileList(sv.repo, change)
+ paths, err := fileList(sv.repo, commit)
if err != nil {
return nil
}
f := site.filesAt(paths, change)
- sv.trees[change] = f
+ sv.trees[key] = f
return f
}
-func (sv *server) files(site *Site, change string) []*File {
+func (sv *server) files(site *Site, commit, change string) []*File {
sv.mu.Lock()
defer sv.mu.Unlock()
- return sv.filesLocked(site, change)
+ return sv.filesLocked(site, commit, change)
+}
+
+// forgetDefault drops the chosen change so the next request picks again —
+// the repo moved under us, which is the repo's business, not ours to remember.
+func (sv *server) forgetDefault() {
+ sv.mu.Lock()
+ sv.def = ""
+ sv.mu.Unlock()
}
-// fileAt renders one file at a change: model coverage and notes, source from
-// jj, highlighted. Results are cached per log generation.
-func (sv *server) fileAt(site *Site, gen int, change, path string) *File {
- key := fmt.Sprintf("%d|%s|%s", gen, change, path)
+// fileAt renders one file: model coverage and notes, source from jj,
+// highlighted. commit is the content it is read at and what the cache is keyed
+// on — change only names it on the page — so an edit under the same change id
+// is a different key, never a stale hit.
+func (sv *server) fileAt(site *Site, gen int, commit, change, path string) *File {
+ key := fmt.Sprintf("%d|%s|%s|%s", gen, scopeKey(site), commit, path)
sv.mu.Lock()
if f, ok := sv.rendered[key]; ok {
sv.mu.Unlock()
@@ -155,7 +221,7 @@ func (sv *server) fileAt(site *Site, gen int, change, path string) *File {
if f.Change == "" {
f.Change = change
}
- src, err := fileShow(sv.repo, change, path)
+ src, err := fileShow(sv.repo, commit, path)
switch {
case err != nil:
f.Stub = "not present at this change"
@@ -178,20 +244,56 @@ func (sv *server) fileAt(site *Site, gen int, change, path string) *File {
// ── request plumbing ──────────────────────────────────────────────────────
-// newPage resolves ?rev= and fills in everything the layout needs.
+// newPage answers the two questions every page starts from: which change am I
+// looking at, and am I seeing only what was recorded there. ?rev= picks the
+// change (default: the one the log points at); ?scope=all widens the view to
+// the whole log, and a change nothing was ever recorded at widens by itself,
+// so the site never looks mysteriously empty.
func (sv *server) newPage(r *http.Request, kind, title string) (*page, *Site, error) {
- site, _, def := sv.snap()
- p := &page{Site: site, Kind: kind, Title: title, Root: "/", Live: true,
- User: sv.user, ChangeID: def, Facets: site.Facets()}
- rev := strings.TrimSpace(r.URL.Query().Get("rev"))
- if rev != "" && rev != def {
- id, err := resolveChange(sv.repo, rev)
- if err != nil {
- return p, site, err
+ full, _, def := sv.snap()
+ q := r.URL.Query()
+ p := &page{Site: full, Kind: kind, Title: title, Root: "/", Live: true,
+ User: sv.user, ChangeID: def, Default: def, Path: r.URL.Path, Scope: "change"}
+ rev := strings.TrimSpace(q.Get("rev"))
+ target := rev
+ if target == "" {
+ target = def
+ }
+ row, err := changeBrief(sv.repo, target)
+ if err != nil {
+ if rev == "" {
+ sv.forgetDefault() // the log's change left the repo; pick again
}
- p.Rev, p.ChangeID = rev, id
+ p.Facets = full.Facets()
+ return p, full, err
+ }
+ p.ChangeID, p.Commit, p.ChangeInfo = row.ID, row.Commit, &row
+ if rev != "" && row.ID != def {
+ p.Rev = rev
}
- return p, site, nil
+ if q.Get("scope") == "all" {
+ p.Scope = "all"
+ }
+ return p, sv.rescope(p), nil
+}
+
+// rescope picks the model for the change the page settled on. Handlers that
+// discover their change from the path (a change page) call it again.
+func (sv *server) rescope(p *page) *Site {
+ full, _, _ := sv.snap()
+ site := full
+ p.ScopeEmpty = false
+ if p.Scope == "change" {
+ if full.Votes[p.ChangeID] > 0 {
+ site = sv.modelFor(p.ChangeID)
+ } else {
+ p.ScopeEmpty = true // asked for this change, nothing was recorded here
+ }
+ }
+ p.Site, p.Facets = site, site.Facets()
+ p.Here = full.NotesAt[p.ChangeID]
+ p.Elsewhere = full.NotesTotal - p.Here
+ return site
}
func (sv *server) render(w http.ResponseWriter, p *page) {
@@ -233,6 +335,7 @@ func (sv *server) handler() http.Handler {
mux.HandleFunc("GET /notes/list", sv.notesList)
mux.HandleFunc("POST /notes", sv.addNote)
mux.HandleFunc("GET /activity", sv.activity)
+ mux.HandleFunc("GET /session/{id}", sv.sessionPage)
mux.HandleFunc("GET /jj", sv.jjPage)
mux.HandleFunc("GET /jj/log", sv.jjLog)
mux.HandleFunc("GET /jj/op", sv.jjOp)
@@ -254,6 +357,7 @@ func (sv *server) index(w http.ResponseWriter, r *http.Request) {
if len(p.Notes) > 24 {
p.Notes = p.Notes[:24]
}
+ p.Files = sv.files(site, p.Commit, p.ChangeID)
sv.render(w, p)
}
@@ -264,7 +368,7 @@ func (sv *server) filesPage(w http.ResponseWriter, r *http.Request) {
sv.render(w, p)
return
}
- p.Tree = template.HTML(renderTree(sv.files(site, p.ChangeID), p.codeLink()))
+ p.Tree = template.HTML(renderTree(sv.files(site, p.Commit, p.ChangeID), p.codeLink()))
sv.render(w, p)
}
@@ -275,7 +379,7 @@ func (sv *server) treeFrag(w http.ResponseWriter, r *http.Request) {
return
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
- fmt.Fprint(w, renderTree(sv.files(site, p.ChangeID), p.codeLink()))
+ fmt.Fprint(w, renderTree(sv.files(site, p.Commit, p.ChangeID), p.codeLink()))
}
func (sv *server) codePage(w http.ResponseWriter, r *http.Request) {
@@ -288,7 +392,7 @@ func (sv *server) codePage(w http.ResponseWriter, r *http.Request) {
}
_, gen, _ := sv.snap()
p.Current = path
- p.File = sv.fileAt(site, gen, p.ChangeID, path)
+ p.File = sv.fileAt(site, gen, p.Commit, p.ChangeID, path)
sv.render(w, p)
}
@@ -338,15 +442,25 @@ func (sv *server) addNote(w http.ResponseWriter, r *http.Request) {
http.Error(w, "a note needs text", http.StatusBadRequest)
return
}
+ // a note belongs to the change its writer was reading, which is the one
+ // the form carries — not the working copy, which may have moved on since
+ _, _, def := sv.snap()
rev := strings.TrimSpace(r.FormValue("rev"))
- if rev == "" {
- rev = "@"
+ target := strings.TrimSpace(r.FormValue("change"))
+ for _, fallback := range []string{rev, def, "@"} {
+ if target != "" {
+ break
+ }
+ target = fallback
}
- change, err := resolveChange(sv.repo, rev)
+ change, err := resolveChange(sv.repo, target)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
+ if rev == "" {
+ rev = target
+ }
start := atoiDefault(r.FormValue("start"), 0)
end := atoiDefault(r.FormValue("end"), 0)
if end < start {
@@ -371,6 +485,12 @@ func (sv *server) addNote(w http.ResponseWriter, r *http.Request) {
http.Error(w, "write log: "+err.Error(), http.StatusInternalServerError)
return
}
+ // answer in the same view the writer is looking at, or the note count
+ // coming back would be the whole log's while their page shows one change
+ scope := r.FormValue("scope")
+ if scope != "all" {
+ site = sv.modelFor(change)
+ }
if !htmxReq(r) {
back := r.FormValue("back")
@@ -406,6 +526,24 @@ func (sv *server) activity(w http.ResponseWriter, r *http.Request) {
sv.frag(w, "activity", p)
}
+// sessionPage shows one session's conversation, with ?note=N anchoring the
+// moment a note was written. It renders from the log alone when the harness
+// transcript cannot be found — the reading timeline is still worth having.
+func (sv *server) sessionPage(w http.ResponseWriter, r *http.Request) {
+ id := r.PathValue("id")
+ if err := safeSession(id); err != nil {
+ http.Error(w, err.Error(), http.StatusBadRequest)
+ return
+ }
+ p, site, err := sv.newPage(r, "session", "session "+short(id)+" — "+sv.title)
+ if err != nil {
+ p.Err = err.Error()
+ }
+ q := r.URL.Query()
+ p.Conv = sv.conversation(site, id, atoiDefault(q.Get("note"), 0), q.Get("all") != "")
+ sv.render(w, p)
+}
+
// ── jj ────────────────────────────────────────────────────────────────────
const defaultLimit = 50
@@ -479,8 +617,11 @@ func (sv *server) changePage(w http.ResponseWriter, r *http.Request) {
return
}
p.Change = c
- p.Rev, p.ChangeID = c.Row.ID, c.Row.ID
+ p.Rev, p.ChangeID, p.Commit = c.Row.ID, c.Row.ID, c.Row.Commit
+ p.ChangeInfo = &c.Row
p.Title = c.Row.Short + " — " + sv.title
+ // the page named a change the query string did not, so the view follows it
+ site = sv.rescope(p)
p.Notes = site.FilterNotes(NoteFilter{Change: c.Row.ID})
sv.render(w, p)
}
@@ -510,12 +651,14 @@ func (sv *server) asset(w http.ResponseWriter, r *http.Request) {
w.Write(b)
}
-func serve(addr, logPath, repo, title, user string, theme, light *Theme) {
+func serve(addr, logPath, repo, title, user string, roots []string, theme, light *Theme) {
sv := newServer(logPath, repo, title, user, theme, light)
+ sv.tx = newTranscripts(roots)
site, _, def := sv.snap()
fmt.Printf("vrsite: http://%s — %d notes, %d agents, repo %s at %s\n",
addr, len(site.Notes), len(site.Agents), repo, short(def))
fmt.Printf("vrsite: comments are appended to %s; the repo is never written to\n", logPath)
+ fmt.Printf("vrsite: session transcripts read from %s\n", strings.Join(sv.tx.roots, ", "))
if err := http.ListenAndServe(addr, sv.handler()); err != nil {
fatal("%v", err)
}
generated by cgit v1.3 (git 2.53.0) at 2026-10-02 05:03:22 +0000