Monorepo for Tangled
pulls: replace log.Println/Printf with structured slog
Signed-off-by: Matías Insaurralde <matias@insaurral.de>
authored by
Matías Insaurralde
and committed by
tangled.org
(Mar 30, 2026, 4:23 AM UTC)
53a5d190
6631f27b
+129
-130
+129
-130
appview/pulls/pulls.go
+129
-130
appview/pulls/pulls.go
···
9
9
"errors"
10
10
"fmt"
11
11
"io"
12
-
"log"
13
12
"log/slog"
14
13
"net/http"
15
14
"slices"
···
107
106
user := s.oauth.GetMultiAccountUser(r)
108
107
f, err := s.repoResolver.Resolve(r)
109
108
if err != nil {
110
-
log.Println("failed to get repo and knot", err)
109
+
s.logger.Error("failed to get repo and knot", "err", err)
111
110
return
112
111
}
113
112
114
113
pull, ok := r.Context().Value("pull").(*models.Pull)
115
114
if !ok {
116
-
log.Println("failed to get pull")
115
+
s.logger.Error("failed to get pull")
117
116
s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
118
117
return
119
118
}
···
128
127
}
129
128
if roundNumber >= len(pull.Submissions) {
130
129
http.Error(w, "bad round id", http.StatusBadRequest)
131
-
log.Println("failed to parse round id", err)
130
+
s.logger.Error("failed to parse round id", "err", err)
132
131
return
133
132
}
134
133
···
157
156
user := s.oauth.GetMultiAccountUser(r)
158
157
f, err := s.repoResolver.Resolve(r)
159
158
if err != nil {
160
-
log.Println("failed to get repo and knot", err)
159
+
s.logger.Error("failed to get repo and knot", "err", err)
161
160
return
162
161
}
163
162
164
163
pull, ok := r.Context().Value("pull").(*models.Pull)
165
164
if !ok {
166
-
log.Println("failed to get pull")
165
+
s.logger.Error("failed to get pull")
167
166
s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
168
167
return
169
168
}
170
169
171
170
backlinks, err := db.GetBacklinks(s.db, pull.AtUri())
172
171
if err != nil {
173
-
log.Println("failed to get pull backlinks", err)
172
+
s.logger.Error("failed to get pull backlinks", "err", err)
174
173
s.pages.Notice(w, "pull-error", "Failed to get pull. Try again later.")
175
174
return
176
175
}
···
182
181
}
183
182
if roundIdInt >= len(pull.Submissions) {
184
183
http.Error(w, "bad round id", http.StatusBadRequest)
185
-
log.Println("failed to parse round id", err)
184
+
s.logger.Error("failed to parse round id", "err", err)
186
185
return
187
186
}
188
187
···
224
223
orm.FilterIn("p.sha", shas),
225
224
)
226
225
if err != nil {
227
-
log.Printf("failed to fetch pipeline statuses: %s", err)
226
+
s.logger.Error("failed to fetch pipeline statuses", "err", err)
228
227
// non-fatal
229
228
}
230
229
···
234
233
235
234
reactionMap, err := db.GetReactionMap(s.db, 20, pull.AtUri())
236
235
if err != nil {
237
-
log.Println("failed to get pull reactions")
236
+
s.logger.Error("failed to get pull reactions", "err", err)
238
237
}
239
238
240
239
userReactions := map[models.ReactionKind]bool{}
···
248
247
orm.FilterContains("scope", tangled.RepoPullNSID),
249
248
)
250
249
if err != nil {
251
-
log.Println("failed to fetch labels", err)
250
+
s.logger.Error("failed to fetch labels", "err", err)
252
251
s.pages.Error503(w)
253
252
return
254
253
}
···
265
264
if interdiff {
266
265
currentPatch, err := patchutil.AsDiff(pull.Submissions[roundIdInt].CombinedPatch())
267
266
if err != nil {
268
-
log.Println("failed to interdiff; current patch malformed")
267
+
s.logger.Error("failed to interdiff; current patch malformed", "err", err)
269
268
s.pages.Notice(w, fmt.Sprintf("interdiff-error-%d", roundIdInt), "Failed to calculate interdiff; current patch is invalid.")
270
269
return
271
270
}
272
271
273
272
previousPatch, err := patchutil.AsDiff(pull.Submissions[roundIdInt-1].CombinedPatch())
274
273
if err != nil {
275
-
log.Println("failed to interdiff; previous patch malformed")
274
+
s.logger.Error("failed to interdiff; previous patch malformed", "err", err)
276
275
s.pages.Notice(w, fmt.Sprintf("interdiff-error-%d", roundIdInt), "Failed to calculate interdiff; previous patch is invalid.")
277
276
return
278
277
}
···
306
305
func (s *Pulls) RepoSinglePull(w http.ResponseWriter, r *http.Request) {
307
306
pull, ok := r.Context().Value("pull").(*models.Pull)
308
307
if !ok {
309
-
log.Println("failed to get pull")
308
+
s.logger.Error("failed to get pull")
310
309
s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
311
310
return
312
311
}
···
350
349
},
351
350
)
352
351
if err := xrpcclient.HandleXrpcErr(xe); err != nil {
353
-
log.Println("failed to check for mergeability", "err", err)
352
+
s.logger.Error("failed to check for mergeability", "err", err)
354
353
return types.MergeCheckResponse{
355
354
Error: fmt.Sprintf("failed to check merge status: %s", err.Error()),
356
355
}
···
444
443
branchResp, err := tangled.GitTempGetBranch(r.Context(), xrpcc, pull.PullSource.Branch, sourceRepo.String())
445
444
if err != nil {
446
445
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
447
-
log.Println("failed to call XRPC repo.branches", xrpcerr)
446
+
s.logger.Error("failed to call XRPC repo.branches", "err", xrpcerr)
448
447
return pages.Unknown
449
448
}
450
-
log.Println("failed to reach knotserver", err)
449
+
s.logger.Error("failed to reach knotserver", "err", err)
451
450
return pages.Unknown
452
451
}
453
452
···
478
477
func (s *Pulls) RepoPullPatchRaw(w http.ResponseWriter, r *http.Request) {
479
478
pull, ok := r.Context().Value("pull").(*models.Pull)
480
479
if !ok {
481
-
log.Println("failed to get pull")
480
+
s.logger.Error("failed to get pull")
482
481
s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
483
482
return
484
483
}
···
487
486
roundIdInt, err := strconv.Atoi(roundId)
488
487
if err != nil || roundIdInt >= len(pull.Submissions) {
489
488
http.Error(w, "bad round id", http.StatusBadRequest)
490
-
log.Println("failed to parse round id", err)
489
+
s.logger.Error("failed to parse round id", "err", err)
491
490
return
492
491
}
493
492
···
504
503
505
504
f, err := s.repoResolver.Resolve(r)
506
505
if err != nil {
507
-
log.Println("failed to get repo and knot", err)
506
+
s.logger.Error("failed to get repo and knot", "err", err)
508
507
return
509
508
}
510
509
···
673
672
if p.PullSource.RepoAt != nil {
674
673
pullSourceRepo, err = db.GetRepoByAtUri(s.db, p.PullSource.RepoAt.String())
675
674
if err != nil {
676
-
log.Printf("failed to get repo by at uri: %v", err)
675
+
s.logger.Error("failed to get repo by at uri", "err", err)
677
676
continue
678
677
} else {
679
678
p.PullSource.Repo = pullSourceRepo
···
716
715
orm.FilterIn("p.sha", shas),
717
716
)
718
717
if err != nil {
719
-
log.Printf("failed to fetch pipeline statuses: %s", err)
718
+
s.logger.Error("failed to fetch pipeline statuses", "err", err)
720
719
// non-fatal
721
720
}
722
721
m := make(map[string]models.Pipeline)
···
763
762
user := s.oauth.GetMultiAccountUser(r)
764
763
f, err := s.repoResolver.Resolve(r)
765
764
if err != nil {
766
-
log.Println("failed to get repo and knot", err)
765
+
s.logger.Error("failed to get repo and knot", "err", err)
767
766
return
768
767
}
769
768
770
769
pull, ok := r.Context().Value("pull").(*models.Pull)
771
770
if !ok {
772
-
log.Println("failed to get pull")
771
+
s.logger.Error("failed to get pull")
773
772
s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
774
773
return
775
774
}
···
778
777
roundNumber, err := strconv.Atoi(roundNumberStr)
779
778
if err != nil || roundNumber >= len(pull.Submissions) {
780
779
http.Error(w, "bad round id", http.StatusBadRequest)
781
-
log.Println("failed to parse round id", err)
780
+
s.logger.Error("failed to parse round id", "err", err)
782
781
return
783
782
}
784
783
···
803
802
// Start a transaction
804
803
tx, err := s.db.BeginTx(r.Context(), nil)
805
804
if err != nil {
806
-
log.Println("failed to start transaction", err)
805
+
s.logger.Error("failed to start transaction", "err", err)
807
806
s.pages.Notice(w, "pull-comment", "Failed to create comment.")
808
807
return
809
808
}
···
813
812
814
813
client, err := s.oauth.AuthorizedClient(r)
815
814
if err != nil {
816
-
log.Println("failed to get authorized client", err)
815
+
s.logger.Error("failed to get authorized client", "err", err)
817
816
s.pages.Notice(w, "pull-comment", "Failed to create comment.")
818
817
return
819
818
}
···
830
829
},
831
830
})
832
831
if err != nil {
833
-
log.Println("failed to create pull comment", err)
832
+
s.logger.Error("failed to create pull comment", "err", err)
834
833
s.pages.Notice(w, "pull-comment", "Failed to create comment.")
835
834
return
836
835
}
···
849
848
// Create the pull comment in the database with the commentAt field
850
849
commentId, err := db.NewPullComment(tx, comment)
851
850
if err != nil {
852
-
log.Println("failed to create pull comment", err)
851
+
s.logger.Error("failed to create pull comment", "err", err)
853
852
s.pages.Notice(w, "pull-comment", "Failed to create comment.")
854
853
return
855
854
}
856
855
857
856
// Commit the transaction
858
857
if err = tx.Commit(); err != nil {
859
-
log.Println("failed to commit transaction", err)
858
+
s.logger.Error("failed to commit transaction", "err", err)
860
859
s.pages.Notice(w, "pull-comment", "Failed to create comment.")
861
860
return
862
861
}
···
873
872
user := s.oauth.GetMultiAccountUser(r)
874
873
f, err := s.repoResolver.Resolve(r)
875
874
if err != nil {
876
-
log.Println("failed to get repo and knot", err)
875
+
s.logger.Error("failed to get repo and knot", "err", err)
877
876
return
878
877
}
879
878
···
884
883
xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
885
884
if err != nil {
886
885
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
887
-
log.Println("failed to call XRPC repo.branches", xrpcerr)
886
+
s.logger.Error("failed to call XRPC repo.branches", "err", xrpcerr)
888
887
s.pages.Error503(w)
889
888
return
890
889
}
891
-
log.Println("failed to fetch branches", err)
890
+
s.logger.Error("failed to fetch branches", "err", err)
892
891
return
893
892
}
894
893
895
894
var result types.RepoBranchesResponse
896
895
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
897
-
log.Println("failed to decode XRPC response", err)
896
+
s.logger.Error("failed to decode XRPC response", "err", err)
898
897
s.pages.Error503(w)
899
898
return
900
899
}
···
1050
1049
xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, didSlashRepo, targetBranch, sourceBranch)
1051
1050
if err != nil {
1052
1051
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1053
-
log.Println("failed to call XRPC repo.compare", xrpcerr)
1052
+
s.logger.Error("failed to call XRPC repo.compare", "err", xrpcerr)
1054
1053
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1055
1054
return
1056
1055
}
1057
-
log.Println("failed to compare", err)
1056
+
s.logger.Error("failed to compare", "err", err)
1058
1057
s.pages.Notice(w, "pull", err.Error())
1059
1058
return
1060
1059
}
1061
1060
1062
1061
var comparison types.RepoFormatPatchResponse
1063
1062
if err := json.Unmarshal(xrpcBytes, &comparison); err != nil {
1064
-
log.Println("failed to decode XRPC compare response", err)
1063
+
s.logger.Error("failed to decode XRPC compare response", "err", err)
1065
1064
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1066
1065
return
1067
1066
}
···
1106
1105
s.pages.Notice(w, "pull", "No such fork.")
1107
1106
return
1108
1107
} else if err != nil {
1109
-
log.Println("failed to fetch fork:", err)
1108
+
s.logger.Error("failed to fetch fork:", "err", err)
1110
1109
s.pages.Notice(w, "pull", "Failed to fetch fork.")
1111
1110
return
1112
1111
}
···
1160
1159
forkXrpcBytes, err := tangled.RepoCompare(r.Context(), forkXrpcc, forkRepoId, hiddenRef, sourceBranch)
1161
1160
if err != nil {
1162
1161
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1163
-
log.Println("failed to call XRPC repo.compare for fork", xrpcerr)
1162
+
s.logger.Error("failed to call XRPC repo.compare for fork", "err", xrpcerr)
1164
1163
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1165
1164
return
1166
1165
}
1167
-
log.Println("failed to compare across branches", err)
1166
+
s.logger.Error("failed to compare across branches", "err", err)
1168
1167
s.pages.Notice(w, "pull", err.Error())
1169
1168
return
1170
1169
}
1171
1170
1172
1171
var comparison types.RepoFormatPatchResponse
1173
1172
if err := json.Unmarshal(forkXrpcBytes, &comparison); err != nil {
1174
-
log.Println("failed to decode XRPC compare response for fork", err)
1173
+
s.logger.Error("failed to decode XRPC compare response for fork", "err", err)
1175
1174
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1176
1175
return
1177
1176
}
···
1232
1231
1233
1232
client, err := s.oauth.AuthorizedClient(r)
1234
1233
if err != nil {
1235
-
log.Println("failed to get authorized client", err)
1234
+
s.logger.Error("failed to get authorized client", "err", err)
1236
1235
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1237
1236
return
1238
1237
}
1239
1238
1240
1239
tx, err := s.db.BeginTx(r.Context(), nil)
1241
1240
if err != nil {
1242
-
log.Println("failed to start tx")
1241
+
s.logger.Error("failed to start tx", "err", err)
1243
1242
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1244
1243
return
1245
1244
}
···
1290
1289
}
1291
1290
err = db.NewPull(tx, pull)
1292
1291
if err != nil {
1293
-
log.Println("failed to create pull request", err)
1292
+
s.logger.Error("failed to create pull request", "err", err)
1294
1293
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1295
1294
return
1296
1295
}
1297
1296
pullId, err := db.NextPullId(tx, repo.RepoAt())
1298
1297
if err != nil {
1299
-
log.Println("failed to get pull id", err)
1298
+
s.logger.Error("failed to get pull id", "err", err)
1300
1299
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1301
1300
return
1302
1301
}
1303
1302
1304
1303
blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(patch), ApplicationGzip)
1305
1304
if err != nil {
1306
-
log.Println("failed to upload patch", err)
1305
+
s.logger.Error("failed to upload patch", "err", err)
1307
1306
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1308
1307
return
1309
1308
}
···
1326
1325
},
1327
1326
})
1328
1327
if err != nil {
1329
-
log.Println("failed to create pull request", err)
1328
+
s.logger.Error("failed to create pull request", "err", err)
1330
1329
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1331
1330
return
1332
1331
}
1333
1332
1334
1333
if err = tx.Commit(); err != nil {
1335
-
log.Println("failed to create pull request", err)
1334
+
s.logger.Error("failed to create pull request", "err", err)
1336
1335
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1337
1336
return
1338
1337
}
···
1357
1356
1358
1357
// must be branch or fork based
1359
1358
if sourceRev == "" {
1360
-
log.Println("stacked PR from patch-based pull")
1359
+
s.logger.Warn("stacked PR from patch-based pull")
1361
1360
s.pages.Notice(w, "pull", "Stacking is only supported on branch and fork based pull-requests.")
1362
1361
return
1363
1362
}
1364
1363
1365
1364
formatPatches, err := patchutil.ExtractPatches(patch)
1366
1365
if err != nil {
1367
-
log.Println("failed to extract patches", err)
1366
+
s.logger.Error("failed to extract patches", "err", err)
1368
1367
s.pages.Notice(w, "pull", fmt.Sprintf("Failed to extract patches: %v", err))
1369
1368
return
1370
1369
}
1371
1370
1372
1371
// must have atleast 1 patch to begin with
1373
1372
if len(formatPatches) == 0 {
1374
-
log.Println("empty patches")
1373
+
s.logger.Error("empty patches")
1375
1374
s.pages.Notice(w, "pull", "No patches found in the generated format-patch.")
1376
1375
return
1377
1376
}
···
1380
1379
stackId := uuid.New()
1381
1380
stack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pullSource, stackId.String())
1382
1381
if err != nil {
1383
-
log.Println("failed to create stack", err)
1382
+
s.logger.Error("failed to create stack", "err", err)
1384
1383
s.pages.Notice(w, "pull", fmt.Sprintf("Failed to create stack: %v", err))
1385
1384
return
1386
1385
}
1387
1386
1388
1387
client, err := s.oauth.AuthorizedClient(r)
1389
1388
if err != nil {
1390
-
log.Println("failed to get authorized client", err)
1389
+
s.logger.Error("failed to get authorized client", "err", err)
1391
1390
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1392
1391
return
1393
1392
}
···
1397
1396
for _, p := range stack {
1398
1397
blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(p.LatestPatch()), ApplicationGzip)
1399
1398
if err != nil {
1400
-
log.Println("failed to upload patch blob", err)
1399
+
s.logger.Error("failed to upload patch blob", "err", err)
1401
1400
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1402
1401
return
1403
1402
}
···
1419
1418
Writes: writes,
1420
1419
})
1421
1420
if err != nil {
1422
-
log.Println("failed to create stacked pull request", err)
1421
+
s.logger.Error("failed to create stacked pull request", "err", err)
1423
1422
s.pages.Notice(w, "pull", "Failed to create stacked pull request. Try again later.")
1424
1423
return
1425
1424
}
···
1427
1426
// create all pulls at once
1428
1427
tx, err := s.db.BeginTx(r.Context(), nil)
1429
1428
if err != nil {
1430
-
log.Println("failed to start tx")
1429
+
s.logger.Error("failed to start tx", "err", err)
1431
1430
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1432
1431
return
1433
1432
}
···
1436
1435
for _, p := range stack {
1437
1436
err = db.NewPull(tx, p)
1438
1437
if err != nil {
1439
-
log.Println("failed to create pull request", err)
1438
+
s.logger.Error("failed to create pull request", "err", err)
1440
1439
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1441
1440
return
1442
1441
}
···
1444
1443
}
1445
1444
1446
1445
if err = tx.Commit(); err != nil {
1447
-
log.Println("failed to create pull request", err)
1446
+
s.logger.Error("failed to create pull request", "err", err)
1448
1447
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1449
1448
return
1450
1449
}
···
1463
1462
func (s *Pulls) ValidatePatch(w http.ResponseWriter, r *http.Request) {
1464
1463
_, err := s.repoResolver.Resolve(r)
1465
1464
if err != nil {
1466
-
log.Println("failed to get repo and knot", err)
1465
+
s.logger.Error("failed to get repo and knot", "err", err)
1467
1466
return
1468
1467
}
1469
1468
···
1498
1497
user := s.oauth.GetMultiAccountUser(r)
1499
1498
f, err := s.repoResolver.Resolve(r)
1500
1499
if err != nil {
1501
-
log.Println("failed to get repo and knot", err)
1500
+
s.logger.Error("failed to get repo and knot", "err", err)
1502
1501
return
1503
1502
}
1504
1503
···
1506
1505
1507
1506
xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
1508
1507
if err != nil {
1509
-
log.Println("failed to fetch branches", err)
1508
+
s.logger.Error("failed to fetch branches", "err", err)
1510
1509
s.pages.Error503(w)
1511
1510
return
1512
1511
}
1513
1512
1514
1513
var result types.RepoBranchesResponse
1515
1514
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
1516
-
log.Println("failed to decode XRPC response", err)
1515
+
s.logger.Error("failed to decode XRPC response", "err", err)
1517
1516
s.pages.Error503(w)
1518
1517
return
1519
1518
}
···
1542
1541
1543
1542
forks, err := db.GetForksByDid(s.db, user.Active.Did)
1544
1543
if err != nil {
1545
-
log.Println("failed to get forks", err)
1544
+
s.logger.Error("failed to get forks", "err", err)
1546
1545
return
1547
1546
}
1548
1547
···
1558
1557
1559
1558
f, err := s.repoResolver.Resolve(r)
1560
1559
if err != nil {
1561
-
log.Println("failed to get repo and knot", err)
1560
+
s.logger.Error("failed to get repo and knot", "err", err)
1562
1561
return
1563
1562
}
1564
1563
···
1575
1574
orm.FilterEq("name", forkName),
1576
1575
)
1577
1576
if err != nil {
1578
-
log.Println("failed to get repo", "did", forkOwnerDid, "name", forkName, "err", err)
1577
+
s.logger.Error("failed to get repo", "did", forkOwnerDid, "name", forkName, "err", err)
1579
1578
return
1580
1579
}
1581
1580
1582
1581
sourceXrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, repo.RepoAt().String())
1583
1582
if err != nil {
1584
1583
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1585
-
log.Println("failed to call XRPC repo.branches for source", xrpcerr)
1584
+
s.logger.Error("failed to call XRPC repo.branches for source", "err", xrpcerr)
1586
1585
s.pages.Error503(w)
1587
1586
return
1588
1587
}
1589
-
log.Println("failed to fetch source branches", err)
1588
+
s.logger.Error("failed to fetch source branches", "err", err)
1590
1589
return
1591
1590
}
1592
1591
1593
1592
// Decode source branches
1594
1593
var sourceBranches types.RepoBranchesResponse
1595
1594
if err := json.Unmarshal(sourceXrpcBytes, &sourceBranches); err != nil {
1596
-
log.Println("failed to decode source branches XRPC response", err)
1595
+
s.logger.Error("failed to decode source branches XRPC response", "err", err)
1597
1596
s.pages.Error503(w)
1598
1597
return
1599
1598
}
···
1601
1600
targetXrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
1602
1601
if err != nil {
1603
1602
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1604
-
log.Println("failed to call XRPC repo.branches for target", xrpcerr)
1603
+
s.logger.Error("failed to call XRPC repo.branches for target", "err", xrpcerr)
1605
1604
s.pages.Error503(w)
1606
1605
return
1607
1606
}
1608
-
log.Println("failed to fetch target branches", err)
1607
+
s.logger.Error("failed to fetch target branches", "err", err)
1609
1608
return
1610
1609
}
1611
1610
1612
1611
// Decode target branches
1613
1612
var targetBranches types.RepoBranchesResponse
1614
1613
if err := json.Unmarshal(targetXrpcBytes, &targetBranches); err != nil {
1615
-
log.Println("failed to decode target branches XRPC response", err)
1614
+
s.logger.Error("failed to decode target branches XRPC response", "err", err)
1616
1615
s.pages.Error503(w)
1617
1616
return
1618
1617
}
···
1633
1632
1634
1633
pull, ok := r.Context().Value("pull").(*models.Pull)
1635
1634
if !ok {
1636
-
log.Println("failed to get pull")
1635
+
s.logger.Error("failed to get pull")
1637
1636
s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
1638
1637
return
1639
1638
}
···
1664
1663
1665
1664
pull, ok := r.Context().Value("pull").(*models.Pull)
1666
1665
if !ok {
1667
-
log.Println("failed to get pull")
1666
+
s.logger.Error("failed to get pull")
1668
1667
s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
1669
1668
return
1670
1669
}
1671
1670
1672
1671
f, err := s.repoResolver.Resolve(r)
1673
1672
if err != nil {
1674
-
log.Println("failed to get repo and knot", err)
1673
+
s.logger.Error("failed to get repo and knot", "err", err)
1675
1674
return
1676
1675
}
1677
1676
1678
1677
if user.Active.Did != pull.OwnerDid {
1679
-
log.Println("unauthorized user")
1678
+
s.logger.Warn("unauthorized user")
1680
1679
w.WriteHeader(http.StatusUnauthorized)
1681
1680
return
1682
1681
}
···
1691
1690
1692
1691
pull, ok := r.Context().Value("pull").(*models.Pull)
1693
1692
if !ok {
1694
-
log.Println("failed to get pull")
1693
+
s.logger.Error("failed to get pull")
1695
1694
s.pages.Notice(w, "resubmit-error", "Failed to edit patch. Try again later.")
1696
1695
return
1697
1696
}
1698
1697
1699
1698
f, err := s.repoResolver.Resolve(r)
1700
1699
if err != nil {
1701
-
log.Println("failed to get repo and knot", err)
1700
+
s.logger.Error("failed to get repo and knot", "err", err)
1702
1701
return
1703
1702
}
1704
1703
1705
1704
if user.Active.Did != pull.OwnerDid {
1706
-
log.Println("unauthorized user")
1705
+
s.logger.Warn("unauthorized user")
1707
1706
w.WriteHeader(http.StatusUnauthorized)
1708
1707
return
1709
1708
}
1710
1709
1711
1710
roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())}
1712
1711
if !roles.IsPushAllowed() {
1713
-
log.Println("unauthorized user")
1712
+
s.logger.Warn("unauthorized user")
1714
1713
w.WriteHeader(http.StatusUnauthorized)
1715
1714
return
1716
1715
}
···
1728
1727
xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, pull.TargetBranch, pull.PullSource.Branch)
1729
1728
if err != nil {
1730
1729
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1731
-
log.Println("failed to call XRPC repo.compare", xrpcerr)
1730
+
s.logger.Error("failed to call XRPC repo.compare", "err", xrpcerr)
1732
1731
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1733
1732
return
1734
1733
}
1735
-
log.Printf("compare request failed: %s", err)
1734
+
s.logger.Error("compare request failed", "err", err)
1736
1735
s.pages.Notice(w, "resubmit-error", err.Error())
1737
1736
return
1738
1737
}
1739
1738
1740
1739
var comparison types.RepoFormatPatchResponse
1741
1740
if err := json.Unmarshal(xrpcBytes, &comparison); err != nil {
1742
-
log.Println("failed to decode XRPC compare response", err)
1741
+
s.logger.Error("failed to decode XRPC compare response", "err", err)
1743
1742
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1744
1743
return
1745
1744
}
···
1756
1755
1757
1756
pull, ok := r.Context().Value("pull").(*models.Pull)
1758
1757
if !ok {
1759
-
log.Println("failed to get pull")
1758
+
s.logger.Error("failed to get pull")
1760
1759
s.pages.Notice(w, "resubmit-error", "Failed to edit patch. Try again later.")
1761
1760
return
1762
1761
}
1763
1762
1764
1763
f, err := s.repoResolver.Resolve(r)
1765
1764
if err != nil {
1766
-
log.Println("failed to get repo and knot", err)
1765
+
s.logger.Error("failed to get repo and knot", "err", err)
1767
1766
return
1768
1767
}
1769
1768
1770
1769
if user.Active.Did != pull.OwnerDid {
1771
-
log.Println("unauthorized user")
1770
+
s.logger.Warn("unauthorized user")
1772
1771
w.WriteHeader(http.StatusUnauthorized)
1773
1772
return
1774
1773
}
1775
1774
1776
1775
forkRepo, err := db.GetRepoByAtUri(s.db, pull.PullSource.RepoAt.String())
1777
1776
if err != nil {
1778
-
log.Println("failed to get source repo", err)
1777
+
s.logger.Error("failed to get source repo", "err", err)
1779
1778
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1780
1779
return
1781
1780
}
···
1788
1787
oauth.WithDev(s.config.Core.Dev),
1789
1788
)
1790
1789
if err != nil {
1791
-
log.Printf("failed to connect to knot server: %v", err)
1790
+
s.logger.Error("failed to connect to knot server", "err", err)
1792
1791
return
1793
1792
}
1794
1793
···
1806
1805
return
1807
1806
}
1808
1807
if !resp.Success {
1809
-
log.Println("Failed to update tracking ref.", "err", resp.Error)
1808
+
s.logger.Warn("failed to update tracking ref", "err", resp.Error)
1810
1809
s.pages.Notice(w, "resubmit-error", "Failed to update tracking ref.")
1811
1810
return
1812
1811
}
···
1822
1821
forkXrpcBytes, err := tangled.RepoCompare(r.Context(), &indigoxrpc.Client{Host: forkHost}, forkRepoId, hiddenRef, pull.PullSource.Branch)
1823
1822
if err != nil {
1824
1823
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1825
-
log.Println("failed to call XRPC repo.compare for fork", xrpcerr)
1824
+
s.logger.Error("failed to call XRPC repo.compare for fork", "err", xrpcerr)
1826
1825
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1827
1826
return
1828
1827
}
1829
-
log.Printf("failed to compare branches: %s", err)
1828
+
s.logger.Error("failed to compare branches", "err", err)
1830
1829
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1831
1830
return
1832
1831
}
1833
1832
1834
1833
var forkComparison types.RepoFormatPatchResponse
1835
1834
if err := json.Unmarshal(forkXrpcBytes, &forkComparison); err != nil {
1836
-
log.Println("failed to decode XRPC compare response for fork", err)
1835
+
s.logger.Error("failed to decode XRPC compare response for fork", "err", err)
1837
1836
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1838
1837
return
1839
1838
}
···
1859
1858
sourceRev string,
1860
1859
) {
1861
1860
if pull.IsStacked() {
1862
-
log.Println("resubmitting stacked PR")
1861
+
s.logger.Info("resubmitting stacked PR")
1863
1862
s.resubmitStackedPullHelper(w, r, repo, user, pull, patch, pull.StackId)
1864
1863
return
1865
1864
}
···
1884
1883
1885
1884
tx, err := s.db.BeginTx(r.Context(), nil)
1886
1885
if err != nil {
1887
-
log.Println("failed to start tx")
1886
+
s.logger.Error("failed to start tx", "err", err)
1888
1887
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1889
1888
return
1890
1889
}
···
1897
1896
combinedPatch := combined
1898
1897
err = db.ResubmitPull(tx, pullAt, newRoundNumber, newPatch, combinedPatch, newSourceRev)
1899
1898
if err != nil {
1900
-
log.Println("failed to create pull request", err)
1899
+
s.logger.Error("failed to create pull request", "err", err)
1901
1900
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1902
1901
return
1903
1902
}
1904
1903
client, err := s.oauth.AuthorizedClient(r)
1905
1904
if err != nil {
1906
-
log.Println("failed to authorize client")
1905
+
s.logger.Error("failed to authorize client", "err", err)
1907
1906
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1908
1907
return
1909
1908
}
···
1917
1916
1918
1917
blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(patch), ApplicationGzip)
1919
1918
if err != nil {
1920
-
log.Println("failed to upload patch blob", err)
1919
+
s.logger.Error("failed to upload patch blob", "err", err)
1921
1920
s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
1922
1921
return
1923
1922
}
···
1939
1938
},
1940
1939
})
1941
1940
if err != nil {
1942
-
log.Println("failed to update record", err)
1941
+
s.logger.Error("failed to update record", "err", err)
1943
1942
s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
1944
1943
return
1945
1944
}
1946
1945
1947
1946
if err = tx.Commit(); err != nil {
1948
-
log.Println("failed to commit transaction", err)
1947
+
s.logger.Error("failed to commit transaction", "err", err)
1949
1948
s.pages.Notice(w, "resubmit-error", "Failed to resubmit pull.")
1950
1949
return
1951
1950
}
···
1968
1967
origStack, _ := r.Context().Value("stack").(models.Stack)
1969
1968
newStack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pull.PullSource, stackId)
1970
1969
if err != nil {
1971
-
log.Println("failed to create resubmitted stack", err)
1970
+
s.logger.Error("failed to create resubmitted stack", "err", err)
1972
1971
s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
1973
1972
return
1974
1973
}
···
2015
2014
2016
2015
tx, err := s.db.Begin()
2017
2016
if err != nil {
2018
-
log.Println("failed to start transaction", err)
2017
+
s.logger.Error("failed to start transaction", "err", err)
2019
2018
s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
2020
2019
return
2021
2020
}
···
2023
2022
2024
2023
client, err := s.oauth.AuthorizedClient(r)
2025
2024
if err != nil {
2026
-
log.Println("failed to authorize client")
2025
+
s.logger.Error("failed to authorize client", "err", err)
2027
2026
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
2028
2027
return
2029
2028
}
···
2040
2039
2041
2040
err := db.DeletePull(tx, p.RepoAt, p.PullId)
2042
2041
if err != nil {
2043
-
log.Println("failed to delete pull", err, p.PullId)
2042
+
s.logger.Error("failed to delete pull", "err", err, "pull_id", p.PullId)
2044
2043
s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
2045
2044
return
2046
2045
}
···
2056
2055
for _, p := range additions {
2057
2056
err := db.NewPull(tx, p)
2058
2057
if err != nil {
2059
-
log.Println("failed to create pull", err, p.PullId)
2058
+
s.logger.Error("failed to create pull", "err", err, "pull_id", p.PullId)
2060
2059
s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
2061
2060
return
2062
2061
}
2063
2062
2064
2063
blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(patch), ApplicationGzip)
2065
2064
if err != nil {
2066
-
log.Println("failed to upload patch blob", err)
2065
+
s.logger.Error("failed to upload patch blob", "err", err)
2067
2066
s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
2068
2067
return
2069
2068
}
···
2098
2097
newSourceRev := np.LatestSha()
2099
2098
err := db.ResubmitPull(tx, pullAt, newRoundNumber, newPatch, combinedPatch, newSourceRev)
2100
2099
if err != nil {
2101
-
log.Println("failed to update pull", err, op.PullId)
2100
+
s.logger.Error("failed to update pull", "err", err, "pull_id", op.PullId)
2102
2101
s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
2103
2102
return
2104
2103
}
2105
2104
2106
2105
blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(patch), ApplicationGzip)
2107
2106
if err != nil {
2108
-
log.Println("failed to upload patch blob", err)
2107
+
s.logger.Error("failed to upload patch blob", "err", err)
2109
2108
s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
2110
2109
return
2111
2110
}
···
2134
2133
)
2135
2134
2136
2135
if err != nil {
2137
-
log.Println("failed to update pull", err, p.PullId)
2136
+
s.logger.Error("failed to update pull", "err", err, "pull_id", p.PullId)
2138
2137
s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
2139
2138
return
2140
2139
}
···
2142
2141
2143
2142
err = tx.Commit()
2144
2143
if err != nil {
2145
-
log.Println("failed to resubmit pull", err)
2144
+
s.logger.Error("failed to resubmit pull", "err", err)
2146
2145
s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
2147
2146
return
2148
2147
}
···
2152
2151
Writes: writes,
2153
2152
})
2154
2153
if err != nil {
2155
-
log.Println("failed to create stacked pull request", err)
2154
+
s.logger.Error("failed to create stacked pull request", "err", err)
2156
2155
s.pages.Notice(w, "pull", "Failed to create stacked pull request. Try again later.")
2157
2156
return
2158
2157
}
···
2165
2164
user := s.oauth.GetMultiAccountUser(r)
2166
2165
f, err := s.repoResolver.Resolve(r)
2167
2166
if err != nil {
2168
-
log.Println("failed to resolve repo:", err)
2167
+
s.logger.Error("failed to resolve repo:", "err", err)
2169
2168
s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
2170
2169
return
2171
2170
}
2172
2171
2173
2172
pull, ok := r.Context().Value("pull").(*models.Pull)
2174
2173
if !ok {
2175
-
log.Println("failed to get pull")
2174
+
s.logger.Error("failed to get pull")
2176
2175
s.pages.Notice(w, "pull-merge-error", "Failed to merge patch. Try again later.")
2177
2176
return
2178
2177
}
···
2182
2181
if pull.IsStacked() {
2183
2182
stack, ok := r.Context().Value("stack").(models.Stack)
2184
2183
if !ok {
2185
-
log.Println("failed to get stack")
2184
+
s.logger.Error("failed to get stack")
2186
2185
s.pages.Notice(w, "pull-merge-error", "Failed to merge patch. Try again later.")
2187
2186
return
2188
2187
}
···
2199
2198
2200
2199
ident, err := s.idResolver.ResolveIdent(r.Context(), pull.OwnerDid)
2201
2200
if err != nil {
2202
-
log.Printf("resolving identity: %s", err)
2201
+
s.logger.Error("resolving identity", "err", err)
2203
2202
w.WriteHeader(http.StatusNotFound)
2204
2203
return
2205
2204
}
2206
2205
2207
2206
email, err := db.GetPrimaryEmail(s.db, pull.OwnerDid)
2208
2207
if err != nil {
2209
-
log.Printf("failed to get primary email: %s", err)
2208
+
s.logger.Error("failed to get primary email", "err", err)
2210
2209
}
2211
2210
2212
2211
authorName := ident.Handle.String()
···
2234
2233
oauth.WithDev(s.config.Core.Dev),
2235
2234
)
2236
2235
if err != nil {
2237
-
log.Printf("failed to connect to knot server: %v", err)
2236
+
s.logger.Error("failed to connect to knot server", "err", err)
2238
2237
s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
2239
2238
return
2240
2239
}
···
2247
2246
2248
2247
tx, err := s.db.Begin()
2249
2248
if err != nil {
2250
-
log.Println("failed to start transcation", err)
2249
+
s.logger.Error("failed to start transaction", "err", err)
2251
2250
s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
2252
2251
return
2253
2252
}
···
2256
2255
for _, p := range pullsToMerge {
2257
2256
err := db.MergePull(tx, f.RepoAt(), p.PullId)
2258
2257
if err != nil {
2259
-
log.Printf("failed to update pull request status in database: %s", err)
2258
+
s.logger.Error("failed to update pull request status in database", "err", err)
2260
2259
s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
2261
2260
return
2262
2261
}
···
2266
2265
err = tx.Commit()
2267
2266
if err != nil {
2268
2267
// TODO: this is unsound, we should also revert the merge from the knotserver here
2269
-
log.Printf("failed to update pull request status in database: %s", err)
2268
+
s.logger.Error("failed to update pull request status in database", "err", err)
2270
2269
s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
2271
2270
return
2272
2271
}
···
2285
2284
2286
2285
f, err := s.repoResolver.Resolve(r)
2287
2286
if err != nil {
2288
-
log.Println("malformed middleware")
2287
+
s.logger.Error("malformed middleware", "err", err)
2289
2288
return
2290
2289
}
2291
2290
2292
2291
pull, ok := r.Context().Value("pull").(*models.Pull)
2293
2292
if !ok {
2294
-
log.Println("failed to get pull")
2293
+
s.logger.Error("failed to get pull")
2295
2294
s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
2296
2295
return
2297
2296
}
···
2303
2302
isPullAuthor := user.Active.Did == pull.OwnerDid
2304
2303
isCloseAllowed := isOwner || isCollaborator || isPullAuthor
2305
2304
if !isCloseAllowed {
2306
-
log.Println("failed to close pull")
2305
+
s.logger.Warn("failed to close pull: unauthorized")
2307
2306
s.pages.Notice(w, "pull-close", "You are unauthorized to close this pull.")
2308
2307
return
2309
2308
}
···
2311
2310
// Start a transaction
2312
2311
tx, err := s.db.BeginTx(r.Context(), nil)
2313
2312
if err != nil {
2314
-
log.Println("failed to start transaction", err)
2313
+
s.logger.Error("failed to start transaction", "err", err)
2315
2314
s.pages.Notice(w, "pull-close", "Failed to close pull.")
2316
2315
return
2317
2316
}
···
2331
2330
// Close the pull in the database
2332
2331
err = db.ClosePull(tx, f.RepoAt(), p.PullId)
2333
2332
if err != nil {
2334
-
log.Println("failed to close pull", err)
2333
+
s.logger.Error("failed to close pull", "err", err)
2335
2334
s.pages.Notice(w, "pull-close", "Failed to close pull.")
2336
2335
return
2337
2336
}
···
2340
2339
2341
2340
// Commit the transaction
2342
2341
if err = tx.Commit(); err != nil {
2343
-
log.Println("failed to commit transaction", err)
2342
+
s.logger.Error("failed to commit transaction", "err", err)
2344
2343
s.pages.Notice(w, "pull-close", "Failed to close pull.")
2345
2344
return
2346
2345
}
···
2358
2357
2359
2358
f, err := s.repoResolver.Resolve(r)
2360
2359
if err != nil {
2361
-
log.Println("failed to resolve repo", err)
2360
+
s.logger.Error("failed to resolve repo", "err", err)
2362
2361
s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.")
2363
2362
return
2364
2363
}
2365
2364
2366
2365
pull, ok := r.Context().Value("pull").(*models.Pull)
2367
2366
if !ok {
2368
-
log.Println("failed to get pull")
2367
+
s.logger.Error("failed to get pull")
2369
2368
s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
2370
2369
return
2371
2370
}
···
2377
2376
isPullAuthor := user.Active.Did == pull.OwnerDid
2378
2377
isCloseAllowed := isOwner || isCollaborator || isPullAuthor
2379
2378
if !isCloseAllowed {
2380
-
log.Println("failed to close pull")
2379
+
s.logger.Warn("failed to close pull: unauthorized")
2381
2380
s.pages.Notice(w, "pull-close", "You are unauthorized to close this pull.")
2382
2381
return
2383
2382
}
···
2385
2384
// Start a transaction
2386
2385
tx, err := s.db.BeginTx(r.Context(), nil)
2387
2386
if err != nil {
2388
-
log.Println("failed to start transaction", err)
2387
+
s.logger.Error("failed to start transaction", "err", err)
2389
2388
s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.")
2390
2389
return
2391
2390
}
···
2405
2404
// Close the pull in the database
2406
2405
err = db.ReopenPull(tx, f.RepoAt(), p.PullId)
2407
2406
if err != nil {
2408
-
log.Println("failed to close pull", err)
2407
+
s.logger.Error("failed to close pull", "err", err)
2409
2408
s.pages.Notice(w, "pull-close", "Failed to close pull.")
2410
2409
return
2411
2410
}
···
2414
2413
2415
2414
// Commit the transaction
2416
2415
if err = tx.Commit(); err != nil {
2417
-
log.Println("failed to commit transaction", err)
2416
+
s.logger.Error("failed to commit transaction", "err", err)
2418
2417
s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.")
2419
2418
return
2420
2419
}