func (h Handle) ServeHTTP(w http.ResponseWriter, r *http.Request) {
requestLog.Info("%v %v", r.Method, r.RequestURI)
for _, initializer := range initializers {
initializer(r)
}
buffer := new(httpbuf.Buffer)
err := h(buffer, r)
if err != nil {
fmt.Println(err)
if webErr, ok := err.(WebError); ok {
http.Error(w, webErr.Message, webErr.Code)
} else {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}
err = Session(r).Save(r, buffer)
context.Clear(r)
buffer.Apply(w)
}
// ServeHTTP builds the context and passes onto the real handler
func (h handler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
// Create the context
ctx, err := NewContext(req)
if err != nil {
log.LogError("Failed to create context: %v", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
defer ctx.Close()
// Run the handler, grab the error, and report it
buf := new(httpbuf.Buffer)
log.LogTrace("Web: %v %v %v %v", req.RemoteAddr, req.Proto, req.Method, req.RequestURI)
err = h(buf, req, ctx)
if err != nil {
log.LogError("Error handling %v: %v", req.RequestURI, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
// Save the session
if err = ctx.Session.Save(req, buf); err != nil {
log.LogError("Failed to save session: %v", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
// Apply the buffered response to the writer
buf.Apply(w)
}
func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
ctx, err := models.NewContext(r, store, dbmap, cache)
if err != nil {
fmt.Println("Call to NewContext() returned error.")
log.Println(err)
}
if ctx.User != nil {
activityCache[ctx.User.ID] = time.Now()
fmt.Println("Hashed new user ID in ServeHTTP()")
log.Println(ctx.User.ID)
}
defer ctx.Close()
buffer := new(httpbuf.Buffer)
err = h(buffer, r, ctx)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if err = ctx.Session.Save(r, buffer); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
buffer.Apply(w)
}
/*
Middleware that buffers all http output. This permits
output to be written before headers are sent. Downside:
no output is sent until it's all ready to be sent, so
this breaks streaming.
Note: currently ignores errors
*/
func Buffer() func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
bw := new(httpbuf.Buffer)
next.ServeHTTP(bw, r)
bw.Apply(w)
})
}
}
func (h LoggedHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if dump, err := httputil.DumpRequest(req, true); err != nil {
logrus.Errorf("Failed to log request:\n%s", err)
} else {
logrus.Info(string(dump))
}
buf := new(httpbuf.Buffer)
h.Handler.ServeHTTP(buf, req)
logrus.Infof("response: %s", buf.String())
buf.Apply(w)
}
func (a WebAction) ServeHTTP(w http.ResponseWriter, r *http.Request) {
buf := new(httpbuf.Buffer)
ctx := &WebContext{
Session: context.Get(r, "session").(*sessions.Session),
User: context.Get(r, "user").(*domain.User),
CSRF: context.Get(r, "csrf").(string),
}
err := a(buf, r, ctx)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
buf.Apply(w)
}
func (h handler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
//create the context
ctx, err := NewContext(req)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
//run the handler and grab the error, and report it
buf := new(httpbuf.Buffer)
err = h(buf, req, ctx)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
//save the session
if err = ctx.Session.Save(req, buf); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
//apply the buffered response to the writer
buf.Apply(w)
}
// ServeHTTP mandatory middleware part
func (a *Session) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
session, err := a.session.Get(r, "_session")
if err != nil {
http.SetCookie(rw, &http.Cookie{Name: "_session", Expires: time.Now().Add(-1 * time.Hour)})
http.Error(rw, err.Error(), http.StatusBadRequest)
return
}
log.Print("zero ", session.Values)
session.Values["time"] = time.Now().String()
context.Set(r, "session", session)
buf := new(httpbuf.Buffer)
next(buf, r)
session.Save(r, rw)
buf.Apply(rw)
// res := rw.(ResponseWriter)
}
func (h handler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
w.Header().Set("Expires", "Fri, 02 Oct 1998 20:00:00 GMT")
w.Header().Set("Pragma", "no-cache")
w.Header().Set("Cache-Control", "no-store, no-cache, max-age=0, must-revalidate")
ctx, err := NewContext(req)
if err != nil {
raven.CaptureError(err, nil)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
defer ctx.Close()
//run the handler and grab the error, and report it
buf := new(httpbuf.Buffer)
err = h(buf, req, ctx)
if err != nil {
raven.CaptureError(err, nil)
log.Printf("call handler error: %s", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
ctx.afterHandle()
//save the session
if len(ctx.Session.Values) > 0 { // session not empty only
if err = ctx.Session.Save(req, buf); err != nil {
log.Printf("session.save error: %s", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
//apply the buffered response to the writer
buf.Apply(w)
}