Merge branch 'main' into feature/update-relayer-ccip-provider-interface

Author: amit-momin

pkg/capabilities/capabilities.go

@@ -292,6 +292,11 @@ type ExecutableAndTriggerCapability interface {
 	ExecutableCapability
 }
 
+type DONWithNodes struct {
+	DON   DON
+	Nodes []Node
+}
+
 // DON represents a network of connected nodes.
 //
 // For an example of an empty DON check, see the following link:

pkg/loop/internal/core/services/capability/capabilities_registry.go

@@ -78,6 +78,27 @@ func (cr *capabilitiesRegistryClient) NodeByPeerID(ctx context.Context, peerID p
 	return cr.nodeFromNodeReply(res), nil
 }
 
+func (cr *capabilitiesRegistryClient) DONsForCapability(ctx context.Context, capabilityID string) ([]capabilities.DONWithNodes, error) {
+	res, err := cr.grpc.DONsForCapability(ctx, &pb.DONForCapabilityRequest{CapabilityID: capabilityID})
+	if err != nil {
+		return nil, err
+	}
+
+	donsWithNodes := []capabilities.DONWithNodes{}
+	for _, d := range res.Dons {
+		don := toDON(d.Don)
+		var nodes []capabilities.Node
+		for _, n := range d.Nodes {
+			nodes = append(nodes, cr.nodeFromNodeReply(n))
+		}
+		donsWithNodes = append(donsWithNodes, capabilities.DONWithNodes{
+			DON:   don,
+			Nodes: nodes,
+		})
+	}
+	return donsWithNodes, nil
+}
+
 func (cr *capabilitiesRegistryClient) nodeFromNodeReply(nodeReply *pb.NodeReply) capabilities.Node {
 	var pid *p2ptypes.PeerID
 	if len(nodeReply.PeerID) > 0 {
@@ -365,6 +386,30 @@ func (c *capabilitiesRegistryServer) NodeByPeerID(ctx context.Context, nodeReque
 	return c.nodeReplyFromNode(node), nil
 }
 
+func (c *capabilitiesRegistryServer) DONsForCapability(ctx context.Context, req *pb.DONForCapabilityRequest) (*pb.DONForCapabilityReply, error) {
+	dons, err := c.impl.DONsForCapability(ctx, req.CapabilityID)
+	if err != nil {
+		return nil, err
+	}
+
+	donWithNodes := []*pb.DONWithNodes{}
+	for _, d := range dons {
+		pbDon := toPbDON(d.DON)
+		nodes := []*pb.NodeReply{}
+		for _, n := range d.Nodes {
+			nodes = append(nodes, c.nodeReplyFromNode(n))
+		}
+		donWithNodes = append(donWithNodes, &pb.DONWithNodes{
+			Don:   pbDon,
+			Nodes: nodes,
+		})
+	}
+
+	return &pb.DONForCapabilityReply{
+		Dons: donWithNodes,
+	}, nil
+}
+
 func (c *capabilitiesRegistryServer) nodeReplyFromNode(node capabilities.Node) *pb.NodeReply {
 	workflowDONpb := toPbDON(node.WorkflowDON)
 

pkg/loop/internal/core/services/capability/capabilities_registry_test.go

@@ -364,6 +364,7 @@ func testCapabilityInfo(t *testing.T, expectedInfo capabilities.CapabilityInfo,
 	require.Equal(t, expectedInfo.Description, gotInfo.Description)
 	require.Equal(t, expectedInfo.Version(), gotInfo.Version())
 }
+
 func TestToDON(t *testing.T) {
 	don := &pb.DON{
 		Id:   0,
@@ -496,6 +497,75 @@ func TestCapabilitiesRegistry_ConfigForCapability_RemoteExecutableConfig(t *test
 	assert.Equal(t, 2*time.Minute, capConf.RemoteExecutableConfig.RegistrationExpiry)
 }
 
+func TestCapabilitiesRegistry_DONsForCapability(t *testing.T) {
+	stopCh := make(chan struct{})
+	logger := logger.Test(t)
+	reg := mocks.NewCapabilitiesRegistry(t)
+
+	pluginName := "registry-test"
+	client, server := plugin.TestPluginGRPCConn(
+		t,
+		true,
+		map[string]plugin.Plugin{
+			pluginName: &testRegistryPlugin{
+				impl: reg,
+				brokerExt: &net.BrokerExt{
+					BrokerConfig: net.BrokerConfig{
+						StopCh: stopCh,
+						Logger: logger,
+					},
+				},
+			},
+		},
+	)
+
+	defer client.Close()
+	defer server.Stop()
+
+	regClient, err := client.Dispense(pluginName)
+	require.NoError(t, err)
+
+	rc, ok := regClient.(*capabilitiesRegistryClient)
+	require.True(t, ok)
+
+	capID := "some-cap@1.0.0"
+
+	donID := uint32(1)
+	expectedDON := capabilities.DON{
+		ID: donID,
+		F:  1,
+		Members: []p2ptypes.PeerID{
+			[32]byte{0: 1},
+			[32]byte{0: 2},
+		},
+	}
+	expectedNodes := []capabilities.Node{
+		{
+			PeerID:              &p2ptypes.PeerID{0: 1},
+			NodeOperatorID:      1,
+			EncryptionPublicKey: [32]byte{0: 1},
+			CapabilityDONs:      []capabilities.DON{},
+		},
+		{
+			PeerID:              &p2ptypes.PeerID{0: 2},
+			NodeOperatorID:      2,
+			EncryptionPublicKey: [32]byte{0: 2},
+			CapabilityDONs:      []capabilities.DON{},
+		},
+	}
+	expectedDONs := []capabilities.DONWithNodes{
+		{
+			DON:   expectedDON,
+			Nodes: expectedNodes,
+		},
+	}
+	reg.On("DONsForCapability", mock.Anything, capID).Once().Return(expectedDONs, nil)
+
+	dons, err := rc.DONsForCapability(t.Context(), capID)
+	require.NoError(t, err)
+	assert.Equal(t, expectedDONs, dons)
+}
+
 func ensureEqual(t *testing.T, expectedNode, actualNode capabilities.Node) {
 	// check local node struct
 	require.Equal(t, expectedNode.PeerID, actualNode.PeerID)