diff --git a/deps/FFMPEG/FFMPEG.cmake b/deps/FFMPEG/FFMPEG.cmake index 3c582f0682..2b148ae3f7 100644 --- a/deps/FFMPEG/FFMPEG.cmake +++ b/deps/FFMPEG/FFMPEG.cmake @@ -69,14 +69,14 @@ else () --disable-filters --enable-filter=*null*,afade,*fifo,*format,*resample,aeval,allrgb,allyuv,atempo,pan,*bars,color,*key,crop,draw*,eq*,framerate,*_qsv,*_vaapi,*v4l2*,hw*,scale,volume,test* --disable-protocols - --enable-protocol=file,fd,pipe,rtp,tcp,udp + --enable-protocol=file,fd,pipe,http,rtp,tcp,udp --disable-muxers --enable-muxer=rtp --disable-encoders --disable-decoders --enable-decoder=*aac*,h264*,mp3*,mjpeg,rv* --disable-demuxers - --enable-demuxer=h264,mp3,mov,rtsp,sdp + --enable-demuxer=h264,mp3,mov,mpjpeg,rtsp,sdp --disable-zlib --disable-avdevice BUILD_IN_SOURCE ON diff --git a/docs/superpowers/plans/2026-09-03-orca-mqtt-contract-consolidation.md b/docs/superpowers/plans/2026-09-03-orca-mqtt-contract-consolidation.md new file mode 100644 index 0000000000..fbcf8f9bc3 --- /dev/null +++ b/docs/superpowers/plans/2026-09-03-orca-mqtt-contract-consolidation.md @@ -0,0 +1,1194 @@ +# OrcaSlicer MQTT Contract Consolidation — Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Make `OrcaPrinterAgent` talk to OrcaCloud and OrcaSonar through one `OrcaMqttConnection` class where LAN and cloud differ only by a `Config` value — commands published to `device//request`, status subscribed on `device//report`, on both transports. + +**Architecture:** One `OrcaMqttConnection` (MQTT 3.1.1 codec + WebSocket transport, `ws://` and `wss://`) in its own translation unit. Two instances: a LAN one owned by `OrcaPrinterAgent`, a per-printer cloud one owned by `OrcaCloudServiceAgent` and driven by `OrcaPrinterAgent` via `get_mqtt_connection()`. `OrcaPrinterAgent` is routing + lifecycle only; `get_appropriate_mqtt_connection(is_lan)` picks the instance and `send_request()` is the uniform outbound seam. Inbound is a per-connection `MessageHandler` callback funnelled to `on_message_fn` (no reader loop). Exactly one socket is connected at a time, for the selected printer. + +**Tech Stack:** C++17, Boost.Beast (WebSocket + TLS), Boost.Asio, nlohmann/json, Catch2 (`tests/slic3rutils`, target `slic3rutils_tests`, discovered via `orcaslicer_discover_tests`). + +**Spec:** `docs/superpowers/specs/2026-09-03-orca-mqtt-contract-consolidation-design.md` — read it alongside this plan. + +## Global Constraints + +- **No git commits.** Per this repo's workflow, all changes stay unstaged; there is no per-task commit. Each task ends at "tests green" (see Workflow note). +- **Build once at the end.** Per-task verification builds and runs only the `slic3rutils_tests` target (`cmake --build build --target slic3rutils_tests`). The full `cmake --build build` runs only in the final task. +- **No back-compat.** OPCP v1.2.0 replaces v1.1.0. No REST `/commands` fallback in the client, no `/tunnel`, no dual-schema handling. +- **`sequence_id` band:** every `sequence_id` the client emits MUST be a decimal string in `20000`–`29999`. +- **Cross-platform:** Windows, macOS, Linux. No POSIX-only calls; use Boost/std. +- **Threading:** every `websocket::stream` write goes through `write_mutex`. Handlers run on the connection's worker thread and must marshal to the UI thread via `queue_on_main_fn` before touching wx. +- **Topic id:** the id in `device//...` is the id the client already holds (LAN: the mDNS-advertised `device_id` passed as `dev_id`; cloud: the cloud printer UUID). No wildcard subscribe, no learning the id from traffic. + +## Workflow note (per-task loop, adapted for no-commits) + +Each task's last step is **"Verify green"**, not "Commit": + +```bash +cmake --build build --target slic3rutils_tests -j +ctest --test-dir build -R 'OrcaMqtt|OrcaPrinterAgent' --output-on-failure +``` + +Leave changes unstaged. Move to the next task. + +--- + +## File Structure + +**New:** + +| File | Responsibility | +|---|---| +| `src/slic3r/Utils/OrcaMqttConnection.hpp` | `OrcaMqttConnection` class: `Config`, lifecycle (`start`/`stop`), `send_request`, `subscribe`/`unsubscribe`, state accessors, and the pure static codec helpers (`parse_endpoint`, `make_*_packet`) — public so tests reach them. | +| `src/slic3r/Utils/OrcaMqttConnection.cpp` | Its implementation (moved verbatim from `OrcaCloudServiceAgent.cpp`, then extended). | +| `tests/slic3rutils/test_orca_mqtt_connection.cpp` | Unit tests: codec byte-shapes, `parse_endpoint`, `Config`→handshake selection, `send_request`/`subscribe` topic strings. | +| `tests/slic3rutils/orca_mqtt_mock_broker.hpp` | Header-only in-process MQTT-over-WS mock (Beast server on `127.0.0.1:0`, plaintext): answers CONNECT→CONNACK, SUBSCRIBE→SUBACK, PUBLISH→PUBACK, and can push a canned message on a subscribed topic. Test-only. | +| `tests/slic3rutils/test_orca_printer_agent.cpp` | `OrcaPrinterAgent` routing + lifecycle tests + the parametrized LAN/cloud integration test. Seeded from `salvage/orcasonar-lan-agent-2026-09-03:tests/slic3rutils/test_orca_printer_agent.cpp` then rewritten for this design. | + +**Modified:** + +| File | Change | +|---|---| +| `src/slic3r/Utils/OrcaCloudServiceAgent.hpp` | Replace the inline `OrcaMqttConnection` class with `#include "OrcaMqttConnection.hpp"`. Keep `get_mqtt_connection()`. Add `configure_selected_printer_mqtt(std::string dev_id)` / `teardown_selected_printer_mqtt()` decls. | +| `src/slic3r/Utils/OrcaCloudServiceAgent.cpp` | Move the `OrcaMqttConnection` impl out. `connect_server()` stops starting the aggregate socket. Implement `configure_selected_printer_mqtt` / `teardown_selected_printer_mqtt`. `is_server_connected()` from the REST health result only. | +| `src/slic3r/Utils/OrcaPrinterAgent.hpp` | Remove `read_loop` / `m_read_loop_thread` / `m_should_end`. Add `std::atomic m_lan_generation`, `std::string m_lan_dev_id`, `void on_connected(const std::string& dev_id, OrcaMqttConnection* conn, uint64_t generation)`, and the `sequence_id`-stamped payload builders. | +| `src/slic3r/Utils/OrcaPrinterAgent.cpp` | Implement `connect_printer`, `disconnect_printer`, `set_user_selected_machine`, the `send_message*` collapse, per-connection `MessageHandler` wiring, generation guard, destructor teardown. Remove `read_loop`. | +| `src/slic3r/CMakeLists.txt` | Add `Utils/OrcaMqttConnection.cpp` + `.hpp` to `SLIC3R_GUI_SOURCES`. | +| `tests/slic3rutils/CMakeLists.txt` | Add `test_orca_mqtt_connection.cpp` and `test_orca_printer_agent.cpp` to `slic3rutils_tests`. | + +--- + +## Task 1: Extract `OrcaMqttConnection` to its own translation unit + +Pure move, no behaviour change. Makes every later diff legible. + +**Files:** +- Create: `src/slic3r/Utils/OrcaMqttConnection.hpp`, `src/slic3r/Utils/OrcaMqttConnection.cpp` +- Modify: `src/slic3r/Utils/OrcaCloudServiceAgent.hpp`, `src/slic3r/Utils/OrcaCloudServiceAgent.cpp`, `src/slic3r/CMakeLists.txt` + +**Interfaces:** +- Produces: `class Slic3r::OrcaMqttConnection` at `src/slic3r/Utils/OrcaMqttConnection.hpp` with today's exact API (`start(const std::string& endpoint, TokenProvider, MessageHandler, StateHandler)`, `stop()`, `is_running()`, `is_connected()`, `subscribe(const std::vector&)`, `unsubscribe(...)`, `clear_subscriptions()`, `send_request(const std::string&, const std::string&)`). + +- [ ] **Step 1: Create `OrcaMqttConnection.hpp`** + +Move the `class OrcaMqttConnection { ... };` block out of `OrcaCloudServiceAgent.hpp` (currently lines ~34–108) into a new header with include guard `#ifndef slic3r_OrcaMqttConnection_hpp_`. Carry the includes it needs: ``, ``, ``, ``, ``, ``, ``, ``, ``, ``, ``, ``, ``. Keep it in `namespace Slic3r`. + +- [ ] **Step 2: Create `OrcaMqttConnection.cpp`** + +Move every `OrcaMqttConnection::` and `OrcaMqttConnection::Connection` definition out of `OrcaCloudServiceAgent.cpp` (the block from `struct OrcaMqttConnection::Connection {` to the end of `OrcaMqttConnection::run()`), plus the file-local `using json = nlohmann::json;` / anonymous-namespace helpers those definitions use. `#include "OrcaMqttConnection.hpp"` at the top; carry the boost/log/json includes it references. + +- [ ] **Step 3: Point `OrcaCloudServiceAgent` at the new header** + +In `OrcaCloudServiceAgent.hpp` replace the removed class with `#include "OrcaMqttConnection.hpp"`. `OrcaCloudServiceAgent.cpp` keeps compiling (it already `#include`s its own header). + +- [ ] **Step 4: Add to the build** + +In `src/slic3r/CMakeLists.txt`, in `set(SLIC3R_GUI_SOURCES` next to `Utils/OrcaCloudServiceAgent.cpp`: + +```cmake + Utils/OrcaMqttConnection.cpp + Utils/OrcaMqttConnection.hpp +``` + +- [ ] **Step 5: Verify green** + +```bash +cmake --build build --target slic3rutils_tests -j +ctest --test-dir build -R 'printer_agent|Orca' --output-on-failure +``` +Expected: builds; existing `test_printer_agent` / `test_qidi_printer_agent` unchanged and passing. No new tests yet. + +--- + +## Task 2: `Config` struct + `parse_endpoint` for `ws://` + +**Files:** +- Modify: `src/slic3r/Utils/OrcaMqttConnection.hpp`, `src/slic3r/Utils/OrcaMqttConnection.cpp` +- Create: `tests/slic3rutils/test_orca_mqtt_connection.cpp` +- Modify: `tests/slic3rutils/CMakeLists.txt` + +**Interfaces:** +- Produces: + ```cpp + struct OrcaMqttConnection::Config { + std::string url; + bool use_tls = false; + TokenProvider bearer_provider; // set => bearer on WS upgrade, CONNECT creds omitted + std::string username; + std::string password; + std::string client_id = "OrcaSlicer"; + int keepalive_seconds = 60; + }; + static bool OrcaMqttConnection::parse_endpoint(const std::string& url, Endpoint& out); // now public, ws:// + wss:// + struct OrcaMqttConnection::Endpoint { std::string host; std::string port; std::string target; }; + ``` + `Endpoint` and `parse_endpoint` move to the `public:` section. + +- [ ] **Step 1: Write the failing test** + +Create `tests/slic3rutils/test_orca_mqtt_connection.cpp`: + +```cpp +#include +#include "slic3r/Utils/OrcaMqttConnection.hpp" + +using Slic3r::OrcaMqttConnection; + +TEST_CASE("OrcaMqtt parse_endpoint handles ws and wss", "[OrcaMqtt]") { + OrcaMqttConnection::Endpoint ep; + + REQUIRE(OrcaMqttConnection::parse_endpoint("ws://printer.local:8280/mqtt", ep)); + CHECK(ep.host == "printer.local"); + CHECK(ep.port == "8280"); + CHECK(ep.target == "/mqtt"); + + REQUIRE(OrcaMqttConnection::parse_endpoint("ws://10.0.0.5/mqtt", ep)); + CHECK(ep.port == "80"); + + REQUIRE(OrcaMqttConnection::parse_endpoint("wss://api.example.com/api/v1/printers/abc/mqtt", ep)); + CHECK(ep.host == "api.example.com"); + CHECK(ep.port == "443"); + CHECK(ep.target == "/api/v1/printers/abc/mqtt"); + + CHECK_FALSE(OrcaMqttConnection::parse_endpoint("http://x/y", ep)); +} +``` + +- [ ] **Step 2: Register the test file and run it (expect FAIL)** + +Add `test_orca_mqtt_connection.cpp` to the `add_executable(${_TEST_NAME}_tests` list in `tests/slic3rutils/CMakeLists.txt`. + +```bash +cmake --build build --target slic3rutils_tests -j +``` +Expected: compile error — `parse_endpoint` is private / `Endpoint` is private / no `ws://` support. + +- [ ] **Step 3: Make it pass** + +In `OrcaMqttConnection.hpp` move `struct Endpoint` and `static bool parse_endpoint(...)` into `public:`. Add the `Config` struct (above) in `public:`. + +In `OrcaMqttConnection.cpp` replace the `wss://`-only `parse_endpoint` body: + +```cpp +bool OrcaMqttConnection::parse_endpoint(const std::string& url, Endpoint& endpoint) { + std::string rest; + std::string default_port; + if (url.rfind("wss://", 0) == 0) { rest = url.substr(6); default_port = "443"; } + else if (url.rfind("ws://", 0) == 0) { rest = url.substr(5); default_port = "80"; } + else return false; + + const auto slash = rest.find('/'); + const std::string authority = rest.substr(0, slash); + endpoint.target = (slash == std::string::npos) ? "/" : rest.substr(slash); + + // host[:port] — leave an unbracketed IPv6 literal alone + const auto colon = authority.rfind(':'); + if (colon != std::string::npos && authority.find(']') == std::string::npos) { + endpoint.host = authority.substr(0, colon); + endpoint.port = authority.substr(colon + 1); + } else { + endpoint.host = authority; + endpoint.port = default_port; + } + return !endpoint.host.empty() && !endpoint.port.empty() && !endpoint.target.empty(); +} +``` + +- [ ] **Step 4: Verify green** + +```bash +cmake --build build --target slic3rutils_tests -j +ctest --test-dir build -R OrcaMqtt --output-on-failure +``` +Expected: PASS. + +--- + +## Task 3: `make_connect_packet` with client-id / auth / keepalive + +**Files:** +- Modify: `src/slic3r/Utils/OrcaMqttConnection.hpp`, `.cpp`, `tests/slic3rutils/test_orca_mqtt_connection.cpp` + +**Interfaces:** +- Consumes: `Config` (Task 2). +- Produces: `static std::vector OrcaMqttConnection::make_connect_packet(const std::string& client_id, const std::string& username, const std::string& password, int keepalive_seconds);` — public. Clean-session always set; username/password flags + fields only when `username` non-empty. + +- [ ] **Step 1: Write the failing test** + +```cpp +TEST_CASE("OrcaMqtt CONNECT packet — no auth (cloud form)", "[OrcaMqtt]") { + auto p = OrcaMqttConnection::make_connect_packet("OrcaSlicer", "", "", 300); + REQUIRE(p.size() >= 12); + CHECK(p[0] == 0x10); // CONNECT + // variable header: protocol name "MQTT", level 4 + CHECK(p[2] == 'M'); CHECK(p[3] == 'Q'); CHECK(p[4] == 'T'); CHECK(p[5] == 'T'); + CHECK(p[6] == 0x04); + CHECK(p[7] == 0x02); // connect flags: clean session only + CHECK(((p[8] << 8) | p[9]) == 300); // keepalive +} + +TEST_CASE("OrcaMqtt CONNECT packet — username/password (LAN form)", "[OrcaMqtt]") { + auto p = OrcaMqttConnection::make_connect_packet("orcaslicer-lan-x", "orcasonar", "code123", 60); + CHECK(p[0] == 0x10); + CHECK(p[7] == (0x02 | 0x80 | 0x40)); // clean session + username + password flags + // payload contains the client id, then username, then password strings + const std::string blob(p.begin(), p.end()); + CHECK(blob.find("orcaslicer-lan-x") != std::string::npos); + CHECK(blob.find("orcasonar") != std::string::npos); + CHECK(blob.find("code123") != std::string::npos); +} +``` + +- [ ] **Step 2: Run it (expect FAIL)** + +```bash +cmake --build build --target slic3rutils_tests -j +``` +Expected: compile error — `make_connect_packet` takes no args / is private. + +- [ ] **Step 3: Implement** + +Move `make_connect_packet` to `public:` and replace its body: + +```cpp +std::vector OrcaMqttConnection::make_connect_packet( + const std::string& client_id, const std::string& username, + const std::string& password, int keepalive_seconds) { + std::vector packet{0x10}; + append_string(packet, "MQTT"); + packet.push_back(4); // protocol level 3.1.1 + + uint8_t flags = 0x02; // clean session + if (!username.empty()) { flags |= 0x80; if (!password.empty()) flags |= 0x40; } + packet.push_back(flags); + + packet.push_back(static_cast(keepalive_seconds >> 8)); + packet.push_back(static_cast(keepalive_seconds & 0xff)); + + append_string(packet, client_id.empty() ? "OrcaSlicer" : client_id); + if (!username.empty()) { + append_string(packet, username); + if (!password.empty()) append_string(packet, password); + } + prepend_remaining_length(packet, packet.size() - 1); + return packet; +} +``` + +Update the one caller in `connect_and_read()` to pass +`current_config.client_id, current_config.username, current_config.password, current_config.keepalive_seconds` +(the `current_config` member arrives in Task 6; until then pass `"OrcaSlicer","","",60` and leave a `// TODO(Task 6): from Config` marker — **remove the marker in Task 6**). + +- [ ] **Step 4: Verify green** + +```bash +ctest --test-dir build -R OrcaMqtt --output-on-failure +``` +Expected: PASS. + +--- + +## Task 4: request / report topic packet builders + +**Files:** +- Modify: `src/slic3r/Utils/OrcaMqttConnection.hpp`, `.cpp`, `tests/slic3rutils/test_orca_mqtt_connection.cpp` + +**Interfaces:** +- Produces (all public, all static): + ```cpp + static std::string request_topic(const std::string& dev_id); // "device//request" + static std::string report_topic(const std::string& dev_id); // "device//report" (already exists; make public) + static std::vector make_publish_packet(const std::string& topic, const std::string& payload); // QoS 0 + static std::vector make_subscribe_packet(uint16_t packet_id, const std::string& topic, uint8_t qos); + static std::vector make_unsubscribe_packet(uint16_t packet_id, const std::string& topic); + ``` + +- [ ] **Step 1: Write the failing test** + +```cpp +TEST_CASE("OrcaMqtt topic helpers", "[OrcaMqtt]") { + CHECK(OrcaMqttConnection::request_topic("abc") == "device/abc/request"); + CHECK(OrcaMqttConnection::report_topic("abc") == "device/abc/report"); +} + +TEST_CASE("OrcaMqtt PUBLISH packet QoS0", "[OrcaMqtt]") { + auto p = OrcaMqttConnection::make_publish_packet("device/abc/request", "{\"ok\":1}"); + CHECK((p[0] & 0xf0) == 0x30); // PUBLISH + CHECK((p[0] & 0x06) == 0x00); // QoS 0 + const std::string blob(p.begin(), p.end()); + CHECK(blob.find("device/abc/request") != std::string::npos); + CHECK(blob.find("{\"ok\":1}") != std::string::npos); +} + +TEST_CASE("OrcaMqtt SUBSCRIBE packet", "[OrcaMqtt]") { + auto p = OrcaMqttConnection::make_subscribe_packet(7, "device/abc/report", 1); + CHECK(p[0] == 0x82); // SUBSCRIBE + reserved bit + CHECK(((p[2] << 8) | p[3]) == 7); // packet id + CHECK(p.back() == 1); // requested QoS +} +``` + +- [ ] **Step 2: Run it (expect FAIL)** — `cmake --build build --target slic3rutils_tests -j`; missing symbols. + +- [ ] **Step 3: Implement** + +Make `report_topic` public. Add: + +```cpp +std::string OrcaMqttConnection::request_topic(const std::string& id) { return "device/" + id + "/request"; } + +std::vector OrcaMqttConnection::make_publish_packet(const std::string& topic, const std::string& payload) { + std::vector packet{0x30}; // PUBLISH, QoS 0, no retain + append_string(packet, topic); // no packet id at QoS 0 + packet.insert(packet.end(), payload.begin(), payload.end()); + prepend_remaining_length(packet, packet.size() - 1); + return packet; +} + +std::vector OrcaMqttConnection::make_subscribe_packet(uint16_t id, const std::string& topic, uint8_t qos) { + std::vector packet{0x82}; + packet.push_back(id >> 8); packet.push_back(id & 0xff); + append_string(packet, topic); + packet.push_back(qos); + prepend_remaining_length(packet, packet.size() - 1); + return packet; +} + +std::vector OrcaMqttConnection::make_unsubscribe_packet(uint16_t id, const std::string& topic) { + std::vector packet{0xA2}; + packet.push_back(id >> 8); packet.push_back(id & 0xff); + append_string(packet, topic); + prepend_remaining_length(packet, packet.size() - 1); + return packet; +} +``` + +Keep the existing `make_topic_packet(uint8_t, uint16_t, const std::vector&)` for now — Task 5 removes its callers. + +- [ ] **Step 4: Verify green** — `ctest --test-dir build -R OrcaMqtt --output-on-failure` + +--- + +## Task 5: single-id `subscribe` / `unsubscribe` + persistent set; `Config`-carrying `start` + +**Files:** +- Modify: `src/slic3r/Utils/OrcaMqttConnection.hpp`, `.cpp`, `tests/slic3rutils/test_orca_mqtt_connection.cpp` + +**Interfaces:** +- Produces: + ```cpp + bool start(const Config& config, MessageHandler on_message, StateHandler on_state); + bool subscribe(const std::string& dev_id); // adds report_topic(dev_id) to the set, SUBSCRIBEs if connected + bool unsubscribe(const std::string& dev_id); + int last_connack_rc() const; // 0 ok, 1..5 refusal, -1 none this attempt + ``` + The old `start(const std::string&, TokenProvider, ...)` and vector `subscribe`/`unsubscribe` are **removed** (no back-compat). `report_topic` set members replace the device-id set. + +- [ ] **Step 1: Write the failing test** + +```cpp +TEST_CASE("OrcaMqtt start takes a Config", "[OrcaMqtt]") { + OrcaMqttConnection conn; + OrcaMqttConnection::Config cfg; + cfg.url = "ws://127.0.0.1:1/mqtt"; // nothing listening + cfg.keepalive_seconds = 42; + // start() returns false (no server) but must compile with the Config overload + const bool ok = conn.start(cfg, [](auto, auto){}, [](bool, bool){}); + CHECK_FALSE(ok); + CHECK(conn.last_connack_rc() == -1); + conn.stop(); +} +``` + +- [ ] **Step 2: Run it (expect FAIL)** — compile error: no `start(Config, ...)`, no `last_connack_rc`. + +- [ ] **Step 3: Implement** + +- Replace the `endpoint_url` / `get_token` members with `Config current_config;` and `std::atomic m_last_connack_rc{-1};`. +- Replace `std::set subscriptions` semantics: it now holds full report-topic strings. Add `pending_subscriptions` / `pending_unsubscriptions` as topic strings too (rename in place). +- New `start`: + ```cpp + bool OrcaMqttConnection::start(const Config& config, MessageHandler on_message, StateHandler on_state) { + stop(); + { std::lock_guard l(mutex); + current_config = config; this->on_message = std::move(on_message); this->on_state = std::move(on_state); + initial_completed = false; initial_result = false; connected = false; m_last_connack_rc = -1; } + stopping.store(false); + worker = std::thread(&OrcaMqttConnection::run, this); + std::unique_lock l(mutex); + initial_cv.wait_for(l, std::chrono::seconds(10), [this]{ return initial_completed; }); + return initial_result; + } + ``` +- `subscribe(dev_id)` / `unsubscribe(dev_id)`: + ```cpp + bool OrcaMqttConnection::subscribe(const std::string& dev_id) { + const std::string topic = report_topic(dev_id); + { std::lock_guard l(mutex); + subscriptions.insert(topic); pending_unsubscriptions.erase(topic); + pending_subscriptions.insert(topic); } + flush_subscription_change(); + return true; + } + ``` + (mirror for `unsubscribe`). +- `connect_and_read()` / `send_current_subscriptions` / `send_pending_subscriptions`: iterate topic strings, build with `make_subscribe_packet(next_packet_id++, topic, 1)` / `make_unsubscribe_packet`. Delete `make_topic_packet` and its declaration. +- In `connect_and_read()` use `current_config`: `parse_endpoint(current_config.url, ep)`; branch TLS on `current_config.use_tls` (Task 7 completes the plaintext branch); build CONNECT via `make_connect_packet(current_config.client_id, current_config.username, current_config.password, current_config.keepalive_seconds)` — **delete the Task 3 TODO marker**; add the `Authorization: Bearer` upgrade header only when `current_config.bearer_provider` is set. +- On CONNACK: `m_last_connack_rc = ;`. If rc ∈ {4,5}: stop the worker, do not retry (terminal). +- Update `OrcaCloudServiceAgent.cpp::connect_server()` (its only caller) to the new signature — see Task 15; for now make it compile with a `Config` built from today's `wss://.../api/v1/printers/mqtt` URL and `bearer_provider = [this]{ return get_access_token(); }`. + +- [ ] **Step 4: Verify green** — `ctest --test-dir build -R OrcaMqtt --output-on-failure` (the new test plus Tasks 2–4). Also `ctest -R 'printer_agent'` still green. + +--- + +## Task 6: `send_request` publishes to `device//request` + +**Files:** +- Modify: `src/slic3r/Utils/OrcaMqttConnection.cpp`, `tests/slic3rutils/test_orca_mqtt_connection.cpp` + +**Interfaces:** +- Consumes: `make_publish_packet`, `request_topic`, `ws_write`/`send` (existing write path), `write_mutex`. +- Produces: `bool send_request(const std::string& dev_id, const std::string& payload)` — returns `false` without sending if `!is_connected()`. + +- [ ] **Step 1: Write the failing test** (uses the mock broker from Task 8 — so this test is added but `[.]`-hidden until Task 9 wires it; for now assert the guard): + +```cpp +TEST_CASE("OrcaMqtt send_request refuses when not connected", "[OrcaMqtt]") { + OrcaMqttConnection conn; + CHECK_FALSE(conn.send_request("abc", "{\"pushing\":{\"command\":\"pushall\",\"sequence_id\":\"20001\"}}")); +} +``` + +- [ ] **Step 2: Run it (expect FAIL)** — `send_request` currently returns something else / is unimplemented. + +- [ ] **Step 3: Implement** + +```cpp +bool OrcaMqttConnection::send_request(const std::string& dev_id, const std::string& payload) { + if (!connected.load()) return false; + std::shared_ptr conn; + { std::lock_guard l(connection_mutex); conn = active_connection; } + if (!conn) return false; + const auto packet = make_publish_packet(request_topic(dev_id), payload); + std::lock_guard w(write_mutex); + try { send(conn->websocket, packet); } // existing write helper + catch (const std::exception& e) { + BOOST_LOG_TRIVIAL(warning) << "OrcaMqtt send_request failed: " << e.what(); + return false; + } + return true; +} +``` + +(If Task 7 renamed `send`→`ws_write`, use that.) + +- [ ] **Step 4: Verify green** — `ctest --test-dir build -R OrcaMqtt --output-on-failure` + +--- + +## Task 7: plaintext (`ws://`) transport branch + +**Files:** +- Modify: `src/slic3r/Utils/OrcaMqttConnection.hpp`, `.cpp` + +**Interfaces:** +- Consumes: `Config.use_tls`, `Config.bearer_provider`. +- Produces: `struct Connection` holds `std::optional ws;` and `std::optional wss;` with `PlainWebSocket = websocket::stream` and `TlsWebSocket = websocket::stream>`. Internal helpers `ws_write(Connection&, const std::vector&)`, `ws_read(Connection&, beast::flat_buffer&, error_code&)`, `ws_handshake(Connection&, const Config&, const Endpoint&)`, `ws_close(Connection&)` dispatch on which optional is engaged. + +- [ ] **Step 1: Write the failing test** (needs the mock broker — mark `[.integration]`, un-hide in Task 9): + +```cpp +TEST_CASE("OrcaMqtt connects over plaintext ws", "[OrcaMqtt][.integration]") { + orca_mqtt_test::MockBroker broker; // Task 8 + OrcaMqttConnection conn; + OrcaMqttConnection::Config cfg; cfg.url = broker.ws_url(); cfg.use_tls = false; + std::atomic up{false}; + REQUIRE(conn.start(cfg, [](auto,auto){}, [&](bool c, bool){ if (c) up = true; })); + CHECK(conn.is_connected()); + conn.stop(); +} +``` + +- [ ] **Step 2: Run it (expect FAIL to build / link)** — no `ws_handshake` etc. + +- [ ] **Step 3: Implement** + +- `Connection` gets both optionals + the shared `beast::flat_buffer read_buffer;` and a `net::io_context io;` / `ssl::context tls{ssl::context::tlsv12_client};` as today. +- `ws_handshake`: resolve host/port; `beast::get_lowest_layer(stream).connect(results)`; if `use_tls`: set SNI (`SSL_set_tlsext_host_name`), `stream.next_layer().handshake(ssl::stream_base::client)`. Then set the upgrade decorator that adds `Authorization: Bearer ` when `config.bearer_provider` is set, and `Sec-WebSocket-Protocol: mqtt`. Then `stream.handshake(host, target)`. +- `ws_write` / `ws_read` / `ws_close`: `if (conn.wss) conn.wss->...; else conn.ws->...;`. +- `connect_and_read()`: replace direct `WebSocket` use with a `Connection` and the `ws_*` helpers; construct `conn->ws.emplace(conn->io)` or `conn->wss.emplace(conn->io, conn->tls)` based on `current_config.use_tls`. +- Delete the old `using WebSocket = websocket::stream>;` typedef and the `send(WebSocket&, ...)` signature (fold into `ws_write`). + +> API note: exact Beast calls (`beast::get_lowest_layer`, `tcp_stream::connect`, decorator signature) vary by Boost version. Match the version already vendored in `deps/`; the existing TLS code in this file is the reference for the `wss` side. + +- [ ] **Step 4: Verify green** + +```bash +cmake --build build --target slic3rutils_tests -j +ctest --test-dir build -R 'OrcaMqtt' --output-on-failure # non-integration subset still green +``` + +--- + +## Task 8: in-process MQTT-over-WS mock broker + +**Files:** +- Create: `tests/slic3rutils/orca_mqtt_mock_broker.hpp` + +**Interfaces:** +- Produces: + ```cpp + namespace orca_mqtt_test { + class MockBroker { // starts on ctor, stops on dtor + public: + MockBroker(); + ~MockBroker(); + std::string ws_url() const; // "ws://127.0.0.1:/mqtt" + void push_report(const std::string& dev_id, const std::string& payload); // server->client PUBLISH on device//report + std::vector received_requests() const; // payloads PUBLISHed by the client to any device//request + int connect_count() const; + }; + } + ``` + +- [ ] **Step 1: Smoke test** + +```cpp +#include "orca_mqtt_mock_broker.hpp" +TEST_CASE("MockBroker starts and reports a url", "[OrcaMqtt][.integration]") { + orca_mqtt_test::MockBroker b; + CHECK(b.ws_url().rfind("ws://127.0.0.1:", 0) == 0); + CHECK(b.connect_count() == 0); +} +``` + +- [ ] **Step 2: Run it (expect FAIL)** — header missing. + +- [ ] **Step 3: Implement** + +Header-only. One `std::thread` running a `net::io_context`; `tcp::acceptor` on `{net::ip::make_address("127.0.0.1"), 0}` (port 0 → OS-assigned, read back via `acceptor.local_endpoint().port()`). On accept: `websocket::stream`, accept the upgrade echoing `Sec-WebSocket-Protocol: mqtt`. Then a minimal MQTT read loop: +- `0x10` CONNECT → reply `0x20 0x02 0x00 0x00` (CONNACK accepted); `connect_count_++`. +- `0x82` SUBSCRIBE → reply `0x90` SUBACK with the echoed packet id and one granted-QoS byte `0x00`; remember the subscribed topic. +- `0x30` PUBLISH (QoS 0) → parse topic + payload; if topic ends `/request`, append payload to `received_requests_`. +- `0xC0` PINGREQ → reply `0xD0 0x00`. +- `0xE0` DISCONNECT / read error → close. +`push_report()` posts a `make`-style PUBLISH (`0x30`, topic `device//report`, payload) onto the connected client socket via `net::post(strand, ...)`. + +Use only Boost already vendored. Guard all shared state (`received_requests_`, `connect_count_`) with a `std::mutex`. + +- [ ] **Step 4: Verify green** — `ctest --test-dir build -R 'MockBroker' --output-on-failure` with `--allow-running-no-tests` off; run the hidden tag explicitly: `ctest --test-dir build -R OrcaMqtt -C RelWithDebInfo` then the test binary directly: `./build/tests/slic3rutils/slic3rutils_tests "[.integration]"`. + +--- + +## Task 9: parametrized LAN/cloud integration test + +**Files:** +- Modify: `tests/slic3rutils/test_orca_mqtt_connection.cpp` + +**Interfaces:** +- Consumes: `MockBroker` (Task 8), `OrcaMqttConnection::start/subscribe/send_request` (Tasks 5–7). + +- [ ] **Step 1: Write the test** + +```cpp +static void run_round_trip(bool use_tls_flag_only) { + orca_mqtt_test::MockBroker broker; + OrcaMqttConnection conn; + OrcaMqttConnection::Config cfg; + cfg.url = broker.ws_url(); // plaintext regardless + cfg.use_tls = false; // the mock is plaintext; the flag path is unit-tested elsewhere + if (use_tls_flag_only) cfg.bearer_provider = []{ return std::string("tok"); }; + else { cfg.username = "orcasonar"; cfg.password = "code"; } + + std::promise> got; + REQUIRE(conn.start(cfg, + [&](const std::string& id, const std::string& payload){ got.set_value({id, payload}); }, + [](bool,bool){})); + REQUIRE(conn.subscribe("dev-1")); + REQUIRE(conn.send_request("dev-1", R"({"pushing":{"command":"pushall","sequence_id":"20001"}})")); + + broker.push_report("dev-1", R"({"print":{"command":"push_status","sequence_id":"20001","result":"success"}})"); + auto fut = got.get_future(); + REQUIRE(fut.wait_for(std::chrono::seconds(3)) == std::future_status::ready); + auto [id, payload] = fut.get(); + CHECK(id == "dev-1"); + CHECK(payload.find("push_status") != std::string::npos); + + // the client's command reached the broker on the request topic + CHECK(broker.received_requests().size() == 1); + conn.stop(); +} + +TEST_CASE("OrcaMqtt round-trip — LAN-style config", "[OrcaMqtt][.integration]") { run_round_trip(false); } +TEST_CASE("OrcaMqtt round-trip — cloud-style config", "[OrcaMqtt][.integration]") { run_round_trip(true); } +``` + +- [ ] **Step 2: Run it (expect FAIL then iterate)** — `./build/tests/slic3rutils/slic3rutils_tests "[.integration]"`. + +- [ ] **Step 3: Fix defects** in `OrcaMqttConnection` until both cases pass with identical assertions. Un-hide the Task 6/7 integration tests (`[.integration]` → keep the tag; they run via explicit tag selection). + +- [ ] **Step 4: Verify green** — `./build/tests/slic3rutils/slic3rutils_tests "[OrcaMqtt]"` (all, including `[.integration]`). + +--- + +## Task 10: `OrcaPrinterAgent` — remove `read_loop`, wire per-connection inbound + +**Files:** +- Modify: `src/slic3r/Utils/OrcaPrinterAgent.hpp`, `.cpp` +- Create: `tests/slic3rutils/test_orca_printer_agent.cpp` (seed from `salvage/orcasonar-lan-agent-2026-09-03`) +- Modify: `tests/slic3rutils/CMakeLists.txt` + +**Interfaces:** +- Produces: `void OrcaPrinterAgent::deliver_to_sink(const std::string& dev_id, const std::string& payload)` (private) — snapshots `on_message_fn` under `state_mutex`, calls it (marshalling via `queue_on_main_fn` when set). Used as the body of every connection's `MessageHandler`. + +- [ ] **Step 1: Seed + write the failing test** + +```bash +git show salvage/orcasonar-lan-agent-2026-09-03:tests/slic3rutils/test_orca_printer_agent.cpp \ + > tests/slic3rutils/test_orca_printer_agent.cpp +``` +Then replace its body with this design's tests. First test: + +```cpp +#include +#include "slic3r/Utils/OrcaPrinterAgent.hpp" +using Slic3r::OrcaPrinterAgent; + +TEST_CASE("OrcaPrinterAgent forwards a status payload to on_message_fn", "[OrcaPrinterAgent]") { + OrcaPrinterAgent agent("/tmp"); + std::string got_id, got_payload; + agent.set_on_message_fn([&](std::string id, std::string p){ got_id = id; got_payload = p; }); + agent.deliver_to_sink("dev-1", R"({"print":{"command":"push_status"}})"); // test-only hook + CHECK(got_id == "dev-1"); + CHECK(got_payload.find("push_status") != std::string::npos); +} +``` + +Add `test_orca_printer_agent.cpp` to `tests/slic3rutils/CMakeLists.txt`. + +- [ ] **Step 2: Run it (expect FAIL)** — `deliver_to_sink` missing; `read_loop` still present. + +- [ ] **Step 3: Implement** + +- `OrcaPrinterAgent.hpp`: delete `read_loop`, `m_read_loop_thread`, `m_should_end`. Add `void deliver_to_sink(const std::string& dev_id, const std::string& payload);`. +- `OrcaPrinterAgent.cpp`: delete the `read_loop` definition and its ctor `std::thread(...)`/`detach()`. Delete the file-scope `std::mutex m_conn_type_mtx;`. Ctor body becomes empty (or just the log line). Add: + ```cpp + void OrcaPrinterAgent::deliver_to_sink(const std::string& dev_id, const std::string& payload) { + OnMessageFn fn; QueueOnMainFn q; + { std::lock_guard l(state_mutex); fn = on_message_fn; q = queue_on_main_fn; } + if (!fn) return; + if (q) q([fn, dev_id, payload]{ fn(dev_id, payload); }); + else fn(dev_id, payload); + } + ``` +- In `set_cloud_agent`, the existing `set_printer_status_callback` lambda body becomes `deliver_to_sink(std::move(dev_id), std::move(payload));`. + +- [ ] **Step 4: Verify green** — `ctest --test-dir build -R OrcaPrinterAgent --output-on-failure` + +--- + +## Task 11: `connect_printer` builds + starts the LAN connection + +**Files:** +- Modify: `src/slic3r/Utils/OrcaPrinterAgent.hpp`, `.cpp`, `tests/slic3rutils/test_orca_printer_agent.cpp` + +**Interfaces:** +- Consumes: `OrcaMqttConnection::Config`, `start`. +- Produces: + ```cpp + static bool OrcaPrinterAgent::parse_lan_endpoint(const std::string& dev_ip, std::string& host, std::string& port); // "8280" default, "/mqtt" implied + static std::string OrcaPrinterAgent::make_lan_client_id(const std::string& dev_id); + ``` + New members: `std::atomic m_lan_generation{0}`, `std::string m_lan_dev_id`. + +- [ ] **Step 1: Write the failing test** + +```cpp +TEST_CASE("OrcaPrinterAgent::parse_lan_endpoint", "[OrcaPrinterAgent]") { + std::string h, p; + REQUIRE(OrcaPrinterAgent::parse_lan_endpoint("192.168.1.9", h, p)); + CHECK(h == "192.168.1.9"); CHECK(p == "8280"); + REQUIRE(OrcaPrinterAgent::parse_lan_endpoint("http://host.local:9000/x", h, p)); + CHECK(h == "host.local"); CHECK(p == "9000"); +} + +TEST_CASE("connect_printer stands up a LAN connection", "[OrcaPrinterAgent]") { + OrcaPrinterAgent agent("/tmp"); + // 10.255.255.1 is unroutable → start() returns fast-ish; we only assert wiring + const int rc = agent.connect_printer("dev-1", "10.255.255.1", "orcasonar", "code", false); + CHECK(rc == BAMBU_NETWORK_SUCCESS); + CHECK(agent.get_user_selected_machine().empty()); // LAN path does not set the cloud selection + agent.disconnect_printer(); +} +``` + +- [ ] **Step 2: Run it (expect FAIL)** — helpers missing; `connect_printer` is a stub returning success without doing anything (make the wiring assertion fail by checking an observable — see Step 3 for the observable: a protected `lan_connection_url()` test hook). + +- [ ] **Step 3: Implement** + +- Add `parse_lan_endpoint` (scheme strip, `host[:port]`, default `8280`) and `make_lan_client_id` (`"orcaslicer-lan-" + dev_id + "-" + <8 hex, drawn once per process>`). +- `connect_printer`: + ```cpp + int OrcaPrinterAgent::connect_printer(std::string dev_id, std::string dev_ip, + std::string username, std::string password, bool use_ssl) { + if (dev_id.empty() || dev_ip.empty()) return BAMBU_NETWORK_ERR_INVALID_HANDLE; + std::string host, port; + if (!parse_lan_endpoint(dev_ip, host, port)) return BAMBU_NETWORK_ERR_INVALID_HANDLE; + disconnect_printer(); + const uint64_t gen = ++m_lan_generation; + OrcaMqttConnection::Config cfg; + cfg.url = "ws://" + host + ":" + port + "/mqtt"; + cfg.use_tls = false; // OrcaSonar LAN is plaintext; use_ssl ignored + cfg.username = username.empty() ? "orcasonar" : username; + cfg.password = password; + cfg.client_id = make_lan_client_id(dev_id); + cfg.keepalive_seconds = 60; + { std::lock_guard l(state_mutex); m_lan_dev_id = dev_id; m_current_connection = LAN; } + lan_mqtt_connection = std::make_unique(); + auto* conn = lan_mqtt_connection.get(); + std::thread([this, conn, cfg, dev_id, gen] { + const bool ok = conn->start(cfg, + [this, gen](const std::string& id, const std::string& p){ if (gen == m_lan_generation.load()) deliver_to_sink(id, p); }, + [this, gen, dev_id, conn](bool c, bool initial){ if (c && !initial && gen == m_lan_generation.load()) on_connected(dev_id, conn, gen); }); + if (ok && gen == m_lan_generation.load()) on_connected(dev_id, conn, gen); + }).detach(); + return BAMBU_NETWORK_SUCCESS; + } + ``` +- Add a protected test hook: `std::string lan_connection_target() const { return lan_mqtt_connection ? /* Config.url snapshot */ : ""; }` — store `cfg.url` in a `std::string m_lan_url;` member when building it, and return that. Assert it in the test. + +- [ ] **Step 4: Verify green** — `ctest --test-dir build -R OrcaPrinterAgent --output-on-failure` + +--- + +## Task 12: `on_connected` — the shared post-connect sequence + +**Files:** +- Modify: `src/slic3r/Utils/OrcaPrinterAgent.hpp`, `.cpp`, `tests/slic3rutils/test_orca_printer_agent.cpp` + +**Interfaces:** +- Consumes: `OrcaMqttConnection::subscribe`, `send_request`. +- Produces: + ```cpp + void OrcaPrinterAgent::on_connected(const std::string& dev_id, OrcaMqttConnection* conn, uint64_t generation); + static std::string OrcaPrinterAgent::seq(int n); // "2000" + zero-padded band offset; returns a string in 20000..29999 + static std::string OrcaPrinterAgent::build_pushing_start(const std::string& sequence_id); + static std::string OrcaPrinterAgent::build_pushall(const std::string& sequence_id); + static std::string OrcaPrinterAgent::build_get_version(const std::string& sequence_id); + static std::string OrcaPrinterAgent::build_get_capabilities(const std::string& sequence_id); + ``` + +- [ ] **Step 1: Write the failing test** — a fake `OrcaMqttConnection` subclass is not available (non-virtual). Instead test the payload builders + call order via a seam: `on_connected` takes an `OrcaMqttConnection*`; make the four `send_request` payloads and the `subscribe` observable by having `on_connected` delegate to a `protected virtual void emit_connect_sequence(const std::string&, std::function subscribe, std::function request)` that the test overrides. + +```cpp +TEST_CASE("post-connect sequence is subscribe then 4 requests in order", "[OrcaPrinterAgent]") { + struct Probe : OrcaPrinterAgent { + using OrcaPrinterAgent::OrcaPrinterAgent; + std::vector calls; + void emit_connect_sequence(const std::string& dev_id, + std::function sub, + std::function req) override { + OrcaPrinterAgent::emit_connect_sequence(dev_id, + [&](const std::string& id){ calls.push_back("sub:" + id); }, + [&](const std::string& body){ calls.push_back(body); }); + } + } probe("/tmp"); + probe.run_connect_sequence_for_test("dev-1"); // thin public shim calling emit_connect_sequence + REQUIRE(probe.calls.size() == 5); + CHECK(probe.calls[0] == "sub:dev-1"); + CHECK(probe.calls[1].find("\"pushing\"") != std::string::npos); + CHECK(probe.calls[1].find("\"start\"") != std::string::npos); + CHECK(probe.calls[2].find("pushall") != std::string::npos); + CHECK(probe.calls[3].find("get_version") != std::string::npos); + CHECK(probe.calls[4].find("get_capabilities") != std::string::npos); + for (auto& c : probe.calls) // sequence_id band + if (auto pos = c.find("sequence_id"); pos != std::string::npos) + CHECK(c.substr(pos).find("\"2") != std::string::npos); +} +``` + +- [ ] **Step 2: Run it (expect FAIL)** — members missing. + +- [ ] **Step 3: Implement** + +- Payload builders return exact JSON, e.g.: + ```cpp + std::string OrcaPrinterAgent::build_pushall(const std::string& sid) { + return R"({"pushing":{"command":"pushall","sequence_id":")" + sid + R"(","version":1,"push_target":1}})"; + } + std::string OrcaPrinterAgent::build_pushing_start(const std::string& sid) { + return R"({"pushing":{"command":"start","sequence_id":")" + sid + R"("}})"; + } + std::string OrcaPrinterAgent::build_get_version(const std::string& sid) { + return R"({"info":{"command":"get_version","sequence_id":")" + sid + R"("}})"; + } + std::string OrcaPrinterAgent::build_get_capabilities(const std::string& sid) { + return R"({"info":{"command":"get_capabilities","sequence_id":")" + sid + R"("}})"; + } + ``` +- `seq(n)`: `return std::to_string(20000 + (n % 10000));` +- `emit_connect_sequence(dev_id, sub, req)`: `sub(dev_id); req(build_pushing_start(seq(1))); req(build_pushall(seq(2))); req(build_get_version(seq(3))); req(build_get_capabilities(seq(4)));` +- `on_connected(dev_id, conn, generation)`: if `generation != m_lan_generation.load()` **and** the cloud generation guard (Task 14) both mismatch, return. Else `emit_connect_sequence(dev_id, [conn](auto& id){ conn->subscribe(id); }, [conn, &dev_id](auto& body){ conn->send_request(dev_id, body); });` +- Add the tiny public shim `run_connect_sequence_for_test`. + +- [ ] **Step 4: Verify green** — `ctest --test-dir build -R OrcaPrinterAgent --output-on-failure` + +--- + +## Task 13: `disconnect_printer` + generation guard + +**Files:** +- Modify: `src/slic3r/Utils/OrcaPrinterAgent.cpp`, `tests/slic3rutils/test_orca_printer_agent.cpp` + +**Interfaces:** +- Consumes: `m_lan_generation`, `lan_mqtt_connection`, `OrcaMqttConnection::stop`. + +- [ ] **Step 1: Write the failing test** + +```cpp +TEST_CASE("a stale-generation inbound message is dropped", "[OrcaPrinterAgent]") { + struct Probe : OrcaPrinterAgent { using OrcaPrinterAgent::OrcaPrinterAgent; + using OrcaPrinterAgent::make_lan_message_handler; }; // expose for the test + Probe agent("/tmp"); + int hits = 0; + agent.set_on_message_fn([&](std::string, std::string){ ++hits; }); + auto handler_gen1 = agent.make_lan_message_handler(/*generation=*/1); + agent.bump_lan_generation_for_test(); // now current == 2 + handler_gen1("dev-1", "{}"); // late callback from gen 1 + CHECK(hits == 0); +} +``` + +- [ ] **Step 2: Run it (expect FAIL)** — helpers missing. + +- [ ] **Step 3: Implement** + +- Factor the message-handler lambda into `std::function make_lan_message_handler(uint64_t generation)` returning `[this, generation](auto& id, auto& p){ if (generation == m_lan_generation.load()) deliver_to_sink(id, p); }`. +- `disconnect_printer`: + ```cpp + int OrcaPrinterAgent::disconnect_printer() { + ++m_lan_generation; // fence stale callbacks + std::unique_ptr doomed; + { std::lock_guard l(state_mutex); + doomed = std::move(lan_mqtt_connection); + m_lan_dev_id.clear(); + if (m_current_connection == LAN) m_current_connection = NONE; } + if (doomed) doomed->stop(); // joins the worker, outside the lock + return BAMBU_NETWORK_SUCCESS; + } + ``` +- Add `bump_lan_generation_for_test()`. + +- [ ] **Step 4: Verify green** — `ctest --test-dir build -R OrcaPrinterAgent --output-on-failure` + +--- + +## Task 14: `set_user_selected_machine` drives the cloud per-printer connection + +**Files:** +- Modify: `src/slic3r/Utils/OrcaPrinterAgent.cpp`, `src/slic3r/Utils/OrcaCloudServiceAgent.hpp`, `.cpp`, `tests/slic3rutils/test_orca_printer_agent.cpp` + +**Interfaces:** +- Consumes: `OrcaCloudServiceAgent::get_mqtt_connection()`. +- Produces on `OrcaCloudServiceAgent`: + ```cpp + int configure_selected_printer_mqtt(const std::string& dev_id); // (re)build Config{wss:///api/v1/printers/{id}/mqtt, bearer}, start() + void teardown_selected_printer_mqtt(); // stop() + std::string selected_printer_mqtt_url() const; // test hook — "" when not configured + ``` + +- [ ] **Step 1: Write the failing test** + +```cpp +TEST_CASE("selecting a cloud printer configures the per-printer socket", "[OrcaPrinterAgent]") { + auto cloud = std::make_shared("/tmp"); + cloud->set_api_base_url("api.example.com"); + OrcaPrinterAgent agent("/tmp"); + agent.set_cloud_agent(cloud); + + agent.set_user_selected_machine("printer-uuid-1"); + CHECK(cloud->selected_printer_mqtt_url() == "wss://api.example.com/api/v1/printers/printer-uuid-1/mqtt"); + + agent.set_user_selected_machine(""); + CHECK(cloud->selected_printer_mqtt_url().empty()); +} +``` + +- [ ] **Step 2: Run it (expect FAIL)** — methods missing; `set_user_selected_machine` still does the aggregate `add_subscribe` dance. + +- [ ] **Step 3: Implement** + +- `OrcaCloudServiceAgent::configure_selected_printer_mqtt(dev_id)`: + ```cpp + OrcaMqttConnection::Config cfg; + cfg.url = "wss://" + api_base_url + "/api/v1/printers/" + dev_id + "/mqtt"; + cfg.use_tls = true; + cfg.bearer_provider = [this]{ return get_access_token(); }; + cfg.client_id = "OrcaSlicer"; + cfg.keepalive_seconds = 300; + m_selected_printer_mqtt_url = cfg.url; + return mqtt_connection->start(cfg, + [this](const std::string& id, const std::string& p){ /* Task 15 routes to printer_status_callback */ deliver_cloud_message(id, p); }, + [this](bool, bool){ }) ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED; + ``` + `teardown_selected_printer_mqtt()`: `mqtt_connection->stop(); m_selected_printer_mqtt_url.clear();` +- `OrcaPrinterAgent::set_user_selected_machine(dev_id)`: + ```cpp + int OrcaPrinterAgent::set_user_selected_machine(std::string dev_id) { + auto* cloud = get_orca_cloud_agent(); + std::string previous; + { std::lock_guard l(state_mutex); + if (dev_id == selected_machine) return BAMBU_NETWORK_SUCCESS; + previous = selected_machine; selected_machine = dev_id; } + if (!cloud) return BAMBU_NETWORK_SUCCESS; + auto* conn = cloud->get_mqtt_connection(); + if (!previous.empty() && conn && conn->is_connected()) + conn->send_request(previous, build_pushing_stop(seq(5))); + cloud->teardown_selected_printer_mqtt(); + if (!dev_id.empty()) { + const uint64_t gen = ++m_lan_generation; // reuse the same fence for cloud + std::thread([this, cloud, dev_id, gen]{ + if (cloud->configure_selected_printer_mqtt(dev_id) == BAMBU_NETWORK_SUCCESS + && gen == m_lan_generation.load()) + on_connected(dev_id, cloud->get_mqtt_connection(), gen); + }).detach(); + { std::lock_guard l(state_mutex); m_current_connection = CLOUD; } + } else { + std::lock_guard l(state_mutex); m_current_connection = NONE; + } + return BAMBU_NETWORK_SUCCESS; + } + ``` + Add `build_pushing_stop` next to `build_pushing_start` (`"command":"stop"`). +- Delete the old aggregate `add_subscribe` / `del_subscribe` / `send_message(pushall)` / `deliver_mock_get_version` body from `set_user_selected_machine` (the mock get_version is now redundant — `on_connected` sends a real `info.get_version`). + +- [ ] **Step 4: Verify green** — `ctest --test-dir build -R OrcaPrinterAgent --output-on-failure` + +--- + +## Task 15: `OrcaCloudServiceAgent::connect_server()` stops starting the aggregate socket + +**Files:** +- Modify: `src/slic3r/Utils/OrcaCloudServiceAgent.cpp`, `.hpp`, `tests/slic3rutils/test_orca_printer_agent.cpp` (or a new `test_orca_cloud_service_agent.cpp`) + +**Interfaces:** +- Consumes: existing REST `http_get(ORCA_HEALTH_PATH, ...)`. +- Produces: `connect_server()` returns success/failure from the health probe alone; `is_server_connected()` returns the last health result; `mqtt_connection` is untouched by `connect_server()`. + +- [ ] **Step 1: Write the failing test** + +```cpp +TEST_CASE("connect_server does not start an MQTT socket", "[OrcaCloud]") { + auto cloud = std::make_shared("/tmp"); + cloud->set_api_base_url("127.0.0.1:1"); // health probe will fail fast + cloud->connect_server(); + REQUIRE(cloud->get_mqtt_connection() != nullptr); + CHECK_FALSE(cloud->get_mqtt_connection()->is_running()); + CHECK(cloud->selected_printer_mqtt_url().empty()); +} +``` + +- [ ] **Step 2: Run it (expect FAIL)** — `connect_server()` currently builds `cfg.url = "wss://" + api_base_url + "/api/v1/printers/mqtt"` and calls `mqtt_connection->start(...)`. + +- [ ] **Step 3: Implement** + +- Delete the whole `if (connected && mqtt_connection && !mqtt_connection->is_running()) { ... mqtt_connection->start(cfg, ...); }` block from `connect_server()` and the trailing "aggregate MQTT" logging. +- Keep the health check; set `is_connected = connected;` from it and call `invoke_server_connected_callback(connected ? 0 : -1, http_code);`. +- `refresh_connection()` still just calls `connect_server()`. +- The `printer_status_callback` / `set_printer_status_callback` machinery stays (Task 14's `configure_selected_printer_mqtt` message lambda calls `deliver_cloud_message` → the registered `printer_status_callback`). Add: + ```cpp + void OrcaCloudServiceAgent::deliver_cloud_message(const std::string& id, const std::string& p) { + OnMessageFn cb; + { std::lock_guard l(callback_mutex); cb = printer_status_callback; } + if (cb) cb(id, p); + } + ``` + +- [ ] **Step 4: Verify green** — `ctest --test-dir build -R 'OrcaCloud|OrcaPrinterAgent' --output-on-failure` + +--- + +## Task 16: collapse `send_message` / `send_message_to_printer` + +**Files:** +- Modify: `src/slic3r/Utils/OrcaPrinterAgent.cpp`, `tests/slic3rutils/test_orca_printer_agent.cpp` + +**Interfaces:** +- Consumes: `get_appropriate_mqtt_connection(bool)`, `OrcaMqttConnection::send_request`. + +- [ ] **Step 1: Write the failing test** + +```cpp +TEST_CASE("send_message* reject when no connection", "[OrcaPrinterAgent]") { + OrcaPrinterAgent agent("/tmp"); // no cloud agent, no LAN connection + CHECK(agent.send_message("d", "{}", 0, 0) == BAMBU_NETWORK_ERR_INVALID_HANDLE); + CHECK(agent.send_message_to_printer("d", "{}", 0, 0) == BAMBU_NETWORK_ERR_INVALID_HANDLE); +} + +TEST_CASE("send_message_to_printer publishes on the LAN connection", "[OrcaPrinterAgent][.integration]") { + orca_mqtt_test::MockBroker broker; + OrcaPrinterAgent agent("/tmp"); + // point the LAN connection at the mock by connecting to its host:port + auto ep = broker.host_port(); // {"127.0.0.1", } + agent.connect_printer("dev-1", ep.first + ":" + ep.second, "orcasonar", "code", false); + // wait for connect + for (int i = 0; i < 100 && broker.connect_count() == 0; ++i) std::this_thread::sleep_for(std::chrono::milliseconds(20)); + CHECK(agent.send_message_to_printer("dev-1", R"({"print":{"command":"pause","sequence_id":"20007"}})", 0, 0) + == BAMBU_NETWORK_SUCCESS); + for (int i = 0; i < 100 && broker.received_requests().empty(); ++i) std::this_thread::sleep_for(std::chrono::milliseconds(20)); + REQUIRE(broker.received_requests().size() >= 1); + CHECK(broker.received_requests().back().find("pause") != std::string::npos); + agent.disconnect_printer(); +} +``` + +> `MockBroker::host_port()` — add a small accessor returning `{"127.0.0.1", std::to_string(port_)}` in Task 8's header (fold this one-line addition here). + +- [ ] **Step 2: Run it (expect FAIL)** — `send_message` still spawns the old REST thread / `send_message_to_printer` is a bare `return SUCCESS`. + +- [ ] **Step 3: Implement** + +```cpp +int OrcaPrinterAgent::send_message(std::string dev_id, std::string json_str, int, int) { + return route_send(false, dev_id, json_str); +} +int OrcaPrinterAgent::send_message_to_printer(std::string dev_id, std::string json_str, int, int) { + return route_send(true, dev_id, json_str); +} +int OrcaPrinterAgent::route_send(bool is_lan, const std::string& dev_id, const std::string& json_str) { + if (dev_id.empty()) return BAMBU_NETWORK_ERR_INVALID_HANDLE; + OrcaMqttConnection* conn = get_appropriate_mqtt_connection(is_lan); + if (!conn) return BAMBU_NETWORK_ERR_INVALID_HANDLE; + return conn->send_request(dev_id, json_str) ? BAMBU_NETWORK_SUCCESS + : BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED; +} +``` + +Guard `get_appropriate_mqtt_connection(false)` against a null cloud agent: `return get_orca_cloud_agent() ? get_orca_cloud_agent()->get_mqtt_connection() : nullptr;` + +- [ ] **Step 4: Verify green** — `./build/tests/slic3rutils/slic3rutils_tests "[OrcaPrinterAgent]"` + +--- + +## Task 17: destructor teardown — no detached threads touching `*this` + +**Files:** +- Modify: `src/slic3r/Utils/OrcaPrinterAgent.cpp`, `tests/slic3rutils/test_orca_printer_agent.cpp` + +- [ ] **Step 1: Write the failing test** + +```cpp +TEST_CASE("destroying an agent mid-connect does not hang or crash", "[OrcaPrinterAgent]") { + for (int i = 0; i < 20; ++i) { + auto agent = std::make_unique("/tmp"); + agent->connect_printer("dev-1", "10.255.255.1", "orcasonar", "code", false); // unroutable, still connecting + agent.reset(); // dtor must join/stop cleanly + } + SUCCEED(); +} +``` + +- [ ] **Step 2: Run it (expect FAIL / hang / TSAN error)** — the `connect_printer` detached thread may outlive `*this` and call `on_connected`/`deliver_to_sink`. + +- [ ] **Step 3: Implement** + +- The detached connect thread already guards every callback with the generation check. Add: `~OrcaPrinterAgent()` bumps `m_lan_generation` first, then: + ```cpp + OrcaPrinterAgent::~OrcaPrinterAgent() { + ++m_lan_generation; + std::unique_ptr lan; + { std::lock_guard l(state_mutex); lan = std::move(lan_mqtt_connection); } + if (lan) lan->stop(); // joins the OrcaMqttConnection worker + if (auto* cloud = get_orca_cloud_agent()) cloud->teardown_selected_printer_mqtt(); + } + ``` +- The remaining race is the *connect* `std::thread(...).detach()` still running `conn->start()` on a `conn` that `lan->stop()` then destroys. Fix: hold the connect thread as a member `std::thread m_lan_connect_thread;` (not detached) and `join()` it in the dtor **before** moving `lan_mqtt_connection`. Update Task 11 & Task 14 to assign `m_lan_connect_thread = std::thread(...)` (join any prior one first). + +- [ ] **Step 4: Verify green** — run under sanitizers if the build has them: `ctest --test-dir build -R OrcaPrinterAgent --output-on-failure` + +--- + +## Task 18: full build, full test run, manual smoke + +**Files:** +- Modify: none (verification only) + +- [ ] **Step 1: Full build** + +```bash +cmake --build build --config RelWithDebInfo --target all -j +``` +Expected: success on Linux. (CI covers Windows/macOS.) + +- [ ] **Step 2: Full unit + integration suite** + +```bash +ctest --test-dir build --output-on-failure +./build/tests/slic3rutils/slic3rutils_tests "[.integration]" +``` +Expected: no regressions in `test_printer_agent`, `test_qidi_printer_agent`, `test_plugin_*`; all `[OrcaMqtt]` / `[OrcaPrinterAgent]` green. + +- [ ] **Step 3: Manual smoke — LAN** + +Run OrcaSlicer against a real OrcaSonar hub: it appears via discovery; select it; Device tab populates (version, temps); set nozzle temperature; confirm the result echo in the log (`OrcaMqtt` / `on_message` lines). Record a log excerpt or screenshot. + +- [ ] **Step 4: Manual smoke — cloud** + +Against OrcaCloud staging with a paired printer (requires CH-1 deployed there): select the printer; same checks. If CH-1 is not yet deployed, record that this step is blocked on the §5.2 hand-off and verify only that the socket opens and status is received (commands will 4403 until CH-1 ships). + +- [ ] **Step 5: Record results** + +Append a short "Verification" section to the spec doc: build result, `ctest` summary line, and the two smoke outcomes (or the cloud-blocked note). + +--- + +## Self-Review + +**Spec coverage** + +| Spec section | Task(s) | +|---|---| +| §3.1 canonical core (topics, envelope) | T4 (topics), T3 (CONNECT), payload builders T12 | +| §3.2 command send = PUBLISH both transports | T6, T16 | +| §3.2 `sequence_id` band 20000–29999 | T12 (`seq`), asserted in T12 test | +| §3.2 capability via `info.get_capabilities` | T12 (`build_get_capabilities`, in the sequence) | +| §3.2 status gating (`pushing.start`/`stop`) | T12 (start), T14 (stop on deselect) | +| §3.2 exact-topic subscribe, no wildcard | T4/T5 (`report_topic(dev_id)`, single-id `subscribe`) | +| §3.2 auth: bearer or CONNECT creds, precedence | T3 (flags), T5/T7 (bearer header vs creds), T7 | +| §3.2 QoS ≤1, tolerate SUBACK QoS 0 | T4 (`make_subscribe_packet` qos arg), T8 mock grants 0, T9 round-trip | +| §3.2 keepalive from Config | T3, T5 | +| §4.1 `OrcaMqttConnection` own TU, Config, API | T1, T2, T5 | +| §4.1 reuse salvage pieces | T2/T3/T5 (parse_endpoint, connect packet, last_connack_rc) | +| §4.2 outbound collapse | T16 | +| §4.2 remove `read_loop`, per-connection MessageHandler | T10 | +| §4.2 `get_appropriate_mqtt_connection` kept | T16 (null-guarded) | +| §4.2 lifecycle table (connect/select/deselect) | T11, T13, T14 | +| §4.2 identical post-connect sequence | T12 | +| §4.2 generation guard | T11 (capture), T13 (test), T17 (dtor) | +| §4.2 CONNACK rc 4/5 terminal | T5 | +| §4.2 dtor stops both, no detached threads on `*this` | T17 | +| §4.3 one socket, per-printer cloud endpoint | T14 (`wss://.../printers/{id}/mqtt`) | +| §4.3 remove aggregate socket, health-only `is_server_connected` | T15 | +| §6.1 unit tests | T2–T6, T12 | +| §6.2 parametrized LAN/cloud integration | T9 | +| §6.2 reconnect re-sends subs + `pushing.start` | *gap → see below* | +| §6.2 auth-reject no retry storm | T5 (rc 4/5 terminal); add assertion in T5 | +| §6.5 gates: full build, no regressions, smoke | T18 | + +**Gaps found & fixed inline:** +- §6.2 "reconnect re-sends subscriptions and re-issues `pushing.start`" had no task. **Added to Task 9 Step 3**: extend the round-trip test with a `broker.drop_client()` call, assert the client reconnects (`connect_count() == 2`), that the report subscription is re-established (a second `push_report` is delivered), and that the agent re-runs `on_connected` (observable via a second `pushall` in `received_requests()`). Requires `MockBroker::drop_client()` — fold into Task 8. +- §6.2 "auth reject → terminal, no retry storm" — **added assertion to Task 5 Step 1 test**: point `Config.username/password` at a mock that CONNACKs `0x05`; assert `last_connack_rc() == 5` and `is_running() == false` within 1 s (needs `MockBroker` ctor flag `refuse_auth` — fold into Task 8). + +**Placeholder scan:** the Task 3 `// TODO(Task 6)` marker is intentional and explicitly removed in Task 5 Step 3 (corrected: the marker is added in T3, removed in T5 — not T6). No other TODO/TBD. All code steps carry real code. + +**Type consistency:** +- `OrcaMqttConnection::start(const Config&, MessageHandler, StateHandler)` — defined T5, used T7/T9/T11/T14. ✓ +- `subscribe(const std::string&)` / `send_request(const std::string&, const std::string&)` — defined T5/T6, used T9/T12/T16. ✓ +- `on_connected(const std::string&, OrcaMqttConnection*, uint64_t)` — decl T11 interfaces, defined T12, called T11/T14. ✓ +- `emit_connect_sequence` / `run_connect_sequence_for_test` — introduced T12, only used by T12's test. ✓ +- `deliver_to_sink` — T10, used T11/T13. ✓ +- `route_send` — T16 only. ✓ +- `configure_selected_printer_mqtt` / `teardown_selected_printer_mqtt` / `selected_printer_mqtt_url` / `deliver_cloud_message` — T14/T15, used T14/T15/T17. ✓ +- `MockBroker` API grows across T8 (`ws_url`, `push_report`, `received_requests`, `connect_count`), T16 (`host_port`), self-review (`drop_client`, `refuse_auth` ctor flag). All folded into Task 8's file; later tasks only call them. ✓ +- `make_connect_packet` 4-arg — T3, caller updated T5. Old 0-arg removed T3. ✓ +- `make_topic_packet` removed in T5; no later reference. ✓ diff --git a/docs/superpowers/specs/2026-09-03-orca-mqtt-contract-consolidation-design.md b/docs/superpowers/specs/2026-09-03-orca-mqtt-contract-consolidation-design.md new file mode 100644 index 0000000000..b4e45a30c5 --- /dev/null +++ b/docs/superpowers/specs/2026-09-03-orca-mqtt-contract-consolidation-design.md @@ -0,0 +1,388 @@ +# OrcaCloud / OrcaSonar MQTT contract consolidation — design + +**Date:** 2026-09-03 +**Status:** Approved design, pre-implementation +**Repos touched by this task:** OrcaSlicer (implementation), plus a written conformance +checklist handed off to OrcaCloud and OrcaSonar (not edited here). + +--- + +## 1. Context & problem + +`OrcaPrinterAgent` talks to two backends that are meant to expose the *same* +printer API: + +- **OrcaCloud** — cloud relay. Cloudflare Durable Object "broker-lite" with a + hand-rolled MQTT 3.1.1 codec (`apps/gateway/src/lib/mqtt-codec.ts`, + `apps/gateway/src/durable-objects/printer-shard.ts`). +- **OrcaSonar** — LAN hub. Real mochi MQTT broker fronted by a `/mqtt` + WebSocket→TCP proxy (`internal/broker/broker.go`, `internal/httpws/server.go`). + +A survey of all three codebases found the *payload and topic layer already ~90 % +identical* (Bambu-dialect JSON, `device//request` + `device//report`, +shared command set, numeric-string `sequence_id`), but the *transport mechanics +diverge*: + +| Dimension | OrcaSonar LAN | OrcaCloud | +|---|---|---| +| Command send | client **PUBLISHes** `device//request` | viewers **receive-only**; commands via `POST /api/v1/printers/:id/commands` | +| Auth | MQTT CONNECT username/password | Bearer token on the HTTP upgrade | +| Endpoint | `ws://:8280/mqtt` | `wss:///api/v1/printers/{id}/mqtt` (and an aggregate `/printers/mqtt`) | +| Socket cardinality | 1 printer : 1 socket | aggregate socket, N printers, dynamic grant | +| Status stream | always on | demand-gated (`pushing.start` / `pushing.stop`) | +| Capability | retained `device//capability` | `info.get_capabilities` command, no retained | +| `sequence_id` bands | unenforced | enforced (OrcaSlicer must use 20000–29999) | +| Spec of record | `spec/protocol/orca_printer_comm_spec.md` (OPCP v1.1.0 + JSON schemas) | `doc/gateway/printer_mqtt_facade_2026-08-07.md` + dialect code | + +Both sides already track the drift: OrcaSonar `API.md:244-301` diffs itself against +OrcaCloud's dialect code; OrcaCloud's facade doc has an explicit "OrcaSonar +adoption" section. + +The client today mirrors the divergence — `send_message` (cloud) has historically +gone via REST while `send_message_to_printer` (LAN) publishes over MQTT — so the +`IPrinterAgent` split is a transport split, not just a routing switch. + +**Goal:** one contract (OPCP v1.2.0) that both backends conform to, and an +OrcaSlicer client where LAN and cloud run *identical code* differing only by a +`Config` value. + +--- + +## 2. Decisions + +| # | Decision | +|---|---| +| D1 | **Contract merge + thin client shim.** Merge to a canonical spec; fix payload-level divergences server-side; the client keeps only a `Config`-sized shim for endpoint/auth/keepalive. | +| D2 | **This task ships:** the OPCP v1.2.0 spec text (authored here), the OrcaSlicer client implementation, and an enumerated conformance checklist for OrcaCloud & OrcaSonar. The other two repos are **not** edited in this task. | +| D3 | **Command transport is MQTT PUBLISH `device//request` on both cloud and LAN.** OrcaCloud gains client PUBLISH via change CH-1. | +| D4 | **Client structure: one `OrcaMqttConnection` class, two `Config`-only instances, routed by `OrcaPrinterAgent`.** The cloud instance uses the **1:1 per-printer** endpoint `/api/v1/printers/{id}/mqtt`, exactly like LAN. | +| D5 | **One socket per transport, selected printer only.** The pre-existing aggregate cloud MQTT socket is removed; unselected printers show announce/REST status on both transports (see §4.3). | +| D6 | **No back-compat.** OPCP v1.2.0 replaces v1.1.0 outright. REST `/commands` is not a required alias. No `/tunnel` bridge concerns. | +| D7 | **OrcaSonar's OPCP is the source of truth.** The contract is OrcaSonar's spec (with the additions in §5.1, most of which absorb behaviours OrcaCloud already ships); OrcaCloud conforms to it. | + +--- + +## 3. OPCP v1.2.0 — the unified contract + +### 3.1 Canonical core (already aligned; ratified here) + +- **Transport:** MQTT 3.1.1 over WebSocket, binary frames, subprotocol `mqtt`, + `cleanSession = 1`. +- **Topics:** `device//request` (client → device), + `device//report` (device → client). `` is the identifier the + client is already provisioned with — the cloud printer UUID on the cloud + binding; the mDNS-advertised `device_id` (TXT `device_id=`, SSDP UDN + `uuid:`) on the LAN binding. The client never learns the id from + message traffic. +- **Envelope:** exactly one top-level namespace key ∈ + `{pushing, info, print, system, camera, xcam, upgrade, files, event}`, plus + `command` and `sequence_id` (decimal string, `^[0-9]+$`). +- **Result echo (single-phase):** same namespace + command + `sequence_id`, plus + `result ∈ {success, fail}`, `reason` on `fail`, optional `errno`. No separate + dialect-layer transport ack. +- **Status:** `.push_status` on the report topic; `msg` 0 = full, 1 = diff. +- **`info.get_version` reply:** `module[]` entries with `name / sw_ver / hw_ver / sn`. +- **Optional extended header** (adopt OrcaSonar spec §3.1 verbatim): + `protocol_version`, `schema_version`, `sent_at_utc_ms`, + `source{role, agent_id, transport}`. Receivers ignore unknown top-level keys. + +### 3.2 Divergence resolutions + +| Divergence | Resolution | Owner | +|---|---|---| +| Command send: REST vs PUBLISH | Client PUBLISHes `device//request` on both transports. | OrcaCloud CH-1 | +| `sequence_id` bands | Normative registry: OrcaSlicer **20000–29999**, dashboard 50000–59999, gateway-minted 70000–79999, status-mirror 90000+. Correlation is producer-scoped (match echoes against your own outstanding ids). | OPCP SPEC-2; client | +| Capability discovery | `info.get_capabilities` command is the REQUIRED path (returns the capability manifest). Retained `device//capability` is an OPTIONAL LAN optimization; clients MUST NOT depend on it. | client; OrcaSonar SN-2 | +| Status gating | Client issues `pushing.start` immediately after SUBSCRIBE and `pushing.stop` on deselect, on both transports. Always-streaming implementations accept both as `result:"success"` no-ops. | client; OrcaSonar SN-1; OrcaCloud CH-4 | +| Topic `` | LAN topic id == advertised `device_id`, so the client subscribes the exact topic — **no `device/+/report` wildcard**. | OrcaSonar SN-3 | +| `system.set_settings` | Schema defined in OPCP (SPEC-5): curated toggles — camera, discovery, moonraker_compat. Unknown setting → `result:"fail"`, `errno = UNSUPPORTED_SETTING`. Not client-driven in this task. | OPCP SPEC-5; OrcaSonar SN-4 | +| Auth | Two mechanisms, both normative: (a) bearer token in the `Authorization` header of the WS upgrade (cloud); (b) MQTT CONNECT username/password (LAN local broker). The client `Config` carries whichever applies. | documented only | +| QoS | Client requests SUBSCRIBE QoS 1 and PUBLISH QoS 0–1; MUST tolerate a SUBACK that grants QoS 0. | client | +| Keepalive | `Config.keepalive_seconds` (default 60 LAN / 300 cloud). Binary PINGREQ. | client | +| Endpoint | LAN `ws://:8280/mqtt`; cloud `wss:///api/v1/printers/{id}/mqtt`. | `Config` | + +Net effect: everything payload- and topic-level is identical on both transports; +the only per-transport variation is `Config` (URL + auth + keepalive) plus one +connect-time `pushing.start`. + +--- + +## 4. OrcaSlicer client architecture + +### 4.1 `OrcaMqttConnection` — the single transport class + +Lives in its own translation unit (extracted from `OrcaCloudServiceAgent.cpp`, +where an earlier `OrcaCloudMqttConnection` / renamed `OrcaMqttConnection` still +sits). No LAN/cloud conditionals in the body. + +```cpp +struct Config { + std::string url; // ws://host:8280/mqtt | wss://api/.../printers/{id}/mqtt + bool use_tls = false; // derived from the URL scheme + TokenProvider bearer_provider; // cloud: Authorization: Bearer on the WS upgrade + std::string username, password; // LAN: MQTT CONNECT credentials + // Precedence: if bearer_provider is set it is used for the WS upgrade and the + // CONNECT username/password are omitted; otherwise CONNECT carries the creds. + std::string client_id; // stable for the process run, unique per instance + int keepalive_seconds = 60; +}; +``` + +API (used identically by both instances): + +| Method | Behaviour | +|---|---| +| `bool start(Config, MessageHandler on_message, StateHandler on_state, CancellationHandler = {})` | spawns the worker thread; blocks (bounded, ~10 s) for the first CONNACK; returns the initial result | +| `void stop()` | idempotent; joins the worker | +| `bool send_request(const std::string& dev_id, const std::string& payload)` | PUBLISH `device//request` (QoS 0/1); thread-safe via the write mutex; false when there is no CONNACKed session. **The uniform outbound seam.** | +| `bool subscribe(const std::string& dev_id)` / `unsubscribe(...)` | SUBSCRIBE / UNSUBSCRIBE `device//report`; persistent set re-sent after every CONNACK | +| `bool is_connected() const` / `int last_connack_rc() const` | CONNACK state; rc 0 = accepted, 1..5 = MQTT refusal, -1 = no CONNACK this attempt | +| `MessageHandler(dev_id, payload)` | inbound: strips the `device//report` topic, hands up raw JSON, on the worker thread | + +All protocol logic (topic construction, MQTT framing, reconnect/backoff, write +serialization, QoS-downgrade tolerance, PINGREQ) is internal. The only internal +branches are `use_tls` (TLS handshake + SNI) and bearer-vs-CONNECT-creds during +the handshake. + +Reusable pieces from `salvage/orcasonar-lan-agent-2026-09-03` (the generalized +`Config`, `ws://` support in `parse_endpoint`, `last_connack_rc`, auth-reject +handling, static frame builders + their tests) are lifted in rather than +re-derived. + +### 4.2 `OrcaPrinterAgent` — routing + lifecycle + +- `std::unique_ptr lan_mqtt_connection` — owned here; + lifecycle = LAN printer selection. +- Cloud per-printer `OrcaMqttConnection` — owned by `OrcaCloudServiceAgent`, + reached via `get_orca_cloud_agent()->get_mqtt_connection()`. +- `OrcaMqttConnection* get_appropriate_mqtt_connection(bool is_lan)` — the one + place that encodes the ownership split. Kept even though callers know their + `is_lan` bit; it is the seam and it is tiny. Where a caller has only a + `dev_id`, resolve via `DeviceManager::get_my_machine(dev_id)->is_lan_mode_printer()`. +- `enum CurrentConn { NONE, CLOUD, LAN } m_current_connection` — a label/gate, + **not** a socket selector. + +**Outbound collapse.** Both methods reduce to the same body: + +```cpp +int OrcaPrinterAgent::send_message(dev_id, json, qos, flag) // is_lan = false +int OrcaPrinterAgent::send_message_to_printer(dev_id, json, qos, flag) // is_lan = true +// -> +auto* conn = get_appropriate_mqtt_connection(is_lan); +if (!conn || dev_id.empty()) return BAMBU_NETWORK_ERR_INVALID_HANDLE; +return conn->send_request(dev_id, json) ? BAMBU_NETWORK_SUCCESS + : BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED; +``` + +The `command_*` helpers keep branching only to build the payload, then call one +or the other. + +**Inbound: remove `read_loop()`.** Each `OrcaMqttConnection` already delivers on +its worker thread via `MessageHandler`. The agent registers one handler per +connection that funnels to `on_message_fn`, marshalled onto the UI thread via +`queue_on_main_fn`. This is already the pattern `set_cloud_agent()` wires for the +cloud side (`set_printer_status_callback`); the LAN side gets the symmetric +wiring when `lan_mqtt_connection` is created. A single reader that "picks the +current connection" reintroduces a one-transport-at-a-time asymmetry and a +busy-spin; the per-connection callback is already uniform. + +**Lifecycle — the post-connect sequence is byte-identical on both transports:** + +| Trigger | LAN | Cloud | +|---|---|---| +| select | `connect_printer(dev_id, dev_ip, user, code, ssl)` | `set_user_selected_machine(dev_id)` | +| agent builds `Config` | `ws://:8280/mqtt` + username/password | `wss:///api/v1/printers/{dev_id}/mqtt` + `bearer_provider` | +| then — shared `on_connected(dev_id, conn)` | `subscribe(dev_id)` → `send_request(dev_id, pushing.start)` → `send_request(dev_id, pushall)` → `send_request(dev_id, info.get_version)` → `send_request(dev_id, info.get_capabilities)` | *the same five calls* | +| deselect / change | `disconnect_printer()` → `stop()` + reset | `send_request(prev, pushing.stop)` → `unsubscribe(prev)` → `stop()` / retarget | + +**Threading & lifetime:** + +- The blocking `start()` runs on a short-lived thread so the UI is never blocked + (mirrors the salvaged WIP). +- A generation counter (atomic, captured by value into every handler lambda) + makes a superseded connection's late `MessageHandler` / `StateHandler` calls + no-ops. +- `~OrcaPrinterAgent` calls `stop()` on both connections (joining their workers) + before any member is destroyed. No detached threads may touch `*this`. +- CONNACK rc 4/5 (bad credentials / not authorised) is terminal: report + `ConnectStatusFailed`, do not retry (a retry storm would flap + `ConnectStatusLost` → `set_selected_machine("")`). + +### 4.3 One socket per transport — the selected printer only + +The client opens exactly one MQTT socket at a time, for the **selected** printer, +identically on both transports: + +- LAN: `ws://:8280/mqtt` — opened on `connect_printer`, closed on + `disconnect_printer`. +- Cloud: `wss:///api/v1/printers/{dev_id}/mqtt` (the 1:1 per-printer + binding, D4) — opened on `set_user_selected_machine(dev_id)`, closed on + deselect. `OrcaCloudServiceAgent` owns the instance; `OrcaPrinterAgent` + drives it via `get_mqtt_connection()`. + +Unselected printers are never connected on either transport. They populate the +Device list from announce data alone — mDNS/SSDP `on_machine_alive` for LAN +hubs, the account REST list for cloud printers — exactly as unselected LAN hubs +already behave. + +**This removes the pre-existing aggregate cloud MQTT socket** +(`wss:///api/v1/printers/mqtt`, started today by +`OrcaCloudServiceAgent::connect_server()`). `is_server_connected()` falls back to +the REST health probe `connect_server()` already performs on the same 5 s +`refresh_connection()` tick. + +**Behaviour change (needs product sign-off, tracked as O2):** unselected cloud +printers in the Device list lose their live status feed and show last-known / +REST status. This is the price of LAN/cloud symmetry and matches how unselected +LAN hubs already appear. If live multi-printer status is later required it is an +`OrcaCloudServiceAgent` concern (its own aggregate consumer), and it must not add +a second `device//report` stream for the already-connected selected printer. + +--- + +## 5. Conformance checklist (hand-off) + +**Framing (D7):** the target state is "cloud and LAN expose an identical API", +and **OrcaSonar's OPCP spec is the source of truth**. Read this section as: + +- §5.1 — additions the OPCP spec (and therefore OrcaSonar's implementation) + needs. Small, and mostly formalising behaviours OrcaCloud already ships + (`pushing.start/stop`, `system.set_settings`, the `sequence_id` registry). +- §5.2 — OrcaCloud is the participant furthest from the contract (commands over + REST, viewer PUBLISH forbidden, aggregate-only socket). These changes make it + conform. +- §5.3 — OrcaSonar's own work: implement the §5.1 additions, plus one or two + guarantees to make explicit. + +### 5.1 OPCP spec additions → v1.2.0 (`OrcaSonar spec/protocol/orca_printer_comm_spec.md`) + +| ID | Change | +|---|---| +| SPEC-1 | Add a normative **Transports** section: the two bindings from §3.1 (LAN local broker; cloud gateway). Both MUST accept client PUBLISH to `device//request`. | +| SPEC-2 | Normative `sequence_id` band registry (§3.2); correlation is producer-scoped. | +| SPEC-3 | `pushing.start` / `pushing.stop` are normative commands — "begin / stop streaming `push_status` to this subscriber". Always-streaming implementations MUST still return `result:"success"` (no-op). | +| SPEC-4 | `info.get_capabilities` is the REQUIRED capability path; retained `device//capability` is OPTIONAL and non-load-bearing. | +| SPEC-5 | Define the `system.set_settings` schema (curated toggles: camera, discovery, moonraker_compat); unknown setting → `result:"fail"`, `errno = UNSUPPORTED_SETTING`. | +| SPEC-6 | Errno registry: enumerate values already in use plus `UNSUPPORTED_COMMAND`, `UNSUPPORTED_SETTING`, `NOT_AUTHORIZED`. Align semantics (not numeric values) with the client's `ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED` / `ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE`. | +| SPEC-7 | Promote the extended envelope header (§3.1 of the OrcaSonar spec) to OPTIONAL on every message; receivers ignore unknown top-level keys. | +| SPEC-8 | Topic `` MUST equal the id the client is provisioned with; no id discovery from traffic. | + +### 5.2 OrcaCloud — conform to OPCP (`~/repos/OrcaCloud/apps/gateway`) + +Assuming the OPCP contract (client PUBLISHes commands over a 1:1 MQTT-over-WS +socket, exactly as against OrcaSonar LAN), OrcaCloud must add: + +| ID | Change | Acceptance | +|---|---|---| +| **CH-1** | `mqtt-viewer` sessions MAY `PUBLISH` to `device/{id}/request` (today → close 4403 in `printer-shard.ts::handleMqttPublish`). Relay viewer → connector via the existing `awaitConnectorReply` / `deliverToConnector` path. `/report` stays connector-only (anti-forgery preserved). | e2e: a viewer publishes `print.pause` `sequence_id` 20001 → connector receives it on `device/{id}/request` → the result echo fans back to that viewer. | +| CH-2 | Move operator-role authorization from the REST `/commands` route (`routes/printer.ts`) into the shard publish handler. READ set — `pushing.pushall`, `info.get_version`, `info.get_capabilities`, `files.list`, `files.metadata` — allowed for viewer / live-token; every other command requires an operator+ session. | live-token viewer publishing `print.stop` → 4403; JWT operator → success. | +| CH-3 | Provide a **1:1 per-printer** WS binding `GET /api/v1/printers/{id}/mqtt` that behaves like OrcaSonar's `/mqtt` (one printer per socket; subscribe the exact `device/{id}/report`; no `X-Orca-Printer-Ids`). If #948 ("shard-only routing") removed this facade path, re-adding it is the change — the client does not use the aggregate `/printers/mqtt`. | client connects, subscribes, publishes a command, receives the echo, with no aggregate-grant header. | +| CH-4 | `pushing.start` / `pushing.stop` over the viewer publish path arm / disarm the demand-mirror for that printer (today armed only by dashboard page polls, #984). Behaviour matches OPCP SPEC-3: on always-streaming backends it is a success no-op; OrcaCloud's mirror is genuinely demand-gated so it acts. | after a viewer `pushing.start`, `push_status` frames arrive on that viewer's `report` subscription; after `pushing.stop` (last viewer gone) they cease. | +| CH-5 | `info.get_capabilities` returns an OPCP capability manifest matching OrcaSonar's `orca_capability_manifest` schema (`protocol_version` ≥ 1.2.0), whether the connector is Bambu- or Klipper-backed. | manifest validates against the OPCP schema. | + +### 5.3 OrcaSonar — implement the spec additions (`~/repos/OrcaSonar/internal`) + +OrcaSonar owns the contract, so its work is small: land the §5.1 spec text, make +the LAN dispatcher match it, and turn two already-true facts into guarantees. + +| ID | Change | Acceptance | +|---|---|---| +| **SN-1** | The LAN dispatcher accepts `pushing.start` / `pushing.stop` as `result:"success"` no-ops — the LAN broker always streams `push_status`, so these commands only need to be *recognised*, not fall through to "unsupported command". (Today they are handled only on the OrcaSonar→cloud connector path, not the LAN dispatcher.) `internal/protocol/dispatcher.go` specials + `internal/protocol/types.go` `SupportedCommands`. See O4: this is the "always-on, nothing to gate" reading, not a per-subscriber mirror. | golden: `{"pushing":{"command":"start","sequence_id":"20005"}}` → `{"pushing":{"command":"start","sequence_id":"20005","result":"success","errno":0}}`. | +| SN-2 | `info.get_capabilities` returns the manifest identically whether requested via command or read from the retained topic, and works before any `pushall`. | fresh connect → command → manifest with `protocol_version ≥ 1.2.0`. | +| SN-3 | Documented guarantee, plus a test, that topic `` == advertised `device_id` (mDNS TXT `device_id=`, SSDP UDN). Lets the client drop the `device/+/report` wildcard. Likely already true (`internal/discovery/discovery.go`, `internal/config/config.go`). | client subscribing `device//report` receives reports. | +| SN-4 | `system.set_settings` → implement per SPEC-5, or return `result:"fail"`, `errno = UNSUPPORTED_SETTING` (not a bare "unsupported command", not a parse error / close). | unknown setting key → structured errno, session stays open. | +| SN-5 | Capability manifest `protocol_version` / `schema_version` → `1.2.0`. | manifest validates against the v1.2.0 schema. | +| SN-6 | Conformance test only (no code change expected): broker accepts client-id `orcaslicer-lan--` and a QoS 1 SUBSCRIBE. | test passes. | + +### 5.4 OrcaSlicer client (this repo — implemented, not enumerated) + +Everything in §4, plus: uses `info.get_capabilities` (never the retained topic), +always issues `pushing.start` / `pushing.stop`, stays in `sequence_id` band +20000–29999, subscribes the exact report topic, tolerates a SUBACK that grants +QoS 0. + +--- + +## 6. Testing & verification + +### 6.1 Client unit tests (`tests/slic3rutils/`, Catch2) + +- `OrcaMqttConnection` static frame builders — CONNECT (bearer and + CONNECT-creds forms), SUBSCRIBE / UNSUBSCRIBE, PUBLISH, PINGREQ, + remaining-length codec, `parse_endpoint` for `ws://` and `wss://`. Byte-level + assertions. +- `send_request` produces topic `device//request` with a verbatim payload; + inbound strips `device//report` → `(id, payload)`. +- `Config` selects the handshake path (auth mode; `use_tls` from scheme). +- `command_*` payload builders match OPCP shapes (string `sequence_id`, band + 20000–29999, single namespace key). +- The post-connect sequence emits exactly + `subscribe → pushing.start → pushall → info.get_version → info.get_capabilities`, + in that order. +- Generation guard: a superseded connection's late handler calls are no-ops. +- SUBACK granting QoS 0 when 1 was requested → still connected, messages still + delivered. + +### 6.2 Client integration (in-process MQTT-over-WS mock) + +- **One parametrized test, two fixtures (LAN `Config` / cloud `Config`):** + connect → CONNACK → subscribe → publish command → mock emits the result echo → + assert `on_message_fn` fires with it. Identical assertions for both fixtures — + this is the "exactly the same" proof. +- Reconnect: mock drops the socket → worker backs off → reconnects → + subscriptions re-sent → `pushing.start` re-issued. +- Auth reject: CONNACK rc 4/5 → terminal `ConnectStatusFailed`, no retry storm. + +### 6.3 Cross-repo conformance (run in those repos' CI, from §5 acceptance rows) + +- OrcaCloud: extend `tests/e2e/lane-b-printers/printer_mqtt.e2e.test.ts` for + CH-1 / CH-2 / CH-3 / CH-4 / CH-5 (each row's acceptance criterion in §5.2). +- OrcaSonar: golden JSONL fixtures for SN-1 / SN-2 / SN-4. + +### 6.4 Manual smoke (record a log / screenshot for each) + +RelWithDebInfo build → + +- (a) real OrcaSonar hub on the LAN: discover, connect, Device tab populates, + set nozzle temperature, observe the result echo; +- (b) OrcaCloud staging with a paired printer: select, same checks. + +Both exercised through the *same* `OrcaMqttConnection` code path. + +### 6.5 Gates before "done" + +- New unit + integration tests green (ctest output as evidence). +- No regression in the existing `tests/slic3rutils` suites (printer-agent, + plugin, qidi). +- LAN and cloud smoke each confirmed with a log/screenshot. +- One `cmake --build build` at the end. + +--- + +## 7. Out of scope + +- Editing OrcaCloud or OrcaSonar in this task (the checklist in §5 is the + hand-off; those land as separate PRs in their own repos). +- A live multi-printer status feed for the Device list on cloud (would be its + own `OrcaCloudServiceAgent` aggregate consumer — see §4.3 / O2). The printer + agent connects the selected printer only. +- Reusing OrcaCloud's aggregate `/printers/mqtt` for the client (option B from + brainstorming — rejected; it forces aggregate-grant semantics into + `OrcaMqttConnection` that the LAN 1:1 case never needs). +- An `IPrinterTransport` abstraction above MQTT (option C — YAGNI while MQTT is + the only transport). +- Camera streaming, filesystem / file transfer, filament sync, AMS mapping. +- Back-compat: the legacy `/tunnel` envelope plane, retaining REST `/commands` + as a required alias, dual-schema acceptance on OrcaSonar. + +--- + +## 8. Open items, risks & resolved questions + +| # | Item | +|---|---| +| O1 | **Does OrcaCloud's 1:1 `/api/v1/printers/{id}/mqtt` still exist post-#948?** ("shard-only routing" made routing shard-backed.) Not a client fork any more — per CH-3 the client uses only the 1:1 endpoint, so if the facade path was removed, re-adding it *is* the OrcaCloud change. Just needs confirmation with the OrcaCloud team of whether CH-3 is "keep" or "re-add". | +| O2 | **Behaviour change: unselected cloud printers lose live status** (§4.3 — consequence of dropping the aggregate socket for LAN/cloud symmetry). They show last-known / REST status, matching unselected LAN hubs. Needs product sign-off before implementation. | +| O3 | **CONNECT-creds vs bearer through a fronting proxy.** If a deployment puts `wss://` in front of OrcaSonar, both auth inputs could be present. Precedence is fixed in §4.1 (`bearer_provider` set ⇒ bearer, CONNECT creds omitted); flagged only so the plan makes it a tested branch. | +| O4 | **Resolved.** `pushing.start` / `pushing.stop` mean "begin / stop streaming `push_status` to me". On OrcaCloud the mirror is genuinely demand-gated so the commands act; on OrcaSonar LAN the broker always streams, so they are recognised-and-succeed no-ops (SN-1). Not the "MQTT subscription granularity" reading — the client still SUBSCRIBEs `device//report` explicitly on both. | +| O5 | **`sequence_id` band collisions.** The client must never emit outside 20000–29999, including for any gateway-minted flow it triggers (print jobs). Audit every `sequence_id` source in `OrcaPrinterAgent`. | diff --git a/src/slic3r/CMakeLists.txt b/src/slic3r/CMakeLists.txt index 8308161a7b..4bb02ee659 100644 --- a/src/slic3r/CMakeLists.txt +++ b/src/slic3r/CMakeLists.txt @@ -725,6 +725,8 @@ set(SLIC3R_GUI_SOURCES Utils/IPrinterAgent.hpp Utils/OrcaCloudServiceAgent.cpp Utils/OrcaCloudServiceAgent.hpp + Utils/OrcaMqttConnection.cpp + Utils/OrcaMqttConnection.hpp Utils/OrcaPrinterAgent.cpp Utils/OrcaPrinterAgent.hpp Utils/QidiPrinterAgent.cpp diff --git a/src/slic3r/GUI/ConnectPrinter.cpp b/src/slic3r/GUI/ConnectPrinter.cpp index 3e78e7fe5c..8e3d58b413 100644 --- a/src/slic3r/GUI/ConnectPrinter.cpp +++ b/src/slic3r/GUI/ConnectPrinter.cpp @@ -35,7 +35,9 @@ ConnectPrinterDialog::ConnectPrinterDialog(wxWindow *parent, wxWindowID id, cons sizer_connect = new wxBoxSizer(wxHORIZONTAL); m_textCtrl_code = new TextInput(this, wxEmptyString); - m_textCtrl_code->GetTextCtrl()->SetMaxLength(10); + // OrcaSonar uses a 12-character base32 access code. Keep this field long + // enough for it while retaining the existing validation for LAN codes. + m_textCtrl_code->GetTextCtrl()->SetMaxLength(12); m_textCtrl_code->SetFont(Label::Body_14); m_textCtrl_code->SetCornerRadius(FromDIP(5)); m_textCtrl_code->SetSize(wxSize(FromDIP(330), FromDIP(40))); diff --git a/src/slic3r/GUI/DeviceManager.cpp b/src/slic3r/GUI/DeviceManager.cpp index 741ed788fc..6c155fe158 100644 --- a/src/slic3r/GUI/DeviceManager.cpp +++ b/src/slic3r/GUI/DeviceManager.cpp @@ -3046,6 +3046,13 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_ } } catch (...) {} + try { + if (j.contains("info")) + parse_new_info2(j["info"]); + } catch (...) { + BOOST_LOG_TRIVIAL(error) << "parse_json: failed to parse OrcaSonar capability info"; + } + try { if (auto ptr = m_fila_system->GetAmsFirmwareSwitch().lock()) { ptr->ParseFirmwareSwitch(j); @@ -5432,6 +5439,86 @@ void MachineObject::parse_new_info(json print) } } +void MachineObject::parse_new_info2(const json& info) +{ + if (!info.is_object() || info.value("command", "") != "get_capabilities") + return; + + const auto capabilities_it = info.find("capabilities"); + if (capabilities_it == info.end() || !capabilities_it->is_object()) + return; + const auto flags_it = capabilities_it->find("flags"); + if (flags_it == capabilities_it->end() || !flags_it->is_object()) + return; + + const json& flags = *flags_it; + BOOST_LOG_TRIVIAL(info) << "parse_new_info2: OrcaSonar capability flags=" << flags.dump(); + + auto parse_bool = [&flags](const char* name, bool& target) { + const auto it = flags.find(name); + if (it != flags.end() && it->is_boolean()) + target = it->get(); + }; + + parse_bool("support_send_to_sd", is_support_send_to_sdcard); + parse_bool("support_filament_backup", is_support_filament_backup); + parse_bool("support_update_remain", is_support_update_remain); + parse_bool("support_auto_recovery_step_loss", is_support_auto_recovery_step_loss); + parse_bool("support_ams_humidity", is_support_ams_humidity); + parse_bool("support_prompt_sound", is_support_prompt_sound); + parse_bool("support_filament_tangle_detect", is_support_filament_tangle_detect); + parse_bool("support_1080dpi", is_support_1080dpi); + parse_bool("support_cloud_print_only", is_support_cloud_print_only); + parse_bool("support_command_ams_switch", is_support_command_ams_switch); + parse_bool("support_mqtt_alive", is_support_mqtt_alive); + parse_bool("support_motor_noise_cali", is_support_motor_noise_cali); + parse_bool("support_timelapse", is_support_timelapse); + parse_bool("support_user_preset", is_support_user_preset); + parse_bool("support_refresh_nozzle", is_support_refresh_nozzle); + parse_bool("support_flow_calibration", is_support_flow_calibration); + parse_bool("support_build_plate_marker_detect", is_support_build_plate_marker_detect); + parse_bool("support_nozzle_blob_detect", is_support_nozzle_blob_detection); + + if (!m_manager->IsMultiMachineEnabled() && !is_support_agora) + parse_bool("support_tunnel_mqtt", is_support_tunnel_mqtt); + + const auto bed_leveling_it = flags.find("support_bed_leveling"); + if (bed_leveling_it != flags.end() && bed_leveling_it->is_number_integer()) + is_support_bed_leveling = bed_leveling_it->get(); + + auto copy_bool = [&flags](json& target, const char* name) { + const auto it = flags.find(name); + if (it != flags.end() && it->is_boolean()) + target[name] = *it; + }; + + // The capability manifest uses an object for this range, while the legacy + // DeviceCore parser consumes a boolean plus a two-element range array. + json device_config; + copy_bool(device_config, "support_chamber"); + copy_bool(device_config, "support_first_layer_inspect"); + copy_bool(device_config, "support_ai_monitoring"); + copy_bool(device_config, "support_lidar_calibration"); + const auto chamber_edit_it = flags.find("support_chamber_temp_edit"); + if (chamber_edit_it != flags.end() && chamber_edit_it->is_boolean()) { + device_config["support_chamber_temp_edit"] = *chamber_edit_it; + } else if (chamber_edit_it != flags.end() && chamber_edit_it->is_object()) { + const auto min_it = chamber_edit_it->find("min"); + const auto max_it = chamber_edit_it->find("max"); + if (min_it != chamber_edit_it->end() && max_it != chamber_edit_it->end() && min_it->is_number() && max_it->is_number()) { + device_config["support_chamber_temp_edit"] = true; + device_config["support_chamber_temp_edit_range"] = {*min_it, *max_it}; + } + } + + json fan_config; + copy_bool(fan_config, "support_aux_fan"); + copy_bool(fan_config, "support_chamber_fan"); + + m_config->ParseConfig(device_config); + m_fan->ParseV2_0(fan_config); +} + static bool is_hex_digit(char c) { return std::isxdigit(static_cast(c)) != 0; } diff --git a/src/slic3r/GUI/DeviceManager.hpp b/src/slic3r/GUI/DeviceManager.hpp index 8788c2288d..6e4e7d7183 100644 --- a/src/slic3r/GUI/DeviceManager.hpp +++ b/src/slic3r/GUI/DeviceManager.hpp @@ -947,6 +947,7 @@ public: /*for parse new info*/ bool check_enable_np(const json& print) const; void parse_new_info(json print); + void parse_new_info2(const json& info); int get_flag_bits(std::string str, int start, int count = 1) const; uint32_t get_flag_bits_no_border(std::string str, int start_idx, int count = 1) const; int get_flag_bits(int num, int start, int count = 1, int base = 10) const; diff --git a/src/slic3r/GUI/GUI_App.cpp b/src/slic3r/GUI/GUI_App.cpp index 4165b071cb..3319d177f5 100644 --- a/src/slic3r/GUI/GUI_App.cpp +++ b/src/slic3r/GUI/GUI_App.cpp @@ -3996,6 +3996,7 @@ void GUI_App::switch_printer_agent() std::string log_dir = data_dir(); std::string cloud_agent_id = agent_info.id == BBL_PRINTER_AGENT_ID ? BBL_CLOUD_PROVIDER : ORCA_CLOUD_PROVIDER; + BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << agent_info.id; std::shared_ptr cloud_agent = m_agent->get_cloud_agent(cloud_agent_id); // Create new printer agent via registry diff --git a/src/slic3r/GUI/MediaPlayCtrl.cpp b/src/slic3r/GUI/MediaPlayCtrl.cpp index 77a183f090..49259bdf5b 100644 --- a/src/slic3r/GUI/MediaPlayCtrl.cpp +++ b/src/slic3r/GUI/MediaPlayCtrl.cpp @@ -290,7 +290,6 @@ void refresh_agora_url(char const* device, char const* dev_ver, char const* chan void MediaPlayCtrl::Play() { switch (current_mode()) { - case CameraStreamMode::http: case CameraStreamMode::http_snapshot: if (!m_next_retry.IsValid() || wxDateTime::Now() < m_next_retry) return; @@ -300,14 +299,13 @@ void MediaPlayCtrl::Play() Stop(_L("Please confirm if the printer is connected.")); return; } - if (auto agent = wxGetApp().getAgent()) - agent->command_start_camera(m_machine); m_button_play->SetIcon("media_stop"); m_web_ctrl->Load(wxURI(m_url), current_mode()); m_web_ctrl->Play(); m_last_state = wxMEDIASTATE_PLAYING; SetStatus(_L("Playing..."), false); return; + case CameraStreamMode::http: case CameraStreamMode::rtsp: if (m_next_retry.IsValid() && wxDateTime::Now() < m_next_retry) return; @@ -769,7 +767,8 @@ void MediaPlayCtrl::load() { m_last_state = MEDIASTATE_LOADING; SetStatus(_L("Loading...")); - if (current_mode() != CameraStreamMode::rtsp) { + const auto mode = current_mode(); + if (mode != CameraStreamMode::rtsp && mode != CameraStreamMode::http) { std::string file_h264 = data_dir() + "/video.h264"; std::string file_info = data_dir() + "/video.info"; BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl dump video to " << file_h264; diff --git a/src/slic3r/GUI/StatusPanel.cpp b/src/slic3r/GUI/StatusPanel.cpp index b00dee3dca..7099f3fea9 100644 --- a/src/slic3r/GUI/StatusPanel.cpp +++ b/src/slic3r/GUI/StatusPanel.cpp @@ -2308,8 +2308,8 @@ void StatusPanel::update_camera_state(MachineObject* obj) auto agent = wxGetApp().getAgent(); const auto camera_mode = agent ? agent->get_camera_stream_mode() : CameraStreamMode::none; - const bool has_printer_webcam = camera_mode == CameraStreamMode::http || camera_mode == CameraStreamMode::http_snapshot; - if (has_printer_webcam) { + const bool use_webview = camera_mode == CameraStreamMode::http_snapshot; + if (use_webview) { //m_camera_switch_button->Hide(); if (!m_custom_camera_view->IsShown()) { // why: do not reload the WebView URL per tick, or redirects can cause a reload loop. @@ -2317,10 +2317,14 @@ void StatusPanel::update_camera_state(MachineObject* obj) m_custom_camera_view->Show(); m_media_ctrl->Hide(); } - } else if (m_custom_camera_view->IsShown()) { - m_custom_camera_view->Hide(); + } else { + if (m_custom_camera_view->IsShown()) { + m_custom_camera_view->Hide(); + // Stop the snapshot WebView before switching to native playback + // or leaving the camera mode. + m_media_play_ctrl->StopWebStream(); + } m_media_ctrl->Show(); - m_media_play_ctrl->StopWebStream(); } //sdcard @@ -2354,7 +2358,7 @@ void StatusPanel::update_camera_state(MachineObject* obj) m_last_recording = obj->is_recording() ? 1 : 0; } - if (has_printer_webcam) { + if (use_webview) { if (m_bitmap_recording_img->IsShown()) { m_bitmap_recording_img->Hide(); m_panel_monitoring_title->Layout(); @@ -2417,7 +2421,7 @@ void StatusPanel::update_camera_state(MachineObject* obj) m_camera_popup->update(show_vcamera); } - m_setting_button->Show(!has_printer_webcam); + m_setting_button->Show(!use_webview); } StatusPanel::StatusPanel(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, long style, const wxString &name) diff --git a/src/slic3r/GUI/WebMediaController.cpp b/src/slic3r/GUI/WebMediaController.cpp index 13d820c98f..378d83b650 100644 --- a/src/slic3r/GUI/WebMediaController.cpp +++ b/src/slic3r/GUI/WebMediaController.cpp @@ -52,10 +52,13 @@ void WebMediaController::Play() "refreshCameraFrame();" "setInterval(refreshCameraFrame,200);" ""; + m_webview->SetPage(html, url); } else { - html += " src=\"" + url + "\">"; + // Load MJPEG streams as the top-level document. Some embedded WebView + // backends buffer a multipart stream when it is used as an resource, + // which introduces noticeable live-view latency. + m_webview->LoadURL(url); } - m_webview->SetPage(html, url); } void WebMediaController::Stop() diff --git a/src/slic3r/GUI/wxMediaCtrl3.cpp b/src/slic3r/GUI/wxMediaCtrl3.cpp index d0d53072d6..c4b114bb9b 100644 --- a/src/slic3r/GUI/wxMediaCtrl3.cpp +++ b/src/slic3r/GUI/wxMediaCtrl3.cpp @@ -188,14 +188,14 @@ void wxMediaCtrl3::bambu_log(void *ctx, int level, tchar const *msg2) BOOST_LOG_TRIVIAL(info) << msg.ToUTF8().data(); } -int wxMediaCtrl3::rtsp_interrupt_callback(void *opaque) +int wxMediaCtrl3::ffmpeg_interrupt_callback(void *opaque) { auto *ctrl = static_cast(opaque); std::lock_guard lock(ctrl->m_mutex); return ctrl->m_url != ctrl->m_active_url; } -int wxMediaCtrl3::PlayRtsp(std::shared_ptr const &url, std::unique_lock &lock) +int wxMediaCtrl3::PlayFfmpeg(std::shared_ptr const &url, std::unique_lock &lock) { if (avformat_network_init() < 0) return 2; @@ -206,7 +206,9 @@ int wxMediaCtrl3::PlayRtsp(std::shared_ptr const &url, std::unique_lockinterrupt_callback = {&wxMediaCtrl3::rtsp_interrupt_callback, this}; + format_context->interrupt_callback = {&wxMediaCtrl3::ffmpeg_interrupt_callback, this}; + format_context->flags |= AVFMT_FLAG_NOBUFFER; + format_context->max_delay = 0; m_active_url = url; auto finish = [&](int error) { @@ -219,8 +221,20 @@ int wxMediaCtrl3::PlayRtsp(std::shared_ptr const &url, std::unique_lockBuildURI().ToUTF8().data(); + const wxString scheme = url->GetScheme(); + const bool http_stream = scheme.CmpNoCase("http") == 0 || scheme.CmpNoCase("https") == 0; AVDictionary *options = nullptr; - av_dict_set(&options, "rtsp_transport", "tcp", 0); + if (http_stream) { + // This is a live multipart MJPEG stream. Keep FFmpeg from building a + // read-ahead buffer, otherwise the UI can display frames several + // seconds behind the camera. + av_dict_set(&options, "fflags", "nobuffer", 0); + av_dict_set(&options, "avioflags", "direct", 0); + av_dict_set(&options, "probesize", "32", 0); + av_dict_set(&options, "analyzeduration", "0", 0); + } else { + av_dict_set(&options, "rtsp_transport", "tcp", 0); + } lock.unlock(); int error = avformat_open_input(&format_context, uri.c_str(), nullptr, &options); av_dict_free(&options); @@ -278,7 +292,12 @@ int wxMediaCtrl3::PlayRtsp(std::shared_ptr const &url, std::unique_lockHasScheme()) break; const wxString scheme = url->GetScheme(); - const bool generic_rtsp = scheme.CmpNoCase("rtsp") == 0 || scheme.CmpNoCase("rtsps") == 0; + const bool generic_ffmpeg = scheme.CmpNoCase("http") == 0 || scheme.CmpNoCase("https") == 0 || + scheme.CmpNoCase("rtsp") == 0 || scheme.CmpNoCase("rtsps") == 0; int error = 0; - if (generic_rtsp) { - error = PlayRtsp(url, lk); + if (generic_ffmpeg) { + error = PlayFfmpeg(url, lk); } else { lk.unlock(); Bambu_Tunnel tunnel = nullptr; diff --git a/src/slic3r/GUI/wxMediaCtrl3.h b/src/slic3r/GUI/wxMediaCtrl3.h index bcc94a17ef..5160030983 100644 --- a/src/slic3r/GUI/wxMediaCtrl3.h +++ b/src/slic3r/GUI/wxMediaCtrl3.h @@ -16,6 +16,7 @@ wxDECLARE_EVENT(EVT_MEDIA_CTRL_STAT, wxCommandEvent); void wxMediaCtrl_OnSize(wxWindow * ctrl, wxSize const & videoSize, int width, int height); #define BAMBU_DYNAMIC +#include #include #include #ifndef _WIN32 @@ -56,10 +57,10 @@ protected: void DoSetSize(int x, int y, int width, int height, int sizeFlags) override; static void bambu_log(void *ctx, int level, tchar const *msg); - static int rtsp_interrupt_callback(void *opaque); + static int ffmpeg_interrupt_callback(void *opaque); void PlayThread(); - int PlayRtsp(std::shared_ptr const &url, std::unique_lock &lock); + int PlayFfmpeg(std::shared_ptr const &url, std::unique_lock &lock); void NotifyStopped(); @@ -83,6 +84,7 @@ private: std::mutex m_mutex; std::condition_variable m_cond; std::thread m_thread; + std::atomic_bool m_refresh_pending{false}; }; #endif /* wxMediaCtrl3_h */ diff --git a/src/slic3r/Utils/IPrinterAgent.hpp b/src/slic3r/Utils/IPrinterAgent.hpp index c076b57be5..219073cebc 100644 --- a/src/slic3r/Utils/IPrinterAgent.hpp +++ b/src/slic3r/Utils/IPrinterAgent.hpp @@ -246,7 +246,7 @@ public: virtual std::string get_user_selected_machine() = 0; /** - * Update the selected machine preference. + * Update the selected cloud machine preference. */ virtual int set_user_selected_machine(std::string dev_id) = 0; diff --git a/src/slic3r/Utils/OrcaCloudServiceAgent.cpp b/src/slic3r/Utils/OrcaCloudServiceAgent.cpp index 4a6c545a82..74bb2209d7 100644 --- a/src/slic3r/Utils/OrcaCloudServiceAgent.cpp +++ b/src/slic3r/Utils/OrcaCloudServiceAgent.cpp @@ -65,522 +65,6 @@ using json = nlohmann::json; namespace Slic3r { -struct OrcaCloudMqttConnection::Connection { - boost::asio::io_context io_context; - boost::asio::ssl::context ssl_context; - WebSocket websocket; - boost::asio::ip::tcp::resolver resolver; - - Connection() - : ssl_context(boost::asio::ssl::context::tls_client) - , websocket(io_context, ssl_context) - , resolver(io_context) - {} -}; - -OrcaCloudMqttConnection::~OrcaCloudMqttConnection() { stop(); } - -bool OrcaCloudMqttConnection::start(const std::string& endpoint, TokenProvider token_provider, MessageHandler message_handler, StateHandler state_handler) { - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT start endpoint=" << endpoint - << " token_callback=" << (token_provider ? "set" : "null") - << " message_callback=" << (message_handler ? "set" : "null") - << " state_callback=" << (state_handler ? "set" : "null"); - stop(); - { - std::lock_guard lock(mutex); - endpoint_url = endpoint; - get_token = std::move(token_provider); - on_message = std::move(message_handler); - on_state = std::move(state_handler); - initial_result = false; - initial_completed = false; - connected = false; - } - stopping.store(false); - worker = std::thread(&OrcaCloudMqttConnection::run, this); - - std::unique_lock lock(mutex); - 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; worker will retry"; - } - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT start initial_result=" << initial_result - << " initial_completed=" << initial_completed; - return initial_result; -} - -void OrcaCloudMqttConnection::stop() { - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT stop requested"; - stopping.store(true); - state_cv.notify_all(); - { - std::lock_guard lock(connection_mutex); - if (active_connection) { - auto& socket = boost::beast::get_lowest_layer(active_connection->websocket).socket(); - boost::system::error_code socket_error; - socket.cancel(socket_error); - socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, socket_error); - socket.close(socket_error); - active_connection->resolver.cancel(); - } - } - if (worker.joinable()) - worker.join(); - - { - std::lock_guard lock(mutex); - connected = false; - if (!initial_completed) { - initial_completed = true; - initial_result = false; - } - } - initial_cv.notify_all(); -} - -bool OrcaCloudMqttConnection::is_running() const { - return worker.joinable() && !stopping.load(); -} - -void OrcaCloudMqttConnection::flush_subscription_change() { - std::shared_ptr conn; - { - std::lock_guard lock(connection_mutex); - conn = active_connection; - } - bool connacked; - { - std::lock_guard lock(mutex); - connacked = connected; - } - if (!conn || !connacked) - return; // no live MQTT session yet — the worker sends the set on CONNACK - - // beast permits a concurrent writer while the worker is blocked in - // websocket.read(); every write is serialised by write_mutex inside send(). - try { - send_pending_subscriptions(conn->websocket); - } 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"; - } -} - -bool OrcaCloudMqttConnection::subscribe(const std::vector& device_ids) { - { - std::lock_guard lock(mutex); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT subscribe requested count=" << device_ids.size() - << " connected=" << connected.load(); - for (const std::string& device_id : device_ids) { - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT subscribe requested dev_id=" << device_id; - if (device_id.empty() || report_topic(device_id).size() > 96) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT subscribe rejected invalid dev_id=" << device_id; - return false; - } - } - for (const std::string& device_id : device_ids) { - subscriptions.insert(device_id); - pending_subscriptions.insert(device_id); - } - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT subscribe queued total_subscriptions=" << subscriptions.size() - << " pending_subscriptions=" << pending_subscriptions.size(); - } - state_cv.notify_all(); - flush_subscription_change(); // emit SUBSCRIBE now on the live socket (no reconnect) - return true; -} - -bool OrcaCloudMqttConnection::unsubscribe(const std::vector& device_ids) { - { - std::lock_guard lock(mutex); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT unsubscribe requested count=" << device_ids.size() - << " connected=" << connected.load(); - for (const std::string& device_id : device_ids) { - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT unsubscribe requested dev_id=" << device_id; - subscriptions.erase(device_id); - pending_subscriptions.erase(device_id); - pending_unsubscriptions.insert(device_id); - } - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT unsubscribe queued total_subscriptions=" << subscriptions.size() - << " pending_unsubscriptions=" << pending_unsubscriptions.size(); - } - state_cv.notify_all(); - flush_subscription_change(); // emit UNSUBSCRIBE now on the live socket (no reconnect) - return true; -} - -void OrcaCloudMqttConnection::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(); -} - -bool OrcaCloudMqttConnection::parse_endpoint(const std::string& url, Endpoint& endpoint) { - constexpr const char* scheme = "wss://"; - constexpr size_t scheme_length = 6; - if (url.compare(0, scheme_length, scheme) != 0) - return false; - - const size_t authority_start = scheme_length; - const size_t path_start = url.find('/', authority_start); - const std::string authority = url.substr(authority_start, path_start - authority_start); - if (authority.empty()) - return false; - - const size_t port_start = authority.rfind(':'); - if (port_start != std::string::npos && authority.find(']') == std::string::npos) { - endpoint.host = authority.substr(0, port_start); - endpoint.port = authority.substr(port_start + 1); - } else { - endpoint.host = authority; - endpoint.port = "443"; - } - endpoint.target = path_start == std::string::npos ? "/" : url.substr(path_start); - return !endpoint.host.empty() && !endpoint.port.empty() && !endpoint.target.empty(); -} - -void OrcaCloudMqttConnection::append_string(std::vector& packet, const std::string& value) { - if (value.size() > 0xffff) - throw std::runtime_error("MQTT string is too long"); - packet.push_back(static_cast(value.size() >> 8)); - packet.push_back(static_cast(value.size() & 0xff)); - packet.insert(packet.end(), value.begin(), value.end()); -} - -void OrcaCloudMqttConnection::prepend_remaining_length(std::vector& packet, size_t length) { - std::vector encoded; - do { - uint8_t byte = static_cast(length % 128); - length /= 128; - if (length != 0) - byte |= 0x80; - encoded.push_back(byte); - } while (length != 0); - packet.insert(packet.begin() + 1, encoded.begin(), encoded.end()); -} - -std::vector OrcaCloudMqttConnection::make_connect_packet() { - std::vector packet{0x10}; - append_string(packet, "MQTT"); - packet.insert(packet.end(), {4, 2, 0, 60}); // level 4, clean session, 60 s keepalive - append_string(packet, "OrcaSlicer"); - prepend_remaining_length(packet, packet.size() - 1); - return packet; -} - -std::string OrcaCloudMqttConnection::report_topic(const std::string& device_id) { return "device/" + device_id + "/report"; } - -std::vector OrcaCloudMqttConnection::make_topic_packet(uint8_t type, uint16_t packet_id, const std::vector& device_ids) { - std::vector packet{type}; - packet.push_back(static_cast(packet_id >> 8)); - packet.push_back(static_cast(packet_id & 0xff)); - for (const std::string& device_id : device_ids) { - append_string(packet, report_topic(device_id)); - if (type == 0x82) // SUBSCRIBE, QoS 0 is sufficient for printer reports. - packet.push_back(0); - } - prepend_remaining_length(packet, packet.size() - 1); - return packet; -} - -std::vector OrcaCloudMqttConnection::make_ping_packet() { return {0xc0, 0}; } - -void OrcaCloudMqttConnection::send(WebSocket& websocket, 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(); - websocket.binary(true); - websocket.write(boost::asio::buffer(packet)); -} - -void OrcaCloudMqttConnection::connect_and_read() { - auto connection = std::make_shared(); - { - std::lock_guard lock(connection_mutex); - active_connection = connection; - if (stopping.load()) - return; - } - - Endpoint endpoint; - if (!parse_endpoint(endpoint_url, endpoint)) { - BOOST_LOG_TRIVIAL(error) << "Orca diagnostic: invalid MQTT endpoint=" << endpoint_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; - - auto& websocket = connection->websocket; - const auto results = connection->resolver.resolve(endpoint.host, endpoint.port); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT DNS resolution succeeded host=" << endpoint.host; - 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; - - // The aggregate viewer is a TLS WebSocket endpoint. 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"); - connection->ssl_context.set_default_verify_paths(); - 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; - - const std::string token = get_token ? get_token() : std::string(); - if (token.empty()) { - BOOST_LOG_TRIVIAL(error) << "Orca diagnostic: MQTT token callback returned an empty token"; - throw std::runtime_error("no access token for Orca Cloud WebSocket"); - } - - websocket.set_option(boost::beast::websocket::stream_base::decorator( - [token](boost::beast::websocket::request_type& request) { - request.set(boost::beast::http::field::user_agent, "OrcaSlicer"); - request.set(boost::beast::http::field::authorization, "Bearer " + token); - request.set("Sec-WebSocket-Protocol", "mqtt"); - })); - boost::beast::http::response response; - boost::system::error_code handshake_error; - 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) << "OrcaCloudMqttConnection: handshake rejected, http=" - << response.result_int() << " (" << response.reason() << "), " - << handshake_error.message(); - throw boost::system::system_error(handshake_error, "Orca Cloud 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 Cloud WebSocket did not negotiate MQTT"); - } - - stream.expires_never(); - send(websocket, make_connect_packet()); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT CONNECT packet sent"; - - boost::beast::flat_buffer buffer; - stream.expires_after(std::chrono::seconds(10)); - websocket.read(buffer); - 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); - if (connack.size() != 4 || static_cast(connack[0]) != 0x20 || - static_cast(connack[2]) != 0x00 || static_cast(connack[3]) != 0x00) { - BOOST_LOG_TRIVIAL(error) << "Orca diagnostic: MQTT CONNECT was refused or malformed"; - throw std::runtime_error("Orca Cloud MQTT CONNECT was refused"); - } - - 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(websocket); - std::chrono::steady_clock::time_point next_ping = std::chrono::steady_clock::now() + std::chrono::seconds(30); - - while (!stopping.load()) { - send_pending_subscriptions(websocket); - buffer.consume(buffer.size()); - stream.expires_after(std::chrono::seconds(1)); - boost::system::error_code error; - websocket.read(buffer, error); - if (error == boost::beast::error::timeout) { - if (std::chrono::steady_clock::now() >= next_ping) { - send(websocket, make_ping_packet()); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT PINGREQ sent"; - next_ping = std::chrono::steady_clock::now() + std::chrono::seconds(30); - } - 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 Cloud MQTT message"); - } - handle_packet(boost::beast::buffers_to_string(buffer.data())); - } - - boost::system::error_code close_error; - websocket.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(); - if (!stopping.load()) - notify_state(false); -} - -void OrcaCloudMqttConnection::send_current_subscriptions(WebSocket& websocket) { - std::vector devices; - { - std::lock_guard lock(mutex); - devices.assign(subscriptions.begin(), subscriptions.end()); - } - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending current MQTT subscriptions count=" << devices.size(); - if (!devices.empty()) { - const uint16_t packet_id = next_packet_id++; - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending SUBSCRIBE packet_id=" << packet_id; - send(websocket, make_topic_packet(0x82, packet_id, devices)); - } -} - -void OrcaCloudMqttConnection::send_pending_subscriptions(WebSocket& websocket) { - std::vector subscribe_ids; - std::vector unsubscribe_ids; - { - std::lock_guard lock(mutex); - subscribe_ids.assign(pending_subscriptions.begin(), pending_subscriptions.end()); - unsubscribe_ids.assign(pending_unsubscriptions.begin(), pending_unsubscriptions.end()); - pending_subscriptions.clear(); - pending_unsubscriptions.clear(); - } - if (!subscribe_ids.empty()) { - const uint16_t packet_id = next_packet_id++; - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending pending SUBSCRIBE count=" << subscribe_ids.size() - << " packet_id=" << packet_id; - for (const std::string& device_id : subscribe_ids) - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: SUBSCRIBE topic=" << report_topic(device_id); - send(websocket, make_topic_packet(0x82, packet_id, subscribe_ids)); - } - if (!unsubscribe_ids.empty()) { - const uint16_t packet_id = next_packet_id++; - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending pending UNSUBSCRIBE count=" << unsubscribe_ids.size() - << " packet_id=" << packet_id; - for (const std::string& device_id : unsubscribe_ids) - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: UNSUBSCRIBE topic=" << report_topic(device_id); - send(websocket, make_topic_packet(0xa2, packet_id, unsubscribe_ids)); - } -} - -void OrcaCloudMqttConnection::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) { - std::ostringstream result_codes; - for (size_t index = 4; index < packet.size(); ++index) { - if (index != 4) - result_codes << ','; - result_codes << "0x" << std::hex << static_cast(static_cast(packet[index])); - } - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: received SUBACK packet_id=" - << ((static_cast(static_cast(packet[2])) << 8) | - static_cast(static_cast(packet[3]))) - << " result_codes=" << result_codes.str(); - } - return; - } - size_t index = 1; - size_t multiplier = 1; - size_t remaining = 0; - 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++]); - remaining += (encoded & 0x7f) * multiplier; - multiplier *= 128; - } 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"); - if (on_message) - on_message(topic, packet.substr(index, remaining_end - index)); - else - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: dropping PUBLISH because message callback is not set"; -} - -void OrcaCloudMqttConnection::notify_state(bool is_now_connected) { - StateHandler callback; - bool initial = false; - { - std::lock_guard lock(mutex); - connected = is_now_connected; - initial = !initial_completed; - if (initial) { - initial_result = is_now_connected; - initial_completed = true; - } - 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) - callback(is_now_connected, false); -} - -void OrcaCloudMqttConnection::run() { - while (!stopping.load()) { - const int retry_seconds = reconnect_delay_seconds.load(); - try { - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT connection attempt retry_delay=" << retry_seconds; - connect_and_read(); - } catch (const std::exception& error) { - BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT connection attempt failed: " << error.what(); - if (!stopping.load()) - notify_state(false); - } - if (stopping.load()) - break; - // Grow the backoff only across attempts that never reached CONNACK; a - // 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(); }); - } -} - namespace { constexpr const char* ORCA_DEFAULT_API_URL = "api.orcaslicer.com"; constexpr const char* ORCA_DEFAULT_AUTH_URL = "https://auth.orcaslicer.com"; @@ -1013,7 +497,7 @@ OrcaCloudServiceAgent::OrcaCloudServiceAgent(std::string log_dir) , api_base_url(ORCA_DEFAULT_API_URL) , auth_base_url(ORCA_DEFAULT_AUTH_URL) , cloud_base_url(ORCA_DEFAULT_CLOUD_URL) - , mqtt_connection(std::make_unique()) + , mqtt_connection(std::make_unique()) { auth_headers["apikey"] = ORCA_DEFAULT_PUB_KEY; pkce_bundle.loopback_port = choose_loopback_port(); @@ -1487,79 +971,22 @@ int OrcaCloudServiceAgent::connect_server() BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: cloud health result=" << result << " http_code=" << http_code << " connected=" << connected << " response_bytes=" << response.size(); - if (connected && mqtt_connection && !mqtt_connection->is_running()) { - // Only (re)start when the worker isn't already alive. connect_server() is - // also called every ~5s by DeviceManagerRefresher::on_timer via - // refresh_connection(); start() begins with stop(), so calling it - // unconditionally tears down and rebuilds a healthy socket every tick. - const std::string endpoint = "wss://" + api_base_url + "/api/v1/printers/mqtt"; - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: starting aggregate MQTT endpoint=" << endpoint; - // Fire-and-forget: start() spawns a worker that reconnects with exponential - // backoff. A failed *initial* attempt (token/network not ready yet during a - // startup gap) must NOT gate the socket's lifetime here — folding it into - // `connected` trips the stop() below and kills the retry loop for the whole - // session. The socket is torn down only on logout / clear_session. - const bool mqtt_started = mqtt_connection->start( - endpoint, - [this] { return get_access_token(); }, - [this](const std::string& topic, const std::string& message) { - constexpr const char* prefix = "device/"; - constexpr const char* suffix = "/report"; - if (topic.compare(0, 7, prefix) != 0 || topic.size() <= 14 || - topic.compare(topic.size() - 7, 7, suffix) != 0) - return; - const std::string device_id = topic.substr(7, topic.size() - 14); - OnMessageFn callback; - { - std::lock_guard lock(callback_mutex); - callback = printer_status_callback; - } - if (callback) - callback(device_id, message); - }, - [this](bool socket_connected, bool initial) { - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: aggregate MQTT state callback connected=" - << socket_connected << " initial=" << initial; - if (initial) - return; - { - std::lock_guard lock(state_mutex); - is_connected = socket_connected; - } - invoke_server_connected_callback(socket_connected ? 0 : -1, 0); - }); - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: aggregate MQTT start returned=" << mqtt_started; + // connect_server() is a REST health probe only. The long-lived MQTT socket is + // per-printer now, driven by set_user_selected_machine -> + // configure_selected_printer_mqtt; this method must not touch mqtt_connection. + { + std::lock_guard lock(state_mutex); + is_connected = connected; } - if (!connected) { - // Transient health-check failure (DNS blip / brief 5xx). Do NOT stop the - // MQTT worker — it owns its own reconnect loop, and connect_server() runs - // on the 5s refresher tick. The socket is torn down only on logout (the - // !logged_in branch above) and clear_session(). - BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: cloud health check failed; leaving aggregate MQTT running"; - } - - // While the aggregate MQTT worker is alive it owns is_connected via its - // StateHandler. Don't let the 5s health probe overwrite it (a DNS blip would - // otherwise flap the "server connected" state and the Device tab). - const bool mqtt_alive = mqtt_connection && mqtt_connection->is_running(); - if (!mqtt_alive) { - { - std::lock_guard lock(state_mutex); - is_connected = connected; - } - invoke_server_connected_callback(connected ? 0 : -1, http_code); - } - - return (connected || mqtt_alive) ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED; + invoke_server_connected_callback(connected ? 0 : -1, http_code); + return connected ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED; } bool OrcaCloudServiceAgent::is_server_connected() { - // The aggregate MQTT socket is the real signal. While its worker is alive, - // report its actual CONNACK state — immune to the 5s health probe's DNS blips. - // Fall back to the last health-check result only when there is no socket. - if (mqtt_connection && mqtt_connection->is_running()) - return mqtt_connection->is_connected(); + // The REST health probe is the signal; the per-printer MQTT socket does not gate + // whole-cloud connectivity (one printer reconnecting must not report the whole + // cloud as lost). std::lock_guard lock(state_mutex); return is_connected; } @@ -1586,7 +1013,9 @@ int OrcaCloudServiceAgent::add_subscribe(std::vector dev_list) BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: add_subscribe rejected because cloud is not ready"; return BAMBU_NETWORK_ERR_INVALID_HANDLE; } - const bool queued = mqtt_connection->subscribe(dev_list); + bool queued = true; + for (const std::string& dev_id : dev_list) + queued = mqtt_connection->subscribe(dev_id) && queued; BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: add_subscribe queued=" << queued; return queued ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECT_FAILED; } @@ -1599,11 +1028,68 @@ int OrcaCloudServiceAgent::del_subscribe(std::vector dev_list) BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: del_subscribe rejected because cloud is not ready"; return BAMBU_NETWORK_ERR_INVALID_HANDLE; } - const bool queued = mqtt_connection->unsubscribe(dev_list); + bool queued = true; + for (const std::string& dev_id : dev_list) + queued = mqtt_connection->unsubscribe(dev_id) && queued; BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: del_subscribe queued=" << queued; return queued ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECT_FAILED; } +int OrcaCloudServiceAgent::configure_selected_printer_mqtt(const std::string& dev_id) +{ + OrcaMqttConnection::Config cfg; + cfg.url = "wss://" + api_base_url + "/api/v1/printers/" + dev_id + "/mqtt"; + cfg.use_tls = true; + cfg.bearer_provider = [this] { return get_access_token(); }; + cfg.client_id = "OrcaSlicer"; + cfg.keepalive_seconds = 300; + + { + std::lock_guard lock(m_selected_url_mutex); + m_selected_printer_mqtt_url = cfg.url; + } + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: configuring per-printer MQTT endpoint=" << cfg.url; + + // NOTE: no lock is held across start() — it blocks for the whole initial connect + // attempt (up to ~10s), and the message handler below re-enters callback_mutex on + // the MQTT worker thread. + const bool ok = mqtt_connection->start( + cfg, + [this](const std::string& id, const std::string& payload) { deliver_cloud_message(id, payload); }, + [this](bool, bool) {}); + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: per-printer MQTT start returned=" << ok; + return ok ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED; +} + +void OrcaCloudServiceAgent::teardown_selected_printer_mqtt() +{ + if (mqtt_connection) { + mqtt_connection->stop(); + // The connection object is reused for the next printer; drop this printer's + // report topic so its 1:1 socket does not re-subscribe the previous device. + mqtt_connection->clear_subscriptions(); + } + std::lock_guard lock(m_selected_url_mutex); + m_selected_printer_mqtt_url.clear(); +} + +std::string OrcaCloudServiceAgent::selected_printer_mqtt_url() const +{ + std::lock_guard lock(m_selected_url_mutex); + return m_selected_printer_mqtt_url; +} + +void OrcaCloudServiceAgent::deliver_cloud_message(const std::string& dev_id, const std::string& payload) +{ + OnMessageFn callback; + { + std::lock_guard lock(callback_mutex); + callback = printer_status_callback; + } + if (callback) + callback(dev_id, payload); +} + int OrcaCloudServiceAgent::set_printer_status_callback(OnMessageFn fn) { std::lock_guard lock(callback_mutex); @@ -3293,6 +2779,15 @@ int OrcaCloudServiceAgent::get_user_print_info(unsigned int* http_code, std::str for (const auto& printer : resp_json.value("data", nlohmann::json::array())) { nlohmann::json device; + std::string role = printer.value("access_role", ""); + + // A printer with the role "view" only has monitoring access for orca cloud. + // The printer is owned by a different person and was shared to the current user without + // any permission to control the printer so we discard this printer. Comment this out if + // OrcaSlicer wants to support view only printers. + if (role.empty() || role == "viewer") + continue; + device["dev_id"] = printer.value("id", ""); device["dev_name"] = printer.value("name", ""); if (printer.contains("model") && printer["model"].is_string()) diff --git a/src/slic3r/Utils/OrcaCloudServiceAgent.hpp b/src/slic3r/Utils/OrcaCloudServiceAgent.hpp index 95f95b7d92..a435c9668f 100644 --- a/src/slic3r/Utils/OrcaCloudServiceAgent.hpp +++ b/src/slic3r/Utils/OrcaCloudServiceAgent.hpp @@ -24,84 +24,14 @@ #include #include +#include "OrcaMqttConnection.hpp" + class wxSecretStore; namespace Slic3r { // Forward declarations class AppConfig; -// MQTT 3.1.1 over the aggregate WebSocket is deliberately kept here instead -// of using the printer SDK. The endpoint is a read-only status stream; MQTT -// PUBLISH must never be sent on it because the cloud closes such sessions. -class OrcaCloudMqttConnection -{ -public: - using TokenProvider = std::function; - using MessageHandler = std::function; - using StateHandler = std::function; - - ~OrcaCloudMqttConnection(); - - bool start(const std::string& endpoint, TokenProvider token_provider, MessageHandler message_handler, StateHandler state_handler); - void stop(); - // True while the worker thread is alive (connected OR retrying). Lets callers - // avoid restarting a healthy connection. - bool is_running() const; - // True once CONNACK has been received and the socket has not since dropped. - bool is_connected() const { return connected.load(); } - bool subscribe(const std::vector& device_ids); - bool unsubscribe(const std::vector& device_ids); - void clear_subscriptions(); - -private: - struct Endpoint { std::string host; std::string port; std::string target; }; - using WebSocket = boost::beast::websocket::stream< - boost::asio::ssl::stream>; - struct Connection; - - static bool parse_endpoint(const std::string& url, Endpoint& endpoint); - static void append_string(std::vector& packet, const std::string& value); - static void prepend_remaining_length(std::vector& packet, size_t length); - static std::vector make_connect_packet(); - static std::string report_topic(const std::string& device_id); - static std::vector make_topic_packet(uint8_t type, uint16_t packet_id, const std::vector& device_ids); - static std::vector make_ping_packet(); - - void send(WebSocket& websocket, const std::vector& packet); - // Emit a queued SUBSCRIBE/UNSUBSCRIBE on the live socket right now (from the - // caller thread), so a selection change is applied without waiting for the - // blocking read loop to next return. No-op if no CONNACKed socket exists yet - // (the worker sends the set on connect). The aggregate viewer is dynamic — the - // WebSocket is never dropped for a subscription change. - void flush_subscription_change(); - void connect_and_read(); - void send_current_subscriptions(WebSocket& websocket); - void send_pending_subscriptions(WebSocket& websocket); - void handle_packet(const std::string& packet); - void notify_state(bool is_now_connected); - void run(); - - std::atomic_bool stopping{true}; - std::atomic_int reconnect_delay_seconds{1}; - std::thread worker; - std::mutex mutex; - std::mutex connection_mutex; - std::mutex write_mutex; // serialises every websocket write (worker + caller threads) - std::shared_ptr active_connection; - std::condition_variable initial_cv; - std::condition_variable state_cv; - std::string endpoint_url; - TokenProvider get_token; - MessageHandler on_message; - StateHandler on_state; - std::set subscriptions; - std::set pending_subscriptions; - std::set pending_unsubscriptions; - std::atomic next_packet_id{1}; - bool initial_result{false}; - bool initial_completed{false}; - std::atomic_bool connected{false}; -}; struct BundleMetadata; struct PluginDescriptor; struct PluginChangelog; @@ -288,10 +218,10 @@ public: int del_subscribe(std::vector dev_list) override; void enable_multi_machine(bool enable) override; - // The aggregate printer socket is status-only. OrcaPrinterAgent registers - // its normal message callback here and adds/removes device report topics - // through add_subscribe()/del_subscribe(). Printer commands continue to - // use the REST commands endpoint; they must never be published here. + // The per-printer MQTT socket carries both directions: inbound reports from + // device//report and commands PUBLISHed to device//request on this + // socket. OrcaPrinterAgent registers its message callback here to receive the + // inbound half; pass an empty fn to clear it before the agent is destroyed. int set_printer_status_callback(OnMessageFn fn); // Send a Bambu-dialect command to one printer via the cloud relay's REST @@ -439,7 +369,26 @@ public: static std::string generate_uuid_for_setting_id(const std::string& name, const std::string& user_id = ""); + OrcaMqttConnection* get_mqtt_connection() noexcept { + return mqtt_connection.get(); + } + + const OrcaMqttConnection* get_mqtt_connection() const noexcept { + return mqtt_connection.get(); + } + + // Per-printer cloud socket: wss:///api/v1/printers//mqtt. + // configure_ blocks for the duration of the initial connect attempt, so callers + // drive it off the UI thread; teardown_ is synchronous. + int configure_selected_printer_mqtt(const std::string& dev_id); + void teardown_selected_printer_mqtt(); + // Test hook: the wss:// URL of the current per-printer socket ("" when none). + std::string selected_printer_mqtt_url() const; + private: + // Fans one inbound per-printer MQTT message out to printer_status_callback. + void deliver_cloud_message(const std::string& dev_id, const std::string& payload); + // Sync protocol helpers int sync_pull( std::function on_success, @@ -516,7 +465,9 @@ private: std::chrono::system_clock::now().time_since_epoch()).count()}; // Member variables - connection state - std::unique_ptr mqtt_connection; + std::unique_ptr mqtt_connection; + std::string m_selected_printer_mqtt_url; // guarded by m_selected_url_mutex + mutable std::mutex m_selected_url_mutex; bool is_connected{false}; bool enable_track{false}; bool multi_machine_enabled{false}; diff --git a/src/slic3r/Utils/OrcaMqttConnection.cpp b/src/slic3r/Utils/OrcaMqttConnection.cpp new file mode 100644 index 0000000000..2173231310 --- /dev/null +++ b/src/slic3r/Utils/OrcaMqttConnection.cpp @@ -0,0 +1,839 @@ +#include "OrcaMqttConnection.hpp" + +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace Slic3r { + +struct OrcaMqttConnection::Connection { + boost::asio::io_context io_context; + boost::asio::ssl::context ssl_context; + boost::asio::ip::tcp::resolver resolver; + // Exactly one of these is engaged once ws_handshake() has run: wss for + // wss:// endpoints, ws for plaintext ws://. + std::optional wss; + std::optional ws; + + Connection() + : ssl_context(boost::asio::ssl::context::tls_client) + , resolver(io_context) + {} +}; + +namespace { +// Apply / clear a tcp_stream timeout on whichever websocket is engaged. +// Templated on the connection type only because Connection is a private nested +// type: a deduced parameter needs no (inaccessible) name for it. +template void expires_after(Conn& conn, std::chrono::seconds timeout) { + if (conn.wss) boost::beast::get_lowest_layer(*conn.wss).expires_after(timeout); + else if (conn.ws) boost::beast::get_lowest_layer(*conn.ws).expires_after(timeout); +} +template void expires_never(Conn& conn) { + if (conn.wss) boost::beast::get_lowest_layer(*conn.wss).expires_never(); + else if (conn.ws) boost::beast::get_lowest_layer(*conn.ws).expires_never(); +} +} // namespace + +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); + current_config = config; + this->on_message = std::move(on_message); + this->on_state = std::move(on_state); + initial_result = false; + initial_completed = false; + connected = false; + m_last_connack_rc.store(-1); + } + stopping.store(false); + worker = std::thread(&OrcaMqttConnection::run, this); + + std::unique_lock lock(mutex); + 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(); + { + std::lock_guard lock(connection_mutex); + if (active_connection) { + // Generic so it accepts either the TLS or the plaintext websocket. + auto shutdown_socket = [](auto& websocket) { + auto& socket = boost::beast::get_lowest_layer(websocket).socket(); + boost::system::error_code socket_error; + socket.cancel(socket_error); + socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, socket_error); + socket.close(socket_error); + }; + if (active_connection->wss) + shutdown_socket(*active_connection->wss); + else if (active_connection->ws) + shutdown_socket(*active_connection->ws); + active_connection->resolver.cancel(); + } + } + if (worker.joinable()) + worker.join(); + + { + std::lock_guard lock(mutex); + connected = false; + acknowledged_subscriptions.clear(); + pending_subscribe_packets.clear(); + pending_requests.clear(); + if (!initial_completed) { + initial_completed = true; + initial_result = false; + } + } + initial_cv.notify_all(); +} + +bool OrcaMqttConnection::is_running() const { + return worker.joinable() && !stopping.load(); +} + +void OrcaMqttConnection::flush_subscription_change() { + std::shared_ptr conn; + { + std::lock_guard lock(connection_mutex); + conn = active_connection; + } + bool connacked; + { + std::lock_guard lock(mutex); + connacked = connected; + } + if (!conn || !connacked) + return; // no live MQTT session yet — the worker sends the set on CONNACK + + // beast permits a concurrent writer while the worker is blocked in + // 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"; + } +} + +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) + return true; +} + +bool OrcaMqttConnection::unsubscribe(const std::string& dev_id) { + const std::string topic = report_topic(dev_id); + { + std::lock_guard lock(mutex); + subscriptions.erase(topic); + acknowledged_subscriptions.erase(topic); + pending_subscriptions.erase(topic); + pending_unsubscriptions.insert(topic); + for (auto it = pending_subscribe_packets.begin(); it != pending_subscribe_packets.end();) { + if (it->second == topic) + it = pending_subscribe_packets.erase(it); + else + ++it; + } + for (auto it = pending_requests.begin(); it != pending_requests.end();) { + if (it->first == dev_id) + it = pending_requests.erase(it); + 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) + return true; +} + +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(); + acknowledged_subscriptions.clear(); + pending_subscribe_packets.clear(); + pending_requests.clear(); +} + +bool OrcaMqttConnection::parse_endpoint(const std::string& url, Endpoint& endpoint) { + std::string rest; + std::string default_port; + if (url.rfind("wss://", 0) == 0) { rest = url.substr(6); default_port = "443"; } + else if (url.rfind("ws://", 0) == 0) { rest = url.substr(5); default_port = "80"; } + else return false; + + const auto slash = rest.find('/'); + const std::string authority = rest.substr(0, slash); + endpoint.target = (slash == std::string::npos) ? "/" : rest.substr(slash); + + // host[:port] — leave an unbracketed IPv6 literal alone + const auto colon = authority.rfind(':'); + if (colon != std::string::npos && authority.find(']') == std::string::npos) { + endpoint.host = authority.substr(0, colon); + endpoint.port = authority.substr(colon + 1); + } else { + endpoint.host = authority; + endpoint.port = default_port; + } + return !endpoint.host.empty() && !endpoint.port.empty() && !endpoint.target.empty(); +} + +void OrcaMqttConnection::append_string(std::vector& packet, const std::string& value) { + if (value.size() > 0xffff) + throw std::runtime_error("MQTT string is too long"); + packet.push_back(static_cast(value.size() >> 8)); + packet.push_back(static_cast(value.size() & 0xff)); + packet.insert(packet.end(), value.begin(), value.end()); +} + +void OrcaMqttConnection::prepend_remaining_length(std::vector& packet, size_t length) { + std::vector encoded; + do { + uint8_t byte = static_cast(length % 128); + length /= 128; + if (length != 0) + byte |= 0x80; + encoded.push_back(byte); + } while (length != 0); + packet.insert(packet.begin() + 1, encoded.begin(), encoded.end()); +} + +std::vector OrcaMqttConnection::make_connect_packet( + const std::string& client_id, const std::string& username, + const std::string& password, int keepalive_seconds) { + std::vector packet{0x10}; + append_string(packet, "MQTT"); + packet.push_back(4); // protocol level 3.1.1 + + uint8_t flags = 0x02; // clean session + if (!username.empty()) { flags |= 0x80; if (!password.empty()) flags |= 0x40; } + packet.push_back(flags); + + packet.push_back(static_cast(keepalive_seconds >> 8)); + packet.push_back(static_cast(keepalive_seconds & 0xff)); + + append_string(packet, client_id.empty() ? "OrcaSlicer" : client_id); + if (!username.empty()) { + append_string(packet, username); + if (!password.empty()) append_string(packet, password); + } + prepend_remaining_length(packet, packet.size() - 1); + return packet; +} + +std::string OrcaMqttConnection::report_topic(const std::string& device_id) { return "device/" + device_id + "/report"; } + +std::string OrcaMqttConnection::request_topic(const std::string& id) { return "device/" + id + "/request"; } + +std::vector OrcaMqttConnection::make_publish_packet(const std::string& topic, const std::string& payload) { + std::vector packet{0x30}; // PUBLISH, QoS 0, no retain + append_string(packet, topic); // no packet id at QoS 0 + packet.insert(packet.end(), payload.begin(), payload.end()); + prepend_remaining_length(packet, packet.size() - 1); + return packet; +} + +std::vector OrcaMqttConnection::make_subscribe_packet(uint16_t id, const std::string& topic, uint8_t qos) { + std::vector packet{0x82}; + packet.push_back(id >> 8); packet.push_back(id & 0xff); + append_string(packet, topic); + packet.push_back(qos); + prepend_remaining_length(packet, packet.size() - 1); + return packet; +} + +std::vector OrcaMqttConnection::make_unsubscribe_packet(uint16_t id, const std::string& topic) { + std::vector packet{0xA2}; + packet.push_back(id >> 8); packet.push_back(id & 0xff); + append_string(packet, topic); + prepend_remaining_length(packet, packet.size() - 1); + return packet; +} + +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)); + } else if (conn.ws) { + conn.ws->binary(true); + conn.ws->write(boost::asio::buffer(packet)); + } +} + +std::size_t OrcaMqttConnection::ws_read(Connection& conn, boost::beast::flat_buffer& buffer, + boost::system::error_code& ec) { + if (conn.wss) + return conn.wss->read(buffer, ec); + if (conn.ws) + return conn.ws->read(buffer, ec); + ec = boost::asio::error::not_connected; + return 0; +} + +void OrcaMqttConnection::ws_close(Connection& conn) { + boost::system::error_code close_error; + if (conn.wss) + 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"); + if (!token.empty()) + request.set(boost::beast::http::field::authorization, "Bearer " + token); + request.set("Sec-WebSocket-Protocol", "mqtt"); + }; + boost::beast::http::response response; + boost::system::error_code handshake_error; + + if (config.use_tls) { + // stop() inspects the engaged optional under connection_mutex; publish it + // under the same lock, then release before the blocking connect. + { + std::lock_guard lock(connection_mutex); + conn.wss.emplace(conn.io_context, conn.ssl_context); + } + auto& websocket = *conn.wss; + 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(); + 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 { + { + std::lock_guard lock(connection_mutex); + conn.ws.emplace(conn.io_context); + } + auto& websocket = *conn.ws; + 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; + { + std::lock_guard lock(connection_mutex); + 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); + { + 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() << ")"; + 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); + active_connection = connection; + if (stopping.load()) + 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). + const bool use_bearer = static_cast(current_config.bearer_provider); + ws_write(*connection, make_connect_packet(current_config.client_id, + 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; + ws_read(*connection, buffer, connack_error); + 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(). + stopping.store(true); + { + std::lock_guard lock(mutex); + initial_completed = true; + initial_result = false; + } + initial_cv.notify_all(); + } + 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. + { + std::lock_guard lock(mutex); + acknowledged_subscriptions.clear(); + pending_subscribe_packets.clear(); + } + 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); + + while (!stopping.load()) { + send_pending_subscriptions(*connection); + // Keepalive is driven every iteration, not only from the read-timeout branch: + // a printer pushing faster than the 1s read deadline would otherwise keep the + // 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())); + } + + ws_close(*connection); + if (!stopping.load()) + notify_state(false); +} + +void OrcaMqttConnection::send_current_subscriptions(Connection& conn) { + std::vector topics; + { + std::lock_guard lock(mutex); + topics.assign(subscriptions.begin(), subscriptions.end()); + acknowledged_subscriptions.clear(); + pending_subscribe_packets.clear(); + 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)); + } +} + +void OrcaMqttConnection::send_pending_subscriptions(Connection& conn) { + std::vector subscribe_topics; + std::vector unsubscribe_topics; + { + std::lock_guard lock(mutex); + subscribe_topics.assign(pending_subscriptions.begin(), pending_subscriptions.end()); + unsubscribe_topics.assign(pending_unsubscriptions.begin(), pending_unsubscriptions.end()); + pending_subscriptions.clear(); + pending_unsubscriptions.clear(); + } + for (const std::string& topic : subscribe_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 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) | + static_cast(static_cast(packet[3])); + std::ostringstream result_codes; + for (size_t index = 4; index < packet.size(); ++index) { + if (index != 4) + 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 + // means the subscription was rejected. + const uint8_t result = static_cast(packet[4]); + std::string topic; + std::deque> requests; + { + std::lock_guard lock(mutex); + auto pending = pending_subscribe_packets.find(packet_id); + if (pending != pending_subscribe_packets.end()) { + topic = pending->second; + pending_subscribe_packets.erase(pending); + for (auto it = pending_requests.begin(); it != pending_requests.end();) { + if (report_topic(it->first) == topic) { + requests.push_back(std::move(*it)); + it = pending_requests.erase(it); + } else { + ++it; + } + } + if (result == 0 || result == 1) { + acknowledged_subscriptions.insert(topic); + } + } + } + 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; + } + size_t index = 1; + size_t multiplier = 1; + size_t remaining = 0; + 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++]); + remaining += (encoded & 0x7f) * multiplier; + multiplier *= 128; + } 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) { + const size_t id_start = 7; + const size_t id_end = topic.rfind('/'); + if (id_end != std::string::npos && id_end > id_start) + 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"; + } +} + +void OrcaMqttConnection::notify_state(bool is_now_connected) { + StateHandler callback; + bool initial = false; + { + std::lock_guard lock(mutex); + connected = is_now_connected; + initial = !initial_completed; + if (initial) { + initial_result = is_now_connected; + initial_completed = true; + } + 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) + callback(is_now_connected, false); +} + +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); + } + if (stopping.load()) + break; + // Grow the backoff only across attempts that never reached CONNACK; a + // 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(); }); + } +} + +} // namespace Slic3r diff --git a/src/slic3r/Utils/OrcaMqttConnection.hpp b/src/slic3r/Utils/OrcaMqttConnection.hpp new file mode 100644 index 0000000000..6131ee86f1 --- /dev/null +++ b/src/slic3r/Utils/OrcaMqttConnection.hpp @@ -0,0 +1,152 @@ +#ifndef slic3r_OrcaMqttConnection_hpp_ +#define slic3r_OrcaMqttConnection_hpp_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace Slic3r { + +// Minimal MQTT 3.1.1 codec + WebSocket transport (ws:// and wss://), shared by the +// LAN (OrcaSonar) and cloud (per-printer) printer connections. Both PUBLISH +// commands to device//request and SUBSCRIBE device//report; Config is the +// only per-transport difference. +class OrcaMqttConnection +{ +public: + using TokenProvider = std::function; + using MessageHandler = std::function; + using StateHandler = std::function; + + struct Endpoint { std::string host; std::string port; std::string target; }; + + struct Config { + std::string url; + bool use_tls = false; + TokenProvider bearer_provider; // set => bearer on WS upgrade, CONNECT creds omitted + std::string username; + std::string password; + std::string client_id = "OrcaSlicer"; + int keepalive_seconds = 60; + }; + + static bool parse_endpoint(const std::string& url, Endpoint& endpoint); + + // Build an MQTT 3.1.1 CONNECT packet. Clean-session is always set; the + // username/password connect flags and payload fields are added only when + // username is non-empty (the cloud form authenticates via a bearer on the + // WebSocket upgrade and omits CONNECT credentials). Public for unit tests. + static std::vector make_connect_packet(const std::string& client_id, + const std::string& username, + const std::string& password, + int keepalive_seconds); + + // Topic-string helpers for the per-device request/report channels and the + // MQTT 3.1.1 PUBLISH / SUBSCRIBE / UNSUBSCRIBE packet builders. All public + // for unit tests. make_publish_packet emits QoS 0 (no packet identifier). + static std::string request_topic(const std::string& dev_id); // "device//request" + static std::string report_topic(const std::string& dev_id); // "device//report" + static std::vector make_publish_packet(const std::string& topic, const std::string& payload); + static std::vector make_subscribe_packet(uint16_t packet_id, const std::string& topic, uint8_t qos); + static std::vector make_unsubscribe_packet(uint16_t packet_id, const std::string& topic); + + ~OrcaMqttConnection(); + + bool start(const Config& config, MessageHandler on_message, StateHandler on_state); + void stop(); + // True while the worker thread is alive (connected OR retrying). Lets callers + // avoid restarting a healthy connection. + bool is_running() const; + // True once CONNACK has been received and the socket has not since dropped. + bool is_connected() const { return connected.load(); } + bool subscribe(const std::string& dev_id); + bool unsubscribe(const std::string& dev_id); + // Last MQTT CONNACK return code: 0 ok, 1..5 refusal, -1 none seen this attempt. + int last_connack_rc() const { return m_last_connack_rc.load(); } + void clear_subscriptions(); + bool send_request(const std::string& dev_id, const std::string& payload); + +private: + // The endpoint may be either a TLS (wss://) or a plaintext (ws://) WebSocket; + // Connection holds whichever one is engaged and the ws_* helpers below + // dispatch on it. + using TlsWebSocket = boost::beast::websocket::stream< + boost::asio::ssl::stream>; + using PlainWebSocket = boost::beast::websocket::stream; + struct Connection; + + static void append_string(std::vector& packet, const std::string& value); + static void prepend_remaining_length(std::vector& packet, size_t length); + static std::vector make_ping_packet(); + + // Transport dispatch: each forwards to conn.wss (TLS) or conn.ws (plaintext). + void ws_write(Connection& conn, const std::vector& packet); // locks write_mutex + std::size_t ws_read(Connection& conn, boost::beast::flat_buffer& buffer, boost::system::error_code& ec); + void ws_handshake(Connection& conn, const Config& config, const Endpoint& endpoint); + void ws_close(Connection& conn); + // Emit a queued SUBSCRIBE/UNSUBSCRIBE on the live socket right now (from the + // caller thread), so a selection change is applied without waiting for the + // blocking read loop to next return. No-op if no CONNACKed socket exists yet + // (the worker sends the set on connect). The WebSocket is never dropped for a + // subscription change. + void flush_subscription_change(); + void connect_and_read(); + void send_current_subscriptions(Connection& conn); + void send_pending_subscriptions(Connection& conn); + void handle_packet(const std::string& packet); + void notify_state(bool is_now_connected); + void run(); + + std::atomic_bool stopping{true}; + std::atomic_int reconnect_delay_seconds{1}; + // Serialises the whole of start() and stop() against each other, so the UI + // thread's stop() (disconnect / dtor) cannot race the connect thread's start() + // into a concurrent worker.join(). Recursive because start() calls stop(). + std::recursive_mutex lifecycle_mutex; + std::thread worker; + std::mutex mutex; + std::mutex connection_mutex; + std::mutex write_mutex; // serialises every websocket write (worker + caller threads) + std::shared_ptr active_connection; + std::condition_variable initial_cv; + std::condition_variable state_cv; + Config current_config; + MessageHandler on_message; + StateHandler on_state; + // Full report-topic strings ("device//report"), not bare device ids. + std::set subscriptions; + std::set pending_subscriptions; + std::set pending_unsubscriptions; + // Requests for a subscribed device wait until the corresponding SUBACK is + // received. Otherwise an immediate pushall response can be published by + // the broker before this client is actually subscribed to the report topic. + std::set acknowledged_subscriptions; + std::map pending_subscribe_packets; + std::deque> pending_requests; + 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}; +}; + +} // namespace Slic3r + +#endif // slic3r_OrcaMqttConnection_hpp_ diff --git a/src/slic3r/Utils/OrcaPrinterAgent.cpp b/src/slic3r/Utils/OrcaPrinterAgent.cpp index 93cadd9abd..6c7fed7eab 100644 --- a/src/slic3r/Utils/OrcaPrinterAgent.cpp +++ b/src/slic3r/Utils/OrcaPrinterAgent.cpp @@ -1,18 +1,377 @@ #include "OrcaPrinterAgent.hpp" +#include "IPrinterAgent.hpp" #include "NetworkAgentFactory.hpp" #include "OrcaCloudServiceAgent.hpp" +#include +#include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include +#include namespace Slic3r { const std::string OrcaPrinterAgent_VERSION = "0.0.1"; -OrcaPrinterAgent::OrcaPrinterAgent(std::string log_dir) : log_dir(std::move(log_dir)) +class OrcaPrinterAgent::OrcaSonarDiscovery { +public: + using EmitFn = std::function; + + explicit OrcaSonarDiscovery(EmitFn emit) : m_emit(std::move(emit)) {} + ~OrcaSonarDiscovery() { stop(); } + + OrcaSonarDiscovery(const OrcaSonarDiscovery&) = delete; + OrcaSonarDiscovery& operator=(const OrcaSonarDiscovery&) = delete; + + void start() + { + std::lock_guard lock(m_lifecycle_mutex); + if (m_running.exchange(true)) + return; + m_thread = std::thread(&OrcaSonarDiscovery::browse_loop, this); + } + + void stop() + { + std::lock_guard lock(m_lifecycle_mutex); + if (!m_running.exchange(false)) + return; + m_wait_cv.notify_all(); + if (m_thread.joinable()) + m_thread.join(); + } + +private: + static std::string lower_ascii(std::string value) + { + std::transform(value.begin(), value.end(), value.begin(), [](unsigned char c) { return static_cast(std::tolower(c)); }); + return value; + } + + static std::string trim_ascii(const std::string& value) + { + const auto first = value.find_first_not_of(" \t\r\n"); + if (first == std::string::npos) + return {}; + const auto last = value.find_last_not_of(" \t\r\n"); + return value.substr(first, last - first + 1); + } + + static bool get_header(const std::string& datagram, const std::string& header_name, std::string& value) + { + std::size_t line_start = 0; + while (line_start < datagram.size()) { + const std::size_t line_end = datagram.find('\n', line_start); + const std::string line = datagram.substr(line_start, line_end == std::string::npos ? std::string::npos : line_end - line_start); + line_start = line_end == std::string::npos ? datagram.size() : line_end + 1; + + const std::size_t colon = line.find(':'); + if (colon == std::string::npos) + continue; + if (lower_ascii(trim_ascii(line.substr(0, colon))) != lower_ascii(header_name)) + continue; + value = trim_ascii(line.substr(colon + 1)); + return !value.empty(); + } + return false; + } + + static bool make_machine_alive_json(const std::string& usn, const std::string& host, const std::string& location, std::string& json) + { + const std::string lower_usn = lower_ascii(usn); + static const std::string uuid_prefix = "uuid:"; + static const std::string device_type = "::urn:schemas-upnp-org:device:basic:1"; + if (lower_usn.rfind(uuid_prefix, 0) != 0) + return false; + + const std::size_t type_start = lower_usn.find(device_type, uuid_prefix.size()); + if (type_start == std::string::npos) + return false; + const std::string device_id = trim_ascii(usn.substr(uuid_prefix.size(), type_start - uuid_prefix.size())); + if (device_id.empty() || host.empty()) + return false; + + const std::string lower_location = lower_ascii(location); + const std::size_t scheme_end = lower_location.find("://"); + if (scheme_end == std::string::npos) + return false; + const std::size_t authority_start = scheme_end + 3; + const std::size_t authority_end = location.find_first_of("/ ?#", authority_start); + const std::string authority = location.substr(authority_start, authority_end == std::string::npos ? + std::string::npos : + authority_end - authority_start); + std::string port = "8280"; + if (!authority.empty()) { + if (authority.front() == '[') { + const std::size_t bracket = authority.find(']'); + if (bracket != std::string::npos && bracket + 1 < authority.size() && authority[bracket + 1] == ':') + port = authority.substr(bracket + 2); + } else { + const std::size_t colon = authority.rfind(':'); + if (colon != std::string::npos && colon + 1 < authority.size()) + port = authority.substr(colon + 1); + } + } + if (port.empty() || port.find_first_not_of("0123456789") != std::string::npos) + return false; + + nlohmann::json machine; + machine["dev_name"] = device_id; + machine["dev_id"] = device_id; + machine["dev_ip"] = host + ":" + port; + machine["dev_type"] = "orcasonar"; + machine["dev_signal"] = "0"; + machine["connect_type"] = "lan"; + machine["bind_state"] = "free"; + machine["sec_link"] = "secure"; + machine["ssdp_version"] = "v1"; + machine["connection_name"] = device_id; + json = machine.dump(); + return true; + } + + void ssdp_round() + { + namespace asio = boost::asio; + using asio::ip::udp; + try { + asio::io_context io_context; + udp::socket socket(io_context); + socket.open(udp::v4()); + socket.set_option(udp::socket::reuse_address(true)); + socket.bind(udp::endpoint(udp::v4(), 0)); + socket.non_blocking(true); + + static constexpr char search_request[] = "M-SEARCH * HTTP/1.1\r\n" + "HOST: 239.255.255.250:1900\r\n" + "MAN: \"ssdp:discover\"\r\n" + "MX: 2\r\n" + "ST: urn:schemas-upnp-org:device:Basic:1\r\n" + "\r\n"; + const auto multicast = asio::ip::make_address_v4("239.255.255.250"); + socket.send_to(asio::buffer(search_request, sizeof(search_request) - 1), udp::endpoint(multicast, 1900)); + + std::array buffer{}; + udp::endpoint sender; + std::set seen_ids; + const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(3); + while (m_running.load() && std::chrono::steady_clock::now() < deadline) { + boost::system::error_code error; + const std::size_t received = socket.receive_from(asio::buffer(buffer), sender, 0, error); + if (!error) { + const std::string datagram(buffer.data(), received); + std::string usn; + std::string location; + std::string server; + if (get_header(datagram, "USN", usn) && get_header(datagram, "LOCATION", location) && + (!get_header(datagram, "SERVER", server) || lower_ascii(server).find("orcasonar") != std::string::npos)) { + std::string machine_alive; + if (make_machine_alive_json(usn, sender.address().to_string(), location, machine_alive)) { + nlohmann::json machine = nlohmann::json::parse(machine_alive); + const std::string device_id = machine["dev_id"].get(); + if (seen_ids.insert(device_id).second && m_emit) + m_emit(machine_alive); + } + } + } else if (error != asio::error::would_block && error != asio::error::try_again) { + BOOST_LOG_TRIVIAL(warning) << "OrcaSonarDiscovery: SSDP receive failed: " << error.message(); + break; + } else { + std::this_thread::sleep_for(std::chrono::milliseconds(50)); + } + } + } catch (const std::exception& error) { + BOOST_LOG_TRIVIAL(warning) << "OrcaSonarDiscovery: SSDP round failed: " << error.what(); + } + } + + void browse_loop() + { + while (m_running.load()) { + ssdp_round(); + std::unique_lock lock(m_wait_mutex); + m_wait_cv.wait_for(lock, std::chrono::seconds(5), [this] { return !m_running.load(); }); + } + } + + EmitFn m_emit; + std::atomic m_running{false}; + std::thread m_thread; + std::mutex m_lifecycle_mutex; + std::mutex m_wait_mutex; + std::condition_variable m_wait_cv; +}; + +OrcaPrinterAgent::OrcaPrinterAgent(std::string log_dir) : log_dir(std::move(log_dir)) {} + +const char* OrcaPrinterAgent::connection_type_name(CurrentConn connection) +{ + switch (connection) { + case LAN: return "LAN"; + case CLOUD: return "cloud"; + case NONE: return "none"; + } + return "unknown"; } -OrcaPrinterAgent::~OrcaPrinterAgent() = default; +OrcaPrinterAgent::~OrcaPrinterAgent() +{ + start_discovery(false, false); + ++m_lan_generation; // fence any late worker callback + ++m_cloud_generation; + + // Drop the cloud status callback before anything else: it holds `this`, and the + // cloud agent outlives the printer agent (NetworkAgent::set_printer_agent swaps + // the printer agent while m_cloud_agents persist). + if (auto* cloud = get_orca_cloud_agent()) + cloud->set_printer_status_callback(nullptr); + + // Stop the LAN connection so the connect thread's start() returns, but keep the + // object alive until that thread is joined (the thread holds a raw conn pointer). + OrcaMqttConnection* live_lan = nullptr; + { + std::lock_guard l(state_mutex); + live_lan = lan_mqtt_connection.get(); + } + if (live_lan) + live_lan->stop(); + + // Same for the cloud per-printer connection the cloud connect thread may hold. + if (auto* cloud = get_orca_cloud_agent()) + cloud->teardown_selected_printer_mqtt(); + + if (m_lan_connect_thread.joinable()) + m_lan_connect_thread.join(); + if (m_cloud_connect_thread.joinable()) + m_cloud_connect_thread.join(); + + // stop() is not sticky: a connect thread that had not yet reached start() when the + // teardown above ran could have raised a fresh socket in between. Tear down once + // more now that both threads are joined, so no live socket survives *this. + if (auto* cloud = get_orca_cloud_agent()) + cloud->teardown_selected_printer_mqtt(); + + { + std::lock_guard l(state_mutex); + lan_mqtt_connection.reset(); + } +} + +OrcaCloudServiceAgent* OrcaPrinterAgent::get_orca_cloud_agent() +{ + if (!m_cloud_agent) + return nullptr; + + return dynamic_cast(m_cloud_agent.get()); +} + +OrcaMqttConnection* OrcaPrinterAgent::get_appropriate_mqtt_connection(bool is_lan) +{ + if (is_lan) { + std::lock_guard l(state_mutex); + return lan_mqtt_connection.get(); + } + auto* cloud = get_orca_cloud_agent(); + return cloud ? cloud->get_mqtt_connection() : nullptr; +} + +void OrcaPrinterAgent::deliver_to_sink(const std::string& dev_id, const std::string& payload) +{ + OnMessageFn fn; + QueueOnMainFn q; + { + std::lock_guard l(state_mutex); + fn = on_message_fn; + q = queue_on_main_fn; + } + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: delivering cloud message dev_id=" << dev_id + << " payload_bytes=" << payload.size() + << " callback=" << (fn ? "set" : "null") + << " queue_on_main=" << (q ? "set" : "null"); + if (!fn) { + BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: dropping cloud message because on_message_fn is not set" + << " dev_id=" << dev_id; + return; + } + if (q) + q([fn, dev_id, payload] { fn(dev_id, payload); }); + else + fn(dev_id, payload); +} + +void OrcaPrinterAgent::deliver_to_local_sink(const std::string& dev_id, const std::string& payload) +{ + parse_ipcam_info(dev_id, payload); + + OnMessageFn fn; + QueueOnMainFn q; + { + std::lock_guard l(state_mutex); + fn = on_local_message_fn; + q = queue_on_main_fn; + } + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: delivering LAN message dev_id=" << dev_id + << " payload_bytes=" << payload.size() + << " callback=" << (fn ? "set" : "null") + << " queue_on_main=" << (q ? "set" : "null"); + if (!fn) { + BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: dropping LAN message because on_local_message_fn is not set" + << " dev_id=" << dev_id; + return; + } + if (q) + q([fn, dev_id, payload] { fn(dev_id, payload); }); + else + fn(dev_id, payload); +} + +void OrcaPrinterAgent::dispatch_local_connect(int state, const std::string& dev_id, const std::string& message) +{ + OnLocalConnectedFn callback; + QueueOnMainFn queue; + { + std::lock_guard lock(state_mutex); + callback = on_local_connect_fn; + queue = queue_on_main_fn; + } + + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: LAN connection callback state=" << state + << " dev_id=" << dev_id << " message=" << message + << " callback=" << (callback ? "set" : "null") + << " queue_on_main=" << (queue ? "set" : "null"); + if (!callback) + return; + + auto dispatch = [callback, state, dev_id, message] { callback(state, dev_id, message); }; + if (queue) + queue(dispatch); + else + dispatch(); +} + +std::function OrcaPrinterAgent::make_lan_message_handler(uint64_t generation) +{ + return [this, generation](const std::string& id, const std::string& payload) { + if (generation == m_lan_generation.load()) + deliver_to_local_sink(id, payload); + else + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: dropping stale LAN message generation=" << generation + << " current_generation=" << m_lan_generation.load() + << " dev_id=" << id; + }; +} void OrcaPrinterAgent::set_cloud_agent(std::shared_ptr cloud) { @@ -20,104 +379,544 @@ void OrcaPrinterAgent::set_cloud_agent(std::shared_ptr cloud { std::lock_guard lock(state_mutex); m_cloud_agent = cloud; - m_orca_cloud = dynamic_cast(cloud.get()); } - if (!m_orca_cloud) { + if (!get_orca_cloud_agent()) { BOOST_LOG_TRIVIAL(warning) << "OrcaPrinterAgent::set_cloud_agent: cloud is not OrcaCloudServiceAgent"; - return; // BBL provider active - nothing to bridge + return; // BBL provider active - nothing to bridge } // OrcaCloudServiceAgent owns the aggregate MQTT socket; it already strips the // device//report topic and hands us (dev_id, raw_json). Forward to the // standard sink. message_arrive_fn self-marshals to the UI thread via CallAfter, // so being called from the MQTT worker thread is fine. - const int callback_result = m_orca_cloud->set_printer_status_callback([this](std::string dev_id, std::string payload) { - BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent: received cloud status dev_id=" << dev_id - << " payload_bytes=" << payload.size(); - OnMessageFn fn; - { - std::lock_guard lock(state_mutex); - fn = on_message_fn; - } - if (fn) - fn(std::move(dev_id), std::move(payload)); - else - BOOST_LOG_TRIVIAL(warning) << "OrcaPrinterAgent: cloud status has no registered on_message callback"; - }); + const int callback_result = get_orca_cloud_agent()->set_printer_status_callback( + [this](std::string dev_id, std::string payload) { deliver_to_sink(dev_id, payload); }); BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent::set_cloud_agent: status callback result=" << callback_result; } // ============================================================================ -// Communication - All Stubs +// Communication // ============================================================================ -int OrcaPrinterAgent::send_message(std::string dev_id, std::string json_str, int qos, int flag) -{ - (void) qos; - (void) flag; // MQTT concepts; N/A for the REST command endpoint +int OrcaPrinterAgent::send_message(std::string dev_id, std::string json_str, int /*qos*/, int /*flag*/) +{ return route_send(/*is_lan=*/false, dev_id, json_str); } - std::shared_ptr cloud; - { - std::lock_guard lock(state_mutex); - cloud = m_cloud_agent; - } - BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent::send_message: dev_id=" << dev_id - << " payload_bytes=" << json_str.size() << " qos=" << qos << " flag=" << flag - << " cloud=" << (cloud ? cloud->get_id() : ""); - if (!cloud || dev_id.empty()) { - BOOST_LOG_TRIVIAL(warning) << "OrcaPrinterAgent::send_message: rejected due to missing cloud or device ID"; +int OrcaPrinterAgent::command_ams_refresh_rfid(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode) +{ + int tray_number = 0; + if (!parse_nonnegative_command_id(tray_id, tray_number)) { + BOOST_LOG_TRIVIAL(warning) << "OrcaPrinterAgent: invalid RFID tray id=" << tray_id; return BAMBU_NETWORK_ERR_INVALID_HANDLE; } - // Detached worker so the UI thread is never blocked on HTTP. Capture a shared_ptr - // copy (keeps the cloud agent alive) - never `this`. - std::thread([cloud, dev_id, body = std::move(json_str)]() { - if (auto* orca = dynamic_cast(cloud.get())) { - const int result = orca->send_printer_command(dev_id, body); - BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent::send_message: cloud command result=" << result - << " dev_id=" << dev_id; - } else { - BOOST_LOG_TRIVIAL(error) << "OrcaPrinterAgent::send_message: cloud agent is not OrcaCloudServiceAgent"; - } - }).detach(); + nlohmann::json j; + j["print"]["command"] = "ams_get_rfid"; + j["print"]["sequence_id"] = std::to_string(sequence_id); + j["print"]["tray_id"] = tray_number; + return route_send(lan_mode, dev_id, j.dump()); +} - return BAMBU_NETWORK_SUCCESS; +int OrcaPrinterAgent::command_ams_calibrate(std::string /*dev_id*/, int /*ams_id*/, int /*sequence_id*/, bool /*lan_mode*/) +{ + // OrcaSonar has no ams_calibrate command. Do not send the Bambu M620 C + // dialect through the vendor-neutral OrcaSonar gcode_line command. + BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent: AMS calibration is not part of the OrcaSonar API"; + return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; +} + +int OrcaPrinterAgent::command_ams_select_tray(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode) +{ + int tray_number = 0; + if (!parse_nonnegative_command_id(tray_id, tray_number)) { + BOOST_LOG_TRIVIAL(warning) << "OrcaPrinterAgent: invalid AMS target tray id=" << tray_id; + return BAMBU_NETWORK_ERR_INVALID_HANDLE; + } + + nlohmann::json j; + j["print"]["command"] = "ams_change_filament"; + j["print"]["sequence_id"] = std::to_string(sequence_id); + j["print"]["target"] = tray_number; + return route_send(lan_mode, dev_id, j.dump()); +} + +int OrcaPrinterAgent::command_start_camera(std::string /*dev_id*/) +{ + // OrcaSonar exposes camera.ipcam_* controls, not the legacy start_camera + // operation used by the Bambu agent. + BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent: camera start is not part of the OrcaSonar API"; + return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; +} + +int OrcaPrinterAgent::command_xyz_abs(std::string dev_id, int sequence_id, bool lan_mode) +{ + nlohmann::json j; + j["print"]["command"] = "gcode_line"; + j["print"]["param"] = "G90\n"; + j["print"]["sequence_id"] = std::to_string(sequence_id); + return route_send(lan_mode, dev_id, j.dump()); +} + +int OrcaPrinterAgent::command_auto_leveling(std::string dev_id, int sequence_id, bool lan_mode) +{ + nlohmann::json j; + j["print"]["command"] = "gcode_line"; + j["print"]["param"] = "G29\n"; + j["print"]["sequence_id"] = std::to_string(sequence_id); + return route_send(lan_mode, dev_id, j.dump()); +} + +int OrcaPrinterAgent::command_go_home(std::string dev_id, bool is_printing, bool supports_mqtt_homing, + int sequence_id, bool lan_mode) +{ + nlohmann::json j; + j["print"]["sequence_id"] = std::to_string(sequence_id); + if (supports_mqtt_homing) { + j["print"]["command"] = "back_to_center"; + } else { + // Preserve the existing safety behavior: never home Z/Y during a print. + j["print"]["command"] = "gcode_line"; + j["print"]["param"] = is_printing ? "G28 X\n" : "G28\n"; + } + return route_send(lan_mode, dev_id, j.dump()); +} + +int OrcaPrinterAgent::command_set_bed(std::string dev_id, int temp, bool /*supports_mqtt_bed_ctrl*/, + int sequence_id, bool lan_mode) +{ + nlohmann::json j; + j["print"]["command"] = "set_bed_temp"; + j["print"]["sequence_id"] = std::to_string(sequence_id); + j["print"]["temp"] = temp; + return route_send(lan_mode, dev_id, j.dump()); +} + +int OrcaPrinterAgent::command_set_nozzle(std::string dev_id, int temp, int sequence_id, bool lan_mode) +{ + nlohmann::json j; + j["print"]["command"] = "set_nozzle_temp"; + j["print"]["sequence_id"] = std::to_string(sequence_id); + j["print"]["extruder_index"] = 0; + j["print"]["target_temp"] = temp; + return route_send(lan_mode, dev_id, j.dump()); +} + +int OrcaPrinterAgent::command_axis_control(std::string dev_id, std::string axis, double unit, double input_val, + int /*speed*/, bool is_core_xy, bool /*supports_mqtt_axis_control*/, + int sequence_id, bool lan_mode) +{ + std::transform(axis.begin(), axis.end(), axis.begin(), [](unsigned char c) { return static_cast(std::toupper(c)); }); + if (axis != "X" && axis != "Y" && axis != "Z" && axis != "E") { + BOOST_LOG_TRIVIAL(warning) << "OrcaPrinterAgent: invalid axis control axis=" << axis; + return BAMBU_NETWORK_ERR_INVALID_HANDLE; + } + + const double requested_distance = input_val * unit; + if (!std::isfinite(requested_distance) || requested_distance == 0.0) { + BOOST_LOG_TRIVIAL(warning) << "OrcaPrinterAgent: invalid axis control distance input=" << input_val + << " unit=" << unit; + return BAMBU_NETWORK_ERR_INVALID_HANDLE; + } + + int direction = requested_distance > 0.0 ? 1 : -1; + if (!is_core_xy && (axis == "Y" || axis == "Z")) + direction = -direction; + + nlohmann::json j; + j["print"]["command"] = "xyz_ctrl"; + j["print"]["sequence_id"] = std::to_string(sequence_id); + j["print"]["axis"] = axis; + j["print"]["dir"] = direction; + j["print"]["distance"] = requested_distance < 0.0 ? -requested_distance : requested_distance; + return route_send(lan_mode, dev_id, j.dump()); +} + +bool OrcaPrinterAgent::parse_lan_endpoint(const std::string& dev_ip, std::string& host, std::string& port) +{ + std::string s = dev_ip; + if (s.rfind("http://", 0) == 0) + s.erase(0, 7); + else if (s.rfind("https://", 0) == 0) + s.erase(0, 8); + if (const auto slash = s.find('/'); slash != std::string::npos) + s.erase(slash); + if (s.empty()) + return false; + port = "8280"; + // split a trailing :port only for host:port, not an unbracketed IPv6 literal + if (const auto colon = s.rfind(':'); colon != std::string::npos && s.find(']') == std::string::npos) { + port = s.substr(colon + 1); + s.erase(colon); + } + if (s.empty() || port.empty()) + return false; + host = s; + return true; +} + +std::string OrcaPrinterAgent::make_lan_client_id(const std::string& dev_id) +{ + static const std::string suffix = [] { + std::random_device rd; + char buf[9]; + std::snprintf(buf, sizeof(buf), "%08x", static_cast(rd())); + return std::string(buf); + }(); + return "orcaslicer-lan-" + dev_id + "-" + suffix; +} + +bool OrcaPrinterAgent::parse_nonnegative_command_id(const std::string& value, int& result) +{ + if (value.empty()) + return false; + try { + std::size_t consumed = 0; + const long long parsed = std::stoll(value, &consumed); + if (consumed != value.size() || parsed < 0 || parsed > std::numeric_limits::max()) + return false; + result = static_cast(parsed); + return true; + } catch (const std::exception&) { + return false; + } +} + +void OrcaPrinterAgent::parse_ipcam_info(const std::string& dev_id, const std::string& payload) +{ + const nlohmann::json envelope = nlohmann::json::parse(payload, nullptr, false); + if (!envelope.is_object()) + return; + + const auto print_it = envelope.find("print"); + if (print_it == envelope.end() || !print_it->is_object()) + return; + + const nlohmann::json& print = *print_it; + const auto command_it = print.find("command"); + const bool is_push_status = command_it != print.end() && command_it->is_string() && command_it->get() == "push_status"; + bool is_full_snapshot = false; + if (is_push_status) { + const auto msg_it = print.find("msg"); + is_full_snapshot = msg_it == print.end() || (msg_it->is_number_integer() && msg_it->get() == 0); + } + + CameraStreamMode stream_mode = CameraStreamMode::none; + std::string stream_url; + bool has_camera_update = false; + const auto ipcam_it = print.find("ipcam"); + if (ipcam_it != print.end() && ipcam_it->is_object()) { + const auto stream_modes_it = ipcam_it->find("stream_mode"); + if (stream_modes_it != ipcam_it->end() && stream_modes_it->is_array()) { + has_camera_update = true; + for (const auto& stream : *stream_modes_it) { + if (!stream.is_object()) + continue; + const auto mode_it = stream.find("mode"); + const auto url_it = stream.find("url"); + if (mode_it == stream.end() || url_it == stream.end() || !mode_it->is_string() || !url_it->is_string()) + continue; + + const std::string mode = mode_it->get(); + if (mode == "rtsp") + stream_mode = CameraStreamMode::rtsp; + else if (mode == "http") + stream_mode = CameraStreamMode::http; + else if (mode == "http_snapshot") + stream_mode = CameraStreamMode::http_snapshot; + else + continue; + + stream_url = url_it->get(); + break; // OrcaSonar orders entries by preference. + } + } + else if (is_full_snapshot) { + has_camera_update = true; + } + } else if (is_full_snapshot) { + // A full push_status without ipcam means the printer has no camera + // stream information. Diff reports omit unchanged domains. + has_camera_update = true; + } + + if (!has_camera_update) + return; + + std::lock_guard lock(state_mutex); + if (m_current_connection != LAN || m_lan_dev_id != dev_id) { + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: ignoring camera update for inactive LAN printer dev_id=" << dev_id; + return; + } + + m_camera_stream_mode = stream_mode; + m_camera_url = std::move(stream_url); + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: updated camera state dev_id=" << dev_id + << " transport=LAN" + << " mode=" << static_cast(m_camera_stream_mode) + << " url=" << m_camera_url; +} + +std::string OrcaPrinterAgent::lan_connection_target() const +{ + std::lock_guard l(state_mutex); + return m_lan_url; +} + +std::string OrcaPrinterAgent::seq(int n) { return std::to_string(20000 + (n % 10000)); } + +std::string OrcaPrinterAgent::build_pushing_start(const std::string& sid) +{ return R"({"pushing":{"command":"start","sequence_id":")" + sid + R"("}})"; } +std::string OrcaPrinterAgent::build_pushing_stop(const std::string& sid) +{ return R"({"pushing":{"command":"stop","sequence_id":")" + sid + R"("}})"; } +std::string OrcaPrinterAgent::build_pushall(const std::string& sid) +{ return R"({"pushing":{"command":"pushall","sequence_id":")" + sid + R"(","version":1,"push_target":1}})"; } +std::string OrcaPrinterAgent::build_get_version(const std::string& sid) +{ return R"({"info":{"command":"get_version","sequence_id":")" + sid + R"("}})"; } +std::string OrcaPrinterAgent::build_get_capabilities(const std::string& sid) +{ return R"({"info":{"command":"get_capabilities","sequence_id":")" + sid + R"("}})"; } + +void OrcaPrinterAgent::emit_connect_sequence(const std::string& dev_id, + std::function subscribe, + std::function request) +{ + subscribe(dev_id); + request(build_pushing_start(seq(1))); + request(build_pushall(seq(2))); + request(build_get_version(seq(3))); + request(build_get_capabilities(seq(4))); +} + +void OrcaPrinterAgent::on_connected(const std::string& dev_id, OrcaMqttConnection* conn, uint64_t generation) +{ + // Called from both connect paths with whichever epoch that path captured; the two + // counters are independent, so matching either one means the caller is still live. + if (!conn || (generation != m_lan_generation.load() && generation != m_cloud_generation.load())) + return; + emit_connect_sequence( + dev_id, [conn](const std::string& id) { conn->subscribe(id); }, + [conn, dev_id](const std::string& body) { conn->send_request(dev_id, body); }); // dev_id captured BY VALUE } int OrcaPrinterAgent::connect_printer(std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl) { + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: connect_printer requested dev_id=" << dev_id + << " dev_ip=" << dev_ip << " username=" << (username.empty() ? "" : username) + << " password_present=" << (!password.empty()) << " use_ssl=" << use_ssl; + (void) use_ssl; // OrcaSonar LAN is plaintext ws:// + if (dev_id.empty() || dev_ip.empty()) { + BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: connect_printer rejected missing dev_id or dev_ip"; + return BAMBU_NETWORK_ERR_INVALID_HANDLE; + } + std::string host, port; + if (!parse_lan_endpoint(dev_ip, host, port)) { + BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: connect_printer rejected unparsable LAN endpoint dev_ip=" << dev_ip; + return BAMBU_NETWORK_ERR_INVALID_HANDLE; + } + disconnect_printer(); + const uint64_t gen = ++m_lan_generation; + + OrcaMqttConnection::Config cfg; + cfg.url = "ws://" + host + ":" + port + "/mqtt"; + cfg.use_tls = false; + cfg.username = username.empty() ? std::string("orcasonar") : username; + cfg.password = password; + cfg.client_id = make_lan_client_id(dev_id); + cfg.keepalive_seconds = 60; + + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: LAN connection prepared generation=" << gen + << " host=" << host << " port=" << port << " url=" << cfg.url + << " mqtt_username=" << cfg.username << " password_present=" << (!cfg.password.empty()) + << " client_id=" << cfg.client_id; + + OrcaMqttConnection* conn = nullptr; + CurrentConn previous_connection; + { + std::lock_guard l(state_mutex); + previous_connection = m_current_connection; + m_lan_dev_id = dev_id; + m_lan_url = cfg.url; + m_camera_stream_mode = CameraStreamMode::none; + m_camera_url.clear(); + m_current_connection = LAN; + lan_mqtt_connection = std::make_unique(); + conn = lan_mqtt_connection.get(); + } + BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent: selected LAN printer dev_id=" << dev_id + << " transport=" << connection_type_name(previous_connection) << "->LAN"; + + if (m_lan_connect_thread.joinable()) + m_lan_connect_thread.join(); // disconnect_printer() above already stopped the old conn, so this is fast + m_lan_connect_thread = std::thread([this, conn, cfg, dev_id, gen] { + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: LAN connect worker started generation=" << gen + << " dev_id=" << dev_id << " url=" << cfg.url; + if (gen != m_lan_generation.load()) { + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: LAN connect worker abandoned before start generation=" << gen + << " current_generation=" << m_lan_generation.load(); + return; // superseded before we ran: never raise a socket nobody will tear down + } + const bool ok = conn->start(cfg, make_lan_message_handler(gen), [this, gen, dev_id, conn](bool connected, bool initial) { + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: LAN MQTT state callback connected=" << connected + << " initial=" << initial << " generation=" << gen + << " current_generation=" << m_lan_generation.load() + << " connack_rc=" << conn->last_connack_rc(); + if (gen != m_lan_generation.load()) { + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: ignoring stale LAN MQTT state callback generation=" << gen; + return; + } + if (connected && !initial) { + on_connected(dev_id, conn, gen); + dispatch_local_connect(ConnectStatusOk, dev_id, "0"); + } else if (!connected && !initial) { + dispatch_local_connect(ConnectStatusLost, dev_id, "connection_lost"); + } + }); + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: LAN MQTT start returned ok=" << ok + << " generation=" << gen << " current_generation=" << m_lan_generation.load() + << " connected=" << conn->is_connected() << " running=" << conn->is_running() + << " connack_rc=" << conn->last_connack_rc(); + if (ok && gen == m_lan_generation.load()) { + on_connected(dev_id, conn, gen); + dispatch_local_connect(ConnectStatusOk, dev_id, "0"); + } else if (!ok && gen == m_lan_generation.load() && !conn->is_running()) { + // A refusal with rc 4/5 terminates the transport. Network errors keep + // retrying in OrcaMqttConnection, so leave the UI in its connecting state. + const int rc = conn->last_connack_rc(); + const std::string reason = rc >= 0 ? std::to_string(rc) : "initial_connect_failed"; + BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: LAN MQTT connection terminated before readiness" + << " generation=" << gen << " connack_rc=" << rc + << " reason=" << reason; + dispatch_local_connect(ConnectStatusFailed, dev_id, reason); + } else if (!ok && gen == m_lan_generation.load()) { + BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: LAN MQTT initial attempt failed but worker is retrying" + << " generation=" << gen << " connack_rc=" << conn->last_connack_rc(); + } + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: LAN connect worker exiting generation=" << gen + << " current_generation=" << m_lan_generation.load(); + }); + return BAMBU_NETWORK_SUCCESS; } int OrcaPrinterAgent::disconnect_printer() { + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: disconnect_printer requested"; + ++m_lan_generation; // fence stale worker callbacks + std::unique_ptr doomed; + std::string prev_dev; + CurrentConn previous_connection; + CurrentConn current_connection; + { + std::lock_guard l(state_mutex); + previous_connection = m_current_connection; + doomed = std::move(lan_mqtt_connection); + prev_dev = m_lan_dev_id; + m_lan_dev_id.clear(); + if (m_current_connection == LAN) { + m_current_connection = NONE; + m_camera_stream_mode = CameraStreamMode::none; + m_camera_url.clear(); + } + current_connection = m_current_connection; + } + BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: LAN disconnect generation=" << m_lan_generation.load() + << " previous_dev_id=" << prev_dev << " had_connection=" << (doomed ? "yes" : "no") + << " connected=" << (doomed && doomed->is_connected() ? "yes" : "no") + << " transport=" << connection_type_name(previous_connection) << "->" + << connection_type_name(current_connection); + // Tell the printer to stop pushing and drop the report topic before the socket + // goes away (§3.2/§5.4: deselect issues pushing.stop on both transports). + if (doomed && !prev_dev.empty() && doomed->is_connected()) { + doomed->send_request(prev_dev, build_pushing_stop(seq(5))); + doomed->unsubscribe(prev_dev); + } + if (doomed) + doomed->stop(); // joins the OrcaMqttConnection worker; OUTSIDE state_mutex + if (m_lan_connect_thread.joinable()) + m_lan_connect_thread.join(); // start() has returned (doomed->stop above); the thread's raw conn ptr + // is still valid here because `doomed` is not destroyed until we return return BAMBU_NETWORK_SUCCESS; } -int OrcaPrinterAgent::send_message_to_printer(std::string dev_id, std::string json_str, int qos, int flag) +int OrcaPrinterAgent::send_message_to_printer(std::string dev_id, std::string json_str, int /*qos*/, int /*flag*/) +{ return route_send(/*is_lan=*/true, dev_id, json_str); } + +int OrcaPrinterAgent::route_send(bool is_lan, const std::string& dev_id, const std::string& json_str) { - return BAMBU_NETWORK_SUCCESS; + std::string command = ""; + try { + const nlohmann::json envelope = nlohmann::json::parse(json_str); + for (const char* namespace_name : {"pushing", "info", "print", "system", "camera", "xcam", "upgrade", "event", "files"}) { + const auto namespace_it = envelope.find(namespace_name); + if (namespace_it != envelope.end() && namespace_it->is_object()) { + const auto command_it = namespace_it->find("command"); + if (command_it != namespace_it->end() && command_it->is_string()) { + command = std::string(namespace_name) + "." + command_it->get(); + break; + } + } + } + } catch (const std::exception&) { + // Preserve the transport's existing behavior for malformed payloads; + // the printer will report the protocol error asynchronously. + } + BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent::route_send is_lan=" << is_lan << " dev_id=" << dev_id + << " command=" << command << " payload_bytes=" << json_str.size(); + if (dev_id.empty()) + return BAMBU_NETWORK_ERR_INVALID_HANDLE; + OrcaMqttConnection* conn = get_appropriate_mqtt_connection(is_lan); + if (!conn) + return BAMBU_NETWORK_ERR_INVALID_HANDLE; + const bool queued = conn->send_request(dev_id, json_str); + BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent::route_send command=" << command << " queued=" << queued + << " is_lan=" << is_lan << " dev_id=" << dev_id; + return queued ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED; } // ============================================================================ // Certificates - All Stubs // ============================================================================ -int OrcaPrinterAgent::check_cert() -{ - return BAMBU_NETWORK_SUCCESS; -} +int OrcaPrinterAgent::check_cert() { return BAMBU_NETWORK_SUCCESS; } -void OrcaPrinterAgent::install_device_cert(std::string dev_id, bool lan_only) -{ -} +void OrcaPrinterAgent::install_device_cert(std::string dev_id, bool lan_only) {} // ============================================================================ -// Discovery - Stub +// Discovery // ============================================================================ -bool OrcaPrinterAgent::start_discovery(bool start, bool sending) +bool OrcaPrinterAgent::start_discovery(bool start, bool /*sending*/) { + if (start) { + std::lock_guard lock(state_mutex); + if (!m_discovery) { + m_discovery = std::make_unique([this](const std::string& machine_alive) { + OnMsgArrivedFn ssdp_fn; + QueueOnMainFn queue_fn; + { + std::lock_guard callback_lock(state_mutex); + ssdp_fn = on_ssdp_msg_fn; + queue_fn = queue_on_main_fn; + } + if (!ssdp_fn) + return; + if (queue_fn) + queue_fn([ssdp_fn, machine_alive] { ssdp_fn(machine_alive); }); + else + ssdp_fn(machine_alive); + }); + } + m_discovery->start(); + return true; + } + + // The discovery thread invokes the callback, which takes state_mutex. Move the + // owner out first, then join without holding that mutex. + std::unique_ptr discovery; + { + std::lock_guard lock(state_mutex); + discovery = std::move(m_discovery); + } + if (discovery) + discovery->stop(); return true; } @@ -125,26 +924,20 @@ bool OrcaPrinterAgent::start_discovery(bool start, bool sending) // Binding - All Stubs // ============================================================================ -int OrcaPrinterAgent::ping_bind(std::string ping_code) -{ - return BAMBU_NETWORK_SUCCESS; -} +int OrcaPrinterAgent::ping_bind(std::string ping_code) { return BAMBU_NETWORK_SUCCESS; } -int OrcaPrinterAgent::bind_detect(std::string dev_ip, std::string sec_link, detectResult& detect) -{ - return BAMBU_NETWORK_SUCCESS; -} +int OrcaPrinterAgent::bind_detect(std::string dev_ip, std::string sec_link, detectResult& detect) { return BAMBU_NETWORK_SUCCESS; } -int OrcaPrinterAgent::bind( - std::string dev_ip, std::string dev_id, std::string dev_model, std::string sec_link, std::string timezone, bool improved, OnUpdateStatusFn update_fn) -{ - return BAMBU_NETWORK_SUCCESS; -} +int OrcaPrinterAgent::bind(std::string dev_ip, + std::string dev_id, + std::string dev_model, + std::string sec_link, + std::string timezone, + bool improved, + OnUpdateStatusFn update_fn) +{ return BAMBU_NETWORK_SUCCESS; } -int OrcaPrinterAgent::unbind(std::string dev_id) -{ - return BAMBU_NETWORK_SUCCESS; -} +int OrcaPrinterAgent::unbind(std::string dev_id) { return BAMBU_NETWORK_SUCCESS; } int OrcaPrinterAgent::request_bind_ticket(std::string* ticket) { @@ -181,107 +974,101 @@ std::string OrcaPrinterAgent::get_user_selected_machine() int OrcaPrinterAgent::set_user_selected_machine(std::string dev_id) { - std::shared_ptr cloud; + auto* cloud = get_orca_cloud_agent(); std::string previous; + CurrentConn previous_connection; + CurrentConn current_connection; { std::lock_guard lock(state_mutex); - if (dev_id == selected_machine) { - BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent::set_user_selected_machine: unchanged dev_id=" << dev_id; + previous_connection = m_current_connection; + // An empty cloud selection must not clear an independently active LAN + // selection. Conversely, selecting a cloud machine with the same id + // while LAN is active is still a transport switch and must proceed. + const bool same_selection = dev_id == selected_machine; + const bool same_transport = dev_id.empty() ? m_current_connection != CLOUD : m_current_connection == CLOUD; + if (same_selection && same_transport) { + BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent::set_user_selected_machine: unchanged dev_id=" << dev_id + << " transport=" << connection_type_name(m_current_connection); return BAMBU_NETWORK_SUCCESS; } previous = selected_machine; selected_machine = dev_id; - cloud = m_cloud_agent; + if (dev_id.empty()) { + if (m_current_connection == CLOUD) { + m_current_connection = NONE; + m_camera_stream_mode = CameraStreamMode::none; + m_camera_url.clear(); + } + } else { + m_current_connection = CLOUD; + m_camera_stream_mode = CameraStreamMode::none; + m_camera_url.clear(); + } + current_connection = m_current_connection; } - BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent::set_user_selected_machine: previous=" << previous - << " new=" << dev_id << " cloud=" << (cloud ? cloud->get_id() : ""); + BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent::set_user_selected_machine: previous=" << previous << " new=" << dev_id + << " cloud=" << (cloud ? "set" : "") << " transport=" + << connection_type_name(previous_connection) << "->" + << connection_type_name(current_connection); if (!cloud) { - BOOST_LOG_TRIVIAL(warning) << "OrcaPrinterAgent::set_user_selected_machine: no cloud agent"; + BOOST_LOG_TRIVIAL(warning) << "OrcaPrinterAgent::set_user_selected_machine: no Orca cloud agent"; return BAMBU_NETWORK_SUCCESS; } - // One report topic at a time. add_subscribe/del_subscribe only mutate a set and - // wake the MQTT worker, so they are safe to call synchronously on the UI thread. - if (!previous.empty()) { - const int result = cloud->del_subscribe({previous}); - BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent::set_user_selected_machine: unsubscribe dev_id=" << previous - << " result=" << result; - } + // Bump ONCE at the top for any change (select or deselect) so a deselect also + // fences an in-flight configure thread started by the previous selection. This is + // the CLOUD epoch only — a cloud selection must not fence a live LAN session. + const uint64_t gen = ++m_cloud_generation; + + auto* conn = cloud->get_mqtt_connection(); + if (!previous.empty() && conn && conn->is_connected()) + conn->send_request(previous, build_pushing_stop(seq(5))); + cloud->teardown_selected_printer_mqtt(); + + if (m_cloud_connect_thread.joinable()) + m_cloud_connect_thread.join(); // teardown_selected_printer_mqtt() above stopped the old cloud conn if (!dev_id.empty()) { - const int result = cloud->add_subscribe({dev_id}); - BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent::set_user_selected_machine: subscribe dev_id=" << dev_id - << " result=" << result; - // Relay retains nothing: ask the printer for a full snapshot. Async inside - // send_message; returns immediately. - send_message(dev_id, - R"({"pushing":{"command":"pushall","sequence_id":"20001","version":1,"push_target":1}})", - 0, 0); - deliver_mock_get_version(dev_id); + m_cloud_connect_thread = std::thread([this, cloud, dev_id, gen] { + if (gen != m_cloud_generation.load()) + return; // superseded before we ran: do not raise a socket nobody tears down + if (cloud->configure_selected_printer_mqtt(dev_id) == BAMBU_NETWORK_SUCCESS && gen == m_cloud_generation.load()) + on_connected(dev_id, cloud->get_mqtt_connection(), gen); + }); + } else { + // Deselect: the joined thread may have raised a fresh socket between the + // teardown above and the join. stop() is not sticky, so tear down again. + cloud->teardown_selected_printer_mqtt(); } return BAMBU_NETWORK_SUCCESS; } -void OrcaPrinterAgent::deliver_mock_get_version(const std::string& dev_id) -{ - // The printer would answer an info.get_version request with its firmware/module - // list; OrcaCloud does not relay that yet, so MachineObject::module_vers stays - // empty and is_info_ready(check_version) never passes (StatusPanel bails, every - // field renders N/A). Synthesize the reply and push it through the same sink as - // real report messages so parse_json handles it identically. Remove once the - // backend answers info.get_version on device//report. - OnMessageFn fn; - { - std::lock_guard lock(state_mutex); - fn = on_message_fn; - } - if (!fn) - return; - static const std::string kMockGetVersion = - R"({"info":{"command":"get_version","sequence_id":"0","module":[)" - R"({"name":"ota","product_name":"OrcaCloud Printer","hw_ver":"","sw_ver":"01.00.00.00","sn":""}]}})"; - BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent: delivering mock info.get_version for dev_id=" << dev_id; - fn(dev_id, kMockGetVersion); -} - // ============================================================================ // Agent Information // ============================================================================ AgentInfo OrcaPrinterAgent::get_agent_info_static() -{ - return AgentInfo{ORCA_PRINTER_AGENT_ID, "Orca", OrcaPrinterAgent_VERSION, "Orca Printer Communication Protocol Agent"}; -} +{ return AgentInfo{ORCA_PRINTER_AGENT_ID, "Orca", OrcaPrinterAgent_VERSION, "Orca Printer Communication Protocol Agent"}; } // ============================================================================ // Print Job Operations - All Stubs // ============================================================================ int OrcaPrinterAgent::start_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) -{ - return BAMBU_NETWORK_SUCCESS; -} +{ return BAMBU_NETWORK_SUCCESS; } -int OrcaPrinterAgent::start_local_print_with_record(PrintParams params, +int OrcaPrinterAgent::start_local_print_with_record(PrintParams params, OnUpdateStatusFn update_fn, - WasCancelledFn cancel_fn, - OnWaitFn wait_fn) -{ - return BAMBU_NETWORK_SUCCESS; -} + WasCancelledFn cancel_fn, + OnWaitFn wait_fn) +{ return BAMBU_NETWORK_SUCCESS; } int OrcaPrinterAgent::start_send_gcode_to_sdcard(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) -{ - return BAMBU_NETWORK_SUCCESS; -} +{ return BAMBU_NETWORK_SUCCESS; } int OrcaPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn) -{ - return BAMBU_NETWORK_SUCCESS; -} +{ return BAMBU_NETWORK_SUCCESS; } int OrcaPrinterAgent::start_sdcard_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn) -{ - return BAMBU_NETWORK_SUCCESS; -} +{ return BAMBU_NETWORK_SUCCESS; } // ============================================================================ // Callback Registration @@ -327,6 +1114,7 @@ int OrcaPrinterAgent::set_on_local_connect_fn(OnLocalConnectedFn fn) { std::lock_guard lock(state_mutex); on_local_connect_fn = fn; + BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent::set_on_local_connect_fn: callback=" << (fn ? "set" : "clear"); return BAMBU_NETWORK_SUCCESS; } @@ -334,6 +1122,7 @@ int OrcaPrinterAgent::set_on_local_message_fn(OnMessageFn fn) { std::lock_guard lock(state_mutex); on_local_message_fn = fn; + BOOST_LOG_TRIVIAL(info) << "OrcaPrinterAgent::set_on_local_message_fn: callback=" << (fn ? "set" : "clear"); return BAMBU_NETWORK_SUCCESS; } @@ -344,4 +1133,20 @@ int OrcaPrinterAgent::set_queue_on_main_fn(QueueOnMainFn fn) return BAMBU_NETWORK_SUCCESS; } +CameraStreamMode OrcaPrinterAgent::get_camera_stream_mode() const +{ + std::lock_guard lock(state_mutex); + if (m_current_connection == CLOUD) + return CameraStreamMode::webrtc; + return m_camera_stream_mode; +} + +std::string OrcaPrinterAgent::get_camera_url() const +{ + std::lock_guard lock(state_mutex); + if (m_current_connection != LAN) + return {}; + return m_camera_url; +} + } // namespace Slic3r diff --git a/src/slic3r/Utils/OrcaPrinterAgent.hpp b/src/slic3r/Utils/OrcaPrinterAgent.hpp index 9cf2b29638..ea7128ff5a 100644 --- a/src/slic3r/Utils/OrcaPrinterAgent.hpp +++ b/src/slic3r/Utils/OrcaPrinterAgent.hpp @@ -3,21 +3,28 @@ #include "IPrinterAgent.hpp" #include "ICloudServiceAgent.hpp" +#include "OrcaCloudServiceAgent.hpp" +#include "OrcaMqttConnection.hpp" +#include +#include +#include #include #include #include +#include namespace Slic3r { class OrcaCloudServiceAgent; /** - * OrcaPrinterAgent - Stub implementation for printer operations. + * OrcaPrinterAgent - OrcaSonar MQTT printer agent. * - * All printer-related operations are currently stubs that return success. - * Actual printer connectivity requires the BBL SDK or future Orca implementation. + * LAN and cloud commands use the same OrcaSonar protocol payloads; only the + * MQTT connection selected by route_send() differs. */ -class OrcaPrinterAgent : public IPrinterAgent { +class OrcaPrinterAgent : public IPrinterAgent +{ public: explicit OrcaPrinterAgent(std::string log_dir); ~OrcaPrinterAgent() override; @@ -44,12 +51,21 @@ public: // Binding int ping_bind(std::string ping_code) override; int bind_detect(std::string dev_ip, std::string sec_link, detectResult& detect) override; - int bind(std::string dev_ip, std::string dev_id, std::string dev_model, std::string sec_link, std::string timezone, bool improved, OnUpdateStatusFn update_fn) override; + int bind(std::string dev_ip, + std::string dev_id, + std::string dev_model, + std::string sec_link, + std::string timezone, + bool improved, + OnUpdateStatusFn update_fn) override; int unbind(std::string dev_id) override; int request_bind_ticket(std::string* ticket) override; int get_hms_snapshot(std::string dev_id, std::string file_name, std::function callback) override; int set_server_callback(OnServerErrFn fn) override; + CameraStreamMode get_camera_stream_mode() const override; + std::string get_camera_url() const override; + // Machine Selection std::string get_user_selected_machine() override; int set_user_selected_machine(std::string dev_id) override; @@ -79,16 +95,123 @@ public: int set_on_local_message_fn(OnMessageFn fn) override; int set_queue_on_main_fn(QueueOnMainFn fn) override; + int command_ams_refresh_rfid(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode) override; + int command_ams_calibrate(std::string dev_id, int ams_id, int sequence_id, bool lan_mode) override; + int command_ams_select_tray(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode) override; + int command_start_camera(std::string dev_id) override; + int command_xyz_abs(std::string dev_id, int sequence_id, bool lan_mode) override; + int command_auto_leveling(std::string dev_id, int sequence_id, bool lan_mode) override; + int command_go_home(std::string dev_id, bool is_printing, bool supports_mqtt_homing, int sequence_id, bool lan_mode) override; + int command_set_bed(std::string dev_id, int temp, bool supports_mqtt_bed_ctrl, int sequence_id, bool lan_mode) override; + int command_set_nozzle(std::string dev_id, int temp, int sequence_id, bool lan_mode) override; + int command_axis_control(std::string dev_id, + std::string axis, + double unit, + double input_val, + int speed, + bool is_core_xy, + bool supports_mqtt_axis_control, + int sequence_id, + bool lan_mode) override; + + // Test-only: drive emit_connect_sequence directly (no socket). + void run_connect_sequence_for_test(const std::string& dev_id) + { + emit_connect_sequence(dev_id, [](const std::string&) {}, [](const std::string&) {}); + } + + // Test-only: advance the LAN connection epoch without a connect/disconnect cycle. + void bump_lan_generation_for_test() { ++m_lan_generation; } + // Test-only: the same for the (independent) cloud selection epoch. + void bump_cloud_generation_for_test() { ++m_cloud_generation; } + +protected: + // Forward one inbound printer message to on_message_fn (marshalled onto the UI + // thread via queue_on_main_fn when set). Body of every connection's MessageHandler. + void deliver_to_sink(const std::string& dev_id, const std::string& payload); + + // Extract OrcaSonar's print.ipcam.stream_mode from LAN reports before they + // are forwarded to the GUI. The getters below then read this agent-owned state. + void parse_ipcam_info(const std::string& dev_id, const std::string& payload); + + // LAN has a separate callback in the existing IPrinterAgent contract because the + // GUI parses local reports with the "lan" dialect and looks up local machines. + void deliver_to_local_sink(const std::string& dev_id, const std::string& payload); + + // Report the asynchronous LAN connection state using the same callback contract as + // the other printer agents. The transport result cannot be returned by + // connect_printer(), which only starts the worker. + void dispatch_local_connect(int state, const std::string& dev_id, const std::string& message); + + // The LAN inbound-message handler for one connection generation: forwards to + // deliver_to_sink only while `generation` is still the live epoch. + std::function make_lan_message_handler(uint64_t generation); + + // Pure LAN-address parsing + client-id. protected static so the test Probe reaches them. + static bool parse_lan_endpoint(const std::string& dev_ip, std::string& host, std::string& port); + static std::string make_lan_client_id(const std::string& dev_id); + // Test hook: the ws:// URL connect_printer built for the current LAN session ("" if none). + std::string lan_connection_target() const; + // Shared post-connect sequence: SUBSCRIBE, then pushing.start, pushall, + // info.get_version, info.get_capabilities. Runs identically on LAN and cloud. + void on_connected(const std::string& dev_id, OrcaMqttConnection* conn, uint64_t generation); + + // The post-connect command sequence, factored behind a seam so a test can + // observe the SUBSCRIBE + 4 request payloads without a live OrcaMqttConnection. + virtual void emit_connect_sequence(const std::string& dev_id, + std::function subscribe, + std::function request); + static std::string seq(int n); // decimal string in the OrcaSlicer 20000..29999 band + static std::string build_pushing_start(const std::string& sequence_id); + static std::string build_pushing_stop(const std::string& sequence_id); + static std::string build_pushall(const std::string& sequence_id); + static std::string build_get_version(const std::string& sequence_id); + static std::string build_get_capabilities(const std::string& sequence_id); + private: + class OrcaSonarDiscovery; + std::string log_dir; std::string selected_machine; - std::shared_ptr m_cloud_agent; - OrcaCloudServiceAgent* m_orca_cloud = nullptr; // == m_cloud_agent.get() when the Orca provider is active - // MOCK: OrcaCloud does not yet relay the printer's info.get_version reply, so - // synthesize it and feed it through on_message_fn (same sink as real report - // messages). Delete once the backend answers info.get_version. - void deliver_mock_get_version(const std::string& dev_id); + enum CurrentConn { NONE, CLOUD, LAN }; + static const char* connection_type_name(CurrentConn connection); + + // The transport for the printer currently selected by the UI. LAN and + // cloud sessions have separate connection objects, so this is selection + // state rather than an inference from whichever socket happens to exist. + CurrentConn m_current_connection = NONE; + + std::shared_ptr m_cloud_agent; + std::unique_ptr lan_mqtt_connection; + + // Two independent epochs: a cloud (de)selection must not fence the live LAN + // feed, and vice versa. Each transport's connect thread and inbound handler + // compare against their own counter only. + std::atomic m_lan_generation{0}; + std::atomic m_cloud_generation{0}; + + // The short-lived threads that run the blocking initial connect for the current + // LAN / cloud session. Joined members (never detached) so they cannot outlive + // *this or the connection they hold a raw pointer to. + std::thread m_lan_connect_thread; + std::thread m_cloud_connect_thread; + + std::unique_ptr m_discovery; + + std::string m_lan_dev_id; // guarded by state_mutex + std::string m_lan_url; // guarded by state_mutex — the Config.url of the live LAN session + CameraStreamMode m_camera_stream_mode = CameraStreamMode::none; // guarded by state_mutex + std::string m_camera_url; // guarded by state_mutex + + OrcaCloudServiceAgent* get_orca_cloud_agent(); + + OrcaMqttConnection* get_appropriate_mqtt_connection(bool is_lan = true); + static bool parse_nonnegative_command_id(const std::string& value, int& result); + + // Route one command payload to device//request on the LAN or the cloud + // per-printer connection. The uniform send path for both send_message* overrides. + int route_send(bool is_lan, const std::string& dev_id, const std::string& json_str); // Callbacks OnMsgArrivedFn on_ssdp_msg_fn; diff --git a/tests/slic3rutils/CMakeLists.txt b/tests/slic3rutils/CMakeLists.txt index edff97ff42..6b39c010b9 100644 --- a/tests/slic3rutils/CMakeLists.txt +++ b/tests/slic3rutils/CMakeLists.txt @@ -13,6 +13,8 @@ add_executable(${_TEST_NAME}_tests test_plugin_status.cpp test_printer_agent.cpp test_qidi_printer_agent.cpp + test_orca_mqtt_connection.cpp + test_orca_printer_agent.cpp test_plugin_install.cpp test_plugin_lifecycle.cpp test_slicing_pipeline_bindings.cpp diff --git a/tests/slic3rutils/orca_mqtt_mock_broker.hpp b/tests/slic3rutils/orca_mqtt_mock_broker.hpp new file mode 100644 index 0000000000..8545a4344f --- /dev/null +++ b/tests/slic3rutils/orca_mqtt_mock_broker.hpp @@ -0,0 +1,317 @@ +#pragma once + +// In-process plaintext MQTT-over-WebSocket broker for the OrcaMqtt tests. +// +// It speaks just enough of MQTT 3.1.1 to drive OrcaMqttConnection / +// OrcaPrinterAgent end to end without a real network: CONNECT/CONNACK, +// SUBSCRIBE/SUBACK, UNSUBSCRIBE/UNSUBACK, client PUBLISH (QoS 0), PINGREQ and +// DISCONNECT. The outbound PUBLISH frame is built with the production +// OrcaMqttConnection::make_publish_packet() so the tests never depend on a +// second, hand-rolled MQTT encoder. + +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace orca_mqtt_test { + +namespace net = boost::asio; +namespace beast = boost::beast; +namespace ws = boost::beast::websocket; +using tcp = boost::asio::ip::tcp; + +// Decode an MQTT remaining-length varint starting at packet[offset]. +// Returns {value, bytes_consumed}; bytes_consumed == 0 means malformed. +inline std::pair mqtt_decode_remaining_length(const std::string& packet, std::size_t offset) +{ + std::size_t value = 0; + std::size_t multiplier = 1; + std::size_t used = 0; + while (offset + used < packet.size() && used < 4) { + const std::uint8_t byte = static_cast(packet[offset + used]); + value += static_cast(byte & 0x7f) * multiplier; + multiplier *= 128; + ++used; + if ((byte & 0x80) == 0) + return {value, used}; + } + return {0, 0}; +} + +inline bool mqtt_topic_is_request(const std::string& topic) +{ + static const std::string suffix = "/request"; + return topic.size() >= suffix.size() && + topic.compare(topic.size() - suffix.size(), suffix.size(), suffix) == 0; +} + +class MockBroker +{ +public: + // refuse_auth: answer every CONNECT with CONNACK rc 5 (not authorized) and + // close, so the reconnect/refusal paths can be exercised. + explicit MockBroker(bool refuse_auth = false) : m_refuse_auth(refuse_auth), m_acceptor(m_io) + { + const tcp::endpoint endpoint(net::ip::make_address("127.0.0.1"), 0); + m_acceptor.open(endpoint.protocol()); + m_acceptor.set_option(net::socket_base::reuse_address(true)); + m_acceptor.bind(endpoint); + m_acceptor.listen(net::socket_base::max_listen_connections); + m_port = std::to_string(m_acceptor.local_endpoint().port()); + // why: a non-blocking acceptor lets the accept loop poll a stop flag, so + // the destructor never has to interrupt a blocking accept(). + m_acceptor.non_blocking(true); + m_thread = std::thread([this] { run(); }); + } + + ~MockBroker() + { + m_stopping.store(true); + drop_client(); // unblocks the worker's blocking read + if (m_thread.joinable()) + m_thread.join(); + boost::system::error_code ec; + m_acceptor.close(ec); // after join: the acceptor is worker-owned + m_io.stop(); + } + + MockBroker(const MockBroker&) = delete; + MockBroker& operator=(const MockBroker&) = delete; + + std::string ws_url() const { return "ws://127.0.0.1:" + m_port + "/mqtt"; } + + std::pair host_port() const { return {std::string("127.0.0.1"), m_port}; } + + // Server -> client PUBLISH on device//report. + void push_report(const std::string& dev_id, const std::string& payload) + { + const std::vector packet = + Slic3r::OrcaMqttConnection::make_publish_packet("device/" + dev_id + "/report", payload); + std::lock_guard lock(m_mutex); + if (!m_stream || !m_stream_ready) + return; + boost::system::error_code ec; + m_stream->binary(true); + m_stream->write(net::buffer(packet), ec); // a vanished client is not a test failure + } + + // Force-close the live client socket; the worker's read returns an error and + // the accept loop picks up the client's reconnect. + void drop_client() + { + std::lock_guard lock(m_mutex); + close_client_locked(); + } + + // Payloads the client PUBLISHed to any device//request topic. + std::vector received_requests() const + { + std::lock_guard lock(m_mutex); + return m_received_requests; + } + + // MQTT CONNECTs seen; increments again after a reconnect. + int connect_count() const { return m_connect_count.load(); } + +private: + void run() + { + try { + while (!m_stopping.load()) { + tcp::socket socket(m_io); + boost::system::error_code ec; + m_acceptor.accept(socket, ec); + if (ec == net::error::would_block || ec == net::error::try_again) { + std::this_thread::sleep_for(std::chrono::milliseconds(5)); + continue; + } + if (ec) + return; + try { + serve(std::move(socket)); + } catch (...) { + // a client dying mid-session must not take the broker down + } + std::lock_guard lock(m_mutex); + close_client_locked(); + m_stream.reset(); + } + } catch (...) { + // never let an exception escape the broker thread + } + } + + void serve(tcp::socket socket) + { + ws::stream* stream = nullptr; + { + std::lock_guard lock(m_mutex); + m_stream.emplace(std::move(socket)); + m_stream_ready = false; + stream = &*m_stream; + } + // why: no io_context is ever run here, so a tcp_stream timer would never + // fire; the sync operations below carry no timeout of their own. + beast::get_lowest_layer(*stream).expires_never(); + stream->set_option(ws::stream_base::decorator( + [](ws::response_type& res) { res.set("Sec-WebSocket-Protocol", "mqtt"); })); + + boost::system::error_code ec; + stream->accept(ec); + if (ec) + return; + stream->binary(true); + { + std::lock_guard lock(m_mutex); + m_stream_ready = true; + } + read_loop(*stream); + } + + // The client sends every MQTT packet as one binary WebSocket message, so one + // read yields exactly one packet. + void read_loop(ws::stream& stream) + { + beast::flat_buffer buffer; + while (!m_stopping.load()) { + boost::system::error_code ec; + buffer.clear(); + stream.read(buffer, ec); + if (ec) + return; + const std::string packet = beast::buffers_to_string(buffer.data()); + if (packet.empty()) + continue; + if (!handle_packet(stream, packet)) + return; + } + } + + // Returns false when the session must be closed. + bool handle_packet(ws::stream& stream, const std::string& packet) + { + switch (static_cast(packet[0]) & 0xf0) { + case 0x10: { // CONNECT + ++m_connect_count; + if (m_refuse_auth) { + write_packet(stream, {0x20, 0x02, 0x00, 0x05}); // CONNACK not authorized + return false; + } + write_packet(stream, {0x20, 0x02, 0x00, 0x00}); // CONNACK accepted + return true; + } + case 0x80: { // SUBSCRIBE (0x82) - packet id follows the remaining-length varint + const auto id = packet_id(packet); + if (id) + write_packet(stream, {0x90, 0x03, id->first, id->second, 0x00}); // SUBACK, QoS 0 + return true; + } + case 0xa0: { // UNSUBSCRIBE (0xa2) + const auto id = packet_id(packet); + if (id) + write_packet(stream, {0xb0, 0x02, id->first, id->second}); // UNSUBACK + return true; + } + case 0x30: { // PUBLISH, QoS 0 (no packet identifier) + record_publish(packet); + return true; + } + case 0xc0: // PINGREQ + write_packet(stream, {0xd0, 0x00}); + return true; + case 0xe0: // DISCONNECT + return false; + default: + return true; + } + } + + // The two packet-identifier bytes sitting right after the remaining-length varint. + static std::optional> packet_id(const std::string& packet) + { + const auto varint = mqtt_decode_remaining_length(packet, 1); + if (varint.second == 0) + return std::nullopt; + const std::size_t pos = 1 + varint.second; + if (pos + 2 > packet.size()) + return std::nullopt; + return std::make_pair(static_cast(packet[pos]), static_cast(packet[pos + 1])); + } + + void record_publish(const std::string& packet) + { + const auto varint = mqtt_decode_remaining_length(packet, 1); + if (varint.second == 0) + return; + std::size_t pos = 1 + varint.second; + if (pos + 2 > packet.size()) + return; + const std::size_t topic_len = (static_cast(static_cast(packet[pos])) << 8) | + static_cast(packet[pos + 1]); + pos += 2; + if (pos + topic_len > packet.size()) + return; + const std::string topic = packet.substr(pos, topic_len); + pos += topic_len; + const std::size_t end = std::min(packet.size(), 1 + varint.second + varint.first); + if (end < pos) + return; + if (!mqtt_topic_is_request(topic)) + return; + std::lock_guard lock(m_mutex); + m_received_requests.push_back(packet.substr(pos, end - pos)); + } + + // Every write - the worker's own replies and push_report() from the test + // thread - is serialised by m_mutex. beast permits a writer while the worker + // is blocked in read(), which is the same arrangement OrcaMqttConnection uses. + void write_packet(ws::stream& stream, const std::vector& packet) + { + std::lock_guard lock(m_mutex); + boost::system::error_code ec; + stream.binary(true); + stream.write(net::buffer(packet), ec); + } + + void close_client_locked() + { + if (!m_stream) + return; + m_stream_ready = false; + boost::system::error_code ec; + auto& socket = beast::get_lowest_layer(*m_stream).socket(); + socket.cancel(ec); + // shutdown() before close() is what actually wakes a blocking read on the + // worker thread; close() alone does not on POSIX. + socket.shutdown(tcp::socket::shutdown_both, ec); + socket.close(ec); + } + + const bool m_refuse_auth; + net::io_context m_io; + tcp::acceptor m_acceptor; + std::string m_port; + std::thread m_thread; + std::atomic_bool m_stopping{false}; + std::atomic m_connect_count{0}; + mutable std::mutex m_mutex; + std::optional> m_stream; // guarded by m_mutex + bool m_stream_ready = false; // guarded by m_mutex + std::vector m_received_requests; // guarded by m_mutex +}; + +} // namespace orca_mqtt_test diff --git a/tests/slic3rutils/test_orca_mqtt_connection.cpp b/tests/slic3rutils/test_orca_mqtt_connection.cpp new file mode 100644 index 0000000000..60c4e9303b --- /dev/null +++ b/tests/slic3rutils/test_orca_mqtt_connection.cpp @@ -0,0 +1,229 @@ +#include +#include + +#include "orca_mqtt_mock_broker.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +using Slic3r::OrcaMqttConnection; + +// Offset of the CONNECT variable header: 1 (fixed header) + N remaining-length varint bytes. +static size_t mqtt_varheader_offset(const std::vector& p) { + size_t i = 1; + while (i < p.size() && (p[i] & 0x80)) ++i; // skip varint continuation bytes + return i + 1; // + the final varint byte +} + +TEST_CASE("OrcaMqtt parse_endpoint handles ws and wss", "[OrcaMqtt]") { + OrcaMqttConnection::Endpoint ep; + + REQUIRE(OrcaMqttConnection::parse_endpoint("ws://printer.local:8280/mqtt", ep)); + CHECK(ep.host == "printer.local"); + CHECK(ep.port == "8280"); + CHECK(ep.target == "/mqtt"); + + REQUIRE(OrcaMqttConnection::parse_endpoint("ws://10.0.0.5/mqtt", ep)); + CHECK(ep.port == "80"); + + REQUIRE(OrcaMqttConnection::parse_endpoint("wss://api.example.com/api/v1/printers/abc/mqtt", ep)); + CHECK(ep.host == "api.example.com"); + CHECK(ep.port == "443"); + CHECK(ep.target == "/api/v1/printers/abc/mqtt"); + + CHECK_FALSE(OrcaMqttConnection::parse_endpoint("http://x/y", ep)); +} + +TEST_CASE("OrcaMqtt CONNECT packet - no auth (cloud form)", "[OrcaMqtt]") { + auto p = OrcaMqttConnection::make_connect_packet("OrcaSlicer", "", "", 300); + REQUIRE(p.size() >= 12); + CHECK(p[0] == 0x10); // CONNECT fixed header + const size_t v = mqtt_varheader_offset(p); + CHECK(p[v + 0] == 0x00); CHECK(p[v + 1] == 0x04); // protocol name length + CHECK(p[v + 2] == 'M'); CHECK(p[v + 3] == 'Q'); + CHECK(p[v + 4] == 'T'); CHECK(p[v + 5] == 'T'); + CHECK(p[v + 6] == 0x04); // protocol level 3.1.1 + CHECK(p[v + 7] == 0x02); // connect flags: clean session only + CHECK(((p[v + 8] << 8) | p[v + 9]) == 300); // keepalive +} + +TEST_CASE("OrcaMqtt CONNECT packet - username/password (LAN form)", "[OrcaMqtt]") { + auto p = OrcaMqttConnection::make_connect_packet("orcaslicer-lan-x", "orcasonar", "code123", 60); + CHECK(p[0] == 0x10); + const size_t v = mqtt_varheader_offset(p); + CHECK(p[v + 7] == (0x02 | 0x80 | 0x40)); // clean session + username + password flags + const std::string blob(p.begin(), p.end()); + CHECK(blob.find("orcaslicer-lan-x") != std::string::npos); + CHECK(blob.find("orcasonar") != std::string::npos); + CHECK(blob.find("code123") != std::string::npos); +} + +// Auth precedence (spec O3): when a bearer_provider is configured, connect_and_read +// passes empty CONNECT credentials, so the packet must carry clean-session only and +// no username/password flags or payload fields. (The precedence branch itself lives +// in connect_and_read; the [.integration] cloud-style round trip exercises it live.) +TEST_CASE("OrcaMqtt CONNECT omits creds when a bearer is configured", "[OrcaMqtt]") { + auto p = OrcaMqttConnection::make_connect_packet("cid", "", "", 60); + const size_t v = mqtt_varheader_offset(p); + CHECK(p[v + 7] == 0x02); // clean session only: no 0x80 / 0x40 + const std::string blob(p.begin(), p.end()); + CHECK(blob.find("orcasonar") == std::string::npos); +} + +TEST_CASE("OrcaMqtt topic helpers", "[OrcaMqtt]") { + CHECK(OrcaMqttConnection::request_topic("abc") == "device/abc/request"); + CHECK(OrcaMqttConnection::report_topic("abc") == "device/abc/report"); +} + +TEST_CASE("OrcaMqtt PUBLISH packet QoS0", "[OrcaMqtt]") { + auto p = OrcaMqttConnection::make_publish_packet("device/abc/request", "{\"ok\":1}"); + CHECK((p[0] & 0xf0) == 0x30); // PUBLISH + CHECK((p[0] & 0x06) == 0x00); // QoS 0 + const std::string blob(p.begin(), p.end()); + CHECK(blob.find("device/abc/request") != std::string::npos); + CHECK(blob.find("{\"ok\":1}") != std::string::npos); +} + +TEST_CASE("OrcaMqtt SUBSCRIBE packet", "[OrcaMqtt]") { + auto p = OrcaMqttConnection::make_subscribe_packet(7, "device/abc/report", 1); + CHECK(p[0] == 0x82); // SUBSCRIBE + reserved bit + const size_t v = mqtt_varheader_offset(p); + CHECK(((p[v] << 8) | p[v + 1]) == 7); // packet id + CHECK(p.back() == 1); // requested QoS +} + +TEST_CASE("OrcaMqtt send_request refuses when not connected", "[OrcaMqtt]") { + OrcaMqttConnection conn; + CHECK_FALSE(conn.send_request("abc", "{\"pushing\":{\"command\":\"pushall\",\"sequence_id\":\"20001\"}}")); +} + +TEST_CASE("OrcaMqtt start takes a Config", "[OrcaMqtt]") { + OrcaMqttConnection conn; + OrcaMqttConnection::Config cfg; + cfg.url = "ws://127.0.0.1:1/mqtt"; // nothing listening + cfg.keepalive_seconds = 42; + // start() returns false (no server) but must compile with the Config overload + const bool ok = conn.start(cfg, [](auto, auto){}, [](bool, bool){}); + CHECK_FALSE(ok); + CHECK(conn.last_connack_rc() == -1); + conn.stop(); +} + +TEST_CASE("MockBroker starts and reports a url", "[OrcaMqtt][.integration]") { + orca_mqtt_test::MockBroker b; + CHECK(b.ws_url().rfind("ws://127.0.0.1:", 0) == 0); + CHECK(b.connect_count() == 0); +} + +// --- End-to-end integration: OrcaMqttConnection against the in-process MockBroker. +// All hidden behind [.integration] (run explicitly). These prove a LAN-style config +// (CONNECT username/password) and a cloud-style config (bearer on the WS upgrade, +// no CONNECT creds) drive the *same* OrcaMqttConnection code path with identical +// assertions. + +static void run_round_trip(bool use_tls_flag_only) { + orca_mqtt_test::MockBroker broker; + OrcaMqttConnection conn; + OrcaMqttConnection::Config cfg; + cfg.url = broker.ws_url(); // plaintext regardless + cfg.use_tls = false; // the mock is plaintext; the flag path is unit-tested elsewhere + if (use_tls_flag_only) cfg.bearer_provider = []{ return std::string("tok"); }; + else { cfg.username = "orcasonar"; cfg.password = "code"; } + + // A mutex + condition_variable rather than a promise: the handler runs on the MQTT + // worker thread and a second inbound message would throw std::future_error there. + std::mutex got_mutex; + std::condition_variable got_cv; + bool got_any = false; + std::string got_id, got_payload; + + REQUIRE(conn.start(cfg, + [&](const std::string& id, const std::string& payload){ + { + std::lock_guard l(got_mutex); + if (got_any) return; // keep the first message only + got_any = true; got_id = id; got_payload = payload; + } + got_cv.notify_all(); + }, + [](bool,bool){})); + REQUIRE(conn.subscribe("dev-1")); + REQUIRE(conn.send_request("dev-1", R"({"pushing":{"command":"pushall","sequence_id":"20001"}})")); + + broker.push_report("dev-1", R"({"print":{"command":"push_status","sequence_id":"20001","result":"success"}})"); + std::string id, payload; + { + std::unique_lock l(got_mutex); + REQUIRE(got_cv.wait_for(l, std::chrono::seconds(3), [&]{ return got_any; })); + id = got_id; payload = got_payload; + } + CHECK(id == "dev-1"); + CHECK(payload.find("push_status") != std::string::npos); + + // the client's command reached the broker on the request topic. The mock records + // the PUBLISH on its own read-loop thread, so poll rather than check immediately. + std::vector reqs; + for (int i = 0; i < 200; ++i) { + reqs = broker.received_requests(); + if (!reqs.empty()) break; + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + REQUIRE(reqs.size() >= 1); + CHECK(reqs.front().find("pushall") != std::string::npos); + conn.stop(); +} + +TEST_CASE("OrcaMqtt round-trip — LAN-style config", "[OrcaMqtt][.integration]") { run_round_trip(false); } +TEST_CASE("OrcaMqtt round-trip — cloud-style config", "[OrcaMqtt][.integration]") { run_round_trip(true); } + +TEST_CASE("OrcaMqtt reconnects and re-subscribes after a socket drop", "[OrcaMqtt][.integration]") { + orca_mqtt_test::MockBroker broker; + OrcaMqttConnection conn; + OrcaMqttConnection::Config cfg; cfg.url = broker.ws_url(); cfg.use_tls = false; cfg.username = "u"; cfg.password = "p"; + + std::mutex m; std::vector got; + REQUIRE(conn.start(cfg, + [&](const std::string&, const std::string& p){ std::lock_guard l(m); got.push_back(p); }, + [](bool,bool){})); + REQUIRE(conn.subscribe("dev-1")); + + broker.drop_client(); + // the worker reconnects with ~1s backoff + for (int i = 0; i < 300 && broker.connect_count() < 2; ++i) + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + CHECK(broker.connect_count() >= 2); + + // a report after the reconnect must still be delivered -> the SUBSCRIBE was re-sent + broker.push_report("dev-1", R"({"print":{"command":"push_status","sequence_id":"20002"}})"); + bool delivered = false; + for (int i = 0; i < 200 && !delivered; ++i) { + { std::lock_guard l(m); delivered = !got.empty(); } + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + CHECK(delivered); + conn.stop(); +} + +TEST_CASE("OrcaMqtt auth rejection is terminal (no retry storm)", "[OrcaMqtt][.integration]") { + orca_mqtt_test::MockBroker broker(/*refuse_auth=*/true); + OrcaMqttConnection conn; + OrcaMqttConnection::Config cfg; cfg.url = broker.ws_url(); cfg.use_tls = false; cfg.username = "u"; cfg.password = "bad"; + + const bool ok = conn.start(cfg, [](const std::string&, const std::string&){}, [](bool,bool){}); + CHECK_FALSE(ok); + CHECK(conn.last_connack_rc() == 5); + // worker must have stopped itself (rc 5 is terminal) — give it a moment + for (int i = 0; i < 100 && conn.is_running(); ++i) + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + CHECK_FALSE(conn.is_running()); + // and it must NOT have hammered the broker with retries + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + CHECK(broker.connect_count() <= 2); + conn.stop(); +} diff --git a/tests/slic3rutils/test_orca_printer_agent.cpp b/tests/slic3rutils/test_orca_printer_agent.cpp new file mode 100644 index 0000000000..b3ad393268 --- /dev/null +++ b/tests/slic3rutils/test_orca_printer_agent.cpp @@ -0,0 +1,170 @@ +#include +#include +#include + +#include "orca_mqtt_mock_broker.hpp" + +#include +#include +#include +#include +#include +#include + +using Slic3r::OrcaPrinterAgent; + +namespace { +// Probe exposes the protected internals the tests drive. +struct Probe : OrcaPrinterAgent { + using OrcaPrinterAgent::OrcaPrinterAgent; + using OrcaPrinterAgent::deliver_to_sink; + using OrcaPrinterAgent::parse_lan_endpoint; + using OrcaPrinterAgent::make_lan_client_id; + using OrcaPrinterAgent::lan_connection_target; +}; +} + +TEST_CASE("OrcaPrinterAgent forwards a status payload to on_message_fn", "[OrcaPrinterAgent]") { + Probe agent("/tmp"); + std::string got_id, got_payload; + agent.set_on_message_fn([&](std::string id, std::string p){ got_id = std::move(id); got_payload = std::move(p); }); + agent.deliver_to_sink("dev-1", R"({"print":{"command":"push_status"}})"); + CHECK(got_id == "dev-1"); + CHECK(got_payload.find("push_status") != std::string::npos); +} + +TEST_CASE("OrcaPrinterAgent::parse_lan_endpoint", "[OrcaPrinterAgent]") { + std::string h, p; + REQUIRE(Probe::parse_lan_endpoint("192.168.1.9", h, p)); + CHECK(h == "192.168.1.9"); CHECK(p == "8280"); + REQUIRE(Probe::parse_lan_endpoint("http://host.local:9000/x", h, p)); + CHECK(h == "host.local"); CHECK(p == "9000"); + CHECK_FALSE(Probe::parse_lan_endpoint("", h, p)); +} + +TEST_CASE("OrcaPrinterAgent::make_lan_client_id is stable and prefixed", "[OrcaPrinterAgent]") { + const auto a = Probe::make_lan_client_id("dev-1"); + const auto b = Probe::make_lan_client_id("dev-1"); + CHECK(a == b); // drawn once per process + CHECK(a.rfind("orcaslicer-lan-dev-1-", 0) == 0); +} + +TEST_CASE("connect_printer wires up a LAN Config", "[OrcaPrinterAgent][.integration]") { + Probe agent("/tmp"); + const int rc = agent.connect_printer("dev-1", "10.255.255.1", "orcasonar", "code", false); + CHECK(rc == BAMBU_NETWORK_SUCCESS); + CHECK(agent.lan_connection_target() == "ws://10.255.255.1:8280/mqtt"); + CHECK(agent.get_user_selected_machine().empty()); // LAN path must not touch the cloud selection + agent.disconnect_printer(); +} + +TEST_CASE("post-connect sequence is subscribe then 4 requests in order", "[OrcaPrinterAgent]") { + struct SeqProbe : OrcaPrinterAgent { + using OrcaPrinterAgent::OrcaPrinterAgent; + std::vector calls; + void emit_connect_sequence(const std::string& dev_id, + std::function /*sub*/, + std::function /*req*/) override { + OrcaPrinterAgent::emit_connect_sequence(dev_id, + [&](const std::string& id){ calls.push_back("sub:" + id); }, + [&](const std::string& body){ calls.push_back(body); }); + } + } probe("/tmp"); + probe.run_connect_sequence_for_test("dev-1"); + REQUIRE(probe.calls.size() == 5); + CHECK(probe.calls[0] == "sub:dev-1"); + CHECK(probe.calls[1].find("\"pushing\"") != std::string::npos); + CHECK(probe.calls[1].find("\"start\"") != std::string::npos); + CHECK(probe.calls[2].find("pushall") != std::string::npos); + CHECK(probe.calls[3].find("get_version") != std::string::npos); + CHECK(probe.calls[4].find("get_capabilities") != std::string::npos); + for (auto& c : probe.calls) + if (auto pos = c.find("sequence_id"); pos != std::string::npos) + CHECK(c.substr(pos).find("\"2") != std::string::npos); +} + +// Hidden: spawns the connect worker and attempts a real (failing) connect. +TEST_CASE("selecting a cloud printer configures the per-printer socket", "[OrcaPrinterAgent][.integration]") { + auto cloud = std::make_shared("/tmp"); + cloud->set_api_base_url("api.example.com"); + OrcaPrinterAgent agent("/tmp"); + agent.set_cloud_agent(cloud); + + agent.set_user_selected_machine("printer-uuid-1"); + // The configure runs on the connect worker; poll rather than racing it. + std::string url; + for (int i = 0; i < 300; ++i) { + url = cloud->selected_printer_mqtt_url(); + if (!url.empty()) break; + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + CHECK(url == "wss://api.example.com/api/v1/printers/printer-uuid-1/mqtt"); + + agent.set_user_selected_machine(""); // teardown is synchronous + CHECK(cloud->selected_printer_mqtt_url().empty()); +} + +TEST_CASE("a stale-generation inbound message is dropped", "[OrcaPrinterAgent]") { + struct GenProbe : OrcaPrinterAgent { + using OrcaPrinterAgent::OrcaPrinterAgent; + using OrcaPrinterAgent::make_lan_message_handler; // expose for the test + }; + GenProbe agent("/tmp"); + int hits = 0; + agent.set_on_message_fn([&](std::string, std::string){ ++hits; }); + auto handler_gen1 = agent.make_lan_message_handler(/*generation=*/1); + // m_lan_generation starts at 0; two bumps -> 2, so the epoch-1 handler is stale. + agent.bump_lan_generation_for_test(); + agent.bump_lan_generation_for_test(); + handler_gen1("dev-1", "{}"); // late callback from gen 1 + CHECK(hits == 0); +} + +TEST_CASE("connect_server does not start an MQTT socket", "[OrcaCloud]") { + auto cloud = std::make_shared("/tmp"); + cloud->set_api_base_url("127.0.0.1:1"); // no session -> connect_server short-circuits before any probe + cloud->connect_server(); + REQUIRE(cloud->get_mqtt_connection() != nullptr); // created in the ctor + CHECK_FALSE(cloud->get_mqtt_connection()->is_running()); // never started + CHECK(cloud->selected_printer_mqtt_url().empty()); +} + +TEST_CASE("send_message* reject when there is no connection", "[OrcaPrinterAgent]") { + OrcaPrinterAgent agent("/tmp"); // no cloud agent, no LAN connection + CHECK(agent.send_message("d", "{}", 0, 0) == BAMBU_NETWORK_ERR_INVALID_HANDLE); + CHECK(agent.send_message_to_printer("d", "{}", 0, 0) == BAMBU_NETWORK_ERR_INVALID_HANDLE); + CHECK(agent.send_message("", "{}", 0, 0) == BAMBU_NETWORK_ERR_INVALID_HANDLE); // empty dev_id +} + +TEST_CASE("send_message_to_printer publishes on the LAN connection", "[OrcaPrinterAgent][.integration]") { + orca_mqtt_test::MockBroker broker; + OrcaPrinterAgent agent("/tmp"); + const auto ep = broker.host_port(); + agent.connect_printer("dev-1", ep.first + ":" + ep.second, "orcasonar", "code", false); + + for (int i = 0; i < 150 && broker.connect_count() == 0; ++i) + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + REQUIRE(broker.connect_count() >= 1); + + CHECK(agent.send_message_to_printer("dev-1", R"({"print":{"command":"pause","sequence_id":"20007"}})", 0, 0) + == BAMBU_NETWORK_SUCCESS); + + // on_connected also publishes 4 requests; poll until "pause" specifically shows up. + bool saw_pause = false; + for (int i = 0; i < 150 && !saw_pause; ++i) { + for (const auto& r : broker.received_requests()) + if (r.find("pause") != std::string::npos) { saw_pause = true; break; } + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + } + CHECK(saw_pause); + agent.disconnect_printer(); +} + +TEST_CASE("destroying an agent mid-connect does not hang or crash", "[OrcaPrinterAgent]") { + for (int i = 0; i < 20; ++i) { + auto agent = std::make_unique("/tmp"); + agent->connect_printer("dev-1", "127.0.0.1:1", "orcasonar", "code", false); // nothing listening: instant ECONNREFUSED + agent.reset(); // ~OrcaPrinterAgent must stop the conn, join the thread, and not hang/crash + } + SUCCEED(); +}