init commit: simple http client

Author: randmonkey

main.go

@@ -0,0 +1,72 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+func main() {
+	var targetURL string
+	var body string
+	var contentType string
+	var accessKey string
+	var secretKey string
+	var method string
+	var verbose bool
+	flag.StringVar(&method, "X", "GET", "http request method")
+	flag.StringVar(&targetURL, "u", "", "URL")
+	flag.StringVar(&body, "d", "", "request body")
+	flag.StringVar(&contentType, "t", "application/json", "content type")
+	flag.StringVar(&accessKey, "ak", "", "QINIU access key")
+	flag.StringVar(&secretKey, "sk", "", "QINIU secret key")
+	flag.BoolVar(&verbose, "v", false, "show verbose (HTTP headers)")
+	flag.Parse()
+
+	client := &http.Client{}
+	client.Transport = &qiniuMacTransport{
+		AccessKey:    accessKey,
+		SecretKey:    []byte(secretKey),
+		RoundTripper: http.DefaultTransport,
+		showHeaders:  verbose,
+	}
+
+	reqURL, err := url.Parse(targetURL)
+	if err != nil {
+		log.Fatalf("invalid URL %s, parse URL failed: %v", targetURL, err)
+	}
+	if reqURL.Scheme == "" {
+		reqURL.Scheme = "http"
+	}
+	req, err := http.NewRequest(method, reqURL.String(), bytes.NewReader([]byte(body)))
+	if err != nil {
+		log.Fatalf("failed to create request: %v", err)
+	}
+	if verbose {
+		fmt.Printf("> %s %s\n", req.Method, req.URL.String())
+	}
+	if body != "" {
+		req.Header.Set("Content-Type", contentType)
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		fmt.Println()
+		log.Fatalf("failed to get response: %v", err)
+	}
+	if verbose {
+		fmt.Println()
+		fmt.Printf("< %s %s %s\n", resp.Request.Method, resp.Request.URL.String(), resp.Status)
+		for key, value := range resp.Header {
+			fmt.Printf("< %s=%s\n", key, strings.Join(value, ";"))
+		}
+	}
+	respBobyBuf, _ := ioutil.ReadAll(resp.Body)
+	fmt.Println(string(respBobyBuf))
+
+}

qiniumac.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+	"bytes"
+	"crypto/hmac"
+	"crypto/sha1"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"sort"
+)
+
+const qiniuHeaderPrefix = "X-Qiniu-"
+
+func includeBody(req *http.Request, ctType string) bool {
+	return req.ContentLength != 0 && req.Body != nil && ctType != "" && ctType != "application/octet-stream"
+}
+
+// ---------------------------------------------------------------------------------------
+
+type sortByHeaderKey []string
+
+func (p sortByHeaderKey) Len() int           { return len(p) }
+func (p sortByHeaderKey) Less(i, j int) bool { return p[i] < p[j] }
+func (p sortByHeaderKey) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+
+func signQiniuHeaderValues(header http.Header, w io.Writer) {
+	var keys []string
+	for key := range header {
+		if len(key) > len(qiniuHeaderPrefix) && key[:len(qiniuHeaderPrefix)] == qiniuHeaderPrefix {
+			keys = append(keys, key)
+		}
+	}
+	if len(keys) == 0 {
+		return
+	}
+
+	if len(keys) > 1 {
+		sort.Sort(sortByHeaderKey(keys))
+	}
+	for _, key := range keys {
+		io.WriteString(w, "\n"+key+": "+header.Get(key))
+	}
+}
+
+// SignRequest calculate
+func SignRequest(sk []byte, req *http.Request) ([]byte, error) {
+
+	h := hmac.New(sha1.New, sk)
+
+	u := req.URL
+	data := req.Method + " " + u.Path
+	if u.RawQuery != "" {
+		data += "?" + u.RawQuery
+	}
+	io.WriteString(h, data+"\nHost: "+req.Host)
+
+	ctType := req.Header.Get("Content-Type")
+	if ctType != "" {
+		io.WriteString(h, "\nContent-Type: "+ctType)
+	}
+
+	signQiniuHeaderValues(req.Header, h)
+
+	io.WriteString(h, "\n\n")
+
+	if includeBody(req, ctType) {
+		bodyBytes, _ := ioutil.ReadAll(req.Body)
+		req.Body.Close() //  must close
+		req.Body = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))
+		h.Write(bodyBytes)
+	}
+
+	return h.Sum(nil), nil
+}

transport.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"encoding/base64"
+	"fmt"
+	"net/http"
+	"strings"
+)
+
+type qiniuMacTransport struct {
+	AccessKey    string
+	SecretKey    []byte
+	RoundTripper http.RoundTripper
+	showHeaders  bool
+}
+
+func (tr *qiniuMacTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	if tr.AccessKey != "" {
+		sign, err := SignRequest(tr.SecretKey, req)
+		if err != nil {
+			return nil, err
+		}
+
+		auth := "Qiniu " + tr.AccessKey + ":" + base64.URLEncoding.EncodeToString(sign)
+		req.Header.Set("Authorization", auth)
+	}
+	if tr.showHeaders {
+		for key, value := range req.Header {
+			fmt.Printf("> %s=%s\n", key, strings.Join(value, ";"))
+		}
+	}
+
+	return tr.RoundTripper.RoundTrip(req)
+}