podman

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
}
16

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

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

25
func FetchDefaultDurationBundle() DurationBundle {
26
	return DurationBundle{
27
		EventuallyTimeout:         durationFromEnv(EventuallyTimeoutEnvVarName, time.Second),
28
		EventuallyPollingInterval: durationFromEnv(EventuallyPollingIntervalEnvVarName, 10*time.Millisecond),
29

30
		ConsistentlyDuration:        durationFromEnv(ConsistentlyDurationEnvVarName, 100*time.Millisecond),
31
		ConsistentlyPollingInterval: durationFromEnv(ConsistentlyPollingIntervalEnvVarName, 10*time.Millisecond),
32
	}
33
}
34

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

47
func toDuration(input interface{}) (time.Duration, error) {
48
	duration, ok := input.(time.Duration)
49
	if ok {
50
		return duration, nil
51
	}
52

53
	value := reflect.ValueOf(input)
54
	kind := reflect.TypeOf(input).Kind()
55

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

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