lal 3.8.0

A strict, language-agnostic build system and dependency manager
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

use std::path::PathBuf;

use core::LalResult;
use super::{ArtifactoryConfig, LocalConfig};

/// An enum struct for the currently configured `Backend`
///
/// Any other implementations should be imported and listed here.
/// Currently only artifactory is supported.
#[derive(Serialize, Deserialize, Clone)]
pub enum BackendConfiguration {
    /// Config for the `ArtifactoryBackend`
    #[serde(rename = "artifactory")]
    Artifactory(ArtifactoryConfig),

    /// Config for the `LocalBackend`
    #[serde(rename = "local")]
    Local(LocalConfig),
}

/// Artifactory is the default backend
impl Default for BackendConfiguration {
    fn default() -> Self { BackendConfiguration::Artifactory(ArtifactoryConfig::default()) }
}


/// The basic definition of a component as it exists online
///
/// A component may have many build artifacts from many environments.
pub struct Component {
    /// Name of the component
    pub name: String,
    /// Version number
    pub version: u32,
    /// The raw location of the component at the specified version number
    ///
    /// No restriction on how this information is encoded, but it must work with `raw_fetch`
    pub location: String,
}

/// Properties a storage backend of artifacts should have
///
/// We are not really relying on Artifactory specific quirks in our default usage
/// so that in case it fails it can be switched over.
/// We do rely on there being a basic API that can implement this trait though.
pub trait Backend {
    /// Get a list of versions for a component in descending order
    fn get_versions(&self, name: &str, loc: &str) -> LalResult<Vec<u32>>;
    /// Get the latest version of a component
    fn get_latest_version(&self, name: &str, loc: &str) -> LalResult<u32>;

    /// Get the version and location information of a component
    ///
    /// If no version is given, figure out what latest is
    fn get_component_info(&self, name: &str, ver: Option<u32>, loc: &str) -> LalResult<Component>;

    /// Publish a release build's ARTIFACT to a specific location
    ///
    /// This will publish everything inside the ARTIFACT dir created by `lal build -r`
    fn publish_artifact(&self, name: &str, version: u32, env: &str) -> LalResult<()>;

    /// Raw fetch of location to a destination
    ///
    /// location can be a HTTPS url / a system path / etc (depending on the backend)
    fn raw_fetch(&self, location: &str, dest: &PathBuf) -> LalResult<()>;

    /// Return the base directory to be used to dump cached downloads
    ///
    /// This has to be in here for `CachedBackend` to have a straight dependency
    fn get_cache_dir(&self) -> String;
}

/// A secondary trait that builds upon the Backend trait
///
/// This wraps the common fetch commands in a caching layer on the cache dir.
pub trait CachedBackend {
    /// Get the latest version of a component across all supported environments
    fn get_latest_supported_versions(
        &self,
        name: &str,
        environments: Vec<String>,
    ) -> LalResult<Vec<u32>>;

    /// Retrieve the location to a cached published component (downloading if necessary)
    fn retrieve_published_component(
        &self,
        name: &str,
        version: Option<u32>,
        env: &str,
    ) -> LalResult<(PathBuf, Component)>;

    /// Retrieve the location to a stashed component
    fn retrieve_stashed_component(&self, name: &str, code: &str) -> LalResult<PathBuf>;

    /// Retrieve and unpack a cached component in INPUT
    fn unpack_published_component(
        &self,
        name: &str,
        version: Option<u32>,
        env: &str,
    ) -> LalResult<Component>;

    /// Retrieve and unpack a stashed component to INPUT
    fn unpack_stashed_component(&self, name: &str, code: &str) -> LalResult<()>;

    /// Add a stashed component from a folder
    fn stash_output(&self, name: &str, code: &str) -> LalResult<()>;
}