一个有用的golang kv数据库bolt

  利用bolt库存储任意数据结构，代码如下，用到了god库，可以序列化和反序列化任意结构体

  "encoding/gob"

    "github.com/boltdb/bolt"

func Serialize(b CmdMsgIndex) []byte {

    var result bytes.Buffer

    encoder := gob.NewEncoder(&result)

    err := encoder.Encode(b)

    if err != nil {

        log.Panicf("serialize the block to byte failed %v \n", err)

    }

    return result.Bytes()

}

func DeserilizeBlock(blockBytes []byte) *CmdMsgIndex {

    var block CmdMsgIndex

    decoder := gob.NewDecoder(bytes.NewReader(blockBytes))

    err := decoder.Decode(&block)

    if err != nil {

        log.Panicf("deserialize the block to byte failed %v \n", err)

    }

    return &block

}

func init() {

    gob.Register(subtopicstruct{})

    gob.Register(forceexcutestruct{})

    gob.Register(getinfostruct{})

    gob.Register(reportstruct{})

    gob.Register(shutstruct{})

    gob.Register(linkstruct{})

    gob.Register(noticestruct{})

    gob.Register(installsoftwarestruct{})

    gob.Register(downloadfilestruct{})

    gob.Register(snapshotstruct{})

    gob.Register(installsoftwarestruct{})

    gob.Register(forceexcutestruct{})

    gob.Register(reportstruct{})

    gob.Register(myhttp.DeviceResp{})

    gob.Register(StartUpLog{})

    gob.Register(shutstruct{})

}


func WriteCmdMap(cmdindex CmdMsgIndex) error {
	db := bbtdb.Db
	err := db.Update(func(tx *bolt.Tx) error {
		b := tx.Bucket([]byte(bkName))
		if b == nil {
			b, err := tx.CreateBucket([]byte(bkName))
			if err != nil {
				log.Panicf("create the bucket%v [%s] failed! %v\n", b, bkName, err)
			}
		}
		if b != nil {
			//AddGodDataType(cmdindex.Type)
			err := b.Put([]byte(cmdindex.TimeStamp), Serialize(cmdindex))
			if nil != err {
				log.Panicf("put the data of new block into Dbfailed! %v\n", err)
			}
		}

		return nil
	})
	if nil != err {
		log.Panicf("update the Dbof block failed! %v\n", err)
	}
	return err
}
func byteString(p []byte) string {
	for i := 0; i < len(p); i++ {
		if p[i] == 0 {
			return string(p[0:i])
		}
	}
	return string(p)
}

type StartUpLog struct {
	TimeStap string `json:"timestap"`
	Notice   string `json:"notice"`
}

func LoadCmdMap() *BBTMSGIndexDb {
	CmdMap = make(map[string]CmdMsgIndex)
	db, err := bolt.Open(dbName, 0600, nil)
	if err != nil {
		log.Panicf("open the Dbfailed! %v\n", err)
	}
	err = db.Update(func(tx *bolt.Tx) error {
		b := tx.Bucket([]byte(bkName))
		if b == nil {
			b, err = tx.CreateBucket([]byte(bkName))
			if err != nil {
				log.Panicf("create the bucket [%s] failed! %v\n", bkName, err)
			}
		}
		if b != nil {
			var cmdmsgindex CmdMsgIndex
			start := new(StartUpLog)
			start.TimeStap = time.Now().Format("2006-01-02 15:04:05") //获取的时间的格式
			cmdmsgindex.TimeStamp = start.TimeStap
			cmdmsgindex.Cmd = start
			cmdmsgindex.ExcuteStatus = EXCUTED
			cmdmsgindex.Sid = fmt.Sprintf("%d", STARTUP)
			cmdmsgindex.Type = STARTUP
			//data1, err := json.Marshal(cmdmsgindex)
			//data2, err := json.Marshal(cmdmsgindex.Cmd)
			//gob.Register(StartUpLog{})
			err = b.Put([]byte(cmdmsgindex.TimeStamp), Serialize(cmdmsgindex))
			if nil != err {
				log.Panicf("put the data of new block into Dbfailed! %v\n", err)
			}
			if err != nil {
				fmt.Print(err.Error())
			}
		}
		return nil
	})
	/*
		Db.View(func(tx *bolt.Tx) error {
			// Assume bucket exists and has keys
			b := tx.Bucket([]byte(bkName))
			c := b.Cursor()
			CmdMap = make(map[int]CmdMsgIndex)
			for k, v := c.First(); k != nil; k, v = c.Next() {
				key := DeserilizeBlock(k).(int)
				value := DeserilizeBlock(v).(CmdMsgIndex)
				CmdMap[key] = value
			}
			return nil
		})
	*/
	db.View(func(tx *bolt.Tx) error {
		// Assume our events bucket exists and has RFC3339 encoded time keys.
		c := tx.Bucket([]byte(bkName)).Cursor()
		// Our time range spans the 90's decade.
		nowTime := time.Now()
		getTime := nowTime.AddDate(0, -1, 0)             //年，月，日   获取一个月前的时间
		minTime := getTime.Format("2006-01-02 15:04:05") //获取的时间的格式
		maxTime := nowTime.Format("2006-01-02 15:04:05") //获取的时间的格式
		min := []byte(minTime)
		max := []byte(maxTime)

		// Iterate over the 90's.
		for k, v := c.Seek(min); k != nil && bytes.Compare(k, max) <= 0; k, v = c.Next() {
			key := byteString(k)
			value := DeserilizeBlock(v)
			fmt.Println(key, value)
			CmdMap[value.Sid] = *value
		}

		return nil
	})
	return &BBTMSGIndexDb{db}
}
func ViewDb() {
	db := bbtdb.Db
	db.View(func(tx *bolt.Tx) error {
		// Assume our events bucket exists and has RFC3339 encoded time keys.
		c := tx.Bucket([]byte(bkName)).Cursor()
		// Our time range spans the 90's decade.
		nowTime := time.Now()
		getTime := nowTime.AddDate(0, -1, 0)             //年，月，日   获取一个月前的时间
		minTime := getTime.Format("2006-01-02 15:04:05") //获取的时间的格式
		maxTime := nowTime.Format("2006-01-02 15:04:05") //获取的时间的格式
		min := []byte(minTime)
		max := []byte(maxTime)

		// Iterate over the 90's.
		for k, v := c.Seek(min); k != nil && bytes.Compare(k, max) <= 0; k, v = c.Next() {
			key := byteString(k)
			value := DeserilizeBlock(v)
			fmt.Println(key, value)
			CmdMap[value.Sid] = *value
		}

		return nil
	})
}