Golang appengine-memcache.Delete类(方法)实例源码

func accept(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	id := r.FormValue("id")
	intID, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	pkg := &Package{}
	key := datastore.NewKey(c, "Package", "", intID, nil)
	err = datastore.Get(c, key, pkg)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	// check if the package is already present
	acceptQuery := datastore.NewQuery("Package").
		Filter("Accepted =", true).
		Filter("Repo =", pkg.Repo)

	var packages []*Package
	keys, err := acceptQuery.GetAll(c, &packages)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	if len(packages) > 1 {
		// just print an error to let admin know
		c.Errorf("More tha one package for repo: %v", pkg.Repo)
	}

	if len(packages) > 0 {
		// update the package and delete
		oldKey := keys[0]
		oldPkg := packages[0]
		oldPkg.Name = pkg.Name
		oldPkg.Description = pkg.Description
		oldPkg.IsLibrary = pkg.IsLibrary
		oldPkg.Category = pkg.Category
		oldPkg.Updated = time.Now()
		if _, err = datastore.Put(c, oldKey, oldPkg); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		if err = datastore.Delete(c, key); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	} else {
		// accept the new package
		pkg.Accepted = true
		if _, err = datastore.Put(c, key, pkg); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
	memcache.Delete(c, pkg.Repo)
	memcache.Delete(c, CAT)
	memcache.Delete(c, ALL_QUERY)
}

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)
	}
}

// clear the pairing cache for the specified dish/pair that is changed
func clearPairingCache(c *context, dishKey *datastore.Key, pairingKey *datastore.Key) {
	url := c.lid.Encode() + "/dish/" + dishKey.Encode() + "/pairing/"
	memcache.Delete(c.c, url)
	if pairingKey != nil {
		url += pairingKey.Encode()
		memcache.Delete(c.c, url)
	}
}

// Unsubscribe removes a feed from the user's feed list.
func unsubscribe(c appengine.Context, feedKey *datastore.Key) error {
	var f FeedInfo
	err := datastore.RunInTransaction(c, func(c appengine.Context) error {
		u, err := getUser(c)
		if err != nil {
			return err
		}

		i := 0
		var k *datastore.Key
		for i, k = range u.Feeds {
			if feedKey.Equal(k) {
				break
			}
		}
		if i >= len(u.Feeds) {
			return nil
		}

		err = fixMissingFieldError(datastore.Get(c, feedKey, &f))
		if err != nil {
			return err
		}

		f.Refs--
		if f.Refs <= 0 {
			if err := f.rmArticles(c); err != nil {
				return err
			}
			if err := datastore.Delete(c, feedKey); err != nil {
				return err
			}

			memcache.Delete(c, articlesMcacheKey(feedKey))

		} else if _, err := datastore.Put(c, feedKey, &f); err != nil {
			return err
		}

		u.Feeds = append(u.Feeds[:i], u.Feeds[i+1:]...)
		return putUser(c, &u)
	}, &datastore.TransactionOptions{XG: true})
	if err != nil {
		return err
	}

	flushUserPageCache(c)

	if f.Refs <= 0 {
		memcache.Delete(c, mcacheFeedsKey)
		memcache.Delete(c, feedKey.StringID())
		return nil
	}

	return memcache.Gob.Set(c, &memcache.Item{Key: feedKey.StringID(), Object: f})
}

func DeleteUser(ctx appengine.Context, user *event.User) {
	key := datastore.NewKey(ctx, "ProxyUser", user.Email, 0, nil)
	datastore.delete(ctx, key)
	key1 := USER_CACHE_KEY_PREFIX + User.Email
	key2 := USER_CACHE_KEY_PREFIX + User.AuthToken
	UserTable[key1] = nil, false
	UserTable[key2] = nil, false
	memcache.Delete(key1)
	memcache.Delete(key2)
}

// default data handler for "DELETE" to remove one itme
func (self *dataHandler) delete(key *datastore.Key) {
	// delete the item
	err := datastore.Delete(self.c, key)
	check(err)
	// remove this item from the cache
	cacheKey := self.lid.Encode() + self.r.URL.Path
	memcache.Delete(self.c, cacheKey)
	// remove the parent from the cache too
	// strip off the key from the URL
	parentURL := cacheKey[:len(cacheKey)-len(key.Encode())]
	memcache.Delete(self.c, parentURL)
	// also without the /
	memcache.Delete(self.c, parentURL[:len(parentURL)-1])
}

func HandleSign(r *http.Request) (err error) {

	c := appengine.NewContext(r)

	if user.Current(c) == nil {
		panic("Not logged in .. can only post with authenticated users")
	}

	if err := r.ParseForm(); err != nil {
		return err
	}
	g := &Buriggie{
		Content: r.FormValue("bericht"),
		Date:    time.Now(),
	}
	if u := user.Current(c); u != nil {
		g.Author = u.String()
	}
	if _, err := datastore.Put(c, datastore.NewIncompleteKey(c, "Greeting", nil), g); err != nil {
		return err
	}

	// nice and clean
	memcache.Delete(c, "buriggies.list.100")

	return nil
}

func DeleteGroup(ctx appengine.Context, group *event.Group) {
	key := datastore.NewKey(ctx, "ProxyGroup", group.Name, 0, nil)
	datastore.delete(ctx, key)
	key1 := GROUP_CACHE_KEY_PREFIX + group.Name
	GroupTable[key1] = nil, false
	memcache.Delete(key1)
}

func C1Logout(c appengine.Context) os.Error {
	u := user.Current(c).Email

	itm, err := memcache.Get(c, u+"__c1Sess")
	if err != nil && err != memcache.ErrCacheMiss {
		return err
	}
	if err == memcache.ErrCacheMiss {
		return nil
	}
	skey := string(itm.Value)
	session := c1SessionCookie(skey)

	r, err := http.NewRequest("GET", "https://www.cadetone.aafc.org.au/logout.php", nil)
	if err != nil {
		return err
	}
	injectSession(r, session)
	client := GetClient(c)
	_, err = client.Do(r)
	if err != nil {
		return err
	}

	memcache.Delete(c, u+"__c1Sess")

	return nil
}

func (cache *Cache) ClearStories(typeKey string) {
	delete(storyListCache, typeKey)

	if err := memcache.Delete(cache.context, typeKey); err != nil && err != memcache.ErrCacheMiss {
		cache.context.Warningf("Error clearing stories from memcache: %v", typeKey, err)
	}
}

func cachePathTime(c appengine.Context, path string) (t int64, err error) {
	t, err = cacheTime(c)
	if err != nil {
		return 0, err
	}

	key := fmt.Sprintf("%d,mtime,%s", t, path)
	item, err := memcache.Get(c, key)
	if err == nil {
		v, err := strconv.ParseInt(string(item.Value), 10, 64)
		if err == nil {
			if chatty {
				c.Infof("cachePathTime %q = %v", key, v)
			}
			return v, nil
		}
		c.Criticalf("memcache.Get %q = %q (%v) - deleting", key, item.Value, err)
		memcache.Delete(c, key)
	}

	var seq int64
	if fi, err := stat(c, path); err == nil {
		seq = fi.Seq
	}

	c.Infof("cachePathTime save %q = %v", key, seq)
	item = &memcache.Item{Key: key, Value: []byte(strconv.FormatInt(seq, 10))}
	if err := memcache.Set(c, item); err != nil {
		c.Criticalf("memcache.Set %q %q: %v", key, item.Value, err)
	}
	return seq, nil
}

func (c *memcacheDriver) Delete(key string) error {
	err := memcache.Delete(c.c, key)
	if err != nil && err != memcache.ErrCacheMiss {
		return err
	}
	return nil
}

func updateHandler(w http.ResponseWriter, r *http.Request) {
	c := gae.NewContext(r)
	g := goon.FromContext(c)
	if r.Header.Get("X-AppEngine-Cron") != "true" {
		http.NotFound(w, r)
		return
	}
	var ups []UpdateSchedule
	if cache, err := memcache.Get(c, "UpdateSchedule"); err == memcache.ErrCacheMiss {
		q := datastore.NewQuery("UpdateSchedule")
		if _, err := g.GetAll(q, &ups); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		if val, err := serialize(&ups); err == nil {
			item := memcache.Item{Key: "UpdateSchedule", Value: val, Expiration: time.Hour * 12}
			memcache.Add(c, &item)
		}
	} else if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	} else {
		deserialize(cache.Value, &ups)
	}
	now := time.Now()
	for _, us := range ups {
		if us.IsUpdateTime(now) {
			if err := updateVillage(us, g); err != nil {
				c.Debugf("%v", err)
			}
			memcache.Delete(c, "UpdateSchedule")
		}
	}
	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
}

// ClearDeviceForRandID clears the cached Device for the specified RandID.
func ClearDeviceForRandID(c appengine.Context, RandID string) {
	mk := prefixDevForRandID + RandID

	if err := memcache.Delete(c, mk); err != nil {
		c.Warningf("Failed to delete %s from memcache: %v", mk, err)
	}
}

func AddClient(c appengine.Context, id string) (string, os.Error) {

	q := datastore.NewQuery("Client")
	var gg []*Client
	var check = 0

	if _, err := q.GetAll(c, &gg); err != nil {
		return "", err
	}

	for _, client := range gg {
		if client.ClientID == id {
			check = check + 1
		}
	}

	if check == 0 {
		key := datastore.NewIncompleteKey("Client")
		client := Client{ClientID: id}

		_, err := datastore.Put(c, key, &client)
		if err != nil {
			return "", err
		}
	}

	memcache.Delete(c, "sut")

	return channel.Create(c, id)

}

func deleteAccountHandler(w http.ResponseWriter, r *http.Request) {

	id := ""
	session, err := sessions.Session(r, "", "datastore")
	c1 := appengine.NewContext(r)
	c1.Debugf("deleteAccount: id=%v, session=%v, err=%v\n", session["userID"], session, err)
	if err == nil {
		if session["userID"] != nil {
			id = session["userID"].(string)
		}
	}
	if id != "" {
		user := loadUser(r, id)
		if user.Id != "" {
			c := appengine.NewContext(r)
			key := datastore.NewKey(c, "User", user.Id, 0, nil)
			datastore.Delete(c, key)
			session["userID"] = ""
			sessions.Save(r, w)
			memUserDelete(c, user.Id)
			memcache.Delete(c, "user"+user.Id)
			http.SetCookie(w, &http.Cookie{Name: "userId", Value: "", Domain: appConfig.AppDomain, Path: "/", MaxAge: -1})
		}
	}
	http.Redirect(w, r, "/", http.StatusFound)
}

func channelDisconnected(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	from, err := strconv.ParseInt(r.FormValue("from"), 10, 0)
	if err != nil {
		c.Errorf("Error ParseInt: %v", err)
		return
	}
	if err := datastore.Delete(c, datastore.NewKey(c, "Endpoint", "", from, nil)); err != nil {
		c.Errorf("Error datastore.Delete: %v", err)
		return
	}

	token, err := getToken(c, from)
	if err != nil {
		c.Errorf("Error getToken(): %v", err)
		return
	}
	//c.Infof("Token: %s", token)

	act, err := memcache.Get(c, token)
	if err != nil && err != memcache.ErrCacheMiss {
		c.Errorf("Error memcache.Get: %v", err)
		return
	}

	var actions []inbox.ActionItem
	if err == nil {
		//c.Infof("mcache: %s", act.Value)
		err = json.Unmarshal(act.Value, &actions)
		if err != nil {
			c.Errorf("Error datastore.Get: %v", err)
			return
		}
		for _, a := range actions {
			var mailItem = new(inmail.Message)
			mkey := datastore.NewKey(c, "Message", "", a.MessageKey, nil)
			if err = datastore.Get(c, mkey, mailItem); err != nil {
				c.Errorf("Error datastore.Get: %v", err)
				continue
			}
			//c.Infof("Cmd: %s",a.Cmd)
			switch a.Cmd {
			case "UNREAD":
				mailItem.DeleteUnreadCount++
			case "DELETE":
				mailItem.DeleteUnreadCount--
			}
			//c.Infof("DeleteUnreadCount: %d",mailItem.DeleteUnreadCount)
			if _, err = datastore.Put(c, mkey, mailItem); err != nil {
				c.Errorf("Error datastore.Get: %v", err)
			}
		}
		if err = memcache.Delete(c, token); err != nil {
			c.Errorf("Error memcache.Delete: %v", err)
		}
	}

	return
}

func UpdateActiveAct(c appengine.Context) os.Error {
	err := memcache.Delete(c, "activeAct")
	if err != nil {
		return err
	}
	_, err = GetActiveAct(c)
	return err
}

func (cache *Cache) ClearStory(storyId int) {
	delete(storyCache, storyId)

	key := cacheKeyStoryPrefix + strconv.Itoa(storyId)
	if err := memcache.Delete(cache.context, key); err != nil && err != memcache.ErrCacheMiss {
		cache.context.Warningf("Error clearing storiy from memcache: %v", key, err)
	}
}