/
factory.go
144 lines (131 loc) · 3.1 KB
/
factory.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
package object
import (
"errors"
"fmt"
"github.com/opensvc/om3/core/naming"
"github.com/opensvc/om3/util/funcopt"
"github.com/opensvc/om3/util/plog"
)
// WithConfigFile sets a non-standard configuration location.
func WithConfigFile(s string) funcopt.O {
return funcopt.F(func(t any) error {
o := t.(*core)
o.configFile = s
return nil
})
}
// WithConfigData sets configuration overriding what is installed in the config file
// Useful for testing volatile services.
func WithConfigData(b any) funcopt.O {
return funcopt.F(func(t any) error {
o := t.(*core)
o.configData = b
return nil
})
}
// WithVolatile makes sure not data is ever written by the object.
func WithVolatile(s bool) funcopt.O {
return funcopt.F(func(t any) error {
o := t.(volatiler)
o.SetVolatile(s)
return nil
})
}
// WithLogger let the factory user decide what kind of logging he wants
func WithLogger(s *plog.Logger) funcopt.O {
return funcopt.F(func(t any) error {
switch o := t.(type) {
case *core:
o.log = s
case *Node:
o.log = s
}
return nil
})
}
func NewList(paths naming.Paths, opts ...funcopt.O) ([]any, error) {
var errs error
l := make([]any, 0)
for _, p := range paths {
if obj, err := New(p, opts...); err != nil {
errors.Join(errs, err)
} else {
l = append(l, obj)
}
}
return l, errs
}
func toPathType(id any) (naming.Path, error) {
var p naming.Path
switch i := id.(type) {
case string:
if parsed, err := naming.ParsePath(i); err != nil {
return p, err
} else {
p = parsed
}
return p, nil
case naming.Path:
p = i
return p, nil
default:
return p, fmt.Errorf("unsupported object path type: %#v", i)
}
}
// New allocates a new kinded object
func New(id any, opts ...funcopt.O) (any, error) {
var p naming.Path
if parsed, err := toPathType(id); err != nil {
return nil, err
} else {
p = parsed
}
switch p.Kind {
case naming.KindSvc:
return NewSvc(p, opts...)
case naming.KindVol:
return NewVol(p, opts...)
case naming.KindCfg:
return NewCfg(p, opts...)
case naming.KindSec:
return NewSec(p, opts...)
case naming.KindUsr:
return NewUsr(p, opts...)
case naming.KindCcfg:
return newCcfg(p, opts...)
default:
return nil, fmt.Errorf("unsupported kind: %s", p.Kind)
}
}
// NewCore returns a Core interface from an object path
func NewCore(p any, opts ...funcopt.O) (Core, error) {
if o, err := New(p, opts...); err != nil {
return nil, err
} else {
return o.(Core), nil
}
}
// NewConfigurer returns a Configurer interface from an object path
func NewConfigurer(p any, opts ...funcopt.O) (Configurer, error) {
if o, err := New(p, opts...); err != nil {
return nil, err
} else {
return o.(Configurer), nil
}
}
// NewActor returns a Actor interface from an object path
func NewActor(p any, opts ...funcopt.O) (Actor, error) {
if o, err := New(p, opts...); err != nil {
return nil, err
} else {
return o.(Actor), nil
}
}
// NewKeystore returns a Keystore interface from an object path
func NewKeystore(p any, opts ...funcopt.O) (Keystore, error) {
if o, err := New(p, opts...); err != nil {
return nil, err
} else {
return o.(Keystore), nil
}
}