kinetics 0.16.7

Kinetics is a hosting platform for Rust applications that allows you to deploy all types of workloads by writing **only Rust code**.
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

use crate::error::Error;
use crate::project::Project;
use crate::runner::{Runnable, Runner};
use crate::writer::Writer;
use color_eyre::owo_colors::OwoColorize;
use eyre::WrapErr;
use serde_json::{json, Value};
use std::path::PathBuf;

#[derive(clap::Args, Clone)]
pub(crate) struct ListCommand {
    /// Organization to list projects for. Defaults to the current project's org from kinetics.toml.
    #[arg(long)]
    org: Option<String>,

    /// Relative path to the project directory
    #[arg(long)]
    project: Option<PathBuf>,
}

impl Runnable for ListCommand {
    fn runner(&self, writer: &Writer) -> impl Runner {
        ListRunner {
            writer,
            org: self.org.clone(),
            project: self.project.clone(),
        }
    }
}

struct ListRunner<'a> {
    writer: &'a Writer,
    org: Option<String>,
    project: Option<PathBuf>,
}

impl Runner for ListRunner<'_> {
    /// Prints out the list of all projects
    async fn run(&mut self) -> Result<(), Error> {
        // Let it fail if user's logged out
        self.api_client().await?;

        self.writer.text(&format!(
            "{}...\n\n",
            console::style("Fetching projects").green().bold()
        ))?;

        let project = self
            .config_project()
            .map_err(|e| self.error(None, None, Some(e.into())))?;

        let org = self
            .org
            .as_deref()
            .or(project.as_ref().and_then(|project| project.org.as_deref()));

        let projects = Project::fetch_all(org)
            .await
            .map_err(|e| self.server_error(Some(e.into())))?;

        if projects.is_empty() {
            self.writer
                .text(&format!("{}", console::style("No projects found").yellow()))?;

            self.writer.json(json!({"success": true, "projects": []}))?;
            return Ok(());
        }

        let mut projects_json: Vec<Value> = vec![];

        for Project { name, url, .. } in &projects {
            self.writer
                .text(&format!("{}\n{}\n\n", name.bold(), url.dimmed()))?;

            projects_json.push(json!({"name": name, "url": url}));
        }

        self.writer
            .json(json!({"success": true, "projects": projects_json}))?;

        Ok(())
    }
}

impl ListRunner<'_> {
    /// Returns the project from the config file, if one exists
    fn config_project(&self) -> eyre::Result<Option<Project>> {
        let path = std::env::current_dir()
            .wrap_err("Failed to get current dir")?
            .join(self.project.clone().unwrap_or_default());

        if !path.join("kinetics.toml").exists() {
            return Ok(None);
        }

        Project::from_path(path).map(Some)
    }
}