Merge pull request #1 from appsignal/clear_cache

Clear cache if size is over configured percentage (defaults to 90%)

Author: matsimitsu

config/src/manager.rs

@@ -24,6 +24,10 @@ const fn _default_overlay_size() -> u32 {
     10 // 10GB
 }
 
+const fn _default_max_cache_pct() -> u8 {
+    90
+}
+
 #[derive(Deserialize, Debug, Clone)]
 pub struct Role {
     pub name: String,
@@ -38,6 +42,8 @@ pub struct Role {
     pub instance_count: u8,
     #[serde(default)]
     pub cache_paths: Vec<Utf8PathBuf>,
+    #[serde(default = "_default_max_cache_pct")]
+    pub max_cache_pct: u8,
     #[serde(default)]
     pub labels: Vec<String>,
 }

manager/src/disk.rs

@@ -28,6 +28,10 @@ impl Disk {
         self.size as u64 * 1024
     }
 
+    pub fn size_in_kilobytes(&self) -> u64 {
+        self.size_in_megabytes() * 1024
+    }
+
     pub fn filename(&self) -> Utf8PathBuf {
         match self.format {
             DiskFormat::Ext4 => Utf8PathBuf::from(format!("{}.ext4", &self.name)),
@@ -44,9 +48,22 @@ impl Disk {
         }
     }
 
+    pub fn usage_on_disk(&self) -> Result<u64, std::io::Error> {
+        fs::du(self.path_with_filename())
+    }
+
     pub fn setup_ext4(&self) -> Result<(), std::io::Error> {
         fs::dd(self.path_with_filename(), self.size_in_megabytes())?;
         fs::mkfs_ext4(self.path_with_filename())?;
         Ok(())
     }
+
+    pub fn destroy(&self) -> Result<(), std::io::Error> {
+        fs::rm_rf(self.path_with_filename())?;
+        Ok(())
+    }
+
+    pub fn usage_pct(&self) -> Result<u8, std::io::Error> {
+        Ok((self.usage_on_disk()? * 100 / self.size_in_kilobytes()) as u8)
+    }
 }

manager/src/instance.rs

@@ -34,6 +34,7 @@ pub struct Instance {
     memory_size: u32,
     cache_paths: Vec<Utf8PathBuf>,
     cache: Disk,
+    max_cache_pct: u8,
     idx: u8,
     role: String,
     github: GitHub,
@@ -62,6 +63,7 @@ impl Instance {
             memory_size: role.memory_size,
             cache_paths: role.cache_paths.clone(),
             role: role.slug(),
+            max_cache_pct: role.max_cache_pct,
             labels: role.labels.clone(),
             github,
             cache,
@@ -203,6 +205,8 @@ impl Instance {
         let _ = rm_rf(self.work_dir.join("rootfs.ext4"));
         copy_sparse(&self.rootfs_image, self.work_dir.join("rootfs.ext4"))?;
 
+        self.try_clear_cache()?;
+
         debug!(
             "{} Generate config: '{}'",
             self.log_prefix(),
@@ -225,6 +229,20 @@ impl Instance {
         self.child = None;
     }
 
+    pub fn try_clear_cache(&mut self) -> Result<()> {
+        let usage_pct = self.cache.usage_pct()?;
+        if usage_pct > self.max_cache_pct {
+            info!(
+                "Cache disk is over {}% ({}%), clearing cache",
+                self.max_cache_pct, usage_pct
+            );
+
+            self.cache.destroy()?;
+            self.cache.setup()?;
+        }
+        Ok(())
+    }
+
     pub fn stop(&mut self) -> Result<()> {
         info!("{} Shutting down instance", self.log_prefix());
 
@@ -303,6 +321,7 @@ mod tests {
             cpus: 1,
             memory_size: 1,
             cache_size: 1,
+            max_cache_pct: 90,
             overlay_size: 1,
             instance_count: 1,
             cache_paths: Vec::new(),

util/src/fs.rs

@@ -54,6 +54,29 @@ pub fn dd(path: impl AsRef<Utf8Path>, size_in_mb: u64) -> std::io::Result<()> {
     Ok(())
 }
 
+pub fn du(path: impl AsRef<Utf8Path>) -> std::io::Result<u64> {
+    let path = path.as_ref();
+
+    let du_output = exec(Command::new("du").args([&path.as_str()]))
+        .map(|o| String::from_utf8_lossy(&o.stdout).to_string())
+        .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
+
+    let size = du_output
+        .split_whitespace()
+        .next()
+        .ok_or(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            format!("Couldn not split '{:?}' into number and rest", du_output),
+        ))?;
+
+    size.parse().map_err(|e| {
+        std::io::Error::new(
+            std::io::ErrorKind::Other,
+            format!("Could not parse '{:?}' to number: {}", size, e),
+        )
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;