···
···
"tangled.sh/tangled.sh/core/appview/reporesolver"
"tangled.sh/tangled.sh/core/appview/xrpcclient"
"tangled.sh/tangled.sh/core/idresolver"
24
-
"tangled.sh/tangled.sh/core/knotclient"
"tangled.sh/tangled.sh/core/patchutil"
"tangled.sh/tangled.sh/core/tid"
"tangled.sh/tangled.sh/core/types"
···
mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
resubmitResult := pages.Unknown
if user.Did == pull.OwnerDid {
102
-
resubmitResult = s.resubmitCheck(f, pull, stack)
102
+
resubmitResult = s.resubmitCheck(r, f, pull, stack)
s.pages.PullActionsFragment(w, pages.PullActionsParams{
···
mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
resubmitResult := pages.Unknown
if user != nil && user.Did == pull.OwnerDid {
157
-
resubmitResult = s.resubmitCheck(f, pull, stack)
157
+
resubmitResult = s.resubmitCheck(r, f, pull, stack)
repoInfo := f.RepoInfo(user)
···
285
-
func (s *Pulls) resubmitCheck(f *reporesolver.ResolvedRepo, pull *db.Pull, stack db.Stack) pages.ResubmitResult {
285
+
func (s *Pulls) resubmitCheck(r *http.Request, f *reporesolver.ResolvedRepo, pull *db.Pull, stack db.Stack) pages.ResubmitResult {
if pull.State == db.PullMerged || pull.State == db.PullDeleted || pull.PullSource == nil {
···
310
-
us, err := knotclient.NewUnsignedClient(knot, s.config.Core.Dev)
312
-
log.Printf("failed to setup client for %s; ignoring: %v", knot, err)
313
-
return pages.Unknown
311
+
if !s.config.Core.Dev {
314
+
host := fmt.Sprintf("%s://%s", scheme, knot)
315
+
xrpcc := &indigoxrpc.Client{
316
-
result, err := us.Branch(ownerDid, repoName, pull.PullSource.Branch)
319
+
repo := fmt.Sprintf("%s/%s", ownerDid, repoName)
320
+
branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, repo)
322
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
323
+
log.Println("failed to call XRPC repo.branches", xrpcerr)
324
+
return pages.Unknown
log.Println("failed to reach knotserver", err)
330
+
targetBranch := branchResp
latestSourceRev := pull.Submissions[pull.LastRoundNumber()].SourceRev
if pull.IsStacked() && stack != nil {
···
latestSourceRev = top.Submissions[top.LastRoundNumber()].SourceRev
329
-
if latestSourceRev != result.Branch.Hash {
339
+
if latestSourceRev != targetBranch.Hash {
return pages.ShouldResubmit
···
681
-
us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
692
+
if !s.config.Core.Dev {
695
+
host := fmt.Sprintf("%s://%s", scheme, f.Knot)
696
+
xrpcc := &indigoxrpc.Client{
700
+
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
701
+
xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
683
-
log.Printf("failed to create unsigned client for %s", f.Knot)
684
-
s.pages.Error503(w)
703
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
704
+
log.Println("failed to call XRPC repo.branches", xrpcerr)
705
+
s.pages.Error503(w)
708
+
log.Println("failed to fetch branches", err)
688
-
result, err := us.Branches(f.OwnerDid(), f.Name)
690
-
log.Println("failed to fetch branches", err)
712
+
var result types.RepoBranchesResponse
713
+
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
714
+
log.Println("failed to decode XRPC response", err)
715
+
s.pages.Error503(w)
···
755
-
us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
757
-
log.Printf("failed to create unsigned client to %s: %v", f.Knot, err)
758
-
s.pages.Notice(w, "pull", "Failed to create a pull request. Try again later.")
780
+
// us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
782
+
// log.Printf("failed to create unsigned client to %s: %v", f.Knot, err)
783
+
// s.pages.Notice(w, "pull", "Failed to create a pull request. Try again later.")
762
-
caps, err := us.Capabilities()
764
-
log.Println("error fetching knot caps", f.Knot, err)
765
-
s.pages.Notice(w, "pull", "Failed to create a pull request. Try again later.")
787
+
// TODO: make capabilities an xrpc call
789
+
PullRequests struct {
791
+
BranchSubmissions bool
792
+
ForkSubmissions bool
793
+
PatchSubmissions bool
796
+
PullRequests: struct {
798
+
BranchSubmissions bool
799
+
ForkSubmissions bool
800
+
PatchSubmissions bool
803
+
BranchSubmissions: true,
804
+
ForkSubmissions: true,
805
+
PatchSubmissions: true,
809
+
// caps, err := us.Capabilities()
811
+
// log.Println("error fetching knot caps", f.Knot, err)
812
+
// s.pages.Notice(w, "pull", "Failed to create a pull request. Try again later.")
if !caps.PullRequests.FormatPatch {
s.pages.Notice(w, "pull", "This knot doesn't support format-patch. Unfortunately, there is no fallback for now.")
···
809
-
// Generate a patch using /compare
810
-
ksClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
812
-
log.Printf("failed to create signed client for %s: %s", f.Knot, err)
813
-
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
857
+
if !s.config.Core.Dev {
860
+
host := fmt.Sprintf("%s://%s", scheme, f.Knot)
861
+
xrpcc := &indigoxrpc.Client{
817
-
comparison, err := ksClient.Compare(f.OwnerDid(), f.Name, targetBranch, sourceBranch)
865
+
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
866
+
xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, targetBranch, sourceBranch)
868
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
869
+
log.Println("failed to call XRPC repo.compare", xrpcerr)
870
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
log.Println("failed to compare", err)
s.pages.Notice(w, "pull", err.Error())
878
+
var comparison types.RepoFormatPatchResponse
879
+
if err := json.Unmarshal(xrpcBytes, &comparison); err != nil {
880
+
log.Println("failed to decode XRPC compare response", err)
881
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
···
oauth.WithLxm(tangled.RepoHiddenRefNSID),
oauth.WithDev(s.config.Core.Dev),
873
-
log.Printf("failed to connect to knot server: %v", err)
874
-
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
878
-
us, err := knotclient.NewUnsignedClient(fork.Knot, s.config.Core.Dev)
880
-
log.Println("failed to create unsigned client:", err)
881
-
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
resp, err := tangled.RepoHiddenRef(
···
// hiddenRef: hidden/feature-1/main (on repo-fork)
// targetBranch: main (on repo-1)
// sourceBranch: feature-1 (on repo-fork)
914
-
comparison, err := us.Compare(fork.Did, fork.Name, hiddenRef, sourceBranch)
963
+
forkScheme := "http"
964
+
if !s.config.Core.Dev {
965
+
forkScheme = "https"
967
+
forkHost := fmt.Sprintf("%s://%s", forkScheme, fork.Knot)
968
+
forkXrpcc := &indigoxrpc.Client{
972
+
forkRepoId := fmt.Sprintf("%s/%s", fork.Did, fork.Name)
973
+
forkXrpcBytes, err := tangled.RepoCompare(r.Context(), forkXrpcc, forkRepoId, hiddenRef, sourceBranch)
975
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
976
+
log.Println("failed to call XRPC repo.compare for fork", xrpcerr)
977
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
log.Println("failed to compare across branches", err)
s.pages.Notice(w, "pull", err.Error())
985
+
var comparison types.RepoFormatPatchResponse
986
+
if err := json.Unmarshal(forkXrpcBytes, &comparison); err != nil {
987
+
log.Println("failed to decode XRPC compare response for fork", err)
988
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
sourceRev := comparison.Rev2
patch := comparison.Patch
···
1214
-
us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
1286
+
if !s.config.Core.Dev {
1289
+
host := fmt.Sprintf("%s://%s", scheme, f.Knot)
1290
+
xrpcc := &indigoxrpc.Client{
1294
+
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
1295
+
xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
1216
-
log.Printf("failed to create unsigned client for %s", f.Knot)
1217
-
s.pages.Error503(w)
1297
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1298
+
log.Println("failed to call XRPC repo.branches", xrpcerr)
1299
+
s.pages.Error503(w)
1302
+
log.Println("failed to fetch branches", err)
1221
-
result, err := us.Branches(f.OwnerDid(), f.Name)
1223
-
log.Println("failed to reach knotserver", err)
1306
+
var result types.RepoBranchesResponse
1307
+
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
1308
+
log.Println("failed to decode XRPC response", err)
1309
+
s.pages.Error503(w)
···
1287
-
sourceBranchesClient, err := knotclient.NewUnsignedClient(repo.Knot, s.config.Core.Dev)
1373
+
sourceScheme := "http"
1374
+
if !s.config.Core.Dev {
1375
+
sourceScheme = "https"
1377
+
sourceHost := fmt.Sprintf("%s://%s", sourceScheme, repo.Knot)
1378
+
sourceXrpcc := &indigoxrpc.Client{
1382
+
sourceRepo := fmt.Sprintf("%s/%s", forkOwnerDid, repo.Name)
1383
+
sourceXrpcBytes, err := tangled.RepoBranches(r.Context(), sourceXrpcc, "", 0, sourceRepo)
1289
-
log.Printf("failed to create unsigned client for %s", repo.Knot)
1290
-
s.pages.Error503(w)
1385
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1386
+
log.Println("failed to call XRPC repo.branches for source", xrpcerr)
1387
+
s.pages.Error503(w)
1390
+
log.Println("failed to fetch source branches", err)
1294
-
sourceResult, err := sourceBranchesClient.Branches(forkOwnerDid, repo.Name)
1296
-
log.Println("failed to reach knotserver for source branches", err)
1394
+
// Decode source branches
1395
+
var sourceBranches types.RepoBranchesResponse
1396
+
if err := json.Unmarshal(sourceXrpcBytes, &sourceBranches); err != nil {
1397
+
log.Println("failed to decode source branches XRPC response", err)
1398
+
s.pages.Error503(w)
1300
-
targetBranchesClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
1402
+
targetScheme := "http"
1403
+
if !s.config.Core.Dev {
1404
+
targetScheme = "https"
1406
+
targetHost := fmt.Sprintf("%s://%s", targetScheme, f.Knot)
1407
+
targetXrpcc := &indigoxrpc.Client{
1411
+
targetRepo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
1412
+
targetXrpcBytes, err := tangled.RepoBranches(r.Context(), targetXrpcc, "", 0, targetRepo)
1302
-
log.Printf("failed to create unsigned client for target knot %s", f.Knot)
1303
-
s.pages.Error503(w)
1414
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1415
+
log.Println("failed to call XRPC repo.branches for target", xrpcerr)
1416
+
s.pages.Error503(w)
1419
+
log.Println("failed to fetch target branches", err)
1307
-
targetResult, err := targetBranchesClient.Branches(f.OwnerDid(), f.Name)
1309
-
log.Println("failed to reach knotserver for target branches", err)
1423
+
// Decode target branches
1424
+
var targetBranches types.RepoBranchesResponse
1425
+
if err := json.Unmarshal(targetXrpcBytes, &targetBranches); err != nil {
1426
+
log.Println("failed to decode target branches XRPC response", err)
1427
+
s.pages.Error503(w)
1313
-
sourceBranches := sourceResult.Branches
1314
-
sort.Slice(sourceBranches, func(i int, j int) bool {
1315
-
return sourceBranches[i].Commit.Committer.When.After(sourceBranches[j].Commit.Committer.When)
1431
+
sort.Slice(sourceBranches.Branches, func(i int, j int) bool {
1432
+
return sourceBranches.Branches[i].Commit.Committer.When.After(sourceBranches.Branches[j].Commit.Committer.When)
s.pages.PullCompareForkBranchesFragment(w, pages.PullCompareForkBranchesParams{
RepoInfo: f.RepoInfo(user),
1320
-
SourceBranches: sourceBranches,
1321
-
TargetBranches: targetResult.Branches,
1437
+
SourceBranches: sourceBranches.Branches,
1438
+
TargetBranches: targetBranches.Branches,
···
1416
-
ksClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
1418
-
log.Printf("failed to create client for %s: %s", f.Knot, err)
1419
-
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1534
+
if !s.config.Core.Dev {
1537
+
host := fmt.Sprintf("%s://%s", scheme, f.Knot)
1538
+
xrpcc := &indigoxrpc.Client{
1423
-
comparison, err := ksClient.Compare(f.OwnerDid(), f.Name, pull.TargetBranch, pull.PullSource.Branch)
1542
+
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
1543
+
xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, pull.TargetBranch, pull.PullSource.Branch)
1545
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1546
+
log.Println("failed to call XRPC repo.compare", xrpcerr)
1547
+
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
log.Printf("compare request failed: %s", err)
s.pages.Notice(w, "resubmit-error", err.Error())
1555
+
var comparison types.RepoFormatPatchResponse
1556
+
if err := json.Unmarshal(xrpcBytes, &comparison); err != nil {
1557
+
log.Println("failed to decode XRPC compare response", err)
1558
+
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
···
// extract patch by performing compare
1466
-
ksClient, err := knotclient.NewUnsignedClient(forkRepo.Knot, s.config.Core.Dev)
1598
+
forkScheme := "http"
1599
+
if !s.config.Core.Dev {
1600
+
forkScheme = "https"
1602
+
forkHost := fmt.Sprintf("%s://%s", forkScheme, forkRepo.Knot)
1603
+
forkRepoId := fmt.Sprintf("%s/%s", forkRepo.Did, forkRepo.Name)
1604
+
forkXrpcBytes, err := tangled.RepoCompare(r.Context(), &indigoxrpc.Client{Host: forkHost}, forkRepoId, pull.TargetBranch, pull.PullSource.Branch)
1468
-
log.Printf("failed to create client for %s: %s", forkRepo.Knot, err)
1606
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1607
+
log.Println("failed to call XRPC repo.compare for fork", xrpcerr)
1608
+
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1611
+
log.Printf("failed to compare branches: %s", err)
1612
+
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1616
+
var forkComparison types.RepoFormatPatchResponse
1617
+
if err := json.Unmarshal(forkXrpcBytes, &forkComparison); err != nil {
1618
+
log.Println("failed to decode XRPC compare response for fork", err)
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
···
1504
-
hiddenRef := fmt.Sprintf("hidden/%s/%s", pull.PullSource.Branch, pull.TargetBranch)
1505
-
comparison, err := ksClient.Compare(forkRepo.Did, forkRepo.Name, hiddenRef, pull.PullSource.Branch)
1507
-
log.Printf("failed to compare branches: %s", err)
1508
-
s.pages.Notice(w, "resubmit-error", err.Error())
1654
+
// Use the fork comparison we already made
1655
+
comparison := forkComparison
sourceRev := comparison.Rev2
patch := comparison.Patch
veryroundbird.house
anirudh.fi