func (r RrdFetchTsvResult) Apply(req *revel.Request, resp *revel.Response) {
revel.TRACE.Printf("Apply start\n")
resp.WriteHeader(http.StatusOK, "text/tab-separated-values")
resp.Out.Write([]byte("date\tvalue\n"))
data := r.data
row := 0
for ti := data.Start.Add(data.Step); ti.Before(data.End) || ti.Equal(data.End); ti = ti.Add(data.Step) {
v := data.ValueAt(0, row)
line := fmt.Sprintf("%d\t%e\n", ti.Unix(), v)
resp.Out.Write([]byte(line))
row++
}
revel.TRACE.Printf("Apply exit\n")
/*
origStep := r.origStep * 1000
jStep := origStep / int(step)
if jStep < 1 {
jStep = 1
}
// TODO: Calculate max, average and such if jStep > 1
revel.TRACE.Printf("jStep=%d, step=%d, origStep=%d\n", jStep, step, origStep)
for j := 0; j < data.RowLen; j += jStep {
t := start + int64(j + 1) * step
v := data.ValueAt(0, j)
if j > 0 && math.IsNaN(v) {
break
}
line := fmt.Sprintf("%d\t%e\n", t, v)
resp.Out.Write([]byte(line))
}
*/
}
// Custom responses -----------------------------------------------------------
// Custom response for image
func (r ImageResponse) Apply(req *revel.Request, resp *revel.Response) {
// FIX:
// If settings loaded out of actions then revel throws nil pointer, so we
// load here the first time only
if font == nil {
fontPath, _ := revel.Config.String("gummyimage.fontpath")
font, _ = gummyimage.LoadFont(fontPath)
}
resp.WriteHeader(http.StatusOK, "image/png")
g, _ := gummyimage.NewDefaultGummy(r.sizeX, r.sizeY, r.bgColor)
g.Font = font
// Custom text?
if len(r.text) == 0 {
g.DrawTextSize(r.fgColor)
} else {
g.DrawTextCenter(r.text, r.fgColor)
}
b := new(bytes.Buffer)
g.Get(r.format, b)
resp.Out.Write(b.Bytes())
}
func (r dynamicImage) Apply(req *revel.Request, resp *revel.Response) {
buffer := bytes.NewBufferString("digraph callgraph{\n")
if r.searchType == "caller" {
var visitedCallers = sort.StringSlice{r.funcName}
callers, ok := allCallers[r.dataSource]
if ok {
r.calcCalls(&callers, r.funcName, 0, buffer, visitedCallers)
}
} else {
var visitedCallees = sort.StringSlice{r.funcName}
callees, ok := allCallees[r.dataSource]
if ok {
r.calcCalls(&callees, r.funcName, 0, buffer, visitedCallees)
}
}
buffer.WriteString("}")
/* set direction */
param0 := "-Grankdir=" + r.direction
cmdDot := exec.Command("dot", param0, "-Tpng")
cmdDot.Stdin = bytes.NewReader(buffer.Bytes())
output, err := cmdDot.Output()
if err != nil {
resp.WriteHeader(http.StatusOK, "text/html")
resp.Out.Write([]byte("No image: " + err.Error()))
return
}
resp.WriteHeader(http.StatusOK, "image/png")
resp.Out.Write(output)
}
func (r RrdFilesResult) Apply(req *revel.Request, resp *revel.Response) {
revel.TRACE.Printf("RrdFilesResult Apply start\n")
resp.WriteHeader(http.StatusOK, "text/plain")
for _, fi := range r.infos {
line := fmt.Sprintf("%s\n", fi.Name())
resp.Out.Write([]byte(line))
}
revel.TRACE.Printf("RrdFilesResult Apply end\n")
}
// Render the Templates into the Response, handles errors and panics using the
// same mechanisms of revel.
func (r *RenderLayoutTemplateResult) Apply(req *revel.Request, resp *revel.Response) {
// Handle panics when rendering templates.
defer func() {
if err := recover(); err != nil {
revel.ERROR.Println(err)
revel.PlaintextErrorResult{fmt.Errorf("Template Execution Panic in %s:\n%s",
r.Template.Name(), err)}.Apply(req, resp)
}
}()
chunked := revel.Config.BoolDefault("results.chunked", false)
r.RenderTmpl[""] = r.Template
r.RenderArgs["ContentForItems"] = r.RenderTmpl
// If it's a HEAD request, throw away the bytes.
out := io.Writer(resp.Out)
if req.Method == "HEAD" {
out = ioutil.Discard
}
// In a prod mode, write the status, render, and hope for the best.
// (In a dev mode, always render to a temporary buffer first to avoid having
// error pages distorted by HTML already written)
if chunked && !revel.DevMode {
resp.WriteHeader(http.StatusOK, "text/html")
if r.Layout == nil {
r.render(req, resp, out)
} else {
r.renderWithLayout(req, resp, out)
}
return
}
// Render the template into a temporary buffer, to see if there was an error
// rendering the template. If not, then copy it into the response buffer.
// Otherwise, template render errors may result in unpredictable HTML (and
// would carry a 200 status code)
var b bytes.Buffer
if r.Layout == nil {
r.render(req, resp, &b)
} else {
r.renderWithLayout(req, resp, &b)
}
if !chunked {
resp.Out.Header().Set("Content-Length", strconv.Itoa(b.Len()))
}
resp.WriteHeader(http.StatusOK, "text/html")
b.WriteTo(out)
}
func (r FResponse404) Apply(req *revel.Request, resp *revel.Response) {
var b []byte
var err error
if revel.Config.BoolDefault("results.pretty", false) {
b, err = json.MarshalIndent(r.obj, "", " ")
} else {
b, err = json.Marshal(r.obj)
}
if err != nil {
revel.ErrorResult{Error: err}.Apply(req, resp)
return
}
resp.WriteHeader(http.StatusNotFound, "application/json")
resp.Out.Write(b)
}
func (r *RenderLayoutTemplateResult) renderError(req *revel.Request, resp *revel.Response, err error) {
var templateContent []string
templateName, line, description := parseTemplateError(err)
if templateName == "" {
templateName = r.Layout.Name()
templateContent = r.Layout.Content()
} else {
if tmpl, err := revel.MainTemplateLoader.Template(templateName); err == nil {
templateContent = tmpl.Content()
}
}
compileError := &revel.Error{
Title: "Layout Execution Error",
Path: templateName,
Description: description,
Line: line,
SourceLines: templateContent,
}
resp.Status = 500
revel.ERROR.Printf("Template Execution Error (in %s): %s", templateName, description)
revel.ErrorResult{r.RenderArgs, compileError}.Apply(req, resp)
}
func (r RssXml) Apply(req *revel.Request, resp *revel.Response) {
resp.WriteHeader(http.StatusOK, "application/xml")
resp.Out.Write([]byte(r))
}
// This will get called for Cert/Key downloads to manage HTTP Headers
func (r Download) Apply(req *revel.Request, resp *revel.Response) {
resp.WriteHeader(http.StatusOK, "text/plain") //Browser can open
//resp.WriteHeader(http.StatusOK, "application/text")//Forces Browser to download
resp.Out.Write([]byte(r))
}
func (r LoginResult) Apply(req *revel.Request, resp *revel.Response) {
resp.WriteHeader(r.StatusCode, "text/html")
resp.Out.Write([]byte(r.Message))
}
func (r HTML) Apply(req *revel.Request, resp *revel.Response) {
resp.WriteHeader(http.StatusOK, "text/html")
resp.Out.Write([]byte(r))
}
// Set HTTP header types for returning image(not html page)
func (r JPGImage) Apply(req *revel.Request, resp *revel.Response) {
// Output screenshot
resp.WriteHeader(http.StatusOK, "image/jpg")
resp.Out.Write(r)
}
func (u Utf8Result) Apply(req *revel.Request, resp *revel.Response) {
resp.WriteHeader(resp.Status, "text/plain; charset=utf-8")
resp.Out.Write([]byte(u))
}
// Marshals the Responder instance as the body response as Json.
// The Responder's implementation of GetHttpStatus() will be used
// as the Http status code in the response.
// The Responder's implementation of GetErroLogString() will be used
// to log to revel.Error.
func (r JsonErrorResult) Apply(req *revel.Request, resp *revel.Response) {
responseData, _ := json.Marshal(r.Responder)
resp.WriteHeader((*r.Responder).GetHttpStatus(), "application/json")
resp.Out.Write(responseData)
revel.ERROR.Printf("Error response: HTTP-%d : %s", (*r.Responder).GetHttpStatus(), (*r.Responder).GetErroLogString())
}