Address issue #804

Stop go routines from dangling on timeout rules.

Author: daveshanley

motor/rule_applicator.go

@@ -808,15 +808,31 @@ func ApplyRulesToRuleSet(execution *RuleSetExecution) *RuleSetExecutionResult {
 
 				timeoutCtx, ruleCancel := context.WithTimeout(context.Background(), execution.Timeout)
 				defer ruleCancel()
-				doneChan := make(chan bool)
+				doneChan := make(chan struct{})
 
-				go runRule(ctx, doneChan)
+				localResults := []model.RuleFunctionResult{}
+				localIgnored := []model.RuleFunctionResult{}
+				localFixed := []model.RuleFunctionResult{}
+				localErrs := []error{}
+				localCtx := ctx
+				localCtx.ruleResults = &localResults
+				localCtx.ignoredResults = &localIgnored
+				localCtx.fixedResults = &localFixed
+				localCtx.errors = &localErrs
+
+				go runRule(localCtx, doneChan)
 
 				select {
 				case <-timeoutCtx.Done():
 					ctx.logger.Error("Rule timed out, skipping", "rule", rule.Id, "timeout", execution.Timeout)
 					break
 				case <-doneChan:
+					lock.Lock()
+					ruleResults = append(ruleResults, localResults...)
+					ignoredResults = append(ignoredResults, localIgnored...)
+					fixedResults = append(fixedResults, localFixed...)
+					errs = append(errs, localErrs...)
+					lock.Unlock()
 					break
 				}
 				done <- true
@@ -872,7 +888,8 @@ func ApplyRulesToRuleSet(execution *RuleSetExecution) *RuleSetExecutionResult {
 	}
 }
 
-func runRule(ctx ruleContext, doneChan chan bool) {
+func runRule(ctx ruleContext, doneChan chan struct{}) {
+	defer close(doneChan)
 
 	// Check for missing auto-fix functions when --fix is enabled
 	if ctx.applyAutoFixes && ctx.rule.AutoFixFunction != "" {
@@ -971,7 +988,6 @@ func runRule(ctx ruleContext, doneChan chan bool) {
 			lock.Lock()
 			*ctx.errors = append(*ctx.errors, err)
 			lock.Unlock()
-			doneChan <- true
 			return
 		}
 		if len(nodes) <= 0 {
@@ -999,7 +1015,6 @@ func runRule(ctx ruleContext, doneChan chan bool) {
 			}
 		}
 	}
-	doneChan <- true
 }
 
 var lock sync.Mutex

motor/rule_timeout_test.go

@@ -0,0 +1,72 @@
+package motor
+
+import (
+	"testing"
+	"time"
+
+	"github.com/daveshanley/vacuum/model"
+	"github.com/daveshanley/vacuum/rulesets"
+	"github.com/stretchr/testify/assert"
+	"go.yaml.in/yaml/v4"
+)
+
+type slowRule struct {
+	sleep time.Duration
+}
+
+func (s *slowRule) GetSchema() model.RuleFunctionSchema {
+	return model.RuleFunctionSchema{
+		Name: "slow",
+	}
+}
+
+func (s *slowRule) GetCategory() string {
+	return model.CategoryValidation
+}
+
+func (s *slowRule) RunRule(nodes []*yaml.Node, context model.RuleFunctionContext) []model.RuleFunctionResult {
+	time.Sleep(s.sleep)
+	return []model.RuleFunctionResult{
+		{
+			Message: "slow rule finished",
+		},
+	}
+}
+
+func TestRuleTimeout_DropsResults(t *testing.T) {
+	yml := `openapi: 3.0.0
+info:
+  title: Test
+  version: 1.0.0
+paths: {}`
+
+	rules := map[string]*model.Rule{
+		"slow": {
+			Id:           "slow",
+			Given:        "$",
+			RuleCategory: model.RuleCategories[model.CategoryValidation],
+			Type:         rulesets.Validation,
+			Severity:     model.SeverityError,
+			Then: model.RuleAction{
+				Function: "slow",
+			},
+		},
+	}
+
+	ex := &RuleSetExecution{
+		RuleSet: &rulesets.RuleSet{
+			Rules: rules,
+		},
+		Spec:    []byte(yml),
+		Timeout: 20 * time.Millisecond,
+		CustomFunctions: map[string]model.RuleFunction{
+			"slow": &slowRule{sleep: 100 * time.Millisecond},
+		},
+	}
+
+	results := ApplyRulesToRuleSet(ex)
+	assert.Len(t, results.Results, 0)
+
+	time.Sleep(150 * time.Millisecond)
+	assert.Len(t, results.Results, 0)
+}