Regen network/multistore upgrades

baseapp/baseapp.go

@@ -1,11 +1,8 @@
 package baseapp
 
 import (
-	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
-	"os"
 	"reflect"
 	"runtime/debug"
 	"strings"
@@ -17,7 +14,6 @@ import (
 	dbm "github.com/tendermint/tm-db"
 
 	"github.com/cosmos/cosmos-sdk/store"
-	storetypes "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
@@ -226,62 +222,6 @@ func DefaultStoreLoader(ms sdk.CommitMultiStore) error {
 	return ms.LoadLatestVersion()
 }
 
-// StoreLoaderWithUpgrade is used to prepare baseapp with a fixed StoreLoader
-// pattern. This is useful in test cases, or with custom upgrade loading logic.
-func StoreLoaderWithUpgrade(upgrades *storetypes.StoreUpgrades) StoreLoader {
-	return func(ms sdk.CommitMultiStore) error {
-		return ms.LoadLatestVersionAndUpgrade(upgrades)
-	}
-}
-
-// UpgradeableStoreLoader can be configured by SetStoreLoader() to check for the
-// existence of a given upgrade file - json encoded StoreUpgrades data.
-//
-// If not file is present, it will peform the default load (no upgrades to store).
-//
-// If the file is present, it will parse the file and execute those upgrades
-// (rename or delete stores), while loading the data. It will also delete the
-// upgrade file upon successful load, so that the upgrade is only applied once,
-// and not re-applied on next restart
-//
-// This is useful for in place migrations when a store key is renamed between
-// two versions of the software. (TODO: this code will move to x/upgrades
-// when PR #4233 is merged, here mainly to help test the design)
-func UpgradeableStoreLoader(upgradeInfoPath string) StoreLoader {
-	return func(ms sdk.CommitMultiStore) error {
-		_, err := os.Stat(upgradeInfoPath)
-		if os.IsNotExist(err) {
-			return DefaultStoreLoader(ms)
-		} else if err != nil {
-			return err
-		}
-
-		// there is a migration file, let's execute
-		data, err := ioutil.ReadFile(upgradeInfoPath)
-		if err != nil {
-			return fmt.Errorf("cannot read upgrade file %s: %v", upgradeInfoPath, err)
-		}
-
-		var upgrades storetypes.StoreUpgrades
-		err = json.Unmarshal(data, &upgrades)
-		if err != nil {
-			return fmt.Errorf("cannot parse upgrade file: %v", err)
-		}
-
-		err = ms.LoadLatestVersionAndUpgrade(&upgrades)
-		if err != nil {
-			return fmt.Errorf("load and upgrade database: %v", err)
-		}
-
-		// if we have a successful load, we delete the file
-		err = os.Remove(upgradeInfoPath)
-		if err != nil {
-			return fmt.Errorf("deleting upgrade file %s: %v", upgradeInfoPath, err)
-		}
-		return nil
-	}
-}
-
 // LoadVersion loads the BaseApp application version. It will panic if called
 // more than once on a running baseapp.
 func (app *BaseApp) LoadVersion(version int64, baseKey *sdk.KVStoreKey) error {

baseapp/baseapp_test.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"encoding/binary"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"sync"
 	"testing"
@@ -137,18 +136,6 @@ func useDefaultLoader(app *BaseApp) {
 	app.SetStoreLoader(DefaultStoreLoader)
 }
 
-func useUpgradeLoader(upgrades *store.StoreUpgrades) func(*BaseApp) {
-	return func(app *BaseApp) {
-		app.SetStoreLoader(StoreLoaderWithUpgrade(upgrades))
-	}
-}
-
-func useFileUpgradeLoader(upgradeInfoPath string) func(*BaseApp) {
-	return func(app *BaseApp) {
-		app.SetStoreLoader(UpgradeableStoreLoader(upgradeInfoPath))
-	}
-}
-
 func initStore(t *testing.T, db dbm.DB, storeKey string, k, v []byte) {
 	rs := rootmulti.NewStore(db)
 	rs.SetPruning(store.PruneSyncable)
@@ -184,19 +171,6 @@ func checkStore(t *testing.T, db dbm.DB, ver int64, storeKey string, k, v []byte
 // Test that we can make commits and then reload old versions.
 // Test that LoadLatestVersion actually does.
 func TestSetLoader(t *testing.T) {
-	// write a renamer to a file
-	f, err := ioutil.TempFile("", "upgrade-*.json")
-	require.NoError(t, err)
-	data := []byte(`{"renamed":[{"old_key": "bnk", "new_key": "banker"}]}`)
-	_, err = f.Write(data)
-	require.NoError(t, err)
-	configName := f.Name()
-	require.NoError(t, f.Close())
-
-	// make sure it exists before running everything
-	_, err = os.Stat(configName)
-	require.NoError(t, err)
-
 	cases := map[string]struct {
 		setLoader    func(*BaseApp)
 		origStoreKey string
@@ -211,26 +185,6 @@ func TestSetLoader(t *testing.T) {
 			origStoreKey: "foo",
 			loadStoreKey: "foo",
 		},
-		"rename with inline opts": {
-			setLoader: useUpgradeLoader(&store.StoreUpgrades{
-				Renamed: []store.StoreRename{{
-					OldKey: "foo",
-					NewKey: "bar",
-				}},
-			}),
-			origStoreKey: "foo",
-			loadStoreKey: "bar",
-		},
-		"file loader with missing file": {
-			setLoader:    useFileUpgradeLoader(configName + "randomchars"),
-			origStoreKey: "bnk",
-			loadStoreKey: "bnk",
-		},
-		"file loader with existing file": {
-			setLoader:    useFileUpgradeLoader(configName),
-			origStoreKey: "bnk",
-			loadStoreKey: "banker",
-		},
 	}
 
 	k := []byte("key")
@@ -265,10 +219,6 @@ func TestSetLoader(t *testing.T) {
 			checkStore(t, db, 2, tc.loadStoreKey, []byte("foo"), nil)
 		})
 	}
-
-	// ensure config file was deleted
-	_, err = os.Stat(configName)
-	require.True(t, os.IsNotExist(err))
 }
 
 func TestAppVersionSetterGetter(t *testing.T) {

store/types/store.go

@@ -44,6 +44,12 @@ type StoreUpgrades struct {
 	Deleted []string      `json:"deleted"`
 }
 
+// UpgradeInfo defines height and StoreUpgrades to be used for multistore upgrades
+type UpgradeInfo struct {
+	Height        int64         `json:"height"`
+	StoreUpgrades StoreUpgrades `json:"store_upgrades"`
+}
+
 // StoreRename defines a name change of a sub-store.
 // All data previously under a PrefixStore with OldKey will be copied
 // to a PrefixStore with NewKey, then deleted from OldKey store.

x/upgrade/abci.go

@@ -37,6 +37,12 @@ func BeginBlocker(k Keeper, ctx sdk.Context, _ abci.RequestBeginBlock) {
 			upgradeMsg := fmt.Sprintf("UPGRADE \"%s\" NEEDED at %s: %s", plan.Name, plan.DueAt(), plan.Info)
 			// We don't have an upgrade handler for this upgrade name, meaning this software is out of date so shutdown
 			ctx.Logger().Error(upgradeMsg)
+
+			// Write upgrade height info to filesystem
+			// So multistore upgrades can make use of this height to determine
+			// to continue or skip the multistore upgrades on launching new binary
+			k.DumpUpgradeInfoToFile(ctx.BlockHeight())
+
 			panic(upgradeMsg)
 		}
 		// We have an upgrade handler for this upgrade name, so apply the upgrade

x/upgrade/abci_test.go

@@ -1,7 +1,15 @@
 package upgrade_test
 
 import (
+	"encoding/json"
 	"errors"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	store "github.com/cosmos/cosmos-sdk/store/types"
+	"github.com/cosmos/cosmos-sdk/tests"
+	"github.com/spf13/viper"
+	"io/ioutil"
+	"os"
+	"path/filepath"
 	"testing"
 	"time"
 
@@ -393,3 +401,44 @@ func TestUpgradeWithoutSkip(t *testing.T) {
 	VerifyDoUpgrade(t)
 	VerifyDone(t, s.ctx, "test")
 }
+
+func TestDumpUpgradeInfoToFile(t *testing.T) {
+	s := setupTest(10, map[int64]bool{})
+	newCtx := s.ctx.WithBlockHeight(s.ctx.BlockHeight() + 1).WithBlockTime(time.Now())
+
+	// set a temporary home dir
+	homeDir, cleanUp := tests.NewTestCaseDir(t)
+	defer cleanUp()
+	// TODO cleanup viper
+	viper.Set(flags.FlagHome, homeDir)
+
+	req := abci.RequestBeginBlock{Header: newCtx.BlockHeader()}
+	planHeight := s.ctx.BlockHeight() + 1
+	err := s.handler(s.ctx, upgrade.SoftwareUpgradeProposal{Title: "prop", Plan: upgrade.Plan{Name: "test", Height: planHeight}})
+	require.Nil(t, err)
+
+	t.Log("verify if binary panics when there exists a upgrade plan")
+	require.Panics(t, func() {
+		s.module.BeginBlock(newCtx, req)
+	})
+
+	// TODO cleanup viper
+	home := viper.GetString(flags.FlagHome)
+	upgradeInfoFilePath := filepath.Join(home, "upgrade-info.json")
+
+	_, err = os.Stat(upgradeInfoFilePath)
+
+	t.Log("verify if upgrade height is written to filesystem when binary panics")
+	require.Nil(t, err)
+
+	var upgradeInfo store.UpgradeInfo
+	info, err := ioutil.ReadFile(upgradeInfoFilePath)
+	require.Nil(t, err)
+
+	err = json.Unmarshal(info, &upgradeInfo)
+	require.Nil(t, err)
+	require.Equal(t, planHeight, upgradeInfo.Height)
+
+	VerifyDoUpgrade(t)
+	VerifyDone(t, s.ctx, "test")
+}

x/upgrade/alias.go

@@ -29,6 +29,8 @@ var (
 	NewQueryAppliedParams            = types.NewQueryAppliedParams
 	NewKeeper                        = keeper.NewKeeper
 	NewQuerier                       = keeper.NewQuerier
+	UpgradeableStoreLoader           = types.UpgradeableStoreLoader
+	StoreLoaderWithUpgrade           = types.StoreLoaderWithUpgrade
 )
 
 type (

x/upgrade/internal/keeper/keeper.go

@@ -2,12 +2,21 @@ package keeper
 
 import (
 	"encoding/binary"
+	"encoding/json"
 	"fmt"
+	"path/filepath"
+
+	"github.com/spf13/viper"
+
+	"io/ioutil"
+	"os"
 
 	"github.com/tendermint/tendermint/libs/log"
 
+	"github.com/cosmos/cosmos-sdk/client/flags"
 	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/store/prefix"
+	store "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	"github.com/cosmos/cosmos-sdk/x/upgrade/internal/types"
@@ -130,3 +139,31 @@ func (k Keeper) ApplyUpgrade(ctx sdk.Context, plan types.Plan) {
 func (k Keeper) IsSkipHeight(height int64) bool {
 	return k.skipUpgradeHeights[height]
 }
+
+// WriteToFile adds plan height to upgrade-info.json
+func (k Keeper) DumpUpgradeInfoToFile(height int64) {
+	// TODO cleanup viper
+	home := viper.GetString(flags.FlagHome)
+	upgradeInfoFilePath := filepath.Join(home, "upgrade-info.json")
+	_, err := os.Stat(upgradeInfoFilePath)
+
+	// If the upgrade-info file is not found, create new
+	if os.IsNotExist(err) {
+		_, err := os.Create(upgradeInfoFilePath)
+
+		if err != nil {
+			panic(fmt.Errorf("error while creating upgrade-info file: %s", err))
+		}
+	}
+
+	var upgradeInfo store.UpgradeInfo
+	upgradeInfo.Height = height
+
+	info, err := json.Marshal(upgradeInfo)
+
+	if err != nil {
+		panic(fmt.Errorf("unable to write upgrade info to filesystem: %s", err.Error()))
+	}
+
+	err = ioutil.WriteFile(upgradeInfoFilePath, info, 0644)
+}