Update http_storage.py

http_storage.py

@@ -118,6 +118,7 @@ class HTTPGPUStorage:
             return {"status": "error", "message": "HTTP client is closing"}
         
         url = f"{self.api_base}{endpoint}"
+        timeout = kwargs.pop('timeout', 30)  # Allow timeout override, default 30s
         
         try:
             # Ensure we have a valid session
@@ -125,28 +126,46 @@ class HTTPGPUStorage:
                 if not self._create_session():
                     return {"status": "error", "message": "Failed to create session"}
             
-            response = self.http_session.request(method, url, timeout=30, **kwargs)
-            
-            # Handle authentication errors by recreating session
-            if response.status_code == 401:
-                logging.warning("Session expired, recreating...")
-                if self._create_session():
-                    response = self.http_session.request(method, url, timeout=30, **kwargs)
-                else:
-                    return {"status": "error", "message": "Failed to recreate session"}
-            
-            response.raise_for_status()
-            
-            # Reset error count on successful request
-            self.error_count = 0
-            
-            return response.json()
-            
-        except requests.exceptions.RequestException as e:
-            self.error_count += 1
-            self.last_error_time = time.time()
-            logging.error(f"HTTP request failed: {e}")
-            return {"status": "error", "message": f"HTTP request failed: {str(e)}"}
+            # Add timeout to kwargs if not present
+            if 'timeout' not in kwargs:
+                kwargs['timeout'] = timeout
+                
+            try:
+                response = self.http_session.request(method, url, **kwargs)
+                
+                # Handle authentication errors by recreating session
+                if response.status_code == 401:
+                    logging.warning("Session expired, recreating...")
+                    if self._create_session():
+                        response = self.http_session.request(method, url, **kwargs)
+                    else:
+                        return {"status": "error", "message": "Failed to recreate session"}
+                
+                response.raise_for_status()
+                
+                # Reset error count on successful request
+                self.error_count = 0
+                
+                return response.json()
+                
+            except requests.exceptions.Timeout:
+                self.error_count += 1
+                self.last_error_time = time.time()
+                logging.error(f"Request timed out after {timeout}s: {url}")
+                return {"status": "error", "message": "Request timed out"}
+                
+            except requests.exceptions.ConnectionError:
+                self.error_count += 1
+                self.last_error_time = time.time()
+                logging.error(f"Connection failed: {url}")
+                return {"status": "error", "message": "HTTP connection unresponsive"}
+                
+            except requests.exceptions.RequestException as e:
+                self.error_count += 1
+                self.last_error_time = time.time()
+                logging.error(f"HTTP request failed: {e}")
+                return {"status": "error", "message": f"HTTP request failed: {str(e)}"}
+                
         except Exception as e:
             self.error_count += 1
             self.last_error_time = time.time()
@@ -318,7 +337,13 @@ class HTTPGPUStorage:
     def is_model_loaded(self, model_name: str) -> bool:
         """Check if a model is loaded via HTTP API"""
         try:
-            response = self._make_request("GET", f"/models/{model_name}/status")
+            import urllib.parse
+            encoded_name = urllib.parse.quote(model_name, safe='')
+            response = self._make_request(
+                "GET", 
+                f"/models/{encoded_name}/status",
+                timeout=60
+            )
             
             if response and response.get('status') == 'loaded':
                 return True
@@ -334,18 +359,22 @@ class HTTPGPUStorage:
         retry_delay = 2
         last_error = None
         
+        # URL encode model name for safety
+        import urllib.parse
+        encoded_name = urllib.parse.quote(model_name, safe='')
+        
         for attempt in range(max_retries):
             try:
-                # Ensure connection is active
-                if self._closing:
+                # Ensure connection is active and create new session if needed
+                if self._closing or not self.session_token:
                     self._closing = False
                     if not self._create_session():
-                        raise ConnectionError("Failed to recreate session")
-
-                # Check if model is already loaded
-                if self.is_model_loaded(model_name):
-                    logging.info(f"Model {model_name} already loaded")
-                    return True
+                        last_error = "Failed to create session"
+                        logging.error(f"Load attempt {attempt + 1} failed: {last_error}")
+                        if attempt < max_retries - 1:
+                            time.sleep(retry_delay * (1.5 ** attempt))
+                            continue
+                        break
 
                 # Calculate model hash if path provided
                 model_hash = None
@@ -360,9 +389,9 @@ class HTTPGPUStorage:
 
                 response = self._make_request(
                     'POST',
-                    f'/models/{model_name}/load',
+                    f'/models/{encoded_name}/load',
                     json=request_data,
-                    timeout=22020  # Increased timeout for model loading
+                    timeout=300  # 5 minutes timeout for model loading
                 )
 
                 if response and response.get('status') == 'success':