kinetics 0.15.1

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

use crate::api::auth;
use crate::credentials::Credentials;
use crate::error::Error;
use crate::runner::{Runnable, Runner};
use crate::writer::Writer;
use eyre::Context;
use serde_json::json;

#[derive(clap::Args, Clone)]
pub(crate) struct LogoutCommand {}

impl Runnable for LogoutCommand {
    fn runner(&self, writer: &Writer) -> impl Runner {
        LogoutRunner { writer }
    }
}

struct LogoutRunner<'a> {
    writer: &'a Writer,
}

impl Runner for LogoutRunner<'_> {
    /// Logs user out
    ///
    /// By cleaning up the local credentials file and voiding credentials on the backend
    async fn run(&mut self) -> Result<(), Error> {
        let credentials = Credentials::new().await?;

        if credentials.is_valid() {
            self.remove(&credentials.email)
                .await
                .wrap_err("Logout request failed")?;
        }

        credentials.delete()?;

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

        self.writer.json(json!({ "success": true }))?;
        Ok(())
    }
}

impl LogoutRunner<'_> {
    async fn remove(&mut self, email: &str) -> eyre::Result<()> {
        let client = self.api_client().await?;

        let response = client
            .post("/auth/logout")
            .json(&auth::logout::Request {
                email: email.to_owned(),
            })
            .send()
            .await?;

        if !response.status().is_success() {
            return Err(eyre::eyre!("Failed to logout: {}", response.text().await?));
        }

        Ok(())
    }
}