fix by golint (#1822)

server/group/tcpmux.go

@@ -27,53 +27,54 @@ import (
 	gerr "github.com/fatedier/golib/errors"
 )
 
-// TcpMuxGroupCtl manage all TcpMuxGroups
-type TcpMuxGroupCtl struct {
-	groups map[string]*TcpMuxGroup
+// TCPMuxGroupCtl manage all TCPMuxGroups
+type TCPMuxGroupCtl struct {
+	groups map[string]*TCPMuxGroup
 
 	// portManager is used to manage port
-	tcpMuxHttpConnectMuxer *tcpmux.HttpConnectTcpMuxer
+	tcpMuxHTTPConnectMuxer *tcpmux.HTTPConnectTCPMuxer
 	mu                     sync.Mutex
 }
 
-// NewTcpMuxGroupCtl return a new TcpMuxGroupCtl
-func NewTcpMuxGroupCtl(tcpMuxHttpConnectMuxer *tcpmux.HttpConnectTcpMuxer) *TcpMuxGroupCtl {
-	return &TcpMuxGroupCtl{
-		groups:                 make(map[string]*TcpMuxGroup),
-		tcpMuxHttpConnectMuxer: tcpMuxHttpConnectMuxer,
+// NewTCPMuxGroupCtl return a new TCPMuxGroupCtl
+func NewTCPMuxGroupCtl(tcpMuxHTTPConnectMuxer *tcpmux.HTTPConnectTCPMuxer) *TCPMuxGroupCtl {
+	return &TCPMuxGroupCtl{
+		groups:                 make(map[string]*TCPMuxGroup),
+		tcpMuxHTTPConnectMuxer: tcpMuxHTTPConnectMuxer,
 	}
 }
 
-// Listen is the wrapper for TcpMuxGroup's Listen
+// Listen is the wrapper for TCPMuxGroup's Listen
 // If there are no group, we will create one here
-func (tmgc *TcpMuxGroupCtl) Listen(multiplexer string, group string, groupKey string,
-	domain string, ctx context.Context) (l net.Listener, err error) {
+func (tmgc *TCPMuxGroupCtl) Listen(ctx context.Context, multiplexer string, group string, groupKey string,
+	domain string) (l net.Listener, err error) {
+
 	tmgc.mu.Lock()
 	tcpMuxGroup, ok := tmgc.groups[group]
 	if !ok {
-		tcpMuxGroup = NewTcpMuxGroup(tmgc)
+		tcpMuxGroup = NewTCPMuxGroup(tmgc)
 		tmgc.groups[group] = tcpMuxGroup
 	}
 	tmgc.mu.Unlock()
 
 	switch multiplexer {
-	case consts.HttpConnectTcpMultiplexer:
-		return tcpMuxGroup.HttpConnectListen(group, groupKey, domain, ctx)
+	case consts.HTTPConnectTCPMultiplexer:
+		return tcpMuxGroup.HTTPConnectListen(ctx, group, groupKey, domain)
 	default:
 		err = fmt.Errorf("unknown multiplexer [%s]", multiplexer)
 		return
 	}
 }
 
-// RemoveGroup remove TcpMuxGroup from controller
-func (tmgc *TcpMuxGroupCtl) RemoveGroup(group string) {
+// RemoveGroup remove TCPMuxGroup from controller
+func (tmgc *TCPMuxGroupCtl) RemoveGroup(group string) {
 	tmgc.mu.Lock()
 	defer tmgc.mu.Unlock()
 	delete(tmgc.groups, group)
 }
 
-// TcpMuxGroup route connections to different proxies
-type TcpMuxGroup struct {
+// TCPMuxGroup route connections to different proxies
+type TCPMuxGroup struct {
 	group    string
 	groupKey string
 	domain   string
@@ -81,36 +82,36 @@ type TcpMuxGroup struct {
 	acceptCh chan net.Conn
 	index    uint64
 	tcpMuxLn net.Listener
-	lns      []*TcpMuxGroupListener
-	ctl      *TcpMuxGroupCtl
+	lns      []*TCPMuxGroupListener
+	ctl      *TCPMuxGroupCtl
 	mu       sync.Mutex
 }
 
-// NewTcpMuxGroup return a new TcpMuxGroup
-func NewTcpMuxGroup(ctl *TcpMuxGroupCtl) *TcpMuxGroup {
-	return &TcpMuxGroup{
-		lns:      make([]*TcpMuxGroupListener, 0),
+// NewTCPMuxGroup return a new TCPMuxGroup
+func NewTCPMuxGroup(ctl *TCPMuxGroupCtl) *TCPMuxGroup {
+	return &TCPMuxGroup{
+		lns:      make([]*TCPMuxGroupListener, 0),
 		ctl:      ctl,
 		acceptCh: make(chan net.Conn),
 	}
 }
 
-// Listen will return a new TcpMuxGroupListener
-// if TcpMuxGroup already has a listener, just add a new TcpMuxGroupListener to the queues
+// Listen will return a new TCPMuxGroupListener
+// if TCPMuxGroup already has a listener, just add a new TCPMuxGroupListener to the queues
 // otherwise, listen on the real address
-func (tmg *TcpMuxGroup) HttpConnectListen(group string, groupKey string, domain string, context context.Context) (ln *TcpMuxGroupListener, err error) {
+func (tmg *TCPMuxGroup) HTTPConnectListen(ctx context.Context, group string, groupKey string, domain string) (ln *TCPMuxGroupListener, err error) {
 	tmg.mu.Lock()
 	defer tmg.mu.Unlock()
 	if len(tmg.lns) == 0 {
 		// the first listener, listen on the real address
-		routeConfig := &vhost.VhostRouteConfig{
+		routeConfig := &vhost.RouteConfig{
 			Domain: domain,
 		}
-		tcpMuxLn, errRet := tmg.ctl.tcpMuxHttpConnectMuxer.Listen(context, routeConfig)
+		tcpMuxLn, errRet := tmg.ctl.tcpMuxHTTPConnectMuxer.Listen(ctx, routeConfig)
 		if errRet != nil {
 			return nil, errRet
 		}
-		ln = newTcpMuxGroupListener(group, tmg, tcpMuxLn.Addr())
+		ln = newTCPMuxGroupListener(group, tmg, tcpMuxLn.Addr())
 
 		tmg.group = group
 		tmg.groupKey = groupKey
@@ -129,14 +130,14 @@ func (tmg *TcpMuxGroup) HttpConnectListen(group string, groupKey string, domain
 		if tmg.groupKey != groupKey {
 			return nil, ErrGroupAuthFailed
 		}
-		ln = newTcpMuxGroupListener(group, tmg, tmg.lns[0].Addr())
+		ln = newTCPMuxGroupListener(group, tmg, tmg.lns[0].Addr())
 		tmg.lns = append(tmg.lns, ln)
 	}
 	return
 }
 
-// worker is called when the real tcp listener has been created
-func (tmg *TcpMuxGroup) worker() {
+// worker is called when the real TCP listener has been created
+func (tmg *TCPMuxGroup) worker() {
 	for {
 		c, err := tmg.tcpMuxLn.Accept()
 		if err != nil {
@@ -151,12 +152,12 @@ func (tmg *TcpMuxGroup) worker() {
 	}
 }
 
-func (tmg *TcpMuxGroup) Accept() <-chan net.Conn {
+func (tmg *TCPMuxGroup) Accept() <-chan net.Conn {
 	return tmg.acceptCh
 }
 
-// CloseListener remove the TcpMuxGroupListener from the TcpMuxGroup
-func (tmg *TcpMuxGroup) CloseListener(ln *TcpMuxGroupListener) {
+// CloseListener remove the TCPMuxGroupListener from the TCPMuxGroup
+func (tmg *TCPMuxGroup) CloseListener(ln *TCPMuxGroupListener) {
 	tmg.mu.Lock()
 	defer tmg.mu.Unlock()
 	for i, tmpLn := range tmg.lns {
@@ -172,17 +173,17 @@ func (tmg *TcpMuxGroup) CloseListener(ln *TcpMuxGroupListener) {
 	}
 }
 
-// TcpMuxGroupListener
-type TcpMuxGroupListener struct {
+// TCPMuxGroupListener
+type TCPMuxGroupListener struct {
 	groupName string
-	group     *TcpMuxGroup
+	group     *TCPMuxGroup
 
 	addr    net.Addr
 	closeCh chan struct{}
 }
 
-func newTcpMuxGroupListener(name string, group *TcpMuxGroup, addr net.Addr) *TcpMuxGroupListener {
-	return &TcpMuxGroupListener{
+func newTCPMuxGroupListener(name string, group *TCPMuxGroup, addr net.Addr) *TCPMuxGroupListener {
+	return &TCPMuxGroupListener{
 		groupName: name,
 		group:     group,
 		addr:      addr,
@@ -190,8 +191,8 @@ func newTcpMuxGroupListener(name string, group *TcpMuxGroup, addr net.Addr) *Tcp
 	}
 }
 
-// Accept will accept connections from TcpMuxGroup
-func (ln *TcpMuxGroupListener) Accept() (c net.Conn, err error) {
+// Accept will accept connections from TCPMuxGroup
+func (ln *TCPMuxGroupListener) Accept() (c net.Conn, err error) {
 	var ok bool
 	select {
 	case <-ln.closeCh:
@@ -204,12 +205,12 @@ func (ln *TcpMuxGroupListener) Accept() (c net.Conn, err error) {
 	}
 }
 
-func (ln *TcpMuxGroupListener) Addr() net.Addr {
+func (ln *TCPMuxGroupListener) Addr() net.Addr {
 	return ln.addr
 }
 
 // Close close the listener
-func (ln *TcpMuxGroupListener) Close() (err error) {
+func (ln *TCPMuxGroupListener) Close() (err error) {
 	close(ln.closeCh)
 
 	// remove self from TcpMuxGroup