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

func GetBuriggies(c appengine.Context, count int) (buriggies []*Buriggie, err error) {

	var gg []*Buriggie

	var cacheKey = "buriggies.list." + strconv.Itoa(count)

	// Get the item from the memcache
	if item, err := memcache.Get(c, cacheKey); err == memcache.ErrCacheMiss {
		// cache miss.. ADD to cache
		q := datastore.NewQuery("Greeting").Order("-Date").Limit(count)
		_, err = q.GetAll(c, &gg)

		qjs, _ := json.Marshal(gg)

		cache_duration, _ := time.ParseDuration("1d")
		// Create an Item - cache for a day
		item := &memcache.Item{
			Key:        cacheKey,
			Value:      qjs,
			Expiration: cache_duration,
		}

		if err := memcache.Add(c, item); err != nil {
			c.Errorf("error setting item: %v", err)
		}

	} else if err != nil {
		c.Errorf("error getting item: %v", err)
	} else {
		err = json.Unmarshal(item.Value, &gg)
	}

	return gg, err
}

func getCached(c appengine.Context, key string, missing func(appengine.Context, string) (*bytes.Buffer, error)) (*memcache.Item, error) {

	item, err := memcache.Get(c, key)

	if err == memcache.ErrCacheMiss {
		c.Infof("item not in the cache: %v", key)

		result, err := missing(c, key)

		if err != nil {
			return nil, err
		}

		item = &memcache.Item{
			Key:   key,
			Value: result.Bytes(),
		}

		if err := memcache.Add(c, item); err == memcache.ErrNotStored {
			c.Warningf("item with key %q already exists", item.Key)
		} else if err != nil {
			return item, err
		}
	} else if err != nil {
		return item, err
	} else {
		c.Infof("Cache hit: %v", key)
	}

	return item, nil
}

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

	c := appengine.NewContext(r)
	id := r.FormValue("id")
	if id == "" {
		serveError(c, w, errors.New("Missing ID parameter"))
		return
	}

	conf := &tweetlib.Config{
		ConsumerKey:    appConfig.TwitterConsumerKey,
		ConsumerSecret: appConfig.TwitterConsumerSecret,
		Callback:       "http://" + appConfig.AppHost + "/twitter?action=temp&id=" + id}
	tok := &tweetlib.Token{}
	tr := &tweetlib.Transport{Config: conf,
		Token:     tok,
		Transport: &urlfetch.Transport{Context: c}}

	tt, err := tr.TempToken()
	if err != nil {
		c := appengine.NewContext(r)
		serveError(c, w, err)
		c.Errorf("%v", err)
		return
	}
	item := &memcache.Item{
		Key:   tt.Token,
		Value: []byte(tt.Secret),
	}
	// Add the item to the memcache, if the key does not already exist
	memcache.Add(c, item)

	http.Redirect(w, r, tt.AuthURL(), http.StatusFound)
}

func cacheSafeSet(c appengine.Context, item *memcache.Item) error {
	var buf bytes.Buffer
	err := gob.NewEncoder(&buf).Encode(item.Object)
	if err != nil {
		return err
	}

	swap := item.Value != nil
	item.Value = buf.Bytes()

	if swap {
		err = memcache.CompareAndSwap(c, item)
		switch err {
		case memcache.ErrCASConflict:
			// OK, cache item set by another request
			return nil
		case memcache.ErrNotStored:
			// Item expired. Try adding below.
		default:
			return err
		}
	}

	err = memcache.Add(c, item)
	if err == memcache.ErrNotStored {
		// OK, cache item set by another request
		err = nil
	}
	return err
}

func updateCacheTime(c appengine.Context, seq int64) {
	const key = rootMemcacheKey
	bseq := []byte(strconv.FormatInt(seq, 10))
	for tries := 0; tries < 10; tries++ {
		item, err := memcache.Get(c, key)
		if err != nil {
			c.Infof("memcache.Get %q: %v", key, err)
			err = memcache.Add(c, &memcache.Item{Key: key, Value: bseq})
			if err == nil {
				c.Infof("memcache.Add %q %q ok", key, bseq)
				return
			}
			c.Infof("memcache.Add %q %q: %v", key, bseq, err)
		}
		v, err := strconv.ParseInt(string(item.Value), 10, 64)
		if err != nil {
			c.Criticalf("memcache.Get %q = %q (%v)", key, item.Value, err)
			return
		}
		if v >= seq {
			return
		}
		item.Value = bseq
		err = memcache.CompareAndSwap(c, item)
		if err == nil {
			c.Infof("memcache.CAS %q %d->%d ok", key, v, seq)
			return
		}
		c.Infof("memcache.CAS %q %d->%d: %v", key, v, seq, err)
	}
	c.Criticalf("repeatedly failed to update root key")
}

func MemoAdd(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	if err := r.ParseForm(); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	key := r.PostFormValue("key")
	value := r.PostFormValue("value")
	c.Debugf("key = %s, value = %s", key, value)

	if key == "" || value == "" {
		http.Error(w, "key or value param error", http.StatusInternalServerError)
		return
	}

	// 有効期限1分
	item := &memcache.Item{
		Key:        key,
		Value:      bytes.NewBufferString(value).Bytes(),
		Expiration: (time.Minute * 1),
	}
	if err := memcache.Add(c, item); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	} else {
		http.Redirect(w, r, "/", http.StatusSeeOther)
	}
}

func sendReminder(c appengine.Context, date time.Time) {
	addr := "[email protected]"

	tag := fmt.Sprintf("diaryentry%dtag", rand.Int63())

	item := &memcache.Item{
		Key:   tag,
		Value: []byte(date.Format(time.RFC850)),
	}

	// Add the item to the memcache, if the key does not already exist
	if err := memcache.Add(c, item); err == memcache.ErrNotStored {
		c.Infof("item with key %q already exists", item.Key)
	} else if err != nil {
		c.Errorf("error adding item: %v", err)
	}

	msg := &mail.Message{
		Sender:  "Automatic Diary <[email protected]>",
		To:      []string{addr},
		Subject: "Entry reminder",
		Body:    fmt.Sprintf(reminderMessage, tag),
	}
	if err := mail.Send(c, msg); err != nil {
		c.Errorf("Couldn't send email: %v", err)
		return
	}
	c.Infof("Reminder mail sent for %v", date)
	c.Infof("body: %v", msg.Body)
}

// Lista entidades
func ListEnt(c appengine.Context, ent string) *[]Entidad {
	estados := make([]Entidad, 0, 32)
	if item, err := memcache.Get(c, "estados"); err == memcache.ErrCacheMiss {
		q := datastore.NewQuery("Entidad")
		if _, err := q.GetAll(c, &estados); err != nil {
			return nil
		}
		b, _ := json.Marshal(estados)
		item := &memcache.Item{
			Key:   "estados",
			Value: b,
		}
		if err := memcache.Add(c, item); err == memcache.ErrNotStored {
			c.Errorf("memcache.Add Entidad : %v", err)
		}
	} else {
		//c.Infof("Memcache activo: %v", item.Key)
		if err := json.Unmarshal(item.Value, &estados); err != nil {
			c.Errorf("Memcache Unmarshalling item: %v", err)
		}
	}
	for i, _ := range estados {
		if ent == estados[i].CveEnt {
			estados[i].Selected = `selected`
		}
	}
	return &estados
}

func cat(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	w.Header().Set("Content-Type", "application/json")
	switch r.Method {
	case "GET":
		var jsonResult []byte
		if item, err := memcache.Get(c, CAT); err == memcache.ErrCacheMiss {
			q := datastore.NewQuery("Package").Filter("Accepted =", true)
			var packages []*Package
			if _, err := q.GetAll(c, &packages); err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
			var categories Categories
			for _, pkg := range packages {
				if strings.TrimSpace(pkg.Category) != "" {
					categories = categories.Add(pkg.Category)
				}
			}
			if jsonResult, err = json.Marshal(categories); err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
			memcache.Add(c, &memcache.Item{Key: CAT, Value: jsonResult})
		} else {
			jsonResult = item.Value
		}
		w.Write(jsonResult)
	}
}

func ListCat(c appengine.Context, IdCat int) *[]Categoria {
	var categorias []Categoria
	if item, err := memcache.Get(c, "categorias"); err == memcache.ErrCacheMiss {
		q := datastore.NewQuery("Categoria")
		//n, _ := q.Count(c)
		//cats := make([]Categoria, 0, n)
		if _, err := q.GetAll(c, &categorias); err != nil {
			return nil
		}
		b, _ := json.Marshal(categorias)
		item := &memcache.Item{
			Key:   "categorias",
			Value: b,
		}
		if err := memcache.Add(c, item); err == memcache.ErrNotStored {
			c.Errorf("memcache.Add Categoria : %v", err)
		}
	} else {
		c.Infof("Memcache activo: %v", item.Key)
		if err := json.Unmarshal(item.Value, &categorias); err != nil {
			c.Errorf("Memcache Unmarchalling item: %v", err)
		}
	}
	for i, _ := range categorias {
		if IdCat == categorias[i].IdCat {
			categorias[i].Selected = `selected`
		}
	}
	return &categorias
}

func SetTokenHandler(rw http.ResponseWriter, req *http.Request) {
	c := appengine.NewContext(req)
	authorizationCode := req.FormValue("code")

	transport := &oauth.Transport{
		Config: config,
		Transport: &urlfetch.Transport{
			Context: c,
		},
	}
	token, err := transport.Exchange(authorizationCode)
	if err != nil {
		fmt.Fprintf(rw, "%s", err.Error())
		return
	}

	// トークン情報の一時保存
	value, err := json.Marshal(token)
	if err != nil {
		fmt.Fprintf(rw, "%s", err.Error())
		return
	}
	item := &memcache.Item{
		Key:   tokenCacheKey,
		Value: value,
	}
	err = memcache.Add(c, item)
	if err != nil {
		fmt.Fprintf(rw, "%s", err.Error())
		return
	}

	fmt.Fprintf(rw, "Success.")
}

func (fi *FileInfo) CreateThumbnail(r io.Reader, c appengine.Context) (data []byte, err os.Error) {
	defer func() {
		if rec := recover(); rec != nil {
			log.Println(rec)
			// 1x1 pixel transparent GIf, bas64 encoded:
			s := "R0lGODlhAQABAIAAAP///////yH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=="
			data, _ = base64.StdEncoding.DecodeString(s)
			fi.ThumbnailUrl = "data:image/gif;base64," + s
		}
		memcache.Add(c, &memcache.Item{
			Key:        string(fi.Key),
			Value:      data,
			Expiration: EXPIRATION_TIME,
		})
	}()
	img, _, err := image.Decode(r)
	check(err)
	if bounds := img.Bounds(); bounds.Dx() > THUMBNAIL_MAX_WIDTH ||
		bounds.Dy() > THUMBNAIL_MAX_HEIGHT {
		w, h := THUMBNAIL_MAX_WIDTH, THUMBNAIL_MAX_HEIGHT
		if bounds.Dx() > bounds.Dy() {
			h = bounds.Dy() * h / bounds.Dx()
		} else {
			w = bounds.Dx() * w / bounds.Dy()
		}
		img = resize.Resize(img, img.Bounds(), w, h)
	}
	var b bytes.Buffer
	err = png.Encode(&b, img)
	check(err)
	data = b.Bytes()
	fi.ThumbnailUrl = "data:image/png;base64," +
		base64.StdEncoding.EncodeToString(data)
	return
}

func municipios(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	_, ok := sess.IsSess(w, r, c)
	if ok {
		if item, err := memcache.Get(c, "msp_"+r.FormValue("CveEnt")); err == memcache.ErrCacheMiss {
			if entidad, err := model.GetEntidad(c, r.FormValue("CveEnt")); err == nil {
				if municipios, _ := entidad.GetMunicipios(c); err == nil {
					b, _ := json.Marshal(municipios)
					item := &memcache.Item{
						Key:   "msp_" + r.FormValue("CveEnt"),
						Value: b,
					}
					if err := memcache.Add(c, item); err == memcache.ErrNotStored {
						c.Infof("item with key %q already exists", item.Key)
					} else if err != nil {
						c.Errorf("Error memcache.Add Municipio : %v", err)
					}
					c.Infof("CveMun generado: %v", item.Key)
					htmlComboMuns(w, municipios, r.FormValue("CveMun"))
				}
			}
		} else {
			//c.Infof("Memcache activo: %v", item.Key)
			var municipios []model.Municipio
			if err := json.Unmarshal(item.Value, &municipios); err != nil {
				c.Errorf("error adding item: %v", err)
			}
			htmlComboMuns(w, &municipios, r.FormValue("CveMun"))
		}
	}
	return
}

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
}

func abstractHandler(w http.ResponseWriter, r *http.Request) {
	// If the requested pic with the requested logo has already been generated, then use the cached version
	ctx := appengine.NewContext(r)
	originalImageUrl := r.URL.Query().Get("img")
	logoImageUrl := r.URL.Query().Get("logo")
	if logoImageUrl == "" {
		logoImageUrl = "brazz"
	}

	if MEMCACHE_ENABLED {
		item, err := memcache.Get(ctx, logoImageUrl+":"+originalImageUrl)
		if err != nil {
			ctx.Infof("Retrieved [%s:%s] from memcache\n", logoImageUrl, originalImageUrl)
			w.Header().Set("Content-Type", "image/png")
			w.Write(item.Value)
			return
		}
	}
	// Load the logo image
	logoImage, err := imageutils.FetchLogoImage(logoImageUrl)
	if err != nil {
		logoImage, err = imageutils.FetchImage(ctx, logoImageUrl, imageutils.TARGET_LOGO_WIDTH)
	}
	if err != nil {
		message := fmt.Sprintf("Unable to load logo image file: %s\n", err)
		ctx.Errorf(message)
		fmt.Fprintf(w, message)
		return
	}
	// Fetch the source image
	originalImage, err := imageutils.FetchImage(ctx, originalImageUrl, imageutils.TARGET_IMAGE_WIDTH)
	if err != nil {
		message := fmt.Sprintf("An error occurred: %s\n", err)
		ctx.Errorf(message)
		fmt.Fprintf(w, message)
		return
	}
	// Generate and return an image with logo over the source
	generatedImage := imageutils.GenerateImageWithLogo(originalImage, logoImage)
	generatedImageBytes, err := imageutils.ImageToBytes(generatedImage)
	if err != nil {
		message := fmt.Sprintf("An error occured: %s\n", err)
		ctx.Errorf(message)
		fmt.Fprintf(w, message)
		return
	}
	// Cache the generated image bytes before sending them in the HTTP response
	if MEMCACHE_ENABLED {
		item := &memcache.Item{
			Key:   logoImageUrl + ":" + originalImageUrl,
			Value: generatedImageBytes,
		}
		memcache.Add(ctx, item)
		ctx.Infof("Caching [%s:%s]\n", logoImageUrl, originalImageUrl)
	}
	ctx.Infof("Serving up [%s:%s]\n", logoImageUrl, originalImageUrl)
	w.Header().Set("Content-Type", "image/png")
	w.Write(generatedImageBytes)
}

/*
 * This exported functions returns (and if needed, generates) a token
 */
func GetToken(r *http.Request) string {
	c := appengine.NewContext(r)
	u := user.Current(c)

	// CSRF Token name
	csrfTokenUserID := "CSRF" + u.ID

	// Get the item from the memcache
	if item, err := memcache.Get(c, csrfTokenUserID); err == nil {
		// Return the token
		return string(item.Value)
	}
	// Get the item from the datastore
	key := datastore.NewKey(c, "SecurityToken", csrfTokenUserID, 0, nil)
	var datastoreSecurityToken SecurityToken
	if err := datastore.Get(c, key, &datastoreSecurityToken); err == nil {
		// Add it to memcache
		item := &memcache.Item{
			Key:   csrfTokenUserID,
			Value: []byte(datastoreSecurityToken.Token),
		}
		memcache.Add(c, item)
		// Return the token
		return datastoreSecurityToken.Token
	}

	// Generate a item
	csrfToken := makeRandomString(256)
	// Save it to the memcache
	item := &memcache.Item{
		Key:   csrfTokenUserID,
		Value: []byte(csrfToken),
	}
	memcache.Add(c, item)
	// Save it to the datastore
	SecurityToken := SecurityToken{
		Token: csrfToken,
	}
	datastore.Put(c, datastore.NewKey(c, "SecurityToken", u.ID, 0, nil), &SecurityToken)

	return csrfToken
}

func (session *Session) CheckCache(id string) bool {
	item := &memcache.Item{
		Key:   id,
		Value: []byte(""),
	}
	// Add the item to the memcache, if the key does not already exist
	if err := memcache.Add(session.context, item); err == memcache.ErrNotStored {
		return true
	}
	return false
}

// PostAndTimeByID returns a PostAndTime for the requested id
func PostAndTimeByID(c appengine.Context, id int64) PostAndTime {
	memcacheKey := "posts_and_time" + strconv.FormatInt(id, 10)
	c.Infof("cs253: Post and time by id memcache key is: %v ", memcacheKey)

	var postAndTime PostAndTime
	c.Infof("cs253: query cache first with memcache key")
	if item, err := memcache.Get(c, memcacheKey); err == memcache.ErrCacheMiss {
		c.Infof("cs253: item not in the cache :%v will perform query instead", err)

		key := datastore.NewKey(c, "Post", "", id, nil)
		c.Infof("cs253: key to use: v%", key)

		if err := datastore.Get(c, key, &postAndTime.Post); err != nil {
			c.Errorf("cs253: post not found : %v", err)
		}
		c.Infof("cs253: get time:")
		postAndTime.Cache_hit_time = time.Now()
		c.Infof("cs253: time is: %v", postAndTime.Cache_hit_time)
		// record information in cache for next time
		mCache := new(bytes.Buffer)
		encCache := gob.NewEncoder(mCache)
		c.Infof("cs253: New Encoder done")
		encCache.Encode(postAndTime)
		c.Infof("cs253: Encode done")

		postItem := &memcache.Item{
			Key:   memcacheKey,
			Value: mCache.Bytes(),
		}
		c.Infof("cs253: memcache Item ready")
		if err := memcache.Add(c, postItem); err == memcache.ErrNotStored {
			c.Errorf("cs253: postAndTime with key %q already exists", item.Key)
		} else if err != nil {
			c.Errorf("error adding item: %v", err)
		}
		c.Infof("cs253: item read to be returned")

	} else if err != nil {
		c.Errorf("cs253: Memcache error getting item: %v", err)
	} else {
		c.Infof("cs253: Memcache item found")

		pCache := bytes.NewBuffer(item.Value)
		c.Infof("cs253: New Buffer ready")
		decCache := gob.NewDecoder(pCache)
		c.Infof("cs253: decoder ready")
		decCache.Decode(&postAndTime)
		c.Infof("cs253: gob decoder of item done")
	}
	return postAndTime
}

func servePresentation(w http.ResponseWriter, r *http.Request) error {
	c := appengine.NewContext(r)
	importPath := r.URL.Path[1:]

	item, err := memcache.Get(c, importPath)
	if err == nil {
		writeHTMLHeader(w, 200)
		w.Write(item.Value)
		return nil
	} else if err != memcache.ErrCacheMiss {
		return err
	}

	c.Infof("Fetching presentation %s.", importPath)
	pres, err := gosrc.GetPresentation(httpClient(r), importPath)
	if err != nil {
		return err
	}

	ctx := &present.Context{
		ReadFile: func(name string) ([]byte, error) {
			if p, ok := pres.Files[name]; ok {
				return p, nil
			}
			return nil, presFileNotFoundError(name)
		},
	}

	doc, err := ctx.Parse(bytes.NewReader(pres.Files[pres.Filename]), pres.Filename, 0)
	if err != nil {
		return err
	}

	var buf bytes.Buffer
	if err := renderPresentation(&buf, importPath, doc); err != nil {
		return err
	}

	if err := memcache.Add(c, &memcache.Item{
		Key:        importPath,
		Value:      buf.Bytes(),
		Expiration: time.Hour,
	}); err != nil {
		return err
	}

	writeHTMLHeader(w, 200)
	_, err = w.Write(buf.Bytes())
	return err
}

/*
 * This function will save the data in the memcache and the datastore
 */
func AddCache(r *http.Request, identifier string, data []byte) {
	c := appengine.NewContext(r)

	// Add it to the memcache
	item := &memcache.Item{
		Key:   identifier,
		Value: data,
	}
	memcache.Add(c, item)

	// Add it to the Datastore
	cache := Cache{
		Cached: data,
	}
	datastore.Put(c, datastore.NewKey(c, "Cache", identifier, 0, nil), &cache)
}