auv-cli-invoke 0.0.22

Application Use Via... script-able OS automation library
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
119
120

use auv_tracing::{ArtifactMetadata, EmitBytesOptions, EventPayload, NewArtifact};
use image::{ExtendedColorType, ImageEncoder, RgbaImage, codecs::png::PngEncoder};

#[derive(serde::Serialize)]
struct ArtifactPreparationFailed {
  purpose: String,
  error: String,
}

impl EventPayload for ArtifactPreparationFailed {
  const NAME: &'static str = "auv.invoke.artifact_preparation_failed";
  const VERSION: u32 = 1;
}

pub(crate) fn emit_png(purpose: &str, image: &RgbaImage) {
  if !auv_tracing::Context::current().can_publish_artifacts() {
    return;
  }
  match prepare_png(purpose, image) {
    Ok(emission) => drop(emission),
    Err(error) => emit_preparation_failure(purpose, error),
  }
}

pub(crate) async fn emit_png_with_receipt(purpose: &str, image: &RgbaImage) -> Option<ArtifactMetadata> {
  if !auv_tracing::Context::current().can_publish_artifacts() {
    return None;
  }
  let emission = match prepare_png(purpose, image) {
    Ok(emission) => emission,
    Err(error) => {
      emit_preparation_failure(purpose, error);
      return None;
    }
  };
  match emission.await {
    Ok(metadata) => metadata,
    Err(error) => {
      emit_preparation_failure(purpose, error.to_string());
      None
    }
  }
}

fn prepare_png(purpose: &str, image: &RgbaImage) -> Result<auv_tracing::ArtifactEmission, String> {
  let mut body = Vec::new();
  PngEncoder::new(&mut body)
    .write_image(image.as_raw(), image.width(), image.height(), ExtendedColorType::Rgba8)
    .map_err(|error| format!("failed to encode {purpose} PNG artifact: {error}"))
    .and_then(|()| {
      let options = EmitBytesOptions::new().with_purpose(purpose).with_content_type("image/png").with_file_extension("png");
      auv_tracing::emit_bytes_artifact(options, body).map_err(|error| format!("invalid {purpose} artifact bytes: {error}"))
    })
}

fn emit_preparation_failure(purpose: &str, error: String) {
  auv_tracing::emit_event!(ArtifactPreparationFailed {
    purpose: purpose.to_string(),
    error,
  });
}

pub(crate) async fn emit_bytes_with_receipt(options: EmitBytesOptions, body: Vec<u8>) -> Option<ArtifactMetadata> {
  if !auv_tracing::Context::current().can_publish_artifacts() {
    return None;
  }
  let purpose = options.purpose().to_string();
  let emission = match auv_tracing::emit_bytes_artifact(options, body).map_err(|error| format!("invalid {purpose} artifact bytes: {error}"))
  {
    Ok(emission) => emission,
    Err(error) => {
      auv_tracing::emit_event!(ArtifactPreparationFailed { purpose, error });
      return None;
    }
  };
  emission.await.ok().flatten()
}

pub(crate) fn emit_prepared<R>(purpose: &str, artifact: Result<NewArtifact<R>, String>)
where
  R: futures_util::io::AsyncRead + Unpin + Send + 'static,
{
  if !auv_tracing::Context::current().can_publish_artifacts() {
    return;
  }
  match artifact {
    Ok(artifact) => drop(auv_tracing::emit_artifact!(artifact)),
    Err(error) => auv_tracing::emit_event!(ArtifactPreparationFailed {
      purpose: purpose.to_string(),
      error,
    }),
  }
}

pub(crate) async fn emit_prepared_with_receipt<R>(purpose: &str, artifact: Result<NewArtifact<R>, String>) -> Option<ArtifactMetadata>
where
  R: futures_util::io::AsyncRead + Unpin + Send + 'static,
{
  if !auv_tracing::Context::current().can_publish_artifacts() {
    return None;
  }
  let emission = match artifact {
    Ok(artifact) => auv_tracing::emit_artifact!(artifact),
    Err(error) => {
      emit_preparation_failure(purpose, error);
      return None;
    }
  };
  match emission.await {
    Ok(metadata) => metadata,
    Err(error) => {
      emit_preparation_failure(purpose, error.to_string());
      None
    }
  }
}

#[cfg(test)]
#[path = "artifact_test.rs"]
mod tests;