Only talk to the CuraEngine socket from the same (Main) thread, and be a lot more careful about handling the StartSliceJob when restarting CuraEngine.

Fixes CURA-1434

plugins/CuraEngineBackend/CuraEngineBackend.py

@@ -74,6 +74,7 @@ class CuraEngineBackend(Backend):
         self._message_handlers["cura.proto.SlicingFinished"] = self._onSlicingFinishedMessage
 
         self._slicing = False
+        self._start_slice_job = None
         self._restart = False
         self._enabled = True
         self._always_restart = True
@@ -153,14 +154,19 @@ class CuraEngineBackend(Backend):
         self._slicing = True
         self.slicingStarted.emit()
 
-        job = StartSliceJob.StartSliceJob(self._profile, self._socket)
+        slice_message = self._socket.createMessage("cura.proto.Slice")
-        job.start()
+        settings_message = self._socket.createMessage("cura.proto.SettingList");
-        job.finished.connect(self._onStartSliceCompleted)
+        self._start_slice_job = StartSliceJob.StartSliceJob(self._profile, slice_message, settings_message)
+        self._start_slice_job.start()
+        self._start_slice_job.finished.connect(self._onStartSliceCompleted)
 
     def _terminate(self):
         self._slicing = False
         self._restart = True
         self._stored_layer_data = []
+        if self._start_slice_job is not None:
+            self._start_slice_job.cancel()
+
         self.slicingCancelled.emit()
         self.processingProgress.emit(0)
         Logger.log("d", "Attempting to kill the engine process")
@@ -174,13 +180,19 @@ class CuraEngineBackend(Backend):
             except Exception as e: # terminating a process that is already terminating causes an exception, silently ignore this.
                 Logger.log("d", "Exception occured while trying to kill the engine %s", str(e))
 
-
     def _onStartSliceCompleted(self, job):
-        if job.getError() or job.getResult() != True:
+        # Note that cancelled slice jobs can still call this method.
+        if self._start_slice_job is job:
+            self._start_slice_job = None
+        if job.isCancelled() or job.getError() or job.getResult() != True:
             if self._message:
                 self._message.hide()
                 self._message = None
             return
+        else:
+            # Preparation completed, send it to the backend.
+            self._socket.sendMessage(job.getSettingsMessage())
+            self._socket.sendMessage(job.getSliceMessage())
 
     def _onSceneChanged(self, source):
         if type(source) is not SceneNode:

plugins/CuraEngineBackend/StartSliceJob.py

@@ -27,18 +27,25 @@ class GcodeStartEndFormatter(Formatter):
             Logger.log("w", "Incorrectly formatted placeholder '%s' in start/end gcode", key)
             return "{" + str(key) + "}"
 
-##  Job class that handles sending the current scene data to CuraEngine
+##  Job class that builds up the message of scene data to send to CuraEngine.
 class StartSliceJob(Job):
-    def __init__(self, profile, socket):
+    def __init__(self, profile, sliceMessage, settingsMessage):
         super().__init__()
 
         self._scene = Application.getInstance().getController().getScene()
         self._profile = profile
-        self._socket = socket
+        self._slice_message = sliceMessage
+        self._settings_message = settingsMessage
+        self._is_cancelled = False
+
+    def getSettingsMessage(self):
+        return self._settings_message
+
+    def getSliceMessage(self):
+        return self._slice_message
 
     def run(self):
-        self._scene.acquireLock()
+        with self._scene.getSceneLock():
-
             for node in DepthFirstIterator(self._scene.getRoot()):
                 if node.callDecoration("getLayerData"):
                     node.getParent().removeChild(node)
@@ -74,17 +81,13 @@ class StartSliceJob(Job):
                 if temp_list:
                     object_groups.append(temp_list)
 
-        self._scene.releaseLock()
-
             if not object_groups:
                 return
 
-        self._sendSettings(self._profile)
+            self._buildSettingsMessage(self._profile)
-
-        slice_message = self._socket.createMessage("cura.proto.Slice")
 
             for group in object_groups:
-            group_message = slice_message.addRepeatedMessage("object_lists")
+                group_message = self._slice_message.addRepeatedMessage("object_lists")
                 if group[0].getParent().callDecoration("isGroup"):
                     self._handlePerObjectSettings(group[0].getParent(), group_message)
                 for object in group:
@@ -103,11 +106,15 @@ class StartSliceJob(Job):
 
                     Job.yieldThread()
 
-        Logger.log("d", "Sending data to engine for slicing.")
-        self._socket.sendMessage(slice_message)
-        Logger.log("d", "Sending data to engine is completed")
         self.setResult(True)
 
+    def cancel(self):
+        super().cancel()
+        self._is_cancelled = True
+
+    def isCancelled(self):
+        return self._is_cancelled
+
     def _expandGcodeTokens(self, key, value, settings):
         try:
             # any setting can be used as a token
@@ -117,22 +124,19 @@ class StartSliceJob(Job):
             Logger.log("w", "Unabled to do token replacement on start/end gcode %s", traceback.format_exc())
             return str(value).encode("utf-8")
 
-    def _sendSettings(self, profile):
+    def _buildSettingsMessage(self, profile):
-        msg = self._socket.createMessage("cura.proto.SettingList");
         settings = profile.getAllSettingValues(include_machine = True)
         start_gcode = settings["machine_start_gcode"]
         settings["material_bed_temp_prepend"] = "{material_bed_temperature}" not in start_gcode
         settings["material_print_temp_prepend"] = "{material_print_temperature}" not in start_gcode
         for key, value in settings.items():
-            s = msg.addRepeatedMessage("settings")
+            s = self._settings_message.addRepeatedMessage("settings")
             s.name = key
             if key == "machine_start_gcode" or key == "machine_end_gcode":
                 s.value = self._expandGcodeTokens(key, value, settings)
             else:
                 s.value = str(value).encode("utf-8")
 
-        self._socket.sendMessage(msg)
-
     def _handlePerObjectSettings(self, node, message):
         profile = node.callDecoration("getProfile")
         if profile: