func delete(w http.ResponseWriter, r *http.Request) {
key := extractKey(r)
parts := strings.Split(key, "/")
if len(parts) == 3 {
result := make(map[string]bool, 1)
context := appengine.NewContext(r)
err := memcache.Delete(context, key)
if err == nil {
result[key] = true
contentType, _ := url.QueryUnescape(parts[0])
if imageTypes.MatchString(contentType) {
thumbnailKey := key + thumbSuffix + filepath.Ext(parts[2])
err := memcache.Delete(context, thumbnailKey)
if err == nil {
result[thumbnailKey] = true
}
}
}
w.Header().Set("Content-Type", "application/json")
b, err := json.Marshal(result)
check(err)
fmt.Fprintln(w, string(b))
} else {
http.Error(w, "405 Method not allowed", http.StatusMethodNotAllowed)
}
}
//Remove removes a card from the datastore, memcache, and stripe
func Remove(w http.ResponseWriter, r *http.Request) {
//get form values
datastoreId := r.FormValue("customerId")
datastoreIdInt, _ := strconv.ParseInt(datastoreId, 10, 64)
//make sure an id was given
if len(datastoreId) == 0 {
output.Error(ErrMissingInput, "A customer's datastore ID must be given but was missing. This value is different from your \"Customer ID\" and should have been submitted automatically.", w, r)
return
}
//init stripe
c := appengine.NewContext(r)
sc := createAppengineStripeClient(c)
//delete customer on stripe
custData, err := findByDatastoreId(c, datastoreIdInt)
if err != nil {
output.Error(err, "An error occured while trying to look up customer's Stripe information.", w, r)
}
stripeCustId := custData.StripeCustomerToken
sc.Customers.Del(stripeCustId)
//delete custome from datastore
completeKey := getCustomerKeyFromId(c, datastoreIdInt)
err = datastore.Delete(c, completeKey)
if err != nil {
output.Error(err, "There was an error while trying to delete this customer. Please try again.", w, r)
return
}
//delete customer from memcache
//delete list of cards in memcache since this list is now stale
//all memcache.Delete operations are listed first so error handling doesn't return if one fails...each call does not depend on another so this is safe
//obviously, if the card is not in the cache it cannot be removed
err1 := memcache.Delete(c, datastoreId)
err2 := memcache.Delete(c, custData.CustomerId)
err3 := memcache.Delete(c, listOfCardsKey)
if err1 != nil && err1 != memcache.ErrCacheMiss {
output.Error(err1, "There was an error flushing this card's data from the cache (by datastore id). Please contact an administrator and have them flush the cache manually.", w, r)
return
}
if err2 != nil && err2 != memcache.ErrCacheMiss {
output.Error(err2, "There was an error flushing this card's data from the cache (by customer id). Please contact an administrator and have them flush the cache manually.", w, r)
return
}
if err3 != nil && err3 != memcache.ErrCacheMiss {
output.Error(err3, "There was an error flushing the cached list of cards.", w, r)
return
}
//customer removed
//return to client
output.Success("removeCustomer", nil, w)
return
}
// serveTwitterCallback handles callbacks from the Twitter OAuth server.
func serveTwitterCallback(c *context) error {
token := c.r.FormValue("oauth_token")
var ci connectInfo
_, err := memcache.Gob.Get(c.c, token, &ci)
if err != nil {
return err
}
memcache.Delete(c.c, token)
tempCred := &oauth.Credentials{
Token: token,
Secret: ci.Secret,
}
httpClient := urlfetch.Client(c.c)
tokenCred, _, err := oauthClient.RequestToken(httpClient, tempCred, c.r.FormValue("oauth_verifier"))
if err != nil {
return err
}
if err := c.updateUserInfo(func(u *userInfo) { u.TwitterCred = *tokenCred }); err != nil {
return err
}
http.Redirect(c.w, c.r, ci.Redirect, 302)
return nil
}
func purgeCache(ctx context.Context, key string) error {
err := memcache.Delete(ctx, key)
if err == memcache.ErrCacheMiss {
err = nil
}
return err
}
// DELETE http://localhost:8080/users/1
//
func (u *UserService) removeUser(request *restful.Request, response *restful.Response) {
c := appengine.NewContext(request.Request)
id := request.PathParameter("user-id")
err := memcache.Delete(c, id)
if err != nil {
response.WriteError(http.StatusInternalServerError, err)
}
}
// removeObjectCache removes cached object from memcache.
// It returns nil in case where memcache.Delete would result in ErrCacheMiss.
func removeObjectCache(ctx context.Context, bucket, obj string) error {
k := path.Join(bucket, obj)
err := memcache.Delete(ctx, k)
if err == memcache.ErrCacheMiss {
err = nil
}
return err
}
// Deletes a record from memcache for the given id
func Delete(id string, req *http.Request) error {
ctx := appengine.NewContext(req)
err := memcache.Delete(ctx, id)
if err != memcache.ErrCacheMiss {
return err
}
return nil
}
func invalidateCache(ctx context.Context, key datastore.Key) *MaybeError {
// delete key from memcache
err := memcache.Delete(ctx, key.String())
var result = new(MaybeError)
if err != nil {
*result = E(err.Error())
} else {
*result = Ok{}
}
return result
}
func submissionsAddHandler(w http.ResponseWriter, r *http.Request) {
ctx := appengine.NewContext(r)
if err := r.ParseForm(); err != nil {
serveErr(ctx, err, w)
return
}
ID, _, err := datastore.AllocateIDs(ctx, "Podcast", nil, 1)
if err != nil {
serveErr(ctx, err, w)
return
}
date, err := time.Parse(yyyymmdd, r.FormValue("date"))
if err != nil {
serveErr(ctx, err, w)
return
}
podcast := Podcast{
ID: ID,
Show: r.FormValue("show"),
Title: r.FormValue("title"),
Desc: r.FormValue("desc"),
URL: template.URL(r.FormValue("url")),
MediaURL: template.URL(r.FormValue("media_url")),
RuntimeSec: r.FormValue("runtime"),
Size: r.FormValue("size"),
Date: date,
Added: time.Now(),
}
if _, err := datastore.Put(ctx, datastore.NewKey(ctx, "Podcast", "", ID, nil), &podcast); err != nil {
serveErr(ctx, err, w)
return
}
key, err := datastore.DecodeKey(r.FormValue("key"))
if err != nil {
serveErr(ctx, err, w)
return
}
if err := datastore.Delete(ctx, key); err != nil {
serveErr(ctx, err, w)
return
}
if err := memcache.Delete(ctx, cacheKey); err != nil {
log.Errorf(ctx, "memcache delete error %v", err)
}
successTmpl.ExecuteTemplate(w, "base", nil)
}
//Delete removes a key value pair from memcache
func Delete(c context.Context, key string) error {
err := memcache.Delete(c, key)
if err == memcache.ErrCacheMiss {
//key does not exist
//this is not an error
return nil
} else if err != nil {
return err
}
//delete successful
return nil
}
func deleteSavedPosts(c context.Context, key string) error {
// flush db
q := datastore.NewQuery(key).Ancestor(getParentKey(c, key)).KeysOnly()
keys, err := q.GetAll(c, nil)
if err != nil {
return err
}
if err = datastore.DeleteMulti(c, keys); err != nil {
return err
}
// flush cache
return memcache.Delete(c, key)
}
func (a *MemcacheDatastoreAccessor) dismissMessage(c context.Context, key *datastore.Key) (*MessageForUser, error) {
msg, err := a.GaeDatastoreAccessor.dismissMessage(c, key)
if err != nil {
return nil, err
}
cacheKey := "getMessagesForUser(" + msg.Username + ")"
err = memcache.Delete(c, cacheKey)
if err == memcache.ErrCacheMiss {
// No problem if wasn't in cache anyway
err = nil
}
return msg, err
}
func (a *MemcacheDatastoreAccessor) saveNewMessage(c context.Context, msg *MessageForUser) (*datastore.Key, error) {
key, err := a.GaeDatastoreAccessor.saveNewMessage(c, msg)
if err != nil {
return key, err
}
cacheKey := "getMessagesForUser(" + msg.Username + ")"
err = memcache.Delete(c, cacheKey)
if err == memcache.ErrCacheMiss {
// No problem if wasn't in cache anyway
err = nil
}
return key, err
}
func uploadHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
return
}
c := appengine.NewContext(r)
// Authenticate using a user token (same as gomote).
user := r.FormValue("user")
if !validUser(user) {
http.Error(w, "bad user", http.StatusForbidden)
return
}
if builderKey == "" {
http.Error(w, "no builder-key found in project metadata", http.StatusInternalServerError)
return
}
if r.FormValue("key") != userKey(c, user) {
http.Error(w, "bad key", http.StatusForbidden)
return
}
var f File
defer r.Body.Close()
if err := json.NewDecoder(r.Body).Decode(&f); err != nil {
log.Errorf(c, "error decoding upload JSON: %v", err)
http.Error(w, "Something broke", http.StatusInternalServerError)
return
}
if f.Filename == "" {
http.Error(w, "Must provide Filename", http.StatusBadRequest)
return
}
if f.Uploaded.IsZero() {
f.Uploaded = time.Now()
}
k := datastore.NewKey(c, "File", f.Filename, 0, rootKey(c))
if _, err := datastore.Put(c, k, &f); err != nil {
log.Errorf(c, "putting File entity: %v", err)
http.Error(w, "could not put File entity", http.StatusInternalServerError)
return
}
if err := memcache.Delete(c, cacheKey); err != nil {
log.Errorf(c, "cache delete error: %v", err)
}
io.WriteString(w, "OK")
}
func createSearchItem(con *data.Context, values url.Values, namespace string, URL string) (*search.Item, error) {
DSKey := values["DSKey"][0]
// We can't do anything without a DSKey
if DSKey == "" || namespace == "" || URL == "" {
con.Log.Errorf("Something is wrong with the input data. DSKey: %v, Namespace: %v, URL: %v.", DSKey, namespace, URL)
return nil, fmt.Errorf("Something is wrong with the input data. DSKey: %v, Namespace: %v, URL: %v.", DSKey, namespace, URL)
}
memI, err := memcache.Get(con.C, DSKey)
_ = memcache.Delete(con.C, DSKey) // ignore possible errors
var searchItem search.Item
searchItem.Description = values["Caption"][0] + " " + values["Description"][0]
if err == nil {
searchItem.HTMLforSearch = gaesearch.HTML(string(memI.Value))
} else {
// ok, no data in the memcache.
// we need to re-query the URL to get the HTML data
c := urlextractclient.Get(con)
info, err := c.Extract(URL)
if err != nil {
con.Log.Errorf("Error in URLextract.Extract(). Error: %v", err)
return nil, err
}
var i data.Item
i = data.ItemFromWebpageInfo(info)
searchItem.HTMLforSearch = gaesearch.HTML(i.HTMLforSearch)
}
if s, err := strconv.ParseInt(values["CreatedAt"][0], 10, 64); err == nil {
searchItem.CreatedAt = time.Unix(s, 0)
} else {
searchItem.CreatedAt = time.Now()
}
return &searchItem, nil
}
func (mp *AppEngineProvider) SessionDestroy(c context.Context, sid string) error {
done := make(chan bool, 2)
go func() {
k := datastore.NewKey(c, "BeegoSessionStore", sid, 0, nil)
if ds_err := datastore.Delete(c, k); ds_err != nil {
log.Errorf(c, "session-appengine: error deleting session data from datastore: %v", ds_err)
}
done <- true
}()
go func() {
mem_err := memcache.Delete(c, sid)
if mem_err != nil {
log.Errorf(c, "session-appengine: error deleting session data from memcache: %v", mem_err)
}
done <- true
}()
_, _ = <-done, <-done
return nil
}
// Data changes should lead to cache entries invalidation.
func htmlCacheEvict(c context.Context, key string) {
_ = memcache.Delete(c, key)
}
// Delete removes the response with key from the cache.
func (c *Cache) Delete(key string) {
if err := memcache.Delete(c.Context, cacheKey(key)); err != nil {
log.Errorf(c.Context, "error deleting cached response: %v", err)
}
}
func (d *DsDir) MemCacheDelete() {
err := memcache.Delete(d.fSys.Ctx(), d.Dir+d.BName)
if err != nil {
aelog.Errorf(d.fSys.Ctx(), "memcache delete dir %v => err %v", d.Dir+d.BName, err)
}
}
// Delete deletes the key
func (d *Driver) Delete(key string) {
memcache.Delete(d.ctx, key)
}
// adminHandler serves an administrative interface.
func adminHandler(w http.ResponseWriter, r *http.Request) {
c := appengine.NewContext(r)
if !user.IsAdmin(c) {
http.Error(w, "forbidden", http.StatusForbidden)
return
}
var newLink *Link
var doErr error
if r.Method == "POST" {
key := r.FormValue("key")
switch r.FormValue("do") {
case "Add":
newLink = &Link{key, r.FormValue("target")}
doErr = putLink(c, newLink)
case "Delete":
k := datastore.NewKey(c, kind, key, 0, nil)
doErr = datastore.Delete(c, k)
default:
http.Error(w, "unknown action", http.StatusBadRequest)
}
err := memcache.Delete(c, cacheKey(key))
if err != nil && err != memcache.ErrCacheMiss {
log.Warningf(c, "%q: %v", key, err)
}
}
var links []*Link
_, err := datastore.NewQuery(kind).Order("Key").GetAll(c, &links)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Errorf(c, "%v", err)
return
}
// Put the new link in the list if it's not there already.
// (Eventual consistency means that it might not show up
// immediately, which might be confusing for the user.)
if newLink != nil && doErr == nil {
found := false
for i := range links {
if links[i].Key == newLink.Key {
found = true
break
}
}
if !found {
links = append([]*Link{newLink}, links...)
}
newLink = nil
}
var data = struct {
BaseURL string
Prefix string
Links []*Link
New *Link
Error error
}{baseURL, prefix, links, newLink, doErr}
if err := adminTemplate.Execute(w, &data); err != nil {
log.Criticalf(c, "adminTemplate: %v", err)
}
}
func TestCachedCertsCacheMiss(t *testing.T) {
rt := newTestRoundTripper()
origTransport := httpTransportFactory
defer func() { httpTransportFactory = origTransport }()
httpTransportFactory = func(c context.Context) http.RoundTripper {
return rt
}
req, _, closer := newTestRequest(t, "GET", "/", nil)
defer closer()
nc, err := appengine.Namespace(appengine.NewContext(req), certNamespace)
if err != nil {
t.Fatal(err)
}
ec := NewContext(req)
tts := []*struct {
respStatus int
respContent, cacheControl, age string
want *certsList
shouldCache bool
}{
{200, `{"keyvalues":null}`, "max-age=3600", "600", &certsList{}, true},
{-1, "", "", "", nil, false},
{400, "", "", "", nil, false},
{200, `{"keyvalues":null}`, "", "", &certsList{}, false},
}
for i, tt := range tts {
if tt.respStatus > 0 {
resp := &http.Response{
Status: fmt.Sprintf("%d", tt.respStatus),
StatusCode: tt.respStatus,
Body: ioutil.NopCloser(strings.NewReader(tt.respContent)),
Header: make(http.Header),
}
resp.Header.Set("cache-control", tt.cacheControl)
resp.Header.Set("age", tt.age)
rt.Add(resp)
}
memcache.Delete(nc, DefaultCertURI)
out, err := cachedCerts(ec)
switch {
case err != nil && tt.want != nil:
t.Errorf("%d: cachedCerts() = %v", i, err)
case err == nil && tt.want == nil:
t.Errorf("%d: cachedCerts() = %#v; want error", i, out)
default:
if !reflect.DeepEqual(out, tt.want) {
t.Errorf("%d: cachedCerts() = %#v; want %#v", i, out, tt.want)
}
if !tt.shouldCache {
continue
}
item, err := memcache.Get(nc, DefaultCertURI)
if err != nil {
t.Errorf("%d: memcache.Get(%q) = %v", i, DefaultCertURI, err)
continue
}
cert := string(item.Value)
if tt.respContent != cert {
t.Errorf("%d: memcache.Get(%q) = %q; want %q",
i, DefaultCertURI, cert, tt.respContent)
}
}
}
}
