使用Golang转发HTTP流数据

package main

import (
	"fmt"
	"net/http"
	"strings"
	"flag"
)

var(
	serverAddr string
)



func main() {
	flag.StringVar(&serverAddr,"addr",":80","server listen addr")
	flag.Parse()
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		_, _ = w.Write([]byte("radio relay server"))
	})
	http.HandleFunc("/play", handlePlay)
	_ = http.ListenAndServe(serverAddr, nil)
}

//提取http头中包含icy-的key-value对
func extractIcyHeaders(headers map[string][]string) map[string]string{
	icyHeaders := make(map[string] string)
	for k, v := range headers{
		k=strings.ToLower(k)
		if strings.HasPrefix(k,"icy-"){
			if len(v)==0{
				icyHeaders[k]=""
			}else{
				icyHeaders[k]=v[0]
			}
		}
	}
	return icyHeaders
}

func sendRequest(url string, icyRequestHeaders map[string]string) *http.Response {
	if len(url)<5{
		fmt.Println("url length too short!")
		return nil
	}
	client := &http.Client{}
	request, err:= http.NewRequest("GET", url, nil)
	if err != nil {
		fmt.Println(err.Error())
		return nil
	}
	for k, v := range icyRequestHeaders {
		request.Header[k]=[]string{v}
	}
	response, err := client.Do(request)
	if err != nil {
		fmt.Println(err.Error())
		return nil
	}
	return response
}



func receiveBody(response *http.Response) (exitChan chan struct{},dataChan chan []byte){
    exitChan=make(chan struct{})
	dataChan=make(chan []byte, 10)
	go func() {
		defer close(dataChan)
		defer response.Body.Close()
		for {
			select {
			case <-exitChan:
				fmt.Println("exit receive data!")
				return
			default:{
				buf := make([]byte, 4096)
				n, err:= response.Body.Read(buf)
				if err != nil || n == 0{
					fmt.Println("receive data error!")
					return
				}else{
					dataChan <-buf[:n]
				}
			}
			}
		}
	}()
	return
}


func setResponseHeaders(w http.ResponseWriter,response *http.Response){
	w.Header().Set("Content-Type","audio/mpeg")
	w.Header().Set("transfer-encoding","identity")
	icyResponseHeaders:=extractIcyHeaders(response.Header)
	for k, v := range icyResponseHeaders {
		w.Header()[k]=[]string{v}
	}
}

func sendBody(w http.ResponseWriter, dataChan <-chan []byte) {
	for {
		data,ok := <-dataChan
		if (!ok){
			fmt.Println("receive data error!")
			break
		}
		n, err := w.Write(data)
		if err != nil || n == 0 {
			fmt.Println("send data error!")
			break
		}
	}
}



func handlePlay(w http.ResponseWriter, r *http.Request) {
	_ = r.ParseForm()
	url:=r.Form.Get("url")
	response:=sendRequest(url,extractIcyHeaders(r.Form));
	if (response!=nil){
		setResponseHeaders(w,response)
		exitChan,dataChan:=receiveBody(response);
		sendBody(w, dataChan)
		close(exitChan)
	}else{
		w.WriteHeader(500)
	}
}