-
Notifications
You must be signed in to change notification settings - Fork 3
/
usergenerator.go
184 lines (154 loc) · 4.4 KB
/
usergenerator.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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
package users
import (
"fmt"
"github.com/goccy/go-json"
"github.com/pkg/errors"
"github.com/qlik-oss/gopherciser/enummap"
"github.com/qlik-oss/gopherciser/statistics"
)
type (
// Type type of scheduler
Type int
// Settings interface to be implemented by user generator
Settings interface {
Iterate(iteration uint64) *User
Validate() error
}
GeneratorCore struct {
GeneratorType Type `json:"type" displayname:"User generator type" doc-key:"config.loginSettings.type"`
}
generatorTmp struct {
GeneratorCore
Settings json.RawMessage `json:"settings"`
}
// UserGenerator of users
UserGenerator struct {
GeneratorCore
Settings Settings `json:"settings" doc-key:"config.loginSettings.settings"`
}
)
const (
// UserGeneratorUnknown unknown user generator
UserGeneratorUnknown Type = iota
// UserGeneratorCircular users according to userlist
UserGeneratorCircular
// UserGeneratorPrefix users with a prefix and an enumeration
UserGeneratorPrefix
// UserGeneratorNone no user creation
UserGeneratorNone
// UserGeneratorCircularFile userlist read from file
UserGeneratorCircularFile
)
var (
userGeneratorTypeEnumMap = enummap.NewEnumMapOrPanic(map[string]int{
"userlist": int(UserGeneratorCircular),
"prefix": int(UserGeneratorPrefix),
"none": int(UserGeneratorNone),
"fromfile": int(UserGeneratorCircularFile),
})
)
func (value Type) GetEnumMap() *enummap.EnumMap {
return userGeneratorTypeEnumMap
}
// String implements stringer interface
func (value Type) String() string {
return userGeneratorTypeEnumMap.StringDefault(int(value), fmt.Sprintf("%d", value))
}
func UserGenHandler(generator Type) interface{} {
switch generator {
case UserGeneratorUnknown:
return nil
case UserGeneratorCircular:
return NewCircularUsers()
case UserGeneratorPrefix:
return &PrefixUsers{}
case UserGeneratorCircularFile:
return NewCircularUsersFromFile()
case UserGeneratorNone:
return &NoneUsers{}
default:
return nil
}
}
// NewUserGeneratorCircular create new circular user generator
func NewUserGeneratorCircular(users []*User) UserGenerator {
circularUsers := NewCircularUsers()
circularUsers.UserList = users
uGen := UserGenerator{
GeneratorCore{
GeneratorType: UserGeneratorCircular,
},
circularUsers,
}
return uGen
}
// NewUserGeneratorPrefix create new prefix user generator
func NewUserGeneratorPrefix(prefix string) UserGenerator {
return UserGenerator{
GeneratorCore{
GeneratorType: UserGeneratorPrefix,
},
&PrefixUsers{
Prefix: prefix,
},
}
}
// NewUserGeneratorNone create new "none" user generator (to be used with e.g. Qlik Core)
func NewUserGeneratorNone() UserGenerator {
return UserGenerator{
GeneratorCore{
GeneratorType: UserGeneratorNone,
},
&NoneUsers{},
}
}
// UnmarshalJSON unmarshal user generator type from json
func (value *Type) UnmarshalJSON(arg []byte) error {
i, err := value.GetEnumMap().UnMarshal(arg)
if err != nil {
return errors.Wrap(err, "Failed to unmarshal Type")
}
*value = Type(i)
return nil
}
// MarshalJSON marshal scheduler type to json
func (value Type) MarshalJSON() ([]byte, error) {
str, err := (*value.GetEnumMap()).String(int(value))
if err != nil {
return nil, errors.Wrap(err, "Failed to get user generator type")
}
if str == "" {
return nil, errors.Errorf("Unknown user generator type<%v>", value)
}
return []byte(fmt.Sprintf(`"%s"`, str)), nil
}
// UnmarshalJSON unmarshal scheduler from json
func (value *UserGenerator) UnmarshalJSON(arg []byte) error {
var gen generatorTmp
if err := json.Unmarshal(arg, &gen); err != nil {
return errors.Wrap(err, "Failed to unmarshal user generator")
}
(*value).GeneratorType = gen.GeneratorType
settings := UserGenHandler(gen.GeneratorType)
if gen.GeneratorType == UserGeneratorNone {
// Allow UserGenerator with no Settings for UserGeneratorNone type
(*value).Settings = settings.(Settings)
return nil
}
if err := json.Unmarshal(gen.Settings, &settings); err != nil {
return errors.Wrap(err, "Failed to unmarshal user generator settings")
}
if settings == nil {
return errors.Errorf("Invalid user generator type")
}
var ok bool
(*value).Settings, ok = settings.(Settings)
if !ok {
return errors.Errorf("Settings not of type Settings (%d)", gen.GeneratorType)
}
return nil
}
// GetNext user to simulate
func (value *UserGenerator) GetNext(counters *statistics.ExecutionCounters) *User {
return value.Settings.Iterate(counters.Users.Inc())
}