//! Never-expiring installed-mod metadata, independent of the disposable portal cache.
use crate::{
Result,
cache::{Cache, url_key},
local_mods::{LocalMod, ModSource},
net::Fetch,
portal::PortalModFull,
portal_data::PortalData,
};
use std::{collections::BTreeSet, path::PathBuf};
#[derive(Clone, Debug)]
pub struct MetadataStore {
files: Cache,
}
pub fn app_metadata_dir() -> Result<PathBuf> {
#[cfg(any(target_os = "linux", target_os = "macos"))]
{
crate::app_dirs::directory(&std::env::vars().collect(), crate::app_dirs::Kind::Metadata)
}
#[cfg(not(any(target_os = "linux", target_os = "macos")))]
{
if let Some(path) = std::env::var_os("FMM_METADATA_DIR").filter(|p| !p.is_empty()) {
return Ok(path.into());
}
let local = std::env::var_os("LOCALAPPDATA")
.ok_or("LOCALAPPDATA is not set; set FMM_METADATA_DIR")?;
Ok(PathBuf::from(local).join("werry/factoriomodmanager/metadata"))
}
}
impl MetadataStore {
pub fn new(root: PathBuf) -> Self {
Self {
files: Cache::new(root),
}
}
pub fn key(name: &str, version: &str) -> Result<String> {
if name.is_empty()
|| !name
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b"_-".contains(&b))
|| version.is_empty()
|| !version.bytes().all(|b| b.is_ascii_digit() || b == b'.')
|| version.split('.').any(str::is_empty)
{
return Err("Invalid metadata name or version".into());
}
Ok(format!("{name}_{version}.json"))
}
pub fn read(&self, name: &str, version: &str) -> Option<PortalModFull> {
let bytes = self.files.read(&Self::key(name, version).ok()?)?;
serde_json::from_slice::<PortalModFull>(&bytes)
.ok()
.filter(|f| f.mod_.name == name)
}
pub fn write(&self, name: &str, version: &str, bytes: &[u8]) -> Result<()> {
let key = Self::key(name, version)?;
let full: PortalModFull = serde_json::from_slice(bytes)?;
if full.mod_.name != name {
return Err("Metadata name mismatch".into());
}
self.files.write(&key, bytes)?;
Ok(())
}
/// Preserve the raw response, including fields this version of the app does not understand.
pub fn retain<F: Fetch>(
&self,
data: &PortalData<F>,
full: &PortalModFull,
version: &str,
) -> Result<()> {
let raw = data
.cache
.read(&format!("full/{}.json", url_key(&full.mod_.name)))
.filter(|b| {
serde_json::from_slice::<PortalModFull>(b)
.is_ok_and(|f| f.mod_.name == full.mod_.name)
})
.unwrap_or(serde_json::to_vec(full)?);
self.write(&full.mod_.name, version, &raw)
}
pub fn image_path(&self, url: &str) -> Result<PathBuf> {
crate::net::validate_url(url)?;
if !url.starts_with("https://assets-mod.factorio.com/") {
return Err("Invalid metadata image host".into());
}
for ext in ["png", "jpg", "gif"] {
let path = self.files.path(&format!("{}.{ext}", url_key(url)))?;
if path.is_file() {
return Ok(path);
}
}
self.files.path(&format!("{}.png", url_key(url)))
}
pub fn retain_thumbnail<F: Fetch>(
&self,
data: &PortalData<F>,
full: &PortalModFull,
) -> Result<()> {
if let Some(url) = crate::portal::thumbnail_url(full.mod_.thumbnail.as_deref()) {
let target = self.image_path(&url)?;
if !target.is_file() {
let source = data.thumbnail(&url)?;
let ext = source
.extension()
.and_then(|s| s.to_str())
.ok_or("Missing image extension")?;
let target = self.files.path(&format!("{}.{ext}", url_key(&url)))?;
crate::cache::atomic_write(&target, &std::fs::read(source)?)?;
}
}
Ok(())
}
pub fn missing(&self, local: &[LocalMod]) -> Vec<(String, String)> {
local
.iter()
.filter(|m| m.source != ModSource::Builtin && self.read(&m.name, &m.version).is_none())
.map(|m| (m.name.clone(), m.version.clone()))
.collect::<BTreeSet<_>>()
.into_iter()
.collect()
}
}