-
-
Notifications
You must be signed in to change notification settings - Fork 307
/
simple.go
186 lines (160 loc) · 5.52 KB
/
simple.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
185
186
// Mgmt
// Copyright (C) 2013-2021+ James Shubin and the project contributors
// Written by James Shubin <james@shubin.ca> and the project contributors
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
package simple
import (
"fmt"
"github.com/purpleidea/mgmt/lang/funcs"
"github.com/purpleidea/mgmt/lang/interfaces"
"github.com/purpleidea/mgmt/lang/types"
"github.com/purpleidea/mgmt/util/errwrap"
)
const (
// DirectInterface specifies whether we should use the direct function
// API or not. If we don't use it, then these simple functions are
// wrapped with the struct below.
DirectInterface = false // XXX: fix any bugs and set to true!
)
// RegisteredFuncs maps a function name to the corresponding static, pure func.
var RegisteredFuncs = make(map[string]*types.FuncValue) // must initialize
// Register registers a simple, static, pure function. It is easier to use than
// the raw function API, but also limits you to simple, static, pure functions.
func Register(name string, fn *types.FuncValue) {
if _, exists := RegisteredFuncs[name]; exists {
panic(fmt.Sprintf("a simple func named %s is already registered", name))
}
if fn == nil {
panic(fmt.Sprintf("simple func %s contains no function body", name))
}
if fn.T == nil {
panic(fmt.Sprintf("simple func %s contains a nil type signature", name))
}
if fn.T.Kind != types.KindFunc {
panic(fmt.Sprintf("simple func %s must be of kind func", name))
}
if fn.T.HasVariant() {
panic(fmt.Sprintf("simple func %s contains a variant type signature", name))
}
RegisteredFuncs[name] = fn // store a copy for ourselves
// register a copy in the main function database
funcs.Register(name, func() interfaces.Func { return &WrappedFunc{Fn: fn} })
}
// ModuleRegister is exactly like Register, except that it registers within a
// named module. This is a helper function.
func ModuleRegister(module, name string, fn *types.FuncValue) {
Register(module+funcs.ModuleSep+name, fn)
}
// WrappedFunc is a scaffolding function struct which fulfills the boiler-plate
// for the function API, but that can run a very simple, static, pure function.
type WrappedFunc struct {
Fn *types.FuncValue
init *interfaces.Init
last types.Value // last value received to use for diff
result types.Value // last calculated output
closeChan chan struct{}
}
// ArgGen returns the Nth arg name for this function.
func (obj *WrappedFunc) ArgGen(index int) (string, error) {
typ := obj.Fn.Type()
if typ.Kind != types.KindFunc {
return "", fmt.Errorf("expected %s, got %s", types.KindFunc, typ.Kind)
}
seq := typ.Ord
if l := len(seq); index >= l {
return "", fmt.Errorf("index %d exceeds arg length of %d", index, l)
}
return seq[index], nil
}
// Validate makes sure we've built our struct properly. It is usually unused for
// normal functions that users can use directly.
func (obj *WrappedFunc) Validate() error {
if obj.Fn == nil { // build must be run first
return fmt.Errorf("type is still unspecified")
}
return nil
}
// Info returns some static info about itself.
func (obj *WrappedFunc) Info() *interfaces.Info {
var typ *types.Type
if obj.Fn != nil { // don't panic if called speculatively
typ = obj.Fn.Type()
}
return &interfaces.Info{
Pure: true,
Memo: false, // TODO: should this be something we specify here?
Sig: typ,
Err: obj.Validate(),
}
}
// Init runs some startup code for this function.
func (obj *WrappedFunc) Init(init *interfaces.Init) error {
obj.init = init
obj.closeChan = make(chan struct{})
return nil
}
// Stream returns the changing values that this func has over time.
func (obj *WrappedFunc) Stream() error {
defer close(obj.init.Output) // the sender closes
for {
select {
case input, ok := <-obj.init.Input:
if !ok {
if len(obj.Fn.Type().Ord) > 0 {
return nil // can't output any more
}
// no inputs were expected, pass through once
}
if ok {
//if err := input.Type().Cmp(obj.Info().Sig.Input); err != nil {
// return errwrap.Wrapf(err, "wrong function input")
//}
if obj.last != nil && input.Cmp(obj.last) == nil {
continue // value didn't change, skip it
}
obj.last = input // store for next
}
values := []types.Value{}
for _, name := range obj.Fn.Type().Ord {
x := input.Struct()[name]
values = append(values, x)
}
result, err := obj.Fn.Call(values) // (Value, error)
if err != nil {
return errwrap.Wrapf(err, "simple function errored")
}
// TODO: do we want obj.result to be a pointer instead?
if obj.result == result {
continue // result didn't change
}
obj.result = result // store new result
case <-obj.closeChan:
return nil
}
select {
case obj.init.Output <- obj.result: // send
if len(obj.Fn.Type().Ord) == 0 {
return nil // no more values, we're a pure func
}
case <-obj.closeChan:
return nil
}
}
}
// Close runs some shutdown code for this function and turns off the stream.
func (obj *WrappedFunc) Close() error {
close(obj.closeChan)
return nil
}