func SetMulti(c appengine.Context, items []*memcache.Item) error { err := memcache.SetMulti(c, items) if err == nil { return make(appengine.MultiError, len(items)) } return err }
func (builder *stepsBuilder) SaveMemcacheBatch(context appengine.Context) stream.EachFn { return func(data stream.T) { if err := memcache.SetMulti(context, data.(*MemcacheSaveBatch).Items); err != nil { panic(err) } } }
func cacheClear(c appengine.Context, keys ...string) error { items := make([]*memcache.Item, len(keys)) for i := range keys { items[i] = &memcache.Item{Key: keys[i], Expiration: 2 * time.Minute, Value: []byte{0}} } return memcache.SetMulti(c, items) }
// Object usually too big (1MB limit), so shard. // http://stackoverflow.com/questions/9127982/ func BytesToShardedMemcache(c appengine.Context, key string, b []byte) { /* var buf bytes.Buffer if err := gob.NewEncoder(&buf).Encode(f); err != nil { db.C.Errorf("fdb error encoding item: %v", err) return } b := buf.Bytes() */ items := []*memcache.Item{} for i := 0; i < len(b); i += chunksize { k := fmt.Sprintf("=%d=%s", i, key) s, e := i, i+chunksize-1 if e >= len(b) { e = len(b) - 1 } c.Infof(" #=== [%7d, %7d] (%d) %s", s, e, len(b), k) items = append(items, &memcache.Item{Key: k, Value: b[s : e+1]}) // slice sytax is [s,e) } if err := memcache.SetMulti(c, items); err != nil { c.Errorf(" #=== cdb sharded store fail: %v", err) } c.Infof(" #=== Stored '%s' (len=%d)!", key, len(b)) }
// Object usually too big (1MB limit), so shard. // http://stackoverflow.com/questions/9127982/ func (db FlightDB) flightsToShardedMemcache(key string, f []f.Flight) { var buf bytes.Buffer if err := gob.NewEncoder(&buf).Encode(f); err != nil { db.C.Errorf("fdb error encoding item: %v", err) return } b := buf.Bytes() items := []*memcache.Item{} for i := 0; i < len(b); i += chunksize { k := fmt.Sprintf("=%d=%s", i, key) s, e := i, i+chunksize-1 if e >= len(b) { e = len(b) - 1 } db.C.Infof(" #--- [%7d, %7d] (%d) %s", s, e, len(b), k) items = append(items, &memcache.Item{Key: k, Value: b[s : e+1]}) // slice sytax is [s,e) } if err := memcache.SetMulti(db.C, items); err != nil { db.C.Errorf(" #--- fdb sharded store fail: %v", err) } db.C.Infof(" #--- Stored '%s' (len=%d)!", key, len(b)) }
// cache writes structs and PropertyLoadSavers to memcache. func cache(key []*datastore.Key, src interface{}, c appengine.Context) error { items, err := encodeItems(key, src) if len(items) > 0 && err == nil { if Debug { c.Debugf("writing to memcache: %#v", src) } err = memcache.SetMulti(c, items) } return err }
func (c Context) Save() { c.Stats.wg.Wait() c.Stats.Duration = time.Since(c.Stats.Start) var buf_part, buf_full bytes.Buffer full := stats_full{ Header: c.req.Header, Stats: c.Stats, } if err := gob.NewEncoder(&buf_full).Encode(&full); err != nil { c.Errorf("appstats Save error: %v", err) return } else if buf_full.Len() > bufMaxLen { // first try clearing stack traces for i := range full.Stats.RPCStats { full.Stats.RPCStats[i].StackData = "" } buf_full.Truncate(0) gob.NewEncoder(&buf_full).Encode(&full) } part := stats_part(*c.Stats) for i := range part.RPCStats { part.RPCStats[i].StackData = "" part.RPCStats[i].In = "" part.RPCStats[i].Out = "" } if err := gob.NewEncoder(&buf_part).Encode(&part); err != nil { c.Errorf("appstats Save error: %v", err) return } item_part := &memcache.Item{ Key: c.Stats.PartKey(), Value: buf_part.Bytes(), } item_full := &memcache.Item{ Key: c.Stats.FullKey(), Value: buf_full.Bytes(), } c.Infof("Saved; %s: %s, %s: %s, link: %v", item_part.Key, ByteSize(len(item_part.Value)), item_full.Key, ByteSize(len(item_full.Value)), c.URL(), ) nc := context(c.req) memcache.SetMulti(nc, []*memcache.Item{item_part, item_full}) }
func (ks *KodeSession) ToCache(c appengine.Context) error { pair := strings.Join(ks.Pair, DELIMITER) // Cache the session under both ids. items := []*memcache.Item{ &memcache.Item{Key: ks.Candidate, Value: []byte(pair)}, &memcache.Item{Key: ks.Interviewer, Value: []byte(pair)}, } err := memcache.SetMulti(c, items) if err != nil { return err } return nil }
func (d *Driver) SetMulti(keys []string, src interface{}) error { var items = make([]*memcache.Item, 0) srcValue := reflect.ValueOf(src) for i, key := range keys { obj := srcValue.Index(i).Interface() if buff, err := json.Marshal(obj); err != nil { return err } else { items = append(items, &memcache.Item{ Key: key, Value: buff, }) } } return memcache.SetMulti(d.ctx, items) }
func (u GAE) MemorySet(items *[]MemoryItem) error { if items == nil || len(*items) < 1 { return nil } gaeItems := make([]*memcache.Item, len(*items)) for index, item := range *items { gaeItems[index] = &memcache.Item{ Key: item.Key, Value: []byte(item.Value), Expiration: time.Duration(item.Ttl) * time.Second, } Verbosef(u, "GAE.MemorySet item[%d] = %v", index, item) } return memcache.SetMulti(u.context, gaeItems) }
func (g *Goon) putMemcache(srcs []interface{}, exists []byte) error { items := make([]*memcache.Item, len(srcs)) payloadSize := 0 for i, src := range srcs { toSerialize := src if exists[i] == 0 { toSerialize = nil } data, err := serializeStruct(toSerialize) if err != nil { g.error(err) return err } key, _, err := g.getStructKey(src) if err != nil { return err } // payloadSize will overflow if we push 2+ gigs on a 32bit machine payloadSize += len(data) items[i] = &memcache.Item{ Key: memkey(key), Value: data, } } memcacheTimeout := MemcachePutTimeoutSmall if payloadSize >= MemcachePutTimeoutThreshold { memcacheTimeout = MemcachePutTimeoutLarge } errc := make(chan error) go func() { errc <- memcache.SetMulti(appengine.Timeout(g.Context, memcacheTimeout), items) }() g.putMemoryMulti(srcs, exists) err := <-errc if appengine.IsTimeoutError(err) { g.timeoutError(err) err = nil } else if err != nil { g.error(err) } return err }