back round 1 view raw

appview,lexicons: add SHA field to sh.tangled.repo.pull #274

merged
opened by oppi.li targeting master from push-vquoltwpkuny

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

options
unified split
Changed files
+78 -20
api
tangled
cbor_gen.go
repopull.go
appview
db
artifact.go
pulls.go
pulls
pulls.go
repo
index.go
repo.go
repo_util.go
lexicons
pulls
pull.json
+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--


     
···

       
7018

       
 

       
		return err


     

       
7019

       
 

       
	}


     

       
7020

       
 

       



     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
7021

       
 

       
	// t.Repo (string) (string)


     

       
7022

       
 

       
	if t.Repo != nil {


     

       
7023

       
 

       



     
···

       
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--


     
···

       
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

       
+

       



     

       
7044

       
 

       
	// t.Repo (string) (string)


     

       
7045

       
 

       
	if t.Repo != nil {


     

       
7046

       
 

       



     
···

       
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 
···

       
32

       
 

       
type RepoPull_Source struct {


     

       
33

       
 

       
	Branch string  `json:"branch" cborgen:"branch"`


     

       
34

       
 

       
	Repo   *string `json:"repo,omitempty" cborgen:"repo,omitempty"`


     

       

       

       
     

       
35

       
 

       
}


     
···

       
32

       
 

       
type RepoPull_Source struct {


     

       
33

       
 

       
	Branch string  `json:"branch" cborgen:"branch"`


     

       
34

       
 

       
	Repo   *string `json:"repo,omitempty" cborgen:"repo,omitempty"`


     

       
35

       
+

       
	Sha    string  `json:"sha" cborgen:"sha"`


     

       
36

       
 

       
}
+1 -1
appview/db/artifact.go 
···

       
27

       
 

       
}


     

       
28

       
 

       



     

       
29

       
 

       
func (a *Artifact) ArtifactAt() syntax.ATURI {


     

       
30

       
-

       
	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", a.Did, tangled.RepoPullNSID, a.Rkey))


     

       
31

       
 

       
}


     

       
32

       
 

       



     

       
33

       
 

       
func AddArtifact(e Execer, artifact Artifact) error {


     
···

       
27

       
 

       
}


     

       
28

       
 

       



     

       
29

       
 

       
func (a *Artifact) ArtifactAt() syntax.ATURI {


     

       
30

       
+

       
	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", a.Did, tangled.RepoArtifactNSID, a.Rkey))


     

       
31

       
 

       
}


     

       
32

       
 

       



     

       
33

       
 

       
func AddArtifact(e Execer, artifact Artifact) error {
+6
appview/db/pulls.go 
···

       
87

       
 

       
	if p.PullSource != nil {


     

       
88

       
 

       
		s := p.PullSource.AsRecord()


     

       
89

       
 

       
		source = &s


     

       

       

       
     

       
90

       
 

       
	}


     

       
91

       
 

       



     

       
92

       
 

       
	record := tangled.RepoPull{


     
···

       
164

       
 

       
	return latestSubmission.Patch


     

       
165

       
 

       
}


     

       
166

       
 

       



     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
167

       
 

       
func (p *Pull) PullAt() syntax.ATURI {


     

       
168

       
 

       
	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", p.OwnerDid, tangled.RepoPullNSID, p.Rkey))


     

       
169

       
 

       
}


     
···

       
87

       
 

       
	if p.PullSource != nil {


     

       
88

       
 

       
		s := p.PullSource.AsRecord()


     

       
89

       
 

       
		source = &s


     

       
90

       
+

       
		source.Sha = p.LatestSha()


     

       
91

       
 

       
	}


     

       
92

       
 

       



     

       
93

       
 

       
	record := tangled.RepoPull{


     
···

       
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 {


     

       
174

       
 

       
	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", p.OwnerDid, tangled.RepoPullNSID, p.Rkey))


     

       
175

       
 

       
}
+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 {


     
···

       
828

       
 

       
		return


     

       
829

       
 

       
	}


     

       
830

       
 

       



     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
831

       
 

       
	s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, sourceRev, pullSource, recordPullSource, isStacked)


     

       
832

       
 

       
}


     

       
833

       
 

       



     
···

       
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 {


     
···

       
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)


     

       
833

       
 

       
}


     

       
834

       
 

       



     
···

       
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 
···

       
133

       
 

       
	for _, c := range commitsTrunc {


     

       
134

       
 

       
		shas = append(shas, c.Hash.String())


     

       
135

       
 

       
	}


     

       
136

       
-

       
	pipelines, err := rp.getPipelineStatuses(repoInfo, shas)


     

       
137

       
 

       
	if err != nil {


     

       
138

       
 

       
		log.Printf("failed to fetch pipeline statuses: %s", err)


     

       
139

       
 

       
		// non-fatal


     
···

       
133

       
 

       
	for _, c := range commitsTrunc {


     

       
134

       
 

       
		shas = append(shas, c.Hash.String())


     

       
135

       
 

       
	}


     

       
136

       
+

       
	pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)


     

       
137

       
 

       
	if err != nil {


     

       
138

       
 

       
		log.Printf("failed to fetch pipeline statuses: %s", err)


     

       
139

       
 

       
		// non-fatal
+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 
···

       
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 
···

       
51

       
 

       
    "source": {


     

       
52

       
 

       
      "type": "object",


     

       
53

       
 

       
      "required": [


     

       
54

       
-

       
        "branch"


     

       

       

       
     

       
55

       
 

       
      ],


     

       
56

       
 

       
      "properties": {


     

       
57

       
 

       
        "branch": {


     

       
58

       
 

       
          "type": "string"


     

       
59

       
 

       
        },


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
60

       
 

       
        "repo": {


     

       
61

       
 

       
          "type": "string",


     

       
62

       
 

       
          "format": "at-uri"


     
···

       
51

       
 

       
    "source": {


     

       
52

       
 

       
      "type": "object",


     

       
53

       
 

       
      "required": [


     

       
54

       
+

       
        "branch",


     

       
55

       
+

       
        "sha"


     

       
56

       
 

       
      ],


     

       
57

       
 

       
      "properties": {


     

       
58

       
 

       
        "branch": {


     

       
59

       
 

       
          "type": "string"


     

       
60

       
 

       
        },


     

       
61

       
+

       
        "sha": {


     

       
62

       
+

       
          "type": "string",


     

       
63

       
+

       
          "minLength": 40,


     

       
64

       
+

       
          "maxLength": 40


     

       
65

       
+

       
        },


     

       
66

       
 

       
        "repo": {


     

       
67

       
 

       
          "type": "string",


     

       
68

       
 

       
          "format": "at-uri"