fix(rpc/subscription): subscribe runtime version notify when version changes

dot/core/service.go

@@ -408,6 +408,26 @@ func (s *Service) handleChainReorg(prev, curr common.Hash) error {
 	return nil
 }
 
+//func (s *Service) notifyRuntimeUpdated(version runtime.Version) {
+//	s.runtimeUpdateSubscriptionsLock.RLock()
+//	defer s.runtimeUpdateSubscriptionsLock.RUnlock()
+//
+//	if len(s.runtimeUpdateSubscriptions) == 0 {
+//		return
+//	}
+//
+//	logger.Debug("notifying runtime updated chans...", "chans", s.runtimeUpdateSubscriptions)
+//	var wg sync.WaitGroup
+//	wg.Add(len(s.runtimeUpdateSubscriptions))
+//	for _, ch := range s.runtimeUpdateSubscriptions {
+//		go func(ch chan<- runtime.Version) {
+//			defer wg.Done()
+//			ch <- version
+//		}(ch)
+//	}
+//	wg.Wait()
+//}
+
 // maintainTransactionPool removes any transactions that were included in the new block, revalidates the transactions in the pool,
 // and moves them to the queue if valid.
 // See https://github.com/paritytech/substrate/blob/74804b5649eccfb83c90aec87bdca58e5d5c8789/client/transaction-pool/src/lib.rs#L545

dot/core/service_test.go

@@ -24,6 +24,7 @@ import (
 	"testing"
 	"time"
 
+	coremocks "github.com/ChainSafe/gossamer/dot/core/mocks"
 	"github.com/ChainSafe/gossamer/dot/network"
 	"github.com/ChainSafe/gossamer/dot/state"
 	"github.com/ChainSafe/gossamer/dot/sync"
@@ -37,8 +38,6 @@ import (
 	"github.com/ChainSafe/gossamer/lib/utils"
 	log "github.com/ChainSafe/log15"
 	"github.com/stretchr/testify/require"
-
-	coremocks "github.com/ChainSafe/gossamer/dot/core/mocks"
 )
 
 func addTestBlocksToState(t *testing.T, depth int, blockState BlockState) {

dot/rpc/modules/api.go

@@ -38,6 +38,8 @@ type BlockAPI interface {
 	RegisterFinalizedChannel(ch chan<- *types.FinalisationInfo) (byte, error)
 	UnregisterFinalisedChannel(id byte)
 	SubChain(start, end common.Hash) ([]common.Hash, error)
+	RegisterRuntimeUpdatedChannel(ch chan<- runtime.Version) (uint32, error)
+	UnregisterRuntimeUpdatedChannel(id uint32) bool
 }
 
 // NetworkAPI interface for network state methods

dot/rpc/modules/api_mocks.go

@@ -3,6 +3,7 @@ package modules
 import (
 	modulesmocks "github.com/ChainSafe/gossamer/dot/rpc/modules/mocks"
 	"github.com/ChainSafe/gossamer/lib/common"
+	runtimemocks "github.com/ChainSafe/gossamer/lib/runtime/mocks"
 	"github.com/stretchr/testify/mock"
 )
 
@@ -34,6 +35,8 @@ func NewMockBlockAPI() *modulesmocks.MockBlockAPI {
 	m.On("GetJustification", mock.AnythingOfType("common.Hash")).Return(make([]byte, 10), nil)
 	m.On("HasJustification", mock.AnythingOfType("common.Hash")).Return(true, nil)
 	m.On("SubChain", mock.AnythingOfType("common.Hash"), mock.AnythingOfType("common.Hash")).Return(make([]common.Hash, 0), nil)
+	m.On("RegisterRuntimeUpdatedChannel", mock.AnythingOfType("chan<- runtime.Version")).Return(uint32(0), nil)
+
 	return m
 }
 
@@ -42,9 +45,22 @@ func NewMockCoreAPI() *modulesmocks.MockCoreAPI {
 	m := new(modulesmocks.MockCoreAPI)
 	m.On("InsertKey", mock.AnythingOfType("crypto.Keypair"))
 	m.On("HasKey", mock.AnythingOfType("string"), mock.AnythingOfType("string")).Return(false, nil)
-	m.On("GetRuntimeVersion", mock.AnythingOfType("*common.Hash")).Return(nil, nil)
+	m.On("GetRuntimeVersion", mock.AnythingOfType("*common.Hash")).Return(NewMockVersion(), nil)
 	m.On("IsBlockProducer").Return(false)
 	m.On("HandleSubmittedExtrinsic", mock.AnythingOfType("types.Extrinsic")).Return(nil)
 	m.On("GetMetadata", mock.AnythingOfType("*common.Hash")).Return(nil, nil)
 	return m
 }
+
+// NewMockVersion creates and returns an runtime Version interface mock
+func NewMockVersion() *runtimemocks.MockVersion {
+	m := new(runtimemocks.MockVersion)
+	m.On("SpecName").Return([]byte(`mock-spec`))
+	m.On("ImplName").Return(nil)
+	m.On("AuthoringVersion").Return(uint32(0))
+	m.On("SpecVersion").Return(uint32(0))
+	m.On("ImplVersion").Return(uint32(0))
+	m.On("TransactionVersion").Return(uint32(0))
+	m.On("APIItems").Return(nil)
+	return m
+}

dot/rpc/modules/api_mocks_test.go

@@ -0,0 +1,43 @@
+// Copyright 2019 ChainSafe Systems (ON) Corp.
+// This file is part of gossamer.
+//
+// The gossamer library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The gossamer library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the gossamer library. If not, see <http://www.gnu.org/licenses/>.
+
+package modules
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewMockStorageAPI(t *testing.T) {
+	m := NewMockStorageAPI()
+	require.NotNil(t, m)
+}
+
+func TestNewMockBlockAPI(t *testing.T) {
+	m := NewMockBlockAPI()
+	require.NotNil(t, m)
+}
+
+func TestNewMockCoreAPI(t *testing.T) {
+	m := NewMockCoreAPI()
+	require.NotNil(t, m)
+}
+
+func TestNewMockVersion(t *testing.T) {
+	m := NewMockVersion()
+	require.NotNil(t, m)
+}

dot/rpc/subscription/listeners.go

@@ -24,6 +24,7 @@ import (
 	"github.com/ChainSafe/gossamer/dot/state"
 	"github.com/ChainSafe/gossamer/dot/types"
 	"github.com/ChainSafe/gossamer/lib/common"
+	"github.com/ChainSafe/gossamer/lib/runtime"
 )
 
 // Listener interface for functions that define Listener related functions
@@ -258,20 +259,26 @@ func (l *ExtrinsicSubmitListener) Stop() { l.cancel() }
 
 // RuntimeVersionListener to handle listening for Runtime Version
 type RuntimeVersionListener struct {
-	wsconn *WSConn
-	subID  uint
+	wsconn        WSConnAPI
+	subID         uint
+	runtimeUpdate chan runtime.Version
+	channelID     uint32
+	coreAPI       modules.CoreAPI
+}
+
+// VersionListener interface defining methods that version listener must implement
+type VersionListener interface {
+	GetChannelID() uint32
 }
 
 // Listen implementation of Listen interface to listen for runtime version changes
 func (l *RuntimeVersionListener) Listen() {
 	// This sends current runtime version once when subscription is created
-	// TODO (ed) add logic to send updates when runtime version changes
-	rtVersion, err := l.wsconn.CoreAPI.GetRuntimeVersion(nil)
+	rtVersion, err := l.coreAPI.GetRuntimeVersion(nil)
 	if err != nil {
 		return
 	}
 	ver := modules.StateRuntimeVersionResponse{}
-
 	ver.SpecName = string(rtVersion.SpecName())
 	ver.ImplName = string(rtVersion.ImplName())
 	ver.AuthoringVersion = rtVersion.AuthoringVersion()
@@ -280,9 +287,31 @@ func (l *RuntimeVersionListener) Listen() {
 	ver.TransactionVersion = rtVersion.TransactionVersion()
 	ver.Apis = modules.ConvertAPIs(rtVersion.APIItems())
 
-	l.wsconn.safeSend(newSubscriptionResponse("state_runtimeVersion", l.subID, ver))
+	go l.wsconn.safeSend(newSubscriptionResponse("state_runtimeVersion", l.subID, ver))
+
+	// listen for runtime updates
+	go func() {
+		for info := range l.runtimeUpdate {
+			ver := modules.StateRuntimeVersionResponse{}
+
+			ver.SpecName = string(info.SpecName())
+			ver.ImplName = string(info.ImplName())
+			ver.AuthoringVersion = info.AuthoringVersion()
+			ver.SpecVersion = info.SpecVersion()
+			ver.ImplVersion = info.ImplVersion()
+			ver.TransactionVersion = info.TransactionVersion()
+			ver.Apis = modules.ConvertAPIs(info.APIItems())
+
+			l.wsconn.safeSend(newSubscriptionResponse("state_runtimeVersion", l.subID, ver))
+		}
+	}()
 }
 
 // Stop to runtimeVersionListener not implemented yet because the listener
-// does not need to be stoped
+// does not need to be stopped
 func (l *RuntimeVersionListener) Stop() {}
+
+// GetChannelID function that returns listener's channel ID
+func (l *RuntimeVersionListener) GetChannelID() uint32 {
+	return l.channelID
+}

dot/rpc/subscription/listeners_test.go

@@ -17,14 +17,18 @@
 package subscription
 
 import (
+	"io/ioutil"
 	"math/big"
+	"path/filepath"
 	"testing"
 	"time"
 
 	"github.com/ChainSafe/gossamer/dot/rpc/modules"
 	"github.com/ChainSafe/gossamer/dot/state"
 	"github.com/ChainSafe/gossamer/dot/types"
 	"github.com/ChainSafe/gossamer/lib/common"
+	"github.com/ChainSafe/gossamer/lib/runtime"
+	"github.com/ChainSafe/gossamer/lib/runtime/wasmer"
 	"github.com/stretchr/testify/require"
 )
 
@@ -159,3 +163,58 @@ func TestExtrinsicSubmitListener_Listen(t *testing.T) {
 	expectedFinalizedRespones := newSubscriptionResponse(AuthorExtrinsicUpdates, esl.subID, resFinalised)
 	require.Equal(t, expectedFinalizedRespones, mockConnection.lastMessage)
 }
+
+func TestRuntimeChannelListener_Listen(t *testing.T) {
+	notifyChan := make(chan runtime.Version)
+	mockConnection := &MockWSConnAPI{}
+	rvl := RuntimeVersionListener{
+		wsconn:        mockConnection,
+		subID:         0,
+		runtimeUpdate: notifyChan,
+		coreAPI:       modules.NewMockCoreAPI(),
+	}
+
+	expectedInitialVersion := modules.StateRuntimeVersionResponse{
+		SpecName: "mock-spec",
+		Apis:     modules.ConvertAPIs(nil),
+	}
+
+	expectedInitialResponse := newSubcriptionBaseResponseJSON()
+	expectedInitialResponse.Method = "state_runtimeVersion"
+	expectedInitialResponse.Params.Result = expectedInitialVersion
+
+	instance := wasmer.NewTestInstance(t, runtime.NODE_RUNTIME)
+	_, err := runtime.GetRuntimeBlob(runtime.POLKADOT_RUNTIME_FP, runtime.POLKADOT_RUNTIME_URL)
+	require.NoError(t, err)
+	fp, err := filepath.Abs(runtime.POLKADOT_RUNTIME_FP)
+	require.NoError(t, err)
+	code, err := ioutil.ReadFile(fp)
+	require.NoError(t, err)
+	version, err := instance.CheckRuntimeVersion(code)
+	require.NoError(t, err)
+
+	expectedUpdatedVersion := modules.StateRuntimeVersionResponse{
+		SpecName:           "polkadot",
+		ImplName:           "parity-polkadot",
+		AuthoringVersion:   0,
+		SpecVersion:        25,
+		ImplVersion:        0,
+		TransactionVersion: 5,
+		Apis:               modules.ConvertAPIs(version.APIItems()),
+	}
+
+	expectedUpdateResponse := newSubcriptionBaseResponseJSON()
+	expectedUpdateResponse.Method = "state_runtimeVersion"
+	expectedUpdateResponse.Params.Result = expectedUpdatedVersion
+
+	go rvl.Listen()
+
+	//check initial response
+	time.Sleep(time.Millisecond * 10)
+	require.Equal(t, expectedInitialResponse, mockConnection.lastMessage)
+
+	// check response after update
+	notifyChan <- version
+	time.Sleep(time.Millisecond * 10)
+	require.Equal(t, expectedUpdateResponse, mockConnection.lastMessage)
+}

dot/rpc/subscription/subscription.go

@@ -45,6 +45,8 @@ func (c *WSConn) getUnsubListener(method string, params interface{}) (unsubListe
 	switch method {
 	case "state_unsubscribeStorage":
 		unsub = c.unsubscribeStorageListener
+	case "state_unsubscribeRuntimeVersion":
+		unsub = c.unsubscribeRuntimeVersionListener
 	default:
 		return nil, nil, errCannotFindUnsubsriber
 	}