render into io.Writer

cmd/magnaserv/magnaserv.go

@@ -106,29 +106,26 @@ func (s *magnaserv) render(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	var b []byte
+	w.Header().Add("Content-Type", "image/png")
 	if renderer == "mapserver" {
 		mapReq.Format = mapReq.Query.Get("FORMAT") // use requested format, not internal mapnik format
 		if s.mapserverRenderer == nil {
 			err = errors.New("mapserver not initialized")
 		}
-		b, err = s.mapserverRenderer.Render(styleFile, renderReq(mapReq))
+		err = s.mapserverRenderer.Render(styleFile, w, renderReq(mapReq))
 	} else {
 		if s.mapnikRenderer == nil {
 			err = errors.New("mapnik not initialized")
 		} else {
-			b, err = s.mapnikRenderer.Render(styleFile, renderReq(mapReq))
+			err = s.mapnikRenderer.Render(styleFile, w, renderReq(mapReq))
 		}
 	}
+	s.internalError(w, r, errors.New("text"))
+
 	if err != nil {
 		s.internalError(w, r, err)
 		return
 	}
-
-	w.Header().Add("Content-Type", "image/png")
-	w.Header().Add("Content-Length", strconv.FormatUint(uint64(len(b)), 10))
-
-	io.Copy(w, bytes.NewBuffer(b))
 }
 
 func (s *magnaserv) projects(w http.ResponseWriter, r *http.Request) {
@@ -229,6 +226,7 @@ func writeCheckedJSON(r io.ReadCloser, fileName string) error {
 
 func (s *magnaserv) internalError(w http.ResponseWriter, r *http.Request, err error) {
 	log.Print(err)
+	w.Header().Set("Content-type", "text/plain")
 	w.WriteHeader(http.StatusInternalServerError)
 	w.Write([]byte("internal error"))
 }

regression/regression_test.go

@@ -225,11 +225,14 @@ func renderMapnik(t *testing.T, c testCase, name string) {
 	if mapnikRenderer == nil {
 		t.Skip("mapnik not initialized")
 	}
-	buf, err := mapnikRenderer.Render(filepath.Join(caseBuildDir, name+".xml"), mapReq)
+
+	f, err := os.Create(filepath.Join(caseBuildDir, "render-"+name+".png"))
 	if err != nil {
 		t.Fatal(err)
 	}
-	if err := ioutil.WriteFile(filepath.Join(caseBuildDir, "render-"+name+".png"), buf, 0644); err != nil {
+	defer f.Close()
+	err = mapnikRenderer.Render(filepath.Join(caseBuildDir, name+".xml"), f, mapReq)
+	if err != nil {
 		t.Fatal(err)
 	}
 }
@@ -247,11 +250,14 @@ func renderMapserver(t *testing.T, c testCase) {
 	if mapserverRenderer == nil {
 		t.Skip("mapserver not initialized")
 	}
-	buf, err := mapserverRenderer.Render(filepath.Join(caseBuildDir, "magnacarto.map"), mapReq)
+
+	f, err := os.Create(filepath.Join(caseBuildDir, "render-magnacarto-ms.png"))
 	if err != nil {
 		t.Fatal(err)
 	}
-	if err := ioutil.WriteFile(filepath.Join(caseBuildDir, "render-magnacarto-ms.png"), buf, 0644); err != nil {
+	defer f.Close()
+	err = mapserverRenderer.Render(filepath.Join(caseBuildDir, "magnacarto.map"), f, mapReq)
+	if err != nil {
 		t.Fatal(err)
 	}
 }

render/mapnik.go

@@ -1,7 +1,9 @@
 package render
 
 import (
+	"bytes"
 	"errors"
+	"io"
 	"net/rpc"
 	"os"
 	"os/exec"
@@ -58,14 +60,18 @@ func (m *Mapnik) RegisterFonts(fontDir string) error {
 	return err
 }
 
-func (m *Mapnik) Render(mapfile string, mapReq Request) ([]byte, error) {
+func (m *Mapnik) Render(mapfile string, dst io.Writer, mapReq Request) error {
 	if m.client == nil {
-		return nil, errors.New("mapnik plugin not initialized")
+		return errors.New("mapnik plugin not initialized")
 	}
 	var buf []byte
 	err := m.client.Call("Mapnik.Render", struct {
 		Mapfile string
 		Req     Request
 	}{mapfile, mapReq}, &buf)
-	return buf, err
+	if err != nil {
+		return err
+	}
+	_, err = io.Copy(dst, bytes.NewBuffer(buf))
+	return err
 }

render/mapserver.go

@@ -1,8 +1,8 @@
 package render
 
 import (
-	"bytes"
 	"fmt"
+	"io"
 	"net/http"
 	"net/http/cgi"
 	"net/url"
@@ -24,7 +24,7 @@ func NewMapServer() (*MapServer, error) {
 	return &MapServer{bin: bin}, nil
 }
 
-func (m *MapServer) Render(mapfile string, mapReq Request) ([]byte, error) {
+func (m *MapServer) Render(mapfile string, dst io.Writer, mapReq Request) error {
 	if !filepath.IsAbs(mapfile) {
 		if wd, err := os.Getwd(); err == nil {
 			mapfile = filepath.Join(wd, mapfile)
@@ -58,23 +58,23 @@ func (m *MapServer) Render(mapfile string, mapReq Request) ([]byte, error) {
 	}
 
 	w := &responseRecorder{
-		Body: &bytes.Buffer{},
+		Body: dst,
 	}
 
 	req, err := http.NewRequest("GET", "/?"+q.Encode(), nil)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	handler.ServeHTTP(w, req)
 
 	if w.Code != 200 {
-		return nil, fmt.Errorf("error while calling mapserv CGI (status %d): %v", w.Code, string(w.Body.Bytes()))
+		return fmt.Errorf("error while calling mapserv CGI (status %d)", w.Code)
 	}
 	if ct := w.Header().Get("Content-type"); ct != "" && !strings.HasPrefix(ct, "image") {
-		return nil, fmt.Errorf(" mapserv CGI did not return image (%v)\n%v", w.Header(), string(w.Body.Bytes()))
+		return fmt.Errorf(" mapserv CGI did not return image (%v)", w.Header())
 	}
-	return w.Body.Bytes(), nil
+	return nil
 }
 
 // responseRecorder from net/http/httptest
@@ -83,9 +83,9 @@ func (m *MapServer) Render(mapfile string, mapReq Request) ([]byte, error) {
 // responseRecorder is an implementation of http.ResponseWriter that
 // records its mutations for later inspection in tests.
 type responseRecorder struct {
-	Code      int           // the HTTP response code from WriteHeader
-	HeaderMap http.Header   // the HTTP response headers
-	Body      *bytes.Buffer // if non-nil, the bytes.Buffer to append written data to
+	Code      int         // the HTTP response code from WriteHeader
+	HeaderMap http.Header // the HTTP response headers
+	Body      io.Writer   // if non-nil, the io.Writer to append written data to
 	Flushed   bool
 
 	wroteHeader bool