lumen-server 0.2.2

Embeddable render service primitives and local HTTP server for Lumen.
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

use std::{collections::HashMap, future::Future, path::PathBuf, pin::Pin, time::Instant};

use serde_json::Value;

pub type ServiceResult<T> = Result<T, ServiceError>;
pub type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;

#[derive(Debug, Clone)]
pub struct RenderJob {
    pub id: RenderJobId,
    pub project: Value,
    pub media_root: Option<PathBuf>,
    pub video_encoder: Option<String>,
    pub metadata: HashMap<String, String>,
}

impl RenderJob {
    pub fn new(id: impl Into<String>, project: Value) -> Self {
        Self {
            id: RenderJobId(id.into()),
            project,
            media_root: None,
            video_encoder: None,
            metadata: HashMap::new(),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct RenderJobId(pub String);

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct RenderLeaseId(pub String);

#[derive(Debug, Clone)]
pub struct RenderLease {
    pub id: RenderLeaseId,
    pub job: RenderJob,
    pub leased_until: Instant,
}

#[derive(Debug, Clone)]
pub struct WorkerId(pub String);

#[derive(Debug, Clone)]
pub struct RenderOutput {
    pub bytes: Vec<u8>,
    pub content_type: &'static str,
    pub metrics: RenderMetrics,
}

#[derive(Debug, Clone)]
pub struct RenderMetrics {
    pub render_ms: u128,
    pub total_frames: u64,
}

#[derive(Debug, Clone)]
pub struct ArtifactWrite {
    pub job_id: RenderJobId,
    pub bytes: Vec<u8>,
    pub content_type: &'static str,
}

#[derive(Debug, Clone)]
pub struct ArtifactRef {
    pub id: String,
    pub content_type: &'static str,
    pub bytes: usize,
    pub uri: String,
}

#[derive(Debug, Clone)]
pub struct ProgressEvent {
    pub job_id: RenderJobId,
    pub stage: String,
    pub ratio: f32,
    pub frame: Option<u32>,
    pub total_frames: Option<u32>,
}

#[derive(Debug, Clone)]
pub struct ServiceError {
    pub code: &'static str,
    pub message: String,
    pub retryable: bool,
}

impl std::fmt::Display for ServiceError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}: {}", self.code, self.message)
    }
}

impl std::error::Error for ServiceError {}

impl From<crate::render::RenderError> for ServiceError {
    fn from(error: crate::render::RenderError) -> Self {
        Self {
            code: error.code,
            message: error.message,
            retryable: error.retryable,
        }
    }
}