service-forge 0.1.11__py3-none-any.whl → 0.1.24__py3-none-any.whl

service_forge/sft/cmd/remote_deploy.py

@@ -0,0 +1,160 @@
+import os
+import json
+import requests
+from pathlib import Path
+from service_forge.sft.util.logger import log_error, log_info, log_success, log_warning
+from service_forge.sft.config.sft_config import sft_config
+
+def remote_deploy_tar(filename: str, service_center_url: str = None) -> None:
+    """
+    Remote deploy specified tar package from service-center
+    """
+    # If URL is not provided, try to get it from configuration
+    if not service_center_url:
+        service_center_url = getattr(sft_config, 'service_center_address', 'http://localhost:5000')
+    
+    # Ensure URL ends with /
+    if not service_center_url.endswith('/'):
+        service_center_url += '/'
+    
+    api_url = f"{service_center_url}api/v1/services/deploy-from-tar"
+    
+    log_info(f"Sending deployment request to {api_url}...")
+    log_info(f"Tar package to deploy: {filename}")
+    
+    try:
+        # Prepare request data
+        data = {
+            "filename": filename
+        }
+        
+        # Send POST request
+        response = requests.post(
+            api_url,
+            json=data,
+            headers={'Content-Type': 'application/json'},
+            timeout=300  # 5 minute timeout
+        )
+        
+        if response.status_code != 200:
+            log_error(f"Deployment request failed, status code: {response.status_code}")
+            try:
+                error_data = response.json()
+                log_error(f"Error message: {error_data.get('message', 'Unknown error')}")
+                if 'data' in error_data and error_data['data']:
+                    log_error(f"Details: {json.dumps(error_data['data'], indent=2, ensure_ascii=False)}")
+            except:
+                log_error(f"Response content: {response.text}")
+            return
+        
+        # Parse response data
+        result = response.json()
+        
+        if result.get('code') != 200:
+            log_error(f"Deployment failed: {result.get('message', 'Unknown error')}")
+            if 'data' in result and result['data']:
+                log_error(f"Details: {json.dumps(result['data'], indent=2, ensure_ascii=False)}")
+            return
+        
+        # Deployment successful
+        data = result.get('data', {})
+        service_name = data.get('service_name', 'Unknown')
+        version = data.get('version', 'Unknown')
+        deploy_output = data.get('deploy_output', '')
+        
+        log_success(f"Successfully deployed service: {service_name} version: {version}")
+        
+        if deploy_output:
+            log_info("Deployment output:")
+            print(deploy_output)
+        
+    except requests.exceptions.Timeout:
+        log_error("Deployment request timed out (exceeded 5 minutes), please check service status or try again later")
+    except requests.exceptions.RequestException as e:
+        log_error(f"Request failed: {str(e)}")
+        log_info(f"Please check if service-center service is running normally and if the URL is correct: {service_center_url}")
+    except Exception as e:
+        log_error(f"Exception occurred while deploying tar package: {str(e)}")
+
+def remote_list_and_deploy(service_center_url: str = None) -> None:
+    """
+    List remote tar packages first, then let user select which package to deploy
+    """
+    # If URL is not provided, try to get it from configuration
+    if not service_center_url:
+        service_center_url = getattr(sft_config, 'service_center_address', 'http://localhost:5000')
+    
+    # Ensure URL ends with /
+    if not service_center_url.endswith('/'):
+        service_center_url += '/'
+    
+    api_url = f"{service_center_url}api/v1/services/tar-list"
+    
+    log_info(f"Getting tar package list from {api_url}...")
+    
+    try:
+        # 发送GET请求获取tar包列表
+        response = requests.get(api_url, timeout=30)
+        
+        if response.status_code != 200:
+            log_error(f"Failed to get tar package list, status code: {response.status_code}")
+            return
+        
+        # Parse response data
+        result = response.json()
+        
+        if result.get('code') != 200:
+            log_error(f"Failed to get tar package list: {result.get('message', 'Unknown error')}")
+            return
+        
+        tar_files = result.get('data', [])
+        
+        if not tar_files:
+            log_info("No tar packages found")
+            return
+        
+        # Display tar package list
+        log_info("Available tar package list:")
+        for i, tar_file in enumerate(tar_files, 1):
+            filename = tar_file.get('filename', '-')
+            service_name = tar_file.get('service_name', '-')
+            version = tar_file.get('version', '-')
+            deployed_status = "Deployed" if tar_file.get('deployed_status', False) else "Not Deployed"
+            
+            print(f"{i}. {filename} (service: {service_name}, version: {version}, status: {deployed_status})")
+        
+        # Let user choose
+        try:
+            choice = input("\nEnter the number of the tar package to deploy (enter 'q' to exit): ").strip()
+            
+            if choice.lower() == 'q':
+                log_info("Deployment cancelled")
+                return
+            
+            index = int(choice) - 1
+            if 0 <= index < len(tar_files):
+                selected_tar = tar_files[index]
+                filename = selected_tar.get('filename')
+                
+                if selected_tar.get('deployed_status', False):
+                    log_warning(f"Tar package {filename} is already deployed, continue deployment?")
+                    confirm = input("Enter 'y' to continue, any other key to cancel: ").strip().lower()
+                    if confirm != 'y':
+                        log_info("Deployment cancelled")
+                        return
+                
+                log_info(f"Selected for deployment: {filename}")
+                remote_deploy_tar(filename, service_center_url)
+            else:
+                log_error("Invalid selection")
+                
+        except ValueError:
+            log_error("Please enter a valid number")
+        except KeyboardInterrupt:
+            log_info("\nDeployment cancelled")
+        
+    except requests.exceptions.RequestException as e:
+        log_error(f"Request failed: {str(e)}")
+        log_info(f"Please check if service-center service is running normally and if the URL is correct: {service_center_url}")
+    except Exception as e:
+        log_error(f"Exception occurred while getting tar package list: {str(e)}")

service_forge/sft/cmd/remote_list_tars.py

@@ -0,0 +1,111 @@
+import os
+import json
+import requests
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+from service_forge.sft.util.logger import log_error, log_info, log_success, log_warning
+from service_forge.sft.config.sft_config import sft_config
+
+def remote_list_tars(service_center_url: str = None) -> None:
+    """
+    Get remote tar package list and status from service-center
+    """
+    # If URL is not provided, try to get it from configuration
+    if not service_center_url:
+        service_center_url = getattr(sft_config, 'service_center_address', 'http://localhost:5000')
+    
+    # Ensure URL ends with /
+    if not service_center_url.endswith('/'):
+        service_center_url += '/'
+    
+    api_url = f"{service_center_url}api/v1/services/tar-list"
+    
+    log_info(f"Getting tar package list from {api_url}...")
+    
+    try:
+        # 发送GET请求
+        response = requests.get(api_url, timeout=30)
+        
+        if response.status_code != 200:
+            log_error(f"Failed to get tar package list, status code: {response.status_code}")
+            try:
+                error_data = response.json()
+                log_error(f"Error message: {error_data.get('message', 'Unknown error')}")
+            except:
+                log_error(f"Response content: {response.text}")
+            return
+        
+        # Parse response data
+        result = response.json()
+        
+        if result.get('code') != 200:
+            log_error(f"Failed to get tar package list: {result.get('message', 'Unknown error')}")
+            return
+        
+        tar_files = result.get('data', [])
+        
+        if not tar_files:
+            log_info("No tar packages found")
+            return
+        
+        # Use rich table to display results
+        console = Console()
+        table = Table(title="Remote Server Tar Package List", show_header=True, header_style="bold magenta")
+        table.add_column("Filename", style="cyan", no_wrap=True)
+        table.add_column("Service Name", style="green", no_wrap=True)
+        table.add_column("Version", style="blue", no_wrap=True)
+        table.add_column("Size", justify="right", style="yellow")
+        table.add_column("Modified Time", style="dim")
+        table.add_column("Deploy Status", justify="center", style="bold")
+        
+        for tar_file in tar_files:
+            # Format file size
+            size = _format_size(tar_file.get('file_size', 0))
+            
+            # Format modification time
+            modified_time = _format_time(tar_file.get('modified_time', 0))
+            
+            # Deployment status
+            deployed_status = "✅ Deployed" if tar_file.get('deployed_status', False) else "❌ Not Deployed"
+            status_style = "green" if tar_file.get('deployed_status', False) else "red"
+            
+            table.add_row(
+                tar_file.get('filename', '-'),
+                tar_file.get('service_name', '-'),
+                tar_file.get('version', '-'),
+                size,
+                modified_time,
+                f"[{status_style}]{deployed_status}[/{status_style}]"
+            )
+        
+        console.print(table)
+        log_success(f"Found {len(tar_files)} tar packages in total")
+        
+    except requests.exceptions.RequestException as e:
+        log_error(f"Request failed: {str(e)}")
+        log_info(f"Please check if service-center service is running normally and if the URL is correct: {service_center_url}")
+    except Exception as e:
+        log_error(f"Exception occurred while getting tar package list: {str(e)}")
+
+def _format_size(size_bytes: int) -> str:
+    """Format file size"""
+    if size_bytes == 0:
+        return "0 B"
+    
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.2f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.2f} TB"
+
+def _format_time(timestamp: float) -> str:
+    """Format timestamp"""
+    if timestamp == 0:
+        return "-"
+    
+    try:
+        from datetime import datetime
+        return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")
+    except:
+        return "-"

service_forge/sft/config/injector.py

@@ -1,10 +1,10 @@
-from omegaconf import OmegaConf
+import yaml
 from pathlib import Path
 from service_forge.sft.util.logger import log_info, log_error
 from service_forge.sft.config.injector_default_files import *
 from service_forge.sft.config.sf_metadata import load_metadata
 from service_forge.sft.config.sft_config import sft_config
-from service_forge.service_config import ServiceConfig
+from service_forge.service_config import ServiceConfig, ServiceFeedbackConfig
 from service_forge.sft.util.name_util import get_service_name
 from service_forge.sft.util.yaml_utils import load_sf_metadata_as_string
 
@@ -16,6 +16,7 @@ class Injector:
         self.ingress_yaml_path = project_dir / "ingress.yaml"
         self.dockerfile_path = project_dir / "Dockerfile"
         self.pyproject_toml_path = project_dir / "pyproject.toml"
+        self.start_sh_path = project_dir / "start.sh"
         self.metadata = load_metadata(self.metadata_path)
         self.name = self.metadata.name
         self.version = self.metadata.version
@@ -60,31 +61,41 @@ class Injector:
 
     def inject_service_config(self) -> None:
         service_config_path = self.project_dir / Path(self.metadata.service_config)
-        config = ServiceConfig.from_dict(OmegaConf.to_object(OmegaConf.load(self.project_dir / self.metadata.service_config)))
+
+        config = ServiceConfig.from_yaml_file(service_config_path)
 
         config.http_port = sft_config.inject_http_port
         config.kafka_host = sft_config.inject_kafka_host
         config.kafka_port = sft_config.inject_kafka_port
-        for database in config.databases:
-            if database.postgres_host is not None:
-                database.postgres_host = sft_config.inject_postgres_host
-                database.postgres_port = sft_config.inject_postgres_port
-                database.postgres_user = sft_config.inject_postgres_user
-                database.postgres_password = sft_config.inject_postgres_password
-                database.postgres_db = self.service_name
-            if database.mongo_host is not None:
-                database.mongo_host = sft_config.inject_mongo_host
-                database.mongo_port = sft_config.inject_mongo_port
-                database.mongo_user = sft_config.inject_mongo_user
-                database.mongo_password = sft_config.inject_mongo_password
-                database.mongo_db = sft_config.inject_mongo_db
-            if database.redis_host is not None:
-                database.redis_host = sft_config.inject_redis_host
-                database.redis_port = sft_config.inject_redis_port
-                database.redis_password = sft_config.inject_redis_password
-
-        with open(service_config_path, "w") as f:
-            f.write(OmegaConf.to_yaml(config.to_dict()))
+        if config.databases is not None:
+            for database in config.databases:
+                if database.postgres_host is not None:
+                    database.postgres_host = sft_config.inject_postgres_host
+                    database.postgres_port = sft_config.inject_postgres_port
+                    database.postgres_user = sft_config.inject_postgres_user
+                    database.postgres_password = sft_config.inject_postgres_password
+                    database.postgres_db = self.service_name
+                if database.mongo_host is not None:
+                    database.mongo_host = sft_config.inject_mongo_host
+                    database.mongo_port = sft_config.inject_mongo_port
+                    database.mongo_user = sft_config.inject_mongo_user
+                    database.mongo_password = sft_config.inject_mongo_password
+                    database.mongo_db = sft_config.inject_mongo_db
+                if database.redis_host is not None:
+                    database.redis_host = sft_config.inject_redis_host
+                    database.redis_port = sft_config.inject_redis_port
+                    database.redis_password = sft_config.inject_redis_password
+        if config.feedback is not None:
+            config.feedback.api_url = sft_config.inject_feedback_api_url
+            config.feedback.api_timeout = sft_config.inject_feedback_api_timeout
+        else:
+            config.feedback = ServiceFeedbackConfig(
+                api_url=sft_config.inject_feedback_api_url,
+                api_timeout=sft_config.inject_feedback_api_timeout,
+            )
+
+        with open(service_config_path, "w", encoding="utf-8") as f:
+            yaml.dump(config.model_dump(), f, allow_unicode=True, indent=2)
 
     def inject_ingress(self) -> None:
         ingress_yaml = DEFAULT_TRAEFIK_INGRESS_YAML.format(
@@ -111,9 +122,20 @@ class Injector:
                 f.write(pyproject_toml)
         print("pyproject_toml_path: ", self.pyproject_toml_path)
 
+    def clear_start_sh(self) -> None:
+        if Path(self.start_sh_path).exists():
+            with open(self.start_sh_path, "rb") as f:
+                content = f.read()
+            content_str = content.decode("utf-8")
+            lines = content_str.splitlines()
+            new_content = "\n".join(lines) + ("\n" if content_str.endswith(('\n', '\r')) else "")
+            with open(self.start_sh_path, "w", encoding="utf-8", newline="\n") as f:
+                f.write(new_content)
+
     def inject(self) -> None:
         self.inject_deployment()
         self.inject_service_config()
         self.inject_ingress()
         self.inject_dockerfile()
-        self.inject_pyproject_toml()
+        self.inject_pyproject_toml()
+        self.clear_start_sh()

service_forge/sft/config/injector_default_files.py

@@ -128,4 +128,4 @@ DEFAULT_PYPROJECT_TOML = """
 
 [tool.uv.sources]
 service-forge = { workspace = true }
-"""
+"""

service_forge/sft/config/sft_config.py

@@ -21,6 +21,8 @@ class SftConfig:
         "inject_postgres_port": "Postgres port for services",
         "inject_postgres_user": "Postgres user for services",
         "inject_postgres_password": "Postgres password for services",
+        "inject_feedback_api_url": "Feedback API URL for services",
+        "inject_feedback_api_timeout": "Feedback API timeout for services",
         "deepseek_api_key": "DeepSeek API key",
         "deepseek_base_url": "DeepSeek base URL",
     }
@@ -52,6 +54,9 @@ class SftConfig:
         inject_redis_port: int = 6379,
         inject_redis_password: str = "rDdM2Y2gX9",
 
+        inject_feedback_api_url: str = "http://vps.shiweinan.com:37919/api/v1/feedback",
+        inject_feedback_api_timeout: int = 5,
+
         deepseek_api_key: str = "82c9df22-f6ed-411e-90d7-c5255376b7ca",
         deepseek_base_url: str = "https://ark.cn-beijing.volces.com/api/v3",
     ):
@@ -80,6 +85,9 @@ class SftConfig:
         self.inject_redis_port = inject_redis_port
         self.inject_redis_password = inject_redis_password
 
+        self.inject_feedback_api_url = inject_feedback_api_url
+        self.inject_feedback_api_timeout = inject_feedback_api_timeout
+
         self.deepseek_api_key = deepseek_api_key
         self.deepseek_base_url = deepseek_base_url
 
@@ -91,10 +99,23 @@ class SftConfig:
     def upload_timeout(self) -> int:
         return 300  # 5 minutes default timeout
 
-    @classmethod
-    def get_config_keys(cls) -> list[str]:
-        sig = inspect.signature(cls.__init__)
-        return [param for param in sig.parameters.keys() if param != 'self']
+    def get_config_keys(self) -> list[str]:
+        # Get initial configuration parameters from __init__ method
+        sig = inspect.signature(self.__class__.__init__)
+        init_keys = [param for param in sig.parameters.keys() if param != 'self']
+        
+        # Get all instance attributes (including dynamically added configurations)
+        instance_keys = []
+        for attr_name in dir(self):
+            # Exclude special methods, private attributes, class attributes, and methods
+            if (not attr_name.startswith('_') and
+                not callable(getattr(self, attr_name)) and
+                attr_name not in ['CONFIG_ROOT', 'CONFIG_DESCRIPTIONS']):
+                instance_keys.append(attr_name)
+        
+        # Merge and deduplicate, maintaining order (initial configs first, then dynamically added)
+        all_keys = list(dict.fromkeys(init_keys + instance_keys))
+        return all_keys
     
     @property
     def config_file_path(self) -> Path:
@@ -105,13 +126,30 @@ class SftConfig:
     
     def to_dict(self) -> dict:
         config_keys = self.get_config_keys()
-        return {key: getattr(self, key) for key in config_keys}
+        result = {}
+        for key in config_keys:
+            value = getattr(self, key)
+            # Convert Path objects to strings for JSON serialization
+            if isinstance(value, Path):
+                value = str(value)
+            result[key] = value
+        return result
     
     def from_dict(self, data: dict) -> None:
-        config_keys = self.get_config_keys()
-        for key in config_keys:
+        # Get initial configuration parameters from __init__ method
+        sig = inspect.signature(self.__class__.__init__)
+        init_keys = [param for param in sig.parameters.keys() if param != 'self']
+        
+        # First, set all initial configuration parameters
+        for key in init_keys:
             if key in data:
                 setattr(self, key, data[key])
+        
+        # Then, handle any additional keys that might be dynamically added configurations
+        for key, value in data.items():
+            if key not in init_keys and key not in ['CONFIG_ROOT', 'CONFIG_DESCRIPTIONS']:
+                # This might be a dynamically added configuration
+                setattr(self, key, value)
     
     def save(self) -> None:
         self.ensure_config_dir()
@@ -121,13 +159,22 @@ class SftConfig:
     def get(self, key: str, default: Optional[str] = None) -> Optional[str]:
         return getattr(self, key, default)
     
-    def set(self, key: str, value: str) -> None:
+    def set(self, key: str, value: str, description: Optional[str] = None) -> None:
         if key in ["config_root"]:
             raise ValueError(f"{key} is read-only")
         if hasattr(self, key):
             setattr(self, key, value)
+            if description:
+                self.CONFIG_DESCRIPTIONS[key] = description
         else:
             raise ValueError(f"Unknown config key: {key}")
+        
+    def add(self, key: str, value: str, description: Optional[str] = None) -> None:
+        if hasattr(self, key):
+            raise ValueError(f"{key} already exists")
+        setattr(self, key, value)
+        if description:
+            self.CONFIG_DESCRIPTIONS[key] = description
     
     def update(self, updates: dict) -> None:
         for key, value in updates.items():

service_forge/storage/__init__.py

@@ -0,0 +1,5 @@
+"""Storage layer for business logic."""
+
+from .feedback_storage import FeedbackStorage, feedback_storage
+
+__all__ = ["FeedbackStorage", "feedback_storage"]