From b91f48141d65d2ad50fd6343a775b4ae86f9cb99 Mon Sep 17 00:00:00 2001 From: peachismomo Date: Fri, 18 Sep 2026 22:31:25 +0800 Subject: [PATCH] fix: load windows roots for cloud MQTT and camera signaling --- src/slic3r/CMakeLists.txt | 2 +- src/slic3r/Utils/Http.cpp | 52 +++++- src/slic3r/Utils/Http.hpp | 6 + .../Utils/OrcaCloudSignalingChannel.cpp | 14 +- src/slic3r/Utils/OrcaMqttConnection.cpp | 149 +----------------- src/slic3r/Utils/OrcaMqttConnection.hpp | 1 - 6 files changed, 66 insertions(+), 158 deletions(-) diff --git a/src/slic3r/CMakeLists.txt b/src/slic3r/CMakeLists.txt index ac7974e7c2..7c865e089d 100644 --- a/src/slic3r/CMakeLists.txt +++ b/src/slic3r/CMakeLists.txt @@ -856,7 +856,7 @@ target_include_directories(libslic3r_gui PRIVATE Utils ${CMAKE_CURRENT_BINARY_DI if (WIN32) target_include_directories(libslic3r_gui SYSTEM PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../deps/WebView2/include) - target_link_libraries(libslic3r_gui Advapi32) + target_link_libraries(libslic3r_gui Advapi32 Crypt32) endif() source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SLIC3R_GUI_SOURCES}) diff --git a/src/slic3r/Utils/Http.cpp b/src/slic3r/Utils/Http.cpp index 6f43df74e4..86c2d681bc 100644 --- a/src/slic3r/Utils/Http.cpp +++ b/src/slic3r/Utils/Http.cpp @@ -14,8 +14,19 @@ #include -#ifdef OPENSSL_CERT_OVERRIDE +#include +#include #include +#include + +#ifdef _WIN32 +# ifndef NOMINMAX +# define NOMINMAX +# endif +# include +# include +// wincrypt.h uses this token for a certificate-name property identifier. +# undef X509_NAME #endif namespace fs = boost::filesystem; @@ -939,6 +950,45 @@ std::string Http::tls_system_cert_store() return ret; } +void Http::add_platform_root_certificates(SSL_CTX* ssl_context) +{ +#ifdef _WIN32 + X509_STORE* openssl_store = SSL_CTX_get_cert_store(ssl_context); + if (!openssl_store) + throw std::runtime_error("unable to get OpenSSL certificate store"); + + const auto load_store = [&](DWORD location) { + HCERTSTORE windows_store = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0, + location | CERT_STORE_OPEN_EXISTING_FLAG | CERT_STORE_READONLY_FLAG, + L"ROOT"); + if (!windows_store) + return; + + PCCERT_CONTEXT windows_certificate = nullptr; + while ((windows_certificate = CertEnumCertificatesInStore(windows_store, windows_certificate)) != nullptr) { + const unsigned char* encoded = windows_certificate->pbCertEncoded; + X509* certificate = d2i_X509(nullptr, &encoded, static_cast(windows_certificate->cbCertEncoded)); + if (!certificate) { + ERR_clear_error(); + continue; + } + + ERR_clear_error(); + if (X509_STORE_add_cert(openssl_store, certificate) != 1) + ERR_clear_error(); + X509_free(certificate); + } + + CertCloseStore(windows_store, 0); + }; + + load_store(CERT_SYSTEM_STORE_CURRENT_USER); + load_store(CERT_SYSTEM_STORE_LOCAL_MACHINE); +#else + (void)ssl_context; +#endif +} + std::string Http::url_encode(const std::string &str) { ::CURL *curl = ::curl_easy_init(); diff --git a/src/slic3r/Utils/Http.hpp b/src/slic3r/Utils/Http.hpp index a44a95e605..87dd57d8cb 100644 --- a/src/slic3r/Utils/Http.hpp +++ b/src/slic3r/Utils/Http.hpp @@ -11,6 +11,8 @@ #include "libslic3r/Exception.hpp" #include "libslic3r_version.h" +typedef struct ssl_ctx_st SSL_CTX; + #define MAX_SIZE_TO_FILE 3*1024 namespace Slic3r { @@ -198,6 +200,10 @@ public: // Return empty string on success or error message on fail. static std::string tls_global_init(); static std::string tls_system_cert_store(); + // Add platform root certificates to a standalone OpenSSL context. This + // supplements set_default_verify_paths() on platforms where OpenSSL does + // not use the native certificate store. + static void add_platform_root_certificates(SSL_CTX* ssl_context); // converts the given string to an url_encoded_string static std::string url_encode(const std::string &str); diff --git a/src/slic3r/Utils/OrcaCloudSignalingChannel.cpp b/src/slic3r/Utils/OrcaCloudSignalingChannel.cpp index 9c3a029db3..e5b253feba 100644 --- a/src/slic3r/Utils/OrcaCloudSignalingChannel.cpp +++ b/src/slic3r/Utils/OrcaCloudSignalingChannel.cpp @@ -130,7 +130,6 @@ void OrcaCloudSignalingChannel::run() nlohmann::json token_response; std::string token_body; - std::string token_error; unsigned int http_code = 0; auto request = Http::post(live_token_url); request.set_post_body(std::string("{}")) @@ -142,19 +141,13 @@ void OrcaCloudSignalingChannel::run() http_code = status; token_body = std::move(body); }) - .on_error([&token_body, &token_error, &http_code](std::string body, std::string error, unsigned status) { + .on_error([&http_code](std::string, std::string, unsigned status) { http_code = status; - token_body = std::move(body); - token_error = std::move(error); }) .perform_sync(); - BOOST_LOG_TRIVIAL(info) << "signaling: live-token HTTP " << http_code - << (token_error.empty() ? "" : " error=" + token_error) - << " body=" << token_body.substr(0, 512); try { token_response = nlohmann::json::parse(token_body); - } catch (const std::exception& e) { - BOOST_LOG_TRIVIAL(warning) << "signaling: live-token body is not JSON: " << e.what(); + } catch (const std::exception&) { } if (http_code < 200 || http_code >= 300 || !token_response.contains("token")) { unavailable(CameraUnavailableReason::Error, "Unable to mint camera live token"); @@ -189,9 +182,9 @@ void OrcaCloudSignalingChannel::run() } } } - auto conn = std::make_shared(); conn->ssl_context.set_default_verify_paths(); + Http::add_platform_root_certificates(conn->ssl_context.native_handle()); { std::lock_guard lock(m_mutex); m_conn = conn; @@ -203,6 +196,7 @@ void OrcaCloudSignalingChannel::run() if (!SSL_set_tlsext_host_name(websocket.next_layer().native_handle(), host.c_str())) throw std::runtime_error("Unable to configure TLS server name"); websocket.next_layer().set_verify_mode(boost::asio::ssl::verify_peer); + websocket.next_layer().set_verify_callback(boost::asio::ssl::host_name_verification(host)); websocket.next_layer().handshake(boost::asio::ssl::stream_base::client); const std::string ws_target = "/api/v1/printers/" + encode_path_component(m_dev_id) + "/camera/live?token=" + diff --git a/src/slic3r/Utils/OrcaMqttConnection.cpp b/src/slic3r/Utils/OrcaMqttConnection.cpp index 2173231310..ef1044e468 100644 --- a/src/slic3r/Utils/OrcaMqttConnection.cpp +++ b/src/slic3r/Utils/OrcaMqttConnection.cpp @@ -1,11 +1,11 @@ #include "OrcaMqttConnection.hpp" +#include "Http.hpp" #include #include #include #include #include -#include #include @@ -52,15 +52,6 @@ OrcaMqttConnection::~OrcaMqttConnection() { stop(); } bool OrcaMqttConnection::start(const Config& config, MessageHandler on_message, StateHandler on_state) { std::lock_guard lifecycle_lock(lifecycle_mutex); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT start url=" << config.url - << " use_tls=" << config.use_tls - << " bearer_provider=" << (config.bearer_provider ? "set" : "null") - << " username_present=" << (!config.username.empty()) - << " password_present=" << (!config.password.empty()) - << " client_id=" << config.client_id - << " keepalive_seconds=" << config.keepalive_seconds - << " message_callback=" << (on_message ? "set" : "null") - << " state_callback=" << (on_state ? "set" : "null"); stop(); { std::lock_guard lock(mutex); @@ -79,26 +70,12 @@ bool OrcaMqttConnection::start(const Config& config, MessageHandler on_message, if (!initial_cv.wait_for(lock, std::chrono::seconds(10), [this] { return initial_completed; })) { initial_completed = true; initial_result = false; - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT initial connection timed out after 10 seconds" - << " url=" << current_config.url - << " last_connack_rc=" << m_last_connack_rc.load() - << " connected=" << connected.load() - << "; worker will retry"; } - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT start initial_result=" << initial_result - << " initial_completed=" << initial_completed - << " last_connack_rc=" << m_last_connack_rc.load() - << " worker_running=" << (worker.joinable() && !stopping.load()); return initial_result; } void OrcaMqttConnection::stop() { std::lock_guard lifecycle_lock(lifecycle_mutex); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT stop requested" - << " url=" << current_config.url - << " connected=" << connected.load() - << " worker_joinable=" << worker.joinable() - << " last_connack_rc=" << m_last_connack_rc.load(); stopping.store(true); state_cv.notify_all(); { @@ -158,35 +135,26 @@ void OrcaMqttConnection::flush_subscription_change() { // websocket.read(); every write is serialised by write_mutex inside ws_write(). try { send_pending_subscriptions(*conn); - } catch (const std::exception& e) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: direct subscription write failed (" << e.what() - << "); worker will resend the full set on reconnect"; + } catch (const std::exception&) { } } bool OrcaMqttConnection::subscribe(const std::string& dev_id) { if (dev_id.empty()) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT subscribe rejected empty dev_id"; return false; } const std::string topic = report_topic(dev_id); if (topic.size() > 96) { // MQTT topic filter cap enforced by the service - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT subscribe rejected oversized topic=" << topic; return false; } { std::lock_guard lock(mutex); if (subscriptions.count(topic) != 0 && pending_unsubscriptions.count(topic) == 0) { - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT subscribe already queued or active topic=" << topic - << " acknowledged=" << (acknowledged_subscriptions.count(topic) != 0); return true; } subscriptions.insert(topic); pending_unsubscriptions.erase(topic); pending_subscriptions.insert(topic); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT subscribe queued topic=" << topic - << " total_subscriptions=" << subscriptions.size() - << " connected=" << connected.load(); } state_cv.notify_all(); flush_subscription_change(); // emit SUBSCRIBE now on the live socket (no reconnect) @@ -213,9 +181,6 @@ bool OrcaMqttConnection::unsubscribe(const std::string& dev_id) { else ++it; } - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT unsubscribe queued topic=" << topic - << " total_subscriptions=" << subscriptions.size() - << " connected=" << connected.load(); } state_cv.notify_all(); flush_subscription_change(); // emit UNSUBSCRIBE now on the live socket (no reconnect) @@ -224,7 +189,6 @@ bool OrcaMqttConnection::unsubscribe(const std::string& dev_id) { void OrcaMqttConnection::clear_subscriptions() { std::lock_guard lock(mutex); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT clear subscriptions count=" << subscriptions.size(); subscriptions.clear(); pending_subscriptions.clear(); pending_unsubscriptions.clear(); @@ -332,16 +296,12 @@ std::vector OrcaMqttConnection::make_ping_packet() { return {0xc0, 0}; void OrcaMqttConnection::ws_write(Connection& conn, const std::vector& packet) { if (packet.empty()) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: attempted to send empty MQTT packet"; return; } // Writes come from the worker thread AND, for dynamic (un)subscribes, the // caller thread. Serialise them; the worker's concurrent read is fine (beast // allows one reader + one writer). std::lock_guard lock(write_mutex); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending MQTT packet type=0x" << std::hex - << static_cast(packet[0] >> 4) << std::dec - << " bytes=" << packet.size(); if (conn.wss) { conn.wss->binary(true); conn.wss->write(boost::asio::buffer(packet)); @@ -367,22 +327,14 @@ void OrcaMqttConnection::ws_close(Connection& conn) { conn.wss->close(boost::beast::websocket::close_code::normal, close_error); else if (conn.ws) conn.ws->close(boost::beast::websocket::close_code::normal, close_error); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT connection closed code=" << close_error.value() - << " message=" << close_error.message(); } void OrcaMqttConnection::ws_handshake(Connection& conn, const Config& config, const Endpoint& endpoint) { - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: WebSocket resolve starting host=" << endpoint.host - << " port=" << endpoint.port << " target=" << endpoint.target - << " tls=" << config.use_tls; const auto results = conn.resolver.resolve(endpoint.host, endpoint.port); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT DNS resolution succeeded host=" << endpoint.host; std::string token; if (config.bearer_provider) { - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: requesting bearer token for WebSocket upgrade"; token = config.bearer_provider(); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: bearer token callback completed token_present=" << !token.empty(); } auto decorator = [token](boost::beast::websocket::request_type& request) { request.set(boost::beast::http::field::user_agent, "OrcaSlicer"); @@ -404,21 +356,17 @@ void OrcaMqttConnection::ws_handshake(Connection& conn, const Config& config, co auto& stream = boost::beast::get_lowest_layer(websocket); stream.expires_after(std::chrono::seconds(10)); stream.connect(results); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT TCP connection established host=" << endpoint.host - << " port=" << endpoint.port; // Set SNI before the TLS handshake so the cloud edge selects the correct // certificate. auto& tls_stream = websocket.next_layer(); if (!SSL_set_tlsext_host_name(tls_stream.native_handle(), endpoint.host.c_str())) throw std::runtime_error("failed to set Orca Cloud TLS server name"); conn.ssl_context.set_default_verify_paths(); + Http::add_platform_root_certificates(conn.ssl_context.native_handle()); tls_stream.set_verify_mode(boost::asio::ssl::verify_peer); tls_stream.set_verify_callback(boost::asio::ssl::host_name_verification(endpoint.host)); tls_stream.handshake(boost::asio::ssl::stream_base::client); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT TLS handshake completed host=" << endpoint.host; websocket.set_option(boost::beast::websocket::stream_base::decorator(decorator)); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending TLS WebSocket upgrade target=" << endpoint.target - << " bearer_header=" << (!token.empty()); websocket.handshake(response, endpoint.host, endpoint.target, handshake_error); } else { { @@ -429,39 +377,23 @@ void OrcaMqttConnection::ws_handshake(Connection& conn, const Config& config, co auto& stream = boost::beast::get_lowest_layer(websocket); stream.expires_after(std::chrono::seconds(10)); stream.connect(results); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT TCP connection established host=" << endpoint.host - << " port=" << endpoint.port << " (plaintext)"; websocket.set_option(boost::beast::websocket::stream_base::decorator(decorator)); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending plaintext WebSocket upgrade target=" << endpoint.target - << " bearer_header=" << (!token.empty()); websocket.handshake(response, endpoint.host, endpoint.target, handshake_error); } if (handshake_error) { - // Surface the server's HTTP status so a persistent rejection (stale token, - // missing api key, wrong route) is diagnosable from the log rather than an - // opaque "handshake declined". - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: WS handshake rejected http=" - << response.result_int() << " (" << response.reason() << "), " - << handshake_error.message(); throw boost::system::system_error(handshake_error, "Orca WebSocket handshake"); } - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: WebSocket handshake completed http=" << response.result_int() - << " negotiated_protocol=" << response["Sec-WebSocket-Protocol"]; if (response["Sec-WebSocket-Protocol"] != "mqtt") { - BOOST_LOG_TRIVIAL(error) << "Orca diagnostic: WebSocket handshake did not negotiate MQTT"; throw std::runtime_error("Orca WebSocket did not negotiate MQTT"); } } bool OrcaMqttConnection::send_request(const std::string& dev_id, const std::string& payload) { if (dev_id.empty()) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT send_request rejected empty dev_id"; return false; } if (!connected.load()) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT send_request rejected because connection is not ready" - << " dev_id=" << dev_id << " last_connack_rc=" << m_last_connack_rc.load(); return false; } std::shared_ptr conn; @@ -470,8 +402,6 @@ bool OrcaMqttConnection::send_request(const std::string& dev_id, const std::stri conn = active_connection; } if (!conn) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT send_request rejected because active connection is null" - << " dev_id=" << dev_id; return false; } const std::string report = report_topic(dev_id); @@ -479,28 +409,19 @@ bool OrcaMqttConnection::send_request(const std::string& dev_id, const std::stri std::lock_guard lock(mutex); if (subscriptions.count(report) != 0 && acknowledged_subscriptions.count(report) == 0) { pending_requests.emplace_back(dev_id, payload); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT request queued until SUBACK" - << " dev_id=" << dev_id << " payload_bytes=" << payload.size() - << " pending_requests=" << pending_requests.size(); return true; } } try { // ws_write() serialises the write via write_mutex; do not lock it here. - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT PUBLISH request dev_id=" << dev_id - << " topic=" << request_topic(dev_id) - << " payload_bytes=" << payload.size(); ws_write(*conn, make_publish_packet(request_topic(dev_id), payload)); - } catch (const std::exception& e) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: send_request failed dev_id=" << dev_id - << " (" << e.what() << ")"; + } catch (const std::exception&) { return false; } return true; } void OrcaMqttConnection::connect_and_read() { - m_connection_stage = "creating connection"; auto connection = std::make_shared(); { std::lock_guard lock(connection_mutex); @@ -509,20 +430,14 @@ void OrcaMqttConnection::connect_and_read() { return; } - m_connection_stage = "parsing endpoint"; Endpoint endpoint; if (!parse_endpoint(current_config.url, endpoint)) { - BOOST_LOG_TRIVIAL(error) << "Orca diagnostic: invalid MQTT endpoint=" << current_config.url; throw std::runtime_error("invalid Orca Cloud WebSocket endpoint"); } - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT connecting host=" << endpoint.host - << " port=" << endpoint.port << " target=" << endpoint.target; - m_connection_stage = "WebSocket handshake"; ws_handshake(*connection, current_config, endpoint); - m_connection_stage = "sending MQTT CONNECT"; expires_never(*connection); // Auth precedence: a bearer_provider authenticates the WebSocket upgrade, so the // CONNECT username/password fields are omitted entirely (the cloud form). @@ -531,9 +446,7 @@ void OrcaMqttConnection::connect_and_read() { use_bearer ? std::string() : current_config.username, use_bearer ? std::string() : current_config.password, current_config.keepalive_seconds)); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT CONNECT packet sent"; - m_connection_stage = "waiting for MQTT CONNACK"; boost::beast::flat_buffer buffer; expires_after(*connection, std::chrono::seconds(10)); boost::system::error_code connack_error; @@ -541,16 +454,12 @@ void OrcaMqttConnection::connect_and_read() { if (connack_error) throw boost::system::system_error(connack_error, "read Orca MQTT CONNACK"); const std::string connack = boost::beast::buffers_to_string(buffer.data()); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT CONNACK received bytes=" << connack.size() - << " header=" << (connack.empty() ? -1 : static_cast(static_cast(connack[0]))) - << " return_code=" << (connack.size() > 3 ? static_cast(static_cast(connack[3])) : -1); // rc: 0 accepted, 1..5 refusal, -1 malformed/not a CONNACK. const int rc = (connack.size() == 4 && static_cast(connack[0]) == 0x20) ? static_cast(static_cast(connack[3])) : -1; m_last_connack_rc.store(rc); if (rc != 0) { - BOOST_LOG_TRIVIAL(error) << "Orca diagnostic: MQTT CONNECT refused rc=" << rc; if (rc == 4 || rc == 5) { // Bad credentials / not authorized — retrying cannot help. Make run()'s // loop exit and unblock any waiting start(). @@ -565,7 +474,6 @@ void OrcaMqttConnection::connect_and_read() { throw std::runtime_error("Orca MQTT CONNECT refused rc=" + std::to_string(rc)); } - m_connection_stage = "reading MQTT messages"; // The subscription acknowledgement belongs to this MQTT session. Clear // the previous session's state before notifying the owner, because the // reconnect callback immediately queues the printer's initial requests. @@ -576,7 +484,6 @@ void OrcaMqttConnection::connect_and_read() { } notify_state(true); reconnect_delay_seconds.store(1); // a fresh CONNACK resets the backoff - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT connection is ready; sending current subscriptions"; send_current_subscriptions(*connection); std::chrono::steady_clock::time_point next_ping = std::chrono::steady_clock::now() + std::chrono::seconds(30); @@ -587,19 +494,15 @@ void OrcaMqttConnection::connect_and_read() { // read hot and the broker would drop us at 1.5 x keepalive. if (std::chrono::steady_clock::now() >= next_ping) { ws_write(*connection, make_ping_packet()); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT PINGREQ sent"; next_ping = std::chrono::steady_clock::now() + std::chrono::seconds(30); } buffer.consume(buffer.size()); - m_connection_stage = "reading MQTT frame"; expires_after(*connection, std::chrono::seconds(1)); boost::system::error_code error; ws_read(*connection, buffer, error); if (error == boost::beast::error::timeout) continue; if (error) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT WebSocket read failed code=" << error.value() - << " message=" << error.message(); throw boost::system::system_error(error, "read Orca MQTT message"); } handle_packet(boost::beast::buffers_to_string(buffer.data())); @@ -620,14 +523,12 @@ void OrcaMqttConnection::send_current_subscriptions(Connection& conn) { for (const std::string& topic : topics) pending_subscriptions.erase(topic); } - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending current MQTT subscriptions count=" << topics.size(); for (const std::string& topic : topics) { const uint16_t packet_id = next_packet_id++; { std::lock_guard lock(mutex); pending_subscribe_packets[packet_id] = topic; } - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending SUBSCRIBE topic=" << topic << " packet_id=" << packet_id; ws_write(conn, make_subscribe_packet(packet_id, topic, 1)); } } @@ -648,28 +549,20 @@ void OrcaMqttConnection::send_pending_subscriptions(Connection& conn) { std::lock_guard lock(mutex); pending_subscribe_packets[packet_id] = topic; } - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending pending SUBSCRIBE topic=" << topic - << " packet_id=" << packet_id; ws_write(conn, make_subscribe_packet(packet_id, topic, 1)); } for (const std::string& topic : unsubscribe_topics) { const uint16_t packet_id = next_packet_id++; - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending pending UNSUBSCRIBE topic=" << topic - << " packet_id=" << packet_id; ws_write(conn, make_unsubscribe_packet(packet_id, topic)); } } void OrcaMqttConnection::handle_packet(const std::string& packet) { if (packet.size() < 2) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: received undersized MQTT packet bytes=" << packet.size(); return; } const uint8_t header = static_cast(packet[0]); const uint8_t packet_type = header >> 4; - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: received MQTT packet type=" << static_cast(packet_type) - << " header=0x" << std::hex << static_cast(header) << std::dec - << " bytes=" << packet.size(); if (packet_type != 3) { // Only QoS 0 PUBLISH carries printer status. if (packet_type == 9 && packet.size() >= 5) { const uint16_t packet_id = (static_cast(static_cast(packet[2])) << 8) | @@ -680,9 +573,6 @@ void OrcaMqttConnection::handle_packet(const std::string& packet) { result_codes << ','; result_codes << "0x" << std::hex << static_cast(static_cast(packet[index])); } - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: received SUBACK packet_id=" - << packet_id - << " result_codes=" << result_codes.str(); // Each production SUBSCRIBE packet currently contains one topic. // MQTT grants QoS 0 or 1 for a requested QoS 1 subscription; 0x80 @@ -710,21 +600,12 @@ void OrcaMqttConnection::handle_packet(const std::string& packet) { } } if (topic.empty()) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: SUBACK has no pending topic packet_id=" << packet_id; } else if (result == 0 || result == 1) { - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: report subscription active topic=" << topic - << " granted_qos=" << static_cast(result) - << " releasing_requests=" << requests.size(); for (const auto& request : requests) { if (!send_request(request.first, request.second)) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: queued MQTT request could not be sent" - << " after SUBACK dev_id=" << request.first; } } } else { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: report subscription rejected topic=" << topic - << " result_code=0x" << std::hex << static_cast(result) << std::dec - << " dropped_requests=" << requests.size(); } } return; @@ -735,7 +616,6 @@ void OrcaMqttConnection::handle_packet(const std::string& packet) { uint8_t encoded = 0; do { if (index >= packet.size() || multiplier > 128 * 128 * 128) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: malformed MQTT PUBLISH remaining length"; return; } encoded = static_cast(packet[index++]); @@ -744,30 +624,23 @@ void OrcaMqttConnection::handle_packet(const std::string& packet) { } while ((encoded & 0x80) != 0); const size_t remaining_end = index + remaining; if (remaining_end > packet.size() || remaining < 2 || index + 2 > remaining_end) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: malformed MQTT PUBLISH body remaining=" << remaining - << " packet_bytes=" << packet.size(); return; } const uint16_t topic_length = (static_cast(packet[index]) << 8) | static_cast(packet[index + 1]); index += 2; if (topic_length > packet.size() - index) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: malformed MQTT PUBLISH topic length=" << topic_length; return; } const std::string topic(packet.data() + index, topic_length); index += topic_length; if (((header >> 1) & 0x03) != 0) { if (index + 2 > remaining_end) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: malformed MQTT PUBLISH packet identifier"; return; } index += 2; // QoS 1/2 packet identifier; the service currently sends QoS 0. } const size_t payload_size = remaining_end - index; - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: received PUBLISH topic=" << topic - << " payload_bytes=" << payload_size - << " message_callback=" << (on_message ? "set" : "null"); // topic is "device//report" (or "/request"); hand the id up, drop anything else. std::string dev_id; if (topic.rfind("device/", 0) == 0) { @@ -777,11 +650,9 @@ void OrcaMqttConnection::handle_packet(const std::string& packet) { dev_id = topic.substr(id_start, id_end - id_start); } if (dev_id.empty()) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: dropping PUBLISH on unrecognized topic=" << topic; } else if (on_message) { on_message(dev_id, packet.substr(index, remaining_end - index)); } else { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: dropping PUBLISH because message callback is not set"; } } @@ -798,8 +669,6 @@ void OrcaMqttConnection::notify_state(bool is_now_connected) { } callback = on_state; } - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT state changed connected=" << is_now_connected - << " initial=" << initial << " state_callback=" << (callback ? "set" : "null"); if (initial) initial_cv.notify_all(); else if (callback) @@ -810,18 +679,9 @@ void OrcaMqttConnection::run() { while (!stopping.load()) { const int retry_seconds = reconnect_delay_seconds.load(); const uint64_t attempt = ++m_attempt_number; - m_connection_stage = "starting attempt"; try { - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT connection attempt=" << attempt - << " retry_delay=" << retry_seconds - << " url=" << current_config.url; connect_and_read(); } catch (const std::exception& error) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT connection attempt=" << attempt - << " failed stage=" << m_connection_stage - << " error=" << error.what() - << " last_connack_rc=" << m_last_connack_rc.load() - << " stopping=" << stopping.load(); if (!stopping.load()) notify_state(false); } @@ -831,7 +691,6 @@ void OrcaMqttConnection::run() { // successful connection resets reconnect_delay_seconds to 1 (connect_and_read). reconnect_delay_seconds.store(std::min(retry_seconds * 2, 30)); std::unique_lock lock(mutex); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT waiting before reconnect seconds=" << retry_seconds; state_cv.wait_for(lock, std::chrono::seconds(retry_seconds), [this] { return stopping.load(); }); } } diff --git a/src/slic3r/Utils/OrcaMqttConnection.hpp b/src/slic3r/Utils/OrcaMqttConnection.hpp index e103e90167..8639dab0e3 100644 --- a/src/slic3r/Utils/OrcaMqttConnection.hpp +++ b/src/slic3r/Utils/OrcaMqttConnection.hpp @@ -141,7 +141,6 @@ private: std::atomic next_packet_id{1}; std::atomic m_last_connack_rc{-1}; uint64_t m_attempt_number{0}; // worker-thread diagnostic sequence - std::string m_connection_stage; // worker-thread diagnostic stage bool initial_result{false}; bool initial_completed{false}; std::atomic_bool connected{false};