lewis.moe
forked from
tangled.org/core
Monorepo for Tangled
appview,lexicons: add SHA field to sh.tangled.repo.pull
refers to the tip of the branch that this PR was opened from. this
addition permits us to associate a CI run with a branch or fork based
pull request.
Signed-off-by: oppiliappan <me@oppi.li>
oppi.li
+36
-2
api/tangled/cbor_gen.go
+36
-2
api/tangled/cbor_gen.go
···
7008
}
7009
7010
cw := cbg.NewCborWriter(w)
7011
-
fieldCount := 2
7012
7013
if t.Repo == nil {
7014
fieldCount--
7015
}
7016
7017
if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7018
return err
7019
}
7020
···
7116
}
7117
7118
switch string(nameBuf[:nameLen]) {
7119
-
// t.Repo (string) (string)
7120
case "repo":
7121
7122
{
···
7008
}
7009
7010
cw := cbg.NewCborWriter(w)
7011
+
fieldCount := 3
7012
7013
if t.Repo == nil {
7014
fieldCount--
7015
}
7016
7017
if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7018
+
return err
7019
+
}
7020
+
7021
+
// t.Sha (string) (string)
7022
+
if len("sha") > 1000000 {
7023
+
return xerrors.Errorf("Value in field \"sha\" was too long")
7024
+
}
7025
+
7026
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sha"))); err != nil {
7027
+
return err
7028
+
}
7029
+
if _, err := cw.WriteString(string("sha")); err != nil {
7030
+
return err
7031
+
}
7032
+
7033
+
if len(t.Sha) > 1000000 {
7034
+
return xerrors.Errorf("Value in field t.Sha was too long")
7035
+
}
7036
+
7037
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Sha))); err != nil {
7038
+
return err
7039
+
}
7040
+
if _, err := cw.WriteString(string(t.Sha)); err != nil {
7041
return err
7042
}
7043
···
7139
}
7140
7141
switch string(nameBuf[:nameLen]) {
7142
+
// t.Sha (string) (string)
7143
+
case "sha":
7144
+
7145
+
{
7146
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
7147
+
if err != nil {
7148
+
return err
7149
+
}
7150
+
7151
+
t.Sha = string(sval)
7152
+
}
7153
+
// t.Repo (string) (string)
7154
case "repo":
7155
7156
{
+1
api/tangled/repopull.go
+1
api/tangled/repopull.go
+1
-1
appview/db/artifact.go
+1
-1
appview/db/artifact.go
+6
appview/db/pulls.go
+6
appview/db/pulls.go
···
87
if p.PullSource != nil {
88
s := p.PullSource.AsRecord()
89
source = &s
90
}
91
92
record := tangled.RepoPull{
···
162
func (p *Pull) LatestPatch() string {
163
latestSubmission := p.Submissions[p.LastRoundNumber()]
164
return latestSubmission.Patch
165
}
166
167
func (p *Pull) PullAt() syntax.ATURI {
···
87
if p.PullSource != nil {
88
s := p.PullSource.AsRecord()
89
source = &s
90
+
source.Sha = p.LatestSha()
91
}
92
93
record := tangled.RepoPull{
···
163
func (p *Pull) LatestPatch() string {
164
latestSubmission := p.Submissions[p.LastRoundNumber()]
165
return latestSubmission.Patch
166
+
}
167
+
168
+
func (p *Pull) LatestSha() string {
169
+
latestSubmission := p.Submissions[p.LastRoundNumber()]
170
+
return latestSubmission.SourceRev
171
}
172
173
func (p *Pull) PullAt() syntax.ATURI {
+21
-11
appview/pulls/pulls.go
+21
-11
appview/pulls/pulls.go
···
798
sourceBranch string,
799
isStacked bool,
800
) {
801
-
pullSource := &db.PullSource{
802
-
Branch: sourceBranch,
803
-
}
804
-
recordPullSource := &tangled.RepoPull_Source{
805
-
Branch: sourceBranch,
806
-
}
807
-
808
// Generate a patch using /compare
809
ksClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
810
if err != nil {
···
826
if !patchutil.IsPatchValid(patch) {
827
s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.")
828
return
829
}
830
831
s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, sourceRev, pullSource, recordPullSource, isStacked)
···
914
return
915
}
916
917
-
s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, sourceRev, &db.PullSource{
918
Branch: sourceBranch,
919
RepoAt: &forkAtUri,
920
-
}, &tangled.RepoPull_Source{Branch: sourceBranch, Repo: &fork.AtUri}, isStacked)
921
}
922
923
func (s *Pulls) createPullRequest(
···
934
) {
935
if isStacked {
936
// creates a series of PRs, each linking to the previous, identified by jj's change-id
937
-
s.createStackedPulLRequest(
938
w,
939
r,
940
f,
···
1049
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pullId))
1050
}
1051
1052
-
func (s *Pulls) createStackedPulLRequest(
1053
w http.ResponseWriter,
1054
r *http.Request,
1055
f *reporesolver.ResolvedRepo,
···
1566
if pull.IsBranchBased() {
1567
recordPullSource = &tangled.RepoPull_Source{
1568
Branch: pull.PullSource.Branch,
1569
}
1570
}
1571
if pull.IsForkBased() {
···
1573
recordPullSource = &tangled.RepoPull_Source{
1574
Branch: pull.PullSource.Branch,
1575
Repo: &repoAt,
1576
}
1577
}
1578
···
798
sourceBranch string,
799
isStacked bool,
800
) {
801
// Generate a patch using /compare
802
ksClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
803
if err != nil {
···
819
if !patchutil.IsPatchValid(patch) {
820
s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.")
821
return
822
+
}
823
+
824
+
pullSource := &db.PullSource{
825
+
Branch: sourceBranch,
826
+
}
827
+
recordPullSource := &tangled.RepoPull_Source{
828
+
Branch: sourceBranch,
829
+
Sha: comparison.Rev2,
830
}
831
832
s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, sourceRev, pullSource, recordPullSource, isStacked)
···
915
return
916
}
917
918
+
pullSource := &db.PullSource{
919
Branch: sourceBranch,
920
RepoAt: &forkAtUri,
921
+
}
922
+
recordPullSource := &tangled.RepoPull_Source{
923
+
Branch: sourceBranch,
924
+
Repo: &fork.AtUri,
925
+
Sha: sourceRev,
926
+
}
927
+
928
+
s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, sourceRev, pullSource, recordPullSource, isStacked)
929
}
930
931
func (s *Pulls) createPullRequest(
···
942
) {
943
if isStacked {
944
// creates a series of PRs, each linking to the previous, identified by jj's change-id
945
+
s.createStackedPullRequest(
946
w,
947
r,
948
f,
···
1057
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pullId))
1058
}
1059
1060
+
func (s *Pulls) createStackedPullRequest(
1061
w http.ResponseWriter,
1062
r *http.Request,
1063
f *reporesolver.ResolvedRepo,
···
1574
if pull.IsBranchBased() {
1575
recordPullSource = &tangled.RepoPull_Source{
1576
Branch: pull.PullSource.Branch,
1577
+
Sha: sourceRev,
1578
}
1579
}
1580
if pull.IsForkBased() {
···
1582
recordPullSource = &tangled.RepoPull_Source{
1583
Branch: pull.PullSource.Branch,
1584
Repo: &repoAt,
1585
+
Sha: sourceRev,
1586
}
1587
}
1588
+1
-1
appview/repo/index.go
+1
-1
appview/repo/index.go
+2
-2
appview/repo/repo.go
+2
-2
appview/repo/repo.go
···
139
for _, c := range repolog.Commits {
140
shas = append(shas, c.Hash.String())
141
}
142
-
pipelines, err := rp.getPipelineStatuses(repoInfo, shas)
143
if err != nil {
144
log.Println(err)
145
// non-fatal
···
304
305
user := rp.oauth.GetUser(r)
306
repoInfo := f.RepoInfo(user)
307
-
pipelines, err := rp.getPipelineStatuses(repoInfo, []string{result.Diff.Commit.This})
308
if err != nil {
309
log.Println(err)
310
// non-fatal
···
139
for _, c := range repolog.Commits {
140
shas = append(shas, c.Hash.String())
141
}
142
+
pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)
143
if err != nil {
144
log.Println(err)
145
// non-fatal
···
304
305
user := rp.oauth.GetUser(r)
306
repoInfo := f.RepoInfo(user)
307
+
pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This})
308
if err != nil {
309
log.Println(err)
310
// non-fatal
+3
-2
appview/repo/repo_util.go
+3
-2
appview/repo/repo_util.go
···
105
// grab pipelines from DB and munge that into a hashmap with commit sha as key
106
//
107
// golang is so blessed that it requires 35 lines of imperative code for this
108
-
func (rp *Repo) getPipelineStatuses(
109
repoInfo repoinfo.RepoInfo,
110
shas []string,
111
) (map[string]db.Pipeline, error) {
···
116
}
117
118
ps, err := db.GetPipelineStatuses(
119
-
rp.db,
120
db.FilterEq("repo_owner", repoInfo.OwnerDid),
121
db.FilterEq("repo_name", repoInfo.Name),
122
db.FilterEq("knot", repoInfo.Knot),
···
105
// grab pipelines from DB and munge that into a hashmap with commit sha as key
106
//
107
// golang is so blessed that it requires 35 lines of imperative code for this
108
+
func getPipelineStatuses(
109
+
d *db.DB,
110
repoInfo repoinfo.RepoInfo,
111
shas []string,
112
) (map[string]db.Pipeline, error) {
···
117
}
118
119
ps, err := db.GetPipelineStatuses(
120
+
d,
121
db.FilterEq("repo_owner", repoInfo.OwnerDid),
122
db.FilterEq("repo_name", repoInfo.Name),
123
db.FilterEq("knot", repoInfo.Knot),
+7
-1
lexicons/pulls/pull.json
+7
-1
lexicons/pulls/pull.json