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)
}
}
// 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)
}
}
func packageReloadHandler(w http.ResponseWriter, r *http.Request) error {
c := appengine.NewContext(r)
importPath := r.FormValue("importPath")
cacheKey := docKeyPrefix + importPath
err := memcache.Delete(c, cacheKey)
c.Infof("memcache.Delete(%s) -> %v", cacheKey, err)
removeDoc(c, importPath)
http.Redirect(w, r, "/"+importPath, 302)
return nil
}
func Logout(r *http.Request) (err bool) {
c := appengine.NewContext(r)
if e := memcache.Delete(c, "user"); e == memcache.ErrCacheMiss {
return false
} else if e != nil {
return false
}
return true
}
func handleDelayedNotify(w http.ResponseWriter, r *http.Request) {
log.Printf("Task started")
c := appengine.NewContext(r)
// Read the form data
perma_blobref := r.FormValue("perma")
// Allow for further notification tasks to be enqueued
memcache.Delete(c, "notify-"+perma_blobref)
// Find out about the users of this permanode
s := newStore(c)
data, err := s.GetPermaNode(perma_blobref)
if err != nil {
http.Error(w, "Err: Failed reading permanode", http.StatusInternalServerError)
return
}
perma := grapher.NewPermaNode(nil)
perma.FromMap(perma_blobref, data)
message := fmt.Sprintf(`{"type":"notification", "perma":"%v", "lastseq":%v}`, perma_blobref, perma.SequenceNumber()-1)
// For all users find all channels on which they are listening
for _, user := range perma.Users() {
// Do we know this user?
userid, err := isLocalUser(c, user)
if err != nil {
// TODO: In the case of federation this is not really an error?
log.Printf("Err: Unknown user %v", user)
continue
}
// Mark that there is an unread file
err = addUnread(c, userid, perma_blobref)
if err != nil {
log.Printf("Err writing unread: %v", err)
}
// Notify browser instances where this user is logged in
var channels []channelStruct
query := datastore.NewQuery("channel").Filter("UserEmail =", user)
for it := query.Run(c); ; {
var data channelStruct
_, e := it.Next(&data)
if e == datastore.Done {
break
}
if e != nil {
log.Printf("Err: in query: %v", e)
break
}
channels = append(channels, data)
}
for _, ch := range channels {
log.Printf("Sending to %v", ch.UserID+"/"+ch.SessionID)
err := channel.Send(c, ch.UserID+"/"+ch.SessionID, message)
if err != nil {
log.Printf("Failed sending to channel %v", ch.UserID+"/"+ch.SessionID)
}
}
}
}
func delete(w http.ResponseWriter, r *http.Request) {
parts := strings.Split(r.URL.Path, "/")
if len(parts) != 3 {
return
}
if key := parts[1]; key != "" {
c := appengine.NewContext(r)
blobstore.Delete(c, appengine.BlobKey(key))
memcache.Delete(c, key)
}
}
func acceptremoval(w http.ResponseWriter, r *http.Request) {
c := appengine.NewContext(r)
repo := r.FormValue("repo")
c.Errorf("REPO: %v", repo)
removeQuery := datastore.NewQuery("Package").
Filter("Accepted =", true).
Filter("Repo = ", repo).
KeysOnly()
keys, err := removeQuery.GetAll(c, nil)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
c.Errorf("FOUND: %v", keys)
for _, key := range keys {
c.Errorf("DELETING: %v", key)
if err := datastore.Delete(c, key); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
// delete removal request
id := r.FormValue("id")
intID, err := strconv.ParseInt(id, 10, 64)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
key := datastore.NewKey(c, "RemoveRequest", "", intID, nil)
if err := datastore.Delete(c, key); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
memcache.Delete(c, repo)
memcache.Delete(c, CAT)
memcache.Delete(c, ALL_QUERY)
}
// WriteMeta writes a metadata value to the datastore under the given key.
// The value is stored in JSON format: it must be possible to marshal v into JSON.
// The value can be read back using ReadMeta.
//
// If an error occurs, WriteMeta returns it but also logs the error
// using ctxt.Errorf.
func WriteMeta(ctxt appengine.Context, key string, v interface{}) error {
js, err := json.Marshal(v)
if err != nil {
ctxt.Errorf("write meta %s: marshal JSON: %v", key, err)
return err
}
err = WriteData(ctxt, "Meta", key, &meta{JSON: js})
if err == nil {
memcache.Delete(ctxt, "app.Meta."+key)
}
return err
}
/*
* This function will clear a specified entity from the memcache and the datastore
*/
func DeleteCache(r *http.Request, identifier string) {
c := appengine.NewContext(r)
// Delete from memcache
memcache.Delete(c, identifier)
// Delete from the datastore
key := datastore.NewKey(c, "Cache", identifier, 0, nil)
var cache Cache
datastore.Get(c, key, &cache)
datastore.Delete(c, key)
}
// break up the text into words and add/remove keywords for the dish
func updateDishKeywords(c *context, key *datastore.Key, dish *Dish) {
words := make(map[string]bool)
addWords(dish.Name, words)
addWords(dish.Source, words)
addWords(dish.Text, words)
addTags(c.c, key, words)
if updateKeywords(c.c, key, words) {
// if we made changes, we need to clear the cache
cacheKey := c.lid.Encode() + "/dish/" + key.Encode() + "/keywords/"
memcache.Delete(c.c, cacheKey)
}
}
// update the ingredient's keywords
func updateIngredientKeywords(c *context, key *datastore.Key,
ing *Ingredient) {
words := make(map[string]bool)
addWords(ing.Name, words)
addWords(ing.Category, words)
addTags(c.c, key, words)
if updateKeywords(c.c, key, words) {
// if we made changes, we need to clear the cache
cacheKey := c.lid.Encode() + "/ingredient/" + key.Encode() + "/keywords/"
memcache.Delete(c.c, cacheKey)
}
}