func (fn authorizationRequiredHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
t := context.GetAuthToken(r)
if t == nil {
context.AddRequestError(r, tokenRequiredErr)
} else {
context.AddRequestError(r, fn(w, r, t))
}
}
func (fn AuthorizationRequiredHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
t := context.GetAuthToken(r)
if t == nil {
w.Header().Set("WWW-Authenticate", "Bearer realm=\"tsuru\" scope=\"tsuru\"")
context.AddRequestError(r, tokenRequiredErr)
} else {
context.AddRequestError(r, fn(w, r, t))
}
}
func (fn AdminRequiredHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
t := context.GetAuthToken(r)
if t == nil {
context.AddRequestError(r, tokenRequiredErr)
} else if user, err := t.User(); err != nil || !user.IsAdmin() {
context.AddRequestError(r, adminRequiredErr)
} else {
context.AddRequestError(r, fn(w, r, t))
}
}
func (s *S) TestErrorHandlingMiddlewareWithError(c *check.C) {
recorder := httptest.NewRecorder()
request, err := http.NewRequest("GET", "/", nil)
c.Assert(err, check.IsNil)
h, log := doHandler()
context.AddRequestError(request, fmt.Errorf("something"))
errorHandlingMiddleware(recorder, request, h)
c.Assert(log.called, check.Equals, true)
c.Assert(recorder.Code, check.Equals, 500)
}
func (s *S) TestErrorHandlingMiddlewareWithHTTPError(c *check.C) {
recorder := httptest.NewRecorder()
request, err := http.NewRequest("GET", "/", nil)
c.Assert(err, check.IsNil)
h, log := doHandler()
context.AddRequestError(request, &errors.HTTP{Code: 403, Message: "other msg"})
errorHandlingMiddleware(recorder, request, h)
c.Assert(log.called, check.Equals, true)
c.Assert(recorder.Code, check.Equals, 403)
}
func (s *S) TestContextClearerMiddleware(c *check.C) {
recorder := httptest.NewRecorder()
request, err := http.NewRequest("GET", "/", nil)
c.Assert(err, check.IsNil)
context.AddRequestError(request, fmt.Errorf("Some Error"))
h, log := doHandler()
contextClearerMiddleware(recorder, request, h)
c.Assert(log.called, check.Equals, true)
contErr := context.GetRequestError(request)
c.Assert(contErr, check.IsNil)
}
func authTokenMiddleware(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
token := r.Header.Get("Authorization")
if token != "" {
t, err := validate(token, r)
if err != nil {
if err != auth.ErrInvalidToken {
context.AddRequestError(r, err)
return
}
log.Debugf("Ignored invalid token for %s: %s", r.URL.Path, err.Error())
} else {
context.SetAuthToken(r, t)
}
}
next(w, r)
}
func (m *appLockMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
if r.Method == "GET" {
next(w, r)
return
}
currentHandler := context.GetDelayedHandler(r)
if currentHandler != nil {
currentHandlerPtr := reflect.ValueOf(currentHandler).Pointer()
for _, h := range m.excludedHandlers {
if reflect.ValueOf(h).Pointer() == currentHandlerPtr {
next(w, r)
return
}
}
}
appName := r.URL.Query().Get(":app")
if appName == "" {
appName = r.URL.Query().Get(":appname")
}
if appName == "" {
next(w, r)
return
}
t := context.GetAuthToken(r)
var owner string
if t != nil {
if t.IsAppToken() {
owner = t.GetAppName()
} else {
owner = t.GetUserName()
}
}
_, err := app.GetByName(appName)
if err == app.ErrAppNotFound {
context.AddRequestError(r, &errors.HTTP{Code: http.StatusNotFound, Message: err.Error()})
return
}
ok, err := app.AcquireApplicationLockWait(appName, owner, fmt.Sprintf("%s %s", r.Method, r.URL.Path), lockWaitDuration)
if err != nil {
context.AddRequestError(r, fmt.Errorf("Error trying to acquire application lock: %s", err))
return
}
if ok {
defer func() {
if !context.IsPreventUnlock(r) {
app.ReleaseApplicationLock(appName)
}
}()
next(w, r)
return
}
a, err := app.GetByName(appName)
httpErr := &errors.HTTP{Code: http.StatusInternalServerError}
if err != nil {
if err == app.ErrAppNotFound {
httpErr.Code = http.StatusNotFound
httpErr.Message = err.Error()
} else {
httpErr.Message = fmt.Sprintf("Error to get application: %s", err)
}
} else {
httpErr.Code = http.StatusConflict
if a.Lock.Locked {
httpErr.Message = fmt.Sprintf("%s", &a.Lock)
} else {
httpErr.Message = "Not locked anymore, please try again."
}
}
context.AddRequestError(r, httpErr)
}
func (fn Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
context.AddRequestError(r, fn(w, r))
}