fix: add grpc error handling to provide more descriptive errors; fix:…

… make CacheInfo public and modify a few methods; fix: remove import aliases; fix: make Close function return one error;

cacheclient/simple_cache_client.go

@@ -1,9 +1,9 @@
 package cacheclient
 
 import (
-	resolver "github.com/momentohq/client-sdk-go/resolver"
-	responses "github.com/momentohq/client-sdk-go/responses"
-	scsmanagers "github.com/momentohq/client-sdk-go/scsmanagers"
+	"github.com/momentohq/client-sdk-go/resolver"
+	"github.com/momentohq/client-sdk-go/responses"
+	"github.com/momentohq/client-sdk-go/scsmanagers"
 )
 
 type simpleCacheClient struct {
@@ -51,17 +51,15 @@ func (scc *simpleCacheClient) Get(cacheName string, key interface{}) (*responses
 	return scc.dataClient.Get(cacheName, key)
 }
 
-func (scc *simpleCacheClient) Close() (error, error) {
+func (scc *simpleCacheClient) Close() error {
 	ccErr := scc.controlClient.Close()
 	dErr := scc.dataClient.Close()
 	if ccErr != nil || dErr != nil {
 		if ccErr != nil {
-			return ccErr, nil
+			return ccErr
 		} else if dErr != nil {
-			return nil, dErr
-		} else {
-			return ccErr, dErr
+			return dErr
 		}
 	}
-	return nil, nil
+	return nil
 }

grpcmanagers/control_manager.go

@@ -1,9 +1,10 @@
-package grpcmanager
+package grpcmanagers
 
 import (
 	"crypto/tls"
 
-	interceptor "github.com/momentohq/client-sdk-go/interceptor"
+	"github.com/momentohq/client-sdk-go/interceptor"
+	"github.com/momentohq/client-sdk-go/scserrors"
 
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
@@ -13,12 +14,12 @@ type ControlGrpcManager struct {
 	Conn *grpc.ClientConn
 }
 
-func NewControlGrpcManager(authToken string, endPoint string) (ControlGrpcManager, error) {
+func NewControlGrpcManager(authToken string, endPoint string) (*ControlGrpcManager, error) {
 	config := &tls.Config{
 		InsecureSkipVerify: false,
 	}
 	conn, err := grpc.Dial(endPoint, grpc.WithTransportCredentials(credentials.NewTLS(config)), grpc.WithDisableRetry(), grpc.WithUnaryInterceptor(interceptor.AddHeadersInterceptor(authToken)))
-	return ControlGrpcManager{Conn: conn}, err
+	return &ControlGrpcManager{Conn: conn}, scserrors.GrpcErrorConverter(err)
 }
 
 func (cm *ControlGrpcManager) Close() error {

grpcmanagers/data_manager.go

@@ -1,9 +1,10 @@
-package grpcmanager
+package grpcmanagers
 
 import (
 	"crypto/tls"
 
-	interceptor "github.com/momentohq/client-sdk-go/interceptor"
+	"github.com/momentohq/client-sdk-go/interceptor"
+	"github.com/momentohq/client-sdk-go/scserrors"
 
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
@@ -18,7 +19,7 @@ func NewDataGrpcManager(authToken string, endPoint string) (DataGrpcManager, err
 		InsecureSkipVerify: false,
 	}
 	conn, err := grpc.Dial(endPoint, grpc.WithTransportCredentials(credentials.NewTLS(config)), grpc.WithDisableRetry(), grpc.WithUnaryInterceptor(interceptor.AddHeadersInterceptor(authToken)))
-	return DataGrpcManager{Conn: conn}, err
+	return DataGrpcManager{Conn: conn}, scserrors.GrpcErrorConverter(err)
 }
 
 func (cm *DataGrpcManager) Close() error {

responses/cache_operation_responses.go

@@ -2,16 +2,16 @@ package responses
 
 import (
 	pb "github.com/momentohq/client-sdk-go/protos"
-	utility "github.com/momentohq/client-sdk-go/utility"
+	"github.com/momentohq/client-sdk-go/utility"
 )
 
 type ListCachesResponse struct {
 	nextToken string
-	caches    []cacheInfo
+	caches    []CacheInfo
 }
 
 func NewListCacheResponse(lcr *pb.ListCachesResponse) *ListCachesResponse {
-	caches := []cacheInfo{}
+	var caches = []CacheInfo{}
 	for _, cache := range lcr.Cache {
 		caches = append(caches, NewCacheInfo(cache))
 	}
@@ -22,20 +22,20 @@ func (lcr *ListCachesResponse) NextToken() string {
 	return lcr.nextToken
 }
 
-func (lcr *ListCachesResponse) Name() []string {
-	caches := []string{}
-	for _, cache := range lcr.caches {
-		caches = append(caches, cache.Name)
-	}
-	return caches
+func (lcr *ListCachesResponse) Caches() []CacheInfo {
+	return lcr.caches
+}
+
+type CacheInfo struct {
+	name string
 }
 
-type cacheInfo struct {
-	Name string
+func (ci CacheInfo) Name() string {
+	return ci.name
 }
 
-func NewCacheInfo(ci *pb.Cache) cacheInfo {
-	return cacheInfo{Name: ci.CacheName}
+func NewCacheInfo(ci *pb.Cache) CacheInfo {
+	return CacheInfo{name: ci.CacheName}
 }
 
 const (

scserrors/scs_errors.go

@@ -1,7 +1,32 @@
-package errors
+package scserrors
 
-import "errors"
+import (
+	"errors"
+	"fmt"
+
+	"google.golang.org/grpc/status"
+)
 
 func InvalidInputError(errMessage string) error {
 	return errors.New("InvalidInputError: " + errMessage)
 }
+
+func InternalServerError(errMessage string) error {
+	return errors.New("InternalServerError: " + errMessage)
+}
+
+func GrpcErrorConverter(grpcErr error) error {
+	if grpcStatus, ok := status.FromError(grpcErr); ok {
+		switch grpcStatus.Code().String() {
+		case "AlreadyExists":
+			return fmt.Errorf(fmt.Sprintf("%s: %s", grpcStatus.Code().String(), grpcStatus.Message()))
+		case "InvalidArgument":
+			return fmt.Errorf(fmt.Sprintf("%s: %s", grpcStatus.Code().String(), grpcStatus.Message()))
+		case "NotFound":
+			return fmt.Errorf(fmt.Sprintf("%s: %s", grpcStatus.Code().String(), grpcStatus.Message()))
+		case "PermissionDenied":
+			return fmt.Errorf(fmt.Sprintf("%s: %s", grpcStatus.Code().String(), grpcStatus.Message()))
+		}
+	}
+	return InternalServerError("CacheService failed with an internal error'")
+}

scsmanagers/scs_control_client.go

@@ -1,26 +1,26 @@
-package scsmanager
+package scsmanagers
 
 import (
 	"context"
 	"fmt"
 	"time"
 
-	grpcmanagers "github.com/momentohq/client-sdk-go/grpcmanagers"
+	"github.com/momentohq/client-sdk-go/grpcmanagers"
 	pb "github.com/momentohq/client-sdk-go/protos"
-	responses "github.com/momentohq/client-sdk-go/responses"
-	utility "github.com/momentohq/client-sdk-go/utility"
+	"github.com/momentohq/client-sdk-go/responses"
+	"github.com/momentohq/client-sdk-go/utility"
 )
 
-const CONTROL_PORT = ":443"
-const CONTROL_CTX_TIMEOUT = 10 * time.Second
+const ControlPort = ":443"
+const ControlCtxTimeout = 10 * time.Second
 
 type ScsControlClient struct {
-	grpcManager grpcmanagers.ControlGrpcManager
+	grpcManager *grpcmanagers.ControlGrpcManager
 	client      pb.ScsControlClient
 }
 
 func NewScsControlClient(authToken string, endPoint string) (*ScsControlClient, error) {
-	newEndPoint := fmt.Sprint(endPoint, CONTROL_PORT)
+	newEndPoint := fmt.Sprint(endPoint, ControlPort)
 	cm, err := grpcmanagers.NewControlGrpcManager(authToken, newEndPoint)
 	if err != nil {
 		return nil, err
@@ -29,14 +29,14 @@ func NewScsControlClient(authToken string, endPoint string) (*ScsControlClient,
 	return &ScsControlClient{grpcManager: cm, client: client}, nil
 }
 
-func (scc *ScsControlClient) Close() error {
-	return scc.grpcManager.Close()
+func (cc *ScsControlClient) Close() error {
+	return cc.grpcManager.Close()
 }
 
 func (cc *ScsControlClient) CreateCache(cacheName string) error {
 	if utility.IsCacheNameValid(cacheName) {
 		request := pb.CreateCacheRequest{CacheName: cacheName}
-		ctx, cancel := context.WithTimeout(context.Background(), CONTROL_CTX_TIMEOUT)
+		ctx, cancel := context.WithTimeout(context.Background(), ControlCtxTimeout)
 		defer cancel()
 		_, err := cc.client.CreateCache(ctx, &request)
 		if err != nil {
@@ -50,7 +50,7 @@ func (cc *ScsControlClient) CreateCache(cacheName string) error {
 func (cc *ScsControlClient) DeleteCache(cacheName string) error {
 	if utility.IsCacheNameValid(cacheName) {
 		request := pb.DeleteCacheRequest{CacheName: cacheName}
-		ctx, cancel := context.WithTimeout(context.Background(), CONTROL_CTX_TIMEOUT)
+		ctx, cancel := context.WithTimeout(context.Background(), ControlCtxTimeout)
 		defer cancel()
 		_, err := cc.client.DeleteCache(ctx, &request)
 		if err != nil {
@@ -67,7 +67,7 @@ func (cc *ScsControlClient) ListCaches(nextToken ...string) (*responses.ListCach
 		defaultToken = nextToken[0]
 	}
 	request := pb.ListCachesRequest{NextToken: defaultToken}
-	ctx, cancel := context.WithTimeout(context.Background(), CONTROL_CTX_TIMEOUT)
+	ctx, cancel := context.WithTimeout(context.Background(), ControlCtxTimeout)
 	defer cancel()
 	resp, err := cc.client.ListCaches(ctx, &request)
 	if err != nil {

scsmanagers/scs_data_client.go

@@ -1,21 +1,21 @@
-package scsmanager
+package scsmanagers
 
 import (
 	"context"
 	"fmt"
 	"reflect"
 	"time"
 
-	grpcmanagers "github.com/momentohq/client-sdk-go/grpcmanagers"
+	"github.com/momentohq/client-sdk-go/grpcmanagers"
 	pb "github.com/momentohq/client-sdk-go/protos"
-	responses "github.com/momentohq/client-sdk-go/responses"
-	scserrors "github.com/momentohq/client-sdk-go/scserrors"
-	utility "github.com/momentohq/client-sdk-go/utility"
+	"github.com/momentohq/client-sdk-go/responses"
+	"github.com/momentohq/client-sdk-go/scserrors"
+	"github.com/momentohq/client-sdk-go/utility"
 	"google.golang.org/grpc/metadata"
 )
 
-const CACHE_PORT = ":443"
-const CACHE_CTX_TIMEOUT = 10 * time.Second
+const CachePort = ":443"
+const CacheCtxTimeout = 10 * time.Second
 
 type ScsDataClient struct {
 	grpcManager       grpcmanagers.DataGrpcManager
@@ -24,7 +24,7 @@ type ScsDataClient struct {
 }
 
 func NewScsDataClient(authToken string, endPoint string, defaultTtlSeconds uint32) (*ScsDataClient, error) {
-	newEndPoint := fmt.Sprint(endPoint, CACHE_PORT)
+	newEndPoint := fmt.Sprint(endPoint, CachePort)
 	cm, err := grpcmanagers.NewDataGrpcManager(authToken, newEndPoint)
 	if err != nil {
 		return nil, err
@@ -38,11 +38,11 @@ func NewScsDataClient(authToken string, endPoint string, defaultTtlSeconds uint3
 	return &ScsDataClient{grpcManager: cm, client: client, defaultTtlSeconds: defaultTtlSeconds}, nil
 }
 
-func (scc *ScsDataClient) Close() error {
-	return scc.grpcManager.Close()
+func (dc *ScsDataClient) Close() error {
+	return dc.grpcManager.Close()
 }
 
-func (scc *ScsDataClient) Set(cacheName string, key interface{}, value interface{}, ttlSeconds ...uint32) (*responses.SetCacheResponse, error) {
+func (dc *ScsDataClient) Set(cacheName string, key interface{}, value interface{}, ttlSeconds ...uint32) (*responses.SetCacheResponse, error) {
 	if utility.IsCacheNameValid(cacheName) {
 		byteKey, errAsBytesKey := asBytes(key, "Unsupported type for key: ")
 		if errAsBytesKey != nil {
@@ -54,7 +54,7 @@ func (scc *ScsDataClient) Set(cacheName string, key interface{}, value interface
 		}
 		var itemTtlMils uint32
 		if len(ttlSeconds) == 0 {
-			itemTtlMils = scc.defaultTtlSeconds * 1000
+			itemTtlMils = dc.defaultTtlSeconds * 1000
 		} else {
 			err := isTtlValid(ttlSeconds[0])
 			if err != nil {
@@ -64,10 +64,10 @@ func (scc *ScsDataClient) Set(cacheName string, key interface{}, value interface
 			}
 		}
 		request := pb.SetRequest{CacheKey: byteKey, CacheBody: byteValue, TtlMilliseconds: itemTtlMils}
-		ctx, cancel := context.WithTimeout(context.Background(), CACHE_CTX_TIMEOUT)
+		ctx, cancel := context.WithTimeout(context.Background(), CacheCtxTimeout)
 		defer cancel()
 		md := createNewMetadata(cacheName)
-		resp, errSet := scc.client.Set(metadata.NewOutgoingContext(ctx, md), &request)
+		resp, errSet := dc.client.Set(metadata.NewOutgoingContext(ctx, md), &request)
 		if errSet != nil {
 			return nil, errSet
 		}
@@ -77,17 +77,17 @@ func (scc *ScsDataClient) Set(cacheName string, key interface{}, value interface
 	return nil, scserrors.InvalidInputError("cache name cannot be empty")
 }
 
-func (scc *ScsDataClient) Get(cacheName string, key interface{}) (*responses.GetCacheResponse, error) {
+func (dc *ScsDataClient) Get(cacheName string, key interface{}) (*responses.GetCacheResponse, error) {
 	if utility.IsCacheNameValid(cacheName) {
 		byteKey, errAsBytes := asBytes(key, "Unsupported type for key: ")
 		if errAsBytes != nil {
 			return nil, errAsBytes
 		}
 		request := pb.GetRequest{CacheKey: byteKey}
-		ctx, cancel := context.WithTimeout(context.Background(), CACHE_CTX_TIMEOUT)
+		ctx, cancel := context.WithTimeout(context.Background(), CacheCtxTimeout)
 		defer cancel()
 		md := createNewMetadata(cacheName)
-		resp, err := scc.client.Get(metadata.NewOutgoingContext(ctx, md), &request)
+		resp, err := dc.client.Get(metadata.NewOutgoingContext(ctx, md), &request)
 		if err != nil {
 			return nil, err
 		}