fix by golint (#1822)

2026-01-11 22:23:12 +00:00 · 2020-05-24 17:48:37 +08:00
parent 2170c481ce
commit 8b75b8b837
80 changed files with 1315 additions and 1324 deletions
--- a/utils/vhost/http.go
+++ b/utils/vhost/http.go
@@ -35,30 +35,30 @@ var (
 	ErrNoDomain = errors.New("no such domain")
 )

-type HttpReverseProxyOptions struct {
+type HTTPReverseProxyOptions struct {
 	ResponseHeaderTimeoutS int64
 }

-type HttpReverseProxy struct {
+type HTTPReverseProxy struct {
 	proxy       *ReverseProxy
-	vhostRouter *VhostRouters
+	vhostRouter *Routers

 	responseHeaderTimeout time.Duration
 }

-func NewHttpReverseProxy(option HttpReverseProxyOptions, vhostRouter *VhostRouters) *HttpReverseProxy {
+func NewHTTPReverseProxy(option HTTPReverseProxyOptions, vhostRouter *Routers) *HTTPReverseProxy {
 	if option.ResponseHeaderTimeoutS <= 0 {
 		option.ResponseHeaderTimeoutS = 60
 	}
-	rp := &HttpReverseProxy{
+	rp := &HTTPReverseProxy{
 		responseHeaderTimeout: time.Duration(option.ResponseHeaderTimeoutS) * time.Second,
 		vhostRouter:           vhostRouter,
 	}
 	proxy := &ReverseProxy{
 		Director: func(req *http.Request) {
 			req.URL.Scheme = "http"
-			url := req.Context().Value("url").(string)
-			oldHost := util.GetHostFromAddr(req.Context().Value("host").(string))
+			url := req.Context().Value(RouteInfoURL).(string)
+			oldHost := util.GetHostFromAddr(req.Context().Value(RouteInfoHost).(string))
 			host := rp.GetRealHost(oldHost, url)
 			if host != "" {
 				req.Host = host
@@ -74,9 +74,9 @@ func NewHttpReverseProxy(option HttpReverseProxyOptions, vhostRouter *VhostRoute
 			ResponseHeaderTimeout: rp.responseHeaderTimeout,
 			DisableKeepAlives:     true,
 			DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
-				url := ctx.Value("url").(string)
-				host := util.GetHostFromAddr(ctx.Value("host").(string))
-				remote := ctx.Value("remote").(string)
+				url := ctx.Value(RouteInfoURL).(string)
+				host := util.GetHostFromAddr(ctx.Value(RouteInfoHost).(string))
+				remote := ctx.Value(RouteInfoRemote).(string)
 				return rp.CreateConnection(host, url, remote)
 			},
 		},
@@ -94,7 +94,7 @@ func NewHttpReverseProxy(option HttpReverseProxyOptions, vhostRouter *VhostRoute

 // Register register the route config to reverse proxy
 // reverse proxy will use CreateConnFn from routeCfg to create a connection to the remote service
-func (rp *HttpReverseProxy) Register(routeCfg VhostRouteConfig) error {
+func (rp *HTTPReverseProxy) Register(routeCfg RouteConfig) error {
 	err := rp.vhostRouter.Add(routeCfg.Domain, routeCfg.Location, &routeCfg)
 	if err != nil {
 		return err
@@ -103,31 +103,31 @@ func (rp *HttpReverseProxy) Register(routeCfg VhostRouteConfig) error {
 }

 // UnRegister unregister route config by domain and location
-func (rp *HttpReverseProxy) UnRegister(domain string, location string) {
+func (rp *HTTPReverseProxy) UnRegister(domain string, location string) {
 	rp.vhostRouter.Del(domain, location)
 }

-func (rp *HttpReverseProxy) GetRealHost(domain string, location string) (host string) {
+func (rp *HTTPReverseProxy) GetRealHost(domain string, location string) (host string) {
 	vr, ok := rp.getVhost(domain, location)
 	if ok {
-		host = vr.payload.(*VhostRouteConfig).RewriteHost
+		host = vr.payload.(*RouteConfig).RewriteHost
 	}
 	return
 }

-func (rp *HttpReverseProxy) GetHeaders(domain string, location string) (headers map[string]string) {
+func (rp *HTTPReverseProxy) GetHeaders(domain string, location string) (headers map[string]string) {
 	vr, ok := rp.getVhost(domain, location)
 	if ok {
-		headers = vr.payload.(*VhostRouteConfig).Headers
+		headers = vr.payload.(*RouteConfig).Headers
 	}
 	return
 }

 // CreateConnection create a new connection by route config
-func (rp *HttpReverseProxy) CreateConnection(domain string, location string, remoteAddr string) (net.Conn, error) {
+func (rp *HTTPReverseProxy) CreateConnection(domain string, location string, remoteAddr string) (net.Conn, error) {
 	vr, ok := rp.getVhost(domain, location)
 	if ok {
-		fn := vr.payload.(*VhostRouteConfig).CreateConnFn
+		fn := vr.payload.(*RouteConfig).CreateConnFn
 		if fn != nil {
 			return fn(remoteAddr)
 		}
@@ -135,11 +135,11 @@ func (rp *HttpReverseProxy) CreateConnection(domain string, location string, rem
 	return nil, fmt.Errorf("%v: %s %s", ErrNoDomain, domain, location)
 }

-func (rp *HttpReverseProxy) CheckAuth(domain, location, user, passwd string) bool {
+func (rp *HTTPReverseProxy) CheckAuth(domain, location, user, passwd string) bool {
 	vr, ok := rp.getVhost(domain, location)
 	if ok {
-		checkUser := vr.payload.(*VhostRouteConfig).Username
-		checkPasswd := vr.payload.(*VhostRouteConfig).Password
+		checkUser := vr.payload.(*RouteConfig).Username
+		checkPasswd := vr.payload.(*RouteConfig).Password
 		if (checkUser != "" || checkPasswd != "") && (checkUser != user || checkPasswd != passwd) {
 			return false
 		}
@@ -148,7 +148,7 @@ func (rp *HttpReverseProxy) CheckAuth(domain, location, user, passwd string) boo
 }

 // getVhost get vhost router by domain and location
-func (rp *HttpReverseProxy) getVhost(domain string, location string) (vr *VhostRouter, ok bool) {
+func (rp *HTTPReverseProxy) getVhost(domain string, location string) (vr *Router, ok bool) {
 	// first we check the full hostname
 	// if not exist, then check the wildcard_domain such as *.example.com
 	vr, ok = rp.vhostRouter.Get(domain, location)
@@ -176,7 +176,7 @@ func (rp *HttpReverseProxy) getVhost(domain string, location string) (vr *VhostR
 	}
 }

-func (rp *HttpReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
+func (rp *HTTPReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 	domain := util.GetHostFromAddr(req.Host)
 	location := req.URL.Path
 	user, passwd, _ := req.BasicAuth()
--- a/utils/vhost/https.go
+++ b/utils/vhost/https.go
@@ -43,13 +43,13 @@ const (
 	extensionRenegotiationInfo   uint16 = 0xff01
 )

-type HttpsMuxer struct {
-	*VhostMuxer
+type HTTPSMuxer struct {
+	*Muxer
 }

-func NewHttpsMuxer(listener net.Listener, timeout time.Duration) (*HttpsMuxer, error) {
-	mux, err := NewVhostMuxer(listener, GetHttpsHostname, nil, nil, nil, timeout)
-	return &HttpsMuxer{mux}, err
+func NewHTTPSMuxer(listener net.Listener, timeout time.Duration) (*HTTPSMuxer, error) {
+	mux, err := NewMuxer(listener, GetHTTPSHostname, nil, nil, nil, timeout)
+	return &HTTPSMuxer{mux}, err
 }

 func readHandshake(rd io.Reader) (host string, err error) {
@@ -65,9 +65,8 @@ func readHandshake(rd io.Reader) (host string, err error) {
 	length, err := rd.Read(data[47:])
 	if err != nil {
 		return
-	} else {
-		length += 47
 	}
+	length += 47
 	data = data[:length]
 	if uint8(data[5]) != typeClientHello {
 		err = fmt.Errorf("readHandshake: type[%d] is not clientHello", uint16(data[5]))
@@ -75,12 +74,12 @@ func readHandshake(rd io.Reader) (host string, err error) {
 	}

 	// session
-	sessionIdLen := int(data[43])
-	if sessionIdLen > 32 || len(data) < 44+sessionIdLen {
-		err = fmt.Errorf("readHandshake: sessionIdLen[%d] is long", sessionIdLen)
+	sessionIDLen := int(data[43])
+	if sessionIDLen > 32 || len(data) < 44+sessionIDLen {
+		err = fmt.Errorf("readHandshake: sessionIdLen[%d] is long", sessionIDLen)
 		return
 	}
-	data = data[44+sessionIdLen:]
+	data = data[44+sessionIDLen:]
 	if len(data) < 2 {
 		err = fmt.Errorf("readHandshake: dataLen[%d] after session is short", len(data))
 		return
@@ -181,7 +180,7 @@ func readHandshake(rd io.Reader) (host string, err error) {
 	return
 }

-func GetHttpsHostname(c net.Conn) (_ net.Conn, _ map[string]string, err error) {
+func GetHTTPSHostname(c net.Conn) (_ net.Conn, _ map[string]string, err error) {
 	reqInfoMap := make(map[string]string, 0)
 	sc, rd := gnet.NewSharedConn(c)
 	host, err := readHandshake(rd)
--- a/utils/vhost/reverseproxy.go
+++ b/utils/vhost/reverseproxy.go
@@ -202,9 +202,9 @@ func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {

 	// =============================
 	// Modified for frp
-	outreq = outreq.WithContext(context.WithValue(outreq.Context(), "url", req.URL.Path))
-	outreq = outreq.WithContext(context.WithValue(outreq.Context(), "host", req.Host))
-	outreq = outreq.WithContext(context.WithValue(outreq.Context(), "remote", req.RemoteAddr))
+	outreq = outreq.WithContext(context.WithValue(outreq.Context(), RouteInfoURL, req.URL.Path))
+	outreq = outreq.WithContext(context.WithValue(outreq.Context(), RouteInfoHost, req.Host))
+	outreq = outreq.WithContext(context.WithValue(outreq.Context(), RouteInfoRemote, req.RemoteAddr))
 	// =============================

 	p.Director(outreq)
--- a/utils/vhost/router.go
+++ b/utils/vhost/router.go
@@ -11,25 +11,25 @@ var (
 	ErrRouterConfigConflict = errors.New("router config conflict")
 )

-type VhostRouters struct {
-	RouterByDomain map[string][]*VhostRouter
+type Routers struct {
+	RouterByDomain map[string][]*Router
 	mutex          sync.RWMutex
 }

-type VhostRouter struct {
+type Router struct {
 	domain   string
 	location string

 	payload interface{}
 }

-func NewVhostRouters() *VhostRouters {
-	return &VhostRouters{
-		RouterByDomain: make(map[string][]*VhostRouter),
+func NewRouters() *Routers {
+	return &Routers{
+		RouterByDomain: make(map[string][]*Router),
 	}
 }

-func (r *VhostRouters) Add(domain, location string, payload interface{}) error {
+func (r *Routers) Add(domain, location string, payload interface{}) error {
 	r.mutex.Lock()
 	defer r.mutex.Unlock()

@@ -39,10 +39,10 @@ func (r *VhostRouters) Add(domain, location string, payload interface{}) error {

 	vrs, found := r.RouterByDomain[domain]
 	if !found {
-		vrs = make([]*VhostRouter, 0, 1)
+		vrs = make([]*Router, 0, 1)
 	}

-	vr := &VhostRouter{
+	vr := &Router{
 		domain:   domain,
 		location: location,
 		payload:  payload,
@@ -54,7 +54,7 @@ func (r *VhostRouters) Add(domain, location string, payload interface{}) error {
 	return nil
 }

-func (r *VhostRouters) Del(domain, location string) {
+func (r *Routers) Del(domain, location string) {
 	r.mutex.Lock()
 	defer r.mutex.Unlock()

@@ -62,7 +62,7 @@ func (r *VhostRouters) Del(domain, location string) {
 	if !found {
 		return
 	}
-	newVrs := make([]*VhostRouter, 0)
+	newVrs := make([]*Router, 0)
 	for _, vr := range vrs {
 		if vr.location != location {
 			newVrs = append(newVrs, vr)
@@ -71,7 +71,7 @@ func (r *VhostRouters) Del(domain, location string) {
 	r.RouterByDomain[domain] = newVrs
 }

-func (r *VhostRouters) Get(host, path string) (vr *VhostRouter, exist bool) {
+func (r *Routers) Get(host, path string) (vr *Router, exist bool) {
 	r.mutex.RLock()
 	defer r.mutex.RUnlock()

@@ -90,7 +90,7 @@ func (r *VhostRouters) Get(host, path string) (vr *VhostRouter, exist bool) {
 	return
 }

-func (r *VhostRouters) exist(host, path string) (vr *VhostRouter, exist bool) {
+func (r *Routers) exist(host, path string) (vr *Router, exist bool) {
 	vrs, found := r.RouterByDomain[host]
 	if !found {
 		return
@@ -106,7 +106,7 @@ func (r *VhostRouters) exist(host, path string) (vr *VhostRouter, exist bool) {
 }

 // sort by location
-type ByLocation []*VhostRouter
+type ByLocation []*Router

 func (a ByLocation) Len() int {
 	return len(a)
--- a/utils/vhost/vhost.go
+++ b/utils/vhost/vhost.go
@@ -26,30 +26,38 @@ import (
 	"github.com/fatedier/golib/errors"
 )

+type RouteInfo string
+
+const (
+	RouteInfoURL    RouteInfo = "url"
+	RouteInfoHost   RouteInfo = "host"
+	RouteInfoRemote RouteInfo = "remote"
+)
+
 type muxFunc func(net.Conn) (net.Conn, map[string]string, error)
 type httpAuthFunc func(net.Conn, string, string, string) (bool, error)
 type hostRewriteFunc func(net.Conn, string) (net.Conn, error)
 type successFunc func(net.Conn) error

-type VhostMuxer struct {
+type Muxer struct {
 	listener       net.Listener
 	timeout        time.Duration
 	vhostFunc      muxFunc
 	authFunc       httpAuthFunc
 	successFunc    successFunc
 	rewriteFunc    hostRewriteFunc
-	registryRouter *VhostRouters
+	registryRouter *Routers
 }

-func NewVhostMuxer(listener net.Listener, vhostFunc muxFunc, authFunc httpAuthFunc, successFunc successFunc, rewriteFunc hostRewriteFunc, timeout time.Duration) (mux *VhostMuxer, err error) {
-	mux = &VhostMuxer{
+func NewMuxer(listener net.Listener, vhostFunc muxFunc, authFunc httpAuthFunc, successFunc successFunc, rewriteFunc hostRewriteFunc, timeout time.Duration) (mux *Muxer, err error) {
+	mux = &Muxer{
 		listener:       listener,
 		timeout:        timeout,
 		vhostFunc:      vhostFunc,
 		authFunc:       authFunc,
 		successFunc:    successFunc,
 		rewriteFunc:    rewriteFunc,
-		registryRouter: NewVhostRouters(),
+		registryRouter: NewRouters(),
 	}
 	go mux.run()
 	return mux, nil
@@ -57,8 +65,8 @@ func NewVhostMuxer(listener net.Listener, vhostFunc muxFunc, authFunc httpAuthFu

 type CreateConnFunc func(remoteAddr string) (net.Conn, error)

-// VhostRouteConfig is the params used to match HTTP requests
-type VhostRouteConfig struct {
+// RouteConfig is the params used to match HTTP requests
+type RouteConfig struct {
 	Domain      string
 	Location    string
 	RewriteHost string
@@ -71,7 +79,7 @@ type VhostRouteConfig struct {

 // listen for a new domain name, if rewriteHost is not empty  and rewriteFunc is not nil
 // then rewrite the host header to rewriteHost
-func (v *VhostMuxer) Listen(ctx context.Context, cfg *VhostRouteConfig) (l *Listener, err error) {
+func (v *Muxer) Listen(ctx context.Context, cfg *RouteConfig) (l *Listener, err error) {
 	l = &Listener{
 		name:        cfg.Domain,
 		location:    cfg.Location,
@@ -89,7 +97,7 @@ func (v *VhostMuxer) Listen(ctx context.Context, cfg *VhostRouteConfig) (l *List
 	return l, nil
 }

-func (v *VhostMuxer) getListener(name, path string) (l *Listener, exist bool) {
+func (v *Muxer) getListener(name, path string) (l *Listener, exist bool) {
 	// first we check the full hostname
 	// if not exist, then check the wildcard_domain such as *.example.com
 	vr, found := v.registryRouter.Get(name, path)
@@ -118,7 +126,7 @@ func (v *VhostMuxer) getListener(name, path string) (l *Listener, exist bool) {
 	}
 }

-func (v *VhostMuxer) run() {
+func (v *Muxer) run() {
 	for {
 		conn, err := v.listener.Accept()
 		if err != nil {
@@ -128,7 +136,7 @@ func (v *VhostMuxer) run() {
 	}
 }

-func (v *VhostMuxer) handle(c net.Conn) {
+func (v *Muxer) handle(c net.Conn) {
 	if err := c.SetDeadline(time.Now().Add(v.timeout)); err != nil {
 		c.Close()
 		return
@@ -195,7 +203,7 @@ type Listener struct {
 	rewriteHost string
 	userName    string
 	passWord    string
-	mux         *VhostMuxer // for closing VhostMuxer
+	mux         *Muxer // for closing Muxer
 	accept      chan net.Conn
 	ctx         context.Context
 }
@@ -219,7 +227,7 @@ func (l *Listener) Accept() (net.Conn, error) {
 		xl.Debug("rewrite host to [%s] success", l.rewriteHost)
 		conn = sConn
 	}
-	return frpNet.NewContextConn(conn, l.ctx), nil
+	return frpNet.NewContextConn(l.ctx, conn), nil
 }

 func (l *Listener) Close() error {