Merge OctoEverywhere changes

bambu_octoapp/bambuclient.py

@@ -2,6 +2,7 @@
 import time
 import json
 import socket
+import logging
 import threading
 from typing import Any, Dict, List, Optional
 
@@ -34,7 +35,7 @@ class BambuClient:
     _Instance:"BambuClient" = None #pyright: ignore[reportAssignmentType]
 
     # Useful for debugging.
-    _PrintMQTTMessages = True
+    _PrintMQTTMessages = False
 
     @staticmethod
     def Init(logger:LoggerLike, config:Config, stateTranslator:IBambuStateTranslator) -> None:
@@ -75,6 +76,8 @@ def __init__(self, logger:LoggerLike, config:Config, stateTranslator:IBambuState
 
         # We use this var to keep track of consecutively failed connections
         self.ConsecutivelyFailedConnectionAttempts = 0
+        # This flag indicates if we have tried a network scan since the plugin started. If not, we should do it again.
+        self.HasDoneNetScanSincePluginStart = False
 
         # Start a thread to setup and maintain the connection.
         self.CurrentConnectionContext:Optional[ConnectionContext] = None
@@ -287,7 +290,15 @@ def _OnDisconnect(self, client:Any, userdata:Any, disconnect_flags:Any, reason_c
         # So if we were pending a subscribe call, give the user a better error message so they know the likely cause.
         if self.IsPendingSubscribe:
             self.Logger.error("Bambu printer mqtt connection lost when trying to sub for events.")
-            self.Logger.error(f"THIS USUALLY MEANS THE PRINTER SERIAL NUMBER IS WRONG. We tried to use the serial number '{self.PrinterSn}'. Double check the SN is correct.")
+            self.Logger.error("")
+            self.Logger.error("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
+            self.Logger.error("This might indicate the printer ACCESS CODE - OR - SERIAL NUMBER IS WRONG.")
+            self.Logger.error(f"     Current Serial Number: '{self.PrinterSn}'")
+            self.Logger.error(f"     Current Access Code:   '{self.LanAccessCode}'")
+            self.Logger.error("")
+            self.Logger.error("Check these values match your printer. If they changed, run the OctoApp installer again to update them or update your Docker configuration.")
+            self.Logger.error("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
+            self.Logger.error("")
         else:
             self.Logger.warning("Bambu printer connection lost. We will try to reconnect in a few seconds.")
         # Clear the state since we lost the connection and won't stay synced.
@@ -342,7 +353,7 @@ def _OnMessage(self, client:Any, userdata:Any, mqttMsg:mqtt.MQTTMessage) -> None
                 raise Exception("Parsed json MQTT message returned None")
 
             # Print for debugging if desired.
-            if BambuClient._PrintMQTTMessages:
+            if BambuClient._PrintMQTTMessages and self.Logger.isEnabledFor(logging.DEBUG):
                 self.Logger.debug("Incoming Bambu Message:\r\n"+json.dumps(msg, indent=3))
 
             # Since we keep a track of the state locally from the partial updates, we need to feed all updates to our state object.
@@ -433,7 +444,8 @@ def _GetConnectionContextToTry(self, isConnectAttemptFromEventBump:bool) -> Conn
         if isConnectAttemptFromEventBump is False:
             self.ConsecutivelyFailedConnectionAttempts += 1
         doPrinterSearch = False
-        if self.ConsecutivelyFailedConnectionAttempts > 6:
+        # We only search every now and then, unless this is one of the first connect attempts after the plugin started.
+        if (self.HasDoneNetScanSincePluginStart is False and self.ConsecutivelyFailedConnectionAttempts > 1) or self.ConsecutivelyFailedConnectionAttempts > 6:
             self.ConsecutivelyFailedConnectionAttempts = 0
             doPrinterSearch = True
 
@@ -468,7 +480,8 @@ def _GetConnectionContextToTry(self, isConnectAttemptFromEventBump:bool) -> Conn
         self.Logger.info(f"Searching for your Bambu Lab printer {self.PrinterSn}")
         if self.LanAccessCode is None:
             return self._GetLocalConnectionContext(configIpOrHostname)
-        ips = NetworkSearch.ScanForInstances_Bambu(self.Logger, self.LanAccessCode, self.PrinterSn, threadCount=25, delaySec=0.2)
+        self.HasDoneNetScanSincePluginStart = True
+        ips = NetworkSearch.ScanForInstances_Bambu(self.Logger, self.LanAccessCode, self.PrinterSn, ipHint=configIpOrHostname, threadCount=25, delaySec=0.2)
 
         # If we get an IP back, it is the printer.
         # The scan above will only return an IP if the printer was successfully connected to, logged into, and fully authorized with the Access Token and Printer SN.

bambu_octoapp/bambumodels.py

@@ -26,6 +26,7 @@ class BambuHmsEntry(NamedTuple):
 class BambuPrintErrors(Enum):
     Unknown = 1             # This will be most errors, since most of them aren't mapped
     FilamentRunOut = 2
+    PrintFailureDetected = 3 # The Bambu AI detected a failure.
 
 
 # Since MQTT syncs a full state and then sends partial updates, we keep track of the full state

bambu_octoapp/bambustatetranslater.py

@@ -156,8 +156,11 @@ def BambuOnPauseOrTempError(self, bambuState:BambuState) -> None:
             self.NotificationsHandler.OnFilamentChange()
             return
 
-        # Send a generic error.
-        self.NotificationsHandler.OnUserInteractionNeeded()
+        # Send the error string from the bambu API map.
+        errorStr = bambuState.GetFileNameWithNoExtension()
+        if errorStr is None:
+            errorStr = "General Error"
+        self.NotificationsHandler.OnError(errorStr)
 
 
     def BambuOnResume(self, bambuState:BambuState) -> None:

elegoo_octoapp/elegoostatetranslater.py

@@ -1,8 +1,10 @@
+import threading
 from typing import Optional, Tuple
 
 from octoapp.logging import LoggerLike
 from octoapp.notificationshandler import NotificationsHandler
 from octoapp.interfaces import IPrinterStateReporter
+from octoapp.util.delayedcallback import DelayedCallback
 
 from .elegooclient import ElegooClient
 from .elegoomodels import PrinterState
@@ -14,11 +16,16 @@
 # and to act as the printer state interface for Bambu printers.
 class ElegooStateTranslator(IPrinterStateReporter, IStateTranslator):
 
+    # The amount of time we will wait for a reconnect before we fire the disconnected notification.
+    c_ConnectionLostNotificationDelaySec = 10.0
+
     def __init__(self, logger:LoggerLike) -> None:
         self.Logger = logger
         self.NotificationsHandler:NotificationsHandler = None #pyright: ignore[reportAttributeAccessIssue]
         self.LastStatus:Optional[str] = None
         self.IsWaitingOnPrintInfoToFirePrintStart = False
+        self.DelayedConnectionLostCallback:Optional[DelayedCallback] = None
+        self.DelayedConnectionLostCallbackLock = threading.Lock()
 
 
     def SetNotificationHandler(self, notificationHandler:NotificationsHandler):
@@ -32,18 +39,33 @@ def OnConnectionLost(self, wasFullyConnected:bool) -> None:
         # If we were fully connected and were printing or warming up, then report  the connection loss.
         # Otherwise, don't bother, since it might just be the user turning off the printer.
         if wasFullyConnected and (PrinterState.IsPrepareOrSlicingState(self.LastStatus) or PrinterState.IsPrintingState(self.LastStatus, False)):
-            self.NotificationsHandler.OnError("Connection to printer lost during a print.")
+            # There seems to be a bug while printing where we will get disconnected from the printer's server but then reconnected with no effect on the print.
+            # To combat spammy notifications, we use a delayed callback to only fire after we know we have been disconnected for some time.
+            with self.DelayedConnectionLostCallbackLock:
+                if self.DelayedConnectionLostCallback is not None:
+                    self.DelayedConnectionLostCallback.Cancel()
+                self.DelayedConnectionLostCallback = DelayedCallback.Create(self.Logger, "ElegooDelayedConnectionLostCallback", self.c_ConnectionLostNotificationDelaySec, self._DelayedConnectionLostCallback)
 
         # Always reset our state.
         self.LastStatus = None
         self.IsWaitingOnPrintInfoToFirePrintStart = False
 
 
+    def _DelayedConnectionLostCallback(self):
+        self.NotificationsHandler.OnError("Connection to printer lost during a print.")
+
+
     # Fired when any mqtt message comes in.
     # State will always be NOT NONE, since it's going to be created before this call.
     # The isFirstFullSyncResponse flag indicates if this is the first full state sync of a new connection.
     def OnStatusUpdate(self, pState:PrinterState, isFirstFullSyncResponse:bool) -> None:
 
+        # Ensure if we have a connection lost delay in progress, cancel it since we're back.
+        with self.DelayedConnectionLostCallbackLock:
+            if self.DelayedConnectionLostCallback is not None:
+                self.DelayedConnectionLostCallback.Cancel()
+                self.DelayedConnectionLostCallback = None
+
         # First, if we have a new connection and we just synced, make sure the notification handler is in sync.
         if isFirstFullSyncResponse:
             self.NotificationsHandler.OnRestorePrintIfNeeded(pState.IsPrinting(False), pState.IsPaused(), pState.GetPrintCookie())

moonraker_octoapp/moonrakerclient.py

@@ -388,8 +388,12 @@ def _OnWsNonResponseMessage(self, msg:Dict[str, Any]) -> None:
                         jobObj = jobContainerObj["job"]
                         filename = jobObj.get("filename", None)
                         if filename is not None:
-                            self.MoonrakerCompat.OnPrintStart(filename)
-                            self.DownloadFileForProcessing(filename)
+                            # Note sometimes the filename can just be ""
+                            if len(filename) == 0:
+                                self.Logger.info("Moonraker client detected print start with no file name, so we aren't firing the print started event.")
+                            else:
+                                self.MoonrakerCompat.OnPrintStart(filename)
+                                self.DownloadFileForProcessing(filename)
                             return
                 elif action == "finished":
                     # This can be a finish canceled or failed.
@@ -560,6 +564,7 @@ def RunBlocking(self) -> None:
                                     onWsClose=self._onWsClose,
                                     onWsError=self._onWsError
                                     )
+                    self.WebSocket.SetDisableCertCheck(True)
 
                 # Run until the socket closes
                 # When it returns, ensure it's closed.

octoapp/Proto/HandshakeAck.py

@@ -0,0 +1,159 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: Proto
+
+import octoflatbuffers
+from typing import Any
+from typing import Optional
+class HandshakeAck(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset: int = 0):
+        n = octoflatbuffers.encode.Get(octoflatbuffers.packer.uoffset, buf, offset)
+        x = HandshakeAck()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsHandshakeAck(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # HandshakeAck
+    def Init(self, buf: bytes, pos: int):
+        self._tab = octoflatbuffers.table.Table(buf, pos)
+
+    # HandshakeAck
+    def Accepted(self):
+        o = octoflatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(octoflatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # HandshakeAck
+    def ConnectedAccounts(self, j: int):
+        o = octoflatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + octoflatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # HandshakeAck
+    def ConnectedAccountsLength(self) -> int:
+        o = octoflatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # HandshakeAck
+    def ConnectedAccountsIsNone(self) -> bool:
+        o = octoflatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # HandshakeAck
+    def Error(self) -> Optional[str]:
+        o = octoflatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # HandshakeAck
+    def BackoffSeconds(self):
+        o = octoflatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(octoflatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # HandshakeAck
+    def RequiresPluginUpdate(self):
+        o = octoflatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(octoflatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # HandshakeAck
+    def Octokey(self) -> Optional[str]:
+        o = octoflatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # HandshakeAck
+    def RsaChallengeResult(self) -> Optional[str]:
+        o = octoflatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # HandshakeAck
+    def RequiresRekey(self):
+        o = octoflatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return bool(self._tab.Get(octoflatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def HandshakeAckStart(builder: octoflatbuffers.Builder):
+    builder.StartObject(8)
+
+def Start(builder: octoflatbuffers.Builder):
+    HandshakeAckStart(builder)
+
+def HandshakeAckAddAccepted(builder: octoflatbuffers.Builder, accepted: bool):
+    builder.PrependBoolSlot(0, accepted, 0)
+
+def AddAccepted(builder: octoflatbuffers.Builder, accepted: bool):
+    HandshakeAckAddAccepted(builder, accepted)
+
+def HandshakeAckAddConnectedAccounts(builder: octoflatbuffers.Builder, connectedAccounts: int):
+    builder.PrependUOffsetTRelativeSlot(1, octoflatbuffers.number_types.UOffsetTFlags.py_type(connectedAccounts), 0)
+
+def AddConnectedAccounts(builder: octoflatbuffers.Builder, connectedAccounts: int):
+    HandshakeAckAddConnectedAccounts(builder, connectedAccounts)
+
+def HandshakeAckStartConnectedAccountsVector(builder, numElems: int) -> int:
+    return builder.StartVector(4, numElems, 4)
+
+def StartConnectedAccountsVector(builder, numElems: int) -> int:
+    return HandshakeAckStartConnectedAccountsVector(builder, numElems)
+
+def HandshakeAckAddError(builder: octoflatbuffers.Builder, error: int):
+    builder.PrependUOffsetTRelativeSlot(2, octoflatbuffers.number_types.UOffsetTFlags.py_type(error), 0)
+
+def AddError(builder: octoflatbuffers.Builder, error: int):
+    HandshakeAckAddError(builder, error)
+
+def HandshakeAckAddBackoffSeconds(builder: octoflatbuffers.Builder, backoffSeconds: int):
+    builder.PrependUint64Slot(3, backoffSeconds, 0)
+
+def AddBackoffSeconds(builder: octoflatbuffers.Builder, backoffSeconds: int):
+    HandshakeAckAddBackoffSeconds(builder, backoffSeconds)
+
+def HandshakeAckAddRequiresPluginUpdate(builder: octoflatbuffers.Builder, requiresPluginUpdate: bool):
+    builder.PrependBoolSlot(4, requiresPluginUpdate, 0)
+
+def AddRequiresPluginUpdate(builder: octoflatbuffers.Builder, requiresPluginUpdate: bool):
+    HandshakeAckAddRequiresPluginUpdate(builder, requiresPluginUpdate)
+
+def HandshakeAckAddOctokey(builder: octoflatbuffers.Builder, octokey: int):
+    builder.PrependUOffsetTRelativeSlot(5, octoflatbuffers.number_types.UOffsetTFlags.py_type(octokey), 0)
+
+def AddOctokey(builder: octoflatbuffers.Builder, octokey: int):
+    HandshakeAckAddOctokey(builder, octokey)
+
+def HandshakeAckAddRsaChallengeResult(builder: octoflatbuffers.Builder, rsaChallengeResult: int):
+    builder.PrependUOffsetTRelativeSlot(6, octoflatbuffers.number_types.UOffsetTFlags.py_type(rsaChallengeResult), 0)
+
+def AddRsaChallengeResult(builder: octoflatbuffers.Builder, rsaChallengeResult: int):
+    HandshakeAckAddRsaChallengeResult(builder, rsaChallengeResult)
+
+def HandshakeAckAddRequiresRekey(builder: octoflatbuffers.Builder, requiresRekey: bool):
+    builder.PrependBoolSlot(7, requiresRekey, 0)
+
+def AddRequiresRekey(builder: octoflatbuffers.Builder, requiresRekey: bool):
+    HandshakeAckAddRequiresRekey(builder, requiresRekey)
+
+def HandshakeAckEnd(builder: octoflatbuffers.Builder) -> int:
+    return builder.EndObject()
+
+def End(builder: octoflatbuffers.Builder) -> int:
+    return HandshakeAckEnd(builder)

octoapp/Proto/HandshakeSyn.py

@@ -176,8 +176,15 @@ def DeviceId(self) -> Optional[str]:
             return self._tab.String(o + self._tab.Pos)
         return None
 
+    # HandshakeSyn
+    def IsDockerContainer(self):
+        o = octoflatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        if o != 0:
+            return bool(self._tab.Get(octoflatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
 def HandshakeSynStart(builder: octoflatbuffers.Builder):
-    builder.StartObject(18)
+    builder.StartObject(19)
 
 def Start(builder: octoflatbuffers.Builder):
     HandshakeSynStart(builder)
@@ -296,6 +303,12 @@ def HandshakeSynAddDeviceId(builder: octoflatbuffers.Builder, deviceId: int):
 def AddDeviceId(builder: octoflatbuffers.Builder, deviceId: int):
     HandshakeSynAddDeviceId(builder, deviceId)
 
+def HandshakeSynAddIsDockerContainer(builder: octoflatbuffers.Builder, isDockerContainer: bool):
+    builder.PrependBoolSlot(18, isDockerContainer, 0)
+
+def AddIsDockerContainer(builder: octoflatbuffers.Builder, isDockerContainer: bool):
+    HandshakeSynAddIsDockerContainer(builder, isDockerContainer)
+
 def HandshakeSynEnd(builder: octoflatbuffers.Builder) -> int:
     return builder.EndObject()