p5 0.10.0

A tui client for Pulumi
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use pulumi_automation::{
    local::{LocalStack, LocalWorkspace},
    workspace::Workspace,
};
use tokio::sync::mpsc;

use crate::actions::{AppAction, WorkspaceAction};

use super::AppTask;

#[derive(Clone)]
pub enum WorkspaceTask {
    ListStacks(LocalWorkspace),
    SelectWorkspace(String),
    SelectStack(LocalWorkspace, String),
    GetStackOutputs(LocalWorkspace, LocalStack),
    GetStackConfig(LocalWorkspace, LocalStack),
    GetStackState(LocalWorkspace, LocalStack),
}

impl WorkspaceTask {
    #[tracing::instrument(skip(self, task_tx, action_tx))]
    pub async fn run(
        &mut self,
        task_tx: &mpsc::Sender<AppTask>,
        action_tx: &mpsc::Sender<AppAction>,
    ) -> crate::Result<()> {
        match self {
            WorkspaceTask::ListStacks(workspace) => {
                if let Ok(stacks) = workspace.list_stacks(Default::default()) {
                    action_tx.try_send(AppAction::WorkspaceAction(
                        WorkspaceAction::PersistStacks(workspace.clone(), stacks),
                    ))?;
                } else {
                    tracing::error!("Failed to list stacks for workspace: {}", workspace.cwd);
                }

                Ok(())
            }
            WorkspaceTask::SelectWorkspace(cwd) => {
                let workspace = LocalWorkspace::new(cwd.clone());

                action_tx.try_send(AppAction::WorkspaceAction(
                    WorkspaceAction::PersistWorkspace(workspace.clone()),
                ))?;

                Ok(())
            }
            WorkspaceTask::SelectStack(workspace, stack_name) => {
                if let Ok(stack) = workspace.select_stack(stack_name.as_str()) {
                    action_tx.try_send(AppAction::WorkspaceAction(
                        WorkspaceAction::PersistStack(workspace.clone(), stack.clone()),
                    ))?;

                    task_tx.try_send(AppTask::WorkspaceTask(WorkspaceTask::GetStackConfig(
                        workspace.clone(),
                        stack.clone(),
                    )))?;
                } else {
                    tracing::error!("Failed to select stack: {}", stack_name);
                }

                Ok(())
            }
            WorkspaceTask::GetStackOutputs(workspace, stack) => {
                if let Ok(outputs) = workspace.stack_outputs(stack.name.as_str()) {
                    action_tx.try_send(AppAction::WorkspaceAction(
                        WorkspaceAction::PersistStackOutputs(
                            workspace.clone(),
                            stack.clone(),
                            outputs,
                        ),
                    ))?;
                } else {
                    tracing::error!("Failed to get stack outputs for stack: {}", stack.name);
                }

                Ok(())
            }
            WorkspaceTask::GetStackConfig(workspace, stack) => {
                if let Ok(config) = workspace.get_stack_config(stack.name.as_str()) {
                    action_tx.try_send(AppAction::WorkspaceAction(
                        WorkspaceAction::PersistStackConfig(
                            workspace.clone(),
                            stack.clone(),
                            config,
                        ),
                    ))?;
                } else {
                    tracing::error!("Failed to get stack config for stack: {}", stack.name);
                }

                Ok(())
            }
            WorkspaceTask::GetStackState(workspace, stack) => {
                if let Ok(state) = workspace.export_stack(stack.name.as_str()) {
                    action_tx.try_send(AppAction::WorkspaceAction(
                        WorkspaceAction::PersistStackState(workspace.clone(), stack.clone(), state),
                    ))?;
                } else {
                    tracing::error!("Failed to get stack state for stack: {}", stack.name);
                }

                Ok(())
            }
        }
    }
}