-
Notifications
You must be signed in to change notification settings - Fork 109
/
collectors.go
150 lines (135 loc) · 4.62 KB
/
collectors.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
package powersensor
import (
"context"
"errors"
v1 "go.viam.com/api/common/v1"
pb "go.viam.com/api/component/powersensor/v1"
"google.golang.org/protobuf/types/known/anypb"
"go.viam.com/rdk/data"
"go.viam.com/rdk/protoutils"
)
type method int64
const (
voltage method = iota
current
power
readings
)
func (m method) String() string {
switch m {
case voltage:
return "Voltage"
case current:
return "Current"
case power:
return "Power"
case readings:
return "Readings"
}
return "Unknown"
}
func assertPowerSensor(resource interface{}) (PowerSensor, error) {
ps, ok := resource.(PowerSensor)
if !ok {
return nil, data.InvalidInterfaceErr(API)
}
return ps, nil
}
// newVoltageCollector returns a collector to register a voltage method. If one is already registered
// with the same MethodMetadata it will panic.
func newVoltageCollector(resource interface{}, params data.CollectorParams) (data.Collector, error) {
ps, err := assertPowerSensor(resource)
if err != nil {
return nil, err
}
cFunc := data.CaptureFunc(func(ctx context.Context, extra map[string]*anypb.Any) (interface{}, error) {
volts, isAc, err := ps.Voltage(ctx, data.FromDMExtraMap)
if err != nil {
// A modular filter component can be created to filter the readings from a component. The error ErrNoCaptureToStore
// is used in the datamanager to exclude readings from being captured and stored.
if errors.Is(err, data.ErrNoCaptureToStore) {
return nil, err
}
return nil, data.FailedToReadErr(params.ComponentName, voltage.String(), err)
}
return pb.GetVoltageResponse{
Volts: volts,
IsAc: isAc,
}, nil
})
return data.NewCollector(cFunc, params)
}
// newCurrentCollector returns a collector to register a current method. If one is already registered
// with the same MethodMetadata it will panic.
func newCurrentCollector(resource interface{}, params data.CollectorParams) (data.Collector, error) {
ps, err := assertPowerSensor(resource)
if err != nil {
return nil, err
}
cFunc := data.CaptureFunc(func(ctx context.Context, extra map[string]*anypb.Any) (interface{}, error) {
curr, isAc, err := ps.Current(ctx, data.FromDMExtraMap)
if err != nil {
// A modular filter component can be created to filter the readings from a component. The error ErrNoCaptureToStore
// is used in the datamanager to exclude readings from being captured and stored.
if errors.Is(err, data.ErrNoCaptureToStore) {
return nil, err
}
return nil, data.FailedToReadErr(params.ComponentName, current.String(), err)
}
return pb.GetCurrentResponse{
Amperes: curr,
IsAc: isAc,
}, nil
})
return data.NewCollector(cFunc, params)
}
// newPowerCollector returns a collector to register a power method. If one is already registered
// with the same MethodMetadata it will panic.
func newPowerCollector(resource interface{}, params data.CollectorParams) (data.Collector, error) {
ps, err := assertPowerSensor(resource)
if err != nil {
return nil, err
}
cFunc := data.CaptureFunc(func(ctx context.Context, extra map[string]*anypb.Any) (interface{}, error) {
pwr, err := ps.Power(ctx, data.FromDMExtraMap)
if err != nil {
// A modular filter component can be created to filter the readings from a component. The error ErrNoCaptureToStore
// is used in the datamanager to exclude readings from being captured and stored.
if errors.Is(err, data.ErrNoCaptureToStore) {
return nil, err
}
return nil, data.FailedToReadErr(params.ComponentName, power.String(), err)
}
return pb.GetPowerResponse{
Watts: pwr,
}, nil
})
return data.NewCollector(cFunc, params)
}
// newReadingsCollector returns a collector to register a readings method. If one is already registered
// with the same MethodMetadata it will panic.
func newReadingsCollector(resource interface{}, params data.CollectorParams) (data.Collector, error) {
ps, err := assertPowerSensor(resource)
if err != nil {
return nil, err
}
cFunc := data.CaptureFunc(func(ctx context.Context, arg map[string]*anypb.Any) (interface{}, error) {
values, err := ps.Readings(ctx, data.FromDMExtraMap)
if err != nil {
// A modular filter component can be created to filter the readings from a component. The error ErrNoCaptureToStore
// is used in the datamanager to exclude readings from being captured and stored.
if errors.Is(err, data.ErrNoCaptureToStore) {
return nil, err
}
return nil, data.FailedToReadErr(params.ComponentName, readings.String(), err)
}
readings, err := protoutils.ReadingGoToProto(values)
if err != nil {
return nil, err
}
return v1.GetReadingsResponse{
Readings: readings,
}, nil
})
return data.NewCollector(cFunc, params)
}