Update http_storage.py

http_storage.py

@@ -414,113 +414,62 @@ class HTTPGPUStorage:
             logging.error(f"Error during inference for model {model_name}: {str(e)}")
             return None
 
-    def wait_for_connection(self, timeout: float = 30.0) -> bool:
-        """Wait for HTTP connection to be established (compatibility method)"""
-        # For HTTP, we just check if we can make a request
+    def ping(self) -> bool:
+        """Ping the server to check connection status."""
         try:
-            if not self.session_token:
-                return self._create_session()
-            
-            # Test connection with a simple request
-            response = self._make_request('GET', '/cache/connection_test')
-            return response is not None
-            
+            response = self._make_request('GET', '/status')
+            return response and response.get('status') == 'ok'
         except Exception as e:
-            logging.error(f"Connection test failed: {e}")
+            logging.error(f"Ping failed: {e}")
             return False
 
     def is_connected(self) -> bool:
-        """Check if HTTP connection is active (compatibility method)"""
-        return self.session_token is not None and not self._closing
+        """Check if the client is connected to the server."""
+        return self.ping()
 
     def get_connection_status(self) -> Dict[str, Any]:
-        """Get detailed connection status"""
-        return {
-            "connected": self.is_connected(),
-            "closing": self._closing,
-            "error_count": self.error_count,
-            "base_url": self.base_url,
-            "last_error_time": self.last_error_time,
-            "loaded_models": list(self.resource_monitor['loaded_models']),
-            "session_id": self.session_id
-        }
+        """Get detailed connection status."""
+        if self.is_connected():
+            return {"status": "connected", "session_id": self.session_id}
+        else:
+            return {"status": "disconnected", "error_count": self.error_count}
 
-    def set_keep_alive(self, enabled: bool):
-        """Set keep-alive mode (compatibility method for HTTP)"""
-        # HTTP connections are stateless, so this is a no-op
-        pass
+    def set_keep_alive(self, interval: int):
+        """Set keep-alive interval (compatibility method)."""
+        logging.info(f"Keep-alive interval set to {interval} seconds (HTTP client does not use websockets).")
 
     def reconnect(self):
-        """Reconnect to server (recreate session for HTTP)"""
-        self.session_token = None
-        self.session_id = None
-        return self._create_session()
+        """Attempt to reconnect (compatibility method)."""
+        logging.info("Attempting to reconnect HTTP client...")
+        self._create_session()
+
+    def wait_for_connection(self, timeout: float = 30.0) -> bool:
+        """Wait for HTTP connection to be established (compatibility method)"""
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            if self.is_connected():
+                logging.info("HTTP connection established.")
+                return True
+            time.sleep(1) # Wait for 1 second before retrying
+        logging.error("HTTP connection not established within timeout.")
+        return False
 
     def close(self):
         """Close HTTP client"""
         self._closing = True
-        if self.http_session:
-            self.http_session.close()
-
-    # Additional methods for multi-chip coordination
-    def transfer_between_chips(self, src_chip: int, dst_chip: int, data_id: str) -> Optional[str]:
-        """Transfer data between chips via HTTP API"""
-        try:
-            request_data = {"data_id": data_id}
-            
-            response = self._make_request(
-                'POST',
-                f'/chips/{src_chip}/transfer/{dst_chip}',
-                json=request_data
-            )
-            
-            if response and response.get('status') == 'success':
-                return response.get('new_data_id')
-            else:
-                logging.error(f"Chip transfer failed: {response.get('message', 'Unknown error')}")
-                return None
-                
-        except Exception as e:
-            logging.error(f"Error in chip transfer: {str(e)}")
-            return None
-
-    def create_sync_barrier(self, barrier_id: str, num_participants: int) -> bool:
-        """Create synchronization barrier via HTTP API"""
-        try:
-            request_data = {"num_participants": num_participants}
-            
-            response = self._make_request(
-                'POST',
-                f'/sync/barrier/{barrier_id}',
-                json=request_data
-            )
-            
-            return response and response.get('status') == 'success'
-            
-        except Exception as e:
-            logging.error(f"Error creating sync barrier: {str(e)}")
-            return False
-
-    def wait_sync_barrier(self, barrier_id: str) -> bool:
-        """Wait at synchronization barrier via HTTP API"""
-        try:
-            response = self._make_request('PUT', f'/sync/barrier/{barrier_id}/wait')
-            
-            if response:
-                status = response.get('status')
-                if status == 'released':
-                    return True
-                elif status == 'waiting':
-                    # In a real implementation, this might poll or use long-polling
-                    time.sleep(0.1)  # Brief delay before next check
-                    return False
-            
-            return False
-            
-        except Exception as e:
-            logging.error(f"Error waiting at sync barrier: {str(e)}")
-            return False
+        logging.info("HTTP client is closing.")
+        # Invalidate session on server side if possible
+        if self.session_token:
+            try:
+                self.http_session.post(f"{self.api_base}/sessions/invalidate",
+                                       headers={'Authorization': f'Bearer {self.session_token}'},
+                                       timeout=5)
+            except Exception as e:
+                logging.warning(f"Failed to invalidate session on server: {e}")
+        self.http_session.close()
+        HTTPGPUStorage._instance = None # Clear singleton instance
 
 # Compatibility alias for existing code
 WebSocketGPUStorage = HTTPGPUStorage
 
+