Change filesystem errors to be consistent across operating systems

packages/vm/src/cache.rs

@@ -1,5 +1,5 @@
 use std::collections::HashSet;
-use std::fs::{create_dir_all, File, OpenOptions};
+use std::fs::{File, OpenOptions};
 use std::io::{Read, Write};
 use std::marker::PhantomData;
 use std::path::{Path, PathBuf};
@@ -10,6 +10,7 @@ use crate::capabilities::required_capabilities_from_module;
 use crate::checksum::Checksum;
 use crate::compatibility::check_wasm;
 use crate::errors::{VmError, VmResult};
+use crate::filesystem::mkdir_p;
 use crate::instance::{Instance, InstanceOptions};
 use crate::modules::{FileSystemCache, InMemoryCache, PinnedMemoryCache};
 use crate::size::Size;
@@ -108,15 +109,9 @@ where
  let wasm_path = state_path.join(WASM_DIR);
 
  // Ensure all the needed directories exist on disk.
- for path in [&state_path, &cache_path, &wasm_path].iter() {
- create_dir_all(path).map_err(|e| {
- VmError::cache_err(format!(
- "Error creating directory {}: {}",
- path.display(),
- e
- ))
- })?;
- }
+ mkdir_p(&state_path).map_err(|_e| VmError::cache_err("Error creating state directory"))?;
+ mkdir_p(&cache_path).map_err(|_e| VmError::cache_err("Error creating cache directory"))?;
+ mkdir_p(&wasm_path).map_err(|_e| VmError::cache_err("Error creating wasm directory"))?;
 
  let fs_cache = FileSystemCache::new(cache_path.join(MODULES_DIR))
  .map_err(|e| VmError::cache_err(format!("Error file system cache: {}", e)))?;
@@ -373,7 +368,7 @@ mod tests {
  use crate::errors::VmError;
  use crate::testing::{mock_backend, mock_env, mock_info, MockApi, MockQuerier, MockStorage};
  use cosmwasm_std::{coins, Empty};
- use std::fs::OpenOptions;
+ use std::fs::{create_dir_all, OpenOptions};
  use std::io::Write;
  use tempfile::TempDir;
 

packages/vm/src/filesystem.rs

@@ -0,0 +1,43 @@
+use std::{fs::create_dir_all, path::PathBuf};
+
+#[derive(Debug)]
+pub struct MkdirPFailure;
+
+/// An implementation for `mkdir -p`.
+///
+/// This is a thin wrapper around fs::create_dir_all that
+/// hides all OS specific error messages to ensure they don't end up
+/// breaking consensus.
+pub fn mkdir_p(path: &PathBuf) -> Result<(), MkdirPFailure> {
+ create_dir_all(path).map_err(|_e| MkdirPFailure {})
+}
+
+#[cfg(test)]
+mod tests {
+ use tempfile::TempDir;
+
+ use super::*;
+
+ #[test]
+ fn mkdir_p_works() {
+ let tmp_root = TempDir::new().unwrap();
+
+ // Can create
+ let path = tmp_root.path().join("something");
+ assert!(!path.is_dir());
+ mkdir_p(&path).unwrap();
+ assert!(path.is_dir());
+
+ // Can be called on existing dir
+ let path = tmp_root.path().join("something else");
+ assert!(!path.is_dir());
+ mkdir_p(&path).unwrap();
+ assert!(path.is_dir());
+ mkdir_p(&path).unwrap(); // no-op
+ assert!(path.is_dir());
+
+ // Fails for dir with null
+ let path = tmp_root.path().join("something\0with NULL");
+ mkdir_p(&path).unwrap_err();
+ }
+}

packages/vm/src/lib.rs

@@ -9,6 +9,7 @@ mod compatibility;
 mod conversion;
 mod environment;
 mod errors;
+mod filesystem;
 mod imports;
 mod instance;
 mod limited;

packages/vm/src/modules/file_system_cache.rs

@@ -1,12 +1,13 @@
-use std::fs;
 use std::io;
 use std::path::PathBuf;
+use thiserror::Error;
 
 use wasmer::{DeserializeError, Module, Store};
 
 use crate::checksum::Checksum;
 use crate::errors::{VmError, VmResult};
 
+use crate::filesystem::mkdir_p;
 use crate::modules::current_wasmer_module_version;
 
 /// Bump this version whenever the module system changes in a way
@@ -42,6 +43,20 @@ pub struct FileSystemCache {
  wasmer_module_version: u32,
 }
 
+/// An error type that hides system specific error information
+/// to ensure deterministic errors across operating systems.
+#[derive(Error, Debug)]
+pub enum NewFileSystemCacheError {
+ #[error("Could not get metadata of cache path")]
+ CouldntGetMetadata,
+ #[error("The supplied path is readonly")]
+ ReadonlyPath,
+ #[error("The supplied path already exists but is no directory")]
+ ExistsButNoDirectory,
+ #[error("Could not create cache path")]
+ CouldntCreatePath,
+}
+
 impl FileSystemCache {
  /// Construct a new `FileSystemCache` around the specified directory.
  /// The contents of the cache are stored in sub-versioned directories.
@@ -50,38 +65,29 @@ impl FileSystemCache {
  ///
  /// This method is unsafe because there's no way to ensure the artifacts
  /// stored in this cache haven't been corrupted or tampered with.
- pub unsafe fn new(path: impl Into<PathBuf>) -> io::Result<Self> {
+ pub unsafe fn new(path: impl Into<PathBuf>) -> Result<Self, NewFileSystemCacheError> {
  let wasmer_module_version = current_wasmer_module_version();
 
  let path: PathBuf = path.into();
  if path.exists() {
- let metadata = path.metadata()?;
+ let metadata = path
+ .metadata()
+ .map_err(|_e| NewFileSystemCacheError::CouldntGetMetadata)?;
  if metadata.is_dir() {
  if !metadata.permissions().readonly() {
  Ok(Self {
  base_path: path,
  wasmer_module_version,
  })
  } else {
- // This directory is readonly.
- Err(io::Error::new(
- io::ErrorKind::PermissionDenied,
- format!("the supplied path is readonly: {}", path.display()),
- ))
+ Err(NewFileSystemCacheError::ReadonlyPath)
  }
  } else {
- // This path points to a file.
- Err(io::Error::new(
- io::ErrorKind::PermissionDenied,
- format!(
- "the supplied path already points to a file: {}",
- path.display()
- ),
- ))
+ Err(NewFileSystemCacheError::ExistsButNoDirectory)
  }
  } else {
  // Create the directory and any parent directories if they don't yet exist.
- fs::create_dir_all(&path)?;
+ mkdir_p(&path).map_err(|_e| NewFileSystemCacheError::CouldntCreatePath)?;
  Ok(Self {
  base_path: path,
  wasmer_module_version,
@@ -115,8 +121,9 @@ impl FileSystemCache {
  /// Stores a serialized module to the file system. Returns the size of the serialized module.
  pub fn store(&mut self, checksum: &Checksum, module: &Module) -> VmResult<()> {
  let modules_dir = self.latest_modules_path();
- fs::create_dir_all(&modules_dir)
- .map_err(|e| VmError::cache_err(format!("Error creating directory: {}", e)))?;
+ mkdir_p(&modules_dir)
+ .map_err(|_e| VmError::cache_err("Error creating modules directory"))?;
+
  let filename = checksum.to_hex();
  let path = modules_dir.join(filename);
  module
@@ -137,6 +144,8 @@ impl FileSystemCache {
 
 #[cfg(test)]
 mod tests {
+ use std::fs;
+
  use super::*;
  use crate::size::Size;
  use crate::wasm_backend::{compile, make_runtime_store};

packages/vm/src/modules/mod.rs

@@ -4,7 +4,7 @@ mod pinned_memory_cache;
 mod sized_module;
 mod versioning;
 
-pub use file_system_cache::FileSystemCache;
+pub use file_system_cache::{FileSystemCache, NewFileSystemCacheError};
 pub use in_memory_cache::InMemoryCache;
 pub use pinned_memory_cache::PinnedMemoryCache;
 pub use versioning::current_wasmer_module_version;