From aa8e2570b4c832fad2adb80352fc4295fe373175 Mon Sep 17 00:00:00 2001 From: goutamadwant Date: Thu, 19 Nov 2026 00:06:09 -0800 Subject: [PATCH] Preserve workflow definitions in realm export and import Validate imported workflows, handle incomplete legacy exports, mask declared step secrets, and defer workflow timer updates until commit. Closes #50972 Signed-off-by: goutamadwant --- .../idm/RealmRepresentation.java | 10 + .../topics/workflows/managing-workflows.adoc | 23 +- .../topics/changes/changes-27_0_0.adoc | 19 + .../workflow/DefaultWorkflowProvider.java | 44 +- .../workflow/ScheduledWorkflowRunner.java | 10 +- .../WorkflowScheduleEventListener.java | 2 +- .../workflow/ScheduledWorkflowRunnerTest.java | 61 +++ .../exportimport/util/ExportUtils.java | 13 + .../util/WorkflowExportImportUtils.java | 126 +++++ .../datastore/DefaultExportImportManager.java | 13 + .../keycloak/exportimport/ExportOptions.java | 9 + .../models/utils/StripSecretsUtils.java | 18 + .../models/utils/StripSecretsUtilsTest.java | 22 + .../resources/admin/RealmAdminResource.java | 1 + .../WorkflowExportImportDisabledTest.java | 157 ++++++ .../workflow/WorkflowExportImportTest.java | 516 ++++++++++++++++++ 16 files changed, 1024 insertions(+), 20 deletions(-) create mode 100644 model/jpa/src/test/java/org/keycloak/models/workflow/ScheduledWorkflowRunnerTest.java create mode 100644 model/storage-private/src/main/java/org/keycloak/exportimport/util/WorkflowExportImportUtils.java create mode 100644 tests/base/src/test/java/org/keycloak/tests/workflow/WorkflowExportImportDisabledTest.java create mode 100644 tests/base/src/test/java/org/keycloak/tests/workflow/WorkflowExportImportTest.java diff --git a/core/src/main/java/org/keycloak/representations/idm/RealmRepresentation.java b/core/src/main/java/org/keycloak/representations/idm/RealmRepresentation.java index df2b2367d807..ac8c03cc1f54 100755 --- a/core/src/main/java/org/keycloak/representations/idm/RealmRepresentation.java +++ b/core/src/main/java/org/keycloak/representations/idm/RealmRepresentation.java @@ -28,6 +28,7 @@ import org.keycloak.common.util.MultivaluedHashMap; import org.keycloak.json.KeycloakJsonMapperFactory; import org.keycloak.json.RawJsonValue; +import org.keycloak.representations.workflows.WorkflowRepresentation; import com.fasterxml.jackson.annotation.JsonIgnore; import com.fasterxml.jackson.annotation.JsonProperty; @@ -202,6 +203,7 @@ public class RealmRepresentation { private List identityProviderMappers; private List protocolMappers; private MultivaluedHashMap components; + private List workflows; protected Boolean internationalizationEnabled; protected Set supportedLocales; protected String defaultLocale; @@ -1482,6 +1484,14 @@ public void setComponents(MultivaluedHashMap getWorkflows() { + return workflows; + } + + public void setWorkflows(List workflows) { + this.workflows = workflows; + } + @JsonIgnore public boolean isIdentityFederationEnabled() { return identityProviders != null && !identityProviders.isEmpty(); diff --git a/docs/documentation/server_admin/topics/workflows/managing-workflows.adoc b/docs/documentation/server_admin/topics/workflows/managing-workflows.adoc index 6d20fe17647e..c9e96327bad2 100644 --- a/docs/documentation/server_admin/topics/workflows/managing-workflows.adoc +++ b/docs/documentation/server_admin/topics/workflows/managing-workflows.adoc @@ -9,6 +9,27 @@ Workflows can be managed through the Admin Console or the Admin REST API. Only realm administrators with the appropriate permissions can manage workflows as they are considered sensitive operations. For more details, see <<_understanding_different_types_realm_admins_,Understanding different types of Realm Admins>>. +== Exporting and importing workflow definitions + +Realm exports include workflow definitions in the `workflows` array. +Realm imports restore these definitions through the workflow provider, using the same validation as workflow creation. +For an Admin Console or Admin REST API realm export, workflow definitions are included only for realm administrators who can access the Workflows API. +Secret properties declared by workflow step providers are masked in administrative exports; command-line exports retain them. + +Exported definitions include workflow settings and step configuration, but not in-progress workflow executions. +Step identifiers are regenerated on import. +Workflows are restored after the other realm resources, so restoring users does not activate the imported workflows. +The workflows feature must be enabled to import workflow definitions. +When the feature is disabled, command-line exports preserve stored workflow definitions in the legacy component format; administrative exports omit them. +Restoring retained definitions requires enabling the workflows feature again. + +Complete workflow component definitions from older realm exports are also accepted. +Configuration already omitted by an older administrative export cannot be recovered. +Legacy workflow components with no configuration are skipped with a warning so the rest of the realm can be imported. +Do not combine complete legacy workflow components and the `workflows` array in the same import. +Importing workflows into an existing realm through the partial-import endpoint (`POST /admin/realms/\{realm}/partialImport`) or the realm-update endpoint (`PUT /admin/realms/\{realm}`) is not supported; both endpoints ignore the `workflows` field. +Use the Workflows Admin API to manage definitions in an existing realm. + == Managing workflows through the Admin Console To manage workflows through the Admin Console, you can follow these steps: @@ -61,5 +82,3 @@ will not be processed further, and they would need to be re-associated with a ne - - diff --git a/docs/documentation/upgrading/topics/changes/changes-27_0_0.adoc b/docs/documentation/upgrading/topics/changes/changes-27_0_0.adoc index 89d5f2515499..143ff55ef8b5 100644 --- a/docs/documentation/upgrading/topics/changes/changes-27_0_0.adoc +++ b/docs/documentation/upgrading/topics/changes/changes-27_0_0.adoc @@ -58,6 +58,25 @@ Use the Admin REST API to manage realm default roles and full scope when the pol This migration installs a new client registration policy provider that earlier nodes do not know. A rolling upgrade is therefore not supported for this change; shut down the cluster and upgrade all nodes together (or use a recreate update) so that older nodes never process Dynamic Client Registration requests against the new policy components. +=== Workflow definitions in realm exports +// https://github.com/keycloak/keycloak/issues/50972 + +With the workflows feature enabled, realm exports now include workflow definitions in a top-level `workflows` array instead of under `components` with the type `org.keycloak.models.workflow.WorkflowProvider`. +The field is omitted when no workflows are exported. +Update tools that read workflow definitions from realm JSON to use the new field. +Administrative exports require the same realm-administrator permissions as the Workflows Admin API and mask declared workflow step secrets; command-line exports retain those secrets. + +Full realm imports restore definitions through the workflow provider and apply workflow creation validation. +Complete legacy workflow components are still accepted, but must not be combined with definitions in the new `workflows` field. +Legacy workflow components with missing or empty configuration, as produced by affected administrative exports, are skipped with a warning identifying the component. +The lost configuration cannot be recovered. +Other invalid workflow definitions cause the realm import to fail. + +The workflows feature must be enabled to restore workflow definitions. +When it is disabled, command-line exports retain stored definitions as legacy components, while administrative exports omit them. +Imports restore definitions only, not in-progress executions, and regenerate step identifiers. +The partial-import and realm-update endpoints ignore the `workflows` field; use the Workflows Admin API to manage workflows in an existing realm. + === PAR metadata omitted when PAR is disabled When the `par` feature is disabled, OpenID Connect discovery now omits `pushed_authorization_request_endpoint` from both the top-level metadata and `mtls_endpoint_aliases`, and omits `require_pushed_authorization_requests`. diff --git a/model/jpa/src/main/java/org/keycloak/models/workflow/DefaultWorkflowProvider.java b/model/jpa/src/main/java/org/keycloak/models/workflow/DefaultWorkflowProvider.java index 15fc67c94e04..dc3f5eb4ddbc 100644 --- a/model/jpa/src/main/java/org/keycloak/models/workflow/DefaultWorkflowProvider.java +++ b/model/jpa/src/main/java/org/keycloak/models/workflow/DefaultWorkflowProvider.java @@ -15,6 +15,7 @@ import org.keycloak.common.util.Time; import org.keycloak.component.ComponentFactory; import org.keycloak.component.ComponentModel; +import org.keycloak.models.AbstractKeycloakTransaction; import org.keycloak.models.KeycloakSession; import org.keycloak.models.KeycloakSessionFactory; import org.keycloak.models.ModelValidationException; @@ -107,8 +108,7 @@ public void updateWorkflow(Workflow workflow, WorkflowRepresentation representat // finally, update the workflow's config along with the steps' configs workflow.updateConfig(representation.getConfig(), newSteps); - cancelScheduledWorkflow(workflow); - scheduleWorkflow(workflow); + rescheduleWorkflow(workflow); notifyScheduleChange(workflow, false); } } @@ -487,16 +487,34 @@ private Workflow addWorkflow(Workflow workflow) { private void scheduleWorkflow(Workflow workflow) { String scheduled = workflow.getConfig().getFirst(WorkflowConstants.CONFIG_SCHEDULE_AFTER); - - if (workflow.isEnabled() && scheduled != null) { - initLastScheduleRun(workflow); - int intervalSecs = (int) DurationConverter.parseDuration(scheduled).toSeconds(); - int initialDelaySecs = ScheduledWorkflowRunner.computeInitialDelay(workflow, intervalSecs); - TimerProvider timer = session.getProvider(TimerProvider.class); - ScheduledWorkflowRunner runner = new ScheduledWorkflowRunner(workflow.getId(), realm.getId(), intervalSecs); - timer.scheduleTask(runner, initialDelaySecs * 1000L, intervalSecs * 1000L); - scheduleLog.debugf("Scheduled workflow '%s' with interval %d s, initial delay %d s", workflow.getName(), intervalSecs, initialDelaySecs); + if (!workflow.isEnabled() || scheduled == null) { + return; } + int intervalSecs = (int) DurationConverter.parseDuration(scheduled).toSeconds(); + initLastScheduleRun(workflow); + int lastScheduleRun = ScheduledWorkflowRunner.getLastScheduleRun(workflow); + TimerProvider timer = session.getProvider(TimerProvider.class); + ScheduledWorkflowRunner runner = new ScheduledWorkflowRunner(workflow.getId(), realm.getId(), intervalSecs); + String workflowName = workflow.getName(); + runAfterCommit(() -> { + long initialDelaySecs = ScheduledWorkflowRunner.computeInitialDelay(lastScheduleRun, intervalSecs); + timer.scheduleTask(runner, initialDelaySecs * 1000L, intervalSecs * 1000L); + scheduleLog.debugf("Scheduled workflow '%s' with interval %d s, initial delay %d s", workflowName, intervalSecs, initialDelaySecs); + }); + } + + private void runAfterCommit(Runnable task) { + // A later operation can still roll back this transaction; leave the existing timer untouched. + session.getTransactionManager().enlistAfterCompletion(new AbstractKeycloakTransaction() { + @Override + protected void commitImpl() { + task.run(); + } + + @Override + protected void rollbackImpl() { + } + }); } private void initLastScheduleRun(Workflow workflow) { @@ -508,7 +526,9 @@ private void initLastScheduleRun(Workflow workflow) { } void cancelScheduledWorkflow(Workflow workflow) { - session.getProvider(TimerProvider.class).cancelTask(ScheduledWorkflowRunner.taskName(workflow.getId())); + TimerProvider timer = session.getProvider(TimerProvider.class); + String taskName = ScheduledWorkflowRunner.taskName(workflow.getId()); + runAfterCommit(() -> timer.cancelTask(taskName)); } void rescheduleWorkflow(Workflow workflow) { diff --git a/model/jpa/src/main/java/org/keycloak/models/workflow/ScheduledWorkflowRunner.java b/model/jpa/src/main/java/org/keycloak/models/workflow/ScheduledWorkflowRunner.java index 2383e8470db2..5210bca6b9e1 100644 --- a/model/jpa/src/main/java/org/keycloak/models/workflow/ScheduledWorkflowRunner.java +++ b/model/jpa/src/main/java/org/keycloak/models/workflow/ScheduledWorkflowRunner.java @@ -147,17 +147,17 @@ static int getLastScheduleRun(Workflow workflow) { return val == null ? 0 : Integer.parseInt(val); } - static int computeInitialDelay(Workflow workflow, int intervalSecs) { + static long computeInitialDelay(Workflow workflow, int intervalSecs) { return computeInitialDelay(getLastScheduleRun(workflow), intervalSecs); } - static int computeInitialDelay(int lastRunSecs, int intervalSecs) { + static long computeInitialDelay(int lastRunSecs, int intervalSecs) { if (lastRunSecs <= 0) { return intervalSecs; } - int nextFireTime = lastRunSecs + intervalSecs; - int delay = nextFireTime - Time.currentTime(); - return Math.max(0, delay); + long nextFireTime = (long) lastRunSecs + intervalSecs; + long delay = nextFireTime - Time.currentTime(); + return Math.max(0L, delay); } } diff --git a/model/jpa/src/main/java/org/keycloak/models/workflow/WorkflowScheduleEventListener.java b/model/jpa/src/main/java/org/keycloak/models/workflow/WorkflowScheduleEventListener.java index 8121cb83d183..27f893404cb4 100644 --- a/model/jpa/src/main/java/org/keycloak/models/workflow/WorkflowScheduleEventListener.java +++ b/model/jpa/src/main/java/org/keycloak/models/workflow/WorkflowScheduleEventListener.java @@ -73,7 +73,7 @@ private void rescheduleWorkflow(KeycloakSession session, WorkflowScheduleCluster int intervalSecs = workflowEvent.getIntervalSecs(); int lastScheduleRun = workflowEvent.getLastScheduleRun(); - int initialDelaySecs = ScheduledWorkflowRunner.computeInitialDelay(lastScheduleRun, intervalSecs); + long initialDelaySecs = ScheduledWorkflowRunner.computeInitialDelay(lastScheduleRun, intervalSecs); String realmId = session.getContext().getRealm().getId(); ScheduledWorkflowRunner runner = new ScheduledWorkflowRunner(workflowId, realmId, intervalSecs); timer.scheduleTask(runner, initialDelaySecs * 1000L, intervalSecs * 1000L); diff --git a/model/jpa/src/test/java/org/keycloak/models/workflow/ScheduledWorkflowRunnerTest.java b/model/jpa/src/test/java/org/keycloak/models/workflow/ScheduledWorkflowRunnerTest.java new file mode 100644 index 000000000000..bf3d5fc90d89 --- /dev/null +++ b/model/jpa/src/test/java/org/keycloak/models/workflow/ScheduledWorkflowRunnerTest.java @@ -0,0 +1,61 @@ +/* + * Copyright 2026 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.keycloak.models.workflow; + +import org.keycloak.common.util.Time; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +public class ScheduledWorkflowRunnerTest { + + @Test + public void testWithoutPreviousRun() { + assertEquals(Integer.MAX_VALUE, ScheduledWorkflowRunner.computeInitialDelay(0, Integer.MAX_VALUE)); + } + + @Test + public void testMaximumInterval() { + assertDelay(Time.currentTime(), Integer.MAX_VALUE); + } + + @Test + public void testPreviousRunAheadOfLocalClock() { + assertDelay(Time.currentTime() + 60, Integer.MAX_VALUE); + } + + @Test + public void testOverdueRun() { + assertDelay(Time.currentTime() - 120, 60); + } + + @Test + public void testOrdinaryInterval() { + assertDelay(Time.currentTime() - 10, 60); + } + + private static void assertDelay(int lastRun, int interval) { + int before = Time.currentTime(); + long delay = ScheduledWorkflowRunner.computeInitialDelay(lastRun, interval); + int after = Time.currentTime(); + long nextRun = (long) lastRun + interval; + assertTrue("Delay must not be shortened by overflow", delay >= Math.max(0L, nextRun - after)); + assertTrue("Delay must not exceed the remaining interval", delay <= Math.max(0L, nextRun - before)); + } +} diff --git a/model/storage-private/src/main/java/org/keycloak/exportimport/util/ExportUtils.java b/model/storage-private/src/main/java/org/keycloak/exportimport/util/ExportUtils.java index 57885faa3a18..07e227b23c89 100755 --- a/model/storage-private/src/main/java/org/keycloak/exportimport/util/ExportUtils.java +++ b/model/storage-private/src/main/java/org/keycloak/exportimport/util/ExportUtils.java @@ -48,6 +48,7 @@ import org.keycloak.models.RoleModel; import org.keycloak.models.UserModel; import org.keycloak.models.utils.ModelToRepresentation; +import org.keycloak.models.workflow.WorkflowProvider; import org.keycloak.organization.OrganizationProvider; import org.keycloak.representations.idm.ClientRepresentation; import org.keycloak.representations.idm.ComponentExportRepresentation; @@ -254,8 +255,20 @@ public static RealmRepresentation exportRealm(KeycloakSession session, RealmMode // components MultivaluedHashMap components = exportComponents(realm, realm.getId()); + boolean keepLegacyComponents = !Profile.isFeatureEnabled(Feature.WORKFLOWS) + && !options.isPartial() && options.isWorkflowsIncluded(); + if (!keepLegacyComponents) { + components.remove(WorkflowProvider.class.getName()); + } rep.setComponents(components); + if (options.isWorkflowsIncluded() && Profile.isFeatureEnabled(Feature.WORKFLOWS)) { + var workflows = WorkflowExportImportUtils.exportWorkflows(session, realm); + if (!workflows.isEmpty()) { + rep.setWorkflows(workflows); + } + } + // Message Bundle rep.setLocalizationTexts(realm.getRealmLocalizationTexts()); diff --git a/model/storage-private/src/main/java/org/keycloak/exportimport/util/WorkflowExportImportUtils.java b/model/storage-private/src/main/java/org/keycloak/exportimport/util/WorkflowExportImportUtils.java new file mode 100644 index 000000000000..3fd245282aff --- /dev/null +++ b/model/storage-private/src/main/java/org/keycloak/exportimport/util/WorkflowExportImportUtils.java @@ -0,0 +1,126 @@ +/* + * Copyright 2026 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.keycloak.exportimport.util; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; +import java.util.Objects; +import java.util.function.Function; + +import org.keycloak.common.Profile; +import org.keycloak.models.KeycloakSession; +import org.keycloak.models.ModelException; +import org.keycloak.models.RealmModel; +import org.keycloak.models.workflow.WorkflowProvider; +import org.keycloak.models.workflow.WorkflowStep; +import org.keycloak.models.workflow.WorkflowStepProvider; +import org.keycloak.representations.idm.ComponentExportRepresentation; +import org.keycloak.representations.idm.RealmRepresentation; +import org.keycloak.representations.workflows.WorkflowRepresentation; +import org.keycloak.representations.workflows.WorkflowStepRepresentation; + +import org.jboss.logging.Logger; + +/** Converts workflow definitions through their provider rather than the generic component importer. */ +public final class WorkflowExportImportUtils { + + private static final Logger logger = Logger.getLogger(WorkflowExportImportUtils.class); + + private WorkflowExportImportUtils() { + } + + public static List exportWorkflows(KeycloakSession session, RealmModel realm) { + return withProvider(session, realm, provider -> provider.getWorkflows().map(provider::toRepresentation).toList()); + } + + private static T withProvider(KeycloakSession session, RealmModel realm, Function action) { + RealmModel previousRealm = session.getContext().getRealm(); + session.getContext().setRealm(realm); + // A session may export several realms; a cached provider retains its original realm. + try { + WorkflowProvider provider = session.getKeycloakSessionFactory().getProviderFactory(WorkflowProvider.class).create(session); + try { + return action.apply(provider); + } finally { + provider.close(); + } + } finally { + session.getContext().setRealm(previousRealm); + } + } + + public static void importWorkflows(KeycloakSession session, RealmModel realm, RealmRepresentation representation) { + List workflows = new ArrayList<>(); + if (representation.getWorkflows() != null) { + workflows.addAll(representation.getWorkflows()); + } + + if (representation.getComponents() != null) { + List legacy = representation.getComponents().get(WorkflowProvider.class.getName()); + if (legacy != null && !legacy.isEmpty()) { + List legacyWorkflows = legacy.stream().map(WorkflowExportImportUtils::fromComponent) + .filter(Objects::nonNull).toList(); + if (!workflows.isEmpty() && !legacyWorkflows.isEmpty()) { + throw new ModelException("Realm contains both workflow definitions and legacy workflow components"); + } + workflows.addAll(legacyWorkflows); + } + } + + if (workflows.isEmpty()) { + return; + } + if (!Profile.isFeatureEnabled(Profile.Feature.WORKFLOWS)) { + throw new ModelException("Cannot import workflow definitions when the workflows feature is disabled"); + } + + withProvider(session, realm, provider -> { + workflows.forEach(provider::toModel); + return null; + }); + } + + private static WorkflowRepresentation fromComponent(ComponentExportRepresentation component) { + if (!"default".equals(component.getProviderId())) { + throw new ModelException("Legacy workflow component " + component.getId() + " has an unsupported provider: " + component.getProviderId()); + } + if (component.getConfig() == null || component.getConfig().isEmpty()) { + logger.warnf("Skipping legacy workflow component %s with no configuration. Configuration omitted by an older administrative export cannot be restored.", + component.getId()); + return null; + } + + List steps = new ArrayList<>(); + if (component.getSubComponents() != null) { + component.getSubComponents().forEach((type, components) -> { + if (!WorkflowStepProvider.class.getName().equals(type)) { + throw new ModelException("Unsupported workflow sub-component type: " + type); + } + components.stream().sorted(Comparator.comparingInt(step -> + new WorkflowStep(step.getProviderId(), step.getConfig()).getPriority())) + .forEach(step -> { + if (step.getSubComponents() != null && !step.getSubComponents().isEmpty()) { + throw new ModelException("Workflow steps cannot contain sub-components"); + } + steps.add(new WorkflowStepRepresentation(step.getId(), step.getProviderId(), step.getConfig())); + }); + }); + } + return new WorkflowRepresentation(component.getId(), component.getConfig().getFirst("name"), component.getConfig(), steps); + } +} diff --git a/model/storage-private/src/main/java/org/keycloak/storage/datastore/DefaultExportImportManager.java b/model/storage-private/src/main/java/org/keycloak/storage/datastore/DefaultExportImportManager.java index 15f255da4996..448805c39c40 100644 --- a/model/storage-private/src/main/java/org/keycloak/storage/datastore/DefaultExportImportManager.java +++ b/model/storage-private/src/main/java/org/keycloak/storage/datastore/DefaultExportImportManager.java @@ -46,6 +46,7 @@ import org.keycloak.exportimport.ExportAdapter; import org.keycloak.exportimport.ExportOptions; import org.keycloak.exportimport.util.ExportUtils; +import org.keycloak.exportimport.util.WorkflowExportImportUtils; import org.keycloak.keys.KeyProvider; import org.keycloak.migration.MigrationProvider; import org.keycloak.migration.ModelVersion; @@ -89,6 +90,8 @@ import org.keycloak.models.utils.KeycloakModelUtils; import org.keycloak.models.utils.ProtocolMapperValidationUtil; import org.keycloak.models.utils.RepresentationToModel; +import org.keycloak.models.workflow.WorkflowProvider; +import org.keycloak.models.workflow.WorkflowStepProvider; import org.keycloak.organization.OrganizationProvider; import org.keycloak.organization.validation.OrganizationsValidation; import org.keycloak.partialimport.PartialImportResults; @@ -551,6 +554,7 @@ public void importRealm(RealmRepresentation rep, RealmModel newRealm, Runnable u } importOrganizations(rep, newRealm); + WorkflowExportImportUtils.importWorkflows(session, newRealm, rep); } @Override @@ -1324,6 +1328,15 @@ public static ComponentModel convertFedProviderToComponent(String realmId, UserF protected static void importComponents(RealmModel newRealm, MultivaluedHashMap components, String parentId) { for (Map.Entry> entry : components.entrySet()) { String providerType = entry.getKey(); + if (WorkflowProvider.class.getName().equals(providerType)) { + if (!newRealm.getId().equals(parentId)) { + throw new ModelException("Workflows must be top-level realm components"); + } + continue; + } + if (WorkflowStepProvider.class.getName().equals(providerType)) { + throw new ModelException("Workflow steps must belong to a workflow"); + } for (ComponentExportRepresentation compRep : entry.getValue()) { ComponentModel component = new ComponentModel(); component.setId(compRep.getId()); diff --git a/server-spi-private/src/main/java/org/keycloak/exportimport/ExportOptions.java b/server-spi-private/src/main/java/org/keycloak/exportimport/ExportOptions.java index edcf94183314..4aa968e202d0 100644 --- a/server-spi-private/src/main/java/org/keycloak/exportimport/ExportOptions.java +++ b/server-spi-private/src/main/java/org/keycloak/exportimport/ExportOptions.java @@ -27,6 +27,7 @@ public class ExportOptions { private boolean groupsAndRolesIncluded = true; private boolean onlyServiceAccountsIncluded = false; private boolean partial; + private boolean workflowsIncluded = true; public ExportOptions() { } @@ -74,4 +75,12 @@ public void setOnlyServiceAccountsIncluded(boolean value) { public boolean isPartial() { return partial; } + + public boolean isWorkflowsIncluded() { + return workflowsIncluded; + } + + public void setWorkflowsIncluded(boolean workflowsIncluded) { + this.workflowsIncluded = workflowsIncluded; + } } diff --git a/server-spi-private/src/main/java/org/keycloak/models/utils/StripSecretsUtils.java b/server-spi-private/src/main/java/org/keycloak/models/utils/StripSecretsUtils.java index e75d27b1994a..5c6bbf2a79a8 100644 --- a/server-spi-private/src/main/java/org/keycloak/models/utils/StripSecretsUtils.java +++ b/server-spi-private/src/main/java/org/keycloak/models/utils/StripSecretsUtils.java @@ -39,6 +39,7 @@ import org.keycloak.common.util.MultivaluedHashMap; import org.keycloak.models.ClientSecretConstants; import org.keycloak.models.KeycloakSession; +import org.keycloak.models.workflow.WorkflowStepProvider; import org.keycloak.provider.ProviderConfigProperty; import org.keycloak.representations.idm.AuthenticatorConfigRepresentation; import org.keycloak.representations.idm.CertificateRepresentation; @@ -221,6 +222,23 @@ protected static void stripRealm(KeycloakSession session, RealmRepresentation re .forEach((providerType, componentList)-> componentList .forEach(component -> stripComponentExport(session, providerType, component, fnGetConfigProperties)))); + Optional.ofNullable(rep.getWorkflows()).ifPresent(workflows -> workflows.forEach(workflow -> + Optional.ofNullable(workflow.getSteps()).ifPresent(steps -> steps.forEach(step -> { + if (step.getConfig() == null) { + return; + } + Map properties = fnGetConfigProperties.getComponentProperties( + session, WorkflowStepProvider.class.getName(), step.getUses()); + properties.values().stream().filter(ProviderConfigProperty::isSecret).forEach(property -> { + if (step.getConfig().containsKey(property.getName())) { + List values = step.getConfig().get(property.getName()); + step.getConfig().put(property.getName(), values == null || values.isEmpty() + ? Collections.singletonList(ComponentRepresentation.SECRET_VALUE) + : values.stream().map(StripSecretsUtils::maskNonVaultValue).collect(Collectors.toList())); + } + }); + })))); + Optional.ofNullable(rep.getUsers()) .ifPresent(users -> users.forEach(StripSecretsUtils::stripUser)); diff --git a/server-spi-private/src/test/java/org/keycloak/models/utils/StripSecretsUtilsTest.java b/server-spi-private/src/test/java/org/keycloak/models/utils/StripSecretsUtilsTest.java index c2e66847ce3f..c3fbc5588e4e 100644 --- a/server-spi-private/src/test/java/org/keycloak/models/utils/StripSecretsUtilsTest.java +++ b/server-spi-private/src/test/java/org/keycloak/models/utils/StripSecretsUtilsTest.java @@ -21,6 +21,7 @@ import java.util.Arrays; import java.util.Collections; import java.util.HashMap; +import java.util.List; import java.util.Map; import java.util.Set; import java.util.stream.Stream; @@ -38,6 +39,8 @@ import org.keycloak.representations.idm.IdentityProviderRepresentation; import org.keycloak.representations.idm.RealmRepresentation; import org.keycloak.representations.idm.UserRepresentation; +import org.keycloak.representations.workflows.WorkflowRepresentation; +import org.keycloak.representations.workflows.WorkflowStepRepresentation; import org.junit.Test; @@ -47,6 +50,25 @@ public class StripSecretsUtilsTest { + @Test + public void stripWorkflowStepSecrets() { + MultivaluedHashMap config = new MultivaluedHashMap<>(); + config.put("token", List.of("plain-text", "${vault.token}")); + config.putSingle("message", "Reminder"); + WorkflowStepRepresentation step = new WorkflowStepRepresentation("step", "custom", config); + RealmRepresentation realm = new RealmRepresentation(); + realm.setWorkflows(List.of(WorkflowRepresentation.withName("reminder").withSteps(step).build())); + ProviderConfigProperty secret = new ProviderConfigProperty(); + secret.setName("token"); + secret.setSecret(true); + + StripSecretsUtils.stripRealm(null, realm, (session, type, id) -> Map.of("token", secret)); + + assertEquals(List.of(ComponentRepresentation.SECRET_VALUE, "${vault.token}"), step.getConfig().get("token")); + assertEquals("Reminder", step.getConfig().getFirst("message")); + assertEquals(List.of("plain-text", "${vault.token}"), config.get("token")); + } + @Test public void checkStrippedRotatedSecret() { ClientRepresentation stripped = StripSecretsUtils.stripSecrets(null, createClient("unmasked_secret")); diff --git a/services/src/main/java/org/keycloak/services/resources/admin/RealmAdminResource.java b/services/src/main/java/org/keycloak/services/resources/admin/RealmAdminResource.java index 4e9a0fb4745d..08304af22d2f 100644 --- a/services/src/main/java/org/keycloak/services/resources/admin/RealmAdminResource.java +++ b/services/src/main/java/org/keycloak/services/resources/admin/RealmAdminResource.java @@ -1423,6 +1423,7 @@ public Response partialExport(@QueryParam("exportGroupsAndRoles") Boolean export // this means that if clients is true but groups/roles is false the service account is exported without roles // the other option is just include service accounts if clientsExported && groupsAndRolesExported ExportOptions options = new ExportOptions(false, clientsExported, groupsAndRolesExported, clientsExported, true); + options.setWorkflowsIncluded(auth.isRealmAdmin()); ExportImportManager exportProvider = session.getProvider(DatastoreProvider.class).getExportImportManager(); diff --git a/tests/base/src/test/java/org/keycloak/tests/workflow/WorkflowExportImportDisabledTest.java b/tests/base/src/test/java/org/keycloak/tests/workflow/WorkflowExportImportDisabledTest.java new file mode 100644 index 000000000000..d4c87f7f5de9 --- /dev/null +++ b/tests/base/src/test/java/org/keycloak/tests/workflow/WorkflowExportImportDisabledTest.java @@ -0,0 +1,157 @@ +/* + * Copyright 2026 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.keycloak.tests.workflow; + +import java.util.List; +import java.util.Map; +import java.util.UUID; + +import jakarta.ws.rs.NotFoundException; +import jakarta.ws.rs.WebApplicationException; + +import org.keycloak.admin.client.Keycloak; +import org.keycloak.common.Profile; +import org.keycloak.common.util.MultivaluedHashMap; +import org.keycloak.connections.jpa.JpaConnectionProvider; +import org.keycloak.exportimport.ExportOptions; +import org.keycloak.exportimport.util.ExportUtils; +import org.keycloak.models.jpa.entities.ComponentConfigEntity; +import org.keycloak.models.jpa.entities.ComponentEntity; +import org.keycloak.models.jpa.entities.RealmEntity; +import org.keycloak.models.workflow.WorkflowProvider; +import org.keycloak.representations.idm.ComponentExportRepresentation; +import org.keycloak.representations.idm.RealmRepresentation; +import org.keycloak.representations.workflows.WorkflowRepresentation; +import org.keycloak.testframework.annotations.InjectAdminClient; +import org.keycloak.testframework.annotations.InjectRealm; +import org.keycloak.testframework.annotations.KeycloakIntegrationTest; +import org.keycloak.testframework.realm.ManagedRealm; +import org.keycloak.testframework.remote.runonserver.InjectRunOnServer; +import org.keycloak.testframework.remote.runonserver.RunOnServerClient; +import org.keycloak.testframework.server.KeycloakServerConfig; +import org.keycloak.testframework.server.KeycloakServerConfigBuilder; + +import org.junit.jupiter.api.Test; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.is; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +@KeycloakIntegrationTest(config = WorkflowExportImportDisabledTest.ServerConfig.class) +public class WorkflowExportImportDisabledTest { + + @InjectAdminClient(mode = InjectAdminClient.Mode.BOOTSTRAP) + Keycloak adminClient; + + @InjectRealm + ManagedRealm realm; + + @InjectRunOnServer(permittedPackages = {"org.keycloak.tests", "org.hamcrest"}) + RunOnServerClient runOnServer; + + @Test + public void testExportWithoutWorkflowsFeature() { + assertNull(realm.admin().partialExport(false, false).getWorkflows()); + } + + @Test + public void testStoredDefinitionsRemainInOfflineBackupOnly() { + runOnServer.run(session -> { + var model = session.getContext().getRealm(); + // Represent a definition persisted before the workflows feature was disabled. + var em = session.getProvider(JpaConnectionProvider.class).getEntityManager(); + ComponentEntity workflow = new ComponentEntity(); + workflow.setId(UUID.randomUUID().toString()); + workflow.setRealm(em.getReference(RealmEntity.class, model.getId())); + workflow.setParentId(model.getId()); + workflow.setProviderType(WorkflowProvider.class.getName()); + workflow.setProviderId("default"); + Map.of("name", "stored-before-disabling-feature", "enabled", "false").forEach((name, value) -> { + ComponentConfigEntity config = new ComponentConfigEntity(); + config.setId(UUID.randomUUID().toString()); + config.setComponent(workflow); + config.setName(name); + config.setValue(value); + workflow.getComponentConfigs().add(config); + }); + em.persist(workflow); + }); + realm.admin().clearRealmCache(); + runOnServer.run(session -> { + var model = session.getContext().getRealm(); + RealmRepresentation full = ExportUtils.exportRealm(session, model, false, false); + assertThat(full.getComponents().containsKey(WorkflowProvider.class.getName()), is(true)); + ExportOptions options = new ExportOptions(); + options.setWorkflowsIncluded(false); + assertThat(ExportUtils.exportRealm(session, model, options, false).getComponents() + .containsKey(WorkflowProvider.class.getName()), is(false)); + }); + RealmRepresentation exported = realm.admin().partialExport(false, false); + assertNull(exported.getWorkflows()); + assertThat(exported.getComponents().containsKey(WorkflowProvider.class.getName()), is(false)); + } + + @Test + public void testCannotSilentlyDiscardWorkflowDefinitions() { + RealmRepresentation imported = new RealmRepresentation(); + imported.setRealm("disabled-workflow-import"); + imported.setWorkflows(List.of(WorkflowRepresentation.withName("reminder").build())); + assertThrows(WebApplicationException.class, () -> adminClient.realms().create(imported)); + assertThrows(NotFoundException.class, () -> adminClient.realm(imported.getRealm()).toRepresentation()); + } + + @Test + public void testCannotRestoreLegacyDefinitionsWithFeatureDisabled() { + RealmRepresentation imported = new RealmRepresentation(); + imported.setRealm("disabled-legacy-workflow-import"); + ComponentExportRepresentation legacy = new ComponentExportRepresentation(); + legacy.setId("legacy-workflow"); + legacy.setProviderId("default"); + legacy.setConfig(new MultivaluedHashMap<>()); + legacy.getConfig().putSingle("name", "stored-workflow"); + imported.setComponents(new MultivaluedHashMap<>()); + imported.getComponents().add(WorkflowProvider.class.getName(), legacy); + + assertThrows(WebApplicationException.class, () -> adminClient.realms().create(imported)); + assertThrows(NotFoundException.class, () -> adminClient.realm(imported.getRealm()).toRepresentation()); + } + + @Test + public void testEmptyLegacyWorkflowDoesNotRequireFeature() { + RealmRepresentation imported = new RealmRepresentation(); + imported.setRealm(realm.getName()); + ComponentExportRepresentation legacy = new ComponentExportRepresentation(); + legacy.setId("legacy-empty-workflow"); + legacy.setProviderId("default"); + legacy.setConfig(new MultivaluedHashMap<>()); + imported.setComponents(new MultivaluedHashMap<>()); + imported.getComponents().add(WorkflowProvider.class.getName(), legacy); + realm.admin().remove(); + + adminClient.realms().create(imported); + + assertThat(realm.admin().toRepresentation().getRealm(), is(imported.getRealm())); + } + + public static class ServerConfig implements KeycloakServerConfig { + @Override + public KeycloakServerConfigBuilder configure(KeycloakServerConfigBuilder config) { + return config.featuresDisabled(Profile.Feature.WORKFLOWS); + } + } +} diff --git a/tests/base/src/test/java/org/keycloak/tests/workflow/WorkflowExportImportTest.java b/tests/base/src/test/java/org/keycloak/tests/workflow/WorkflowExportImportTest.java new file mode 100644 index 000000000000..60e90b46bfb0 --- /dev/null +++ b/tests/base/src/test/java/org/keycloak/tests/workflow/WorkflowExportImportTest.java @@ -0,0 +1,516 @@ +/* + * Copyright 2026 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.keycloak.tests.workflow; + +import java.io.IOException; +import java.time.Duration; +import java.util.List; + +import jakarta.ws.rs.NotFoundException; +import jakarta.ws.rs.WebApplicationException; +import jakarta.ws.rs.core.Response; + +import org.keycloak.admin.client.Keycloak; +import org.keycloak.common.util.DurationConverter; +import org.keycloak.common.util.MultivaluedHashMap; +import org.keycloak.exportimport.util.ExportUtils; +import org.keycloak.models.AdminRoles; +import org.keycloak.models.Constants; +import org.keycloak.models.utils.PostMigrationEvent; +import org.keycloak.models.workflow.DefaultWorkflowProviderFactory; +import org.keycloak.models.workflow.DisableUserStepProviderFactory; +import org.keycloak.models.workflow.ScheduledWorkflowRunner; +import org.keycloak.models.workflow.WorkflowProvider; +import org.keycloak.models.workflow.WorkflowStateProvider; +import org.keycloak.models.workflow.WorkflowStepProvider; +import org.keycloak.models.workflow.events.UserAuthenticatedWorkflowEventFactory; +import org.keycloak.representations.idm.ComponentExportRepresentation; +import org.keycloak.representations.idm.ErrorRepresentation; +import org.keycloak.representations.idm.RealmRepresentation; +import org.keycloak.representations.workflows.WorkflowRepresentation; +import org.keycloak.representations.workflows.WorkflowScheduleRepresentation; +import org.keycloak.representations.workflows.WorkflowStepRepresentation; +import org.keycloak.testframework.admin.AdminClientFactory; +import org.keycloak.testframework.annotations.InjectAdminClient; +import org.keycloak.testframework.annotations.InjectAdminClientFactory; +import org.keycloak.testframework.annotations.InjectRealm; +import org.keycloak.testframework.annotations.KeycloakIntegrationTest; +import org.keycloak.testframework.injection.LifeCycle; +import org.keycloak.testframework.realm.ManagedRealm; +import org.keycloak.testframework.realm.RealmBuilder; +import org.keycloak.testframework.realm.RealmConfig; +import org.keycloak.testframework.realm.UserBuilder; +import org.keycloak.testframework.remote.runonserver.InjectRunOnServer; +import org.keycloak.testframework.remote.runonserver.RunOnServerClient; +import org.keycloak.timer.TimerProvider; +import org.keycloak.util.JsonSerialization; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.node.ObjectNode; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.containsString; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.nullValue; +import static org.hamcrest.Matchers.sameInstance; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +@KeycloakIntegrationTest +public class WorkflowExportImportTest { + + @InjectRealm(config = ExportPermissionsRealmConfig.class, lifecycle = LifeCycle.METHOD) + ManagedRealm realm; + + @InjectRealm(ref = "other", lifecycle = LifeCycle.METHOD) + ManagedRealm other; + + @InjectAdminClient(mode = InjectAdminClient.Mode.BOOTSTRAP) + Keycloak adminClient; + + @InjectAdminClientFactory + AdminClientFactory adminClientFactory; + + @InjectRunOnServer(permittedPackages = {"org.keycloak.tests", "org.hamcrest"}) + RunOnServerClient runOnServer; + + @Test + public void testManageRealmExportOmitsWorkflows() { + createWorkflow(); + try (Keycloak client = adminClientFactory.create().realm(realm.getName()) + .clientId(Constants.ADMIN_CLI_CLIENT_ID).username("realm-manager").password("password").build()) { + RealmRepresentation exported = client.realm(realm.getName()).partialExport(false, false); + assertThat(exported.getRealm(), is(realm.getName())); + assertNull(exported.getWorkflows()); + assertThat(exported.getComponents().containsKey(WorkflowProvider.class.getName()), is(false)); + } + assertThat(realm.admin().partialExport(false, false).getWorkflows(), hasSize(1)); + } + + public static class ExportPermissionsRealmConfig implements RealmConfig { + @Override + public RealmBuilder configure(RealmBuilder realm) { + return realm.users(UserBuilder.create("realm-manager").password("password") + .email("realm-manager@localhost").firstName("Realm").lastName("Manager") + .clientRoles(Constants.REALM_MANAGEMENT_CLIENT_ID, AdminRoles.MANAGE_REALM)); + } + } + + @Test + public void testPartialExportPreservesWorkflowConfiguration() throws IOException { + createWorkflow(); + + RealmRepresentation exported = realm.admin().partialExport(false, false); + JsonNode json = JsonSerialization.mapper.readTree(JsonSerialization.writeValueAsBytes(exported)); + assertThat(json.toString(), containsString("Track inactive users")); + assertThat(json.path("workflows").size(), is(1)); + assertThat(json.path("workflows").get(0).path("name").asText(), is("Track inactive users")); + assertThat(json.path("workflows").get(0).path("steps").size(), is(1)); + assertThat(exported.getWorkflows().get(0).getSteps().get(0).getAfter(), is("2592000")); + assertThat(exported.getComponents().containsKey(WorkflowProvider.class.getName()), is(false)); + } + + @Test + public void testFullExportImport() throws IOException { + createWorkflow(); + RealmRepresentation exported = runOnServer.fetch(session -> + ExportUtils.exportRealm(session, session.getContext().getRealm(), false, false), RealmRepresentation.class); + WorkflowRepresentation expected = realm.admin().workflows().list().get(0); + assertThat(exported.getWorkflows(), hasSize(1)); + realm.admin().remove(); + adminClient.realms().create(exported); + WorkflowRepresentation actual = realm.admin().workflows().list().get(0); + assertDefinitionEquals(expected, actual); + } + + @Test + public void testExportSeveralRealmsInOneSession() { + createWorkflow(); + String otherName = other.getName(); + runOnServer.run(session -> { + var original = session.getContext().getRealm(); + session.getProvider(WorkflowProvider.class); + assertThat(ExportUtils.exportRealm(session, original, false, false).getWorkflows(), hasSize(1)); + var otherRealm = session.realms().getRealmByName(otherName); + assertThat(ExportUtils.exportRealm(session, otherRealm, false, false).getWorkflows(), nullValue()); + assertThat(session.getContext().getRealm().getId(), is(original.getId())); + }); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + public void testLegacyWorkflowComponentsImport(boolean includeEmptyWorkflow) throws IOException { + createWorkflow(); + WorkflowRepresentation expected = realm.admin().workflows().list().get(0); + ComponentExportRepresentation legacy = new ComponentExportRepresentation(); + legacy.setId(expected.getId()); + legacy.setProviderId("default"); + legacy.setConfig(expected.getConfig()); + legacy.setSubComponents(new MultivaluedHashMap<>()); + for (WorkflowStepRepresentation step : expected.getSteps()) { + ComponentExportRepresentation component = new ComponentExportRepresentation(); + component.setId(step.getId()); + component.setProviderId(step.getUses()); + component.setConfig(step.getConfig()); + legacy.getSubComponents().add(WorkflowStepProvider.class.getName(), component); + } + RealmRepresentation imported = new RealmRepresentation(); + imported.setRealm(realm.getName()); + imported.setComponents(new MultivaluedHashMap<>()); + imported.getComponents().add(WorkflowProvider.class.getName(), legacy); + if (includeEmptyWorkflow) { + imported.getComponents().add(WorkflowProvider.class.getName(), emptyLegacyWorkflow(false)); + } + realm.admin().remove(); + adminClient.realms().create(imported); + assertDefinitionEquals(expected, realm.admin().workflows().list().get(0)); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + public void testEmptyLegacyWorkflowDoesNotPreventRealmImport(boolean missingConfig) { + RealmRepresentation imported = new RealmRepresentation(); + imported.setRealm(realm.getName()); + imported.setDisplayName("Legacy export"); + ComponentExportRepresentation legacy = emptyLegacyWorkflow(missingConfig); + imported.setComponents(new MultivaluedHashMap<>()); + imported.getComponents().add(WorkflowProvider.class.getName(), legacy); + realm.admin().remove(); + + adminClient.realms().create(imported); + + assertThat(realm.admin().toRepresentation().getDisplayName(), is("Legacy export")); + assertThat(realm.admin().workflows().list(), hasSize(0)); + } + + @Test + public void testEmptyLegacyWorkflowAlongsideNewDefinition() { + createWorkflow(); + RealmRepresentation imported = realm.admin().partialExport(false, false); + imported.getComponents().add(WorkflowProvider.class.getName(), emptyLegacyWorkflow(false)); + realm.admin().remove(); + + adminClient.realms().create(imported); + + assertThat(realm.admin().workflows().list(), hasSize(1)); + assertThat(realm.admin().workflows().list().get(0).getName(), is("Track inactive users")); + } + + @Test + public void testMixedWorkflowFormatsAreRejected() { + RealmRepresentation imported = new RealmRepresentation(); + imported.setRealm("mixed-workflow-formats"); + imported.setWorkflows(List.of(WorkflowRepresentation.withName("new-format").build())); + ComponentExportRepresentation legacy = emptyLegacyWorkflow(false); + legacy.getConfig().putSingle("name", "legacy-format"); + imported.setComponents(new MultivaluedHashMap<>()); + imported.getComponents().add(WorkflowProvider.class.getName(), legacy); + + WebApplicationException exception = assertThrows(WebApplicationException.class, () -> adminClient.realms().create(imported)); + try (Response response = exception.getResponse()) { + assertThat(response.getStatus(), is(Response.Status.BAD_REQUEST.getStatusCode())); + assertThat(response.readEntity(ErrorRepresentation.class).getErrorMessage(), + is("Realm contains both workflow definitions and legacy workflow components")); + } + assertThrows(NotFoundException.class, () -> adminClient.realm(imported.getRealm()).toRepresentation()); + } + + @ParameterizedTest + @ValueSource(strings = {"unknown-provider", "invalid-configuration"}) + public void testInvalidLegacyWorkflowStillRejectsImport(String invalid) { + RealmRepresentation imported = new RealmRepresentation(); + imported.setRealm("invalid-legacy-workflow"); + ComponentExportRepresentation legacy = emptyLegacyWorkflow(false); + if (invalid.equals("unknown-provider")) { + legacy.setProviderId("unknown"); + } else { + legacy.getConfig().putSingle("name", ""); + } + imported.setComponents(new MultivaluedHashMap<>()); + imported.getComponents().add(WorkflowProvider.class.getName(), legacy); + + assertThrows(WebApplicationException.class, () -> adminClient.realms().create(imported)); + assertThrows(NotFoundException.class, () -> adminClient.realm(imported.getRealm()).toRepresentation()); + } + + private static ComponentExportRepresentation emptyLegacyWorkflow(boolean missingConfig) { + ComponentExportRepresentation legacy = new ComponentExportRepresentation(); + legacy.setId("legacy-empty-workflow"); + legacy.setProviderId("default"); + legacy.setConfig(missingConfig ? null : new MultivaluedHashMap<>()); + return legacy; + } + + @Test + public void testExportOmitsEmptyWorkflows() throws IOException { + RealmRepresentation exported = realm.admin().partialExport(false, false); + JsonNode json = JsonSerialization.mapper.readTree(JsonSerialization.writeValueAsBytes(exported)); + assertThat(json.has("workflows"), is(false)); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + public void testRolledBackUpdatePreservesTimer(boolean scheduledSteps) { + createScheduledWorkflow(scheduledSteps); + runOnServer.run(session -> { + WorkflowProvider provider = session.getProvider(WorkflowProvider.class); + var workflow = provider.getWorkflow("transactional-workflow"); + TimerProvider timer = session.getProvider(TimerProvider.class); + String task = new ScheduledWorkflowRunner(workflow.getId(), session.getContext().getRealm().getId(), 2592000).getTaskName(); + var original = timer.getTasks().get(task); + WorkflowRepresentation updated = provider.toRepresentation(workflow); + updated.setSchedule(WorkflowScheduleRepresentation.create().after("60d").build()); + provider.updateWorkflow(workflow, updated); + assertThat(timer.getTasks().get(task), sameInstance(original)); + session.getTransactionManager().setRollbackOnly(); + }); + assertScheduledInterval(2592000000L); + assertThat(DurationConverter.parseDuration(realm.admin().workflows().workflow("transactional-workflow") + .toRepresentation().getSchedule().getAfter()), is(Duration.ofDays(30))); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + public void testCommittedUpdateReplacesTimer(boolean scheduledSteps) { + createScheduledWorkflow(scheduledSteps); + runOnServer.run(session -> { + WorkflowProvider provider = session.getProvider(WorkflowProvider.class); + var workflow = provider.getWorkflow("transactional-workflow"); + WorkflowRepresentation updated = provider.toRepresentation(workflow); + updated.setSchedule(WorkflowScheduleRepresentation.create().after("60d").build()); + provider.updateWorkflow(workflow, updated); + }); + assertScheduledInterval(5184000000L); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + public void testDisablingWorkflowCancelsTimerAfterCommit(boolean scheduledSteps) { + createScheduledWorkflow(scheduledSteps); + runOnServer.run(session -> { + WorkflowProvider provider = session.getProvider(WorkflowProvider.class); + var workflow = provider.getWorkflow("transactional-workflow"); + TimerProvider timer = session.getProvider(TimerProvider.class); + String task = new ScheduledWorkflowRunner(workflow.getId(), session.getContext().getRealm().getId(), 2592000).getTaskName(); + var original = timer.getTasks().get(task); + WorkflowRepresentation updated = provider.toRepresentation(workflow); + updated.getConfig().putSingle("enabled", "false"); + provider.updateWorkflow(workflow, updated); + assertThat(timer.getTasks().get(task), sameInstance(original)); + }); + runOnServer.run(session -> { + String task = new ScheduledWorkflowRunner("transactional-workflow", session.getContext().getRealm().getId(), 2592000).getTaskName(); + assertThat(session.getProvider(TimerProvider.class).getTasks().containsKey(task), is(false)); + }); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + public void testWorkflowRemovalUpdatesTimerAfterCommitOnly(boolean rollback) { + createScheduledWorkflow(false); + runOnServer.run(session -> { + WorkflowProvider provider = session.getProvider(WorkflowProvider.class); + var workflow = provider.getWorkflow("transactional-workflow"); + TimerProvider timer = session.getProvider(TimerProvider.class); + String task = new ScheduledWorkflowRunner(workflow.getId(), session.getContext().getRealm().getId(), 2592000).getTaskName(); + var original = timer.getTasks().get(task); + provider.removeWorkflow(workflow); + assertThat(timer.getTasks().get(task), sameInstance(original)); + if (rollback) { + session.getTransactionManager().setRollbackOnly(); + } + }); + runOnServer.run(session -> { + String task = new ScheduledWorkflowRunner("transactional-workflow", session.getContext().getRealm().getId(), 2592000).getTaskName(); + assertThat(session.getProvider(TimerProvider.class).getTasks().containsKey(task), is(rollback)); + }); + } + + private void createScheduledWorkflow(boolean scheduledSteps) { + runOnServer.run(session -> { + WorkflowRepresentation definition = WorkflowRepresentation.withName("transactional") + .schedule(WorkflowScheduleRepresentation.create().after("30d").build()) + .withSteps(WorkflowStepRepresentation.create().of(DisableUserStepProviderFactory.ID) + .after(Duration.ofDays(30)).build()).build(); + definition.setId("transactional-workflow"); + var workflow = session.getProvider(WorkflowProvider.class).toModel(definition); + if (scheduledSteps) { + session.getProvider(WorkflowStateProvider.class).scheduleStep(workflow, workflow.getSteps().findFirst().orElseThrow(), + "scheduled-resource", "scheduled-execution"); + } + }); + assertScheduledInterval(2592000000L); + } + + @Test + public void testStartupReschedulesStoredWorkflow() { + createScheduledWorkflow(false); + runOnServer.run(session -> { + String task = new ScheduledWorkflowRunner("transactional-workflow", session.getContext().getRealm().getId(), 2592000).getTaskName(); + session.getProvider(TimerProvider.class).cancelTask(task); + var factory = session.getKeycloakSessionFactory(); + ((DefaultWorkflowProviderFactory) factory.getProviderFactory(WorkflowProvider.class)).onEvent(new PostMigrationEvent(factory)); + }); + assertScheduledInterval(2592000000L); + } + + @Test + public void testRolledBackRealmRemovalPreservesTimer() { + createScheduledWorkflow(false); + runOnServer.run(session -> { + String realmId = session.getContext().getRealm().getId(); + String task = new ScheduledWorkflowRunner("transactional-workflow", realmId, 2592000).getTaskName(); + TimerProvider timer = session.getProvider(TimerProvider.class); + var original = timer.getTasks().get(task); + session.realms().removeRealm(realmId); + assertThat(timer.getTasks().get(task), sameInstance(original)); + session.getTransactionManager().setRollbackOnly(); + }); + assertScheduledInterval(2592000000L); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + public void testMultipleTimerChangesInOneTransaction(boolean disable) { + createScheduledWorkflow(true); + runOnServer.run(session -> { + WorkflowProvider provider = session.getProvider(WorkflowProvider.class); + String task = new ScheduledWorkflowRunner("transactional-workflow", session.getContext().getRealm().getId(), 2592000).getTaskName(); + TimerProvider timer = session.getProvider(TimerProvider.class); + var original = timer.getTasks().get(task); + for (String interval : List.of("60d", "90d")) { + var workflow = provider.getWorkflow("transactional-workflow"); + WorkflowRepresentation updated = provider.toRepresentation(workflow); + updated.setSchedule(WorkflowScheduleRepresentation.create().after(interval).build()); + provider.updateWorkflow(workflow, updated); + } + if (disable) { + var workflow = provider.getWorkflow("transactional-workflow"); + WorkflowRepresentation updated = provider.toRepresentation(workflow); + updated.getConfig().putSingle("enabled", "false"); + provider.updateWorkflow(workflow, updated); + } + assertThat(timer.getTasks().get(task), sameInstance(original)); + }); + if (disable) { + runOnServer.run(session -> { + String task = new ScheduledWorkflowRunner("transactional-workflow", session.getContext().getRealm().getId(), 2592000).getTaskName(); + assertThat(session.getProvider(TimerProvider.class).getTasks().containsKey(task), is(false)); + }); + } else { + assertScheduledInterval(7776000000L); + } + } + + private void assertScheduledInterval(long intervalMillis) { + runOnServer.run(session -> { + String task = new ScheduledWorkflowRunner("transactional-workflow", session.getContext().getRealm().getId(), 2592000).getTaskName(); + var scheduled = session.getProvider(TimerProvider.class).getTasks().get(task); + assertThat(scheduled.getIntervalMillis(), is(intervalMillis)); + }); + } + + private void createWorkflow() { + WorkflowRepresentation workflow = WorkflowRepresentation.withName("Track inactive users") + .onEvent(UserAuthenticatedWorkflowEventFactory.ID) + .withConfig("enabled", "false") + .schedule(WorkflowScheduleRepresentation.create().after("30d").batchSize(10).build()) + .concurrency().cancelInProgress(UserAuthenticatedWorkflowEventFactory.ID) + .withSteps(WorkflowStepRepresentation.create().of(DisableUserStepProviderFactory.ID) + .after(Duration.ofDays(30)).build()) + .build(); + try (Response response = realm.admin().workflows().create(workflow)) { + assertThat(response.getStatus(), is(Response.Status.CREATED.getStatusCode())); + } + + } + + @Test + public void testImportUsesWorkflowValidation() { + RealmRepresentation imported = new RealmRepresentation(); + imported.setRealm("invalid-workflow-import"); + imported.setWorkflows(List.of(WorkflowRepresentation.withName("").build())); + assertThrows(WebApplicationException.class, () -> adminClient.realms().create(imported)); + assertThrows(NotFoundException.class, () -> adminClient.realm(imported.getRealm()).toRepresentation()); + } + + @ParameterizedTest + @ValueSource(strings = {"0s", "-1s", "2147483648s"}) + public void testUnsupportedScheduleDoesNotPersist(String interval) { + RealmRepresentation imported = new RealmRepresentation(); + imported.setRealm("unsupported-workflow-schedule"); + imported.setWorkflows(List.of(WorkflowRepresentation.withName("scheduled") + .schedule(WorkflowScheduleRepresentation.create().after(interval).build()) + .withSteps(WorkflowStepRepresentation.create().of(DisableUserStepProviderFactory.ID) + .after(Duration.ofDays(30)).build()).build())); + assertThrows(WebApplicationException.class, () -> adminClient.realms().create(imported)); + assertThrows(NotFoundException.class, () -> adminClient.realm(imported.getRealm()).toRepresentation()); + } + + @Test + public void testRolledBackDefinitionDoesNotRegisterTimer() { + runOnServer.run(session -> { + WorkflowRepresentation definition = WorkflowRepresentation.withName("rolled-back") + .schedule(WorkflowScheduleRepresentation.create().after("30d").build()) + .withSteps(WorkflowStepRepresentation.create().of(DisableUserStepProviderFactory.ID) + .after(Duration.ofDays(30)).build()) + .build(); + definition.setId("rolled-back-workflow"); + session.getProvider(WorkflowProvider.class).toModel(definition); + String task = new ScheduledWorkflowRunner(definition.getId(), session.getContext().getRealm().getId(), 2592000).getTaskName(); + assertThat(session.getProvider(TimerProvider.class).getTasks().containsKey(task), is(false)); + session.getTransactionManager().setRollbackOnly(); + }); + runOnServer.run(session -> { + String task = new ScheduledWorkflowRunner("rolled-back-workflow", session.getContext().getRealm().getId(), 2592000).getTaskName(); + assertThat(session.getProvider(TimerProvider.class).getTasks().containsKey(task), is(false)); + assertThat(session.getProvider(WorkflowProvider.class).getWorkflows().count(), is(0L)); + }); + } + + @Test + public void testImportedScheduleIsRegisteredAfterCommit() { + RealmRepresentation imported = new RealmRepresentation(); + imported.setRealm(realm.getName()); + WorkflowRepresentation definition = WorkflowRepresentation.withName("scheduled-import") + .schedule(WorkflowScheduleRepresentation.create().after("30d").build()) + .withSteps(WorkflowStepRepresentation.create().of(DisableUserStepProviderFactory.ID) + .after(Duration.ofDays(30)).build()).build(); + definition.setId("scheduled-import-workflow"); + imported.setWorkflows(List.of(definition)); + realm.admin().remove(); + adminClient.realms().create(imported); + runOnServer.run(session -> { + String task = new ScheduledWorkflowRunner("scheduled-import-workflow", session.getContext().getRealm().getId(), 2592000).getTaskName(); + assertThat(session.getProvider(TimerProvider.class).getTasks().containsKey(task), is(true)); + }); + } + + private static void assertDefinitionEquals(WorkflowRepresentation expected, WorkflowRepresentation actual) throws IOException { + ObjectNode expectedJson = (ObjectNode) JsonSerialization.mapper.readTree(JsonSerialization.writeValueAsBytes(expected)); + ObjectNode actualJson = (ObjectNode) JsonSerialization.mapper.readTree(JsonSerialization.writeValueAsBytes(actual)); + // Provider creation generates step IDs; this export restores definitions, not running executions. + for (ObjectNode json : List.of(expectedJson, actualJson)) { + json.path("steps").forEach(step -> ((ObjectNode) step).remove("id")); + } + assertThat(actualJson, is(expectedJson)); + } +}