// NewSimpleInMemoryStore creates a new SimpleInMemoryStore. Simple as that.
func NewSimpleInMemoryStore() *SimpleInMemoryStore {
return &SimpleInMemoryStore{
Nodeinfos: make(map[string]NodeInfo),
//Statistics: make(map[string]*StatisticsStruct),
statistics: cache2go.Cache("statistics"),
StatusInfo: make(map[string]NodeStatusInfo),
//NeighbourInfos: make(map[string]*NeighbourStruct),
neighbourCache: cache2go.Cache("neighbours"),
GatewayList: make(map[string]bool),
}
}
func main() {
cache := cache2go.Cache("myCache")
// The data loader gets called automatically whenever something
// tries to retrieve a non-existing key from the cache.
cache.SetDataLoader(func(key interface{}) *cache2go.CacheItem {
// Apply some clever loading logic here, e.g. read values for
// this key from database, network or file.
val := "This is a test with key " + key.(string)
// This helper method creates the cached item for us. Yay!
item := cache2go.CreateCacheItem(key, 0, val)
return &item
})
// Let's retrieve a few auto-generated items from the cache.
for i := 0; i < 10; i++ {
res, err := cache.Value("someKey_" + strconv.Itoa(i))
if err == nil {
fmt.Println("Found value in cache:", res.Data())
} else {
fmt.Println("Error retrieving value from cache:", err)
}
}
}
func main() {
cache := cache2go.Cache("myCache")
// This callback will be triggered every time a new item
// gets added to the cache.
cache.SetAddedItemCallback(func(entry *cache2go.CacheItem) {
fmt.Println("Added:", entry.Key(), entry.Data(), entry.CreatedOn())
})
// This callback will be triggered every time an item
// is about to be removed from the cache.
cache.SetAboutToDeleteItemCallback(func(entry *cache2go.CacheItem) {
fmt.Println("Deleting:", entry.Key(), entry.Data(), entry.CreatedOn())
})
// Caching a new item will execute the AddedItem callback.
cache.Add("someKey", 0, "This is a test!")
// Let's retrieve the item from the cache
res, err := cache.Value("someKey")
if err == nil {
fmt.Println("Found value in cache:", res.Data())
} else {
fmt.Println("Error retrieving value from cache:", err)
}
// Deleting the item will execute the AboutToDeleteItem callback.
cache.Delete("someKey")
}
func main() {
cache := cache2go.Cache("myCache")
// This callback will be triggered every time a new item
// gets added to the cache.
cache.SetAddedItemCallback(func(entry *cache2go.CacheItem) {
fmt.Println("Added:", entry.Key(), entry.Data(), entry.CreatedOn())
})
// This callback will be triggered every time an item
// is about to be removed from the cache.
cache.SetAboutToDeleteItemCallback(func(entry *cache2go.CacheItem) {
fmt.Println("Deleting:", entry.Key(), entry.Data(), entry.CreatedOn())
})
// Caching a new item will execute the AddedItem callback.
cache.Add("someKey", 0, "This is a test!")
// Let's retrieve the item from the cache
res, err := cache.Value("someKey")
if err == nil {
fmt.Println("Found value in cache:", res.Data())
} else {
fmt.Println("Error retrieving value from cache:", err)
}
// Deleting the item will execute the AboutToDeleteItem callback.
cache.Delete("someKey")
// Caching a new item that expires in 3 seconds
res = cache.Add("anotherKey", 3*time.Second, "This is another test")
// This callback will be triggered when the item is about to expire
res.SetAboutToExpireCallback(func(key interface{}) {
fmt.Println("About to expire:", key.(string))
})
time.Sleep(5 * time.Second)
}
func main() {
// Accessing a new cache table for the first time will create it.
cache := cache2go.Cache("myCache")
// We will put a new item in the cache. It will expire after
// not being accessed via Value(key) for more than 5 seconds.
val := myStruct{"This is a test!", []byte{}}
cache.Add("someKey", 5*time.Second, &val)
// Let's retrieve the item from the cache.
res, err := cache.Value("someKey")
if err == nil {
fmt.Println("Found value in cache:", res.Data().(*myStruct).text)
} else {
fmt.Println("Error retrieving value from cache:", err)
}
// Wait for the item to expire in cache.
time.Sleep(6 * time.Second)
res, err = cache.Value("someKey")
if err != nil {
fmt.Println("Item is not cached (anymore).")
}
// Add another item that never expires.
cache.Add("someKey", 0, &val)
// cache2go supports a few handy callbacks and loading mechanisms.
cache.SetAboutToDeleteItemCallback(func(e *cache2go.CacheItem) {
fmt.Println("Deleting:", e.Key(), e.Data().(*myStruct).text, e.CreatedOn())
})
// Remove the item from the cache.
cache.Delete("someKey")
// And wipe the entire cache table.
cache.Flush()
}
"content-security-policy": true, // sent in response
"content-security-policy-report-only": true, // sent in response
"accept-encoding": true, // sent in request
"cookie": true, // sent in request
}
type proxyManager struct {
req *http.Request
uri *url.URL
resp *http.Response
}
var sessionManager *Manager
//cache
var cache = cache2go.Cache("cache")
// cache buffer
type cacheBuffer struct {
header http.Header
body []byte
}
func encodeURL(plainURL []byte) string {
return GopeeEncPrefix + base64.URLEncoding.EncodeToString(plainURL)
}
func decodeURL(encodedURL string) (decodedURI *url.URL, err error) {
encodedURL = strings.TrimSpace(encodedURL)
if encodedURL == "" || !strings.HasPrefix(encodedURL, GopeeEncPrefix) {
err = errors.New("invalid path supplied to decode")