• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

temporalio / sdk-java / #427

16 Nov 2026 04:17PM UTC coverage: 71.787% (+0.1%) from 71.675%
#427

push

github

web-flow
Provide the namespace to storage drivers (#3203)

8613 of 14069 branches covered (61.22%)

Branch coverage included in aggregate %.

13 of 22 new or added lines in 12 files covered. (59.09%)

140 existing lines in 13 files now uncovered.

34118 of 45456 relevant lines covered (75.06%)

0.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.37
/temporal-sdk/src/main/java/io/temporal/internal/statemachines/MutableSideEffectStateMachine.java
1
package io.temporal.internal.statemachines;
2

3
import com.google.common.annotations.VisibleForTesting;
4
import com.google.common.base.Strings;
5
import io.temporal.api.command.v1.RecordMarkerCommandAttributes;
6
import io.temporal.api.common.v1.Payloads;
7
import io.temporal.api.enums.v1.CommandType;
8
import io.temporal.api.enums.v1.EventType;
9
import io.temporal.api.history.v1.HistoryEvent;
10
import io.temporal.api.history.v1.MarkerRecordedEventAttributes;
11
import io.temporal.api.sdk.v1.UserMetadata;
12
import io.temporal.common.converter.DefaultDataConverter;
13
import io.temporal.common.converter.StdConverterBackwardsCompatAdapter;
14
import io.temporal.workflow.Functions;
15
import java.util.HashMap;
16
import java.util.Map;
17
import java.util.Objects;
18
import java.util.Optional;
19

20
final class MutableSideEffectStateMachine {
21

22
  static final String MARKER_DATA_KEY = "data";
23
  static final String MARKER_SKIP_COUNT_KEY = "skipCount";
24
  static final String MARKER_ID_KEY = "id";
25
  static final String MUTABLE_SIDE_EFFECT_MARKER_NAME = "MutableSideEffect";
26

27
  private final String id;
28
  private UserMetadata metadata;
29
  private final Functions.Func<Boolean> replaying;
30
  private final Functions.Proc1<CancellableCommand> commandSink;
31

32
  private Optional<Payloads> result = Optional.empty();
1 ✔
33

34
  private int currentSkipCount;
35

36
  private int skipCountFromMarker = Integer.MAX_VALUE;
1 ✔
37

38
  enum ExplicitEvent {
1 ✔
39
    CHECK_EXECUTION_STATE,
1 ✔
40
    SCHEDULE,
1 ✔
41
    NON_MATCHING_EVENT
1 ✔
42
  }
43

44
  enum State {
1 ✔
45
    CREATED,
1 ✔
46
    REPLAYING,
1 ✔
47
    EXECUTING,
1 ✔
48
    MARKER_COMMAND_CREATED,
1 ✔
49
    SKIPPED,
1 ✔
50
    CACHED_RESULT_NOTIFIED,
1 ✔
51
    RESULT_NOTIFIED,
1 ✔
52
    SKIPPED_NOTIFIED,
1 ✔
53
    RESULT_NOTIFIED_REPLAYING,
1 ✔
54
    MARKER_COMMAND_CREATED_REPLAYING,
1 ✔
55
    MARKER_COMMAND_RECORDED,
1 ✔
56
  }
57

58
  public static final StateMachineDefinition<State, ExplicitEvent, InvocationStateMachine>
59
      STATE_MACHINE_DEFINITION =
1 ✔
60
          StateMachineDefinition.<State, ExplicitEvent, InvocationStateMachine>newInstance(
1 ✔
61
                  "MutableSideEffect",
62
                  State.CREATED,
63
                  State.MARKER_COMMAND_RECORDED,
64
                  State.SKIPPED_NOTIFIED)
65
              .add(
1 ✔
66
                  State.CREATED,
67
                  ExplicitEvent.CHECK_EXECUTION_STATE,
68
                  new State[] {State.REPLAYING, State.EXECUTING},
69
                  InvocationStateMachine::getExecutionState)
70
              .add(
1 ✔
71
                  State.EXECUTING,
72
                  ExplicitEvent.SCHEDULE,
73
                  new State[] {State.MARKER_COMMAND_CREATED, State.SKIPPED},
74
                  InvocationStateMachine::createMarker)
75
              .add(
1 ✔
76
                  State.REPLAYING,
77
                  ExplicitEvent.SCHEDULE,
78
                  State.MARKER_COMMAND_CREATED_REPLAYING,
79
                  InvocationStateMachine::createFakeCommand)
80
              .add(
1 ✔
81
                  State.MARKER_COMMAND_CREATED,
82
                  CommandType.COMMAND_TYPE_RECORD_MARKER,
83
                  State.RESULT_NOTIFIED,
84
                  InvocationStateMachine::notifyCachedResult)
85
              .add(
1 ✔
86
                  State.SKIPPED,
87
                  CommandType.COMMAND_TYPE_RECORD_MARKER,
88
                  State.SKIPPED_NOTIFIED,
89
                  InvocationStateMachine::cancelCommandNotifyCachedResult)
90
              .add(
1 ✔
91
                  State.RESULT_NOTIFIED,
92
                  EventType.EVENT_TYPE_MARKER_RECORDED,
93
                  State.MARKER_COMMAND_RECORDED)
94
              .add(
1 ✔
95
                  State.MARKER_COMMAND_CREATED_REPLAYING,
96
                  CommandType.COMMAND_TYPE_RECORD_MARKER,
97
                  State.RESULT_NOTIFIED_REPLAYING)
98
              .add(
1 ✔
99
                  State.RESULT_NOTIFIED_REPLAYING,
100
                  ExplicitEvent.NON_MATCHING_EVENT,
101
                  State.SKIPPED_NOTIFIED,
102
                  InvocationStateMachine::cancelCommandNotifyCachedResult)
103
              .add(
1 ✔
104
                  State.RESULT_NOTIFIED_REPLAYING,
105
                  EventType.EVENT_TYPE_MARKER_RECORDED,
106
                  new State[] {State.MARKER_COMMAND_RECORDED, State.SKIPPED_NOTIFIED},
107
                  InvocationStateMachine::notifyFromEvent);
108

109
  /** Represents a single invocation of mutableSideEffect. */
110
  @VisibleForTesting
111
  class InvocationStateMachine
112
      extends EntityStateMachineInitialCommand<State, ExplicitEvent, InvocationStateMachine> {
113

114
    private final Functions.Proc1<Optional<Payloads>> resultCallback;
115
    private final Functions.Func1<Optional<Payloads>, Optional<Payloads>> func;
116

117
    InvocationStateMachine(
118
        Functions.Func1<Optional<Payloads>, Optional<Payloads>> func,
119
        Functions.Proc1<Optional<Payloads>> callback,
120
        Functions.Proc1<StateMachine> stateMachineSink) {
1 ✔
121
      super(
1 ✔
122
          STATE_MACHINE_DEFINITION,
123
          MutableSideEffectStateMachine.this.commandSink,
1 ✔
124
          stateMachineSink);
125
      this.func = Objects.requireNonNull(func);
1 ✔
126
      this.resultCallback = Objects.requireNonNull(callback);
1 ✔
127
    }
1 ✔
128

129
    State getExecutionState() {
130
      return replaying.apply() ? State.REPLAYING : State.EXECUTING;
1 ✔
131
    }
132

133
    void notifySkippedReplaying() {
134
      if (getState() == State.RESULT_NOTIFIED_REPLAYING) {
1 ✔
135
        // No marker event accounts for this skip. Count it before the callback can make another
136
        // call.
137
        currentSkipCount++;
1 ✔
138
        explicitEvent(ExplicitEvent.NON_MATCHING_EVENT);
1 ✔
139
      }
140
    }
1 ✔
141

142
    @Override
143
    public WorkflowStateMachines.HandleEventStatus handleEvent(
144
        HistoryEvent event, boolean hasNextEvent) {
145
      if (event.getEventType() != EventType.EVENT_TYPE_MARKER_RECORDED
1 ✔
146
          || !event
147
              .getMarkerRecordedEventAttributes()
1 ✔
148
              .getMarkerName()
1 ✔
149
              .equals(MUTABLE_SIDE_EFFECT_MARKER_NAME)) {
1 !
150
        explicitEvent(ExplicitEvent.NON_MATCHING_EVENT);
1 ✔
151
        return WorkflowStateMachines.HandleEventStatus.NON_MATCHING_EVENT;
1 ✔
152
      }
153
      Map<String, Payloads> detailsMap = event.getMarkerRecordedEventAttributes().getDetailsMap();
1 ✔
154
      Optional<Payloads> idPayloads = Optional.ofNullable(detailsMap.get(MARKER_ID_KEY));
1 ✔
155
      String expectedId =
1 ✔
156
          StdConverterBackwardsCompatAdapter.fromPayloads(
1 ✔
157
              0, idPayloads, String.class, String.class);
158
      if (Strings.isNullOrEmpty(expectedId)) {
1 !
UNCOV
159
        throw new IllegalStateException(
×
160
            "Marker details map missing required key: " + MARKER_ID_KEY);
161
      }
162
      if (!id.equals(expectedId)) {
1 !
UNCOV
163
        explicitEvent(ExplicitEvent.NON_MATCHING_EVENT);
×
UNCOV
164
        return WorkflowStateMachines.HandleEventStatus.NON_MATCHING_EVENT;
×
165
      }
166
      return super.handleEvent(event, hasNextEvent);
1 ✔
167
    }
168

169
    State createMarker() {
170
      Optional<Payloads> updated = func.apply(result);
1 ✔
171
      if (!updated.isPresent()) {
1 ✔
172
        currentSkipCount++;
1 ✔
173
        addCommand(StateMachineCommandUtils.RECORD_MARKER_FAKE_COMMAND);
1 ✔
174
        return State.SKIPPED;
1 ✔
175
      } else {
176
        result = updated;
1 ✔
177
        Map<String, Payloads> details = new HashMap<>();
1 ✔
178
        details.put(MARKER_ID_KEY, DefaultDataConverter.STANDARD_INSTANCE.toPayloads(id).get());
1 ✔
179
        details.put(MARKER_DATA_KEY, updated.get());
1 ✔
180
        details.put(
1 ✔
181
            MARKER_SKIP_COUNT_KEY,
182
            DefaultDataConverter.STANDARD_INSTANCE.toPayloads(currentSkipCount).get());
1 ✔
183
        RecordMarkerCommandAttributes markerAttributes =
184
            RecordMarkerCommandAttributes.newBuilder()
1 ✔
185
                .setMarkerName(MUTABLE_SIDE_EFFECT_MARKER_NAME)
1 ✔
186
                .putAllDetails(details)
1 ✔
187
                .build();
1 ✔
188
        addCommand(StateMachineCommandUtils.createRecordMarker(markerAttributes, metadata));
1 ✔
189
        metadata = null; // only used once
1 ✔
190
        currentSkipCount = 0;
1 ✔
191
        return State.MARKER_COMMAND_CREATED;
1 ✔
192
      }
193
    }
194

195
    void createFakeCommand() {
196
      addCommand(StateMachineCommandUtils.RECORD_MARKER_FAKE_COMMAND);
1 ✔
197
    }
1 ✔
198

199
    /**
200
     * Returns MARKER_COMMAND_RECORDED only if the currentEvent:
201
     *
202
     * <ul>
203
     *   <li>Is a Marker
204
     *   <li>Has MutableSideEffect marker name
205
     *   <li>Its skip count matches. Not matching access count means that current event is for a
206
     *       some following mutableSideEffect invocation.
207
     * </ul>
208
     */
209
    State notifyFromEvent() {
210
      State r = notifyFromEventImpl();
1 ✔
211
      notifyCachedResult();
1 ✔
212
      return r;
1 ✔
213
    }
214

215
    State notifyFromEventImpl() {
216
      MarkerRecordedEventAttributes attributes = currentEvent.getMarkerRecordedEventAttributes();
1 ✔
217
      Map<String, Payloads> detailsMap = attributes.getDetailsMap();
1 ✔
218
      Optional<Payloads> skipCountPayloads =
1 ✔
219
          Optional.ofNullable(detailsMap.get(MARKER_SKIP_COUNT_KEY));
1 ✔
220
      if (!skipCountPayloads.isPresent()) {
1 !
UNCOV
221
        throw new IllegalStateException(
×
222
            "Marker details detailsMap missing required key: " + MARKER_SKIP_COUNT_KEY);
223
      }
224
      Optional<Payloads> oid = Optional.ofNullable(detailsMap.get(MARKER_ID_KEY));
1 ✔
225
      String idFromMarker =
1 ✔
226
          StdConverterBackwardsCompatAdapter.fromPayloads(0, oid, String.class, String.class);
1 ✔
227
      if (!id.equals(idFromMarker)) {
1 !
UNCOV
228
        throw new IllegalArgumentException("Ids doesnt match: " + id + "<>" + idFromMarker);
×
229
      }
230
      skipCountFromMarker =
1 ✔
231
          StdConverterBackwardsCompatAdapter.fromPayloads(
1 ✔
232
              0, skipCountPayloads, Integer.class, Integer.class);
233
      if (++currentSkipCount < skipCountFromMarker) {
1 ✔
234
        skipCountFromMarker = Integer.MAX_VALUE;
1 ✔
235
        return State.SKIPPED_NOTIFIED;
1 ✔
236
      }
237
      if (!attributes.getMarkerName().equals(MUTABLE_SIDE_EFFECT_MARKER_NAME)) {
1 !
UNCOV
238
        throw new IllegalStateException(
×
239
            "Expected " + MUTABLE_SIDE_EFFECT_MARKER_NAME + ", received: " + attributes);
240
      }
241
      currentSkipCount = 0;
1 ✔
242
      result = Optional.ofNullable(detailsMap.get(MARKER_DATA_KEY));
1 ✔
243
      return State.MARKER_COMMAND_RECORDED;
1 ✔
244
    }
245

246
    void notifyCachedResult() {
247
      resultCallback.apply(result);
1 ✔
248
    }
1 ✔
249

250
    void cancelCommandNotifyCachedResult() {
251
      cancelCommand();
1 ✔
252
      notifyCachedResult();
1 ✔
253
    }
1 ✔
254
  }
255

256
  /** Creates new MutableSideEffectStateMachine */
257
  public static MutableSideEffectStateMachine newInstance(
258
      String id,
259
      UserMetadata metadata,
260
      Functions.Func<Boolean> replaying,
261
      Functions.Proc1<CancellableCommand> commandSink,
262
      Functions.Proc1<StateMachine> stateMachineSink) {
263
    return new MutableSideEffectStateMachine(
1 ✔
264
        id, metadata, replaying, commandSink, stateMachineSink);
265
  }
266

267
  private MutableSideEffectStateMachine(
268
      String id,
269
      UserMetadata metadata,
270
      Functions.Func<Boolean> replaying,
271
      Functions.Proc1<CancellableCommand> commandSink,
272
      Functions.Proc1<StateMachine> stateMachineSink) {
1 ✔
273
    this.id = Objects.requireNonNull(id);
1 ✔
274
    this.metadata = metadata;
1 ✔
275
    this.replaying = Objects.requireNonNull(replaying);
1 ✔
276
    this.commandSink = Objects.requireNonNull(commandSink);
1 ✔
277
  }
1 ✔
278

279
  public InvocationStateMachine mutableSideEffect(
280
      Functions.Func1<Optional<Payloads>, Optional<Payloads>> func,
281
      Functions.Proc1<Optional<Payloads>> callback,
282
      Functions.Proc1<StateMachine> stateMachineSink) {
283
    InvocationStateMachine ism = new InvocationStateMachine(func, callback, stateMachineSink);
1 ✔
284
    ism.explicitEvent(ExplicitEvent.CHECK_EXECUTION_STATE);
1 ✔
285
    ism.explicitEvent(ExplicitEvent.SCHEDULE);
1 ✔
286
    return ism;
1 ✔
287
  }
288
}
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE TRIAL · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc