fasthttp高性能之道（二）

package main

import (
	"log"

	"github.com/valyala/fasthttp"
)

func main() {
	status, body, err := fasthttp.Get(nil, "https://www.baidu.com")
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("status: %v, body: %s", status, string(body))
}

import (
	"log"
	"time"

	"github.com/valyala/fasthttp"
)

var (
	// HTTPClient global http client object
	client *fasthttp.Client = &fasthttp.Client{
		MaxConnsPerHost: 16384, // MaxConnsPerHost  default is 512, increase to 16384
		ReadTimeout:     5 * time.Second,
		WriteTimeout:    5 * time.Second,
	}
)

func main() {
	req := fasthttp.AcquireRequest()
	req.SetRequestURI("http://127.0.0.1:29898/api/v1/report")
	req.Header.SetMethod("POST")
	req.Header.SetContentType("text/plain")
	req.SetBody([]byte("hello world"))

	resp := fasthttp.AcquireResponse()

	defer fasthttp.ReleaseResponse(resp)
	defer fasthttp.ReleaseRequest(req)

	if err := client.Do(req, resp); err != nil {
		log.Fatal(err)
	}

	log.Println(resp)
}

package main

import (
	"github.com/valyala/fasthttp"
	"log"
	"os"
)

var (
	client = &fasthttp.HostClient{
		Addr: "localhost:19898,localhost:29898",
	}
	body = make([]byte, 4096)
)

func main() {
	if len(os.Args) < 2 {
		log.Fatalf("Missing url")
	}
	urls := os.Args[1:]
	for _, url := range urls {
		statusCode, body, err := client.Get(body, url)
		if err != nil {
			log.Fatalf("Error when loading page %s through local proxy: %s", url, err)
		}
		if statusCode != fasthttp.StatusOK {
			log.Fatalf("Unexpected status code: %d. Expecting %d", statusCode, fasthttp.StatusOK)
		}
		log.Printf("body: %s\n", string(body))
	}
}

func (c *HostClient) Do(req *Request, resp *Response) error {
	var err error
	var retry bool
	maxAttempts := c.MaxIdemponentCallAttempts
	if maxAttempts <= 0 {
		maxAttempts = DefaultMaxIdemponentCallAttempts
	}
	attempts := 0

	atomic.AddInt32(&c.pendingRequests, 1)
	for {
		retry, err = c.do(req, resp)
		if err == nil || !retry {
			break
		}

		if !isIdempotent(req) {
			// Retry non-idempotent requests if the server closes
			// the connection before sending the response.
			//
			// This case is possible if the server closes the idle
			// keep-alive connection on timeout.
			//
			// Apache and nginx usually do this.
			if err != io.EOF {
				break
			}
		}
		attempts++
		if attempts >= maxAttempts {
			break
		}
	}
	atomic.AddInt32(&c.pendingRequests, -1)

	if err == io.EOF {
		err = ErrConnectionClosed
	}
	return err
}

func (c *HostClient) do(req *Request, resp *Response) (bool, error) {
	nilResp := false
	if resp == nil {
		nilResp = true
		resp = AcquireResponse()
	}

	ok, err := c.doNonNilReqResp(req, resp)

	if nilResp {
		ReleaseResponse(resp)
	}

	return ok, err
}

func (c *HostClient) doNonNilReqResp(req *Request, resp *Response) (bool, error) {
	// ...
	atomic.StoreUint32(&c.lastUseTime, uint32(time.Now().Unix()-startTimeUnix))

	resp.Reset()

	// ...
	cc, err := c.acquireConn()
	if err != nil {
		return false, err
	}
	conn := cc.c

	resp.parseNetConn(conn)

	// ...
	bw := c.acquireWriter(conn)
	err = req.Write(bw)

	// ...
	c.releaseWriter(bw)

	// ...
	br := c.acquireReader(conn)
	// ...
	c.releaseReader(br)

	if resetConnection || req.ConnectionClose() || resp.ConnectionClose() {
		c.closeConn(cc)
	} else {
		c.releaseConn(cc)
	}

	return false, err
}

	mLock sync.Mutex
	m     map[string]*HostClient
	ms    map[string]*HostClient

import (
    "fmt"
    "log"

    "github.com/valyala/fasthttp"
)

var (
    lbc fasthttp.LBClient
)

func main() {
    servers := []string{
        "127.0.0.1:8888",
        "127.0.0.1:9999",
    }

    for _, addr := range servers {
        c := &fasthttp.HostClient{
            Addr: addr,
        }
        lbc.Clients = append(lbc.Clients, c)
    }

    var req fasthttp.Request
    var resp fasthttp.Response
    for i := 0; i < 10; i++ {
        url := fmt.Sprintf("http://abcedfg/foo/bar/%d", i)
        req.SetRequestURI(url)
        if err := lbc.Do(&req, &resp); err != nil {
            log.Printf("Error when sending request: %s", err)
            continue
        }
        if resp.StatusCode() != fasthttp.StatusOK {
            log.Printf("unexpected status code: %d. Expecting %d", resp.StatusCode(), fasthttp.StatusOK)
            continue
        }

        log.Println(resp.Body())
    }
}

func (c *lbClient) DoDeadline(req *Request, resp *Response, deadline time.Time) error {
	err := c.c.DoDeadline(req, resp, deadline)
	if !c.isHealthy(req, resp, err) && c.incPenalty() {
		// Penalize the client returning error, so the next requests
		// are routed to another clients.
		time.AfterFunc(penaltyDuration, c.decPenalty)
	}
	return err
}