sse client

[chrisfeng0723]

I simulated an SSE client with net/http and can receive pushes from the SSE server. However, with resty, the data is pushed all at once. The code is as follows. Do I need any other settings?

       client := resty.New()
    resp, err := client.R().
        EnableTrace().
        SetHeader("Content-Type", "application/json").
        SetBody(value).
        Post("localhost:8080/stream")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.RawBody().Close()

    reader := bufio.NewReader(resp.RawBody())
    for {

        line, err := reader.ReadString('\n')
        if err != nil {
            break
        }
        fmt.Println(line)
    }

[xuji-cny]

I have the same doubt

[xiaziheng98]

I have the same doubt too

[jeevatkm]

@chrisfeng0723 In resty response, body read fully at once. It is not a stream. Maybe you could try https://pkg.go.dev/github.com/go-resty/resty/v2#Request.SetDoNotParseResponse and handle the body yourself. However, it will not be an actual SSE experience.

I may think of adding an SSE client in the v3.

[gospider007]

this can help you : https://github.com/gospider007/requests/blob/master/test/protocol/sse_test.go

[CermakM]

SSE client would be very appreciated! 🙏

[sosyz]

maybe this code can help you

func TestSSE(t *testing.T) {
    // Start the server
    go func() {
        err := http.ListenAndServe(":5000", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            w.Header().Set("Content-Type", "text/event-stream")
            w.Header().Set("Cache-Control", "no-cache")
            w.Header().Set("Connection", "keep-alive")
            for i := 0; i < 3; i++ {
                _, err := w.Write([]byte(fmt.Sprintf("%d\n", i)))
                if err != nil {
                    t.Log("Error writing SSE event:", err)
                    return
                }

                if f, ok := w.(http.Flusher); ok {
                    f.Flush()
                }
                time.Sleep(1 * time.Second)
            }
        }))
        if err != nil {
            t.Error(err)
        }
    }()
    time.Sleep(time.Second * 3)

    resp, err := resty.New().
        R().
        SetDoNotParseResponse(true).
        Get("http://localhost:5000")
    if err != nil {
        t.Error(err)
    }
    defer resp.RawResponse.Body.Close()

    scanner := bufio.NewScanner(resp.RawResponse.Body)
    reply := ""
    for scanner.Scan() {
        _res := scanner.Text()
        if _res == "" {
            continue
        }
        reply += _res
        t.Log(_res)
    }

    t.Log(reply)
}