validate.go

package goss

import (
	"fmt"
	"io"
	"os"
	"runtime"
	"sync"
	"time"

	"github.com/SimonBaeumer/goss/outputs"
	"github.com/SimonBaeumer/goss/resource"
	"github.com/SimonBaeumer/goss/system"
	"github.com/SimonBaeumer/goss/util"
	"github.com/fatih/color"
)

type Validator struct {
	GossConfig    GossConfig
	RetryTimeout  time.Duration
	Sleep         time.Duration
	FormatOptions []string
	Outputer      outputs.Outputer
	MaxConcurrent int //Separating concurrency and validation, irritating atm...
	OutputWriter  io.Writer
}

// Validate validation runtime
func (v *Validator) Validate(startTime time.Time) int {
	if v.OutputWriter == nil {
		v.OutputWriter = os.Stdout
	}

	outputConfig := util.OutputConfig{
		FormatOptions: v.FormatOptions,
	}

	sys := system.New()

	i := 1
	for {
		iStartTime := time.Now()

		out := validate(sys, v.GossConfig, v.MaxConcurrent)
		exitCode := v.Outputer.Output(v.OutputWriter, out, iStartTime, outputConfig)
		if v.RetryTimeout == 0 || exitCode == 0 {
			return exitCode
		}

		elapsed := time.Since(startTime)
		if elapsed+v.Sleep > v.RetryTimeout {
			color.Red("\nERROR: Timeout of %s reached before tests entered a passing state", v.RetryTimeout)
			return exitCode
		}
		color.Red("Retrying in %s (elapsed/timeout time: %.3fs/%s)\n\n\n", v.Sleep, elapsed.Seconds(), v.RetryTimeout)

		// Reset Cache
		sys = system.New()
		time.Sleep(v.Sleep)
		i++
		fmt.Printf("Attempt #%d:\n", i)
	}
}

func validate(sys *system.System, gossConfig GossConfig, maxConcurrent int) <-chan []resource.TestResult {
	out := make(chan []resource.TestResult)
	in := make(chan resource.Resource)

	// Send resources to input channel
	go func() {
		for _, res := range gossConfig.Resources() {
			in <- res
		}
		close(in)
	}()

	// Read resources from input channel and validate
	workerCount := runtime.NumCPU() * 5
	if workerCount > maxConcurrent {
		workerCount = maxConcurrent
	}
	var wg sync.WaitGroup
	for i := 0; i < workerCount; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for res := range in {
				out <- res.Validate(sys)
			}
		}()
	}

	// Wait for the out channel to be finished, after that close it
	go func() {
		wg.Wait()
		close(out)
	}()

	return out
}