Keep the Orca Cloud Agent Tests Out of the System Keychain

The display-name tests call set_user_session(), which persists the session.
The agent they built was in keychain mode, so every run saved a fake
OrcaSlicer/Auth session into the system keychain of whoever ran the tests,
replacing their real Orca Cloud login on any desktop with a working keychain.

Move them next to the other agent tests and build the agent the same way:
encrypted-file mode with a throwaway config directory.

src/libslic3r/CutSurface.cpp

@@ -809,20 +809,13 @@ void priv::set_skip_for_out_of_aoi(std::vector<bool>          &skip_indicies,
     }); // END parallel for
 
     // inspect all triangles, when it is out of bounding box
-    // NOTE: std::vector<bool> is bit packed, thus setting its items from multiple threads is a
-    // read-modify-write race on the shared words and silently loses flags. Collect the flags into
-    // a byte per triangle, where the chunks do not share memory, and merge them afterwards.
-    std::vector<unsigned char> skip_triangle(its.indices.size(), 0);
     tbb::parallel_for(tbb::blocked_range<size_t>(0, its.indices.size()),
-    [&its, &is_on_sides, &skip_triangle](const tbb::blocked_range<size_t> &range) {
+    [&its, &is_on_sides, &skip_indicies](const tbb::blocked_range<size_t> &range) {
         for (size_t i = range.begin(); i < range.end(); ++i) {
             if (is_all_on_one_side(its.indices[i], is_on_sides)) 
-                skip_triangle[i] = 1;
+                skip_indicies[i] = true;
         }
     }); // END parallel for
-    for (size_t i = 0; i < skip_triangle.size(); ++i)
-        if (skip_triangle[i])
-            skip_indicies[i] = true;
 }
 
 indexed_triangle_set Slic3r::its_mask(const indexed_triangle_set &its,

src/libslic3r/MultiMaterialSegmentation.cpp

@@ -1378,66 +1378,55 @@ static inline std::vector<std::vector<ExPolygons>> segmentation_top_and_bottom_l
         return out;
     };
 
-    // The layers are processed in groups of "granularity" layers. A layer projects its shells up to "granularity"
-    // layers away, thus a group may write into the slots of its neighbor groups. The even and the odd groups
-    // therefore write into two disjoint halves of the output vectors (the 2nd half is offset by num_layers) and
-    // both halves are merged below. The group index has to be derived from the layer index and not from the extent
-    // of the TBB sub-range: tbb::blocked_range bisects at midpoints, thus a sub-range neither starts at a multiple
-    // of the grain size nor covers a whole group, and two sub-ranges of one group would append into a single
-    // ExPolygons concurrently. Iterating over the groups keeps every group on a single thread, in ascending order.
-    const size_t num_groups = (num_layers + size_t(granularity) - 1) / size_t(granularity);
-    tbb::parallel_for(tbb::blocked_range<size_t>(0, num_groups, 1), [&granularity, &num_layers, &num_facets_states, &layer_color_stat, &top_raw, &triangles_by_color_top,
-                                                                    &throw_on_cancel_callback, &input_expolygons, &bottom_raw, &triangles_by_color_bottom,
-                                                                    &shell_triangles_by_color_top, &shell_triangles_by_color_bottom](const tbb::blocked_range<size_t> &range) {
-        for (size_t group_idx = range.begin(); group_idx < range.end(); ++ group_idx) {
-            const size_t layer_idx_offset = (group_idx & 1) * num_layers;
-            const size_t layer_idx_begin  = group_idx * size_t(granularity);
-            const size_t layer_idx_end    = std::min(num_layers, layer_idx_begin + size_t(granularity));
-            for (size_t layer_idx = layer_idx_begin; layer_idx < layer_idx_end; ++ layer_idx) {
-                for (size_t color_idx = 0; color_idx < num_facets_states; ++color_idx) {
-                    throw_on_cancel_callback();
-                    LayerColorStat stat = layer_color_stat(layer_idx, color_idx);
-                    if (std::vector<Polygons> &top = top_raw[color_idx]; ! top.empty() && ! top[layer_idx].empty())
-                        if (ExPolygons top_ex = union_ex(top[layer_idx]); ! top_ex.empty()) {
-                            // Clean up thin projections. They are not printable anyways.
-                            top_ex = opening_ex(top_ex, stat.small_region_threshold);
-                            if (! top_ex.empty()) {
-                                append(triangles_by_color_top[color_idx][layer_idx + layer_idx_offset], top_ex);
-                                float offset = 0.f;
-                                ExPolygons layer_slices_trimmed = input_expolygons[layer_idx];
-                                for (int last_idx = int(layer_idx) - 1; last_idx > std::max(int(layer_idx - stat.top_shell_layers), int(0)); --last_idx) {
-                                    //BBS: offset width should be 2*spacing to avoid too narrow area which has overlap of wall line
-                                    //offset -= stat.extrusion_width ;
-                                    offset -= (stat.extrusion_spacing + stat.extrusion_width);
-                                    layer_slices_trimmed = intersection_ex(layer_slices_trimmed, input_expolygons[last_idx]);
-                                    ExPolygons last = opening_ex(intersection_ex(top_ex, offset_ex(layer_slices_trimmed, offset)), stat.small_region_threshold);
-                                    if (last.empty())
-                                        break;
-                                    append(shell_triangles_by_color_top[color_idx][last_idx + layer_idx_offset], std::move(last));
-                                }
+    tbb::parallel_for(tbb::blocked_range<size_t>(0, num_layers, granularity), [&granularity, &num_layers, &num_facets_states, &layer_color_stat, &top_raw, &triangles_by_color_top,
+                                                                               &throw_on_cancel_callback, &input_expolygons, &bottom_raw, &triangles_by_color_bottom,
+                                                                               &shell_triangles_by_color_top, &shell_triangles_by_color_bottom](const tbb::blocked_range<size_t> &range) {
+        size_t group_idx   = range.begin() / granularity;
+        size_t layer_idx_offset = (group_idx & 1) * num_layers;
+        for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++ layer_idx) {
+            for (size_t color_idx = 0; color_idx < num_facets_states; ++color_idx) {
+                throw_on_cancel_callback();
+                LayerColorStat stat = layer_color_stat(layer_idx, color_idx);
+                if (std::vector<Polygons> &top = top_raw[color_idx]; ! top.empty() && ! top[layer_idx].empty())
+                    if (ExPolygons top_ex = union_ex(top[layer_idx]); ! top_ex.empty()) {
+                        // Clean up thin projections. They are not printable anyways.
+                        top_ex = opening_ex(top_ex, stat.small_region_threshold);
+                        if (! top_ex.empty()) {
+                            append(triangles_by_color_top[color_idx][layer_idx + layer_idx_offset], top_ex);
+                            float offset = 0.f;
+                            ExPolygons layer_slices_trimmed = input_expolygons[layer_idx];
+                            for (int last_idx = int(layer_idx) - 1; last_idx > std::max(int(layer_idx - stat.top_shell_layers), int(0)); --last_idx) {
+                                //BBS: offset width should be 2*spacing to avoid too narrow area which has overlap of wall line
+                                //offset -= stat.extrusion_width ;
+                                offset -= (stat.extrusion_spacing + stat.extrusion_width);
+                                layer_slices_trimmed = intersection_ex(layer_slices_trimmed, input_expolygons[last_idx]);
+                                ExPolygons last = opening_ex(intersection_ex(top_ex, offset_ex(layer_slices_trimmed, offset)), stat.small_region_threshold);
+                                if (last.empty())
+                                    break;
+                                append(shell_triangles_by_color_top[color_idx][last_idx + layer_idx_offset], std::move(last));
                             }
                         }
-                    if (std::vector<Polygons> &bottom = bottom_raw[color_idx]; ! bottom.empty() && ! bottom[layer_idx].empty())
-                        if (ExPolygons bottom_ex = union_ex(bottom[layer_idx]); ! bottom_ex.empty()) {
-                            // Clean up thin projections. They are not printable anyways.
-                            bottom_ex = opening_ex(bottom_ex, stat.small_region_threshold);
-                            if (! bottom_ex.empty()) {
-                                append(triangles_by_color_bottom[color_idx][layer_idx + layer_idx_offset], bottom_ex);
-                                float offset = 0.f;
-                                ExPolygons layer_slices_trimmed = input_expolygons[layer_idx];
-                                for (size_t last_idx = layer_idx + 1; last_idx < std::min(layer_idx + stat.bottom_shell_layers, num_layers); ++last_idx) {
-                                    //BBS: offset width should be 2*spacing to avoid too narrow area which has overlap of wall line
-                                    //offset -= stat.extrusion_width;
-                                    offset -= (stat.extrusion_spacing + stat.extrusion_width);
-                                    layer_slices_trimmed = intersection_ex(layer_slices_trimmed, input_expolygons[last_idx]);
-                                    ExPolygons last = opening_ex(intersection_ex(bottom_ex, offset_ex(layer_slices_trimmed, offset)), stat.small_region_threshold);
-                                    if (last.empty())
-                                        break;
-                                    append(shell_triangles_by_color_bottom[color_idx][last_idx + layer_idx_offset], std::move(last));
-                                }
+                    }
+                if (std::vector<Polygons> &bottom = bottom_raw[color_idx]; ! bottom.empty() && ! bottom[layer_idx].empty())
+                    if (ExPolygons bottom_ex = union_ex(bottom[layer_idx]); ! bottom_ex.empty()) {
+                        // Clean up thin projections. They are not printable anyways.
+                        bottom_ex = opening_ex(bottom_ex, stat.small_region_threshold);
+                        if (! bottom_ex.empty()) {
+                            append(triangles_by_color_bottom[color_idx][layer_idx + layer_idx_offset], bottom_ex);
+                            float offset = 0.f;
+                            ExPolygons layer_slices_trimmed = input_expolygons[layer_idx];
+                            for (size_t last_idx = layer_idx + 1; last_idx < std::min(layer_idx + stat.bottom_shell_layers, num_layers); ++last_idx) {
+                                //BBS: offset width should be 2*spacing to avoid too narrow area which has overlap of wall line
+                                //offset -= stat.extrusion_width;
+                                offset -= (stat.extrusion_spacing + stat.extrusion_width);
+                                layer_slices_trimmed = intersection_ex(layer_slices_trimmed, input_expolygons[last_idx]);
+                                ExPolygons last = opening_ex(intersection_ex(bottom_ex, offset_ex(layer_slices_trimmed, offset)), stat.small_region_threshold);
+                                if (last.empty())
+                                    break;
+                                append(shell_triangles_by_color_bottom[color_idx][last_idx + layer_idx_offset], std::move(last));
                             }
                         }
-                }
+                    }
             }
         }
     });

src/libslic3r/Support/TreeModelVolumes.cpp

@@ -424,16 +424,8 @@ void TreeModelVolumes::calculateCollision(const coord_t radius, const LayerIndex
         [this](size_t i, size_t j) { return m_layer_outlines[i].second.size() < m_layer_outlines[j].second.size(); });
 
     // Layer range for which the collisions will be calculated.
-    // Another thread may have advanced getMaxCalculatedLayer() past max_layer_idx after this calculation
-    // was requested. Bail out in that case, otherwise the layer range would be negative and allocating
-    // it would throw std::length_error out of a parallel task.
-    const LayerIndex            start_layer = 1 + m_collision_cache.getMaxCalculatedLayer(radius);
-    if (start_layer > max_layer_idx) {
-        BOOST_LOG_TRIVIAL(debug) << "Requested calculation for value already calculated ?";
-        return;
-    }
     LayerPolygonCache           data;
-    data.allocate(start_layer, max_layer_idx + 1);
+    data.allocate(m_collision_cache.getMaxCalculatedLayer(radius) + 1, max_layer_idx + 1);
 
     const bool                  calculate_placable = m_support_rests_on_model && radius == 0;
     LayerPolygonCache           data_placeable;
@@ -812,12 +804,6 @@ void TreeModelVolumes::calculateWallRestrictions(const std::vector<RadiusLayerPa
             const coord_t    radius             = keys[key_idx].first;
             const LayerIndex max_required_layer = keys[key_idx].second;
             const coord_t    min_layer_bottom   = std::max(1, m_wall_restrictions_cache.getMaxCalculatedLayer(radius));
-            if (min_layer_bottom > max_required_layer) {
-                // Another thread has calculated this range in the meantime. Continuing would make
-                // buffer_size negative and allocating it would throw std::length_error.
-                BOOST_LOG_TRIVIAL(debug) << "Requested calculation for value already calculated ?";
-                continue;
-            }
             const size_t     buffer_size        = max_required_layer + 1 - min_layer_bottom;
             std::vector<Polygons> data(buffer_size, Polygons{});
             std::vector<Polygons> data_min;

src/libslic3r/Thread.cpp

@@ -12,7 +12,6 @@
 #include <thread>
 #include <tbb/parallel_for.h>
 #include <tbb/task_arena.h>
-#include <tbb/task_scheduler_observer.h>
 
 #include "Thread.hpp"
 #include "Utils.hpp"
@@ -213,71 +212,70 @@ bool is_main_thread_active()
 	return get_main_thread_id() == boost::this_thread::get_id();
 }
 
-// Name the current TBB worker thread and set its locale to "C", so that the G-code generator
-// produces "." as a decimal separator. Called once per worker thread, before it runs its first task.
-static void setup_tbb_worker_thread()
-{
-	static std::atomic<size_t> s_worker_idx{ 0 };
-	std::ostringstream name;
-	name << "slic3r_tbb_" << (1 + s_worker_idx.fetch_add(1, std::memory_order_relaxed));
-	set_current_thread_name(name.str().c_str());
-#ifdef _WIN32
-	_configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
-	std::setlocale(LC_ALL, "C");
-#else
-	// We are leaking some memory here, because the newlocale() produced memory will never be released.
-	// This is not a problem though, as there will be a maximum one worker thread created per physical thread.
-	uselocale(newlocale(
-#ifdef __APPLE__
-		LC_ALL_MASK
-#else // some Unix / Linux / BSD
-		LC_ALL
-#endif
-		, "C", nullptr));
-#endif
-}
-
-// Sets up the TBB worker threads of the arena of the thread, which activated the observation.
-// A worker sets itself up on entry to the arena, before it executes its first task, thus unlike a barrier
-// inside a parallel_for, this does not depend on TBB running any number of tasks simultaneously.
-class TBBWorkerThreadSetupObserver : public tbb::task_scheduler_observer
-{
-public:
-	TBBWorkerThreadSetupObserver() { this->observe(true); }
-
-	void on_scheduler_entry(bool is_worker) override
-	{
-		// Leave the external threads (the calling / UI thread) alone, their name and locale must not be modified here.
-		if (! is_worker)
-			return;
-		// A worker thread enters an arena many times, while its name and locale have to be set just once.
-		static thread_local bool initialized = false;
-		if (initialized)
-			return;
-		initialized = true;
-		setup_tbb_worker_thread();
-	}
-};
-
-// Name the threads of the Intel TBB thread pool by an index and set their locale to "C"
-// for the G-code generator to produce "." as a decimal separator.
-// Formerly all the worker threads were caught inside a single parallel_for, which was held on a condition
-// variable barrier until max_concurrency() of its chunks were running. TBB guarantees no such simultaneity,
-// thus the barrier was able to block the slicing threads indefinitely. The TBB scheduler observer below
-// sets each worker up on its own, thus no two chunks have to run at the same time.
+// Spawn (n - 1) worker threads on Intel TBB thread pool and name them by an index and a system thread ID.
+// Also it sets locale of the worker threads to "C" for the G-code generator to produce "." as a decimal separator.
 void name_tbb_thread_pool_threads_set_locale()
 {
+	static bool initialized = false;
+	if (initialized)
+		return;
+	initialized = true;
+
+	// see GH issue #5661 PrusaSlicer hangs on Linux when run with non standard task affinity
+	// TBB will respect the task affinity mask on Linux and spawn less threads than std::thread::hardware_concurrency().
+//	const size_t nthreads_hw = std::thread::hardware_concurrency();
+	const size_t nthreads_hw = tbb::this_task_arena::max_concurrency();
+	size_t       nthreads    = nthreads_hw;
+
 #ifdef SLIC3R_PROFILE
 	// Shiny profiler is not thread safe, thus disable parallelization.
 	disable_multi_threading();
+	nthreads = 1;
 #endif
 
-	// An observer is local to the arena of the thread which activates it, thus one observer is registered
-	// per calling thread. Being function local and thread local, it is also initialized exactly once per
-	// thread without a race. It is intentionally never destroyed, as it has to stay alive as long as the
-	// TBB scheduler may notify it, which includes the shutdown of the process.
-	static thread_local tbb::task_scheduler_observer *observer = new TBBWorkerThreadSetupObserver();
-	(void)observer;
+	size_t                  nthreads_running(0);
+	std::condition_variable cv;
+	std::mutex				cv_m;
+	auto					master_thread_id = std::this_thread::get_id();
+    tbb::parallel_for(
+        tbb::blocked_range<size_t>(0, nthreads, 1),
+        [&nthreads_running, nthreads, &master_thread_id, &cv, &cv_m](const tbb::blocked_range<size_t> &range) {
+        	assert(range.begin() + 1 == range.end());
+			if (std::unique_lock<std::mutex> lk(cv_m);  ++nthreads_running == nthreads) {
+				lk.unlock();
+        		// All threads are spinning.
+        		// Wake them up.
+    			cv.notify_all();
+        	} else {
+        		// Wait for the last thread to wake the others.
+			    cv.wait(lk, [&nthreads_running, nthreads]{return nthreads_running == nthreads;});
+        	}
+        	auto thread_id = std::this_thread::get_id();
+			if (thread_id == master_thread_id) {
+				// The calling thread runs the 0'th task.
+				assert(range.begin() == 0);
+			} else {
+				assert(range.begin() > 0);
+				std::ostringstream name;
+		        name << "slic3r_tbb_" << range.begin();
+		        set_current_thread_name(name.str().c_str());
+		        // Set locales of the worker thread to "C".
+#ifdef _WIN32
+			    _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
+			    std::setlocale(LC_ALL, "C");
+#else
+				// We are leaking some memory here, because the newlocale() produced memory will never be released.
+				// This is not a problem though, as there will be a maximum one worker thread created per physical thread.
+				uselocale(newlocale(
+#ifdef __APPLE__
+					LC_ALL_MASK
+#else // some Unix / Linux / BSD
+					LC_ALL
+#endif
+					, "C", nullptr));
+#endif
+    		}
+        });
 }
 
 }

src/libslic3r/TriangleSetSampling.cpp

@@ -28,10 +28,6 @@ TriangleSetSamples sample_its_uniform_parallel(size_t samples_count, const index
         area_sum_to_triangle_idx[area_sum] = t_idx;
     }
 
-    if (area_sum_to_triangle_idx.empty())
-        // No triangle to sample from.
-        return {};
-
     std::mt19937_64 mersenne_engine { 27644437 };
     // random numbers on interval [0, 1)
     std::uniform_real_distribution<double> fdistribution;
@@ -54,10 +50,7 @@ TriangleSetSamples sample_its_uniform_parallel(size_t samples_count, const index
                     tbb::blocked_range<size_t> r) {
                 for (size_t s_idx = r.begin(); s_idx < r.end(); ++s_idx) {
                     double t_sample = random_samples[s_idx].x() * area_sum;
-                    // The keys of area_sum_to_triangle_idx are accumulated areas in double precision, while area_sum
-                    // is a float, thus t_sample may reach or exceed the largest key and upper_bound() may return end().
-                    auto   t_it    = area_sum_to_triangle_idx.upper_bound(t_sample);
-                    size_t t_idx   = (t_it == area_sum_to_triangle_idx.end() ? std::prev(t_it) : t_it)->second;
+                    size_t t_idx = area_sum_to_triangle_idx.upper_bound(t_sample)->second;
 
                     double sq_u = std::sqrt(random_samples[s_idx].y());
                     double v = random_samples[s_idx].z();

src/slic3r/Utils/OrcaCloudServiceAgent.cpp

@@ -819,7 +819,9 @@ int OrcaCloudServiceAgent::user_logout(bool request)
         }
     }
 
-    clear_session();
+    // An explicit logout also wipes the backend the token storage option is not using, so a token
+    // stranded by switching that option cannot sign the account back in later.
+    clear_session(/*all_backends=*/request);
     return BAMBU_NETWORK_SUCCESS;
 }
 
@@ -1604,7 +1606,9 @@ void OrcaCloudServiceAgent::persist_user_secret(const std::string& secret)
         }
     }
 
-    (void) stored;
+    if (stored) {
+        secret_stored = true;
+    }
 }
 
 bool OrcaCloudServiceAgent::load_user_secret(std::string& out_secret)
@@ -1644,6 +1648,7 @@ bool OrcaCloudServiceAgent::load_user_secret(std::string& out_secret)
                 }
 
                 if (integrity_ok && aes256gcm_decrypt(encoded_payload, key, plain) && !plain.empty()) {
+                    secret_stored = true;
                     out_secret = plain;
                     // Upgrade legacy payloads to signed format
                     if (payload.rfind("v2:", 0) != 0) {
@@ -1661,6 +1666,7 @@ bool OrcaCloudServiceAgent::load_user_secret(std::string& out_secret)
             if (store.Load(SECRET_STORE_SERVICE, username, secret) && secret.IsOk()) {
                 out_secret.assign(static_cast<const char*>(secret.GetData()), secret.GetSize());
                 if (!out_secret.empty()) {
+                    secret_stored = true;
                     return true;
                 }
             }
@@ -1670,11 +1676,20 @@ bool OrcaCloudServiceAgent::load_user_secret(std::string& out_secret)
     return false;
 }
 
-void OrcaCloudServiceAgent::clear_user_secret()
+void OrcaCloudServiceAgent::clear_user_secret(bool all_backends)
 {
-    wxSecretStore store = wxSecretStore::GetDefault();
-    if (store.IsOk()) {
-        store.Delete(SECRET_STORE_SERVICE);
+    // Nothing this process loaded or saved: leave the store alone. Deleting would only cost a
+    // keychain round trip (or a hang while the keychain is unresponsive) and could remove a
+    // login another instance just saved.
+    if (!secret_stored.exchange(false) && !all_backends) {
+        return;
+    }
+
+    if (all_backends || !m_use_encrypted_token_file) {
+        wxSecretStore store = wxSecretStore::GetDefault();
+        if (store.IsOk()) {
+            store.Delete(SECRET_STORE_SERVICE);
+        }
     }
 
     compute_fallback_path();
@@ -2023,13 +2038,13 @@ bool OrcaCloudServiceAgent::set_user_session(const json& session_json, bool noti
     return success;
 }
 
-void OrcaCloudServiceAgent::clear_session()
+void OrcaCloudServiceAgent::clear_session(bool all_backends)
 {
     {
         std::lock_guard<std::mutex> lock(session_mutex);
         session = SessionInfo{};
     }
-    clear_user_secret();
+    clear_user_secret(all_backends);
 }
 
 // ============================================================================

src/slic3r/Utils/OrcaCloudServiceAgent.hpp

@@ -326,7 +326,7 @@ public:
 
     void persist_user_secret(const std::string& secret);
     bool load_user_secret(std::string& out_secret);
-    void clear_user_secret();
+    void clear_user_secret(bool all_backends = false);
 
     // Token refresh helpers
     bool          refresh_if_expiring(std::chrono::seconds skew, const std::string& reason);
@@ -344,7 +344,7 @@ public:
                           bool persist = true);
     // Accepts either nested Orca cloud / GoTrue session JSON or flat WebView token JSON.
     bool set_user_session(const nlohmann::json& session_json, bool notify_login = true);
-    void clear_session();
+    void clear_session(bool all_backends = false);
 
     static std::string generate_uuid_for_setting_id(const std::string& name, const std::string& user_id = "");
 
@@ -413,6 +413,11 @@ private:
     // Member variables - auth state
     PkceBundle pkce_bundle;
     std::string secret_fallback_path;
+    // Set once this process has read a secret from the store or written one. Unless the user logs
+    // out explicitly, clear_user_secret() only touches the store while it is set, so a logged-out
+    // instance (the GUI polls the login status every 2 s) makes no keychain calls and cannot wipe
+    // a login another instance saved.
+    std::atomic_bool secret_stored{false};
     SessionHandler session_handler;
     OnLoginCompleteHandler on_login_complete_handler;
     SessionInfo session;

tests/slic3rutils/CMakeLists.txt

@@ -13,6 +13,7 @@ add_executable(${_TEST_NAME}_tests
     test_prebuild_queue.cpp
     test_staged_build.cpp
     test_network_versions.cpp
+    test_orca_cloud_agent.cpp
     test_action_source.cpp
     test_plugin_host_api.cpp
     # Exercise seam enums and predicates through the embedded Python host API.

tests/slic3rutils/python_test_support.hpp

@@ -6,6 +6,7 @@
 #include <boost/filesystem.hpp>
 #include <memory.h>
 #include <stdexcept>
+#include <string>
 #include <pybind11/embed.h>
 #include <pybind11/pybind11.h>
 
@@ -25,8 +26,15 @@ void ensure_python_initialized()
     config.parse_argv = 0;
 
     const auto python_home = boost::dll::program_location().parent_path() / "python";
+#ifdef _WIN32
+    const auto stdlib = python_home / "Lib";
+#else
+    const auto stdlib = python_home / "lib" /
+                        ("python" + std::to_string(PY_MAJOR_VERSION) + "." + std::to_string(PY_MINOR_VERSION));
+#endif
 
-    if (boost::filesystem::exists(python_home)) {
+    // Only a real runtime: a stray python/ folder (packages a test left behind) is not a home.
+    if (boost::filesystem::exists(stdlib / "encodings")) {
         const std::string home = python_home.string();
         const PyStatus status  = PyConfig_SetBytesString(&config, &config.home, home.c_str());
 

tests/slic3rutils/slic3rutils_tests_main.cpp

@@ -1,39 +1,6 @@
 #include <catch2/catch_all.hpp>
 
 #include "slic3r/Utils/Http.hpp"
-#include "slic3r/Utils/OrcaCloudServiceAgent.hpp"
-
-namespace {
-
-nlohmann::json flat_session_json(const nlohmann::json& fields)
-{
-    nlohmann::json session = {
-        {"access_token", "test-token"},
-        {"user_id", "test-user-id"}
-    };
-    session.update(fields);
-    return session;
-}
-
-nlohmann::json nested_session_json(const nlohmann::json& metadata)
-{
-    return {
-        {"access_token", "test-token"},
-        {"user", {
-            {"id", "test-user-id"},
-            {"user_metadata", metadata}
-        }}
-    };
-}
-
-std::string resolved_display_name(const nlohmann::json& session)
-{
-    Slic3r::OrcaCloudServiceAgent agent("");
-    REQUIRE(agent.set_user_session(session, false));
-    return agent.get_user_nickname();
-}
-
-} // namespace
 
 TEST_CASE("Check SSL certificates paths", "[Http][NotWorking]") {
     
@@ -53,62 +20,6 @@ TEST_CASE("Check SSL certificates paths", "[Http][NotWorking]") {
     REQUIRE(status == 200);
 }
 
-TEST_CASE("Orca cloud flat session resolves display name consistently", "[OrcaCloudServiceAgent]")
-{
-    CHECK(resolved_display_name(flat_session_json({
-        {"username", "orca_username"},
-        {"display_name", "Display Name"},
-        {"nickname", "Nickname"}
-    })) == "Display Name");
-
-    CHECK(resolved_display_name(flat_session_json({
-        {"username", "orca_username"},
-        {"nickname", "Nickname"}
-    })) == "Nickname");
-
-    CHECK(resolved_display_name(flat_session_json({
-        {"username", "orca_username"},
-        {"full_name", "Full Name"}
-    })) == "Full Name");
-
-    CHECK(resolved_display_name(flat_session_json({
-        {"username", "orca_username"},
-        {"name", "Provider Name"}
-    })) == "Provider Name");
-
-    CHECK(resolved_display_name(flat_session_json({
-        {"username", "orca_username"}
-    })) == "orca_username");
-}
-
-TEST_CASE("Orca cloud nested session resolves display name consistently", "[OrcaCloudServiceAgent]")
-{
-    CHECK(resolved_display_name(nested_session_json({
-        {"username", "orca_username"},
-        {"display_name", "Display Name"},
-        {"nickname", "Nickname"}
-    })) == "Display Name");
-
-    CHECK(resolved_display_name(nested_session_json({
-        {"username", "orca_username"},
-        {"nickname", "Nickname"}
-    })) == "Nickname");
-
-    CHECK(resolved_display_name(nested_session_json({
-        {"username", "orca_username"},
-        {"full_name", "Full Name"}
-    })) == "Full Name");
-
-    CHECK(resolved_display_name(nested_session_json({
-        {"username", "orca_username"},
-        {"name", "Provider Name"}
-    })) == "Provider Name");
-
-    CHECK(resolved_display_name(nested_session_json({
-        {"username", "orca_username"}
-    })) == "orca_username");
-}
-
 TEST_CASE("Http digest authentication", "[Http][NotWorking]") {
     Slic3r::Http g = Slic3r::Http::get("https://httpbingo.org/digest-auth/auth/guest/guest");
 

tests/slic3rutils/test_orca_cloud_agent.cpp

@@ -0,0 +1,173 @@
+#include <catch2/catch_all.hpp>
+
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+
+#include <memory>
+#include <string>
+
+#include "slic3r/Utils/OrcaCloudServiceAgent.hpp"
+#include "test_utils.hpp"
+
+using namespace Slic3r;
+namespace fs = boost::filesystem;
+
+namespace {
+
+// The encrypted token file is the one secret backend a test can observe without a system
+// keychain. Every agent pointed at the same directory shares it, like separate app instances
+// share the keychain entry.
+std::unique_ptr<OrcaCloudServiceAgent> make_file_backed_agent(const fs::path& dir)
+{
+    auto agent = std::make_unique<OrcaCloudServiceAgent>(dir.string());
+    agent->set_use_encrypted_token_file(true);
+    agent->set_config_dir(dir.string());
+    return agent;
+}
+
+fs::path secret_file(const fs::path& dir) { return dir / secret_constants::USER_SECRET_FILENAME; }
+
+nlohmann::json flat_session_json(const nlohmann::json& fields)
+{
+    nlohmann::json session = {
+        {"access_token", "test-token"},
+        {"user_id", "test-user-id"}
+    };
+    session.update(fields);
+    return session;
+}
+
+nlohmann::json nested_session_json(const nlohmann::json& metadata)
+{
+    return {
+        {"access_token", "test-token"},
+        {"user", {
+            {"id", "test-user-id"},
+            {"user_metadata", metadata}
+        }}
+    };
+}
+
+// set_user_session() persists the session, so it goes to a throwaway token file rather than the
+// system keychain of whoever runs the tests.
+std::string resolved_display_name(const nlohmann::json& session)
+{
+    ScopedTemporaryDir dir("orca-secret");
+    auto               agent = make_file_backed_agent(dir.path());
+    REQUIRE(agent->set_user_session(session, false));
+    return agent->get_user_nickname();
+}
+
+} // namespace
+
+TEST_CASE("Logging out removes the secret this instance saved", "[OrcaCloudServiceAgent]")
+{
+    ScopedTemporaryDir dir("orca-secret");
+    auto agent = make_file_backed_agent(dir.path());
+
+    agent->persist_user_secret("refresh-token");
+    REQUIRE(fs::exists(secret_file(dir.path())));
+
+    agent->user_logout(false);
+    CHECK_FALSE(fs::exists(secret_file(dir.path())));
+}
+
+TEST_CASE("Logging out removes a secret this instance loaded from the store", "[OrcaCloudServiceAgent]")
+{
+    ScopedTemporaryDir dir("orca-secret");
+    make_file_backed_agent(dir.path())->persist_user_secret("refresh-token");
+
+    auto        agent = make_file_backed_agent(dir.path());
+    std::string secret;
+    REQUIRE(agent->load_user_secret(secret));
+    CHECK(secret == "refresh-token");
+
+    agent->user_logout(false);
+    CHECK_FALSE(fs::exists(secret_file(dir.path())));
+}
+
+TEST_CASE("Logging out leaves a secret this instance never loaded or saved alone", "[OrcaCloudServiceAgent]")
+{
+    ScopedTemporaryDir dir("orca-secret");
+    make_file_backed_agent(dir.path())->persist_user_secret("refresh-token");
+
+    // A logged-out instance is asked to log out on every login-status poll.
+    auto other = make_file_backed_agent(dir.path());
+    other->user_logout(false);
+    other->user_logout(false);
+    CHECK(fs::exists(secret_file(dir.path())));
+
+    std::string secret;
+    REQUIRE(make_file_backed_agent(dir.path())->load_user_secret(secret));
+    CHECK(secret == "refresh-token");
+}
+
+TEST_CASE("Logging out leaves a secret this instance could not read alone", "[OrcaCloudServiceAgent]")
+{
+    ScopedTemporaryDir dir("orca-secret");
+    // Written under another encryption key, e.g. by another OS user sharing the data directory.
+    fs::ofstream(secret_file(dir.path())) << "v2:0000:not-a-payload-this-user-can-decrypt";
+
+    auto        agent = make_file_backed_agent(dir.path());
+    std::string secret;
+    REQUIRE_FALSE(agent->load_user_secret(secret));
+
+    agent->user_logout(false);
+    CHECK(fs::exists(secret_file(dir.path())));
+}
+
+TEST_CASE("Orca cloud flat session resolves display name consistently", "[OrcaCloudServiceAgent]")
+{
+    CHECK(resolved_display_name(flat_session_json({
+        {"username", "orca_username"},
+        {"display_name", "Display Name"},
+        {"nickname", "Nickname"}
+    })) == "Display Name");
+
+    CHECK(resolved_display_name(flat_session_json({
+        {"username", "orca_username"},
+        {"nickname", "Nickname"}
+    })) == "Nickname");
+
+    CHECK(resolved_display_name(flat_session_json({
+        {"username", "orca_username"},
+        {"full_name", "Full Name"}
+    })) == "Full Name");
+
+    CHECK(resolved_display_name(flat_session_json({
+        {"username", "orca_username"},
+        {"name", "Provider Name"}
+    })) == "Provider Name");
+
+    CHECK(resolved_display_name(flat_session_json({
+        {"username", "orca_username"}
+    })) == "orca_username");
+}
+
+TEST_CASE("Orca cloud nested session resolves display name consistently", "[OrcaCloudServiceAgent]")
+{
+    CHECK(resolved_display_name(nested_session_json({
+        {"username", "orca_username"},
+        {"display_name", "Display Name"},
+        {"nickname", "Nickname"}
+    })) == "Display Name");
+
+    CHECK(resolved_display_name(nested_session_json({
+        {"username", "orca_username"},
+        {"nickname", "Nickname"}
+    })) == "Nickname");
+
+    CHECK(resolved_display_name(nested_session_json({
+        {"username", "orca_username"},
+        {"full_name", "Full Name"}
+    })) == "Full Name");
+
+    CHECK(resolved_display_name(nested_session_json({
+        {"username", "orca_username"},
+        {"name", "Provider Name"}
+    })) == "Provider Name");
+
+    CHECK(resolved_display_name(nested_session_json({
+        {"username", "orca_username"}
+    })) == "orca_username");
+}

tests/slic3rutils/test_plugin_capability_config.cpp

@@ -38,6 +38,9 @@ namespace {
 // before this destructor's shutdown() runs.
 struct ScopedPluginManager
 {
+    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
+    // which would otherwise land in the working directory.
+    ScopedDataDir python_data_dir{"plugin-python"};
     bool initialized = PluginManager::instance().initialize();
 
     ~ScopedPluginManager()

tests/slic3rutils/test_plugin_cloud_metadata.cpp

@@ -31,6 +31,9 @@ namespace {
 // same as any other plugin.
 struct ScopedManagerShutdown
 {
+    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
+    // which would otherwise land in the working directory.
+    ScopedDataDir python_data_dir{"plugin-python"};
     bool initialized = PluginManager::instance().initialize();
 
     ~ScopedManagerShutdown()

tests/slic3rutils/test_plugin_lifecycle.cpp

@@ -42,6 +42,9 @@ namespace {
 // Declare this FIRST in a test so it is destroyed last.
 struct ScopedPluginManager
 {
+    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
+    // which would otherwise land in the working directory.
+    ScopedDataDir python_data_dir{"plugin-python"};
     bool initialized = false;
 
     ScopedPluginManager() { initialized = PluginManager::instance().initialize(); }

tests/slic3rutils/test_plugin_printer_agent.cpp

@@ -12,6 +12,8 @@
 #include <memory>
 #include <string>
 
+#include "plugin_test_utils.hpp"
+
 namespace py = pybind11;
 using namespace Slic3r;
 
@@ -21,6 +23,9 @@ namespace {
 // into Python unless PythonInterpreter::instance() reports initialized.
 struct ScopedPluginManager
 {
+    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
+    // which would otherwise land in the working directory.
+    ScopedDataDir python_data_dir{"plugin-python"};
     bool initialized = PluginManager::instance().initialize();
 
     ~ScopedPluginManager()

tests/slic3rutils/test_slicing_pipeline_config.cpp

@@ -35,6 +35,9 @@ namespace {
 
 struct ScopedPluginManager
 {
+    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
+    // which would otherwise land in the working directory.
+    ScopedDataDir python_data_dir{"plugin-python"};
     bool initialized = false;
 
     ScopedPluginManager() { initialized = PluginManager::instance().initialize(); }