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
|
package module
import (
"fmt"
"log"
"strings"
"tunnel/pkg/server/env"
"tunnel/pkg/server/opts"
"tunnel/pkg/server/queue"
)
type moduleInitFunc func(opts.Opts, env.Env) (module, error)
var modules = map[string]moduleInitFunc{}
type module interface {
Open(env env.Env) (interface{}, error)
}
type M interface {
module
String() string
}
type Sender interface {
Send(rq, wq queue.Q) error
}
type Recver interface {
Recv(rq, wq queue.Q) error
}
type Func func(rq, wq queue.Q) error
func (f Func) Send(rq, wq queue.Q) error {
return f(rq, wq)
}
func (f Func) Open(env env.Env) (interface{}, error) {
return f, nil
}
type wrapper struct {
module
name string
reverse bool
}
func (w *wrapper) String() string {
return fmt.Sprintf("module:%s", w.name)
}
func Open(m M, env env.Env) (Func, Func, error) {
var send, recv Func
w := m.(*wrapper)
it, err := m.Open(env)
if err != nil {
return nil, nil, err
}
if sender, ok := it.(Sender); ok {
send = sender.Send
}
if recver, ok := it.(Recver); ok {
recv = recver.Recv
}
if w.reverse {
send, recv = recv, send
}
return send, recv, nil
}
func New(desc string, env env.Env) (M, error) {
name, opts := opts.Parse(desc)
reverse := false
if strings.HasPrefix(name, "-") {
name = name[1:]
reverse = true
}
if f, ok := modules[name]; !ok {
return nil, fmt.Errorf("unknown module '%s'", name)
} else if m, err := f(opts, env); err != nil {
return nil, err
} else {
w := &wrapper{
module: m,
name: name,
reverse: reverse,
}
return w, nil
}
}
func register(name string, f moduleInitFunc) {
if _, ok := modules[name]; ok {
log.Panicf("duplicate module name '%s'", name)
}
modules[name] = f
}
func registerFunc(name string, p Func) {
register(name, func(opts.Opts, env.Env) (module, error) {
return p, nil
})
}
|
