chore: Refator Proto classes

Signed-off-by: Javier Aliaga <[email protected]>

Author: javier-aliaga

sdk-actors/src/main/java/io/dapr/actors/client/DaprClientImpl.java

@@ -15,24 +15,15 @@
 
 import com.google.protobuf.ByteString;
 import io.dapr.client.resiliency.ResiliencyOptions;
-import io.dapr.config.Properties;
 import io.dapr.exceptions.DaprException;
 import io.dapr.internal.grpc.DaprClientGrpcInterceptors;
 import io.dapr.internal.resiliency.RetryPolicy;
 import io.dapr.internal.resiliency.TimeoutPolicy;
+import io.dapr.v1.DaprActorsProtos;
 import io.dapr.v1.DaprGrpc;
-import io.dapr.v1.DaprProtos;
-import io.grpc.CallOptions;
-import io.grpc.Channel;
-import io.grpc.ClientCall;
-import io.grpc.ClientInterceptor;
-import io.grpc.ForwardingClientCall;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
 import io.grpc.stub.StreamObserver;
 import reactor.core.publisher.Mono;
 import reactor.core.publisher.MonoSink;
-import reactor.util.context.ContextView;
 
 import java.util.Map;
 import java.util.concurrent.ExecutionException;
@@ -89,16 +80,16 @@ class DaprClientImpl implements DaprClient {
    */
   @Override
   public Mono<byte[]> invoke(String actorType, String actorId, String methodName, byte[] jsonPayload) {
-    DaprProtos.InvokeActorRequest req =
-        DaprProtos.InvokeActorRequest.newBuilder()
+    DaprActorsProtos.InvokeActorRequest req =
+        DaprActorsProtos.InvokeActorRequest.newBuilder()
             .setActorType(actorType)
             .setActorId(actorId)
             .setMethod(methodName)
             .putAllMetadata(this.metadata)
             .setData(jsonPayload == null ? ByteString.EMPTY : ByteString.copyFrom(jsonPayload))
             .build();
     return Mono.deferContextual(
-        context -> this.<DaprProtos.InvokeActorResponse>createMono(
+        context -> this.<DaprActorsProtos.InvokeActorResponse>createMono(
             it -> this.grpcInterceptors.intercept(client, context).invokeActor(req, it)
         )
     ).map(r -> r.getData().toByteArray());

sdk-actors/src/main/java/io/dapr/actors/runtime/DaprClientImpl.java

@@ -20,8 +20,8 @@
 import io.dapr.config.Properties;
 import io.dapr.exceptions.DaprException;
 import io.dapr.utils.DurationUtils;
+import io.dapr.v1.DaprActorsProtos;
 import io.dapr.v1.DaprGrpc;
-import io.dapr.v1.DaprProtos;
 import io.grpc.ManagedChannel;
 import io.grpc.stub.StreamObserver;
 import reactor.core.publisher.Mono;
@@ -78,14 +78,14 @@ class DaprClientImpl implements DaprClient {
    */
   @Override
   public Mono<byte[]> getState(String actorType, String actorId, String keyName) {
-    DaprProtos.GetActorStateRequest req =
-            DaprProtos.GetActorStateRequest.newBuilder()
+    DaprActorsProtos.GetActorStateRequest req =
+        DaprActorsProtos.GetActorStateRequest.newBuilder()
                     .setActorType(actorType)
                     .setActorId(actorId)
                     .setKey(keyName)
                     .build();
 
-    return Mono.<DaprProtos.GetActorStateResponse>create(it ->
+    return Mono.<DaprActorsProtos.GetActorStateResponse>create(it ->
             client.getActorState(req, createStreamObserver(it))).map(r -> r.getData().toByteArray());
   }
 
@@ -97,13 +97,13 @@ public Mono<Void> saveStateTransactionally(
       String actorType,
       String actorId,
       List<ActorStateOperation> operations) {
-    List<DaprProtos.TransactionalActorStateOperation> grpcOps = new ArrayList<>();
+    List<DaprActorsProtos.TransactionalActorStateOperation> grpcOps = new ArrayList<>();
     for (ActorStateOperation op : operations) {
       String operationType = op.getOperationType();
       String key = op.getKey();
       Object value = op.getValue();
-      DaprProtos.TransactionalActorStateOperation.Builder opBuilder =
-          DaprProtos.TransactionalActorStateOperation.newBuilder()
+      DaprActorsProtos.TransactionalActorStateOperation.Builder opBuilder =
+          DaprActorsProtos.TransactionalActorStateOperation.newBuilder()
               .setOperationType(operationType)
               .setKey(key);
       if (value != null) {
@@ -126,8 +126,8 @@ public Mono<Void> saveStateTransactionally(
       grpcOps.add(opBuilder.build());
     }
 
-    DaprProtos.ExecuteActorStateTransactionRequest req =
-        DaprProtos.ExecuteActorStateTransactionRequest.newBuilder()
+    DaprActorsProtos.ExecuteActorStateTransactionRequest req =
+        DaprActorsProtos.ExecuteActorStateTransactionRequest.newBuilder()
             .setActorType(actorType)
             .setActorId(actorId)
             .addAllOperations(grpcOps)
@@ -145,8 +145,8 @@ public Mono<Void> registerReminder(
       String actorId,
       String reminderName,
       ActorReminderParams reminderParams) {
-    DaprProtos.RegisterActorReminderRequest req =
-            DaprProtos.RegisterActorReminderRequest.newBuilder()
+    DaprActorsProtos.RegisterActorReminderRequest req =
+        DaprActorsProtos.RegisterActorReminderRequest.newBuilder()
                     .setActorType(actorType)
                     .setActorId(actorId)
                     .setName(reminderName)
@@ -162,8 +162,8 @@ public Mono<Void> registerReminder(
    */
   @Override
   public Mono<Void> unregisterReminder(String actorType, String actorId, String reminderName) {
-    DaprProtos.UnregisterActorReminderRequest req =
-        DaprProtos.UnregisterActorReminderRequest.newBuilder()
+    DaprActorsProtos.UnregisterActorReminderRequest req =
+        DaprActorsProtos.UnregisterActorReminderRequest.newBuilder()
             .setActorType(actorType)
             .setActorId(actorId)
             .setName(reminderName)
@@ -181,8 +181,8 @@ public Mono<Void> registerTimer(
       String actorId,
       String timerName,
       ActorTimerParams timerParams) {
-    DaprProtos.RegisterActorTimerRequest req =
-         DaprProtos.RegisterActorTimerRequest.newBuilder()
+    DaprActorsProtos.RegisterActorTimerRequest req =
+        DaprActorsProtos.RegisterActorTimerRequest.newBuilder()
              .setActorType(actorType)
              .setActorId(actorId)
              .setName(timerName)
@@ -200,8 +200,8 @@ public Mono<Void> registerTimer(
    */
   @Override
   public Mono<Void> unregisterTimer(String actorType, String actorId, String timerName) {
-    DaprProtos.UnregisterActorTimerRequest req =
-        DaprProtos.UnregisterActorTimerRequest.newBuilder()
+    DaprActorsProtos.UnregisterActorTimerRequest req =
+        DaprActorsProtos.UnregisterActorTimerRequest.newBuilder()
             .setActorType(actorType)
             .setActorId(actorId)
             .setName(timerName)

sdk-actors/src/test/java/io/dapr/actors/client/DaprGrpcClientTest.java

@@ -14,8 +14,8 @@
 package io.dapr.actors.client;
 
 import com.google.protobuf.ByteString;
+import io.dapr.v1.DaprActorsProtos;
 import io.dapr.v1.DaprGrpc;
-import io.dapr.v1.DaprProtos;
 import io.grpc.ManagedChannel;
 import io.grpc.Status;
 import io.grpc.StatusException;
@@ -60,22 +60,22 @@ public class DaprGrpcClientTest {
       mock(DaprGrpc.DaprImplBase.class, delegatesTo(
           new DaprGrpc.DaprImplBase() {
             @Override
-            public void invokeActor(DaprProtos.InvokeActorRequest request,
-                StreamObserver<DaprProtos.InvokeActorResponse> responseObserver) {
+            public void invokeActor(DaprActorsProtos.InvokeActorRequest request,
+                                    StreamObserver<DaprActorsProtos.InvokeActorResponse> responseObserver) {
               assertEquals(ACTOR_TYPE, request.getActorType());
               assertEquals(METHOD_NAME, request.getMethod());
               switch (request.getActorId()) {
                 case ACTOR_ID_OK:
                   assertArrayEquals(REQUEST_PAYLOAD, request.getData().toByteArray());
                   responseObserver.onNext(
-                      DaprProtos.InvokeActorResponse.newBuilder().setData(ByteString.copyFrom(RESPONSE_PAYLOAD))
+                      DaprActorsProtos.InvokeActorResponse.newBuilder().setData(ByteString.copyFrom(RESPONSE_PAYLOAD))
                           .build());
                   responseObserver.onCompleted();
                   return;
                 case ACTOR_ID_NULL_INPUT:
                   assertArrayEquals(new byte[0], request.getData().toByteArray());
                   responseObserver.onNext(
-                      DaprProtos.InvokeActorResponse.newBuilder().setData(ByteString.copyFrom(RESPONSE_PAYLOAD))
+                      DaprActorsProtos.InvokeActorResponse.newBuilder().setData(ByteString.copyFrom(RESPONSE_PAYLOAD))
                           .build());
                   responseObserver.onCompleted();
                   return;

sdk-actors/src/test/java/io/dapr/actors/runtime/DaprGrpcClientTest.java

@@ -17,9 +17,8 @@
 import com.google.protobuf.Any;
 import com.google.protobuf.ByteString;
 import com.google.protobuf.Empty;
-import com.google.protobuf.GeneratedMessageV3;
+import io.dapr.v1.DaprActorsProtos;
 import io.dapr.v1.DaprGrpc;
-import io.dapr.v1.DaprProtos;
 import io.grpc.ManagedChannel;
 import io.grpc.Status;
 import io.grpc.StatusException;
@@ -178,17 +177,83 @@ public void unregisterActorTimer() {
     }
 
 
-    private class CustomDaprClient extends DaprGrpc.DaprImplBase {
+  private static class OperationsMatcher {
+
+    private final List<ActorStateOperation> operations;
+
+    OperationsMatcher(List<ActorStateOperation> operations) {
+      this.operations = operations;
+    }
+
+    private static boolean nullableEquals(Object one, Any another) {
+      if (one == null) {
+        return another.getValue().isEmpty();
+      }
+
+      if ((one == null) ^ (another == null)) {
+        return false;
+      }
+
+      try {
+        Any oneAny = getAny(one);
+        return oneAny.getValue().equals(another.getValue());
+      } catch (IOException e) {
+        e.printStackTrace();
+        return false;
+      }
+    }
+
+    private static Any getAny(Object value) throws IOException {
+      if (value instanceof byte[]) {
+        String base64 = OBJECT_MAPPER.writeValueAsString(value);
+        return Any.newBuilder().setValue(ByteString.copyFrom(base64.getBytes())).build();
+      } else if (value instanceof String) {
+        return Any.newBuilder().setValue(ByteString.copyFrom(((String) value).getBytes())).build();
+      }
+
+      throw new IllegalArgumentException("Must be byte[] or String");
+    }
+
+    public boolean matches(DaprActorsProtos.ExecuteActorStateTransactionRequest argument) {
+      if (argument == null) {
+        return false;
+      }
+
+      if (operations.size() != argument.getOperationsCount()) {
+        return false;
+      }
+
+      for (ActorStateOperation operation : operations) {
+        boolean found = false;
+        for (DaprActorsProtos.TransactionalActorStateOperation grpcOperation : argument.getOperationsList()) {
+          if (operation.getKey().equals(grpcOperation.getKey())
+              && operation.getOperationType().equals(grpcOperation.getOperationType())
+              && nullableEquals(operation.getValue(), grpcOperation.getValue())) {
+            found = true;
+            break;
+          }
+        }
+
+        if (!found) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+  }
+
+  private class CustomDaprClient extends DaprGrpc.DaprImplBase {
 
         @Override
-        public void getActorState(DaprProtos.GetActorStateRequest request,
-                                  StreamObserver<DaprProtos.GetActorStateResponse> responseObserver) {
+        public void getActorState(DaprActorsProtos.GetActorStateRequest request,
+                                  StreamObserver<DaprActorsProtos.GetActorStateResponse> responseObserver) {
             assertEquals(ACTOR_TYPE, request.getActorType());
             assertEquals(KEY, request.getKey());
             assertEquals(ACTOR_ID, request.getActorId());
             switch (request.getActorId()) {
                 case ACTOR_ID:
-                    populateObserver(responseObserver,  DaprProtos.GetActorStateResponse.newBuilder().setData(ByteString.copyFrom(RESPONSE_PAYLOAD))
+                  populateObserver(responseObserver, DaprActorsProtos.GetActorStateResponse.newBuilder().setData(ByteString.copyFrom(RESPONSE_PAYLOAD))
                             .build());
                     return;
 
@@ -199,7 +264,7 @@ public void getActorState(DaprProtos.GetActorStateRequest request,
             super.getActorState(request, responseObserver);
         }
 
-        public void executeActorStateTransaction(io.dapr.v1.DaprProtos.ExecuteActorStateTransactionRequest request,
+    public void executeActorStateTransaction(DaprActorsProtos.ExecuteActorStateTransactionRequest request,
                                                  io.grpc.stub.StreamObserver<com.google.protobuf.Empty> responseObserver) {
             assertEquals(ACTOR_TYPE, request.getActorType());
             assertEquals(ACTOR_ID, request.getActorId());
@@ -217,7 +282,7 @@ public void executeActorStateTransaction(io.dapr.v1.DaprProtos.ExecuteActorState
         }
 
         @Override
-        public void registerActorReminder(io.dapr.v1.DaprProtos.RegisterActorReminderRequest request,
+        public void registerActorReminder(DaprActorsProtos.RegisterActorReminderRequest request,
                                           io.grpc.stub.StreamObserver<com.google.protobuf.Empty> responseObserver) {
             assertEquals(REMINDER_NAME, request.getName());
             assertEquals("0h0m1s0ms", request.getDueTime());
@@ -236,7 +301,7 @@ public void registerActorReminder(io.dapr.v1.DaprProtos.RegisterActorReminderReq
             super.registerActorReminder(request, responseObserver);
         }
 
-        public void registerActorTimer(io.dapr.v1.DaprProtos.RegisterActorTimerRequest request,
+    public void registerActorTimer(DaprActorsProtos.RegisterActorTimerRequest request,
                                        io.grpc.stub.StreamObserver<com.google.protobuf.Empty> responseObserver) {
             assertEquals(ACTOR_TYPE, request.getActorType());
             assertEquals(ACTOR_ID, request.getActorId());
@@ -261,7 +326,7 @@ public void registerActorTimer(io.dapr.v1.DaprProtos.RegisterActorTimerRequest r
          * Unregister an actor timer.
          * </pre>
          */
-        public void unregisterActorTimer(io.dapr.v1.DaprProtos.UnregisterActorTimerRequest request,
+        public void unregisterActorTimer(DaprActorsProtos.UnregisterActorTimerRequest request,
                                          io.grpc.stub.StreamObserver<com.google.protobuf.Empty> responseObserver) {
             assertEquals(ACTOR_TYPE, request.getActorType());
             assertEquals(ACTOR_ID, request.getActorId());
@@ -278,7 +343,7 @@ public void unregisterActorTimer(io.dapr.v1.DaprProtos.UnregisterActorTimerReque
             super.unregisterActorTimer(request, responseObserver);
         }
 
-        public void unregisterActorReminder(io.dapr.v1.DaprProtos.UnregisterActorReminderRequest request,
+    public void unregisterActorReminder(DaprActorsProtos.UnregisterActorReminderRequest request,
                                             io.grpc.stub.StreamObserver<com.google.protobuf.Empty> responseObserver) {
             assertEquals(ACTOR_TYPE, request.getActorType());
             assertEquals(ACTOR_ID, request.getActorId());
@@ -306,70 +371,4 @@ private <T extends com.google.protobuf.Message> void populateObserver(StreamObse
             responseObserver.onCompleted();
         }
     }
-
-    private static class OperationsMatcher {
-
-        private final List<ActorStateOperation> operations;
-
-        OperationsMatcher(List<ActorStateOperation> operations) {
-            this.operations = operations;
-        }
-
-        public boolean matches(DaprProtos.ExecuteActorStateTransactionRequest argument) {
-            if (argument == null) {
-                return false;
-            }
-
-            if (operations.size() != argument.getOperationsCount()) {
-                return false;
-            }
-
-            for (ActorStateOperation operation : operations) {
-                boolean found = false;
-                for (DaprProtos.TransactionalActorStateOperation grpcOperation : argument.getOperationsList()) {
-                    if (operation.getKey().equals(grpcOperation.getKey())
-                            && operation.getOperationType().equals(grpcOperation.getOperationType())
-                            && nullableEquals(operation.getValue(), grpcOperation.getValue())) {
-                        found = true;
-                        break;
-                    }
-                }
-
-                if (!found) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        private static boolean nullableEquals(Object one, Any another) {
-            if (one == null) {
-                return another.getValue().isEmpty();
-            }
-
-            if ((one == null) ^ (another == null)) {
-                return false;
-            }
-
-            try {
-                Any oneAny = getAny(one);
-                return oneAny.getValue().equals(another.getValue());
-            } catch (IOException e) {
-                e.printStackTrace();
-                return false;
-            }
-        }
-
-        private static Any getAny(Object value) throws IOException {
-            if (value instanceof byte[]) {
-                String base64 = OBJECT_MAPPER.writeValueAsString(value);
-                return Any.newBuilder().setValue(ByteString.copyFrom(base64.getBytes())).build();
-            } else if (value instanceof String) {
-                return Any.newBuilder().setValue(ByteString.copyFrom(((String)value).getBytes())).build();
-            }
-
-            throw new IllegalArgumentException("Must be byte[] or String");
-        }
-    }
 }