cura_app.py 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238
  1. #!/usr/bin/env python3
  2. # Copyright (c) 2022 Ultimaker B.V.
  3. # Cura is released under the terms of the LGPLv3 or higher.
  4. # Remove the working directory from sys.path.
  5. # This fixes a security issue where Cura could import Python packages from the
  6. # current working directory, and therefore be made to execute locally installed
  7. # code (e.g. in the user's home directory where AppImages by default run from).
  8. # See issue CURA-7081.
  9. import sys
  10. if "" in sys.path:
  11. sys.path.remove("")
  12. import argparse
  13. import faulthandler
  14. import os
  15. if sys.platform != "linux": # Turns out the Linux build _does_ use this, but we're not making an Enterprise release for that system anyway.
  16. os.environ["QT_PLUGIN_PATH"] = "" # Security workaround: Don't need it, and introduces an attack vector, so set to nul.
  17. os.environ["QML2_IMPORT_PATH"] = "" # Security workaround: Don't need it, and introduces an attack vector, so set to nul.
  18. from PyQt5.QtNetwork import QSslConfiguration, QSslSocket
  19. from UM.Platform import Platform
  20. from cura import ApplicationMetadata
  21. from cura.ApplicationMetadata import CuraAppName
  22. from cura.CrashHandler import CrashHandler
  23. try:
  24. import sentry_sdk
  25. with_sentry_sdk = True
  26. except ImportError:
  27. with_sentry_sdk = False
  28. parser = argparse.ArgumentParser(prog = "cura",
  29. add_help = False)
  30. parser.add_argument("--debug",
  31. action = "store_true",
  32. default = False,
  33. help = "Turn on the debug mode by setting this option."
  34. )
  35. known_args = vars(parser.parse_known_args()[0])
  36. if with_sentry_sdk:
  37. sentry_env = "unknown" # Start off with a "IDK"
  38. if hasattr(sys, "frozen"):
  39. sentry_env = "production" # A frozen build has the possibility to be a "real" distribution.
  40. if ApplicationMetadata.CuraVersion == "master":
  41. sentry_env = "development" # Master is always a development version.
  42. elif "beta" in ApplicationMetadata.CuraVersion or "BETA" in ApplicationMetadata.CuraVersion:
  43. sentry_env = "beta"
  44. elif "alpha" in ApplicationMetadata.CuraVersion or "ALPHA" in ApplicationMetadata.CuraVersion:
  45. sentry_env = "alpha"
  46. try:
  47. if ApplicationMetadata.CuraVersion.split(".")[2] == "99":
  48. sentry_env = "nightly"
  49. except IndexError:
  50. pass
  51. # Errors to be ignored by Sentry
  52. ignore_errors = [KeyboardInterrupt, MemoryError]
  53. try:
  54. sentry_sdk.init("https://5034bf0054fb4b889f82896326e79b13@sentry.io/1821564",
  55. before_send = CrashHandler.sentryBeforeSend,
  56. environment = sentry_env,
  57. release = "cura%s" % ApplicationMetadata.CuraVersion,
  58. default_integrations = False,
  59. max_breadcrumbs = 300,
  60. server_name = "cura",
  61. ignore_errors = ignore_errors)
  62. except Exception:
  63. with_sentry_sdk = False
  64. if not known_args["debug"]:
  65. def get_cura_dir_path():
  66. if Platform.isWindows():
  67. appdata_path = os.getenv("APPDATA")
  68. if not appdata_path: #Defensive against the environment variable missing (should never happen).
  69. appdata_path = "."
  70. return os.path.join(appdata_path, CuraAppName)
  71. elif Platform.isLinux():
  72. return os.path.expanduser("~/.local/share/" + CuraAppName)
  73. elif Platform.isOSX():
  74. return os.path.expanduser("~/Library/Logs/" + CuraAppName)
  75. # Do not redirect stdout and stderr to files if we are running CLI.
  76. if hasattr(sys, "frozen") and "cli" not in os.path.basename(sys.argv[0]).lower():
  77. dirpath = get_cura_dir_path()
  78. os.makedirs(dirpath, exist_ok = True)
  79. sys.stdout = open(os.path.join(dirpath, "stdout.log"), "w", encoding = "utf-8")
  80. sys.stderr = open(os.path.join(dirpath, "stderr.log"), "w", encoding = "utf-8")
  81. # WORKAROUND: GITHUB-88 GITHUB-385 GITHUB-612
  82. if Platform.isLinux(): # Needed for platform.linux_distribution, which is not available on Windows and OSX
  83. # For Ubuntu: https://bugs.launchpad.net/ubuntu/+source/python-qt4/+bug/941826
  84. # The workaround is only needed on Ubuntu+NVidia drivers. Other drivers are not affected, but fine with this fix.
  85. try:
  86. import ctypes
  87. from ctypes.util import find_library
  88. libGL = find_library("GL")
  89. ctypes.CDLL(libGL, ctypes.RTLD_GLOBAL)
  90. except:
  91. # GLES-only systems (e.g. ARM Mali) do not have libGL, ignore error
  92. pass
  93. # When frozen, i.e. installer version, don't let PYTHONPATH mess up the search path for DLLs.
  94. if Platform.isWindows() and hasattr(sys, "frozen"):
  95. try:
  96. del os.environ["PYTHONPATH"]
  97. except KeyError:
  98. pass
  99. # GITHUB issue #6194: https://github.com/Ultimaker/Cura/issues/6194
  100. # With AppImage 2 on Linux, the current working directory will be somewhere in /tmp/<rand>/usr, which is owned
  101. # by root. For some reason, QDesktopServices.openUrl() requires to have a usable current working directory,
  102. # otherwise it doesn't work. This is a workaround on Linux that before we call QDesktopServices.openUrl(), we
  103. # switch to a directory where the user has the ownership.
  104. if Platform.isLinux() and hasattr(sys, "frozen"):
  105. os.chdir(os.path.expanduser("~"))
  106. # WORKAROUND: GITHUB-704 GITHUB-708
  107. # It looks like setuptools creates a .pth file in
  108. # the default /usr/lib which causes the default site-packages
  109. # to be inserted into sys.path before PYTHONPATH.
  110. # This can cause issues such as having libsip loaded from
  111. # the system instead of the one provided with Cura, which causes
  112. # incompatibility issues with libArcus
  113. if "PYTHONPATH" in os.environ.keys(): # If PYTHONPATH is used
  114. PYTHONPATH = os.environ["PYTHONPATH"].split(os.pathsep) # Get the value, split it..
  115. PYTHONPATH.reverse() # and reverse it, because we always insert at 1
  116. for PATH in PYTHONPATH: # Now beginning with the last PATH
  117. PATH_real = os.path.realpath(PATH) # Making the the path "real"
  118. if PATH_real in sys.path: # This should always work, but keep it to be sure..
  119. sys.path.remove(PATH_real)
  120. sys.path.insert(1, PATH_real) # Insert it at 1 after os.curdir, which is 0.
  121. def exceptHook(hook_type, value, traceback):
  122. from cura.CrashHandler import CrashHandler
  123. from cura.CuraApplication import CuraApplication
  124. has_started = False
  125. if CuraApplication.Created:
  126. has_started = CuraApplication.getInstance().started
  127. #
  128. # When the exception hook is triggered, the QApplication may not have been initialized yet. In this case, we don't
  129. # have an QApplication to handle the event loop, which is required by the Crash Dialog.
  130. # The flag "CuraApplication.Created" is set to True when CuraApplication finishes its constructor call.
  131. #
  132. # Before the "started" flag is set to True, the Qt event loop has not started yet. The event loop is a blocking
  133. # call to the QApplication.exec_(). In this case, we need to:
  134. # 1. Remove all scheduled events so no more unnecessary events will be processed, such as loading the main dialog,
  135. # loading the machine, etc.
  136. # 2. Start the Qt event loop with exec_() and show the Crash Dialog.
  137. #
  138. # If the application has finished its initialization and was running fine, and then something causes a crash,
  139. # we run the old routine to show the Crash Dialog.
  140. #
  141. from PyQt5.Qt import QApplication
  142. if CuraApplication.Created:
  143. _crash_handler = CrashHandler(hook_type, value, traceback, has_started)
  144. if CuraApplication.splash is not None:
  145. CuraApplication.splash.close()
  146. if not has_started:
  147. CuraApplication.getInstance().removePostedEvents(None)
  148. _crash_handler.early_crash_dialog.show()
  149. sys.exit(CuraApplication.getInstance().exec_())
  150. else:
  151. _crash_handler.show()
  152. else:
  153. application = QApplication(sys.argv)
  154. application.removePostedEvents(None)
  155. _crash_handler = CrashHandler(hook_type, value, traceback, has_started)
  156. # This means the QtApplication could be created and so the splash screen. Then Cura closes it
  157. if CuraApplication.splash is not None:
  158. CuraApplication.splash.close()
  159. _crash_handler.early_crash_dialog.show()
  160. sys.exit(application.exec_())
  161. # Set exception hook to use the crash dialog handler
  162. sys.excepthook = exceptHook
  163. # Enable dumping traceback for all threads
  164. if sys.stderr and not sys.stderr.closed:
  165. faulthandler.enable(file = sys.stderr, all_threads = True)
  166. elif sys.stdout and not sys.stdout.closed:
  167. faulthandler.enable(file = sys.stdout, all_threads = True)
  168. from cura.CuraApplication import CuraApplication
  169. # WORKAROUND: CURA-6739
  170. # The CTM file loading module in Trimesh requires the OpenCTM library to be dynamically loaded. It uses
  171. # ctypes.util.find_library() to find libopenctm.dylib, but this doesn't seem to look in the ".app" application folder
  172. # on Mac OS X. Adding the search path to environment variables such as DYLD_LIBRARY_PATH and DYLD_FALLBACK_LIBRARY_PATH
  173. # makes it work. The workaround here uses DYLD_FALLBACK_LIBRARY_PATH.
  174. if Platform.isOSX() and getattr(sys, "frozen", False):
  175. old_env = os.environ.get("DYLD_FALLBACK_LIBRARY_PATH", "")
  176. # This is where libopenctm.so is in the .app folder.
  177. search_path = os.path.join(CuraApplication.getInstallPrefix(), "MacOS")
  178. path_list = old_env.split(":")
  179. if search_path not in path_list:
  180. path_list.append(search_path)
  181. os.environ["DYLD_FALLBACK_LIBRARY_PATH"] = ":".join(path_list)
  182. import trimesh.exchange.load
  183. os.environ["DYLD_FALLBACK_LIBRARY_PATH"] = old_env
  184. # WORKAROUND: CURA-6739
  185. # Similar CTM file loading fix for Linux, but NOTE THAT this doesn't work directly with Python 3.5.7. There's a fix
  186. # for ctypes.util.find_library() in Python 3.6 and 3.7. That fix makes sure that find_library() will check
  187. # LD_LIBRARY_PATH. With Python 3.5, that fix needs to be backported to make this workaround work.
  188. if Platform.isLinux() and getattr(sys, "frozen", False):
  189. old_env = os.environ.get("LD_LIBRARY_PATH", "")
  190. # This is where libopenctm.so is in the AppImage.
  191. search_path = os.path.join(CuraApplication.getInstallPrefix(), "bin")
  192. path_list = old_env.split(":")
  193. if search_path not in path_list:
  194. path_list.append(search_path)
  195. os.environ["LD_LIBRARY_PATH"] = ":".join(path_list)
  196. import trimesh.exchange.load
  197. os.environ["LD_LIBRARY_PATH"] = old_env
  198. # WORKAROUND: Cura#5488
  199. # When using the KDE qqc2-desktop-style, the UI layout is completely broken, and
  200. # even worse, it crashes when switching to the "Preview" pane.
  201. if Platform.isLinux():
  202. os.environ["QT_QUICK_CONTROLS_STYLE"] = "default"
  203. if ApplicationMetadata.CuraDebugMode:
  204. ssl_conf = QSslConfiguration.defaultConfiguration()
  205. ssl_conf.setPeerVerifyMode(QSslSocket.VerifyNone)
  206. QSslConfiguration.setDefaultConfiguration(ssl_conf)
  207. app = CuraApplication()
  208. app.run()