|
|
|
use core::fmt;
|
|
|
|
use std::{path::PathBuf, str::FromStr};
|
|
|
|
|
|
|
|
use futures::future;
|
|
|
|
use semver::{Version, VersionReq};
|
|
|
|
use serde::{Deserialize, Deserializer, Serialize, Serializer};
|
|
|
|
use tokio::fs;
|
|
|
|
|
|
|
|
use crate::{
|
|
|
|
config::ConfigAccess,
|
|
|
|
consts::{ARCH, BIN_DIR, CACHE_DIR, CFG_DIR, DATA_DIR, NODE_VERSIONS_DIR, OS},
|
|
|
|
error::VersionError,
|
|
|
|
versioning::{SimpleVersion, VersionMetadata},
|
|
|
|
};
|
|
|
|
|
|
|
|
use miette::{Context, IntoDiagnostic, Result};
|
|
|
|
|
|
|
|
use self::{
|
|
|
|
downloader::{versions::Versions, NodeDownloader},
|
|
|
|
local_versions::InstalledVersions,
|
|
|
|
node_path::NodePath,
|
|
|
|
};
|
|
|
|
|
|
|
|
pub mod downloader;
|
|
|
|
mod local_versions;
|
|
|
|
pub(crate) mod node_path;
|
|
|
|
|
|
|
|
#[derive(Clone, Debug)]
|
|
|
|
pub enum NodeVersion {
|
|
|
|
Latest,
|
|
|
|
LatestLts,
|
|
|
|
Lts(String),
|
|
|
|
Req(VersionReq),
|
|
|
|
}
|
|
|
|
|
|
|
|
impl FromStr for NodeVersion {
|
|
|
|
type Err = &'static str;
|
|
|
|
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
|
|
let input = s.to_lowercase();
|
|
|
|
|
|
|
|
let version = match &*input {
|
|
|
|
"latest" => Self::Latest,
|
|
|
|
"lts" => Self::LatestLts,
|
|
|
|
_ => {
|
|
|
|
let version_string = s.trim().trim_start_matches('v');
|
|
|
|
|
|
|
|
if let Ok(req) = VersionReq::parse(version_string) {
|
|
|
|
Self::Req(req)
|
|
|
|
} else {
|
|
|
|
Self::Lts(version_string.to_lowercase())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
Ok(version)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'de> Deserialize<'de> for NodeVersion {
|
|
|
|
#[inline]
|
|
|
|
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
|
|
|
|
where
|
|
|
|
D: Deserializer<'de>,
|
|
|
|
{
|
|
|
|
let string = String::deserialize(deserializer)?;
|
|
|
|
Self::from_str(&string).map_err(serde::de::Error::custom)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Serialize for NodeVersion {
|
|
|
|
#[inline]
|
|
|
|
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
|
|
|
|
where
|
|
|
|
S: Serializer,
|
|
|
|
{
|
|
|
|
self.to_string().serialize(serializer)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl fmt::Display for NodeVersion {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
|
|
match self {
|
|
|
|
NodeVersion::Latest => String::from("latest"),
|
|
|
|
NodeVersion::LatestLts => String::from("lts"),
|
|
|
|
NodeVersion::Lts(name) => name.to_owned(),
|
|
|
|
NodeVersion::Req(req) => req.to_string(),
|
|
|
|
}
|
|
|
|
.fmt(f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct Repository {
|
|
|
|
downloader: NodeDownloader,
|
|
|
|
installed_versions: InstalledVersions,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Repository {
|
|
|
|
/// Initializes a new repository with the given confi
|
|
|
|
#[tracing::instrument(level = "debug", skip_all)]
|
|
|
|
pub async fn init(config: ConfigAccess) -> Result<Self> {
|
|
|
|
Self::create_folders().await?;
|
|
|
|
let mut downloader = NodeDownloader::new(config.clone());
|
|
|
|
|
|
|
|
let installed_versions = match InstalledVersions::load() {
|
|
|
|
Ok(v) => v,
|
|
|
|
Err(_) => {
|
|
|
|
let installed: InstalledVersions =
|
|
|
|
load_installed_versions_info(downloader.versions().await?)
|
|
|
|
.await?
|
|
|
|
.into();
|
|
|
|
installed.save()?;
|
|
|
|
installed
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
Ok(Self {
|
|
|
|
downloader,
|
|
|
|
installed_versions,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
#[tracing::instrument(level = "debug")]
|
|
|
|
async fn create_folders() -> Result<()> {
|
|
|
|
let dirs = vec![
|
|
|
|
&*CFG_DIR,
|
|
|
|
&*DATA_DIR,
|
|
|
|
&*CACHE_DIR,
|
|
|
|
&*BIN_DIR,
|
|
|
|
&*NODE_VERSIONS_DIR,
|
|
|
|
];
|
|
|
|
for result in future::join_all(dirs.into_iter().map(|dir| async move {
|
|
|
|
if !dir.exists() {
|
|
|
|
fs::create_dir_all(dir).await.into_diagnostic()?;
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}))
|
|
|
|
.await
|
|
|
|
{
|
|
|
|
#[allow(clippy::question_mark)]
|
|
|
|
if let Err(e) = result {
|
|
|
|
return Err(e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the path for the given node version
|
|
|
|
#[tracing::instrument(level = "debug", skip(self))]
|
|
|
|
pub fn get_version_path(&mut self, version: &NodeVersion) -> Result<Option<NodePath>> {
|
|
|
|
let info = self.lookup_local_version(version)?;
|
|
|
|
let path = build_version_path(&info.version);
|
|
|
|
|
|
|
|
Ok(if path.exists() {
|
|
|
|
Some(NodePath::new(path))
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns a list of installed versions
|
|
|
|
pub fn installed_versions(&self) -> Vec<Version> {
|
|
|
|
self.installed_versions
|
|
|
|
.all()
|
|
|
|
.into_iter()
|
|
|
|
.map(|v| v.clone().into())
|
|
|
|
.collect()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns if the given version is installed
|
|
|
|
#[tracing::instrument(level = "debug", skip(self))]
|
|
|
|
pub async fn is_installed(&mut self, version: &NodeVersion) -> Result<bool> {
|
|
|
|
let info = if let Ok(v) = self.lookup_local_version(version) {
|
|
|
|
v
|
|
|
|
} else {
|
|
|
|
self.lookup_remote_version(version).await?
|
|
|
|
};
|
|
|
|
|
|
|
|
Ok(build_version_path(&info.version).exists())
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Installs the given node version
|
|
|
|
#[tracing::instrument(level = "debug", skip(self))]
|
|
|
|
pub async fn install_version(&mut self, version: &NodeVersion) -> Result<()> {
|
|
|
|
let info = self.lookup_remote_version(version).await?.to_owned();
|
|
|
|
self.downloader.download(&info.version).await?;
|
|
|
|
self.installed_versions.insert((info.version, info));
|
|
|
|
self.installed_versions.save()?;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Uninstalls the given node version by deleting the versions directory
|
|
|
|
#[tracing::instrument(level = "debug", skip(self))]
|
|
|
|
pub async fn uninstall(&mut self, version: &NodeVersion) -> Result<()> {
|
|
|
|
let info = self.lookup_local_version(version)?.clone();
|
|
|
|
let version_dir = NODE_VERSIONS_DIR.join(info.version.to_string());
|
|
|
|
|
|
|
|
if !version_dir.exists() {
|
|
|
|
return Err(VersionError::not_installed(version).into());
|
|
|
|
}
|
|
|
|
|
|
|
|
fs::remove_dir_all(version_dir)
|
|
|
|
.await
|
|
|
|
.into_diagnostic()
|
|
|
|
.context("Deleting node version")?;
|
|
|
|
self.installed_versions.remove(&info.version);
|
|
|
|
self.installed_versions.save()?;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Performs a lookup for the given node version
|
|
|
|
#[tracing::instrument(level = "debug", skip(self))]
|
|
|
|
pub async fn lookup_remote_version(
|
|
|
|
&mut self,
|
|
|
|
version_req: &NodeVersion,
|
|
|
|
) -> Result<&VersionMetadata> {
|
|
|
|
let versions = self.downloader.versions().await?;
|
|
|
|
|
|
|
|
let version = match version_req {
|
|
|
|
NodeVersion::Latest => versions.latest(),
|
|
|
|
NodeVersion::LatestLts => versions.latest_lts(),
|
|
|
|
NodeVersion::Lts(lts) => versions
|
|
|
|
.get_lts(lts)
|
|
|
|
.ok_or_else(|| VersionError::unknown_version(lts.to_owned()))?,
|
|
|
|
NodeVersion::Req(req) => versions
|
|
|
|
.get_fulfilling(req)
|
|
|
|
.ok_or_else(|| VersionError::unfulfillable_version(req.to_owned()))?,
|
|
|
|
};
|
|
|
|
|
|
|
|
Ok(version)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Performs a lookup for the given node version
|
|
|
|
#[tracing::instrument(level = "debug", skip(self))]
|
|
|
|
pub fn lookup_local_version(&self, version_req: &NodeVersion) -> Result<&VersionMetadata> {
|
|
|
|
let versions = &self.installed_versions;
|
|
|
|
let version = match version_req {
|
|
|
|
NodeVersion::Latest => versions
|
|
|
|
.latest()
|
|
|
|
.ok_or_else(|| VersionError::not_installed("latest"))?,
|
|
|
|
NodeVersion::LatestLts => versions
|
|
|
|
.latest_lts()
|
|
|
|
.ok_or_else(|| VersionError::not_installed("lts"))?,
|
|
|
|
NodeVersion::Lts(lts) => versions
|
|
|
|
.lts(lts)
|
|
|
|
.ok_or_else(|| VersionError::unknown_version(lts.to_owned()))?,
|
|
|
|
NodeVersion::Req(req) => versions
|
|
|
|
.fulfilling(req)
|
|
|
|
.ok_or_else(|| VersionError::unfulfillable_version(req.to_owned()))?,
|
|
|
|
};
|
|
|
|
|
|
|
|
Ok(version)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the reference to all known versions
|
|
|
|
#[tracing::instrument(level = "debug", skip(self))]
|
|
|
|
pub async fn all_versions(&mut self) -> Result<&Versions> {
|
|
|
|
self.downloader.versions().await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn build_version_path(version: &SimpleVersion) -> PathBuf {
|
|
|
|
NODE_VERSIONS_DIR
|
|
|
|
.join(version.to_string())
|
|
|
|
.join(format!("node-v{}-{}-{}", version, OS, ARCH))
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn load_installed_versions_info(versions: &Versions) -> Result<Vec<VersionMetadata>> {
|
|
|
|
let mut installed_versions = Vec::new();
|
|
|
|
let mut iter = fs::read_dir(&*NODE_VERSIONS_DIR).await.into_diagnostic()?;
|
|
|
|
|
|
|
|
while let Some(entry) = iter.next_entry().await.into_diagnostic()? {
|
|
|
|
if let Ok(version) = Version::parse(entry.file_name().to_string_lossy().as_ref()) {
|
|
|
|
installed_versions.push(version);
|
|
|
|
};
|
|
|
|
}
|
|
|
|
let versions = installed_versions
|
|
|
|
.into_iter()
|
|
|
|
.filter_map(|v| versions.get(&v))
|
|
|
|
.cloned()
|
|
|
|
.collect();
|
|
|
|
|
|
|
|
Ok(versions)
|
|
|
|
}
|