commit ca4b9c8ba21e24162639f4d53f9ea755972c3e5f · julien.rbrt.fr/tangled-core

+37

appview/oauth/handler/handler.go

···

       14
       14
        
       	"github.com/lestrrat-go/jwx/v2/jwk"

     

       15
       15
        
       	"tangled.sh/tangled.sh/core/appview"

     

       16
       16
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       17
       17
       +
       	"tangled.sh/tangled.sh/core/appview/knotclient"

     

       17
       18
        
       	"tangled.sh/tangled.sh/core/appview/middleware"

     

       18
       19
        
       	"tangled.sh/tangled.sh/core/appview/oauth"

     

       19
       20
        
       	"tangled.sh/tangled.sh/core/appview/oauth/client"

     

       20
       21
        
       	"tangled.sh/tangled.sh/core/appview/pages"

     

       22
       22
       +
       	"tangled.sh/tangled.sh/core/rbac"

     

       21
       23
        
       )

     

       22
       24
        
       

     

       23
       25
        
       const (

     
···

       31
       33
        
       	Db       *db.DB

     

       32
       34
        
       	Store    *sessions.CookieStore

     

       33
       35
        
       	OAuth    *oauth.OAuth

     

       36
       36
       +
       	Enforcer *rbac.Enforcer

     

       34
       37
        
       }

     

       35
       38
        
       

     

       36
       39
        
       func (o *OAuthHandler) Router() http.Handler {

     
···

       243
       246
        
       	}

     

       244
       247
        
       

     

       245
       248
        
       	log.Println("session saved successfully")

     

       249
       249
       +
       	go o.addToDefaultKnot(oauthRequest.Did)

     

       246
       250
        
       

     

       247
       251
        
       	http.Redirect(w, r, "/", http.StatusFound)

     

       248
       252
        
       }

     
···

       270
       274
        
       	}

     

       271
       275
        
       	return pubKey, nil

     

       272
       276
        
       }

     

       277
       277
       +
       

     

       278
       278
       +
       func (o *OAuthHandler) addToDefaultKnot(did string) {

     

       279
       279
       +
       	defaultKnot := "knot1.tangled.sh"

     

       280
       280
       +
       

     

       281
       281
       +
       	log.Printf("adding %s to default knot", did)

     

       282
       282
       +
       	err := o.Enforcer.AddMember(defaultKnot, did)

     

       283
       283
       +
       	if err != nil {

     

       284
       284
       +
       		log.Println("failed to add user to knot1.tangled.sh: ", err)

     

       285
       285
       +
       		return

     

       286
       286
       +
       	}

     

       287
       287
       +
       	err = o.Enforcer.E.SavePolicy()

     

       288
       288
       +
       	if err != nil {

     

       289
       289
       +
       		log.Println("failed to add user to knot1.tangled.sh: ", err)

     

       290
       290
       +
       		return

     

       291
       291
       +
       	}

     

       292
       292
       +
       

     

       293
       293
       +
       	secret, err := db.GetRegistrationKey(o.Db, defaultKnot)

     

       294
       294
       +
       	if err != nil {

     

       295
       295
       +
       		log.Println("failed to get registration key for knot1.tangled.sh")

     

       296
       296
       +
       		return

     

       297
       297
       +
       	}

     

       298
       298
       +
       	signedClient, err := knotclient.NewSignedClient(defaultKnot, secret, o.Config.Core.Dev)

     

       299
       299
       +
       	resp, err := signedClient.AddMember(did)

     

       300
       300
       +
       	if err != nil {

     

       301
       301
       +
       		log.Println("failed to add user to knot1.tangled.sh: ", err)

     

       302
       302
       +
       		return

     

       303
       303
       +
       	}

     

       304
       304
       +
       

     

       305
       305
       +
       	if resp.StatusCode != http.StatusNoContent {

     

       306
       306
       +
       		log.Println("failed to add user to knot1.tangled.sh: ", resp.StatusCode)

     

       307
       307
       +
       		return

     

       308
       308
       +
       	}

     

       309
       309
       +
       }

+2 -1

appview/state/artifact.go

···

       16
       16
        
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       17
       17
        
       	"tangled.sh/tangled.sh/core/appview"

     

       18
       18
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       19
       19
       +
       	"tangled.sh/tangled.sh/core/appview/knotclient"

     

       19
       20
        
       	"tangled.sh/tangled.sh/core/appview/pages"

     

       20
       21
        
       	"tangled.sh/tangled.sh/core/types"

     

       21
       22
        
       )

     
···

       263
       264
        
       		return nil, err

     

       264
       265
        
       	}

     

       265
       266
        
       

     

       266
       266
       -
       	us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       267
       267
       +
       	us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       267
       268
        
       	if err != nil {

     

       268
       269
        
       		return nil, err

     

       269
       270
        
       	}

+15 -14

appview/state/pull.go

···

       14
       14
        
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       15
       15
        
       	"tangled.sh/tangled.sh/core/appview"

     

       16
       16
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       17
       17
       +
       	"tangled.sh/tangled.sh/core/appview/knotclient"

     

       17
       18
        
       	"tangled.sh/tangled.sh/core/appview/oauth"

     

       18
       19
        
       	"tangled.sh/tangled.sh/core/appview/pages"

     

       19
       20
        
       	"tangled.sh/tangled.sh/core/patchutil"

     
···

       143
       144
        
       		}

     

       144
       145
        
       	}

     

       145
       146
        
       

     

       146
       146
       -
       	ksClient, err := NewSignedClient(f.Knot, secret, s.config.Core.Dev)

     

       147
       147
       +
       	ksClient, err := knotclient.NewSignedClient(f.Knot, secret, s.config.Core.Dev)

     

       147
       148
        
       	if err != nil {

     

       148
       149
        
       		log.Printf("failed to setup signed client for %s; ignoring: %v", f.Knot, err)

     

       149
       150
        
       		return types.MergeCheckResponse{

     
···

       215
       216
        
       		repoName = f.RepoName

     

       216
       217
        
       	}

     

       217
       218
        
       

     

       218
       218
       -
       	us, err := NewUnsignedClient(knot, s.config.Core.Dev)

     

       219
       219
       +
       	us, err := knotclient.NewUnsignedClient(knot, s.config.Core.Dev)

     

       219
       220
        
       	if err != nil {

     

       220
       221
        
       		log.Printf("failed to setup client for %s; ignoring: %v", knot, err)

     

       221
       222
        
       		return pages.Unknown

     
···

       582
       583
        
       

     

       583
       584
        
       	switch r.Method {

     

       584
       585
        
       	case http.MethodGet:

     

       585
       585
       -
       		us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       586
       586
       +
       		us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       586
       587
        
       		if err != nil {

     

       587
       588
        
       			log.Printf("failed to create unsigned client for %s", f.Knot)

     

       588
       589
        
       			s.pages.Error503(w)

     
···

       651
       652
        
       			return

     

       652
       653
        
       		}

     

       653
       654
        
       

     

       654
       654
       -
       		us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       655
       655
       +
       		us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       655
       656
        
       		if err != nil {

     

       656
       657
        
       			log.Printf("failed to create unsigned client to %s: %v", f.Knot, err)

     

       657
       658
        
       			s.pages.Notice(w, "pull", "Failed to create a pull request. Try again later.")

     
···

       703
       704
        
       	}

     

       704
       705
        
       

     

       705
       706
        
       	// Generate a patch using /compare

     

       706
       706
       -
       	ksClient, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       707
       707
       +
       	ksClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       707
       708
        
       	if err != nil {

     

       708
       709
        
       		log.Printf("failed to create signed client for %s: %s", f.Knot, err)

     

       709
       710
        
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     
···

       755
       756
        
       		return

     

       756
       757
        
       	}

     

       757
       758
        
       

     

       758
       758
       -
       	sc, err := NewSignedClient(fork.Knot, secret, s.config.Core.Dev)

     

       759
       759
       +
       	sc, err := knotclient.NewSignedClient(fork.Knot, secret, s.config.Core.Dev)

     

       759
       760
        
       	if err != nil {

     

       760
       761
        
       		log.Println("failed to create signed client:", err)

     

       761
       762
        
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       762
       763
        
       		return

     

       763
       764
        
       	}

     

       764
       765
        
       

     

       765
       765
       -
       	us, err := NewUnsignedClient(fork.Knot, s.config.Core.Dev)

     

       766
       766
       +
       	us, err := knotclient.NewUnsignedClient(fork.Knot, s.config.Core.Dev)

     

       766
       767
        
       	if err != nil {

     

       767
       768
        
       		log.Println("failed to create unsigned client:", err)

     

       768
       769
        
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     
···

       964
       965
        
       		return

     

       965
       966
        
       	}

     

       966
       967
        
       

     

       967
       967
       -
       	us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       968
       968
       +
       	us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       968
       969
        
       	if err != nil {

     

       969
       970
        
       		log.Printf("failed to create unsigned client for %s", f.Knot)

     

       970
       971
        
       		s.pages.Error503(w)

     
···

       1034
       1035
        
       		return

     

       1035
       1036
        
       	}

     

       1036
       1037
        
       

     

       1037
       1037
       -
       	sourceBranchesClient, err := NewUnsignedClient(repo.Knot, s.config.Core.Dev)

     

       1038
       1038
       +
       	sourceBranchesClient, err := knotclient.NewUnsignedClient(repo.Knot, s.config.Core.Dev)

     

       1038
       1039
        
       	if err != nil {

     

       1039
       1040
        
       		log.Printf("failed to create unsigned client for %s", repo.Knot)

     

       1040
       1041
        
       		s.pages.Error503(w)

     
···

       1061
       1062
        
       		return

     

       1062
       1063
        
       	}

     

       1063
       1064
        
       

     

       1064
       1064
       -
       	targetBranchesClient, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       1065
       1065
       +
       	targetBranchesClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       1065
       1066
        
       	if err != nil {

     

       1066
       1067
        
       		log.Printf("failed to create unsigned client for target knot %s", f.Knot)

     

       1067
       1068
        
       		s.pages.Error503(w)

     
···

       1247
       1248
        
       		return

     

       1248
       1249
        
       	}

     

       1249
       1250
        
       

     

       1250
       1250
       -
       	ksClient, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       1251
       1251
       +
       	ksClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       1251
       1252
        
       	if err != nil {

     

       1252
       1253
        
       		log.Printf("failed to create client for %s: %s", f.Knot, err)

     

       1253
       1254
        
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     
···

       1367
       1368
        
       	}

     

       1368
       1369
        
       

     

       1369
       1370
        
       	// extract patch by performing compare

     

       1370
       1370
       -
       	ksClient, err := NewUnsignedClient(forkRepo.Knot, s.config.Core.Dev)

     

       1371
       1371
       +
       	ksClient, err := knotclient.NewUnsignedClient(forkRepo.Knot, s.config.Core.Dev)

     

       1371
       1372
        
       	if err != nil {

     

       1372
       1373
        
       		log.Printf("failed to create client for %s: %s", forkRepo.Knot, err)

     

       1373
       1374
        
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     
···

       1382
       1383
        
       	}

     

       1383
       1384
        
       

     

       1384
       1385
        
       	// update the hidden tracking branch to latest

     

       1385
       1385
       -
       	signedClient, err := NewSignedClient(forkRepo.Knot, secret, s.config.Core.Dev)

     

       1386
       1386
       +
       	signedClient, err := knotclient.NewSignedClient(forkRepo.Knot, secret, s.config.Core.Dev)

     

       1386
       1387
        
       	if err != nil {

     

       1387
       1388
        
       		log.Printf("failed to create signed client for %s: %s", forkRepo.Knot, err)

     

       1388
       1389
        
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     
···

       1533
       1534
        
       		log.Printf("failed to get primary email: %s", err)

     

       1534
       1535
        
       	}

     

       1535
       1536
        
       

     

       1536
       1536
       -
       	ksClient, err := NewSignedClient(f.Knot, secret, s.config.Core.Dev)

     

       1537
       1537
       +
       	ksClient, err := knotclient.NewSignedClient(f.Knot, secret, s.config.Core.Dev)

     

       1537
       1538
        
       	if err != nil {

     

       1538
       1539
        
       		log.Printf("failed to create signed client for %s: %s", f.Knot, err)

     

       1539
       1540
        
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

+11 -10

appview/state/repo.go

···

       19
       19
        
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       20
       20
        
       	"tangled.sh/tangled.sh/core/appview"

     

       21
       21
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       22
       22
       +
       	"tangled.sh/tangled.sh/core/appview/knotclient"

     

       22
       23
        
       	"tangled.sh/tangled.sh/core/appview/oauth"

     

       23
       24
        
       	"tangled.sh/tangled.sh/core/appview/pages"

     

       24
       25
        
       	"tangled.sh/tangled.sh/core/appview/pages/markup"

     
···

       45
       46
        
       		return

     

       46
       47
        
       	}

     

       47
       48
        
       

     

       48
       48
       -
       	us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       49
       49
       +
       	us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       49
       50
        
       	if err != nil {

     

       50
       51
        
       		log.Printf("failed to create unsigned client for %s", f.Knot)

     

       51
       52
        
       		s.pages.Error503(w)

     
···

       150
       151
        
       

     

       151
       152
        
       	ref := chi.URLParam(r, "ref")

     

       152
       153
        
       

     

       153
       153
       -
       	us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       154
       154
       +
       	us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       154
       155
        
       	if err != nil {

     

       155
       156
        
       		log.Println("failed to create unsigned client", err)

     

       156
       157
        
       		return

     
···

       416
       417
        
       		return

     

       417
       418
        
       	}

     

       418
       419
        
       

     

       419
       419
       -
       	us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       420
       420
       +
       	us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       420
       421
        
       	if err != nil {

     

       421
       422
        
       		log.Println("failed to create unsigned client", err)

     

       422
       423
        
       		return

     
···

       474
       475
        
       		return

     

       475
       476
        
       	}

     

       476
       477
        
       

     

       477
       477
       -
       	us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       478
       478
       +
       	us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       478
       479
        
       	if err != nil {

     

       479
       480
        
       		log.Println("failed to create unsigned client", err)

     

       480
       481
        
       		return

     
···

       657
       658
        
       		return

     

       658
       659
        
       	}

     

       659
       660
        
       

     

       660
       660
       -
       	ksClient, err := NewSignedClient(f.Knot, secret, s.config.Core.Dev)

     

       661
       661
       +
       	ksClient, err := knotclient.NewSignedClient(f.Knot, secret, s.config.Core.Dev)

     

       661
       662
        
       	if err != nil {

     

       662
       663
        
       		log.Println("failed to create client to ", f.Knot)

     

       663
       664
        
       		return

     
···

       752
       753
        
       		return

     

       753
       754
        
       	}

     

       754
       755
        
       

     

       755
       755
       -
       	ksClient, err := NewSignedClient(f.Knot, secret, s.config.Core.Dev)

     

       756
       756
       +
       	ksClient, err := knotclient.NewSignedClient(f.Knot, secret, s.config.Core.Dev)

     

       756
       757
        
       	if err != nil {

     

       757
       758
        
       		log.Println("failed to create client to ", f.Knot)

     

       758
       759
        
       		return

     
···

       847
       848
        
       		return

     

       848
       849
        
       	}

     

       849
       850
        
       

     

       850
       850
       -
       	ksClient, err := NewSignedClient(f.Knot, secret, s.config.Core.Dev)

     

       851
       851
       +
       	ksClient, err := knotclient.NewSignedClient(f.Knot, secret, s.config.Core.Dev)

     

       851
       852
        
       	if err != nil {

     

       852
       853
        
       		log.Println("failed to create client to ", f.Knot)

     

       853
       854
        
       		return

     
···

       893
       894
        
       

     

       894
       895
        
       		var branchNames []string

     

       895
       896
        
       		var defaultBranch string

     

       896
       896
       -
       		us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       897
       897
       +
       		us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       897
       898
        
       		if err != nil {

     

       898
       899
        
       			log.Println("failed to create unsigned client", err)

     

       899
       900
        
       		} else {

     
···

       1060
       1061
        
       

     

       1061
       1062
        
       	knot := f.Knot

     

       1062
       1063
        
       	var disableFork bool

     

       1063
       1063
       -
       	us, err := NewUnsignedClient(knot, s.config.Core.Dev)

     

       1064
       1064
       +
       	us, err := knotclient.NewUnsignedClient(knot, s.config.Core.Dev)

     

       1064
       1065
        
       	if err != nil {

     

       1065
       1066
        
       		log.Printf("failed to create unsigned client for %s: %v", knot, err)

     

       1066
       1067
        
       	} else {

     
···

       1862
       1863
        
       			return

     

       1863
       1864
        
       		}

     

       1864
       1865
        
       

     

       1865
       1865
       -
       		client, err := NewSignedClient(knot, secret, s.config.Core.Dev)

     

       1866
       1866
       +
       		client, err := knotclient.NewSignedClient(knot, secret, s.config.Core.Dev)

     

       1866
       1867
        
       		if err != nil {

     

       1867
       1868
        
       			s.pages.Notice(w, "repo", "Failed to reach knot server.")

     

       1868
       1869
        
       			return

+2 -1

appview/state/repo_util.go

···

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

     

       14
       14
        
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       15
       15
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       16
       16
       +
       	"tangled.sh/tangled.sh/core/appview/knotclient"

     

       16
       17
        
       	"tangled.sh/tangled.sh/core/appview/oauth"

     

       17
       18
        
       	"tangled.sh/tangled.sh/core/appview/pages/repoinfo"

     

       18
       19
        
       )

     
···

       45
       46
        
       	ref := chi.URLParam(r, "ref")

     

       46
       47
        
       

     

       47
       48
        
       	if ref == "" {

     

       48
       48
       -
       		us, err := NewUnsignedClient(knot, s.config.Core.Dev)

     

       49
       49
       +
       		us, err := knotclient.NewUnsignedClient(knot, s.config.Core.Dev)

     

       49
       50
        
       		if err != nil {

     

       50
       51
        
       			return nil, err

     

       51
       52
        
       		}

appview/state/router.go

···

       264
       264
        
       		Db:       s.db,

     

       265
       265
        
       		Store:    sessions.NewCookieStore([]byte(s.config.Core.CookieSecret)),

     

       266
       266
        
       		OAuth:    s.oauth,

     

       267
       267
       +
       		Enforcer: s.enforcer,

     

       267
       268
        
       	}

     

       268
       269
        
       

     

       269
       270
        
       	return oauth.Router()

+1 -1

appview/state/signer.go appview/knotclient/signer.go

···

       1
       1
       -
       package state

     

       1
       1
       +
       package knotclient

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"bytes"

+4 -3

appview/state/state.go

···

       20
       20
        
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       21
       21
        
       	"tangled.sh/tangled.sh/core/appview"

     

       22
       22
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       23
       23
       +
       	"tangled.sh/tangled.sh/core/appview/knotclient"

     

       23
       24
        
       	"tangled.sh/tangled.sh/core/appview/oauth"

     

       24
       25
        
       	"tangled.sh/tangled.sh/core/appview/pages"

     

       25
       26
        
       	"tangled.sh/tangled.sh/core/jetstream"

     
···

       309
       310
        
       		return

     

       310
       311
        
       	}

     

       311
       312
        
       

     

       312
       312
       -
       	client, err := NewSignedClient(domain, secret, s.config.Core.Dev)

     

       313
       313
       +
       	client, err := knotclient.NewSignedClient(domain, secret, s.config.Core.Dev)

     

       313
       314
        
       	if err != nil {

     

       314
       315
        
       		log.Println("failed to create client to ", domain)

     

       315
       316
        
       	}

     
···

       551
       552
        
       		return

     

       552
       553
        
       	}

     

       553
       554
        
       

     

       554
       554
       -
       	ksClient, err := NewSignedClient(domain, secret, s.config.Core.Dev)

     

       555
       555
       +
       	ksClient, err := knotclient.NewSignedClient(domain, secret, s.config.Core.Dev)

     

       555
       556
        
       	if err != nil {

     

       556
       557
        
       		log.Println("failed to create client to ", domain)

     

       557
       558
        
       		return

     
···

       672
       673
        
       			return

     

       673
       674
        
       		}

     

       674
       675
        
       

     

       675
       675
       -
       		client, err := NewSignedClient(domain, secret, s.config.Core.Dev)

     

       676
       676
       +
       		client, err := knotclient.NewSignedClient(domain, secret, s.config.Core.Dev)

     

       676
       677
        
       		if err != nil {

     

       677
       678
        
       			s.pages.Notice(w, "repo", "Failed to connect to knot server.")

     

       678
       679
        
       			return