temporary

Yuri Zmytrakov · Yuri Zmytrakov · commit 312ba8a04184 · 2025-10-17T11:07:21.000+02:00
diff --git a/stac_fastapi/core/stac_fastapi/core/redis_utils.py b/stac_fastapi/core/stac_fastapi/core/redis_utils.py
@@ -4,7 +4,7 @@
 import logging
 from typing import List, Optional, Tuple
 
-from pydantic import field_validator
+# from pydantic import field_validator
 from pydantic_settings import BaseSettings
 from redis import asyncio as aioredis
 from redis.asyncio.sentinel import Sentinel
@@ -13,225 +13,135 @@
 
 
 class RedisSentinelSettings(BaseSettings):
-    """Configuration for connecting to Redis Sentinel."""
+    """Configuration settings for connecting to Redis Sentinel."""
 
     REDIS_SENTINEL_HOSTS: str = ""
     REDIS_SENTINEL_PORTS: str = "26379"
     REDIS_SENTINEL_MASTER_NAME: str = "master"
-    REDIS_DB: int = 15
+    REDIS_DB: int = 0
 
     REDIS_MAX_CONNECTIONS: int = 10
-    REDIS_RETRY_TIMEOUT: bool = True
     REDIS_DECODE_RESPONSES: bool = True
     REDIS_CLIENT_NAME: str = "stac-fastapi-app"
     REDIS_HEALTH_CHECK_INTERVAL: int = 30
     REDIS_SELF_LINK_TTL: int = 1800
 
-    @field_validator("REDIS_DB")
-    @classmethod
-    def validate_db_sentinel(cls, v: int) -> int:
-        """Validate REDIS_DB is not negative int."""
-        if v < 0:
-            raise ValueError("REDIS_DB must be a positive integer")
-        return v
-
-    @field_validator("REDIS_MAX_CONNECTIONS")
-    @classmethod
-    def validate_max_connections_sentinel(cls, v: int) -> int:
-        """Validate REDIS_MAX_CONNECTIONS is at least 1."""
-        if v < 1:
-            raise ValueError("REDIS_MAX_CONNECTIONS must be at least 1")
-        return v
-
-    @field_validator("REDIS_HEALTH_CHECK_INTERVAL")
-    @classmethod
-    def validate_health_check_interval_sentinel(cls, v: int) -> int:
-        """Validate REDIS_HEALTH_CHECK_INTERVAL is not negative integer."""
-        if v < 0:
-            raise ValueError("REDIS_HEALTH_CHECK_INTERVAL must be a positive integer")
-        return v
-
-    @field_validator("REDIS_SELF_LINK_TTL")
-    @classmethod
-    def validate_self_link_ttl_sentinel(cls, v: int) -> int:
-        """Validate REDIS_SELF_LINK_TTL is not a negative integer."""
-        if v < 0:
-            raise ValueError("REDIS_SELF_LINK_TTL must be a positive integer")
-        return v
-
-    def get_sentinel_hosts(self) -> List[str]:
-        """Parse Redis Sentinel hosts from string to list."""
-        if not self.REDIS_SENTINEL_HOSTS:
-            return []
-
-        if self.REDIS_SENTINEL_HOSTS.strip().startswith("["):
-            return json.loads(self.REDIS_SENTINEL_HOSTS)
-        else:
-            return [
+    def get_sentinel_nodes(self) -> List[Tuple[str, int]]:
+        """Return list of (host, port) tuples."""
+        try:
+            hosts = json.loads(self.REDIS_SENTINEL_HOSTS)
+            ports = json.loads(self.REDIS_SENTINEL_PORTS)
+        except json.JSONDecodeError:
+            hosts = [
                 h.strip() for h in self.REDIS_SENTINEL_HOSTS.split(",") if h.strip()
             ]
-
-    def get_sentinel_ports(self) -> List[int]:
-        """Parse Redis Sentinel ports from string to list of integers."""
-        if not self.REDIS_SENTINEL_PORTS:
-            return [26379]
-
-        if self.REDIS_SENTINEL_PORTS.strip().startswith("["):
-            return json.loads(self.REDIS_SENTINEL_PORTS)
-        else:
-            ports_str_list = [
-                p.strip() for p in self.REDIS_SENTINEL_PORTS.split(",") if p.strip()
+            ports = [
+                int(p.strip())
+                for p in self.REDIS_SENTINEL_PORTS.split(",")
+                if p.strip()
             ]
-            return [int(port) for port in ports_str_list]
-
-    def get_sentinel_nodes(self) -> List[Tuple[str, int]]:
-        """Get list of (host, port) tuples for Sentinel connection."""
-        hosts = self.get_sentinel_hosts()
-        ports = self.get_sentinel_ports()
-
-        if not hosts:
-            return []
 
         if len(ports) == 1 and len(hosts) > 1:
             ports = ports * len(hosts)
 
-        if len(hosts) != len(ports):
-            raise ValueError(
-                f"Mismatch between hosts ({len(hosts)}) and ports ({len(ports)})"
-            )
-
-        return [(str(host), int(port)) for host, port in zip(hosts, ports)]
+        return list(zip(hosts, ports))
 
 
 class RedisSettings(BaseSettings):
-    """Configuration for connecting Redis."""
+    """Configuration settings for connecting to a standalone Redis instance."""
 
     REDIS_HOST: str = ""
     REDIS_PORT: int = 6379
     REDIS_DB: int = 0
 
     REDIS_MAX_CONNECTIONS: int = 10
-    REDIS_RETRY_TIMEOUT: bool = True
     REDIS_DECODE_RESPONSES: bool = True
     REDIS_CLIENT_NAME: str = "stac-fastapi-app"
     REDIS_HEALTH_CHECK_INTERVAL: int = 30
     REDIS_SELF_LINK_TTL: int = 1800
 
-    @field_validator("REDIS_PORT")
-    @classmethod
-    def validate_port_standalone(cls, v: int) -> int:
-        """Validate REDIS_PORT is not a negative integer."""
-        if v < 0:
-            raise ValueError("REDIS_PORT must be a positive integer")
-        return v
-
-    @field_validator("REDIS_DB")
-    @classmethod
-    def validate_db_standalone(cls, v: int) -> int:
-        """Validate REDIS_DB is not a negative integer."""
-        if v < 0:
-            raise ValueError("REDIS_DB must be a positive integer")
-        return v
-
-    @field_validator("REDIS_MAX_CONNECTIONS")
-    @classmethod
-    def validate_max_connections_standalone(cls, v: int) -> int:
-        """Validate REDIS_MAX_CONNECTIONS is at least 1."""
-        if v < 1:
-            raise ValueError("REDIS_MAX_CONNECTIONS must be at least 1")
-        return v
-
-    @field_validator("REDIS_HEALTH_CHECK_INTERVAL")
-    @classmethod
-    def validate_health_check_interval_standalone(cls, v: int) -> int:
-        """Validate REDIS_HEALTH_CHECK_INTERVAL is not a negative."""
-        if v < 0:
-            raise ValueError("REDIS_HEALTH_CHECK_INTERVAL must be a positive integer")
-        return v
-
-    @field_validator("REDIS_SELF_LINK_TTL")
-    @classmethod
-    def validate_self_link_ttl_standalone(cls, v: int) -> int:
-        """Validate REDIS_SELF_LINK_TTL is negative."""
-        if v < 0:
-            raise ValueError("REDIS_SELF_LINK_TTL must be a positive integer")
-        return v
-
-
-# Configure only one Redis configuration
+
 sentinel_settings = RedisSentinelSettings()
 standalone_settings = RedisSettings()
 
 
+redis: Optional[aioredis.Redis] = None
+
+
 async def connect_redis() -> Optional[aioredis.Redis]:
-    """Return a Redis connection Redis or Redis Sentinel."""
+    """Initialize global Redis connection (Sentinel or Standalone)."""
+    global redis
+    if redis:
+        return redis
+
     try:
         if sentinel_settings.REDIS_SENTINEL_HOSTS:
             sentinel_nodes = sentinel_settings.get_sentinel_nodes()
             sentinel = Sentinel(
                 sentinel_nodes,
-                decode_responses=sentinel_settings.REDIS_DECODE_RESPONSES,
+                decode_responses=True,
             )
 
             redis = sentinel.master_for(
                 service_name=sentinel_settings.REDIS_SENTINEL_MASTER_NAME,
                 db=sentinel_settings.REDIS_DB,
-                decode_responses=sentinel_settings.REDIS_DECODE_RESPONSES,
-                retry_on_timeout=sentinel_settings.REDIS_RETRY_TIMEOUT,
+                decode_responses=True,
                 client_name=sentinel_settings.REDIS_CLIENT_NAME,
                 max_connections=sentinel_settings.REDIS_MAX_CONNECTIONS,
                 health_check_interval=sentinel_settings.REDIS_HEALTH_CHECK_INTERVAL,
             )
             logger.info("Connected to Redis Sentinel")
 
         elif standalone_settings.REDIS_HOST:
-            pool = aioredis.ConnectionPool(
+            redis = aioredis.Redis(
                 host=standalone_settings.REDIS_HOST,
                 port=standalone_settings.REDIS_PORT,
                 db=standalone_settings.REDIS_DB,
-                max_connections=standalone_settings.REDIS_MAX_CONNECTIONS,
-                decode_responses=standalone_settings.REDIS_DECODE_RESPONSES,
-                retry_on_timeout=standalone_settings.REDIS_RETRY_TIMEOUT,
+                decode_responses=True,
+                client_name=standalone_settings.REDIS_CLIENT_NAME,
                 health_check_interval=standalone_settings.REDIS_HEALTH_CHECK_INTERVAL,
             )
-            redis = aioredis.Redis(
-                connection_pool=pool, client_name=standalone_settings.REDIS_CLIENT_NAME
-            )
-            logger.info("Connected to Redis")
+            logger.info("Connected to standalone Redis")
+
         else:
-            logger.warning("No Redis configuration found")
+            logger.warning("No Redis configuration found.")
             return None
 
+        await redis.ping()
         return redis
 
-    except aioredis.ConnectionError as e:
-        logger.error(f"Redis connection error: {e}")
-        return None
-    except aioredis.AuthenticationError as e:
-        logger.error(f"Redis authentication error: {e}")
-        return None
-    except aioredis.TimeoutError as e:
-        logger.error(f"Redis timeout error: {e}")
-        return None
     except Exception as e:
         logger.error(f"Failed to connect to Redis: {e}")
+        redis = None
         return None
 
 
+async def close_redis():
+    """Close global Redis connection."""
+    global redis
+    if redis:
+        await redis.close()
+        redis = None
+        logger.info("Redis connection closed.")
+
+
 async def save_self_link(
     redis: aioredis.Redis, token: Optional[str], self_href: str
 ) -> None:
-    """Save the self link for the current token."""
-    if token:
-        if sentinel_settings.REDIS_SENTINEL_HOSTS:
-            ttl_seconds = sentinel_settings.REDIS_SELF_LINK_TTL
-        elif standalone_settings.REDIS_HOST:
-            ttl_seconds = standalone_settings.REDIS_SELF_LINK_TTL
-        await redis.setex(f"nav:self:{token}", ttl_seconds, self_href)
+    """Save current self link for token."""
+    if not token:
+        return
+
+    ttl = (
+        sentinel_settings.REDIS_SELF_LINK_TTL
+        if sentinel_settings.REDIS_SENTINEL_HOSTS
+        else standalone_settings.REDIS_SELF_LINK_TTL
+    )
+    await redis.setex(f"nav:self:{token}", ttl, self_href)
 
 
 async def get_prev_link(redis: aioredis.Redis, token: Optional[str]) -> Optional[str]:
-    """Get the previous page link for the current token (if exists)."""
+    """Return previous page link for token."""
     if not token:
         return None
     return await redis.get(f"nav:self:{token}")
@@ -240,17 +150,17 @@ async def get_prev_link(redis: aioredis.Redis, token: Optional[str]) -> Optional
 async def redis_pagination_links(
     current_url: str, token: str, next_token: str, links: list
 ) -> None:
-    """Handle Redis pagination."""
-    redis = await connect_redis()
-    if not redis:
-        logger.warning("Redis connection failed.")
+    """Manage pagination links stored in Redis."""
+    redis_conn = await connect_redis()
+    if not redis_conn:
+        logger.warning("Redis not available for pagination.")
         return
 
     try:
         if next_token:
-            await save_self_link(redis, next_token, current_url)
+            await save_self_link(redis_conn, next_token, current_url)
 
-        prev_link = await get_prev_link(redis, token)
+        prev_link = await get_prev_link(redis_conn, token)
         if prev_link:
             links.insert(
                 0,
@@ -262,6 +172,4 @@ async def redis_pagination_links(
                 },
             )
     except Exception as e:
-        logger.warning(f"Redis pagination operation failed: {e}")
-    finally:
-        await redis.close()
+        logger.warning(f"Redis pagination failed: {e}")
diff --git a/stac_fastapi/tests/redis/test_redis_utils.py b/stac_fastapi/tests/redis/test_redis_utils.py
@@ -6,38 +6,34 @@
 @pytest.mark.asyncio
 async def test_redis_connection():
     """Test Redis connection."""
-    async with connect_redis() as redis:
-        if redis is None:
-            pytest.skip("Redis not configured")
+    redis = await connect_redis()
 
-        await redis.set("string_key", "string_value")
-        string_value = await redis.get("string_key")
-        assert string_value == "string_value"
+    await redis.set("string_key", "string_value")
+    string_value = await redis.get("string_key")
+    assert string_value == "string_value"
 
-        exists = await redis.exists("string_key")
-        assert exists == 1
+    exists = await redis.exists("string_key")
+    assert exists == 1
 
-        await redis.delete("string_key")
-        deleted_value = await redis.get("string_key")
-        assert deleted_value is None
+    await redis.delete("string_key")
+    deleted_value = await redis.get("string_key")
+    assert deleted_value is None
 
 
 @pytest.mark.asyncio
 async def test_redis_utils_functions():
-    async with connect_redis() as redis:
-        if redis is None:
-            pytest.skip("Redis not configured")
+    redis = await connect_redis()
 
-        token = "test_token_123"
-        self_link = "http://mywebsite.com/search?token=test_token_123"
+    token = "test_token_123"
+    self_link = "http://mywebsite.com/search?token=test_token_123"
 
-        await save_self_link(redis, token, self_link)
-        retrieved_link = await get_prev_link(redis, token)
-        assert retrieved_link == self_link
+    await save_self_link(redis, token, self_link)
+    retrieved_link = await get_prev_link(redis, token)
+    assert retrieved_link == self_link
 
-        await save_self_link(redis, None, "should_not_save")
-        null_result = await get_prev_link(redis, None)
-        assert null_result is None
+    await save_self_link(redis, None, "should_not_save")
+    null_result = await get_prev_link(redis, None)
+    assert null_result is None
 
-        non_existent = await get_prev_link(redis, "non_existent_token")
-        assert non_existent is None
+    non_existent = await get_prev_link(redis, "non_existent_token")
+    assert non_existent is None
