util/rest/client.go - servicecomb-service-center - Git at Google

 //Copyright 2017 Huawei Technologies Co., Ltd
 //
 //Licensed under the Apache License, Version 2.0 (the "License");
 //you may not use this file except in compliance with the License.
 //You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 //Unless required by applicable law or agreed to in writing, software
 //distributed under the License is distributed on an "AS IS" BASIS,
 //WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 //See the License for the specific language governing permissions and
 //limitations under the License.
 package rest

 import (
 	"bytes"
 	"compress/gzip"
 	"encoding/json"
 	"fmt"
 	"github.com/ServiceComb/service-center/util"
 	"github.com/ServiceComb/service-center/util/errors"
 	"github.com/astaxie/beego"
 	"io"
 	"io/ioutil"
 	"net"
 	"net/http"
 	"reflect"
 	"time"
 )

 type HttpClient struct {
 	gzip   bool
 	client *http.Client
 }

 func getTLSTransport(verifyPeer bool, supplyCert bool, verifyCN bool) (transport *http.Transport, err error) {
 	tlsConfig, err := GetClientTLSConfig(verifyPeer, supplyCert, verifyCN)
 	if err != nil {
 		return nil, err
 	}

 	transport = &http.Transport{
 		TLSClientConfig:       tlsConfig,
 		TLSHandshakeTimeout:   DEFAULT_TLS_HANDSHAKE_TIMEOUT,
 		ResponseHeaderTimeout: DEFAULT_HTTP_RESPONSE_TIMEOUT,
 	}

 	return transport, nil
 }

 /**
   获取普通HTTP客户端
 */
 var httpClient = &http.Client{
 	Transport: transport,
 	Timeout:   30 * time.Second,
 }

 var maxIdleConnsPerHost = beego.AppConfig.DefaultInt("max_idle_conns_per_host", 200)
 var transport = &http.Transport{
 	Dial: (&net.Dialer{
 		Timeout:   5 * time.Second,
 		KeepAlive: 30 * time.Second,
 	}).Dial,
 	MaxIdleConnsPerHost:   maxIdleConnsPerHost,
 	ResponseHeaderTimeout: 10 * time.Second,
 }

 func GetHttpClient(gzip bool) (client *HttpClient, err error) {
 	return &HttpClient{
 		gzip:   gzip,
 		client: httpClient,
 	}, nil
 }

 /**
   获取TLS认证HTTP客户端
   gzip  控制是否支持压缩
   verifyPeer  控制是否认证客户端
   supplyCert  控制是否加载和发送证书
   verifyCN    控制是否认证对端CN
 */
 func getHttpsClient(gzip, verifyPeer, supplyCert, verifyCN bool) (client *HttpClient, err error) {
 	transport, err := getTLSTransport(verifyPeer, supplyCert, verifyCN)
 	if err != nil {
 		util.LOGGER.Errorf(err, "get tls transport failed.")
 	}

 	client = &HttpClient{
 		gzip: gzip,
 		client: &http.Client{
 			Transport: transport,
 			Timeout:   30 * time.Second,
 		},
 	}

 	return client, nil
 }

 /**
   获取TLS认证HTTP客户端（支持压缩，提供证书，是否认证对端通过参数控制）
 */
 func GetHttpsClient(verifyPeer bool) (client *HttpClient, err error) {
 	return getHttpsClient(true, verifyPeer, true, false)
 }

 /**
   获取匿名认证HTTP客户端（支持压缩，不提供证书，也不认证对端）
 */
 func GetAnnoHttpsClient(gzip bool) (client *HttpClient, err error) {
 	return getHttpsClient(gzip, false, false, false)
 }

 func (client *HttpClient) getHeaders(method string, headers map[string]string, body interface{}) map[string]string {
 	newHeaders := make(map[string]string)
 	if body != nil {
 		newHeaders["Content-Type"] = "application/json;utf-8"
 		newHeaders["Accept"] = "application/json"
 	}

 	if client.gzip {
 		newHeaders["Accept-Encoding"] = "gzip"
 		newHeaders["Content-Encoding"] = "gzip"
 	}

 	if headers != nil {
 		for key, value := range headers {
 			newHeaders[key] = value
 		}
 	}

 	return newHeaders
 }

 func gzipCompress(src []byte) (dst []byte) {
 	var byteBuffer bytes.Buffer

 	func() {
 		gzipWriter := gzip.NewWriter(&byteBuffer)
 		defer gzipWriter.Close()
 		gzipWriter.Write(src)
 	}()

 	return byteBuffer.Bytes()
 }

 func readAndGunzip(reader io.Reader) (dst []byte, err error) {
 	gzipReader, err := gzip.NewReader(reader)
 	if err != nil {
 		util.LOGGER.Errorf(err, "duplicate gzip reader failed.")
 		return nil, err
 	}

 	defer gzipReader.Close()
 	dst, err = ioutil.ReadAll(gzipReader)
 	if err != nil {
 		util.LOGGER.Errorf(err, "read from gzip reader failed.")
 		return nil, err
 	}

 	return dst, nil
 }

 func (client *HttpClient) httpDo(method string, url string, headers map[string]string, body interface{}) (int, string) {
 	status, result := HTTP_ERROR_STATUS_CODE, ""

 	var bodyBytes []byte = nil
 	var err error = nil
 	var bodyReader io.Reader = nil
 	if body != nil {
 		if headers == nil || len(headers["Content-Type"]) == 0 {
 			// 如果请求头未传入Conent-Type，则按照json格式进行编码（如果是非json类型，需要自行在headers里指定类型）
 			bodyBytes, err = json.Marshal(body)
 			if err != nil {
 				util.LOGGER.Errorf(err, "mashal object failed.")
 				return status, result
 			}
 		} else {
 			// 如果指定了Content-Type类型，则传入的body必须为byte流
 			var ok bool = false
 			bodyBytes, ok = body.([]byte)
 			if !ok {
 				util.LOGGER.Errorf(nil, "invalid body type '%s'(%s), body must type of byte array if Content-Type specified.", reflect.TypeOf(body), headers["Content-Type"])
 				return status, result
 			}
 		}

 		//如果配置了gzip压缩，则对body压缩一次(如果请求头里传入已经gzip压缩了，则不重复压缩)
 		if client.gzip && (headers == nil || headers["Content-Encoding"] != "gzip") {
 			bodyBytes = gzipCompress(bodyBytes)
 		}

 		bodyReader = bytes.NewBuffer(bodyBytes)
 	}

 	req, err := http.NewRequest(method, url, bodyReader)
 	if err != nil {
 		util.LOGGER.Errorf(err, "create request failed.")
 		return status, result
 	}

 	newHeaders := client.getHeaders(method, headers, body)
 	for key, value := range newHeaders {
 		req.Header.Set(key, value)
 	}

 	resp, err := client.client.Do(req)
 	if err != nil {
 		util.LOGGER.Errorf(err, "invoke request failed.")
 		return status, result
 	}

 	defer resp.Body.Close()
 	status = resp.StatusCode
 	var respBody []byte
 	if resp.Header.Get("Content-Encoding") == "gzip" {
 		// 如果响应头里包含了响应消息的压缩格式为gzip，则在返回前先解压缩
 		respBody, _ = readAndGunzip(resp.Body)
 	} else {
 		respBody, _ = ioutil.ReadAll(resp.Body)
 	}
 	result = string(respBody)

 	return status, result
 }

 func (client *HttpClient) HttpDo(method string, url string, headers map[string]string, body interface{}) (*http.Response, error) {
 	var bodyBytes []byte = nil
 	var err error = nil
 	var bodyReader io.Reader = nil
 	if body != nil {
 		if headers == nil || len(headers["Content-Type"]) == 0 {
 			// 如果请求头未传入Conent-Type，则按照json格式进行编码（如果是非json类型，需要自行在headers里指定类型）
 			bodyBytes, err = json.Marshal(body)
 			if err != nil {
 				util.LOGGER.Errorf(err, "mashal object failed.")
 				return nil, err
 			}
 		} else {
 			// 如果指定了Content-Type类型，则传入的body必须为byte流
 			var ok bool = false
 			bodyBytes, ok = body.([]byte)
 			if !ok {
 				err := errors.New(fmt.Sprintf("invalid body type '%s'(%s), body must type of byte array if Content-Type specified.", reflect.TypeOf(body), headers["Content-Type"]))
 				util.LOGGER.Errorf(err, "")
 				return nil, err
 			}
 		}

 		//如果配置了gzip压缩，则对body压缩一次(如果请求头里传入已经gzip压缩了，则不重复压缩)
 		if client.gzip && (headers == nil || headers["Content-Encoding"] != "gzip") {
 			bodyBytes = gzipCompress(bodyBytes)
 		}

 		bodyReader = bytes.NewBuffer(bodyBytes)
 	}

 	req, err := http.NewRequest(method, url, bodyReader)
 	if err != nil {
 		util.LOGGER.Errorf(err, "create request failed.")
 		return nil, err
 	}

 	newHeaders := client.getHeaders(method, headers, body)
 	for key, value := range newHeaders {
 		req.Header.Set(key, value)
 	}

 	resp, err := client.client.Do(req)
 	if err != nil {
 		util.LOGGER.Errorf(err, "Request -----> %s failed.", url)
 		return resp, err
 	}
 	if resp.StatusCode != 200 && resp.StatusCode != 201 {
 		util.LOGGER.Errorf(nil, "Request -----> %s not ok, status is %s", url, resp.Status)
 		return resp, errors.New(fmt.Sprintf("Request failed, status is %s", resp.Status))
 	}
 	return resp, err
 }

 func (client *HttpClient) Get(url string, headers map[string]string) (int, string) {
 	return client.httpDo(HTTP_METHOD_GET, url, headers, nil)
 }

 func (client *HttpClient) Put(url string, headers map[string]string, body interface{}) (int, string) {
 	return client.httpDo(HTTP_METHOD_PUT, url, headers, body)
 }

 func (client *HttpClient) Post(url string, headers map[string]string, body interface{}) (int, string) {
 	return client.httpDo(HTTP_METHOD_POST, url, headers, body)
 }

 func (client *HttpClient) Delete(url string, headers map[string]string) (int, string) {
 	return client.httpDo(HTTP_METHOD_DELETE, url, headers, nil)
 }

 func (client *HttpClient) Do(req *http.Request) (*http.Response, error) {
 	return client.client.Do(req)
 }
	//Copyright 2017 Huawei Technologies Co., Ltd
	//
	//Licensed under the Apache License, Version 2.0 (the "License");
	//you may not use this file except in compliance with the License.
	//You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	//Unless required by applicable law or agreed to in writing, software
	//distributed under the License is distributed on an "AS IS" BASIS,
	//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	//See the License for the specific language governing permissions and
	//limitations under the License.
	package rest

	import (
	"bytes"
	"compress/gzip"
	"encoding/json"
	"fmt"
	"github.com/ServiceComb/service-center/util"
	"github.com/ServiceComb/service-center/util/errors"
	"github.com/astaxie/beego"
	"io"
	"io/ioutil"
	"net"
	"net/http"
	"reflect"
	"time"
	)

	type HttpClient struct {
	gzip bool
	client *http.Client
	}

	func getTLSTransport(verifyPeer bool, supplyCert bool, verifyCN bool) (transport *http.Transport, err error) {
	tlsConfig, err := GetClientTLSConfig(verifyPeer, supplyCert, verifyCN)
	if err != nil {
	return nil, err
	}

	transport = &http.Transport{
	TLSClientConfig: tlsConfig,
	TLSHandshakeTimeout: DEFAULT_TLS_HANDSHAKE_TIMEOUT,
	ResponseHeaderTimeout: DEFAULT_HTTP_RESPONSE_TIMEOUT,
	}

	return transport, nil
	}

	/**
	获取普通HTTP客户端
	*/
	var httpClient = &http.Client{
	Transport: transport,
	Timeout: 30 * time.Second,
	}

	var maxIdleConnsPerHost = beego.AppConfig.DefaultInt("max_idle_conns_per_host", 200)
	var transport = &http.Transport{
	Dial: (&net.Dialer{
	Timeout: 5 * time.Second,
	KeepAlive: 30 * time.Second,
	}).Dial,
	MaxIdleConnsPerHost: maxIdleConnsPerHost,
	ResponseHeaderTimeout: 10 * time.Second,
	}

	func GetHttpClient(gzip bool) (client *HttpClient, err error) {
	return &HttpClient{
	gzip: gzip,
	client: httpClient,
	}, nil
	}

	/**
	获取TLS认证HTTP客户端
	gzip 控制是否支持压缩
	verifyPeer 控制是否认证客户端
	supplyCert 控制是否加载和发送证书
	verifyCN 控制是否认证对端CN
	*/
	func getHttpsClient(gzip, verifyPeer, supplyCert, verifyCN bool) (client *HttpClient, err error) {
	transport, err := getTLSTransport(verifyPeer, supplyCert, verifyCN)
	if err != nil {
	util.LOGGER.Errorf(err, "get tls transport failed.")
	}

	client = &HttpClient{
	gzip: gzip,
	client: &http.Client{
	Transport: transport,
	Timeout: 30 * time.Second,
	},
	}

	return client, nil
	}

	/**
	获取TLS认证HTTP客户端（支持压缩，提供证书，是否认证对端通过参数控制）
	*/
	func GetHttpsClient(verifyPeer bool) (client *HttpClient, err error) {
	return getHttpsClient(true, verifyPeer, true, false)
	}

	/**
	获取匿名认证HTTP客户端（支持压缩，不提供证书，也不认证对端）
	*/
	func GetAnnoHttpsClient(gzip bool) (client *HttpClient, err error) {
	return getHttpsClient(gzip, false, false, false)
	}

	func (client *HttpClient) getHeaders(method string, headers map[string]string, body interface{}) map[string]string {
	newHeaders := make(map[string]string)
	if body != nil {
	newHeaders["Content-Type"] = "application/json;utf-8"
	newHeaders["Accept"] = "application/json"
	}

	if client.gzip {
	newHeaders["Accept-Encoding"] = "gzip"
	newHeaders["Content-Encoding"] = "gzip"
	}

	if headers != nil {
	for key, value := range headers {
	newHeaders[key] = value
	}
	}

	return newHeaders
	}

	func gzipCompress(src []byte) (dst []byte) {
	var byteBuffer bytes.Buffer

	func() {
	gzipWriter := gzip.NewWriter(&byteBuffer)
	defer gzipWriter.Close()
	gzipWriter.Write(src)
	}()

	return byteBuffer.Bytes()
	}

	func readAndGunzip(reader io.Reader) (dst []byte, err error) {
	gzipReader, err := gzip.NewReader(reader)
	if err != nil {
	util.LOGGER.Errorf(err, "duplicate gzip reader failed.")
	return nil, err
	}

	defer gzipReader.Close()
	dst, err = ioutil.ReadAll(gzipReader)
	if err != nil {
	util.LOGGER.Errorf(err, "read from gzip reader failed.")
	return nil, err
	}

	return dst, nil
	}

	func (client *HttpClient) httpDo(method string, url string, headers map[string]string, body interface{}) (int, string) {
	status, result := HTTP_ERROR_STATUS_CODE, ""

	var bodyBytes []byte = nil
	var err error = nil
	var bodyReader io.Reader = nil
	if body != nil {
	if headers == nil \|\| len(headers["Content-Type"]) == 0 {
	// 如果请求头未传入Conent-Type，则按照json格式进行编码（如果是非json类型，需要自行在headers里指定类型）
	bodyBytes, err = json.Marshal(body)
	if err != nil {
	util.LOGGER.Errorf(err, "mashal object failed.")
	return status, result
	}
	} else {
	// 如果指定了Content-Type类型，则传入的body必须为byte流
	var ok bool = false
	bodyBytes, ok = body.([]byte)
	if !ok {
	util.LOGGER.Errorf(nil, "invalid body type '%s'(%s), body must type of byte array if Content-Type specified.", reflect.TypeOf(body), headers["Content-Type"])
	return status, result
	}
	}

	//如果配置了gzip压缩，则对body压缩一次(如果请求头里传入已经gzip压缩了，则不重复压缩)
	if client.gzip && (headers == nil \|\| headers["Content-Encoding"] != "gzip") {
	bodyBytes = gzipCompress(bodyBytes)
	}

	bodyReader = bytes.NewBuffer(bodyBytes)
	}

	req, err := http.NewRequest(method, url, bodyReader)
	if err != nil {
	util.LOGGER.Errorf(err, "create request failed.")
	return status, result
	}

	newHeaders := client.getHeaders(method, headers, body)
	for key, value := range newHeaders {
	req.Header.Set(key, value)
	}

	resp, err := client.client.Do(req)
	if err != nil {
	util.LOGGER.Errorf(err, "invoke request failed.")
	return status, result
	}

	defer resp.Body.Close()
	status = resp.StatusCode
	var respBody []byte
	if resp.Header.Get("Content-Encoding") == "gzip" {
	// 如果响应头里包含了响应消息的压缩格式为gzip，则在返回前先解压缩
	respBody, _ = readAndGunzip(resp.Body)
	} else {
	respBody, _ = ioutil.ReadAll(resp.Body)
	}
	result = string(respBody)

	return status, result
	}

	func (client HttpClient) HttpDo(method string, url string, headers map[string]string, body interface{}) (http.Response, error) {
	var bodyBytes []byte = nil
	var err error = nil
	var bodyReader io.Reader = nil
	if body != nil {
	if headers == nil \|\| len(headers["Content-Type"]) == 0 {
	// 如果请求头未传入Conent-Type，则按照json格式进行编码（如果是非json类型，需要自行在headers里指定类型）
	bodyBytes, err = json.Marshal(body)
	if err != nil {
	util.LOGGER.Errorf(err, "mashal object failed.")
	return nil, err
	}
	} else {
	// 如果指定了Content-Type类型，则传入的body必须为byte流
	var ok bool = false
	bodyBytes, ok = body.([]byte)
	if !ok {
	err := errors.New(fmt.Sprintf("invalid body type '%s'(%s), body must type of byte array if Content-Type specified.", reflect.TypeOf(body), headers["Content-Type"]))
	util.LOGGER.Errorf(err, "")
	return nil, err
	}
	}

	//如果配置了gzip压缩，则对body压缩一次(如果请求头里传入已经gzip压缩了，则不重复压缩)
	if client.gzip && (headers == nil \|\| headers["Content-Encoding"] != "gzip") {
	bodyBytes = gzipCompress(bodyBytes)
	}

	bodyReader = bytes.NewBuffer(bodyBytes)
	}

	req, err := http.NewRequest(method, url, bodyReader)
	if err != nil {
	util.LOGGER.Errorf(err, "create request failed.")
	return nil, err
	}

	newHeaders := client.getHeaders(method, headers, body)
	for key, value := range newHeaders {
	req.Header.Set(key, value)
	}

	resp, err := client.client.Do(req)
	if err != nil {
	util.LOGGER.Errorf(err, "Request -----> %s failed.", url)
	return resp, err
	}
	if resp.StatusCode != 200 && resp.StatusCode != 201 {
	util.LOGGER.Errorf(nil, "Request -----> %s not ok, status is %s", url, resp.Status)
	return resp, errors.New(fmt.Sprintf("Request failed, status is %s", resp.Status))
	}
	return resp, err
	}

	func (client *HttpClient) Get(url string, headers map[string]string) (int, string) {
	return client.httpDo(HTTP_METHOD_GET, url, headers, nil)
	}

	func (client *HttpClient) Put(url string, headers map[string]string, body interface{}) (int, string) {
	return client.httpDo(HTTP_METHOD_PUT, url, headers, body)
	}

	func (client *HttpClient) Post(url string, headers map[string]string, body interface{}) (int, string) {
	return client.httpDo(HTTP_METHOD_POST, url, headers, body)
	}

	func (client *HttpClient) Delete(url string, headers map[string]string) (int, string) {
	return client.httpDo(HTTP_METHOD_DELETE, url, headers, nil)
	}

	func (client HttpClient) Do(req http.Request) (*http.Response, error) {
	return client.client.Do(req)
	}