protocodec: add BackendGetterWithInfo wrapper

Author: dfinkel

protocodec/backend_getter_v2.go

@@ -34,11 +34,10 @@ func (b backendGetterV2[C, T]) Get(ctx context.Context, key string, dest galaxyc
 		d.Set(out)
 		return nil
 	}
-	return b.setSlow(out, dest)
-
+	return setSlowV2(out, dest)
 }
 
-func (b backendGetterV2[C, T]) setSlow(out T, dest galaxycache.Codec) error {
+func setSlowV2[C any, T pointerMessage[C]](out T, dest galaxycache.Codec) error {
 	vs, mErr := proto.Marshal(out)
 	if mErr != nil {
 		return fmt.Errorf("failed to marshal value as bytes: %w", mErr)
@@ -49,3 +48,29 @@ func (b backendGetterV2[C, T]) setSlow(out T, dest galaxycache.Codec) error {
 	}
 	return nil
 }
+
+// BackendGetterWithInfo is an adapter that implements [galaxycache.BackendGetterWithInfo]
+// (it wraps an unexported type because type-inference is much better on function-calls)
+func BackendGetterWithInfo[C any, T pointerMessage[C]](f func(ctx context.Context, key string) (T, galaxycache.BackendGetInfo, error)) galaxycache.BackendGetterWithInfo {
+	return backendGetterWithInfo[C, T](f)
+}
+
+// backendGetterWithInfo is an adapter type that implements galaxycache.BackendGetterWithInfo
+type backendGetterWithInfo[C any, T pointerMessage[C]] func(ctx context.Context, key string) (T, galaxycache.BackendGetInfo, error)
+
+// Get populates dest with the value identified by key
+// The returned data must be unversioned. That is, key must
+// uniquely describe the loaded data, without an implicit
+// current time, and without relying on cache expiration
+// mechanisms.
+func (b backendGetterWithInfo[C, T]) GetWithInfo(ctx context.Context, key string, dest galaxycache.Codec) (galaxycache.BackendGetInfo, error) {
+	out, bgInfo, bgErr := b(ctx, key)
+	if bgErr != nil {
+		return galaxycache.BackendGetInfo{}, bgErr
+	}
+	if d, ok := dest.(*CodecV2[C, T]); ok {
+		d.Set(out)
+		return bgInfo, nil
+	}
+	return bgInfo, setSlowV2(out, dest)
+}

protocodec/backend_getter_v2_test.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"testing"
+	"time"
 
 	"google.golang.org/protobuf/proto"
 
@@ -104,3 +105,98 @@ func TestBackendGetterV2Bad(t *testing.T) {
 		}
 	}
 }
+
+// Test of common-good-case
+func TestBackendGetterWithInfoGood(t *testing.T) {
+	expiry := time.Now().Add(time.Minute * 97)
+	beGood := func(ctx context.Context, key string) (*testpbv2.TestMessage, galaxycache.BackendGetInfo, error) {
+		return &testpbv2.TestMessage{
+			Name: proto.String("TestName"),
+			City: proto.String("TestCity"),
+		}, galaxycache.BackendGetInfo{Expiration: expiry}, nil
+	}
+
+	be := protocodec.BackendGetterWithInfo(beGood)
+
+	ctx := context.Background()
+
+	// test with a proto codec passed (local common-case)
+	{
+		pc := protocodec.NewV2[testpbv2.TestMessage]()
+
+		if bgInfo, getErr := be.GetWithInfo(ctx, "foobar", &pc); getErr != nil {
+			t.Errorf("noop Get call failed: %s", getErr)
+		} else if !bgInfo.Expiration.Equal(expiry) {
+			t.Errorf("unexpected expiration: %s; wanted %s", bgInfo.Expiration, expiry)
+		}
+
+		pv := pc.Get()
+		if pv.City == nil || *pv.City != "TestCity" {
+			t.Errorf("unexpected value for City: %v", pv.City)
+		}
+		if pv.Name == nil || *pv.Name != "TestName" {
+			t.Errorf("unexpected value for Name: %v", pv.Name)
+		}
+	}
+	// test with a ByteCodec to exercise the common-case when a remote-fetch is done
+	{
+		c := galaxycache.ByteCodec{}
+
+		if bgInfo, getErr := be.GetWithInfo(ctx, "foobar", &c); getErr != nil {
+			t.Errorf("noop Get call failed: %s", getErr)
+		} else if !bgInfo.Expiration.Equal(expiry) {
+			t.Errorf("unexpected expiration: %s; wanted %s", bgInfo.Expiration, expiry)
+		}
+
+		if len(c) < len("TestName")+len("TestCity") {
+			t.Errorf("marshaled bytes too short (less than sum of two string fields)")
+		}
+
+		pc := protocodec.NewV2[testpbv2.TestMessage]()
+
+		if umErr := pc.UnmarshalBinary([]byte(c)); umErr != nil {
+			t.Errorf("failed to unmarshal bytes: %s", umErr)
+		}
+
+		pv := pc.Get()
+		if pv.City == nil || *pv.City != "TestCity" {
+			t.Errorf("unexpected value for City: %v", pv.City)
+		}
+		if pv.Name == nil || *pv.Name != "TestName" {
+			t.Errorf("unexpected value for Name: %v", pv.Name)
+		}
+	}
+}
+
+func TestBackendGetterWithInfoBad(t *testing.T) {
+	sentinel := errors.New("sentinel error")
+
+	beErrorer := func(ctx context.Context, key string) (*testpbv2.TestMessage, galaxycache.BackendGetInfo, error) {
+		return nil, galaxycache.BackendGetInfo{}, fmt.Errorf("error: %w", sentinel)
+	}
+
+	be := protocodec.BackendGetterWithInfo(beErrorer)
+
+	ctx := context.Background()
+
+	// test with a proto codec passed (local common-case)
+	{
+		pc := protocodec.NewV2[testpbv2.TestMessage]()
+
+		if _, getErr := be.GetWithInfo(ctx, "foobar", &pc); getErr == nil {
+			t.Errorf("noop Get call didn't fail")
+		} else if !errors.Is(getErr, sentinel) {
+			t.Errorf("Error from Get did not wrap/equal sentinel")
+		}
+	}
+	// test with a ByteCodec to exercise the common-case when a remote-fetch is done
+	{
+		c := galaxycache.ByteCodec{}
+
+		if _, getErr := be.GetWithInfo(ctx, "foobar", &c); getErr == nil {
+			t.Errorf("noop Get call didn't fail")
+		} else if !errors.Is(getErr, sentinel) {
+			t.Errorf("Error from Get did not wrap/equal sentinel")
+		}
+	}
+}

protocodec/galaxywrap_v2.go

@@ -18,3 +18,14 @@ func GalaxyGet[C any, T pointerMessage[C]](ctx context.Context, g *galaxycache.G
 	}
 	return pc.msg, nil
 }
+
+// GalaxyGetWithInfo is a simple wrapper around a [galaxycache.Galaxy.GetWithOptions] method-call that takes
+// care of constructing the [protocodec.CodecV2], etc. (making the interface more idiomatic for Go)
+func GalaxyGetWithInfo[C any, T pointerMessage[C]](ctx context.Context, g *galaxycache.Galaxy, opts galaxycache.GetOptions, key string) (m T, info galaxycache.GetInfo, getErr error) {
+	pc := CodecV2[C, T]{}
+	info, getErr = g.GetWithOptions(ctx, opts, key, &pc)
+	if getErr != nil {
+		return // use named return values to bring the inlining cost down
+	}
+	return pc.msg, info, nil
+}