1
package internal
2

3
import (
4
	"fmt"
5
	"os"
6
	"reflect"
7
	"time"
8
)
9

10
type DurationBundle struct {
11
	EventuallyTimeout                       time.Duration
12
	EventuallyPollingInterval               time.Duration
13
	ConsistentlyDuration                    time.Duration
14
	ConsistentlyPollingInterval             time.Duration
15
	EnforceDefaultTimeoutsWhenUsingContexts bool
16
}
17

18
const (
19
	EventuallyTimeoutEnvVarName         = "GOMEGA_DEFAULT_EVENTUALLY_TIMEOUT"
20
	EventuallyPollingIntervalEnvVarName = "GOMEGA_DEFAULT_EVENTUALLY_POLLING_INTERVAL"
21

22
	ConsistentlyDurationEnvVarName        = "GOMEGA_DEFAULT_CONSISTENTLY_DURATION"
23
	ConsistentlyPollingIntervalEnvVarName = "GOMEGA_DEFAULT_CONSISTENTLY_POLLING_INTERVAL"
24

25
	EnforceDefaultTimeoutsWhenUsingContextsEnvVarName = "GOMEGA_ENFORCE_DEFAULT_TIMEOUTS_WHEN_USING_CONTEXTS"
26
)
27

28
func FetchDefaultDurationBundle() DurationBundle {
29
	_, EnforceDefaultTimeoutsWhenUsingContexts := os.LookupEnv(EnforceDefaultTimeoutsWhenUsingContextsEnvVarName)
30
	return DurationBundle{
31
		EventuallyTimeout:         durationFromEnv(EventuallyTimeoutEnvVarName, time.Second),
32
		EventuallyPollingInterval: durationFromEnv(EventuallyPollingIntervalEnvVarName, 10*time.Millisecond),
33

34
		ConsistentlyDuration:                    durationFromEnv(ConsistentlyDurationEnvVarName, 100*time.Millisecond),
35
		ConsistentlyPollingInterval:             durationFromEnv(ConsistentlyPollingIntervalEnvVarName, 10*time.Millisecond),
36
		EnforceDefaultTimeoutsWhenUsingContexts: EnforceDefaultTimeoutsWhenUsingContexts,
37
	}
38
}
39

40
func durationFromEnv(key string, defaultDuration time.Duration) time.Duration {
41
	value := os.Getenv(key)
42
	if value == "" {
43
		return defaultDuration
44
	}
45
	duration, err := time.ParseDuration(value)
46
	if err != nil {
47
		panic(fmt.Sprintf("Expected a duration when using %s!  Parse error %v", key, err))
48
	}
49
	return duration
50
}
51

52
func toDuration(input any) (time.Duration, error) {
53
	duration, ok := input.(time.Duration)
54
	if ok {
55
		return duration, nil
56
	}
57

58
	value := reflect.ValueOf(input)
59
	kind := reflect.TypeOf(input).Kind()
60

61
	if reflect.Int <= kind && kind <= reflect.Int64 {
62
		return time.Duration(value.Int()) * time.Second, nil
63
	} else if reflect.Uint <= kind && kind <= reflect.Uint64 {
64
		return time.Duration(value.Uint()) * time.Second, nil
65
	} else if reflect.Float32 <= kind && kind <= reflect.Float64 {
66
		return time.Duration(value.Float() * float64(time.Second)), nil
67
	} else if reflect.String == kind {
68
		duration, err := time.ParseDuration(value.String())
69
		if err != nil {
70
			return 0, fmt.Errorf("%#v is not a valid parsable duration string: %w", input, err)
71
		}
72
		return duration, nil
73
	}
74

75
	return 0, fmt.Errorf("%#v is not a valid interval. Must be a time.Duration, a parsable duration string, or a number.", input)
76
}
77

78