I experiment with steaming video and can't explain the following behaviour. I get different response headers from Go's net/http server, from two different handlers, when the only difference is where I declare my buffer.
In the code below there are two handlers where the only difference is that one handler declares the buffer locally. in that version the streaming works correctly, Chrome stream the video, I see it gets response with Transfer-Encoding: chunked and content-type: video/mp4.
In the second version where the buffer is an input param, Chrome doesn't stream the video and the headers are different.
package main
import (
"bytes"
"io"
"log"
"net/http"
"os"
)
func main() {
file := "/Users/someUser/Documents/Zoom/Ronen/zoom_0.mp4"
f, err := os.Open(file)
defer f.Close()
if err != nil {
log.Fatalln(err)
}
http.ListenAndServe(":9008", GetVidHandler(f))
}
//This implementation works, buff is declared locally.
//I get header of content-type video/mp4
func GetVidHandler(f *os.File) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
offset := int64(0)
var buff [4096]byte
for {
n, _ := f.ReadAt(buff[:], offset)
offset += int64(n)
re := bytes.NewReader(buff[:])
io.Copy(w, re)
}
}
}
//This implementation doesn't stream, buff is input param
//I get header of content-type octet-stream
func GetVidHandler(f *os.File, buff [4096]byte) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
offset := int64(0)
for {
n, _ := f.ReadAt(buff[:], offset)
offset += int64(n)
re := bytes.NewReader(buff[:])
io.Copy(w, re)
}
}
}
Thanks for the comments, but fixing them still don't change the behaviour. Foe example the following code gets
write tcp 127.0.0.1:9008->127.0.0.1:60443: write: broken pipe
package main
import (
"bytes"
"io"
"log"
"net/http"
"os"
)
type Viewer struct {
ch chan []byte
buff [3][4096]byte
}
func main() {
file := "/Users/someUSer/Documents/Zoom/Ronen/zoom_0.mp4"
f, err := os.Open(file)
defer f.Close()
if err != nil {
log.Fatalln(err)
}
m := make(map[int]*Viewer)
start := make(chan struct{})
go func() {
offset := int64(0)
<-start
log.Println("Starting...")
i := 0
for {
var b [4096]byte
n, err := f.ReadAt(b[:], offset)
if err != nil {
log.Println(err)
return
}
offset += int64(n)
for _, v := range m {
copy(v.buff[i%3][:], b[:n])
v.ch <- v.buff[i%3][:n]
}
i++
}
}()
http.ListenAndServe(":9008", GetVidHandler(m, start))
}
func GetVidHandler(m map[int]*Viewer, start chan struct{}) http.HandlerFunc {
i := 0
return func(w http.ResponseWriter, r *http.Request) {
current := i
v := &Viewer{ch: make(chan []byte)}
m[current] = v
i++
select {
case start <- struct{}{}:
default:
}
cn, ok := w.(http.CloseNotifier)
if !ok {
http.NotFound(w, r)
return
}
// flusher, ok := w.(http.Flusher)
// if !ok {
// http.NotFound(w, r)
// return
// }
// Send the initial headers saying we're gonna stream the response.
// w.Header().Set("Transfer-Encoding", "chunked")
// w.Header().Set("Content-Type", "video/mp4")
// w.WriteHeader(http.StatusOK)
// // flusher.Flush()
// b := <-v.ch
// log.Println(current, "-Writing ", len(b), " Bytes")
// log.Printf("%d - WRITE - First 100 bytes %v
", current, b[:100])
// w.Write(b[:len(b)])
// flusher.Flush()
for {
select {
case <-cn.CloseNotify():
log.Println("Client stopped listening")
return
default:
b := <-v.ch
re := bytes.NewReader(b[:])
_, err := io.Copy(w, re)
if err != nil {
log.Println(err)
}
}
}
}
}
//Works
// func GetVidHandler(f *os.File) http.HandlerFunc {
// return func(w http.ResponseWriter, r *http.Request) {
// offset := int64(0)
// var buff [4096]byte
// for {
// n, _ := f.ReadAt(buff[:], offset)
// log.Printf("WRITE - First 100 bytes %v
", buff[:100])
// offset += int64(n)
// re := bytes.NewReader(buff[:])
// io.Copy(w, re)
// }
// }
// }