service-forge 0.1.11__py3-none-any.whl

service_forge/sft/config/sf_metadata.py

@@ -0,0 +1,30 @@
+from omegaconf import OmegaConf
+
+class SfMetadata:
+    def __init__(
+        self,
+        name: str,
+        version: str,
+        description: str,
+        service_config: str,
+        config_only: bool,
+        env: list[dict],
+    ) -> None:
+        self.name = name
+        self.version = version
+        self.description = description
+        self.service_config = service_config
+        self.config_only = config_only
+        self.env = env
+
+def load_metadata(path: str) -> SfMetadata:
+    with open(path, 'r') as file:
+        data = OmegaConf.load(file)
+        return SfMetadata(
+            name=data.get('name'),
+            version=data.get('version'),
+            description=data.get('description'),
+            service_config=data.get('service_config'),
+            config_only=data.get('config_only'),
+            env=data.get('env', []),
+        )

service_forge/sft/config/sft_config.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import inspect
+from pathlib import Path
+from typing import Optional
+from omegaconf import OmegaConf
+
+class SftConfig:
+    CONFIG_ROOT = Path.home() / ".sft"
+    
+    # Configuration descriptions mapping
+    CONFIG_DESCRIPTIONS = {
+        "sft_file_root": "SFT file storage root directory",
+        "service_center_address": "Service center address",
+        "k8s_namespace": "Kubernetes namespace",
+        "registry_address": "Registry address",
+        "inject_http_port": "HTTP port for services",
+        "inject_kafka_host": "Kafka host for services",
+        "inject_kafka_port": "Kafka port for services",
+        "inject_postgres_host": "Postgres host for services",
+        "inject_postgres_port": "Postgres port for services",
+        "inject_postgres_user": "Postgres user for services",
+        "inject_postgres_password": "Postgres password for services",
+        "deepseek_api_key": "DeepSeek API key",
+        "deepseek_base_url": "DeepSeek base URL",
+    }
+
+    def __init__(
+        self,
+        sft_file_root: str = "/tmp/sft",
+        service_center_address: str = "http://vps.shiweinan.com:37919/service_center",
+        k8s_namespace: str = "secondbrain",
+        registry_address: str = "crpi-cev6qq28wwgwwj0y.cn-beijing.personal.cr.aliyuncs.com/nexthci",
+
+        inject_http_port: int = 8000,
+
+        inject_kafka_host: str = "localhost",
+        inject_kafka_port: int = 9092,
+
+        inject_postgres_host: str = "second-brain-postgres-postgresql",
+        inject_postgres_port: int = 5432,
+        inject_postgres_user: str = "postgres",
+        inject_postgres_password: str = "gnBGWg7aL4",
+
+        inject_mongo_host: str = "mongo-mongodb",
+        inject_mongo_port: int = 27017,
+        inject_mongo_user: str = "secondbrain",
+        inject_mongo_password: str = "secondbrain",
+        inject_mongo_db: str = "secondbrain",
+
+        inject_redis_host: str = "redis-master",
+        inject_redis_port: int = 6379,
+        inject_redis_password: str = "rDdM2Y2gX9",
+
+        deepseek_api_key: str = "82c9df22-f6ed-411e-90d7-c5255376b7ca",
+        deepseek_base_url: str = "https://ark.cn-beijing.volces.com/api/v3",
+    ):
+        self.sft_file_root = sft_file_root
+        self.service_center_address = service_center_address
+        self.k8s_namespace = k8s_namespace
+        self.registry_address = registry_address
+
+        self.inject_http_port = inject_http_port
+
+        self.inject_kafka_host = inject_kafka_host
+        self.inject_kafka_port = inject_kafka_port
+
+        self.inject_postgres_host = inject_postgres_host
+        self.inject_postgres_port = inject_postgres_port
+        self.inject_postgres_user = inject_postgres_user
+        self.inject_postgres_password = inject_postgres_password
+
+        self.inject_mongo_host = inject_mongo_host
+        self.inject_mongo_port = inject_mongo_port
+        self.inject_mongo_user = inject_mongo_user
+        self.inject_mongo_password = inject_mongo_password
+        self.inject_mongo_db = inject_mongo_db
+
+        self.inject_redis_host = inject_redis_host
+        self.inject_redis_port = inject_redis_port
+        self.inject_redis_password = inject_redis_password
+
+        self.deepseek_api_key = deepseek_api_key
+        self.deepseek_base_url = deepseek_base_url
+
+    @property
+    def server_url(self) -> str:
+        return self.service_center_address
+
+    @property
+    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']
+    
+    @property
+    def config_file_path(self) -> Path:
+        return self.CONFIG_ROOT / "config.yaml"
+    
+    def ensure_config_dir(self) -> None:
+        self.CONFIG_ROOT.mkdir(parents=True, exist_ok=True)
+    
+    def to_dict(self) -> dict:
+        config_keys = self.get_config_keys()
+        return {key: getattr(self, key) for key in config_keys}
+    
+    def from_dict(self, data: dict) -> None:
+        config_keys = self.get_config_keys()
+        for key in config_keys:
+            if key in data:
+                setattr(self, key, data[key])
+    
+    def save(self) -> None:
+        self.ensure_config_dir()
+        config_dict = self.to_dict()
+        OmegaConf.save(config_dict, self.config_file_path)
+    
+    def get(self, key: str, default: Optional[str] = None) -> Optional[str]:
+        return getattr(self, key, default)
+    
+    def set(self, key: str, value: str) -> None:
+        if key in ["config_root"]:
+            raise ValueError(f"{key} is read-only")
+        if hasattr(self, key):
+            setattr(self, key, value)
+        else:
+            raise ValueError(f"Unknown config key: {key}")
+    
+    def update(self, updates: dict) -> None:
+        for key, value in updates.items():
+            self.set(key, value)
+
+
+def load_config() -> SftConfig:
+    # config = SftConfig()
+    config = SftConfig()
+    config_file = config.config_file_path
+    
+    if config_file.exists():
+        try:
+            data = OmegaConf.load(config_file)
+            config = SftConfig(**OmegaConf.to_container(data, resolve=True))
+        except Exception as e:
+            ...
+
+    config.save()
+    
+    return config
+
+sft_config = load_config()

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('.', '-')}"