func (self *FSMemcache) Initialize() error { self.conn = memcache.New(self.ServerList...) if self.conn == nil { return errors.New("Unable to initialize memcache driver") } return nil }
func TestApp(t *testing.T) { app := newTestAppAndListenTCP(t) mc := memcache.New(app.Listener.Addr().String()) item, err := mc.Get("hoge") if err != nil { t.Fatal(err) } t.Logf("key = %s", item.Key) t.Logf("flags = %d", item.Flags) t.Logf("id = %s", item.Value) if k := item.Key; k != "hoge" { t.Errorf("Unexpected key: %s", k) } if f := item.Flags; f != 0 { t.Errorf("Unexpected flags: %d", f) } if _, err := strconv.ParseInt(string(item.Value), 10, 64); err != nil { t.Errorf("Invalid id: %s", err) } }
func main() { fmt.Println("Iniciando Webserver....") hostname := os.Getenv("HOSTNAME") if hostname != "" { fmt.Println("Running from Container") memcachedServer = "memcached1" rabbitServer = "some-rabbit" } else { fmt.Println("Running from Localhost") } //Esta IP es la IP del container, también se puede poner la de la máquina virtual y funciona //(que es más práctico porque es siempre la misma para todos los containers), la otra es poner el nomber del link //Create the memcached client with the container name linked mc = memcache.New(memcachedServer + ":11211") //Create the Rabbit connection initRabbitMQ() //Creathe the webserver http.HandleFunc("/", handler) http.ListenAndServe(":8080", nil) }
func TestAppIdleTimeout(t *testing.T) { app := newTestAppAndListenTCP(t) app.SetIdleTimeout(1) mc := memcache.New(app.Listener.Addr().String()) t.Log("Before timeout") { item, err := mc.Get("hoge") if err != nil { t.Fatal(err) } if _, err := strconv.ParseInt(string(item.Value), 10, 64); err != nil { t.Errorf("Invalid id: %s", err) } } time.Sleep(2 * time.Second) t.Log("After timeout") { _, err := mc.Get("hoge") if err == nil { t.Fatal("Connection must be disconnected") } } }
func getData(url string) (rv []byte, err error) { mc := memcache.New(*mcdServer) itm, err := mc.Get(url) if err != nil { log.Printf("Fetching %v", url) resp, err := http.Get(url) if err != nil { return rv, err } defer resp.Body.Close() data, err := ioutil.ReadAll(resp.Body) itm = &memcache.Item{ Key: url, Value: data, Expiration: (86400 * 15), } err = mc.Set(itm) if err != nil { log.Printf("Error caching %v: %v", url, err) } } return itm.Value, nil }
func (c *connMc) dials() error { resp, err := c.etcdClient.Get(c.etcdKey+"/servers", true, false) if err != nil { log.Printf("etcd get error: %s", err) return err } if len(resp.Node.Nodes) == 0 { log.Printf("no UQ server registered in etcd") return errors.New("no UQ server registered in etcd") } c.addrs = make([]string, 0) for i, node := range resp.Node.Nodes { parts := strings.Split(node.Key, "/") log.Printf("parts: %v", parts) addr := parts[len(parts)-1] log.Printf("server-%d : %s", i, addr) conn := memcache.New(addr) c.addrs = append(c.addrs, addr) c.conns[addr] = conn } log.Printf("mc conn succ: %v", len(c.conns)) return nil }
// Updates a task state group func (memcacheBackend *MemcacheBackend) updateStateGroup(groupUUID string, taskState *TaskState) error { var taskStateGroup TaskStateGroup client := memcache.New(memcacheBackend.servers...) item, err := client.Get(groupUUID) if err != nil { taskStateGroup = TaskStateGroup{ GroupUUID: groupUUID, States: make(map[string]TaskState), } } else { if err := json.Unmarshal(item.Value, &taskStateGroup); err != nil { log.Printf("Failed to unmarshal task state group: %v", string(item.Value)) log.Print(err) return err } } taskStateGroup.States[taskState.TaskUUID] = *taskState encoded, err := json.Marshal(taskStateGroup) if err != nil { return fmt.Errorf("JSON Encode Message: %v", err) } if err := client.Set(&memcache.Item{ Key: groupUUID, Value: encoded, }); err != nil { return err } return memcacheBackend.setExpirationTime(groupUUID) }
func main() { // Connect to our memcache instance mc := memcache.New("127.0.0.1:11111") err := mc.Set(&memcache.Item{Key: "key_one", Value: []byte("michael")}) if err != nil { log.Fatal(err) } err = mc.Set(&memcache.Item{Key: "key_two", Value: []byte("programming")}) if err != nil { log.Fatal(err) } val, err := mc.Get("key_one") if err != nil { log.Fatal(err) } fmt.Printf("key_one: %s\n", val.Value) it, err := mc.GetMulti([]string{"key_one", "key_two"}) if err != nil { log.Fatal(err) } for k, v := range it { fmt.Printf("%s -> %s\n", k, v.Value) } }
func BenchmarkAdd(b *testing.B) { b.StopTimer() keyPrefix := "set_key" var mcs [nroutine]*memcache.Client for i := 0; i < nroutine; i++ { mcs[i] = memcache.New("127.0.0.1:11211") // pre get because the lazy connecting strategy mcs[i].Get(keyPrefix) } b.StartTimer() var wg sync.WaitGroup nloop := b.N / nroutine * moretimes for i := 0; i < nroutine; i++ { wg.Add(1) go func(idx int) { defer wg.Done() for j := 0; j < nloop; j++ { key := fmt.Sprintf("%s_%d_%d", keyPrefix, i, j) mcs[idx].Get(key) } }(i) } wg.Wait() }
func initializeCache() { var err error cacher = memcache.New(config.MCHost) if err != nil { logrus.Fatal("cache:", err) } }
func main() { var ( host = flag.String("host", "memcached", "memcached host or ip address") command = flag.String("command", "get", "get set, state") key = flag.String("key", "key", "key") value = flag.String("value", "value", "value") ) flag.Parse() mc := memcache.New(*host + ":11211") mc.Timeout = time.Second switch *command { case "get": item, err := mc.Get(*key) if err == nil { fmt.Printf("got %s -> %s\n", *key, string(item.Value)) } else { fmt.Printf("error %v\n", err) } case "set": item := memcache.Item{Key: *key, Value: []byte(*value)} err := mc.Set(&item) if err == nil { fmt.Printf("set %s -> %s\n", *key, *value) } else { fmt.Printf("error %v\n", err) } } }
func New(opts util.JsMap, log *util.HekaLogger) *Storage { config = opts var ok bool if _, ok = config["memcache.server"]; !ok { config["memcache.server"] = "127.0.0.1:11211" } if _, ok = config["db.timeout_live"]; !ok { config["db.timeout_live"] = "259200" } if _, ok = config["db.timeout_reg"]; !ok { config["db.timeout_reg"] = "10800" } if _, ok = config["db.timeout_del"]; !ok { config["db.timeout_del"] = "86400" } if _, ok = config["shard.defaultHost"]; !ok { config["shard.defaultHost"] = "localhost" } if _, ok = config["shard.currentHost"]; !ok { config["shard.currentHost"] = config["shard.defaultHost"] } if _, ok = config["shard.prefix"]; !ok { config["shard.prefix"] = "_h-" } log.Info("storage", "Creating new memcache handler", nil) return &Storage{mc: memcache.New(config["memcache.server"].(string)), config: config, log: log} }
// setup connections to other services running on this host func setupServices() { var error error services.Statsd, error = g2s.Dial("udp", "localhost:8125") if error != nil { log.Fatal("could not set up statsd client.") } services.Memcached = memcache.New("localhost:11211") // setup push service usingSandbox := "true" // true or false uniqushResponse, uniqushError := http.PostForm("http://localhost:9898/addpsp", url.Values{ "pushservicetype": {"apns"}, "service": {"newspeak"}, "cert": {"/etc/newspeak/apns-certs/cert.pem"}, "key": {"/etc/newspeak/apns-certs/priv-noenc.pem"}, "sandbox": {usingSandbox}, }) if uniqushError != nil { log.Fatal("could not add push service provider for apple push notifications: " + string(uniqushError.Error())) } else { uniqushResponseBodyBytes, uniqushError := ioutil.ReadAll(uniqushResponse.Body) uniqushResponseBody := string(uniqushResponseBodyBytes) uniqushResponse.Body.Close() if uniqushError != nil { log.Fatal("could not read response when adding push service provider for apple push notifications: " + string(uniqushError.Error())) } else if uniqushResponseBody[0:30] != "[AddPushServiceProvider][Info]" { log.Fatal("invalid response when adding push service provider for apple push notifications: " + uniqushResponseBody) } else { fmt.Println("added push service provider for apple push notifications. usingSandbox:" + usingSandbox + ", uniqush response:" + uniqushResponseBody) } } }
func makeHandler() web.HandlerFunc { db, err := sql.Open("sqlite3", databaseFile) if err != nil { panic(err) } mc := memcache.New(memcacheServer) return func(req *web.RequestHandler) { req.SetHeader("Access-Control-Allow-Origin", "*") k := strings.Split(req.HTTP.RemoteAddr, ":")[0] // Check quota el, err := mc.Get(k) if err == memcache.ErrCacheMiss { err = mc.Set(&memcache.Item{ Key: k, Value: []byte("1"), Expiration: expirySeconds}) } if err != nil { req.HTTPError(503, "memcache: %s", err.Error()) return } if el != nil { count, _ := strconv.Atoi(string(el.Value)) if count < maxRequestsPerIP { mc.Increment(k, 1) } else { req.HTTPError(403, "") return } } Lookup(req, db) } }
func worker(queue chan []work, opts options, wg *sync.WaitGroup) { defer wg.Done() mc := memcache.New(opts.hostport) for batch := range queue { for _, work := range batch { ok := false var i uint for i = 1; i <= opts.retry; i++ { err := mc.Set(&memcache.Item{Key: work.id, Value: work.blob}) if err != nil { pause := 2 << i * backoff if opts.verbose { log.Printf("retry %d for %s in %s (%s)", i, work.id, pause, err) } time.Sleep(pause) } else { ok = true break } } if !ok { log.Fatal(errSetFailed) } } } }
func main() { appId := flag.String("appid", "", "weixin appid") appSecret := flag.String("appsecret", "", "weixin appsecret") accessTokenKeyFlag := flag.String("a", "access_token", "access token key") jssdkTicketKeyFlag := flag.String("j", "jssdk_ticket", "jssdk ticket key") memcacheAddr := flag.String("mem_addr", "127.0.0.1:11211", "memcache addr") _ = flag.String("redis_addr", "127.0.0.1:6379", "redis addr") flag.Parse() accessTokenKey = *accessTokenKeyFlag jssdkTicketKey = *jssdkTicketKeyFlag log.Printf("appId=%s\n", *appId) log.Printf("appSecret=%s\n", *appSecret) log.Printf("accessTokenKey=%s\n", accessTokenKey) log.Printf("jssdkTicketKey=%s\n", jssdkTicketKey) log.Printf("memcacheAddr=%s\n", *memcacheAddr) accessTokenCH := make(chan string) wx = weixin.New(*appId, *appSecret) mc = memcache.New(*memcacheAddr) go cacheAccessToken(accessTokenCH) go cacheJSSDKTicket(accessTokenCH) for { time.Sleep(time.Second) } }
func newRateLimiter(c *Config) (*httprl.RateLimiter, error) { var backend httprl.Backend switch c.RateLimitBackend { case "map": m := httprl.NewMap(1) m.Start() backend = m case "redis": addrs := strings.Split(c.RedisAddr, ",") rc, err := redis.NewClient(addrs...) if err != nil { return nil, err } rc.SetTimeout(c.RedisTimeout) backend = redisrl.New(rc) case "memcache": addrs := strings.Split(c.MemcacheAddr, ",") mc := memcache.New(addrs...) mc.Timeout = c.MemcacheTimeout backend = memcacherl.New(mc) default: return nil, fmt.Errorf("unsupported backend: %q" + c.RateLimitBackend) } rl := &httprl.RateLimiter{ Backend: backend, Limit: c.RateLimitLimit, Interval: int32(c.RateLimitInterval.Seconds()), ErrorLog: c.errorLogger(), //Policy: httprl.AllowPolicy, } return rl, nil }
func NewApiHandler(server_config *Config) *ApiHandler { h := new(ApiHandler) h.SetAccessLog(server_config) h.Servlets = make(map[string]Servlet) h.Memcached = memcache.New(server_config.Memcache.Host) return h }
func stressMc(idx, n int) { // mc := memcache.New("192.168.1.227:11213", "192.168.1.226:11213") mc := memcache.New("192.168.1.226:11212") for { nsf := 0 ts1 := time.Now().Unix() for i := 0; i < n; i += 1 { // fmt.Println("set", i, "goroutine", idx) key := "foo-" + strconv.Itoa(idx) + "-" + strconv.Itoa(i) err := mc.Set(&memcache.Item{Key: key, Value: []byte("my valuejjjjjjjjjjjjjjjjjjjjjjjjjjjjjllllllllllllllllllllllllllllllllllllaaaaaaaaaaaaaaaaaaaaaaaaf" + strconv.Itoa(i))}) if err != nil { // fmt.Println("err happend setting: ", key); nsf += 1 } } ts2 := time.Now().Unix() fmt.Println("index", idx, "set "+strconv.Itoa(n)+" keys, time:", ts2-ts1, "fail:", nsf) ngf := 0 for i := 0; i < n; i += 1 { // fmt.Println("get", i, "goroutine", idx) key := "foo-" + strconv.Itoa(idx) + "-" + strconv.Itoa(i) _, err := mc.Get(key) if err != nil { // fmt.Println("err happend getting: ", key); ngf += 1 } } ts3 := time.Now().Unix() fmt.Println("index", idx, "get "+strconv.Itoa(n)+" keys, time:", ts3-ts2, "fail:", ngf) // fmt.Println("index", idx, "set fail: ", nsf, "get fail: ", ngf) time.Sleep(1 * time.Second) } }
// MustClient will use the cache cluster ID to describe // the cache cluster and instantiate a memcache.Client // with the cache nodes returned from AWS. func (e *ElastiCache) MustClient() *memcache.Client { var creds *credentials.Credentials if e.AccessKey != "" { creds = credentials.NewStaticCredentials(e.AccessKey, e.SecretKey, "") } else { creds = credentials.NewEnvCredentials() } ecclient := elasticache.New(session.New(&aws.Config{ Credentials: creds, Region: &e.Region, })) resp, err := ecclient.DescribeCacheClusters(&elasticache.DescribeCacheClustersInput{ CacheClusterId: &e.ClusterID, ShowCacheNodeInfo: aws.Bool(true), }) if err != nil { log.Fatalf("unable to describe cache cluster: %s", err) } var nodes []string for _, cluster := range resp.CacheClusters { for _, cnode := range cluster.CacheNodes { addr := fmt.Sprintf("%s:%d", *cnode.Endpoint.Address, *cnode.Endpoint.Port) nodes = append(nodes, addr) } } return memcache.New(nodes...) }
//CreateCStore will create a new CStore func CreateMCStore(expiresTime time.Duration, servers []string) *MCStore { store := new(MCStore) store.mc = memcache.New(servers...) store.mc.Timeout = expiresTime return store }
func init() { servers, err := getServerList() if err != nil { panic(err) } client = memcache.New(servers...) }
func getGomemcacheClient(nServers int) *memcache.Client { servers := make([]string, nServers) for i := 0; i < nServers; i++ { servers[i] = fmt.Sprintf("localhost:%d", 21211+i) } return memcache.New(servers...) }
func initMemcacheConn() { var ( host = config.GetConf().String("memcache::host") port = config.GetConf().String("memcache::port") ) mClient = memcache.New(host + ":" + port) }
func NewCache(connstr string, handler http.Handler, limit Bytes, limiter LimiterFactory) http.Handler { return &Cache{ mc: memcache.New(connstr), handler: handler, Limit: limit, limiter: limiter, } }
func NewMemcache(servers []string, cacheKeyPrefix string) *Memcache { m := new(Memcache) m.mc = memcache.New(servers...) m.keyprefix = cacheKeyPrefix return m }
func NewKV(addrs []string) kv.KV { if len(addrs) == 0 { addrs = []string{"127.0.0.1:11211"} } return &mkv{ Client: mc.New(addrs...), } }
func New(server ...string) *Provider { if len(server) == 0 { panic("[memcacheProvider.New] len(server)==0") } return &Provider{ Client: memcache.New(server...), } }
func main() { mc := memcache.New("127.0.0.1:11211") gtk.Init(nil) window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL) window.SetTitle("memcachedclient") window.Connect("destroy", gtk.MainQuit) vbox := gtk.NewVBox(false, 1) swin := gtk.NewScrolledWindow(nil, nil) textview := gtk.NewTextView() textview.SetEditable(false) textview.SetCursorVisible(false) textview.ModifyFontEasy("monospace 12") swin.Add(textview) vbox.Add(swin) buffer := textview.GetBuffer() input := gtk.NewEntry() input.SetEditable(true) vbox.PackEnd(input, false, false, 0) tag := buffer.CreateTag("red", map[string]string{"foreground": "#FF0000"}) input.Connect("activate", func() { var iter gtk.TextIter tokens := strings.SplitN(input.GetText(), " ", 3) if len(tokens) == 2 && strings.ToUpper(tokens[0]) == "GET" { if t, err := mc.Get(tokens[1]); err == nil { buffer.GetEndIter(&iter) buffer.Insert(&iter, string(t.Value)+"\n") } else { buffer.InsertWithTag(&iter, err.Error()+"\n", tag) } input.SetText("") } else if len(tokens) == 3 && strings.ToUpper(tokens[0]) == "SET" { if err := mc.Set( &memcache.Item{ Key: tokens[1], Value: []byte(tokens[2]), }); err == nil { buffer.GetEndIter(&iter) buffer.InsertWithTag(&iter, "OK\n", tag) } else { buffer.InsertWithTag(&iter, err.Error()+"\n", tag) } input.SetText("") } }) input.GrabFocus() window.Add(vbox) window.SetSizeRequest(300, 500) window.ShowAll() gtk.Main() }
func New(config *Config, sid string) *Memcache { m := &Memcache{ config: config, sid: sid, client: memcache.New(config.Host), } return m }