135 lines
4.4 KiB
Rust
135 lines
4.4 KiB
Rust
use std::process::ExitStatus;
|
|
|
|
use anyhow::Result;
|
|
use gpui::{AppContext, Context, Entity, Task};
|
|
use language::Buffer;
|
|
use project::{TaskSourceKind, WorktreeId};
|
|
use remote::ConnectionState;
|
|
use task::{DebugScenario, ResolvedTask, SpawnInTerminal, TaskContext, TaskTemplate};
|
|
use ui::Window;
|
|
|
|
use crate::{Toast, Workspace, notifications::NotificationId};
|
|
|
|
impl Workspace {
|
|
pub fn schedule_task(
|
|
self: &mut Workspace,
|
|
task_source_kind: TaskSourceKind,
|
|
task_to_resolve: &TaskTemplate,
|
|
task_cx: &TaskContext,
|
|
omit_history: bool,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
match self.project.read(cx).remote_connection_state(cx) {
|
|
None | Some(ConnectionState::Connected) => {}
|
|
Some(
|
|
ConnectionState::Connecting
|
|
| ConnectionState::Disconnected
|
|
| ConnectionState::HeartbeatMissed
|
|
| ConnectionState::Reconnecting,
|
|
) => {
|
|
log::warn!("Cannot schedule tasks when disconnected from a remote host");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if let Some(spawn_in_terminal) =
|
|
task_to_resolve.resolve_task(&task_source_kind.to_id_base(), task_cx)
|
|
{
|
|
self.schedule_resolved_task(
|
|
task_source_kind,
|
|
spawn_in_terminal,
|
|
omit_history,
|
|
window,
|
|
cx,
|
|
);
|
|
}
|
|
}
|
|
|
|
pub fn schedule_resolved_task(
|
|
self: &mut Workspace,
|
|
task_source_kind: TaskSourceKind,
|
|
resolved_task: ResolvedTask,
|
|
omit_history: bool,
|
|
window: &mut Window,
|
|
cx: &mut Context<Workspace>,
|
|
) {
|
|
let spawn_in_terminal = resolved_task.resolved.clone();
|
|
if !omit_history {
|
|
if let Some(debugger_provider) = self.debugger_provider.as_ref() {
|
|
debugger_provider.task_scheduled(cx);
|
|
}
|
|
|
|
self.project().update(cx, |project, cx| {
|
|
if let Some(task_inventory) =
|
|
project.task_store().read(cx).task_inventory().cloned()
|
|
{
|
|
task_inventory.update(cx, |inventory, _| {
|
|
inventory.task_scheduled(task_source_kind, resolved_task);
|
|
})
|
|
}
|
|
});
|
|
}
|
|
|
|
if let Some(terminal_provider) = self.terminal_provider.as_ref() {
|
|
let task_status = terminal_provider.spawn(spawn_in_terminal, window, cx);
|
|
|
|
let task = cx.spawn(async |w, cx| {
|
|
let res = cx.background_spawn(task_status).await;
|
|
match res {
|
|
Some(Ok(status)) => {
|
|
if status.success() {
|
|
log::debug!("Task spawn succeeded");
|
|
} else {
|
|
log::debug!("Task spawn failed, code: {:?}", status.code());
|
|
}
|
|
}
|
|
Some(Err(e)) => {
|
|
log::error!("Task spawn failed: {e:#}");
|
|
_ = w.update(cx, |w, cx| {
|
|
let id = NotificationId::unique::<ResolvedTask>();
|
|
w.show_toast(Toast::new(id, format!("Task spawn failed: {e}")), cx);
|
|
})
|
|
}
|
|
None => log::debug!("Task spawn got cancelled"),
|
|
};
|
|
});
|
|
self.scheduled_tasks.push(task);
|
|
}
|
|
}
|
|
|
|
pub fn start_debug_session(
|
|
&mut self,
|
|
scenario: DebugScenario,
|
|
task_context: TaskContext,
|
|
active_buffer: Option<Entity<Buffer>>,
|
|
worktree_id: Option<WorktreeId>,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if let Some(provider) = self.debugger_provider.as_mut() {
|
|
provider.start_session(
|
|
scenario,
|
|
task_context,
|
|
active_buffer,
|
|
worktree_id,
|
|
window,
|
|
cx,
|
|
)
|
|
}
|
|
}
|
|
|
|
pub fn spawn_in_terminal(
|
|
self: &mut Workspace,
|
|
spawn_in_terminal: SpawnInTerminal,
|
|
window: &mut Window,
|
|
cx: &mut Context<Workspace>,
|
|
) -> Task<Option<Result<ExitStatus>>> {
|
|
if let Some(terminal_provider) = self.terminal_provider.as_ref() {
|
|
terminal_provider.spawn(spawn_in_terminal, window, cx)
|
|
} else {
|
|
Task::ready(None)
|
|
}
|
|
}
|
|
}
|