nniback / core /sandbox /resolver.py
Kyrlos11's picture
Upload 842 files
22087d0 verified
Raw History Blame Contribute Delete
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
@dataclass
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()
@classmethod
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)