fix backends, more parameters

Author: igorbenav

crudadmin/admin_interface/crud_admin.py

@@ -1231,50 +1231,184 @@ async def _create_initial_admin(self, admin_data: Union[dict, BaseModel]) -> Non
                 raise
 
     def use_redis_sessions(
-        self, redis_url: str = "redis://localhost:6379", **kwargs: Any
+        self,
+        redis_url: Optional[str] = None,
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        db: Optional[int] = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        **kwargs: Any,
     ) -> "CRUDAdmin":
         """Configure Redis session backend.
 
+        You can configure Redis connection using either a URL or individual parameters,
+        but not both.
+
         Args:
-            redis_url: Redis connection URL
-            **kwargs: Additional Redis configuration options
+            redis_url: Redis connection URL (e.g., "redis://user:pass@localhost:6379/0")
+            host: Redis host (default: "localhost")
+            port: Redis port (default: 6379)
+            db: Redis database number (default: 0)
+            username: Redis username for ACL authentication (Redis 6.0+, default: None)
+            password: Redis password (default: None)
+            **kwargs: Additional Redis configuration options (pool_size, connect_timeout, etc.)
 
         Returns:
             Self for method chaining
+
+        Raises:
+            ValueError: If both redis_url and individual parameters are provided
+
+        Examples:
+            Using URL:
+            ```python
+            admin.use_redis_sessions(redis_url="redis://myuser:mypass@localhost:6379/1")
+            ```
+
+            Using individual parameters:
+            ```python
+            admin.use_redis_sessions(host="localhost", port=6379, db=1, username="myuser", password="secret")
+            ```
         """
         self._session_backend = "redis"
-        self._session_backend_kwargs = {"redis_url": redis_url, **kwargs}
+
+        individual_params = [host, port, db, username, password]
+        has_individual_params = any(param is not None for param in individual_params)
+
+        if redis_url is not None and has_individual_params:
+            raise ValueError(
+                "Cannot specify both redis_url and individual parameters (host, port, db, username, password). "
+                "Use either redis_url='redis://...' OR individual parameters like host='localhost'."
+            )
+
+        if redis_url is not None:
+            parsed_redis_kwargs = self._parse_redis_url(redis_url)
+        elif has_individual_params:
+            parsed_redis_kwargs = {
+                "host": host or "localhost",
+                "port": port or 6379,
+                "db": db or 0,
+            }
+            if username is not None:
+                parsed_redis_kwargs["username"] = username
+            if password is not None:
+                parsed_redis_kwargs["password"] = password
+        else:
+            parsed_redis_kwargs = {
+                "host": "localhost",
+                "port": 6379,
+                "db": 0,
+            }
+
+        if "track_sessions_in_db" in kwargs:
+            self.track_sessions_in_db = kwargs.pop("track_sessions_in_db")
+        else:
+            self.track_sessions_in_db = False
+
+        parsed_redis_kwargs.update(kwargs)
+        self._session_backend_kwargs = parsed_redis_kwargs
+
+        if hasattr(self, "session_manager"):
+            self._recreate_session_manager()
+
         return self
 
     def use_memcached_sessions(
-        self, servers: Optional[List[str]] = None, **kwargs: Any
+        self,
+        servers: Optional[List[str]] = None,
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        **kwargs: Any,
     ) -> "CRUDAdmin":
         """Configure Memcached session backend.
 
+        You can configure Memcached connection using either a servers list or individual parameters,
+        but not both.
+
         Args:
-            servers: List of memcached server addresses
-            **kwargs: Additional Memcached configuration options
+            servers: List of memcached server addresses (e.g., ["localhost:11211", "server2:11211"])
+            host: Memcached host (default: "localhost")
+            port: Memcached port (default: 11211)
+            **kwargs: Additional Memcached configuration options (pool_size, etc.)
 
         Returns:
             Self for method chaining
+
+        Raises:
+            ValueError: If both servers and individual parameters are provided
+
+        Examples:
+            Using servers list:
+            ```python
+            admin.use_memcached_sessions(servers=["localhost:11211", "server2:11211"])
+            ```
+
+            Using individual parameters:
+            ```python
+            admin.use_memcached_sessions(host="localhost", port=11211)
+            ```
+
+        Note:
+            aiomcache currently supports only single server connections,
+            so only the first server in the list will be used.
         """
-        if servers is None:
-            servers = ["localhost:11211"]
+        individual_params = [host, port]
+        has_individual_params = any(param is not None for param in individual_params)
+
+        if servers is not None and has_individual_params:
+            raise ValueError(
+                "Cannot specify both servers and individual parameters (host, port). "
+                "Use either servers=['host:port', ...] OR individual parameters like host='localhost'."
+            )
+
+        if servers is not None:
+            parsed_memcached_kwargs = self._parse_memcached_servers(servers)
+        elif has_individual_params:
+            parsed_memcached_kwargs = {
+                "host": host or "localhost",
+                "port": port or 11211,
+            }
+        else:
+            parsed_memcached_kwargs = {
+                "host": "localhost",
+                "port": 11211,
+            }
+
+        if "track_sessions_in_db" in kwargs:
+            self.track_sessions_in_db = kwargs.pop("track_sessions_in_db")
+        else:
+            self.track_sessions_in_db = False
+
+        parsed_memcached_kwargs.update(kwargs)
+
         self._session_backend = "memcached"
-        self._session_backend_kwargs = {"servers": servers, **kwargs}
+        self._session_backend_kwargs = parsed_memcached_kwargs
+
+        if hasattr(self, "session_manager"):
+            self._recreate_session_manager()
+
         return self
 
     def use_memory_sessions(self, **kwargs: Any) -> "CRUDAdmin":
         """Configure in-memory session backend.
 
         Args:
             **kwargs: Additional memory storage configuration options
+                     Note: track_sessions_in_db is ignored for memory sessions
 
         Returns:
             Self for method chaining
         """
+        kwargs.pop("track_sessions_in_db", None)
+
         self._session_backend = "memory"
         self._session_backend_kwargs = kwargs
+        self.track_sessions_in_db = False
+
+        if hasattr(self, "session_manager"):
+            self._recreate_session_manager()
+
         return self
 
     def use_database_sessions(self, **kwargs: Any) -> "CRUDAdmin":
@@ -1292,4 +1426,130 @@ def use_database_sessions(self, **kwargs: Any) -> "CRUDAdmin":
         self._session_backend = "database"
         self._session_backend_kwargs = kwargs
         self.track_sessions_in_db = True
+
+        if hasattr(self, "session_manager"):
+            self._recreate_session_manager()
+
         return self
+
+    def _parse_redis_url(self, redis_url: str) -> Dict[str, Any]:
+        """Parse Redis URL to extract connection parameters.
+
+        Args:
+            redis_url: Redis connection URL (e.g., redis://user:pass@localhost:6379/0)
+
+        Returns:
+            Dictionary of Redis connection parameters
+        """
+        from urllib.parse import urlparse
+
+        parsed = urlparse(redis_url)
+
+        redis_kwargs = {
+            "host": parsed.hostname or "localhost",
+            "port": parsed.port or 6379,
+            "db": int(parsed.path.lstrip("/"))
+            if parsed.path and parsed.path != "/"
+            else 0,
+        }
+
+        if parsed.username:
+            redis_kwargs["username"] = parsed.username
+
+        if parsed.password:
+            redis_kwargs["password"] = parsed.password
+
+        return redis_kwargs
+
+    def _parse_memcached_servers(self, servers: List[str]) -> Dict[str, Any]:
+        """Parse Memcached servers list to extract connection parameters.
+
+        Args:
+            servers: List of server addresses (e.g., ["localhost:11211", "server2:11211"])
+
+        Returns:
+            Dictionary of Memcached connection parameters
+
+        Note:
+            aiomcache currently supports only single server connections,
+            so we use the first server in the list.
+        """
+        if not servers:
+            return {"host": "localhost", "port": 11211}
+
+        server = servers[0]
+
+        if ":" in server:
+            host, port_str = server.split(":", 1)
+            try:
+                port = int(port_str)
+            except ValueError:
+                port = 11211
+        else:
+            host = server
+            port = 11211
+
+        return {"host": host, "port": port}
+
+    def _recreate_session_manager(self) -> None:
+        """Recreate session manager with current backend configuration."""
+        session_backend = getattr(self, "_session_backend", "memory")
+        backend_kwargs = getattr(self, "_session_backend_kwargs", {})
+
+        if self.track_sessions_in_db:
+            if session_backend in ["redis", "memcached"]:
+                actual_backend = "hybrid"
+                backend_kwargs["db_config"] = self.db_config
+                backend_kwargs["_cache_backend"] = session_backend
+            else:
+                actual_backend = "database"
+                backend_kwargs["db_config"] = self.db_config
+        else:
+            actual_backend = session_backend
+
+        session_timeout_minutes = 30  # default
+        if hasattr(self, "session_manager"):
+            session_timeout_minutes = int(
+                self.session_manager.session_timeout.total_seconds() / 60
+            )
+
+        storage: AbstractSessionStorage[SessionData] = get_session_storage(
+            backend=actual_backend,
+            model_type=SessionData,
+            prefix="session:",
+            expiration=session_timeout_minutes * 60,
+            **backend_kwargs,
+        )
+
+        if hasattr(self, "session_manager"):
+            max_sessions = self.session_manager.max_sessions
+            cleanup_interval_minutes = int(
+                self.session_manager.cleanup_interval.total_seconds() / 60
+            )
+            csrf_token_bytes = self.session_manager.csrf_token_bytes
+            rate_limiter = self.session_manager.rate_limiter
+            login_max_attempts = self.session_manager.login_max_attempts
+            login_window_minutes = int(
+                self.session_manager.login_window.total_seconds() / 60
+            )
+        else:
+            max_sessions = 5
+            cleanup_interval_minutes = 15
+            csrf_token_bytes = 32
+            rate_limiter = None
+            login_max_attempts = 5
+            login_window_minutes = 15
+
+        self.session_manager = SessionManager(
+            session_storage=storage,
+            max_sessions_per_user=max_sessions,
+            session_timeout_minutes=session_timeout_minutes,
+            cleanup_interval_minutes=cleanup_interval_minutes,
+            csrf_token_bytes=csrf_token_bytes,
+            rate_limiter=rate_limiter,
+            login_max_attempts=login_max_attempts,
+            login_window_minutes=login_window_minutes,
+        )
+
+        if hasattr(self, "admin_authentication"):
+            self.admin_authentication.session_manager = self.session_manager

crudadmin/session/backends/redis.py

@@ -28,6 +28,7 @@ def __init__(
         host: str = "localhost",
         port: int = 6379,
         db: int = 0,
+        username: Optional[str] = None,
         password: Optional[str] = None,
         pool_size: int = 10,
         connect_timeout: int = 10,
@@ -40,6 +41,7 @@ def __init__(
             host: Redis host
             port: Redis port
             db: Redis database number
+            username: Redis username (for ACL authentication, Redis 6.0+)
             password: Redis password
             pool_size: Redis connection pool size
             connect_timeout: Redis connection timeout
@@ -50,6 +52,7 @@ def __init__(
             host=host,
             port=port,
             db=db,
+            username=username,
             password=password,
             socket_timeout=connect_timeout,
             socket_connect_timeout=connect_timeout,