Performance improvement: Use lazy provider for network provider

Signed-off-by: Alexandros Filios <alexandros.filios@ibm.com>

Author: alexandrosfilios

token/services/network/network.go

@@ -11,9 +11,9 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
-	"sync"
 	"time"
 
+	"github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/lazy"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/view"
 	"github.com/hyperledger-labs/fabric-token-sdk/token"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/logging"
@@ -394,49 +394,60 @@ func (n *Network) Connect(ns string) ([]token.ServiceOption, error) {
 
 // Provider returns an instance of network provider
 type Provider struct {
-	lock     sync.Mutex
-	networks map[string]*Network
-	drivers  []driver.Driver
+	networks        lazy.Provider[netId, *Network]
+	networkProvider *networkProvider
+}
+
+type netId struct {
+	network, channel string
+}
+
+func key(id netId) string {
+	return id.network + id.channel
 }
 
 // NewProvider returns a new instance of network provider
 func NewProvider() *Provider {
-	ms := &Provider{
-		networks: map[string]*Network{},
-		drivers:  make([]driver.Driver, 0),
+	ms := &networkProvider{drivers: make([]driver.Driver, 0)}
+
+	return &Provider{
+		networkProvider: ms,
+		networks:        lazy.NewProviderWithKeyMapper(key, ms.newNetwork),
 	}
-	return ms
 }
 
 func (np *Provider) RegisterDriver(driver driver.Driver) {
-	np.drivers = append(np.drivers, driver)
+	np.networkProvider.registerDriver(driver)
 }
 
 // GetNetwork returns a network instance for the given network and channel
 func (np *Provider) GetNetwork(network string, channel string) (*Network, error) {
-	np.lock.Lock()
-	defer np.lock.Unlock()
-
 	logger.Debugf("GetNetwork: [%s:%s]", network, channel)
+	return np.networks.Get(netId{network: network, channel: channel})
+}
 
-	key := network + channel
-	service, ok := np.networks[key]
-	if !ok {
-		var err error
-		service, err = np.newNetwork(network, channel)
-		if err != nil {
-			logger.Errorf("failed to get network: [%s:%s] %s", network, channel, err)
-			return nil, err
-		}
-		np.networks[key] = service
+func (np *Provider) Normalize(opt *token.ServiceOptions) (*token.ServiceOptions, error) {
+	if opt == nil {
+		return nil, errors.New("no service options provided")
 	}
+	n, err := np.GetNetwork(opt.Network, opt.Channel)
+	if err != nil {
+		return nil, errors.WithMessagef(err, "failed to get network [%s:%s]", opt.Network, opt.Channel)
+	}
+	return n.Normalize(opt)
+}
 
-	logger.Debugf("GetNetwork: [%s:%s], returning...", network, channel)
+// networkProvider instantiates new networks based on the registered drivers
+type networkProvider struct {
+	drivers []driver.Driver
+}
 
-	return service, nil
+func (np *networkProvider) registerDriver(driver driver.Driver) {
+	np.drivers = append(np.drivers, driver)
 }
 
-func (np *Provider) newNetwork(network string, channel string) (*Network, error) {
+func (np *networkProvider) newNetwork(netId netId) (*Network, error) {
+	network, channel := netId.network, netId.channel
 	var errs []error
 	for _, d := range np.drivers {
 		nw, err := d.New(network, channel)
@@ -450,17 +461,6 @@ func (np *Provider) newNetwork(network string, channel string) (*Network, error)
 	return nil, errors.Errorf("no network driver found for [%s:%s], errs [%v]", network, channel, errs)
 }
 
-func (np *Provider) Normalize(opt *token.ServiceOptions) (*token.ServiceOptions, error) {
-	if opt == nil {
-		return nil, errors.New("no service options provided")
-	}
-	n, err := np.GetNetwork(opt.Network, opt.Channel)
-	if err != nil {
-		return nil, errors.WithMessagef(err, "failed to get network [%s:%s]", opt.Network, opt.Channel)
-	}
-	return n.Normalize(opt)
-}
-
 // GetInstance returns a network instance for the given network and channel
 func GetInstance(sp token.ServiceProvider, network, channel string) *Network {
 	n, err := GetProvider(sp).GetNetwork(network, channel)