warpgate 0.35.0

Download, resolve, and manage Extism WASM plugins.
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 docker_credential::{CredentialRetrievalError, DockerCredential};
use oci_client::secrets::RegistryAuth;
use serde::{Deserialize, Serialize};
use tracing::{trace, warn};

/// Media type for a WASM file layer in an OCI image.
pub const WASM_LAYER_MEDIA_TYPE_WASM: &str = "application/wasm";

/// Media type for a TOML file layer in an OCI image.
pub const WASM_LAYER_MEDIA_TYPE_TOML: &str = "application/toml";

/// Media type for a JSON file layer in an OCI image.
pub const WASM_LAYER_MEDIA_TYPE_JSON: &str = "application/json";

/// Media type for a YAML file layer in an OCI image.
pub const WASM_LAYER_MEDIA_TYPE_YAML: &str = "application/yaml";

/// Media type for a Markdown file layer in an OCI image.
pub const WASM_LAYER_MEDIA_TYPE_MARKDOWN: &str = "text/markdown";

/// Media type for an uncompressed tarball layer in an OCI image.
pub const WASM_LAYER_MEDIA_TYPE_TAR: &str = "application/vnd.oci.image.layer.v1.tar";

/// Media type for a gzip compressed tarball layer in an OCI image.
pub const WASM_LAYER_MEDIA_TYPE_TAR_GZIP: &str = "application/vnd.oci.image.layer.v1.tar+gzip";

/// Media type for a zstd compressed tarball layer in an OCI image.
pub const WASM_LAYER_MEDIA_TYPE_TAR_ZSTD: &str = "application/vnd.oci.image.layer.v1.tar+zstd";

/// Configures an individual plugin registry.
#[derive(Clone, Debug, Default, Deserialize, Eq, Hash, PartialEq, Serialize)]
#[serde(default, rename_all = "kebab-case")]
#[cfg_attr(feature = "schematic", derive(schematic::Schematic))]
pub struct RegistryConfig {
    /// Whether this registry requires authentication or not.
    /// If true, we'll attempt to retrieve credentials from the Docker
    /// config for this registry's host.
    pub auth: bool,

    /// Whether this registry should be used as the default when
    /// no registry is specified in the locator, or when only an
    /// identifier is provided.
    pub default: bool,

    /// The domain/host of the registry.
    pub registry: String,

    /// An optional namespace to bucket the plugin into.
    /// This is typically the organization or user.
    pub namespace: Option<String>,
}

impl RegistryConfig {
    /// Return the Docker credentials for the current registry host.
    pub fn get_credential(&self) -> RegistryAuth {
        if !self.auth {
            return RegistryAuth::Anonymous;
        }

        match docker_credential::get_credential(&self.registry) {
            Ok(DockerCredential::UsernamePassword(username, password)) => {
                trace!("Found Docker credentials (username and password)");

                RegistryAuth::Basic(username, password)
            }
            Ok(DockerCredential::IdentityToken(_)) => {
                trace!(
                    "Cannot use contents of Docker config, identity token not supported; using anonymous auth"
                );

                RegistryAuth::Anonymous
            }
            Err(CredentialRetrievalError::ConfigNotFound) => RegistryAuth::Anonymous,
            Err(CredentialRetrievalError::NoCredentialConfigured) => RegistryAuth::Anonymous,
            Err(error) => {
                warn!("Error handling Docker configuration file: {error}; using anonymous auth");

                RegistryAuth::Anonymous
            }
        }
    }

    /// Return a fully-qualified reference with the provided ID.
    pub fn get_reference(&self, id: &str) -> String {
        let mut reference = String::new();
        reference.push_str(&self.registry);
        reference.push('/');

        if let Some(namespace) = &self.namespace {
            reference.push_str(namespace);
            reference.push('/');
        }

        reference.push_str(id);
        reference
    }

    /// Return a fully-qualified reference with the provided ID and tag.
    pub fn get_reference_with_tag(&self, id: &str, tag: &str) -> String {
        let mut reference = self.get_reference(id);
        reference.push(':');
        reference.push_str(tag);
        reference
    }
}