fdc-shared-kernel 0.0.191__tar.gz → 0.0.192__tar.gz

{fdc_shared_kernel-0.0.191 → fdc_shared_kernel-0.0.192}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fdc_shared_kernel
-Version: 0.0.191
+Version: 0.0.192
 Summary: Shared library for microservice
 Author-email: Shikhil S <shikhil.s@dbizsolution.com>, Ahammed Akdham N <ahammedakdham.n@dbizsolution.com>
 Classifier: Programming Language :: Python :: 3

{fdc_shared_kernel-0.0.191 → fdc_shared_kernel-0.0.192}/fdc_shared_kernel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fdc_shared_kernel
-Version: 0.0.191
+Version: 0.0.192
 Summary: Shared library for microservice
 Author-email: Shikhil S <shikhil.s@dbizsolution.com>, Ahammed Akdham N <ahammedakdham.n@dbizsolution.com>
 Classifier: Programming Language :: Python :: 3

{fdc_shared_kernel-0.0.191 → fdc_shared_kernel-0.0.192}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fdc_shared_kernel"
-version = "0.0.191"
+version = "0.0.192"
 requires-python = ">=3.7"
 readme = "README_pypi.md"
 description = "Shared library for microservice"

{fdc_shared_kernel-0.0.191 → fdc_shared_kernel-0.0.192}/shared_kernel/data_warehouse_handlers/connections/fabric_sql_warehouse_connection.py

@@ -23,6 +23,7 @@ logger = Logger(config.get("APP_NAME"))
 class FabricSQLWarehouseConnection(DataWarehouseConnection):
 
     _engines: Dict[str, Engine] = {}
+    _tokens: Dict[str, dict] = {}
     _lock = threading.Lock()
 
     def __init__(
@@ -43,39 +44,16 @@ class FabricSQLWarehouseConnection(DataWarehouseConnection):
         self.search = pagination.get("search") if isinstance(pagination, dict) else None
 
     def _engine_key(self, cfg: FabricSQLConfig) -> str:
-        pwd_hash = hashlib.sha256(cfg.password.encode()).hexdigest()
-        return f"{cfg.host}|{cfg.port}|{cfg.database}|{cfg.username}|{pwd_hash}"
+        h = hashlib.md5(f"{cfg.host}:{cfg.port}:{cfg.database}:{cfg.username}".encode()).hexdigest()
+        return h
 
-    def _get_fabric_connection_params(self, cfg: FabricSQLConfig) -> tuple:
+    def _get_fabric_connection_params(self, cfg: FabricSQLConfig) -> str:
         """
-        Builds the token authentication and connection parameters for Microsoft Fabric SQL.
+        Builds the base connection parameters for Microsoft Fabric SQL.
         
         Returns:
-            tuple: (connection_string, connect_args)
+            str: Connection string
         """
-        logger.info("Using Fabric SQL connector (pyodbc native) with access token authentication")
-        tenant_id = getattr(cfg, "tenant_id", None)
-        if not tenant_id:
-            raise ValueError(
-                "tenant_id is required in FabricSQLConfig for authenticating to Microsoft Fabric via Active Directory Service Principal."
-            )
-
-        from azure.identity import ClientSecretCredential
-        import struct
-
-        # Get OAuth2 token for Azure SQL / Fabric from Microsoft Entra ID
-        cred = ClientSecretCredential(
-            tenant_id=tenant_id,
-            client_id=cfg.username,
-            client_secret=cfg.password
-        )
-        token_obj = cred.get_token("https://database.windows.net/.default")
-        
-        # Encode token as UTF-16-LE and pack into structure expected by the SQL Server ODBC driver.
-        # The binary layout expects [4 bytes for length of token payload] followed by the [raw token bytes].
-        token_bytes = token_obj.token.encode("utf-16-le")
-        token_struct = struct.pack(f"<I{len(token_bytes)}s", len(token_bytes), token_bytes)
-
         import urllib.parse
         # Build ODBC params. We omit UID and Password fields entirely from the connection string.
         # Authentication is handled solely by injecting the access token into the connection handle.
@@ -89,11 +67,7 @@ class FabricSQLWarehouseConnection(DataWarehouseConnection):
         # We use odbc_connect query param to prevent SQLAlchemy dialect from auto-injecting
         # conflicting credentials/parameters (avoiding error FA005).
         connection_string = f"mssql+pyodbc:///?odbc_connect={odbc_params}"
-        
-        # Inject the token using ODBC attribute SQL_COPT_SS_ACCESS_TOKEN (attribute ID 1256)
-        # before the connection is established.
-        connect_args = {"attrs_before": {1256: token_struct}}
-        return connection_string, connect_args
+        return connection_string
 
     def _get_engine(self) -> Engine:
         cfg = self._fabric_config
@@ -102,19 +76,79 @@ class FabricSQLWarehouseConnection(DataWarehouseConnection):
         if key not in self._engines:
             with self.__class__._lock: # thread-safe
                 if key not in self._engines: # recheck
-                    connection_string, connect_args = self._get_fabric_connection_params(cfg)
+                    from sqlalchemy import event
+                    
+                    connection_string = self._get_fabric_connection_params(cfg)
 
-                    self._engines[key] = create_engine(
+                    engine = create_engine(
                         connection_string,
-                        connect_args=connect_args,
                         pool_size=10,
                         max_overflow=5,
                         pool_timeout=30,
                         pool_recycle=1800,
                         pool_pre_ping=True,
                     )
+                    
+                    # Ensure a thread-safe token cache structure exists for this database key.
+                    # Each unique database configuration gets its own token cache, expiration tracker, and lock.
+                    if key not in self._tokens:
+                        self._tokens[key] = {
+                            "token": None,       # Stores the packed binary token structure
+                            "expires_at": 0,     # Unix timestamp indicating token expiration time
+                            "lock": threading.Lock() # Lock to synchronize concurrent token refreshes
+                        }
+                    
+                    # Register an event listener on the engine to intercept connection establishment.
+                    # Every time SQLAlchemy checks out or opens a new raw DBAPI connection from the pool,
+                    # this listener executes to inject a valid, fresh Entra ID access token.
+                    @event.listens_for(engine, "do_connect")
+                    def provide_token(dialect, conn_rec, cargs, cparams):
+                        now = time.time()
+                        token_info = self._tokens[key]
+                        
+                        # Check if the token is missing or near expiration (within 5 minutes / 300 seconds).
+                        # This buffer ensures we don't send a token that is about to expire.
+                        if token_info["token"] is None or now >= token_info["expires_at"] - 300:
+                            # Acquire the database-specific lock to serialize token generation.
+                            # If 10 threads try to connect concurrently when a token expires,
+                            # only the first thread executes the token fetch; others block here.
+                            with token_info["lock"]:
+                                # Double-checked locking pattern: once the lock is acquired,
+                                # re-verify if another thread updated the token while we were waiting.
+                                if token_info["token"] is None or now >= token_info["expires_at"] - 300:
+                                    tenant_id = getattr(cfg, "tenant_id", None)
+                                    if not tenant_id:
+                                        raise ValueError(
+                                            "tenant_id is required in FabricSQLConfig for authenticating to Microsoft Fabric via Active Directory Service Principal."
+                                        )
+                                    
+                                    from azure.identity import ClientSecretCredential
+                                    import struct
+                                    
+                                    logger.info("Fetching fresh Entra ID access token for Fabric SQL connection...")
+                                    # Instantiate the credential to retrieve a token for the Azure SQL Endpoint
+                                    cred = ClientSecretCredential(
+                                        tenant_id=tenant_id,
+                                        client_id=cfg.username,
+                                        client_secret=cfg.password
+                                    )
+                                    token_obj = cred.get_token("https://database.windows.net/.default")
+                                    
+                                    # Encode the OAuth token to UTF-16-LE bytes.
+                                    # Pack the payload into the binary structure required by ODBC Driver 18:
+                                    # [4 bytes representing the length of the token string] followed by [the token string bytes].
+                                    token_bytes = token_obj.token.encode("utf-16-le")
+                                    token_info["token"] = struct.pack(f"<I{len(token_bytes)}s", len(token_bytes), token_bytes)
+                                    token_info["expires_at"] = token_obj.expires_on
+                                    logger.info("Successfully fetched and cached fresh Entra ID access token.")
+                                    
+                        # Inject the packed binary token structure into pyodbc's attrs_before connection attribute list.
+                        # Attribute ID 1256 maps to SQL_COPT_SS_ACCESS_TOKEN.
+                        cparams["attrs_before"] = {1256: token_info["token"]}
+
+                    self._engines[key] = engine
                     logger.info(
-                        f"Created new Fabric SQL engine for {cfg.host}:{cfg.port}/{cfg.database}"
+                        f"Created new Fabric SQL engine for {cfg.host}:{cfg.port}/{cfg.database} with dynamic token provider"
                     )
 
         return self._engines[key]
@@ -163,6 +197,7 @@ class FabricSQLWarehouseConnection(DataWarehouseConnection):
         for engine in self._engines.values():
             engine.dispose()
         self._engines.clear()
+        self._tokens.clear()
         logger.info("All Fabric SQL engine pools disposed.")
 
     def is_valid_connection(self) -> bool:

{fdc_shared_kernel-0.0.191 → fdc_shared_kernel-0.0.192}/shared_kernel/data_warehouse_handlers/fabric_sql_handler.py

@@ -52,9 +52,6 @@ class FabricSQLWarehouseHandler(WarehouseHandler):
         connection = self._build_connection()
         return FabricSQLQueryExecutor(warehouse_connection=connection)
 
-    def get_constants_section(self) -> str:
-        return "mssql"
-
     def get_query_object(self) -> MSSQLQuery:
         return MSSQLQuery