db.go

package upx

import (
	"encoding/json"
	"io/ioutil"
	"os"
	"path"
	"path/filepath"
	"strings"

	"github.com/syndtr/goleveldb/leveldb"
	"github.com/syndtr/goleveldb/leveldb/util"
	"github.com/upyun/upx/cache"
)

var db *leveldb.DB

type dbKey struct {
	SrcPath string `json:"src_path"`
	DstPath string `json:"dst_path"`
}

type fileMeta struct {
	Name  string `json:"name"`
	IsDir bool   `json:"isdir"`
}

type dbValue struct {
	ModifyTime int64       `json:"modify_time"`
	Md5        string      `json:"md5"`
	IsDir      string      `json:"isdir"`
	Items      []*fileMeta `json:"items"`
}

func makeDBKey(src, dst string) ([]byte, error) {
	return json.Marshal(&dbKey{
		SrcPath: src,
		DstPath: path.Join(session.Bucket, dst),
	})
}

func parseDBKey(key []byte) (*dbKey, error) {
	dbkey := &dbKey{}
	err := json.Unmarshal(
		key,
		dbkey,
	)
	return dbkey, err
}

func makeDBValue(filename string, md5 bool) (*dbValue, error) {
	finfo, err := os.Stat(filename)
	if err != nil {
		return nil, err
	}

	dbV := &dbValue{
		ModifyTime: finfo.ModTime().UnixNano(),
	}

	if !finfo.IsDir() {
		if md5 {
			md5Str, _ := md5File(filename)
			dbV.Md5 = md5Str
		}
		dbV.IsDir = "false"
	} else {
		dbV.IsDir = "true"
	}
	return dbV, nil
}

func getDBValue(src, dst string) (*dbValue, error) {
	key, err := makeDBKey(src, dst)
	if err != nil {
		return nil, err
	}

	raw, err := db.Get(key, nil)
	if err != nil {
		if err == leveldb.ErrNotFound {
			return nil, nil
		}
		return nil, err
	}

	var value dbValue
	if err = json.Unmarshal(raw, &value); err != nil {
		return nil, err
	}
	return &value, nil
}

func setDBValue(src, dst string, v *dbValue) error {
	key, err := makeDBKey(src, dst)
	if err != nil {
		return err
	}

	if v == nil {
		v, err = makeDBValue(src, true)
		if err != nil {
			return err
		}
	}

	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	return db.Put(key, b, nil)
}

func delDBValue(src, dst string) error {
	key, err := makeDBKey(src, dst)
	if err != nil {
		return err
	}

	return db.Delete(key, nil)
}

func delDBValues(srcPrefix, dstPrefix string) {
	dstPrefix = path.Join(session.Bucket, dstPrefix)
	iter := db.NewIterator(
		util.BytesPrefix([]byte("{")),
		nil,
	)
	if ok := iter.First(); !ok {
		return
	}
	for {
		k, err := parseDBKey(iter.Key())
		if err != nil {
			PrintError("decode %s: %v", string(iter.Key()), err)
		}
		if strings.HasPrefix(k.SrcPath, srcPrefix) && strings.HasPrefix(k.DstPath, dstPrefix) {
			PrintOnlyVerbose("found %s => %s to delete", k.SrcPath, k.DstPath)
			db.Delete(iter.Key(), nil)
		}
		if ok := iter.Next(); !ok {
			break
		}
	}
}

func makeFileMetas(dirname string) ([]*fileMeta, error) {
	var res []*fileMeta
	fInfos, err := ioutil.ReadDir(dirname)
	if err != nil {
		return res, err
	}
	for _, fInfo := range fInfos {
		fpath := filepath.Join(dirname, fInfo.Name())
		fi, _ := os.Stat(fpath)
		if fi != nil && fi.IsDir() {
			res = append(res, &fileMeta{fInfo.Name(), true})
		} else {
			res = append(res, &fileMeta{fInfo.Name(), false})
		}
	}
	return res, nil
}

func diffFileMetas(src []*fileMeta, dst []*fileMeta) []*fileMeta {
	i, j := 0, 0
	var res []*fileMeta
	for i < len(src) && j < len(dst) {
		if src[i].Name < dst[j].Name {
			res = append(res, src[i])
			i++
		} else if src[i].Name == dst[j].Name {
			if src[i].IsDir != dst[j].IsDir {
				res = append(res, src[i])
			}
			i++
			j++
		} else {
			j++
		}
	}

	res = append(res, src[i:]...)
	return res
}

func initDB() (err error) {
	db, err = cache.GetClient()
	if err != nil {
		Print("db %v %s", err, cache.GetDBName())
	}
	return err
}