patch of appview: add user in 503 error pages · round #0 · pull #11 · serendipty01.dev/tangled-core

+6 -2

appview/issues/issues.go

···

       101
        
       	)

     

       102
        
       	if err != nil {

     

       103
        
       		l.Error("failed to fetch labels", "err", err)

     

       104
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       105
        
       		return

     

       106
        
       	}

     

       107
        
       

     
···

       826
        
       	)

     

       827
        
       	if err != nil {

     

       828
        
       		l.Error("failed to fetch labels", "err", err)

     

       829
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       830
        
       		return

     

       831
        
       	}

     

       832

···

       101
        
       	)

     

       102
        
       	if err != nil {

     

       103
        
       		l.Error("failed to fetch labels", "err", err)

     

       104
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       105
       +
       			LoggedInUser: user,

     

       106
       +
       		})

     

       107
        
       		return

     

       108
        
       	}

     

       109
        
       

     
···

       828
        
       	)

     

       829
        
       	if err != nil {

     

       830
        
       		l.Error("failed to fetch labels", "err", err)

     

       831
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       832
       +
       			LoggedInUser: user,

     

       833
       +
       		})

     

       834
        
       		return

     

       835
        
       	}

     

       836

+2 -2

appview/pages/pages.go

···

       1534
        
       	return p.execute("errors/knot404", w, params)

     

       1535
        
       }

     

       1536
        
       

     

       1537
       -
       func (p *Pages) Error503(w io.Writer) error {

     

       1538
       -
       	return p.execute("errors/503", w, nil)

     

       1539
        
       }

···

       1534
        
       	return p.execute("errors/knot404", w, params)

     

       1535
        
       }

     

       1536
        
       

     

       1537
       +
       func (p *Pages) Error503(w io.Writer, params ErrorPageParams) error {

     

       1538
       +
       	return p.execute("errors/503", w, params)

     

       1539
        
       }

+30 -10

appview/pulls/pulls.go

···

       205
        
       	)

     

       206
        
       	if err != nil {

     

       207
        
       		log.Println("failed to fetch labels", err)

     

       208
       -
       		s.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       209
        
       		return

     

       210
        
       	}

     

       211
        
       

     
···

       636
        
       	)

     

       637
        
       	if err != nil {

     

       638
        
       		log.Println("failed to fetch labels", err)

     

       639
       -
       		s.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       640
        
       		return

     

       641
        
       	}

     

       642
        
       

     
···

       785
        
       		if err != nil {

     

       786
        
       			if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       787
        
       				log.Println("failed to call XRPC repo.branches", xrpcerr)

     

       788
       -
       				s.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       789
        
       				return

     

       790
        
       			}

     

       791
        
       			log.Println("failed to fetch branches", err)

     
···

       795
        
       		var result types.RepoBranchesResponse

     

       796
        
       		if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       797
        
       			log.Println("failed to decode XRPC response", err)

     

       798
       -
       			s.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       799
        
       			return

     

       800
        
       		}

     

       801
        
       

     
···

       1392
        
       	if err != nil {

     

       1393
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       1394
        
       			log.Println("failed to call XRPC repo.branches", xrpcerr)

     

       1395
       -
       			s.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       1396
        
       			return

     

       1397
        
       		}

     

       1398
        
       		log.Println("failed to fetch branches", err)

     
···

       1402
        
       	var result types.RepoBranchesResponse

     

       1403
        
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       1404
        
       		log.Println("failed to decode XRPC response", err)

     

       1405
       -
       		s.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       1406
        
       		return

     

       1407
        
       	}

     

       1408
        
       

     
···

       1484
        
       	if err != nil {

     

       1485
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       1486
        
       			log.Println("failed to call XRPC repo.branches for source", xrpcerr)

     

       1487
       -
       			s.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       1488
        
       			return

     

       1489
        
       		}

     

       1490
        
       		log.Println("failed to fetch source branches", err)

     
···

       1495
        
       	var sourceBranches types.RepoBranchesResponse

     

       1496
        
       	if err := json.Unmarshal(sourceXrpcBytes, &sourceBranches); err != nil {

     

       1497
        
       		log.Println("failed to decode source branches XRPC response", err)

     

       1498
       -
       		s.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       1499
        
       		return

     

       1500
        
       	}

     

       1501
        
       

     
···

       1513
        
       	if err != nil {

     

       1514
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       1515
        
       			log.Println("failed to call XRPC repo.branches for target", xrpcerr)

     

       1516
       -
       			s.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       1517
        
       			return

     

       1518
        
       		}

     

       1519
        
       		log.Println("failed to fetch target branches", err)

     
···

       1524
        
       	var targetBranches types.RepoBranchesResponse

     

       1525
        
       	if err := json.Unmarshal(targetXrpcBytes, &targetBranches); err != nil {

     

       1526
        
       		log.Println("failed to decode target branches XRPC response", err)

     

       1527
       -
       		s.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       1528
        
       		return

     

       1529
        
       	}

     

       1530

···

       205
        
       	)

     

       206
        
       	if err != nil {

     

       207
        
       		log.Println("failed to fetch labels", err)

     

       208
       +
       		s.pages.Error503(w, pages.ErrorPageParams{

     

       209
       +
       			LoggedInUser: user,

     

       210
       +
       		})

     

       211
        
       		return

     

       212
        
       	}

     

       213
        
       

     
···

       638
        
       	)

     

       639
        
       	if err != nil {

     

       640
        
       		log.Println("failed to fetch labels", err)

     

       641
       +
       		s.pages.Error503(w, pages.ErrorPageParams{

     

       642
       +
       			LoggedInUser: user,

     

       643
       +
       		})

     

       644
        
       		return

     

       645
        
       	}

     

       646
        
       

     
···

       789
        
       		if err != nil {

     

       790
        
       			if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       791
        
       				log.Println("failed to call XRPC repo.branches", xrpcerr)

     

       792
       +
       				s.pages.Error503(w, pages.ErrorPageParams{

     

       793
       +
       					LoggedInUser: user,

     

       794
       +
       				})

     

       795
        
       				return

     

       796
        
       			}

     

       797
        
       			log.Println("failed to fetch branches", err)

     
···

       801
        
       		var result types.RepoBranchesResponse

     

       802
        
       		if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       803
        
       			log.Println("failed to decode XRPC response", err)

     

       804
       +
       			s.pages.Error503(w, pages.ErrorPageParams{

     

       805
       +
       				LoggedInUser: user,

     

       806
       +
       			})

     

       807
        
       			return

     

       808
        
       		}

     

       809
        
       

     
···

       1400
        
       	if err != nil {

     

       1401
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       1402
        
       			log.Println("failed to call XRPC repo.branches", xrpcerr)

     

       1403
       +
       			s.pages.Error503(w, pages.ErrorPageParams{

     

       1404
       +
       				LoggedInUser: user,

     

       1405
       +
       			})

     

       1406
        
       			return

     

       1407
        
       		}

     

       1408
        
       		log.Println("failed to fetch branches", err)

     
···

       1412
        
       	var result types.RepoBranchesResponse

     

       1413
        
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       1414
        
       		log.Println("failed to decode XRPC response", err)

     

       1415
       +
       		s.pages.Error503(w, pages.ErrorPageParams{

     

       1416
       +
       			LoggedInUser: user,

     

       1417
       +
       		})

     

       1418
        
       		return

     

       1419
        
       	}

     

       1420
        
       

     
···

       1496
        
       	if err != nil {

     

       1497
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       1498
        
       			log.Println("failed to call XRPC repo.branches for source", xrpcerr)

     

       1499
       +
       			s.pages.Error503(w, pages.ErrorPageParams{

     

       1500
       +
       				LoggedInUser: user,

     

       1501
       +
       			})

     

       1502
        
       			return

     

       1503
        
       		}

     

       1504
        
       		log.Println("failed to fetch source branches", err)

     
···

       1509
        
       	var sourceBranches types.RepoBranchesResponse

     

       1510
        
       	if err := json.Unmarshal(sourceXrpcBytes, &sourceBranches); err != nil {

     

       1511
        
       		log.Println("failed to decode source branches XRPC response", err)

     

       1512
       +
       		s.pages.Error503(w, pages.ErrorPageParams{

     

       1513
       +
       			LoggedInUser: user,

     

       1514
       +
       		})

     

       1515
        
       		return

     

       1516
        
       	}

     

       1517
        
       

     
···

       1529
        
       	if err != nil {

     

       1530
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       1531
        
       			log.Println("failed to call XRPC repo.branches for target", xrpcerr)

     

       1532
       +
       			s.pages.Error503(w, pages.ErrorPageParams{

     

       1533
       +
       				LoggedInUser: user,

     

       1534
       +
       			})

     

       1535
        
       			return

     

       1536
        
       		}

     

       1537
        
       		log.Println("failed to fetch target branches", err)

     
···

       1542
        
       	var targetBranches types.RepoBranchesResponse

     

       1543
        
       	if err := json.Unmarshal(targetXrpcBytes, &targetBranches); err != nil {

     

       1544
        
       		log.Println("failed to decode target branches XRPC response", err)

     

       1545
       +
       		s.pages.Error503(w, pages.ErrorPageParams{

     

       1546
       +
       			LoggedInUser: user,

     

       1547
       +
       		})

     

       1548
        
       		return

     

       1549
        
       	}

     

       1550

+3 -1

appview/repo/index.go

···

       67
        
       			return

     

       68
        
       		}

     

       69
        
       

     

       70
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       71
        
       		l.Error("failed to build index response", "err", err)

     

       72
        
       		return

     

       73
        
       	}

···

       67
        
       			return

     

       68
        
       		}

     

       69
        
       

     

       70
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       71
       +
       			LoggedInUser: user,

     

       72
       +
       		})

     

       73
        
       		l.Error("failed to build index response", "err", err)

     

       74
        
       		return

     

       75
        
       	}

+76 -31

appview/repo/repo.go

···

       90
        
       

     

       91
        
       func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) {

     

       92
        
       	l := rp.logger.With("handler", "DownloadArchive")

     

       0
        
       
     

       93
        
       

     

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

     

       95
        
       	ref, _ = url.PathUnescape(ref)

     
···

       113
        
       	archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, repo)

     

       114
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       115
        
       		l.Error("failed to call XRPC repo.archive", "err", xrpcerr)

     

       116
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       117
        
       		return

     

       118
        
       	}

     

       119
        
       

     
···

       130
        
       

     

       131
        
       func (rp *Repo) RepoLog(w http.ResponseWriter, r *http.Request) {

     

       132
        
       	l := rp.logger.With("handler", "RepoLog")

     

       0
        
       
     

       133
        
       

     

       134
        
       	f, err := rp.repoResolver.Resolve(r)

     

       135
        
       	if err != nil {

     
···

       169
        
       	xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo)

     

       170
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       171
        
       		l.Error("failed to call XRPC repo.log", "err", xrpcerr)

     

       172
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       173
        
       		return

     

       174
        
       	}

     

       175
        
       

     

       176
        
       	var xrpcResp types.RepoLogResponse

     

       177
        
       	if err := json.Unmarshal(xrpcBytes, &xrpcResp); err != nil {

     

       178
        
       		l.Error("failed to decode XRPC response", "err", err)

     

       179
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       180
        
       		return

     

       181
        
       	}

     

       182
        
       

     

       183
        
       	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       184
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       185
        
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       186
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       187
        
       		return

     

       188
        
       	}

     

       189
        
       

     
···

       204
        
       	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       205
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       206
        
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       207
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       208
        
       		return

     

       209
        
       	}

     

       210
        
       

     
···

       217
        
       		}

     

       218
        
       	}

     

       219
        
       

     

       220
       -
       	user := rp.oauth.GetUser(r)

     

       221
       -
       

     

       222
        
       	emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(xrpcResp.Commits), true)

     

       223
        
       	if err != nil {

     

       224
        
       		l.Error("failed to fetch email to did mapping", "err", err)

     
···

       388
        
       	xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo)

     

       389
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       390
        
       		l.Error("failed to call XRPC repo.diff", "err", xrpcerr)

     

       391
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       392
        
       		return

     

       393
        
       	}

     

       394
        
       

     

       395
        
       	var result types.RepoCommitResponse

     

       396
        
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       397
        
       		l.Error("failed to decode XRPC response", "err", err)

     

       398
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       399
        
       		return

     

       400
        
       	}

     

       401
        
       

     
···

       433
        
       

     

       434
        
       func (rp *Repo) RepoTree(w http.ResponseWriter, r *http.Request) {

     

       435
        
       	l := rp.logger.With("handler", "RepoTree")

     

       0
        
       
     

       436
        
       

     

       437
        
       	f, err := rp.repoResolver.Resolve(r)

     

       438
        
       	if err != nil {

     
···

       462
        
       	xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo)

     

       463
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       464
        
       		l.Error("failed to call XRPC repo.tree", "err", xrpcerr)

     

       465
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       466
        
       		return

     

       467
        
       	}

     

       468
        
       

     
···

       514
        
       		return

     

       515
        
       	}

     

       516
        
       

     

       517
       -
       	user := rp.oauth.GetUser(r)

     

       518
       -
       

     

       519
        
       	var breadcrumbs [][]string

     

       520
        
       	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})

     

       521
        
       	if treePath != "" {

     
···

       537
        
       

     

       538
        
       func (rp *Repo) RepoTags(w http.ResponseWriter, r *http.Request) {

     

       539
        
       	l := rp.logger.With("handler", "RepoTags")

     

       0
        
       
     

       540
        
       

     

       541
        
       	f, err := rp.repoResolver.Resolve(r)

     

       542
        
       	if err != nil {

     
···

       557
        
       	xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       558
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       559
        
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       560
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       561
        
       		return

     

       562
        
       	}

     

       563
        
       

     

       564
        
       	var result types.RepoTagsResponse

     

       565
        
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       566
        
       		l.Error("failed to decode XRPC response", "err", err)

     

       567
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       568
        
       		return

     

       569
        
       	}

     

       570
        
       

     
···

       596
        
       		}

     

       597
        
       	}

     

       598
        
       

     

       599
       -
       	user := rp.oauth.GetUser(r)

     

       600
        
       	rp.pages.RepoTags(w, pages.RepoTagsParams{

     

       601
        
       		LoggedInUser:      user,

     

       602
        
       		RepoInfo:          f.RepoInfo(user),

     
···

       608
        
       

     

       609
        
       func (rp *Repo) RepoBranches(w http.ResponseWriter, r *http.Request) {

     

       610
        
       	l := rp.logger.With("handler", "RepoBranches")

     

       0
        
       
     

       611
        
       

     

       612
        
       	f, err := rp.repoResolver.Resolve(r)

     

       613
        
       	if err != nil {

     
···

       628
        
       	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       629
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       630
        
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       631
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       632
        
       		return

     

       633
        
       	}

     

       634
        
       

     

       635
        
       	var result types.RepoBranchesResponse

     

       636
        
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       637
        
       		l.Error("failed to decode XRPC response", "err", err)

     

       638
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       639
        
       		return

     

       640
        
       	}

     

       641
        
       

     

       642
        
       	sortBranches(result.Branches)

     

       643
        
       

     

       644
       -
       	user := rp.oauth.GetUser(r)

     

       645
        
       	rp.pages.RepoBranches(w, pages.RepoBranchesParams{

     

       646
        
       		LoggedInUser:         user,

     

       647
        
       		RepoInfo:             f.RepoInfo(user),

     
···

       700
        
       

     

       701
        
       func (rp *Repo) RepoBlob(w http.ResponseWriter, r *http.Request) {

     

       702
        
       	l := rp.logger.With("handler", "RepoBlob")

     

       0
        
       
     

       703
        
       

     

       704
        
       	f, err := rp.repoResolver.Resolve(r)

     

       705
        
       	if err != nil {

     
···

       726
        
       	resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)

     

       727
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       728
        
       		l.Error("failed to call XRPC repo.blob", "err", xrpcerr)

     

       729
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       730
        
       		return

     

       731
        
       	}

     

       732
        
       

     
···

       798
        
       		sizeHint = uint64(len(resp.Content))

     

       799
        
       	}

     

       800
        
       

     

       801
       -
       	user := rp.oauth.GetUser(r)

     

       802
       -
       

     

       803
        
       	// Determine if content is binary (dereference pointer)

     

       804
        
       	isBinary := false

     

       805
        
       	if resp.IsBinary != nil {

     
···

       826
        
       

     

       827
        
       func (rp *Repo) RepoBlobRaw(w http.ResponseWriter, r *http.Request) {

     

       828
        
       	l := rp.logger.With("handler", "RepoBlobRaw")

     

       0
        
       
     

       829
        
       

     

       830
        
       	f, err := rp.repoResolver.Resolve(r)

     

       831
        
       	if err != nil {

     
···

       874
        
       	resp, err := client.Do(req)

     

       875
        
       	if err != nil {

     

       876
        
       		l.Error("failed to reach knotserver", "err", err)

     

       877
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       878
        
       		return

     

       879
        
       	}

     

       880
        
       	defer resp.Body.Close()

     
···

       1965
        
       	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       1966
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       1967
        
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       1968
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       1969
        
       		return

     

       1970
        
       	}

     

       1971
        
       

     

       1972
        
       	var result types.RepoBranchesResponse

     

       1973
        
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       1974
        
       		l.Error("failed to decode XRPC response", "err", err)

     

       1975
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       1976
        
       		return

     

       1977
        
       	}

     

       1978
        
       

     

       1979
        
       	defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", models.DefaultLabelDefs()))

     

       1980
        
       	if err != nil {

     

       1981
        
       		l.Error("failed to fetch labels", "err", err)

     

       1982
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       1983
        
       		return

     

       1984
        
       	}

     

       1985
        
       

     

       1986
        
       	labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))

     

       1987
        
       	if err != nil {

     

       1988
        
       		l.Error("failed to fetch labels", "err", err)

     

       1989
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       1990
        
       		return

     

       1991
        
       	}

     

       1992
        
       	// remove default labels from the labels list, if present

     
···

       2420
        
       	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       2421
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       2422
        
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       2423
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       2424
        
       		return

     

       2425
        
       	}

     

       2426
        
       

     
···

       2457
        
       	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       2458
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       2459
        
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       2460
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       2461
        
       		return

     

       2462
        
       	}

     

       2463
        
       

     
···

       2534
        
       	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       2535
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       2536
        
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       2537
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       2538
        
       		return

     

       2539
        
       	}

     

       2540
        
       

     
···

       2548
        
       	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       2549
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       2550
        
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       2551
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       2552
        
       		return

     

       2553
        
       	}

     

       2554
        
       

     
···

       2562
        
       	compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head)

     

       2563
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       2564
        
       		l.Error("failed to call XRPC repo.compare", "err", xrpcerr)

     

       2565
       -
       		rp.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       2566
        
       		return

     

       2567
        
       	}

     

       2568

···

       90
        
       

     

       91
        
       func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) {

     

       92
        
       	l := rp.logger.With("handler", "DownloadArchive")

     

       93
       +
       	user := rp.oauth.GetUser(r)

     

       94
        
       

     

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

     

       96
        
       	ref, _ = url.PathUnescape(ref)

     
···

       114
        
       	archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, repo)

     

       115
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       116
        
       		l.Error("failed to call XRPC repo.archive", "err", xrpcerr)

     

       117
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       118
       +
       			LoggedInUser: user,

     

       119
       +
       		})

     

       120
        
       		return

     

       121
        
       	}

     

       122
        
       

     
···

       133
        
       

     

       134
        
       func (rp *Repo) RepoLog(w http.ResponseWriter, r *http.Request) {

     

       135
        
       	l := rp.logger.With("handler", "RepoLog")

     

       136
       +
       	user := rp.oauth.GetUser(r)

     

       137
        
       

     

       138
        
       	f, err := rp.repoResolver.Resolve(r)

     

       139
        
       	if err != nil {

     
···

       173
        
       	xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo)

     

       174
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       175
        
       		l.Error("failed to call XRPC repo.log", "err", xrpcerr)

     

       176
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       177
       +
       			LoggedInUser: user,

     

       178
       +
       		})

     

       179
        
       		return

     

       180
        
       	}

     

       181
        
       

     

       182
        
       	var xrpcResp types.RepoLogResponse

     

       183
        
       	if err := json.Unmarshal(xrpcBytes, &xrpcResp); err != nil {

     

       184
        
       		l.Error("failed to decode XRPC response", "err", err)

     

       185
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       186
       +
       			LoggedInUser: user,

     

       187
       +
       		})

     

       188
        
       		return

     

       189
        
       	}

     

       190
        
       

     

       191
        
       	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       192
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       193
        
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       194
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       195
       +
       			LoggedInUser: user,

     

       196
       +
       		})

     

       197
        
       		return

     

       198
        
       	}

     

       199
        
       

     
···

       214
        
       	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       215
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       216
        
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       217
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       218
       +
       			LoggedInUser: user,

     

       219
       +
       		})

     

       220
        
       		return

     

       221
        
       	}

     

       222
        
       

     
···

       229
        
       		}

     

       230
        
       	}

     

       231
        
       

     

       0
        
       
     

       0
        
       
     

       232
        
       	emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(xrpcResp.Commits), true)

     

       233
        
       	if err != nil {

     

       234
        
       		l.Error("failed to fetch email to did mapping", "err", err)

     
···

       398
        
       	xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo)

     

       399
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       400
        
       		l.Error("failed to call XRPC repo.diff", "err", xrpcerr)

     

       401
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       402
       +
       			LoggedInUser: user,

     

       403
       +
       		})

     

       404
        
       		return

     

       405
        
       	}

     

       406
        
       

     

       407
        
       	var result types.RepoCommitResponse

     

       408
        
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       409
        
       		l.Error("failed to decode XRPC response", "err", err)

     

       410
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       411
       +
       			LoggedInUser: user,

     

       412
       +
       		})

     

       413
        
       		return

     

       414
        
       	}

     

       415
        
       

     
···

       447
        
       

     

       448
        
       func (rp *Repo) RepoTree(w http.ResponseWriter, r *http.Request) {

     

       449
        
       	l := rp.logger.With("handler", "RepoTree")

     

       450
       +
       	user := rp.oauth.GetUser(r)

     

       451
        
       

     

       452
        
       	f, err := rp.repoResolver.Resolve(r)

     

       453
        
       	if err != nil {

     
···

       477
        
       	xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo)

     

       478
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       479
        
       		l.Error("failed to call XRPC repo.tree", "err", xrpcerr)

     

       480
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       481
       +
       			LoggedInUser: user,

     

       482
       +
       		})

     

       483
        
       		return

     

       484
        
       	}

     

       485
        
       

     
···

       531
        
       		return

     

       532
        
       	}

     

       533
        
       

     

       0
        
       
     

       0
        
       
     

       534
        
       	var breadcrumbs [][]string

     

       535
        
       	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})

     

       536
        
       	if treePath != "" {

     
···

       552
        
       

     

       553
        
       func (rp *Repo) RepoTags(w http.ResponseWriter, r *http.Request) {

     

       554
        
       	l := rp.logger.With("handler", "RepoTags")

     

       555
       +
       	user := rp.oauth.GetUser(r)

     

       556
        
       

     

       557
        
       	f, err := rp.repoResolver.Resolve(r)

     

       558
        
       	if err != nil {

     
···

       573
        
       	xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       574
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       575
        
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       576
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       577
       +
       			LoggedInUser: user,

     

       578
       +
       		})

     

       579
        
       		return

     

       580
        
       	}

     

       581
        
       

     

       582
        
       	var result types.RepoTagsResponse

     

       583
        
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       584
        
       		l.Error("failed to decode XRPC response", "err", err)

     

       585
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       586
       +
       			LoggedInUser: user,

     

       587
       +
       		})

     

       588
        
       		return

     

       589
        
       	}

     

       590
        
       

     
···

       616
        
       		}

     

       617
        
       	}

     

       618
        
       

     

       0
        
       
     

       619
        
       	rp.pages.RepoTags(w, pages.RepoTagsParams{

     

       620
        
       		LoggedInUser:      user,

     

       621
        
       		RepoInfo:          f.RepoInfo(user),

     
···

       627
        
       

     

       628
        
       func (rp *Repo) RepoBranches(w http.ResponseWriter, r *http.Request) {

     

       629
        
       	l := rp.logger.With("handler", "RepoBranches")

     

       630
       +
       	user := rp.oauth.GetUser(r)

     

       631
        
       

     

       632
        
       	f, err := rp.repoResolver.Resolve(r)

     

       633
        
       	if err != nil {

     
···

       648
        
       	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       649
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       650
        
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       651
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       652
       +
       			LoggedInUser: user,

     

       653
       +
       		})

     

       654
        
       		return

     

       655
        
       	}

     

       656
        
       

     

       657
        
       	var result types.RepoBranchesResponse

     

       658
        
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       659
        
       		l.Error("failed to decode XRPC response", "err", err)

     

       660
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       661
       +
       			LoggedInUser: user,

     

       662
       +
       		})

     

       663
        
       		return

     

       664
        
       	}

     

       665
        
       

     

       666
        
       	sortBranches(result.Branches)

     

       667
        
       

     

       0
        
       
     

       668
        
       	rp.pages.RepoBranches(w, pages.RepoBranchesParams{

     

       669
        
       		LoggedInUser:         user,

     

       670
        
       		RepoInfo:             f.RepoInfo(user),

     
···

       723
        
       

     

       724
        
       func (rp *Repo) RepoBlob(w http.ResponseWriter, r *http.Request) {

     

       725
        
       	l := rp.logger.With("handler", "RepoBlob")

     

       726
       +
       	user := rp.oauth.GetUser(r)

     

       727
        
       

     

       728
        
       	f, err := rp.repoResolver.Resolve(r)

     

       729
        
       	if err != nil {

     
···

       750
        
       	resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)

     

       751
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       752
        
       		l.Error("failed to call XRPC repo.blob", "err", xrpcerr)

     

       753
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       754
       +
       			LoggedInUser: user,

     

       755
       +
       		})

     

       756
        
       		return

     

       757
        
       	}

     

       758
        
       

     
···

       824
        
       		sizeHint = uint64(len(resp.Content))

     

       825
        
       	}

     

       826
        
       

     

       0
        
       
     

       0
        
       
     

       827
        
       	// Determine if content is binary (dereference pointer)

     

       828
        
       	isBinary := false

     

       829
        
       	if resp.IsBinary != nil {

     
···

       850
        
       

     

       851
        
       func (rp *Repo) RepoBlobRaw(w http.ResponseWriter, r *http.Request) {

     

       852
        
       	l := rp.logger.With("handler", "RepoBlobRaw")

     

       853
       +
       	user := rp.oauth.GetUser(r)

     

       854
        
       

     

       855
        
       	f, err := rp.repoResolver.Resolve(r)

     

       856
        
       	if err != nil {

     
···

       899
        
       	resp, err := client.Do(req)

     

       900
        
       	if err != nil {

     

       901
        
       		l.Error("failed to reach knotserver", "err", err)

     

       902
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       903
       +
       			LoggedInUser: user,

     

       904
       +
       		})

     

       905
        
       		return

     

       906
        
       	}

     

       907
        
       	defer resp.Body.Close()

     
···

       1992
        
       	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       1993
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       1994
        
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       1995
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       1996
       +
       			LoggedInUser: user,

     

       1997
       +
       		})

     

       1998
        
       		return

     

       1999
        
       	}

     

       2000
        
       

     

       2001
        
       	var result types.RepoBranchesResponse

     

       2002
        
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       2003
        
       		l.Error("failed to decode XRPC response", "err", err)

     

       2004
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       2005
       +
       			LoggedInUser: user,

     

       2006
       +
       		})

     

       2007
        
       		return

     

       2008
        
       	}

     

       2009
        
       

     

       2010
        
       	defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", models.DefaultLabelDefs()))

     

       2011
        
       	if err != nil {

     

       2012
        
       		l.Error("failed to fetch labels", "err", err)

     

       2013
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       2014
       +
       			LoggedInUser: user,

     

       2015
       +
       		})

     

       2016
        
       		return

     

       2017
        
       	}

     

       2018
        
       

     

       2019
        
       	labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))

     

       2020
        
       	if err != nil {

     

       2021
        
       		l.Error("failed to fetch labels", "err", err)

     

       2022
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       2023
       +
       			LoggedInUser: user,

     

       2024
       +
       		})

     

       2025
        
       		return

     

       2026
        
       	}

     

       2027
        
       	// remove default labels from the labels list, if present

     
···

       2455
        
       	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       2456
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       2457
        
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       2458
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       2459
       +
       			LoggedInUser: user,

     

       2460
       +
       		})

     

       2461
        
       		return

     

       2462
        
       	}

     

       2463
        
       

     
···

       2494
        
       	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       2495
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       2496
        
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       2497
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       2498
       +
       			LoggedInUser: user,

     

       2499
       +
       		})

     

       2500
        
       		return

     

       2501
        
       	}

     

       2502
        
       

     
···

       2573
        
       	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       2574
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       2575
        
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       2576
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       2577
       +
       			LoggedInUser: user,

     

       2578
       +
       		})

     

       2579
        
       		return

     

       2580
        
       	}

     

       2581
        
       

     
···

       2589
        
       	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       2590
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       2591
        
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       2592
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       2593
       +
       			LoggedInUser: user,

     

       2594
       +
       		})

     

       2595
        
       		return

     

       2596
        
       	}

     

       2597
        
       

     
···

       2605
        
       	compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head)

     

       2606
        
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       2607
        
       		l.Error("failed to call XRPC repo.compare", "err", xrpcerr)

     

       2608
       +
       		rp.pages.Error503(w, pages.ErrorPageParams{

     

       2609
       +
       			LoggedInUser: user,

     

       2610
       +
       		})

     

       2611
        
       		return

     

       2612
        
       	}

     

       2613

+6 -2

appview/state/gfi.go

···

       28
        
       	repoLabels, err := db.GetRepoLabels(s.db, db.FilterEq("label_at", goodFirstIssueLabel))

     

       29
        
       	if err != nil {

     

       30
        
       		log.Println("failed to get repo labels", err)

     

       31
       -
       		s.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       32
        
       		return

     

       33
        
       	}

     

       34
        
       

     
···

       57
        
       	)

     

       58
        
       	if err != nil {

     

       59
        
       		log.Println("failed to get issues", err)

     

       60
       -
       		s.pages.Error503(w)

     

       0
        
       
     

       0
        
       
     

       61
        
       		return

     

       62
        
       	}

     

       63

···

       28
        
       	repoLabels, err := db.GetRepoLabels(s.db, db.FilterEq("label_at", goodFirstIssueLabel))

     

       29
        
       	if err != nil {

     

       30
        
       		log.Println("failed to get repo labels", err)

     

       31
       +
       		s.pages.Error503(w, pages.ErrorPageParams{

     

       32
       +
       			LoggedInUser: user,

     

       33
       +
       		})

     

       34
        
       		return

     

       35
        
       	}

     

       36
        
       

     
···

       59
        
       	)

     

       60
        
       	if err != nil {

     

       61
        
       		log.Println("failed to get issues", err)

     

       62
       +
       		s.pages.Error503(w, pages.ErrorPageParams{

     

       63
       +
       			LoggedInUser: user,

     

       64
       +
       		})

     

       65
        
       		return

     

       66
        
       	}

     

       67