Adding better wording for the Bambu Connect issue.

Author: QuinnDamerell

bambu_octoeverywhere/bambuclient.py

@@ -292,8 +292,16 @@ def _OnDisconnect(self, client:Any, userdata:Any, disconnect_flags:Any, reason_c
         # If the serial number is wrong in the subscribe call, instead of returning an error the Bambu Lab printers just disconnect.
         # 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("")
+            self.Logger.error("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
             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("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 OctoEverywhere 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.

elegoo_octoeverywhere/elegooclient.py

@@ -328,6 +328,7 @@ def _ClientWorker(self):
 
                 # Setup the websocket client for this connection.
                 self.WebSocket = Client(url, onWsOpen=self._OnWsConnect, onWsClose=self._OnWsClose, onWsError=self._OnWsError, onWsData=self._OnWsData)
+                self.WebSocket.SetDisableCertCheck(True)
 
                 # Connect to the server
                 with self.WebSocket:

linux_host/networksearch.py

@@ -363,6 +363,7 @@ def onWsError(ws:IWebSocketClient, exception:Exception):
             try:
                 logger.debug(f"Connecting to Elegoo on {url}...")
                 client = Client(url, onWsOpen=onWsOpen, onWsData=onWsData, onWsClose=onWsClose, onWsError=onWsError)
+                client.SetDisableCertCheck(True)
                 # We must run async, so we don't block this testing thread.
                 client.RunAsync()
                 failedToConnect = False

moonraker_octoeverywhere/moonrakerclient.py

@@ -499,6 +499,7 @@ def _WebSocketWorkerThread(self) -> None:
                                     onWsClose=self._onWsClose,
                                     onWsError=self._onWsError
                                     )
+                    self.WebSocket.SetDisableCertCheck(True)
 
                 # Run until the socket closes
                 # When it returns, ensure it's closed.

octoeverywhere/WebStream/octowebstreamwshelper.py

@@ -113,6 +113,9 @@ def AttemptConnection(self):
         if ws is None:
             return False
 
+        # Disable SSLs checks to support locally signed certs.
+        ws.SetDisableCertCheck(True)
+
         # To ensure we never leak a websocket, we need to use this lock.
         # We need to check the is closed flag and then only set the ws if it's not closed.
         with self.StateLock:
@@ -256,7 +259,7 @@ def _GetWebsocketObject(self) -> Optional[IWebSocketClient]:
 
         # Make the websocket object and start it running.
         self.Logger.debug(self.getLogMsgPrefix()+"opening websocket to "+str(uri) + " attempt "+ str(self.ConnectionAttempt))
-        return  Client(url=uri, onWsOpen=self.onWsOpened, onWsData=self.onWsData, onWsClose=self.onWsClosed, onWsError=self.onWsError, subProtocolList=self.SubProtocolList)
+        return Client(url=uri, onWsOpen=self.onWsOpened, onWsData=self.onWsData, onWsClose=self.onWsClosed, onWsError=self.onWsError, subProtocolList=self.SubProtocolList)
 
 
     # When close is called, all http operations should be shutdown.

octoeverywhere/interfaces.py

@@ -305,6 +305,10 @@ def Send(self, buffer:Buffer, msgStartOffsetBytes:Optional[int]=None, msgSize:Op
     def SendWithOptCode(self, buffer:Buffer, msgStartOffsetBytes:Optional[int]=None, msgSize:Optional[int]=None, optCode=WebSocketOpCode.BINARY) -> None:
         pass
 
+    @abstractmethod
+    def SetDisableCertCheck(self, disable:bool) -> None:
+        pass
+
 
 class IRelayWebSocketProvider(ABC):
 

octoeverywhere/websocketimpl.py

@@ -1,4 +1,5 @@
 import queue
+import ssl
 import threading
 from typing import Any, Dict, List, Callable, Optional
 
@@ -39,6 +40,7 @@ def __init__(
         self.hasFiredWsErrorCallback = False
         self.hasPendingErrorCallbackFire = False
         self.hasDeferredCloseCallbackDueToPendingErrorCallback = False
+        self.disableCertCheck = False
 
         # We use a send queue thread because it allows us to process downloads about 2x faster.
         # This is because the downstream work of the WS can be made faster if it's done in parallel
@@ -96,6 +98,12 @@ def OnError(ws:WebSocket, exception:Exception):
         )
 
 
+    # This has it's own function so the caller very explicitly has to call it, rather than it being an init overload.
+    # If set to true, this websocket connection will not validate the cert it's connecting to. This should only be done locally!
+    def SetDisableCertCheck(self, disable:bool):
+        self.disableCertCheck = disable
+
+
     # Runs the websocket blocking until it closes.
     def RunUntilClosed(self, pingIntervalSec:Optional[int]=None, pingTimeoutSec:Optional[int]=None):
         #
@@ -133,12 +141,17 @@ def RunUntilClosed(self, pingIntervalSec:Optional[int]=None, pingTimeoutSec:Opti
             if pingIntervalSec > 0 and pingTimeoutSec <= 0:
                 raise Exception("The ping timeout must be greater than 0.")
 
+            # Only if the client explicated called the function to disable this will we turn off cert verification.
+            sslopt={"ca_certs":certifi.where()}
+            if self.disableCertCheck:
+                sslopt = {"cert_reqs":  ssl.CERT_NONE, "check_hostname": False}
+
             # Since some clients use RunAsync, check that we didn't close before the async action started.
             with self.isClosedLock:
                 if self.isClosed:
                     return
 
-            self.Ws.run_forever(skip_utf8_validation=True, ping_interval=pingIntervalSec, ping_timeout=pingTimeoutSec, sslopt={"ca_certs":certifi.where()})  #pyright: ignore[reportUnknownMemberType]
+            self.Ws.run_forever(skip_utf8_validation=True, ping_interval=pingIntervalSec, ping_timeout=pingTimeoutSec, sslopt=sslopt)  #pyright: ignore[reportUnknownMemberType]
         except Exception as e:
             # There's a compat issue where  run_forever will try to access "isAlive" when the socket is closing
             # "isAlive" apparently doesn't exist in some PY versions of thread, so this throws. We will ignore that error,

py_installer/NetworkConnectors/MoonrakerConnector.py

@@ -276,6 +276,7 @@ def OnError(ws:IWebSocketClient, exception:Exception):
         Logger.Debug(f"Checking for moonraker using the address: `{url}`")
         try:
             with Client(url, onWsOpen=OnOpened, onWsData=OnData, onWsError=OnError, onWsClose=OnClosed) as ws:
+                ws.SetDisableCertCheck(True)
                 ws.RunAsync()
 
                 # Wait for the event or a timeout.