update http/tcp/aes

crypto/aes.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"crypto/aes"
 	"crypto/cipher"
+	"errors"
 )
 
 // AES aes
@@ -52,9 +53,14 @@ func (c *AES) Decrypt(bs []byte) (ds []byte, err error) {
 	if err != nil {
 		return nil, err
 	}
+	n := len(bs)
 	blockSize := block.BlockSize()
+	if n%blockSize != 0 {
+		return nil, errors.New(`crypto/cipher: input not full blocks`)
+	}
+
 	blockMode := cipher.NewCBCDecrypter(block, c.iv[:blockSize])
-	ds = make([]byte, len(bs))
+	ds = make([]byte, n)
 	blockMode.CryptBlocks(ds, bs)
 	ds = pkcs7UnPadding(ds)
 	return

db/init.go

@@ -0,0 +1,4 @@
+package db
+
+func init() {
+}

pool/buffer.go

@@ -0,0 +1,25 @@
+package pool
+
+import (
+	"bytes"
+	"sync"
+)
+
+var bufferPool = sync.Pool{
+	New: func() interface{} {
+		return &bytes.Buffer{}
+	},
+}
+
+// NewBuffer get Buffer from poll
+func NewBuffer() *bytes.Buffer {
+	b := bufferPool.Get().(*bytes.Buffer)
+	b.Reset()
+	return b
+}
+
+// PutBuffer add *bytes.Buffer to the pool.
+func PutBuffer(b *bytes.Buffer) {
+	b.Reset()
+	bufferPool.Put(b)
+}

pool/buffer_test.go

@@ -0,0 +1,26 @@
+package pool_test
+
+import (
+	"bytes"
+	"testing"
+
+	"git.chuangxin1.com/myth/sacred/pool"
+)
+
+var data = make([]byte, 10000)
+
+func BenchmarkBufferWithPool(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		buf := pool.NewBuffer()
+		buf.Write(data)
+		buf.Reset()
+		pool.PutBuffer(buf)
+	}
+}
+
+func BenchmarkBuffer(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		var buf bytes.Buffer
+		buf.Write(data)
+	}
+}

tcp/error.go

@@ -0,0 +1 @@
+package tcp

tcp/optimize.go

@@ -0,0 +1 @@
+package tcp

tcp/read.go

@@ -0,0 +1 @@
+package tcp

tcp/server.go

@@ -0,0 +1 @@
+package tcp

tcp/write.go

@@ -0,0 +1,16 @@
+package tcp
+
+import (
+	"net"
+	"time"
+)
+
+// Write write to socket with timeout
+func Write(c *net.TCPConn, t time.Duration, b []byte) (n int, err error) {
+	err = c.SetWriteDeadline(time.Now().Add(t))
+	if err != nil {
+		return
+	}
+	n, err = c.Write(b)
+	return
+}

xhttp/client.go

@@ -11,12 +11,19 @@ import (
 )
 
 // readBody read response
-func readBody(res *http.Response) (msg Message, err error) {
+func readBody(req *http.Request, res *http.Response) (msg Message, err error) {
 	var (
 		body   []byte
 		reader io.Reader
 	)
 
+	msg.StatusCode = res.StatusCode
+	msg.Header = res.Header
+
+	defer res.Body.Close()
+	msg.res = res
+	msg.req = req
+
 	encoding := res.Header.Get("Content-Encoding")
 	switch encoding {
 	case "gzip":
@@ -31,14 +38,12 @@ func readBody(res *http.Response) (msg Message, err error) {
 		return
 	}
 
-	msg.StatusCode = res.StatusCode
-	msg.Header = res.Header
 	msg.Body = body
 	return
 }
 
 // newRequest new request
-func newRequest(method, uri string, body io.Reader, opt RequestOption) (res *http.Response, err error) {
+func newRequest(method, uri string, body io.Reader, opt RequestOption) (req *http.Request, res *http.Response, err error) {
 	t := &http.Transport{
 		Dial: func(netw, addr string) (net.Conn, error) {
 			conn, err := net.DialTimeout(netw, addr, opt.RequestTimeOut)
@@ -62,7 +67,7 @@ func newRequest(method, uri string, body io.Reader, opt RequestOption) (res *htt
 		t.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
 	}
 	c := &http.Client{Transport: t}
-	var req *http.Request
+	//var req *http.Request
 	req, err = http.NewRequest(method, uri, body)
 	if err != nil {
 		return
@@ -72,43 +77,51 @@ func newRequest(method, uri string, body io.Reader, opt RequestOption) (res *htt
 		req.Header.Add(k, v)
 	}
 
+	if opt.Cookies != nil {
+		for _, c := range opt.Cookies {
+			req.AddCookie(c)
+		}
+	}
+
+	if len(opt.username) > 0 {
+		req.SetBasicAuth(opt.username, opt.password)
+	}
+
 	res, err = c.Do(req)
 	return
 }
 
 // Get HTTP request GET
 func Get(uri string, opt RequestOption) (msg Message, err error) {
-	var res *http.Response
-	if res, err = newRequest("GET", uri, nil, opt); err != nil {
+	var (
+		res *http.Response
+		req *http.Request
+	)
+	if req, res, err = newRequest("GET", uri, nil, opt); err != nil {
 		return
 	}
 
-	defer res.Body.Close()
-	msg, err = readBody(res)
+	msg, err = readBody(req, res)
 	return
 }
 
 // Head HTTP request HEAD
 func Head(uri string, opt RequestOption) (msg Message, err error) {
-	var res *http.Response
-	if res, err = newRequest("HEAD", uri, nil, opt); err != nil {
-		return
-	}
-
-	defer res.Body.Close()
-	//msg, err = readBody(res)
+	msg.req, msg.res, err = newRequest("HEAD", uri, nil, opt)
 	return
 }
 
 // GetJSON HTTP request GET, response JSON
 func GetJSON(v interface{}, uri string, opt RequestOption) (msg Message, err error) {
-	var res *http.Response
-	if res, err = newRequest("GET", uri, nil, opt); err != nil {
+	var (
+		res *http.Response
+		req *http.Request
+	)
+	if req, res, err = newRequest("GET", uri, nil, opt); err != nil {
 		return
 	}
 
-	defer res.Body.Close()
-	msg, err = readBody(res)
+	msg, err = readBody(req, res)
 	if err != nil {
 		return
 	}
@@ -118,13 +131,15 @@ func GetJSON(v interface{}, uri string, opt RequestOption) (msg Message, err err
 
 // GetXML HTTP request GET, response XML
 func GetXML(v interface{}, uri string, opt RequestOption) (msg Message, err error) {
-	var res *http.Response
-	if res, err = newRequest("GET", uri, nil, opt); err != nil {
+	var (
+		res *http.Response
+		req *http.Request
+	)
+	if req, res, err = newRequest("GET", uri, nil, opt); err != nil {
 		return
 	}
 
-	defer res.Body.Close()
-	msg, err = readBody(res)
+	msg, err = readBody(req, res)
 	if err != nil {
 		return
 	}
@@ -134,77 +149,98 @@ func GetXML(v interface{}, uri string, opt RequestOption) (msg Message, err erro
 
 // Post HTTP request POST
 func Post(uri string, body io.Reader, opt RequestOption) (msg Message, err error) {
-	var res *http.Response
-	if res, err = newRequest("POST", uri, body, opt); err != nil {
+	var (
+		res *http.Response
+		req *http.Request
+	)
+	if req, res, err = newRequest("POST", uri, body, opt); err != nil {
 		return
 	}
-	defer res.Body.Close()
-	msg, err = readBody(res)
+
+	msg, err = readBody(req, res)
 	return
 }
 
 // Put HTTP request PUT
 func Put(uri string, body io.Reader, opt RequestOption) (msg Message, err error) {
-	var res *http.Response
-	if res, err = newRequest("PUT", uri, body, opt); err != nil {
+	var (
+		res *http.Response
+		req *http.Request
+	)
+	if req, res, err = newRequest("PUT", uri, body, opt); err != nil {
 		return
 	}
-	defer res.Body.Close()
-	msg, err = readBody(res)
+
+	msg, err = readBody(req, res)
 	return
 }
 
 // Delete HTTP request DELETE
 func Delete(uri string, body io.Reader, opt RequestOption) (msg Message, err error) {
-	var res *http.Response
-	if res, err = newRequest("DELETE", uri, body, opt); err != nil {
+	var (
+		res *http.Response
+		req *http.Request
+	)
+	if req, res, err = newRequest("DELETE", uri, body, opt); err != nil {
 		return
 	}
-	defer res.Body.Close()
-	msg, err = readBody(res)
+
+	msg, err = readBody(req, res)
 	return
 }
 
 // Connect HTTP request CONNECT
 func Connect(uri string, body io.Reader, opt RequestOption) (msg Message, err error) {
-	var res *http.Response
-	if res, err = newRequest("CONNECT", uri, body, opt); err != nil {
+	var (
+		res *http.Response
+		req *http.Request
+	)
+	if req, res, err = newRequest("CONNECT", uri, body, opt); err != nil {
 		return
 	}
-	defer res.Body.Close()
-	msg, err = readBody(res)
+
+	msg, err = readBody(req, res)
 	return
 }
 
 // Options HTTP request OPTIONS
 func Options(uri string, body io.Reader, opt RequestOption) (msg Message, err error) {
-	var res *http.Response
-	if res, err = newRequest("OPTIONS", uri, body, opt); err != nil {
+	var (
+		res *http.Response
+		req *http.Request
+	)
+	if req, res, err = newRequest("OPTIONS", uri, body, opt); err != nil {
 		return
 	}
-	defer res.Body.Close()
-	msg, err = readBody(res)
+
+	msg, err = readBody(req, res)
 	return
 }
 
 // Trace HTTP request TRACE
 func Trace(uri string, body io.Reader, opt RequestOption) (msg Message, err error) {
-	var res *http.Response
-	if res, err = newRequest("TRACE", uri, body, opt); err != nil {
+	var (
+		res *http.Response
+		req *http.Request
+	)
+	if req, res, err = newRequest("TRACE", uri, body, opt); err != nil {
 		return
 	}
-	defer res.Body.Close()
-	msg, err = readBody(res)
+
+	msg, err = readBody(req, res)
 	return
 }
 
 // Patch HTTP request PATCH
 func Patch(uri string, body io.Reader, opt RequestOption) (msg Message, err error) {
-	var res *http.Response
-	if res, err = newRequest("PATCH", uri, body, opt); err != nil {
+	var (
+		res *http.Response
+		req *http.Request
+	)
+	if req, res, err = newRequest("PATCH", uri, body, opt); err != nil {
 		return
 	}
-	defer res.Body.Close()
-	msg, err = readBody(res)
+
+	msg, err = readBody(req, res)
 	return
 }

xhttp/option.go

@@ -1,6 +1,7 @@
 package xhttp
 
 import (
+	"net/http"
 	"time"
 )
 
@@ -10,6 +11,9 @@ type RequestOption struct {
 	ResponseHeaderTimeout time.Duration
 
 	Headers map[string]string
+	Cookies []*http.Cookie
+
+	username, password string
 
 	CertFile string
 	KeyFile  string
@@ -76,6 +80,19 @@ func (r *RequestOption) SetHeader(k, v string) *RequestOption {
 	return r
 }
 
+// AddCookie adds a cookie to the request.
+func (r *RequestOption) AddCookie(c *http.Cookie) *RequestOption {
+	r.Cookies = append(r.Cookies, c)
+	return r
+}
+
+// SetBasicAuth sets the request's Authorization header to use HTTP Basic Authentication with the provided username and password.
+func (r *RequestOption) SetBasicAuth(username, password string) *RequestOption {
+	r.username = username
+	r.password = password
+	return r
+}
+
 // AcceptEncodingGZIP Accept-Encoding gzip
 func (r *RequestOption) AcceptEncodingGZIP() *RequestOption {
 	r.Headers[AcceptEncoding] = "gzip, deflate, br"

xhttp/response.go

@@ -4,10 +4,14 @@ import (
 	"encoding/json"
 	"encoding/xml"
 	"net/http"
+	"net/url"
 )
 
 // Message HTTP response
 type Message struct {
+	req *http.Request
+	res *http.Response
+
 	StatusCode int
 	Body       []byte
 	Header     http.Header
@@ -22,3 +26,23 @@ func (m Message) JSON(v interface{}) error {
 func (m Message) XML(v interface{}) error {
 	return xml.Unmarshal(m.Body, v)
 }
+
+// Cookies parses and returns the cookies set in the Set-Cookie headers.
+func (m Message) Cookies() []*http.Cookie {
+	return m.res.Cookies()
+}
+
+// Location returns the URL of the response's "Location" header, if present. Relative redirects are resolved relative to the Response's Request. ErrNoLocation is returned if no Location header is present.
+func (m Message) Location() (*url.URL, error) {
+	return m.res.Location()
+}
+
+// UserAgent returns the client's User-Agent, if sent in the request.
+func (m Message) UserAgent() string {
+	return m.req.UserAgent()
+}
+
+// Referer returns the referring URL, if sent in the request.
+func (m Message) Referer() string {
+	return m.req.Referer()
+}

xhttp/serve.go

@@ -24,7 +24,7 @@ func run(addr string, router http.Handler, option ServerOption) (errs, err error
 	errc := make(chan error)
 	go func() {
 		c := make(chan os.Signal, 1)
-		signal.Notify(c, syscall.SIGHUP, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGTERM)
+		signal.Notify(c, syscall.SIGHUP, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGTERM, os.Interrupt)
 		errc <- fmt.Errorf("%s", <-c)
 	}()