A transparent cache for datastore, backed by memcache.

doc.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Package gae provides a fakable wrapped interface for the appengine SDK's
 // APIs. This means that it's possible to mock all of the supported appengine
 // APIs for testing (or potentially implement a different backend for them).
 //
 // Features
 //
@@ skipping 179 matching lines @@
 //   }
 //
 // Filters
 //
 // Each service also supports "filters". Filters are proxy objects which have
 // the same interface as the service they're filtering, and pass data through to
 // the previous filter in the stack. Conceptually, a filtered version of, for
 // example, the Datastore, could look like:
 //    User code
 //    <count filter (counts how many times each API is called by the user)>
-//    <dscache filter (attempts to use memcache as a cache for datastore)>
+//    <dscache filter (attempts to use memcache as a cache for rawdatastore)>
 //    <count filter (counts how many times each API is actually hit)>
 //    memory datastore.RawInterface implementation
 //
 // So datastore.Get would return the full stack. In code, this would look
 // like:
 //   func HTTPHandler(r *http.Request) {
 //     c := prod.UseRequest(r)                                                    // production datastore
 //     c, rawCount := count.FilterRDS(c)      // add count filter
 //     c = dscache.FilterRDS(c)               // add dscache filter
 //     c, userCount := count.FilterRDS(c)     // add another count filter
 //   }
 //
 // Filters may or may not have state, it's up to the filter itself. In the case
 // of the count filter, it returns its state from the Filter<Service> method,
 // and the state can be observed to see how many times each API was invoked.
 // Since filters stack, we can compare counts from rawCount versus userCount to
 // see how many calls to the actual real datastore went through, vs. how many
 // went to memcache, for example.
 //
 // Note that Filters apply only to the service.RawInterface. All implementations
 // of service.Interface boil down to calls to service.RawInterface methods, but
 // it's possible that bad calls to the service.Interface methods could return
 // an error before ever reaching the filters or service implementation.
 package gae