Warn when running low on disk space when performing certain editor operations

The following editor operations will now warn the user if the available
space on the target disk is low:

- Saving a scene (< 1 GiB).
- Importing a set of resources (< 2 GiB).
- Downloading export templates (< 4 GiB).
- Installing export templates (< 4 GiB).
- Exporting a project (< 10 GiB).
- Packing a project as a ZIP file (< 10 GiB).

Author: Calinou

editor/editor_file_system.cpp

@@ -3142,6 +3142,13 @@ void EditorFileSystem::reimport_files(const Vector<String> &p_files) {
 
 	EditorProgress *ep = memnew(EditorProgress("reimport", TTR("(Re)Importing Assets"), p_files.size()));
 
+	if (!p_files.is_empty()) {
+		// Imported resources can be relatively large, so check if there is enough disk space.
+		// We perform the check here so it's performed only one for all files to be reimported,
+		// instead of once for each file.
+		EditorNode::get_singleton()->check_disk_space(p_files[0], 2.0, TTR("Importing resources will fail if the disk runs out of space."));
+	}
+
 	// The method reimport_files runs on the main thread, and if VSync is enabled
 	// or Update Continuously is disabled, Main::Iteration takes longer each frame.
 	// Each EditorProgress::step can trigger a redraw, and when there are many files to import,

editor/editor_node.cpp

@@ -1800,6 +1800,11 @@ void EditorNode::_find_node_types(Node *p_node, int &count_2d, int &count_3d) {
 }
 
 void EditorNode::_save_scene_with_preview(String p_file, int p_idx) {
+	// Scene files are typically less than 1 MB, but text-based scenes with large amounts of embedded binary data
+	// can be much larger (sometimes 100 MB or more). Consider a buffer of 1 GiB to be safe, since there are
+	// also temporary files and thumbnails that come into play.
+	check_disk_space(p_file, 1.0, TTR("Saving scenes will fail if the disk runs out of space."));
+
 	save_scene_progress = memnew(EditorProgress("save", TTR("Saving Scene"), 4));
 
 	if (editor_data.get_edited_scene_root() != nullptr) {
@@ -6790,6 +6795,21 @@ bool EditorNode::call_build() {
 	return builds_successful;
 }
 
+// Check for available disk space on the target disk and warn the user if needed according to a set threshold.
+// The threshold (set in GiB) should be set to cover most use cases for the file being written.
+void EditorNode::check_disk_space(const String &p_target_path, float p_size_gib, const String &p_rationale) const {
+	Ref<DirAccess> dir = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
+	String path = p_target_path.get_basename();
+	if (path.is_relative_path()) {
+		path = "res://" + path;
+	}
+	dir->open(path);
+	if (dir->get_space_left() < p_size_gib * Math::pow(1024.0, 3.0)) {
+		// Less than `p_size_gib` GiB available.
+		WARN_PRINT_ED(vformat(TTR("Current available space on target disk is low (%s)."), String::humanize_size(dir->get_space_left())) + " " + p_rationale);
+	}
+}
+
 void EditorNode::_inherit_imported(const String &p_action) {
 	open_imported->hide();
 	load_scene(open_import_request, true, true);

editor/editor_node.h

@@ -741,6 +741,8 @@ class EditorNode : public Node {
 	static void add_init_callback(EditorNodeInitCallback p_callback) { _init_callbacks.push_back(p_callback); }
 	static void add_build_callback(EditorBuildCallback p_callback);
 
+	void check_disk_space(const String &p_target_path, float p_size_gib, const String &p_rationale) const;
+
 	static bool immediate_confirmation_dialog(const String &p_text, const String &p_ok_text = TTR("Ok"), const String &p_cancel_text = TTR("Cancel"), uint32_t p_wrap_width = 0);
 
 	static void cleanup();

editor/export/editor_export_platform.cpp

@@ -214,6 +214,11 @@ bool EditorExportPlatform::fill_log_messages(RichTextLabel *p_log, Error p_err)
 	return has_messages;
 }
 
+void EditorExportPlatform::check_disk_space(const String &p_path) const {
+	// Project files can grow quite large, so check for a reasonable amount of available space before exporting.
+	EditorNode::get_singleton()->check_disk_space(p_path, 10.0, TTR("Exporting the project will fail if the disk runs out of space."));
+}
+
 bool EditorExportPlatform::_check_hash(const uint8_t *p_hash, const Vector<uint8_t> &p_data) {
 	if (p_hash == nullptr) {
 		return false;
@@ -2189,11 +2194,13 @@ Error EditorExportPlatform::save_zip_patch(const Ref<EditorExportPreset> &p_pres
 
 Error EditorExportPlatform::export_pack(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, BitField<EditorExportPlatform::DebugFlags> p_flags) {
 	ExportNotifier notifier(*this, p_preset, p_debug, p_path, p_flags);
+	check_disk_space(p_path);
 	return save_pack(p_preset, p_debug, p_path);
 }
 
 Error EditorExportPlatform::export_zip(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, BitField<EditorExportPlatform::DebugFlags> p_flags) {
 	ExportNotifier notifier(*this, p_preset, p_debug, p_path, p_flags);
+	check_disk_space(p_path);
 	return save_zip(p_preset, p_debug, p_path);
 }
 
@@ -2203,6 +2210,7 @@ Error EditorExportPlatform::export_pack_patch(const Ref<EditorExportPreset> &p_p
 	if (err != OK) {
 		return err;
 	}
+	check_disk_space(p_path);
 	err = save_pack_patch(p_preset, p_debug, p_path);
 	_unload_patches();
 	return err;
@@ -2214,6 +2222,7 @@ Error EditorExportPlatform::export_zip_patch(const Ref<EditorExportPreset> &p_pr
 	if (err != OK) {
 		return err;
 	}
+	check_disk_space(p_path);
 	err = save_zip_patch(p_preset, p_debug, p_path);
 	_unload_patches();
 	return err;

editor/export/editor_export_platform.h

@@ -231,6 +231,8 @@ class EditorExportPlatform : public RefCounted {
 	virtual Ref<EditorExportPreset> create_preset();
 	virtual bool is_executable(const String &p_path) const { return false; }
 
+	void check_disk_space(const String &p_path) const;
+
 	virtual void clear_messages() { messages.clear(); }
 	virtual void add_message(ExportMessageType p_type, const String &p_category, const String &p_message) {
 		ExportMessage msg;

editor/export/editor_export_platform_extension.cpp

@@ -267,6 +267,7 @@ List<String> EditorExportPlatformExtension::get_binary_extensions(const Ref<Edit
 
 Error EditorExportPlatformExtension::export_project(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, BitField<EditorExportPlatform::DebugFlags> p_flags) {
 	ExportNotifier notifier(*this, p_preset, p_debug, p_path, p_flags);
+	check_disk_space(p_path);
 
 	Error ret = FAILED;
 	GDVIRTUAL_CALL(_export_project, p_preset, p_debug, p_path, p_flags, ret);

editor/export/editor_export_platform_pc.cpp

@@ -117,6 +117,7 @@ bool EditorExportPlatformPC::has_valid_project_configuration(const Ref<EditorExp
 
 Error EditorExportPlatformPC::export_project(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, BitField<EditorExportPlatform::DebugFlags> p_flags) {
 	ExportNotifier notifier(*this, p_preset, p_debug, p_path, p_flags);
+	check_disk_space(p_path);
 
 	Error err = prepare_template(p_preset, p_debug, p_path, p_flags);
 	if (err == OK) {

editor/export/export_template_manager.cpp

@@ -159,6 +159,14 @@ void ExportTemplateManager::_download_current() {
 	}
 	is_downloading_templates = true;
 
+	// Decompressed official export templates are typically around 2 GiB on disk.
+	// However, the compressed file has to stay on disk until the export templates are done extracting,
+	// so we also need to account for its compressed size on top.
+	EditorNode::get_singleton()->check_disk_space(
+			EditorPaths::get_singleton()->get_data_dir(),
+			4.0,
+			TTR("Downloading export templates will fail if the disk runs out of space."));
+
 	install_options_vb->hide();
 	download_progress_hb->show();
 
@@ -425,6 +433,12 @@ void ExportTemplateManager::_install_file() {
 }
 
 bool ExportTemplateManager::_install_file_selected(const String &p_file, bool p_skip_progress) {
+	// Decompressed official export templates are typically around 2 GiB on disk.
+	EditorNode::get_singleton()->check_disk_space(
+			EditorPaths::get_singleton()->get_data_dir(),
+			4.0,
+			TTR("Installing export templates will fail if the disk runs out of space."));
+
 	Ref<FileAccess> io_fa;
 	zlib_filefunc_def io = zipio_create_io(&io_fa);
 

editor/export/project_zip_packer.cpp

@@ -50,6 +50,9 @@ String ProjectZIPPacker::get_project_zip_safe_name() {
 }
 
 void ProjectZIPPacker::pack_project_zip(const String &p_path) {
+	// Project files can grow quite large, so check for a reasonable amount of available space before packing.
+	EditorNode::get_singleton()->check_disk_space(p_path, 10.0, TTR("Packing the project as ZIP will fail if the disk runs out of space."));
+
 	Ref<FileAccess> io_fa;
 	zlib_filefunc_def io = zipio_create_io(&io_fa);
 

platform/android/export/export_plugin.cpp

@@ -3337,6 +3337,7 @@ bool EditorExportPlatformAndroid::_is_clean_build_required(const Ref<EditorExpor
 Error EditorExportPlatformAndroid::export_project(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, BitField<EditorExportPlatform::DebugFlags> p_flags) {
 	int export_format = int(p_preset->get("gradle_build/export_format"));
 	bool should_sign = p_preset->get("package/signed");
+	check_disk_space(p_path);
 	return export_project_helper(p_preset, p_debug, p_path, export_format, should_sign, p_flags);
 }