func NewCache(config CacheConfig) (Cache, error) { if config.Driver == "" { return nil, nil } else if config.Driver == "memory" { var data struct { Interval int `json:"interval,omitempty"` } data.Interval = config.GcInterval configString, err := json.Marshal(data) if err != nil { return nil, err } cacheInner, err := cache.NewCache("memory", string(configString)) if err != nil { return nil, err } return &cacheImplement{ store: cacheInner, saveprefix: config.SavePrefix, }, nil } else if config.Driver == "redis" { var data struct { Key string `json:"key"` Conn string `json:"conn"` Password string `json:"password,omitempty"` } if config.SavePrefix == "" { return nil, errors.New("invalid config.SavePrefix is empty") } data.Key = config.SavePrefix configArray := Explode(config.SavePath, ",") if len(configArray) == 0 { return nil, errors.New("invalid config.SavePath " + config.SavePath) } data.Conn = configArray[0] if len(configArray) >= 3 { data.Password = configArray[2] } configString, err := json.Marshal(data) if err != nil { return nil, err } cacheInner, err := cache.NewCache("redis", string(configString)) if err != nil { return nil, err } return &cacheImplement{ store: cacheInner, saveprefix: config.SavePrefix, }, nil } else { return nil, errors.New("invalid cache config " + config.Driver) } }
func Initialize() { var err error beego.Info("thisi s is s ") var cac cache.Cache cac, err = cache.NewCache("memory", `{"interval":360}`) cachemanager.Cache = cac // session settings beego.BConfig.WebConfig.Session.SessionOn = true //beego.BConfig.WebConfig.Session.SessionProvider = Cfg.MustValue("session", "session_provider", "file") //beego.BConfig.WebConfig.Session.SessionProviderConfig = Cfg.MustValue("session", "session_path", "sessions") //beego.BConfig.WebConfig.Session.SessionName = Cfg.MustValue("session", "session_name", "wetalk_sess") //beego.BConfig.WebConfig.Session.SessionCookieLifeTime = Cfg.MustInt("session", "session_life_time", 0) //beego.BConfig.WebConfig.Session.SessionGCMaxLifetime = Cfg.MustInt64("session", "session_gc_time", 86400) //load custom configurations loadConfig() //disable live reload for db connections PostgresConnection = beego.AppConfig.DefaultString(beego.BConfig.RunMode+"::"+"pg_conn", "user=postgres password=root dbname=eq sslmode=disable") PostgresMigrateConnection = beego.AppConfig.DefaultString(beego.BConfig.RunMode+"::"+"pg_migrate", "postgres://*****:*****@localhost:5432/test?sslmode=disable") // cache system Captcha = captcha.NewCaptcha("/captcha/", cac) Captcha.FieldIDName = "CaptchaId" Captcha.FieldCaptchaName = "Captcha" settingCompress() settingLocales() //watch conf files change configWatcher() if err != nil { beego.Error(err) } }
//初始化文件缓存,配置参数如下 // // filecache_dir 缓存文件目录 // // filecache_suffix 缓存文件后缀(.cache) // // filecache_level 目录层级(2) // // filecache_expire 过期时间(3600秒) func InitFilecache() (cache.Cache, error) { if beego.BConfig.RunMode == "dev" { beego.Info("initiating file cache") } filecache_dir := beego.AppConfig.DefaultString("filecache_dir", "") filecache_suffix := beego.AppConfig.DefaultString("filecache_suffix", ".cache") filecache_level := beego.AppConfig.DefaultInt("filecache_level", 2) filecache_expire := beego.AppConfig.DefaultInt("filecache_expire", 3600) if filecache_dir == "" { panic("filecache_dir is not set") } info, err := os.Stat(filecache_dir) if err != nil && !os.IsExist(err) { if err := os.MkdirAll(filecache_dir, 777); err != nil { panic(fmt.Sprintf("%s not exist and can not be created\n%v", filecache_dir, err)) } } if !info.IsDir() { panic(fmt.Sprintf("%s is not a directory", filecache_dir)) } if err := syscall.Access(filecache_dir, syscall.O_RDWR); err != nil { panic(fmt.Sprintf("%s is not accessable\n%v", filecache_dir, err)) } return cache.NewCache("file", fmt.Sprintf(`{"CachePath":"%s","FileSuffix":"%s","DirectoryLevel":%d,"EmbedExpiry":%d}`, filecache_suffix, filecache_suffix, filecache_level, filecache_expire)) }
func init() { var err error Cache, err = cache.NewCache("memory", `{"interval":720}`) if err != nil { log.Errorf("Failed to initialize cache, error:%v", err) } }
func LoadConfig() { redisServer := beego.AppConfig.String("redis_resource") redisServer = "{\"conn\":\"" + redisServer + "\"}" store, err := cache.NewCache("redis", redisServer) if err != nil { log.Panic("缓存出错" + err.Error()) } Captcha = captcha.NewWithFilter("/captcha/", store) driverName := beego.AppConfig.String("driverName") dataSource := beego.AppConfig.String("dataSource") maxIdle, _ := beego.AppConfig.Int("maxIdle") maxOpen, _ := beego.AppConfig.Int("maxOpen") orm.RegisterDriver("mysql", orm.DR_MySQL) // set default database err = orm.RegisterDataBase("default", driverName, dataSource, maxIdle, maxOpen) if err != nil { beego.Error(err) } orm.RunCommand() err = orm.RunSyncdb("default", false, false) if err != nil { beego.Error(err) } SocialAuthInit() config.InitConfig() }
func NewCache(name, config string) (*Cache, error) { adp, err := bgcache.NewCache(name, config) if err != nil { return nil, err } return &Cache{adapter: adp, name: name}, nil }
func TestRedisCache(t *testing.T) { bm, err := cache.NewCache("redis", `{"conn": "127.0.0.1:6379"}`) if err != nil { t.Error("init err") } if err = bm.Put("astaxie", 1, 10); err != nil { t.Error("set Error", err) } if !bm.IsExist("astaxie") { t.Error("check err") } time.Sleep(10 * time.Second) if bm.IsExist("astaxie") { t.Error("check err") } if err = bm.Put("astaxie", 1, 10); err != nil { t.Error("set Error", err) } if v, _ := redis.Int(bm.Get("astaxie"), err); v != 1 { t.Error("get err") } if err = bm.Incr("astaxie"); err != nil { t.Error("Incr Error", err) } if v, _ := redis.Int(bm.Get("astaxie"), err); v != 2 { t.Error("get err") } if err = bm.Decr("astaxie"); err != nil { t.Error("Decr Error", err) } if v, _ := redis.Int(bm.Get("astaxie"), err); v != 1 { t.Error("get err") } bm.Delete("astaxie") if bm.IsExist("astaxie") { t.Error("delete err") } //test string if err = bm.Put("astaxie", "author", 10); err != nil { t.Error("set Error", err) } if !bm.IsExist("astaxie") { t.Error("check err") } if v, _ := redis.String(bm.Get("astaxie"), err); v != "author" { t.Error("get err") } // test clear all if err = bm.ClearAll(); err != nil { t.Error("clear all err") } }
//初始化内存缓存,配置参数如下 // // memory_gc_interval 内存回收周期(60秒) func InitMemorycache() (cache.Cache, error) { if beego.BConfig.RunMode == "dev" { beego.Info("initiating memory cache") } memory_interval := beego.AppConfig.DefaultInt("memory_gc_interval", 60) return cache.NewCache("memory", fmt.Sprintf(`{"interval":%d}`, memory_interval)) }
func init() { log.Println("---------- Context init called.-----------------") AppCtx = &AppContext{} AppCtx.Sitename = beego.AppConfig.String("sitename") // cache init APPCache, _ = cache.NewCache("memory", `{"interval":3600}`) }
func initRedis() { var err error cc, err = cache.NewCache("redis", `{"conn":"`+beego.AppConfig.String("redis_host")+`"}`) if err != nil { beego.Info(err) } }
func initMemcache() { var err error cc, err = cache.NewCache("memcache", `{"conn":"`+beego.AppConfig.String("memcache_host")+`"}`) if err != nil { beego.Info(err) } }
//初始化redis缓存,配置参数如下 // // rediscache_host redis主机(127.0.0.1) // // rediscache_port redis端口(6379) func InitRediscache() (cache.Cache, error) { if beego.BConfig.RunMode == "dev" { beego.Info("initiating redis cache") } rediscache_host := beego.AppConfig.DefaultString("rediscache_host", "127.0.0.1") rediscache_port := beego.AppConfig.DefaultString("rediscache_port", "6379") return cache.NewCache("redis", fmt.Sprintf(`{"conn":"%s:%s"}`, rediscache_host, rediscache_port)) }
//初始化memcache缓存,配置参数如下 // // memcache_host memcache主机(127.0.0.1) // // memcache_port memcache端口(11211) func InitMemcache() (cache.Cache, error) { if beego.BConfig.RunMode == "dev" { beego.Info("initiating memcache") } memcache_host := beego.AppConfig.DefaultString("memcache_host", "127.0.0.1") memcache_port := beego.AppConfig.DefaultString("memcache_port", "11211") return cache.NewCache("memcache", fmt.Sprintf(`{"conn":"%s:%s"`, memcache_host, memcache_port)) }
func init() { var err error Cache, err = cache.NewCache("memory", `{"interval":720}`) if err != nil { log.Errorf("Failed to initialize cache, error:%v", err) } endpoint = os.Getenv("REGISTRY_URL") username = "******" }
func GetRedisInstance() cache.Cache { if redisBase == nil { redisInst, err := cache.NewCache("redis", `{"conn":"127.0.0.1:6379", "key":"beecacheRedis"}`) if err != nil { log.Println(err) } redisBase = &RedisBase{RedisInst: redisInst} } return redisBase.RedisInst }
// 初始化Cache func initCache() error { var err error // Cache 第三方引擎 helper.GlobalCache, err = cache.NewCache(CACHE_ENGINE_REDIS, "{\"conn\": \""+models.RedisAddress+"\"}") if err != nil { return err } return nil }
func init() { var err error Cache, err = cache.NewCache("memory", `{"interval":720}`) if err != nil { log.Errorf("Failed to initialize cache, error:%v", err) } endpoint = os.Getenv("REGISTRY_URL") username = "******" repositoryClients = make(map[string]*registry.Repository, 10) }
func (this *MainController) Get() { // c,_ := cache.NewCache("file", `{"CachePath":"./cache","FileSuffix":".cache","DirectoryLevel":2,"EmbedExpiry":120}`) c,_ := cache.NewCache("memory", `{"interval":60}`) tmp:=c.Get("hello") this.dump(tmp) if(tmp != nil){ this.dump(tmp); }else{ c.Put("hello",time.Now(),2) } }
//初始化缓存 func InitCache() { //初始化权限配置缓存 var err error Cache_All, err = cache.NewCache("memory", `{"interval":60}`) if err != nil { //抛出异常 Debug(err) return } setCacheAdminConfigData() }
func init() { orm.RegisterDriver("sqlite", orm.DR_Sqlite) // 参数4(可选) 设置最大空闲连接 // 参数5(可选) 设置最大数据库连接 (go >= 1.2) maxIdle := 30 maxConn := 30 orm.RegisterDataBase("default", "sqlite3", "db/ifcdb.db", maxIdle, maxConn) // 需要在init中注册定义的model orm.RegisterModel(new(VItemList), new(OnLineActive)) //设定一个缓存,保存最初始的ItemList,避免每次打开主页就去读取数据库 bm, _ = cache.NewCache("memory", `{"interval":60}`) }
func Cache() (bm cache.Cache, err error) { cachetime, err := beego.AppConfig.Int("cache_time") if err != nil { cachetime = 3600 } settings := fmt.Sprintf(`{"interval":%d}`, cachetime) bm, err = cache.NewCache("memory", settings) if err != nil { return } return bm, nil }
func main() { models.O = orm.NewOrm() models.O.Using("default") // 默认使用 default,你可以指定为其他数据库 var err error models.PageCache, err = cache.NewCache("memory", `{"interval":60}`) if err != nil { println(err.Error()) return } models.CDNInit() beego.ErrorController(&controllers.Error{}) beego.Run() }
func init() { beego.AppConfigPath = "conf/app.conf" beego.SetStaticPath("/js", "public/js") beego.SetStaticPath("/img", "public/img") beego.SetStaticPath("/favicon.ico", "public/img/favicon.ico") beego.SetStaticPath("/css", "public/css") beego.SetStaticPath("/html", "tpl") beego.SetStaticPath("/admin/js", "public/admin/js") beego.SetStaticPath("/admin/img", "public/admin/img") beego.SetStaticPath("/admin/css", "public/admin/css") beego.SetStaticPath("/admin/assets", "public/admin") beego.SetLevel(beego.LevelDebug) beego.SetLogFuncCall(true) beego.BeeLogger.SetLogFuncCallDepth(4) bm, _ = cache.NewCache("memory", `{"interval":60}`) }
func initRedis() { // cc = &cache.Cache{} var err error defer func() { if r := recover(); r != nil { log.Redf("initial redis error caught: %v\n", r) cc = nil } }() cc, err = cache.NewCache("redis", `{"conn":"`+beego.AppConfig.String("redis_host")+`"}`) if err != nil { log.Redln(err) } }
//后台做登录的验证 func (c *baseController) Prepare() { RedisObject, err := cache.NewCache("redis", `{"conn":"45.78.16.95:6039","password":"******"}`) if err != nil { c.StopRun() } pass := RedisObject.Get("xiaowa") var password []byte var p string switch pass.(type) { case []byte: password = pass.([]byte) p = string(password) c.Data["Email"] = p default: c.Data["Email"] = pass } }
func GetInstance() *ServiceFactory { once.Do(func() { if instance == nil { bm, err := cache.NewCache("memory", `{"interval":60}`) if err != nil { beego.Error("cache init fail=>", err) } cacheService := CacheService{ SeftCache: bm, } instance = &ServiceFactory{ CookieService: &CookieService{}, AuthService: &AuthService{}, CacheService: &cacheService, SSHService: &SSHService{}, } } }) return instance }
func (c *SecureContent) Get() { // Check if the user already have a valid token var j goJwt.GOJWT res := c.Ctx.ResponseWriter req := c.Ctx.Request u, err := j.ParseToken(&res, req) if err != nil { log.Print("Invalid token") c.Ctx.Redirect(301, "/") return } // print our state string to the console. Ideally, you should verify // that it's the same string as the one you set in `setState` //fmt.Println("key: ", gothic.) log.Print("User: "******"redis", `{"conn":":6379"}`) c.Data["Email"] = u["Name"] c.Data["Name"] = red.Get("astaxie") c.TplNames = "index.tpl" }
func init() { var err error //db, err = xorm.NewEngine("mysql", "writer:writer2015@tcp(dbwriter.mysql.rds.aliyuncs.com:3306)/writer?charset=utf8") db, err = xorm.NewEngine("sqlite3", beego.AppConfig.String("Sqlite3DB")) if err != nil { beego.Trace(err) } db.SetMapper(core.SameMapper{}) //db.ShowInfo = true //db.ShowDebug = true db.ShowSQL = true //db.ShowErr = true //db.ShowWarn = true // 缓存 bm, err = cache.NewCache("memory", `{"interval":60}`) if err != nil { beego.Trace(err) } }
func InitRedis() { cacheConfig := beego.AppConfig.String("cache") log.Greenf("cacheConfig:%v \n", cacheConfig) var cc cache.Cache if "redis" == cacheConfig { var err error defer utils.Recover("redis init falure") cc, err = cache.NewCache("redis", `{"conn":"`+beego.AppConfig.String("redis_host")+`"}`) if err != nil { log.Redf("%v", err) } cache, ok := cc.(*caches.MyRedisCache) if ok { redis = cache } else { log.Redf("parse cache to MyRedisCache failure !") } } }
func InitEnv() { var err error // log logLevel := Cfg.String("log_level") log.SetLevelWithDefault(logLevel, "info") // cache Cache, err = cache.NewCache("memory", `{"interval":60}`) if err != nil { log.Fetal("cache init fail :(") os.Exit(1) } blogCacheExpire, _ = Cfg.Int64("blog_cache_expire") catalogCacheExpire, _ = Cfg.Int64("catalog_cache_expire") // database dbUser := Cfg.String("db_user") dbPass := Cfg.String("db_pass") dbHost := Cfg.String("db_host") dbPort := Cfg.String("db_port") dbName := Cfg.String("db_name") maxIdleConn, _ := Cfg.Int("db_max_idle_conn") maxOpenConn, _ := Cfg.Int("db_max_open_conn") dbLink := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8", dbUser, dbPass, dbHost, dbPort, dbName) + "&loc=Asia%2FChongqing" orm.RegisterDriver("mysql", orm.DR_MySQL) orm.RegisterDataBase("default", "mysql", dbLink, maxIdleConn, maxOpenConn) RunMode = Cfg.String("runmode") if RunMode == "dev" { orm.Debug = true } initCfg() }