patch of appview: improve error handling in knotstream/spindlestream · round #0 · pull #276 · tangled.org/core

+7 -8

appview/state/knotstream.go

···

       143
       143
        
       	// trigger info

     

       144
       144
        
       	var trigger db.Trigger

     

       145
       145
        
       	var sha string

     

       146
       146
       -
       	switch record.TriggerMetadata.Kind {

     

       146
       146
       +
       	trigger.Kind = workflow.TriggerKind(record.TriggerMetadata.Kind)

     

       147
       147
       +
       	switch trigger.Kind {

     

       147
       148
        
       	case workflow.TriggerKindPush:

     

       148
       148
       -
       		trigger.Kind = workflow.TriggerKindPush

     

       149
       149
        
       		trigger.PushRef = &record.TriggerMetadata.Push.Ref

     

       150
       150
        
       		trigger.PushNewSha = &record.TriggerMetadata.Push.NewSha

     

       151
       151
        
       		trigger.PushOldSha = &record.TriggerMetadata.Push.OldSha

     

       152
       152
        
       		sha = *trigger.PushNewSha

     

       153
       153
        
       	case workflow.TriggerKindPullRequest:

     

       154
       154
       -
       		trigger.Kind = workflow.TriggerKindPush

     

       155
       154
        
       		trigger.PRSourceBranch = &record.TriggerMetadata.PullRequest.SourceBranch

     

       156
       155
        
       		trigger.PRTargetBranch = &record.TriggerMetadata.PullRequest.TargetBranch

     

       157
       156
        
       		trigger.PRSourceSha = &record.TriggerMetadata.PullRequest.SourceSha

     
···

       161
       160
        
       

     

       162
       161
        
       	tx, err := d.Begin()

     

       163
       162
        
       	if err != nil {

     

       164
       164
       -
       		return err

     

       163
       163
       +
       		return fmt.Errorf("failed to start txn: %w", err)

     

       165
       164
        
       	}

     

       166
       165
        
       

     

       167
       166
        
       	triggerId, err := db.AddTrigger(tx, trigger)

     

       168
       167
        
       	if err != nil {

     

       169
       169
       -
       		return err

     

       168
       168
       +
       		return fmt.Errorf("failed to add trigger entry: %w", err)

     

       170
       169
        
       	}

     

       171
       170
        
       

     

       172
       171
        
       	pipeline := db.Pipeline{

     
···

       180
       179
        
       

     

       181
       180
        
       	err = db.AddPipeline(tx, pipeline)

     

       182
       181
        
       	if err != nil {

     

       183
       183
       -
       		return err

     

       182
       182
       +
       		return fmt.Errorf("failed to add pipeline: %w", err)

     

       184
       183
        
       	}

     

       185
       184
        
       

     

       186
       185
        
       	err = tx.Commit()

     

       187
       186
        
       	if err != nil {

     

       188
       188
       -
       		return err

     

       187
       187
       +
       		return fmt.Errorf("failed to commit txn: %w", err)

     

       189
       188
        
       	}

     

       190
       189
        
       

     

       191
       191
       -
       	return err

     

       190
       190
       +
       	return nil

     

       192
       191
        
       }

+7 -1

appview/state/spindlestream.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
        
       	"encoding/json"

     

       6
       6
       +
       	"fmt"

     

       6
       7
        
       	"log/slog"

     

       7
       8
        
       	"strings"

     

       8
       9
        
       	"time"

     
···

       100
       101
        
       		ExitCode:     exitCode,

     

       101
       102
        
       	}

     

       102
       103
        
       

     

       103
       103
       -
       	return db.AddPipelineStatus(d, status)

     

       104
       104
       +
       	err = db.AddPipelineStatus(d, status)

     

       105
       105
       +
       	if err != nil {

     

       106
       106
       +
       		return fmt.Errorf("failed to add pipeline status: %w", err)

     

       107
       107
       +
       	}

     

       108
       108
       +
       

     

       109
       109
       +
       	return nil

     

       104
       110
        
       }

+2 -6

knotserver/internal.go

···

       147
       147
        
       }

     

       148
       148
        
       

     

       149
       149
        
       func (h *InternalHandle) triggerPipeline(line git.PostReceiveLine, gitUserDid, repoDid, repoName string) error {

     

       150
       150
       -
       	const (

     

       151
       151
       -
       		WorkflowDir = ".tangled/workflows"

     

       152
       152
       -
       	)

     

       153
       153
       -
       

     

       154
       150
        
       	didSlashRepo, err := securejoin.SecureJoin(repoDid, repoName)

     

       155
       151
        
       	if err != nil {

     

       156
       152
        
       		return err

     
···

       166
       162
        
       		return err

     

       167
       163
        
       	}

     

       168
       164
        
       

     

       169
       169
       -
       	workflowDir, err := gr.FileTree(context.Background(), WorkflowDir)

     

       165
       165
       +
       	workflowDir, err := gr.FileTree(context.Background(), workflow.WorkflowDir)

     

       170
       166
        
       	if err != nil {

     

       171
       167
        
       		return err

     

       172
       168
        
       	}

     
···

       177
       173
        
       			continue

     

       178
       174
        
       		}

     

       179
       175
        
       

     

       180
       180
       -
       		fpath := filepath.Join(WorkflowDir, e.Name)

     

       176
       176
       +
       		fpath := filepath.Join(workflow.WorkflowDir, e.Name)

     

       181
       177
        
       		contents, err := gr.RawContent(fpath)

     

       182
       178
        
       		if err != nil {

     

       183
       179
        
       			continue

+1

knotserver/server.go

···

       75
       75
        
       	jc, err := jetstream.NewJetstreamClient(c.Server.JetstreamEndpoint, "knotserver", []string{

     

       76
       76
        
       		tangled.PublicKeyNSID,

     

       77
       77
        
       		tangled.KnotMemberNSID,

     

       78
       78
       +
       		tangled.RepoPullNSID,

     

       78
       79
        
       	}, nil, logger, db, true, c.Server.LogDids)

     

       79
       80
        
       	if err != nil {

     

       80
       81
        
       		logger.Error("failed to setup jetstream", "error", err)