patch of knotserver,hook: send messages from the knot to the hook, and print it to the git client · round #1 · pull #355 · tangled.org/core

+14

hook/hook.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"bufio"

     

       5
       5
        
       	"context"

     

       6
       6
       +
       	"encoding/json"

     

       6
       7
        
       	"fmt"

     

       7
       8
        
       	"net/http"

     

       8
       9
        
       	"os"

     
···

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

     

       12
       13
        
       )

     

       13
       14
        
       

     

       15
       15
       +
       type HookResponse struct {

     

       16
       16
       +
       	Messages []string `json:"messages"`

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

       14
       19
        
       // The hook command is nested like so:

     

       15
       20
        
       //

     

       16
       21
        
       //	knot hook --[flags] [hook]

     
···

       88
       93
        
       		return fmt.Errorf("unexpected status code: %d", resp.StatusCode)

     

       89
       94
        
       	}

     

       90
       95
        
       

     

       96
       96
       +
       	var data HookResponse

     

       97
       97
       +
       	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {

     

       98
       98
       +
       		return fmt.Errorf("failed to decode response: %w", err)

     

       99
       99
       +
       	}

     

       100
       100
       +
       

     

       101
       101
       +
       	for _, message := range data.Messages {

     

       102
       102
       +
       		fmt.Println(message)

     

       103
       103
       +
       	}

     

       104
       104
       +
       

     

       91
       105
        
       	return nil

     

       92
       106
        
       }

+45 -5

knotserver/internal.go

···

       13
       13
        
       	"github.com/go-chi/chi/v5"

     

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

     

       15
       15
        
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       16
       16
       +
       	"tangled.sh/tangled.sh/core/hook"

     

       16
       17
        
       	"tangled.sh/tangled.sh/core/knotserver/config"

     

       17
       18
        
       	"tangled.sh/tangled.sh/core/knotserver/db"

     

       18
       19
        
       	"tangled.sh/tangled.sh/core/knotserver/git"

     
···

       65
       66
        
       }

     

       66
       67
        
       

     

       67
       68
        
       type PushOptions struct {

     

       68
       68
       -
       	skipCi bool

     

       69
       69
       +
       	skipCi    bool

     

       70
       70
       +
       	verboseCi bool

     

       69
       71
        
       }

     

       70
       72
        
       

     

       71
       73
        
       func (h *InternalHandle) PostReceiveHook(w http.ResponseWriter, r *http.Request) {

     
···

       101
       103
        
       		if option == "skip-ci" || option == "ci-skip" {

     

       102
       104
        
       			pushOptions.skipCi = true

     

       103
       105
        
       		}

     

       106
       106
       +
       		if option == "verbose-ci" || option == "ci-verbose" {

     

       107
       107
       +
       			pushOptions.verboseCi = true

     

       108
       108
       +
       		}

     

       109
       109
       +
       	}

     

       110
       110
       +
       

     

       111
       111
       +
       	resp := hook.HookResponse{

     

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

     

       104
       113
        
       	}

     

       105
       114
        
       

     

       106
       115
        
       	for _, line := range lines {

     
···

       110
       119
        
       			// non-fatal

     

       111
       120
        
       		}

     

       112
       121
        
       

     

       113
       113
       -
       		err = h.triggerPipeline(line, gitUserDid, repoDid, repoName, pushOptions)

     

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

     

       114
       123
        
       		if err != nil {

     

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

     

       116
       125
        
       			// non-fatal

     

       117
       126
        
       		}

     

       118
       127
        
       	}

     

       128
       128
       +
       

     

       129
       129
       +
       	writeJSON(w, resp)

     

       119
       130
        
       }

     

       120
       131
        
       

     

       121
       132
        
       func (h *InternalHandle) insertRefUpdate(line git.PostReceiveLine, gitUserDid, repoDid, repoName string) error {

     
···

       161
       172
        
       	return h.db.InsertEvent(event, h.n)

     

       162
       173
        
       }

     

       163
       174
        
       

     

       164
       164
       -
       func (h *InternalHandle) triggerPipeline(line git.PostReceiveLine, gitUserDid, repoDid, repoName string, pushOptions PushOptions) error {

     

       175
       175
       +
       func (h *InternalHandle) triggerPipeline(clientMsgs *[]string, line git.PostReceiveLine, gitUserDid, repoDid, repoName string, pushOptions PushOptions) error {

     

       165
       176
        
       	if pushOptions.skipCi {

     

       166
       177
        
       		return nil

     

       167
       178
        
       	}

     
···

       186
       197
        
       		return err

     

       187
       198
        
       	}

     

       188
       199
        
       

     

       200
       200
       +
       	pipelineParseErrors := []string{}

     

       201
       201
       +
       

     

       189
       202
        
       	var pipeline workflow.Pipeline

     

       190
       203
        
       	for _, e := range workflowDir {

     

       191
       204
        
       		if !e.IsFile {

     
···

       200
       213
        
       

     

       201
       214
        
       		wf, err := workflow.FromFile(e.Name, contents)

     

       202
       215
        
       		if err != nil {

     

       203
       203
       -
       			// TODO: log here, respond to client that is pushing

     

       204
       216
        
       			h.l.Error("failed to parse workflow", "err", err, "path", fpath)

     

       217
       217
       +
       			pipelineParseErrors = append(pipelineParseErrors, fmt.Sprintf("- at %s: %s\n", fpath, err))

     

       205
       218
        
       			continue

     

       206
       219
        
       		}

     

       207
       220
        
       

     
···

       226
       239
        
       		},

     

       227
       240
        
       	}

     

       228
       241
        
       

     

       229
       229
       -
       	// TODO: send the diagnostics back to the user here via stderr

     

       230
       242
        
       	cp := compiler.Compile(pipeline)

     

       231
       243
        
       	eventJson, err := json.Marshal(cp)

     

       232
       244
        
       	if err != nil {

     

       233
       245
        
       		return err

     

       234
       246
        
       	}

     

       235
       247
        
       

     

       248
       248
       +
       	if pushOptions.verboseCi {

     

       249
       249
       +
       		hasDiagnostics := false

     

       250
       250
       +
       		if len(pipelineParseErrors) > 0 {

     

       251
       251
       +
       			hasDiagnostics = true

     

       252
       252
       +
       			*clientMsgs = append(*clientMsgs, "error: failed to parse workflow(s):")

     

       253
       253
       +
       			for _, error := range pipelineParseErrors {

     

       254
       254
       +
       				*clientMsgs = append(*clientMsgs, error)

     

       255
       255
       +
       			}

     

       256
       256
       +
       		}

     

       257
       257
       +
       		if len(compiler.Diagnostics.Errors) > 0 {

     

       258
       258
       +
       			hasDiagnostics = true

     

       259
       259
       +
       			*clientMsgs = append(*clientMsgs, "error(s) on pipeline:")

     

       260
       260
       +
       			for _, error := range compiler.Diagnostics.Errors {

     

       261
       261
       +
       				*clientMsgs = append(*clientMsgs, fmt.Sprintf("- %s:\n", error))

     

       262
       262
       +
       			}

     

       263
       263
       +
       		}

     

       264
       264
       +
       		if len(compiler.Diagnostics.Warnings) > 0 {

     

       265
       265
       +
       			hasDiagnostics = true

     

       266
       266
       +
       			*clientMsgs = append(*clientMsgs, "warning(s) on pipeline:")

     

       267
       267
       +
       			for _, warning := range compiler.Diagnostics.Warnings {

     

       268
       268
       +
       				*clientMsgs = append(*clientMsgs, fmt.Sprintf("- at %s: %s: %s\n", warning.Path, warning.Type, warning.Reason))

     

       269
       269
       +
       			}

     

       270
       270
       +
       		}

     

       271
       271
       +
       		if !hasDiagnostics {

     

       272
       272
       +
       			*clientMsgs = append(*clientMsgs, fmt.Sprintf("pipeline compiled with no diagnostics\n"))

     

       273
       273
       +
       		}

     

       274
       274
       +
       	}

     

       275
       275
       +
       

     

       236
       276
        
       	// do not run empty pipelines

     

       237
       277
        
       	if cp.Workflows == nil {

     

       238
       278
        
       		return nil