Test 2

integration/fsc/pingpong/cmd/initiator/main.go

@@ -10,20 +10,18 @@ import (
 	"github.com/hyperledger-labs/fabric-smart-client/integration/fsc/pingpong"
 	"github.com/hyperledger-labs/fabric-smart-client/integration/fsc/pingpong/mock"
 	fscnode "github.com/hyperledger-labs/fabric-smart-client/node"
-	"github.com/hyperledger-labs/fabric-smart-client/platform/view"
 )
 
 func main() {
 	node := fscnode.New()
 	node.Execute(func() error {
-		registry := view.GetRegistry(node)
-		if err := registry.RegisterFactory("init", &pingpong.InitiatorViewFactory{}); err != nil {
+		if err := node.RegisterFactory("init", &pingpong.InitiatorViewFactory{}); err != nil {
 			return err
 		}
-		if err := registry.RegisterFactory("mockInit", &mock.InitiatorViewFactory{}); err != nil {
+		if err := node.RegisterFactory("mockInit", &mock.InitiatorViewFactory{}); err != nil {
 			return err
 		}
-		if err := registry.RegisterFactory("stream", &pingpong.StreamerViewFactory{}); err != nil {
+		if err := node.RegisterFactory("stream", &pingpong.StreamerViewFactory{}); err != nil {
 			return err
 		}
 		return nil

integration/fsc/pingpong/cmd/responder/main.go

@@ -10,18 +10,17 @@ import (
 	"github.com/hyperledger-labs/fabric-smart-client/integration/fsc/pingpong"
 	"github.com/hyperledger-labs/fabric-smart-client/integration/fsc/pingpong/mock"
 	fscnode "github.com/hyperledger-labs/fabric-smart-client/node"
-	"github.com/hyperledger-labs/fabric-smart-client/platform/view"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/view/core/registry"
 )
 
 func main() {
 	node := fscnode.New()
 	node.Execute(func() error {
-		registry := view.GetRegistry(node)
 		initiatorID := registry.GetIdentifier(&pingpong.Initiator{})
-		if err := registry.RegisterResponder(&pingpong.Responder{}, initiatorID); err != nil {
+		if err := node.RegisterResponder(&pingpong.Responder{}, initiatorID); err != nil {
 			return err
 		}
-		if err := registry.RegisterResponder(&pingpong.Responder{}, &mock.Initiator{}); err != nil {
+		if err := node.RegisterResponder(&pingpong.Responder{}, &mock.Initiator{}); err != nil {
 			return err
 		}
 		return nil

integration/fsc/pingpong/pingpong_test.go

@@ -194,7 +194,7 @@ var _ = Describe("EndToEnd", func() {
 func newNode(conf string) api.FabricSmartClientNode {
 	n := node.NewEmpty(conf)
 	Expect(n).NotTo(BeNil())
-	n.AddSDK(viewsdk.NewSDK(n.Registry()))
+	n.AddSDK(viewsdk.NewSDK(n))
 	return n
 }
 

integration/nwo/fsc/node/node_template.go

@@ -17,7 +17,6 @@ package main
 import (
 	fscnode "github.com/hyperledger-labs/fabric-smart-client/node"
 
-	{{ if InstallView }}viewregistry "github.com/hyperledger-labs/fabric-smart-client/platform/view"{{ end }}
 	{{- range .Imports }}
 	{{ Alias . }} "{{ . }}"{{ end }}
 )
@@ -29,13 +28,12 @@ func main() {
 	{{ end }}
 	n.Execute(func() error {
 		{{- if InstallView }}
-		registry := viewregistry.GetRegistry(n)
 		{{- range .Factories }}
-		if err := registry.RegisterFactory("{{ .Id }}", {{ .Type }}); err != nil {
+		if err := n.RegisterFactory("{{ .Id }}", {{ .Type }}); err != nil {
 			return err
 		}{{ end }}
 		{{- range .Responders }}
-		registry.RegisterResponder({{ .Responder }}, {{ .Initiator }}){{ end }}
+		n.RegisterResponder({{ .Responder }}, {{ .Initiator }}){{ end }}
 		{{ end }}
 		return nil
 	})

node/node.go

@@ -28,13 +28,17 @@ type FabricSmartClient interface {
 	Stop()
 	InstallSDK(p api.SDK) error
 	ConfigService() node3.ConfigService
-	Registry() node3.Registry
 	GetService(v interface{}) (interface{}, error)
 	RegisterService(service interface{}) error
 	RegisterFactory(id string, factory api.Factory) error
 	RegisterResponder(responder view.View, initiatedBy interface{}) error
 	RegisterResponderWithIdentity(responder view.View, id view.Identity, initiatedBy view.View) error
-	ResolveIdentities(endpoints ...string) ([]view.Identity, error)
+
+	// RegisterViewManager injects the ViewManager dependency
+	RegisterViewManager(manager node3.ViewManager)
+
+	// RegisterViewRegistry injects the ViewRegistry dependency
+	RegisterViewRegistry(registry node3.ViewRegistry)
 }
 
 type node struct {
@@ -51,7 +55,7 @@ func New() *node {
 
 func NewFromConfPath(confPath string) *node {
 	n := node3.NewEmpty(confPath)
-	n.AddSDK(sdk.NewSDK(n.Registry()))
+	n.AddSDK(sdk.NewSDK(n))
 	return newFromFsc(n)
 }
 

pkg/node/node.go

@@ -17,12 +17,12 @@ import (
 	"github.com/hyperledger-labs/fabric-smart-client/platform/common/services/logging"
 	view2 "github.com/hyperledger-labs/fabric-smart-client/platform/view"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/core/config"
-	tracing2 "github.com/hyperledger-labs/fabric-smart-client/platform/view/sdk/tracing"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/registry"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/tracing"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/view"
 	"github.com/pkg/errors"
 	"go.opentelemetry.io/otel/trace"
+	"go.opentelemetry.io/otel/trace/noop"
 )
 
 const (
@@ -33,6 +33,12 @@ var logger = logging.MustGetLogger("fsc")
 
 type ExecuteCallbackFunc = func() error
 
+type ViewRegistry interface {
+	RegisterFactory(id string, factory view2.Factory) error
+	RegisterResponder(responder view2.View, initiatedBy interface{}) error
+	RegisterResponderWithIdentity(responder view2.View, id view.Identity, initiatedBy interface{}) error
+}
+
 type ViewManager interface {
 	NewView(id string, in []byte) (view.View, error)
 	InitiateView(view view.View, ctx context.Context) (interface{}, error)
@@ -43,8 +49,13 @@ type ViewManager interface {
 }
 
 type Registry interface {
-	GetService(v interface{}) (interface{}, error)
+	serviceRegistry
+	RegisterViewManager(manager ViewManager)
+	RegisterViewRegistry(registry ViewRegistry)
+}
 
+type serviceRegistry interface {
+	GetService(v interface{}) (interface{}, error)
 	RegisterService(service interface{}) error
 }
 
@@ -58,13 +69,15 @@ type PostStart interface {
 }
 
 type node struct {
-	registry      Registry
+	registry      serviceRegistry
 	configService ConfigService
 	sdks          []api.SDK
 	context       context.Context
 	cancel        context.CancelFunc
 	running       bool
 	tracer        trace.Tracer
+	viewManager   ViewManager
+	viewRegistry  ViewRegistry
 }
 
 func NewEmpty(confPath string) *node {
@@ -81,9 +94,26 @@ func NewEmpty(confPath string) *node {
 		sdks:          []api.SDK{},
 		registry:      registry,
 		configService: configService,
+		tracer:        noop.NewTracerProvider().Tracer("noop"),
 	}
 }
 
+func (n *node) RegisterTracerProvider(provider trace.TracerProvider) {
+	logger.Infof("Register tracer provider")
+	n.tracer = provider.Tracer("node_view_client", tracing.WithMetricsOpts(tracing.MetricsOpts{
+		Namespace:  "viewsdk",
+		LabelNames: []tracing.LabelName{fidLabel},
+	}))
+}
+
+func (n *node) RegisterViewManager(manager ViewManager) {
+	n.viewManager = manager
+}
+
+func (n *node) RegisterViewRegistry(registry ViewRegistry) {
+	n.viewRegistry = registry
+}
+
 func (n *node) AddSDK(sdk api.SDK) {
 	n.sdks = append(n.sdks, sdk)
 }
@@ -157,56 +187,29 @@ func (n *node) InstallSDK(p api.SDK) error {
 }
 
 func (n *node) RegisterFactory(id string, factory api.Factory) error {
-	return view2.GetRegistry(n.registry).RegisterFactory(id, factory)
+	return n.viewRegistry.RegisterFactory(id, factory)
 }
 
 func (n *node) RegisterResponder(responder view.View, initiatedBy interface{}) error {
-	return view2.GetRegistry(n.registry).RegisterResponder(responder, initiatedBy)
+	return n.viewRegistry.RegisterResponder(responder, initiatedBy)
 }
 
 func (n *node) RegisterResponderWithIdentity(responder view.View, id view.Identity, initiatedBy view.View) error {
-	return view2.GetRegistry(n.registry).RegisterResponderWithIdentity(responder, id, initiatedBy)
+	return n.viewRegistry.RegisterResponderWithIdentity(responder, id, initiatedBy)
 }
 
+// RegisterService To be deprecated
 func (n *node) RegisterService(service interface{}) error {
 	return n.registry.RegisterService(service)
 }
 
+// GetService to be deprecated
 func (n *node) GetService(v interface{}) (interface{}, error) {
 	return n.registry.GetService(v)
 }
 
-func (n *node) Registry() Registry {
-	return n.registry
-}
-
-func (n *node) ResolveIdentities(endpoints ...string) ([]view.Identity, error) {
-	resolver := view2.GetEndpointService(n.registry)
-
-	var ids []view.Identity
-	for _, e := range endpoints {
-		identity, err := resolver.GetIdentity(e, nil)
-		if err != nil {
-			return nil, errors.Wrapf(err, "cannot find the identity at %s", e)
-		}
-		ids = append(ids, identity)
-	}
-
-	return ids, nil
-}
-
-func (n *node) getTracer() trace.Tracer {
-	if n.tracer == nil {
-		n.tracer = tracing2.Get(n.registry).Tracer("node_view_client", tracing.WithMetricsOpts(tracing.MetricsOpts{
-			Namespace:  "viewsdk",
-			LabelNames: []tracing.LabelName{fidLabel},
-		}))
-	}
-	return n.tracer
-}
-
 func (n *node) CallView(fid string, in []byte) (interface{}, error) {
-	ctx, span := n.getTracer().Start(context.Background(), "CallView",
+	ctx, span := n.tracer.Start(context.Background(), "CallView",
 		trace.WithSpanKind(trace.SpanKindClient),
 		tracing.WithAttributes(tracing.String(fidLabel, fid)))
 	defer span.End()
@@ -239,44 +242,20 @@ func (n *node) CallView(fid string, in []byte) (interface{}, error) {
 }
 
 func (n *node) InitiateContext(view view.View) (view.Context, error) {
-	s, err := n.GetService(reflect.TypeOf((*ViewManager)(nil)))
-	if err != nil {
-		return nil, err
-	}
-	manager := s.(ViewManager)
-
-	return manager.InitiateContext(view)
+	return n.viewManager.InitiateContext(view)
 }
 
 // InitiateContextFrom creates a new view context, derived from the passed context.Context
 func (n *node) InitiateContextFrom(ctx context.Context, view view.View) (view.Context, error) {
-	s, err := n.GetService(reflect.TypeOf((*ViewManager)(nil)))
-	if err != nil {
-		return nil, err
-	}
-	manager := s.(ViewManager)
-
-	return manager.InitiateContextFrom(ctx, view, nil, "")
+	return n.viewManager.InitiateContextFrom(ctx, view, nil, "")
 }
 
 func (n *node) InitiateContextWithIdentity(view view.View, id view.Identity) (view.Context, error) {
-	s, err := n.GetService(reflect.TypeOf((*ViewManager)(nil)))
-	if err != nil {
-		return nil, err
-	}
-	manager := s.(ViewManager)
-
-	return manager.InitiateContextWithIdentity(view, id)
+	return n.viewManager.InitiateContextWithIdentity(view, id)
 }
 
 func (n *node) Context(contextID string) (view.Context, error) {
-	s, err := n.GetService(reflect.TypeOf((*ViewManager)(nil)))
-	if err != nil {
-		return nil, err
-	}
-	manager := s.(ViewManager)
-
-	return manager.Context(contextID)
+	return n.viewManager.Context(contextID)
 }
 
 func (n *node) Initiate(fid string, in []byte) (string, error) {

platform/common/utils/dig/dig.go

@@ -10,12 +10,16 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
+	"reflect"
 	"runtime/debug"
 
 	"github.com/hyperledger-labs/fabric-smart-client/pkg/node"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/common/services/logging"
 	"go.uber.org/dig"
 )
 
+var logger = logging.MustGetLogger("dig-utils")
+
 type invoker interface {
 	Invoke(function interface{}, opts ...dig.InvokeOption) error
 }
@@ -40,6 +44,26 @@ func Register[T any](c invoker) error {
 	return nil
 }
 
+func RegisterOptional[T any](c invoker) error {
+	//Temporary workaround for services that are imported still using the registry
+	err := c.Invoke(func(in struct {
+		dig.In
+		Registry node.Registry
+		Service  T `optional:"true"`
+	}) error {
+		if reflect.ValueOf(in.Service).IsNil() {
+			logger.Warnf("Skipping registration of optional dependency [%T]", new(T))
+			return nil
+		}
+		return in.Registry.RegisterService(in.Service)
+	})
+	if err != nil {
+		debug.PrintStack()
+		return fmt.Errorf("failed registering type %T: %+v", *new(T), err)
+	}
+	return nil
+}
+
 func ProvideAll(c *dig.Container, constructors ...interface{}) error {
 	errs := make([]error, len(constructors))
 	for i, constructor := range constructors {