init

Author: lunny

Diff for: README.md

@@ -0,0 +1 @@
+# cache memcache

Diff for: memcache.go

@@ -0,0 +1,92 @@
+// Copyright 2013 Beego Authors
+// Copyright 2014 The Macaron Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package cache
+
+import (
+	"strings"
+
+	"github.com/Unknwon/com"
+	"github.com/bradfitz/gomemcache/memcache"
+
+	"github.com/tango-contrib/cache"
+)
+
+// MemcacheCacher represents a memcache cache adapter implementation.
+type MemcacheCacher struct {
+	c *memcache.Client
+}
+
+func NewItem(key string, data []byte, expire int32) *memcache.Item {
+	return &memcache.Item{
+		Key:        key,
+		Value:      data,
+		Expiration: expire,
+	}
+}
+
+// Put puts value into cache with key and expire time.
+// If expired is 0, it lives forever.
+func (c *MemcacheCacher) Put(key string, val interface{}, expire int64) error {
+	return c.c.Set(NewItem(key, []byte(com.ToStr(val)), int32(expire)))
+}
+
+// Get gets cached value by given key.
+func (c *MemcacheCacher) Get(key string) interface{} {
+	item, err := c.c.Get(key)
+	if err != nil {
+		return nil
+	}
+	return string(item.Value)
+}
+
+// Delete deletes cached value by given key.
+func (c *MemcacheCacher) Delete(key string) error {
+	return c.c.Delete(key)
+}
+
+// Incr increases cached int-type value by given key as a counter.
+func (c *MemcacheCacher) Incr(key string) error {
+	_, err := c.c.Increment(key, 1)
+	return err
+}
+
+// Decr decreases cached int-type value by given key as a counter.
+func (c *MemcacheCacher) Decr(key string) error {
+	_, err := c.c.Decrement(key, 1)
+	return err
+}
+
+// IsExist returns true if cached value exists.
+func (c *MemcacheCacher) IsExist(key string) bool {
+	_, err := c.c.Get(key)
+	return err == nil
+}
+
+// Flush deletes all cached data.
+func (c *MemcacheCacher) Flush() error {
+	return c.c.FlushAll()
+}
+
+// StartAndGC starts GC routine based on config string settings.
+// AdapterConfig: 127.0.0.1:9090;127.0.0.1:9091
+func (c *MemcacheCacher) StartAndGC(opt cache.Options) error {
+	c.c = memcache.New(strings.Split(opt.AdapterConfig, ";")...)
+	return nil
+}
+
+func init() {
+	cache.Register("memcache", &MemcacheCacher{})
+}

Diff for: memcache.goconvey

@@ -0,0 +1 @@
+ignore

Diff for: memcache_test.go

@@ -0,0 +1,113 @@
+// Copyright 2014 The Macaron Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package cache
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/Unknwon/com"
+	"github.com/lunny/tango"
+	. "github.com/smartystreets/goconvey/convey"
+
+	"github.com/tango-contrib/cache"
+)
+
+type CacheAction struct {
+	cache.Cache
+}
+
+func (c *CacheAction) Get() {
+	So(c.Put("uname", "unknwon", 1), ShouldBeNil)
+	So(c.Put("uname2", "unknwon2", 1), ShouldBeNil)
+	So(c.IsExist("uname"), ShouldBeTrue)
+
+	So(c.Cache.Get("404"), ShouldBeNil)
+	So(c.Cache.Get("uname").(string), ShouldEqual, "unknwon")
+
+	time.Sleep(1 * time.Second)
+	So(c.Cache.Get("uname"), ShouldBeNil)
+	time.Sleep(1 * time.Second)
+	So(c.Cache.Get("uname2"), ShouldBeNil)
+
+	So(c.Put("uname", "unknwon", 0), ShouldBeNil)
+	So(c.Delete("uname"), ShouldBeNil)
+	So(c.Cache.Get("uname"), ShouldBeNil)
+
+	So(c.Put("uname", "unknwon", 0), ShouldBeNil)
+	So(c.Flush(), ShouldBeNil)
+	So(c.Cache.Get("uname"), ShouldBeNil)
+}
+
+type Cache2Action struct {
+	cache.Cache
+}
+
+func (c *Cache2Action) Get() {
+	So(c.Incr("404"), ShouldNotBeNil)
+	So(c.Decr("404"), ShouldNotBeNil)
+
+	So(c.Put("int", 0, 0), ShouldBeNil)
+	So(c.Put("int64", int64(0), 0), ShouldBeNil)
+	So(c.Put("string", "hi", 0), ShouldBeNil)
+
+	So(c.Incr("int"), ShouldBeNil)
+	So(c.Incr("int64"), ShouldBeNil)
+
+	So(c.Decr("int"), ShouldBeNil)
+	So(c.Decr("int64"), ShouldBeNil)
+
+	So(c.Incr("string"), ShouldNotBeNil)
+	So(c.Decr("string"), ShouldNotBeNil)
+
+	So(com.StrTo(c.Cache.Get("int").(string)).MustInt(), ShouldEqual, 0)
+	So(com.StrTo(c.Cache.Get("int64").(string)).MustInt64(), ShouldEqual, 0)
+
+	So(c.Flush(), ShouldBeNil)
+}
+
+func Test_MemcacheCacher(t *testing.T) {
+	Convey("Test memcache cache adapter", t, func() {
+		opt := cache.Options{
+			Adapter:       "memcache",
+			AdapterConfig: "127.0.0.1:9090",
+		}
+
+		Convey("Basic operations", func() {
+			t := tango.New()
+			t.Use(cache.New(opt))
+
+			t.Get("/", new(CacheAction))
+
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", "/", nil)
+			So(err, ShouldBeNil)
+			t.ServeHTTP(resp, req)
+		})
+
+		Convey("Increase and decrease operations", func() {
+			t := tango.New()
+			t.Use(cache.New(opt))
+			t.Get("/", new(Cache2Action))
+
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", "/", nil)
+			So(err, ShouldBeNil)
+			t.ServeHTTP(resp, req)
+		})
+	})
+}