Download core/sandbox/resolver.py from Kyrlos11/nniback: direct link, hf CLI and curl.
- Browser
- Download file 10.2 kB
-
https://huggingface.co/spaces/Kyrlos11/nniback/resolve/main/core/sandbox/resolver.py
- Command line
-
hf download hf://spaces/Kyrlos11/nniback/core/sandbox/resolver.py
-
curl -L -o resolver.py https://huggingface.co/spaces/Kyrlos11/nniback/resolve/main/core/sandbox/resolver.py
10.2 kB
| from typing import Optional, Tuple, Dict, Any | |
| from dataclasses import dataclass | |
| import asyncio | |
| import time | |
| from daytona_sdk import AsyncSandbox | |
| from core.utils.logger import logger | |
| from core.sandbox.sandbox import get_or_start_sandbox, create_sandbox | |
| from core.cache.runtime_cache import get_cached_project_metadata, set_cached_project_metadata | |
| class SandboxInfo: | |
| sandbox_id: str | |
| sandbox: AsyncSandbox | |
| password: str | |
| sandbox_url: Optional[str] = None | |
| vnc_preview: Optional[str] = None | |
| token: Optional[str] = None | |
| class SandboxResolver: | |
| _instance: Optional['SandboxResolver'] = None | |
| _lock = asyncio.Lock() | |
| def __init__(self): | |
| self._resolution_locks: Dict[str, asyncio.Lock] = {} | |
| self._locks_lock = asyncio.Lock() | |
| def get_instance(cls) -> 'SandboxResolver': | |
| if cls._instance is None: | |
| cls._instance = cls() | |
| return cls._instance | |
| async def _get_project_lock(self, project_id: str) -> asyncio.Lock: | |
| async with self._locks_lock: | |
| if project_id not in self._resolution_locks: | |
| self._resolution_locks[project_id] = asyncio.Lock() | |
| return self._resolution_locks[project_id] | |
| async def resolve( | |
| self, | |
| project_id: str, | |
| account_id: str, | |
| db_client=None, | |
| require_started: bool = True | |
| ) -> Optional[SandboxInfo]: | |
| lock = await self._get_project_lock(project_id) | |
| async with lock: | |
| return await self._resolve_internal( | |
| project_id, account_id, db_client, require_started | |
| ) | |
| async def _resolve_internal( | |
| self, | |
| project_id: str, | |
| account_id: str, | |
| db_client, | |
| require_started: bool | |
| ) -> Optional[SandboxInfo]: | |
| start_time = time.time() | |
| cached = await get_cached_project_metadata(project_id) | |
| sandbox_data = cached.get('sandbox', {}) if cached else {} | |
| sandbox_id = sandbox_data.get('sandbox_id') or sandbox_data.get('id') | |
| if sandbox_id: | |
| try: | |
| sandbox = await get_or_start_sandbox(sandbox_id) | |
| elapsed = (time.time() - start_time) * 1000 | |
| logger.debug(f"[RESOLVER] Cache hit for {project_id}: {sandbox_id} in {elapsed:.0f}ms") | |
| return SandboxInfo( | |
| sandbox_id=sandbox_id, | |
| sandbox=sandbox, | |
| password=sandbox_data.get('pass', ''), | |
| sandbox_url=sandbox_data.get('sandbox_url'), | |
| vnc_preview=sandbox_data.get('vnc_preview'), | |
| token=sandbox_data.get('token') | |
| ) | |
| except Exception as e: | |
| logger.warning(f"[RESOLVER] Cached sandbox {sandbox_id} failed: {e}") | |
| if db_client: | |
| sandbox_info = await self._resolve_from_db(project_id, account_id, db_client) | |
| if sandbox_info: | |
| elapsed = (time.time() - start_time) * 1000 | |
| logger.debug(f"[RESOLVER] DB hit for {project_id}: {sandbox_info.sandbox_id} in {elapsed:.0f}ms") | |
| return sandbox_info | |
| sandbox_info = await self._claim_or_create(project_id, account_id, db_client) | |
| if sandbox_info: | |
| elapsed = (time.time() - start_time) * 1000 | |
| logger.info(f"[RESOLVER] New sandbox for {project_id}: {sandbox_info.sandbox_id} in {elapsed:.0f}ms") | |
| return sandbox_info | |
| async def _resolve_from_db( | |
| self, | |
| project_id: str, | |
| account_id: str, | |
| db_client | |
| ) -> Optional[SandboxInfo]: | |
| try: | |
| from core.resources import ResourceService, ResourceStatus | |
| result = await db_client.table('projects').select( | |
| 'sandbox_resource_id' | |
| ).eq('project_id', project_id).execute() | |
| if not result.data or not result.data[0].get('sandbox_resource_id'): | |
| return None | |
| resource_id = result.data[0]['sandbox_resource_id'] | |
| resource_service = ResourceService(db_client) | |
| resource = await resource_service.get_resource_by_id(resource_id) | |
| if not resource or resource.get('status') != ResourceStatus.ACTIVE.value: | |
| return None | |
| sandbox_id = resource.get('external_id') | |
| config = resource.get('config', {}) | |
| sandbox = await get_or_start_sandbox(sandbox_id) | |
| await self._update_cache(project_id, sandbox_id, config) | |
| return SandboxInfo( | |
| sandbox_id=sandbox_id, | |
| sandbox=sandbox, | |
| password=config.get('pass', ''), | |
| sandbox_url=config.get('sandbox_url'), | |
| vnc_preview=config.get('vnc_preview'), | |
| token=config.get('token') | |
| ) | |
| except Exception as e: | |
| logger.error(f"[RESOLVER] DB resolution failed for {project_id}: {e}") | |
| return None | |
| async def _claim_or_create( | |
| self, | |
| project_id: str, | |
| account_id: str, | |
| db_client | |
| ) -> Optional[SandboxInfo]: | |
| from core.sandbox.pool_config import get_pool_config | |
| from core.sandbox.pool_service import claim_sandbox_from_pool | |
| # Check if pool is enabled via config | |
| pool_config = get_pool_config() | |
| if pool_config.enabled: | |
| try: | |
| claimed = await claim_sandbox_from_pool(account_id, project_id) | |
| if claimed: | |
| sandbox_id, config = claimed | |
| sandbox = await get_or_start_sandbox(sandbox_id) | |
| await self._update_cache(project_id, sandbox_id, config) | |
| logger.info(f"[RESOLVER] Claimed from pool: {sandbox_id} for {project_id}") | |
| return SandboxInfo( | |
| sandbox_id=sandbox_id, | |
| sandbox=sandbox, | |
| password=config.get('pass', ''), | |
| sandbox_url=config.get('sandbox_url'), | |
| vnc_preview=config.get('vnc_preview'), | |
| token=config.get('token') | |
| ) | |
| except Exception as e: | |
| logger.warning(f"[RESOLVER] Pool claim failed: {e}") | |
| else: | |
| logger.debug(f"[RESOLVER] Pool disabled (SANDBOX_POOL_ENABLED=false), creating new sandbox for {project_id}") | |
| return await self._create_new(project_id, account_id, db_client) | |
| async def _create_new( | |
| self, | |
| project_id: str, | |
| account_id: str, | |
| db_client | |
| ) -> Optional[SandboxInfo]: | |
| import uuid | |
| from core.resources import ResourceService, ResourceType, ResourceStatus | |
| try: | |
| password = str(uuid.uuid4()) | |
| sandbox = await create_sandbox(password, project_id) | |
| sandbox_id = sandbox.id | |
| await asyncio.sleep(2) | |
| vnc_url, website_url, token = await self._get_preview_links(sandbox) | |
| config = { | |
| 'pass': password, | |
| 'vnc_preview': vnc_url, | |
| 'sandbox_url': website_url, | |
| 'token': token | |
| } | |
| if db_client: | |
| resource_service = ResourceService(db_client) | |
| resource = await resource_service.create_resource( | |
| account_id=account_id, | |
| resource_type=ResourceType.SANDBOX, | |
| external_id=sandbox_id, | |
| config=config, | |
| status=ResourceStatus.ACTIVE | |
| ) | |
| await resource_service.link_resource_to_project(project_id, resource['id']) | |
| await self._update_cache(project_id, sandbox_id, config) | |
| logger.info(f"[RESOLVER] Created new sandbox: {sandbox_id} for {project_id}") | |
| return SandboxInfo( | |
| sandbox_id=sandbox_id, | |
| sandbox=sandbox, | |
| password=password, | |
| sandbox_url=website_url, | |
| vnc_preview=vnc_url, | |
| token=token | |
| ) | |
| except Exception as e: | |
| logger.error(f"[RESOLVER] Create failed for {project_id}: {e}") | |
| return None | |
| async def _get_preview_links(self, sandbox: AsyncSandbox) -> Tuple[Optional[str], Optional[str], Optional[str]]: | |
| try: | |
| vnc_link = await sandbox.get_preview_link(6080) | |
| website_link = await sandbox.get_preview_link(8080) | |
| vnc_url = vnc_link.url if hasattr(vnc_link, 'url') else str(vnc_link).split("url='")[1].split("'")[0] | |
| website_url = website_link.url if hasattr(website_link, 'url') else str(website_link).split("url='")[1].split("'")[0] | |
| token = vnc_link.token if hasattr(vnc_link, 'token') else None | |
| return vnc_url, website_url, token | |
| except Exception: | |
| return None, None, None | |
| async def _update_cache(self, project_id: str, sandbox_id: str, config: Dict[str, Any]) -> None: | |
| try: | |
| sandbox_data = { | |
| 'sandbox_id': sandbox_id, | |
| 'pass': config.get('pass'), | |
| 'vnc_preview': config.get('vnc_preview'), | |
| 'sandbox_url': config.get('sandbox_url'), | |
| 'token': config.get('token') | |
| } | |
| await set_cached_project_metadata(project_id, sandbox_data) | |
| except Exception as e: | |
| logger.warning(f"[RESOLVER] Cache update failed: {e}") | |
| def get_resolver() -> SandboxResolver: | |
| return SandboxResolver.get_instance() | |
| async def resolve_sandbox( | |
| project_id: str, | |
| account_id: str, | |
| db_client=None, | |
| require_started: bool = True | |
| ) -> Optional[SandboxInfo]: | |
| resolver = get_resolver() | |
| return await resolver.resolve(project_id, account_id, db_client, require_started) | |