You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
226 lines
5.3 KiB
226 lines
5.3 KiB
package util
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/tls"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"time"
|
|
)
|
|
|
|
type RequestMethod string
|
|
type ContentType string
|
|
type RequestHeader map[string][]string
|
|
|
|
const (
|
|
GET RequestMethod = "GET"
|
|
POST RequestMethod = "POST"
|
|
PUT RequestMethod = "PUT"
|
|
DELETE RequestMethod = "DELETE"
|
|
)
|
|
const (
|
|
ContentTypePlain ContentType = "text/plain;charset=utf-8"
|
|
ContentTypeHtml ContentType = "text/html;charset=utf-8"
|
|
ContentTypeXml ContentType = "text/xml;charset=utf-8"
|
|
ContentTypeJson ContentType = "application/json;charset=utf-8"
|
|
ContentTypeForm ContentType = "application/x-www-form-urlencoded;charset=utf-8"
|
|
ContentTypeFile ContentType = "multipart/form-data;charset=utf-8"
|
|
)
|
|
|
|
func Get(url string) ([]byte, error) {
|
|
return Request(url, GET, ContentTypePlain, nil, nil)
|
|
}
|
|
|
|
func Post(url string, contentType ContentType, v interface{}) ([]byte, error) {
|
|
return Request(url, POST, contentType, nil, v)
|
|
}
|
|
|
|
func Put(url string, contentType ContentType, v interface{}) ([]byte, error) {
|
|
return Request(url, PUT, contentType, nil, v)
|
|
}
|
|
|
|
func Del(url string) ([]byte, error) {
|
|
return Request(url, DELETE, ContentTypePlain, nil, nil)
|
|
}
|
|
|
|
func GetByHeader(url string, header RequestHeader) ([]byte, error) {
|
|
return Request(url, GET, ContentTypePlain, header, nil)
|
|
}
|
|
|
|
func PostByHeader(url string, contentType ContentType, header RequestHeader, v interface{}) ([]byte, error) {
|
|
return Request(url, POST, contentType, header, v)
|
|
}
|
|
|
|
func PutByHeader(url string, contentType ContentType, header RequestHeader, v interface{}) ([]byte, error) {
|
|
return Request(url, PUT, contentType, header, v)
|
|
}
|
|
|
|
func DelByHeader(url string, header RequestHeader) ([]byte, error) {
|
|
return Request(url, DELETE, ContentTypePlain, header, nil)
|
|
}
|
|
|
|
func GetJson(url string, v interface{}) ([]byte, error) {
|
|
return Request(url, GET, ContentTypeJson, nil, v)
|
|
}
|
|
|
|
func PostJson(url string, v interface{}) ([]byte, error) {
|
|
return Request(url, POST, ContentTypeJson, nil, v)
|
|
}
|
|
|
|
func PutJson(url string, v interface{}) ([]byte, error) {
|
|
return Request(url, PUT, ContentTypeJson, nil, v)
|
|
}
|
|
|
|
func DelJson(url string, v interface{}) ([]byte, error) {
|
|
return Request(url, DELETE, ContentTypeJson, nil, v)
|
|
}
|
|
|
|
func PostJsonByHeader(url string, header RequestHeader, v interface{}) ([]byte, error) {
|
|
return Request(url, POST, ContentTypeJson, header, v)
|
|
}
|
|
|
|
func PutJsonByHeader(url string, header RequestHeader, v interface{}) ([]byte, error) {
|
|
return Request(url, PUT, ContentTypeJson, header, v)
|
|
}
|
|
|
|
func Request(url string, method RequestMethod, contentType ContentType, header RequestHeader, v interface{}) ([]byte, error) {
|
|
var body io.Reader
|
|
var err error
|
|
|
|
//PrintInfo("response URL:")
|
|
//PrintInfo(url)
|
|
|
|
switch contentType {
|
|
case ContentTypePlain:
|
|
//return nil, fmt.Errorf("unsupported content-type:%s", contentType)
|
|
case ContentTypeHtml:
|
|
return nil, fmt.Errorf("unsupported content-type:%s", contentType)
|
|
case ContentTypeXml:
|
|
return nil, fmt.Errorf("unsupported content-type:%s", contentType)
|
|
case ContentTypeForm:
|
|
return nil, fmt.Errorf("unsupported content-type:%s", contentType)
|
|
case ContentTypeJson:
|
|
body, err = toJson(v)
|
|
case ContentTypeFile:
|
|
return nil, fmt.Errorf("unsupported content-type:%s", contentType)
|
|
default:
|
|
return nil, fmt.Errorf("invalid content-type:%s", contentType)
|
|
}
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
tran := &http.Transport{
|
|
//TLSClientConfig: loadTlsConfig(),
|
|
}
|
|
|
|
client := &http.Client{Transport: tran, Timeout: time.Second * 180}
|
|
req, err := http.NewRequest(string(method), url, body)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
req.Header.Set("Connection", "keep-alive")
|
|
|
|
if len(contentType) == 0 {
|
|
contentType = ContentTypePlain
|
|
}
|
|
req.Header.Set("Content-Type", string(contentType))
|
|
|
|
if len(header) > 0 {
|
|
for k, vs := range header {
|
|
req.Header.Set(k, vs[0])
|
|
for i := 1; i < len(vs); i++ {
|
|
req.Header.Add(k, vs[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
rsp, err := client.Do(req)
|
|
|
|
if err != nil {
|
|
closeBody(rsp)
|
|
return nil, err
|
|
}
|
|
|
|
return readRsp(rsp)
|
|
}
|
|
|
|
func loadTlsConfig() *tls.Config {
|
|
pemFile, err := FindFile("cert/2990195__241210.com.pem")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
keyFile, err := FindFile("cert/2990195__241210.com.key")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
PrintInfo(pemFile)
|
|
PrintInfo(keyFile)
|
|
|
|
cert, err := tls.LoadX509KeyPair(pemFile, keyFile)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
/*caFile, err := util.FindFile("cert/ca.pem")
|
|
if err != nil {
|
|
log.Fatalf("load CA cert err: %v", err)
|
|
}
|
|
|
|
certPool := x509.NewCertPool()
|
|
ca, err := ioutil.ReadFile(caFile)
|
|
if err != nil {
|
|
log.Fatalf("ioutil.ReadFile err: %v", err)
|
|
}
|
|
|
|
if ok := certPool.AppendCertsFromPEM(ca); !ok {
|
|
log.Fatalf("certPool.AppendCertsFromPEM err")
|
|
}*/
|
|
|
|
tlsCfg := &tls.Config{
|
|
Certificates: []tls.Certificate{cert},
|
|
//ClientAuth: tls.RequireAndVerifyClientCert,
|
|
//ClientCAs: certPool,
|
|
InsecureSkipVerify: true,
|
|
}
|
|
|
|
return tlsCfg
|
|
}
|
|
|
|
func toJson(v interface{}) (*bytes.Buffer, error) {
|
|
if v == nil {
|
|
return nil, nil
|
|
}
|
|
|
|
b, err := json.Marshal(v)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
//PrintInfo("response data:")
|
|
//PrintJSON(v)
|
|
|
|
return bytes.NewBuffer(b), nil
|
|
}
|
|
|
|
func readRsp(resp *http.Response) ([]byte, error) {
|
|
defer closeBody(resp)
|
|
return ioutil.ReadAll(resp.Body)
|
|
}
|
|
|
|
func closeBody(resp *http.Response) {
|
|
if resp != nil && resp.Body != nil {
|
|
err := resp.Body.Close()
|
|
if err != nil {
|
|
PrintErr(err)
|
|
}
|
|
}
|
|
}
|