This is an automated email from the ASF dual-hosted git repository.

vincbeck pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/airflow.git


The following commit(s) were added to refs/heads/main by this push:
     new d3ce442368 Fix inheritance chain in security manager (#33901)
d3ce442368 is described below

commit d3ce44236895e9e1779ea39d7681b59a25af0509
Author: RaphaĆ«l Vandon <[email protected]>
AuthorDate: Mon Sep 11 10:26:59 2023 -0700

    Fix inheritance chain in security manager (#33901)
---
 .../endpoints/role_and_permission_endpoint.py      |   6 +-
 airflow/auth/managers/base_auth_manager.py         |  23 +-
 .../auth/managers/fab/cli_commands/role_command.py |   2 +-
 airflow/auth/managers/fab/fab_auth_manager.py      |  21 +-
 .../fab/security_manager/modules/__init__.py       |  17 -
 .../managers/fab/security_manager/modules/db.py    | 557 ---------------
 .../managers/fab/security_manager/modules/oauth.py | 186 -----
 .../auth/managers/fab/security_manager/override.py | 726 +++++++++++++++++--
 airflow/models/dagbag.py                           |   2 +-
 airflow/www/extensions/init_appbuilder.py          |  19 +-
 airflow/www/extensions/init_auth_manager.py        |  26 +-
 airflow/www/fab_security/manager.py                |   9 +
 airflow/www/security.py                            | 786 +--------------------
 .../www/security_appless.py                        |  28 +-
 airflow/www/{security.py => security_manager.py}   |  57 +-
 docs/apache-airflow/security/access-control.rst    |   6 +-
 docs/apache-airflow/security/webserver.rst         |   8 +-
 .../endpoints/test_role_and_permission_endpoint.py |   2 +-
 .../managers/fab/security_manager/test_override.py | 116 +--
 tests/auth/managers/fab/test_fab_auth_manager.py   |   6 +-
 tests/auth/managers/test_base_auth_manager.py      |   8 +-
 tests/models/test_dagbag.py                        |   4 +-
 tests/test_utils/api_connexion_utils.py            |   2 +-
 tests/test_utils/mock_security_manager.py          |   4 +-
 tests/www/test_security.py                         |   2 +-
 25 files changed, 820 insertions(+), 1803 deletions(-)

diff --git a/airflow/api_connexion/endpoints/role_and_permission_endpoint.py 
b/airflow/api_connexion/endpoints/role_and_permission_endpoint.py
index 2b07c4de2d..b8ace0e1de 100644
--- a/airflow/api_connexion/endpoints/role_and_permission_endpoint.py
+++ b/airflow/api_connexion/endpoints/role_and_permission_endpoint.py
@@ -40,14 +40,14 @@ from airflow.utils.airflow_flask_app import get_airflow_app
 
 if TYPE_CHECKING:
     from airflow.api_connexion.types import APIResponse, UpdateMask
-    from airflow.www.security import AirflowSecurityManager
+    from airflow.www.security_manager import AirflowSecurityManagerV2
 
 
-def _check_action_and_resource(sm: AirflowSecurityManager, perms: 
list[tuple[str, str]]) -> None:
+def _check_action_and_resource(sm: AirflowSecurityManagerV2, perms: 
list[tuple[str, str]]) -> None:
     """
     Check if the action or resource exists and otherwise raise 400.
 
-    This function is intended for use in the REST API because it raise 400
+    This function is intended for use in the REST API because it raises an 
HTTP error 400
     """
     for action, resource in perms:
         if not sm.get_action(action):
diff --git a/airflow/auth/managers/base_auth_manager.py 
b/airflow/auth/managers/base_auth_manager.py
index a512804b4c..66b79b0a26 100644
--- a/airflow/auth/managers/base_auth_manager.py
+++ b/airflow/auth/managers/base_auth_manager.py
@@ -24,9 +24,11 @@ from airflow.exceptions import AirflowException
 from airflow.utils.log.logging_mixin import LoggingMixin
 
 if TYPE_CHECKING:
+    from flask import Flask
+
     from airflow.auth.managers.models.base_user import BaseUser
     from airflow.cli.cli_config import CLICommand
-    from airflow.www.security import AirflowSecurityManager
+    from airflow.www.security_manager import AirflowSecurityManagerV2
 
 
 class BaseAuthManager(LoggingMixin):
@@ -36,8 +38,9 @@ class BaseAuthManager(LoggingMixin):
     Auth managers are responsible for any user management related operation 
such as login, logout, authz, ...
     """
 
-    def __init__(self):
-        self._security_manager: AirflowSecurityManager | None = None
+    def __init__(self, app: Flask) -> None:
+        self._security_manager: AirflowSecurityManagerV2 | None = None
+        self.app = app
 
     @staticmethod
     def get_cli_commands() -> list[CLICommand]:
@@ -80,22 +83,24 @@ class BaseAuthManager(LoggingMixin):
         Return the security manager override class.
 
         The security manager override class is responsible for overriding the 
default security manager
-        class airflow.www.security.AirflowSecurityManager with a custom 
implementation. This class is
-        essentially inherited from airflow.www.security.AirflowSecurityManager.
+        class airflow.www.security_manager.AirflowSecurityManagerV2 with a 
custom implementation.
+        This class is essentially inherited from 
airflow.www.security_manager.AirflowSecurityManagerV2.
 
-        By default, return an empty class.
+        By default, return the generic AirflowSecurityManagerV2.
         """
-        return object
+        from airflow.www.security_manager import AirflowSecurityManagerV2
+
+        return AirflowSecurityManagerV2
 
     @property
-    def security_manager(self) -> AirflowSecurityManager:
+    def security_manager(self) -> AirflowSecurityManagerV2:
         """Get the security manager."""
         if not self._security_manager:
             raise AirflowException("Security manager not defined.")
         return self._security_manager
 
     @security_manager.setter
-    def security_manager(self, security_manager: AirflowSecurityManager):
+    def security_manager(self, security_manager: AirflowSecurityManagerV2):
         """
         Set the security manager.
 
diff --git a/airflow/auth/managers/fab/cli_commands/role_command.py 
b/airflow/auth/managers/fab/cli_commands/role_command.py
index ce69c7f201..fc828ede77 100644
--- a/airflow/auth/managers/fab/cli_commands/role_command.py
+++ b/airflow/auth/managers/fab/cli_commands/role_command.py
@@ -29,7 +29,7 @@ from airflow.cli.simple_table import AirflowConsole
 from airflow.utils import cli as cli_utils
 from airflow.utils.cli import suppress_logs_and_warning
 from airflow.utils.providers_configuration_loader import 
providers_configuration_loaded
-from airflow.www.security import EXISTING_ROLES
+from airflow.www.security_manager import EXISTING_ROLES
 
 if TYPE_CHECKING:
     from airflow.auth.managers.fab.models import Action, Permission, Resource, 
Role
diff --git a/airflow/auth/managers/fab/fab_auth_manager.py 
b/airflow/auth/managers/fab/fab_auth_manager.py
index 354a073be2..27c96d6dd5 100644
--- a/airflow/auth/managers/fab/fab_auth_manager.py
+++ b/airflow/auth/managers/fab/fab_auth_manager.py
@@ -17,6 +17,7 @@
 # under the License.
 from __future__ import annotations
 
+import warnings
 from typing import TYPE_CHECKING
 
 from airflow import AirflowException
@@ -90,8 +91,24 @@ class FabAuthManager(BaseAuthManager):
     def get_security_manager_override_class(self) -> type:
         """Return the security manager override."""
         from airflow.auth.managers.fab.security_manager.override import 
FabAirflowSecurityManagerOverride
-
-        return FabAirflowSecurityManagerOverride
+        from airflow.www.security import AirflowSecurityManager
+
+        sm_from_config = self.app.config.get("SECURITY_MANAGER_CLASS")
+        if sm_from_config:
+            if not issubclass(sm_from_config, AirflowSecurityManager):
+                raise Exception(
+                    """Your CUSTOM_SECURITY_MANAGER must extend 
FabAirflowSecurityManagerOverride,
+                     not FAB's own security manager."""
+                )
+            if not issubclass(sm_from_config, 
FabAirflowSecurityManagerOverride):
+                warnings.warn(
+                    "Please make your custom security manager inherit from "
+                    "FabAirflowSecurityManagerOverride instead of 
AirflowSecurityManager.",
+                    DeprecationWarning,
+                )
+            return sm_from_config
+
+        return FabAirflowSecurityManagerOverride  # default choice
 
     def url_for(self, *args, **kwargs):
         """Wrapper to allow mocking without having to import at the top of the 
file."""
diff --git a/airflow/auth/managers/fab/security_manager/modules/__init__.py 
b/airflow/auth/managers/fab/security_manager/modules/__init__.py
deleted file mode 100644
index 217e5db960..0000000000
--- a/airflow/auth/managers/fab/security_manager/modules/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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.
diff --git a/airflow/auth/managers/fab/security_manager/modules/db.py 
b/airflow/auth/managers/fab/security_manager/modules/db.py
deleted file mode 100644
index 77f1a8205f..0000000000
--- a/airflow/auth/managers/fab/security_manager/modules/db.py
+++ /dev/null
@@ -1,557 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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.
-from __future__ import annotations
-
-import logging
-import uuid
-
-from flask_appbuilder import const
-from flask_appbuilder.models.sqla import Base
-from sqlalchemy import func, inspect, select
-from sqlalchemy.exc import MultipleResultsFound
-from werkzeug.security import generate_password_hash
-
-from airflow import AirflowException
-from airflow.auth.managers.fab.models import Action, Permission, Resource, Role
-
-log = logging.getLogger(__name__)
-
-
-class FabAirflowSecurityManagerOverrideDb:
-    """
-    FabAirflowSecurityManagerOverride is split into multiple classes to avoid 
having one massive class.
-
-    This class contains all methods in
-    
airflow.auth.managers.fab.security_manager.override.FabAirflowSecurityManagerOverride
 related to the
-    database.
-
-    :param appbuilder: The appbuilder.
-    """
-
-    # Models
-    role_model = Role
-    permission_model = Permission
-    action_model = Action
-    resource_model = Resource
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-        self.appbuilder = kwargs["appbuilder"]
-
-    @property
-    def get_session(self):
-        return self.appbuilder.get_session
-
-    def create_db(self):
-        """
-        Create the database.
-
-        Creates admin and public roles if they don't exist.
-        """
-        if not self.appbuilder.update_perms:
-            log.debug("Skipping db since appbuilder disables update_perms")
-            return
-        try:
-            engine = self.get_session.get_bind(mapper=None, clause=None)
-            inspector = inspect(engine)
-            if "ab_user" not in inspector.get_table_names():
-                log.info(const.LOGMSG_INF_SEC_NO_DB)
-                Base.metadata.create_all(engine)
-                log.info(const.LOGMSG_INF_SEC_ADD_DB)
-
-            roles_mapping = 
self.appbuilder.app.config.get("FAB_ROLES_MAPPING", {})
-            for pk, name in roles_mapping.items():
-                self.update_role(pk, name)
-            for role_name in self._builtin_roles:
-                self.add_role(role_name)
-            if self.auth_role_admin not in self._builtin_roles:
-                self.add_role(self.auth_role_admin)
-            self.add_role(self.auth_role_public)
-            if self.count_users() == 0 and self.auth_role_public != 
self.auth_role_admin:
-                log.warning(const.LOGMSG_WAR_SEC_NO_USER)
-        except Exception as e:
-            log.error(const.LOGMSG_ERR_SEC_CREATE_DB, e)
-            exit(1)
-
-    """
-    -----------
-    Role entity
-    -----------
-    """
-
-    def update_role(self, role_id, name: str) -> Role | None:
-        """Update a role in the database."""
-        role = self.get_session.get(self.role_model, role_id)
-        if not role:
-            return None
-        try:
-            role.name = name
-            self.get_session.merge(role)
-            self.get_session.commit()
-            log.info(const.LOGMSG_INF_SEC_UPD_ROLE, role)
-        except Exception as e:
-            log.error(const.LOGMSG_ERR_SEC_UPD_ROLE, e)
-            self.get_session.rollback()
-            return None
-        return role
-
-    def add_role(self, name: str) -> Role:
-        """Add a role in the database."""
-        role = self.find_role(name)
-        if role is None:
-            try:
-                role = self.role_model()
-                role.name = name
-                self.get_session.add(role)
-                self.get_session.commit()
-                log.info(const.LOGMSG_INF_SEC_ADD_ROLE, name)
-                return role
-            except Exception as e:
-                log.error(const.LOGMSG_ERR_SEC_ADD_ROLE, e)
-                self.get_session.rollback()
-        return role
-
-    def find_role(self, name):
-        """
-        Find a role in the database.
-
-        :param name: the role name
-        """
-        return 
self.get_session.query(self.role_model).filter_by(name=name).one_or_none()
-
-    def get_all_roles(self):
-        return self.get_session.query(self.role_model).all()
-
-    def get_public_role(self):
-        return 
self.get_session.query(self.role_model).filter_by(name=self.auth_role_public).one_or_none()
-
-    def delete_role(self, role_name: str) -> None:
-        """
-        Delete the given Role.
-
-        :param role_name: the name of a role in the ab_role table
-        """
-        session = self.get_session
-        role = session.query(Role).filter(Role.name == role_name).first()
-        if role:
-            log.info("Deleting role '%s'", role_name)
-            session.delete(role)
-            session.commit()
-        else:
-            raise AirflowException(f"Role named '{role_name}' does not exist")
-
-    """
-    -----------
-    User entity
-    -----------
-    """
-
-    def add_user(
-        self,
-        username,
-        first_name,
-        last_name,
-        email,
-        role,
-        password="",
-        hashed_password="",
-    ):
-        """Generic function to create user."""
-        try:
-            user = self.user_model()
-            user.first_name = first_name
-            user.last_name = last_name
-            user.username = username
-            user.email = email
-            user.active = True
-            user.roles = role if isinstance(role, list) else [role]
-            if hashed_password:
-                user.password = hashed_password
-            else:
-                user.password = generate_password_hash(password)
-            self.get_session.add(user)
-            self.get_session.commit()
-            log.info(const.LOGMSG_INF_SEC_ADD_USER, username)
-            return user
-        except Exception as e:
-            log.error(const.LOGMSG_ERR_SEC_ADD_USER, e)
-            self.get_session.rollback()
-            return False
-
-    def load_user(self, user_id):
-        """Load user by ID."""
-        return self.get_user_by_id(int(user_id))
-
-    def get_user_by_id(self, pk):
-        return self.get_session.get(self.user_model, pk)
-
-    def count_users(self):
-        """Return the number of users in the database."""
-        return self.get_session.query(func.count(self.user_model.id)).scalar()
-
-    def add_register_user(self, username, first_name, last_name, email, 
password="", hashed_password=""):
-        """
-        Add a registration request for the user.
-
-        :rtype : RegisterUser
-        """
-        register_user = self.registeruser_model()
-        register_user.username = username
-        register_user.email = email
-        register_user.first_name = first_name
-        register_user.last_name = last_name
-        if hashed_password:
-            register_user.password = hashed_password
-        else:
-            register_user.password = generate_password_hash(password)
-        register_user.registration_hash = str(uuid.uuid1())
-        try:
-            self.get_session.add(register_user)
-            self.get_session.commit()
-            return register_user
-        except Exception as e:
-            log.error(const.LOGMSG_ERR_SEC_ADD_REGISTER_USER, e)
-            self.get_session.rollback()
-            return None
-
-    def find_user(self, username=None, email=None):
-        """Finds user by username or email."""
-        if username:
-            try:
-                if self.auth_username_ci:
-                    return (
-                        self.get_session.query(self.user_model)
-                        .filter(func.lower(self.user_model.username) == 
func.lower(username))
-                        .one_or_none()
-                    )
-                else:
-                    return (
-                        self.get_session.query(self.user_model)
-                        .filter(func.lower(self.user_model.username) == 
func.lower(username))
-                        .one_or_none()
-                    )
-            except MultipleResultsFound:
-                log.error("Multiple results found for user %s", username)
-                return None
-        elif email:
-            try:
-                return 
self.get_session.query(self.user_model).filter_by(email=email).one_or_none()
-            except MultipleResultsFound:
-                log.error("Multiple results found for user with email %s", 
email)
-                return None
-
-    def find_register_user(self, registration_hash):
-        return self.get_session.scalar(
-            select(self.registeruser_mode)
-            .where(self.registeruser_model.registration_hash == 
registration_hash)
-            .limit(1)
-        )
-
-    def update_user(self, user):
-        try:
-            self.get_session.merge(user)
-            self.get_session.commit()
-            log.info(const.LOGMSG_INF_SEC_UPD_USER, user)
-        except Exception as e:
-            log.error(const.LOGMSG_ERR_SEC_UPD_USER, e)
-            self.get_session.rollback()
-            return False
-
-    def del_register_user(self, register_user):
-        """
-        Deletes registration object from database.
-
-        :param register_user: RegisterUser object to delete
-        """
-        try:
-            self.get_session.delete(register_user)
-            self.get_session.commit()
-            return True
-        except Exception as e:
-            log.error(const.LOGMSG_ERR_SEC_DEL_REGISTER_USER, e)
-            self.get_session.rollback()
-            return False
-
-    def get_all_users(self):
-        return self.get_session.query(self.user_model).all()
-
-    """
-    -------------
-    Action entity
-    -------------
-    """
-
-    def get_action(self, name: str) -> Action:
-        """
-        Gets an existing action record.
-
-        :param name: name
-        :return: Action record, if it exists
-        """
-        return 
self.get_session.query(self.action_model).filter_by(name=name).one_or_none()
-
-    def create_action(self, name):
-        """
-        Adds an action to the backend, model action.
-
-        :param name:
-            name of the action: 'can_add','can_edit' etc...
-        """
-        action = self.get_action(name)
-        if action is None:
-            try:
-                action = self.action_model()
-                action.name = name
-                self.get_session.add(action)
-                self.get_session.commit()
-                return action
-            except Exception as e:
-                log.error(const.LOGMSG_ERR_SEC_ADD_PERMISSION, e)
-                self.get_session.rollback()
-        return action
-
-    def delete_action(self, name: str) -> bool:
-        """
-        Deletes a permission action.
-
-        :param name: Name of action to delete (e.g. can_read).
-        """
-        action = self.get_action(name)
-        if not action:
-            log.warning(const.LOGMSG_WAR_SEC_DEL_PERMISSION, name)
-            return False
-        try:
-            perms = (
-                self.get_session.query(self.permission_model)
-                .filter(self.permission_model.action == action)
-                .all()
-            )
-            if perms:
-                log.warning(const.LOGMSG_WAR_SEC_DEL_PERM_PVM, action, perms)
-                return False
-            self.get_session.delete(action)
-            self.get_session.commit()
-            return True
-        except Exception as e:
-            log.error(const.LOGMSG_ERR_SEC_DEL_PERMISSION, e)
-            self.get_session.rollback()
-            return False
-
-    """
-    ---------------
-    Resource entity
-    ---------------
-    """
-
-    def get_resource(self, name: str) -> Resource:
-        """
-        Returns a resource record by name, if it exists.
-
-        :param name: Name of resource
-        """
-        return 
self.get_session.query(self.resource_model).filter_by(name=name).one_or_none()
-
-    def create_resource(self, name) -> Resource:
-        """
-        Create a resource with the given name.
-
-        :param name: The name of the resource to create created.
-        :return: The FAB resource created.
-        """
-        resource = self.get_resource(name)
-        if resource is None:
-            try:
-                resource = self.resource_model()
-                resource.name = name
-                self.get_session.add(resource)
-                self.get_session.commit()
-                return resource
-            except Exception as e:
-                log.error(const.LOGMSG_ERR_SEC_ADD_VIEWMENU, e)
-                self.get_session.rollback()
-        return resource
-
-    def get_all_resources(self) -> list[Resource]:
-        """
-        Gets all existing resource records.
-
-        :return: List of all resources
-        """
-        return self.get_session.query(self.resource_model).all()
-
-    def delete_resource(self, name: str) -> bool:
-        """
-        Deletes a Resource from the backend.
-
-        :param name:
-            name of the resource
-        """
-        resource = self.get_resource(name)
-        if not resource:
-            log.warning(const.LOGMSG_WAR_SEC_DEL_VIEWMENU, name)
-            return False
-        try:
-            perms = (
-                self.get_session.query(self.permission_model)
-                .filter(self.permission_model.resource == resource)
-                .all()
-            )
-            if perms:
-                log.warning(const.LOGMSG_WAR_SEC_DEL_VIEWMENU_PVM, resource, 
perms)
-                return False
-            self.get_session.delete(resource)
-            self.get_session.commit()
-            return True
-        except Exception as e:
-            log.error(const.LOGMSG_ERR_SEC_DEL_PERMISSION, e)
-            self.get_session.rollback()
-            return False
-
-    """
-    ---------------
-    Permission entity
-    ---------------
-    """
-
-    def get_permission(
-        self,
-        action_name: str,
-        resource_name: str,
-    ) -> Permission | None:
-        """
-        Gets a permission made with the given action->resource pair, if the 
permission already exists.
-
-        :param action_name: Name of action
-        :param resource_name: Name of resource
-        :return: The existing permission
-        """
-        action = self.get_action(action_name)
-        resource = self.get_resource(resource_name)
-        if action and resource:
-            return (
-                self.get_session.query(self.permission_model)
-                .filter_by(action=action, resource=resource)
-                .one_or_none()
-            )
-        return None
-
-    def get_resource_permissions(self, resource: Resource) -> Permission:
-        """
-        Retrieve permission pairs associated with a specific resource object.
-
-        :param resource: Object representing a single resource.
-        :return: Action objects representing resource->action pair
-        """
-        return 
self.get_session.query(self.permission_model).filter_by(resource_id=resource.id).all()
-
-    def create_permission(self, action_name, resource_name) -> Permission | 
None:
-        """
-        Adds a permission on a resource to the backend.
-
-        :param action_name:
-            name of the action to add: 'can_add','can_edit' etc...
-        :param resource_name:
-            name of the resource to add
-        """
-        if not (action_name and resource_name):
-            return None
-        perm = self.get_permission(action_name, resource_name)
-        if perm:
-            return perm
-        resource = self.create_resource(resource_name)
-        action = self.create_action(action_name)
-        perm = self.permission_model()
-        perm.resource_id, perm.action_id = resource.id, action.id
-        try:
-            self.get_session.add(perm)
-            self.get_session.commit()
-            log.info(const.LOGMSG_INF_SEC_ADD_PERMVIEW, perm)
-            return perm
-        except Exception as e:
-            log.error(const.LOGMSG_ERR_SEC_ADD_PERMVIEW, e)
-            self.get_session.rollback()
-            return None
-
-    def delete_permission(self, action_name: str, resource_name: str) -> None:
-        """
-        Deletes the permission linking an action->resource pair.
-
-        Doesn't delete the underlying action or resource.
-
-        :param action_name: Name of existing action
-        :param resource_name: Name of existing resource
-        :return: None
-        """
-        if not (action_name and resource_name):
-            return
-        perm = self.get_permission(action_name, resource_name)
-        if not perm:
-            return
-        roles = (
-            
self.get_session.query(self.role_model).filter(self.role_model.permissions.contains(perm)).first()
-        )
-        if roles:
-            log.warning(const.LOGMSG_WAR_SEC_DEL_PERMVIEW, resource_name, 
action_name, roles)
-            return
-        try:
-            # delete permission on resource
-            self.get_session.delete(perm)
-            self.get_session.commit()
-            # if no more permission on permission view, delete permission
-            if not 
self.get_session.query(self.permission_model).filter_by(action=perm.action).all():
-                self.delete_action(perm.action.name)
-            log.info(const.LOGMSG_INF_SEC_DEL_PERMVIEW, action_name, 
resource_name)
-        except Exception as e:
-            log.error(const.LOGMSG_ERR_SEC_DEL_PERMVIEW, e)
-            self.get_session.rollback()
-
-    def add_permission_to_role(self, role: Role, permission: Permission | 
None) -> None:
-        """
-        Add an existing permission pair to a role.
-
-        :param role: The role about to get a new permission.
-        :param permission: The permission pair to add to a role.
-        :return: None
-        """
-        if permission and permission not in role.permissions:
-            try:
-                role.permissions.append(permission)
-                self.get_session.merge(role)
-                self.get_session.commit()
-                log.info(const.LOGMSG_INF_SEC_ADD_PERMROLE, permission, 
role.name)
-            except Exception as e:
-                log.error(const.LOGMSG_ERR_SEC_ADD_PERMROLE, e)
-                self.get_session.rollback()
-
-    def remove_permission_from_role(self, role: Role, permission: Permission) 
-> None:
-        """
-        Remove a permission pair from a role.
-
-        :param role: User role containing permissions.
-        :param permission: Object representing resource-> action pair
-        """
-        if permission in role.permissions:
-            try:
-                role.permissions.remove(permission)
-                self.get_session.merge(role)
-                self.get_session.commit()
-                log.info(const.LOGMSG_INF_SEC_DEL_PERMROLE, permission, 
role.name)
-            except Exception as e:
-                log.error(const.LOGMSG_ERR_SEC_DEL_PERMROLE, e)
-                self.get_session.rollback()
diff --git a/airflow/auth/managers/fab/security_manager/modules/oauth.py 
b/airflow/auth/managers/fab/security_manager/modules/oauth.py
deleted file mode 100644
index e1a10de84d..0000000000
--- a/airflow/auth/managers/fab/security_manager/modules/oauth.py
+++ /dev/null
@@ -1,186 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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.
-from __future__ import annotations
-
-import base64
-import json
-import logging
-
-import re2
-from flask import session
-
-log = logging.getLogger(__name__)
-
-
-class FabAirflowSecurityManagerOverrideOauth:
-    """
-    FabAirflowSecurityManagerOverride is split into multiple classes to avoid 
having one massive class.
-
-    This class contains all methods in
-    
airflow.auth.managers.fab.security_manager.override.FabAirflowSecurityManagerOverride
 related to the
-    oauth authentication.
-    """
-
-    def get_oauth_user_info(self, provider, resp):
-        """
-        Get the OAuth user information from different OAuth APIs.
-
-        All providers have different ways to retrieve user info.
-        """
-        # for GITHUB
-        if provider == "github" or provider == "githublocal":
-            me = self.oauth_remotes[provider].get("user")
-            data = me.json()
-            log.debug("User info from GitHub: %s", data)
-            return {"username": "github_" + data.get("login")}
-        # for twitter
-        if provider == "twitter":
-            me = self.oauth_remotes[provider].get("account/settings.json")
-            data = me.json()
-            log.debug("User info from Twitter: %s", data)
-            return {"username": "twitter_" + data.get("screen_name", "")}
-        # for linkedin
-        if provider == "linkedin":
-            me = self.oauth_remotes[provider].get(
-                "people/~:(id,email-address,first-name,last-name)?format=json"
-            )
-            data = me.json()
-            log.debug("User info from LinkedIn: %s", data)
-            return {
-                "username": "linkedin_" + data.get("id", ""),
-                "email": data.get("email-address", ""),
-                "first_name": data.get("firstName", ""),
-                "last_name": data.get("lastName", ""),
-            }
-        # for Google
-        if provider == "google":
-            me = self.oauth_remotes[provider].get("userinfo")
-            data = me.json()
-            log.debug("User info from Google: %s", data)
-            return {
-                "username": "google_" + data.get("id", ""),
-                "first_name": data.get("given_name", ""),
-                "last_name": data.get("family_name", ""),
-                "email": data.get("email", ""),
-            }
-        # for Azure AD Tenant. Azure OAuth response contains
-        # JWT token which has user info.
-        # JWT token needs to be base64 decoded.
-        # https://docs.microsoft.com/en-us/azure/active-directory/develop/
-        # active-directory-protocols-oauth-code
-        if provider == "azure":
-            log.debug("Azure response received : %s", resp)
-            id_token = resp["id_token"]
-            log.debug(str(id_token))
-            me = 
FabAirflowSecurityManagerOverrideOauth._azure_jwt_token_parse(id_token)
-            log.debug("Parse JWT token : %s", me)
-            return {
-                "name": me.get("name", ""),
-                "email": me["upn"],
-                "first_name": me.get("given_name", ""),
-                "last_name": me.get("family_name", ""),
-                "id": me["oid"],
-                "username": me["oid"],
-                "role_keys": me.get("roles", []),
-            }
-        # for OpenShift
-        if provider == "openshift":
-            me = 
self.oauth_remotes[provider].get("apis/user.openshift.io/v1/users/~")
-            data = me.json()
-            log.debug("User info from OpenShift: %s", data)
-            return {"username": "openshift_" + 
data.get("metadata").get("name")}
-        # for Okta
-        if provider == "okta":
-            me = self.oauth_remotes[provider].get("userinfo")
-            data = me.json()
-            log.debug("User info from Okta: %s", data)
-            return {
-                "username": "okta_" + data.get("sub", ""),
-                "first_name": data.get("given_name", ""),
-                "last_name": data.get("family_name", ""),
-                "email": data.get("email", ""),
-                "role_keys": data.get("groups", []),
-            }
-        # for Keycloak
-        if provider in ["keycloak", "keycloak_before_17"]:
-            me = self.oauth_remotes[provider].get("openid-connect/userinfo")
-            me.raise_for_status()
-            data = me.json()
-            log.debug("User info from Keycloak: %s", data)
-            return {
-                "username": data.get("preferred_username", ""),
-                "first_name": data.get("given_name", ""),
-                "last_name": data.get("family_name", ""),
-                "email": data.get("email", ""),
-            }
-        else:
-            return {}
-
-    @staticmethod
-    def oauth_token_getter():
-        """Authentication (OAuth) token getter function."""
-        token = session.get("oauth")
-        log.debug("Token Get: %s", token)
-        return token
-
-    @staticmethod
-    def _azure_parse_jwt(token):
-        """
-        Parse Azure JWT token content.
-
-        :param token: the JWT token
-
-        :meta private:
-        """
-        jwt_token_parts = r"^([^\.\s]*)\.([^\.\s]+)\.([^\.\s]*)$"
-        matches = re2.search(jwt_token_parts, token)
-        if not matches or len(matches.groups()) < 3:
-            log.error("Unable to parse token.")
-            return {}
-        return {
-            "header": matches.group(1),
-            "Payload": matches.group(2),
-            "Sig": matches.group(3),
-        }
-
-    @staticmethod
-    def _azure_jwt_token_parse(self, token):
-        """
-        Parse and decode Azure JWT token.
-
-        :param token: the JWT token
-
-        :meta private:
-        """
-        jwt_split_token = 
FabAirflowSecurityManagerOverrideOauth._azure_parse_jwt(token)
-        if not jwt_split_token:
-            return
-
-        jwt_payload = jwt_split_token["Payload"]
-        # Prepare for base64 decoding
-        payload_b64_string = jwt_payload
-        payload_b64_string += "=" * (4 - (len(jwt_payload) % 4))
-        decoded_payload = 
base64.urlsafe_b64decode(payload_b64_string.encode("ascii"))
-
-        if not decoded_payload:
-            log.error("Payload of id_token could not be base64 url decoded.")
-            return
-
-        jwt_decoded_payload = json.loads(decoded_payload.decode("utf-8"))
-
-        return jwt_decoded_payload
diff --git a/airflow/auth/managers/fab/security_manager/override.py 
b/airflow/auth/managers/fab/security_manager/override.py
index 011f43e86b..66032dc166 100644
--- a/airflow/auth/managers/fab/security_manager/override.py
+++ b/airflow/auth/managers/fab/security_manager/override.py
@@ -17,26 +17,33 @@
 # under the License.
 from __future__ import annotations
 
+import base64
+import json
 import logging
+import uuid
 import warnings
 from functools import cached_property
 from typing import TYPE_CHECKING
 
-from flask import flash, g
+import re2
+from flask import flash, g, session
 from flask_appbuilder import const
 from flask_appbuilder.const import AUTH_DB, AUTH_LDAP, AUTH_OAUTH, AUTH_OID, 
AUTH_REMOTE_USER
+from flask_appbuilder.models.sqla import Base
 from flask_appbuilder.models.sqla.interface import SQLAInterface
 from flask_babel import lazy_gettext
 from flask_jwt_extended import JWTManager
 from flask_login import LoginManager
 from itsdangerous import want_bytes
 from markupsafe import Markup
+from sqlalchemy import func, inspect, select
+from sqlalchemy.exc import MultipleResultsFound
 from werkzeug.security import generate_password_hash
 
+from airflow import AirflowException
 from airflow.auth.managers.fab.models import Action, Permission, RegisterUser, 
Resource, Role
 from airflow.auth.managers.fab.models.anonymous_user import AnonymousUser
-from airflow.auth.managers.fab.security_manager.modules.db import 
FabAirflowSecurityManagerOverrideDb
-from airflow.auth.managers.fab.security_manager.modules.oauth import 
FabAirflowSecurityManagerOverrideOauth
+from airflow.www.security_manager import AirflowSecurityManagerV2
 from airflow.www.session import AirflowDatabaseSessionInterface
 
 if TYPE_CHECKING:
@@ -53,9 +60,7 @@ log = logging.getLogger(__name__)
 MAX_NUM_DATABASE_USER_SESSIONS = 50000
 
 
-class FabAirflowSecurityManagerOverride(
-    FabAirflowSecurityManagerOverrideDb, FabAirflowSecurityManagerOverrideOauth
-):
+class FabAirflowSecurityManagerOverride(AirflowSecurityManagerV2):
     """
     This security manager overrides the default AirflowSecurityManager 
security manager.
 
@@ -64,29 +69,6 @@ class FabAirflowSecurityManagerOverride(
     the AirflowSecurityManager should be defined here instead of 
AirflowSecurityManager.
 
     :param appbuilder: The appbuilder.
-    :param actionmodelview: The obj instance for action model view.
-    :param authdbview: The class for auth db view.
-    :param authldapview: The class for auth ldap view.
-    :param authoauthview: The class for auth oauth view.
-    :param authoidview: The class for auth oid view.
-    :param authremoteuserview: The class for auth remote user view.
-    :param permissionmodelview: The class for permission model view.
-    :param registeruser_view: The class for register user view.
-    :param registeruserdbview: The class for register user db view.
-    :param registeruseroauthview: The class for register user oauth view.
-    :param registerusermodelview: The class for register user model view.
-    :param registeruseroidview: The class for register user oid view.
-    :param resetmypasswordview: The class for reset my password view.
-    :param resetpasswordview: The class for reset password view.
-    :param rolemodelview: The class for role model view.
-    :param user_model: The user model.
-    :param userinfoeditview: The class for user info edit view.
-    :param userdbmodelview: The class for user db model view.
-    :param userldapmodelview: The class for user ldap model view.
-    :param useroauthmodelview: The class for user oauth model view.
-    :param useroidmodelview: The class for user oid model view.
-    :param userremoteusermodelview: The class for user remote user model view.
-    :param userstatschartview: The class for user stats chart view.
     """
 
     """ The obj instance for authentication view """
@@ -103,37 +85,16 @@ class FabAirflowSecurityManagerOverride(
     """ Initialized (remote_app) providers dict {'provider_name', OBJ } """
     oauth_allow_list: dict[str, list] = {}
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-        self.appbuilder = kwargs["appbuilder"]
-        self.actionmodelview = kwargs["actionmodelview"]
-        self.authdbview = kwargs["authdbview"]
-        self.authldapview = kwargs["authldapview"]
-        self.authoauthview = kwargs["authoauthview"]
-        self.authoidview = kwargs["authoidview"]
-        self.authremoteuserview = kwargs["authremoteuserview"]
-        self.permissionmodelview = kwargs["permissionmodelview"]
-        self.registeruser_view = kwargs["registeruser_view"]
-        self.registeruserdbview = kwargs["registeruserdbview"]
-        self.registeruseroauthview = kwargs["registeruseroauthview"]
-        self.registerusermodelview = kwargs["registerusermodelview"]
-        self.registeruseroidview = kwargs["registeruseroidview"]
-        self.resetmypasswordview = kwargs["resetmypasswordview"]
-        self.resetpasswordview = kwargs["resetpasswordview"]
-        self.rolemodelview = kwargs["rolemodelview"]
-        self.user_model = kwargs["user_model"]
-        self.userinfoeditview = kwargs["userinfoeditview"]
-        self.userdbmodelview = kwargs["userdbmodelview"]
-        self.userldapmodelview = kwargs["userldapmodelview"]
-        self.useroauthmodelview = kwargs["useroauthmodelview"]
-        self.useroidmodelview = kwargs["useroidmodelview"]
-        self.userremoteusermodelview = kwargs["userremoteusermodelview"]
-        self.userstatschartview = kwargs["userstatschartview"]
+    def __init__(self, appbuilder):
+        # done in super, but we need it before we can call super.
+        self.appbuilder = appbuilder
 
         self._init_config()
         self._init_auth()
         self._init_data_model()
+        # can only call super once data model init has been done
+        # because of the view.datamodel hack that's done in the init there.
+        super().__init__(appbuilder=appbuilder)
 
         self._builtin_roles: dict = self.create_builtin_roles()
 
@@ -314,10 +275,6 @@ class FabAirflowSecurityManagerOverride(
                 "warning",
             )
 
-    def load_user(self, user_id):
-        """Load user by ID."""
-        return self.get_user_by_id(int(user_id))
-
     def load_user_jwt(self, _jwt_header, jwt_data):
         identity = jwt_data["sub"]
         user = self.load_user(identity)
@@ -444,7 +401,7 @@ class FabAirflowSecurityManagerOverride(
                 provider_name = provider["name"]
                 log.debug("OAuth providers init %s", provider_name)
                 obj_provider = self.oauth.register(provider_name, 
**provider["remote_app"])
-                obj_provider._tokengetter = 
FabAirflowSecurityManagerOverrideOauth.oauth_token_getter
+                obj_provider._tokengetter = self.oauth_token_getter
                 if not self.oauth_user_info:
                     self.oauth_user_info = self.get_oauth_user_info
                 # Whitelist only users with matching emails
@@ -474,3 +431,650 @@ class FabAirflowSecurityManagerOverride(
         self.actionmodelview.datamodel = SQLAInterface(self.action_model)
         self.resourcemodelview.datamodel = SQLAInterface(self.resource_model)
         self.permissionmodelview.datamodel = 
SQLAInterface(self.permission_model)
+
+    def create_db(self):
+        """
+        Create the database.
+
+        Creates admin and public roles if they don't exist.
+        """
+        if not self.appbuilder.update_perms:
+            log.debug("Skipping db since appbuilder disables update_perms")
+            return
+        try:
+            engine = self.get_session.get_bind(mapper=None, clause=None)
+            inspector = inspect(engine)
+            if "ab_user" not in inspector.get_table_names():
+                log.info(const.LOGMSG_INF_SEC_NO_DB)
+                Base.metadata.create_all(engine)
+                log.info(const.LOGMSG_INF_SEC_ADD_DB)
+
+            roles_mapping = 
self.appbuilder.app.config.get("FAB_ROLES_MAPPING", {})
+            for pk, name in roles_mapping.items():
+                self.update_role(pk, name)
+            for role_name in self._builtin_roles:
+                self.add_role(role_name)
+            if self.auth_role_admin not in self._builtin_roles:
+                self.add_role(self.auth_role_admin)
+            self.add_role(self.auth_role_public)
+            if self.count_users() == 0 and self.auth_role_public != 
self.auth_role_admin:
+                log.warning(const.LOGMSG_WAR_SEC_NO_USER)
+        except Exception as e:
+            log.error(const.LOGMSG_ERR_SEC_CREATE_DB, e)
+            exit(1)
+
+    """
+    -----------
+    Role entity
+    -----------
+    """
+
+    def update_role(self, role_id, name: str) -> Role | None:
+        """Update a role in the database."""
+        role = self.get_session.get(self.role_model, role_id)
+        if not role:
+            return None
+        try:
+            role.name = name
+            self.get_session.merge(role)
+            self.get_session.commit()
+            log.info(const.LOGMSG_INF_SEC_UPD_ROLE, role)
+        except Exception as e:
+            log.error(const.LOGMSG_ERR_SEC_UPD_ROLE, e)
+            self.get_session.rollback()
+            return None
+        return role
+
+    def add_role(self, name: str) -> Role:
+        """Add a role in the database."""
+        role = self.find_role(name)
+        if role is None:
+            try:
+                role = self.role_model()
+                role.name = name
+                self.get_session.add(role)
+                self.get_session.commit()
+                log.info(const.LOGMSG_INF_SEC_ADD_ROLE, name)
+                return role
+            except Exception as e:
+                log.error(const.LOGMSG_ERR_SEC_ADD_ROLE, e)
+                self.get_session.rollback()
+        return role
+
+    def find_role(self, name):
+        """
+        Find a role in the database.
+
+        :param name: the role name
+        """
+        return 
self.get_session.query(self.role_model).filter_by(name=name).one_or_none()
+
+    def get_all_roles(self):
+        return self.get_session.query(self.role_model).all()
+
+    def get_public_role(self):
+        return 
self.get_session.query(self.role_model).filter_by(name=self.auth_role_public).one_or_none()
+
+    def delete_role(self, role_name: str) -> None:
+        """
+        Delete the given Role.
+
+        :param role_name: the name of a role in the ab_role table
+        """
+        session = self.get_session
+        role = session.query(Role).filter(Role.name == role_name).first()
+        if role:
+            log.info("Deleting role '%s'", role_name)
+            session.delete(role)
+            session.commit()
+        else:
+            raise AirflowException(f"Role named '{role_name}' does not exist")
+
+    """
+    -----------
+    User entity
+    -----------
+    """
+
+    def add_user(
+        self,
+        username,
+        first_name,
+        last_name,
+        email,
+        role,
+        password="",
+        hashed_password="",
+    ):
+        """Generic function to create user."""
+        try:
+            user = self.user_model()
+            user.first_name = first_name
+            user.last_name = last_name
+            user.username = username
+            user.email = email
+            user.active = True
+            user.roles = role if isinstance(role, list) else [role]
+            if hashed_password:
+                user.password = hashed_password
+            else:
+                user.password = generate_password_hash(password)
+            self.get_session.add(user)
+            self.get_session.commit()
+            log.info(const.LOGMSG_INF_SEC_ADD_USER, username)
+            return user
+        except Exception as e:
+            log.error(const.LOGMSG_ERR_SEC_ADD_USER, e)
+            self.get_session.rollback()
+            return False
+
+    def load_user(self, user_id):
+        """Load user by ID."""
+        return self.get_user_by_id(int(user_id))
+
+    def get_user_by_id(self, pk):
+        return self.get_session.get(self.user_model, pk)
+
+    def count_users(self):
+        """Return the number of users in the database."""
+        return self.get_session.query(func.count(self.user_model.id)).scalar()
+
+    def add_register_user(self, username, first_name, last_name, email, 
password="", hashed_password=""):
+        """
+        Add a registration request for the user.
+
+        :rtype : RegisterUser
+        """
+        register_user = self.registeruser_model()
+        register_user.username = username
+        register_user.email = email
+        register_user.first_name = first_name
+        register_user.last_name = last_name
+        if hashed_password:
+            register_user.password = hashed_password
+        else:
+            register_user.password = generate_password_hash(password)
+        register_user.registration_hash = str(uuid.uuid1())
+        try:
+            self.get_session.add(register_user)
+            self.get_session.commit()
+            return register_user
+        except Exception as e:
+            log.error(const.LOGMSG_ERR_SEC_ADD_REGISTER_USER, e)
+            self.get_session.rollback()
+            return None
+
+    def find_user(self, username=None, email=None):
+        """Finds user by username or email."""
+        if username:
+            try:
+                if self.auth_username_ci:
+                    return (
+                        self.get_session.query(self.user_model)
+                        .filter(func.lower(self.user_model.username) == 
func.lower(username))
+                        .one_or_none()
+                    )
+                else:
+                    return (
+                        self.get_session.query(self.user_model)
+                        .filter(func.lower(self.user_model.username) == 
func.lower(username))
+                        .one_or_none()
+                    )
+            except MultipleResultsFound:
+                log.error("Multiple results found for user %s", username)
+                return None
+        elif email:
+            try:
+                return 
self.get_session.query(self.user_model).filter_by(email=email).one_or_none()
+            except MultipleResultsFound:
+                log.error("Multiple results found for user with email %s", 
email)
+                return None
+
+    def find_register_user(self, registration_hash):
+        return self.get_session.scalar(
+            select(self.registeruser_mode)
+            .where(self.registeruser_model.registration_hash == 
registration_hash)
+            .limit(1)
+        )
+
+    def update_user(self, user):
+        try:
+            self.get_session.merge(user)
+            self.get_session.commit()
+            log.info(const.LOGMSG_INF_SEC_UPD_USER, user)
+        except Exception as e:
+            log.error(const.LOGMSG_ERR_SEC_UPD_USER, e)
+            self.get_session.rollback()
+            return False
+
+    def del_register_user(self, register_user):
+        """
+        Deletes registration object from database.
+
+        :param register_user: RegisterUser object to delete
+        """
+        try:
+            self.get_session.delete(register_user)
+            self.get_session.commit()
+            return True
+        except Exception as e:
+            log.error(const.LOGMSG_ERR_SEC_DEL_REGISTER_USER, e)
+            self.get_session.rollback()
+            return False
+
+    def get_all_users(self):
+        return self.get_session.query(self.user_model).all()
+
+    """
+    -------------
+    Action entity
+    -------------
+    """
+
+    def get_action(self, name: str) -> Action:
+        """
+        Gets an existing action record.
+
+        :param name: name
+        :return: Action record, if it exists
+        """
+        return 
self.get_session.query(self.action_model).filter_by(name=name).one_or_none()
+
+    def create_action(self, name):
+        """
+        Adds an action to the backend, model action.
+
+        :param name:
+            name of the action: 'can_add','can_edit' etc...
+        """
+        action = self.get_action(name)
+        if action is None:
+            try:
+                action = self.action_model()
+                action.name = name
+                self.get_session.add(action)
+                self.get_session.commit()
+                return action
+            except Exception as e:
+                log.error(const.LOGMSG_ERR_SEC_ADD_PERMISSION, e)
+                self.get_session.rollback()
+        return action
+
+    def delete_action(self, name: str) -> bool:
+        """
+        Deletes a permission action.
+
+        :param name: Name of action to delete (e.g. can_read).
+        """
+        action = self.get_action(name)
+        if not action:
+            log.warning(const.LOGMSG_WAR_SEC_DEL_PERMISSION, name)
+            return False
+        try:
+            perms = (
+                self.get_session.query(self.permission_model)
+                .filter(self.permission_model.action == action)
+                .all()
+            )
+            if perms:
+                log.warning(const.LOGMSG_WAR_SEC_DEL_PERM_PVM, action, perms)
+                return False
+            self.get_session.delete(action)
+            self.get_session.commit()
+            return True
+        except Exception as e:
+            log.error(const.LOGMSG_ERR_SEC_DEL_PERMISSION, e)
+            self.get_session.rollback()
+            return False
+
+    """
+    ---------------
+    Resource entity
+    ---------------
+    """
+
+    def get_resource(self, name: str) -> Resource:
+        """
+        Returns a resource record by name, if it exists.
+
+        :param name: Name of resource
+        """
+        return 
self.get_session.query(self.resource_model).filter_by(name=name).one_or_none()
+
+    def create_resource(self, name) -> Resource:
+        """
+        Create a resource with the given name.
+
+        :param name: The name of the resource to create created.
+        :return: The FAB resource created.
+        """
+        resource = self.get_resource(name)
+        if resource is None:
+            try:
+                resource = self.resource_model()
+                resource.name = name
+                self.get_session.add(resource)
+                self.get_session.commit()
+                return resource
+            except Exception as e:
+                log.error(const.LOGMSG_ERR_SEC_ADD_VIEWMENU, e)
+                self.get_session.rollback()
+        return resource
+
+    def get_all_resources(self) -> list[Resource]:
+        """
+        Gets all existing resource records.
+
+        :return: List of all resources
+        """
+        return self.get_session.query(self.resource_model).all()
+
+    def delete_resource(self, name: str) -> bool:
+        """
+        Deletes a Resource from the backend.
+
+        :param name:
+            name of the resource
+        """
+        resource = self.get_resource(name)
+        if not resource:
+            log.warning(const.LOGMSG_WAR_SEC_DEL_VIEWMENU, name)
+            return False
+        try:
+            perms = (
+                self.get_session.query(self.permission_model)
+                .filter(self.permission_model.resource == resource)
+                .all()
+            )
+            if perms:
+                log.warning(const.LOGMSG_WAR_SEC_DEL_VIEWMENU_PVM, resource, 
perms)
+                return False
+            self.get_session.delete(resource)
+            self.get_session.commit()
+            return True
+        except Exception as e:
+            log.error(const.LOGMSG_ERR_SEC_DEL_PERMISSION, e)
+            self.get_session.rollback()
+            return False
+
+    """
+    ---------------
+    Permission entity
+    ---------------
+    """
+
+    def get_permission(
+        self,
+        action_name: str,
+        resource_name: str,
+    ) -> Permission | None:
+        """
+        Gets a permission made with the given action->resource pair, if the 
permission already exists.
+
+        :param action_name: Name of action
+        :param resource_name: Name of resource
+        :return: The existing permission
+        """
+        action = self.get_action(action_name)
+        resource = self.get_resource(resource_name)
+        if action and resource:
+            return (
+                self.get_session.query(self.permission_model)
+                .filter_by(action=action, resource=resource)
+                .one_or_none()
+            )
+        return None
+
+    def get_resource_permissions(self, resource: Resource) -> Permission:
+        """
+        Retrieve permission pairs associated with a specific resource object.
+
+        :param resource: Object representing a single resource.
+        :return: Action objects representing resource->action pair
+        """
+        return 
self.get_session.query(self.permission_model).filter_by(resource_id=resource.id).all()
+
+    def create_permission(self, action_name, resource_name) -> Permission | 
None:
+        """
+        Adds a permission on a resource to the backend.
+
+        :param action_name:
+            name of the action to add: 'can_add','can_edit' etc...
+        :param resource_name:
+            name of the resource to add
+        """
+        if not (action_name and resource_name):
+            return None
+        perm = self.get_permission(action_name, resource_name)
+        if perm:
+            return perm
+        resource = self.create_resource(resource_name)
+        action = self.create_action(action_name)
+        perm = self.permission_model()
+        perm.resource_id, perm.action_id = resource.id, action.id
+        try:
+            self.get_session.add(perm)
+            self.get_session.commit()
+            log.info(const.LOGMSG_INF_SEC_ADD_PERMVIEW, perm)
+            return perm
+        except Exception as e:
+            log.error(const.LOGMSG_ERR_SEC_ADD_PERMVIEW, e)
+            self.get_session.rollback()
+            return None
+
+    def delete_permission(self, action_name: str, resource_name: str) -> None:
+        """
+        Deletes the permission linking an action->resource pair.
+
+        Doesn't delete the underlying action or resource.
+
+        :param action_name: Name of existing action
+        :param resource_name: Name of existing resource
+        :return: None
+        """
+        if not (action_name and resource_name):
+            return
+        perm = self.get_permission(action_name, resource_name)
+        if not perm:
+            return
+        roles = (
+            
self.get_session.query(self.role_model).filter(self.role_model.permissions.contains(perm)).first()
+        )
+        if roles:
+            log.warning(const.LOGMSG_WAR_SEC_DEL_PERMVIEW, resource_name, 
action_name, roles)
+            return
+        try:
+            # delete permission on resource
+            self.get_session.delete(perm)
+            self.get_session.commit()
+            # if no more permission on permission view, delete permission
+            if not 
self.get_session.query(self.permission_model).filter_by(action=perm.action).all():
+                self.delete_action(perm.action.name)
+            log.info(const.LOGMSG_INF_SEC_DEL_PERMVIEW, action_name, 
resource_name)
+        except Exception as e:
+            log.error(const.LOGMSG_ERR_SEC_DEL_PERMVIEW, e)
+            self.get_session.rollback()
+
+    def add_permission_to_role(self, role: Role, permission: Permission | 
None) -> None:
+        """
+        Add an existing permission pair to a role.
+
+        :param role: The role about to get a new permission.
+        :param permission: The permission pair to add to a role.
+        :return: None
+        """
+        if permission and permission not in role.permissions:
+            try:
+                role.permissions.append(permission)
+                self.get_session.merge(role)
+                self.get_session.commit()
+                log.info(const.LOGMSG_INF_SEC_ADD_PERMROLE, permission, 
role.name)
+            except Exception as e:
+                log.error(const.LOGMSG_ERR_SEC_ADD_PERMROLE, e)
+                self.get_session.rollback()
+
+    def remove_permission_from_role(self, role: Role, permission: Permission) 
-> None:
+        """
+        Remove a permission pair from a role.
+
+        :param role: User role containing permissions.
+        :param permission: Object representing resource-> action pair
+        """
+        if permission in role.permissions:
+            try:
+                role.permissions.remove(permission)
+                self.get_session.merge(role)
+                self.get_session.commit()
+                log.info(const.LOGMSG_INF_SEC_DEL_PERMROLE, permission, 
role.name)
+            except Exception as e:
+                log.error(const.LOGMSG_ERR_SEC_DEL_PERMROLE, e)
+                self.get_session.rollback()
+
+    def get_oauth_user_info(self, provider, resp):
+        """
+        Get the OAuth user information from different OAuth APIs.
+
+        All providers have different ways to retrieve user info.
+        """
+        # for GITHUB
+        if provider == "github" or provider == "githublocal":
+            me = self.oauth_remotes[provider].get("user")
+            data = me.json()
+            log.debug("User info from GitHub: %s", data)
+            return {"username": "github_" + data.get("login")}
+        # for twitter
+        if provider == "twitter":
+            me = self.oauth_remotes[provider].get("account/settings.json")
+            data = me.json()
+            log.debug("User info from Twitter: %s", data)
+            return {"username": "twitter_" + data.get("screen_name", "")}
+        # for linkedin
+        if provider == "linkedin":
+            me = self.oauth_remotes[provider].get(
+                "people/~:(id,email-address,first-name,last-name)?format=json"
+            )
+            data = me.json()
+            log.debug("User info from LinkedIn: %s", data)
+            return {
+                "username": "linkedin_" + data.get("id", ""),
+                "email": data.get("email-address", ""),
+                "first_name": data.get("firstName", ""),
+                "last_name": data.get("lastName", ""),
+            }
+        # for Google
+        if provider == "google":
+            me = self.oauth_remotes[provider].get("userinfo")
+            data = me.json()
+            log.debug("User info from Google: %s", data)
+            return {
+                "username": "google_" + data.get("id", ""),
+                "first_name": data.get("given_name", ""),
+                "last_name": data.get("family_name", ""),
+                "email": data.get("email", ""),
+            }
+        # for Azure AD Tenant. Azure OAuth response contains
+        # JWT token which has user info.
+        # JWT token needs to be base64 decoded.
+        # https://docs.microsoft.com/en-us/azure/active-directory/develop/
+        # active-directory-protocols-oauth-code
+        if provider == "azure":
+            log.debug("Azure response received : %s", resp)
+            id_token = resp["id_token"]
+            log.debug(str(id_token))
+            me = self._azure_jwt_token_parse(id_token)
+            log.debug("Parse JWT token : %s", me)
+            return {
+                "name": me.get("name", ""),
+                "email": me["upn"],
+                "first_name": me.get("given_name", ""),
+                "last_name": me.get("family_name", ""),
+                "id": me["oid"],
+                "username": me["oid"],
+                "role_keys": me.get("roles", []),
+            }
+        # for OpenShift
+        if provider == "openshift":
+            me = 
self.oauth_remotes[provider].get("apis/user.openshift.io/v1/users/~")
+            data = me.json()
+            log.debug("User info from OpenShift: %s", data)
+            return {"username": "openshift_" + 
data.get("metadata").get("name")}
+        # for Okta
+        if provider == "okta":
+            me = self.oauth_remotes[provider].get("userinfo")
+            data = me.json()
+            log.debug("User info from Okta: %s", data)
+            return {
+                "username": "okta_" + data.get("sub", ""),
+                "first_name": data.get("given_name", ""),
+                "last_name": data.get("family_name", ""),
+                "email": data.get("email", ""),
+                "role_keys": data.get("groups", []),
+            }
+        # for Keycloak
+        if provider in ["keycloak", "keycloak_before_17"]:
+            me = self.oauth_remotes[provider].get("openid-connect/userinfo")
+            me.raise_for_status()
+            data = me.json()
+            log.debug("User info from Keycloak: %s", data)
+            return {
+                "username": data.get("preferred_username", ""),
+                "first_name": data.get("given_name", ""),
+                "last_name": data.get("family_name", ""),
+                "email": data.get("email", ""),
+            }
+        else:
+            return {}
+
+    @staticmethod
+    def oauth_token_getter():
+        """Authentication (OAuth) token getter function."""
+        token = session.get("oauth")
+        log.debug("Token Get: %s", token)
+        return token
+
+    @staticmethod
+    def _azure_parse_jwt(token):
+        """
+        Parse Azure JWT token content.
+
+        :param token: the JWT token
+
+        :meta private:
+        """
+        jwt_token_parts = r"^([^\.\s]*)\.([^\.\s]+)\.([^\.\s]*)$"
+        matches = re2.search(jwt_token_parts, token)
+        if not matches or len(matches.groups()) < 3:
+            log.error("Unable to parse token.")
+            return {}
+        return {
+            "header": matches.group(1),
+            "Payload": matches.group(2),
+            "Sig": matches.group(3),
+        }
+
+    @staticmethod
+    def _azure_jwt_token_parse(token):
+        """
+        Parse and decode Azure JWT token.
+
+        :param token: the JWT token
+
+        :meta private:
+        """
+        jwt_split_token = 
FabAirflowSecurityManagerOverride._azure_parse_jwt(token)
+        if not jwt_split_token:
+            return
+
+        jwt_payload = jwt_split_token["Payload"]
+        # Prepare for base64 decoding
+        payload_b64_string = jwt_payload
+        payload_b64_string += "=" * (4 - (len(jwt_payload) % 4))
+        decoded_payload = 
base64.urlsafe_b64decode(payload_b64_string.encode("ascii"))
+
+        if not decoded_payload:
+            log.error("Payload of id_token could not be base64 url decoded.")
+            return
+
+        jwt_decoded_payload = json.loads(decoded_payload.decode("utf-8"))
+
+        return jwt_decoded_payload
diff --git a/airflow/models/dagbag.py b/airflow/models/dagbag.py
index 7a926f2736..b603cf08be 100644
--- a/airflow/models/dagbag.py
+++ b/airflow/models/dagbag.py
@@ -692,7 +692,7 @@ class DagBag(LoggingMixin):
         root_dag_id = dag.parent_dag.dag_id if dag.parent_dag else dag.dag_id
 
         cls.logger().debug("Syncing DAG permissions: %s to the DB", 
root_dag_id)
-        from airflow.www.security import ApplessAirflowSecurityManager
+        from airflow.www.security_appless import ApplessAirflowSecurityManager
 
         security_manager = ApplessAirflowSecurityManager(session=session)
         security_manager.sync_perm_for_dag(root_dag_id, dag.access_control)
diff --git a/airflow/www/extensions/init_appbuilder.py 
b/airflow/www/extensions/init_appbuilder.py
index 2f8fe473aa..12474142d1 100644
--- a/airflow/www/extensions/init_appbuilder.py
+++ b/airflow/www/extensions/init_appbuilder.py
@@ -40,13 +40,15 @@ from flask_appbuilder.views import IndexView, UtilView
 
 from airflow import settings
 from airflow.configuration import conf
-from airflow.www.extensions.init_auth_manager import get_auth_manager
+from airflow.www.extensions.init_auth_manager import get_auth_manager, 
init_auth_manager
 
 if TYPE_CHECKING:
+    from flask import Flask
     from flask_appbuilder import BaseView
     from flask_appbuilder.security.manager import BaseSecurityManager
     from sqlalchemy.orm import Session
 
+
 # This product contains a modified portion of 'Flask App Builder' developed by 
Daniel Vaz Gaspar.
 # (https://github.com/dpgaspar/Flask-AppBuilder).
 # Copyright 2013, Daniel Vaz Gaspar
@@ -655,22 +657,13 @@ class AirflowAppBuilder:
                         view.get_init_inner_views().append(v)
 
 
-def init_appbuilder(app) -> AirflowAppBuilder:
+def init_appbuilder(app: Flask) -> AirflowAppBuilder:
     """Init `Flask App Builder 
<https://flask-appbuilder.readthedocs.io/en/latest/>`__."""
-    from airflow.www.security import AirflowSecurityManager
-
-    security_manager_class = app.config.get("SECURITY_MANAGER_CLASS") or 
AirflowSecurityManager
-
-    if not issubclass(security_manager_class, AirflowSecurityManager):
-        raise Exception(
-            """Your CUSTOM_SECURITY_MANAGER must now extend 
AirflowSecurityManager,
-             not FAB's security manager."""
-        )
-
+    auth_manager = init_auth_manager(app)
     return AirflowAppBuilder(
         app=app,
         session=settings.Session,
-        security_manager_class=security_manager_class,
+        
security_manager_class=auth_manager.get_security_manager_override_class(),
         base_template="airflow/main.html",
         update_perms=conf.getboolean("webserver", "UPDATE_FAB_PERMS"),
         auth_rate_limited=conf.getboolean("webserver", "AUTH_RATE_LIMITED", 
fallback=True),
diff --git a/airflow/www/extensions/init_auth_manager.py 
b/airflow/www/extensions/init_auth_manager.py
index 24ae020862..32db0f2cdc 100644
--- a/airflow/www/extensions/init_auth_manager.py
+++ b/airflow/www/extensions/init_auth_manager.py
@@ -18,13 +18,16 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from airflow.compat.functools import cache
 from airflow.configuration import conf
 from airflow.exceptions import AirflowConfigException
 
 if TYPE_CHECKING:
+    from flask import Flask
+
     from airflow.auth.managers.base_auth_manager import BaseAuthManager
 
+auth_manager: BaseAuthManager | None = None
+
 
 def get_auth_manager_cls() -> type[BaseAuthManager]:
     """Returns just the auth manager class without initializing it.
@@ -42,13 +45,22 @@ def get_auth_manager_cls() -> type[BaseAuthManager]:
     return auth_manager_cls
 
 
-@cache
-def get_auth_manager() -> BaseAuthManager:
-    """
-    Initialize auth manager.
+def init_auth_manager(app: Flask) -> BaseAuthManager:
+    """Initialize the auth manager with the given flask app object.
 
-    Import the user manager class, instantiate it and return it.
+    Import the user manager class and instantiate it.
     """
+    global auth_manager
     auth_manager_cls = get_auth_manager_cls()
+    auth_manager = auth_manager_cls(app)
+    return auth_manager
 
-    return auth_manager_cls()
+
+def get_auth_manager() -> BaseAuthManager:
+    """Returns the auth manager, provided it's been initialized before."""
+    if auth_manager is None:
+        raise Exception(
+            "Auth Manager has not been initialized yet. "
+            "The `init_auth_manager` method needs to be called first."
+        )
+    return auth_manager
diff --git a/airflow/www/fab_security/manager.py 
b/airflow/www/fab_security/manager.py
index 0b2eb3492a..2015a572ed 100644
--- a/airflow/www/fab_security/manager.py
+++ b/airflow/www/fab_security/manager.py
@@ -196,6 +196,9 @@ class BaseSecurityManager:
                         log.warning("Can't find role specified in 
AUTH_ROLES_MAPPING: %s", fab_role_name)
         return _roles
 
+    def add_role(self, name: str) -> Role:
+        raise NotImplementedError
+
     @property
     def auth_type_provider_name(self):
         provider_to_auth_type = {AUTH_DB: "db", AUTH_LDAP: "ldap"}
@@ -1074,6 +1077,12 @@ class BaseSecurityManager:
             role_admin = self.find_role(self.auth_role_admin)
             self.add_permission_to_role(role_admin, perm)
 
+    def get_resource(self, name: str) -> Resource:
+        raise NotImplementedError
+
+    def get_action(self, name: str) -> Action:
+        raise NotImplementedError
+
     def security_cleanup(self, baseviews, menus):
         """
         Will cleanup all unused permissions from the database.
diff --git a/airflow/www/security.py b/airflow/www/security.py
index 0a8d6cbf1e..0f0a0f5aed 100644
--- a/airflow/www/security.py
+++ b/airflow/www/security.py
@@ -16,785 +16,25 @@
 # under the License.
 from __future__ import annotations
 
-import warnings
-from typing import TYPE_CHECKING, Any, Collection, Container, Iterable, 
Sequence
+from typing import TYPE_CHECKING
 
-from flask import g
-from sqlalchemy import or_, select
-from sqlalchemy.orm import joinedload
+from deprecated import deprecated
 
-from airflow.auth.managers.fab.models import Permission, Resource, Role, User
-from airflow.auth.managers.fab.views.permissions import (
-    ActionModelView,
-    PermissionPairModelView,
-    ResourceModelView,
-)
-from airflow.auth.managers.fab.views.roles_list import CustomRoleModelView
-from airflow.auth.managers.fab.views.user import (
-    CustomUserDBModelView,
-    CustomUserLDAPModelView,
-    CustomUserOAuthModelView,
-    CustomUserOIDModelView,
-    CustomUserRemoteUserModelView,
-)
-from airflow.auth.managers.fab.views.user_edit import (
-    CustomResetMyPasswordView,
-    CustomResetPasswordView,
-    CustomUserInfoEditView,
-)
-from airflow.auth.managers.fab.views.user_stats import CustomUserStatsChartView
-from airflow.exceptions import AirflowException, RemovedInAirflow3Warning
-from airflow.models import DagBag, DagModel
-from airflow.security import permissions
-from airflow.utils.log.logging_mixin import LoggingMixin
-from airflow.utils.session import NEW_SESSION, provide_session
-from airflow.www.extensions.init_auth_manager import get_auth_manager
-from airflow.www.fab_security.sqla.manager import SecurityManager
-from airflow.www.utils import CustomSQLAInterface
-
-EXISTING_ROLES = {
-    "Admin",
-    "Viewer",
-    "User",
-    "Op",
-    "Public",
-}
+from airflow.auth.managers.fab.security_manager.override import 
FabAirflowSecurityManagerOverride
 
 if TYPE_CHECKING:
-    from sqlalchemy.orm import Session
-
-    SecurityManagerOverride: type = object
-else:
-    # Fetch the security manager override from the auth manager
-    SecurityManagerOverride = 
get_auth_manager().get_security_manager_override_class()
-
-
-class AirflowSecurityManager(SecurityManagerOverride, SecurityManager, 
LoggingMixin):
-    """Custom security manager, which introduces a permission model adapted to 
Airflow."""
-
-    ###########################################################################
-    #                               PERMISSIONS
-    ###########################################################################
-
-    # [START security_viewer_perms]
-    VIEWER_PERMISSIONS = [
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_AUDIT_LOG),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_DAG),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_DAG_DEPENDENCIES),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_DAG_CODE),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_DAG_RUN),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_DATASET),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_CLUSTER_ACTIVITY),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_IMPORT_ERROR),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_DAG_WARNING),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_JOB),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_MY_PASSWORD),
-        (permissions.ACTION_CAN_EDIT, permissions.RESOURCE_MY_PASSWORD),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_MY_PROFILE),
-        (permissions.ACTION_CAN_EDIT, permissions.RESOURCE_MY_PROFILE),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_PLUGIN),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_SLA_MISS),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_TASK_INSTANCE),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_TASK_LOG),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_XCOM),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_WEBSITE),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_BROWSE_MENU),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_DAG),
-        (permissions.ACTION_CAN_ACCESS_MENU, 
permissions.RESOURCE_DAG_DEPENDENCIES),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_DAG_RUN),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_DATASET),
-        (permissions.ACTION_CAN_ACCESS_MENU, 
permissions.RESOURCE_CLUSTER_ACTIVITY),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_DOCS),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_DOCS_MENU),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_JOB),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_AUDIT_LOG),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_PLUGIN),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_SLA_MISS),
-        (permissions.ACTION_CAN_ACCESS_MENU, 
permissions.RESOURCE_TASK_INSTANCE),
-    ]
-    # [END security_viewer_perms]
-
-    # [START security_user_perms]
-    USER_PERMISSIONS = [
-        (permissions.ACTION_CAN_EDIT, permissions.RESOURCE_DAG),
-        (permissions.ACTION_CAN_DELETE, permissions.RESOURCE_DAG),
-        (permissions.ACTION_CAN_CREATE, permissions.RESOURCE_TASK_INSTANCE),
-        (permissions.ACTION_CAN_EDIT, permissions.RESOURCE_TASK_INSTANCE),
-        (permissions.ACTION_CAN_DELETE, permissions.RESOURCE_TASK_INSTANCE),
-        (permissions.ACTION_CAN_CREATE, permissions.RESOURCE_DAG_RUN),
-        (permissions.ACTION_CAN_EDIT, permissions.RESOURCE_DAG_RUN),
-        (permissions.ACTION_CAN_DELETE, permissions.RESOURCE_DAG_RUN),
-    ]
-    # [END security_user_perms]
-
-    # [START security_op_perms]
-    OP_PERMISSIONS = [
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_CONFIG),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_ADMIN_MENU),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_CONFIG),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_CONNECTION),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_POOL),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_VARIABLE),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_XCOM),
-        (permissions.ACTION_CAN_CREATE, permissions.RESOURCE_CONNECTION),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_CONNECTION),
-        (permissions.ACTION_CAN_EDIT, permissions.RESOURCE_CONNECTION),
-        (permissions.ACTION_CAN_DELETE, permissions.RESOURCE_CONNECTION),
-        (permissions.ACTION_CAN_CREATE, permissions.RESOURCE_POOL),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_POOL),
-        (permissions.ACTION_CAN_EDIT, permissions.RESOURCE_POOL),
-        (permissions.ACTION_CAN_DELETE, permissions.RESOURCE_POOL),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_PROVIDER),
-        (permissions.ACTION_CAN_CREATE, permissions.RESOURCE_VARIABLE),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_VARIABLE),
-        (permissions.ACTION_CAN_EDIT, permissions.RESOURCE_VARIABLE),
-        (permissions.ACTION_CAN_DELETE, permissions.RESOURCE_VARIABLE),
-        (permissions.ACTION_CAN_DELETE, permissions.RESOURCE_XCOM),
-    ]
-    # [END security_op_perms]
-
-    ADMIN_PERMISSIONS = [
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_TASK_RESCHEDULE),
-        (permissions.ACTION_CAN_ACCESS_MENU, 
permissions.RESOURCE_TASK_RESCHEDULE),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_TRIGGER),
-        (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_TRIGGER),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_PASSWORD),
-        (permissions.ACTION_CAN_EDIT, permissions.RESOURCE_PASSWORD),
-        (permissions.ACTION_CAN_READ, permissions.RESOURCE_ROLE),
-        (permissions.ACTION_CAN_EDIT, permissions.RESOURCE_ROLE),
-    ]
-
-    # global resource for dag-level access
-    DAG_RESOURCES = {permissions.RESOURCE_DAG}
-    DAG_ACTIONS = permissions.DAG_ACTIONS
-
-    ###########################################################################
-    #                     DEFAULT ROLE CONFIGURATIONS
-    ###########################################################################
-
-    ROLE_CONFIGS: list[dict[str, Any]] = [
-        {"role": "Public", "perms": []},
-        {"role": "Viewer", "perms": VIEWER_PERMISSIONS},
-        {
-            "role": "User",
-            "perms": VIEWER_PERMISSIONS + USER_PERMISSIONS,
-        },
-        {
-            "role": "Op",
-            "perms": VIEWER_PERMISSIONS + USER_PERMISSIONS + OP_PERMISSIONS,
-        },
-        {
-            "role": "Admin",
-            "perms": VIEWER_PERMISSIONS + USER_PERMISSIONS + OP_PERMISSIONS + 
ADMIN_PERMISSIONS,
-        },
-    ]
-
-    actionmodelview = ActionModelView
-    permissionmodelview = PermissionPairModelView
-    rolemodelview = CustomRoleModelView
-    resourcemodelview = ResourceModelView
-    userdbmodelview = CustomUserDBModelView
-    resetmypasswordview = CustomResetMyPasswordView
-    resetpasswordview = CustomResetPasswordView
-    userinfoeditview = CustomUserInfoEditView
-    userldapmodelview = CustomUserLDAPModelView
-    useroauthmodelview = CustomUserOAuthModelView
-    userremoteusermodelview = CustomUserRemoteUserModelView
-    useroidmodelview = CustomUserOIDModelView
-    userstatschartview = CustomUserStatsChartView
-
-    def __init__(self, appbuilder) -> None:
-        super().__init__(
-            appbuilder=appbuilder,
-            actionmodelview=self.actionmodelview,
-            authdbview=self.authdbview,
-            authldapview=self.authldapview,
-            authoauthview=self.authoauthview,
-            authoidview=self.authoidview,
-            authremoteuserview=self.authremoteuserview,
-            permissionmodelview=self.permissionmodelview,
-            registeruser_view=self.registeruser_view,
-            registeruserdbview=self.registeruserdbview,
-            registeruseroauthview=self.registeruseroauthview,
-            registerusermodelview=self.registerusermodelview,
-            registeruseroidview=self.registeruseroidview,
-            resetmypasswordview=self.resetmypasswordview,
-            resetpasswordview=self.resetpasswordview,
-            rolemodelview=self.rolemodelview,
-            user_model=self.user_model,
-            userinfoeditview=self.userinfoeditview,
-            userdbmodelview=self.userdbmodelview,
-            userldapmodelview=self.userldapmodelview,
-            useroauthmodelview=self.useroauthmodelview,
-            useroidmodelview=self.useroidmodelview,
-            userremoteusermodelview=self.userremoteusermodelview,
-            userstatschartview=self.userstatschartview,
-        )
-
-        # Go and fix up the SQLAInterface used from the stock one to our 
subclass.
-        # This is needed to support the "hack" where we had to edit
-        # FieldConverter.conversion_table in place in airflow.www.utils
-        for attr in dir(self):
-            if attr.endswith("view"):
-                view = getattr(self, attr, None)
-                if view and getattr(view, "datamodel", None):
-                    view.datamodel = CustomSQLAInterface(view.datamodel.obj)
-        self.perms = None
-
-    def _get_root_dag_id(self, dag_id: str) -> str:
-        if "." in dag_id:
-            dm = self.appbuilder.get_session.execute(
-                select(DagModel.dag_id, 
DagModel.root_dag_id).where(DagModel.dag_id == dag_id)
-            ).one()
-            return dm.root_dag_id or dm.dag_id
-        return dag_id
-
-    def init_role(self, role_name, perms) -> None:
-        """
-        Initialize the role with actions and related resources.
-
-        :param role_name:
-        :param perms:
-        :return:
-        """
-        warnings.warn(
-            "`init_role` has been deprecated. Please use `bulk_sync_roles` 
instead.",
-            RemovedInAirflow3Warning,
-            stacklevel=2,
-        )
-        self.bulk_sync_roles([{"role": role_name, "perms": perms}])
-
-    def bulk_sync_roles(self, roles: Iterable[dict[str, Any]]) -> None:
-        """Sync the provided roles and permissions."""
-        existing_roles = self._get_all_roles_with_permissions()
-        non_dag_perms = self._get_all_non_dag_permissions()
-
-        for config in roles:
-            role_name = config["role"]
-            perms = config["perms"]
-            role = existing_roles.get(role_name) or self.add_role(role_name)
-
-            for action_name, resource_name in perms:
-                perm = non_dag_perms.get((action_name, resource_name)) or 
self.create_permission(
-                    action_name, resource_name
-                )
-
-                if perm not in role.permissions:
-                    self.add_permission_to_role(role, perm)
-
-    @staticmethod
-    def get_user_roles(user=None):
-        """
-        Get all the roles associated with the user.
-
-        :param user: the ab_user in FAB model.
-        :return: a list of roles associated with the user.
-        """
-        if user is None:
-            user = g.user
-        return user.roles
-
-    def get_readable_dags(self, user) -> Iterable[DagModel]:
-        """Gets the DAGs readable by authenticated user."""
-        warnings.warn(
-            "`get_readable_dags` has been deprecated. Please use 
`get_readable_dag_ids` instead.",
-            RemovedInAirflow3Warning,
-            stacklevel=2,
-        )
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", RemovedInAirflow3Warning)
-            return self.get_accessible_dags([permissions.ACTION_CAN_READ], 
user)
-
-    def get_editable_dags(self, user) -> Iterable[DagModel]:
-        """Gets the DAGs editable by authenticated user."""
-        warnings.warn(
-            "`get_editable_dags` has been deprecated. Please use 
`get_editable_dag_ids` instead.",
-            RemovedInAirflow3Warning,
-            stacklevel=2,
-        )
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", RemovedInAirflow3Warning)
-            return self.get_accessible_dags([permissions.ACTION_CAN_EDIT], 
user)
-
-    @provide_session
-    def get_accessible_dags(
-        self,
-        user_actions: Container[str] | None,
-        user,
-        session: Session = NEW_SESSION,
-    ) -> Iterable[DagModel]:
-        warnings.warn(
-            "`get_accessible_dags` has been deprecated. Please use 
`get_accessible_dag_ids` instead.",
-            RemovedInAirflow3Warning,
-            stacklevel=3,
-        )
-        dag_ids = self.get_accessible_dag_ids(user, user_actions, session)
-        return 
session.scalars(select(DagModel).where(DagModel.dag_id.in_(dag_ids)))
-
-    def get_readable_dag_ids(self, user) -> set[str]:
-        """Gets the DAG IDs readable by authenticated user."""
-        return self.get_accessible_dag_ids(user, [permissions.ACTION_CAN_READ])
-
-    def get_editable_dag_ids(self, user) -> set[str]:
-        """Gets the DAG IDs editable by authenticated user."""
-        return self.get_accessible_dag_ids(user, [permissions.ACTION_CAN_EDIT])
-
-    @provide_session
-    def get_accessible_dag_ids(
-        self,
-        user,
-        user_actions: Container[str] | None = None,
-        session: Session = NEW_SESSION,
-    ) -> set[str]:
-        """Generic function to get readable or writable DAGs for user."""
-        if not user_actions:
-            user_actions = [permissions.ACTION_CAN_EDIT, 
permissions.ACTION_CAN_READ]
-
-        if not get_auth_manager().is_logged_in():
-            roles = user.roles
-        else:
-            if (permissions.ACTION_CAN_EDIT in user_actions and 
self.can_edit_all_dags(user)) or (
-                permissions.ACTION_CAN_READ in user_actions and 
self.can_read_all_dags(user)
-            ):
-                return {dag.dag_id for dag in 
session.execute(select(DagModel.dag_id))}
-            user_query = session.scalar(
-                select(User)
-                .options(
-                    joinedload(User.roles)
-                    .subqueryload(Role.permissions)
-                    .options(joinedload(Permission.action), 
joinedload(Permission.resource))
-                )
-                .where(User.id == user.id)
-            )
-            roles = user_query.roles
-
-        resources = set()
-        for role in roles:
-            for permission in role.permissions:
-                action = permission.action.name
-                if action in user_actions:
-                    resource = permission.resource.name
-                    if resource == permissions.RESOURCE_DAG:
-                        return {dag.dag_id for dag in 
session.execute(select(DagModel.dag_id))}
-
-                    if resource.startswith(permissions.RESOURCE_DAG_PREFIX):
-                        
resources.add(resource[len(permissions.RESOURCE_DAG_PREFIX) :])
-                    else:
-                        resources.add(resource)
-        return {
-            dag.dag_id
-            for dag in 
session.execute(select(DagModel.dag_id).where(DagModel.dag_id.in_(resources)))
-        }
-
-    def can_access_some_dags(self, action: str, dag_id: str | None = None) -> 
bool:
-        """Checks if user has read or write access to some dags."""
-        if dag_id and dag_id != "~":
-            root_dag_id = self._get_root_dag_id(dag_id)
-            return self.has_access(action, 
permissions.resource_name_for_dag(root_dag_id))
-
-        user = g.user
-        if action == permissions.ACTION_CAN_READ:
-            return any(self.get_readable_dag_ids(user))
-        return any(self.get_editable_dag_ids(user))
-
-    def can_read_dag(self, dag_id: str, user=None) -> bool:
-        """Determines whether a user has DAG read access."""
-        root_dag_id = self._get_root_dag_id(dag_id)
-        dag_resource_name = permissions.resource_name_for_dag(root_dag_id)
-        return self.has_access(permissions.ACTION_CAN_READ, dag_resource_name, 
user=user)
-
-    def can_edit_dag(self, dag_id: str, user=None) -> bool:
-        """Determines whether a user has DAG edit access."""
-        root_dag_id = self._get_root_dag_id(dag_id)
-        dag_resource_name = permissions.resource_name_for_dag(root_dag_id)
-        return self.has_access(permissions.ACTION_CAN_EDIT, dag_resource_name, 
user=user)
-
-    def can_delete_dag(self, dag_id: str, user=None) -> bool:
-        """Determines whether a user has DAG delete access."""
-        root_dag_id = self._get_root_dag_id(dag_id)
-        dag_resource_name = permissions.resource_name_for_dag(root_dag_id)
-        return self.has_access(permissions.ACTION_CAN_DELETE, 
dag_resource_name, user=user)
-
-    def prefixed_dag_id(self, dag_id: str) -> str:
-        """Returns the permission name for a DAG id."""
-        warnings.warn(
-            "`prefixed_dag_id` has been deprecated. "
-            "Please use `airflow.security.permissions.resource_name_for_dag` 
instead.",
-            RemovedInAirflow3Warning,
-            stacklevel=2,
-        )
-        root_dag_id = self._get_root_dag_id(dag_id)
-        return permissions.resource_name_for_dag(root_dag_id)
-
-    def is_dag_resource(self, resource_name: str) -> bool:
-        """Determines if a resource belongs to a DAG or all DAGs."""
-        if resource_name == permissions.RESOURCE_DAG:
-            return True
-        return resource_name.startswith(permissions.RESOURCE_DAG_PREFIX)
-
-    def has_access(self, action_name: str, resource_name: str, user=None) -> 
bool:
-        """
-        Verify whether a given user could perform a certain action on the 
given resource.
-
-        Example actions might include can_read, can_write, can_delete, etc.
-
-        :param action_name: action_name on resource (e.g can_read, can_edit).
-        :param resource_name: name of view-menu or resource.
-        :param user: user name
-        :return: Whether user could perform certain action on the resource.
-        :rtype bool
-        """
-        if not user:
-            user = g.user
-        if (action_name, resource_name) in user.perms:
-            return True
-
-        if self.is_dag_resource(resource_name):
-            if (action_name, permissions.RESOURCE_DAG) in user.perms:
-                return True
-            return (action_name, resource_name) in user.perms
-
-        return False
-
-    def _has_role(self, role_name_or_list: Container, user) -> bool:
-        """Whether the user has this role name."""
-        if not isinstance(role_name_or_list, list):
-            role_name_or_list = [role_name_or_list]
-        return any(r.name in role_name_or_list for r in user.roles)
-
-    def has_all_dags_access(self, user) -> bool:
-        """
-        Has all the dag access in any of the 3 cases.
-
-        1. Role needs to be in (Admin, Viewer, User, Op).
-        2. Has can_read action on dags resource.
-        3. Has can_edit action on dags resource.
-        """
-        if not user:
-            user = g.user
-        return (
-            self._has_role(["Admin", "Viewer", "Op", "User"], user)
-            or self.can_read_all_dags(user)
-            or self.can_edit_all_dags(user)
-        )
-
-    def can_edit_all_dags(self, user=None) -> bool:
-        """Has can_edit action on DAG resource."""
-        return self.has_access(permissions.ACTION_CAN_EDIT, 
permissions.RESOURCE_DAG, user)
-
-    def can_read_all_dags(self, user=None) -> bool:
-        """Has can_read action on DAG resource."""
-        return self.has_access(permissions.ACTION_CAN_READ, 
permissions.RESOURCE_DAG, user)
+    pass
 
-    def clean_perms(self) -> None:
-        """FAB leaves faulty permissions that need to be cleaned up."""
-        self.log.debug("Cleaning faulty perms")
-        sesh = self.appbuilder.get_session
-        perms = sesh.query(Permission).filter(
-            or_(
-                Permission.action == None,  # noqa
-                Permission.resource == None,  # noqa
-            )
-        )
-        # Since FAB doesn't define ON DELETE CASCADE on these tables, we need
-        # to delete the _object_ so that SQLA knows to delete the many-to-many
-        # relationship object too. :(
 
-        deleted_count = 0
-        for perm in perms:
-            sesh.delete(perm)
-            deleted_count += 1
-        sesh.commit()
-        if deleted_count:
-            self.log.info("Deleted %s faulty permissions", deleted_count)
-
-    def _merge_perm(self, action_name: str, resource_name: str) -> None:
-        """
-        Add the new (action, resource) to assoc_permission_role if it doesn't 
exist.
-
-        It will add the related entry to ab_permission and ab_resource two 
meta tables as well.
-
-        :param action_name: Name of the action
-        :param resource_name: Name of the resource
-        :return:
-        """
-        action = self.get_action(action_name)
-        resource = self.get_resource(resource_name)
-        perm = None
-        if action and resource:
-            perm = self.appbuilder.get_session.scalar(
-                select(self.permission_model).filter_by(action=action, 
resource=resource).limit(1)
-            )
-        if not perm and action_name and resource_name:
-            self.create_permission(action_name, resource_name)
-
-    def add_homepage_access_to_custom_roles(self) -> None:
-        """
-        Add Website.can_read access to all custom roles.
-
-        :return: None.
-        """
-        website_permission = 
self.create_permission(permissions.ACTION_CAN_READ, 
permissions.RESOURCE_WEBSITE)
-        custom_roles = [role for role in self.get_all_roles() if role.name not 
in EXISTING_ROLES]
-        for role in custom_roles:
-            self.add_permission_to_role(role, website_permission)
-
-        self.appbuilder.get_session.commit()
-
-    def get_all_permissions(self) -> set[tuple[str, str]]:
-        """Returns all permissions as a set of tuples with the action and 
resource names."""
-        return set(
-            self.appbuilder.get_session.execute(
-                select(self.action_model.name, self.resource_model.name)
-                .join(self.permission_model.action)
-                .join(self.permission_model.resource)
-            )
-        )
-
-    def _get_all_non_dag_permissions(self) -> dict[tuple[str, str], 
Permission]:
-        """
-        Get permissions except those that are for specific DAGs.
-
-        Returns a dict with a key of (action_name, resource_name) and value of 
permission
-        with all permissions except those that are for specific DAGs.
-        """
-        return {
-            (action_name, resource_name): viewmodel
-            for action_name, resource_name, viewmodel in (
-                self.appbuilder.get_session.execute(
-                    select(self.action_model.name, self.resource_model.name, 
self.permission_model)
-                    .join(self.permission_model.action)
-                    .join(self.permission_model.resource)
-                    
.where(~self.resource_model.name.like(f"{permissions.RESOURCE_DAG_PREFIX}%"))
-                )
-            )
-        }
-
-    def _get_all_roles_with_permissions(self) -> dict[str, Role]:
-        """Returns a dict with a key of role name and value of role with early 
loaded permissions."""
-        return {
-            r.name: r
-            for r in self.appbuilder.get_session.scalars(
-                
select(self.role_model).options(joinedload(self.role_model.permissions))
-            ).unique()
-        }
-
-    def create_dag_specific_permissions(self) -> None:
-        """
-        Add permissions to all DAGs.
-
-        Creates 'can_read', 'can_edit', and 'can_delete' permissions for all
-        DAGs, along with any `access_control` permissions provided in them.
-
-        This does iterate through ALL the DAGs, which can be slow. See 
`sync_perm_for_dag`
-        if you only need to sync a single DAG.
-
-        :return: None.
-        """
-        perms = self.get_all_permissions()
-        dagbag = DagBag(read_dags_from_db=True)
-        dagbag.collect_dags_from_db()
-        dags = dagbag.dags.values()
-
-        for dag in dags:
-            root_dag_id = dag.parent_dag.dag_id if dag.parent_dag else 
dag.dag_id
-            dag_resource_name = permissions.resource_name_for_dag(root_dag_id)
-            for action_name in self.DAG_ACTIONS:
-                if (action_name, dag_resource_name) not in perms:
-                    self._merge_perm(action_name, dag_resource_name)
-
-            if dag.access_control is not None:
-                self.sync_perm_for_dag(dag_resource_name, dag.access_control)
-
-    def update_admin_permission(self) -> None:
-        """
-        Add missing permissions to the table for admin.
-
-        Admin should get all the permissions, except the dag permissions
-        because Admin already has Dags permission.
-        Add the missing ones to the table for admin.
-
-        :return: None.
-        """
-        session = self.appbuilder.get_session
-        dag_resources = session.scalars(
-            
select(Resource).where(Resource.name.like(f"{permissions.RESOURCE_DAG_PREFIX}%"))
-        )
-        resource_ids = [resource.id for resource in dag_resources]
-
-        perms = 
session.scalars(select(Permission).where(~Permission.resource_id.in_(resource_ids)))
-        perms = [p for p in perms if p.action and p.resource]
-
-        admin = self.find_role("Admin")
-        admin.permissions = list(set(admin.permissions) | set(perms))
-
-        session.commit()
-
-    def sync_roles(self) -> None:
-        """
-        Initialize default and custom roles with related permissions.
-
-        1. Init the default role(Admin, Viewer, User, Op, public)
-           with related permissions.
-        2. Init the custom role(dag-user) with related permissions.
-
-        :return: None.
-        """
-        # Create global all-dag permissions
-        self.create_perm_vm_for_all_dag()
-
-        # Sync the default roles (Admin, Viewer, User, Op, public) with 
related permissions
-        self.bulk_sync_roles(self.ROLE_CONFIGS)
-
-        self.add_homepage_access_to_custom_roles()
-        # init existing roles, the rest role could be created through UI.
-        self.update_admin_permission()
-        self.clean_perms()
-
-    def sync_resource_permissions(self, perms: Iterable[tuple[str, str]] | 
None = None) -> None:
-        """Populates resource-based permissions."""
-        if not perms:
-            return
-
-        for action_name, resource_name in perms:
-            self.create_resource(resource_name)
-            self.create_permission(action_name, resource_name)
-
-    def sync_perm_for_dag(
-        self,
-        dag_id: str,
-        access_control: dict[str, Collection[str]] | None = None,
-    ) -> None:
-        """
-        Sync permissions for given dag id.
-
-        The dag id surely exists in our dag bag as only / refresh button or 
DagBag will call this function.
-
-        :param dag_id: the ID of the DAG whose permissions should be updated
-        :param access_control: a dict where each key is a rolename and
-            each value is a set() of action names (e.g.,
-            {'can_read'}
-        :return:
-        """
-        dag_resource_name = permissions.resource_name_for_dag(dag_id)
-        for dag_action_name in self.DAG_ACTIONS:
-            self.create_permission(dag_action_name, dag_resource_name)
-
-        if access_control is not None:
-            self.log.debug("Syncing DAG-level permissions for DAG '%s'", 
dag_resource_name)
-            self._sync_dag_view_permissions(dag_resource_name, access_control)
-        else:
-            self.log.debug(
-                "Not syncing DAG-level permissions for DAG '%s' as access 
control is unset.",
-                dag_resource_name,
-            )
-
-    def _sync_dag_view_permissions(self, dag_id: str, access_control: 
dict[str, Collection[str]]) -> None:
-        """
-        Set the access policy on the given DAG's ViewModel.
-
-        :param dag_id: the ID of the DAG whose permissions should be updated
-        :param access_control: a dict where each key is a rolename and
-            each value is a set() of action names (e.g. {'can_read'})
-        """
-        dag_resource_name = permissions.resource_name_for_dag(dag_id)
-
-        def _get_or_create_dag_permission(action_name: str) -> Permission | 
None:
-            perm = self.get_permission(action_name, dag_resource_name)
-            if not perm:
-                self.log.info("Creating new action '%s' on resource '%s'", 
action_name, dag_resource_name)
-                perm = self.create_permission(action_name, dag_resource_name)
-
-            return perm
-
-        def _revoke_stale_permissions(resource: Resource):
-            existing_dag_perms = self.get_resource_permissions(resource)
-            for perm in existing_dag_perms:
-                non_admin_roles = [role for role in perm.role if role.name != 
"Admin"]
-                for role in non_admin_roles:
-                    target_perms_for_role = access_control.get(role.name, ())
-                    if perm.action.name not in target_perms_for_role:
-                        self.log.info(
-                            "Revoking '%s' on DAG '%s' for role '%s'",
-                            perm.action,
-                            dag_resource_name,
-                            role.name,
-                        )
-                        self.remove_permission_from_role(role, perm)
-
-        resource = self.get_resource(dag_resource_name)
-        if resource:
-            _revoke_stale_permissions(resource)
-
-        for rolename, action_names in access_control.items():
-            role = self.find_role(rolename)
-            if not role:
-                raise AirflowException(
-                    f"The access_control mapping for DAG '{dag_id}' includes a 
role named "
-                    f"'{rolename}', but that role does not exist"
-                )
-
-            action_names = set(action_names)
-            invalid_action_names = action_names - self.DAG_ACTIONS
-            if invalid_action_names:
-                raise AirflowException(
-                    f"The access_control map for DAG '{dag_resource_name}' 
includes "
-                    f"the following invalid permissions: 
{invalid_action_names}; "
-                    f"The set of valid permissions is: {self.DAG_ACTIONS}"
-                )
-
-            for action_name in action_names:
-                dag_perm = _get_or_create_dag_permission(action_name)
-                if dag_perm:
-                    self.add_permission_to_role(role, dag_perm)
-
-    def create_perm_vm_for_all_dag(self) -> None:
-        """Create perm-vm if not exist and insert into FAB security model for 
all-dags."""
-        # create perm for global logical dag
-        for resource_name in self.DAG_RESOURCES:
-            for action_name in self.DAG_ACTIONS:
-                self._merge_perm(action_name, resource_name)
-
-    def check_authorization(
-        self,
-        perms: Sequence[tuple[str, str]] | None = None,
-        dag_id: str | None = None,
-    ) -> bool:
-        """Checks that the logged in user has the specified permissions."""
-        if not perms:
-            return True
-
-        for perm in perms:
-            if perm in (
-                (permissions.ACTION_CAN_READ, permissions.RESOURCE_DAG),
-                (permissions.ACTION_CAN_EDIT, permissions.RESOURCE_DAG),
-                (permissions.ACTION_CAN_DELETE, permissions.RESOURCE_DAG),
-            ):
-                can_access_all_dags = self.has_access(*perm)
-                if not can_access_all_dags:
-                    action = perm[0]
-                    if not self.can_access_some_dags(action, dag_id):
-                        return False
-            elif not self.has_access(*perm):
-                return False
-
-        return True
-
-
-class FakeAppBuilder:
-    """Stand-in class to replace a Flask App Builder.
+@deprecated(
+    reason="If you want to override the security manager, you should inherit 
from "
+    
"`airflow.auth.managers.fab.security_manager.override.FabAirflowSecurityManagerOverride`
 "
+    "instead"
+)
+class AirflowSecurityManager(FabAirflowSecurityManagerOverride):
+    """Placeholder, just here to avoid breaking the code of users who inherit 
from this.
 
-    The only purpose is to provide the ``self.appbuilder.get_session`` 
interface
-    for ``ApplessAirflowSecurityManager`` so it can be used without a real 
Flask
-    app, which is slow to create.
+    Do not use if writing new code.
     """
 
-    def __init__(self, session: Session | None = None) -> None:
-        self.get_session = session
-
-
-class ApplessAirflowSecurityManager(AirflowSecurityManager):
-    """Security Manager that doesn't need the whole flask app."""
-
-    def __init__(self, session: Session | None = None):
-        self.appbuilder = FakeAppBuilder(session)
+    ...
diff --git a/tests/test_utils/mock_security_manager.py 
b/airflow/www/security_appless.py
similarity index 50%
copy from tests/test_utils/mock_security_manager.py
copy to airflow/www/security_appless.py
index f55f5e31bd..32233c1fcd 100644
--- a/tests/test_utils/mock_security_manager.py
+++ b/airflow/www/security_appless.py
@@ -16,10 +16,28 @@
 # under the License.
 from __future__ import annotations
 
-from airflow.www.security import AirflowSecurityManager
+from typing import TYPE_CHECKING
 
+from airflow.auth.managers.fab.security_manager.override import 
FabAirflowSecurityManagerOverride
 
-class MockSecurityManager(AirflowSecurityManager):
-    VIEWER_VMS = {
-        "Airflow",
-    }
+if TYPE_CHECKING:
+    from flask_session import Session
+
+
+class FakeAppBuilder:
+    """Stand-in class to replace a Flask App Builder.
+
+    The only purpose is to provide the ``self.appbuilder.get_session`` 
interface
+    for ``ApplessAirflowSecurityManager`` so it can be used without a real 
Flask
+    app, which is slow to create.
+    """
+
+    def __init__(self, session: Session | None = None) -> None:
+        self.get_session = session
+
+
+class ApplessAirflowSecurityManager(FabAirflowSecurityManagerOverride):
+    """Security Manager that doesn't need the whole flask app."""
+
+    def __init__(self, session: Session | None = None):
+        self.appbuilder = FakeAppBuilder(session)
diff --git a/airflow/www/security.py b/airflow/www/security_manager.py
similarity index 93%
copy from airflow/www/security.py
copy to airflow/www/security_manager.py
index 0a8d6cbf1e..172857098a 100644
--- a/airflow/www/security.py
+++ b/airflow/www/security_manager.py
@@ -63,14 +63,12 @@ EXISTING_ROLES = {
 if TYPE_CHECKING:
     from sqlalchemy.orm import Session
 
-    SecurityManagerOverride: type = object
-else:
-    # Fetch the security manager override from the auth manager
-    SecurityManagerOverride = 
get_auth_manager().get_security_manager_override_class()
 
+class AirflowSecurityManagerV2(SecurityManager, LoggingMixin):
+    """Custom security manager, which introduces a permission model adapted to 
Airflow.
 
-class AirflowSecurityManager(SecurityManagerOverride, SecurityManager, 
LoggingMixin):
-    """Custom security manager, which introduces a permission model adapted to 
Airflow."""
+    It's named V2 to differentiate it from the obsolete 
airflow.www.security.AirflowSecurityManager.
+    """
 
     ###########################################################################
     #                               PERMISSIONS
@@ -204,32 +202,7 @@ class AirflowSecurityManager(SecurityManagerOverride, 
SecurityManager, LoggingMi
     userstatschartview = CustomUserStatsChartView
 
     def __init__(self, appbuilder) -> None:
-        super().__init__(
-            appbuilder=appbuilder,
-            actionmodelview=self.actionmodelview,
-            authdbview=self.authdbview,
-            authldapview=self.authldapview,
-            authoauthview=self.authoauthview,
-            authoidview=self.authoidview,
-            authremoteuserview=self.authremoteuserview,
-            permissionmodelview=self.permissionmodelview,
-            registeruser_view=self.registeruser_view,
-            registeruserdbview=self.registeruserdbview,
-            registeruseroauthview=self.registeruseroauthview,
-            registerusermodelview=self.registerusermodelview,
-            registeruseroidview=self.registeruseroidview,
-            resetmypasswordview=self.resetmypasswordview,
-            resetpasswordview=self.resetpasswordview,
-            rolemodelview=self.rolemodelview,
-            user_model=self.user_model,
-            userinfoeditview=self.userinfoeditview,
-            userdbmodelview=self.userdbmodelview,
-            userldapmodelview=self.userldapmodelview,
-            useroauthmodelview=self.useroauthmodelview,
-            useroidmodelview=self.useroidmodelview,
-            userremoteusermodelview=self.userremoteusermodelview,
-            userstatschartview=self.userstatschartview,
-        )
+        super().__init__(appbuilder=appbuilder)
 
         # Go and fix up the SQLAInterface used from the stock one to our 
subclass.
         # This is needed to support the "hack" where we had to edit
@@ -376,7 +349,6 @@ class AirflowSecurityManager(SecurityManagerOverride, 
SecurityManager, LoggingMi
                     resource = permission.resource.name
                     if resource == permissions.RESOURCE_DAG:
                         return {dag.dag_id for dag in 
session.execute(select(DagModel.dag_id))}
-
                     if resource.startswith(permissions.RESOURCE_DAG_PREFIX):
                         
resources.add(resource[len(permissions.RESOURCE_DAG_PREFIX) :])
                     else:
@@ -779,22 +751,3 @@ class AirflowSecurityManager(SecurityManagerOverride, 
SecurityManager, LoggingMi
                 return False
 
         return True
-
-
-class FakeAppBuilder:
-    """Stand-in class to replace a Flask App Builder.
-
-    The only purpose is to provide the ``self.appbuilder.get_session`` 
interface
-    for ``ApplessAirflowSecurityManager`` so it can be used without a real 
Flask
-    app, which is slow to create.
-    """
-
-    def __init__(self, session: Session | None = None) -> None:
-        self.get_session = session
-
-
-class ApplessAirflowSecurityManager(AirflowSecurityManager):
-    """Security Manager that doesn't need the whole flask app."""
-
-    def __init__(self, session: Session | None = None):
-        self.appbuilder = FakeAppBuilder(session)
diff --git a/docs/apache-airflow/security/access-control.rst 
b/docs/apache-airflow/security/access-control.rst
index 7692a54cb5..bef8b34f42 100644
--- a/docs/apache-airflow/security/access-control.rst
+++ b/docs/apache-airflow/security/access-control.rst
@@ -51,7 +51,7 @@ Viewer
 ^^^^^^
 ``Viewer`` users have limited read permissions:
 
-.. exampleinclude:: /../../airflow/www/security.py
+.. exampleinclude:: /../../airflow/www/security_manager.py
     :language: python
     :start-after: [START security_viewer_perms]
     :end-before: [END security_viewer_perms]
@@ -60,7 +60,7 @@ User
 ^^^^
 ``User`` users have ``Viewer`` permissions plus additional permissions:
 
-.. exampleinclude:: /../../airflow/www/security.py
+.. exampleinclude:: /../../airflow/www/security_manager.py
     :language: python
     :start-after: [START security_user_perms]
     :end-before: [END security_user_perms]
@@ -69,7 +69,7 @@ Op
 ^^
 ``Op`` users have ``User`` permissions plus additional permissions:
 
-.. exampleinclude:: /../../airflow/www/security.py
+.. exampleinclude:: /../../airflow/www/security_manager.py
     :language: python
     :start-after: [START security_op_perms]
     :end-before: [END security_op_perms]
diff --git a/docs/apache-airflow/security/webserver.rst 
b/docs/apache-airflow/security/webserver.rst
index d990afa4d4..282eabaa5b 100644
--- a/docs/apache-airflow/security/webserver.rst
+++ b/docs/apache-airflow/security/webserver.rst
@@ -169,7 +169,7 @@ Here is an example of what you might have in your 
webserver_config.py:
 
 .. code-block:: python
 
-    from airflow.www.security import AirflowSecurityManager
+    from airflow.auth.managers.fab.security_manager.override import 
FabAirflowSecurityManagerOverride
     from flask_appbuilder.security.manager import AUTH_OAUTH
     import os
 
@@ -200,7 +200,7 @@ Here is an example of what you might have in your 
webserver_config.py:
     ]
 
 
-    class CustomSecurityManager(AirflowSecurityManager):
+    class CustomSecurityManager(FabAirflowSecurityManagerOverride):
         pass
 
 
@@ -213,7 +213,7 @@ webserver_config.py itself if you wish.
 
 .. code-block:: python
 
-    from airflow.www.security import AirflowSecurityManager
+    from airflow.auth.managers.fab.security_manager.override import 
FabAirflowSecurityManagerOverride
     import logging
     from typing import Any, List, Union
     import os
@@ -244,7 +244,7 @@ webserver_config.py itself if you wish.
         return list(set(team_role_map.get(team, FAB_PUBLIC_ROLE) for team in 
team_list))
 
 
-    class GithubTeamAuthorizer(AirflowSecurityManager):
+    class GithubTeamAuthorizer(FabAirflowSecurityManagerOverride):
 
         # In this example, the oauth provider == 'github'.
         # If you ever want to support other providers, see how it is done here:
diff --git a/tests/api_connexion/endpoints/test_role_and_permission_endpoint.py 
b/tests/api_connexion/endpoints/test_role_and_permission_endpoint.py
index 0a62de1043..bdede1f16f 100644
--- a/tests/api_connexion/endpoints/test_role_and_permission_endpoint.py
+++ b/tests/api_connexion/endpoints/test_role_and_permission_endpoint.py
@@ -21,7 +21,7 @@ import pytest
 from airflow.api_connexion.exceptions import EXCEPTIONS_LINK_MAP
 from airflow.auth.managers.fab.models import Role
 from airflow.security import permissions
-from airflow.www.security import EXISTING_ROLES
+from airflow.www.security_manager import EXISTING_ROLES
 from tests.test_utils.api_connexion_utils import (
     assert_401,
     create_role,
diff --git a/tests/auth/managers/fab/security_manager/test_override.py 
b/tests/auth/managers/fab/security_manager/test_override.py
index 9f931e6a2d..9d63954767 100644
--- a/tests/auth/managers/fab/security_manager/test_override.py
+++ b/tests/auth/managers/fab/security_manager/test_override.py
@@ -17,113 +17,35 @@
 from __future__ import annotations
 
 from unittest import mock
-from unittest.mock import MagicMock, Mock
+from unittest.mock import Mock
 
-import pytest
-
-from airflow.auth.managers.fab.models import User
 from airflow.auth.managers.fab.security_manager.override import 
FabAirflowSecurityManagerOverride
 
-appbuilder = Mock()
-actionmodelview = Mock()
-authdbview = Mock()
-authldapview = Mock()
-authoauthview = Mock()
-authoidview = Mock()
-authremoteuserview = Mock()
-permissionmodelview = Mock()
-registeruser_view = Mock()
-registeruserdbview = Mock()
-registeruseroauthview = Mock()
-registerusermodelview = Mock()
-registeruseroidview = Mock()
-resetmypasswordview = Mock()
-resetpasswordview = Mock()
-rolemodelview = Mock()
-user_model = User
-userinfoeditview = Mock()
-userdbmodelview = Mock()
-userldapmodelview = Mock()
-useroauthmodelview = Mock()
-useroidmodelview = Mock()
-userremoteusermodelview = Mock()
-userstatschartview = Mock()
-
-
[email protected]
-def security_manager_override():
-    class SubSecurityManager:
-        def __init__(self, **kwargs):
-            pass
-
-    class EmptySecurityManager(FabAirflowSecurityManagerOverride, 
SubSecurityManager):
-        def __init__(self, appbuilder):
-            super().__init__(
-                appbuilder=appbuilder,
-                actionmodelview=actionmodelview,
-                authdbview=authdbview,
-                authldapview=authldapview,
-                authoauthview=authoauthview,
-                authoidview=authoidview,
-                authremoteuserview=authremoteuserview,
-                permissionmodelview=permissionmodelview,
-                registeruser_view=registeruser_view,
-                registeruserdbview=registeruserdbview,
-                registeruseroauthview=registeruseroauthview,
-                registerusermodelview=registerusermodelview,
-                registeruseroidview=registeruseroidview,
-                resetmypasswordview=resetmypasswordview,
-                resetpasswordview=resetpasswordview,
-                rolemodelview=rolemodelview,
-                user_model=user_model,
-                userinfoeditview=userinfoeditview,
-                userdbmodelview=userdbmodelview,
-                userldapmodelview=userldapmodelview,
-                useroauthmodelview=useroauthmodelview,
-                useroidmodelview=useroidmodelview,
-                userremoteusermodelview=userremoteusermodelview,
-                userstatschartview=userstatschartview,
-            )
-
-    with mock.patch(
-        "airflow.auth.managers.fab.security_manager.override.LoginManager"
-    ) as mock_login_manager, mock.patch(
-        "airflow.auth.managers.fab.security_manager.override.JWTManager"
-    ) as mock_jwt_manager, mock.patch.object(
-        FabAirflowSecurityManagerOverride, "create_db"
-    ):
-        mock_login_manager_instance = Mock()
-        mock_login_manager.return_value = mock_login_manager_instance
-        mock_jwt_manager_instance = Mock()
-        mock_jwt_manager.return_value = mock_jwt_manager_instance
 
-        appbuilder.app.config = MagicMock()
+class EmptySecurityManager(FabAirflowSecurityManagerOverride):
+    # noinspection PyMissingConstructor
+    # super() not called on purpose to avoid the whole chain of init calls
+    def __init__(self):
+        pass
 
-        security_manager_override = EmptySecurityManager(appbuilder)
 
-        mock_login_manager.assert_called_once_with(appbuilder.app)
-        
mock_login_manager_instance.user_loader.assert_called_once_with(security_manager_override.load_user)
-        
mock_jwt_manager_instance.init_app.assert_called_once_with(appbuilder.app)
-        mock_jwt_manager_instance.user_lookup_loader.assert_called_once_with(
-            security_manager_override.load_user_jwt
-        )
-
-    return security_manager_override
+class TestFabAirflowSecurityManagerOverride:
+    def test_load_user(self):
+        sm = EmptySecurityManager()
+        sm.get_user_by_id = Mock()
 
+        sm.load_user("123")
 
-class TestFabAirflowSecurityManagerOverride:
-    def test_load_user(self, security_manager_override):
-        mock_get_user_by_id = Mock()
-        security_manager_override.get_user_by_id = mock_get_user_by_id
-        security_manager_override.load_user("123")
-        mock_get_user_by_id.assert_called_once_with(123)
+        sm.get_user_by_id.assert_called_once_with(123)
 
     @mock.patch("airflow.auth.managers.fab.security_manager.override.g", 
spec={})
-    def test_load_user_jwt(self, mock_g, security_manager_override):
+    def test_load_user_jwt(self, mock_g):
+        sm = EmptySecurityManager()
         mock_user = Mock()
-        mock_load_user = Mock(return_value=mock_user)
-        security_manager_override.load_user = mock_load_user
-        actual_user = security_manager_override.load_user_jwt(None, {"sub": 
"test_identity"})
-        mock_load_user.assert_called_once_with("test_identity")
+        sm.load_user = Mock(return_value=mock_user)
+
+        actual_user = sm.load_user_jwt(None, {"sub": "test_identity"})
+
+        sm.load_user.assert_called_once_with("test_identity")
         assert actual_user is mock_user
         assert mock_g.user is mock_user
diff --git a/tests/auth/managers/fab/test_fab_auth_manager.py 
b/tests/auth/managers/fab/test_fab_auth_manager.py
index 66c279510e..4802b23cf2 100644
--- a/tests/auth/managers/fab/test_fab_auth_manager.py
+++ b/tests/auth/managers/fab/test_fab_auth_manager.py
@@ -25,12 +25,14 @@ from airflow import AirflowException
 from airflow.auth.managers.fab.fab_auth_manager import FabAuthManager
 from airflow.auth.managers.fab.models import User
 from airflow.auth.managers.fab.security_manager.override import 
FabAirflowSecurityManagerOverride
-from airflow.www.security import ApplessAirflowSecurityManager
+from airflow.www.security_appless import ApplessAirflowSecurityManager
 
 
 @pytest.fixture
 def auth_manager():
-    auth_manager = FabAuthManager()
+    app_mock = Mock(name="flask_app")
+    app_mock.config.get.return_value = None  # this is called to get the 
security manager override (if any)
+    auth_manager = FabAuthManager(app_mock)
     auth_manager.security_manager = ApplessAirflowSecurityManager()
     return auth_manager
 
diff --git a/tests/auth/managers/test_base_auth_manager.py 
b/tests/auth/managers/test_base_auth_manager.py
index f339e7d33f..c506133b43 100644
--- a/tests/auth/managers/test_base_auth_manager.py
+++ b/tests/auth/managers/test_base_auth_manager.py
@@ -20,7 +20,8 @@ import pytest
 
 from airflow.auth.managers.base_auth_manager import BaseAuthManager
 from airflow.exceptions import AirflowException
-from airflow.www.security import ApplessAirflowSecurityManager
+from airflow.www.security_appless import ApplessAirflowSecurityManager
+from airflow.www.security_manager import AirflowSecurityManagerV2
 
 
 @pytest.fixture
@@ -35,12 +36,13 @@ def auth_manager():
         def get_url_login(self, **kwargs) -> str:
             raise NotImplementedError()
 
-    return EmptyAuthManager()
+    # noinspection PyTypeChecker
+    return EmptyAuthManager(None)
 
 
 class TestBaseAuthManager:
     def test_get_security_manager_override_class_return_empty_class(self, 
auth_manager):
-        assert auth_manager.get_security_manager_override_class() is object
+        assert auth_manager.get_security_manager_override_class() is 
AirflowSecurityManagerV2
 
     def test_get_security_manager_not_defined(self, auth_manager):
         with pytest.raises(AirflowException, match="Security manager not 
defined."):
diff --git a/tests/models/test_dagbag.py b/tests/models/test_dagbag.py
index e0a999b9d8..f7b36dbb47 100644
--- a/tests/models/test_dagbag.py
+++ b/tests/models/test_dagbag.py
@@ -42,7 +42,7 @@ from airflow.models.serialized_dag import SerializedDagModel
 from airflow.serialization.serialized_objects import SerializedDAG
 from airflow.utils.dates import timezone as tz
 from airflow.utils.session import create_session
-from airflow.www.security import ApplessAirflowSecurityManager
+from airflow.www.security_appless import ApplessAirflowSecurityManager
 from tests import cluster_policies
 from tests.models import TEST_DAGS_FOLDER
 from tests.test_utils import db
@@ -901,7 +901,7 @@ class TestDagBag:
             _sync_to_db()
             mock_sync_perm_for_dag.assert_called_once_with(dag, 
session=session)
 
-    @patch("airflow.www.security.ApplessAirflowSecurityManager")
+    @patch("airflow.www.security_appless.ApplessAirflowSecurityManager")
     def test_sync_perm_for_dag(self, mock_security_manager):
         """
         Test that dagbag._sync_perm_for_dag will call 
ApplessAirflowSecurityManager.sync_perm_for_dag
diff --git a/tests/test_utils/api_connexion_utils.py 
b/tests/test_utils/api_connexion_utils.py
index 7360ed18f6..836ad95d7b 100644
--- a/tests/test_utils/api_connexion_utils.py
+++ b/tests/test_utils/api_connexion_utils.py
@@ -19,7 +19,7 @@ from __future__ import annotations
 from contextlib import contextmanager
 
 from airflow.api_connexion.exceptions import EXCEPTIONS_LINK_MAP
-from airflow.www.security import EXISTING_ROLES
+from airflow.www.security_manager import EXISTING_ROLES
 
 
 @contextmanager
diff --git a/tests/test_utils/mock_security_manager.py 
b/tests/test_utils/mock_security_manager.py
index f55f5e31bd..e8050f83ef 100644
--- a/tests/test_utils/mock_security_manager.py
+++ b/tests/test_utils/mock_security_manager.py
@@ -16,10 +16,10 @@
 # under the License.
 from __future__ import annotations
 
-from airflow.www.security import AirflowSecurityManager
+from airflow.www.security_manager import AirflowSecurityManagerV2
 
 
-class MockSecurityManager(AirflowSecurityManager):
+class MockSecurityManager(AirflowSecurityManagerV2):
     VIEWER_VMS = {
         "Airflow",
     }
diff --git a/tests/www/test_security.py b/tests/www/test_security.py
index 8dc0ebec26..b70aad536b 100644
--- a/tests/www/test_security.py
+++ b/tests/www/test_security.py
@@ -873,7 +873,7 @@ def test_create_dag_specific_permissions(session, 
security_manager, monkeypatch,
     dagbag_class_mock.return_value = dagbag_mock
     import airflow.www.security
 
-    monkeypatch.setitem(airflow.www.security.__dict__, "DagBag", 
dagbag_class_mock)
+    monkeypatch.setitem(airflow.www.security_manager.__dict__, "DagBag", 
dagbag_class_mock)
     security_manager._sync_dag_view_permissions = mock.Mock()
 
     for dag in sample_dags:

Reply via email to