How best to use render in negroni middleware? about render HOT 11 CLOSED

I tried to implement something along the lines of mikebthun/negronicql but I couldn't get it to work. Here's what I tried:

package renderer

import (
    "github.com/gorilla/context"
    "gopkg.in/unrolled/render.v1"
    "net/http"
)

type RenderMiddleware struct {
    Render *render.Render
}

func New(render *render.Render) *RenderMiddleware {
    return &RenderMiddleware{render}
}

func (render RenderMiddleware) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {

    // Attach the renderer
    context.Set(r, "Render", render.Render)

    // Call the next middleware handler
    next(rw, r)

}

Then in my package main I have:

    render := render.New(render.Options{})
    renderer := renderer.New(render)
    n.Use(renderer)

Then I can successfully use render := context.Get(r, "Render") later, but when I try to use render.JSON() I get this:

render.JSON undefined (type interface {} has no field or method JSON)

It's getting pretty late here, so I'm probably missing something obvious, in which case, if I work it out tomorrow morning, I'll post the answer here and close the ticket. :-)

from render.

Arg, found it. I knew it was something simple and stupid. Instead of render := context.Get(r, "Render") I need to use render := context.Get(req, "Render").(*render.Render). I knew it was simple. :-)

from render.

Glad you got it figured out!

from render.

Is this an advised solution? I've been trying to figure out the same thing, but it seems weird to attach an existing renderer on every single call to a middleware handler?

from render.

While the solution above works, I personally have taken a different approach in most of my apps. Just like you would normally create a global DB variable somewhere and always refer to that, I create a Render variable somewhere convenient and use that:

// Render is the global renderer for all views.
var Render *render.Render

// Then you can initialize it or add this to a setup method elsewhere.
func init() {
    Render = render.New(render.Options{
        // options live here
    })
}

from render.

Awesome, thanks a bunch!

from render.

@unrolled Thanks for sharing your example, really helpful. Are there any multi threading considerations here? Is Render threadsafe? In your example, it would be possible for two simultaneous executions of Render.JSON(), are there any variables which might cause issues there?

I'm super new to Go, so you probably know the idioms better than me. Is creating a single DB variable the idiomatic approach? I saw the negronicql package attaching the DB handler to the session, but that may be the exception rather than the norm. I'd be grateful for any opinion you want to share.

from render.

My very inexperienced and pretty crude reading of the render.go and engine.go code didn't find any potential thread conflicts, but I don't understand the paradigm nearly well enough to be anything like confident in my conclusion.

I'd guess if it's not possible to set any options after the Render instance has been created, then it's probably thread safe by default, but I'll wait for your reply @unrolled before jumping to any conclusions. :-)

from render.

A global render.Render object is threadsafe. Once it is initialized, the package is basically static. So no worries regarding race conditions or simultaneous executions.

For the DB variable, I would yes it's idiomatic to create a single instance and refer to that from everywhere. Be sure to refer to the global variable rather than passing the pointer along though, passing the pointer could led to issues if something changes the global variable.

A good example of this can be found here: https://github.com/sourcegraph/thesrc/blob/master/datastore/db.go

from render.

Can anyone help me Plz!
I want to make a separate package for routers and put all of my routes into this package and access them in my main package, according to url request, i'm using mux for routing and net/http.
Here is my main.go from Main Package

package main

import (
    "RESTMONGOMVC/controllers"
    "log"
    "net/http"

    "github.com/gorilla/mux"

    "gopkg.in/mgo.v2"
)

var (
    session    *mgo.Session
    collection *mgo.Collection
    err        error
)

func getSession() *mgo.Session {
    // Connect to our local mongo
    s, err := mgo.Dial("mongodb://localhost")

    // Check if connection error, is mongo running?
    if err != nil {
        panic(err)
    }

    // Deliver session
    return s
}
func main() {
    var err error
    r := mux.NewRouter()
    uc := controllers.NewNoteController(getSession())
    r.HandleFunc("/api/notes", uc.GetNotes).Methods("GET")
    r.HandleFunc("/api/notes", uc.CreateNote).Methods("POST")
    r.HandleFunc("/api/notes/{id}", uc.UpdateNote).Methods("PUT")
    r.HandleFunc("/api/notes/{id}", uc.DeleteNote).Methods("DELETE")
    http.Handle("/api/", r)
    http.Handle("/", http.FileServer(http.Dir(".")))
    log.Println("Starting Mongodb Session")
    session, err = mgo.Dial("localhost")
    if err != nil {
        panic(err)
    }
    defer session.Close()
    session.SetMode(mgo.Monotonic, true)
    collection = session.DB("notesdb").C("notes")
    log.Println("Listening on 8080")
    http.ListenAndServe(":8080", nil)
}

from render.

You can just export the *http.ServeMux represented by your r variable.

i.e.

package handler

// You could also pass in an *Env struct that embeds your mgo connection and other
// "application wide" services that your routes need to use.
func Routes(session *mgo.Session) *http.ServeMux {
    r := mux.NewRouter()
    uc := controllers.NewNoteController(getSession())
    r.HandleFunc("/api/notes", uc.GetNotes).Methods("GET")
    r.HandleFunc("/api/notes", uc.CreateNote).Methods("POST")
    r.HandleFunc("/api/notes/{id}", uc.UpdateNote).Methods("PUT")
    r.HandleFunc("/api/notes/{id}", uc.DeleteNote).Methods("DELETE")
    http.Handle("/api/", r)
    // Truncated for brevity

    return r
}

... and in your main package:

package main

func main() {
    r := handler.Routes(getSession())

    // Pass your `http.ServeMux` to ListenAndServe
    http.ListenAndServe(":8080", r)
}

Basic example but I hope that's clear. Further questions might be better off asked on https://groups.google.com/forum/?fromgroups#!forum/golang-nuts or http://stackoverflow.com/questions/tagged/go

from render.