Milo flex raw log viewer endpoint

appengine/gaemiddleware/context.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package gaemiddleware
 
 import (
         "net/http"
+        "os"
 
         "golang.org/x/net/context"
         "google.golang.org/appengine"
 
         "github.com/luci/gae/filter/dscache"
+        "github.com/luci/gae/impl/cloud"
         "github.com/luci/gae/impl/prod"
         "github.com/luci/gae/service/urlfetch"
 
         "github.com/luci/luci-go/common/data/caching/cacheContext"
         "github.com/luci/luci-go/common/data/caching/proccache"
         "github.com/luci/luci-go/common/logging"
 
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/auth/authdb"
         "github.com/luci/luci-go/server/middleware"
         "github.com/luci/luci-go/server/router"
         "github.com/luci/luci-go/server/settings"
 
         "github.com/luci/luci-go/appengine/gaeauth/client"
         "github.com/luci/luci-go/appengine/gaeauth/server"
         "github.com/luci/luci-go/appengine/gaeauth/server/gaesigner"
         "github.com/luci/luci-go/appengine/gaesecrets"
         "github.com/luci/luci-go/appengine/gaesettings"
         "github.com/luci/luci-go/appengine/tsmon"
         "github.com/luci/luci-go/luci_config/appengine/gaeconfig"
+
+        "cloud.google.com/go/datastore"
 )
 
 var (
         // globalProcessCache holds state cached between requests.
         globalProcessCache = &proccache.Cache{}
 
         // globalSettings holds global app settings lazily updated from the datastore.
         globalSettings = settings.New(gaesettings.Storage{})
 
         // globalAuthCache is used to cache various auth token.
@@ skipping 15 matching lines @@
                 AccessTokenProvider: client.GetAccessToken,
                 AnonymousTransport:  urlfetch.Get,
                 Cache:               globalAuthCache,
                 IsDevMode:           appengine.IsDevAppServer(),
         }
 
         // globalTsMonState holds state related to time series monitoring.
         globalTsMonState = &tsmon.State{}
 )
 
+// WithCloud installs the set of standard flexible environment services.
+// Notably, this does not install Memcache (not available in Flex) or use DS cache
+// (requires memcache).
+func WithCloud(c context.Context) context.Context {
+        c = logging.SetLevel(c, logging.Debug)
+        project := os.Getenv("GCLOUD_PROJECT")

[hinoka, 2017/04/17 23:31:17]

This assumes we are in a GCE container.

+        // Use the cloud datastore client.
+        dsClient, err := datastore.NewClient(c, project)
+        if err != nil {
+                panic(err)
+        }
+        c = cloud.Config{DS: dsClient}.Use(c)
+        c = settings.Use(c, globalSettings)
+
+        // The rest of the service may use applied configuration.
+        c = proccache.Use(c, globalProcessCache)
+        c = gaeconfig.Use(c)
+        c = gaesecrets.Use(c, nil)
+        c = auth.SetConfig(c, globalAuthConfig)
+
+        // Wrap this in a cache context so that lookups for any of the aforementioned
+        // items are fast.
+        return cacheContext.Wrap(c)
+}
+
 // WithProd adds various production GAE LUCI services to the context.
 //
 // Basically, it installs GAE-specific backends and caches for various
 // subsystems to make them work in GAE environment.
 //
 // One example is a backend for Logging: github.com/luci/luci-go/common/logging.
 // Logs emitted through a WithProd() context go to GAE logs.
 //
 // 'Production' here means the services will use real GAE APIs (not mocks or
 // stubs), so WithProd should never be used from unit tests.
@@ skipping 46 matching lines @@
         // parent will ensure that any such resource leaks are cleaned up.
         var cancelFunc context.CancelFunc
         c.Context, cancelFunc = context.WithCancel(c.Context)
         defer cancelFunc()
 
         // Apply production settings.
         c.Context = WithProd(c.Context, c.Request)
 
         next(c)
 }
+
+// CloudServices is a middleware that installs the set of standard production
+// AppEngine services by calling WithCloud.
+func CloudServices(c *router.Context, next router.Handler) {
+        // Create a cancelable Context that cancels when this request finishes.
+        //
+        // We do this because Contexts will leak resources and/or goroutines if they
+        // have timers or can be canceled, but aren't. Predictably canceling the
+        // parent will ensure that any such resource leaks are cleaned up.
+        var cancelFunc context.CancelFunc
+        c.Context, cancelFunc = context.WithCancel(c.Context)
+        defer cancelFunc()
+
+        // Apply production settings.
+        c.Context = WithCloud(c.Context)
+
+        next(c)
+}
+
+// BaseCloud returns a list of middleware: CloudServices middleware, a panic catcher if this
+// is not a devserver, and the monitoring middleware.
+func BaseCloud() router.MiddlewareChain {
+        return router.NewMiddlewareChain(
+                CloudServices, middleware.WithPanicCatcher, globalTsMonState.Middleware,
+        )
+}