service-forge 0.1.11__py3-none-any.whl

service_forge/sft/cmd/config_command.py

@@ -0,0 +1,67 @@
+from typing import Optional
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from service_forge.sft.config.sft_config import SftConfig
+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 list_config() -> None:
+    try:
+        console = Console()
+        
+        table = Table(title="SFT Configuration", show_header=True, header_style="bold magenta")
+        table.add_column("Key", style="cyan", no_wrap=True)
+        table.add_column("Value", style="green")
+        table.add_column("Description", style="yellow")
+        
+        # Automatically add rows for all config items
+        config_dict = sft_config.to_dict()
+        for key, value in sorted(config_dict.items()):
+            description = SftConfig.CONFIG_DESCRIPTIONS.get(key, "No description available")
+            table.add_row(key, str(value), description)
+        
+        console.print(table)
+        console.print(f"\n[dim]Config file location: {sft_config.config_file_path}[/dim]")
+    except Exception as e:
+        log_error(f"Failed to load config: {e}")
+        raise typer.Exit(1)
+
+def get_config(key: str) -> None:
+    try:
+        value = sft_config.get(key)
+        
+        if value is None:
+            log_error(f"Config key '{key}' not found")
+            log_info("Available keys: config_root, sft_file_root, k8s_namespace")
+            raise typer.Exit(1)
+        
+        log_info(f"{key} = {value}")
+    except ValueError as e:
+        log_error(str(e))
+        raise typer.Exit(1)
+    except Exception as e:
+        log_error(f"Failed to get config: {e}")
+        raise typer.Exit(1)
+
+def set_config(key: str, value: str) -> None:
+    try:
+        current_value = sft_config.get(key)
+        if current_value is None:
+            log_error(f"Unknown config key: {key}")
+            log_info("Available keys: config_root, sft_file_root, k8s_namespace")
+            raise typer.Exit(1)
+        
+        sft_config.set(key, value)
+        sft_config.save()
+        
+        log_success(f"Updated {key} = {value}")
+        log_info(f"Config saved to {sft_config.config_file_path}")
+    except ValueError as e:
+        log_error(str(e))
+        raise typer.Exit(1)
+    except Exception as e:
+        log_error(f"Failed to set config: {e}")
+        raise typer.Exit(1)
+

service_forge/sft/cmd/deploy_service.py

@@ -0,0 +1,123 @@
+import os
+import shutil
+import subprocess
+import tarfile
+import tempfile
+from pathlib import Path
+
+import typer
+from omegaconf import OmegaConf
+from service_forge.sft.util.logger import log_error, log_info, log_success, log_warning
+from service_forge.sft.file.sft_file_manager import sft_file_manager
+from service_forge.sft.config.sft_config import sft_config
+from service_forge.sft.util.assert_util import assert_file_exists, assert_dir_exists
+from service_forge.sft.config.sf_metadata import load_metadata
+from service_forge.sft.kubernetes.kubernetes_manager import KubernetesManager
+from service_forge.sft.config.injector import Injector
+from service_forge.sft.util.name_util import get_service_name
+
+def _extract_tar_file(tar_file: Path, temp_path: Path) -> None:
+    log_info(f"Extracting tar file to: {temp_path}")
+    
+    try:
+        with tarfile.open(tar_file, 'r') as tar:
+            tar.extractall(temp_path)
+    except Exception as e:
+        log_error(f"Failed to extract tar file: {e}")
+        raise typer.Exit(1)
+    
+    log_success("Tar file extracted successfully")
+
+def _build_docker_image(project_dir: Path, name: str, version: str) -> None:
+    image_name = f"sf-{name}:{version}"
+    full_image_name = sft_config.registry_address + "/" + image_name
+    log_info(f"Building Docker image: {image_name}")
+    try:
+        # build docker image
+        build_result = subprocess.run(
+            ["docker", "build", "-t", full_image_name, str(project_dir)],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        log_success(f"Docker image built successfully: {image_name}")
+        if build_result.stdout:
+            log_info(build_result.stdout)
+
+        # push docker image to registry
+        log_info(f"Pushing Docker image to registry: {full_image_name}")
+        push_result = subprocess.run(
+            ["docker", "push", full_image_name],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        log_success(f"Docker image pushed successfully: {full_image_name}")
+        if push_result.stdout:
+            log_info(push_result.stdout)
+
+    except subprocess.CalledProcessError as e:
+        log_error(f"Docker operation failed: {e}")
+        if e.stderr:
+            log_error(e.stderr)
+        raise typer.Exit(1)
+    except FileNotFoundError:
+        log_error("Docker command not found. Please install Docker.")
+        raise typer.Exit(1)
+
+def _apply_k8s_deployment(deployment_yaml: Path, ingress_yaml: Path, name: str, version: str) -> None:
+    log_info("Applying k8s deployment...")
+    
+    try:
+        k8s_manager = KubernetesManager()
+        k8s_manager.delete_service(sft_config.k8s_namespace, get_service_name(name, version), force=True)
+        k8s_manager.apply_deployment_yaml(deployment_yaml, sft_config.k8s_namespace)
+        k8s_manager.apply_deployment_yaml(ingress_yaml, sft_config.k8s_namespace)
+        log_success("K8s deployment applied successfully")
+    except Exception as e:
+        log_error(f"K8s deployment failed: {e}")
+        raise typer.Exit(1)
+    
+    log_success(f"Deployment process completed for {name}:{version}")
+
+def _inject_config(project_dir: Path) -> None:
+    injector = Injector(project_dir)
+    injector.inject()
+
+def deploy_service(name: str, version: str) -> None:
+    tar_file = sft_file_manager.tar_path / f"sf_{name}_{version}.tar"
+
+    assert_file_exists(tar_file)
+    
+    temp_parent = os.path.join(tempfile.gettempdir(), "sft")
+    os.makedirs(temp_parent, exist_ok=True)
+    
+    with tempfile.TemporaryDirectory(prefix=f"deploy_{name}_{version}", dir=temp_parent) as temp_dir:
+        temp_path = Path(temp_dir)
+
+        _extract_tar_file(tar_file, temp_path)
+
+        project_dir = temp_path / f"{name}_{version}"
+
+        _inject_config(project_dir)
+
+        dockerfile_path = project_dir / "Dockerfile"
+        metadata_path = project_dir / "sf-meta.yaml"
+        deployment_yaml = project_dir / "deployment.yaml"
+        ingress_yaml = project_dir / "ingress.yaml"
+        
+        assert_dir_exists(project_dir)
+        assert_file_exists(dockerfile_path)
+        assert_file_exists(metadata_path)
+        assert_file_exists(deployment_yaml)
+        assert_file_exists(ingress_yaml)
+
+        try:
+            meta_data = load_metadata(metadata_path)
+        except Exception as e:
+            log_error(f"Failed to read sf-meta.yaml: {e}")
+            raise typer.Exit(1)
+        
+        _build_docker_image(project_dir, meta_data.name, meta_data.version)
+        # TODO: create new user in mongodb and redis
+        _apply_k8s_deployment(deployment_yaml, ingress_yaml, meta_data.name, meta_data.version)

service_forge/sft/cmd/list_tars.py

@@ -0,0 +1,41 @@
+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
+from service_forge.sft.file.sft_file_manager import sft_file_manager
+
+def list_tars() -> None:
+    tar_files = sft_file_manager.load_tars()
+    
+    if not tar_files:
+        log_info("No tar files found.")
+        return
+    
+    console = Console()
+    table = Table(title="Service Tar Files", show_header=True, header_style="bold magenta")
+    table.add_column("Project", style="cyan", no_wrap=True)
+    table.add_column("Version", style="cyan", no_wrap=True)
+    table.add_column("File Name", style="cyan", no_wrap=True)
+    table.add_column("Size", justify="right", style="green")
+    table.add_column("Modified Time", style="yellow")
+    
+    for tar_file in tar_files:
+        table.add_row(tar_file.project_name, tar_file.version, tar_file.path.name, tar_file._format_size(), tar_file._format_modified_time())
+    
+    console.print(table)
+
+
+def _format_size(size_bytes: int) -> str:
+    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:
+    from datetime import datetime
+    return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")
+

service_forge/sft/cmd/service_command.py

@@ -0,0 +1,149 @@
+from typing import List, Optional
+import typer
+from rich.console import Console
+from rich.table import Table
+from kubernetes import client, config
+from kubernetes.client.rest import ApiException
+
+from service_forge.sft.config.sft_config import sft_config
+from service_forge.sft.util.logger import log_error, log_info, log_success, log_warning
+from service_forge.sft.kubernetes.kubernetes_manager import KubernetesManager
+
+def list_services() -> None:
+    namespace = sft_config.k8s_namespace
+    kubernetes_manager = KubernetesManager()
+    services = kubernetes_manager.get_services_in_namespace(namespace)
+    
+    if not services:
+        log_warning(f"No services starting with 'sf-' found in namespace '{namespace}'")
+        return
+    
+    console = Console()
+    table = Table(title=f"Services in namespace '{namespace}' (sf-*)", show_header=True, header_style="bold magenta")
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("Type", style="green")
+    table.add_column("Port", style="yellow")
+    table.add_column("Target Port", style="yellow")
+    
+    for service_name in sorted(services):
+        details = kubernetes_manager.get_service_details(namespace, service_name)
+        table.add_row(
+            details.name,
+            details.type or "-",
+            str(details.port or "-"),
+            str(details.target_port or "-")
+        )
+    
+    console.print(table)
+    log_info(f"Found {len(services)} service(s)")
+
+def show_logs(
+    namespace: str,
+    pod_name: str,
+    container_name: str,
+    tail: int,
+    follow: bool,
+    previous: bool
+) -> None:
+    kubernetes_manager = KubernetesManager()
+    try:
+        if not follow:
+            log_info(f"Fetching logs from pod '{pod_name}' (container: {container_name})...")
+        
+        logs = kubernetes_manager.get_pod_logs(
+            namespace=namespace,
+            pod_name=pod_name,
+            container_name=container_name,
+            tail=tail,
+            follow=follow,
+            previous=previous
+        )
+        
+        if follow:
+            try:
+                for line in logs:
+                    log_info(line, end="")
+            except KeyboardInterrupt:
+                log_warning("Log streaming interrupted")
+                raise typer.Exit(0)
+        else:
+            if logs:
+                log_info(logs)
+            else:
+                log_warning(f"No logs available for pod '{pod_name}' container '{container_name}'")
+                
+    except ApiException as e:
+        if e.status == 404:
+            log_error(f"Pod '{pod_name}' or container '{container_name}' not found")
+        elif e.status == 400:
+            log_error(f"Bad request: {e.reason}")
+            if "previous" in str(e.body).lower():
+                log_info("Note: 'previous' flag only works for stopped containers")
+        else:
+            log_error(f"Failed to get logs: {e.reason}")
+            if e.body:
+                log_error(f"Error details: {e.body}")
+    except Exception as e:
+        log_error(f"Failed to get logs: {e}")
+
+
+def show_service_logs(
+    service_name: str,
+    container: Optional[str] = None,
+    tail: int = 100,
+    follow: bool = False,
+    previous: bool = False
+) -> None:
+    namespace = sft_config.k8s_namespace
+    kubernetes_manager = KubernetesManager()
+    
+    if not service_name.startswith("sf-"):
+        log_warning(f"Service name '{service_name}' does not start with 'sf-'. Proceeding anyway...")
+    
+    services = kubernetes_manager.get_services_in_namespace(namespace)
+    if service_name not in services:
+        log_error(f"Service '{service_name}' not found in namespace '{namespace}'")
+        log_info(f"Available services: {', '.join(services) if services else 'None'}")
+        raise typer.Exit(1)
+    
+    pod_names = kubernetes_manager.get_pods_for_service(namespace, service_name)
+    if not pod_names:
+        log_error(f"No pods found for service '{service_name}' in namespace '{namespace}'")
+        raise typer.Exit(1)
+    
+    log_info(f"Found {len(pod_names)} pod(s) for service '{service_name}'")
+    
+    for pod_name in pod_names:
+        containers = kubernetes_manager.get_pod_containers(namespace, pod_name)
+        
+        if not containers:
+            log_warning(f"No containers found in pod '{pod_name}'")
+            continue
+
+        if container and container not in containers:
+            log_error(f"Container '{container}' not found in pod '{pod_name}'")
+            log_info(f"Available containers: {', '.join(containers)}")
+            continue
+        
+        target_containers = [container] if container else containers
+        
+        for container_name in target_containers:
+            show_logs(namespace, pod_name, container_name, tail, follow, previous)
+
+def delete_service(service_name: str, force: bool = False) -> None:
+    namespace = sft_config.k8s_namespace
+    
+    if not service_name.startswith("sf-"):
+        log_error(f"Service name '{service_name}' does not start with 'sf-'")
+        raise typer.Exit(1)
+    
+    kubernetes_manager = KubernetesManager()
+
+    services = kubernetes_manager.get_services_in_namespace(namespace)
+    if service_name not in services:
+        log_warning(f"Service '{service_name}' not found in namespace '{namespace}'")
+        log_info(f"Available services: {', '.join(services) if services else 'None'}")
+    
+    log_info(f"Deleting service '{service_name}' from namespace '{namespace}'...")
+    kubernetes_manager.delete_service(namespace, service_name, force)
+    

service_forge/sft/cmd/upload_service.py

@@ -0,0 +1,36 @@
+import typer
+from pathlib import Path
+from service_forge.sft.util.logger import log_error, log_success
+from service_forge.sft.file.sft_file_manager import sft_file_manager
+from service_forge.sft.util.assert_util import assert_dir_exists, assert_file_exists
+from service_forge.sft.config.sf_metadata import load_metadata
+
+def upload_service(project_path: str) -> None:
+    project_dir = Path(project_path).resolve()
+    assert_dir_exists(project_dir)
+    
+    metadata_path = project_dir / "sf-meta.yaml"
+    assert_file_exists(metadata_path)
+    
+    try:
+        meta_data = load_metadata(metadata_path)
+    except Exception as e:
+        log_error(f"Failed to read sf-meta.yaml: {e}")
+        raise typer.Exit(1)
+        
+    try:
+        tar_file = sft_file_manager.create_tar(project_dir, meta_data.name, meta_data.version)
+    except Exception as e:
+        log_error(f"Failed to create tar file: {e}")
+        raise typer.Exit(1)
+
+    log_success(f"Packaging successful: {tar_file}")
+
+    # upload to the service
+    try:
+        sft_file_manager.upload_tar(tar_file)
+    except Exception as e:
+        log_error(f"Failed to upload tar file: {e}")
+        raise typer.Exit(1)
+
+    log_success(f"Upload successful: {tar_file}")

service_forge/sft/config/injector.py

@@ -0,0 +1,119 @@
+from omegaconf import OmegaConf
+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.sft.util.name_util import get_service_name
+from service_forge.sft.util.yaml_utils import load_sf_metadata_as_string
+
+class Injector:
+    def __init__(self, project_dir: Path):
+        self.project_dir = project_dir
+        self.deployment_yaml_path = project_dir / "deployment.yaml"
+        self.metadata_path = project_dir / "sf-meta.yaml"
+        self.ingress_yaml_path = project_dir / "ingress.yaml"
+        self.dockerfile_path = project_dir / "Dockerfile"
+        self.pyproject_toml_path = project_dir / "pyproject.toml"
+        self.metadata = load_metadata(self.metadata_path)
+        self.name = self.metadata.name
+        self.version = self.metadata.version
+        self.namespace = sft_config.k8s_namespace
+
+        try:
+            self.sf_metadata_string = load_sf_metadata_as_string(self.metadata_path)
+        except Exception as e:
+            log_error(f"Failed to load sf-metadata as string: {e}")
+            self.sf_metadata_string = ""
+
+    @property
+    def service_name(self) -> str:
+        return get_service_name(self.name, self.version)
+
+    def inject_deployment(self) -> None:
+        single_line_metadata = self.sf_metadata_string.replace('\n', '\\n').replace('"', '\\"')
+
+        envs = {
+            "DEEPSEEK_API_KEY": sft_config.deepseek_api_key,
+            "DEEPSEEK_BASE_URL": sft_config.deepseek_base_url,
+        }
+
+        for env in self.metadata.env:
+            envs[env['name']] = env['value']
+
+        env_str = ""
+        for key, value in envs.items():
+            env_str += f"          - name: {key}\n            value: {value}\n"
+
+        deployment_yaml = DEFAULT_DEPLOYMENT_YAML.format(
+            service_name=self.service_name,
+            name=self.name,
+            version=self.version,
+            namespace=self.namespace,
+            sf_metadata=f'"{single_line_metadata}"',
+            env=env_str,
+        )
+        with open(self.deployment_yaml_path, "w") as f:
+            f.write(deployment_yaml)
+        print("deployment_yaml_path: ", self.deployment_yaml_path)
+
+    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.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()))
+
+    def inject_ingress(self) -> None:
+        ingress_yaml = DEFAULT_TRAEFIK_INGRESS_YAML.format(
+            name=self.name,
+            version=self.version.replace(".", "-"),
+            namespace=self.namespace,
+        )
+        with open(self.ingress_yaml_path, "w") as f:
+            f.write(ingress_yaml)
+        print("ingress_yaml_path: ", self.ingress_yaml_path)
+
+    def inject_dockerfile(self) -> None:
+        dockerfile = DEFAULT_DOCKERFILE
+        with open(self.dockerfile_path, "w") as f:
+            f.write(dockerfile)
+        print("dockerfile_path: ", self.dockerfile_path)
+
+    def inject_pyproject_toml(self) -> None:
+        pyproject_toml = DEFAULT_PYPROJECT_TOML
+        with open(self.pyproject_toml_path, "r") as f:
+            existing_pyproject_toml = f.read()
+        if pyproject_toml.strip() not in existing_pyproject_toml.strip():
+            with open(self.pyproject_toml_path, "a") as f:
+                f.write(pyproject_toml)
+        print("pyproject_toml_path: ", self.pyproject_toml_path)
+
+    def inject(self) -> None:
+        self.inject_deployment()
+        self.inject_service_config()
+        self.inject_ingress()
+        self.inject_dockerfile()
+        self.inject_pyproject_toml()

service_forge/sft/config/injector_default_files.py

@@ -0,0 +1,131 @@
+DEFAULT_DEPLOYMENT_YAML = """
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: {service_name}
+  namespace: {namespace}
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: {service_name}
+  template:
+    metadata:
+      labels:
+        app: {service_name}
+    spec:
+      imagePullSecrets:
+        - name: aliyun-regcred
+      containers:
+      - name: {service_name}
+        image: crpi-cev6qq28wwgwwj0y.cn-beijing.personal.cr.aliyuncs.com/nexthci/sf-{name}:{version}
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 8000
+        env:
+{env}
+
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: {service_name}
+  namespace: {namespace}
+  annotations:
+    metadata: {sf_metadata}
+spec:
+  type: ClusterIP
+  selector:
+    app: {service_name}
+  ports:
+    - protocol: TCP
+      port: 80
+      targetPort: 8000
+"""
+
+DEFAULT_TRAEFIK_INGRESS_YAML = """
+apiVersion: traefik.io/v1alpha1
+kind: Middleware
+metadata:
+  name: strip-prefix-sf-{name}-{version}v
+  namespace: {namespace}
+spec:
+  stripPrefix:
+    prefixes:
+      - /api/v1/{name}-{version}
+
+---
+
+apiVersion: traefik.io/v1alpha1
+kind: IngressRoute
+metadata:
+  name: sf-{name}-{version}v
+  namespace: {namespace}
+spec:
+  entryPoints:
+    - web
+  routes:
+    - match: PathPrefix(`/api/v1/{name}-{version}/openapi.json`)
+      kind: Rule
+      services:
+        - name: sf-{name}-{version}v
+          namespace: {namespace}
+          port: 80
+      middlewares:
+        - name: strip-prefix-sf-{name}-{version}v
+          namespace: {namespace}
+        - name: cors
+          namespace: {namespace}
+
+    - match: PathPrefix(`/api/v1/{name}-{version}/docs`)
+      kind: Rule
+      services:
+        - name: sf-{name}-{version}v
+          namespace: {namespace}
+          port: 80
+      middlewares:
+        - name: strip-prefix-sf-{name}-{version}v
+          namespace: {namespace}
+        - name: cors
+          namespace: {namespace}
+
+    - match: PathPrefix(`/api/v1/{name}-{version}`)
+      kind: Rule
+      services:
+        - name: sf-{name}-{version}v
+          namespace: {namespace}
+          port: 80
+      middlewares:
+        - name: strip-prefix-sf-{name}-{version}v
+          namespace: {namespace}
+        - name: cors
+          namespace: {namespace}
+        - name: jwt-auth
+          namespace: {namespace}
+"""
+
+DEFAULT_DOCKERFILE = """
+FROM crpi-cev6qq28wwgwwj0y.cn-beijing.personal.cr.aliyuncs.com/nexthci/service-forge:latest
+
+WORKDIR /app
+
+COPY . ./service
+
+WORKDIR /app
+RUN uv sync
+
+ENV PYTHONPATH=/app/service:/app:/app/src
+ENV PATH="/app/.venv/bin:$PATH"
+
+WORKDIR /app/service
+
+RUN chmod +x start.sh
+
+CMD ["./start.sh"]
+"""
+
+DEFAULT_PYPROJECT_TOML = """
+
+[tool.uv.sources]
+service-forge = { workspace = true }
+"""