#![forbid(unsafe_code)]
use std::collections::HashMap;
use std::env;
use std::fmt;
use std::io::Read;
use std::sync::mpsc;
use std::thread;
use std::time::{Duration, Instant};
const DEFAULT_API_URL: &str = "https://api.envlet.dev";
const REQUEST_ATTEMPTS: usize = 3;
const RETRY_DELAYS: [Duration; 2] = [Duration::from_millis(400), Duration::from_millis(1600)];
const REQUEST_TIMEOUT: Duration = Duration::from_millis(2500);
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Error {
ConfigMissing,
ConfigInvalid,
Auth { code: String },
NotFound,
Network,
Api { code: String, status: u16 },
}
impl fmt::Display for Error {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::ConfigMissing => formatter.write_str("Envlet configuration is missing"),
Self::ConfigInvalid => formatter.write_str("Envlet configuration is invalid"),
Self::Auth { code } => write!(formatter, "Envlet authentication failed: {code}"),
Self::NotFound => formatter.write_str("Envlet value not found"),
Self::Network => formatter.write_str("could not reach the Envlet API"),
Self::Api { code, status } => {
write!(formatter, "Envlet API request failed: {code} (status {status})")
}
}
}
}
impl std::error::Error for Error {}
impl Error {
pub fn code(&self) -> &str {
match self {
Self::ConfigMissing => "config_missing",
Self::ConfigInvalid => "config_invalid",
Self::Auth { code } | Self::Api { code, .. } => code,
Self::NotFound => "not_found",
Self::Network => "network_error",
}
}
}
pub struct Options {
pub token: Option<String>,
pub api_url: Option<String>,
pub retry: bool,
pub override_existing: bool,
}
impl Default for Options {
fn default() -> Self {
Self {
token: None,
api_url: None,
retry: true,
override_existing: false,
}
}
}
pub fn load(options: &Options) -> Result<HashMap<String, String>, Error> {
let body = request("/v1/values", options)?;
let root = parse_json(&body).map_err(|_| invalid_response())?;
let values = root
.as_object()
.and_then(|object| object.get("values"))
.and_then(JsonValue::as_object)
.ok_or_else(invalid_response)?;
let mut result = HashMap::with_capacity(values.len());
for (name, value) in values {
let value = value.as_string().ok_or_else(invalid_response)?;
result.insert(name.clone(), value.to_owned());
}
Ok(result)
}
pub fn get(name: &str, options: &Options) -> Result<String, Error> {
let path = format!("/v1/values/{}", encode_path_segment(name));
let body = request(&path, options)?;
let root = parse_json(&body).map_err(|_| invalid_response())?;
root.as_object()
.and_then(|object| object.get("value"))
.and_then(JsonValue::as_string)
.map(str::to_owned)
.ok_or_else(invalid_response)
}
pub fn inject(options: &Options) -> Result<HashMap<String, String>, Error> {
let values = load(options)?;
if values.iter().any(|(name, value)| {
name.is_empty()
|| name.contains('=')
|| name.contains('\0')
|| value.contains('\0')
}) {
return Err(invalid_response());
}
for (name, value) in &values {
if !options.override_existing && env::var_os(name).is_some() {
continue;
}
env::set_var(name, value);
}
Ok(values)
}
fn request(path: &str, options: &Options) -> Result<String, Error> {
let token = resolve_token(options)?;
let api_url = resolve_api_url(options)?;
let url = format!("{api_url}{path}");
let attempts = if options.retry { REQUEST_ATTEMPTS } else { 1 };
let mut last_error = Error::Network;
for attempt in 0..attempts {
if attempt > 0 {
thread::sleep(RETRY_DELAYS[attempt - 1]);
}
let response = match bounded_get(&url, &token) {
Ok(response) => response,
Err(Error::Network) => {
last_error = Error::Network;
continue;
}
Err(error) => return Err(error),
};
let (status, body) = response;
if status == 200 {
return Ok(body);
}
let error = response_error(status, &body);
if status >= 500 {
last_error = error;
continue;
}
return Err(error);
}
Err(last_error)
}
fn resolve_token(options: &Options) -> Result<String, Error> {
let token = match &options.token {
Some(token) => token.clone(),
None => environment_string("ENVLET_TOKEN")?.ok_or(Error::ConfigMissing)?,
};
if token.is_empty()
|| !token.is_ascii()
|| token.bytes().any(|byte| byte <= 0x1f || byte == 0x7f)
{
return Err(Error::ConfigInvalid);
}
Ok(token)
}
fn resolve_api_url(options: &Options) -> Result<String, Error> {
let api_url = match &options.api_url {
Some(api_url) => api_url.clone(),
None => environment_string("ENVLET_API_URL")?
.unwrap_or_else(|| DEFAULT_API_URL.to_owned()),
};
let api_url = api_url.trim_end_matches('/');
if !(api_url.starts_with("http://") || api_url.starts_with("https://")) {
return Err(Error::ConfigInvalid);
}
Ok(api_url.to_owned())
}
fn environment_string(name: &str) -> Result<Option<String>, Error> {
match env::var(name) {
Ok(value) => Ok(Some(value)),
Err(env::VarError::NotPresent) => Ok(None),
Err(env::VarError::NotUnicode(_)) => Err(Error::ConfigInvalid),
}
}
fn response_error(status: u16, body: &str) -> Error {
let default_code = match status {
401 | 403 => "unauthorized",
404 => "not_found",
_ => "request_failed",
};
let code = error_code(body).unwrap_or_else(|| default_code.to_owned());
match status {
401 | 403 => Error::Auth { code },
404 if code == "not_found" => Error::NotFound,
_ => Error::Api { code, status },
}
}
fn error_code(body: &str) -> Option<String> {
let root = parse_json(body).ok()?;
root.as_object()?
.get("error")?
.as_object()?
.get("code")?
.as_string()
.filter(|code| !code.is_empty())
.map(str::to_owned)
}
fn invalid_response() -> Error {
Error::Api {
code: "invalid_response".to_owned(),
status: 200,
}
}
fn encode_path_segment(value: &str) -> String {
const HEX: &[u8; 16] = b"0123456789ABCDEF";
let mut encoded = String::with_capacity(value.len());
for byte in value.bytes() {
if byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'.' | b'_' | b'~') {
encoded.push(char::from(byte));
} else {
encoded.push('%');
encoded.push(char::from(HEX[(byte >> 4) as usize]));
encoded.push(char::from(HEX[(byte & 0x0f) as usize]));
}
}
encoded
}
fn remaining(deadline: Instant) -> Result<Duration, Error> {
deadline
.checked_duration_since(Instant::now())
.filter(|duration| !duration.is_zero())
.ok_or(Error::Network)
}
fn bounded_get(url: &str, bearer_token: &str) -> Result<(u16, String), Error> {
let deadline = Instant::now() + REQUEST_TIMEOUT;
let url = url.to_owned();
let bearer_token = bearer_token.to_owned();
let (sender, receiver) = mpsc::sync_channel(1);
let _request = thread::Builder::new()
.spawn(move || {
let _ = sender.send(ureq_get(&url, &bearer_token));
})
.map_err(|_| Error::Network)?;
receiver
.recv_timeout(remaining(deadline)?)
.map_err(|_| Error::Network)?
}
fn ureq_get(url: &str, bearer_token: &str) -> Result<(u16, String), Error> {
let agent = ureq::AgentBuilder::new()
.timeout(REQUEST_TIMEOUT)
.timeout_connect(REQUEST_TIMEOUT)
.timeout_read(REQUEST_TIMEOUT)
.timeout_write(REQUEST_TIMEOUT)
.build();
let authorization = format!("Bearer {bearer_token}");
let response = match agent
.get(url)
.set("Authorization", &authorization)
.set("Accept", "application/json")
.call()
{
Ok(response) => response,
Err(ureq::Error::Status(_, response)) => response,
Err(ureq::Error::Transport(_)) => return Err(Error::Network),
};
let status = response.status();
let mut body = String::new();
response
.into_reader()
.read_to_string(&mut body)
.map_err(|_| Error::Network)?;
Ok((status, body))
}
enum JsonValue {
Object(HashMap<String, JsonValue>),
String(String),
Other,
}
impl JsonValue {
fn as_object(&self) -> Option<&HashMap<String, JsonValue>> {
match self {
Self::Object(object) => Some(object),
_ => None,
}
}
fn as_string(&self) -> Option<&str> {
match self {
Self::String(value) => Some(value),
_ => None,
}
}
}
fn parse_json(input: &str) -> Result<JsonValue, ()> {
let mut parser = JsonParser { input, position: 0 };
let value = parser.parse_value()?;
parser.skip_whitespace();
if parser.position == input.len() {
Ok(value)
} else {
Err(())
}
}
struct JsonParser<'a> {
input: &'a str,
position: usize,
}
impl JsonParser<'_> {
fn parse_value(&mut self) -> Result<JsonValue, ()> {
self.skip_whitespace();
match self.peek() {
Some(b'{') => self.parse_object(),
Some(b'[') => self.parse_array(),
Some(b'"') => self.parse_string().map(JsonValue::String),
Some(b't') => self.parse_literal(b"true"),
Some(b'f') => self.parse_literal(b"false"),
Some(b'n') => self.parse_literal(b"null"),
Some(b'-' | b'0'..=b'9') => self.parse_number(),
_ => Err(()),
}
}
fn parse_object(&mut self) -> Result<JsonValue, ()> {
self.expect(b'{')?;
self.skip_whitespace();
let mut object = HashMap::new();
if self.consume(b'}') {
return Ok(JsonValue::Object(object));
}
loop {
self.skip_whitespace();
let name = self.parse_string()?;
self.skip_whitespace();
self.expect(b':')?;
let value = self.parse_value()?;
object.insert(name, value);
self.skip_whitespace();
if self.consume(b'}') {
return Ok(JsonValue::Object(object));
}
self.expect(b',')?;
}
}
fn parse_array(&mut self) -> Result<JsonValue, ()> {
self.expect(b'[')?;
self.skip_whitespace();
if self.consume(b']') {
return Ok(JsonValue::Other);
}
loop {
self.parse_value()?;
self.skip_whitespace();
if self.consume(b']') {
return Ok(JsonValue::Other);
}
self.expect(b',')?;
}
}
fn parse_string(&mut self) -> Result<String, ()> {
self.expect(b'"')?;
let mut value = String::new();
let mut segment_start = self.position;
loop {
let byte = self.peek().ok_or(())?;
match byte {
b'"' => {
value.push_str(&self.input[segment_start..self.position]);
self.position += 1;
return Ok(value);
}
b'\\' => {
value.push_str(&self.input[segment_start..self.position]);
self.position += 1;
let escaped = self.peek().ok_or(())?;
self.position += 1;
match escaped {
b'"' => value.push('"'),
b'\\' => value.push('\\'),
b'/' => value.push('/'),
b'b' => value.push('\u{0008}'),
b'f' => value.push('\u{000c}'),
b'n' => value.push('\n'),
b'r' => value.push('\r'),
b't' => value.push('\t'),
b'u' => value.push(self.parse_unicode_escape()?),
_ => return Err(()),
}
segment_start = self.position;
}
0x00..=0x1f => return Err(()),
_ => self.position += 1,
}
}
}
fn parse_unicode_escape(&mut self) -> Result<char, ()> {
let first = self.parse_hex_quad()?;
let code_point = if (0xd800..=0xdbff).contains(&first) {
self.expect(b'\\')?;
self.expect(b'u')?;
let second = self.parse_hex_quad()?;
if !(0xdc00..=0xdfff).contains(&second) {
return Err(());
}
0x10000 + (((first as u32 - 0xd800) << 10) | (second as u32 - 0xdc00))
} else if (0xdc00..=0xdfff).contains(&first) {
return Err(());
} else {
first as u32
};
char::from_u32(code_point).ok_or(())
}
fn parse_hex_quad(&mut self) -> Result<u16, ()> {
let end = self.position.checked_add(4).ok_or(())?;
let digits = self.input.as_bytes().get(self.position..end).ok_or(())?;
let digits = std::str::from_utf8(digits).map_err(|_| ())?;
let value = u16::from_str_radix(digits, 16).map_err(|_| ())?;
self.position = end;
Ok(value)
}
fn parse_literal(&mut self, literal: &[u8]) -> Result<JsonValue, ()> {
if self.input.as_bytes().get(self.position..self.position + literal.len()) == Some(literal) {
self.position += literal.len();
Ok(JsonValue::Other)
} else {
Err(())
}
}
fn parse_number(&mut self) -> Result<JsonValue, ()> {
self.consume(b'-');
if !self.consume(b'0') {
self.consume_range(b'1', b'9')?;
while self.consume_range(b'0', b'9').is_ok() {}
}
if self.consume(b'.') {
self.consume_range(b'0', b'9')?;
while self.consume_range(b'0', b'9').is_ok() {}
}
if matches!(self.peek(), Some(b'e' | b'E')) {
self.position += 1;
if matches!(self.peek(), Some(b'+' | b'-')) {
self.position += 1;
}
self.consume_range(b'0', b'9')?;
while self.consume_range(b'0', b'9').is_ok() {}
}
Ok(JsonValue::Other)
}
fn consume_range(&mut self, start: u8, end: u8) -> Result<(), ()> {
match self.peek() {
Some(byte) if (start..=end).contains(&byte) => {
self.position += 1;
Ok(())
}
_ => Err(()),
}
}
fn skip_whitespace(&mut self) {
while matches!(self.peek(), Some(b' ' | b'\n' | b'\r' | b'\t')) {
self.position += 1;
}
}
fn expect(&mut self, expected: u8) -> Result<(), ()> {
if self.consume(expected) {
Ok(())
} else {
Err(())
}
}
fn consume(&mut self, expected: u8) -> bool {
if self.peek() == Some(expected) {
self.position += 1;
true
} else {
false
}
}
fn peek(&self) -> Option<u8> {
self.input.as_bytes().get(self.position).copied()
}
}