148 lines
3.2 KiB
Go
148 lines
3.2 KiB
Go
package http
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"crypto/tls"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type HttpTransport struct{}
|
|
|
|
func (t *HttpTransport) RoundTrip(req *Request) (*Response, error) {
|
|
var err error
|
|
var conn net.Conn
|
|
switch req.URL.Scheme {
|
|
case "http":
|
|
conn, err = net.Dial("tcp", req.ConnectPath)
|
|
case "https":
|
|
conn, err = tls.Dial("tcp", req.ConnectPath, nil)
|
|
default:
|
|
panic("scheme not support")
|
|
}
|
|
if err != nil {
|
|
return nil, errors.New("connect " + req.ConnectPath)
|
|
}
|
|
|
|
defer conn.Close()
|
|
|
|
WriteRequestDebugWrap(conn, req, WriteRequest)
|
|
return ReadResponseDebugWrap(conn, ReadResponse)
|
|
}
|
|
|
|
func WriteRequest(w io.Writer, req *Request) {
|
|
fmt.Fprintf(w, "%s %s %s\r\n", req.Method, req.URL.Path, req.Protocol)
|
|
|
|
for _, header := range req.Headers {
|
|
fmt.Fprintf(w, "%s: %s\r\n", header.Name, header.Value)
|
|
}
|
|
fmt.Fprintf(w, "\r\n")
|
|
|
|
if len(req.Body) > 0 {
|
|
fmt.Fprintf(w, "%s\r\n", req.Body)
|
|
}
|
|
}
|
|
|
|
func WriteRequestDebugWrap(w io.Writer, req *Request, f func(w io.Writer, req *Request)) {
|
|
buffer := &bytes.Buffer{}
|
|
|
|
f(buffer, req)
|
|
|
|
fmt.Println("----- Debug Info -----")
|
|
fmt.Println(buffer.String())
|
|
fmt.Println("----- Debug End Info -----")
|
|
|
|
w.Write(buffer.Bytes())
|
|
}
|
|
|
|
func ReadResponse(r io.Reader) (*Response, error) {
|
|
b := bufio.NewReader(r)
|
|
|
|
protocol, err := b.ReadString(' ')
|
|
if err != nil {
|
|
return nil, errors.New("read protocol")
|
|
}
|
|
protocol = protocol[:len(protocol)-1]
|
|
|
|
statusCode, err := b.ReadString(' ')
|
|
if err != nil {
|
|
return nil, errors.New("read statusCode")
|
|
}
|
|
statusCode = statusCode[:len(statusCode)-1]
|
|
|
|
statusMessage, err := b.ReadString('\r')
|
|
if err != nil {
|
|
return nil, errors.New("read statusMessage")
|
|
}
|
|
statusMessage = statusMessage[:len(statusMessage)-1]
|
|
|
|
if _, err := b.ReadString('\n'); err != nil {
|
|
return nil, errors.New("read LF")
|
|
}
|
|
|
|
headerStr := ""
|
|
contentLengthStr := ""
|
|
headers := []Header{}
|
|
for {
|
|
headerStr, err = b.ReadString('\n')
|
|
if err != nil {
|
|
return nil, errors.New("read header")
|
|
}
|
|
if headerStr == "\r\n" {
|
|
break
|
|
}
|
|
arr := strings.Split(headerStr, ": ")
|
|
value := strings.TrimSpace(arr[1])
|
|
header := Header{Name: arr[0], Value: value}
|
|
if header.Name == "Content-Length" {
|
|
contentLengthStr = header.Value
|
|
}
|
|
headers = append(headers, header)
|
|
}
|
|
|
|
length, err := strconv.Atoi(contentLengthStr)
|
|
if err != nil {
|
|
return nil, errors.New("read Content-Length")
|
|
}
|
|
|
|
body := make([]byte, 0, length)
|
|
|
|
for i := 0; i < length; i++ {
|
|
r, err := b.ReadByte()
|
|
if err != nil {
|
|
return nil, errors.New("read body")
|
|
}
|
|
body = append(body, r)
|
|
}
|
|
|
|
return &Response{
|
|
Protocol: protocol,
|
|
StatusCode: statusCode,
|
|
StatusMessage: statusMessage,
|
|
Headers: headers,
|
|
Body: body,
|
|
}, nil
|
|
}
|
|
|
|
func ReadResponseDebugWrap(r io.Reader, f func(r io.Reader) (*Response, error)) (*Response, error) {
|
|
resp, err := f(r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fmt.Println("----- Debug Info -----")
|
|
fmt.Printf("%s %s %s\n", resp.Protocol, resp.StatusCode, resp.StatusMessage)
|
|
for _, header := range resp.Headers {
|
|
fmt.Printf("%s: %s\n", header.Name, header.Value)
|
|
}
|
|
if len(resp.Body) > 0 {
|
|
fmt.Println(string(resp.Body))
|
|
}
|
|
fmt.Println("----- Debug End Info -----")
|
|
return resp, nil
|
|
}
|