mirror of
https://github.com/ansible-middleware/keycloak.git
synced 2026-11-21 14:48:50 +00:00
Check mode compared the realm returned by Keycloak with a plain dict.update() of the module parameters. Keycloak stores attributes, browserSecurityHeaders and smtpServer as string maps, merges attributes and browserSecurityHeaders into the existing values and masks the SMTP password, so the comparison never matched and check mode always reported a change while a live run reported ok. Predict the realm Keycloak would return for those maps in check mode and add molecule checks for unchanged and changed settings. Fixes #447 Signed-off-by: sarankumar1325 <120080287+sarankumar1325@users.noreply.github.com>
1319 lines
46 KiB
Python
1319 lines
46 KiB
Python
|
|
# Copyright (c) 2017, Eike Frost <ei@kefro.st>
|
|
# Copyright (c) 2021, Christophe Gilles <christophe.gilles54@gmail.com>
|
|
# GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or https://www.gnu.org/licenses/gpl-3.0.txt)
|
|
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
from __future__ import (absolute_import, division, print_function)
|
|
from __future__ import annotations
|
|
__metaclass__ = type
|
|
|
|
DOCUMENTATION = r"""
|
|
module: keycloak_realm
|
|
|
|
short_description: Allows administration of Keycloak realm using Keycloak API
|
|
|
|
# Originally added in community.general 3.0.0
|
|
version_added: "3.0.0"
|
|
|
|
description:
|
|
- This module allows the administration of Keycloak realm using the Keycloak REST API. It requires access to the REST API
|
|
using OpenID Connect; the user connecting and the realm being used must have the requisite access rights. In a default
|
|
Keycloak installation, admin-cli and an admin user would work, as would a separate realm definition with the scope tailored
|
|
to your needs and a user having the expected roles.
|
|
- The names of module options are snake_cased versions of the camelCase ones found in the Keycloak API and its documentation
|
|
at U(https://www.keycloak.org/docs-api/latest/rest-api/index.html). Aliases are provided so camelCased versions can be used
|
|
as well.
|
|
- The Keycloak API does not always sanity check inputs, for example you can set SAML-specific settings on an OpenID Connect
|
|
client for instance and also the other way around. B(Be careful). If you do not specify a setting, usually a sensible
|
|
default is chosen.
|
|
attributes:
|
|
check_mode:
|
|
support: full
|
|
diff_mode:
|
|
support: full
|
|
action_group:
|
|
# Originally added in community.general 10.2.0
|
|
version_added: "3.0.0"
|
|
|
|
options:
|
|
state:
|
|
description:
|
|
- State of the realm.
|
|
- On V(present), the realm is created (or updated if it exists already).
|
|
- On V(absent), the realm is removed if it exists.
|
|
choices: ['present', 'absent']
|
|
default: 'present'
|
|
type: str
|
|
|
|
id:
|
|
description:
|
|
- The realm to create.
|
|
type: str
|
|
realm:
|
|
description:
|
|
- The realm name.
|
|
type: str
|
|
access_code_lifespan:
|
|
description:
|
|
- The realm access code lifespan.
|
|
aliases:
|
|
- accessCodeLifespan
|
|
type: int
|
|
access_code_lifespan_login:
|
|
description:
|
|
- The realm access code lifespan login.
|
|
aliases:
|
|
- accessCodeLifespanLogin
|
|
type: int
|
|
access_code_lifespan_user_action:
|
|
description:
|
|
- The realm access code lifespan user action.
|
|
aliases:
|
|
- accessCodeLifespanUserAction
|
|
type: int
|
|
access_token_lifespan:
|
|
description:
|
|
- The realm access token lifespan.
|
|
aliases:
|
|
- accessTokenLifespan
|
|
type: int
|
|
access_token_lifespan_for_implicit_flow:
|
|
description:
|
|
- The realm access token lifespan for implicit flow.
|
|
aliases:
|
|
- accessTokenLifespanForImplicitFlow
|
|
type: int
|
|
account_theme:
|
|
description:
|
|
- The realm account theme.
|
|
aliases:
|
|
- accountTheme
|
|
type: str
|
|
action_token_generated_by_admin_lifespan:
|
|
description:
|
|
- The realm action token generated by admin lifespan.
|
|
aliases:
|
|
- actionTokenGeneratedByAdminLifespan
|
|
type: int
|
|
action_token_generated_by_user_lifespan:
|
|
description:
|
|
- The realm action token generated by user lifespan.
|
|
aliases:
|
|
- actionTokenGeneratedByUserLifespan
|
|
type: int
|
|
admin_events_details_enabled:
|
|
description:
|
|
- The realm admin events details enabled.
|
|
aliases:
|
|
- adminEventsDetailsEnabled
|
|
type: bool
|
|
admin_events_enabled:
|
|
description:
|
|
- The realm admin events enabled.
|
|
aliases:
|
|
- adminEventsEnabled
|
|
type: bool
|
|
admin_permissions_enabled:
|
|
description:
|
|
- The realm admin permissions enabled.
|
|
aliases:
|
|
- adminPermissionsEnabled
|
|
type: bool
|
|
admin_theme:
|
|
description:
|
|
- The realm admin theme.
|
|
aliases:
|
|
- adminTheme
|
|
type: str
|
|
attributes:
|
|
description:
|
|
- The realm attributes.
|
|
type: dict
|
|
browser_flow:
|
|
description:
|
|
- The realm browser flow.
|
|
aliases:
|
|
- browserFlow
|
|
type: str
|
|
browser_security_headers:
|
|
description:
|
|
- The realm browser security headers.
|
|
aliases:
|
|
- browserSecurityHeaders
|
|
type: dict
|
|
brute_force_protected:
|
|
description:
|
|
- The realm brute force protected.
|
|
aliases:
|
|
- bruteForceProtected
|
|
type: bool
|
|
brute_force_strategy:
|
|
description:
|
|
- The realm brute force strategy.
|
|
aliases:
|
|
- bruteForceStrategy
|
|
choices: ['LINEAR', 'MULTIPLE']
|
|
type: str
|
|
client_authentication_flow:
|
|
description:
|
|
- The realm client authentication flow.
|
|
aliases:
|
|
- clientAuthenticationFlow
|
|
type: str
|
|
client_scope_mappings:
|
|
description:
|
|
- The realm client scope mappings.
|
|
aliases:
|
|
- clientScopeMappings
|
|
type: dict
|
|
default_default_client_scopes:
|
|
description:
|
|
- The realm default default client scopes.
|
|
aliases:
|
|
- defaultDefaultClientScopes
|
|
type: list
|
|
elements: str
|
|
default_groups:
|
|
description:
|
|
- The realm default groups.
|
|
aliases:
|
|
- defaultGroups
|
|
type: list
|
|
elements: str
|
|
default_locale:
|
|
description:
|
|
- The realm default locale.
|
|
aliases:
|
|
- defaultLocale
|
|
type: str
|
|
default_optional_client_scopes:
|
|
description:
|
|
- The realm default optional client scopes.
|
|
aliases:
|
|
- defaultOptionalClientScopes
|
|
type: list
|
|
elements: str
|
|
default_roles:
|
|
description:
|
|
- The realm default roles.
|
|
aliases:
|
|
- defaultRoles
|
|
type: list
|
|
elements: str
|
|
default_signature_algorithm:
|
|
description:
|
|
- The realm default signature algorithm.
|
|
aliases:
|
|
- defaultSignatureAlgorithm
|
|
type: str
|
|
direct_grant_flow:
|
|
description:
|
|
- The realm direct grant flow.
|
|
aliases:
|
|
- directGrantFlow
|
|
type: str
|
|
display_name:
|
|
description:
|
|
- The realm display name.
|
|
aliases:
|
|
- displayName
|
|
type: str
|
|
display_name_html:
|
|
description:
|
|
- The realm display name HTML.
|
|
aliases:
|
|
- displayNameHtml
|
|
type: str
|
|
docker_authentication_flow:
|
|
description:
|
|
- The realm docker authentication flow.
|
|
aliases:
|
|
- dockerAuthenticationFlow
|
|
type: str
|
|
duplicate_emails_allowed:
|
|
description:
|
|
- The realm duplicate emails allowed option.
|
|
aliases:
|
|
- duplicateEmailsAllowed
|
|
type: bool
|
|
edit_username_allowed:
|
|
description:
|
|
- The realm edit username allowed option.
|
|
aliases:
|
|
- editUsernameAllowed
|
|
type: bool
|
|
email_theme:
|
|
description:
|
|
- The realm email theme.
|
|
aliases:
|
|
- emailTheme
|
|
type: str
|
|
enabled:
|
|
description:
|
|
- The realm enabled option.
|
|
type: bool
|
|
enabled_event_types:
|
|
description:
|
|
- The realm enabled event types.
|
|
aliases:
|
|
- enabledEventTypes
|
|
type: list
|
|
elements: str
|
|
events_enabled:
|
|
description:
|
|
- Enables or disables login events for this realm.
|
|
aliases:
|
|
- eventsEnabled
|
|
type: bool
|
|
events_expiration:
|
|
description:
|
|
- The realm events expiration.
|
|
aliases:
|
|
- eventsExpiration
|
|
type: int
|
|
events_listeners:
|
|
description:
|
|
- The realm events listeners.
|
|
aliases:
|
|
- eventsListeners
|
|
type: list
|
|
elements: str
|
|
failure_factor:
|
|
description:
|
|
- The realm failure factor.
|
|
aliases:
|
|
- failureFactor
|
|
type: int
|
|
first_broker_login_flow:
|
|
description:
|
|
- The realm first broker login flow.
|
|
aliases:
|
|
- firstBrokerLoginFlow
|
|
type: str
|
|
internationalization_enabled:
|
|
description:
|
|
- The realm internationalization enabled option.
|
|
aliases:
|
|
- internationalizationEnabled
|
|
type: bool
|
|
localization_texts:
|
|
description:
|
|
- The custom localization texts for a realm.
|
|
aliases:
|
|
- localizationTexts
|
|
type: dict
|
|
login_theme:
|
|
description:
|
|
- The realm login theme.
|
|
aliases:
|
|
- loginTheme
|
|
type: str
|
|
login_with_email_allowed:
|
|
description:
|
|
- The realm login with email allowed option.
|
|
aliases:
|
|
- loginWithEmailAllowed
|
|
type: bool
|
|
max_delta_time_seconds:
|
|
description:
|
|
- The realm max delta time in seconds.
|
|
aliases:
|
|
- maxDeltaTimeSeconds
|
|
type: int
|
|
max_failure_wait_seconds:
|
|
description:
|
|
- The realm max failure wait in seconds.
|
|
aliases:
|
|
- maxFailureWaitSeconds
|
|
type: int
|
|
max_secondary_auth_failures:
|
|
description:
|
|
- The realm max secondary authentication failures (used with brute force detection for secondary auth mechanisms).
|
|
aliases:
|
|
- maxSecondaryAuthFailures
|
|
type: int
|
|
max_temporary_lockouts:
|
|
description:
|
|
- The realm max temporary lockouts.
|
|
aliases:
|
|
- maxTemporaryLockouts
|
|
type: int
|
|
minimum_quick_login_wait_seconds:
|
|
description:
|
|
- The realm minimum quick login wait in seconds.
|
|
aliases:
|
|
- minimumQuickLoginWaitSeconds
|
|
type: int
|
|
not_before:
|
|
description:
|
|
- The realm not before.
|
|
aliases:
|
|
- notBefore
|
|
type: int
|
|
offline_session_idle_timeout:
|
|
description:
|
|
- The realm offline session idle timeout.
|
|
aliases:
|
|
- offlineSessionIdleTimeout
|
|
type: int
|
|
offline_session_max_lifespan:
|
|
description:
|
|
- The realm offline session max lifespan.
|
|
aliases:
|
|
- offlineSessionMaxLifespan
|
|
type: int
|
|
offline_session_max_lifespan_enabled:
|
|
description:
|
|
- The realm offline session max lifespan enabled option.
|
|
aliases:
|
|
- offlineSessionMaxLifespanEnabled
|
|
type: bool
|
|
otp_policy_algorithm:
|
|
description:
|
|
- The realm otp policy algorithm.
|
|
aliases:
|
|
- otpPolicyAlgorithm
|
|
type: str
|
|
otp_policy_digits:
|
|
description:
|
|
- The realm otp policy digits.
|
|
aliases:
|
|
- otpPolicyDigits
|
|
type: int
|
|
otp_policy_initial_counter:
|
|
description:
|
|
- The realm otp policy initial counter.
|
|
aliases:
|
|
- otpPolicyInitialCounter
|
|
type: int
|
|
otp_policy_look_ahead_window:
|
|
description:
|
|
- The realm otp policy look ahead window.
|
|
aliases:
|
|
- otpPolicyLookAheadWindow
|
|
type: int
|
|
otp_policy_period:
|
|
description:
|
|
- The realm otp policy period.
|
|
aliases:
|
|
- otpPolicyPeriod
|
|
type: int
|
|
otp_policy_type:
|
|
description:
|
|
- The realm otp policy type.
|
|
aliases:
|
|
- otpPolicyType
|
|
type: str
|
|
otp_supported_applications:
|
|
description:
|
|
- The realm otp supported applications.
|
|
aliases:
|
|
- otpSupportedApplications
|
|
type: list
|
|
elements: str
|
|
password_policy:
|
|
description:
|
|
- The realm password policy.
|
|
aliases:
|
|
- passwordPolicy
|
|
type: str
|
|
organizations_enabled:
|
|
description:
|
|
- Enables support for experimental organization feature.
|
|
aliases:
|
|
- organizationsEnabled
|
|
type: bool
|
|
permanent_lockout:
|
|
description:
|
|
- The realm permanent lockout.
|
|
aliases:
|
|
- permanentLockout
|
|
type: bool
|
|
prune_undefined_realm_attributes:
|
|
description:
|
|
- If True all realm attributes which are not defined in the attributes dict will be deleted
|
|
aliases:
|
|
- pruneUndefinedRealmAttributes
|
|
type: bool
|
|
default: true
|
|
quick_login_check_milli_seconds:
|
|
description:
|
|
- The realm quick login check in milliseconds.
|
|
aliases:
|
|
- quickLoginCheckMilliSeconds
|
|
type: int
|
|
refresh_token_max_reuse:
|
|
description:
|
|
- The realm refresh token max reuse.
|
|
aliases:
|
|
- refreshTokenMaxReuse
|
|
type: int
|
|
registration_allowed:
|
|
description:
|
|
- The realm registration allowed option.
|
|
aliases:
|
|
- registrationAllowed
|
|
type: bool
|
|
registration_email_as_username:
|
|
description:
|
|
- The realm registration email as username option.
|
|
aliases:
|
|
- registrationEmailAsUsername
|
|
type: bool
|
|
registration_flow:
|
|
description:
|
|
- The realm registration flow.
|
|
aliases:
|
|
- registrationFlow
|
|
type: str
|
|
remember_me:
|
|
description:
|
|
- The realm remember me option.
|
|
aliases:
|
|
- rememberMe
|
|
type: bool
|
|
reset_credentials_flow:
|
|
description:
|
|
- The realm reset credentials flow.
|
|
aliases:
|
|
- resetCredentialsFlow
|
|
type: str
|
|
reset_password_allowed:
|
|
description:
|
|
- The realm reset password allowed option.
|
|
aliases:
|
|
- resetPasswordAllowed
|
|
type: bool
|
|
revoke_refresh_token:
|
|
description:
|
|
- The realm revoke refresh token option.
|
|
aliases:
|
|
- revokeRefreshToken
|
|
type: bool
|
|
smtp_server:
|
|
description:
|
|
- The realm smtp server.
|
|
aliases:
|
|
- smtpServer
|
|
type: dict
|
|
ssl_required:
|
|
description:
|
|
- The realm ssl required option.
|
|
choices: ['all', 'external', 'none']
|
|
aliases:
|
|
- sslRequired
|
|
type: str
|
|
sso_session_idle_timeout:
|
|
description:
|
|
- The realm sso session idle timeout.
|
|
aliases:
|
|
- ssoSessionIdleTimeout
|
|
type: int
|
|
sso_session_idle_timeout_remember_me:
|
|
description:
|
|
- The realm sso session idle timeout remember me.
|
|
aliases:
|
|
- ssoSessionIdleTimeoutRememberMe
|
|
type: int
|
|
sso_session_max_lifespan:
|
|
description:
|
|
- The realm sso session max lifespan.
|
|
aliases:
|
|
- ssoSessionMaxLifespan
|
|
type: int
|
|
sso_session_max_lifespan_remember_me:
|
|
description:
|
|
- The realm sso session max lifespan remember me.
|
|
aliases:
|
|
- ssoSessionMaxLifespanRememberMe
|
|
type: int
|
|
supported_locales:
|
|
description:
|
|
- The realm supported locales.
|
|
aliases:
|
|
- supportedLocales
|
|
type: list
|
|
elements: str
|
|
user_managed_access_allowed:
|
|
description:
|
|
- The realm user managed access allowed option.
|
|
aliases:
|
|
- userManagedAccessAllowed
|
|
type: bool
|
|
verify_email:
|
|
description:
|
|
- The realm verify email option.
|
|
aliases:
|
|
- verifyEmail
|
|
type: bool
|
|
wait_increment_seconds:
|
|
description:
|
|
- The realm wait increment in seconds.
|
|
aliases:
|
|
- waitIncrementSeconds
|
|
type: int
|
|
client_session_idle_timeout:
|
|
description:
|
|
- All Clients inherit from this setting, time a session is allowed to be idle before it expires.
|
|
aliases:
|
|
- clientSessionIdleTimeout
|
|
type: int
|
|
client_session_max_lifespan:
|
|
description:
|
|
- All Clients inherit from this setting, max time before a session is expired.
|
|
aliases:
|
|
- clientSessionMaxLifespan
|
|
type: int
|
|
client_offline_session_idle_timeout:
|
|
description:
|
|
- All Clients inherit from this setting, time an offline session is allowed to be idle before it expires.
|
|
aliases:
|
|
- clientOfflineSessionIdleTimeout
|
|
type: int
|
|
client_offline_session_max_lifespan:
|
|
description:
|
|
- All Clients inherit from this setting, max time before an offline session is expired regardless of activity.
|
|
aliases:
|
|
- clientOfflineSessionMaxLifespan
|
|
type: int
|
|
oauth2_device_code_lifespan:
|
|
description:
|
|
- Max time before the device code and user code are expired.
|
|
aliases:
|
|
- oauth2DeviceCodeLifespan
|
|
type: int
|
|
oauth2_device_polling_interval:
|
|
description:
|
|
- The minimum amount of time in seconds that the client should wait between polling requests to the token endpoint.
|
|
aliases:
|
|
- oauth2DevicePollingInterval
|
|
type: int
|
|
web_authn_policy_rp_entity_name:
|
|
description:
|
|
- WebAuthn Relying Party Entity Name.
|
|
aliases:
|
|
- webAuthnPolicyRpEntityName
|
|
type: str
|
|
web_authn_policy_signature_algorithms:
|
|
description:
|
|
- List of acceptable WebAuthn signature algorithms.
|
|
aliases:
|
|
- webAuthnPolicySignatureAlgorithms
|
|
type: list
|
|
elements: str
|
|
web_authn_policy_rp_id:
|
|
description:
|
|
- WebAuthn Relying Party ID (domain). Empty string means use request host.
|
|
aliases:
|
|
- webAuthnPolicyRpId
|
|
type: str
|
|
web_authn_policy_attestation_conveyance_preference:
|
|
description:
|
|
- Attestation conveyance preference for WebAuthn.
|
|
aliases:
|
|
- webAuthnPolicyAttestationConveyancePreference
|
|
type: str
|
|
web_authn_policy_authenticator_attachment:
|
|
description:
|
|
- Authenticator attachment preference for WebAuthn authenticators.
|
|
aliases:
|
|
- webAuthnPolicyAuthenticatorAttachment
|
|
type: str
|
|
web_authn_policy_require_resident_key:
|
|
description:
|
|
- Whether resident keys are required for WebAuthn (Yes/No/not specified).
|
|
aliases:
|
|
- webAuthnPolicyRequireResidentKey
|
|
type: str
|
|
web_authn_policy_user_verification_requirement:
|
|
description:
|
|
- User verification requirement for WebAuthn.
|
|
aliases:
|
|
- webAuthnPolicyUserVerificationRequirement
|
|
type: str
|
|
web_authn_policy_create_timeout:
|
|
description:
|
|
- Timeout for WebAuthn credential creation (ms).
|
|
aliases:
|
|
- webAuthnPolicyCreateTimeout
|
|
type: int
|
|
web_authn_policy_avoid_same_authenticator_register:
|
|
description:
|
|
- Avoid registering the same authenticator multiple times.
|
|
aliases:
|
|
- webAuthnPolicyAvoidSameAuthenticatorRegister
|
|
type: bool
|
|
web_authn_policy_acceptable_aaguids:
|
|
description:
|
|
- List of acceptable AAGUIDs for WebAuthn authenticators.
|
|
aliases:
|
|
- webAuthnPolicyAcceptableAaguids
|
|
type: list
|
|
elements: str
|
|
web_authn_policy_extra_origins:
|
|
description:
|
|
- Additional acceptable origins for WebAuthn requests.
|
|
aliases:
|
|
- webAuthnPolicyExtraOrigins
|
|
type: list
|
|
elements: str
|
|
web_authn_policy_passwordless_rp_entity_name:
|
|
description:
|
|
- WebAuthn Passwordless Relying Party Entity Name.
|
|
aliases:
|
|
- webAuthnPolicyPasswordlessRpEntityName
|
|
type: str
|
|
web_authn_policy_passwordless_signature_algorithms:
|
|
description:
|
|
- List of acceptable WebAuthn signature algorithms for passwordless.
|
|
aliases:
|
|
- webAuthnPolicyPasswordlessSignatureAlgorithms
|
|
type: list
|
|
elements: str
|
|
web_authn_policy_passwordless_rp_id:
|
|
description:
|
|
- WebAuthn Passwordless Relying Party ID (domain).
|
|
aliases:
|
|
- webAuthnPolicyPasswordlessRpId
|
|
type: str
|
|
web_authn_policy_passwordless_attestation_conveyance_preference:
|
|
description:
|
|
- Attestation conveyance preference for WebAuthn passwordless.
|
|
aliases:
|
|
- webAuthnPolicyPasswordlessAttestationConveyancePreference
|
|
type: str
|
|
web_authn_policy_passwordless_authenticator_attachment:
|
|
description:
|
|
- Authenticator attachment for WebAuthn passwordless.
|
|
aliases:
|
|
- webAuthnPolicyPasswordlessAuthenticatorAttachment
|
|
type: str
|
|
web_authn_policy_passwordless_require_resident_key:
|
|
description:
|
|
- Whether resident keys are required for WebAuthn passwordless (V(Yes)/V(No)/V(not specified)).
|
|
aliases:
|
|
- webAuthnPolicyPasswordlessRequireResidentKey
|
|
type: str
|
|
web_authn_policy_passwordless_user_verification_requirement:
|
|
description:
|
|
- User verification requirement for WebAuthn passwordless.
|
|
aliases:
|
|
- webAuthnPolicyPasswordlessUserVerificationRequirement
|
|
type: str
|
|
web_authn_policy_passwordless_create_timeout:
|
|
description:
|
|
- Timeout for WebAuthn passwordless credential creation (ms).
|
|
aliases:
|
|
- webAuthnPolicyPasswordlessCreateTimeout
|
|
type: int
|
|
web_authn_policy_passwordless_avoid_same_authenticator_register:
|
|
description:
|
|
- Avoid registering the same authenticator multiple times for passwordless.
|
|
aliases:
|
|
- webAuthnPolicyPasswordlessAvoidSameAuthenticatorRegister
|
|
type: bool
|
|
web_authn_policy_passwordless_acceptable_aaguids:
|
|
description:
|
|
- List of acceptable AAGUIDs for WebAuthn passwordless authenticators.
|
|
aliases:
|
|
- webAuthnPolicyPasswordlessAcceptableAaguids
|
|
type: list
|
|
elements: str
|
|
web_authn_policy_passwordless_extra_origins:
|
|
description:
|
|
- Additional acceptable origins for WebAuthn passwordless requests.
|
|
aliases:
|
|
- webAuthnPolicyPasswordlessExtraOrigins
|
|
type: list
|
|
elements: str
|
|
web_authn_policy_passwordless_passkeys_enabled:
|
|
description:
|
|
- Enable passkeys (conditional UI) authentication in the username forms.
|
|
aliases:
|
|
- webAuthnPolicyPasswordlessPasskeysEnabled
|
|
type: bool
|
|
|
|
extends_documentation_fragment:
|
|
- middleware_automation.keycloak.keycloak
|
|
- middleware_automation.keycloak.actiongroup_keycloak
|
|
- middleware_automation.keycloak.attributes
|
|
|
|
author:
|
|
- Christophe Gilles (@kris2kris)
|
|
"""
|
|
|
|
EXAMPLES = r"""
|
|
- name: Create or update Keycloak realm (minimal example)
|
|
middleware_automation.keycloak.keycloak_realm:
|
|
auth_client_id: admin-cli
|
|
auth_keycloak_url: https://auth.example.com
|
|
auth_realm: master
|
|
auth_username: USERNAME
|
|
auth_password: PASSWORD
|
|
realm: unique_realm_name
|
|
state: present
|
|
|
|
- name: Delete a Keycloak realm
|
|
middleware_automation.keycloak.keycloak_realm:
|
|
auth_client_id: admin-cli
|
|
auth_keycloak_url: https://auth.example.com
|
|
auth_realm: master
|
|
auth_username: USERNAME
|
|
auth_password: PASSWORD
|
|
realm: unique_realm_name
|
|
state: absent
|
|
"""
|
|
|
|
RETURN = r"""
|
|
msg:
|
|
description: Message as to what action was taken.
|
|
returned: always
|
|
type: str
|
|
sample: "Realm testrealm has been updated"
|
|
|
|
proposed:
|
|
description: Representation of proposed realm.
|
|
returned: always
|
|
type: dict
|
|
sample: {"realm": "test"}
|
|
|
|
existing:
|
|
description: Representation of existing realm (sample is truncated).
|
|
returned: always
|
|
type: dict
|
|
sample:
|
|
{
|
|
"adminUrl": "http://www.example.com/admin_url",
|
|
"attributes": {
|
|
"request.object.signature.alg": "RS256"
|
|
}
|
|
}
|
|
|
|
end_state:
|
|
description: Representation of realm after module execution (sample is truncated).
|
|
returned: on success
|
|
type: dict
|
|
sample:
|
|
{
|
|
"adminUrl": "http://www.example.com/admin_url",
|
|
"attributes": {
|
|
"request.object.signature.alg": "RS256"
|
|
}
|
|
}
|
|
"""
|
|
|
|
from ansible.module_utils.basic import AnsibleModule
|
|
|
|
from ansible_collections.middleware_automation.keycloak.plugins.module_utils.identity.keycloak.keycloak import (
|
|
KeycloakAPI,
|
|
KeycloakError,
|
|
camel,
|
|
get_token,
|
|
keycloak_argument_spec,
|
|
)
|
|
from ansible_collections.middleware_automation.keycloak.plugins.module_utils.identity.keycloak._keycloak_utils import (
|
|
merge_settings_without_absent_nulls,
|
|
)
|
|
|
|
|
|
SCOPE_TYPES = [
|
|
("default", "defaultDefaultClientScopes"),
|
|
("optional", "defaultOptionalClientScopes"),
|
|
]
|
|
|
|
|
|
def _get_realm_client_scopes(kc, realm, scope_type):
|
|
if scope_type == "default":
|
|
scopes = kc.get_default_client_scopes(realm)
|
|
else:
|
|
scopes = kc.get_optional_client_scopes(realm)
|
|
return scopes or []
|
|
|
|
|
|
def _build_scope_name_to_id(kc, realm):
|
|
return {s["name"]: s["id"] for s in kc.get_client_scopes(realm)}
|
|
|
|
|
|
def _validate_desired_scopes(module, realm, desired_scopes, scope_name_to_id):
|
|
for scope_type, _key in SCOPE_TYPES:
|
|
for name in (desired_scopes.get(scope_type) or []):
|
|
if name not in scope_name_to_id:
|
|
module.fail_json(msg=f"Client scope '{name}' does not exist in realm {realm}.")
|
|
|
|
|
|
def _sync_realm_client_scopes(kc, realm, desired_scope_names, scope_type, current_scopes, scope_name_to_id):
|
|
current_names = {s["name"] for s in current_scopes}
|
|
desired_names = set(desired_scope_names)
|
|
|
|
for name in current_names - desired_names:
|
|
scope_id = next(s["id"] for s in current_scopes if s["name"] == name)
|
|
if scope_type == "default":
|
|
kc.delete_default_client_scope(scope_id, realm)
|
|
else:
|
|
kc.delete_optional_client_scope(scope_id, realm)
|
|
|
|
for name in desired_names - current_names:
|
|
scope_id = scope_name_to_id[name]
|
|
if scope_type == "default":
|
|
kc.add_default_client_scope(scope_id, realm)
|
|
else:
|
|
kc.add_optional_client_scope(scope_id, realm)
|
|
|
|
|
|
def _apply_realm_client_scopes(module, kc, realm, desired_scopes):
|
|
scope_name_to_id = _build_scope_name_to_id(kc, realm)
|
|
_validate_desired_scopes(module, realm, desired_scopes, scope_name_to_id)
|
|
for scope_type, _key in SCOPE_TYPES:
|
|
if scope_type in desired_scopes:
|
|
current = _get_realm_client_scopes(kc, realm, scope_type)
|
|
_sync_realm_client_scopes(kc, realm, desired_scopes[scope_type],
|
|
scope_type, current, scope_name_to_id)
|
|
|
|
|
|
def _get_scope_names_dict(kc, realm, desired_scopes):
|
|
result = {}
|
|
for scope_type, _key in SCOPE_TYPES:
|
|
if scope_type in desired_scopes:
|
|
result[scope_type] = sorted(s["name"] for s in _get_realm_client_scopes(kc, realm, scope_type))
|
|
return result
|
|
|
|
|
|
def _inject_scope_names(target, scope_names):
|
|
for scope_type, key in SCOPE_TYPES:
|
|
if scope_type in scope_names:
|
|
target[key] = scope_names[scope_type]
|
|
|
|
|
|
def normalise_cr(realmrep):
|
|
"""Re-sorts any properties where the order is important so that diff's is minimised and the change detection is more effective.
|
|
|
|
:param realmrep: the realmrep dict to be sanitized
|
|
:return: normalised realmrep dict
|
|
"""
|
|
# Avoid the dict passed in to be modified
|
|
realmrep = realmrep.copy()
|
|
|
|
if "enabledEventTypes" in realmrep:
|
|
realmrep["enabledEventTypes"] = list(sorted(realmrep["enabledEventTypes"]))
|
|
|
|
if "otpSupportedApplications" in realmrep:
|
|
realmrep["otpSupportedApplications"] = list(sorted(realmrep["otpSupportedApplications"]))
|
|
|
|
if "supportedLocales" in realmrep:
|
|
realmrep["supportedLocales"] = list(sorted(realmrep["supportedLocales"]))
|
|
|
|
return realmrep
|
|
|
|
|
|
# Keycloak masks the stored SMTP password with this value when returning a realm representation
|
|
SECRET_MASK = "**********"
|
|
|
|
|
|
def _stringify_map_value(value):
|
|
"""Convert a value to the string form Keycloak uses for string-to-string map entries."""
|
|
if isinstance(value, bool):
|
|
return "true" if value else "false"
|
|
return str(value)
|
|
|
|
|
|
def _check_mode_desired_realm(before_realm, changeset):
|
|
"""Predict the realm representation Keycloak would return after applying changeset.
|
|
|
|
Keycloak stores realm ``attributes``, ``browserSecurityHeaders`` and ``smtpServer`` as
|
|
string-to-string maps and merges ``attributes`` and ``browserSecurityHeaders`` into the
|
|
existing values, while ``smtpServer`` is replaced as a whole and returned with its
|
|
password masked. A plain ``dict.update()`` of the module parameters therefore never
|
|
matches the realm Keycloak returns, so check mode always reported a change.
|
|
|
|
:param before_realm: the realm representation currently stored in Keycloak
|
|
:param changeset: the proposed changes built from the module parameters
|
|
:return: the predicted realm representation
|
|
"""
|
|
desired = before_realm.copy()
|
|
desired.update(changeset)
|
|
|
|
for key in ("attributes", "browserSecurityHeaders"):
|
|
if isinstance(changeset.get(key), dict):
|
|
merged = dict(before_realm.get(key) or {})
|
|
for name, value in changeset[key].items():
|
|
if value is None:
|
|
merged.pop(name, None)
|
|
else:
|
|
merged[name] = _stringify_map_value(value)
|
|
desired[key] = merged
|
|
|
|
if isinstance(changeset.get("smtpServer"), dict):
|
|
smtp = dict((name, _stringify_map_value(value)) for name, value in changeset["smtpServer"].items() if value is not None)
|
|
before_password = (before_realm.get("smtpServer") or {}).get("password")
|
|
if "password" in smtp and before_password == SECRET_MASK:
|
|
# The stored password cannot be read back, so it cannot be compared
|
|
smtp["password"] = before_password
|
|
desired["smtpServer"] = smtp
|
|
|
|
return desired
|
|
|
|
|
|
def sanitize_cr(realmrep):
|
|
"""Removes probably sensitive details from a realm representation.
|
|
|
|
:param realmrep: the realmrep dict to be sanitized
|
|
:return: sanitized realmrep dict
|
|
"""
|
|
if not realmrep:
|
|
return realmrep
|
|
|
|
result = realmrep.copy()
|
|
if "secret" in result:
|
|
result["secret"] = "********"
|
|
if "attributes" in result:
|
|
if "saml.signing.private.key" in result["attributes"]:
|
|
result["attributes"] = result["attributes"].copy()
|
|
result["attributes"]["saml.signing.private.key"] = "********"
|
|
return normalise_cr(result)
|
|
|
|
|
|
def main():
|
|
"""
|
|
Module execution
|
|
|
|
:return:
|
|
"""
|
|
argument_spec = keycloak_argument_spec()
|
|
|
|
meta_args = dict(
|
|
state=dict(default="present", choices=["present", "absent"]),
|
|
id=dict(type="str"),
|
|
realm=dict(type="str"),
|
|
access_code_lifespan=dict(type="int", aliases=["accessCodeLifespan"]),
|
|
access_code_lifespan_login=dict(type="int", aliases=["accessCodeLifespanLogin"]),
|
|
access_code_lifespan_user_action=dict(type="int", aliases=["accessCodeLifespanUserAction"]),
|
|
access_token_lifespan=dict(type="int", aliases=["accessTokenLifespan"], no_log=False),
|
|
access_token_lifespan_for_implicit_flow=dict(
|
|
type="int", aliases=["accessTokenLifespanForImplicitFlow"], no_log=False
|
|
),
|
|
account_theme=dict(type="str", aliases=["accountTheme"]),
|
|
action_token_generated_by_admin_lifespan=dict(
|
|
type="int", aliases=["actionTokenGeneratedByAdminLifespan"], no_log=False
|
|
),
|
|
action_token_generated_by_user_lifespan=dict(
|
|
type="int", aliases=["actionTokenGeneratedByUserLifespan"], no_log=False
|
|
),
|
|
admin_events_details_enabled=dict(type="bool", aliases=["adminEventsDetailsEnabled"]),
|
|
admin_events_enabled=dict(type="bool", aliases=["adminEventsEnabled"]),
|
|
admin_permissions_enabled=dict(type="bool", aliases=["adminPermissionsEnabled"]),
|
|
admin_theme=dict(type="str", aliases=["adminTheme"]),
|
|
attributes=dict(type="dict"),
|
|
browser_flow=dict(type="str", aliases=["browserFlow"]),
|
|
browser_security_headers=dict(type="dict", aliases=["browserSecurityHeaders"]),
|
|
brute_force_protected=dict(type="bool", aliases=["bruteForceProtected"]),
|
|
brute_force_strategy=dict(type="str", choices=["LINEAR", "MULTIPLE"], aliases=["bruteForceStrategy"]),
|
|
client_authentication_flow=dict(type="str", aliases=["clientAuthenticationFlow"]),
|
|
client_scope_mappings=dict(type="dict", aliases=["clientScopeMappings"]),
|
|
default_default_client_scopes=dict(type="list", elements="str", aliases=["defaultDefaultClientScopes"]),
|
|
default_groups=dict(type="list", elements="str", aliases=["defaultGroups"]),
|
|
default_locale=dict(type="str", aliases=["defaultLocale"]),
|
|
default_optional_client_scopes=dict(type="list", elements="str", aliases=["defaultOptionalClientScopes"]),
|
|
default_roles=dict(type="list", elements="str", aliases=["defaultRoles"]),
|
|
default_signature_algorithm=dict(type="str", aliases=["defaultSignatureAlgorithm"]),
|
|
direct_grant_flow=dict(type="str", aliases=["directGrantFlow"]),
|
|
display_name=dict(type="str", aliases=["displayName"]),
|
|
display_name_html=dict(type="str", aliases=["displayNameHtml"]),
|
|
docker_authentication_flow=dict(type="str", aliases=["dockerAuthenticationFlow"]),
|
|
duplicate_emails_allowed=dict(type="bool", aliases=["duplicateEmailsAllowed"]),
|
|
edit_username_allowed=dict(type="bool", aliases=["editUsernameAllowed"]),
|
|
email_theme=dict(type="str", aliases=["emailTheme"]),
|
|
enabled=dict(type="bool"),
|
|
enabled_event_types=dict(type="list", elements="str", aliases=["enabledEventTypes"]),
|
|
events_enabled=dict(type="bool", aliases=["eventsEnabled"]),
|
|
events_expiration=dict(type="int", aliases=["eventsExpiration"]),
|
|
events_listeners=dict(type="list", elements="str", aliases=["eventsListeners"]),
|
|
failure_factor=dict(type="int", aliases=["failureFactor"]),
|
|
first_broker_login_flow=dict(type="str", aliases=["firstBrokerLoginFlow"]),
|
|
internationalization_enabled=dict(type="bool", aliases=["internationalizationEnabled"]),
|
|
localization_texts=dict(type="dict", aliases=["localizationTexts"]),
|
|
login_theme=dict(type="str", aliases=["loginTheme"]),
|
|
login_with_email_allowed=dict(type="bool", aliases=["loginWithEmailAllowed"]),
|
|
max_delta_time_seconds=dict(type="int", aliases=["maxDeltaTimeSeconds"]),
|
|
max_failure_wait_seconds=dict(type="int", aliases=["maxFailureWaitSeconds"]),
|
|
max_secondary_auth_failures=dict(type="int", aliases=["maxSecondaryAuthFailures"]),
|
|
max_temporary_lockouts=dict(type="int", aliases=["maxTemporaryLockouts"]),
|
|
minimum_quick_login_wait_seconds=dict(type="int", aliases=["minimumQuickLoginWaitSeconds"]),
|
|
not_before=dict(type="int", aliases=["notBefore"]),
|
|
offline_session_idle_timeout=dict(type="int", aliases=["offlineSessionIdleTimeout"]),
|
|
offline_session_max_lifespan=dict(type="int", aliases=["offlineSessionMaxLifespan"]),
|
|
offline_session_max_lifespan_enabled=dict(type="bool", aliases=["offlineSessionMaxLifespanEnabled"]),
|
|
otp_policy_algorithm=dict(type="str", aliases=["otpPolicyAlgorithm"]),
|
|
otp_policy_digits=dict(type="int", aliases=["otpPolicyDigits"]),
|
|
otp_policy_initial_counter=dict(type="int", aliases=["otpPolicyInitialCounter"]),
|
|
otp_policy_look_ahead_window=dict(type="int", aliases=["otpPolicyLookAheadWindow"]),
|
|
otp_policy_period=dict(type="int", aliases=["otpPolicyPeriod"]),
|
|
otp_policy_type=dict(type="str", aliases=["otpPolicyType"]),
|
|
otp_supported_applications=dict(type="list", elements="str", aliases=["otpSupportedApplications"]),
|
|
password_policy=dict(type="str", aliases=["passwordPolicy"], no_log=False),
|
|
organizations_enabled=dict(type="bool", aliases=["organizationsEnabled"]),
|
|
permanent_lockout=dict(type="bool", aliases=["permanentLockout"]),
|
|
prune_undefined_realm_attributes=dict(type="bool", aliases=["pruneUndefinedRealmAttributes"], default=True),
|
|
quick_login_check_milli_seconds=dict(type="int", aliases=["quickLoginCheckMilliSeconds"]),
|
|
refresh_token_max_reuse=dict(type="int", aliases=["refreshTokenMaxReuse"], no_log=False),
|
|
registration_allowed=dict(type="bool", aliases=["registrationAllowed"]),
|
|
registration_email_as_username=dict(type="bool", aliases=["registrationEmailAsUsername"]),
|
|
registration_flow=dict(type="str", aliases=["registrationFlow"]),
|
|
remember_me=dict(type="bool", aliases=["rememberMe"]),
|
|
reset_credentials_flow=dict(type="str", aliases=["resetCredentialsFlow"]),
|
|
reset_password_allowed=dict(type="bool", aliases=["resetPasswordAllowed"], no_log=False),
|
|
revoke_refresh_token=dict(type="bool", aliases=["revokeRefreshToken"]),
|
|
smtp_server=dict(type="dict", aliases=["smtpServer"]),
|
|
ssl_required=dict(choices=["external", "all", "none"], aliases=["sslRequired"]),
|
|
sso_session_idle_timeout=dict(type="int", aliases=["ssoSessionIdleTimeout"]),
|
|
sso_session_idle_timeout_remember_me=dict(type="int", aliases=["ssoSessionIdleTimeoutRememberMe"]),
|
|
sso_session_max_lifespan=dict(type="int", aliases=["ssoSessionMaxLifespan"]),
|
|
sso_session_max_lifespan_remember_me=dict(type="int", aliases=["ssoSessionMaxLifespanRememberMe"]),
|
|
supported_locales=dict(type="list", elements="str", aliases=["supportedLocales"]),
|
|
user_managed_access_allowed=dict(type="bool", aliases=["userManagedAccessAllowed"]),
|
|
verify_email=dict(type="bool", aliases=["verifyEmail"]),
|
|
wait_increment_seconds=dict(type="int", aliases=["waitIncrementSeconds"]),
|
|
client_session_idle_timeout=dict(type="int", aliases=["clientSessionIdleTimeout"]),
|
|
client_session_max_lifespan=dict(type="int", aliases=["clientSessionMaxLifespan"]),
|
|
client_offline_session_idle_timeout=dict(type="int", aliases=["clientOfflineSessionIdleTimeout"]),
|
|
client_offline_session_max_lifespan=dict(type="int", aliases=["clientOfflineSessionMaxLifespan"]),
|
|
oauth2_device_code_lifespan=dict(type="int", aliases=["oauth2DeviceCodeLifespan"]),
|
|
oauth2_device_polling_interval=dict(type="int", aliases=["oauth2DevicePollingInterval"]),
|
|
web_authn_policy_rp_entity_name=dict(type="str", aliases=["webAuthnPolicyRpEntityName"]),
|
|
web_authn_policy_signature_algorithms=dict(
|
|
type="list", elements="str", aliases=["webAuthnPolicySignatureAlgorithms"]
|
|
),
|
|
web_authn_policy_rp_id=dict(type="str", aliases=["webAuthnPolicyRpId"]),
|
|
web_authn_policy_attestation_conveyance_preference=dict(
|
|
type="str", aliases=["webAuthnPolicyAttestationConveyancePreference"]
|
|
),
|
|
web_authn_policy_authenticator_attachment=dict(type="str", aliases=["webAuthnPolicyAuthenticatorAttachment"]),
|
|
web_authn_policy_require_resident_key=dict(
|
|
type="str", aliases=["webAuthnPolicyRequireResidentKey"], no_log=False
|
|
),
|
|
web_authn_policy_user_verification_requirement=dict(
|
|
type="str", aliases=["webAuthnPolicyUserVerificationRequirement"]
|
|
),
|
|
web_authn_policy_create_timeout=dict(type="int", aliases=["webAuthnPolicyCreateTimeout"]),
|
|
web_authn_policy_avoid_same_authenticator_register=dict(
|
|
type="bool", aliases=["webAuthnPolicyAvoidSameAuthenticatorRegister"]
|
|
),
|
|
web_authn_policy_acceptable_aaguids=dict(
|
|
type="list", elements="str", aliases=["webAuthnPolicyAcceptableAaguids"]
|
|
),
|
|
web_authn_policy_extra_origins=dict(type="list", elements="str", aliases=["webAuthnPolicyExtraOrigins"]),
|
|
web_authn_policy_passwordless_rp_entity_name=dict(
|
|
type="str", aliases=["webAuthnPolicyPasswordlessRpEntityName"]
|
|
),
|
|
web_authn_policy_passwordless_signature_algorithms=dict(
|
|
type="list", elements="str", aliases=["webAuthnPolicyPasswordlessSignatureAlgorithms"], no_log=False
|
|
),
|
|
web_authn_policy_passwordless_rp_id=dict(type="str", aliases=["webAuthnPolicyPasswordlessRpId"]),
|
|
web_authn_policy_passwordless_attestation_conveyance_preference=dict(
|
|
type="str", aliases=["webAuthnPolicyPasswordlessAttestationConveyancePreference"], no_log=False
|
|
),
|
|
web_authn_policy_passwordless_authenticator_attachment=dict(
|
|
type="str", aliases=["webAuthnPolicyPasswordlessAuthenticatorAttachment"], no_log=False
|
|
),
|
|
web_authn_policy_passwordless_require_resident_key=dict(
|
|
type="str", aliases=["webAuthnPolicyPasswordlessRequireResidentKey"], no_log=False
|
|
),
|
|
web_authn_policy_passwordless_user_verification_requirement=dict(
|
|
type="str", aliases=["webAuthnPolicyPasswordlessUserVerificationRequirement"], no_log=False
|
|
),
|
|
web_authn_policy_passwordless_create_timeout=dict(
|
|
type="int", aliases=["webAuthnPolicyPasswordlessCreateTimeout"]
|
|
),
|
|
web_authn_policy_passwordless_avoid_same_authenticator_register=dict(
|
|
type="bool", aliases=["webAuthnPolicyPasswordlessAvoidSameAuthenticatorRegister"]
|
|
),
|
|
web_authn_policy_passwordless_acceptable_aaguids=dict(
|
|
type="list", elements="str", aliases=["webAuthnPolicyPasswordlessAcceptableAaguids"], no_log=False
|
|
),
|
|
web_authn_policy_passwordless_extra_origins=dict(
|
|
type="list", elements="str", aliases=["webAuthnPolicyPasswordlessExtraOrigins"], no_log=False
|
|
),
|
|
web_authn_policy_passwordless_passkeys_enabled=dict(
|
|
type="bool", aliases=["webAuthnPolicyPasswordlessPasskeysEnabled"]
|
|
),
|
|
)
|
|
|
|
argument_spec.update(meta_args)
|
|
|
|
module = AnsibleModule(
|
|
argument_spec=argument_spec,
|
|
supports_check_mode=True,
|
|
required_one_of=(
|
|
[
|
|
["id", "realm", "enabled"],
|
|
["token", "auth_realm", "auth_username", "auth_password", "auth_client_id", "auth_client_secret"],
|
|
]
|
|
),
|
|
required_together=([["auth_username", "auth_password"]]),
|
|
required_by={"refresh_token": "auth_realm"},
|
|
)
|
|
|
|
result = dict(changed=False, msg="", diff={}, proposed={}, existing={}, end_state={})
|
|
|
|
# Obtain access token, initialize API
|
|
try:
|
|
connection_header = get_token(module.params)
|
|
except KeycloakError as e:
|
|
module.fail_json(msg=str(e))
|
|
|
|
kc = KeycloakAPI(module, connection_header)
|
|
|
|
realm = module.params.get("realm")
|
|
state = module.params.get("state")
|
|
prune_undefined_realm_attributes = module.params.get("prune_undefined_realm_attributes")
|
|
|
|
# convert module parameters to realm representation parameters (if they belong in there)
|
|
params_to_ignore = list(keycloak_argument_spec().keys()) + ["state", "prune_undefined_realm_attributes"]
|
|
|
|
# Filter and map the parameters names that apply to the role
|
|
realm_params = [x for x in module.params if x not in params_to_ignore and module.params.get(x) is not None]
|
|
|
|
# See whether the realm already exists in Keycloak
|
|
before_realm = kc.get_realm_by_id(realm=realm)
|
|
|
|
if before_realm is None:
|
|
before_realm = {}
|
|
|
|
# Build a proposed changeset from parameters given to this module
|
|
changeset = {}
|
|
|
|
for realm_param in realm_params:
|
|
new_param_value = module.params.get(realm_param)
|
|
if camel(realm_param) == "attributes" and not prune_undefined_realm_attributes:
|
|
new_param_value = merge_settings_without_absent_nulls(before_realm.get("attributes"), new_param_value)
|
|
|
|
changeset[camel(realm_param)] = new_param_value
|
|
|
|
# Extract client scope settings - these require separate API calls
|
|
desired_scopes = {}
|
|
for scope_type, key in SCOPE_TYPES:
|
|
value = changeset.pop(key, None)
|
|
if value is not None:
|
|
desired_scopes[scope_type] = value
|
|
has_scope_changes = bool(desired_scopes)
|
|
|
|
# Prepare the desired values using the existing values (non-existence results in a dict that is save to use as a basis)
|
|
desired_realm = before_realm.copy()
|
|
desired_realm.update(changeset)
|
|
|
|
result["proposed"] = sanitize_cr(changeset)
|
|
_inject_scope_names(result["proposed"], desired_scopes)
|
|
before_realm_sanitized = sanitize_cr(before_realm)
|
|
result["existing"] = before_realm_sanitized
|
|
|
|
# Validate that all desired scope names exist (early, before check_mode or mutations)
|
|
if has_scope_changes and before_realm:
|
|
scope_name_to_id = _build_scope_name_to_id(kc, realm)
|
|
_validate_desired_scopes(module, realm, desired_scopes, scope_name_to_id)
|
|
|
|
# Cater for when it doesn't exist (an empty dict)
|
|
if not before_realm:
|
|
if state == "absent":
|
|
# Do nothing and exit
|
|
if module._diff:
|
|
result["diff"] = dict(before="", after="")
|
|
result["changed"] = False
|
|
result["end_state"] = {}
|
|
result["msg"] = "Realm does not exist, doing nothing."
|
|
module.exit_json(**result)
|
|
|
|
# Process a creation
|
|
result["changed"] = True
|
|
|
|
if module._diff:
|
|
result["diff"] = dict(before="", after=sanitize_cr(desired_realm))
|
|
|
|
if module.check_mode:
|
|
module.exit_json(**result)
|
|
|
|
# create it
|
|
kc.create_realm(desired_realm)
|
|
|
|
created_realm_name = desired_realm.get("realm") or desired_realm.get("id")
|
|
if has_scope_changes:
|
|
_apply_realm_client_scopes(module, kc, created_realm_name, desired_scopes)
|
|
|
|
after_realm = kc.get_realm_by_id(created_realm_name)
|
|
after_realm_sanitized = sanitize_cr(after_realm)
|
|
_inject_scope_names(after_realm_sanitized, _get_scope_names_dict(kc, created_realm_name, desired_scopes))
|
|
|
|
result["end_state"] = after_realm_sanitized
|
|
|
|
result["msg"] = f"Realm {created_realm_name} has been created."
|
|
module.exit_json(**result)
|
|
|
|
else:
|
|
if state == "present":
|
|
# Fetch current client scopes before update for comparison
|
|
before_scope_names = _get_scope_names_dict(kc, realm, desired_scopes)
|
|
_inject_scope_names(before_realm_sanitized, before_scope_names)
|
|
|
|
result["existing"] = before_realm_sanitized
|
|
|
|
# Process an update
|
|
result["changed"] = True
|
|
if module.check_mode:
|
|
# We can only compare the current realm with the proposed updates we have
|
|
before_norm = normalise_cr(before_realm)
|
|
desired_norm = normalise_cr(_check_mode_desired_realm(before_realm, changeset))
|
|
_inject_scope_names(before_norm, before_scope_names)
|
|
_inject_scope_names(desired_norm, {st: sorted(v) for st, v in desired_scopes.items()})
|
|
if module._diff:
|
|
result["diff"] = dict(before=sanitize_cr(before_norm), after=sanitize_cr(desired_norm))
|
|
result["changed"] = before_norm != desired_norm
|
|
|
|
module.exit_json(**result)
|
|
|
|
# do the update
|
|
kc.update_realm(desired_realm, realm=realm)
|
|
|
|
if has_scope_changes:
|
|
_apply_realm_client_scopes(module, kc, realm, desired_scopes)
|
|
|
|
after_realm = kc.get_realm_by_id(realm=realm)
|
|
after_realm_sanitized = sanitize_cr(after_realm)
|
|
|
|
after_scope_names = _get_scope_names_dict(kc, realm, desired_scopes)
|
|
_inject_scope_names(after_realm_sanitized, after_scope_names)
|
|
scopes_changed = before_scope_names != after_scope_names
|
|
|
|
if before_realm == after_realm and not scopes_changed:
|
|
result["changed"] = False
|
|
|
|
result["end_state"] = after_realm_sanitized
|
|
|
|
if module._diff:
|
|
result["diff"] = dict(before=before_realm_sanitized, after=after_realm_sanitized)
|
|
|
|
result["msg"] = f"Realm {desired_realm['realm']} has been updated."
|
|
module.exit_json(**result)
|
|
|
|
else:
|
|
# Process a deletion (because state was not 'present')
|
|
result["changed"] = True
|
|
|
|
if module._diff:
|
|
result["diff"] = dict(before=before_realm_sanitized, after="")
|
|
|
|
if module.check_mode:
|
|
module.exit_json(**result)
|
|
|
|
# delete it
|
|
kc.delete_realm(realm=realm)
|
|
|
|
result["proposed"] = {}
|
|
result["end_state"] = {}
|
|
|
|
result["msg"] = f"Realm {before_realm['realm']} has been deleted."
|
|
|
|
module.exit_json(**result)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|