From 30ff3f011fcf46420da0b6b681c8d4652d6aa7aa Mon Sep 17 00:00:00 2001 From: Tim Conley Date: Mon, 16 Nov 2026 10:29:24 -0800 Subject: [PATCH 1/5] Prepare SDK internals for generated System Nexus APIs Add external workflow method capture, scoped system-envelope conversion, and payload visitor support independently of generated workflow bindings. Seed the envelope allowlist with protobuf request and response types so the infrastructure builds and tests without nexgen. --- CHANGELOG.md | 2 + .../system/SystemNexusDataConverter.java | 106 +++++++++ .../ExternalWorkflowInvocationHandler.java | 111 ++++++++- .../system/SystemNexusDataConverterTest.java | 173 ++++++++++++++ .../TypedWorkflowMethodCaptureTest.java | 220 ++++++++++++++++++ temporal-serviceclient/build.gradle | 6 +- .../payload/visitor/SystemNexusPayloads.java | 49 ++++ .../internal/payload/visitor/Traversal.java | 31 +++ .../src/main/nexus/system-nexus-roots.txt | 2 + .../internal/payload/gen/ProtoClosure.java | 20 ++ .../visitor/gen/PayloadVisitorGenerator.java | 56 ++++- .../payload/gen/ProtoClosureRootTest.java | 54 +++++ .../visitor/SystemNexusPayloadTest.java | 133 +++++++++++ 13 files changed, 955 insertions(+), 8 deletions(-) create mode 100644 temporal-sdk/src/main/java/io/temporal/internal/nexus/system/SystemNexusDataConverter.java create mode 100644 temporal-sdk/src/test/java/io/temporal/internal/nexus/system/SystemNexusDataConverterTest.java create mode 100644 temporal-sdk/src/test/java/io/temporal/workflow/TypedWorkflowMethodCaptureTest.java create mode 100644 temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/SystemNexusPayloads.java create mode 100644 temporal-serviceclient/src/main/nexus/system-nexus-roots.txt create mode 100644 temporal-serviceclient/src/test/java/io/temporal/internal/payload/gen/ProtoClosureRootTest.java create mode 100644 temporal-serviceclient/src/test/java/io/temporal/internal/payload/visitor/SystemNexusPayloadTest.java diff --git a/CHANGELOG.md b/CHANGELOG.md index c44fcb06b1..785cf05e51 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,8 @@ to docs, or any other relevant information. ### Changed - Updated Cloud API bindings to v0.27.0, including opt-in user group memberships, projects, project-scoped custom roles, and caller rate limits. +- Add internal System Nexus envelope conversion, payload traversal, and external workflow method + capture support for generated workflow APIs. ## [1.41.1] - 2026-11-16 diff --git a/temporal-sdk/src/main/java/io/temporal/internal/nexus/system/SystemNexusDataConverter.java b/temporal-sdk/src/main/java/io/temporal/internal/nexus/system/SystemNexusDataConverter.java new file mode 100644 index 0000000000..984310bf81 --- /dev/null +++ b/temporal-sdk/src/main/java/io/temporal/internal/nexus/system/SystemNexusDataConverter.java @@ -0,0 +1,106 @@ +package io.temporal.internal.nexus.system; + +import com.google.protobuf.Message; +import io.temporal.api.common.v1.Payload; +import io.temporal.api.common.v1.Payloads; +import io.temporal.api.failure.v1.Failure; +import io.temporal.common.converter.DataConverter; +import io.temporal.common.converter.DataConverterException; +import io.temporal.common.converter.RawValue; +import io.temporal.internal.common.converter.TemporalTransferTypeDataConverter; +import io.temporal.internal.payload.visitor.SystemNexusPayloads; +import java.lang.reflect.Type; +import java.util.Objects; +import java.util.Optional; +import java.util.function.Supplier; +import javax.annotation.Nonnull; + +/** Keeps the server-readable envelope separate from the destination workflow's user converter. */ +public final class SystemNexusDataConverter implements DataConverter { + public static final String ENDPOINT = "__temporal_system"; + private static final ThreadLocal USER_CONVERTER = new ThreadLocal<>(); + private final DataConverter userConverter; + + /** Returns the user converter active in the current synchronous transfer conversion scope. */ + public static DataConverter currentDataConverter() { + DataConverter converter = USER_CONVERTER.get(); + if (converter == null) + throw new IllegalStateException("System Nexus user converter context is not active"); + return converter; + } + + static T withDataConverter(DataConverter converter, Supplier action) { + Objects.requireNonNull(converter, "converter"); + DataConverter previous = USER_CONVERTER.get(); + USER_CONVERTER.set(converter); + try { + return action.get(); + } finally { + if (previous == null) USER_CONVERTER.remove(); + else USER_CONVERTER.set(previous); + } + } + + public SystemNexusDataConverter(DataConverter userConverter) { + this.userConverter = Objects.requireNonNull(userConverter, "userConverter"); + } + + @Override + public Optional toPayload(T value) { + if (value instanceof RawValue) return Optional.of(((RawValue) value).getPayload()); + return withDataConverter( + userConverter, + () -> { + Object transferred = TemporalTransferTypeDataConverter.toTransferValue(value); + if (!(transferred instanceof Message)) + throw new DataConverterException( + "System Nexus inputs must have a protobuf transfer type"); + return Optional.of(SystemNexusPayloads.pack((Message) transferred)); + }); + } + + @Override + public T fromPayload(Payload payload, Class valueClass, Type valueType) { + if (valueClass == RawValue.class) return valueClass.cast(new RawValue(payload)); + return withDataConverter( + userConverter, + () -> { + Message value = SystemNexusPayloads.unpack(payload).build(); + TemporalTransferTypeDataConverter.TransferType transfer = + TemporalTransferTypeDataConverter.transferTypeFor(valueClass, valueType); + if (transfer == null) return valueClass.cast(value); + if (!transfer.getRawType().isInstance(value)) + throw new DataConverterException( + "Unexpected system Nexus response type: " + + value.getDescriptorForType().getFullName()); + return transfer.fromValue(value, valueClass); + }); + } + + @Override + public Optional toPayloads(Object... values) { + if (values == null || values.length == 0) return Optional.empty(); + Payloads.Builder result = Payloads.newBuilder(); + for (Object value : values) result.addPayloads(toPayload(value).get()); + return Optional.of(result.build()); + } + + @Override + public T fromPayloads( + int index, Optional values, Class valueClass, Type valueType) { + if (!values.isPresent() || index >= values.get().getPayloadsCount()) return null; + return fromPayload(values.get().getPayloads(index), valueClass, valueType); + } + + @Nonnull + @Override + public RuntimeException failureToException(@Nonnull Failure failure) { + return userConverter.failureToException(failure); + } + + @Nonnull + @Override + public Failure exceptionToFailure(@Nonnull Throwable failure) { + return userConverter.exceptionToFailure(failure); + } +} diff --git a/temporal-sdk/src/main/java/io/temporal/internal/sync/ExternalWorkflowInvocationHandler.java b/temporal-sdk/src/main/java/io/temporal/internal/sync/ExternalWorkflowInvocationHandler.java index 0f7def87ea..5469a2ce12 100644 --- a/temporal-sdk/src/main/java/io/temporal/internal/sync/ExternalWorkflowInvocationHandler.java +++ b/temporal-sdk/src/main/java/io/temporal/internal/sync/ExternalWorkflowInvocationHandler.java @@ -4,13 +4,111 @@ import io.temporal.common.interceptors.WorkflowOutboundCallsInterceptor; import io.temporal.common.metadata.POJOWorkflowInterfaceMetadata; import io.temporal.common.metadata.POJOWorkflowMethodMetadata; +import io.temporal.common.metadata.WorkflowMethodType; +import io.temporal.internal.common.InternalUtils; +import io.temporal.internal.common.JavaLambdaUtils; import io.temporal.workflow.ExternalWorkflowStub; import io.temporal.workflow.Functions; +import java.lang.invoke.MethodHandleInfo; +import java.lang.invoke.SerializedLambda; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; +import java.lang.reflect.Proxy; +import java.lang.reflect.Type; +import java.util.Objects; -/** Dynamic implementation of a strongly typed child workflow interface. */ -class ExternalWorkflowInvocationHandler implements InvocationHandler { +/** Dynamic implementation of a strongly typed external workflow interface. */ +public class ExternalWorkflowInvocationHandler implements InvocationHandler { + + private static final ThreadLocal probeContext = new ThreadLocal<>(); + private static final ThreadLocal probeResult = new ThreadLocal<>(); + + /** Probes one invocation without starting a workflow or sending a signal. */ + public static ProbeResult probe( + Object method, Functions.Proc invocation, WorkflowMethodType expected) { + Objects.requireNonNull(invocation, "invocation"); + if (probeContext.get() != null) { + throw new IllegalStateException("Already probing an external workflow invocation"); + } + SerializedLambda reference = + JavaLambdaUtils.toSerializedLambda(Objects.requireNonNull(method, "method")); + Object target = JavaLambdaUtils.getTarget(reference); + if (reference == null + || reference.getImplMethodKind() != MethodHandleInfo.REF_invokeInterface + || target == null + || !Proxy.isProxyClass(target.getClass()) + || !(Proxy.getInvocationHandler(target) instanceof ExternalWorkflowInvocationHandler)) { + throw new IllegalArgumentException( + "Expected a bound method from Workflow.newExternalWorkflowStub"); + } + ProbeContext context = new ProbeContext(expected); + probeContext.set(context); + try { + invocation.apply(); + ProbeResult result = probeResult.get(); + if (context.invocations != 1 || result == null) { + throw new IllegalArgumentException( + "Expected exactly one external workflow " + expected + " invocation"); + } + return result; + } finally { + probeResult.remove(); + probeContext.remove(); + } + } + + private static final class ProbeContext { + private final WorkflowMethodType expected; + private int invocations; + + private ProbeContext(WorkflowMethodType expected) { + this.expected = Objects.requireNonNull(expected, "expected"); + } + } + + /** Metadata captured from a bound external workflow method. */ + public static final class ProbeResult { + private final ExternalWorkflowStub stub; + private final String name; + private final Object[] arguments; + private final Class resultClass; + private final Type resultType; + private final Method method; + + private ProbeResult( + ExternalWorkflowStub stub, POJOWorkflowMethodMetadata metadata, Object[] args) { + this.stub = stub; + this.name = metadata.getName(); + this.arguments = args == null ? new Object[0] : args.clone(); + this.method = metadata.getWorkflowMethod(); + this.resultClass = method.getReturnType(); + this.resultType = method.getGenericReturnType(); + } + + public ExternalWorkflowStub getStub() { + return stub; + } + + public String getName() { + return name; + } + + public Object[] getArguments() { + return arguments.clone(); + } + + public Class getResultClass() { + return resultClass; + } + + public Type getResultType() { + return resultType; + } + + public Method getMethod() { + return method; + } + } private final ExternalWorkflowStub stub; private final POJOWorkflowInterfaceMetadata workflowMetadata; @@ -40,6 +138,15 @@ public Object invoke(Object proxy, Method method, Object[] args) { return stub; } POJOWorkflowMethodMetadata methodMetadata = workflowMetadata.getMethodMetadata(method); + ProbeContext context = probeContext.get(); + if (context != null) { + if (++context.invocations != 1 || methodMetadata.getType() != context.expected) { + throw new IllegalArgumentException( + "Expected exactly one external workflow " + context.expected + " invocation"); + } + probeResult.set(new ProbeResult(stub, methodMetadata, args)); + return InternalUtils.getValueOrDefault(null, method.getReturnType()); + } switch (methodMetadata.getType()) { case QUERY: throw new UnsupportedOperationException( diff --git a/temporal-sdk/src/test/java/io/temporal/internal/nexus/system/SystemNexusDataConverterTest.java b/temporal-sdk/src/test/java/io/temporal/internal/nexus/system/SystemNexusDataConverterTest.java new file mode 100644 index 0000000000..0da2195e43 --- /dev/null +++ b/temporal-sdk/src/test/java/io/temporal/internal/nexus/system/SystemNexusDataConverterTest.java @@ -0,0 +1,173 @@ +package io.temporal.internal.nexus.system; + +import static org.junit.Assert.*; + +import com.google.protobuf.ByteString; +import io.temporal.api.common.v1.Payload; +import io.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionRequest; +import io.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionResponse; +import io.temporal.common.converter.*; +import io.temporal.internal.payload.visitor.SystemNexusPayloads; +import io.temporal.payload.codec.PayloadCodec; +import io.temporal.payload.context.SerializationContext; +import io.temporal.payload.context.WorkflowSerializationContext; +import java.lang.reflect.Type; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; +import org.junit.Test; + +public class SystemNexusDataConverterTest { + @Test + public void scopesUserConversionAndKeepsTheOuterEnvelopeReadable() throws Exception { + DataConverter user = + new CodecDataConverter( + DefaultDataConverter.STANDARD_INSTANCE, Collections.singletonList(new TaggingCodec())); + SystemNexusDataConverter converter = + new SystemNexusDataConverter( + user.withContext(new WorkflowSerializationContext("destination", "target"))); + Payload encoded = converter.toPayload(new Envelope("value")).get(); + assertTrue(SystemNexusPayloads.isSystemPayload(encoded)); + assertFalse(encoded.containsMetadata("test-codec")); + SignalWithStartWorkflowExecutionRequest wire = + SignalWithStartWorkflowExecutionRequest.parseFrom(encoded.getData()); + assertTrue(wire.getInput().getPayloads(0).containsMetadata("test-codec")); + assertEquals( + "destination/target", + wire.getInput().getPayloads(0).getMetadataOrThrow("test-codec").toStringUtf8()); + assertEquals("value", converter.fromPayload(encoded, Envelope.class, Envelope.class).value); + assertThrows(IllegalStateException.class, SystemNexusDataConverter::currentDataConverter); + } + + @Test + public void acceptsUnmarkedServerResponsesAndRawValues() { + SystemNexusDataConverter converter = + new SystemNexusDataConverter(DefaultDataConverter.STANDARD_INSTANCE); + Payload response = + SystemNexusPayloads.pack( + SignalWithStartWorkflowExecutionResponse.newBuilder().setRunId("run").build()) + .toBuilder() + .removeMetadata("__temporal_system_payload") + .build(); + assertEquals( + "run", + converter + .fromPayload( + response, + SignalWithStartWorkflowExecutionResponse.class, + SignalWithStartWorkflowExecutionResponse.class) + .getRunId()); + assertSame(response, converter.toPayload(new RawValue(response)).get()); + assertSame( + response, converter.fromPayload(response, RawValue.class, RawValue.class).getPayload()); + assertThrows( + DataConverterException.class, + () -> converter.fromPayload(response, Envelope.class, Envelope.class)); + assertThrows(DataConverterException.class, () -> converter.toPayload("not a transfer model")); + assertThrows(IllegalStateException.class, SystemNexusDataConverter::currentDataConverter); + } + + @Test + public void restoresNestedScopesAfterSuccessAndFailure() { + DataConverter outer = DefaultDataConverter.STANDARD_INSTANCE; + DataConverter inner = + new CodecDataConverter(outer, Collections.singletonList(new TaggingCodec())); + SystemNexusDataConverter.withDataConverter( + outer, + () -> { + assertSame(outer, SystemNexusDataConverter.currentDataConverter()); + assertSame( + inner, + SystemNexusDataConverter.withDataConverter( + inner, SystemNexusDataConverter::currentDataConverter)); + assertSame(outer, SystemNexusDataConverter.currentDataConverter()); + assertThrows( + IllegalArgumentException.class, + () -> + SystemNexusDataConverter.withDataConverter( + inner, + () -> { + throw new IllegalArgumentException("failure"); + })); + assertSame(outer, SystemNexusDataConverter.currentDataConverter()); + return null; + }); + assertThrows(IllegalStateException.class, SystemNexusDataConverter::currentDataConverter); + } + + // A handwritten transfer fixture, independent of nexgen or workflow-facing generated bindings. + @TransferTypeConvertible(Envelope.Converter.class) + public static final class Envelope { + final String value; + + Envelope(String value) { + this.value = value; + } + + public static final class Converter implements TransferTypeConverter { + @Override + public Type getTransferType(Type valueType) { + return SignalWithStartWorkflowExecutionRequest.class; + } + + @Override + public Object toTransferType(Envelope value) { + return SignalWithStartWorkflowExecutionRequest.newBuilder() + .setInput(SystemNexusDataConverter.currentDataConverter().toPayloads(value.value).get()) + .build(); + } + + @Override + public Envelope fromTransferType(Object value, Type valueType) { + SignalWithStartWorkflowExecutionRequest wire = + (SignalWithStartWorkflowExecutionRequest) value; + return new Envelope( + SystemNexusDataConverter.currentDataConverter() + .fromPayload(wire.getInput().getPayloads(0), String.class, String.class)); + } + } + } + + private static final class TaggingCodec implements PayloadCodec { + private final String destination; + + TaggingCodec() { + this("unscoped"); + } + + private TaggingCodec(String destination) { + this.destination = destination; + } + + @Override + public PayloadCodec withContext(SerializationContext context) { + WorkflowSerializationContext workflow = (WorkflowSerializationContext) context; + return new TaggingCodec(workflow.getNamespace() + "/" + workflow.getWorkflowId()); + } + + @Override + public List encode(List payloads) { + return payloads.stream() + .map( + payload -> { + assertFalse(SystemNexusPayloads.isSystemPayload(payload)); + return payload.toBuilder() + .putMetadata("test-codec", ByteString.copyFromUtf8(destination)) + .build(); + }) + .collect(Collectors.toList()); + } + + @Override + public List decode(List payloads) { + return payloads.stream() + .map( + payload -> { + assertTrue(payload.containsMetadata("test-codec")); + assertEquals(destination, payload.getMetadataOrThrow("test-codec").toStringUtf8()); + return payload.toBuilder().removeMetadata("test-codec").build(); + }) + .collect(Collectors.toList()); + } + } +} diff --git a/temporal-sdk/src/test/java/io/temporal/workflow/TypedWorkflowMethodCaptureTest.java b/temporal-sdk/src/test/java/io/temporal/workflow/TypedWorkflowMethodCaptureTest.java new file mode 100644 index 0000000000..2da582ce65 --- /dev/null +++ b/temporal-sdk/src/test/java/io/temporal/workflow/TypedWorkflowMethodCaptureTest.java @@ -0,0 +1,220 @@ +package io.temporal.workflow; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; + +import io.temporal.api.common.v1.WorkflowExecution; +import io.temporal.common.CronSchedule; +import io.temporal.common.MethodRetry; +import io.temporal.common.interceptors.WorkflowOutboundCallsInterceptor; +import io.temporal.common.metadata.WorkflowMethodType; +import io.temporal.internal.sync.ExternalWorkflowInvocationHandler; +import io.temporal.internal.sync.ExternalWorkflowInvocationHandler.ProbeResult; +import io.temporal.internal.sync.StubMarker; +import java.lang.reflect.Proxy; +import java.util.List; +import java.util.concurrent.*; +import org.junit.Test; + +public class TypedWorkflowMethodCaptureTest { + public interface Base { + @SignalMethod(name = "custom-signal") + void signal(String value, int number); + } + + @WorkflowInterface + public interface Target extends Base { + @WorkflowMethod(name = "custom-workflow") + @MethodRetry( + initialIntervalSeconds = 7, + maximumAttempts = 3, + backoffCoefficient = 3, + maximumIntervalSeconds = 100, + doNotRetry = {"NoRetry"}) + @CronSchedule("0 * * * *") + int start(String value); + + @QueryMethod + String query(); + + @UpdateMethod + String update(); + } + + @WorkflowInterface + public interface GenericTarget { + @WorkflowMethod + List start(); + } + + private final WorkflowOutboundCallsInterceptor outbound = + mock(WorkflowOutboundCallsInterceptor.class); + private final RuntimeException normalSignal = new IllegalStateException("normal signal path"); + + private T stub(Class type, String id) { + return type.cast( + Proxy.newProxyInstance( + type.getClassLoader(), + new Class[] {type, StubMarker.class}, + new ExternalWorkflowInvocationHandler( + type, + WorkflowExecution.newBuilder().setWorkflowId(id).build(), + outbound, + ignored -> { + throw normalSignal; + }))); + } + + @Test + public void probesNamesArgumentsAnnotationsAndReturnTypesWithoutCommands() { + Target target = stub(Target.class, "target"); + Functions.Func1 method = target::start; + ProbeResult call = + ExternalWorkflowInvocationHandler.probe( + method, + () -> assertEquals(0, (int) method.apply("input")), + WorkflowMethodType.WORKFLOW); + assertEquals("custom-workflow", call.getName()); + assertArrayEquals(new Object[] {"input"}, call.getArguments()); + assertEquals(int.class, call.getResultClass()); + assertEquals(int.class, call.getResultType()); + assertEquals("target", call.getStub().getExecution().getWorkflowId()); + assertEquals(3, call.getMethod().getAnnotation(MethodRetry.class).maximumAttempts()); + assertEquals("0 * * * *", call.getMethod().getAnnotation(CronSchedule.class).value()); + assertSame(ExternalWorkflowStub.fromTyped(target), call.getStub()); + call.getArguments()[0] = "changed"; + assertEquals("input", call.getArguments()[0]); + + Functions.Proc2 signal = target::signal; + ProbeResult signalCall = + ExternalWorkflowInvocationHandler.probe( + signal, () -> signal.apply("value", 42), WorkflowMethodType.SIGNAL); + assertEquals("custom-signal", signalCall.getName()); + assertArrayEquals(new Object[] {"value", 42}, signalCall.getArguments()); + GenericTarget generic = stub(GenericTarget.class, "generic"); + Functions.Func> start = generic::start; + ProbeResult genericCall = + ExternalWorkflowInvocationHandler.probe( + start, () -> start.apply(), WorkflowMethodType.WORKFLOW); + assertEquals("java.util.List", genericCall.getResultType().getTypeName()); + verifyNoInteractions(outbound); + assertThrows(IllegalStateException.class, () -> target.start("outside probe")); + assertSame( + normalSignal, assertThrows(RuntimeException.class, () -> target.signal("outside", 1))); + } + + @Test + public void rejectsMissingRepeatedWrongKindAndNonBoundInvocations() { + Target target = stub(Target.class, "target"); + Functions.Func1 start = target::start; + assertThrows( + IllegalArgumentException.class, + () -> + ExternalWorkflowInvocationHandler.probe(start, () -> {}, WorkflowMethodType.WORKFLOW)); + assertThrows( + IllegalArgumentException.class, + () -> + ExternalWorkflowInvocationHandler.probe( + start, + () -> { + start.apply("first"); + start.apply("second"); + }, + WorkflowMethodType.WORKFLOW)); + assertThrows( + IllegalArgumentException.class, + () -> + ExternalWorkflowInvocationHandler.probe( + start, () -> start.apply("input"), WorkflowMethodType.SIGNAL)); + Functions.Proc2 signal = target::signal; + assertThrows( + IllegalArgumentException.class, + () -> + ExternalWorkflowInvocationHandler.probe( + signal, () -> signal.apply("value", 1), WorkflowMethodType.WORKFLOW)); + Functions.Func query = target::query; + Functions.Func update = target::update; + assertThrows( + IllegalArgumentException.class, + () -> + ExternalWorkflowInvocationHandler.probe( + query, () -> query.apply(), WorkflowMethodType.SIGNAL)); + assertThrows( + IllegalArgumentException.class, + () -> + ExternalWorkflowInvocationHandler.probe( + update, () -> update.apply(), WorkflowMethodType.SIGNAL)); + Functions.Proc lambda = () -> target.start("input"); + assertThrows( + IllegalArgumentException.class, + () -> ExternalWorkflowInvocationHandler.probe(lambda, lambda, WorkflowMethodType.WORKFLOW)); + verifyNoInteractions(outbound); + } + + @Test + public void restoresProbeStateAfterFailureAndRejectsNesting() { + Target target = stub(Target.class, "target"); + Functions.Func1 method = target::start; + RuntimeException failure = new RuntimeException("failed"); + assertSame( + failure, + assertThrows( + RuntimeException.class, + () -> + ExternalWorkflowInvocationHandler.probe( + method, + () -> { + throw failure; + }, + WorkflowMethodType.WORKFLOW))); + ProbeResult result = + ExternalWorkflowInvocationHandler.probe( + method, + () -> { + assertThrows( + IllegalStateException.class, + () -> + ExternalWorkflowInvocationHandler.probe( + method, () -> method.apply("nested"), WorkflowMethodType.WORKFLOW)); + method.apply("outer"); + }, + WorkflowMethodType.WORKFLOW); + assertArrayEquals(new Object[] {"outer"}, result.getArguments()); + assertThrows(IllegalStateException.class, () -> target.start("outside probe")); + verifyNoInteractions(outbound); + } + + @Test + public void isolatesProbeResultsAcrossThreads() throws Exception { + Target first = stub(Target.class, "first"); + Target second = stub(Target.class, "second"); + CyclicBarrier barrier = new CyclicBarrier(2); + ExecutorService executor = Executors.newFixedThreadPool(2); + try { + Future a = executor.submit(() -> parallelProbe(first::start, "a", barrier)); + Future b = executor.submit(() -> parallelProbe(second::start, "b", barrier)); + assertEquals("first:a", a.get(10, TimeUnit.SECONDS)); + assertEquals("second:b", b.get(10, TimeUnit.SECONDS)); + } finally { + executor.shutdownNow(); + } + verifyNoInteractions(outbound); + } + + private String parallelProbe( + Functions.Func1 method, String value, CyclicBarrier barrier) { + ProbeResult result = + ExternalWorkflowInvocationHandler.probe( + method, + () -> { + try { + barrier.await(5, TimeUnit.SECONDS); + } catch (Exception e) { + throw new RuntimeException(e); + } + method.apply(value); + }, + WorkflowMethodType.WORKFLOW); + return result.getStub().getExecution().getWorkflowId() + ":" + result.getArguments()[0]; + } +} diff --git a/temporal-serviceclient/build.gradle b/temporal-serviceclient/build.gradle index b698e1dbe6..0a5887a041 100644 --- a/temporal-serviceclient/build.gradle +++ b/temporal-serviceclient/build.gradle @@ -149,15 +149,19 @@ sourceSets { dependencies { payloadGeneratorsImplementation "com.google.protobuf:protobuf-java:$protoVersion" + testImplementation sourceSets.payloadGenerators.output } def generatedPayloadVisitorDir = layout.buildDirectory.dir('generated/payloadvisitor/java') +// Protobuf envelope roots are independent of workflow-facing generated bindings. +def systemNexusRoots = file('src/main/nexus/system-nexus-roots.txt') def generatePayloadVisitor = tasks.register('generatePayloadVisitor', JavaExec) { dependsOn 'compilePayloadGeneratorsJava', 'generateProto' classpath = sourceSets.payloadGenerators.runtimeClasspath mainClass = 'io.temporal.internal.payload.visitor.gen.PayloadVisitorGenerator' - args apiDescriptorSet.get().asFile.absolutePath, generatedPayloadVisitorDir.get().asFile.absolutePath + args apiDescriptorSet.get().asFile.absolutePath, generatedPayloadVisitorDir.get().asFile.absolutePath, systemNexusRoots.absolutePath + inputs.file(systemNexusRoots) inputs.file(apiDescriptorSet) inputs.files(sourceSets.payloadGenerators.runtimeClasspath) outputs.dir(generatedPayloadVisitorDir) diff --git a/temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/SystemNexusPayloads.java b/temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/SystemNexusPayloads.java new file mode 100644 index 0000000000..03eed8a3c6 --- /dev/null +++ b/temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/SystemNexusPayloads.java @@ -0,0 +1,49 @@ +package io.temporal.internal.payload.visitor; + +import com.google.protobuf.ByteString; +import com.google.protobuf.InvalidProtocolBufferException; +import com.google.protobuf.Message; +import io.temporal.api.common.v1.Payload; + +/** Fixed binary protobuf envelopes used by Temporal system Nexus operations. */ +public final class SystemNexusPayloads { + private static final String MARKER = "__temporal_system_payload"; + private static final ByteString TRUE = ByteString.copyFromUtf8("true"); + private static final ByteString ENCODING = ByteString.copyFromUtf8("binary/protobuf"); + + private SystemNexusPayloads() {} + + public static boolean isSystemPayload(Payload payload) { + return TRUE.equals(payload.getMetadataMap().get(MARKER)); + } + + public static Payload pack(Message message) { + return Payload.newBuilder() + .putMetadata(MARKER, TRUE) + .putMetadata("encoding", ENCODING) + .putMetadata( + "messageType", ByteString.copyFromUtf8(message.getDescriptorForType().getFullName())) + .setData(message.toByteString()) + .build(); + } + + public static Message.Builder unpack(Payload payload) { + // The marker controls generic visitation. Server responses use the same binary envelope + // without the marker and are decoded in the system operation's known converter scope. + if (!ENCODING.equals(payload.getMetadataMap().get("encoding"))) { + throw new VisitorException("Invalid Temporal system payload encoding"); + } + ByteString type = payload.getMetadataMap().get("messageType"); + String name = type == null ? "" : type.toStringUtf8(); + MessageRegistryEntry entry = GeneratedPayloadVisitor.SYSTEM_ROOTS.get(name); + if (entry == null) { + throw new VisitorException("Unknown Temporal system payload: " + name); + } + Message.Builder builder = entry.newBuilder.get(); + try { + return builder.mergeFrom(payload.getData()); + } catch (InvalidProtocolBufferException e) { + throw new VisitorException("Failed to unpack Temporal system payload: " + name, e); + } + } +} diff --git a/temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/Traversal.java b/temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/Traversal.java index ffbdd712ce..570d8bd7c0 100644 --- a/temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/Traversal.java +++ b/temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/Traversal.java @@ -82,7 +82,27 @@ void exit(Object previous) { /** Record a visit of a payload sequence (a {@code Payloads} or {@code repeated Payload}). */ void payloads(List batch, Consumer> writeBack) { + if (batch.stream().anyMatch(SystemNexusPayloads::isSystemPayload)) { + List result = new ArrayList<>(); + // Keep ordinary sequences batched: codecs may change their cardinality. + int start = 0; + for (int i = 0; i < batch.size(); i++) { + if (SystemNexusPayloads.isSystemPayload(batch.get(i))) { + if (start < i) { + payloads(batch.subList(start, i), result::addAll); + } + systemPayload(batch.get(i), result::add); + start = i + 1; + } + } + if (start < batch.size()) { + payloads(batch.subList(start, batch.size()), result::addAll); + } + deferWriteBack(() -> writeBack.accept(result)); + return; + } if (payloadVisitor == null) { + deferWriteBack(() -> writeBack.accept(batch)); return; } LeafJob job = new LeafJob(batch, currentContext, false); @@ -92,6 +112,10 @@ void payloads(List batch, Consumer> writeBack) { /** The visitor must return exactly one payload (checked in {@link #record}). */ void singlePayload(Payload value, Consumer writeBack) { + if (SystemNexusPayloads.isSystemPayload(value)) { + systemPayload(value, writeBack); + return; + } if (payloadVisitor == null) { return; } @@ -100,6 +124,13 @@ void singlePayload(Payload value, Consumer writeBack) { writeBacks.add(() -> writeBack.accept(job.result.get(0))); } + private void systemPayload(Payload value, Consumer writeBack) { + Message.Builder inner = SystemNexusPayloads.unpack(value); + dispatch(inner); + deferWriteBack( + () -> writeBack.accept(value.toBuilder().setData(inner.build().toByteString()).build())); + } + /** Applied after all visits, single-threaded, in walk order. */ void deferWriteBack(Runnable writeBack) { writeBacks.add(writeBack); diff --git a/temporal-serviceclient/src/main/nexus/system-nexus-roots.txt b/temporal-serviceclient/src/main/nexus/system-nexus-roots.txt new file mode 100644 index 0000000000..434e51e32a --- /dev/null +++ b/temporal-serviceclient/src/main/nexus/system-nexus-roots.txt @@ -0,0 +1,2 @@ +temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionRequest +temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionResponse diff --git a/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/gen/ProtoClosure.java b/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/gen/ProtoClosure.java index 9d71f8e16c..c7597fd6eb 100644 --- a/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/gen/ProtoClosure.java +++ b/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/gen/ProtoClosure.java @@ -48,7 +48,27 @@ public boolean reaches(Descriptor d) { /** Builds the closure and payload-reachability set from the given seed file descriptors. */ public static ProtoClosure of(List seeds) { + return of(seeds, java.util.Collections.emptyList()); + } + + /** + * Adds message roots and their reachable fields without requiring their files to be service + * seeds. + */ + public static ProtoClosure of(List seeds, List roots) { List all = collectMessages(fileClosure(seeds)); + Set seen = new HashSet<>(); + for (Descriptor descriptor : all) seen.add(descriptor.getFullName()); + Deque queue = new ArrayDeque<>(roots); + while (!queue.isEmpty()) { + Descriptor descriptor = queue.remove(); + if (!seen.add(descriptor.getFullName())) continue; + if (!descriptor.getOptions().getMapEntry()) all.add(descriptor); + for (FieldDescriptor field : descriptor.getFields()) { + if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) + queue.add(field.getMessageType()); + } + } return new ProtoClosure(all, computeReachability(all)); } diff --git a/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/visitor/gen/PayloadVisitorGenerator.java b/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/visitor/gen/PayloadVisitorGenerator.java index bbe19c1594..ecc57746ae 100644 --- a/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/visitor/gen/PayloadVisitorGenerator.java +++ b/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/visitor/gen/PayloadVisitorGenerator.java @@ -35,7 +35,8 @@ * into. Accessor names derived by {@link io.temporal.internal.payload.gen.ProtoNames} are therefore * checked by compiling the generated source rather than by reflection here. * - *

Usage: {@code PayloadVisitorGenerator }. + *

Usage: {@code PayloadVisitorGenerator + * [system-nexus-roots-file]}. */ public final class PayloadVisitorGenerator { @@ -85,31 +86,58 @@ static final class FieldPlan { public static void main(String[] args) throws Exception { if (args.length < 2) { throw new IllegalArgumentException( - "usage: PayloadVisitorGenerator "); + "usage: PayloadVisitorGenerator [system-nexus-roots-file]"); } - new PayloadVisitorGenerator().run(Paths.get(args[0]), Paths.get(args[1])); + new PayloadVisitorGenerator() + .run(Paths.get(args[0]), Paths.get(args[1]), args.length > 2 ? Paths.get(args[2]) : null); } private ProtoClosure closure; + private final java.util.Set systemRoots = new java.util.TreeSet<>(); void run(Path descriptorSetFile, Path outputRoot) throws IOException, DescriptorValidationException { + run(descriptorSetFile, outputRoot, null); + } + + void run(Path descriptorSetFile, Path outputRoot, Path systemRootsFile) + throws IOException, DescriptorValidationException { + systemRoots.clear(); Map files = ProtoDescriptorSets.load(descriptorSetFile); + if (systemRootsFile != null) { + for (String line : Files.readAllLines(systemRootsFile, StandardCharsets.UTF_8)) { + if (!line.trim().isEmpty()) systemRoots.add(line.trim()); + } + } List seeds = Arrays.asList( ProtoDescriptorSets.require(files, WORKFLOW_SERVICE_PROTO), ProtoDescriptorSets.require(files, OPERATOR_SERVICE_PROTO)); - this.closure = ProtoClosure.of(seeds); + Map messages = new TreeMap<>(); + for (FileDescriptor file : files.values()) { + for (Descriptor descriptor : file.getMessageTypes()) indexMessages(descriptor, messages); + } + List roots = new ArrayList<>(); + for (String name : systemRoots) { + Descriptor root = messages.get(name); + if (root == null) throw new IllegalStateException("Unknown system Nexus root: " + name); + roots.add(root); + } + this.closure = ProtoClosure.of(seeds, roots); // Deterministic output order, keyed by descriptor full name. Map emitted = new TreeMap<>(); for (Descriptor d : closure.allMessages) { - if (reaches(d)) { + if (reaches(d) || systemRoots.contains(d.getFullName())) { emitted.put(d.getFullName(), d); } } + for (String root : systemRoots) { + if (!emitted.containsKey(root)) + throw new IllegalStateException("Unknown system Nexus root: " + root); + } String source = emit(emitted); Path dir = outputRoot; @@ -122,6 +150,11 @@ void run(Path descriptorSetFile, Path outputRoot) System.out.println("PayloadVisitorGenerator: wrote " + emitted.size() + " visitors to " + out); } + private static void indexMessages(Descriptor descriptor, Map messages) { + messages.put(descriptor.getFullName(), descriptor); + for (Descriptor nested : descriptor.getNestedTypes()) indexMessages(nested, messages); + } + // --- Reachability + classification --- /** Whether {@code d} can transitively contain a payload; delegates to the shared closure. */ @@ -186,9 +219,22 @@ private String emit(Map emitted) { sb.append("final class ").append(OUTPUT_CLASS).append(" {\n"); sb.append(" private ").append(OUTPUT_CLASS).append("() {}\n\n"); + sb.append(" private static Map buildSystemRoots() {\n"); + sb.append(" Map m = new HashMap<>();\n"); + for (String root : systemRoots) { + sb.append(" m.put(\"") + .append(root) + .append("\", REGISTRY.get(\"") + .append(root) + .append("\"));\n"); + } + sb.append(" return m;\n }\n"); + List list = new ArrayList<>(emitted.values()); sb.append(" static final Map REGISTRY = buildRegistry();\n\n"); + sb.append( + " static final Map SYSTEM_ROOTS = buildSystemRoots();\n"); sb.append(" private static Map buildRegistry() {\n"); sb.append(" Map m = new HashMap<>(") .append(Math.max(16, list.size() * 2)) diff --git a/temporal-serviceclient/src/test/java/io/temporal/internal/payload/gen/ProtoClosureRootTest.java b/temporal-serviceclient/src/test/java/io/temporal/internal/payload/gen/ProtoClosureRootTest.java new file mode 100644 index 0000000000..f5913e59bf --- /dev/null +++ b/temporal-serviceclient/src/test/java/io/temporal/internal/payload/gen/ProtoClosureRootTest.java @@ -0,0 +1,54 @@ +package io.temporal.internal.payload.gen; + +import static org.junit.Assert.*; + +import com.google.protobuf.DescriptorProtos.*; +import com.google.protobuf.Descriptors.*; +import io.temporal.api.common.v1.Payload; +import java.util.Arrays; +import java.util.Collections; +import org.junit.Test; + +public class ProtoClosureRootTest { + @Test + public void explicitRootsDiscoverTheirChildrenWithoutServiceSeeds() throws Exception { + String payloadFile = Payload.getDescriptor().getFile().getName(); + FileDescriptor file = + FileDescriptor.buildFrom( + FileDescriptorProto.newBuilder() + .setName("explicit-roots.proto") + .setPackage("temporal.api.test.v1") + .setSyntax("proto3") + .addDependency(payloadFile) + .addMessageType(DescriptorProto.newBuilder().setName("EmptyResponse")) + .addMessageType( + DescriptorProto.newBuilder() + .setName("Request") + .addField( + FieldDescriptorProto.newBuilder() + .setName("child") + .setNumber(1) + .setType(FieldDescriptorProto.Type.TYPE_MESSAGE) + .setTypeName(".temporal.api.test.v1.Child"))) + .addMessageType( + DescriptorProto.newBuilder() + .setName("Child") + .addField( + FieldDescriptorProto.newBuilder() + .setName("payload") + .setNumber(1) + .setType(FieldDescriptorProto.Type.TYPE_MESSAGE) + .setTypeName(".temporal.api.common.v1.Payload"))) + .build(), + new FileDescriptor[] {Payload.getDescriptor().getFile()}); + Descriptor request = file.findMessageTypeByName("Request"); + Descriptor empty = file.findMessageTypeByName("EmptyResponse"); + Descriptor child = file.findMessageTypeByName("Child"); + ProtoClosure closure = ProtoClosure.of(Collections.emptyList(), Arrays.asList(request, empty)); + assertTrue(closure.allMessages.contains(empty)); + assertTrue(closure.allMessages.contains(child)); + assertTrue(closure.reaches(request)); + assertTrue(closure.reaches(child)); + assertFalse(closure.reaches(empty)); + } +} diff --git a/temporal-serviceclient/src/test/java/io/temporal/internal/payload/visitor/SystemNexusPayloadTest.java b/temporal-serviceclient/src/test/java/io/temporal/internal/payload/visitor/SystemNexusPayloadTest.java new file mode 100644 index 0000000000..501ebdaefc --- /dev/null +++ b/temporal-serviceclient/src/test/java/io/temporal/internal/payload/visitor/SystemNexusPayloadTest.java @@ -0,0 +1,133 @@ +package io.temporal.internal.payload.visitor; + +import static org.junit.Assert.*; + +import com.google.protobuf.ByteString; +import io.temporal.api.common.v1.Payload; +import io.temporal.api.common.v1.Payloads; +import io.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionRequest; +import io.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionResponse; +import java.util.Arrays; +import java.util.Collections; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import org.junit.Test; + +public class SystemNexusPayloadTest { + private static Payload payload(String value) { + return Payload.newBuilder().setData(ByteString.copyFromUtf8(value)).build(); + } + + @Test + public void visitsNestedSequencesBeforeRepacking() throws Exception { + SignalWithStartWorkflowExecutionRequest request = + SignalWithStartWorkflowExecutionRequest.newBuilder() + .setInput(Payloads.newBuilder().addPayloads(payload("workflow"))) + .setSignalInput(Payloads.newBuilder().addPayloads(payload("signal"))) + .build(); + CompletableFuture> workflow = new CompletableFuture<>(); + Payloads outer = Payloads.newBuilder().addPayloads(SystemNexusPayloads.pack(request)).build(); + CompletableFuture result = + PayloadVisitors.visit( + outer, + PayloadVisitorOptions.newBuilder( + (context, values) -> { + if (values.get(0).getData().toStringUtf8().equals("workflow")) { + return workflow; + } + return CompletableFuture.completedFuture( + Collections.singletonList(payload("SIGNAL"))); + }) + .build()); + assertFalse(result.isDone()); + workflow.complete(Arrays.asList(payload("ONE"), payload("TWO"))); + SignalWithStartWorkflowExecutionRequest decoded = + SignalWithStartWorkflowExecutionRequest.parseFrom(result.join().getPayloads(0).getData()); + assertEquals(2, decoded.getInput().getPayloadsCount()); + assertEquals("SIGNAL", decoded.getSignalInput().getPayloads(0).getData().toStringUtf8()); + assertEquals( + outer.getPayloads(0).getMetadataMap(), result.join().getPayloads(0).getMetadataMap()); + } + + @Test + public void handlesPayloadFreeResponses() { + Payload response = + SystemNexusPayloads.pack( + SignalWithStartWorkflowExecutionResponse.newBuilder().setRunId("run").build()); + Payloads outer = Payloads.newBuilder().addPayloads(response).build(); + assertEquals( + outer, + PayloadVisitors.visit( + outer, + PayloadVisitorOptions.newBuilder( + (context, values) -> { + throw new AssertionError("Outer envelope was visited"); + }) + .build()) + .join()); + } + + @Test + public void preservesMixedSequencesAndMessageOnlyTraversal() { + SignalWithStartWorkflowExecutionRequest request = + SignalWithStartWorkflowExecutionRequest.newBuilder() + .setInput(Payloads.newBuilder().addPayloads(payload("nested"))) + .build(); + Payload marked = SystemNexusPayloads.pack(request); + Payloads outer = + Payloads.newBuilder() + .addPayloads(payload("before")) + .addPayloads(marked) + .addPayloads(payload("after")) + .build(); + Payloads visited = + PayloadVisitors.visit( + outer, + PayloadVisitorOptions.newBuilder( + (context, values) -> + CompletableFuture.completedFuture( + Arrays.asList(values.get(0), values.get(0)))) + .build()) + .join(); + assertEquals(5, visited.getPayloadsCount()); + assertEquals(payload("before"), visited.getPayloads(0)); + assertEquals(payload("after"), visited.getPayloads(4)); + assertEquals( + 2, + ((SignalWithStartWorkflowExecutionRequest) + SystemNexusPayloads.unpack(visited.getPayloads(2)).build()) + .getInput() + .getPayloadsCount()); + assertEquals( + outer, + MessageVisitors.visit( + outer, MessageVisitorOptions.newBuilder((context, message) -> context).build())); + } + + @Test + public void rejectsUnknownAndMalformedMarkedPayloads() { + Payload unknown = + SystemNexusPayloads.pack(SignalWithStartWorkflowExecutionRequest.getDefaultInstance()) + .toBuilder() + .putMetadata("messageType", ByteString.copyFromUtf8("unknown.Message")) + .build(); + Payload malformed = + SystemNexusPayloads.pack(SignalWithStartWorkflowExecutionRequest.getDefaultInstance()) + .toBuilder() + .setData(ByteString.copyFrom(new byte[] {(byte) 0xff})) + .build(); + for (Payload value : Arrays.asList(unknown, malformed)) { + CompletionException error = + assertThrows( + CompletionException.class, + () -> + PayloadVisitors.visit( + Payloads.newBuilder().addPayloads(value).build(), + PayloadVisitorOptions.newBuilder( + (context, values) -> CompletableFuture.completedFuture(values)) + .build()) + .join()); + assertTrue(error.getCause() instanceof VisitorException); + } + } +} From 873bd0f4bfa65377071f3f943e392ea88d8e43d1 Mon Sep 17 00:00:00 2001 From: Tim Conley Date: Mon, 16 Nov 2026 10:34:30 -0800 Subject: [PATCH 2/5] Limit prerequisites to method capture and converter scoping Keep envelope handling, payload traversal, and operation-root metadata in the workflow API integration. Test the converter scope directly without generated models or operation metadata. --- CHANGELOG.md | 4 +- .../system/SystemNexusConverterContext.java | 37 ++++ .../system/SystemNexusDataConverter.java | 106 ----------- .../SystemNexusConverterContextTest.java | 76 ++++++++ .../system/SystemNexusDataConverterTest.java | 173 ------------------ temporal-serviceclient/build.gradle | 6 +- .../payload/visitor/SystemNexusPayloads.java | 49 ----- .../internal/payload/visitor/Traversal.java | 31 ---- .../src/main/nexus/system-nexus-roots.txt | 2 - .../internal/payload/gen/ProtoClosure.java | 20 -- .../visitor/gen/PayloadVisitorGenerator.java | 56 +----- .../payload/gen/ProtoClosureRootTest.java | 54 ------ .../visitor/SystemNexusPayloadTest.java | 133 -------------- 13 files changed, 121 insertions(+), 626 deletions(-) create mode 100644 temporal-sdk/src/main/java/io/temporal/internal/nexus/system/SystemNexusConverterContext.java delete mode 100644 temporal-sdk/src/main/java/io/temporal/internal/nexus/system/SystemNexusDataConverter.java create mode 100644 temporal-sdk/src/test/java/io/temporal/internal/nexus/system/SystemNexusConverterContextTest.java delete mode 100644 temporal-sdk/src/test/java/io/temporal/internal/nexus/system/SystemNexusDataConverterTest.java delete mode 100644 temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/SystemNexusPayloads.java delete mode 100644 temporal-serviceclient/src/main/nexus/system-nexus-roots.txt delete mode 100644 temporal-serviceclient/src/test/java/io/temporal/internal/payload/gen/ProtoClosureRootTest.java delete mode 100644 temporal-serviceclient/src/test/java/io/temporal/internal/payload/visitor/SystemNexusPayloadTest.java diff --git a/CHANGELOG.md b/CHANGELOG.md index 785cf05e51..a5050eee43 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,8 +22,8 @@ to docs, or any other relevant information. ### Changed - Updated Cloud API bindings to v0.27.0, including opt-in user group memberships, projects, project-scoped custom roles, and caller rate limits. -- Add internal System Nexus envelope conversion, payload traversal, and external workflow method - capture support for generated workflow APIs. +- Add internal converter scoping and external workflow method capture support for generated + workflow APIs. ## [1.41.1] - 2026-11-16 diff --git a/temporal-sdk/src/main/java/io/temporal/internal/nexus/system/SystemNexusConverterContext.java b/temporal-sdk/src/main/java/io/temporal/internal/nexus/system/SystemNexusConverterContext.java new file mode 100644 index 0000000000..0f85629c1d --- /dev/null +++ b/temporal-sdk/src/main/java/io/temporal/internal/nexus/system/SystemNexusConverterContext.java @@ -0,0 +1,37 @@ +package io.temporal.internal.nexus.system; + +import io.temporal.common.converter.DataConverter; +import java.util.Objects; +import java.util.function.Supplier; + +/** Scopes user-value conversion independently of generated bindings and system envelopes. */ +public final class SystemNexusConverterContext { + private static final ThreadLocal USER_CONVERTER = new ThreadLocal<>(); + + private SystemNexusConverterContext() {} + + /** Returns the user converter active in the current synchronous transfer conversion scope. */ + public static DataConverter currentDataConverter() { + DataConverter converter = USER_CONVERTER.get(); + if (converter == null) { + throw new IllegalStateException("System Nexus user converter context is not active"); + } + return converter; + } + + /** Runs a synchronous conversion with the user converter and restores any enclosing scope. */ + public static T withDataConverter(DataConverter converter, Supplier action) { + Objects.requireNonNull(converter, "converter"); + DataConverter previous = USER_CONVERTER.get(); + USER_CONVERTER.set(converter); + try { + return action.get(); + } finally { + if (previous == null) { + USER_CONVERTER.remove(); + } else { + USER_CONVERTER.set(previous); + } + } + } +} diff --git a/temporal-sdk/src/main/java/io/temporal/internal/nexus/system/SystemNexusDataConverter.java b/temporal-sdk/src/main/java/io/temporal/internal/nexus/system/SystemNexusDataConverter.java deleted file mode 100644 index 984310bf81..0000000000 --- a/temporal-sdk/src/main/java/io/temporal/internal/nexus/system/SystemNexusDataConverter.java +++ /dev/null @@ -1,106 +0,0 @@ -package io.temporal.internal.nexus.system; - -import com.google.protobuf.Message; -import io.temporal.api.common.v1.Payload; -import io.temporal.api.common.v1.Payloads; -import io.temporal.api.failure.v1.Failure; -import io.temporal.common.converter.DataConverter; -import io.temporal.common.converter.DataConverterException; -import io.temporal.common.converter.RawValue; -import io.temporal.internal.common.converter.TemporalTransferTypeDataConverter; -import io.temporal.internal.payload.visitor.SystemNexusPayloads; -import java.lang.reflect.Type; -import java.util.Objects; -import java.util.Optional; -import java.util.function.Supplier; -import javax.annotation.Nonnull; - -/** Keeps the server-readable envelope separate from the destination workflow's user converter. */ -public final class SystemNexusDataConverter implements DataConverter { - public static final String ENDPOINT = "__temporal_system"; - private static final ThreadLocal USER_CONVERTER = new ThreadLocal<>(); - private final DataConverter userConverter; - - /** Returns the user converter active in the current synchronous transfer conversion scope. */ - public static DataConverter currentDataConverter() { - DataConverter converter = USER_CONVERTER.get(); - if (converter == null) - throw new IllegalStateException("System Nexus user converter context is not active"); - return converter; - } - - static T withDataConverter(DataConverter converter, Supplier action) { - Objects.requireNonNull(converter, "converter"); - DataConverter previous = USER_CONVERTER.get(); - USER_CONVERTER.set(converter); - try { - return action.get(); - } finally { - if (previous == null) USER_CONVERTER.remove(); - else USER_CONVERTER.set(previous); - } - } - - public SystemNexusDataConverter(DataConverter userConverter) { - this.userConverter = Objects.requireNonNull(userConverter, "userConverter"); - } - - @Override - public Optional toPayload(T value) { - if (value instanceof RawValue) return Optional.of(((RawValue) value).getPayload()); - return withDataConverter( - userConverter, - () -> { - Object transferred = TemporalTransferTypeDataConverter.toTransferValue(value); - if (!(transferred instanceof Message)) - throw new DataConverterException( - "System Nexus inputs must have a protobuf transfer type"); - return Optional.of(SystemNexusPayloads.pack((Message) transferred)); - }); - } - - @Override - public T fromPayload(Payload payload, Class valueClass, Type valueType) { - if (valueClass == RawValue.class) return valueClass.cast(new RawValue(payload)); - return withDataConverter( - userConverter, - () -> { - Message value = SystemNexusPayloads.unpack(payload).build(); - TemporalTransferTypeDataConverter.TransferType transfer = - TemporalTransferTypeDataConverter.transferTypeFor(valueClass, valueType); - if (transfer == null) return valueClass.cast(value); - if (!transfer.getRawType().isInstance(value)) - throw new DataConverterException( - "Unexpected system Nexus response type: " - + value.getDescriptorForType().getFullName()); - return transfer.fromValue(value, valueClass); - }); - } - - @Override - public Optional toPayloads(Object... values) { - if (values == null || values.length == 0) return Optional.empty(); - Payloads.Builder result = Payloads.newBuilder(); - for (Object value : values) result.addPayloads(toPayload(value).get()); - return Optional.of(result.build()); - } - - @Override - public T fromPayloads( - int index, Optional values, Class valueClass, Type valueType) { - if (!values.isPresent() || index >= values.get().getPayloadsCount()) return null; - return fromPayload(values.get().getPayloads(index), valueClass, valueType); - } - - @Nonnull - @Override - public RuntimeException failureToException(@Nonnull Failure failure) { - return userConverter.failureToException(failure); - } - - @Nonnull - @Override - public Failure exceptionToFailure(@Nonnull Throwable failure) { - return userConverter.exceptionToFailure(failure); - } -} diff --git a/temporal-sdk/src/test/java/io/temporal/internal/nexus/system/SystemNexusConverterContextTest.java b/temporal-sdk/src/test/java/io/temporal/internal/nexus/system/SystemNexusConverterContextTest.java new file mode 100644 index 0000000000..f9f598fe40 --- /dev/null +++ b/temporal-sdk/src/test/java/io/temporal/internal/nexus/system/SystemNexusConverterContextTest.java @@ -0,0 +1,76 @@ +package io.temporal.internal.nexus.system; + +import static org.junit.Assert.*; + +import io.temporal.common.converter.CodecDataConverter; +import io.temporal.common.converter.DataConverter; +import io.temporal.common.converter.DefaultDataConverter; +import java.util.Collections; +import java.util.concurrent.*; +import org.junit.Test; + +public class SystemNexusConverterContextTest { + @Test + public void restoresNestedScopesAfterSuccessAndFailure() { + DataConverter outer = DefaultDataConverter.STANDARD_INSTANCE; + DataConverter inner = new CodecDataConverter(outer, Collections.emptyList()); + SystemNexusConverterContext.withDataConverter( + outer, + () -> { + assertSame(outer, SystemNexusConverterContext.currentDataConverter()); + assertSame( + inner, + SystemNexusConverterContext.withDataConverter( + inner, SystemNexusConverterContext::currentDataConverter)); + assertSame(outer, SystemNexusConverterContext.currentDataConverter()); + assertThrows( + IllegalArgumentException.class, + () -> + SystemNexusConverterContext.withDataConverter( + inner, + () -> { + throw new IllegalArgumentException("failure"); + })); + assertSame(outer, SystemNexusConverterContext.currentDataConverter()); + return null; + }); + assertThrows(IllegalStateException.class, SystemNexusConverterContext::currentDataConverter); + assertThrows( + NullPointerException.class, + () -> SystemNexusConverterContext.withDataConverter(null, () -> null)); + assertThrows(IllegalStateException.class, SystemNexusConverterContext::currentDataConverter); + } + + @Test + public void isolatesConcurrentConversionScopes() throws Exception { + DataConverter first = DefaultDataConverter.STANDARD_INSTANCE; + DataConverter second = new CodecDataConverter(first, Collections.emptyList()); + CyclicBarrier barrier = new CyclicBarrier(2); + ExecutorService executor = Executors.newFixedThreadPool(2); + try { + Future a = executor.submit(() -> scopedConverter(first, barrier)); + Future b = executor.submit(() -> scopedConverter(second, barrier)); + assertSame(first, a.get(10, TimeUnit.SECONDS)); + assertSame(second, b.get(10, TimeUnit.SECONDS)); + } finally { + executor.shutdownNow(); + } + assertThrows(IllegalStateException.class, SystemNexusConverterContext::currentDataConverter); + } + + private DataConverter scopedConverter(DataConverter converter, CyclicBarrier barrier) { + DataConverter result = + SystemNexusConverterContext.withDataConverter( + converter, + () -> { + try { + barrier.await(5, TimeUnit.SECONDS); + } catch (Exception e) { + throw new RuntimeException(e); + } + return SystemNexusConverterContext.currentDataConverter(); + }); + assertThrows(IllegalStateException.class, SystemNexusConverterContext::currentDataConverter); + return result; + } +} diff --git a/temporal-sdk/src/test/java/io/temporal/internal/nexus/system/SystemNexusDataConverterTest.java b/temporal-sdk/src/test/java/io/temporal/internal/nexus/system/SystemNexusDataConverterTest.java deleted file mode 100644 index 0da2195e43..0000000000 --- a/temporal-sdk/src/test/java/io/temporal/internal/nexus/system/SystemNexusDataConverterTest.java +++ /dev/null @@ -1,173 +0,0 @@ -package io.temporal.internal.nexus.system; - -import static org.junit.Assert.*; - -import com.google.protobuf.ByteString; -import io.temporal.api.common.v1.Payload; -import io.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionRequest; -import io.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionResponse; -import io.temporal.common.converter.*; -import io.temporal.internal.payload.visitor.SystemNexusPayloads; -import io.temporal.payload.codec.PayloadCodec; -import io.temporal.payload.context.SerializationContext; -import io.temporal.payload.context.WorkflowSerializationContext; -import java.lang.reflect.Type; -import java.util.Collections; -import java.util.List; -import java.util.stream.Collectors; -import org.junit.Test; - -public class SystemNexusDataConverterTest { - @Test - public void scopesUserConversionAndKeepsTheOuterEnvelopeReadable() throws Exception { - DataConverter user = - new CodecDataConverter( - DefaultDataConverter.STANDARD_INSTANCE, Collections.singletonList(new TaggingCodec())); - SystemNexusDataConverter converter = - new SystemNexusDataConverter( - user.withContext(new WorkflowSerializationContext("destination", "target"))); - Payload encoded = converter.toPayload(new Envelope("value")).get(); - assertTrue(SystemNexusPayloads.isSystemPayload(encoded)); - assertFalse(encoded.containsMetadata("test-codec")); - SignalWithStartWorkflowExecutionRequest wire = - SignalWithStartWorkflowExecutionRequest.parseFrom(encoded.getData()); - assertTrue(wire.getInput().getPayloads(0).containsMetadata("test-codec")); - assertEquals( - "destination/target", - wire.getInput().getPayloads(0).getMetadataOrThrow("test-codec").toStringUtf8()); - assertEquals("value", converter.fromPayload(encoded, Envelope.class, Envelope.class).value); - assertThrows(IllegalStateException.class, SystemNexusDataConverter::currentDataConverter); - } - - @Test - public void acceptsUnmarkedServerResponsesAndRawValues() { - SystemNexusDataConverter converter = - new SystemNexusDataConverter(DefaultDataConverter.STANDARD_INSTANCE); - Payload response = - SystemNexusPayloads.pack( - SignalWithStartWorkflowExecutionResponse.newBuilder().setRunId("run").build()) - .toBuilder() - .removeMetadata("__temporal_system_payload") - .build(); - assertEquals( - "run", - converter - .fromPayload( - response, - SignalWithStartWorkflowExecutionResponse.class, - SignalWithStartWorkflowExecutionResponse.class) - .getRunId()); - assertSame(response, converter.toPayload(new RawValue(response)).get()); - assertSame( - response, converter.fromPayload(response, RawValue.class, RawValue.class).getPayload()); - assertThrows( - DataConverterException.class, - () -> converter.fromPayload(response, Envelope.class, Envelope.class)); - assertThrows(DataConverterException.class, () -> converter.toPayload("not a transfer model")); - assertThrows(IllegalStateException.class, SystemNexusDataConverter::currentDataConverter); - } - - @Test - public void restoresNestedScopesAfterSuccessAndFailure() { - DataConverter outer = DefaultDataConverter.STANDARD_INSTANCE; - DataConverter inner = - new CodecDataConverter(outer, Collections.singletonList(new TaggingCodec())); - SystemNexusDataConverter.withDataConverter( - outer, - () -> { - assertSame(outer, SystemNexusDataConverter.currentDataConverter()); - assertSame( - inner, - SystemNexusDataConverter.withDataConverter( - inner, SystemNexusDataConverter::currentDataConverter)); - assertSame(outer, SystemNexusDataConverter.currentDataConverter()); - assertThrows( - IllegalArgumentException.class, - () -> - SystemNexusDataConverter.withDataConverter( - inner, - () -> { - throw new IllegalArgumentException("failure"); - })); - assertSame(outer, SystemNexusDataConverter.currentDataConverter()); - return null; - }); - assertThrows(IllegalStateException.class, SystemNexusDataConverter::currentDataConverter); - } - - // A handwritten transfer fixture, independent of nexgen or workflow-facing generated bindings. - @TransferTypeConvertible(Envelope.Converter.class) - public static final class Envelope { - final String value; - - Envelope(String value) { - this.value = value; - } - - public static final class Converter implements TransferTypeConverter { - @Override - public Type getTransferType(Type valueType) { - return SignalWithStartWorkflowExecutionRequest.class; - } - - @Override - public Object toTransferType(Envelope value) { - return SignalWithStartWorkflowExecutionRequest.newBuilder() - .setInput(SystemNexusDataConverter.currentDataConverter().toPayloads(value.value).get()) - .build(); - } - - @Override - public Envelope fromTransferType(Object value, Type valueType) { - SignalWithStartWorkflowExecutionRequest wire = - (SignalWithStartWorkflowExecutionRequest) value; - return new Envelope( - SystemNexusDataConverter.currentDataConverter() - .fromPayload(wire.getInput().getPayloads(0), String.class, String.class)); - } - } - } - - private static final class TaggingCodec implements PayloadCodec { - private final String destination; - - TaggingCodec() { - this("unscoped"); - } - - private TaggingCodec(String destination) { - this.destination = destination; - } - - @Override - public PayloadCodec withContext(SerializationContext context) { - WorkflowSerializationContext workflow = (WorkflowSerializationContext) context; - return new TaggingCodec(workflow.getNamespace() + "/" + workflow.getWorkflowId()); - } - - @Override - public List encode(List payloads) { - return payloads.stream() - .map( - payload -> { - assertFalse(SystemNexusPayloads.isSystemPayload(payload)); - return payload.toBuilder() - .putMetadata("test-codec", ByteString.copyFromUtf8(destination)) - .build(); - }) - .collect(Collectors.toList()); - } - - @Override - public List decode(List payloads) { - return payloads.stream() - .map( - payload -> { - assertTrue(payload.containsMetadata("test-codec")); - assertEquals(destination, payload.getMetadataOrThrow("test-codec").toStringUtf8()); - return payload.toBuilder().removeMetadata("test-codec").build(); - }) - .collect(Collectors.toList()); - } - } -} diff --git a/temporal-serviceclient/build.gradle b/temporal-serviceclient/build.gradle index 0a5887a041..b698e1dbe6 100644 --- a/temporal-serviceclient/build.gradle +++ b/temporal-serviceclient/build.gradle @@ -149,19 +149,15 @@ sourceSets { dependencies { payloadGeneratorsImplementation "com.google.protobuf:protobuf-java:$protoVersion" - testImplementation sourceSets.payloadGenerators.output } def generatedPayloadVisitorDir = layout.buildDirectory.dir('generated/payloadvisitor/java') -// Protobuf envelope roots are independent of workflow-facing generated bindings. -def systemNexusRoots = file('src/main/nexus/system-nexus-roots.txt') def generatePayloadVisitor = tasks.register('generatePayloadVisitor', JavaExec) { dependsOn 'compilePayloadGeneratorsJava', 'generateProto' classpath = sourceSets.payloadGenerators.runtimeClasspath mainClass = 'io.temporal.internal.payload.visitor.gen.PayloadVisitorGenerator' - args apiDescriptorSet.get().asFile.absolutePath, generatedPayloadVisitorDir.get().asFile.absolutePath, systemNexusRoots.absolutePath - inputs.file(systemNexusRoots) + args apiDescriptorSet.get().asFile.absolutePath, generatedPayloadVisitorDir.get().asFile.absolutePath inputs.file(apiDescriptorSet) inputs.files(sourceSets.payloadGenerators.runtimeClasspath) outputs.dir(generatedPayloadVisitorDir) diff --git a/temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/SystemNexusPayloads.java b/temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/SystemNexusPayloads.java deleted file mode 100644 index 03eed8a3c6..0000000000 --- a/temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/SystemNexusPayloads.java +++ /dev/null @@ -1,49 +0,0 @@ -package io.temporal.internal.payload.visitor; - -import com.google.protobuf.ByteString; -import com.google.protobuf.InvalidProtocolBufferException; -import com.google.protobuf.Message; -import io.temporal.api.common.v1.Payload; - -/** Fixed binary protobuf envelopes used by Temporal system Nexus operations. */ -public final class SystemNexusPayloads { - private static final String MARKER = "__temporal_system_payload"; - private static final ByteString TRUE = ByteString.copyFromUtf8("true"); - private static final ByteString ENCODING = ByteString.copyFromUtf8("binary/protobuf"); - - private SystemNexusPayloads() {} - - public static boolean isSystemPayload(Payload payload) { - return TRUE.equals(payload.getMetadataMap().get(MARKER)); - } - - public static Payload pack(Message message) { - return Payload.newBuilder() - .putMetadata(MARKER, TRUE) - .putMetadata("encoding", ENCODING) - .putMetadata( - "messageType", ByteString.copyFromUtf8(message.getDescriptorForType().getFullName())) - .setData(message.toByteString()) - .build(); - } - - public static Message.Builder unpack(Payload payload) { - // The marker controls generic visitation. Server responses use the same binary envelope - // without the marker and are decoded in the system operation's known converter scope. - if (!ENCODING.equals(payload.getMetadataMap().get("encoding"))) { - throw new VisitorException("Invalid Temporal system payload encoding"); - } - ByteString type = payload.getMetadataMap().get("messageType"); - String name = type == null ? "" : type.toStringUtf8(); - MessageRegistryEntry entry = GeneratedPayloadVisitor.SYSTEM_ROOTS.get(name); - if (entry == null) { - throw new VisitorException("Unknown Temporal system payload: " + name); - } - Message.Builder builder = entry.newBuilder.get(); - try { - return builder.mergeFrom(payload.getData()); - } catch (InvalidProtocolBufferException e) { - throw new VisitorException("Failed to unpack Temporal system payload: " + name, e); - } - } -} diff --git a/temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/Traversal.java b/temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/Traversal.java index 570d8bd7c0..ffbdd712ce 100644 --- a/temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/Traversal.java +++ b/temporal-serviceclient/src/main/java/io/temporal/internal/payload/visitor/Traversal.java @@ -82,27 +82,7 @@ void exit(Object previous) { /** Record a visit of a payload sequence (a {@code Payloads} or {@code repeated Payload}). */ void payloads(List batch, Consumer> writeBack) { - if (batch.stream().anyMatch(SystemNexusPayloads::isSystemPayload)) { - List result = new ArrayList<>(); - // Keep ordinary sequences batched: codecs may change their cardinality. - int start = 0; - for (int i = 0; i < batch.size(); i++) { - if (SystemNexusPayloads.isSystemPayload(batch.get(i))) { - if (start < i) { - payloads(batch.subList(start, i), result::addAll); - } - systemPayload(batch.get(i), result::add); - start = i + 1; - } - } - if (start < batch.size()) { - payloads(batch.subList(start, batch.size()), result::addAll); - } - deferWriteBack(() -> writeBack.accept(result)); - return; - } if (payloadVisitor == null) { - deferWriteBack(() -> writeBack.accept(batch)); return; } LeafJob job = new LeafJob(batch, currentContext, false); @@ -112,10 +92,6 @@ void payloads(List batch, Consumer> writeBack) { /** The visitor must return exactly one payload (checked in {@link #record}). */ void singlePayload(Payload value, Consumer writeBack) { - if (SystemNexusPayloads.isSystemPayload(value)) { - systemPayload(value, writeBack); - return; - } if (payloadVisitor == null) { return; } @@ -124,13 +100,6 @@ void singlePayload(Payload value, Consumer writeBack) { writeBacks.add(() -> writeBack.accept(job.result.get(0))); } - private void systemPayload(Payload value, Consumer writeBack) { - Message.Builder inner = SystemNexusPayloads.unpack(value); - dispatch(inner); - deferWriteBack( - () -> writeBack.accept(value.toBuilder().setData(inner.build().toByteString()).build())); - } - /** Applied after all visits, single-threaded, in walk order. */ void deferWriteBack(Runnable writeBack) { writeBacks.add(writeBack); diff --git a/temporal-serviceclient/src/main/nexus/system-nexus-roots.txt b/temporal-serviceclient/src/main/nexus/system-nexus-roots.txt deleted file mode 100644 index 434e51e32a..0000000000 --- a/temporal-serviceclient/src/main/nexus/system-nexus-roots.txt +++ /dev/null @@ -1,2 +0,0 @@ -temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionRequest -temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionResponse diff --git a/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/gen/ProtoClosure.java b/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/gen/ProtoClosure.java index c7597fd6eb..9d71f8e16c 100644 --- a/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/gen/ProtoClosure.java +++ b/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/gen/ProtoClosure.java @@ -48,27 +48,7 @@ public boolean reaches(Descriptor d) { /** Builds the closure and payload-reachability set from the given seed file descriptors. */ public static ProtoClosure of(List seeds) { - return of(seeds, java.util.Collections.emptyList()); - } - - /** - * Adds message roots and their reachable fields without requiring their files to be service - * seeds. - */ - public static ProtoClosure of(List seeds, List roots) { List all = collectMessages(fileClosure(seeds)); - Set seen = new HashSet<>(); - for (Descriptor descriptor : all) seen.add(descriptor.getFullName()); - Deque queue = new ArrayDeque<>(roots); - while (!queue.isEmpty()) { - Descriptor descriptor = queue.remove(); - if (!seen.add(descriptor.getFullName())) continue; - if (!descriptor.getOptions().getMapEntry()) all.add(descriptor); - for (FieldDescriptor field : descriptor.getFields()) { - if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) - queue.add(field.getMessageType()); - } - } return new ProtoClosure(all, computeReachability(all)); } diff --git a/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/visitor/gen/PayloadVisitorGenerator.java b/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/visitor/gen/PayloadVisitorGenerator.java index ecc57746ae..bbe19c1594 100644 --- a/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/visitor/gen/PayloadVisitorGenerator.java +++ b/temporal-serviceclient/src/payloadGenerators/java/io/temporal/internal/payload/visitor/gen/PayloadVisitorGenerator.java @@ -35,8 +35,7 @@ * into. Accessor names derived by {@link io.temporal.internal.payload.gen.ProtoNames} are therefore * checked by compiling the generated source rather than by reflection here. * - *

Usage: {@code PayloadVisitorGenerator - * [system-nexus-roots-file]}. + *

Usage: {@code PayloadVisitorGenerator }. */ public final class PayloadVisitorGenerator { @@ -86,58 +85,31 @@ static final class FieldPlan { public static void main(String[] args) throws Exception { if (args.length < 2) { throw new IllegalArgumentException( - "usage: PayloadVisitorGenerator [system-nexus-roots-file]"); + "usage: PayloadVisitorGenerator "); } - new PayloadVisitorGenerator() - .run(Paths.get(args[0]), Paths.get(args[1]), args.length > 2 ? Paths.get(args[2]) : null); + new PayloadVisitorGenerator().run(Paths.get(args[0]), Paths.get(args[1])); } private ProtoClosure closure; - private final java.util.Set systemRoots = new java.util.TreeSet<>(); void run(Path descriptorSetFile, Path outputRoot) throws IOException, DescriptorValidationException { - run(descriptorSetFile, outputRoot, null); - } - - void run(Path descriptorSetFile, Path outputRoot, Path systemRootsFile) - throws IOException, DescriptorValidationException { - systemRoots.clear(); Map files = ProtoDescriptorSets.load(descriptorSetFile); - if (systemRootsFile != null) { - for (String line : Files.readAllLines(systemRootsFile, StandardCharsets.UTF_8)) { - if (!line.trim().isEmpty()) systemRoots.add(line.trim()); - } - } List seeds = Arrays.asList( ProtoDescriptorSets.require(files, WORKFLOW_SERVICE_PROTO), ProtoDescriptorSets.require(files, OPERATOR_SERVICE_PROTO)); - Map messages = new TreeMap<>(); - for (FileDescriptor file : files.values()) { - for (Descriptor descriptor : file.getMessageTypes()) indexMessages(descriptor, messages); - } - List roots = new ArrayList<>(); - for (String name : systemRoots) { - Descriptor root = messages.get(name); - if (root == null) throw new IllegalStateException("Unknown system Nexus root: " + name); - roots.add(root); - } - this.closure = ProtoClosure.of(seeds, roots); + this.closure = ProtoClosure.of(seeds); // Deterministic output order, keyed by descriptor full name. Map emitted = new TreeMap<>(); for (Descriptor d : closure.allMessages) { - if (reaches(d) || systemRoots.contains(d.getFullName())) { + if (reaches(d)) { emitted.put(d.getFullName(), d); } } - for (String root : systemRoots) { - if (!emitted.containsKey(root)) - throw new IllegalStateException("Unknown system Nexus root: " + root); - } String source = emit(emitted); Path dir = outputRoot; @@ -150,11 +122,6 @@ void run(Path descriptorSetFile, Path outputRoot, Path systemRootsFile) System.out.println("PayloadVisitorGenerator: wrote " + emitted.size() + " visitors to " + out); } - private static void indexMessages(Descriptor descriptor, Map messages) { - messages.put(descriptor.getFullName(), descriptor); - for (Descriptor nested : descriptor.getNestedTypes()) indexMessages(nested, messages); - } - // --- Reachability + classification --- /** Whether {@code d} can transitively contain a payload; delegates to the shared closure. */ @@ -219,22 +186,9 @@ private String emit(Map emitted) { sb.append("final class ").append(OUTPUT_CLASS).append(" {\n"); sb.append(" private ").append(OUTPUT_CLASS).append("() {}\n\n"); - sb.append(" private static Map buildSystemRoots() {\n"); - sb.append(" Map m = new HashMap<>();\n"); - for (String root : systemRoots) { - sb.append(" m.put(\"") - .append(root) - .append("\", REGISTRY.get(\"") - .append(root) - .append("\"));\n"); - } - sb.append(" return m;\n }\n"); - List list = new ArrayList<>(emitted.values()); sb.append(" static final Map REGISTRY = buildRegistry();\n\n"); - sb.append( - " static final Map SYSTEM_ROOTS = buildSystemRoots();\n"); sb.append(" private static Map buildRegistry() {\n"); sb.append(" Map m = new HashMap<>(") .append(Math.max(16, list.size() * 2)) diff --git a/temporal-serviceclient/src/test/java/io/temporal/internal/payload/gen/ProtoClosureRootTest.java b/temporal-serviceclient/src/test/java/io/temporal/internal/payload/gen/ProtoClosureRootTest.java deleted file mode 100644 index f5913e59bf..0000000000 --- a/temporal-serviceclient/src/test/java/io/temporal/internal/payload/gen/ProtoClosureRootTest.java +++ /dev/null @@ -1,54 +0,0 @@ -package io.temporal.internal.payload.gen; - -import static org.junit.Assert.*; - -import com.google.protobuf.DescriptorProtos.*; -import com.google.protobuf.Descriptors.*; -import io.temporal.api.common.v1.Payload; -import java.util.Arrays; -import java.util.Collections; -import org.junit.Test; - -public class ProtoClosureRootTest { - @Test - public void explicitRootsDiscoverTheirChildrenWithoutServiceSeeds() throws Exception { - String payloadFile = Payload.getDescriptor().getFile().getName(); - FileDescriptor file = - FileDescriptor.buildFrom( - FileDescriptorProto.newBuilder() - .setName("explicit-roots.proto") - .setPackage("temporal.api.test.v1") - .setSyntax("proto3") - .addDependency(payloadFile) - .addMessageType(DescriptorProto.newBuilder().setName("EmptyResponse")) - .addMessageType( - DescriptorProto.newBuilder() - .setName("Request") - .addField( - FieldDescriptorProto.newBuilder() - .setName("child") - .setNumber(1) - .setType(FieldDescriptorProto.Type.TYPE_MESSAGE) - .setTypeName(".temporal.api.test.v1.Child"))) - .addMessageType( - DescriptorProto.newBuilder() - .setName("Child") - .addField( - FieldDescriptorProto.newBuilder() - .setName("payload") - .setNumber(1) - .setType(FieldDescriptorProto.Type.TYPE_MESSAGE) - .setTypeName(".temporal.api.common.v1.Payload"))) - .build(), - new FileDescriptor[] {Payload.getDescriptor().getFile()}); - Descriptor request = file.findMessageTypeByName("Request"); - Descriptor empty = file.findMessageTypeByName("EmptyResponse"); - Descriptor child = file.findMessageTypeByName("Child"); - ProtoClosure closure = ProtoClosure.of(Collections.emptyList(), Arrays.asList(request, empty)); - assertTrue(closure.allMessages.contains(empty)); - assertTrue(closure.allMessages.contains(child)); - assertTrue(closure.reaches(request)); - assertTrue(closure.reaches(child)); - assertFalse(closure.reaches(empty)); - } -} diff --git a/temporal-serviceclient/src/test/java/io/temporal/internal/payload/visitor/SystemNexusPayloadTest.java b/temporal-serviceclient/src/test/java/io/temporal/internal/payload/visitor/SystemNexusPayloadTest.java deleted file mode 100644 index 501ebdaefc..0000000000 --- a/temporal-serviceclient/src/test/java/io/temporal/internal/payload/visitor/SystemNexusPayloadTest.java +++ /dev/null @@ -1,133 +0,0 @@ -package io.temporal.internal.payload.visitor; - -import static org.junit.Assert.*; - -import com.google.protobuf.ByteString; -import io.temporal.api.common.v1.Payload; -import io.temporal.api.common.v1.Payloads; -import io.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionRequest; -import io.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionResponse; -import java.util.Arrays; -import java.util.Collections; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionException; -import org.junit.Test; - -public class SystemNexusPayloadTest { - private static Payload payload(String value) { - return Payload.newBuilder().setData(ByteString.copyFromUtf8(value)).build(); - } - - @Test - public void visitsNestedSequencesBeforeRepacking() throws Exception { - SignalWithStartWorkflowExecutionRequest request = - SignalWithStartWorkflowExecutionRequest.newBuilder() - .setInput(Payloads.newBuilder().addPayloads(payload("workflow"))) - .setSignalInput(Payloads.newBuilder().addPayloads(payload("signal"))) - .build(); - CompletableFuture> workflow = new CompletableFuture<>(); - Payloads outer = Payloads.newBuilder().addPayloads(SystemNexusPayloads.pack(request)).build(); - CompletableFuture result = - PayloadVisitors.visit( - outer, - PayloadVisitorOptions.newBuilder( - (context, values) -> { - if (values.get(0).getData().toStringUtf8().equals("workflow")) { - return workflow; - } - return CompletableFuture.completedFuture( - Collections.singletonList(payload("SIGNAL"))); - }) - .build()); - assertFalse(result.isDone()); - workflow.complete(Arrays.asList(payload("ONE"), payload("TWO"))); - SignalWithStartWorkflowExecutionRequest decoded = - SignalWithStartWorkflowExecutionRequest.parseFrom(result.join().getPayloads(0).getData()); - assertEquals(2, decoded.getInput().getPayloadsCount()); - assertEquals("SIGNAL", decoded.getSignalInput().getPayloads(0).getData().toStringUtf8()); - assertEquals( - outer.getPayloads(0).getMetadataMap(), result.join().getPayloads(0).getMetadataMap()); - } - - @Test - public void handlesPayloadFreeResponses() { - Payload response = - SystemNexusPayloads.pack( - SignalWithStartWorkflowExecutionResponse.newBuilder().setRunId("run").build()); - Payloads outer = Payloads.newBuilder().addPayloads(response).build(); - assertEquals( - outer, - PayloadVisitors.visit( - outer, - PayloadVisitorOptions.newBuilder( - (context, values) -> { - throw new AssertionError("Outer envelope was visited"); - }) - .build()) - .join()); - } - - @Test - public void preservesMixedSequencesAndMessageOnlyTraversal() { - SignalWithStartWorkflowExecutionRequest request = - SignalWithStartWorkflowExecutionRequest.newBuilder() - .setInput(Payloads.newBuilder().addPayloads(payload("nested"))) - .build(); - Payload marked = SystemNexusPayloads.pack(request); - Payloads outer = - Payloads.newBuilder() - .addPayloads(payload("before")) - .addPayloads(marked) - .addPayloads(payload("after")) - .build(); - Payloads visited = - PayloadVisitors.visit( - outer, - PayloadVisitorOptions.newBuilder( - (context, values) -> - CompletableFuture.completedFuture( - Arrays.asList(values.get(0), values.get(0)))) - .build()) - .join(); - assertEquals(5, visited.getPayloadsCount()); - assertEquals(payload("before"), visited.getPayloads(0)); - assertEquals(payload("after"), visited.getPayloads(4)); - assertEquals( - 2, - ((SignalWithStartWorkflowExecutionRequest) - SystemNexusPayloads.unpack(visited.getPayloads(2)).build()) - .getInput() - .getPayloadsCount()); - assertEquals( - outer, - MessageVisitors.visit( - outer, MessageVisitorOptions.newBuilder((context, message) -> context).build())); - } - - @Test - public void rejectsUnknownAndMalformedMarkedPayloads() { - Payload unknown = - SystemNexusPayloads.pack(SignalWithStartWorkflowExecutionRequest.getDefaultInstance()) - .toBuilder() - .putMetadata("messageType", ByteString.copyFromUtf8("unknown.Message")) - .build(); - Payload malformed = - SystemNexusPayloads.pack(SignalWithStartWorkflowExecutionRequest.getDefaultInstance()) - .toBuilder() - .setData(ByteString.copyFrom(new byte[] {(byte) 0xff})) - .build(); - for (Payload value : Arrays.asList(unknown, malformed)) { - CompletionException error = - assertThrows( - CompletionException.class, - () -> - PayloadVisitors.visit( - Payloads.newBuilder().addPayloads(value).build(), - PayloadVisitorOptions.newBuilder( - (context, values) -> CompletableFuture.completedFuture(values)) - .build()) - .join()); - assertTrue(error.getCause() instanceof VisitorException); - } - } -} From 1c8c21683e36cccdd6cadb94919f2603a1344d6e Mon Sep 17 00:00:00 2001 From: Tim Conley Date: Tue, 17 Nov 2026 11:10:30 -0800 Subject: [PATCH 3/5] Retain original method metadata in workflow probes --- .../ExternalWorkflowInvocationHandler.java | 27 +++---------------- .../TypedWorkflowMethodCaptureTest.java | 23 +++++++++++----- 2 files changed, 20 insertions(+), 30 deletions(-) diff --git a/temporal-sdk/src/main/java/io/temporal/internal/sync/ExternalWorkflowInvocationHandler.java b/temporal-sdk/src/main/java/io/temporal/internal/sync/ExternalWorkflowInvocationHandler.java index 5469a2ce12..5e812c7d22 100644 --- a/temporal-sdk/src/main/java/io/temporal/internal/sync/ExternalWorkflowInvocationHandler.java +++ b/temporal-sdk/src/main/java/io/temporal/internal/sync/ExternalWorkflowInvocationHandler.java @@ -14,7 +14,6 @@ import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; -import java.lang.reflect.Type; import java.util.Objects; /** Dynamic implementation of a strongly typed external workflow interface. */ @@ -69,44 +68,26 @@ private ProbeContext(WorkflowMethodType expected) { /** Metadata captured from a bound external workflow method. */ public static final class ProbeResult { private final ExternalWorkflowStub stub; - private final String name; private final Object[] arguments; - private final Class resultClass; - private final Type resultType; - private final Method method; + private final POJOWorkflowMethodMetadata metadata; private ProbeResult( ExternalWorkflowStub stub, POJOWorkflowMethodMetadata metadata, Object[] args) { this.stub = stub; - this.name = metadata.getName(); this.arguments = args == null ? new Object[0] : args.clone(); - this.method = metadata.getWorkflowMethod(); - this.resultClass = method.getReturnType(); - this.resultType = method.getGenericReturnType(); + this.metadata = metadata; } public ExternalWorkflowStub getStub() { return stub; } - public String getName() { - return name; - } - public Object[] getArguments() { return arguments.clone(); } - public Class getResultClass() { - return resultClass; - } - - public Type getResultType() { - return resultType; - } - - public Method getMethod() { - return method; + public POJOWorkflowMethodMetadata getMetadata() { + return metadata; } } diff --git a/temporal-sdk/src/test/java/io/temporal/workflow/TypedWorkflowMethodCaptureTest.java b/temporal-sdk/src/test/java/io/temporal/workflow/TypedWorkflowMethodCaptureTest.java index 2da582ce65..94d027f36e 100644 --- a/temporal-sdk/src/test/java/io/temporal/workflow/TypedWorkflowMethodCaptureTest.java +++ b/temporal-sdk/src/test/java/io/temporal/workflow/TypedWorkflowMethodCaptureTest.java @@ -74,13 +74,19 @@ public void probesNamesArgumentsAnnotationsAndReturnTypesWithoutCommands() { method, () -> assertEquals(0, (int) method.apply("input")), WorkflowMethodType.WORKFLOW); - assertEquals("custom-workflow", call.getName()); + assertEquals("custom-workflow", call.getMetadata().getName()); + assertEquals(WorkflowMethodType.WORKFLOW, call.getMetadata().getType()); + assertEquals(Target.class, call.getMetadata().getWorkflowInterface()); assertArrayEquals(new Object[] {"input"}, call.getArguments()); - assertEquals(int.class, call.getResultClass()); - assertEquals(int.class, call.getResultType()); + assertEquals(int.class, call.getMetadata().getWorkflowMethod().getReturnType()); + assertEquals(int.class, call.getMetadata().getWorkflowMethod().getGenericReturnType()); assertEquals("target", call.getStub().getExecution().getWorkflowId()); - assertEquals(3, call.getMethod().getAnnotation(MethodRetry.class).maximumAttempts()); - assertEquals("0 * * * *", call.getMethod().getAnnotation(CronSchedule.class).value()); + assertEquals( + 3, + call.getMetadata().getWorkflowMethod().getAnnotation(MethodRetry.class).maximumAttempts()); + assertEquals( + "0 * * * *", + call.getMetadata().getWorkflowMethod().getAnnotation(CronSchedule.class).value()); assertSame(ExternalWorkflowStub.fromTyped(target), call.getStub()); call.getArguments()[0] = "changed"; assertEquals("input", call.getArguments()[0]); @@ -89,14 +95,17 @@ public void probesNamesArgumentsAnnotationsAndReturnTypesWithoutCommands() { ProbeResult signalCall = ExternalWorkflowInvocationHandler.probe( signal, () -> signal.apply("value", 42), WorkflowMethodType.SIGNAL); - assertEquals("custom-signal", signalCall.getName()); + assertEquals("custom-signal", signalCall.getMetadata().getName()); + assertEquals(WorkflowMethodType.SIGNAL, signalCall.getMetadata().getType()); assertArrayEquals(new Object[] {"value", 42}, signalCall.getArguments()); GenericTarget generic = stub(GenericTarget.class, "generic"); Functions.Func> start = generic::start; ProbeResult genericCall = ExternalWorkflowInvocationHandler.probe( start, () -> start.apply(), WorkflowMethodType.WORKFLOW); - assertEquals("java.util.List", genericCall.getResultType().getTypeName()); + assertEquals( + "java.util.List", + genericCall.getMetadata().getWorkflowMethod().getGenericReturnType().getTypeName()); verifyNoInteractions(outbound); assertThrows(IllegalStateException.class, () -> target.start("outside probe")); assertSame( From 4626320747fb4ae191287363ff68a9d95f32c513 Mon Sep 17 00:00:00 2001 From: Tim Conley Date: Tue, 17 Nov 2026 11:12:34 -0800 Subject: [PATCH 4/5] Probe workflow invocations without serialized lambda inspection --- .../ExternalWorkflowInvocationHandler.java | 18 +------ .../TypedWorkflowMethodCaptureTest.java | 53 +++++++++++-------- 2 files changed, 32 insertions(+), 39 deletions(-) diff --git a/temporal-sdk/src/main/java/io/temporal/internal/sync/ExternalWorkflowInvocationHandler.java b/temporal-sdk/src/main/java/io/temporal/internal/sync/ExternalWorkflowInvocationHandler.java index 5e812c7d22..ea2249a6c6 100644 --- a/temporal-sdk/src/main/java/io/temporal/internal/sync/ExternalWorkflowInvocationHandler.java +++ b/temporal-sdk/src/main/java/io/temporal/internal/sync/ExternalWorkflowInvocationHandler.java @@ -6,14 +6,10 @@ import io.temporal.common.metadata.POJOWorkflowMethodMetadata; import io.temporal.common.metadata.WorkflowMethodType; import io.temporal.internal.common.InternalUtils; -import io.temporal.internal.common.JavaLambdaUtils; import io.temporal.workflow.ExternalWorkflowStub; import io.temporal.workflow.Functions; -import java.lang.invoke.MethodHandleInfo; -import java.lang.invoke.SerializedLambda; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; -import java.lang.reflect.Proxy; import java.util.Objects; /** Dynamic implementation of a strongly typed external workflow interface. */ @@ -23,23 +19,11 @@ public class ExternalWorkflowInvocationHandler implements InvocationHandler { private static final ThreadLocal probeResult = new ThreadLocal<>(); /** Probes one invocation without starting a workflow or sending a signal. */ - public static ProbeResult probe( - Object method, Functions.Proc invocation, WorkflowMethodType expected) { + public static ProbeResult probe(Functions.Proc invocation, WorkflowMethodType expected) { Objects.requireNonNull(invocation, "invocation"); if (probeContext.get() != null) { throw new IllegalStateException("Already probing an external workflow invocation"); } - SerializedLambda reference = - JavaLambdaUtils.toSerializedLambda(Objects.requireNonNull(method, "method")); - Object target = JavaLambdaUtils.getTarget(reference); - if (reference == null - || reference.getImplMethodKind() != MethodHandleInfo.REF_invokeInterface - || target == null - || !Proxy.isProxyClass(target.getClass()) - || !(Proxy.getInvocationHandler(target) instanceof ExternalWorkflowInvocationHandler)) { - throw new IllegalArgumentException( - "Expected a bound method from Workflow.newExternalWorkflowStub"); - } ProbeContext context = new ProbeContext(expected); probeContext.set(context); try { diff --git a/temporal-sdk/src/test/java/io/temporal/workflow/TypedWorkflowMethodCaptureTest.java b/temporal-sdk/src/test/java/io/temporal/workflow/TypedWorkflowMethodCaptureTest.java index 94d027f36e..b0dd0eb354 100644 --- a/temporal-sdk/src/test/java/io/temporal/workflow/TypedWorkflowMethodCaptureTest.java +++ b/temporal-sdk/src/test/java/io/temporal/workflow/TypedWorkflowMethodCaptureTest.java @@ -71,9 +71,7 @@ public void probesNamesArgumentsAnnotationsAndReturnTypesWithoutCommands() { Functions.Func1 method = target::start; ProbeResult call = ExternalWorkflowInvocationHandler.probe( - method, - () -> assertEquals(0, (int) method.apply("input")), - WorkflowMethodType.WORKFLOW); + () -> assertEquals(0, (int) method.apply("input")), WorkflowMethodType.WORKFLOW); assertEquals("custom-workflow", call.getMetadata().getName()); assertEquals(WorkflowMethodType.WORKFLOW, call.getMetadata().getType()); assertEquals(Target.class, call.getMetadata().getWorkflowInterface()); @@ -94,15 +92,14 @@ public void probesNamesArgumentsAnnotationsAndReturnTypesWithoutCommands() { Functions.Proc2 signal = target::signal; ProbeResult signalCall = ExternalWorkflowInvocationHandler.probe( - signal, () -> signal.apply("value", 42), WorkflowMethodType.SIGNAL); + () -> signal.apply("value", 42), WorkflowMethodType.SIGNAL); assertEquals("custom-signal", signalCall.getMetadata().getName()); assertEquals(WorkflowMethodType.SIGNAL, signalCall.getMetadata().getType()); assertArrayEquals(new Object[] {"value", 42}, signalCall.getArguments()); GenericTarget generic = stub(GenericTarget.class, "generic"); Functions.Func> start = generic::start; ProbeResult genericCall = - ExternalWorkflowInvocationHandler.probe( - start, () -> start.apply(), WorkflowMethodType.WORKFLOW); + ExternalWorkflowInvocationHandler.probe(() -> start.apply(), WorkflowMethodType.WORKFLOW); assertEquals( "java.util.List", genericCall.getMetadata().getWorkflowMethod().getGenericReturnType().getTypeName()); @@ -113,18 +110,16 @@ public void probesNamesArgumentsAnnotationsAndReturnTypesWithoutCommands() { } @Test - public void rejectsMissingRepeatedWrongKindAndNonBoundInvocations() { + public void rejectsMissingRepeatedAndWrongKindInvocations() { Target target = stub(Target.class, "target"); Functions.Func1 start = target::start; assertThrows( IllegalArgumentException.class, - () -> - ExternalWorkflowInvocationHandler.probe(start, () -> {}, WorkflowMethodType.WORKFLOW)); + () -> ExternalWorkflowInvocationHandler.probe(() -> {}, WorkflowMethodType.WORKFLOW)); assertThrows( IllegalArgumentException.class, () -> ExternalWorkflowInvocationHandler.probe( - start, () -> { start.apply("first"); start.apply("second"); @@ -134,29 +129,46 @@ public void rejectsMissingRepeatedWrongKindAndNonBoundInvocations() { IllegalArgumentException.class, () -> ExternalWorkflowInvocationHandler.probe( - start, () -> start.apply("input"), WorkflowMethodType.SIGNAL)); + () -> start.apply("input"), WorkflowMethodType.SIGNAL)); Functions.Proc2 signal = target::signal; assertThrows( IllegalArgumentException.class, () -> ExternalWorkflowInvocationHandler.probe( - signal, () -> signal.apply("value", 1), WorkflowMethodType.WORKFLOW)); + () -> signal.apply("value", 1), WorkflowMethodType.WORKFLOW)); Functions.Func query = target::query; Functions.Func update = target::update; assertThrows( IllegalArgumentException.class, () -> ExternalWorkflowInvocationHandler.probe( - query, () -> query.apply(), WorkflowMethodType.SIGNAL)); + () -> query.apply(), WorkflowMethodType.SIGNAL)); assertThrows( IllegalArgumentException.class, () -> ExternalWorkflowInvocationHandler.probe( - update, () -> update.apply(), WorkflowMethodType.SIGNAL)); - Functions.Proc lambda = () -> target.start("input"); - assertThrows( - IllegalArgumentException.class, - () -> ExternalWorkflowInvocationHandler.probe(lambda, lambda, WorkflowMethodType.WORKFLOW)); + () -> update.apply(), WorkflowMethodType.SIGNAL)); + verifyNoInteractions(outbound); + } + + @Test + public void capturesInvocationsWithoutInspectingTheirLambdaRepresentation() { + Target target = stub(Target.class, "target"); + Functions.Proc invocation = + new Functions.Proc() { + @Override + public void apply() { + target.start("input"); + } + }; + ProbeResult call = + ExternalWorkflowInvocationHandler.probe(invocation, WorkflowMethodType.WORKFLOW); + assertEquals("custom-workflow", call.getMetadata().getName()); + assertArrayEquals(new Object[] {"input"}, call.getArguments()); + ProbeResult lambda = + ExternalWorkflowInvocationHandler.probe( + () -> target.start("lambda"), WorkflowMethodType.WORKFLOW); + assertArrayEquals(new Object[] {"lambda"}, lambda.getArguments()); verifyNoInteractions(outbound); } @@ -171,20 +183,18 @@ public void restoresProbeStateAfterFailureAndRejectsNesting() { RuntimeException.class, () -> ExternalWorkflowInvocationHandler.probe( - method, () -> { throw failure; }, WorkflowMethodType.WORKFLOW))); ProbeResult result = ExternalWorkflowInvocationHandler.probe( - method, () -> { assertThrows( IllegalStateException.class, () -> ExternalWorkflowInvocationHandler.probe( - method, () -> method.apply("nested"), WorkflowMethodType.WORKFLOW)); + () -> method.apply("nested"), WorkflowMethodType.WORKFLOW)); method.apply("outer"); }, WorkflowMethodType.WORKFLOW); @@ -214,7 +224,6 @@ private String parallelProbe( Functions.Func1 method, String value, CyclicBarrier barrier) { ProbeResult result = ExternalWorkflowInvocationHandler.probe( - method, () -> { try { barrier.await(5, TimeUnit.SECONDS); From b2227e56e190287c269eb8cc2e69703815f17570 Mon Sep 17 00:00:00 2001 From: Tim Conley Date: Tue, 17 Nov 2026 11:13:41 -0800 Subject: [PATCH 5/5] Omit changelog entry for internal prerequisites --- CHANGELOG.md | 2 -- 1 file changed, 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a5050eee43..c44fcb06b1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,8 +22,6 @@ to docs, or any other relevant information. ### Changed - Updated Cloud API bindings to v0.27.0, including opt-in user group memberships, projects, project-scoped custom roles, and caller rate limits. -- Add internal converter scoping and external workflow method capture support for generated - workflow APIs. ## [1.41.1] - 2026-11-16