service-forge 0.1.18__py3-none-any.whl

service_forge/sft/file/ignore_pattern.py

@@ -0,0 +1,80 @@
+import fnmatch
+import re
+from pathlib import Path
+from typing import List
+
+
+class IgnorePattern:
+    def __init__(self, patterns: List[str], base_path: Path):
+        self.base_path = base_path.resolve()
+        self.patterns: List[tuple[str, bool]] = []
+        
+        for pattern in patterns:
+            pattern = pattern.strip()
+            if not pattern or pattern.startswith('#'):
+                continue
+            
+            is_negation = pattern.startswith('!')
+            if is_negation:
+                pattern = pattern[1:].strip()
+            
+            pattern = pattern.replace('\\', '/')
+            
+            if pattern.startswith('/'):
+                pattern = pattern[1:]
+            
+            self.patterns.append((pattern, is_negation))
+    
+    def should_ignore(self, file_path: Path) -> bool:
+        file_path = file_path.resolve()
+        
+        try:
+            relative_path = file_path.relative_to(self.base_path)
+        except ValueError:
+            return False
+        
+        path_str = str(relative_path).replace('\\', '/')
+        
+        ignored = False
+        for pattern, is_negation in self.patterns:
+            if self._match_pattern(pattern, path_str, file_path):
+                if is_negation:
+                    ignored = False
+                else:
+                    ignored = True
+        
+        return ignored
+    
+    def _match_pattern(self, pattern: str, path_str: str, file_path: Path) -> bool:
+        if pattern.endswith('/'):
+            pattern = pattern[:-1]
+            if not file_path.is_dir():
+                return False
+        
+        if '**' in pattern:
+            regex_pattern = pattern.replace('**', '.*')
+            regex_pattern = fnmatch.translate(regex_pattern)
+            return bool(re.match(regex_pattern, path_str))
+        
+        path_parts = path_str.split('/')
+        
+        if '/' in pattern:
+            return fnmatch.fnmatch(path_str, pattern)
+        
+        return any(fnmatch.fnmatch(part, pattern) for part in path_parts)
+
+
+def load_ignore_patterns(project_path: Path) -> IgnorePattern:
+    project_path = project_path.resolve()
+    ignore_file = project_path / '.sftignore'
+    
+    if not ignore_file.exists():
+        return IgnorePattern([], project_path)
+    
+    try:
+        with open(ignore_file, 'r', encoding='utf-8') as f:
+            patterns = f.readlines()
+        return IgnorePattern(patterns, project_path)
+    except Exception:
+        return IgnorePattern([], project_path)
+

service_forge/sft/file/sft_file_manager.py

@@ -0,0 +1,107 @@
+import os
+import tarfile
+from pathlib import Path
+import requests
+
+from service_forge.sft.file.ignore_pattern import load_ignore_patterns
+from service_forge.sft.config.sft_config import sft_config
+from service_forge.sft.util.logger import log_success, log_info, log_error
+
+class SftTarFile:
+    # example: sf_tag_service_0.0.1.tar
+    def __init__(self, path: Path):
+        self.path = path
+        self.name = path.name
+        self.size = path.stat().st_size
+        self.modified_time = path.stat().st_mtime
+        self.project_name = '_'.join(path.name.split('_')[1:-1])
+        self.version = path.name.split('_')[-1][:-4]
+
+    def _format_size(self) -> str:
+        for unit in ['B', 'KB', 'MB', 'GB']:
+            if self.size < 1024.0:
+                return f"{self.size:.2f} {unit}"
+            self.size /= 1024.0
+        return f"{self.size:.2f} TB"
+
+    def _format_modified_time(self) -> str:
+        from datetime import datetime
+        return datetime.fromtimestamp(self.modified_time).strftime("%Y-%m-%d %H:%M:%S")
+
+    @staticmethod
+    def is_valid_path(path: Path) -> bool:
+        return path.is_file() and path.suffix == '.tar' and path.name.startswith('sf_')
+
+
+class SftFileManager:
+    def __init__(self):
+        self.tar_path = Path(sft_config.sft_file_root) / "service-tar"
+        self.tars: list[SftTarFile] = []
+        os.makedirs(self.tar_path, exist_ok=True)
+        self.load_tars()
+
+    def create_tar(self, project_path: Path, name: str, version: str) -> Path:
+        project_path = Path(project_path).resolve()
+        tar_path = Path(self.tar_path) / f"sf_{name}_{version}.tar"
+        
+        ignore_pattern = load_ignore_patterns(project_path)
+        
+        with tarfile.open(tar_path, 'w') as tar:
+            for root, dirs, files in os.walk(project_path):
+                root_path = Path(root)
+                
+                dirs[:] = [
+                    d for d in dirs 
+                    if not ignore_pattern.should_ignore(root_path / d)
+                ]
+                
+                for file in files:
+                    file_path = root_path / file
+                    if ignore_pattern.should_ignore(file_path):
+                        continue
+                    
+                    arcname = file_path.relative_to(project_path)
+                    tar.add(file_path, arcname=Path(f"{name}_{version}") / arcname)
+        self.load_tars()
+        return tar_path
+
+    def load_tars(self) -> list[SftTarFile]:
+        self.tars = [SftTarFile(p) for p in self.tar_path.iterdir() if SftTarFile.is_valid_path(p)]
+        return self.tars
+    
+    def upload_tar(self, tar_path: Path) -> None:
+        if not tar_path.exists():
+            raise FileNotFoundError(f"File not found: {tar_path}")
+        
+        upload_url = f"{sft_config.server_url}/api/v1/services/upload-tar"
+        
+        try:
+            with open(tar_path, 'rb') as file:
+                files = {'file': (tar_path.name, file)}
+                
+                response = requests.post(
+                    upload_url,
+                    files=files,
+                    timeout=sft_config.upload_timeout
+                )
+                
+                if response.status_code == 200:
+                    result = response.json()
+                    if result.get('code') == 200:
+                        log_success(f"Upload successful: {result.get('message')}")
+                        log_info(f"File saved path: {result.get('data', {}).get('file_path')}")
+                    else:
+                        raise Exception(f"Upload failed: {result.get('message')}")
+                else:
+                    try:
+                        error_detail = response.json()
+                        error_message = error_detail.get('message', f"HTTP错误: {response.status_code}")
+                        if 'debug' in error_detail and error_detail['debug']:
+                            log_error(f"Error details: {error_detail['debug']}")
+                        raise Exception(error_message)
+                    except ValueError:
+                        raise Exception(f"Server returned error status code: {response.status_code}")
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Upload request failed: {str(e)}")
+
+sft_file_manager = SftFileManager()

service_forge/sft/kubernetes/kubernetes_manager.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+from kubernetes.utils.create_from_yaml import FailToCreateError
+import threading
+from pathlib import Path
+import yaml
+from kubernetes import client, config, utils
+from kubernetes.client.rest import ApiException
+from kubernetes.dynamic import DynamicClient
+from kubernetes.dynamic.exceptions import NotFoundError
+from service_forge.sft.util.logger import log_error, log_info, log_success, log_warning
+
+class KubernetesServiceDetails:
+    def __init__(self, name: str, type: str | None = None, port: int | None = None, target_port: int | None = None):
+        self.name = name
+        self.type = type
+        self.port = port
+        self.target_port = target_port
+
+class KubernetesManager:
+    _instance_lock = threading.Lock()
+
+    def __init__(self):
+        try:
+            config.load_incluster_config()
+            # 使用InCluster配置创建DynamicClient
+            self.dynamic_client = DynamicClient(client.ApiClient())
+        except config.ConfigException:
+            config.load_kube_config()
+            # 如果InCluster配置失败，使用kubeconfig文件创建DynamicClient
+            self.dynamic_client = DynamicClient(config.new_client_from_config())
+
+        self.k8s_client = client.CoreV1Api()
+        self.k8s_apps_client = client.AppsV1Api()
+        self.k8s_batch_client = client.BatchV1Api()
+        self.k8s_rbac_client = client.RbacAuthorizationV1Api()
+        self.k8s_networking_client = client.NetworkingV1Api()
+        self.k8s_apiextensions_client = client.ApiextensionsV1Api()
+
+        self.api_mapping = {
+            "v1": self.k8s_client,
+            "apps/v1": self.k8s_apps_client,
+            "batch/v1": self.k8s_batch_client,
+            "rbac.authorization.k8s.io/v1": self.k8s_rbac_client,
+            "networking.k8s.io/v1": self.k8s_networking_client,
+            "apiextensions.k8s.io/v1": self.k8s_apiextensions_client,
+        }
+
+    def __new__(cls) -> KubernetesManager:
+        if not hasattr(cls, '_instance'):
+            with KubernetesManager._instance_lock:
+                if not hasattr(cls, '_instance'):
+                    KubernetesManager._instance = super().__new__(cls)
+        return KubernetesManager._instance
+
+    def get_services_in_namespace(self, namespace: str) -> list[str]:
+        try:
+            services = self.k8s_client.list_namespaced_service(namespace=namespace)
+            return [svc.metadata.name for svc in services.items if svc.metadata.name.startswith("sf-")]
+        except ApiException as e:
+            log_error(f"Failed to get services: {e.reason}")
+            return []
+        except Exception as e:
+            log_error(f"Failed to get services: {e}")
+            return []
+
+    def get_service_details(self, namespace: str, service_name: str) -> KubernetesServiceDetails:
+        try:
+            service = self.k8s_client.read_namespaced_service(name=service_name, namespace=namespace)
+            return KubernetesServiceDetails(
+                name=service.metadata.name,
+                type=service.spec.type,
+                port=service.spec.ports[0].port,
+                target_port=service.spec.ports[0].target_port
+            )
+        except ApiException as e:
+            log_error(f"Failed to get service details: {e.reason}")
+            return KubernetesServiceDetails(name=service_name)
+        except Exception as e:
+            log_error(f"Failed to get service details: {e}")
+            return KubernetesServiceDetails(name=service_name)
+
+    def get_pods_for_service(self, namespace: str, service_name: str) -> list[str]:
+        try:
+            service = self.k8s_client.read_namespaced_service(name=service_name, namespace=namespace)
+            selector = service.spec.selector
+            if not selector:
+                log_error(f"Service '{service_name}' has no selector")
+                return []
+            label_selector = ",".join([f"{k}={v}" for k, v in selector.items()])
+            pods = self.k8s_client.list_namespaced_pod(namespace=namespace, label_selector=label_selector)
+            return [pod.metadata.name for pod in pods.items]
+        except ApiException as e:
+            log_error(f"Failed to get pods for service: {e.reason}")
+            return []
+        except Exception as e:
+            log_error(f"Failed to get pods for service: {e}")
+            return []
+
+    def get_pod_containers(self, namespace: str, pod_name: str) -> list[str]:
+        try:
+            pod = self.k8s_client.read_namespaced_pod(name=pod_name, namespace=namespace)
+            containers = []
+            if pod.spec.containers:
+                containers.extend([c.name for c in pod.spec.containers])
+            if pod.spec.init_containers:
+                containers.extend([c.name for c in pod.spec.init_containers])
+            return containers
+        except ApiException as e:
+            log_error(f"Failed to get pod containers: {e.reason}")
+            return []
+        except Exception as e:
+            log_error(f"Failed to get pod containers: {e}")
+            return []
+
+    def get_pod_logs(self, namespace: str, pod_name: str, container_name: str, tail: int, follow: bool, previous: bool) -> str:
+        try:
+            logs = self.k8s_client.read_namespaced_pod_log(
+                name=pod_name,
+                namespace=namespace,
+                container=container_name,
+                tail_lines=tail if not follow else None,
+                previous=previous,
+                follow=follow,
+                _preload_content=not follow
+            )
+            return logs
+        except ApiException as e:
+            log_error(f"Failed to get pod logs: {e.reason}")
+            return ""
+        except Exception as e:
+            log_error(f"Failed to get pod logs: {e}")
+
+    def apply_dynamic_yaml(self, obj: dict, namespace: str) -> None:
+        api_version = obj["apiVersion"]
+        kind = obj["kind"]
+        metadata = obj["metadata"]
+        name = metadata["name"]
+
+        resource = self.dynamic_client.resources.get(api_version=api_version, kind=kind)
+
+        try:
+            resource.get(name=name, namespace=namespace)
+            print(f"{kind}/{name} exists → patching...")
+            resource.patch(name=name, namespace=namespace, body=obj, content_type="application/merge-patch+json")
+
+        except NotFoundError:
+            print(f"{kind}/{name} not found → creating...")
+            resource.create(body=obj, namespace=namespace)
+
+
+    def apply_deployment_yaml(self, deployment_yaml: Path, namespace: str) -> None:
+        with open(deployment_yaml, 'r') as f:
+            objs = yaml.safe_load_all(f)
+            for obj in objs:
+                api_version = obj["apiVersion"]
+                kind = obj["kind"]
+                metadata = obj["metadata"]
+
+                name = metadata["name"]
+
+                api_client = self.api_mapping.get(api_version)
+                if not api_client:
+                    self.apply_dynamic_yaml(obj, namespace)
+                    continue
+
+                read_fn = getattr(api_client, f"read_namespaced_{kind.lower()}", None)
+                create_fn = getattr(api_client, f"create_namespaced_{kind.lower()}", None)
+                patch_fn = getattr(api_client, f"patch_namespaced_{kind.lower()}", None)
+
+                if not read_fn:
+                    raise Exception(f"Unsupported resource type: {kind}")
+
+                try:
+                    read_fn(name=name, namespace=namespace)
+                    print(f"{kind}/{name} exists → patching...")
+                    patch_fn(name=name, namespace=namespace, body=obj)
+
+                except ApiException as e:
+                    if e.status == 404:
+                        print(f"{kind}/{name} not found → creating...")
+                        create_fn(namespace=namespace, body=obj)
+                    else:
+                        raise
+
+    def delete_service(self, namespace: str, service_name: str, force: bool = False) -> None:
+        delete_options = client.V1DeleteOptions()
+        if force:
+            delete_options.grace_period_seconds = 0
+            delete_options.propagation_policy = "Background"
+        
+        # Delete deployment
+        try:
+            log_info(f"Attempting to delete deployment '{service_name}'...")
+            self.k8s_apps_client.delete_namespaced_deployment(
+                name=service_name,
+                namespace=namespace,
+                body=delete_options
+            )
+            log_success(f"Deployment '{service_name}' deleted successfully")
+        except ApiException as e:
+            if e.status == 404:
+                log_warning(f"Deployment '{service_name}' not found, skipping...")
+            else:
+                log_warning(f"Failed to delete deployment '{service_name}': {e.reason}")
+                log_warning("Continuing with service deletion...")
+        except Exception as e:
+            log_warning(f"Failed to delete deployment '{service_name}': {e}")
+            log_warning("Continuing with service deletion...")
+        
+        # Delete service
+        try:
+            log_info(f"Attempting to delete service '{service_name}'...")
+            self.k8s_client.delete_namespaced_service(
+                name=service_name,
+                namespace=namespace,
+                body=delete_options
+            )
+            log_success(f"Service '{service_name}' deleted successfully")
+        except ApiException as e:
+            if e.status == 404:
+                log_warning(f"Service '{service_name}' not found, skipping...")
+            else:
+                log_error(f"Failed to delete service '{service_name}': {e.reason}")
+                if e.body:
+                    log_error(f"Error details: {e.body}")
+        except Exception as e:
+            log_error(f"Failed to delete service '{service_name}': {e}")
+        
+        # Delete IngressRoute (Traefik CRD)
+        try:
+            log_info(f"Attempting to delete IngressRoute '{service_name}'...")
+            ingressroute_resource = self.dynamic_client.resources.get(
+                api_version="traefik.io/v1alpha1",
+                kind="IngressRoute"
+            )
+            ingressroute_resource.delete(name=service_name, namespace=namespace)
+            log_success(f"IngressRoute '{service_name}' deleted successfully")
+        except NotFoundError:
+            log_warning(f"IngressRoute '{service_name}' not found, skipping...")
+        except Exception as e:
+            log_warning(f"Failed to delete IngressRoute '{service_name}': {e}")
+        
+        # Delete Middleware (Traefik CRD)
+        middleware_name = f"strip-prefix-{service_name}"
+        try:
+            log_info(f"Attempting to delete Middleware '{middleware_name}'...")
+            middleware_resource = self.dynamic_client.resources.get(
+                api_version="traefik.io/v1alpha1",
+                kind="Middleware"
+            )
+            middleware_resource.delete(name=middleware_name, namespace=namespace)
+            log_success(f"Middleware '{middleware_name}' deleted successfully")
+        except NotFoundError:
+            log_warning(f"Middleware '{middleware_name}' not found, skipping...")
+        except Exception as e:
+            log_warning(f"Failed to delete Middleware '{middleware_name}': {e}")
+        

service_forge/sft/util/assert_util.py

@@ -0,0 +1,25 @@
+import typer
+from pathlib import Path
+from typing import Callable, TypeVar, Any
+from service_forge.sft.util.logger import log_error, log_info
+from service_forge.sft.config.sf_metadata import load_metadata, SfMetadata
+
+T = TypeVar('T')
+
+def assert_dir_exists(path: Path) -> None:
+    if not path.exists():
+        log_error(f"Directory does not exist: {path}")
+        raise typer.Exit(1)
+    if not path.is_dir():
+        log_error(f"Path is not a directory: {path}")
+        raise typer.Exit(1)
+    log_info(f"Directory exists: {path}")
+
+def assert_file_exists(path: Path) -> None:
+    if not path.exists():
+        log_error(f"File does not exist: {path}")
+        raise typer.Exit(1)
+    if not path.is_file():
+        log_error(f"Path is not a file: {path}")
+        raise typer.Exit(1)
+    log_info(f"File exists: {path}")

service_forge/sft/util/logger.py

@@ -0,0 +1,16 @@
+from rich.console import Console
+from typing import Any
+
+console = Console()
+
+def log_error(message: str, **kwargs: Any) -> None:
+    console.print(f"[red]{message}[/red]", **kwargs)
+
+def log_info(message: str, **kwargs: Any) -> None:
+    console.print(f"{message}", **kwargs)
+
+def log_success(message: str, **kwargs: Any) -> None:
+    console.print(f"[green]{message}[/green]", **kwargs)
+
+def log_warning(message: str, **kwargs: Any) -> None:
+    console.print(f"[yellow]{message}[/yellow]", **kwargs)

service_forge/sft/util/name_util.py

@@ -0,0 +1,8 @@
+def get_metadata_file_name(name: str, version: str) -> str:
+    return "sf-meta.yaml"
+
+def get_service_name(name: str, version: str) -> str:
+    return f"sf-{name}-{version.replace('.', '-')}v"
+
+def get_service_url_name(name: str, version: str) -> str:
+    return f"{name}-{version.replace('.', '-')}"

service_forge/sft/util/yaml_utils.py

@@ -0,0 +1,57 @@
+import yaml
+from pathlib import Path
+from typing import Any, Dict
+
+
+def extract_yaml_content_without_comments(yaml_file: Path) -> str:
+    """
+    读取 YAML 文件，去除注释，返回格式化的 YAML 字符串
+
+    Args:
+        yaml_file: YAML 文件路径
+
+    Returns:
+        去除注释后的 YAML 字符串
+    """
+    with open(yaml_file, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    # 移除注释行（以 # 开头的行，但不包含字符串中的 #）
+    lines = content.split('\n')
+    filtered_lines = []
+
+    for line in lines:
+        stripped = line.strip()
+        # 跳过空行和纯注释行
+        if not stripped or stripped.startswith('#'):
+            continue
+        filtered_lines.append(line)
+
+    # 重新组合并解析为 Python 对象，然后重新序列化
+    yaml_content = '\n'.join(filtered_lines)
+
+    try:
+        # 使用 yaml.safe_load 解析，然后重新序列化确保格式正确
+        data = yaml.safe_load(yaml_content)
+        if data is None:
+            return ""
+        return yaml.dump(data, default_flow_style=False, allow_unicode=True, sort_keys=False)
+    except yaml.YAMLError:
+        # 如果解析失败，返回原始过滤后的内容
+        return yaml_content
+
+
+def load_sf_metadata_as_string(metadata_file: Path) -> str:
+    """
+    加载 sf-meta.yaml 文件，去除注释后返回字符串格式
+
+    Args:
+        metadata_file: sf-meta.yaml 文件路径
+
+    Returns:
+        去除注释后的 YAML 内容字符串
+    """
+    if not metadata_file.exists():
+        raise FileNotFoundError(f"Metadata file not found: {metadata_file}")
+
+    return extract_yaml_content_without_comments(metadata_file)

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"]