b030bb388b
## What changed? Fix a race condition in GetWorkflowExecutionHistory that caused SDK workers to receive incomplete history and fail with "premature end of stream". On the last page of a paginated `GetWorkflowExecutionHistory` response, re-query mutable state to detect events that were committed to the DB between the first and last page fetches. If `freshNextEventId > continuationToken.NextEventId`, the gap is fetched from persistence and appended to the response before transient/speculative events are added. The continuation token is updated with the fresh boundary so `appendTransientTasks` validates against the correct `NextEventId`. If the re-query itself fails, the request returns an error so the client retries. Also adds a `nil` check in `ValidateTransientWorkflowTaskEvents`, preventing a possible nil-pointer dereference. ## Why? A speculative WFT is converted to normal (e.g., by an incoming signal), committing 1–2 new events. The continuation token from page 1 points to NextEventId=8; the DB range [6, 8) on page 2 returns only events 6–7, missing the newly-committed events 8 and 9. `appendTransientTasks` finds no transient tasks (speculative was committed), so the assembled history is missing 2 events. ## How did you test it? - [X] built - [X] run locally and tested manually - [ ] covered by existing tests - [ ] added new unit test(s) - [X] added new functional test(s) ## Potential risks - The re-query on the last history page adds one extra GetMutableState RPC per paginated `GetWorkflowExecutionHistory` call. This is bounded to final-page responses only and the existing path already made this call inside `appendTransientTasks`, so the net overhead is one additional call specifically when a gap is detected. - Returning an error when the fresh mutable-state re-query fails changes the previous behavior of silently continuing. Clients will retry, which is correct, but retry storms are possible if persistence is consistently unavailable mitigated by the client's existing backoff.
Temporal—durable execution platform
Introduction • Getting Started • Contributing • Temporal Docs • Temporal 101
Introduction
Temporal is a durable execution platform that enables developers to build scalable applications without sacrificing productivity or reliability. The Temporal server executes units of application logic called Workflows in a resilient manner that automatically handles intermittent failures, and retries failed operations.
Temporal is a mature technology that originated as a fork of Uber's Cadence. It is developed by Temporal Technologies, a startup by the creators of Cadence.
Getting Started
Download and Start Temporal Server Locally
Execute the following commands to start a pre-built image along with all the dependencies.
brew install temporal
temporal server start-dev
Refer to Temporal CLI documentation for more installation options.
Run the Samples
Clone or download samples for Go or Java and run them with the local Temporal server. We have a number of HelloWorld type scenarios available, as well as more advanced ones. Note that the sets of samples are currently different between Go and Java.
Use CLI
Use Temporal CLI to interact with the running Temporal server.
temporal operator namespace list
temporal workflow list
Use Temporal Web UI
Try Temporal Web UI by opening http://localhost:8233 for viewing your sample workflows executing on Temporal.
Repository
This repository contains the source code of the Temporal server. To implement Workflows, Activities and Workers, use one of the supported languages.
Contributing
We'd love your help in making Temporal great.
Helpful links to get started:
- work on or propose a new feature
- learn about the Temporal Server architecture
- learn how to build and run the Temporal Server locally
- learn about Temporal Server testing tools and best practices
- join the Temporal community forum and Slack