interdiff of round #1 and #0 · pull #612 · tangled.org/core

REVERTED

hook/hook.go

···

       10
       10
        
       	"strings"

     

       11
       11
        
       

     

       12
       12
        
       	"github.com/urfave/cli/v3"

     

       13
       13
       -
       	"tangled.org/core/idresolver"

     

       14
       14
       -
       	"tangled.org/core/knotserver/git"

     

       15
       13
        
       )

     

       16
       14
        
       

     

       17
       15
        
       type HookResponse struct {

     
···

       70
       68
        
       

     

       71
       69
        
       	client := &http.Client{}

     

       72
       70
        
       

     

       73
       73
       -
       	gr, err := git.PlainOpen(gitDir)

     

       74
       74
       -
       	defaultBranch, err := gr.FindMainBranch()

     

       75
       75
       -
       	if err != nil {

     

       76
       76
       -
       		fmt.Fprintln(os.Stderr, "failed to retrieve default branch")

     

       77
       77
       -
       		return nil

     

       78
       78
       -
       	}

     

       79
       79
       -
       	gitPath := strings.Split(gitDir, "/")

     

       80
       80
       -
       	repoName := gitPath[len(gitPath)-1]

     

       81
       81
       -
       	userIdent, err := idresolver.DefaultResolver().ResolveIdent(ctx, userDid)

     

       82
       82
       -
       	lines, err := git.ParsePostReceive(strings.NewReader(payload))

     

       83
       83
       -
       	if err != nil {

     

       84
       84
       -
       		return fmt.Errorf("failed to parse post-receive payload: %w", err)

     

       85
       85
       -
       	}

     

       86
       86
       -
       	for _, line := range lines {

     

       87
       87
       -
       		if line.OldSha.IsZero() && line.OldSha != line.NewSha {

     

       88
       88
       -
       			fmt.Fprintln(os.Stderr, "")

     

       89
       89
       -
       			fmt.Fprintf(os.Stderr, "Create a PR pointing to %s\n", defaultBranch)

     

       90
       90
       -
       			fmt.Fprintf(os.Stderr, "\thttps://tangled.org/@%s/%s/compare/%s...%s\n", userIdent.Handle.String(), repoName, defaultBranch, strings.TrimPrefix(line.Ref, "refs/heads/"))

     

       91
       91
       -
       			fmt.Fprintln(os.Stderr, "")

     

       92
       92
       -
       		}

     

       93
       93
       -
       	}

     

       94
       94
       -
       

     

       95
       71
        
       	req, err := http.NewRequest("POST", "http://"+endpoint+"/hooks/post-receive", strings.NewReader(payload))

     

       96
       72
        
       	if err != nil {

     

       97
       73
        
       		return fmt.Errorf("failed to create request: %w", err)

NEW

knotserver/internal.go

···

       15
       15
        
       	"github.com/go-chi/chi/v5/middleware"

     

       16
       16
        
       	"tangled.org/core/api/tangled"

     

       17
       17
        
       	"tangled.org/core/hook"

     

       18
       18
       +
       	"tangled.org/core/idresolver"

     

       18
       19
        
       	"tangled.org/core/knotserver/config"

     

       19
       20
        
       	"tangled.org/core/knotserver/db"

     

       20
       21
        
       	"tangled.org/core/knotserver/git"

     
···

       111
       112
        
       		Messages: make([]string, 0),

     

       112
       113
        
       	}

     

       113
       114
        
       

     

       115
       115
       +
       	userIdent, err := idresolver.DefaultResolver().ResolveIdent(r.Context(), gitUserDid)

     

       116
       116
       +
       	user := gitUserDid

     

       117
       117
       +
       	if err != nil {

     

       118
       118
       +
       		l.Error("Failed to fetch user identity", "err", err)

     

       119
       119
       +
       		// non-fatal

     

       120
       120
       +
       	} else {

     

       121
       121
       +
       		user = userIdent.Handle.String()

     

       122
       122
       +
       	}

     

       123
       123
       +
       	gr, err := git.PlainOpen(gitRelativeDir)

     

       124
       124
       +
       	if err != nil {

     

       125
       125
       +
       		l.Error("Failed to open git repository", "err", err)

     

       126
       126
       +
       		return

     

       127
       127
       +
       	}

     

       128
       128
       +
       	defaultBranch, err := gr.FindMainBranch()

     

       129
       129
       +
       	if err != nil {

     

       130
       130
       +
       		l.Error("Failed to fetch default branch", "err", err)

     

       131
       131
       +
       		return

     

       132
       132
       +
       	}

     

       133
       133
       +
       

     

       114
       134
        
       	for _, line := range lines {

     

       115
       135
        
       		err := h.insertRefUpdate(line, gitUserDid, repoDid, repoName)

     

       116
       136
        
       		if err != nil {

     
···

       118
       138
        
       			// non-fatal

     

       119
       139
        
       		}

     

       120
       140
        
       

     

       141
       141
       +
       		if (line.NewSha.String() != line.OldSha.String()) && line.OldSha.IsZero() && (line.Ref != fmt.Sprint("refs/heads/", defaultBranch)) {

     

       142
       142
       +
       			resp.Messages = append(resp.Messages, "")

     

       143
       143
       +
       			resp.Messages = append(resp.Messages, fmt.Sprintf("Create a PR pointing to %s", defaultBranch))

     

       144
       144
       +
       			resp.Messages = append(resp.Messages, fmt.Sprintf("\t%s/@%s/%s/compare/%s...%s", h.c.AppViewEndpoint, user, repoName, defaultBranch, strings.TrimPrefix(line.Ref, "refs/heads/")))

     

       145
       145
       +
       			resp.Messages = append(resp.Messages, "")

     

       146
       146
       +
       		}

     

       147
       147
       +
       

     

       121
       148
        
       		err = h.triggerPipeline(&resp.Messages, line, gitUserDid, repoDid, repoName, pushOptions)

     

       122
       149
        
       		if err != nil {

     

       123
       150
        
       			l.Error("failed to trigger pipeline", "err", err, "line", line, "did", gitUserDid, "repo", gitRelativeDir)