Skip to content

Implement UpdateActivityExecutionOptions#9850

Merged
spkane31 merged 20 commits into
feature/activity-operator-cmdsfrom
spk/activity-operator-update-options
Apr 13, 2026
Merged

Implement UpdateActivityExecutionOptions#9850
spkane31 merged 20 commits into
feature/activity-operator-cmdsfrom
spk/activity-operator-update-options

Conversation

@spkane31
Copy link
Copy Markdown
Contributor

@spkane31 spkane31 commented Apr 7, 2026

What changed?

Implements the UpdateActivityExecutionOptions RPC for standalone activities. The workflow-activity path is already supported via the existing UpdateActivityOptions history service API this PR only wires up the standalone path end-to-end.

Core changes:

  • chasm/lib/activity/activity.go — Adds UpdateActivityExecutionOptions method on Activity:
    • Validates mutual exclusion of update_mask / restore_original
    • restore_original: bulk-assigns all fields from the original_options snapshot stored at schedule time
    • Field-mask path: applies only the specified fields via mergeActivityOptions
    • Stamp invalidation: bumps attempt.Stamp to cancel in-flight ActivityDispatchTask and timeout tasks, then re-queues a new dispatch and schedule-to-start timeout
    • Retry interval recalculation: after a retry-policy update, recomputes attempt.CurrentRetryInterval so the re-dispatch fires at the new (possibly shorter) interval rather than the stale one
    • Schedule-to-close update: adds a new ScheduleToCloseTimeoutTask at the updated deadline so a shortened timeout fires immediately
    • Adds original_options to ActivityState proto and populates it in NewStandaloneActivity
  • chasm/lib/activity/handler.go — Routes the standalone path to chasm.UpdateComponent to (*Activity).UpdateActivityExecutionOptions
  • chasm/lib/activity/frontend.go — Adds input validation (validateUpdateActivityExecutionOptionsRequest: activity ID required/length, identity length, run ID UUID), and gates the standalone path behind the Enabled config flag while always permitting the workflow path

Why?

UpdateActivityExecutionOptions is the new unified RPC for updating activity options for both standalone activities and workflow-embedded activities.

How did you test it?

  • built
  • run locally and tested manually
  • covered by existing tests
  • added new unit test(s)
  • added new functional test(s)

Potential risks

Minimal, this is into a feature branch

@spkane31 spkane31 requested review from a team as code owners April 7, 2026 21:49
@spkane31 spkane31 force-pushed the spk/activity-operator-update-options branch from adcb1b0 to 6e743f6 Compare April 7, 2026 22:05
@spkane31 spkane31 changed the title Spk/activity operator update options Implement UpdateActivityExecutionOptions Apr 7, 2026
@spkane31 spkane31 requested review from dandavison and fretz12 April 8, 2026 17:53
Comment thread chasm/lib/activity/activity.go Outdated
Comment thread chasm/lib/activity/handler.go
Comment thread chasm/lib/activity/activity_tasks.go Outdated
// Discard stale tasks created before a schedule-to-close extension.
// When the deadline is extended, a new task is added at the updated deadline; any earlier
// task (from the old shorter deadline) must not time out the activity prematurely.
if timeout := activity.GetScheduleToCloseTimeout().AsDuration(); timeout > 0 {
Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

If a user updates the options such that scheduleToClose is 0 (disabled), this validation would cause a spurious fire.
We should add a check.

        timeout := activity.GetScheduleToCloseTimeout().AsDuration()
        if timeout <= 0 {                                                                                                                                                                                                                                                                                                                                                                                                        
                return false, nil                                                                                                                                                                                                                                                                                                                                                                                                
        }            

Also, I'm wondering if it's more robust to have a dedicated stamp (like we do for attempt) for scheduleToClose. A bit more extra storage, but avoids any time comparisons for validations as it can be fragile. @bergundy @dandavison lmk your thoughts

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yeah, just put a stamp on this instead IMHO. Just make sure that if there's no stamp on the task it's not used for validation.

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Comment thread chasm/lib/activity/activity.go
Comment thread chasm/lib/activity/validator.go Outdated
Comment thread tests/activity_api_update_test.go
@spkane31 spkane31 requested review from bergundy and fretz12 April 9, 2026 18:58
Comment thread chasm/lib/activity/activity_tasks.go Outdated
// Discard stale tasks created before a schedule-to-close extension.
// When the deadline is extended, a new task is added at the updated deadline; any earlier
// task (from the old shorter deadline) must not time out the activity prematurely.
if timeout := activity.GetScheduleToCloseTimeout().AsDuration(); timeout > 0 {
Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

chasm.TaskAttributes{ScheduledTime: deadline},
&activitypb.StartToCloseTimeoutTask{Stamp: attempt.GetStamp()},
)
}
Copy link
Copy Markdown
Contributor

@dandavison dandavison Apr 9, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We need to regenerate the heartbeat task also to cover the case where the pending heartbeat task was invalidated by the stamp bump. It looks like the heartbeating test works around that to make it pass.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Dispatched the heartbeat task using the same logic in TransitionStarted and changed the test to remove the heartbeating to force the task generation

)
}
}

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Maybe worth leaving a comment here for ourselves that we need to handle the StartDelay timer also.

Comment thread tests/standalone_activity_test.go Outdated
require.NoError(t, err)

// Heartbeat once — this creates a new HeartbeatTimeoutTask with the updated 2s timeout
// and the new stamp. Without this heartbeat the timer would not be armed.
Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I don't think we should be doing this -- it's papering over the lack of heartbeat task regeneration in the implementation.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Removed

@spkane31 spkane31 requested a review from dandavison April 9, 2026 22:37
Comment thread chasm/lib/activity/proto/v1/activity_state.proto Outdated
Comment thread chasm/lib/activity/activity.go
Comment thread chasm/lib/activity/validator.go
Comment thread chasm/lib/activity/activity.go Outdated
Comment thread chasm/lib/activity/activity.go
Comment thread chasm/lib/activity/activity.go Outdated
Comment thread chasm/lib/activity/activity.go Outdated

attempt.Stamp++

if a.GetStatus() == activitypb.ACTIVITY_EXECUTION_STATUS_STARTED {
Copy link
Copy Markdown
Contributor

@dandavison dandavison Apr 10, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We need to also consider CANCEL_REQUESTED -- we don't want to miss a heartbeat timeout while in CANCEL_REQUESTED. It look like there's a pre-existing bug in that the start-to-close task validator rejects the task if it is in CANCEL_REQUESTED; I've opened #9901 for that. So I believe the condition here should be STARTED || CANCEL_REQUESTED.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Added your changes into the branch

@spkane31 spkane31 requested review from dandavison and fretz12 April 10, 2026 17:29
activity := &Activity{
ActivityState: &activitypb.ActivityState{
ActivityType: request.ActivityType,
ActivityState: common.CloneProto(&activitypb.ActivityState{
Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

maybe a brief comment on why we're cloning

// for workflow-embedded activities; complexity is inherent to the per-field update pattern.
//
//nolint:revive // cyclomatic: field-mask application mirrors existing updateactivityoptions logic
func (a *Activity) mergeActivityOptions(
Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Can we refactor the core logic here with that in the merge method in service/history/api/updateactivityoptions/api.go? It's largely a repeat and good to have all in one place.

return nil
}

func validateUpdateActivityExecutionOptionsRequest(
Copy link
Copy Markdown
Member

@bergundy bergundy Apr 10, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We should be validating the following:

		TaskQueue:  Use standard task queue validation, this is a security risk that can cause an activity to be executed on the per-namespace-worker task queue
		ScheduleToCloseTimeout: validate+normalize with standard timeout validator
		ScheduleToStartTimeout: validate+normalize with standard timeout validator
		StartToCloseTimeout: validate+normalize with standard timeout validator
		HeartbeatTimeout: validate+normalize with standard timeout validator
		Priority: already validated
		RetryPolicy: I am pretty sure there's a validator and maybe normalizer for this.

// An incremental version number used to validate ScheduleToCloseTimeoutTask tasks.
// Incremented each time a new ScheduleToCloseTimeoutTask is scheduled (at activity creation
// and on each options update that re-schedules the task). Unlike attempt.stamp, this counter
// is NOT reset on retries, because schedule-to-close spans the full activity lifetime.
Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Suggested change
// is NOT reset on retries, because schedule-to-close spans the full activity lifetime.
// is NOT incremented on retries, because schedule-to-close spans the full activity lifetime.

Comment thread chasm/lib/activity/proto/v1/tasks.proto Outdated
}

message ScheduleToCloseTimeoutTask {
// The current schedule-to-close stamp for this activity. Used for task validation.
Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Suggested change
// The current schedule-to-close stamp for this activity. Used for task validation.
// The schedule-to-close stamp for this task. Used for task validation.

Comment thread chasm/lib/activity/activity.go Outdated
// The next heartbeat time is the max of (the last heartbeats recorded time and
// the current attempts started time) plus the heartbeat timeout
lastHb, _ := a.LastHeartbeat.TryGet(ctx)
lastHBTime := util.MaxTime(
Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

nit: inconsistent lastHb vs lastHB

mergeInto.RetryPolicy = &commonpb.RetryPolicy{}
}
mergeInto.RetryPolicy.MaximumAttempts = mergeFrom.GetRetryPolicy().GetMaximumAttempts()
}
Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Not blocking this PR but looking at this feature and the existing UpdateWorkflowOptions feature, it would be easy to add an option and forget to handle it in the merge/update/value-clearing logic. It would be good to have tests that uses protobuf reflection to verify that all possible paths are either handled by the update APIs or intentionally not offered for update/clearing.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Added a test for this, great idea!

@spkane31 spkane31 merged commit 0cbb52d into feature/activity-operator-cmds Apr 13, 2026
41 of 45 checks passed
@spkane31 spkane31 deleted the spk/activity-operator-update-options branch April 13, 2026 21:23
spkane31 added a commit that referenced this pull request Apr 21, 2026
Implements the `UpdateActivityExecutionOptions` RPC for standalone
activities. The workflow-activity path is already supported via the
existing UpdateActivityOptions history service API this PR only wires up
the standalone path end-to-end.

Core changes:

- `chasm/lib/activity/activity.go` — Adds UpdateActivityExecutionOptions
method on Activity:
  - Validates mutual exclusion of `update_mask` / `restore_original`
- `restore_original`: bulk-assigns all fields from the
`original_options` snapshot stored at schedule time
- Field-mask path: applies only the specified fields via
`mergeActivityOptions`
- Stamp invalidation: bumps `attempt.Stamp` to cancel in-flight
`ActivityDispatchTask` and timeout tasks, then re-queues a new dispatch
and schedule-to-start timeout
- Retry interval recalculation: after a retry-policy update, recomputes
`attempt.CurrentRetryInterval` so the re-dispatch fires at the new
(possibly shorter) interval rather than the stale one
- Schedule-to-close update: adds a new `ScheduleToCloseTimeoutTask` at
the updated deadline so a shortened timeout fires immediately
- Adds `original_options` to `ActivityState` proto and populates it in
`NewStandaloneActivity`
- chasm/lib/activity/handler.go — Routes the standalone path to
`chasm.UpdateComponent` to (*Activity).UpdateActivityExecutionOptions
- chasm/lib/activity/frontend.go — Adds input validation
(`validateUpdateActivityExecutionOptionsRequest`: activity ID
required/length, identity length, run ID UUID), and gates the standalone
path behind the Enabled config flag while always permitting the workflow
path

UpdateActivityExecutionOptions is the new unified RPC for updating
activity options for both standalone activities and workflow-embedded
activities.

- [ ] built
- [ ] run locally and tested manually
- [ ] covered by existing tests
- [ ] added new unit test(s)
- [X] added new functional test(s)

Minimal, this is into a feature branch
spkane31 added a commit that referenced this pull request Apr 21, 2026
Implements the `UpdateActivityExecutionOptions` RPC for standalone
activities. The workflow-activity path is already supported via the
existing UpdateActivityOptions history service API this PR only wires up
the standalone path end-to-end.

Core changes:

- `chasm/lib/activity/activity.go` — Adds UpdateActivityExecutionOptions
method on Activity:
  - Validates mutual exclusion of `update_mask` / `restore_original`
- `restore_original`: bulk-assigns all fields from the
`original_options` snapshot stored at schedule time
- Field-mask path: applies only the specified fields via
`mergeActivityOptions`
- Stamp invalidation: bumps `attempt.Stamp` to cancel in-flight
`ActivityDispatchTask` and timeout tasks, then re-queues a new dispatch
and schedule-to-start timeout
- Retry interval recalculation: after a retry-policy update, recomputes
`attempt.CurrentRetryInterval` so the re-dispatch fires at the new
(possibly shorter) interval rather than the stale one
- Schedule-to-close update: adds a new `ScheduleToCloseTimeoutTask` at
the updated deadline so a shortened timeout fires immediately
- Adds `original_options` to `ActivityState` proto and populates it in
`NewStandaloneActivity`
- chasm/lib/activity/handler.go — Routes the standalone path to
`chasm.UpdateComponent` to (*Activity).UpdateActivityExecutionOptions
- chasm/lib/activity/frontend.go — Adds input validation
(`validateUpdateActivityExecutionOptionsRequest`: activity ID
required/length, identity length, run ID UUID), and gates the standalone
path behind the Enabled config flag while always permitting the workflow
path

UpdateActivityExecutionOptions is the new unified RPC for updating
activity options for both standalone activities and workflow-embedded
activities.

- [ ] built
- [ ] run locally and tested manually
- [ ] covered by existing tests
- [ ] added new unit test(s)
- [X] added new functional test(s)

Minimal, this is into a feature branch
spkane31 added a commit that referenced this pull request Apr 28, 2026
Implements the `UpdateActivityExecutionOptions` RPC for standalone
activities. The workflow-activity path is already supported via the
existing UpdateActivityOptions history service API this PR only wires up
the standalone path end-to-end.

Core changes:

- `chasm/lib/activity/activity.go` — Adds UpdateActivityExecutionOptions
method on Activity:
  - Validates mutual exclusion of `update_mask` / `restore_original`
- `restore_original`: bulk-assigns all fields from the
`original_options` snapshot stored at schedule time
- Field-mask path: applies only the specified fields via
`mergeActivityOptions`
- Stamp invalidation: bumps `attempt.Stamp` to cancel in-flight
`ActivityDispatchTask` and timeout tasks, then re-queues a new dispatch
and schedule-to-start timeout
- Retry interval recalculation: after a retry-policy update, recomputes
`attempt.CurrentRetryInterval` so the re-dispatch fires at the new
(possibly shorter) interval rather than the stale one
- Schedule-to-close update: adds a new `ScheduleToCloseTimeoutTask` at
the updated deadline so a shortened timeout fires immediately
- Adds `original_options` to `ActivityState` proto and populates it in
`NewStandaloneActivity`
- chasm/lib/activity/handler.go — Routes the standalone path to
`chasm.UpdateComponent` to (*Activity).UpdateActivityExecutionOptions
- chasm/lib/activity/frontend.go — Adds input validation
(`validateUpdateActivityExecutionOptionsRequest`: activity ID
required/length, identity length, run ID UUID), and gates the standalone
path behind the Enabled config flag while always permitting the workflow
path

UpdateActivityExecutionOptions is the new unified RPC for updating
activity options for both standalone activities and workflow-embedded
activities.

- [ ] built
- [ ] run locally and tested manually
- [ ] covered by existing tests
- [ ] added new unit test(s)
- [X] added new functional test(s)

Minimal, this is into a feature branch
spkane31 added a commit that referenced this pull request Apr 29, 2026
Implements the `UpdateActivityExecutionOptions` RPC for standalone
activities. The workflow-activity path is already supported via the
existing UpdateActivityOptions history service API this PR only wires up
the standalone path end-to-end.

Core changes:

- `chasm/lib/activity/activity.go` — Adds UpdateActivityExecutionOptions
method on Activity:
  - Validates mutual exclusion of `update_mask` / `restore_original`
- `restore_original`: bulk-assigns all fields from the
`original_options` snapshot stored at schedule time
- Field-mask path: applies only the specified fields via
`mergeActivityOptions`
- Stamp invalidation: bumps `attempt.Stamp` to cancel in-flight
`ActivityDispatchTask` and timeout tasks, then re-queues a new dispatch
and schedule-to-start timeout
- Retry interval recalculation: after a retry-policy update, recomputes
`attempt.CurrentRetryInterval` so the re-dispatch fires at the new
(possibly shorter) interval rather than the stale one
- Schedule-to-close update: adds a new `ScheduleToCloseTimeoutTask` at
the updated deadline so a shortened timeout fires immediately
- Adds `original_options` to `ActivityState` proto and populates it in
`NewStandaloneActivity`
- chasm/lib/activity/handler.go — Routes the standalone path to
`chasm.UpdateComponent` to (*Activity).UpdateActivityExecutionOptions
- chasm/lib/activity/frontend.go — Adds input validation
(`validateUpdateActivityExecutionOptionsRequest`: activity ID
required/length, identity length, run ID UUID), and gates the standalone
path behind the Enabled config flag while always permitting the workflow
path

UpdateActivityExecutionOptions is the new unified RPC for updating
activity options for both standalone activities and workflow-embedded
activities.

- [ ] built
- [ ] run locally and tested manually
- [ ] covered by existing tests
- [ ] added new unit test(s)
- [X] added new functional test(s)

Minimal, this is into a feature branch
spkane31 added a commit that referenced this pull request Apr 29, 2026
Implements the `UpdateActivityExecutionOptions` RPC for standalone
activities. The workflow-activity path is already supported via the
existing UpdateActivityOptions history service API this PR only wires up
the standalone path end-to-end.

Core changes:

- `chasm/lib/activity/activity.go` — Adds UpdateActivityExecutionOptions
method on Activity:
  - Validates mutual exclusion of `update_mask` / `restore_original`
- `restore_original`: bulk-assigns all fields from the
`original_options` snapshot stored at schedule time
- Field-mask path: applies only the specified fields via
`mergeActivityOptions`
- Stamp invalidation: bumps `attempt.Stamp` to cancel in-flight
`ActivityDispatchTask` and timeout tasks, then re-queues a new dispatch
and schedule-to-start timeout
- Retry interval recalculation: after a retry-policy update, recomputes
`attempt.CurrentRetryInterval` so the re-dispatch fires at the new
(possibly shorter) interval rather than the stale one
- Schedule-to-close update: adds a new `ScheduleToCloseTimeoutTask` at
the updated deadline so a shortened timeout fires immediately
- Adds `original_options` to `ActivityState` proto and populates it in
`NewStandaloneActivity`
- chasm/lib/activity/handler.go — Routes the standalone path to
`chasm.UpdateComponent` to (*Activity).UpdateActivityExecutionOptions
- chasm/lib/activity/frontend.go — Adds input validation
(`validateUpdateActivityExecutionOptionsRequest`: activity ID
required/length, identity length, run ID UUID), and gates the standalone
path behind the Enabled config flag while always permitting the workflow
path

UpdateActivityExecutionOptions is the new unified RPC for updating
activity options for both standalone activities and workflow-embedded
activities.

- [ ] built
- [ ] run locally and tested manually
- [ ] covered by existing tests
- [ ] added new unit test(s)
- [X] added new functional test(s)

Minimal, this is into a feature branch
spkane31 added a commit that referenced this pull request May 11, 2026
Implements the `UpdateActivityExecutionOptions` RPC for standalone
activities. The workflow-activity path is already supported via the
existing UpdateActivityOptions history service API this PR only wires up
the standalone path end-to-end.

Core changes:

- `chasm/lib/activity/activity.go` — Adds UpdateActivityExecutionOptions
method on Activity:
  - Validates mutual exclusion of `update_mask` / `restore_original`
- `restore_original`: bulk-assigns all fields from the
`original_options` snapshot stored at schedule time
- Field-mask path: applies only the specified fields via
`mergeActivityOptions`
- Stamp invalidation: bumps `attempt.Stamp` to cancel in-flight
`ActivityDispatchTask` and timeout tasks, then re-queues a new dispatch
and schedule-to-start timeout
- Retry interval recalculation: after a retry-policy update, recomputes
`attempt.CurrentRetryInterval` so the re-dispatch fires at the new
(possibly shorter) interval rather than the stale one
- Schedule-to-close update: adds a new `ScheduleToCloseTimeoutTask` at
the updated deadline so a shortened timeout fires immediately
- Adds `original_options` to `ActivityState` proto and populates it in
`NewStandaloneActivity`
- chasm/lib/activity/handler.go — Routes the standalone path to
`chasm.UpdateComponent` to (*Activity).UpdateActivityExecutionOptions
- chasm/lib/activity/frontend.go — Adds input validation
(`validateUpdateActivityExecutionOptionsRequest`: activity ID
required/length, identity length, run ID UUID), and gates the standalone
path behind the Enabled config flag while always permitting the workflow
path

UpdateActivityExecutionOptions is the new unified RPC for updating
activity options for both standalone activities and workflow-embedded
activities.

- [ ] built
- [ ] run locally and tested manually
- [ ] covered by existing tests
- [ ] added new unit test(s)
- [X] added new functional test(s)

Minimal, this is into a feature branch
spkane31 added a commit that referenced this pull request May 12, 2026
Implements the `UpdateActivityExecutionOptions` RPC for standalone
activities. The workflow-activity path is already supported via the
existing UpdateActivityOptions history service API this PR only wires up
the standalone path end-to-end.

Core changes:

- `chasm/lib/activity/activity.go` — Adds UpdateActivityExecutionOptions
method on Activity:
  - Validates mutual exclusion of `update_mask` / `restore_original`
- `restore_original`: bulk-assigns all fields from the
`original_options` snapshot stored at schedule time
- Field-mask path: applies only the specified fields via
`mergeActivityOptions`
- Stamp invalidation: bumps `attempt.Stamp` to cancel in-flight
`ActivityDispatchTask` and timeout tasks, then re-queues a new dispatch
and schedule-to-start timeout
- Retry interval recalculation: after a retry-policy update, recomputes
`attempt.CurrentRetryInterval` so the re-dispatch fires at the new
(possibly shorter) interval rather than the stale one
- Schedule-to-close update: adds a new `ScheduleToCloseTimeoutTask` at
the updated deadline so a shortened timeout fires immediately
- Adds `original_options` to `ActivityState` proto and populates it in
`NewStandaloneActivity`
- chasm/lib/activity/handler.go — Routes the standalone path to
`chasm.UpdateComponent` to (*Activity).UpdateActivityExecutionOptions
- chasm/lib/activity/frontend.go — Adds input validation
(`validateUpdateActivityExecutionOptionsRequest`: activity ID
required/length, identity length, run ID UUID), and gates the standalone
path behind the Enabled config flag while always permitting the workflow
path

UpdateActivityExecutionOptions is the new unified RPC for updating
activity options for both standalone activities and workflow-embedded
activities.

- [ ] built
- [ ] run locally and tested manually
- [ ] covered by existing tests
- [ ] added new unit test(s)
- [X] added new functional test(s)

Minimal, this is into a feature branch
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

4 participants