Stop Malformed Network Responses from Crashing the App

Duet, MKS and UltiMaker parsed print host replies with boost read_json
inside the HTTP completion callback with no try, so an HTML or truncated
reply threw out of the Physical Printer Test button and terminated the app,
or killed the upload queue thread. The five identical copies of the parser
(ESP3D's and Flashforge's were unused) are replaced by one shared
PrintHost::get_err_code_from_body that reports a non-JSON reply as an error.
The upload queue now catches a failing job per job, so one bad upload no
longer leaves later jobs queued forever.

Flashforge read material station slots with nlohmann value(), which throws
on off-type fields or non-object entries. The parsing moves into
Flashforge::parse_material_slots, which reads fields leniently with the
existing try_parse_json_int and skips bad entries.

UserManager::parse_json parsed the payload before its try block; the parse
now happens inside it.

src/OrcaSlicer.cpp

@@ -2116,14 +2116,9 @@ int CLI::run(int argc, char **argv)
 
     // One resolver for the whole run, so presets from the same vendor tree share its load.
     std::unique_ptr<PresetBundle> system_preset_resolver;
-    auto ensure_system_preset_resolver = [&system_preset_resolver]() -> PresetBundle & {
-        if (!system_preset_resolver)
-            system_preset_resolver = std::make_unique<PresetBundle>();
-        return *system_preset_resolver;
-    };
-    auto resolve_preset = [&ensure_cli_preset_bundle, &ensure_system_preset_resolver](const std::string &file, DynamicPrintConfig &config,
-                                                                                      std::string &config_type, const std::string &config_from,
-                                                                                      bool probe_type, std::string &error) {
+    auto resolve_preset = [&ensure_cli_preset_bundle, &system_preset_resolver](const std::string &file, DynamicPrintConfig &config,
+                                                                               std::string &config_type, const std::string &config_from,
+                                                                               bool probe_type, std::string &error) {
         const auto *inherits = config.option<ConfigOptionString>(BBL_JSON_KEY_INHERITS);
         if (!probe_type && (inherits == nullptr || inherits->value.empty()))
             return true;
@@ -2131,7 +2126,9 @@ int CLI::run(int argc, char **argv)
         PresetBundle                 *bundle = nullptr;
         bool                          allow_source_manifest = false;
         if (config_from == "system") {
-            bundle                = &ensure_system_preset_resolver();
+            if (!system_preset_resolver)
+                system_preset_resolver = std::make_unique<PresetBundle>();
+            bundle                = system_preset_resolver.get();
             allow_source_manifest = true;
         } else {
             bundle = ensure_cli_preset_bundle(error);
@@ -3123,49 +3120,6 @@ int CLI::run(int argc, char **argv)
         return 0;
     };
 
-    // A project saved before a printer or process option existed has no value for it. The GUI takes such
-    // keys from the project's system preset (load_external_preset refreshes every key the project did not
-    // override), so fill them from there too instead of leaving them to the option default.
-    // The extruder variant keys describe the project's variant layout and are kept as they are, so an
-    // older project is not left with a variant list from one layout and ids from another.
-    auto fill_missing_project_keys = [this, &ensure_system_preset_resolver](const std::string &system_name, Preset::Type type) {
-        if (system_name.empty())
-            return;
-        static const std::set<std::string> skip_keys = {
-            "inherits", "compatible_printers", "compatible_prints", "compatible_printers_condition", "compatible_prints_condition",
-            "print_settings_id", "filament_settings_id", "printer_settings_id",
-            "print_host", "print_host_webui", "printhost_apikey", "printhost_cafile", "printhost_user", "printhost_password", "printhost_port",
-            "printer_extruder_id", "printer_extruder_variant", "print_extruder_id", "print_extruder_variant", "extruder_variant_list"};
-        const std::vector<std::string> &options = type == Preset::TYPE_PRINTER ? Preset::printer_options() : Preset::print_options();
-        // Keys the legacy handler drops on load can never be in a project, so they do not count as missing.
-        auto dropped_on_load = [](std::string key) {
-            std::string value;
-            PrintConfigDef::handle_legacy(key, value);
-            return key.empty();
-        };
-        std::vector<std::string> missing;
-        for (const std::string &key : options)
-            if (m_print_config.option(key) == nullptr && skip_keys.count(key) == 0 && !dropped_on_load(key))
-                missing.push_back(key);
-        if (missing.empty())
-            return;
-        DynamicPrintConfig system_config;
-        std::string        error;
-        if (!ensure_system_preset_resolver().resolve_system_preset(system_config, type, system_name, config_substitution_rule, error)) {
-            BOOST_LOG_TRIVIAL(warning) << boost::format("CLI: system preset '%1%' not resolved (%2%); keys missing from the project keep their defaults") % system_name % error;
-            return;
-        }
-        for (const std::string &key : missing)
-            if (const ConfigOption *opt = system_config.option(key)) {
-                m_print_config.set_key_value(key, opt->clone());
-                BOOST_LOG_TRIVIAL(info) << boost::format("CLI: %1% missing from the project, taken from '%2%': %3%") % key % system_name % opt->serialize();
-            }
-    };
-    if (new_printer_name.empty())
-        fill_missing_project_keys(current_printer_system_name, Preset::TYPE_PRINTER);
-    if (new_process_name.empty())
-        fill_missing_project_keys(current_process_system_name, Preset::TYPE_PRINT);
-
     std::vector<std::string>& different_settings = m_print_config.option<ConfigOptionStrings>("different_settings_to_system", true)->values;
     std::vector<std::string>& inherits_group = m_print_config.option<ConfigOptionStrings>("inherits_group", true)->values;
     inherits_group.resize(filament_count + 2, std::string());

src/libslic3r/PresetBundle.cpp

@@ -575,20 +575,18 @@ bool PresetBundle::resolve_preset_config(DynamicPrintConfig &config, Preset::Typ
 const PresetBundle *PresetBundle::load_source_vendor(const boost::filesystem::path &root_dir,
                                                     const std::string &vendor_id,
                                                     ForwardCompatibilitySubstitutionRule compatibility_rule,
-                                                    std::string &error, bool allow_cache)
+                                                    std::string &error)
 {
-    auto key = std::make_tuple(root_dir.string(), vendor_id, compatibility_rule, allow_cache);
+    auto key = std::make_tuple(root_dir.string(), vendor_id, compatibility_rule);
     if (auto it = m_source_vendor_bundles.find(key); it != m_source_vendor_bundles.end())
         return it->second.get();
 
     // The library loads with no base of its own, so the tree a vendor inherits from
     // is the same one that resolves the library's own presets.
-    const std::string   library_file = std::string(ORCA_FILAMENT_LIBRARY);
-    const PresetBundle *library      = nullptr;
+    const PresetBundle *library = nullptr;
     if (vendor_id != ORCA_FILAMENT_LIBRARY &&
-        (boost::filesystem::is_regular_file(root_dir / (library_file + ".json")) ||
-         (allow_cache && boost::filesystem::is_regular_file(root_dir / (library_file + ".opc"))))) {
-        library = load_source_vendor(root_dir, ORCA_FILAMENT_LIBRARY, compatibility_rule, error, allow_cache);
+        boost::filesystem::is_regular_file(root_dir / (std::string(ORCA_FILAMENT_LIBRARY) + ".json"))) {
+        library = load_source_vendor(root_dir, ORCA_FILAMENT_LIBRARY, compatibility_rule, error);
         if (library == nullptr) {
             error = "OrcaFilamentLibrary contains invalid presets";
             return nullptr;
@@ -597,7 +595,7 @@ const PresetBundle *PresetBundle::load_source_vendor(const boost::filesystem::pa
 
     auto bundle = std::make_unique<PresetBundle>();
     bundle->m_preserve_vendor_source_paths = true;
-    bundle->load_vendor_configs_from_json(root_dir.string(), vendor_id, LoadSystem, compatibility_rule, library, allow_cache);
+    bundle->load_vendor_configs_from_json(root_dir.string(), vendor_id, LoadSystem, compatibility_rule, library, false);
     if (bundle->error_count() != 0) {
         error = "Vendor bundle contains invalid presets";
         return nullptr;
@@ -640,43 +638,6 @@ bool PresetBundle::resolve_preset_config_type(DynamicPrintConfig &config, Preset
     return true;
 }
 
-bool PresetBundle::resolve_system_preset(DynamicPrintConfig &config, Preset::Type type, const std::string &name,
-                                         ForwardCompatibilitySubstitutionRule compatibility_rule, std::string &error)
-{
-    const std::string vendor_id = find_preset_vendor(name, type);
-    if (vendor_id.empty()) {
-        error = "No vendor lists the preset";
-        return false;
-    }
-    // Release builds ship a vendor as its preset cache alone, without the profile JSONs.
-    auto installed = [&vendor_id](const fs::path &root) {
-        return fs::is_regular_file(root / (vendor_id + ".json")) || fs::is_regular_file(root / (vendor_id + ".opc"));
-    };
-    fs::path root_dir = fs::path(data_dir()) / PRESET_SYSTEM_DIR;
-    if (!installed(root_dir))
-        root_dir = fs::path(resources_dir()) / PRESET_PROFILES_DIR;
-    const bool cache_only = !fs::is_regular_file(root_dir / (vendor_id + ".json"));
-
-    try {
-        const PresetBundle *vendor = load_source_vendor(root_dir, vendor_id, compatibility_rule, error, cache_only);
-        if (vendor == nullptr)
-            return false;
-        const PresetCollection &collection = type == Preset::TYPE_PRINTER ? vendor->printers :
-                                             type == Preset::TYPE_PRINT   ? vendor->prints : vendor->filaments;
-        const Preset *preset = collection.find_preset(name, false);
-        if (preset == nullptr) {
-            error = "Preset was not found in its vendor bundle";
-            return false;
-        }
-        config = preset->config;
-    } catch (const std::exception &ex) {
-        error = ex.what();
-        return false;
-    }
-    error.clear();
-    return true;
-}
-
 PresetBundle::PresetBundle(const PresetBundle &rhs)
 {
     *this = rhs;

src/libslic3r/PresetBundle.hpp

@@ -273,10 +273,6 @@ public:
                                     const std::string &source_file,
                                     ForwardCompatibilitySubstitutionRule compatibility_rule,
                                     std::string &error, bool allow_source_manifest = true);
-    // Resolve a system preset by name. The vendor tree is read from data_dir()/system when installed
-    // there, as the GUI reads it, and from the bundled profiles otherwise.
-    bool resolve_system_preset(DynamicPrintConfig &config, Preset::Type type, const std::string &name,
-                               ForwardCompatibilitySubstitutionRule compatibility_rule, std::string &error);
 
     // Load selections (current print, current filaments, current printer) from config.ini
     // This is done just once on application start up.
@@ -667,14 +663,13 @@ private:
     // Vendor trees loaded by resolve_preset_config's manifest path, so every preset
     // resolved through this bundle shares one load per source root and vendor. The
     // filament library is one such tree, shared by every vendor under its root.
-    // A tree read from its preset cache is kept apart: its presets carry no source file.
-    std::map<std::tuple<std::string, std::string, ForwardCompatibilitySubstitutionRule, bool>, std::unique_ptr<PresetBundle>>
+    std::map<std::tuple<std::string, std::string, ForwardCompatibilitySubstitutionRule>, std::unique_ptr<PresetBundle>>
         m_source_vendor_bundles;
 
     const PresetBundle *load_source_vendor(const boost::filesystem::path &root_dir,
                                            const std::string &vendor_id,
                                            ForwardCompatibilitySubstitutionRule compatibility_rule,
-                                           std::string &error, bool allow_cache = false);
+                                           std::string &error);
 
     // Orca: validation only - flag any printer with two or more compatible
     // filament presets sharing one filament_id (ambiguous AMS subtype match).

src/libvgcode/src/Shaders.hpp

@@ -34,10 +34,6 @@ static const char* Segments_Vertex_Shader =
 // ORCA: 0 during the shadow caster pass - the bias below shifts eye_position but not
 // world_position, so the caster would write a depth the receiver never looks up.
 "uniform float bias_scale;\n"
-// draw the instances last to first, top layers before the ones they hide, so that early depth
-// rejection discards most of the hidden fragments; set when the camera looks down on the print
-"uniform int reverse_order;\n"
-"uniform int instance_count;\n"
 "in int vertex_id;\n"
 "out vec3 color;\n"
 "// ORCA: realistic view - the light the shadow map is able to block, kept apart from the\n"
@@ -63,8 +59,7 @@ static const char* Segments_Vertex_Shader =
 "  return top_diffuse + front_diffuse + top_specular;\n"
 "}\n"
 "void main() {\n"
-"  int instance = (reverse_order != 0) ? instance_count - 1 - gl_InstanceID : gl_InstanceID;\n"
-"  int id_a = int(texelFetch(segment_index_tex, instance).r);\n"
+"  int id_a = int(texelFetch(segment_index_tex, gl_InstanceID).r);\n"
 "  int id_b = id_a + 1;\n"
 "  vec3 pos_a = texelFetch(position_tex, id_a).xyz;\n"
 "  vec3 pos_b = texelFetch(position_tex, id_b).xyz;\n"

src/libvgcode/src/ViewerImpl.cpp

@@ -763,8 +763,6 @@ void ViewerImpl::init(const std::string& opengl_context_version)
     m_uni_segments_height_width_angle_tex_id = glGetUniformLocation(m_segments_shader_id, "height_width_angle_tex");
     m_uni_segments_colors_tex_id             = glGetUniformLocation(m_segments_shader_id, "color_tex");
     m_uni_segments_segment_index_tex_id      = glGetUniformLocation(m_segments_shader_id, "segment_index_tex");
-    m_uni_segments_reverse_order_id          = glGetUniformLocation(m_segments_shader_id, "reverse_order");
-    m_uni_segments_instance_count_id         = glGetUniformLocation(m_segments_shader_id, "instance_count");
     // ORCA: realistic view
     m_uni_segments_shadow_map_id             = glGetUniformLocation(m_segments_shader_id, "shadow_map");
     m_uni_segments_shadow_light_vp_id        = glGetUniformLocation(m_segments_shader_id, "shadow_light_vp");
@@ -2092,15 +2090,6 @@ void ViewerImpl::render_segments(const Mat4x4& view_matrix, const Mat4x4& projec
     glsafe(glUniformMatrix4fv(m_uni_segments_view_matrix_id, 1, GL_FALSE, view_matrix.data()));
     glsafe(glUniformMatrix4fv(m_uni_segments_projection_matrix_id, 1, GL_FALSE, projection_matrix.data()));
     glsafe(glUniform3fv(m_uni_segments_camera_position_id, 1, camera_position.data()));
-    // The segments come in print order, bottom layer first. Seen from above, that is back to front,
-    // and every hidden fragment is shaded before the one that covers it. Drawing them last to first
-    // lets the depth test reject the hidden ones instead. The camera looks down when the world's
-    // up axis points towards it, which is the view matrix's (2, 2) entry being positive.
-    const bool top_down = !m_rendering_shadow_casters && view_matrix[10] > 0.0f;
-    glsafe(glUniform1i(m_uni_segments_reverse_order_id, top_down ? 1 : 0));
-#ifndef ENABLE_OPENGL_ES
-    glsafe(glUniform1i(m_uni_segments_instance_count_id, static_cast<int>(m_enabled_segments_count)));
-#endif // ENABLE_OPENGL_ES
     // ORCA: realistic view. The depth pass writes the map it would otherwise read, so it shades
     // with the lookup off.
     glsafe(glUniform1i(m_uni_segments_shadow_map_id, m_shadow_map_texture_unit));

src/libvgcode/src/ViewerImpl.hpp

@@ -362,8 +362,6 @@ private:
     int m_uni_segments_height_width_angle_tex_id{ -1 };
     int m_uni_segments_colors_tex_id{ -1 };
     int m_uni_segments_segment_index_tex_id{ -1 };
-    int m_uni_segments_reverse_order_id{ -1 };
-    int m_uni_segments_instance_count_id{ -1 };
     int m_uni_segments_shadow_map_id{ -1 };
     int m_uni_segments_shadow_light_vp_id{ -1 };
     int m_uni_segments_shadow_intensity_id{ -1 };

src/slic3r/GUI/UserManager.cpp

@@ -31,14 +31,15 @@ int UserManager::parse_json(std::string payload)
 {
     bool restored_json = false;
     json j;
-    json j_pre = json::parse(payload);
-    if (j_pre.empty()) {
-        return -1;
-    }
 
     //bind/unbind
 
     try {
+        json j_pre = json::parse(payload);
+        if (j_pre.empty()) {
+            return -1;
+        }
+
         if (j_pre.contains("bind")) {
             if (j_pre["bind"].contains("command")) {
 

src/slic3r/Utils/Duet.cpp

@@ -274,13 +274,4 @@ bool Duet::start_print(wxString &msg, const std::string &filename, ConnectionTyp
 	return res;
 }
 
-int Duet::get_err_code_from_body(const std::string &body) const
-{
-	pt::ptree root;
-	std::istringstream iss (body); // wrap returned json to istringstream
-	pt::read_json(iss, root);
-
-	return root.get<int>("err", 0);
-}
-
 }

src/slic3r/Utils/Duet.hpp

@@ -40,7 +40,6 @@ private:
 	ConnectionType connect(wxString &msg) const;
 	void disconnect(ConnectionType connectionType) const;
 	bool start_print(wxString &msg, const std::string &filename, ConnectionType connectionType, bool simulationMode) const;
-	int get_err_code_from_body(const std::string &body) const;
 };
 
 }

src/slic3r/Utils/ESP3D.cpp

@@ -146,15 +146,6 @@ bool ESP3D::start_print(wxString& msg, const std::string& filename) const
     return ret;
 }
 
-int ESP3D::get_err_code_from_body(const std::string& body) const
-{
-    pt::ptree          root;
-    std::istringstream iss(body); // wrap returned json to istringstream
-    pt::read_json(iss, root);
-
-    return root.get<int>("err", 0);
-}
-
 // ESP3D only accepts 8.3 filenames else it crashes marlin and other undefined behaviour
 std::string ESP3D::get_short_name(const std::string& filename) const
 {

src/slic3r/Utils/ESP3D.hpp

@@ -33,7 +33,6 @@ private:
     std::string m_console_port;
 
     bool        start_print(wxString& msg, const std::string& filename) const;
-    int         get_err_code_from_body(const std::string& body) const;
     std::string get_short_name(const std::string& filename) const;
     std::string format_command(const std::string& path, const std::string& arg, const std::string& val) const;
 };

src/slic3r/Utils/Flashforge.cpp

@@ -510,12 +510,22 @@ bool Flashforge::fetch_material_slots(std::vector<FlashforgeMaterialSlot>& slots
     if (!request_local_api_json("detail", json{{"serialNumber", m_serial_number}, {"checkCode", m_check_code}}.dump(), body, msg))
         return false;
 
-    const auto parsed = json::parse(body, nullptr, false, true);
-    if (parsed.is_discarded()) {
+    if (!parse_material_slots(body, slots, supports_material_station)) {
         msg = _(L("Flashforge returned an invalid JSON response."));
         return false;
     }
 
+    return true;
+}
+
+bool Flashforge::parse_material_slots(const std::string& body, std::vector<FlashforgeMaterialSlot>& slots, bool* supports_material_station)
+{
+    slots.clear();
+
+    const auto parsed = json::parse(body, nullptr, false, true);
+    if (parsed.is_discarded())
+        return false;
+
     const auto& detail = parsed.contains("detail") ? parsed["detail"] : parsed;
     const auto& station = detail.contains("matlStationInfo") ? detail["matlStationInfo"] :
                           detail.contains("MatlStationInfo") ? detail["MatlStationInfo"] : json();
@@ -542,12 +552,21 @@ bool Flashforge::fetch_material_slots(std::vector<FlashforgeMaterialSlot>& slots
     if (supports_material_station != nullptr)
         *supports_material_station = reports_material_station;
 
+    // Fields are read leniently: firmware may send numbers as strings or flags as numbers.
     for (const auto& slot : slot_infos) {
+        if (!slot.is_object())
+            continue;
         FlashforgeMaterialSlot info;
-        info.slot_id        = slot.value("slotId", static_cast<int>(slots.size()) + 1);
-        info.has_filament   = slot.value("hasFilament", false);
-        info.material_name  = slot.value("materialName", std::string());
-        info.material_color = slot.value("materialColor", std::string());
+        info.slot_id = static_cast<int>(slots.size()) + 1;
+        if (const auto it = slot.find("slotId"); it != slot.end())
+            try_parse_json_int(*it, info.slot_id);
+        int has_filament = 0;
+        if (const auto it = slot.find("hasFilament"); it != slot.end() && try_parse_json_int(*it, has_filament))
+            info.has_filament = has_filament != 0;
+        if (const auto it = slot.find("materialName"); it != slot.end() && it->is_string())
+            info.material_name = it->get<std::string>();
+        if (const auto it = slot.find("materialColor"); it != slot.end() && it->is_string())
+            info.material_color = it->get<std::string>();
         slots.emplace_back(std::move(info));
     }
 
@@ -670,13 +689,4 @@ std::string Flashforge::extract_host_name() const
     return out;
 }
 
-int Flashforge::get_err_code_from_body(const std::string& body) const
-{
-    pt::ptree          root;
-    std::istringstream iss(body); // wrap returned json to istringstream
-    pt::read_json(iss, root);
-
-    return root.get<int>("err", 0);
-}
-
 } // namespace Slic3r

src/slic3r/Utils/Flashforge.hpp

@@ -45,6 +45,8 @@ public:
     PrintHostPostUploadActions get_post_upload_actions() const override { return PrintHostPostUploadAction::StartPrint; }
     std::string                get_host() const override { return m_host; }
     bool                       fetch_material_slots(std::vector<FlashforgeMaterialSlot>& slots, bool* supports_material_station, wxString& msg) const;
+    // Parses a local API "detail" reply. Returns false when the body is not valid JSON.
+    static bool                parse_material_slots(const std::string& body, std::vector<FlashforgeMaterialSlot>& slots, bool* supports_material_station);
     static bool                discover_printers(std::vector<FlashforgeDiscoveredPrinter>& printers, wxString& msg, int timeout_ms = 10000, int idle_timeout_ms = 1500, int max_retries = 3);
 
 private:
@@ -68,7 +70,6 @@ private:
     bool request_local_api_json(const std::string& path, const std::string& body, std::string& response_body, wxString& error_msg) const;
     std::string make_http_url(const std::string& path) const;
     std::string extract_host_name() const;
-    int  get_err_code_from_body(const std::string &body) const;
     bool connect(wxString& msg) const;
     bool start_print(wxString& msg, const std::string& filename) const;
 };

src/slic3r/Utils/MKS.cpp

@@ -141,13 +141,4 @@ bool MKS::start_print(wxString& msg, const std::string& filename) const
 	return ret;
 }
 
-int MKS::get_err_code_from_body(const std::string& body) const
-{
-	pt::ptree root;
-	std::istringstream iss(body); // wrap returned json to istringstream
-	pt::read_json(iss, root);
-
-	return root.get<int>("err", 0);
-}
-
 } // Slic3r

src/slic3r/Utils/MKS.hpp

@@ -34,7 +34,6 @@ private:
 
 	std::string get_upload_url(const std::string& filename) const;
 	bool start_print(wxString& msg, const std::string& filename) const;
-	int get_err_code_from_body(const std::string& body) const;
 };
 
 }

src/slic3r/Utils/PrintHost.cpp

@@ -3,10 +3,13 @@
 #include <vector>
 #include <thread>
 #include <exception>
+#include <sstream>
 #include <boost/optional.hpp>
 #include <boost/log/trivial.hpp>
 #include <boost/filesystem.hpp>
 #include <nlohmann/json.hpp>
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/json_parser.hpp>
 
 #include <wx/string.h>
 #include <wx/app.h>
@@ -172,6 +175,20 @@ std::string moonraker_error_reason(const std::string &body)
 
 } // namespace
 
+int PrintHost::get_err_code_from_body(const std::string &body)
+{
+    boost::property_tree::ptree root;
+    std::istringstream iss(body);
+    try {
+        boost::property_tree::read_json(iss, root);
+    } catch (const std::exception &ex) {
+        BOOST_LOG_TRIVIAL(error) << "PrintHost: response is not valid JSON: " << ex.what();
+        return -1;
+    }
+
+    return root.get<int>("err", 0);
+}
+
 wxString PrintHost::format_error(const std::string &body, const std::string &error, unsigned status) const
 {
     if (status != 0) {
@@ -303,7 +320,12 @@ void PrintHostJobQueue::priv::bg_thread_main()
                 % job.cancelled;
 
             if (! job.cancelled) {
-                perform_job(std::move(job));
+                // A failing job must not stop the worker, or later jobs would stay queued forever.
+                try {
+                    perform_job(std::move(job));
+                } catch (const std::exception &e) {
+                    emit_error(e.what());
+                }
             }
 
             remove_source();

src/slic3r/Utils/PrintHost.hpp

@@ -87,6 +87,8 @@ public:
 
     static PrintHost* get_print_host(DynamicPrintConfig *config);
     static std::string get_print_host_webui(DynamicPrintConfig *config);
+    // Reads the "err" field of a JSON reply, 0 when absent. Returns -1 when the body is not valid JSON.
+    static int get_err_code_from_body(const std::string &body);
 
     //Support for cloud webui login
     virtual bool is_cloud() const { return false; }

src/slic3r/Utils/UltiMaker.cpp

@@ -654,13 +654,4 @@ bool UltiMaker::start_print(wxString &msg, const std::string &filename, Connecti
 	return res;
 }
 
-int UltiMaker::get_err_code_from_body(const std::string &body) const
-{
-	pt::ptree root;
-	std::istringstream iss (body); // wrap returned json to istringstream
-	pt::read_json(iss, root);
-
-	return root.get<int>("err", 0);
-}
-
 }

src/slic3r/Utils/UltiMaker.hpp

@@ -64,7 +64,6 @@ private:
 	void set_auth(Http& http) const;
 	void disconnect(ConnectionType connectionType) const;
 	bool start_print(wxString &msg, const std::string &filename, ConnectionType connectionType) const;
-	int get_err_code_from_body(const std::string &body) const;
 };
 
 }

tests/cli/CMakeLists.txt

@@ -15,11 +15,3 @@ set_tests_properties(cli_strict_mode PROPERTIES
     LABELS "CLI;RequiresApp"
     SKIP_RETURN_CODE 77
     TIMEOUT 900)
-
-add_test(NAME cli_project_missing_keys
-    COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cli_project_missing_keys.sh $<TARGET_FILE:OrcaSlicer> ${ORCA_CLI_TEST_PYTHON}
-        ${CMAKE_SOURCE_DIR}/resources/profiles/BBL)
-set_tests_properties(cli_project_missing_keys PROPERTIES
-    LABELS "CLI;RequiresApp"
-    SKIP_RETURN_CODE 77
-    TIMEOUT 900)

tests/cli/test_cli_project_missing_keys.sh

@@ -1,89 +0,0 @@
-#!/usr/bin/env bash
-# End-to-end check that the CLI fills settings missing from a project from the project's system presets.
-#
-# A project saved before an option existed has no value for it. The GUI takes such keys from the
-# project's system printer and process presets, not from the option defaults, and the CLI must slice
-# the project with the same values. A project is exported from the shipped Bambu Lab P1S presets, one
-# printer key and one process key are removed from it, one kept key is changed, and it is sliced again.
-#
-# usage: test_cli_project_missing_keys.sh <orca-slicer binary> <python3> <resources/profiles/BBL>
-set -u
-
-BIN="${1:-}"
-PY="${2:-python3}"
-PROFILES="${3:-}"
-# 77 is the test's SKIP_RETURN_CODE.
-[ -x "$BIN" ] || { echo "SKIP: orca-slicer binary not found: $BIN"; exit 77; }
-[ -d "$PROFILES" ] || { echo "FAIL: profiles directory not found: $PROFILES"; exit 1; }
-
-WORK="$(mktemp -d "${TMPDIR:-/tmp}/orca-cli-missing-keys.XXXXXX")"
-trap 'rm -rf "$WORK"' EXIT
-
-"$PY" - "$WORK/cube.stl" <<'EOF'
-import sys
-
-v = [(x, y, z) for z in (0, 10) for y in (0, 10) for x in (0, 10)]
-with open(sys.argv[1], "w") as f:
-    f.write("solid cube\n")
-    for a, b, c, d in ((0, 2, 3, 1), (4, 5, 7, 6), (0, 1, 5, 4), (2, 6, 7, 3), (0, 4, 6, 2), (1, 3, 7, 5)):
-        for tri in ((v[a], v[b], v[c]), (v[a], v[c], v[d])):
-            f.write("facet normal 0 0 0\nouter loop\n")
-            for p in tri:
-                f.write("vertex %g %g %g\n" % p)
-            f.write("endloop\nendfacet\n")
-    f.write("endsolid cube\n")
-EOF
-
-# slice <tag> <input> [option...]: slice into $WORK/<tag>/out.3mf with a fresh data directory.
-slice() {
-    local out="$WORK/$1" input="$2"; shift 2
-    mkdir -p "$out"
-    timeout 300 "$BIN" --datadir "$out/datadir" "$@" --slice 0 --outputdir "$out" --export-3mf out.3mf "$input" \
-        > "$out/log" 2>&1 || { echo "FAIL: $1: orca-slicer exited $?"; tail -n 40 "$out/log"; exit 1; }
-}
-
-slice base "$WORK/cube.stl" \
-    --load-settings "$PROFILES/machine/Bambu Lab P1S 0.4 nozzle.json;$PROFILES/process/0.20mm Standard @BBL X1C.json" \
-    --load-filaments "$PROFILES/filament/Bambu PLA Basic @BBL P1S 0.4 nozzle.json"
-
-# The removed keys, with their option defaults from PrintConfig.cpp, and a kept key with a new value.
-"$PY" - "$WORK/base/out.3mf" "$WORK/old.3mf" <<'EOF' || exit $?
-import json, sys, zipfile
-
-src, dst = sys.argv[1], sys.argv[2]
-missing = {"extruder_clearance_dist_to_rod": "40", "sparse_infill_density": "20%"}
-with zipfile.ZipFile(src) as zin, zipfile.ZipFile(dst, "w", zipfile.ZIP_DEFLATED) as zout:
-    for item in zin.infolist():
-        data = zin.read(item.filename)
-        if item.filename == "Metadata/project_settings.config":
-            config = json.loads(data)
-            for key, default in missing.items():
-                if config[key] == default:
-                    print("SKIP: %s is %s in the system preset, the option default, so the test cannot tell them apart" % (key, default))
-                    sys.exit(77)
-            expected = {key: config.pop(key) for key in missing}
-            expected["wall_loops"] = str(int(config["wall_loops"]) + 1)
-            config["wall_loops"] = expected["wall_loops"]
-            data = json.dumps(config, indent=4)
-        zout.writestr(item, data)
-with open(dst + ".expected.json", "w") as f:
-    json.dump(expected, f)
-EOF
-
-slice project "$WORK/old.3mf"
-
-"$PY" - "$WORK/project/out.3mf" "$WORK/old.3mf.expected.json" <<'EOF'
-import json, sys, zipfile
-
-with zipfile.ZipFile(sys.argv[1]) as z:
-    config = json.loads(z.read("Metadata/project_settings.config"))
-with open(sys.argv[2]) as f:
-    expected = json.load(f)
-errors = ["%s is %r, want %r" % (key, config.get(key), want) for key, want in expected.items() if config.get(key) != want]
-for e in errors:
-    print("FAIL: " + e)
-sys.exit(1 if errors else 0)
-EOF
-status=$?
-[ "$status" -eq 0 ] || { tail -n 40 "$WORK/project/log"; exit 1; }
-echo "PASS"

tests/libslic3r/test_preset_bundle_loading.cpp

@@ -5405,35 +5405,6 @@ struct ScopedDataDir
     ~ScopedDataDir() { set_data_dir(previous); }
 };
 
-// resources_dir() is process-wide too; system preset lookups scan its profiles directory.
-struct ScopedResourcesDir
-{
-    std::string previous = resources_dir();
-    explicit ScopedResourcesDir(const fs::path &dir) { set_resources_dir(dir.string()); }
-    ~ScopedResourcesDir() { set_resources_dir(previous); }
-};
-
-// An "Acme" vendor under root whose "Acme Printer" inherits extruder_clearance_dist_to_rod from an
-// abstract base, with the printer in a nested sub_path so the name cannot be derived from the file.
-void write_acme_printer_vendor(const fs::path &root, double dist_to_rod)
-{
-    const fs::path machine_dir = root / "Acme" / "machine";
-    fs::create_directories(machine_dir / "nested");
-    std::ofstream((root / "Acme.json").string())
-        << R"({"version":"1.0.0","name":"Acme",)"
-        << R"("machine_model_list":[{"name":"Acme One","sub_path":"machine/model.json"}],"machine_list":[)"
-        << R"({"name":"fdm_acme_common","sub_path":"machine/base.json"},)"
-        << R"({"name":"Acme Printer","sub_path":"machine/nested/printer.json"}]})";
-    std::ofstream((machine_dir / "model.json").string())
-        << R"({"type":"machine_model","name":"Acme One","nozzle_diameter":"0.4"})";
-    std::ofstream((machine_dir / "base.json").string())
-        << R"({"type":"machine","name":"fdm_acme_common","from":"system","instantiation":"false",)"
-        << R"("extruder_clearance_dist_to_rod":")" << dist_to_rod << R"("})";
-    std::ofstream((machine_dir / "nested" / "printer.json").string())
-        << R"({"type":"machine","name":"Acme Printer","from":"system","instantiation":"true","inherits":"fdm_acme_common",)"
-        << R"("printer_model":"Acme One","printer_variant":"0.4"})";
-}
-
 std::string read_file(const fs::path &file)
 {
     std::ifstream in(file.string(), std::ios::binary);
@@ -5511,75 +5482,3 @@ TEST_CASE("Config import confines zip entries, preset names and bundle ids to th
         CHECK_FALSE(any_filename_contains(temp_dir.path(), "bundle-escape"));
     }
 }
-
-TEST_CASE("A system preset resolves by name from the bundled profiles", "[Preset][Bundle]")
-{
-    ScopedTemporaryDir temp_dir;
-    ScopedDataDir      data(temp_dir.path() / "data");
-    ScopedResourcesDir resources(temp_dir.path() / "resources");
-    write_acme_printer_vendor(temp_dir.path() / "resources" / "profiles", 33.);
-
-    PresetBundle       bundle;
-    DynamicPrintConfig config;
-    std::string        error;
-    REQUIRE(bundle.resolve_system_preset(config, Preset::TYPE_PRINTER, "Acme Printer",
-                                         ForwardCompatibilitySubstitutionRule::EnableSilent, error));
-    CHECK(error.empty());
-    CHECK_THAT(config.opt_float("extruder_clearance_dist_to_rod"), Catch::Matchers::WithinAbs(33., 1e-6));
-}
-
-TEST_CASE("A system preset resolves from the data directory copy of its vendor", "[Preset][Bundle]")
-{
-    ScopedTemporaryDir temp_dir;
-    ScopedDataDir      data(temp_dir.path() / "data");
-    ScopedResourcesDir resources(temp_dir.path() / "resources");
-    write_acme_printer_vendor(temp_dir.path() / "resources" / "profiles", 33.);
-    write_acme_printer_vendor(temp_dir.path() / "data" / PRESET_SYSTEM_DIR, 35.);
-
-    PresetBundle       bundle;
-    DynamicPrintConfig config;
-    std::string        error;
-    REQUIRE(bundle.resolve_system_preset(config, Preset::TYPE_PRINTER, "Acme Printer",
-                                         ForwardCompatibilitySubstitutionRule::EnableSilent, error));
-    CHECK_THAT(config.opt_float("extruder_clearance_dist_to_rod"), Catch::Matchers::WithinAbs(35., 1e-6));
-}
-
-TEST_CASE("A system preset resolves from a vendor shipped as its preset cache alone", "[Preset][Bundle]")
-{
-    ScopedTemporaryDir temp_dir;
-    ScopedDataDir      data(temp_dir.path() / "data");
-    ScopedResourcesDir resources(temp_dir.path() / "resources");
-    const fs::path     profiles = temp_dir.path() / "resources" / "profiles";
-    write_acme_printer_vendor(profiles, 33.);
-
-    PresetBundle writer;
-    writer.set_generate_vendor_caches(true);
-    writer.load_vendor_configs_from_json(profiles.string(), "Acme", PresetBundle::LoadSystem,
-                                         ForwardCompatibilitySubstitutionRule::EnableSilent);
-    REQUIRE(fs::exists(profiles / "Acme.opc"));
-    // Release builds ship the cache and drop the profile JSONs, manifest included.
-    fs::remove(profiles / "Acme.json");
-    fs::remove_all(profiles / "Acme");
-
-    PresetBundle       bundle;
-    DynamicPrintConfig config;
-    std::string        error;
-    REQUIRE(bundle.resolve_system_preset(config, Preset::TYPE_PRINTER, "Acme Printer",
-                                         ForwardCompatibilitySubstitutionRule::EnableSilent, error));
-    CHECK_THAT(config.opt_float("extruder_clearance_dist_to_rod"), Catch::Matchers::WithinAbs(33., 1e-6));
-}
-
-TEST_CASE("A system preset no vendor lists is not resolved", "[Preset][Bundle]")
-{
-    ScopedTemporaryDir temp_dir;
-    ScopedDataDir      data(temp_dir.path() / "data");
-    ScopedResourcesDir resources(temp_dir.path() / "resources");
-    write_acme_printer_vendor(temp_dir.path() / "resources" / "profiles", 33.);
-
-    PresetBundle       bundle;
-    DynamicPrintConfig config;
-    std::string        error;
-    CHECK_FALSE(bundle.resolve_system_preset(config, Preset::TYPE_PRINTER, "Unknown Printer",
-                                             ForwardCompatibilitySubstitutionRule::EnableSilent, error));
-    CHECK_FALSE(error.empty());
-}

tests/slic3rutils/CMakeLists.txt

@@ -25,6 +25,7 @@ add_executable(${_TEST_NAME}_tests
     test_plugin_cloud_metadata.cpp
     test_plugin_audit.cpp
     test_shortcuts.cpp
+    test_user_manager.cpp
     ../fff_print/test_helpers.cpp
     )
 

tests/slic3rutils/test_printhost.cpp

@@ -1,8 +1,12 @@
 #include <catch2/catch_all.hpp>
 
+#include <string>
+#include <vector>
+
 #include <nlohmann/json.hpp>
 
 #include "slic3r/Utils/PrintHost.hpp"
+#include "slic3r/Utils/Flashforge.hpp"
 
 using namespace Slic3r;
 
@@ -46,6 +50,14 @@ std::string moonraker_error(int code, const std::string& message, const std::str
 constexpr const char* k_busy_file_403 =
     R"JSON({"error": {"code": 403, "message": "Forbidden", "traceback": "Traceback (most recent call last):\n\n  File \"/home/lava/moonraker/moonraker/components/file_manager/file_manager.py\", line 1017, in _finish_gcode_upload\n    can_start = self._handle_operation_check(check_path)\n                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nmoonraker.utils.exceptions.ServerError: File currently in use\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n\n  File \"/home/lava/moonraker/moonraker/components/application.py\", line 1069, in post\n    raise tornado.web.HTTPError(\ntornado.web.HTTPError: HTTP 403: Forbidden (File is loaded, upload not permitted)\n"}})JSON";
 
+// Replies a print host can send instead of JSON: a proxy or login page, nothing, a cut-off body.
+const std::vector<std::string> non_json_replies = {
+    "<html><body>proxy login required</body></html>",
+    "",
+    "{\"err\":",
+    "{\"detail\":{\"matlStationInfo\":{\"slotInfos\":[{\"slotId\":1,",
+};
+
 } // namespace
 
 TEST_CASE("A Klipper upload error shows its reason instead of a Python traceback", "[PrintHost][Regression]")
@@ -211,3 +223,94 @@ TEST_CASE("Error bodies that are not a Moonraker envelope are left unchanged", "
         CHECK(format_error("", "curl:Could not connect", 0) == "curl:Could not connect");
     }
 }
+
+TEST_CASE("Print host error code is read from a JSON reply", "[PrintHost]")
+{
+    CHECK(PrintHost::get_err_code_from_body(R"({"err":0})") == 0);
+    CHECK(PrintHost::get_err_code_from_body(R"({"err":2})") == 2);
+    CHECK(PrintHost::get_err_code_from_body(R"({"status":"ok"})") == 0);
+}
+
+TEST_CASE("Print host error code reports a reply that is not JSON as an error", "[PrintHost]")
+{
+    const std::string body = GENERATE(from_range(non_json_replies));
+    int err = 0;
+    REQUIRE_NOTHROW(err = PrintHost::get_err_code_from_body(body));
+    CHECK(err != 0);
+}
+
+TEST_CASE("Print host error code tolerates a wrongly typed err field", "[PrintHost]")
+{
+    const std::string body = GENERATE(as<std::string>{}, R"({"err":"busy"})", R"({"err":{"code":1}})", R"([1,2])");
+    CHECK_NOTHROW(PrintHost::get_err_code_from_body(body));
+}
+
+TEST_CASE("Flashforge material slots are read from a well-formed reply", "[PrintHost][Flashforge]")
+{
+    const std::string body = R"({"code":0,"detail":{"hasMatlStation":true,"matlStationInfo":{"slotCnt":2,"slotInfos":[
+        {"slotId":1,"hasFilament":true,"materialName":"PLA","materialColor":"#FFFFFF"},
+        {"slotId":2,"hasFilament":false,"materialName":"","materialColor":""}]}}})";
+
+    std::vector<FlashforgeMaterialSlot> slots;
+    bool supports_station = false;
+    REQUIRE(Flashforge::parse_material_slots(body, slots, &supports_station));
+    CHECK(supports_station);
+    REQUIRE(slots.size() == 2);
+    CHECK(slots[0].slot_id == 1);
+    CHECK(slots[0].has_filament);
+    CHECK(slots[0].material_name == "PLA");
+    CHECK(slots[0].material_color == "#FFFFFF");
+    CHECK(slots[1].slot_id == 2);
+    CHECK_FALSE(slots[1].has_filament);
+}
+
+TEST_CASE("Flashforge material slots accept numbers as strings and flags as numbers", "[PrintHost][Flashforge]")
+{
+    const std::string body = R"({"detail":{"matlStationInfo":{"slotInfos":[
+        {"slotId":"3","hasFilament":1,"materialName":null,"materialColor":7}]}}})";
+
+    std::vector<FlashforgeMaterialSlot> slots;
+    REQUIRE_NOTHROW(Flashforge::parse_material_slots(body, slots, nullptr));
+    REQUIRE(slots.size() == 1);
+    CHECK(slots[0].slot_id == 3);
+    CHECK(slots[0].has_filament);
+    CHECK(slots[0].material_name.empty());
+    CHECK(slots[0].material_color.empty());
+}
+
+TEST_CASE("Flashforge material slots skip entries that are not objects", "[PrintHost][Flashforge]")
+{
+    const std::string body = R"({"detail":{"matlStationInfo":{"slotInfos":[5,"slot",null,[],
+        {"slotId":4,"hasFilament":true,"materialName":"PETG"}]}}})";
+
+    std::vector<FlashforgeMaterialSlot> slots;
+    REQUIRE_NOTHROW(Flashforge::parse_material_slots(body, slots, nullptr));
+    REQUIRE(slots.size() == 1);
+    CHECK(slots[0].slot_id == 4);
+    CHECK(slots[0].material_name == "PETG");
+}
+
+TEST_CASE("Flashforge material slots tolerate slot info that is not a list", "[PrintHost][Flashforge]")
+{
+    const std::string body = GENERATE(as<std::string>{},
+                                      R"({"detail":{"matlStationInfo":{"slotInfos":5}}})",
+                                      R"({"detail":{"matlStationInfo":{"slotInfos":"none"}}})",
+                                      R"({"detail":{"matlStationInfo":7}})",
+                                      R"({"detail":"offline"})");
+
+    std::vector<FlashforgeMaterialSlot> slots;
+    bool ok = false;
+    REQUIRE_NOTHROW(ok = Flashforge::parse_material_slots(body, slots, nullptr));
+    CHECK(ok);
+    CHECK(slots.empty());
+}
+
+TEST_CASE("Flashforge material slots reject a reply that is not JSON", "[PrintHost][Flashforge]")
+{
+    const std::string body = GENERATE(from_range(non_json_replies));
+    std::vector<FlashforgeMaterialSlot> slots;
+    bool ok = true;
+    REQUIRE_NOTHROW(ok = Flashforge::parse_material_slots(body, slots, nullptr));
+    CHECK_FALSE(ok);
+    CHECK(slots.empty());
+}

tests/slic3rutils/test_user_manager.cpp

@@ -0,0 +1,23 @@
+#include <catch2/catch_all.hpp>
+
+#include <string>
+
+#include "slic3r/GUI/UserManager.hpp"
+
+using namespace Slic3r;
+
+TEST_CASE("User message that is not JSON is rejected without throwing", "[UserManager]")
+{
+    const std::string payload = GENERATE(as<std::string>{}, "not json", "", "<html></html>", "{\"bind\":");
+    UserManager manager;
+    int result = 0;
+    REQUIRE_NOTHROW(result = manager.parse_json(payload));
+    CHECK(result == -1);
+}
+
+TEST_CASE("User message without a successful bind is ignored", "[UserManager]")
+{
+    const std::string payload = GENERATE(as<std::string>{}, "{}", R"({"bind":{"command":"unbind"}})", R"({"bind":"bind"})", "[1]");
+    UserManager manager;
+    CHECK(manager.parse_json(payload) == -1);
+}