e6data-python-connector 2.3.9rc2__tar.gz → 2.3.9rc4__tar.gz

{e6data_python_connector-2.3.9rc2/e6data_python_connector.egg-info → e6data_python_connector-2.3.9rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.3.9rc2
+Version: 2.3.9rc4
 Summary: Client for the e6data distributed SQL Engine.
 Home-page: https://github.com/e6x-labs/e6data-python-connector
 Author: e6data, Inc.
@@ -38,7 +38,7 @@ Dynamic: summary
 
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.3.9rc2-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.9rc4-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.3.9rc2 → e6data_python_connector-2.3.9rc4}/README.md

@@ -1,6 +1,6 @@
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.3.9rc2-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.9rc4-blue.svg)
 
 ## Introduction
 

e6data_python_connector-2.3.9rc4/e6data_python_connector/__init__.py

@@ -0,0 +1,3 @@
+from e6data_python_connector.e6data_grpc import Connection, Cursor
+
+__all__ = ['Connection', 'Cursor']

{e6data_python_connector-2.3.9rc2 → e6data_python_connector-2.3.9rc4}/e6data_python_connector/cluster_manager.py

@@ -8,7 +8,6 @@ import multiprocessing
 
 from e6data_python_connector.strategy import _get_active_strategy, _set_active_strategy, _set_pending_strategy, \
     _get_grpc_header as _get_strategy_header
-from e6data_python_connector.retry_handler import get_retry_handler, LOCK_ACQUISITION_RETRY_CONFIG
 
 
 def _get_grpc_header(engine_ip=None, cluster=None, strategy=None):
@@ -87,33 +86,16 @@ class _StatusLock:
         Acquires both the thread-level lock and process-level semaphore
         to ensure the current operation can safely access shared resources.
 
-        Uses retry logic to handle lock contention in high-concurrency environments.
-
         Raises:
            TimeoutError: If the lock cannot be acquired within the timeout period.
 
         Returns:
            _StatusLock: The current instance of the lock, used for context management.
         """
-        retry_handler = get_retry_handler('lock_acquisition')
-        
-        def acquire_locks():
-            thread_acquired = self._status_thread_lock.acquire(timeout=self._LOCK_TIMEOUT)
-            if not thread_acquired:
-                raise TimeoutError("Failed to acquire thread lock")
-            
-            try:
-                mp_acquired = self._status_multiprocessing_lock.acquire(timeout=self._LOCK_TIMEOUT)
-                if not mp_acquired:
-                    self._status_thread_lock.release()
-                    raise TimeoutError("Failed to acquire multiprocessing lock")
-            except Exception:
-                self._status_thread_lock.release()
-                raise
-            
-            return self
-        
-        return retry_handler.execute_with_retry(acquire_locks, "lock_acquisition")
+
+        self._status_thread_lock.acquire(timeout=self._LOCK_TIMEOUT)
+        self._status_multiprocessing_lock.acquire(timeout=self._LOCK_TIMEOUT)
+        return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         """

{e6data_python_connector-2.3.9rc2 → e6data_python_connector-2.3.9rc4}/e6data_python_connector/e6data_grpc.py

@@ -26,9 +26,6 @@ from e6data_python_connector.constants import *
 from e6data_python_connector.datainputstream import get_query_columns_info, read_rows_from_chunk
 from e6data_python_connector.server import e6x_engine_pb2_grpc, e6x_engine_pb2
 from e6data_python_connector.typeId import *
-from e6data_python_connector.process_safe_manager import get_strategy_manager
-from e6data_python_connector.auto_resume_coordinator import get_resume_coordinator
-from e6data_python_connector.session_manager import get_session_manager
 
 apilevel = '2.0'
 threadsafety = 2  # Threads may share the e6xdb and connections.
@@ -115,70 +112,181 @@ class HiveParamEscaper(ParamEscaper):
 
 _escaper = HiveParamEscaper()
 
-# Initialize global managers
-_strategy_manager = get_strategy_manager()
-_resume_coordinator = get_resume_coordinator()
-_session_manager = get_session_manager()
+# Thread-safe and process-safe storage for active deployment strategy
+_strategy_lock = threading.Lock()
+_strategy_manager = None
+_shared_strategy = None
+_local_strategy_cache = {
+    'active_strategy': None,
+    'last_check_time': 0,
+    'pending_strategy': None,  # Strategy to use for next query
+    'query_strategy_map': {},  # Map of query_id to strategy used
+    'last_transition_time': 0,  # Timestamp of last strategy transition
+    'session_invalidated': False  # Flag to invalidate all sessions
+}
+
+# Strategy cache timeout in seconds (5 minutes)
+STRATEGY_CACHE_TIMEOUT = 300
 
 
 def _get_shared_strategy():
-    """Get shared strategy state (deprecated - use strategy manager directly)."""
-    # For backward compatibility
-    return {
-        'active_strategy': _strategy_manager.get_active_strategy(),
-        'pending_strategy': _strategy_manager.get_pending_strategy(),
-        'session_generation': _strategy_manager.get_session_generation()
-    }
+    """Get or create the shared strategy storage."""
+    global _strategy_manager, _shared_strategy
+
+    # Try to use multiprocessing.Manager for process-safe storage
+    try:
+        if _strategy_manager is None:
+            _strategy_manager = multiprocessing.Manager()
+            _shared_strategy = _strategy_manager.dict()
+            _shared_strategy['active_strategy'] = None
+            _shared_strategy['last_check_time'] = 0
+            _shared_strategy['pending_strategy'] = None
+            _shared_strategy['query_strategy_map'] = _strategy_manager.dict()
+            _shared_strategy['last_transition_time'] = 0
+            _shared_strategy['session_invalidated'] = False
+        return _shared_strategy
+    except:
+        # Fall back to thread-local storage if Manager fails
+        return _local_strategy_cache
 
 
 def _get_active_strategy():
-    """Get the active deployment strategy (blue or green)."""
-    return _strategy_manager.get_active_strategy()
+    """Get the active deployment strategy (blue or green) from shared memory."""
+    with _strategy_lock:
+        shared_strategy = _get_shared_strategy()
+        # current_time = time.time()
+        # Check if strategy is cached and not expired
+        # if (shared_strategy['active_strategy'] is not None and
+        #     current_time - shared_strategy['last_check_time'] < STRATEGY_CACHE_TIMEOUT):
+        if shared_strategy['active_strategy'] is not None:
+            return shared_strategy['active_strategy']
+        return None
 
 
 def _set_active_strategy(strategy):
-    """Set the active deployment strategy."""
-    return _strategy_manager.set_active_strategy(strategy)
+    """Set the active deployment strategy in shared memory."""
+    if not strategy:
+        return
+    # Normalize strategy to lowercase and validate
+    normalized_strategy = strategy.lower()
+    if normalized_strategy not in ['blue', 'green']:
+        return
+
+    with _strategy_lock:
+        shared_strategy = _get_shared_strategy()
+        current_time = time.time()
+
+        # Only update transition time if strategy actually changed
+        if shared_strategy['active_strategy'] != normalized_strategy:
+            shared_strategy['last_transition_time'] = current_time
+
+        shared_strategy['active_strategy'] = normalized_strategy
+        shared_strategy['last_check_time'] = current_time
 
 
 def _clear_strategy_cache():
     """Clear the cached strategy to force re-detection."""
-    return _strategy_manager.clear_strategy_cache()
+    with _strategy_lock:
+        shared_strategy = _get_shared_strategy()
+        shared_strategy['active_strategy'] = None
+        shared_strategy['last_check_time'] = 0
+        shared_strategy['pending_strategy'] = None
 
 
 def _set_pending_strategy(strategy):
     """Set the pending strategy to be used for the next query."""
-    return _strategy_manager.set_pending_strategy(strategy)
+    if not strategy:
+        return
+    # Normalize strategy to lowercase and validate
+    normalized_strategy = strategy.lower()
+    if normalized_strategy not in ['blue', 'green']:
+        return
+
+    with _strategy_lock:
+        shared_strategy = _get_shared_strategy()
+        current_active = shared_strategy['active_strategy']
+
+        if normalized_strategy != current_active:
+            shared_strategy['pending_strategy'] = normalized_strategy
 
 
 def _apply_pending_strategy():
     """Apply the pending strategy as the active strategy."""
-    return _strategy_manager.apply_pending_strategy()
+    with _strategy_lock:
+        shared_strategy = _get_shared_strategy()
+        if shared_strategy['pending_strategy']:
+            old_strategy = shared_strategy['active_strategy']
+            new_strategy = shared_strategy['pending_strategy']
+            current_time = time.time()
+
+            shared_strategy['active_strategy'] = new_strategy
+            shared_strategy['pending_strategy'] = None
+            shared_strategy['last_check_time'] = current_time
+            shared_strategy['last_transition_time'] = current_time
+            shared_strategy['session_invalidated'] = True  # Invalidate all sessions
+
+            return new_strategy
+        return None
 
 
 def _invalidate_all_sessions():
     """Invalidate all existing sessions to force fresh connections with new strategy."""
-    return _strategy_manager.invalidate_all_sessions()
+    # This is a global flag that all connections will check
+    shared_strategy = _get_shared_strategy()
+    shared_strategy['session_invalidated'] = True
 
 
 def _register_query_strategy(query_id, strategy):
     """Register the strategy used for a specific query."""
-    return _strategy_manager.register_query_strategy(query_id, strategy)
+    if not query_id or not strategy:
+        return
+    # Normalize strategy to lowercase and validate
+    normalized_strategy = strategy.lower()
+    if normalized_strategy not in ['blue', 'green']:
+        return
+
+    with _strategy_lock:
+        shared_strategy = _get_shared_strategy()
+        query_map = shared_strategy.get('query_strategy_map', {})
+        query_map[query_id] = normalized_strategy
+        shared_strategy['query_strategy_map'] = query_map
 
 
 def _get_query_strategy(query_id):
     """Get the strategy used for a specific query."""
-    return _strategy_manager.get_query_strategy(query_id)
+    current_active_strategy = _get_active_strategy()
+    if not query_id:
+        return current_active_strategy
+    with _strategy_lock:
+        shared_strategy = _get_shared_strategy()
+        query_map = shared_strategy.get('query_strategy_map', {})
+        return query_map.get(query_id, current_active_strategy)
 
 
 def _cleanup_query_strategy(query_id):
     """Remove the strategy mapping for a completed query."""
-    return _strategy_manager.cleanup_query_strategy(query_id)
+    if not query_id:
+        return
+    with _strategy_lock:
+        shared_strategy = _get_shared_strategy()
+        query_map = shared_strategy.get('query_strategy_map', {})
+        if query_id in query_map:
+            del query_map[query_id]
+            shared_strategy['query_strategy_map'] = query_map
 
 
 def _get_strategy_debug_info():
     """Get debug information about current strategy state."""
-    return _strategy_manager.get_debug_info()
+    with _strategy_lock:
+        shared_strategy = _get_shared_strategy()
+        return {
+            'active_strategy': shared_strategy.get('active_strategy'),
+            'pending_strategy': shared_strategy.get('pending_strategy'),
+            'last_check_time': shared_strategy.get('last_check_time', 0),
+            'last_transition_time': shared_strategy.get('last_transition_time', 0),
+            'query_count': len(shared_strategy.get('query_strategy_map', {})),
+            'current_time': time.time()
+        }
 
 
 def _get_grpc_header(engine_ip=None, cluster=None, strategy=None):
@@ -262,11 +370,6 @@ class Connection(object):
         self._auto_resume = auto_resume
 
         self._grpc_options = grpc_options
-        
-        # Process-safe session management
-        self._connection_id = _session_manager.register_connection(self)
-        self._session_invalidated_externally = False
-        self._last_session_generation = 0
         if self._grpc_options is None:
             self._grpc_options = dict()
         self.grpc_prepare_timeout = self._grpc_options.get('grpc_prepare_timeout') or 10 * 60  # 10 minutes
@@ -277,11 +380,7 @@ class Connection(object):
             """
             self.grpc_auto_resume_timeout_seconds = self._grpc_options.pop('grpc_auto_resume_timeout_seconds')
         self._create_client()
-        """
-        generate a unique bas64 hash for the connection based on the host, port, username, and secure channel.
-        """
-
-        self._hash = str(datetime.datetime.now()) + '_hash'
+        self._hash = str(datetime.datetime.now().timestamp()) + 'hash' + str(id(self))
 
     @property
     def _get_grpc_options(self):
@@ -358,10 +457,6 @@ class Connection(object):
         Raises:
             Exception: If there is an error during the re-authentication process.
         """
-        # Clear current session
-        if hasattr(self, '_connection_id'):
-            _session_manager.invalidate_session(self._connection_id)
-        
         self.close()
         self._create_client()
         return self.get_session_id
@@ -372,114 +467,158 @@ class Connection(object):
         To get the session id, if user is not authorised, first authenticate the user.
         Also detects the active deployment strategy (blue/green) on first authentication.
         """
-        # Check for external session invalidation
-        if self._session_invalidated_externally:
+        # Check if we need a fresh connection due to strategy change
+        shared_strategy = _get_shared_strategy()
+        pending_strategy = shared_strategy.get('pending_strategy')
+        active_strategy = shared_strategy.get('active_strategy')
+        session_invalidated = shared_strategy.get('session_invalidated', False)
+
+        # Check if session was invalidated globally
+        if self._session_id and session_invalidated:
             self._session_id = None
-            self._session_invalidated_externally = False
             self.close()
             self._create_client()
-        
-        # Check session validity through session manager
-        session_info = _session_manager.get_session(self._connection_id)
-        if session_info and session_info.is_valid:
-            self._session_id = session_info.session_id
-            return self._session_id
-        elif self._session_id:
-            # Session exists but is invalid - clear it
-            self._session_id = None
-            _session_manager.remove_session(self._connection_id)
-
-        # Check if we need to apply pending strategy
-        pending_strategy = _strategy_manager.get_pending_strategy()
-        if pending_strategy:
-            applied_strategy = _apply_pending_strategy()
-            if applied_strategy:
-                # Strategy was applied - invalidate session
+            # Clear the invalidation flag
+            shared_strategy['session_invalidated'] = False
+
+        # Only create fresh connection if we have no active queries
+        elif self._session_id and pending_strategy and pending_strategy != active_strategy:
+            query_map = shared_strategy.get('query_strategy_map', {})
+            if len(query_map) == 0:
+                # Apply the pending strategy immediately since no queries are active
+                _apply_pending_strategy()
+                # Force complete reconnection with new strategy
                 self._session_id = None
-                _session_manager.remove_session(self._connection_id)
                 self.close()
                 self._create_client()
 
-        # Authenticate if needed
         if not self._session_id:
             try:
-                session_id = _session_manager.authenticate_with_retry(self)
-                if session_id:
-                    self._session_id = session_id
-                else:
-                    raise ValueError("Authentication failed")
+                authenticate_request = e6x_engine_pb2.AuthenticateRequest(
+                    user=self.__username,
+                    password=self.__password
+                )
+
+                # Check if we have a cached strategy
+                active_strategy = _get_active_strategy()
+                shared_strategy = _get_shared_strategy()
+                pending_strategy = shared_strategy.get('pending_strategy')
+
+                if active_strategy and not pending_strategy:
+                    # Use cached strategy only if there's no pending strategy
+                    try:
+                        authenticate_response = self._client.authenticate(
+                            authenticate_request,
+                            metadata=_get_grpc_header(cluster=self.cluster_name, strategy=active_strategy)
+                        )
+                        self._session_id = authenticate_response.sessionId
+                        if not self._session_id:
+                            raise ValueError("Invalid credentials.")
+                        # Check for new strategy in authenticate response
+                        if hasattr(authenticate_response, 'new_strategy') and authenticate_response.new_strategy:
+                            new_strategy = authenticate_response.new_strategy.lower()
+                            if new_strategy != active_strategy:
+                                _set_pending_strategy(new_strategy)
+                                # Don't apply immediately - let new queries use fresh connections
+                    except _InactiveRpcError as e:
+                        print(self._hash, self.cluster_name, 'Error during authentication with active strategy:', active_strategy, file=sys.stderr)
+                        if e.code() == grpc.StatusCode.UNKNOWN and 'status: 456' in e.details():
+                            # Strategy changed, clear cache and retry
+                            _clear_strategy_cache()
+                            active_strategy = None
+                        else:
+                            raise e
+                elif pending_strategy:
+                    # If there's a pending strategy, force re-authentication with new strategy
+                    active_strategy = None
+
+                if not active_strategy:
+                    # Check if we have a pending strategy to use
+                    if pending_strategy:
+                        # Use pending strategy and apply it immediately
+                        _apply_pending_strategy()
+                        active_strategy = _get_active_strategy()
+                        strategies = [active_strategy]
+                    else:
+                        # Always try blue first, then green if it fails with 456
+                        strategies = ['blue', 'green']
+                    last_error = None
+                    for strategy in strategies:
+                        try:
+                            authenticate_response = self._client.authenticate(
+                                authenticate_request,
+                                metadata=_get_grpc_header(cluster=self.cluster_name, strategy=strategy)
+                            )
+                            self._session_id = authenticate_response.sessionId
+                            if self._session_id:
+                                # Success! Cache this strategy
+                                _set_active_strategy(strategy)
+
+                                # Check for new strategy in authenticate response
+                                if hasattr(authenticate_response,
+                                           'new_strategy') and authenticate_response.new_strategy:
+                                    new_strategy = authenticate_response.new_strategy.lower()
+                                    if new_strategy != strategy:
+                                        _set_pending_strategy(new_strategy)
+                                        # Don't apply immediately - let new queries use fresh connections
+                                break
+                        except _InactiveRpcError as e:
+                            print(self._hash, self.cluster_name, 'Error during authentication with strategy:', strategy, file=sys.stderr)
+                            if e.code() == grpc.StatusCode.UNKNOWN and 'status: 456' in e.details():
+                                # Wrong strategy, try the next one
+                                last_error = e
+                                continue
+                            else:
+                                # Different error, handle it normally
+                                raise e
+
+                    if not self._session_id and last_error:
+                        # Neither strategy worked
+                        raise last_error
+
+                if not self._session_id:
+                    raise ValueError("Invalid credentials.")
             except _InactiveRpcError as e:
-                # Handle 503 errors with auto-resume
-                if (self._auto_resume and 
-                    e.code() == grpc.StatusCode.UNAVAILABLE and 
-                    'status: 503' in e.details()):
-                    
-                    should_resume, reason = _resume_coordinator.should_attempt_resume(
-                        self._host, self._port, self.cluster_name
-                    )
-                    
-                    if should_resume:
-                        if _resume_coordinator.start_resume_attempt(self._host, self._port, self.cluster_name):
-                            try:
-                                success = self._perform_cluster_resume()
-                                _resume_coordinator.complete_resume_attempt(
-                                    self._host, self._port, self.cluster_name, success
-                                )
-                                
-                                if success:
-                                    # Try authentication again after successful resume
-                                    session_id = _session_manager.authenticate_with_retry(self)
-                                    if session_id:
-                                        self._session_id = session_id
-                                    else:
-                                        raise ValueError("Authentication failed even after cluster resume")
-                                else:
-                                    raise ValueError("Cluster resume failed")
-                            except Exception as resume_error:
-                                _resume_coordinator.complete_resume_attempt(
-                                    self._host, self._port, self.cluster_name, False, str(resume_error)
-                                )
-                                raise resume_error
+                if self._auto_resume:
+                    if e.code() == grpc.StatusCode.UNAVAILABLE and 'status: 503' in e.details():
+                        status = ClusterManager(
+                            host=self._host,
+                            port=self._port,
+                            user=self.__username,
+                            password=self.__password,
+                            secure_channel=self._secure_channel,
+                            cluster_uuid=self.cluster_name,
+                            timeout=self.grpc_auto_resume_timeout_seconds
+                        ).resume()
+                        print(self._hash, self.cluster_name, 'Cluster resume status:', status, file=sys.stderr)
+                        if status:
+                            # return self.get_session_id
+                            authenticate_request = e6x_engine_pb2.AuthenticateRequest(
+                                user=self.__username,
+                                password=self.__password
+                            )
+                            authenticate_response = self._client.authenticate(
+                                authenticate_request,
+                                metadata=_get_grpc_header(cluster=self.cluster_name, strategy=_get_active_strategy())
+                            )
+                            self._session_id = authenticate_response.sessionId
+                            # Check for new strategy in authenticate response
+                            if hasattr(authenticate_response, 'new_strategy') and authenticate_response.new_strategy:
+                                new_strategy = authenticate_response.new_strategy.lower()
+                                if new_strategy != _get_active_strategy():
+                                    _set_pending_strategy(new_strategy)
+                                    # Don't apply immediately - let new queries use fresh connections
                         else:
-                            raise ValueError("Cannot attempt resume: another process is handling it")
+                            raise e
                     else:
-                        raise ValueError(f"Cannot resume cluster: {reason}")
+                        raise e
                 else:
                     raise e
-
-        if not self._session_id:
-            raise ValueError("Failed to obtain valid session ID")
-            
+            except Exception as e:
+                print(self._hash, self.cluster_name, 'Error during authentication:', e, file=sys.stderr)
+                self._channel.close()
+                raise e
         return self._session_id
-    
-    def _perform_cluster_resume(self) -> bool:
-        """
-        Perform cluster resume operation.
-        
-        Returns:
-            True if resume was successful, False otherwise
-        """
-        try:
-            print(self._hash, f'Auto resuming cluster {self.cluster_name}...')
-            
-            cluster_manager = ClusterManager(
-                host=self._host,
-                port=self._port,
-                user=self.__username,
-                password=self.__password,
-                secure_channel=self._secure_channel,
-                cluster_uuid=self.cluster_name,
-                timeout=self.grpc_auto_resume_timeout_seconds,
-                grpc_options=self._grpc_options
-            )
-            
-            status = cluster_manager.resume()
-            print(self._hash, f'Cluster {self.cluster_name} resume result: {status}')
-            return status
-            
-        except Exception as e:
-            print(self._hash, f'Cluster resume failed: {e}')
-            return False
 
     def __enter__(self):
         """
@@ -514,10 +653,6 @@ class Connection(object):
         if self._channel is not None:
             self._channel.close()
             self._channel = None
-        
-        # Clean up session tracking
-        if hasattr(self, '_connection_id'):
-            _session_manager.remove_session(self._connection_id)
         self._session_id = None
 
     def check_connection(self):

{e6data_python_connector-2.3.9rc2 → e6data_python_connector-2.3.9rc4/e6data_python_connector.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.3.9rc2
+Version: 2.3.9rc4
 Summary: Client for the e6data distributed SQL Engine.
 Home-page: https://github.com/e6x-labs/e6data-python-connector
 Author: e6data, Inc.
@@ -38,7 +38,7 @@ Dynamic: summary
 
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.3.9rc2-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.9rc4-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.3.9rc2 → e6data_python_connector-2.3.9rc4}/e6data_python_connector.egg-info/SOURCES.txt

@@ -5,7 +5,6 @@ pyproject.toml
 setup.cfg
 setup.py
 e6data_python_connector/__init__.py
-e6data_python_connector/auto_resume_coordinator.py
 e6data_python_connector/cluster_manager.py
 e6data_python_connector/common.py
 e6data_python_connector/constants.py
@@ -14,9 +13,6 @@ e6data_python_connector/date_time_utils.py
 e6data_python_connector/dialect.py
 e6data_python_connector/e6data_grpc.py
 e6data_python_connector/exceptions.py
-e6data_python_connector/process_safe_manager.py
-e6data_python_connector/retry_handler.py
-e6data_python_connector/session_manager.py
 e6data_python_connector/strategy.py
 e6data_python_connector/typeId.py
 e6data_python_connector.egg-info/PKG-INFO

{e6data_python_connector-2.3.9rc2 → e6data_python_connector-2.3.9rc4}/setup.py

@@ -12,7 +12,7 @@
 
 import setuptools
 
-VERSION = (2, 3, 9,'rc2')
+VERSION = (2, 3, 9,'rc4')
 
 
 def get_long_desc():