fabric refactor

platform/fabric/channel.go

@@ -27,35 +27,35 @@ func (c *Channel) Name() string {
 }
 
 func (c *Channel) Vault() *Vault {
-	return &Vault{ch: c.ch}
+	return &Vault{txidStore: c.ch.TXIDStore(), vault: c.ch.Vault(), ch: c.ch}
 }
 
 func (c *Channel) Ledger() *Ledger {
-	return &Ledger{ch: c}
+	return &Ledger{l: c.ch.Ledger()}
 }
 
 func (c *Channel) MSPManager() *MSPManager {
-	return &MSPManager{ch: c.ch}
+	return &MSPManager{ch: c.ch.ChannelMembership()}
 }
 
 func (c *Channel) Committer() *Committer {
 	return c.committer
 }
 
 func (c *Channel) Finality() *Finality {
-	return &Finality{ch: c.ch}
+	return &Finality{finality: c.ch.Finality()}
 }
 
 func (c *Channel) Chaincode(name string) *Chaincode {
 	return &Chaincode{
 		fns:           c.fns,
-		chaincode:     c.ch.Chaincode(name),
+		chaincode:     c.ch.ChaincodeManager().Chaincode(name),
 		EventListener: newEventListener(c.sp, name),
 	}
 }
 
 func (c *Channel) Delivery() *Delivery {
-	return &Delivery{ch: c}
+	return &Delivery{delivery: c.ch.Delivery()}
 }
 
 func (c *Channel) MetadataService() *MetadataService {

platform/fabric/committer.go

@@ -18,38 +18,38 @@ type TxStatusChangeListener interface {
 }
 
 type Committer struct {
-	ch          driver.Channel
+	committer   driver.Committer
 	subscribers *events.Subscribers
 }
 
 func NewCommitter(ch driver.Channel) *Committer {
-	return &Committer{ch: ch, subscribers: events.NewSubscribers()}
+	return &Committer{committer: ch.Committer(), subscribers: events.NewSubscribers()}
 }
 
 // ProcessNamespace registers namespaces that will be committed even if the rwset is not known
 func (c *Committer) ProcessNamespace(nss ...string) error {
-	return c.ch.ProcessNamespace(nss...)
+	return c.committer.ProcessNamespace(nss...)
 }
 
 // Status returns a validation code this committer bind to the passed transaction id, plus
 // a list of dependant transaction ids if they exist.
-func (c *Committer) Status(txID string) (ValidationCode, string, []string, error) {
-	vc, message, deps, err := c.ch.Status(txID)
-	return ValidationCode(vc), message, deps, err
+func (c *Committer) Status(txID string) (ValidationCode, string, error) {
+	vc, message, err := c.committer.Status(txID)
+	return ValidationCode(vc), message, err
 }
 
 func (c *Committer) AddStatusReporter(sr driver.StatusReporter) error {
-	return c.ch.AddStatusReporter(sr)
+	return c.committer.AddStatusReporter(sr)
 }
 
 // SubscribeTxStatusChanges registers a listener for transaction status changes for the passed transaction id.
 // If the transaction id is empty, the listener will be called for all transactions.
 func (c *Committer) SubscribeTxStatusChanges(txID string, listener TxStatusChangeListener) error {
-	return c.ch.SubscribeTxStatusChanges(txID, listener)
+	return c.committer.SubscribeTxStatusChanges(txID, listener)
 }
 
 // UnsubscribeTxStatusChanges unregisters a listener for transaction status changes for the passed transaction id.
 // If the transaction id is empty, the listener will be called for all transactions.
 func (c *Committer) UnsubscribeTxStatusChanges(txID string, listener TxStatusChangeListener) error {
-	return c.ch.UnsubscribeTxStatusChanges(txID, listener)
+	return c.committer.UnsubscribeTxStatusChanges(txID, listener)
 }

platform/fabric/config.go

@@ -15,3 +15,7 @@ type ConfigService struct {
 func (s *ConfigService) GetString(key string) string {
 	return s.confService.GetString(key)
 }
+
+func (s *ConfigService) DefaultChannel() string {
+	return s.confService.DefaultChannel()
+}

platform/fabric/core/generic/chaincode.go

@@ -7,12 +7,74 @@ SPDX-License-Identifier: Apache-2.0
 package generic
 
 import (
+	"context"
+	"sync"
+	"time"
+
 	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric/core/generic/chaincode"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric/driver"
 )
 
+type Broadcaster interface {
+	Broadcast(context context.Context, blob interface{}) error
+}
+
+type MSPProvider interface {
+	MSPManager() driver.MSPManager
+}
+
+type ChaincodeManager struct {
+	NetworkID       string
+	ChannelID       string
+	ConfigService   driver.ConfigService
+	ChannelConfig   driver.ChannelConfig
+	NumRetries      uint
+	RetrySleep      time.Duration
+	LocalMembership driver.LocalMembership
+	PeerManager     chaincode.PeerManager
+	SignerService   driver.SignerService
+	Broadcaster     Broadcaster
+	Finality        driver.Finality
+	MSPProvider     MSPProvider
+
+	// chaincodes
+	ChaincodesLock sync.RWMutex
+	Chaincodes     map[string]driver.Chaincode
+}
+
+func NewChaincodeManager(
+	networkID string,
+	channelID string,
+	configService driver.ConfigService,
+	channelConfig driver.ChannelConfig,
+	numRetries uint,
+	retrySleep time.Duration,
+	localMembership driver.LocalMembership,
+	peerManager chaincode.PeerManager,
+	signerService driver.SignerService,
+	broadcaster Broadcaster,
+	finality driver.Finality,
+	MSPProvider MSPProvider,
+) *ChaincodeManager {
+	return &ChaincodeManager{
+		NetworkID:       networkID,
+		ChannelID:       channelID,
+		ConfigService:   configService,
+		ChannelConfig:   channelConfig,
+		NumRetries:      numRetries,
+		RetrySleep:      retrySleep,
+		LocalMembership: localMembership,
+		PeerManager:     peerManager,
+		SignerService:   signerService,
+		Broadcaster:     broadcaster,
+		Finality:        finality,
+		MSPProvider:     MSPProvider,
+		Chaincodes:      map[string]driver.Chaincode{},
+	}
+}
+
 // Chaincode returns a chaincode handler for the passed chaincode name
-func (c *Channel) Chaincode(name string) driver.Chaincode {
+func (c *ChaincodeManager) Chaincode(name string) driver.Chaincode {
 	c.ChaincodesLock.RLock()
 	ch, ok := c.Chaincodes[name]
 	if ok {
@@ -27,7 +89,17 @@ func (c *Channel) Chaincode(name string) driver.Chaincode {
 	if ok {
 		return ch
 	}
-	ch = chaincode.NewChaincode(name, c.Network, c)
+	ch = chaincode.NewChaincode(
+		name,
+		c.ConfigService,
+		c.ChannelConfig,
+		c.LocalMembership,
+		c.PeerManager,
+		c.SignerService,
+		c.Broadcaster,
+		c.Finality,
+		c.MSPProvider,
+	)
 	c.Chaincodes[name] = ch
 	return ch
 }

platform/fabric/core/generic/chaincode/chaincode.go

@@ -7,31 +7,81 @@ SPDX-License-Identifier: Apache-2.0
 package chaincode
 
 import (
+	"context"
 	"sync"
 	"time"
 
 	"github.com/ReneKroon/ttlcache/v2"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric/core/generic/peer"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric/driver"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/flogging"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/grpc"
 )
 
+var logger = flogging.MustGetLogger("fabric-sdk.core.generic.chaincode")
+
+type PeerManager interface {
+	NewPeerClientForAddress(cc grpc.ConnectionConfig) (peer.Client, error)
+}
+
+type Broadcaster interface {
+	Broadcast(context context.Context, blob interface{}) error
+}
+
+type SerializableSigner interface {
+	Sign(message []byte) ([]byte, error)
+
+	Serialize() ([]byte, error)
+}
+
+type MSPProvider interface {
+	MSPManager() driver.MSPManager
+}
+
 type Chaincode struct {
-	name       string
-	Network    Network
-	channel    Channel
-	NumRetries uint
-	RetrySleep time.Duration
+	name            string
+	NetworkID       string
+	ChannelID       string
+	ConfigService   driver.ConfigService
+	ChannelConfig   driver.ChannelConfig
+	NumRetries      uint
+	RetrySleep      time.Duration
+	LocalMembership driver.LocalMembership
+	PeerManager     PeerManager
+	SignerService   driver.SignerService
+	Broadcaster     Broadcaster
+	Finality        driver.Finality
+	MSPProvider     MSPProvider
 
 	discoveryResultsCacheLock sync.RWMutex
 	discoveryResultsCache     ttlcache.SimpleCache
 }
 
-func NewChaincode(name string, network Network, channel Channel) *Chaincode {
+func NewChaincode(
+	name string,
+	networkConfig driver.ConfigService,
+	channelConfig driver.ChannelConfig,
+	localMembership driver.LocalMembership,
+	peerManager PeerManager,
+	signerService driver.SignerService,
+	broadcaster Broadcaster,
+	finality driver.Finality,
+	MSPProvider MSPProvider,
+) *Chaincode {
 	return &Chaincode{
 		name:                      name,
-		Network:                   network,
-		channel:                   channel,
-		NumRetries:                channel.Config().NumRetries,
-		RetrySleep:                channel.Config().RetrySleep,
+		NetworkID:                 networkConfig.NetworkName(),
+		ChannelID:                 channelConfig.ID(),
+		ConfigService:             networkConfig,
+		ChannelConfig:             channelConfig,
+		NumRetries:                channelConfig.GetNumRetries(),
+		RetrySleep:                channelConfig.GetRetrySleep(),
+		LocalMembership:           localMembership,
+		PeerManager:               peerManager,
+		SignerService:             signerService,
+		Broadcaster:               broadcaster,
+		Finality:                  finality,
+		MSPProvider:               MSPProvider,
 		discoveryResultsCacheLock: sync.RWMutex{},
 		discoveryResultsCache:     ttlcache.NewCache(),
 	}
@@ -54,18 +104,13 @@ func (c *Chaincode) IsAvailable() (bool, error) {
 }
 
 func (c *Chaincode) IsPrivate() bool {
-	channels, err := c.Network.Config().Channels()
-	if err != nil {
-		logger.Error("failed getting channels' configurations [%s]", err)
+	channel := c.ConfigService.Channel(c.ChannelID)
+	if channel == nil {
 		return false
 	}
-	for _, channel := range channels {
-		if channel.Name == c.channel.Name() {
-			for _, chaincode := range channel.Chaincodes {
-				if chaincode.Name == c.name {
-					return chaincode.Private
-				}
-			}
+	for _, chaincode := range channel.ChaincodeConfigs() {
+		if chaincode.ID() == c.name {
+			return chaincode.IsPrivate()
 		}
 	}
 	// Nothing was found