simulation manager

simapp/app.go

@@ -101,6 +101,9 @@ type SimApp struct {
 
 	// the module manager
 	mm *module.Manager
+
+	// simulation manager
+	sm *module.SimulationManager
 }
 
 // NewSimApp returns a reference to an initialized SimApp.
@@ -199,7 +202,9 @@ func NewSimApp(
 
 	app.mm.RegisterInvariants(&app.crisisKeeper)
 	app.mm.RegisterRoutes(app.Router(), app.QueryRouter())
-	app.mm.RegisterStoreDecoders()
+
+	app.sm = module.NewSimulationManager(app.mm.Modules)
+	app.sm.RegisterStoreDecoders()
 
 	// initialize stores
 	app.MountKVStores(keys)

types/module/module.go

@@ -3,6 +3,7 @@ Package module contains application module patterns and associated "manager" fun
 The module pattern has been broken down by:
  - independent module functionality (AppModuleBasic)
  - inter-dependent module genesis functionality (AppModuleGenesis)
+ - inter-dependent module simulation functionality (AppModuleSimulation)
  - inter-dependent module full functionality (AppModule)
 
 inter-dependent module functionality is module functionality which somehow
@@ -41,6 +42,7 @@ import (
 )
 
 //__________________________________________________________________________________________
+
 // AppModuleBasic is the standard form for basic non-dependant elements of an application module.
 type AppModuleBasic interface {
 	Name() string
@@ -56,9 +58,10 @@ type AppModuleBasic interface {
 	GetQueryCmd(*codec.Codec) *cobra.Command
 }
 
-// collections of AppModuleBasic
+// BasicManager is a collection of AppModuleBasic
 type BasicManager map[string]AppModuleBasic
 
+// NewBasicManager creates a new BasicManager object
 func NewBasicManager(modules ...AppModuleBasic) BasicManager {
 	moduleMap := make(map[string]AppModuleBasic)
 	for _, module := range modules {
@@ -67,14 +70,14 @@ func NewBasicManager(modules ...AppModuleBasic) BasicManager {
 	return moduleMap
 }
 
-// RegisterCodecs registers all module codecs
+// RegisterCodec registers all module codecs
 func (bm BasicManager) RegisterCodec(cdc *codec.Codec) {
 	for _, b := range bm {
 		b.RegisterCodec(cdc)
 	}
 }
 
-// Provided default genesis information for all modules
+// DefaultGenesis provided default genesis information for all modules
 func (bm BasicManager) DefaultGenesis() map[string]json.RawMessage {
 	genesis := make(map[string]json.RawMessage)
 	for _, b := range bm {
@@ -83,7 +86,7 @@ func (bm BasicManager) DefaultGenesis() map[string]json.RawMessage {
 	return genesis
 }
 
-// Provided default genesis information for all modules
+// ValidateGenesis provided default genesis information for all modules
 func (bm BasicManager) ValidateGenesis(genesis map[string]json.RawMessage) error {
 	for _, b := range bm {
 		if err := b.ValidateGenesis(genesis[b.Name()]); err != nil {
@@ -93,14 +96,14 @@ func (bm BasicManager) ValidateGenesis(genesis map[string]json.RawMessage) error
 	return nil
 }
 
-// RegisterRestRoutes registers all module rest routes
+// RegisterRESTRoutes registers all module rest routes
 func (bm BasicManager) RegisterRESTRoutes(ctx context.CLIContext, rtr *mux.Router) {
 	for _, b := range bm {
 		b.RegisterRESTRoutes(ctx, rtr)
 	}
 }
 
-// add all tx commands to the rootTxCmd
+// AddTxCommands adds all tx commands to the rootTxCmd
 func (bm BasicManager) AddTxCommands(rootTxCmd *cobra.Command, cdc *codec.Codec) {
 	for _, b := range bm {
 		if cmd := b.GetTxCmd(cdc); cmd != nil {
@@ -109,7 +112,7 @@ func (bm BasicManager) AddTxCommands(rootTxCmd *cobra.Command, cdc *codec.Codec)
 	}
 }
 
-// add all query commands to the rootQueryCmd
+// AddQueryCommands adds all query commands to the rootQueryCmd
 func (bm BasicManager) AddQueryCommands(rootQueryCmd *cobra.Command, cdc *codec.Codec) {
 	for _, b := range bm {
 		if cmd := b.GetQueryCmd(cdc); cmd != nil {
@@ -119,20 +122,28 @@ func (bm BasicManager) AddQueryCommands(rootQueryCmd *cobra.Command, cdc *codec.
 }
 
 //_________________________________________________________
+
 // AppModuleGenesis is the standard form for an application module genesis functions
 type AppModuleGenesis interface {
 	AppModuleBasic
 	InitGenesis(sdk.Context, json.RawMessage) []abci.ValidatorUpdate
 	ExportGenesis(sdk.Context) json.RawMessage
 }
 
+// AppModuleSimulation defines the standard functions that every module should expose
+// for the SDK blockchain simulator
+type AppModuleSimulation interface {
+	// register a func to decode the each module's defined types from their corresponding store key
+	RegisterStoreDecoder(sdk.StoreDecoderRegistry)
+}
+
 // AppModule is the standard form for an application module
 type AppModule interface {
 	AppModuleGenesis
+	AppModuleSimulation
 
 	// registers
 	RegisterInvariants(sdk.InvariantRegistry)
-	RegisterStoreDecoder(sdk.StoreDecoderRegistry)
 
 	// routes
 	Route() string
@@ -146,7 +157,8 @@ type AppModule interface {
 }
 
 //___________________________
-// app module
+
+// GenesisOnlyAppModule is an AppModule that only has import/export functionality
 type GenesisOnlyAppModule struct {
 	AppModuleGenesis
 }
@@ -158,49 +170,48 @@ func NewGenesisOnlyAppModule(amg AppModuleGenesis) AppModule {
 	}
 }
 
-// register invariants
+// RegisterInvariants register no invariants
 func (GenesisOnlyAppModule) RegisterInvariants(_ sdk.InvariantRegistry) {}
 
 // RegisterStoreDecoder empty store decoder registry
 func (GenesisOnlyAppModule) RegisterStoreDecoder(_ sdk.StoreDecoderRegistry) {}
 
-// module message route ngame
+// Route empty module message route
 func (GenesisOnlyAppModule) Route() string { return "" }
 
-// module handler
+// NewHandler empty module handler
 func (GenesisOnlyAppModule) NewHandler() sdk.Handler { return nil }
 
-// module querier route ngame
+// QuerierRoute empty module querier route
 func (GenesisOnlyAppModule) QuerierRoute() string { return "" }
 
-// module querier
+// NewQuerierHandler empty module querier
 func (gam GenesisOnlyAppModule) NewQuerierHandler() sdk.Querier { return nil }
 
-// module begin-block
+// BeginBlock empty module begin-block
 func (gam GenesisOnlyAppModule) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) {}
 
-// module end-block
+// EndBlock empty module end-block
 func (GenesisOnlyAppModule) EndBlock(_ sdk.Context, _ abci.RequestEndBlock) []abci.ValidatorUpdate {
 	return []abci.ValidatorUpdate{}
 }
 
 //____________________________________________________________________________
-// module manager provides the high level utility for managing and executing
+
+// Manager defines a module manager that provides the high level utility for managing and executing
 // operations for a group of modules
 type Manager struct {
 	Modules            map[string]AppModule
-	StoreDecoders      sdk.StoreDecoderRegistry
 	OrderInitGenesis   []string
 	OrderExportGenesis []string
 	OrderBeginBlockers []string
 	OrderEndBlockers   []string
 }
 
-// NewModuleManager creates a new Manager object
+// NewManager creates a new Manager object
 func NewManager(modules ...AppModule) *Manager {
 
 	moduleMap := make(map[string]AppModule)
-	decoders := make(sdk.StoreDecoderRegistry)
 	var modulesStr []string
 	for _, module := range modules {
 		moduleMap[module.Name()] = module
@@ -209,49 +220,41 @@ func NewManager(modules ...AppModule) *Manager {
 
 	return &Manager{
 		Modules:            moduleMap,
-		StoreDecoders:      decoders,
 		OrderInitGenesis:   modulesStr,
 		OrderExportGenesis: modulesStr,
 		OrderBeginBlockers: modulesStr,
 		OrderEndBlockers:   modulesStr,
 	}
 }
 
-// set the order of init genesis calls
+// SetOrderInitGenesis sets the order of init genesis calls
 func (m *Manager) SetOrderInitGenesis(moduleNames ...string) {
 	m.OrderInitGenesis = moduleNames
 }
 
-// set the order of export genesis calls
+// SetOrderExportGenesis sets the order of export genesis calls
 func (m *Manager) SetOrderExportGenesis(moduleNames ...string) {
 	m.OrderExportGenesis = moduleNames
 }
 
-// set the order of set begin-blocker calls
+// SetOrderBeginBlockers sets the order of set begin-blocker calls
 func (m *Manager) SetOrderBeginBlockers(moduleNames ...string) {
 	m.OrderBeginBlockers = moduleNames
 }
 
-// set the order of set end-blocker calls
+// SetOrderEndBlockers sets the order of set end-blocker calls
 func (m *Manager) SetOrderEndBlockers(moduleNames ...string) {
 	m.OrderEndBlockers = moduleNames
 }
 
-// register all module routes and module querier routes
+// RegisterInvariants registers all module routes and module querier routes
 func (m *Manager) RegisterInvariants(ir sdk.InvariantRegistry) {
 	for _, module := range m.Modules {
 		module.RegisterInvariants(ir)
 	}
 }
 
-// RegisterStoreDecoders registers the each type decoder with the respective key
-func (m *Manager) RegisterStoreDecoders() {
-	for _, module := range m.Modules {
-		module.RegisterStoreDecoder(m.StoreDecoders)
-	}
-}
-
-// register all module routes and module querier routes
+// RegisterRoutes registers all module routes and module querier routes
 func (m *Manager) RegisterRoutes(router sdk.Router, queryRouter sdk.QueryRouter) {
 	for _, module := range m.Modules {
 		if module.Route() != "" {
@@ -263,7 +266,7 @@ func (m *Manager) RegisterRoutes(router sdk.Router, queryRouter sdk.QueryRouter)
 	}
 }
 
-// perform init genesis functionality for modules
+// InitGenesis performs init genesis functionality for modules
 func (m *Manager) InitGenesis(ctx sdk.Context, genesisData map[string]json.RawMessage) abci.ResponseInitChain {
 	var validatorUpdates []abci.ValidatorUpdate
 	for _, moduleName := range m.OrderInitGenesis {
@@ -286,7 +289,7 @@ func (m *Manager) InitGenesis(ctx sdk.Context, genesisData map[string]json.RawMe
 	}
 }
 
-// perform export genesis functionality for modules
+// ExportGenesis performs export genesis functionality for modules
 func (m *Manager) ExportGenesis(ctx sdk.Context) map[string]json.RawMessage {
 	genesisData := make(map[string]json.RawMessage)
 	for _, moduleName := range m.OrderExportGenesis {
@@ -337,4 +340,29 @@ func (m *Manager) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) abci.Respo
 	}
 }
 
-// DONTCOVER
+//____________________________________________________________________________
+
+// SimulationManager defines a simulation manager that provides the high level utility
+// for managing and executing simulation functionalities for a group of modules
+type SimulationManager struct {
+	Modules       map[string]AppModule
+	StoreDecoders sdk.StoreDecoderRegistry
+}
+
+// NewSimulationManager creates a new SimulationManager object
+func NewSimulationManager(moduleMap map[string]AppModule) *SimulationManager {
+
+	decoders := make(sdk.StoreDecoderRegistry)
+
+	return &SimulationManager{
+		Modules:       moduleMap,
+		StoreDecoders: decoders,
+	}
+}
+
+// RegisterStoreDecoders registers each of the modules' store decoders into a map
+func (sm *SimulationManager) RegisterStoreDecoders() {
+	for _, module := range sm.Modules {
+		module.RegisterStoreDecoder(sm.StoreDecoders)
+	}
+}