func convertResponse(stdreq *http.Request, fastresp *fasthttp.Response) *http.Response { status := fastresp.Header.StatusCode() body := fastresp.Body() stdresp := &http.Response{ Request: stdreq, StatusCode: status, Status: http.StatusText(status), } fastresp.Header.VisitAll(func(k, v []byte) { sk := string(k) sv := string(v) if stdresp.Header == nil { stdresp.Header = make(http.Header) } stdresp.Header.Add(sk, sv) }) if fastresp.Header.ContentLength() == -1 { stdresp.TransferEncoding = []string{"chunked"} } if body != nil { stdresp.Body = ioutil.NopCloser(bytes.NewReader(body)) } else { stdresp.Body = ioutil.NopCloser(bytes.NewReader(nil)) } return stdresp }
func ExampleLBClient() { // Requests will be spread among these servers. servers := []string{ "google.com:80", "foobar.com:8080", "127.0.0.1:123", } // Prepare clients for each server var lbc fasthttp.LBClient for _, addr := range servers { c := &fasthttp.HostClient{ Addr: addr, } lbc.Clients = append(lbc.Clients, c) } // Send requests to load-balanced servers 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.Fatalf("Error when sending request: %s", err) } if resp.StatusCode() != fasthttp.StatusOK { log.Fatalf("unexpected status code: %d. Expecting %d", resp.StatusCode(), fasthttp.StatusOK) } useResponseBody(resp.Body()) } }
func fetchFromUpstream(h *fasthttp.RequestHeader, key []byte) *ybc.Item { upstreamUrl := fmt.Sprintf("%s://%s%s", *upstreamProtocol, *upstreamHost, h.RequestURI()) var req fasthttp.Request req.SetRequestURI(upstreamUrl) var resp fasthttp.Response err := upstreamClient.Do(&req, &resp) if err != nil { logRequestError(h, "Cannot make request for [%s]: [%s]", key, err) return nil } if resp.StatusCode() != fasthttp.StatusOK { logRequestError(h, "Unexpected status code=%d for the response [%s]", resp.StatusCode(), key) return nil } contentType := string(resp.Header.ContentType()) if contentType == "" { contentType = "application/octet-stream" } body := resp.Body() contentLength := len(body) itemSize := contentLength + len(contentType) + 1 txn, err := cache.NewSetTxn(key, itemSize, ybc.MaxTtl) if err != nil { logRequestError(h, "Cannot start set txn for response [%s], itemSize=%d: [%s]", key, itemSize, err) return nil } if err = storeContentType(h, txn, contentType); err != nil { txn.Rollback() return nil } n, err := txn.Write(body) if err != nil { logRequestError(h, "Cannot read response [%s] body with size=%d to cache: [%s]", key, contentLength, err) txn.Rollback() return nil } if n != contentLength { logRequestError(h, "Unexpected number of bytes copied=%d from response [%s] to cache. Expected %d", n, key, contentLength) txn.Rollback() return nil } item, err := txn.CommitItem() if err != nil { logRequestError(h, "Cannot commit set txn for response [%s], size=%d: [%s]", key, contentLength, err) return nil } atomic.AddInt64(&stats.BytesReadFromUpstream, int64(n)) return item }
func TestRouterServeFiles(t *testing.T) { router := New() recv := catchPanic(func() { router.ServeFiles("/noFilepath", os.TempDir()) }) if recv == nil { t.Fatal("registering path not ending with '*filepath' did not panic") } body := []byte("fake ico") ioutil.WriteFile(os.TempDir()+"/favicon.ico", body, 0644) router.ServeFiles("/*filepath", os.TempDir()) s := &fasthttp.Server{ Handler: router.Handler, } rw := &readWriter{} ch := make(chan error) rw.r.WriteString(string("GET /favicon.ico HTTP/1.1\r\n\r\n")) go func() { ch <- s.ServeConn(rw) }() select { case err := <-ch: if err != nil { t.Fatalf("return error %s", err) } case <-time.After(500 * time.Millisecond): t.Fatalf("timeout") } br := bufio.NewReader(&rw.w) var resp fasthttp.Response if err := resp.Read(br); err != nil { t.Fatalf("Unexpected error when reading response: %s", err) } if resp.Header.StatusCode() != 200 { t.Fatalf("Unexpected status code %d. Expected %d", resp.Header.StatusCode(), 423) } if !bytes.Equal(resp.Body(), body) { t.Fatalf("Unexpected body %q. Expected %q", resp.Body(), string(body)) } }
func TestRouterNotAllowed(t *testing.T) { handlerFunc := func(_ *fasthttp.RequestCtx, _ Params) {} router := New() router.POST("/path", handlerFunc) // Test not allowed s := &fasthttp.Server{ Handler: router.Handler, } rw := &readWriter{} ch := make(chan error) rw.r.WriteString("GET /path HTTP/1.1\r\n\r\n") go func() { ch <- s.ServeConn(rw) }() select { case err := <-ch: if err != nil { t.Fatalf("return error %s", err) } case <-time.After(100 * time.Millisecond): t.Fatalf("timeout") } br := bufio.NewReader(&rw.w) var resp fasthttp.Response if err := resp.Read(br); err != nil { t.Fatalf("Unexpected error when reading response: %s", err) } if !(resp.Header.StatusCode() == fasthttp.StatusMethodNotAllowed) { t.Errorf("NotAllowed handling failed: Code=%d, Header=%v", resp.Header.StatusCode(), resp.Header) } else if allow := string(resp.Header.Peek("Allow")); allow != "POST, OPTIONS" { t.Error("unexpected Allow header value: " + allow) } // add another method router.DELETE("/path", handlerFunc) router.OPTIONS("/path", handlerFunc) // must be ignored // test again rw.r.WriteString("GET /path HTTP/1.1\r\n\r\n") go func() { ch <- s.ServeConn(rw) }() select { case err := <-ch: if err != nil { t.Fatalf("return error %s", err) } case <-time.After(100 * time.Millisecond): t.Fatalf("timeout") } if err := resp.Read(br); err != nil { t.Fatalf("Unexpected error when reading response: %s", err) } if !(resp.Header.StatusCode() == fasthttp.StatusMethodNotAllowed) { t.Errorf("NotAllowed handling failed: Code=%d, Header=%v", resp.Header.StatusCode(), resp.Header) } else if allow := string(resp.Header.Peek("Allow")); allow != "POST, DELETE, OPTIONS" && allow != "DELETE, POST, OPTIONS" { t.Error("unexpected Allow header value: " + allow) } responseText := "custom method" router.MethodNotAllowed = fasthttp.RequestHandler(func(ctx *fasthttp.RequestCtx) { ctx.SetStatusCode(fasthttp.StatusTeapot) ctx.Write([]byte(responseText)) }) rw.r.WriteString("GET /path HTTP/1.1\r\n\r\n") go func() { ch <- s.ServeConn(rw) }() select { case err := <-ch: if err != nil { t.Fatalf("return error %s", err) } case <-time.After(100 * time.Millisecond): t.Fatalf("timeout") } if err := resp.Read(br); err != nil { t.Fatalf("Unexpected error when reading response: %s", err) } if !bytes.Equal(resp.Body(), []byte(responseText)) { t.Errorf("unexpected response got %q want %q", string(resp.Body()), responseText) } if resp.Header.StatusCode() != fasthttp.StatusTeapot { t.Errorf("unexpected response code %d want %d", resp.Header.StatusCode(), fasthttp.StatusTeapot) } if allow := string(resp.Header.Peek("Allow")); allow != "POST, DELETE, OPTIONS" && allow != "DELETE, POST, OPTIONS" { t.Error("unexpected Allow header value: " + allow) } }