-
Notifications
You must be signed in to change notification settings - Fork 2
/
registry.go
95 lines (79 loc) · 1.92 KB
/
registry.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
package server
import (
"fmt"
"reflect"
"strings"
"sync"
)
// registry keeps track of endpoints we have registered
type registry struct {
sync.RWMutex
endpoints map[string]*Endpoint
middleware []Middleware
}
// newRegistry mints a new registry
func newRegistry() *registry {
return ®istry{
endpoints: make(map[string]*Endpoint, 5),
middleware: make([]Middleware, 0, 5),
}
}
// add will add an endpoint and enforce some basic laws, like lowercase names, and some Authoriser
func (r *registry) add(ep *Endpoint) (err error) {
if len(ep.Name) == 0 {
err = fmt.Errorf("Missing name in endpoint: %+v", ep)
return
}
lowerName := strings.ToLower(ep.Name)
if lowerName != ep.Name {
err = fmt.Errorf("Endpoint name should be lowercase: %+v", ep)
return
}
// add a default Authoriser, if none
if ep.Authoriser == nil || reflect.ValueOf(ep.Authoriser).IsNil() {
ep.Authoriser = DefaultAuthoriser
}
// Apply any registered middleware
h := ep.Handler
for _, m := range r.middleware {
h = m(ep, h)
}
ep.Handler = h
r.Lock()
defer r.Unlock()
r.endpoints[ep.Name] = ep
return
}
// add will add a middleware, these will be applied to any endpoints registered
// after this call
func (r *registry) addMiddleware(mw Middleware) (err error) {
r.Lock()
defer r.Unlock()
r.middleware = append(r.middleware, mw)
return
}
// find will find an endpoint by name from within the registry
func (r *registry) find(epName string) (ep *Endpoint, ok bool) {
r.RLock()
defer r.RUnlock()
ep, ok = r.endpoints[epName]
return
}
// iterate locks, copies and returns a snapshot of registered endpoints
func (r *registry) iterate() []*Endpoint {
r.RLock()
defer r.RUnlock()
ret := make([]*Endpoint, len(r.endpoints))
i := 0
for _, ep := range r.endpoints {
ret[i] = ep
i++
}
return ret
}
// size counts up how many registered endpoints
func (r *registry) size() int {
r.RLock()
defer r.RUnlock()
return len(r.endpoints)
}