feat: add local keydb

docker-compose.yml

@@ -14,43 +14,4 @@ services:
       APP_WORKERS: "1"
     env_file:
       - .env
-    depends_on:
-      keydb:
-        condition: service_healthy
     restart: no
-
-  keydb:
-      image: eqalpha/keydb
-      container_name: keydb
-      restart: no
-      expose:
-        - "6379"
-      volumes:
-        - keydb_data:/data
-      command:
-        - keydb-server
-        - --requirepass
-        - ${KEYDB_PASSWORD}
-        - --dir
-        - /data
-        - --appendonly
-        - "yes"
-        - --appendfsync
-        - everysec
-        - --save
-        - "900"
-        - "1"
-        - --save
-        - "300"
-        - "10"
-        - --save
-        - "60"
-        - "10000"
-      healthcheck:
-        test: ["CMD", "redis-cli", "-a", "${KEYDB_PASSWORD}", "ping"]
-        interval: 5s
-        timeout: 2s
-        retries: 20
-
-volumes:
-  keydb_data:

src/application/commands/create_order_command.py

@@ -19,13 +19,11 @@ class CreateOrderCommand:
             *,
             unit_of_work: IUnitOfWork,
             logger: ILogger,
-            cache_local: ICache,
             remote_cache: ICache,
             itpay_service: IItPayService,
     ) -> None:
         self._unit_of_work = unit_of_work
         self._logger = logger
-        self._cache_local = cache_local
         self._remote_cache = remote_cache
         self._itpay_service = itpay_service
 

src/infrastructure/config/settings.py

@@ -74,11 +74,6 @@ class Settings(BaseSettings):
     REDIS_PASSWORD: str | None = None
     REDIS_DB: int = 0
 
-    KEYDB_LOCAL_HOST: str | None = None
-    KEYDB_LOCAL_PORT: int | None = None
-    KEYDB_LOCAL_PASSWORD: str | None = None
-    KEYDB_LOCAL_DB: int | None = None
-
     KEYDB_REMOTE_HOST: str | None = None
     KEYDB_REMOTE_PORT: int | None = None
     KEYDB_REMOTE_PASSWORD: str | None = None
@@ -293,14 +288,6 @@ class Settings(BaseSettings):
         auth = f':{password}@' if password else ''
         return f'redis://{auth}{host}:{port}/{db}'
 
-    @property
-    def KEYDB_LOCAL_URL(self) -> str:
-        host = self.KEYDB_LOCAL_HOST or self.REDIS_HOST
-        port = int(self.KEYDB_LOCAL_PORT) if self.KEYDB_LOCAL_PORT is not None else int(self.REDIS_PORT)
-        password = self.KEYDB_LOCAL_PASSWORD if self.KEYDB_LOCAL_PASSWORD is not None else self.REDIS_PASSWORD
-        db = int(self.KEYDB_LOCAL_DB) if self.KEYDB_LOCAL_DB is not None else int(self.REDIS_DB)
-        return self._redis_url(host=host, port=port, password=password, db=db)
-
     @property
     def KEYDB_REMOTE_URL(self) -> str:
         host = self.KEYDB_REMOTE_HOST or self.REDIS_HOST

src/main.py

@@ -40,7 +40,6 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     logger.set_instance_id(instance_id)
     logger.info(f'Users service instance started with id {instance_id}')
 
-    app.state.redis_local = create_redis_client(settings.KEYDB_LOCAL_URL)
     app.state.redis_remote = create_redis_client(settings.KEYDB_REMOTE_URL)
     app.state.redis = app.state.redis_remote
 
@@ -61,7 +60,6 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     app.state.jwt_key_store = jwt_store
     app.state.jwt_keys_scheduler = jwt_scheduler
     yield
-    await app.state.redis_local.aclose()
     await app.state.redis_remote.aclose()
     logger.info(f'Users service instance ended with id {instance_id}')
 

src/presentation/dependencies/__init__.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 
-from src.presentation.dependencies.cache import get_cache,get_cache_local,get_cache_remote,get_redis,get_redis_local,get_redis_remote
+from src.presentation.dependencies.cache import get_cache,get_cache_remote,get_redis,get_redis_remote
 from src.presentation.dependencies.queue_messanger import get_rabbit
 from src.presentation.dependencies.security import get_jwt_service
 
 
-__all__=['get_jwt_service','get_redis','get_redis_local','get_redis_remote','get_cache','get_cache_local','get_cache_remote','get_rabbit']
+__all__=['get_jwt_service','get_redis','get_redis_remote','get_cache','get_cache_remote','get_rabbit']

src/presentation/dependencies/cache.py

@@ -8,10 +8,6 @@ from src.application.contracts import ICache
 from src.infrastructure.cache import KeydbCache,RemoteCache
 
 
-def get_redis_local(request: Request) -> Redis:
-    return request.app.state.redis_local
-
-
 def get_redis_remote(request: Request) -> Redis:
     return request.app.state.redis_remote
 
@@ -20,10 +16,6 @@ def get_redis(request: Request) -> Redis:
     return request.app.state.redis_remote
 
 
-def get_cache_local(redis_client: Redis = Depends(get_redis_local)) -> ICache:
-    return KeydbCache(redis_client)
-
-
 def get_cache_remote(redis_client: Redis = Depends(get_redis_remote)) -> ICache:
     return KeydbCache(redis_client)
 

src/presentation/dependencies/commands.py

@@ -6,7 +6,7 @@ from src.application.contracts import ICache,ILogger,IQueueMessanger
 from src.application.contracts.i_itpay_service import IItPayService
 from src.infrastructure.config import settings
 from src.infrastructure.itpay.client import ItPayClient
-from src.presentation.dependencies.cache import get_cache_local,get_remote_cache
+from src.presentation.dependencies.cache import get_remote_cache
 from src.presentation.dependencies.logger import get_logger
 from src.presentation.dependencies.queue_messanger import get_rabbit
 from src.presentation.dependencies.unit_of_work import get_unit_of_work
@@ -22,14 +22,12 @@ def get_itpay_service() -> IItPayService:
 def get_create_order_command(
     logger: ILogger = Depends(get_logger),
     unit_of_work: IUnitOfWork = Depends(get_unit_of_work),
-    cache_local: ICache = Depends(get_cache_local),
     remote_cache: ICache = Depends(get_remote_cache),
     itpay_service: IItPayService = Depends(get_itpay_service),
 ) -> CreateOrderCommand:
     return CreateOrderCommand(
         unit_of_work=unit_of_work,
         logger=logger,
-        cache_local=cache_local,
         remote_cache=remote_cache,
         itpay_service=itpay_service,
     )