f: remove unnecessary scope

Author: joostjager

lightning-persister/src/fs_store.rs

@@ -287,92 +287,90 @@ impl FilesystemStoreInner {
 			return Ok(());
 		}
 
-		{
-			let inner_lock_ref = {
-				let mut outer_lock = self.locks.lock().unwrap();
-				Arc::clone(&outer_lock.entry(dest_file_path.clone()).or_default())
-			};
-			let mut last_written_version = inner_lock_ref.write().unwrap();
-
-			// If a version is provided, we check if we already have a newer version written/removed. This is used in
-			// async contexts to realize eventual consistency.
-			if let Some(version) = version {
-				if version <= *last_written_version {
-					// If the version is not greater, we don't touch the file.
-					return Ok(());
-				}
-
-				*last_written_version = version;
+		let inner_lock_ref = {
+			let mut outer_lock = self.locks.lock().unwrap();
+			Arc::clone(&outer_lock.entry(dest_file_path.clone()).or_default())
+		};
+		let mut last_written_version = inner_lock_ref.write().unwrap();
+
+		// If a version is provided, we check if we already have a newer version written/removed. This is used in
+		// async contexts to realize eventual consistency.
+		if let Some(version) = version {
+			if version <= *last_written_version {
+				// If the version is not greater, we don't touch the file.
+				return Ok(());
 			}
 
-			if lazy {
-				// If we're lazy we just call remove and be done with it.
-				fs::remove_file(&dest_file_path)?;
-			} else {
-				// If we're not lazy we try our best to persist the updated metadata to ensure
-				// atomicity of this call.
-				#[cfg(not(target_os = "windows"))]
-				{
-					fs::remove_file(&dest_file_path)?;
+			*last_written_version = version;
+		}
 
-					let parent_directory = dest_file_path.parent().ok_or_else(|| {
-						let msg = format!(
-							"Could not retrieve parent directory of {}.",
-							dest_file_path.display()
-						);
-						std::io::Error::new(std::io::ErrorKind::InvalidInput, msg)
-					})?;
-					let dir_file = fs::OpenOptions::new().read(true).open(parent_directory)?;
-					// The above call to `fs::remove_file` corresponds to POSIX `unlink`, whose changes
-					// to the inode might get cached (and hence possibly lost on crash), depending on
-					// the target platform and file system.
-					//
-					// In order to assert we permanently removed the file in question we therefore
-					// call `fsync` on the parent directory on platforms that support it.
-					dir_file.sync_all()?;
-				}
+		if lazy {
+			// If we're lazy we just call remove and be done with it.
+			fs::remove_file(&dest_file_path)?;
+		} else {
+			// If we're not lazy we try our best to persist the updated metadata to ensure
+			// atomicity of this call.
+			#[cfg(not(target_os = "windows"))]
+			{
+				fs::remove_file(&dest_file_path)?;
 
-				#[cfg(target_os = "windows")]
-				{
-					// Since Windows `DeleteFile` API is not persisted until the last open file handle
-					// is dropped, and there seemingly is no reliable way to flush the directory
-					// metadata, we here fall back to use a 'recycling bin' model, i.e., first move the
-					// file to be deleted to a temporary trash file and remove the latter file
-					// afterwards.
-					//
-					// This should be marginally better, as, according to the documentation,
-					// `MoveFileExW` APIs should offer stronger persistence guarantees,
-					// at least if `MOVEFILE_WRITE_THROUGH`/`MOVEFILE_REPLACE_EXISTING` is set.
-					// However, all this is partially based on assumptions and local experiments, as
-					// Windows API is horribly underdocumented.
-					let mut trash_file_path = dest_file_path.clone();
-					let trash_file_ext =
-						format!("{}.trash", self.tmp_file_counter.fetch_add(1, Ordering::AcqRel));
-					trash_file_path.set_extension(trash_file_ext);
+				let parent_directory = dest_file_path.parent().ok_or_else(|| {
+					let msg = format!(
+						"Could not retrieve parent directory of {}.",
+						dest_file_path.display()
+					);
+					std::io::Error::new(std::io::ErrorKind::InvalidInput, msg)
+				})?;
+				let dir_file = fs::OpenOptions::new().read(true).open(parent_directory)?;
+				// The above call to `fs::remove_file` corresponds to POSIX `unlink`, whose changes
+				// to the inode might get cached (and hence possibly lost on crash), depending on
+				// the target platform and file system.
+				//
+				// In order to assert we permanently removed the file in question we therefore
+				// call `fsync` on the parent directory on platforms that support it.
+				dir_file.sync_all()?;
+			}
 
-					call!(unsafe {
-						windows_sys::Win32::Storage::FileSystem::MoveFileExW(
-							path_to_windows_str(&dest_file_path).as_ptr(),
-							path_to_windows_str(&trash_file_path).as_ptr(),
-							windows_sys::Win32::Storage::FileSystem::MOVEFILE_WRITE_THROUGH
+			#[cfg(target_os = "windows")]
+			{
+				// Since Windows `DeleteFile` API is not persisted until the last open file handle
+				// is dropped, and there seemingly is no reliable way to flush the directory
+				// metadata, we here fall back to use a 'recycling bin' model, i.e., first move the
+				// file to be deleted to a temporary trash file and remove the latter file
+				// afterwards.
+				//
+				// This should be marginally better, as, according to the documentation,
+				// `MoveFileExW` APIs should offer stronger persistence guarantees,
+				// at least if `MOVEFILE_WRITE_THROUGH`/`MOVEFILE_REPLACE_EXISTING` is set.
+				// However, all this is partially based on assumptions and local experiments, as
+				// Windows API is horribly underdocumented.
+				let mut trash_file_path = dest_file_path.clone();
+				let trash_file_ext =
+					format!("{}.trash", self.tmp_file_counter.fetch_add(1, Ordering::AcqRel));
+				trash_file_path.set_extension(trash_file_ext);
+
+				call!(unsafe {
+					windows_sys::Win32::Storage::FileSystem::MoveFileExW(
+						path_to_windows_str(&dest_file_path).as_ptr(),
+						path_to_windows_str(&trash_file_path).as_ptr(),
+						windows_sys::Win32::Storage::FileSystem::MOVEFILE_WRITE_THROUGH
 							| windows_sys::Win32::Storage::FileSystem::MOVEFILE_REPLACE_EXISTING,
-							)
-					})?;
-
-					{
-						// We fsync the trash file in hopes this will also flush the original's file
-						// metadata to disk.
-						let trash_file = fs::OpenOptions::new()
-							.read(true)
-							.write(true)
-							.open(&trash_file_path.clone())?;
-						trash_file.sync_all()?;
-					}
+					)
+				})?;
 
-					// We're fine if this remove would fail as the trash file will be cleaned up in
-					// list eventually.
-					fs::remove_file(trash_file_path).ok();
+				{
+					// We fsync the trash file in hopes this will also flush the original's file
+					// metadata to disk.
+					let trash_file = fs::OpenOptions::new()
+						.read(true)
+						.write(true)
+						.open(&trash_file_path.clone())?;
+					trash_file.sync_all()?;
 				}
+
+				// We're fine if this remove would fail as the trash file will be cleaned up in
+				// list eventually.
+				fs::remove_file(trash_file_path).ok();
 			}
 		}