Use strongly type IR when sending data to remote infra server

Signed-off-by: Zachary Nixon <nixozach@amazon.com>

Author: zac-nixon

examples/remote-infra/README.md

@@ -24,9 +24,10 @@ The provider implements the four RPCs defined in
 | `CreateOrUpdateRateLimitInfra` | No-op. Rate limiting must be provisioned out of band, see below  |
 | `DeleteRateLimitInfra`         | No-op                                                            |
 
-The IR is delivered as JSON in the request's `ir_bytes` field. The example
-ignores fields it doesn't understand, which is the same forward-compatibility
-posture you'll want in your own provider.
+The IR is delivered as a structured `Infra` protobuf message in the request's
+`infra` field. The example maps only the subset of fields it understands onto
+its own pared-down types (see `synthesizer/ir.go`) and ignores the rest, which
+is the same forward-compatibility posture you'll want in your own provider.
 
 ## Layout
 

examples/remote-infra/main.go

@@ -13,7 +13,6 @@ package main
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"flag"
 	"fmt"
@@ -43,27 +42,64 @@ type basicServer struct {
 }
 
 func (bs *basicServer) CreateOrUpdateProxyInfra(ctx context.Context, req *pb.CreateOrUpdateProxyInfraRequest) (*pb.CreateOrUpdateProxyInfraResponse, error) {
-	ir := new(synthesizer.Infra{})
-	if err := json.Unmarshal(req.GetIrBytes(), ir); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal IR: %w", err)
-	}
+	ir := infraFromProto(req.GetInfra())
 
 	fmt.Printf("Creating proxy infra [%v]\n", ir)
 	err := bs.synth.CreateOrUpdate(ctx, ir)
 	return new(pb.CreateOrUpdateProxyInfraResponse{}), err
 }
 
 func (bs *basicServer) DeleteProxyInfra(ctx context.Context, req *pb.DeleteProxyInfraRequest) (*pb.DeleteProxyInfraResponse, error) {
-	ir := new(synthesizer.Infra{})
-	if err := json.Unmarshal(req.GetIrBytes(), ir); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal IR: %w", err)
-	}
+	ir := infraFromProto(req.GetInfra())
 
 	fmt.Printf("Deleting proxy infra [%v]\n", ir)
 	err := bs.synth.Delete(ctx, ir)
 	return new(pb.DeleteProxyInfraResponse{}), err
 }
 
+// infraFromProto maps the structured proto IR onto the pared-down
+// synthesizer.Infra used by this example. Fields the synthesizer does not
+// consume (proxy config, addresses, resolved metric sinks, and the owner
+// reference within metadata) are intentionally dropped, demonstrating the
+// forward-compatible posture a provider should adopt: read only what you
+// understand.
+func infraFromProto(in *pb.Infra) *synthesizer.Infra {
+	if in == nil || in.GetProxy() == nil {
+		return new(synthesizer.Infra{})
+	}
+
+	p := in.GetProxy()
+	proxy := &synthesizer.ProxyInfra{
+		Name:      p.GetName(),
+		Namespace: p.GetNamespace(),
+	}
+
+	if md := p.GetMetadata(); md != nil {
+		proxy.Metadata = &synthesizer.InfraMetadata{
+			Annotations: md.GetAnnotations(),
+			Labels:      md.GetLabels(),
+		}
+	}
+
+	for _, l := range p.GetListeners() {
+		if l == nil {
+			continue
+		}
+		listener := &synthesizer.ProxyListener{Name: l.GetName()}
+		for _, port := range l.GetPorts() {
+			listener.Ports = append(listener.Ports, synthesizer.ListenerPort{
+				Name:          port.GetName(),
+				Protocol:      port.GetProtocol(),
+				ServicePort:   port.GetServicePort(),
+				ContainerPort: port.GetContainerPort(),
+			})
+		}
+		proxy.Listeners = append(proxy.Listeners, listener)
+	}
+
+	return &synthesizer.Infra{Proxy: proxy}
+}
+
 func (bs *basicServer) CreateOrUpdateRateLimitInfra(_ context.Context, _ *pb.CreateOrUpdateRateLimitInfraRequest) (*pb.CreateOrUpdateRateLimitInfraResponse, error) {
 	return new(pb.CreateOrUpdateRateLimitInfraResponse{}), nil
 }