reuse transport & expose Account.SetTransport()

Author: NETkiddy

account.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"strconv"
 	"encoding/json"
+	"net/http"
 )
 
 const (
@@ -20,12 +21,19 @@ func NewAccount(endpoint, secretId, secretKey string) *Account {
 	}
 }
 
-func (this *Account) SetProxy(proxyUrl string) {
+func (this *Account) SetProxy(proxyUrl string) *Account{
 	this.client.setProxy(proxyUrl)
+	return this
 }
 
-func (this *Account) UnsetProxy() {
+func (this *Account) UnsetProxy() *Account{
 	this.client.unsetProxy()
+	return this
+}
+
+func (this *Account) SetTransport(transport http.RoundTripper) *Account{
+	this.client.CmqHttp.SetTransport(transport)
+	return this
 }
 
 func (this *Account) setSignMethod(method string) (err error) {

cmq_client.go

@@ -21,7 +21,6 @@ type CMQClient struct {
 	SecretKey  string
 	Method     string
 	SignMethod string
-	Proxy      string
 	CmqHttp    *CMQHttp
 }
 
@@ -48,12 +47,12 @@ func (this *CMQClient) setSignMethod(signMethod string) (err error) {
 }
 
 func (this *CMQClient) setProxy(proxyUrl string) {
-	this.Proxy = proxyUrl
+	this.CmqHttp.setProxy(proxyUrl)
 	return
 }
 
 func (this *CMQClient) unsetProxy() {
-	this.Proxy = ""
+	this.CmqHttp.unsetProxy()
 	return
 }
 
@@ -121,10 +120,6 @@ func (this *CMQClient) call(action string, param map[string]string) (resp string
 	//log.Printf("urlStr :%v", urlStr)
 	//log.Printf("reqStr :%v", reqStr)
 
-	proxyUrlStr := this.Proxy
-	if proxyUrl, found := param["proxyUrl"]; found {
-		proxyUrlStr = proxyUrl
-	}
 	userTimeout := 0
 	if UserpollingWaitSeconds, found := param["UserpollingWaitSeconds"]; found {
 		userTimeout, err = strconv.Atoi(UserpollingWaitSeconds)
@@ -133,7 +128,7 @@ func (this *CMQClient) call(action string, param map[string]string) (resp string
 		}
 	}
 
-	resp, err = this.CmqHttp.request(this.Method, urlStr, reqStr, proxyUrlStr, userTimeout)
+	resp, err = this.CmqHttp.request(this.Method, urlStr, reqStr, userTimeout)
 	if err != nil {
 		return resp, fmt.Errorf("CmqHttp.request failed: %v", err.Error())
 	}

cmq_http.go

@@ -1,96 +1,112 @@
 package cmq_go
 
 import (
-	"net"
 	"time"
 	"net/http"
 	"fmt"
 	"io/ioutil"
 	"net/url"
 	"bytes"
+	"errors"
+	"net"
+)
+
+const (
+	DEFAULT_HTTP_TIMEOUT = 3000 //ms
 )
 
 type CMQHttp struct {
-	timeout     int
 	isKeepAlive bool
 	conn        *http.Client
 }
 
+var DefaultTransport = &http.Transport{
+	Proxy: http.ProxyFromEnvironment,
+	DialContext: (&net.Dialer{
+		Timeout:   30 * time.Second,
+		KeepAlive: 30 * time.Second,
+		DualStack: true,
+	}).DialContext,
+	MaxIdleConns:          500,
+	MaxIdleConnsPerHost:   100,
+	IdleConnTimeout:       90 * time.Second,
+	TLSHandshakeTimeout:   10 * time.Second,
+	ExpectContinueTimeout: 1 * time.Second,
+}
+
 func NewCMQHttp() *CMQHttp {
 	return &CMQHttp{
-		timeout:     10000,
 		isKeepAlive: true,
-		conn:        nil,
+		conn: &http.Client{
+			Timeout:   DEFAULT_HTTP_TIMEOUT * time.Millisecond,
+			Transport: DefaultTransport,
+		},
 	}
+
 }
 
-func (this *CMQHttp) request(method, urlStr, reqStr, proxyUrlStr string, userTimeout int) (result string, err error){
-	var client *http.Client
-	timeout := 0
-	if userTimeout >= 0 {
-		timeout = userTimeout
+func (this *CMQHttp) setProxy(proxyUrlStr string) (err error) {
+	if proxyUrlStr == "" {
+		return
 	}
-	keepalive := 0
-	if this.isKeepAlive {
-		keepalive = 30
+	proxyUrl, err := url.Parse(proxyUrlStr)
+	if err != nil {
+		return
 	}
+	transport, err := this.getTransport()
+	if err != nil {
+		return
+	}
+	transport.Proxy = http.ProxyURL(proxyUrl)
+	return
+}
 
-	if proxyUrlStr == "" {
-		unproxyTransport := &http.Transport{
-			Proxy: http.ProxyFromEnvironment,
-			DialContext: (&net.Dialer{
-				Timeout:   30 * time.Second,
-				KeepAlive: time.Duration(keepalive) * time.Second,
-				DualStack: true,
-			}).DialContext,
-			MaxIdleConns:          100,
-			IdleConnTimeout:       90 * time.Second,
-			TLSHandshakeTimeout:   10 * time.Second,
-			ExpectContinueTimeout: 1 * time.Second,
-		}
+func (this *CMQHttp) unsetProxy() (err error) {
+	transport, err := this.getTransport()
+	if err != nil {
+		return
+	}
+	transport.Proxy = nil
+	return
+}
+
+func (this *CMQHttp) getTransport() (*http.Transport, error) {
+	if this.conn.Transport == nil {
+		this.SetTransport(DefaultTransport)
+	}
 
-		client = &http.Client{
-			Timeout:   time.Duration(timeout) * time.Second,
-			Transport: unproxyTransport,
-		}
-	} else {
-		proxyUrl, err := url.Parse(proxyUrlStr)
-		if err != nil {
-			panic(err)
-		}
-		proxyTransport := &http.Transport{
-			Proxy: http.ProxyURL(proxyUrl),
-			DialContext: (&net.Dialer{
-				Timeout:   30 * time.Second,
-				KeepAlive: time.Duration(keepalive) * time.Second,
-				DualStack: true,
-			}).DialContext,
-			MaxIdleConns:          100,
-			IdleConnTimeout:       90 * time.Second,
-			TLSHandshakeTimeout:   10 * time.Second,
-			ExpectContinueTimeout: 1 * time.Second,
-		}
-		client = &http.Client{
-			Timeout:   time.Duration(timeout) * time.Second,
-			Transport: proxyTransport,
-		}
+	if transport, ok := this.conn.Transport.(*http.Transport); ok {
+		return transport, nil
+	}
+	return nil, errors.New("transport is not an *http.Transport instance")
+}
+
+func (this *CMQHttp) SetTransport(transport http.RoundTripper) {
+	this.conn.Transport = transport
+}
+
+func (this *CMQHttp) request(method, urlStr, reqStr string, userTimeout int) (result string, err error) {
+	timeout := DEFAULT_HTTP_TIMEOUT
+	if userTimeout >= 0 {
+		timeout += userTimeout
 	}
+	this.conn.Timeout = time.Duration(timeout) * time.Millisecond
 
 	req, err := http.NewRequest(method, urlStr, bytes.NewReader([]byte(reqStr)))
 	if err != nil {
 		return "", fmt.Errorf("make http req error %v", err)
 	}
-	resp, err := client.Do(req)
+	resp, err := this.conn.Do(req)
 	if err != nil {
 		return "", fmt.Errorf("http error  %v", err)
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
-		return "",fmt.Errorf("http error code %d", resp.StatusCode)
+		return "", fmt.Errorf("http error code %d", resp.StatusCode)
 	}
 	body, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return "",fmt.Errorf("read http resp body error %v", err)
+		return "", fmt.Errorf("read http resp body error %v", err)
 	}
 	result = string(body)
 	return