add pkgrel support

src/pkg/package.rs

@@ -17,17 +17,19 @@ pub struct Package {
     pub arch: Architecture,
     /// Name of the package
     pub name: String,
+    pub rel: u64,
     /// Version of the package
     pub version: Option<String>,
 }
 
 impl Package {
     /// Create a new package
-    pub fn new(repo: &str, arch: Architecture, pkg_name: &str, version: &str) -> Self {
+    pub fn new(repo: &str, arch: Architecture, pkg_name: &str, version: &str, rel: u64) -> Self {
         let pkg = Package {
             repo: repo.to_string(),
             arch,
             name: pkg_name.to_string(),
+            rel: rel,
             version: Some(version.to_string()),
         };
 
@@ -35,6 +37,13 @@ impl Package {
         pkg
     }
 
+    pub fn version(ver: &str) -> (String, u64) {
+        let mut splitted = ver.split('-').collect::<Vec<_>>();
+        let rel = splitted.pop().unwrap();
+        let ver = splitted.join("-");
+        (ver, rel.parse().unwrap())
+    }
+
     pub fn install_script(&self) -> Option<String> {
         let pkg = self.base_path().join(self.file_name());
         read_file_tar(&pkg, ".INSTALL")
@@ -65,8 +74,7 @@ impl Package {
             .collect()
     }
 
-    pub fn pkginfo(&self) -> Vec<(String, String)> {
-        let content = read_file_tar(&self.base_path().join(self.file_name()), ".PKGINFO").unwrap();
+    pub fn pkginfo_from_str(content: &str) -> Vec<(String, String)> {
         let mut ret: Vec<(String, Vec<String>)> = Vec::new();
 
         for line in content.split("\n") {
@@ -89,6 +97,11 @@ impl Package {
         ret
     }
 
+    pub fn pkginfo(&self) -> Vec<(String, String)> {
+        let content = read_file_tar(&self.base_path().join(self.file_name()), ".PKGINFO").unwrap();
+        Package::pkginfo_from_str(&content)
+    }
+
     pub fn arch(&self) -> Vec<Architecture> {
         let mut ret = Vec::new();
         for a in [
@@ -149,11 +162,12 @@ impl Package {
 
     /// Parse a pkg filename
     pub fn from_filename(repo: &str, file_name: &str) -> Package {
-        let (pkg_name, version, _, arch) = Package::extract_pkg_name(file_name).unwrap();
+        let (pkg_name, version, rel, arch) = Package::extract_pkg_name(file_name).unwrap();
         Self {
             repo: repo.to_string(),
             arch,
             name: pkg_name,
+            rel: rel.parse().unwrap(),
             version: Some(version.to_string()),
         }
     }
@@ -164,13 +178,16 @@ impl Package {
             repo: repo.to_string(),
             arch,
             name: pkg_name.to_string(),
+            rel: 1,
             version: None,
         };
 
         let versions = base.versions();
         let ver = versions.first()?;
+        let (ver, rel) = Package::version(&ver);
 
         base.version = Some(ver.clone());
+        base.rel = rel;
 
         Some(base)
     }
@@ -274,7 +291,6 @@ impl Package {
 
     /// Build a pkg filename from the packages values
     pub fn file_name(&self) -> String {
-        // TODO : pkgrel support
         format!(
             "{}-{}-{}-{}.pkg.tar.zst",
             self.name,
@@ -282,9 +298,9 @@ impl Package {
                 ver.to_string()
             } else {
                 let versions = self.versions();
-                versions.first().unwrap().clone()
+                Package::version(&versions.first().unwrap().clone()).0
             },
-            1,
+            self.rel,
             self.arch.to_string(),
         )
     }
@@ -292,15 +308,14 @@ impl Package {
     /// Get all versions of the package
     pub fn versions(&self) -> Vec<String> {
         let dir_path = self.base_path();
-        let mut versions = vec![];
+        let mut versions: Vec<String> = vec![];
 
         if let Ok(entries) = std::fs::read_dir(dir_path) {
             for entry in entries.filter_map(Result::ok) {
                 let file_name = entry.file_name().into_string().unwrap_or_default();
                 if file_name.starts_with(&self.name) && file_name.ends_with(".pkg.tar.zst") {
-                    if let Some(version) = Package::from_filename(&self.repo, &file_name).version {
-                        versions.push(version.to_string());
-                    }
+                    let (_, version, rel, _) = Package::extract_pkg_name(&file_name).unwrap();
+                    versions.push(format!("{version}-{rel}"));
                 }
             }
         }
@@ -347,7 +362,11 @@ pub fn read_file_tar(tar: &PathBuf, file_path: &str) -> Option<String> {
     let mut file = File::open(tar).ok()?;
     let mut buf = Vec::new();
     file.read_to_end(&mut buf).unwrap();
-    let uncompressed = zstd::decode_all(Cursor::new(buf)).unwrap();
+    read_file_tar_raw(&buf, file_path)
+}
+
+pub fn read_file_tar_raw(tar: &[u8], file_path: &str) -> Option<String> {
+    let uncompressed = zstd::decode_all(Cursor::new(tar)).unwrap();
     let content = Cursor::new(uncompressed);
     let mut a = Archive::new(content);
 

src/pkg/repo.rs

@@ -140,8 +140,8 @@ impl Repository {
 
     pub fn get_pkg(&self, pkg_name: &str) -> Option<Package> {
         // Find package
-        let (name, version, _, arch) = Package::extract_pkg_name(pkg_name).unwrap();
-        let pkg = Package::new(&self.name, arch, &name, &version);
+        let (name, version, rel, arch) = Package::extract_pkg_name(pkg_name).unwrap();
+        let pkg = Package::new(&self.name, arch, &name, &version, rel.parse().unwrap());
 
         // Return if exists
         if pkg.exists() { Some(pkg) } else { None }

src/routes/push.rs

@@ -1,4 +1,5 @@
 use based::request::api::{FallibleApiResponse, api_error};
+use pacco::pkg::package::read_file_tar_raw;
 use rocket::tokio::io::AsyncReadExt;
 use rocket::{FromForm, State, post};
 use serde_json::json;
@@ -16,9 +17,6 @@ use crate::config::Config;
 
 #[derive(FromForm)]
 pub struct PkgUpload<'r> {
-    name: String,
-    arch: String,
-    version: String,
     pkg: TempFile<'r>,
     sig: Option<TempFile<'r>>,
 }
@@ -50,15 +48,39 @@ pub async fn upload_pkg(
         return Err(api_error("This repository is a mirror."));
     }
 
-    let pkg = Package::new(
-        repo,
-        Architecture::parse(&upload.arch).ok_or_else(|| api_error("Invalid architecture"))?,
-        &upload.name,
-        &upload.version,
+    let pkg_file = tmp_file_to_vec(&upload.pkg).await;
+    let content = read_file_tar_raw(&pkg_file, ".PKGINFO")
+        .ok_or_else(|| api_error("Unable to read package file"))?;
+    let pkg_info = Package::pkginfo_from_str(&content);
+
+    let pkg_name = pkg_info
+        .iter()
+        .find(|x| x.0 == "pkgname")
+        .ok_or_else(|| api_error("Package has no pkgname"))?
+        .1
+        .as_str();
+
+    let (version, rel) = Package::version(
+        &pkg_info
+            .iter()
+            .find(|x| x.0 == "pkgver")
+            .ok_or_else(|| api_error("Package has no pkgver"))?
+            .1,
     );
 
+    let arch = pkg_info
+        .iter()
+        .find(|x| x.0 == "pkgname")
+        .ok_or_else(|| api_error("Package has no arch"))?
+        .1
+        .as_str();
+
+    let arch = Architecture::parse(&arch).ok_or_else(|| api_error("Invalid architecture"))?;
+
+    let pkg = Package::new(repo, arch, pkg_name, &version, rel);
+
     pkg.save(
-        tmp_file_to_vec(&upload.pkg).await,
+        pkg_file,
         if let Some(sig) = &upload.sig {
             Some(tmp_file_to_vec(sig).await)
         } else {

src/routes/ui.rs

@@ -5,7 +5,7 @@ use based::{
 use maud::{PreEscaped, html};
 use rocket::{State, get};
 
-use pacco::pkg::{Repository, arch::Architecture, find_package_by_name};
+use pacco::pkg::{Package, Repository, arch::Architecture, find_package_by_name};
 
 use crate::config::Config;
 
@@ -24,7 +24,9 @@ pub async fn pkg_ui(
     let mut pkg = repo.get_pkg_by_name(pkg_name)?;
 
     if let Some(ver) = ver {
-        pkg = pkg.get_version(ver);
+        let (version, rel) = Package::version(ver);
+        pkg = pkg.get_version(&version);
+        pkg.rel = rel;
     }
 
     let versions = pkg.versions();