func GetFromDatastoreSimpleOrMemcache(c appengine.Context, kind, stringID, memcacheID string, dst interface{}) error {
if capability.Enabled(c, "memcache", "*") {
answer := GetFromMemcache(c, memcacheID, dst)
if answer != nil {
dst = answer
return nil
}
}
if !capability.Enabled(c, "datastore_v3", "*") {
c.Errorf("Datastore - GetFromDatastoreOrMemcache - error 1 - Datastore not available.")
return errors.New("Datastore not available")
}
err := GetFromDatastoreSimple(c, kind, stringID, dst)
if err != nil {
c.Infof("Trying to reach - %s - %s", kind, stringID)
c.Infof("Datastore - GetFromDatastoreOrMemcache error 1 - %s", err)
return err
}
if capability.Enabled(c, "memcache", "*") {
PutInMemcache(c, memcacheID, dst)
}
return nil
}
func UserAuthServiceAvailable(ctx appengine.Context) bool {
if !capability.Enabled(ctx, "datastore_v3", "*") {
return false
}
if !capability.Enabled(ctx, "memcache", "*") {
return false
}
return true
}
func PutInDatastoreSimpleAndMemcache(c appengine.Context, kind, stringID, memcacheID string, variable interface{}) (*datastore.Key, error) {
if !capability.Enabled(c, "datastore_v3", "*") {
c.Errorf("Datastore - PutInDatastoreSimpleAndMemcache - error 1 - Datastore not available.")
return nil, errors.New("Datastore not available")
}
key, err := PutInDatastoreSimple(c, kind, stringID, variable)
if err != nil {
c.Errorf("Datastore - PutInDatastoreSimpleAndMemcache - error 2 - %s", err)
return nil, err
}
if capability.Enabled(c, "memcache", "*") {
PutInMemcache(c, memcacheID, variable)
}
return key, nil
}
func Capabilities(w http.ResponseWriter, r *http.Request) {
var stat ServiceStatus
c := appengine.NewContext(r)
stat.Blob = capability.Enabled(c, "blobstore", "")
stat.Read = capability.Enabled(c, "datastore_v3", "")
stat.Write = capability.Enabled(c, "datastore_v3", "write")
stat.Mail = capability.Enabled(c, "mail", "")
stat.Cache = capability.Enabled(c, "memcache", "")
stat.Task = capability.Enabled(c, "taskqueue", "")
stat.URLFetch = capability.Enabled(c, "urlfetch", "")
fmt.Fprintf(w, "%v", stat)
}
func GetFromMemcache(c appengine.Context, key string, dst interface{}) interface{} {
if !capability.Enabled(c, "memcache", "*") {
c.Errorf("Datastore - GetFromMemcache - error 1 - Memcache not available.")
return nil
}
item, err := memcache.Get(c, key)
if err != nil && err != memcache.ErrCacheMiss {
c.Errorf("Datastore - GetFromMemcache - error 2 - %s", err)
return nil
} else if err == memcache.ErrCacheMiss {
return nil
}
dec := gob.NewDecoder(bytes.NewBuffer(item.Value))
err = dec.Decode(dst)
if err != nil {
c.Errorf("Datastore - GetFromMemcache - error 3 - %s", err)
return nil
}
return dst
}
func PutInMemcache(c appengine.Context, key string, toStore interface{}) {
if !capability.Enabled(c, "memcache", "*") {
c.Errorf("Datastore - PutInMemcache - error 1 - Memcache not available.")
return
}
var data bytes.Buffer
enc := gob.NewEncoder(&data)
err := enc.Encode(toStore)
if err != nil {
c.Errorf("Datastore - PutInMemcache - error 2 - %s", err)
return
}
item := &memcache.Item{
Key: key,
Value: data.Bytes(),
}
if err := memcache.Set(c, item); err != nil {
c.Errorf("Datastore - PutInMemcache - error 3 - %s", err)
}
}