commit 907dedfc0829ec27b97ed51e615cf67c109a43f6 · notnite.com/core

+15 -12

cmd/knotserver/main.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
        
       	"fmt"

     

       6
       6
       -
       	"log"

     

       7
       7
       -
       	"log/slog"

     

       8
       6
        
       	"net/http"

     

       9
       9
       -
       	"os"

     

       10
       7
        
       

     

       11
       8
        
       	"github.com/sotangled/tangled/knotserver"

     

       12
       9
        
       	"github.com/sotangled/tangled/knotserver/config"

     

       13
       10
        
       	"github.com/sotangled/tangled/knotserver/db"

     

       11
       11
       +
       	"github.com/sotangled/tangled/log"

     

       14
       12
        
       	"github.com/sotangled/tangled/rbac"

     

       15
       13
        
       )

     

       16
       14
        
       

     
···

       19
       17
        
       	// ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)

     

       20
       18
        
       	// defer stop()

     

       21
       19
        
       

     

       22
       22
       -
       	slog.SetDefault(slog.New(slog.NewTextHandler(os.Stdout, nil)))

     

       20
       20
       +
       	l := log.New("knotserver")

     

       23
       21
        
       

     

       24
       22
        
       	c, err := config.Load(ctx)

     

       25
       23
        
       	if err != nil {

     

       26
       26
       -
       		log.Fatal(err)

     

       24
       24
       +
       		l.Error("failed to load config", "error", err)

     

       25
       25
       +
       		return

     

       27
       26
        
       	}

     

       28
       27
        
       

     

       29
       28
        
       	if c.Server.Dev {

     

       30
       30
       -
       		log.Println("running in dev mode, signature verification is disabled")

     

       29
       29
       +
       		l.Info("running in dev mode, signature verification is disabled")

     

       31
       30
        
       	}

     

       32
       31
        
       

     

       33
       32
        
       	db, err := db.Setup(c.Server.DBPath)

     

       34
       33
        
       	if err != nil {

     

       35
       35
       -
       		log.Fatalf("failed to setup db: %s", err)

     

       34
       34
       +
       		l.Error("failed to setup db", "error", err)

     

       35
       35
       +
       		return

     

       36
       36
        
       	}

     

       37
       37
        
       

     

       38
       38
        
       	e, err := rbac.NewEnforcer(c.Server.DBPath)

     

       39
       39
        
       	if err != nil {

     

       40
       40
       -
       		log.Fatalf("failed to setup rbac enforcer: %s", err)

     

       40
       40
       +
       		l.Error("failed to setup rbac enforcer", "error", err)

     

       41
       41
       +
       		return

     

       41
       42
        
       	}

     

       42
       43
        
       

     

       43
       43
       -
       	mux, err := knotserver.Setup(ctx, c, db, e)

     

       44
       44
       +
       	mux, err := knotserver.Setup(ctx, c, db, e, l)

     

       44
       45
        
       	if err != nil {

     

       45
       45
       -
       		log.Fatal(err)

     

       46
       46
       +
       		l.Error("failed to setup server", "error", err)

     

       47
       47
       +
       		return

     

       46
       48
        
       	}

     

       47
       49
        
       

     

       48
       50
        
       	addr := fmt.Sprintf("%s:%d", c.Server.Host, c.Server.Port)

     

       49
       51
        
       

     

       50
       50
       -
       	log.Println("starting main server on", addr)

     

       51
       51
       -
       	log.Fatal(http.ListenAndServe(addr, mux))

     

       52
       52
       +
       	l.Info("starting main server", "address", addr)

     

       53
       53
       +
       	l.Error("server error", "error", http.ListenAndServe(addr, mux))

     

       54
       54
       +
       	return

     

       52
       55
        
       }

+3 -3

knotserver/file.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"bytes"

     

       5
       5
        
       	"io"

     

       6
       6
       -
       	"log"

     

       6
       6
       +
       	"log/slog"

     

       7
       7
        
       	"net/http"

     

       8
       8
        
       	"strings"

     

       9
       9
        
       

     
···

       43
       43
        
       	}

     

       44
       44
        
       }

     

       45
       45
        
       

     

       46
       46
       -
       func (h *Handle) showFile(content string, data map[string]any, w http.ResponseWriter) {

     

       46
       46
       +
       func (h *Handle) showFile(content string, data map[string]any, w http.ResponseWriter, l *slog.Logger) {

     

       47
       47
        
       	lc, err := countLines(strings.NewReader(content))

     

       48
       48
        
       	if err != nil {

     

       49
       49
        
       		// Non-fatal, we'll just skip showing line numbers in the template.

     

       50
       50
       -
       		log.Printf("counting lines: %s", err)

     

       50
       50
       +
       		l.Warn("counting lines", "error", err)

     

       51
       51
        
       	}

     

       52
       52
        
       

     

       53
       53
        
       	lines := make([]int, lc)

+3 -4

knotserver/git.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"compress/gzip"

     

       5
       5
        
       	"io"

     

       6
       6
       -
       	"log"

     

       7
       6
        
       	"net/http"

     

       8
       7
        
       	"path/filepath"

     

       9
       8
        
       

     
···

       26
       25
        
       

     

       27
       26
        
       	if err := cmd.InfoRefs(); err != nil {

     

       28
       27
        
       		http.Error(w, err.Error(), 500)

     

       29
       29
       -
       		log.Printf("git: failed to execute git-upload-pack (info/refs) %s", err)

     

       28
       28
       +
       		d.l.Error("git: failed to execute git-upload-pack (info/refs)", "handler", "InfoRefs", "error", err)

     

       30
       29
        
       		return

     

       31
       30
        
       	}

     

       32
       31
        
       }

     
···

       53
       52
        
       		reader, err := gzip.NewReader(r.Body)

     

       54
       53
        
       		if err != nil {

     

       55
       54
        
       			http.Error(w, err.Error(), 500)

     

       56
       56
       -
       			log.Printf("git: failed to create gzip reader: %s", err)

     

       55
       55
       +
       			d.l.Error("git: failed to create gzip reader", "handler", "UploadPack", "error", err)

     

       57
       56
        
       			return

     

       58
       57
        
       		}

     

       59
       58
        
       		defer reader.Close()

     
···

       62
       61
        
       	cmd.Stdin = reader

     

       63
       62
        
       	if err := cmd.UploadPack(); err != nil {

     

       64
       63
        
       		http.Error(w, err.Error(), 500)

     

       65
       65
       -
       		log.Printf("git: failed to execute git-upload-pack %s", err)

     

       64
       64
       +
       		d.l.Error("git: failed to execute git-upload-pack", "handler", "UploadPack", "error", err)

     

       66
       65
        
       		return

     

       67
       66
        
       	}

     

       68
       67
        
       }

+4 -1

knotserver/handler.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
        
       	"fmt"

     

       6
       6
       +
       	"log/slog"

     

       6
       7
        
       	"net/http"

     

       7
       8
        
       

     

       8
       9
        
       	"github.com/go-chi/chi/v5"

     
···

       21
       22
        
       	db *db.DB

     

       22
       23
        
       	js *jsclient.JetstreamClient

     

       23
       24
        
       	e  *rbac.Enforcer

     

       25
       25
       +
       	l  *slog.Logger

     

       24
       26
        
       

     

       25
       27
        
       	// init is a channel that is closed when the knot has been initailized

     

       26
       28
        
       	// i.e. when the first user (knot owner) has been added.

     
···

       28
       30
        
       	knotInitialized bool

     

       29
       31
        
       }

     

       30
       32
        
       

     

       31
       31
       -
       func Setup(ctx context.Context, c *config.Config, db *db.DB, e *rbac.Enforcer) (http.Handler, error) {

     

       33
       33
       +
       func Setup(ctx context.Context, c *config.Config, db *db.DB, e *rbac.Enforcer, l *slog.Logger) (http.Handler, error) {

     

       32
       34
        
       	r := chi.NewRouter()

     

       33
       35
        
       

     

       34
       36
        
       	h := Handle{

     

       35
       37
        
       		c:    c,

     

       36
       38
        
       		db:   db,

     

       37
       39
        
       		e:    e,

     

       40
       40
       +
       		l:    l,

     

       38
       41
        
       		init: make(chan struct{}),

     

       39
       42
        
       	}

     

       40
       43

+66 -34

knotserver/jetstream.go

···

       5
       5
        
       	"encoding/json"

     

       6
       6
        
       	"fmt"

     

       7
       7
        
       	"io"

     

       8
       8
       -
       	"log"

     

       9
       8
        
       	"net/http"

     

       10
       9
        
       	"net/url"

     

       11
       10
        
       	"strings"

     
···

       14
       13
        
       	"github.com/sotangled/tangled/api/tangled"

     

       15
       14
        
       	"github.com/sotangled/tangled/knotserver/db"

     

       16
       15
        
       	"github.com/sotangled/tangled/knotserver/jsclient"

     

       16
       16
       +
       	"github.com/sotangled/tangled/log"

     

       17
       17
        
       )

     

       18
       18
        
       

     

       19
       19
        
       func (h *Handle) StartJetstream(ctx context.Context) error {

     

       20
       20
       +
       	l := h.l.With("component", "jetstream")

     

       21
       21
       +
       	ctx = log.IntoContext(ctx, l)

     

       20
       22
        
       	collections := []string{tangled.PublicKeyNSID, tangled.KnotMemberNSID}

     

       21
       23
        
       	dids := []string{}

     

       22
       24
        
       

     

       23
       23
       -
       	lastTimeUs, err := h.getLastTimeUs()

     

       25
       25
       +
       	lastTimeUs, err := h.getLastTimeUs(ctx)

     

       24
       26
        
       	if err != nil {

     

       25
       27
        
       		return err

     

       26
       28
        
       	}

     
···

       31
       33
        
       		return fmt.Errorf("failed to read from jetstream: %w", err)

     

       32
       34
        
       	}

     

       33
       35
        
       

     

       34
       34
       -
       	go h.processMessages(messages)

     

       36
       36
       +
       	go h.processMessages(ctx, messages)

     

       35
       37
        
       

     

       36
       38
        
       	return nil

     

       37
       39
        
       }

     

       38
       40
        
       

     

       39
       39
       -
       func (h *Handle) getLastTimeUs() (int64, error) {

     

       41
       41
       +
       func (h *Handle) getLastTimeUs(ctx context.Context) (int64, error) {

     

       42
       42
       +
       	l := log.FromContext(ctx)

     

       40
       43
        
       	lastTimeUs, err := h.db.GetLastTimeUs()

     

       41
       44
        
       	if err != nil {

     

       42
       42
       -
       		log.Println("couldn't get last time us, starting from now")

     

       45
       45
       +
       		l.Info("couldn't get last time us, starting from now")

     

       43
       46
        
       		lastTimeUs = time.Now().UnixMicro()

     

       44
       47
        
       	}

     

       45
       48
        
       

     

       46
       49
        
       	// If last time is older than a week, start from now

     

       47
       50
        
       	if time.Now().UnixMicro()-lastTimeUs > 7*24*60*60*1000*1000 {

     

       48
       51
        
       		lastTimeUs = time.Now().UnixMicro()

     

       49
       49
       -
       		log.Printf("last time us is older than a week. discarding that and starting from now.")

     

       52
       52
       +
       		l.Info("last time us is older than a week. discarding that and starting from now")

     

       50
       53
        
       		err = h.db.SaveLastTimeUs(lastTimeUs)

     

       51
       54
        
       		if err != nil {

     

       52
       52
       -
       			log.Println("failed to save last time us")

     

       55
       55
       +
       			l.Error("failed to save last time us")

     

       53
       56
        
       		}

     

       54
       57
        
       	}

     

       55
       58
        
       

     

       56
       56
       -
       	log.Printf("found last time_us %d", lastTimeUs)

     

       59
       59
       +
       	l.Info("found last time_us", "time_us", lastTimeUs)

     

       57
       60
        
       	return lastTimeUs, nil

     

       58
       61
        
       }

     

       59
       62
        
       

     

       60
       60
       -
       func (h *Handle) processPublicKey(did string, record map[string]interface{}) {

     

       63
       63
       +
       func (h *Handle) processPublicKey(ctx context.Context, did string, record map[string]interface{}) error {

     

       64
       64
       +
       	l := log.FromContext(ctx)

     

       61
       65
        
       	if err := h.db.AddPublicKeyFromRecord(did, record); err != nil {

     

       62
       62
       -
       		log.Printf("failed to add public key: %v", err)

     

       63
       63
       -
       	} else {

     

       64
       64
       -
       		log.Printf("added public key from firehose: %s", did)

     

       66
       66
       +
       		l.Error("failed to add public key", "error", err)

     

       67
       67
       +
       		return fmt.Errorf("failed to add public key: %w", err)

     

       65
       68
        
       	}

     

       69
       69
       +
       	l.Info("added public key from firehose", "did", did)

     

       70
       70
       +
       	return nil

     

       66
       71
        
       }

     

       67
       72
        
       

     

       68
       68
       -
       func (h *Handle) fetchAndAddKeys(did string) {

     

       73
       73
       +
       func (h *Handle) fetchAndAddKeys(ctx context.Context, did string) error {

     

       74
       74
       +
       	l := log.FromContext(ctx)

     

       75
       75
       +
       

     

       69
       76
        
       	keysEndpoint, err := url.JoinPath(h.c.AppViewEndpoint, "keys", did)

     

       70
       77
        
       	if err != nil {

     

       71
       71
       -
       		log.Printf("error building endpoint url: %s: %v", did, err)

     

       72
       72
       -
       		return

     

       78
       78
       +
       		l.Error("error building endpoint url", "did", did, "error", err.Error())

     

       79
       79
       +
       		return fmt.Errorf("error building endpoint url: %w", err)

     

       73
       80
        
       	}

     

       74
       81
        
       

     

       75
       82
        
       	resp, err := http.Get(keysEndpoint)

     

       76
       83
        
       	if err != nil {

     

       77
       77
       -
       		log.Printf("error getting keys for %s: %v", did, err)

     

       78
       78
       -
       		return

     

       84
       84
       +
       		l.Error("error getting keys", "did", did, "error", err)

     

       85
       85
       +
       		return fmt.Errorf("error getting keys: %w", err)

     

       79
       86
        
       	}

     

       80
       87
        
       	defer resp.Body.Close()

     

       81
       88
        
       

     

       82
       89
        
       	plaintext, err := io.ReadAll(resp.Body)

     

       83
       90
        
       	if err != nil {

     

       84
       84
       -
       		log.Printf("error reading response body: %v", err)

     

       85
       85
       -
       		return

     

       91
       91
       +
       		l.Error("error reading response body", "error", err)

     

       92
       92
       +
       		return fmt.Errorf("error reading response body: %w", err)

     

       86
       93
        
       	}

     

       87
       94
        
       

     

       88
       95
        
       	for _, key := range strings.Split(string(plaintext), "\n") {

     
···

       94
       101
        
       		}

     

       95
       102
        
       		pk.Key = key

     

       96
       103
        
       		if err := h.db.AddPublicKey(pk); err != nil {

     

       97
       97
       -
       			log.Printf("failed to add public key: %v", err)

     

       104
       104
       +
       			l.Error("failed to add public key", "error", err)

     

       105
       105
       +
       			return fmt.Errorf("failed to add public key: %w", err)

     

       98
       106
        
       		}

     

       99
       107
        
       	}

     

       108
       108
       +
       	return nil

     

       100
       109
        
       }

     

       101
       110
        
       

     

       102
       102
       -
       func (h *Handle) processKnotMember(did string, record map[string]interface{}) {

     

       111
       111
       +
       func (h *Handle) processKnotMember(ctx context.Context, did string, record map[string]interface{}) error {

     

       112
       112
       +
       	l := log.FromContext(ctx)

     

       103
       113
        
       	ok, err := h.e.E.Enforce(did, ThisServer, ThisServer, "server:invite")

     

       104
       114
        
       	if err != nil || !ok {

     

       105
       105
       -
       		log.Printf("failed to add member from did %s", did)

     

       106
       106
       -
       		return

     

       115
       115
       +
       		l.Error("failed to add member", "did", did)

     

       116
       116
       +
       		return fmt.Errorf("failed to enforce permissions: %w", err)

     

       107
       117
        
       	}

     

       108
       118
        
       

     

       109
       109
       -
       	log.Printf("adding member")

     

       119
       119
       +
       	l.Info("adding member")

     

       110
       120
        
       	if err := h.e.AddMember(ThisServer, record["member"].(string)); err != nil {

     

       111
       111
       -
       		log.Printf("failed to add member: %v", err)

     

       112
       112
       -
       	} else {

     

       113
       113
       -
       		log.Printf("added member from firehose: %s", record["member"])

     

       121
       121
       +
       		l.Error("failed to add member", "error", err)

     

       122
       122
       +
       		return fmt.Errorf("failed to add member: %w", err)

     

       123
       123
       +
       	}

     

       124
       124
       +
       	l.Info("added member from firehose", "member", record["member"])

     

       125
       125
       +
       

     

       126
       126
       +
       	if err := h.db.AddDid(did); err != nil {

     

       127
       127
       +
       		l.Error("failed to add did", "error", err)

     

       128
       128
       +
       		return fmt.Errorf("failed to add did: %w", err)

     

       114
       129
        
       	}

     

       115
       130
        
       

     

       116
       116
       -
       	h.fetchAndAddKeys(did)

     

       131
       131
       +
       	if err := h.fetchAndAddKeys(ctx, did); err != nil {

     

       132
       132
       +
       		return fmt.Errorf("failed to fetch and add keys: %w", err)

     

       133
       133
       +
       	}

     

       134
       134
       +
       

     

       117
       135
        
       	h.js.UpdateDids([]string{did})

     

       136
       136
       +
       	return nil

     

       118
       137
        
       }

     

       119
       138
        
       

     

       120
       120
       -
       func (h *Handle) processMessages(messages <-chan []byte) {

     

       139
       139
       +
       func (h *Handle) processMessages(ctx context.Context, messages <-chan []byte) {

     

       140
       140
       +
       	l := log.FromContext(ctx)

     

       141
       141
       +
       	l.Info("waiting for knot to be initialized")

     

       121
       142
        
       	<-h.init

     

       122
       122
       -
       	log.Println("initalized jetstream watcher")

     

       143
       143
       +
       	l.Info("initialized jetstream watcher")

     

       123
       144
        
       

     

       124
       145
        
       	for msg := range messages {

     

       125
       146
        
       		var data map[string]interface{}

     

       126
       147
        
       		if err := json.Unmarshal(msg, &data); err != nil {

     

       127
       127
       -
       			log.Printf("error unmarshaling message: %v", err)

     

       148
       148
       +
       			l.Error("error unmarshaling message", "error", err)

     

       128
       149
        
       			continue

     

       129
       150
        
       		}

     

       130
       151
        
       

     
···

       133
       154
        
       			did := data["did"].(string)

     

       134
       155
        
       			record := commit["record"].(map[string]interface{})

     

       135
       156
        
       

     

       157
       157
       +
       			var processErr error

     

       136
       158
        
       			switch commit["collection"].(string) {

     

       137
       159
        
       			case tangled.PublicKeyNSID:

     

       138
       138
       -
       				h.processPublicKey(did, record)

     

       160
       160
       +
       				if err := h.processPublicKey(ctx, did, record); err != nil {

     

       161
       161
       +
       					processErr = fmt.Errorf("failed to process public key: %w", err)

     

       162
       162
       +
       				}

     

       139
       163
        
       			case tangled.KnotMemberNSID:

     

       140
       140
       -
       				h.processKnotMember(did, record)

     

       164
       164
       +
       				if err := h.processKnotMember(ctx, did, record); err != nil {

     

       165
       165
       +
       					processErr = fmt.Errorf("failed to process knot member: %w", err)

     

       166
       166
       +
       				}

     

       167
       167
       +
       			}

     

       168
       168
       +
       

     

       169
       169
       +
       			if processErr != nil {

     

       170
       170
       +
       				l.Error("error processing message", "error", processErr)

     

       171
       171
       +
       				continue

     

       141
       172
        
       			}

     

       142
       173
        
       

     

       143
       174
        
       			lastTimeUs := int64(data["time_us"].(float64))

     

       144
       175
        
       			if err := h.db.SaveLastTimeUs(lastTimeUs); err != nil {

     

       145
       145
       -
       				log.Printf("failed to save last time us: %v", err)

     

       176
       176
       +
       				l.Error("failed to save last time us", "error", err)

     

       177
       177
       +
       				continue

     

       146
       178
        
       			}

     

       147
       179
        
       		}

     

       148
       180
        
       	}

+45 -22

knotserver/routes.go

···

       9
       9
        
       	"errors"

     

       10
       10
        
       	"fmt"

     

       11
       11
        
       	"html/template"

     

       12
       12
       -
       	"log"

     

       13
       12
        
       	"net/http"

     

       14
       13
        
       	"path/filepath"

     

       15
       14
        
       	"strconv"

     
···

       30
       29
        
       

     

       31
       30
        
       func (h *Handle) RepoIndex(w http.ResponseWriter, r *http.Request) {

     

       32
       31
        
       	path := filepath.Join(h.c.Repo.ScanPath, didPath(r))

     

       32
       32
       +
       	l := h.l.With("path", path, "handler", "RepoIndex")

     

       33
       33
        
       

     

       34
       34
        
       	gr, err := git.Open(path, "")

     

       35
       35
        
       	if err != nil {

     
···

       37
       37
        
       			writeMsg(w, "repo empty")

     

       38
       38
        
       			return

     

       39
       39
        
       		} else {

     

       40
       40
       -
       			log.Println(err)

     

       40
       40
       +
       			l.Error("opening repo", "error", err.Error())

     

       41
       41
        
       			notFound(w)

     

       42
       42
        
       			return

     

       43
       43
        
       		}

     
···

       45
       45
        
       	commits, err := gr.Commits()

     

       46
       46
        
       	if err != nil {

     

       47
       47
        
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       48
       48
       -
       		log.Println(err)

     

       48
       48
       +
       		l.Error("fetching commits", "error", err.Error())

     

       49
       49
        
       		return

     

       50
       50
        
       	}

     

       51
       51
        
       

     
···

       73
       73
        
       	}

     

       74
       74
        
       

     

       75
       75
        
       	if readmeContent == "" {

     

       76
       76
       -
       		log.Printf("no readme found for %s", path)

     

       76
       76
       +
       		l.Warn("no readme found")

     

       77
       77
        
       	}

     

       78
       78
        
       

     

       79
       79
        
       	mainBranch, err := gr.FindMainBranch(h.c.Repo.MainBranch)

     

       80
       80
        
       	if err != nil {

     

       81
       81
        
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       82
       82
       -
       		log.Println(err)

     

       82
       82
       +
       		l.Error("finding main branch", "error", err.Error())

     

       83
       83
        
       		return

     

       84
       84
        
       	}

     

       85
       85
        
       

     
···

       100
       100
        
       	treePath := chi.URLParam(r, "*")

     

       101
       101
        
       	ref := chi.URLParam(r, "ref")

     

       102
       102
        
       

     

       103
       103
       +
       	l := h.l.With("handler", "RepoTree", "ref", ref, "treePath", treePath)

     

       104
       104
       +
       

     

       103
       105
        
       	path := filepath.Join(h.c.Repo.ScanPath, didPath(r))

     

       104
       106
        
       	gr, err := git.Open(path, ref)

     

       105
       107
        
       	if err != nil {

     
···

       110
       112
        
       	files, err := gr.FileTree(treePath)

     

       111
       113
        
       	if err != nil {

     

       112
       114
        
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       113
       113
       -
       		log.Println(err)

     

       115
       115
       +
       		l.Error("file tree", "error", err.Error())

     

       114
       116
        
       		return

     

       115
       117
        
       	}

     

       116
       118
        
       

     
···

       133
       135
        
       	treePath := chi.URLParam(r, "*")

     

       134
       136
        
       	ref := chi.URLParam(r, "ref")

     

       135
       137
        
       

     

       138
       138
       +
       	l := h.l.With("handler", "FileContent", "ref", ref, "treePath", treePath)

     

       139
       139
       +
       

     

       136
       140
        
       	path := filepath.Join(h.c.Repo.ScanPath, didPath(r))

     

       137
       141
        
       	gr, err := git.Open(path, ref)

     

       138
       142
        
       	if err != nil {

     
···

       155
       159
        
       	if raw {

     

       156
       160
        
       		h.showRaw(string(safe), w)

     

       157
       161
        
       	} else {

     

       158
       158
       -
       		h.showFile(string(safe), data, w)

     

       162
       162
       +
       		h.showFile(string(safe), data, w, l)

     

       159
       163
        
       	}

     

       160
       164
        
       }

     

       161
       165
        
       

     

       162
       166
        
       func (h *Handle) Archive(w http.ResponseWriter, r *http.Request) {

     

       163
       167
        
       	name := chi.URLParam(r, "name")

     

       164
       168
        
       	file := chi.URLParam(r, "file")

     

       169
       169
       +
       

     

       170
       170
       +
       	l := h.l.With("handler", "Archive", "name", name, "file", file)

     

       165
       171
        
       

     

       166
       172
        
       	// TODO: extend this to add more files compression (e.g.: xz)

     

       167
       173
        
       	if !strings.HasSuffix(file, ".tar.gz") {

     
···

       192
       198
        
       	if err != nil {

     

       193
       199
        
       		// once we start writing to the body we can't report error anymore

     

       194
       200
        
       		// so we are only left with printing the error.

     

       195
       195
       -
       		log.Println(err)

     

       201
       201
       +
       		l.Error("writing tar file", "error", err.Error())

     

       196
       202
        
       		return

     

       197
       203
        
       	}

     

       198
       204
        
       

     
···

       200
       206
        
       	if err != nil {

     

       201
       207
        
       		// once we start writing to the body we can't report error anymore

     

       202
       208
        
       		// so we are only left with printing the error.

     

       203
       203
       -
       		log.Println(err)

     

       209
       209
       +
       		l.Error("flushing?", "error", err.Error())

     

       204
       210
        
       		return

     

       205
       211
        
       	}

     

       206
       212
        
       }

     

       207
       213
        
       

     

       208
       214
        
       func (h *Handle) Log(w http.ResponseWriter, r *http.Request) {

     

       209
       209
       -
       	fmt.Println(r.URL.Path)

     

       210
       215
        
       	ref := chi.URLParam(r, "ref")

     

       216
       216
       +
       	path := filepath.Join(h.c.Repo.ScanPath, didPath(r))

     

       211
       217
        
       

     

       212
       212
       -
       	path := filepath.Join(h.c.Repo.ScanPath, didPath(r))

     

       218
       218
       +
       	l := h.l.With("handler", "Log", "ref", ref, "path", path)

     

       219
       219
       +
       

     

       213
       220
        
       	gr, err := git.Open(path, ref)

     

       214
       221
        
       	if err != nil {

     

       215
       222
        
       		notFound(w)

     
···

       219
       226
        
       	commits, err := gr.Commits()

     

       220
       227
        
       	if err != nil {

     

       221
       228
        
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       222
       222
       -
       		log.Println(err)

     

       229
       229
       +
       		l.Error("fetching commits", "error", err.Error())

     

       223
       230
        
       		return

     

       224
       231
        
       	}

     

       225
       232
        
       

     
···

       269
       276
        
       func (h *Handle) Diff(w http.ResponseWriter, r *http.Request) {

     

       270
       277
        
       	ref := chi.URLParam(r, "ref")

     

       271
       278
        
       

     

       279
       279
       +
       	l := h.l.With("handler", "Diff", "ref", ref)

     

       280
       280
       +
       

     

       272
       281
        
       	path := filepath.Join(h.c.Repo.ScanPath, didPath(r))

     

       273
       282
        
       	gr, err := git.Open(path, ref)

     

       274
       283
        
       	if err != nil {

     
···

       279
       288
        
       	diff, err := gr.Diff()

     

       280
       289
        
       	if err != nil {

     

       281
       290
        
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       282
       282
       -
       		log.Println(err)

     

       291
       291
       +
       		l.Error("getting diff", "error", err.Error())

     

       283
       292
        
       		return

     

       284
       293
        
       	}

     

       285
       294
        
       

     
···

       297
       306
        
       

     

       298
       307
        
       func (h *Handle) Refs(w http.ResponseWriter, r *http.Request) {

     

       299
       308
        
       	path := filepath.Join(h.c.Repo.ScanPath, didPath(r))

     

       309
       309
       +
       	l := h.l.With("handler", "Refs")

     

       310
       310
       +
       

     

       300
       311
        
       	gr, err := git.Open(path, "")

     

       301
       312
        
       	if err != nil {

     

       302
       313
        
       		notFound(w)

     
···

       306
       317
        
       	tags, err := gr.Tags()

     

       307
       318
        
       	if err != nil {

     

       308
       319
        
       		// Non-fatal, we *should* have at least one branch to show.

     

       309
       309
       -
       		log.Println(err)

     

       320
       320
       +
       		l.Error("getting tags", "error", err.Error())

     

       310
       321
        
       	}

     

       311
       322
        
       

     

       312
       323
        
       	branches, err := gr.Branches()

     

       313
       324
        
       	if err != nil {

     

       314
       314
       -
       		log.Println(err)

     

       325
       325
       +
       		l.Error("getting branches", "error", err.Error())

     

       315
       326
        
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       316
       327
        
       		return

     

       317
       328
        
       	}

     
···

       327
       338
        
       }

     

       328
       339
        
       

     

       329
       340
        
       func (h *Handle) Keys(w http.ResponseWriter, r *http.Request) {

     

       341
       341
       +
       	l := h.l.With("handler", "Keys")

     

       342
       342
       +
       

     

       330
       343
        
       	switch r.Method {

     

       331
       344
        
       	case http.MethodGet:

     

       332
       345
        
       		keys, err := h.db.GetAllPublicKeys()

     

       333
       346
        
       		if err != nil {

     

       334
       347
        
       			writeError(w, err.Error(), http.StatusInternalServerError)

     

       335
       335
       -
       			log.Println(err)

     

       348
       348
       +
       			l.Error("getting public keys", "error", err.Error())

     

       336
       349
        
       			return

     

       337
       350
        
       		}

     

       338
       351
        
       

     
···

       358
       371
        
       

     

       359
       372
        
       		if err := h.db.AddPublicKey(pk); err != nil {

     

       360
       373
        
       			writeError(w, err.Error(), http.StatusInternalServerError)

     

       361
       361
       -
       			log.Printf("adding public key: %s", err)

     

       374
       374
       +
       			l.Error("adding public key", "error", err.Error())

     

       362
       375
        
       			return

     

       363
       376
        
       		}

     

       364
       377
        
       

     
···

       368
       381
        
       }

     

       369
       382
        
       

     

       370
       383
        
       func (h *Handle) NewRepo(w http.ResponseWriter, r *http.Request) {

     

       384
       384
       +
       	l := h.l.With("handler", "NewRepo")

     

       385
       385
       +
       

     

       371
       386
        
       	data := struct {

     

       372
       387
        
       		Did  string `json:"did"`

     

       373
       388
        
       		Name string `json:"name"`

     
···

       385
       400
        
       	repoPath := filepath.Join(h.c.Repo.ScanPath, relativeRepoPath)

     

       386
       401
        
       	err := git.InitBare(repoPath)

     

       387
       402
        
       	if err != nil {

     

       388
       388
       -
       		log.Println(err)

     

       403
       403
       +
       		l.Error("initializing bare repo", "error", err.Error())

     

       389
       404
        
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       390
       405
        
       		return

     

       391
       406
        
       	}

     
···

       393
       408
        
       	// add perms for this user to access the repo

     

       394
       409
        
       	err = h.e.AddRepo(did, ThisServer, relativeRepoPath)

     

       395
       410
        
       	if err != nil {

     

       396
       396
       -
       		log.Println(err)

     

       411
       411
       +
       		l.Error("adding repo permissions", "error", err.Error())

     

       397
       412
        
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       398
       413
        
       		return

     

       399
       414
        
       	}

     
···

       402
       417
        
       }

     

       403
       418
        
       

     

       404
       419
        
       func (h *Handle) AddMember(w http.ResponseWriter, r *http.Request) {

     

       420
       420
       +
       	l := h.l.With("handler", "AddMember")

     

       421
       421
       +
       

     

       405
       422
        
       	data := struct {

     

       406
       423
        
       		Did        string   `json:"did"`

     

       407
       424
        
       		PublicKeys []string `json:"keys"`

     
···

       427
       444
        
       

     

       428
       445
        
       	h.js.UpdateDids([]string{did})

     

       429
       446
        
       	if err := h.e.AddMember(ThisServer, did); err != nil {

     

       430
       430
       -
       		log.Println(err)

     

       447
       447
       +
       		l.Error("adding member", "error", err.Error())

     

       431
       448
        
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       432
       449
        
       		return

     

       433
       450
        
       	}

     
···

       436
       453
        
       }

     

       437
       454
        
       

     

       438
       455
        
       func (h *Handle) Init(w http.ResponseWriter, r *http.Request) {

     

       456
       456
       +
       	l := h.l.With("handler", "Init")

     

       457
       457
       +
       

     

       439
       458
        
       	if h.knotInitialized {

     

       440
       459
        
       		writeError(w, "knot already initialized", http.StatusConflict)

     

       441
       460
        
       		return

     
···

       447
       466
        
       	}{}

     

       448
       467
        
       

     

       449
       468
        
       	if err := json.NewDecoder(r.Body).Decode(&data); err != nil {

     

       469
       469
       +
       		l.Error("failed to decode request body", "error", err.Error())

     

       450
       470
        
       		writeError(w, "invalid request body", http.StatusBadRequest)

     

       451
       471
        
       		return

     

       452
       472
        
       	}

     

       453
       473
        
       

     

       454
       474
        
       	if data.Did == "" {

     

       475
       475
       +
       		l.Error("empty DID in request")

     

       455
       476
        
       		writeError(w, "did is empty", http.StatusBadRequest)

     

       456
       477
        
       		return

     

       457
       478
        
       	}

     
···

       464
       485
        
       			pk.Key = k

     

       465
       486
        
       			err := h.db.AddPublicKey(pk)

     

       466
       487
        
       			if err != nil {

     

       488
       488
       +
       				l.Error("failed to add public key", "error", err.Error())

     

       467
       489
        
       				writeError(w, err.Error(), http.StatusInternalServerError)

     

       468
       490
        
       				return

     

       469
       491
        
       			}

     

       470
       492
        
       		}

     

       471
       493
        
       	} else {

     

       494
       494
       +
       		l.Error("failed to add DID", "error", err.Error())

     

       472
       495
        
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       473
       496
        
       		return

     

       474
       497
        
       	}

     

       475
       498
        
       

     

       476
       499
        
       	h.js.UpdateDids([]string{data.Did})

     

       477
       500
        
       	if err := h.e.AddOwner(ThisServer, data.Did); err != nil {

     

       478
       478
       -
       		log.Println(err)

     

       501
       501
       +
       		l.Error("adding owner", "error", err.Error())

     

       479
       502
        
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       480
       503
        
       		return

     

       481
       504
        
       	}

     

       482
       482
       -
       	// Signal that the knot is ready

     

       505
       505
       +
       

     

       483
       506
        
       	close(h.init)

     

       484
       507
        
       

     

       485
       508
        
       	mac := hmac.New(sha256.New, []byte(h.c.Server.Secret))

+49

log/log.go

···

       1
       1
       +
       package log

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"log/slog"

     

       6
       6
       +
       	"os"

     

       7
       7
       +
       )

     

       8
       8
       +
       

     

       9
       9
       +
       // NewHandler sets up a new slog.Handler with the service name

     

       10
       10
       +
       // as an attribute

     

       11
       11
       +
       func NewHandler(name string) slog.Handler {

     

       12
       12
       +
       	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{})

     

       13
       13
       +
       

     

       14
       14
       +
       	var attrs []slog.Attr

     

       15
       15
       +
       	attrs = append(attrs, slog.Attr{Key: "service", Value: slog.StringValue(name)})

     

       16
       16
       +
       	handler.WithAttrs(attrs)

     

       17
       17
       +
       	return handler

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       20
       20
       +
       func New(name string) *slog.Logger {

     

       21
       21
       +
       	return slog.New(NewHandler(name))

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       24
       24
       +
       func NewContext(ctx context.Context, name string) context.Context {

     

       25
       25
       +
       	return IntoContext(ctx, New(name))

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       28
       28
       +
       type ctxKey struct{}

     

       29
       29
       +
       

     

       30
       30
       +
       // IntoContext adds a logger to a context. Use FromContext to

     

       31
       31
       +
       // pull the logger out.

     

       32
       32
       +
       func IntoContext(ctx context.Context, l *slog.Logger) context.Context {

     

       33
       33
       +
       	return context.WithValue(ctx, ctxKey{}, l)

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       36
       36
       +
       // FromContext returns a logger from a context.Context;

     

       37
       37
       +
       // if the passed context is nil, we return the default slog

     

       38
       38
       +
       // logger.

     

       39
       39
       +
       func FromContext(ctx context.Context) *slog.Logger {

     

       40
       40
       +
       	if ctx != nil {

     

       41
       41
       +
       		v := ctx.Value(ctxKey{})

     

       42
       42
       +
       		if v == nil {

     

       43
       43
       +
       			return slog.Default()

     

       44
       44
       +
       		}

     

       45
       45
       +
       		return v.(*slog.Logger)

     

       46
       46
       +
       	}

     

       47
       47
       +
       

     

       48
       48
       +
       	return slog.Default()

     

       49
       49
       +
       }