go_dreamfactory/sys/db/db.go

package db

import (
	"errors"
	"fmt"
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/lego/utils/codec/json"
	"io/ioutil"
	"os"
)

func newSys(options *Options) (sys *DB, err error) {
	sys = &DB{
		options: options,
		servers: make(map[string]*DBConn),
	}
	sys.init()
	return
}

type DB struct {
	options *Options
	local   *DBConn
	cross   *DBConn
	servers map[string]*DBConn
}

func (this *DB) init() (err error) {
	if this.local, err = newDBConn(this.options.Log, DBConfig{
		RedisIsCluster:  this.options.RedisIsCluster,
		RedisAddr:       this.options.RedisAddr,
		RedisPassword:   this.options.RedisPassword,
		RedisDB:         this.options.RedisDB,
		MongodbUrl:      this.options.MongodbUrl,
		MongodbDatabase: this.options.MongodbDatabase,
	}); err != nil {
		return
	}
	err = this.readercrossconf(this.options.CrossConfig)
	return
}

//读取游戏配置文件
func (this *DB) readercrossconf(path string) (err error) {
	config := make(comm.CrossConfigs, 0)
	var (
		jsonFile  *os.File
		byteValue []byte
	)
	if jsonFile, err = os.Open(path); err != nil {
		return
	} else {
		defer jsonFile.Close()
		if byteValue, err = ioutil.ReadAll(jsonFile); err != nil {
			return
		}
		if err = json.Unmarshal(byteValue, &config); err != nil {
			return
		}
		if cf, ok := config[this.options.CrossTag]; !ok {
			err = fmt.Errorf("no found Crossconfig:%s", this.options.CrossTag)
			return
		} else {
			if !this.options.IsCross {
				if this.cross, err = newDBConn(this.options.Log, DBConfig{
					RedisIsCluster:  cf.LoaclDB.RedisIsCluster,
					RedisAddr:       cf.LoaclDB.RedisAddr,
					RedisPassword:   cf.LoaclDB.RedisPassword,
					RedisDB:         cf.LoaclDB.RedisDB,
					MongodbUrl:      cf.LoaclDB.MongodbUrl,
					MongodbDatabase: cf.LoaclDB.MongodbDatabase,
				}); err != nil {
					log.Error("comment db err!", log.Fields{"stag": cf.AreaId, "db": cf.LoaclDB, "err": err})
					return
				}
			} else {
				for k, v := range cf.ServiceList {
					if this.servers[k], err = newDBConn(this.options.Log, DBConfig{
						RedisIsCluster:  v.RedisIsCluster,
						RedisAddr:       v.RedisAddr,
						RedisPassword:   v.RedisPassword,
						RedisDB:         v.RedisDB,
						MongodbUrl:      v.MongodbUrl,
						MongodbDatabase: v.MongodbDatabase,
					}); err != nil {
						log.Error("comment db err!", log.Fields{"stag": k, "db": v, "err": err})
						return
					}
				}
			}
		}
	}
	return
}

//同步服务列表
func (this *DB) SyncServiceList() (err error) {
	config := make(comm.CrossConfigs, 0)
	var (
		jsonFile  *os.File
		byteValue []byte
	)
	if jsonFile, err = os.Open(this.options.CrossConfig); err != nil {
		return
	} else {
		defer jsonFile.Close()
		if byteValue, err = ioutil.ReadAll(jsonFile); err != nil {
			return
		}
		if err = json.Unmarshal(byteValue, &config); err != nil {
			return
		}
		if cf, ok := config[this.options.CrossTag]; !ok {
			err = fmt.Errorf("no found Crossconfig:%s", this.options.CrossTag)
			return
		} else {
			if this.options.IsCross {
				for k, v := range cf.ServiceList {
					if _, ok := this.servers[k]; !ok {
						if this.servers[k], err = newDBConn(this.options.Log, DBConfig{
							RedisIsCluster:  v.RedisIsCluster,
							RedisAddr:       v.RedisAddr,
							RedisPassword:   v.RedisPassword,
							RedisDB:         v.RedisDB,
							MongodbUrl:      v.MongodbUrl,
							MongodbDatabase: v.MongodbDatabase,
						}); err != nil {
							log.Error("comment db err!", log.Fields{"stag": k, "db": v, "err": err})
							return
						}
					}

				}
			} else {
				err = errors.New("curr service is not cross!")
				return
			}
		}
	}
	return
}

func (this *DB) Local() (conn *DBConn, err error) {
	conn = this.local
	if conn == nil {
		err = errors.New("LocalDBConn on init")
	}
	return
}
func (this *DB) IsCross() bool {
	return this.options.IsCross
}
func (this *DB) CrossTag() string {
	return this.options.CrossTag
}

func (this *DB) Cross() (conn *DBConn, err error) {
	conn = this.cross
	if conn == nil {
		err = errors.New("CrossDBConn on init")
	}
	return
}

func (this *DB) ServerDBConn(stage string) (conn *DBConn, err error) {
	ok := false
	conn, ok = this.servers[stage]
	if !ok {
		err = fmt.Errorf("DBConn:%s on init", stage)
	}
	return
}

func (this *DB) GetServerTags() []string {
	keys := make([]string, 0)
	for k, _ := range this.servers {
		keys = append(keys, k)
	}
	return keys
}