modify import path (#1805)

[bytom/bytom.git] / asset / image.go

diff --git a/asset/image.go b/asset/image.go
index 323f873..3b7627d 100644 (file)
--- a/asset/image.go
+++ b/asset/image.go
@@ -2,51 +2,46 @@ package asset
 
 import (
        "encoding/json"
+
+       log "github.com/sirupsen/logrus"
+
+       "github.com/bytom/bytom/common"
 )
 
-type AssetImage struct {
-       Assets     []*Asset
-       AssetIndex uint64
+// Image is the struct for hold export asset data
+type Image struct {
+       Assets []*Asset `json:"assets"`
 }
 
-func (reg *Registry) Backup() (*AssetImage, error) {
-       assetIndex, err := reg.getNextAssetIndex()
-       if err != nil {
-               return nil, err
+// Backup export all the asset info into image
+func (reg *Registry) Backup() (*Image, error) {
+       assetImage := &Image{
+               Assets: []*Asset{},
        }
 
-       assets := []*Asset{}
        assetIter := reg.db.IteratorPrefix([]byte(assetPrefix))
        defer assetIter.Release()
-
        for assetIter.Next() {
                asset := &Asset{}
                if err := json.Unmarshal(assetIter.Value(), asset); err != nil {
                        return nil, err
                }
-               assets = append(assets, asset)
+               assetImage.Assets = append(assetImage.Assets, asset)
        }
 
-       assetImage := &AssetImage{
-               AssetIndex: assetIndex,
-               Assets:     assets,
-       }
        return assetImage, nil
 }
 
-func (reg *Registry) Restore(image *AssetImage) error {
-       localIndex, err := reg.getNextAssetIndex()
-       if err != nil {
-               return err
-       }
-
-       if localIndex > image.AssetIndex {
-               image.AssetIndex = localIndex
-       }
-
+// Restore load the image data into asset manage
+func (reg *Registry) Restore(image *Image) error {
+       maxAssetIndex := uint64(0)
        storeBatch := reg.db.NewBatch()
        for _, asset := range image.Assets {
-               if existed := reg.db.Get(AliasKey(*asset.Alias)); existed != nil {
+               if existed := reg.db.Get(Key(&asset.AssetID)); existed != nil {
+                       log.WithFields(log.Fields{"alias": asset.Alias, "id": asset.AssetID}).Warning("skip restore asset due to already existed")
+                       continue
+               }
+               if existed := reg.db.Get(aliasKey(*asset.Alias)); existed != nil {
                        return ErrDuplicateAlias
                }
 
@@ -55,10 +50,16 @@ func (reg *Registry) Restore(image *AssetImage) error {
                        return err
                }
 
-               storeBatch.Set(AliasKey(*asset.Alias), []byte(asset.AssetID.String()))
+               if asset.Signer.KeyIndex > maxAssetIndex {
+                       maxAssetIndex = asset.Signer.KeyIndex
+               }
+               storeBatch.Set(aliasKey(*asset.Alias), []byte(asset.AssetID.String()))
                storeBatch.Set(Key(&asset.AssetID), rawAsset)
        }
+
+       if localIndex := reg.getNextAssetIndex(); localIndex < maxAssetIndex {
+               storeBatch.Set(assetIndexKey, common.Unit64ToBytes(maxAssetIndex))
+       }
        storeBatch.Write()
-       reg.saveNextAssetIndex(image.AssetIndex)
        return nil
 }