forked from pierrre/imageserver
/
server.go
69 lines (58 loc) · 1.53 KB
/
server.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
// Package imageserver provides an Image server toolkit.
package imageserver
// Server represents an Image server
type Server interface {
Get(Params) (*Image, error)
}
// ServerFunc is a Server func.
type ServerFunc func(params Params) (*Image, error)
// Get implements Server.
func (f ServerFunc) Get(params Params) (*Image, error) {
return f(params)
}
// SourceParam is the source Param name.
const SourceParam = "source"
// SourceServer is a source Server.
//
// It forwards to the underlying Server with only the source param.
type SourceServer struct {
Server
}
// Get implements Server.
func (s *SourceServer) Get(params Params) (*Image, error) {
source, err := params.Get(SourceParam)
if err != nil {
return nil, err
}
params = Params{SourceParam: source}
return s.Server.Get(params)
}
// NewLimitServer creates a new Server that limits the number of concurrent executions.
//
// It uses a buffered channel to limit the number of concurrent executions.
func NewLimitServer(s Server, limit int) Server {
return &limitServer{
Server: s,
limitCh: make(chan struct{}, limit),
}
}
type limitServer struct {
Server
limitCh chan struct{}
}
func (s *limitServer) Get(params Params) (*Image, error) {
s.limitCh <- struct{}{}
defer func() {
<-s.limitCh
}()
return s.Server.Get(params)
}
// StaticServer is an Image Server that always returns the same Image and error.
type StaticServer struct {
Image *Image
Error error
}
// Get implements Server.
func (s *StaticServer) Get(params Params) (*Image, error) {
return s.Image, s.Error
}