golink: add support for deleting links

To delete a link, go to its page in `.detail` and click on the "Delete"
button. Stats for the deleted link are removed as well.

Co-authored-by: Will Norris <will@tailscale.com>
Signed-off-by: Gabriel Wong <gabriel@bifrost.ai>
Signed-off-by: Will Norris <will@tailscale.com>

Author: gabrielwong159

db.go

@@ -133,6 +133,25 @@ func (s *SQLiteDB) Save(link *Link) error {
 	return nil
 }
 
+// Delete removes a Link using its short name.
+func (s *SQLiteDB) Delete(short string) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	result, err := s.db.Exec("DELETE FROM Links WHERE ID = ?", linkID(short))
+	if err != nil {
+		return err
+	}
+	rows, err := result.RowsAffected()
+	if err != nil {
+		return err
+	}
+	if rows != 1 {
+		return fmt.Errorf("expected to affect 1 row, affected %d", rows)
+	}
+	return nil
+}
+
 // LoadStats returns click stats for links.
 func (s *SQLiteDB) LoadStats() (ClickStats, error) {
 	allLinks, err := s.LoadAll()
@@ -186,3 +205,15 @@ func (s *SQLiteDB) SaveStats(stats ClickStats) error {
 	}
 	return tx.Commit()
 }
+
+// DeleteStats deletes click stats for a link.
+func (s *SQLiteDB) DeleteStats(short string) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	_, err := s.db.Exec("DELETE FROM Stats WHERE ID = ?", linkID(short))
+	if err != nil {
+		return err
+	}
+	return nil
+}

db_test.go

@@ -11,8 +11,8 @@ import (
 	"github.com/google/go-cmp/cmp/cmpopts"
 )
 
-// Test saving and loading links for SQLiteDB
-func Test_SQLiteDB_SaveLoadLinks(t *testing.T) {
+// Test saving, loading, and deleting links for SQLiteDB.
+func Test_SQLiteDB_SaveLoadDeleteLinks(t *testing.T) {
 	db, err := NewSQLiteDB(path.Join(t.TempDir(), "links.db"))
 	if err != nil {
 		t.Error(err)
@@ -48,10 +48,25 @@ func Test_SQLiteDB_SaveLoadLinks(t *testing.T) {
 	if !cmp.Equal(got, links, sortLinks) {
 		t.Errorf("db.LoadAll got %v, want %v", got, links)
 	}
+
+	for _, link := range links {
+		if err := db.Delete(link.Short); err != nil {
+			t.Error(err)
+		}
+	}
+
+	got, err = db.LoadAll()
+	if err != nil {
+		t.Error(err)
+	}
+	want := []*Link(nil)
+	if !cmp.Equal(got, want) {
+		t.Errorf("db.LoadAll got %v, want %v", got, want)
+	}
 }
 
-// Test saving and loading stats for SQLiteDB
-func Test_SQLiteDB_SaveLoadStats(t *testing.T) {
+// Test saving, loading, and deleting stats for SQLiteDB.
+func Test_SQLiteDB_SaveLoadDeleteStats(t *testing.T) {
 	db, err := NewSQLiteDB(path.Join(t.TempDir(), "links.db"))
 	if err != nil {
 		t.Error(err)
@@ -94,4 +109,19 @@ func Test_SQLiteDB_SaveLoadStats(t *testing.T) {
 	if !cmp.Equal(got, want) {
 		t.Errorf("db.LoadStats got %v, want %v", got, want)
 	}
+
+	for k := range want {
+		if err := db.DeleteStats(k); err != nil {
+			t.Error(err)
+		}
+	}
+
+	got, err = db.LoadStats()
+	if err != nil {
+		t.Error(err)
+	}
+	want = ClickStats{}
+	if !cmp.Equal(got, want) {
+		t.Errorf("db.LoadStats got %v, want %v", got, want)
+	}
 }

golink.go

@@ -8,7 +8,9 @@ import (
 	"bufio"
 	"bytes"
 	"context"
+	"crypto/rand"
 	"embed"
+	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"flag"
@@ -29,6 +31,7 @@ import (
 	texttemplate "text/template"
 	"time"
 
+	"golang.org/x/net/xsrftoken"
 	"tailscale.com/client/tailscale"
 	"tailscale.com/hostinfo"
 	"tailscale.com/ipn"
@@ -137,6 +140,7 @@ func Run() error {
 	http.HandleFunc("/.help", serveHelp)
 	http.HandleFunc("/.opensearch", serveOpenSearch)
 	http.HandleFunc("/.all", serveAll)
+	http.HandleFunc("/.delete/", serveDelete)
 	http.Handle("/.static/", http.StripPrefix("/.", http.FileServer(http.FS(embeddedFS))))
 
 	if *dev != "" {
@@ -200,6 +204,9 @@ var (
 	// allTmpl is the template used by the http://go/.all page
 	allTmpl *template.Template
 
+	// deleteTmpl is the template used after a link has been deleted.
+	deleteTmpl *template.Template
+
 	// opensearchTmpl is the template used by the http://go/.opensearch page
 	opensearchTmpl *template.Template
 )
@@ -215,13 +222,20 @@ type homeData struct {
 	Clicks []visitData
 }
 
+var xsrfKey string
+
 func init() {
 	homeTmpl = template.Must(template.ParseFS(embeddedFS, "tmpl/base.html", "tmpl/home.html"))
 	detailTmpl = template.Must(template.ParseFS(embeddedFS, "tmpl/base.html", "tmpl/detail.html"))
 	successTmpl = template.Must(template.ParseFS(embeddedFS, "tmpl/base.html", "tmpl/success.html"))
 	helpTmpl = template.Must(template.ParseFS(embeddedFS, "tmpl/base.html", "tmpl/help.html"))
 	allTmpl = template.Must(template.ParseFS(embeddedFS, "tmpl/base.html", "tmpl/all.html"))
+	deleteTmpl = template.Must(template.ParseFS(embeddedFS, "tmpl/base.html", "tmpl/delete.html"))
 	opensearchTmpl = template.Must(template.ParseFS(embeddedFS, "tmpl/opensearch.xml"))
+
+	b := make([]byte, 24)
+	rand.Read(b)
+	xsrfKey = base64.StdEncoding.EncodeToString(b)
 }
 
 // initStats initializes the in-memory stats counter with counts from db.
@@ -266,6 +280,16 @@ func flushStatsLoop() {
 	}
 }
 
+// deleteLinkStats removes the link stats from memory.
+func deleteLinkStats(link *Link) {
+	stats.mu.Lock()
+	delete(stats.clicks, link.Short)
+	delete(stats.dirty, link.Short)
+	stats.mu.Unlock()
+
+	db.DeleteStats(link.Short)
+}
+
 func serveHome(w http.ResponseWriter, short string) {
 	var clicks []visitData
 
@@ -388,6 +412,7 @@ type detailData struct {
 	// Editable indicates whether the current user can edit the link.
 	Editable bool
 	Link     *Link
+	XSRF     string
 }
 
 func serveDetail(w http.ResponseWriter, r *http.Request) {
@@ -426,6 +451,7 @@ func serveDetail(w http.ResponseWriter, r *http.Request) {
 	if link.Owner == login || !ownerExists {
 		data.Editable = true
 		data.Link.Owner = login
+		data.XSRF = xsrftoken.Generate(xsrfKey, login, short)
 	}
 
 	detailTmpl.Execute(w, data)
@@ -521,6 +547,44 @@ func userExists(ctx context.Context, login string) (bool, error) {
 
 var reShortName = regexp.MustCompile(`^\w[\w\-\.]*$`)
 
+func serveDelete(w http.ResponseWriter, r *http.Request) {
+	short := strings.TrimPrefix(r.RequestURI, "/.delete/")
+	if short == "" {
+		http.Error(w, "short required", http.StatusBadRequest)
+		return
+	}
+
+	login, err := currentUser(r)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	link, err := db.Load(short)
+	if errors.Is(err, fs.ErrNotExist) {
+		http.NotFound(w, r)
+		return
+	}
+
+	if link.Owner != login {
+		http.Error(w, "cannot delete link owned by another user", http.StatusForbidden)
+		return
+	}
+
+	if !xsrftoken.Valid(r.PostFormValue("xsrf"), xsrfKey, login, short) {
+		http.Error(w, "invalid XSRF token", http.StatusBadRequest)
+		return
+	}
+
+	if err := db.Delete(short); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	deleteLinkStats(link)
+
+	deleteTmpl.Execute(w, link)
+}
+
 // serveSave handles requests to save or update a Link.  Both short name and
 // long URL are validated for proper format. Existing links may only be updated
 // by their owner.

golink_test.go

@@ -11,6 +11,8 @@ import (
 	"strings"
 	"testing"
 	"time"
+
+	"golang.org/x/net/xsrftoken"
 )
 
 func init() {
@@ -163,6 +165,79 @@ func TestServeSave(t *testing.T) {
 	}
 }
 
+func TestServeDelete(t *testing.T) {
+	var err error
+	db, err = NewSQLiteDB(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	db.Save(&Link{Short: "a", Owner: "a@example.com"})
+	db.Save(&Link{Short: "foo", Owner: "foo@example.com"})
+
+	xsrf := func(short string) string {
+		return xsrftoken.Generate(xsrfKey, "foo@example.com", short)
+	}
+
+	tests := []struct {
+		name        string
+		short       string
+		xsrf        string
+		currentUser func(*http.Request) (string, error)
+		wantStatus  int
+	}{
+		{
+			name:       "missing short",
+			short:      "",
+			wantStatus: http.StatusBadRequest,
+		},
+		{
+			name:       "non-existant link",
+			short:      "does-not-exist",
+			wantStatus: http.StatusNotFound,
+		},
+		{
+			name:       "unowned link",
+			short:      "a",
+			wantStatus: http.StatusForbidden,
+		},
+		{
+			name:       "invalid xsrf",
+			short:      "foo",
+			xsrf:       xsrf("invalid"),
+			wantStatus: http.StatusBadRequest,
+		},
+		{
+			name:       "valid xsrf",
+			short:      "foo",
+			xsrf:       xsrf("foo"),
+			wantStatus: http.StatusOK,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.currentUser != nil {
+				oldCurrentUser := currentUser
+				currentUser = tt.currentUser
+				t.Cleanup(func() {
+					currentUser = oldCurrentUser
+				})
+			}
+
+			r := httptest.NewRequest("POST", "/.delete/"+tt.short, strings.NewReader(url.Values{
+				"xsrf": {tt.xsrf},
+			}.Encode()))
+			r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+			w := httptest.NewRecorder()
+			serveDelete(w, r)
+
+			if w.Code != tt.wantStatus {
+				t.Errorf("serveDelete(%q) = %d; want %d", tt.short, w.Code, tt.wantStatus)
+			}
+		})
+	}
+}
+
 func TestExpandLink(t *testing.T) {
 	tests := []struct {
 		name      string    // test name