artifactize-core 0.11.0

The library behind artifactize: Artifacts, evals, reviews, the monitor and review models, and the shared operations every interface calls.
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

//! Repository discovery and verification workflows, without text rendering.

use super::{Context, cancellation_listener, print_json};
use serde_json::json;
use std::{
    io::{self, Write},
    path::PathBuf,
    time::Duration,
};

use super::{PolicyArgs, SelectionArgs, outcome_code};
use crate::{config::read_workspace_config, project::selection::Selection};

/// Execution-only arguments, separate from selection and dependency policy.
pub(super) struct VerifyLimits {
    pub jobs: u32,
    pub max_executions: Option<u64>,
    pub timeout_ms: Option<Duration>,
    pub reuse_only: Vec<crate::config::ProfileKind>,
}

pub(super) async fn verify(
    context: Context,
    selection: SelectionArgs,
    policy: PolicyArgs,
    limits: VerifyLimits,
) -> Result<u8, String> {
    let VerifyLimits {
        jobs,
        max_executions,
        timeout_ms,
        reuse_only,
    } = limits;
    let selection = selection.resolve()?;
    let options = crate::project::VerifyOptions {
        jobs: jobs as usize,
        max_executions,
        wait_timeout: timeout_ms.unwrap_or(crate::project::DEFAULT_HUMAN_WAIT),
        reuse_only: reuse_only.into_iter().collect(),
        announce_run: true,
        ..policy.options()
    };
    let (cancellation, listener) = cancellation_listener()?;
    let result = crate::project::verify(
        &context.repo.unwrap_or_else(|| PathBuf::from(".")),
        context.state_dir.as_deref(),
        &selection,
        &options,
        cancellation,
    )
    .await;
    listener.abort();
    let view = result?;
    super::render::verify(&view, context.json)?;
    Ok(outcome_code(&view.run))
}

pub(super) async fn status(
    context: Context,
    selection: SelectionArgs,
    policy: PolicyArgs,
) -> Result<u8, String> {
    let selection = selection.resolve()?;
    let (cancellation, listener) = cancellation_listener()?;
    let result = crate::project::status(
        &context.repo.unwrap_or_else(|| PathBuf::from(".")),
        context.state_dir.as_deref(),
        &selection,
        &policy.options(),
        cancellation,
    )
    .await;
    listener.abort();
    let view = result?;
    if context.json {
        print_json(&view)?;
    } else {
        super::render::status(&view).map_err(|error| error.to_string())?;
    }
    Ok(u8::from(!view.satisfied))
}

pub(super) async fn graph(
    context: Context,
    artifact: Option<crate::types::ArtifactName>,
) -> Result<u8, String> {
    let config = read_workspace_config(&context.repo.unwrap_or_else(|| PathBuf::from(".")))
        .map_err(|error| error.to_string())?;
    let selection = artifact.map_or(Selection::All, |artifact_id| Selection::Artifact {
        artifact_id,
    });
    let view = crate::query::graph(&config, &selection)?;
    if context.json {
        print_json(&view)?;
    } else {
        super::render::graph(&view).map_err(|error| error.to_string())?;
    }
    Ok(0)
}

pub(super) async fn check(context: Context) -> Result<u8, String> {
    let repo = context.repo.unwrap_or_else(|| PathBuf::from("."));
    let config = read_workspace_config(&repo).map_err(|error| error.to_string())?;
    let mut stdout = io::stdout().lock();
    if context.json {
        writeln!(
            stdout,
            "{}",
            json!({ "ok": true, "artifacts": config.artifacts.len(), "evals": config.evals.len() })
        )
    } else {
        writeln!(stdout, "Folder configuration is valid.")
    }
    .map_err(|error| error.to_string())?;
    Ok(0)
}