Struct LocalContainerService 

pub struct LocalContainerService { /* private fields */ }

Implementations

impl LocalContainerService

pub fn new( db: DBService, msg_stores: Arc<RwLock<HashMap<Uuid, Arc<MsgStore>>>>, config: Arc<RwLock<Config>>, git: GitService, image_service: ImageService, analytics: Option<AnalyticsContext>, approvals: Approvals, ) -> Self

pub async fn get_child_from_store( &self, id: &Uuid, ) -> Option<Arc<RwLock<AsyncGroupChild>>>

pub async fn add_child_to_store(&self, id: Uuid, exec: AsyncGroupChild)

pub async fn remove_child_from_store(&self, id: &Uuid)

pub async fn cleanup_expired_attempt( db: &DBService, attempt_id: Uuid, worktree_path: PathBuf, git_repo_path: PathBuf, ) -> Result<(), DeploymentError>

pub async fn cleanup_expired_attempts( db: &DBService, ) -> Result<(), DeploymentError>

pub async fn spawn_worktree_cleanup(&self)

pub fn spawn_exit_monitor( &self, exec_id: &Uuid, exit_signal: Option<Receiver<()>>, ) -> JoinHandle<()>

Spawn a background task that polls the child process for completion and cleans up the execution entry when it exits.

pub fn spawn_os_exit_watcher( &self, exec_id: Uuid, ) -> Receiver<Result<ExitStatus>>

pub fn dir_name_from_task_attempt(attempt_id: &Uuid, task_title: &str) -> String

Trait Implementations

impl Clone for LocalContainerService

fn clone(&self) -> LocalContainerService

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ContainerService for LocalContainerService

fn create<'life0, 'life1, 'async_trait>( &'life0 self, task_attempt: &'life1 TaskAttempt, ) -> Pin<Box<dyn Future<Output = Result<ContainerRef, ContainerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create a container

fn copy_project_files<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, source_dir: &'life1 Path, target_dir: &'life2 Path, copy_files: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<(), ContainerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Copy files from the original project directory to the worktree

fn create_for_run<'life0, 'life1, 'async_trait>( &'life0 self, execution_run: &'life1 ExecutionRun, ) -> Pin<Box<dyn Future<Output = Result<ContainerRef, ContainerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create a worktree for an execution run

fn start_execution_inner_for_run<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, execution_run: &'life1 ExecutionRun, execution_process: &'life2 ExecutionProcess, executor_action: &'life3 ExecutorAction, ) -> Pin<Box<dyn Future<Output = Result<(), ContainerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Inner start execution for runs

fn msg_stores(&self) -> &Arc<RwLock<HashMap<Uuid, Arc<MsgStore>>>>

fn db(&self) -> &DBService

fn git(&self) -> &GitService

fn git_branch_prefix<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = String> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn task_attempt_to_current_dir(&self, task_attempt: &TaskAttempt) -> PathBuf

fn delete_inner<'life0, 'life1, 'async_trait>( &'life0 self, task_attempt: &'life1 TaskAttempt, ) -> Pin<Box<dyn Future<Output = Result<(), ContainerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn ensure_container_exists<'life0, 'life1, 'async_trait>( &'life0 self, task_attempt: &'life1 TaskAttempt, ) -> Pin<Box<dyn Future<Output = Result<ContainerRef, ContainerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn is_container_clean<'life0, 'life1, 'async_trait>( &'life0 self, task_attempt: &'life1 TaskAttempt, ) -> Pin<Box<dyn Future<Output = Result<bool, ContainerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn start_execution_inner<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, task_attempt: &'life1 TaskAttempt, execution_process: &'life2 ExecutionProcess, executor_action: &'life3 ExecutorAction, ) -> Pin<Box<dyn Future<Output = Result<(), ContainerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn stop_execution<'life0, 'life1, 'async_trait>( &'life0 self, execution_process: &'life1 ExecutionProcess, status: ExecutionProcessStatus, ) -> Pin<Box<dyn Future<Output = Result<(), ContainerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn stream_diff<'life0, 'life1, 'async_trait>( &'life0 self, task_attempt: &'life1 TaskAttempt, stats_only: bool, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'static, Result<LogMsg, Error>>, ContainerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Stream diff updates as LogMsg for WebSocket endpoints.

fn try_commit_changes<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 ExecutionContext, ) -> Pin<Box<dyn Future<Output = Result<bool, ContainerError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, task_attempt: &'life1 TaskAttempt, ) -> Pin<Box<dyn Future<Output = Result<(), ContainerError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

fn has_running_processes<'life0, 'async_trait>( &'life0 self, task_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<bool, ContainerError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Check if a task has any running execution processes

fn stop_task_processes<'life0, 'life1, 'async_trait>( &'life0 self, task_attempts: &'life1 [TaskAttempt], ) -> Pin<Box<dyn Future<Output = Result<(), ContainerError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Stop execution processes for task attempts without cleanup

fn cleanup_action( &self, cleanup_script: Option<String>, ) -> Option<Box<ExecutorAction>>

fn try_stop<'life0, 'life1, 'async_trait>( &'life0 self, task_attempt: &'life1 TaskAttempt, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

fn get_msg_store_by_id<'life0, 'life1, 'async_trait>( &'life0 self, uuid: &'life1 Uuid, ) -> Pin<Box<dyn Future<Output = Option<Arc<MsgStore>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Fetch the MsgStore for a given execution ID, panicking if missing.

fn git_branch_from_task_attempt<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, attempt_id: &'life1 Uuid, task_title: &'life2 str, ) -> Pin<Box<dyn Future<Output = String> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

fn stream_raw_logs<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 Uuid, ) -> Pin<Box<dyn Future<Output = Option<Pin<Box<dyn Stream<Item = Result<LogMsg, Error>> + Send>>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

fn stream_normalized_logs<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 Uuid, ) -> Pin<Box<dyn Future<Output = Option<Pin<Box<dyn Stream<Item = Result<LogMsg, Error>> + Send>>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

fn spawn_stream_raw_logs_to_db(&self, execution_id: &Uuid) -> JoinHandle<()>

fn start_attempt<'life0, 'life1, 'async_trait>( &'life0 self, task_attempt: &'life1 TaskAttempt, executor_profile_id: ExecutorProfileId, ) -> Pin<Box<dyn Future<Output = Result<ExecutionProcess, ContainerError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

fn start_execution<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, task_attempt: &'life1 TaskAttempt, executor_action: &'life2 ExecutorAction, run_reason: &'life3 ExecutionProcessRunReason, ) -> Pin<Box<dyn Future<Output = Result<ExecutionProcess, ContainerError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

fn try_start_next_action<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 ExecutionContext, ) -> Pin<Box<dyn Future<Output = Result<(), ContainerError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

fn exit_plan_mode_tool<'life0, 'async_trait>( &'life0 self, ctx: ExecutionContext, ) -> Pin<Box<dyn Future<Output = Result<(), ContainerError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

fn execution_run_to_current_dir(&self, execution_run: &ExecutionRun) -> PathBuf

Get the current directory for an execution run (worktree path)

fn start_run<'life0, 'life1, 'async_trait>( &'life0 self, execution_run: &'life1 ExecutionRun, executor_profile_id: ExecutorProfileId, ) -> Pin<Box<dyn Future<Output = Result<ExecutionProcess, ContainerError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Start an execution run - lightweight executor invocation without Task

fn start_execution_for_run<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, execution_run: &'life1 ExecutionRun, executor_action: &'life2 ExecutorAction, run_reason: &'life3 ExecutionProcessRunReason, ) -> Pin<Box<dyn Future<Output = Result<ExecutionProcess, ContainerError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Start execution for an execution run (reuses executor spawning logic)

fn stream_raw_logs_for_run<'life0, 'life1, 'async_trait>( &'life0 self, execution_run_id: &'life1 Uuid, ) -> Pin<Box<dyn Future<Output = Option<Pin<Box<dyn Stream<Item = Result<LogMsg, Error>> + Send>>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Stream raw logs for an execution run