cleanup + check the length of the statuses

Signed-off-by: Angelo De Caro <adc@zurich.ibm.com>

Author: adecaro

platform/fabricx/core/queryservice/query.go

@@ -80,6 +80,10 @@ func (s *RemoteQueryService) GetTransactionStatus(txID string) (int32, error) {
 		return 0, errors.Wrap(err, "query get rows")
 	}
 	logger.Debugf("QS GetState: got response in %v", time.Since(now))
+	if len(res.Statuses) == 0 {
+		logger.Errorf("QS GetState: no statuses for tx %s", txID)
+		return 0, errors.Errorf("QS GetState: no statuses for tx %s", txID)
+	}
 	return int32(res.Statuses[0].StatusWithHeight.Code), nil
 }
 

platform/fabricx/driver/finality.go

@@ -0,0 +1,27 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package driver
+
+import (
+	"github.com/hyperledger-labs/fabric-smart-client/platform/common/driver"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric"
+	fdriver "github.com/hyperledger-labs/fabric-smart-client/platform/fabric/driver"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/fabricx/core/finality"
+)
+
+const (
+	Valid   = fdriver.Valid
+	Invalid = fdriver.Invalid
+	Unknown = fdriver.Unknown
+	Busy    = fdriver.Busy
+)
+
+type (
+	TxID                    = driver.TxID
+	FinalityListener        = fabric.FinalityListener
+	FinalityListenerManager = finality.ListenerManager
+)

platform/fabricx/driver/qs.go

@@ -8,12 +8,14 @@ package driver
 
 import (
 	"github.com/hyperledger-labs/fabric-smart-client/platform/common/driver"
+	fdriver "github.com/hyperledger-labs/fabric-smart-client/platform/fabric/driver"
 )
 
 type (
-	Namespace  = driver.Namespace
-	PKey       = driver.PKey
-	VaultValue = driver.VaultValue
+	ValidationCode = fdriver.ValidationCode
+	Namespace      = driver.Namespace
+	PKey           = driver.PKey
+	VaultValue     = driver.VaultValue
 )
 
 type QueryService interface {

platform/fabricx/finality.go

@@ -7,21 +7,19 @@ SPDX-License-Identifier: Apache-2.0
 package fabricx
 
 import (
-	"github.com/hyperledger-labs/fabric-smart-client/platform/common/driver"
-	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric"
-	"github.com/hyperledger-labs/fabric-smart-client/platform/fabricx/core/finality"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/fabricx/driver"
 )
 
 type (
 	TxID             = driver.TxID
-	FinalityListener = fabric.FinalityListener
+	FinalityListener = driver.FinalityListener
 )
 
 type Finality struct {
-	manager finality.ListenerManager
+	manager driver.FinalityListenerManager
 }
 
-func NewFinality(manager finality.ListenerManager) *Finality {
+func NewFinality(manager driver.FinalityListenerManager) *Finality {
 	return &Finality{manager: manager}
 }
 

platform/fabricx/fns.go

@@ -23,7 +23,7 @@ var (
 	logger                     = logging.MustGetLogger()
 )
 
-// NetworkService models a Fabric Network
+// NetworkService models a FabricX Network Service
 type NetworkService struct {
 	*fabric.NetworkService
 	queryService *QueryService
@@ -55,16 +55,16 @@ func NewNetworkService(
 	}, nil
 }
 
-func (ns *NetworkService) FabricNetworkService() *fabric.NetworkService {
-	return ns.NetworkService
+func (s *NetworkService) FabricNetworkService() *fabric.NetworkService {
+	return s.NetworkService
 }
 
-func (ns *NetworkService) QueryService() *QueryService {
-	return ns.queryService
+func (s *NetworkService) QueryService() *QueryService {
+	return s.queryService
 }
 
-func (ns *NetworkService) FinalityService() (*Finality, error) {
-	return ns.finalityProvider.Get("")
+func (s *NetworkService) FinalityService() (*Finality, error) {
+	return s.finalityProvider.Get("")
 }
 
 type NetworkServiceProvider struct {
@@ -94,12 +94,12 @@ func NewNetworkServiceProvider(
 	}
 }
 
-func (nsp *NetworkServiceProvider) FabricNetworkServiceProvider() *fabric.NetworkServiceProvider {
-	return nsp.fnsProvider
+func (p *NetworkServiceProvider) FabricNetworkServiceProvider() *fabric.NetworkServiceProvider {
+	return p.fnsProvider
 }
 
-func (nsp *NetworkServiceProvider) FabricNetworkService(id string) (*NetworkService, error) {
-	return nsp.providers.Get(id)
+func (p *NetworkServiceProvider) FabricNetworkService(id string) (*NetworkService, error) {
+	return p.providers.Get(id)
 }
 
 func GetNetworkServiceProvider(sp services.Provider) (*NetworkServiceProvider, error) {
@@ -110,10 +110,6 @@ func GetNetworkServiceProvider(sp services.Provider) (*NetworkServiceProvider, e
 	return s.(*NetworkServiceProvider), nil
 }
 
-func GetFabricNetworkNames(sp services.Provider) ([]string, error) {
-	return fabric.GetFabricNetworkNames(sp)
-}
-
 // GetFabricNetworkService returns the Fabric Network Service for the passed id, nil if not found
 func GetFabricNetworkService(sp services.Provider, id string) (*NetworkService, error) {
 	provider, err := GetNetworkServiceProvider(sp)

platform/fabricx/qs.go

@@ -7,18 +7,24 @@ SPDX-License-Identifier: Apache-2.0
 package fabricx
 
 import (
-	fdriver "github.com/hyperledger-labs/fabric-smart-client/platform/fabric/driver"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/fabricx/driver"
 	"github.com/hyperledger/fabric-x-committer/api/protoblocktx"
 )
 
 type (
-	ValidationCode = fdriver.ValidationCode
+	ValidationCode = driver.ValidationCode
 	Namespace      = driver.Namespace
 	PKey           = driver.PKey
 	VaultValue     = driver.VaultValue
 )
 
+const (
+	Valid   = driver.Valid
+	Invalid = driver.Invalid
+	Unknown = driver.Unknown
+	Busy    = driver.Busy
+)
+
 type QueryService struct {
 	driver.QueryService
 }
@@ -30,14 +36,14 @@ func NewQueryService(queryService driver.QueryService) *QueryService {
 func (q *QueryService) GetTxStatus(txID string) (ValidationCode, error) {
 	c, err := q.GetTransactionStatus(txID)
 	if err != nil {
-		return fdriver.Unknown, err
+		return Unknown, err
 	}
 	switch protoblocktx.Status(c) {
 	case protoblocktx.Status_NOT_VALIDATED:
-		return fdriver.Unknown, nil
+		return Unknown, nil
 	case protoblocktx.Status_COMMITTED:
-		return fdriver.Valid, nil
+		return Valid, nil
 	default:
-		return fdriver.Invalid, nil
+		return Invalid, nil
 	}
 }