Merge pull request #1569 from CosmWasm/remove-code

Remove Wasm codes

Author: webmaster128

CHANGELOG.md

@@ -31,6 +31,8 @@ and this project adheres to
   get reverted. ([#1513])
 - cosmwasm-std: Add new `WasmQuery::CodeInfo` to get the checksum of a code ID
   ([#1561]).
+- cosmwasm-vm: Add `Cache::remove_wasm` to remove obsolete Wasm blobs and their
+  compiled modules.
 
 [#1436]: https://github.com/CosmWasm/cosmwasm/issues/1436
 [#1437]: https://github.com/CosmWasm/cosmwasm/issues/1437

packages/vm/src/cache.rs

@@ -1,5 +1,5 @@
 use std::collections::HashSet;
-use std::fs::{File, OpenOptions};
+use std::fs::{self, File, OpenOptions};
 use std::io::{Read, Write};
 use std::marker::PhantomData;
 use std::path::{Path, PathBuf};
@@ -57,6 +57,7 @@ pub struct CacheOptions {
 }
 
 pub struct CacheInner {
+    /// The directory in which the Wasm blobs are stored in the file system.
     wasm_path: PathBuf,
     /// Instances memory limit in bytes. Use a value that is divisible by the Wasm page size 65536,
     /// e.g. full MiBs.
@@ -161,6 +162,25 @@ where
         Ok(checksum)
     }
 
+    /// Removes the Wasm blob for the given checksum from disk and its
+    /// compiled module from the file system cache.
+    ///
+    /// The existence of the original code is required since the caller (wasmd)
+    /// has to keep track of which entries we have here.
+    pub fn remove_wasm(&self, checksum: &Checksum) -> VmResult<()> {
+        let mut cache = self.inner.lock().unwrap();
+
+        // Remove compiled moduled from disk (if it exists).
+        // Here we could also delete from memory caches but this is not really
+        // necessary as they are pushed out from the LRU over time or disappear
+        // when the node process restarts.
+        cache.fs_cache.remove(checksum)?;
+
+        let path = &cache.wasm_path;
+        remove_wasm_from_disk(path, checksum)?;
+        Ok(())
+    }
+
     /// Retrieves a Wasm blob that was previously stored via save_wasm.
     /// When the cache is instantiated with the same base dir, this finds Wasm files on disc across multiple cache instances (i.e. node restarts).
     /// This function is public to allow a checksum to Wasm lookup in the blockchain.
@@ -364,6 +384,23 @@ fn load_wasm_from_disk(dir: impl Into<PathBuf>, checksum: &Checksum) -> VmResult
     Ok(wasm)
 }
 
+/// Removes the Wasm blob for the given checksum from disk.
+///
+/// In contrast to the file system cache, the existence of the original
+/// code is required. So a non-existent file leads to an error as it
+/// indicates a bug.
+fn remove_wasm_from_disk(dir: impl Into<PathBuf>, checksum: &Checksum) -> VmResult<()> {
+    let path = dir.into().join(checksum.to_hex());
+
+    if !path.exists() {
+        return Err(VmError::cache_err("Wasm file does not exist"));
+    }
+
+    fs::remove_file(path).map_err(|_e| VmError::cache_err("Error removing Wasm file from disk"))?;
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -573,6 +610,37 @@ mod tests {
         }
     }
 
+    #[test]
+    fn remove_wasm_works() {
+        let cache: Cache<MockApi, MockStorage, MockQuerier> =
+            unsafe { Cache::new(make_testing_options()).unwrap() };
+
+        // Store
+        let checksum = cache.save_wasm(CONTRACT).unwrap();
+
+        // Exists
+        cache.load_wasm(&checksum).unwrap();
+
+        // Remove
+        cache.remove_wasm(&checksum).unwrap();
+
+        // Does not exist anymore
+        match cache.load_wasm(&checksum).unwrap_err() {
+            VmError::CacheErr { msg, .. } => {
+                assert_eq!(msg, "Error opening Wasm file for reading")
+            }
+            e => panic!("Unexpected error: {:?}", e),
+        }
+
+        // Removing again fails
+        match cache.remove_wasm(&checksum).unwrap_err() {
+            VmError::CacheErr { msg, .. } => {
+                assert_eq!(msg, "Wasm file does not exist")
+            }
+            e => panic!("Unexpected error: {:?}", e),
+        }
+    }
+
     #[test]
     fn get_instance_finds_cached_module() {
         let cache = unsafe { Cache::new(make_testing_options()).unwrap() };
@@ -988,6 +1056,23 @@ mod tests {
         assert_eq!(code, loaded);
     }
 
+    #[test]
+    fn remove_wasm_from_disk_works() {
+        let tmp_dir = TempDir::new().unwrap();
+        let path = tmp_dir.path();
+        let code = vec![12u8; 17];
+        let checksum = save_wasm_to_disk(path, &code).unwrap();
+
+        remove_wasm_from_disk(path, &checksum).unwrap();
+
+        // removing again fails
+
+        match remove_wasm_from_disk(path, &checksum).unwrap_err() {
+            VmError::CacheErr { msg } => assert_eq!(msg, "Wasm file does not exist"),
+            err => panic!("Unexpected error: {:?}", err),
+        }
+    }
+
     #[test]
     fn analyze_works() {
         let cache: Cache<MockApi, MockStorage, MockQuerier> =

packages/vm/src/modules/file_system_cache.rs

@@ -1,3 +1,4 @@
+use std::fs;
 use std::io;
 use std::path::PathBuf;
 use thiserror::Error;
@@ -137,6 +138,22 @@ impl FileSystemCache {
         Ok(())
     }
 
+    /// Removes a serialized module from the file system.
+    ///
+    /// Returns true if the file existed and false if the file did not exist.
+    pub fn remove(&mut self, checksum: &Checksum) -> VmResult<bool> {
+        let filename = checksum.to_hex();
+        let file_path = self.latest_modules_path().join(filename);
+
+        if file_path.exists() {
+            fs::remove_file(file_path)
+                .map_err(|_e| VmError::cache_err("Error deleting module from disk"))?;
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
     /// The path to the latest version of the modules.
     fn latest_modules_path(&self) -> PathBuf {
         let version = format!(
@@ -225,4 +242,34 @@ mod tests {
         );
         let _serialized_module = fs::read(file_path).unwrap();
     }
+
+    #[test]
+    fn file_system_cache_remove_works() {
+        let tmp_dir = TempDir::new().unwrap();
+        let mut cache = unsafe { FileSystemCache::new(tmp_dir.path()).unwrap() };
+
+        // Create module
+        let wasm = wat::parse_str(SOME_WAT).unwrap();
+        let checksum = Checksum::generate(&wasm);
+
+        // Store module
+        let module = compile(&wasm, None, &[]).unwrap();
+        cache.store(&checksum, &module).unwrap();
+
+        // It's there
+        let store = make_runtime_store(TESTING_MEMORY_LIMIT);
+        assert!(cache.load(&checksum, &store).unwrap().is_some());
+
+        // Remove module
+        let existed = cache.remove(&checksum).unwrap();
+        assert!(existed);
+
+        // it's gone now
+        let store = make_runtime_store(TESTING_MEMORY_LIMIT);
+        assert!(cache.load(&checksum, &store).unwrap().is_none());
+
+        // Remove again
+        let existed = cache.remove(&checksum).unwrap();
+        assert!(!existed);
+    }
 }