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()
}