crankshaft-engine 0.6.0

The core engine that comprises Crankshaft
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
109
110
111
112
113
114
115
116
117
118

//! Task inputs.

use anyhow::Context;
use anyhow::Result;
use bon::Builder;

mod contents;

pub use contents::Contents;

/// A type of input.
#[derive(Clone, Debug)]
pub enum Type {
    /// A file.
    File,

    /// A directory.
    Directory,
}

/// An input to a task.
#[derive(Builder, Clone, Debug)]
#[builder(builder_type = Builder)]
pub struct Input {
    /// An optional name to give the input.
    #[builder(into)]
    pub(crate) name: Option<String>,

    /// A description of the input.
    #[builder(into)]
    pub(crate) description: Option<String>,

    /// The contents of the input.
    #[builder(into)]
    pub(crate) contents: Contents,

    /// The expected guest path of the input.
    #[builder(into)]
    pub(crate) path: String,

    /// The type of the input.
    #[builder(into)]
    pub(crate) ty: Type,

    /// Whether or not the input should be treated as read-only.
    ///
    /// Defaults to `true`.
    #[builder(default = true)]
    pub(crate) read_only: bool,
}

impl Input {
    /// The name of the input (if it exists).
    pub fn name(&self) -> Option<&str> {
        self.name.as_deref()
    }

    /// The description of the input (if it exists).
    pub fn description(&self) -> Option<&str> {
        self.description.as_deref()
    }

    /// The contents of the input.
    pub fn contents(&self) -> &Contents {
        &self.contents
    }

    /// The path where the input should be placed within the container.
    pub fn path(&self) -> &str {
        &self.path
    }

    /// The type of the container.
    pub fn ty(&self) -> &Type {
        &self.ty
    }

    /// Gets whether or not the input is read-only.
    ///
    /// Inputs are read-only by default.
    pub fn read_only(&self) -> bool {
        self.read_only
    }
}

impl TryFrom<Input> for tes::v1::types::task::Input {
    type Error = anyhow::Error;

    fn try_from(input: Input) -> Result<Self, Self::Error> {
        let Input {
            name,
            description,
            contents,
            path,
            ty,
            read_only: _,
        } = input;

        let (url, content) = contents.one_hot()?;

        let ty = match ty {
            Type::File => tes::v1::types::task::IoType::File,
            Type::Directory => tes::v1::types::task::IoType::Directory,
        };

        Ok(tes::v1::types::task::Input {
            name,
            description,
            url: url.map(|url| url.to_string()),
            path,
            ty,
            content: content
                .map(|v| String::from_utf8(v).context("TES requires file content to be UTF-8"))
                .transpose()?,
            streamable: None,
        })
    }
}