test-results: package frontend: Add delete keys task queue

go/src/infra/appengine/test-results/frontend/handlers.go

 package frontend
 
 import (
+        "encoding/json"
         "html/template"
         "net/http"
         "time"
 
         "google.golang.org/appengine"
 
+        "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/appengine/gaemiddleware"
+        "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/server/router"
         "github.com/luci/luci-go/server/templates"
 )
 
+const (
+        defaultQueueName    = "default"
+        deleteKeysQueueName = "delete-keys"
+)
+
 func init() {
         r := router.New()
-        baseMW := base()
 
-        r.GET("/testfile", baseMW, getHandler)
-        r.GET("/testfile/", baseMW, getHandler)
+        baseMW := gaemiddleware.BaseProd()
+        getMW := baseMW.Extend(templatesMiddleware())
+
+        gaemiddleware.InstallHandlers(r, baseMW)
+
+        r.GET("/testfile", getMW, getHandler)
+        r.GET("/testfile/", getMW, getHandler)
+        r.POST("/testfile/upload", baseMW.Extend(withParsedUploadForm), uploadHandler)
+
+        r.GET("/builders", baseMW, getBuildersHandler)
+        r.GET("/updatebuilders", baseMW, updateBuildersHandler)
+        r.GET("/builderstate", baseMW, getBuilderStateHandler)
+        r.GET("/updatebuilderstate", baseMW, updateBuilderStateHandler)
+
+        r.POST(
+                "/internal/delete-keys",
+                baseMW.Extend(gaemiddleware.RequireTaskQueue(deleteKeysQueueName)),
+                deleteKeysHandler,
+        )
 
         http.DefaultServeMux.Handle("/", r)
 }
 
-// base returns the root middleware chain.
-func base() router.MiddlewareChain {
-        templateBundle := &templates.Bundle{
+// templatesMiddleware returns the templates middleware.
+func templatesMiddleware() router.Middleware {
+        return templates.WithTemplates(&templates.Bundle{
                 Loader:    templates.FileSystemLoader("templates"),
                 DebugMode: appengine.IsDevAppServer(),
                 FuncMap: template.FuncMap{
                         "timeParams": func(t time.Time) string {
                                 return t.Format(paramsTimeFormat)
                         },
                         "timeJS": func(t time.Time) int64 {
                                 return t.Unix() * 1000
                         },
                 },
+        })
+}
+
+// deleteKeysHandler is task queue handler for deleting keys.
+func deleteKeysHandler(ctx *router.Context) {
+        c, w, r := ctx.Context, ctx.Writer, ctx.Request
+
+        keys := struct {
+                Keys []string `json:"keys"`
+        }{}
+        if err := json.NewDecoder(r.Body).Decode(&keys); err != nil {
+                logging.WithError(err).Errorf(c, "deleteKeysHandler")
+                w.WriteHeader(http.StatusInternalServerError)

[Vadim Sh., 2016/08/16 18:56:13]

better to return 200 here
otherwise Task Queue service would retry the task again (with same body, so it
will fail again).

[nishanths, 2016/08/16 20:35:13]

Done, thanks!

+                return
         }
 
-        return gaemiddleware.BaseProd().Extend(
-                templates.WithTemplates(templateBundle),
-        )
+        dkeys := make([]*datastore.Key, 0, len(keys.Keys))
+        for _, k := range keys.Keys {
+                dk, err := datastore.NewKeyEncoded(k)
+                if err != nil {
+                        logging.WithError(err).Errorf(c, "deleteKeysHandler")
+                        w.WriteHeader(http.StatusInternalServerError)
+                        return
+                }
+                dkeys = append(dkeys, dk)
+        }
+
+        if err := datastore.Get(c).Delete(dkeys); err != nil {
+                logging.WithError(err).Errorf(c, "deleteKeysHandler")
+                w.WriteHeader(http.StatusInternalServerError)
+                return
+        }
+
+        w.WriteHeader(http.StatusOK)
 }