tinkc 0.1.6

Tinkerbell tink grpc client wrapper
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

extern crate juniper;
#[macro_use]
extern crate juniper_codegen;
use eyre::Result;
use serde::Deserialize;
use thiserror::Error;
use tinkc::Tink;

#[derive(Debug, Deserialize, GraphQLObject)]
struct Hardware {
    device: String,
    image: String,
}

#[derive(Debug, GraphQLEnum)]
enum WorkflowState {
    Pending,
    Running,
    Failed,
    Timeout,
    Success,
}

#[derive(Error, Debug)]
enum WorkflowError {
    #[error("Invalid workflow state {0}")]
    InvalidWorkflowState(i32),
}

impl TryFrom<i32> for WorkflowState {
    type Error = WorkflowError;

    fn try_from(i: i32) -> std::result::Result<Self, Self::Error> {
        match i {
            0 => Ok(WorkflowState::Pending),
            1 => Ok(WorkflowState::Running),
            2 => Ok(WorkflowState::Failed),
            3 => Ok(WorkflowState::Timeout),
            4 => Ok(WorkflowState::Success),
            e => Err(WorkflowError::InvalidWorkflowState(e)),
        }
    }
}

#[derive(Debug, GraphQLObject)]
struct Workflow {
    id: String,
    hardware: Hardware,
    state: WorkflowState,
}

impl TryFrom<tinkc::Workflow> for Workflow {
    type Error = eyre::Error;
    fn try_from(wf: tinkc::Workflow) -> std::result::Result<Workflow, Self::Error> {
        Ok(Workflow {
            state: wf.state.try_into()?,
            hardware: serde_json::from_str(&wf.hardware)?,
            id: wf.id,
        })
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    let mut client = Tink::new(
        "http://[::1]:42113",
        "examples/data/tls/ca.pem",
        "localhost",
    )
    .await?;
    let workflows: Vec<Workflow> = client.workflows().await?;
    for workflow in workflows.iter() {
        println!("{:?}", workflow);
    }
    Ok(())
}