[server] prepare module.Open to return error

1 files changed, 62 insertions, 26 deletions

diff --git a/pkg/server/module/module.go b/pkg/server/module/module.go
index 69fb90b..3df6eb5 100644
--- a/pkg/server/module/module.go
+++ b/pkg/server/module/module.go
@@ -3,6 +3,7 @@ package module
 import (
 	"fmt"
 	"log"
+	"strings"
 	"tunnel/pkg/server/env"
 	"tunnel/pkg/server/opts"
 	"tunnel/pkg/server/queue"
@@ -13,7 +14,7 @@ type moduleInitFunc func(opts.Opts, env.Env) (module, error)
 var modules = map[string]moduleInitFunc{}
 
 type module interface {
-	Open(env env.Env) (Pipe, Pipe)
+	Open(env env.Env) (interface{}, error)
 }
 
 type M interface {
@@ -21,57 +22,92 @@ type M interface {
 	String() string
 }
 
-type Pipe func(rq, wq queue.Q) error
-
-func (p Pipe) Open(env env.Env) (Pipe, Pipe) {
-	return p, nil
+type Sender interface {
+	Send(rq, wq queue.Q) error
 }
 
-type reverse struct {
-	M
+type Recver interface {
+	Recv(rq, wq queue.Q) error
 }
 
-func Reverse(m M) M {
-	return &reverse{m}
+type Func func(rq, wq queue.Q) error
+
+func (f Func) Send(rq, wq queue.Q) error {
+	return f(rq, wq)
 }
 
-func (r *reverse) Open(env env.Env) (Pipe, Pipe) {
-	p1, p2 := r.M.Open(env)
-	return p2, p1
+func (f Func) Open(env env.Env) (interface{}, error) {
+	return f, nil
 }
 
-type named struct {
-	name string
+type wrapper struct {
 	module
+	name    string
+	reverse bool
 }
 
-func (m *named) String() string {
-	return fmt.Sprintf("module:%s", m.name)
+func (w *wrapper) String() string {
+	return fmt.Sprintf("module:%s", w.name)
 }
 
-func register(name string, f moduleInitFunc) {
-	if _, ok := modules[name]; ok {
-		log.Panicf("duplicate module name '%s'", 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
 	}
 
-	modules[name] = f
-}
+	if sender, ok := it.(Sender); ok {
+		send = sender.Send
+	}
 
-func registerPipe(name string, p Pipe) {
-	register(name, func(opts.Opts, env.Env) (module, error) {
-		return p, nil
-	})
+	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 {
-		return &named{name: name, module: m}, nil
+		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
+	})
 }