update from main and solve conflicts

Author: nytian

CHANGELOG.md

@@ -1,7 +1,17 @@
 ## Unreleased
 
+## v1.9.0
+* Fix entity locking deserialization and add Jackson support for EntityInstanceId/EntityMetadata ([#281](https://github.com/microsoft/durabletask-java/pull/281))
+* Durable Entities ([#268](https://github.com/microsoft/durabletask-java/pull/268))
+* Add work item filtering support for `DurableTaskGrpcWorker` to enable worker-side filtering of orchestration and activity work items ([#275](https://github.com/microsoft/durabletask-java/pull/275))
+* Add support for calls to HTTP endpoints ([#271](https://github.com/microsoft/durabletask-java/pull/271))
+* Add getSuspendPostUri and getResumePostUri getters to HttpManagementPayload ([#264](https://github.com/microsoft/durabletask-java/pull/264))
+
+## v1.8.0
 * Adding rewind client API ([#253](https://github.com/microsoft/durabletask-java/pull/253)). Note: orchestration processing for rewind is supported with Azure Functions but not with the standalone `GrpcDurableTaskWorker`.
+* Add permissions to build-validation workflow ([#265](https://github.com/microsoft/durabletask-java/pull/265))
 * Add distributed tracing (OpenTelemetry) support with W3C Trace Context propagation ([#266](https://github.com/microsoft/durabletask-java/pull/266))
+* Add GitHub Copilot agents for automated PR verification, daily code review, and issue triage ([#269](https://github.com/microsoft/durabletask-java/pull/269))
 
 ## v1.7.0
 * Add descriptive error when orchestration type is not registered ([#261](https://github.com/microsoft/durabletask-java/pull/261))

azurefunctions/build.gradle

@@ -6,10 +6,26 @@ plugins {
 }
 
 group 'com.microsoft'
-version = '1.7.0'
+version = '1.9.0'
 archivesBaseName = 'durabletask-azure-functions'
 
 def protocVersion = '3.25.8'
+// Java 11 is used to compile and run all tests. Set the JDK_11 env var to your
+// local JDK 11 home directory, e.g. C:/Program Files/Java/openjdk-11.0.12_7/
+// If unset, falls back to the current JDK running Gradle.
+def rawJdkPath = System.env.JDK_11 ?: System.getProperty("java.home")
+// Handle case where JDK_11 points to an executable (e.g., .../bin/javac.exe)
+// instead of the JDK home directory — walk up to the JDK root.
+def PATH_TO_TEST_JAVA_RUNTIME = rawJdkPath
+if (rawJdkPath != null) {
+    def f = new File(rawJdkPath)
+    if (f.isFile()) {
+        PATH_TO_TEST_JAVA_RUNTIME = f.parentFile.parentFile.absolutePath
+    }
+}
+// Append .exe on Windows when invoking javac/java directly
+def isWindows = System.getProperty("os.name").toLowerCase().contains("win")
+def exeSuffix = isWindows ? ".exe" : ""
 
 repositories {
     maven {
@@ -22,11 +38,30 @@ dependencies {
     implementation group: 'com.microsoft.azure.functions', name: 'azure-functions-java-library', version: '3.2.3'
     implementation "com.google.protobuf:protobuf-java:${protocVersion}"
     compileOnly "com.microsoft.azure.functions:azure-functions-java-spi:1.1.0"
+
+    // Test dependencies
+    testImplementation 'org.mockito:mockito-core:5.21.0'
+    testImplementation 'org.mockito:mockito-junit-jupiter:5.21.0'
+    testImplementation platform('org.junit:junit-bom:5.14.2')
+    testImplementation 'org.junit.jupiter:junit-jupiter'
+    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 }
 
 sourceCompatibility = JavaVersion.VERSION_1_8
 targetCompatibility = JavaVersion.VERSION_1_8
 
+compileTestJava {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+    options.fork = true
+    options.forkOptions.executable = "${PATH_TO_TEST_JAVA_RUNTIME}/bin/javac${exeSuffix}"
+}
+
+test {
+    useJUnitPlatform()
+    executable = "${PATH_TO_TEST_JAVA_RUNTIME}/bin/java${exeSuffix}"
+}
+
 publishing {
     repositories {
         maven {

azurefunctions/src/main/java/com/microsoft/durabletask/azurefunctions/DurableClientContext.java

@@ -9,6 +9,13 @@
 import com.microsoft.azure.functions.HttpStatus;
 import com.microsoft.durabletask.DurableTaskClient;
 import com.microsoft.durabletask.DurableTaskGrpcClientFactory;
+import com.microsoft.durabletask.DurableEntityClient;
+import com.microsoft.durabletask.EntityInstanceId;
+import com.microsoft.durabletask.EntityMetadata;
+import com.microsoft.durabletask.EntityQuery;
+import com.microsoft.durabletask.EntityQueryResult;
+import com.microsoft.durabletask.CleanEntityStorageRequest;
+import com.microsoft.durabletask.CleanEntityStorageResult;
 import com.microsoft.durabletask.OrchestrationMetadata;
 import com.microsoft.durabletask.OrchestrationRuntimeStatus;
 
@@ -133,6 +140,79 @@ public HttpManagementPayload createHttpManagementPayload(HttpRequestMessage<?> r
         return this.getClientResponseLinks(request, instanceId);
     }
 
+    /**
+     * Gets the entity client for interacting with durable entities.
+     * <p>
+     * This mirrors the .NET SDK's {@code DurableTaskClient.Entities} property.
+     *
+     * @return the {@link DurableEntityClient} for this client
+     */
+    public DurableEntityClient getEntities() {
+        return getClient().getEntities();
+    }
+
+    /**
+     * Sends a fire-and-forget signal to a durable entity.
+     *
+     * @param entityId the target entity's instance ID
+     * @param operationName the name of the operation to invoke on the entity
+     * @param input the input to pass to the operation (may be {@code null})
+     */
+    public void signalEntity(EntityInstanceId entityId, String operationName, Object input) {
+        getClient().getEntities().signalEntity(entityId, operationName, input);
+    }
+
+    /**
+     * Sends a fire-and-forget signal to a durable entity with no input.
+     *
+     * @param entityId the target entity's instance ID
+     * @param operationName the name of the operation to invoke on the entity
+     */
+    public void signalEntity(EntityInstanceId entityId, String operationName) {
+        getClient().getEntities().signalEntity(entityId, operationName);
+    }
+
+    /**
+     * Gets the metadata for a durable entity, including optionally its serialized state.
+     *
+     * @param entityId the entity's instance ID
+     * @param includeState whether to include the entity's serialized state in the result
+     * @return the entity metadata, or {@code null} if the entity does not exist
+     */
+    public EntityMetadata getEntityMetadata(EntityInstanceId entityId, boolean includeState) {
+        return getClient().getEntities().getEntityMetadata(entityId, includeState);
+    }
+
+    /**
+     * Gets the metadata for a durable entity without including its serialized state.
+     *
+     * @param entityId the entity's instance ID
+     * @return the entity metadata, or {@code null} if the entity does not exist
+     */
+    public EntityMetadata getEntityMetadata(EntityInstanceId entityId) {
+        return getClient().getEntities().getEntityMetadata(entityId);
+    }
+
+    /**
+     * Queries the durable store for entity instances matching the specified filter criteria.
+     *
+     * @param query the query filter criteria
+     * @return the query result containing matching entities and an optional continuation token
+     */
+    public EntityQueryResult queryEntities(EntityQuery query) {
+        return getClient().getEntities().queryEntities(query);
+    }
+
+    /**
+     * Cleans up entity storage by removing empty entities and/or releasing orphaned locks.
+     *
+     * @param request the clean storage request specifying what to clean
+     * @return the result of the clean operation, including counts of removed entities and released locks
+     */
+    public CleanEntityStorageResult cleanEntityStorage(CleanEntityStorageRequest request) {
+        return getClient().getEntities().cleanEntityStorage(request);
+    }
+
     private HttpManagementPayload getClientResponseLinks(HttpRequestMessage<?> request, String instanceId) {
         String instanceStatusURL = this.getInstanceStatusURL(request, instanceId);
         return new HttpManagementPayload(instanceId, instanceStatusURL, this.requiredQueryStringParameters);

azurefunctions/src/main/java/com/microsoft/durabletask/azurefunctions/DurableEntityTrigger.java

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for
+ * license information.
+ */
+
+package com.microsoft.durabletask.azurefunctions;
+
+import com.microsoft.azure.functions.annotation.CustomBinding;
+import com.microsoft.azure.functions.annotation.HasImplicitOutput;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * <p>
+ * Azure Functions attribute for binding a function parameter to a Durable Task entity request.
+ * </p><p>
+ * The following is an example of an entity function that uses this trigger binding to implement
+ * a counter entity backed by a {@code TaskEntity} subclass.
+ * </p>
+ * <pre>
+ * {@literal @}FunctionName("Counter")
+ * public String counterEntity(
+ *         {@literal @}DurableEntityTrigger(name = "req") String req) {
+ *     return EntityRunner.loadAndRun(req, () -&gt; new CounterEntity());
+ * }
+ * </pre>
+ *
+ * @since 2.0.0
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.PARAMETER)
+@CustomBinding(direction = "in", name = "", type = "entityTrigger")
+@HasImplicitOutput
+public @interface DurableEntityTrigger {
+    /**
+     * <p>The name of the entity function.</p>
+     * <p>If not specified, the function name is used as the name of the entity.</p>
+     * <p>This property supports binding parameters.</p>
+     *
+     * @return The name of the entity function.
+     */
+    String entityName() default "";
+
+    /**
+     * The variable name used in function.json.
+     *
+     * @return The variable name used in function.json.
+     */
+    String name();
+
+    /**
+     * <p>
+     * Defines how Functions runtime should treat the parameter value. Possible values are:
+     * </p>
+     * <ul>
+     * <li>"": get the value as a string, and try to deserialize to actual parameter type like POJO</li>
+     * <li>string: always get the value as a string</li>
+     * <li>binary: get the value as a binary data, and try to deserialize to actual parameter type byte[]</li>
+     * </ul>
+     *
+     * @return The dataType which will be used by the Functions runtime.
+     */
+    String dataType() default "string";
+}

azurefunctions/src/main/java/com/microsoft/durabletask/azurefunctions/HttpManagementPayload.java

@@ -93,7 +93,25 @@ public String getPurgeHistoryDeleteUri() {
      * @return The HTTP URL for posting instance restart commands.
      */
     public String getRestartPostUri() {
-        return restartPostUri;
+        return this.restartPostUri;
+    }
+
+    /**
+     * Gets the HTTP POST instance suspend endpoint.
+     *
+     * @return The HTTP URL for posting instance suspend commands.
+     */
+    public String getSuspendPostUri() {
+        return this.suspendPostUri;
+    }
+
+    /**
+     * Gets the HTTP POST instance resume endpoint.
+     *
+     * @return The HTTP URL for posting instance resume commands.
+     */
+    public String getResumePostUri() {
+        return this.resumePostUri;
     }
 
     /**
@@ -102,7 +120,7 @@ public String getRestartPostUri() {
      * @return The HTTP URL for posting instance rewind commands.
      */
     public String getRewindPostUri() {
-        return rewindPostUri;
+        return this.rewindPostUri;
     }
 
 }

azurefunctions/src/main/java/com/microsoft/durabletask/azurefunctions/internal/middleware/EntityMiddleware.java

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for
+ * license information.
+ */
+
+package com.microsoft.durabletask.azurefunctions.internal.middleware;
+
+import com.microsoft.azure.functions.internal.spi.middleware.Middleware;
+import com.microsoft.azure.functions.internal.spi.middleware.MiddlewareChain;
+import com.microsoft.azure.functions.internal.spi.middleware.MiddlewareContext;
+import com.microsoft.durabletask.DataConverter;
+
+/**
+ * Durable Function Entity Middleware
+ *
+ * <p>This class is internal and is hence not for public use. Its APIs are unstable and can change
+ * at any time.
+ */
+public class EntityMiddleware implements Middleware {
+
+    private static final String ENTITY_TRIGGER = "DurableEntityTrigger";
+
+    @Override
+    public void invoke(MiddlewareContext context, MiddlewareChain chain) throws Exception {
+        String parameterName = context.getParameterName(ENTITY_TRIGGER);
+        if (parameterName == null) {
+            chain.doNext(context);
+            return;
+        }
+
+        // The entity function receives the raw base64-encoded EntityBatchRequest as a String.
+        // The user function is expected to call EntityRunner.loadAndRun() with a TaskEntityFactory
+        // and return the base64-encoded EntityBatchResult.
+        //
+        // Unlike orchestrations, entity operations are simple request/response calls with no
+        // replay-based blocking (no OrchestratorBlockedException equivalent), so the middleware
+        // delegates directly to the user function.
+        try {
+            chain.doNext(context);
+        } catch (Exception e) {
+            Throwable cause = e.getCause();
+            if (cause instanceof DataConverter.DataConverterException) {
+                throw (DataConverter.DataConverterException) cause;
+            }
+            throw new RuntimeException("Unexpected failure in entity function execution", e);
+        }
+    }
+}

azurefunctions/src/main/resources/META-INF/services/com.microsoft.azure.functions.internal.spi.middleware.Middleware

@@ -1 +1,2 @@
-com.microsoft.durabletask.azurefunctions.internal.middleware.OrchestrationMiddleware
+com.microsoft.durabletask.azurefunctions.internal.middleware.OrchestrationMiddleware
+com.microsoft.durabletask.azurefunctions.internal.middleware.EntityMiddleware