commit 71953ed5003cc6878bd65ffa312b1434c5d0c4b2 · nel.pet/core

+72 -26

api/tangled/cbor_gen.go

···

       5812
       5812
        
       		fieldCount--

     

       5813
       5813
        
       	}

     

       5814
       5814
        
       

     

       5815
       5815
       +
       	if t.Labels == nil {

     

       5816
       5816
       +
       		fieldCount--

     

       5817
       5817
       +
       	}

     

       5818
       5818
       +
       

     

       5815
       5819
        
       	if t.Source == nil {

     

       5816
       5820
        
       		fieldCount--

     

       5817
       5821
        
       	}

     
···

       5889
       5893
        
       		return err

     

       5890
       5894
        
       	}

     

       5891
       5895
        
       

     

       5892
       5892
       -
       	// t.Owner (string) (string)

     

       5893
       5893
       -
       	if len("owner") > 1000000 {

     

       5894
       5894
       -
       		return xerrors.Errorf("Value in field \"owner\" was too long")

     

       5895
       5895
       -
       	}

     

       5896
       5896
       +
       	// t.Labels ([]string) (slice)

     

       5897
       5897
       +
       	if t.Labels != nil {

     

       5898
       5898
       +
       

     

       5899
       5899
       +
       		if len("labels") > 1000000 {

     

       5900
       5900
       +
       			return xerrors.Errorf("Value in field \"labels\" was too long")

     

       5901
       5901
       +
       		}

     

       5902
       5902
       +
       

     

       5903
       5903
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("labels"))); err != nil {

     

       5904
       5904
       +
       			return err

     

       5905
       5905
       +
       		}

     

       5906
       5906
       +
       		if _, err := cw.WriteString(string("labels")); err != nil {

     

       5907
       5907
       +
       			return err

     

       5908
       5908
       +
       		}

     

       5896
       5909
        
       

     

       5897
       5897
       -
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {

     

       5898
       5898
       -
       		return err

     

       5899
       5899
       -
       	}

     

       5900
       5900
       -
       	if _, err := cw.WriteString(string("owner")); err != nil {

     

       5901
       5901
       -
       		return err

     

       5902
       5902
       -
       	}

     

       5910
       5910
       +
       		if len(t.Labels) > 8192 {

     

       5911
       5911
       +
       			return xerrors.Errorf("Slice value in field t.Labels was too long")

     

       5912
       5912
       +
       		}

     

       5913
       5913
       +
       

     

       5914
       5914
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Labels))); err != nil {

     

       5915
       5915
       +
       			return err

     

       5916
       5916
       +
       		}

     

       5917
       5917
       +
       		for _, v := range t.Labels {

     

       5918
       5918
       +
       			if len(v) > 1000000 {

     

       5919
       5919
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       5920
       5920
       +
       			}

     

       5903
       5921
        
       

     

       5904
       5904
       -
       	if len(t.Owner) > 1000000 {

     

       5905
       5905
       -
       		return xerrors.Errorf("Value in field t.Owner was too long")

     

       5906
       5906
       -
       	}

     

       5922
       5922
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       5923
       5923
       +
       				return err

     

       5924
       5924
       +
       			}

     

       5925
       5925
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       5926
       5926
       +
       				return err

     

       5927
       5927
       +
       			}

     

       5907
       5928
        
       

     

       5908
       5908
       -
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {

     

       5909
       5909
       -
       		return err

     

       5910
       5910
       -
       	}

     

       5911
       5911
       -
       	if _, err := cw.WriteString(string(t.Owner)); err != nil {

     

       5912
       5912
       -
       		return err

     

       5929
       5929
       +
       		}

     

       5913
       5930
        
       	}

     

       5914
       5931
        
       

     

       5915
       5932
        
       	// t.Source (string) (string)

     
···

       6107
       6124
        
       

     

       6108
       6125
        
       				t.LexiconTypeID = string(sval)

     

       6109
       6126
        
       			}

     

       6110
       6110
       -
       			// t.Owner (string) (string)

     

       6111
       6111
       -
       		case "owner":

     

       6127
       6127
       +
       			// t.Labels ([]string) (slice)

     

       6128
       6128
       +
       		case "labels":

     

       6129
       6129
       +
       

     

       6130
       6130
       +
       			maj, extra, err = cr.ReadHeader()

     

       6131
       6131
       +
       			if err != nil {

     

       6132
       6132
       +
       				return err

     

       6133
       6133
       +
       			}

     

       6134
       6134
       +
       

     

       6135
       6135
       +
       			if extra > 8192 {

     

       6136
       6136
       +
       				return fmt.Errorf("t.Labels: array too large (%d)", extra)

     

       6137
       6137
       +
       			}

     

       6138
       6138
       +
       

     

       6139
       6139
       +
       			if maj != cbg.MajArray {

     

       6140
       6140
       +
       				return fmt.Errorf("expected cbor array")

     

       6141
       6141
       +
       			}

     

       6142
       6142
       +
       

     

       6143
       6143
       +
       			if extra > 0 {

     

       6144
       6144
       +
       				t.Labels = make([]string, extra)

     

       6145
       6145
       +
       			}

     

       6146
       6146
       +
       

     

       6147
       6147
       +
       			for i := 0; i < int(extra); i++ {

     

       6148
       6148
       +
       				{

     

       6149
       6149
       +
       					var maj byte

     

       6150
       6150
       +
       					var extra uint64

     

       6151
       6151
       +
       					var err error

     

       6152
       6152
       +
       					_ = maj

     

       6153
       6153
       +
       					_ = extra

     

       6154
       6154
       +
       					_ = err

     

       6112
       6155
        
       

     

       6113
       6113
       -
       			{

     

       6114
       6114
       -
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       6115
       6115
       -
       				if err != nil {

     

       6116
       6116
       -
       					return err

     

       6156
       6156
       +
       					{

     

       6157
       6157
       +
       						sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       6158
       6158
       +
       						if err != nil {

     

       6159
       6159
       +
       							return err

     

       6160
       6160
       +
       						}

     

       6161
       6161
       +
       

     

       6162
       6162
       +
       						t.Labels[i] = string(sval)

     

       6163
       6163
       +
       					}

     

       6164
       6164
       +
       

     

       6117
       6165
        
       				}

     

       6118
       6118
       -
       

     

       6119
       6119
       -
       				t.Owner = string(sval)

     

       6120
       6166
        
       			}

     

       6121
       6167
        
       			// t.Source (string) (string)

     

       6122
       6168
        
       		case "source":

+3 -2

api/tangled/tangledrepo.go

···

       22
       22
        
       	Description   *string `json:"description,omitempty" cborgen:"description,omitempty"`

     

       23
       23
        
       	// knot: knot where the repo was created

     

       24
       24
        
       	Knot string `json:"knot" cborgen:"knot"`

     

       25
       25
       +
       	// labels: List of labels that this repo subscribes to

     

       26
       26
       +
       	Labels []string `json:"labels,omitempty" cborgen:"labels,omitempty"`

     

       25
       27
        
       	// name: name of the repo

     

       26
       26
       -
       	Name  string `json:"name" cborgen:"name"`

     

       27
       27
       -
       	Owner string `json:"owner" cborgen:"owner"`

     

       28
       28
       +
       	Name string `json:"name" cborgen:"name"`

     

       28
       29
        
       	// source: source of the repo

     

       29
       30
        
       	Source *string `json:"source,omitempty" cborgen:"source,omitempty"`

     

       30
       31
        
       	// spindle: CI runner to send jobs to and receive results from

-3

appview/repo/repo.go

···

       313
       313
        
       				Val: &tangled.Repo{

     

       314
       314
        
       					Knot:        f.Knot,

     

       315
       315
        
       					Name:        f.Name,

     

       316
       316
       -
       					Owner:       user.Did,

     

       317
       316
        
       					CreatedAt:   f.Created.Format(time.RFC3339),

     

       318
       317
        
       					Description: &newDescription,

     

       319
       318
        
       					Spindle:     &f.Spindle,

     
···

       950
       949
        
       			Val: &tangled.Repo{

     

       951
       950
        
       				Knot:        f.Knot,

     

       952
       951
        
       				Name:        f.Name,

     

       953
       953
       -
       				Owner:       user.Did,

     

       954
       952
        
       				CreatedAt:   f.Created.Format(time.RFC3339),

     

       955
       953
        
       				Description: &f.Description,

     

       956
       954
        
       				Spindle:     spindlePtr,

     
···

       1636
       1634
        
       					Knot:      repo.Knot,

     

       1637
       1635
        
       					Name:      repo.Name,

     

       1638
       1636
        
       					CreatedAt: createdAt,

     

       1639
       1639
       -
       					Owner:     user.Did,

     

       1640
       1637
        
       					Source:    &sourceAt,

     

       1641
       1638
        
       				}},

     

       1642
       1639
        
       		})

-3

appview/state/router.go

···

       238
       238
        
       		Db:         s.db,

     

       239
       239
        
       		OAuth:      s.oauth,

     

       240
       240
        
       		Pages:      s.pages,

     

       241
       241
       -
       		Config:     s.config,

     

       242
       242
       -
       		Enforcer:   s.enforcer,

     

       243
       241
        
       		IdResolver: s.idResolver,

     

       244
       244
       -
       		Knotstream: s.knotstream,

     

       245
       242
        
       		Notifier:   s.notifier,

     

       246
       243
        
       		Logger:     logger,

     

       247
       244
        
       	}

-1

appview/state/state.go

···

       453
       453
        
       					Knot:      repo.Knot,

     

       454
       454
        
       					Name:      repoName,

     

       455
       455
        
       					CreatedAt: createdAt,

     

       456
       456
       -
       					Owner:     user.Did,

     

       457
       456
        
       				}},

     

       458
       457
        
       		})

     

       459
       458
        
       		if err != nil {

-6

appview/strings/strings.go

···

       9
       9
        
       	"time"

     

       10
       10
        
       

     

       11
       11
        
       	"tangled.org/core/api/tangled"

     

       12
       12
       -
       	"tangled.org/core/appview/config"

     

       13
       12
        
       	"tangled.org/core/appview/db"

     

       14
       13
        
       	"tangled.org/core/appview/middleware"

     

       15
       14
        
       	"tangled.org/core/appview/notify"

     

       16
       15
        
       	"tangled.org/core/appview/oauth"

     

       17
       16
        
       	"tangled.org/core/appview/pages"

     

       18
       17
        
       	"tangled.org/core/appview/pages/markup"

     

       19
       19
       -
       	"tangled.org/core/eventconsumer"

     

       20
       18
        
       	"tangled.org/core/idresolver"

     

       21
       21
       -
       	"tangled.org/core/rbac"

     

       22
       19
        
       	"tangled.org/core/tid"

     

       23
       20
        
       

     

       24
       21
        
       	"github.com/bluesky-social/indigo/api/atproto"

     
···

       32
       29
        
       	Db         *db.DB

     

       33
       30
        
       	OAuth      *oauth.OAuth

     

       34
       31
        
       	Pages      *pages.Pages

     

       35
       35
       -
       	Config     *config.Config

     

       36
       36
       -
       	Enforcer   *rbac.Enforcer

     

       37
       32
        
       	IdResolver *idresolver.Resolver

     

       38
       33
        
       	Logger     *slog.Logger

     

       39
       39
       -
       	Knotstream *eventconsumer.Consumer

     

       40
       34
        
       	Notifier   notify.Notifier

     

       41
       35
        
       }

     

       42
       36

+2 -2

knotserver/ingester.go

···

       141
       141
        
       		return fmt.Errorf("rejected pull record: not this knot, %s != %s", repo.Knot, h.c.Server.Hostname)

     

       142
       142
        
       	}

     

       143
       143
        
       

     

       144
       144
       -
       	didSlashRepo, err := securejoin.SecureJoin(repo.Owner, repo.Name)

     

       144
       144
       +
       	didSlashRepo, err := securejoin.SecureJoin(ident.DID.String(), repo.Name)

     

       145
       145
        
       	if err != nil {

     

       146
       146
        
       		return fmt.Errorf("failed to construct relative repo path: %w", err)

     

       147
       147
        
       	}

     
···

       191
       191
        
       			Kind:        string(workflow.TriggerKindPullRequest),

     

       192
       192
        
       			PullRequest: &trigger,

     

       193
       193
        
       			Repo: &tangled.Pipeline_TriggerRepo{

     

       194
       194
       -
       				Did:  repo.Owner,

     

       194
       194
       +
       				Did:  ident.DID.String(),

     

       195
       195
        
       				Knot: repo.Knot,

     

       196
       196
        
       				Repo: repo.Name,

     

       197
       197
        
       			},

-36

knotserver/util.go

···

       1
       1
        
       package knotserver

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"net/http"

     

       5
       5
       -
       	"os"

     

       6
       6
       -
       	"path/filepath"

     

       7
       7
       -
       

     

       8
       4
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       9
       9
       -
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       10
       10
       -
       	"github.com/go-chi/chi/v5"

     

       11
       5
        
       )

     

       12
       12
       -
       

     

       13
       13
       -
       func didPath(r *http.Request) string {

     

       14
       14
       -
       	did := chi.URLParam(r, "did")

     

       15
       15
       -
       	name := chi.URLParam(r, "name")

     

       16
       16
       -
       	path, _ := securejoin.SecureJoin(did, name)

     

       17
       17
       -
       	filepath.Clean(path)

     

       18
       18
       -
       	return path

     

       19
       19
       -
       }

     

       20
       20
       -
       

     

       21
       21
       -
       func getDescription(path string) (desc string) {

     

       22
       22
       -
       	db, err := os.ReadFile(filepath.Join(path, "description"))

     

       23
       23
       -
       	if err == nil {

     

       24
       24
       -
       		desc = string(db)

     

       25
       25
       -
       	} else {

     

       26
       26
       -
       		desc = ""

     

       27
       27
       -
       	}

     

       28
       28
       -
       	return

     

       29
       29
       -
       }

     

       30
       30
       -
       func setContentDisposition(w http.ResponseWriter, name string) {

     

       31
       31
       -
       	h := "inline; filename=\"" + name + "\""

     

       32
       32
       -
       	w.Header().Add("Content-Disposition", h)

     

       33
       33
       -
       }

     

       34
       34
       -
       

     

       35
       35
       -
       func setGZipMIME(w http.ResponseWriter) {

     

       36
       36
       -
       	setMIME(w, "application/gzip")

     

       37
       37
       -
       }

     

       38
       38
       -
       

     

       39
       39
       -
       func setMIME(w http.ResponseWriter, mime string) {

     

       40
       40
       -
       	w.Header().Add("Content-Type", mime)

     

       41
       41
       -
       }

     

       42
       6
        
       

     

       43
       7
        
       var TIDClock = syntax.NewTIDClock(0)

     

       44
       8

+8 -5

lexicons/repo/repo.json

···

       12
       12
        
               "required": [

     

       13
       13
        
                 "name",

     

       14
       14
        
                 "knot",

     

       15
       15
       -
                 "owner",

     

       16
       15
        
                 "createdAt"

     

       17
       16
        
               ],

     

       18
       17
        
               "properties": {

     

       19
       18
        
                 "name": {

     

       20
       19
        
                   "type": "string",

     

       21
       20
        
                   "description": "name of the repo"

     

       22
       22
       -
                 },

     

       23
       23
       -
                 "owner": {

     

       24
       24
       -
                   "type": "string",

     

       25
       25
       -
                   "format": "did"

     

       26
       21
        
                 },

     

       27
       22
        
                 "knot": {

     

       28
       23
        
                   "type": "string",

     
···

       41
       36
        
                   "type": "string",

     

       42
       37
        
                   "format": "uri",

     

       43
       38
        
                   "description": "source of the repo"

     

       39
       39
       +
                 },

     

       40
       40
       +
                 "labels": {

     

       41
       41
       +
                   "type": "array",

     

       42
       42
       +
                   "description": "List of labels that this repo subscribes to",

     

       43
       43
       +
                   "items": {

     

       44
       44
       +
                     "type": "string",

     

       45
       45
       +
                     "format": "at-uri"

     

       46
       46
       +
                   }

     

       44
       47
        
                 },

     

       45
       48
        
                 "createdAt": {

     

       46
       49
        
                   "type": "string",

+5 -5

spindle/ingester.go

···

       162
       162
        
       

     

       163
       163
        
       		// no spindle configured for this repo

     

       164
       164
        
       		if record.Spindle == nil {

     

       165
       165
       -
       			l.Info("no spindle configured", "did", record.Owner, "name", record.Name)

     

       165
       165
       +
       			l.Info("no spindle configured", "name", record.Name)

     

       166
       166
        
       			return nil

     

       167
       167
        
       		}

     

       168
       168
        
       

     

       169
       169
        
       		// this repo did not want this spindle

     

       170
       170
        
       		if *record.Spindle != domain {

     

       171
       171
       -
       			l.Info("different spindle configured", "did", record.Owner, "name", record.Name, "spindle", *record.Spindle, "domain", domain)

     

       171
       171
       +
       			l.Info("different spindle configured", "name", record.Name, "spindle", *record.Spindle, "domain", domain)

     

       172
       172
        
       			return nil

     

       173
       173
        
       		}

     

       174
       174
        
       

     

       175
       175
        
       		// add this repo to the watch list

     

       176
       176
       -
       		if err := s.db.AddRepo(record.Knot, record.Owner, record.Name); err != nil {

     

       176
       176
       +
       		if err := s.db.AddRepo(record.Knot, did, record.Name); err != nil {

     

       177
       177
        
       			l.Error("failed to add repo", "error", err)

     

       178
       178
        
       			return fmt.Errorf("failed to add repo: %w", err)

     

       179
       179
        
       		}

     

       180
       180
        
       

     

       181
       181
       -
       		didSlashRepo, err := securejoin.SecureJoin(record.Owner, record.Name)

     

       181
       181
       +
       		didSlashRepo, err := securejoin.SecureJoin(did, record.Name)

     

       182
       182
        
       		if err != nil {

     

       183
       183
        
       			return err

     

       184
       184
        
       		}

     

       185
       185
        
       

     

       186
       186
        
       		// add repo to rbac

     

       187
       187
       -
       		if err := s.e.AddRepo(record.Owner, rbac.ThisServer, didSlashRepo); err != nil {

     

       187
       187
       +
       		if err := s.e.AddRepo(did, rbac.ThisServer, didSlashRepo); err != nil {

     

       188
       188
        
       			l.Error("failed to add repo to enforcer", "error", err)

     

       189
       189
        
       			return fmt.Errorf("failed to add repo: %w", err)

     

       190
       190
        
       		}

+1 -1

spindle/xrpc/add_secret.go

···

       62
       62
        
       	}

     

       63
       63
        
       

     

       64
       64
        
       	repo := resp.Value.Val.(*tangled.Repo)

     

       65
       65
       -
       	didPath, err := securejoin.SecureJoin(repo.Owner, repo.Name)

     

       65
       65
       +
       	didPath, err := securejoin.SecureJoin(ident.DID.String(), repo.Name)

     

       66
       66
        
       	if err != nil {

     

       67
       67
        
       		fail(xrpcerr.GenericError(err))

     

       68
       68
        
       		return

+1 -1

spindle/xrpc/list_secrets.go

···

       57
       57
        
       	}

     

       58
       58
        
       

     

       59
       59
        
       	repo := resp.Value.Val.(*tangled.Repo)

     

       60
       60
       -
       	didPath, err := securejoin.SecureJoin(repo.Owner, repo.Name)

     

       60
       60
       +
       	didPath, err := securejoin.SecureJoin(ident.DID.String(), repo.Name)

     

       61
       61
        
       	if err != nil {

     

       62
       62
        
       		fail(xrpcerr.GenericError(err))

     

       63
       63
        
       		return

+1 -1

spindle/xrpc/remove_secret.go

···

       56
       56
        
       	}

     

       57
       57
        
       

     

       58
       58
        
       	repo := resp.Value.Val.(*tangled.Repo)

     

       59
       59
       -
       	didPath, err := securejoin.SecureJoin(repo.Owner, repo.Name)

     

       59
       59
       +
       	didPath, err := securejoin.SecureJoin(ident.DID.String(), repo.Name)

     

       60
       60
        
       	if err != nil {

     

       61
       61
        
       		fail(xrpcerr.GenericError(err))

     

       62
       62
        
       		return