-
Notifications
You must be signed in to change notification settings - Fork 20
/
context.go
161 lines (128 loc) · 3.22 KB
/
context.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
// Copyright (c) 2018 DDN. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package harness
import (
"bytes"
"fmt"
"io/ioutil"
"os"
"sync"
"github.com/intel-hpdd/logging/debug"
)
type (
cleanupFn func() error
kvmap map[string]string
// ScenarioContext holds per-scenario context. It should be unique for
// each scenario, in order to avoid leaking state between scenarios.
ScenarioContext struct {
sync.Mutex
HsmDriver HsmDriver
AgentDriver *AgentDriver
Config *Config
TestFiles map[string]*TestFile
// These are per-scenario, unless otherwise configured
S3Bucket string
S3Prefix string
cleanupFunctions []cleanupFn
workdir string
kv kvmap
failed bool
setup *sync.Once
}
multiError []error
)
func (m multiError) Error() string {
var buf bytes.Buffer
fmt.Fprintf(&buf, "Error(s):\n")
for _, err := range m {
fmt.Fprintf(&buf, " %s", err)
}
return buf.String()
}
// Fail marks the scenario as failed
func (s *ScenarioContext) Fail() {
s.Lock()
defer s.Unlock()
s.failed = true
}
// Failed returns the protected value
func (s *ScenarioContext) Failed() bool {
s.Lock()
defer s.Unlock()
return s.failed
}
// SetKey inserts or updates a value for a given key
func (s *ScenarioContext) SetKey(key, value string) {
s.Lock()
defer s.Unlock()
s.kv[key] = value
}
// GetKey attempts to get the value associated with key, or fails
func (s *ScenarioContext) GetKey(key string) (string, error) {
s.Lock()
defer s.Unlock()
val, ok := s.kv[key]
if !ok {
return "", fmt.Errorf("No value for key %s found", key)
}
return val, nil
}
func (s *ScenarioContext) createWorkdir() {
var err error
s.workdir, err = ioutil.TempDir("", "lhsmd-uat")
if err != nil {
panic(fmt.Errorf("failed to create workdir: %s", err))
}
/*
testDirs := []string{"/etc/lhsmd", "/archives/1"}
for _, td := range testDirs {
if err := os.MkdirAll(wd+td, 0755); err != nil {
panic(fmt.Errorf("failed to mkdir %s: %s", wd+td, err))
}
}
*/
s.AddCleanup(func() error {
debug.Printf("Cleaning up %s", s.workdir)
return os.RemoveAll(s.workdir)
})
}
// Workdir returns the path to the context's working directory, which
// is created as a tempdir.
func (s *ScenarioContext) Workdir() string {
s.setup.Do(func() {
s.createWorkdir()
})
return s.workdir
}
// Cleanup runs all cleanup functions, and returns an error if any of them fail
func (s *ScenarioContext) Cleanup() error {
var errors multiError
for _, fn := range s.cleanupFunctions {
if err := fn(); err != nil {
errors = append(errors, err)
}
}
if len(errors) > 0 {
return errors
}
return nil
}
// AddCleanup registers a cleanup handler
func (s *ScenarioContext) AddCleanup(fn cleanupFn) {
s.cleanupFunctions = append(s.cleanupFunctions, fn)
}
// NewScenarioContext returns a freshly-initialized *ScenarioContext
func NewScenarioContext(cfg *Config) *ScenarioContext {
hsmDriver, err := getHsmDriver(cfg)
if err != nil {
panic("Unable to find a suitable HSM driver")
}
return &ScenarioContext{
Config: cfg,
HsmDriver: hsmDriver,
TestFiles: make(map[string]*TestFile),
kv: make(kvmap),
setup: &sync.Once{},
}
}