def __init_websockets(splash, app_bootstrap, settings): """ Initializes the local websocket server. :pram splash: Splash widget. :param app_bootstrap: The application bootstrap instance. :param settings: The application's settings. :returns: The tk_framework_desktopserver.Server instance and a boolean indicating if the Desktop should keep launching. """ if not __is_64bit_python(): # Do not import if Python is not 64-bits logger.warning("Interpreter is not 64-bits, can't load desktop server") return None, True if not settings.integration_enabled: # Do not import if server is disabled. logger.info("Integration was disabled in config.ini.") return None, True # First try to import the framework. If it fails, let the user decide if the Desktop should # keep launching. try: splash.show() splash.set_message("Initializing browser integration") # Import framework import tk_framework_desktopserver app_bootstrap.add_logger_to_logfile( tk_framework_desktopserver.get_logger()) except Exception, e: return None, __handle_unexpected_exception_during_websocket_init( splash, app_bootstrap, e)
def _assert_toolkit_enabled(splash, connection): """ Returns the path to the pipeline configuration for a given site. :param splash: Splash dialog """ # get the pipeline configuration for the site we are logged into while True: pc_schema = connection.schema_entity_read().get( "PipelineConfiguration") if pc_schema is not None: break # Toolkit is not turned on show the dialog that explains what to do splash.hide() dialog = TurnOnToolkit(connection) dialog.show() dialog.raise_() dialog.activateWindow() results = dialog.exec_() if results == dialog.Rejected: # dialog was canceled, raise the exception and let the main exception handler deal # with it. raise ToolkitDisabledError() splash.show()
def _assert_toolkit_enabled(splash, connection): """ Returns the path to the pipeline configuration for a given site. :param splash: Splash dialog """ # get the pipeline configuration for the site we are logged into while True: pc_schema = connection.schema_entity_read().get("PipelineConfiguration") if pc_schema is not None: break # Toolkit is not turned on show the dialog that explains what to do splash.hide() dialog = TurnOnToolkit(connection) dialog.show() dialog.raise_() dialog.activateWindow() results = dialog.exec_() if results == dialog.Rejected: # dialog was canceled, raise the exception and let the main exception handler deal # with it. raise ToolkitDisabledError() splash.show()
def __init_websockets(splash, app_bootstrap, settings): """ Initializes the local websocket server. :pram splash: Splash widget. :param app_bootstrap: The application bootstrap instance. :param settings: The application's settings. :returns: The tk_framework_desktopserver.Server instance and a boolean indicating if the Desktop should keep launching. """ if not __is_64bit_python(): # Do not import if Python is not 64-bits logger.warning("Interpreter is not 64-bits, can't load desktop server") return None, True if not settings.integration_enabled: # Do not import if server is disabled. logger.info("Integration was disabled in config.ini.") return None, True # First try to import the framework. If it fails, let the user decide if the Desktop should # keep launching. try: splash.show() splash.set_message("Initializing browser integration") # Import framework import tk_framework_desktopserver app_bootstrap.add_logger_to_logfile(tk_framework_desktopserver.get_logger()) except Exception, e: return None, __handle_unexpected_exception_during_websocket_init(splash, app_bootstrap, e)
def __launch_app(app, splash, user, app_bootstrap, settings): """ Shows the splash screen, optionally downloads and configures Toolkit, imports it, optionally updates it and then launches the desktop engine. :param app: Application object for event processing. :param splash: Splash dialog to update user on what is currently going on :param user: Current ShotgunUser. :param app_bootstrap: Application bootstrap. :param settings: The application's settings. :returns: The error code to return to the shell. """ # show the splash screen splash.show() import sgtk sgtk.set_authenticated_user(user) # Downloads an upgrade for the startup if available. startup_updated = upgrade_startup( splash, sgtk, app_bootstrap ) if startup_updated: __restart_app_with_countdown(splash, "Shotgun Desktop updated.") splash.set_message("Looking up site configuration.") connection = user.create_sg_connection() _assert_toolkit_enabled(splash, connection) logger.debug("Getting the default site configuration.") pc_path, pc, toolkit_classic_required = shotgun_desktop.paths.get_pipeline_configuration_info(connection) # We're about to bootstrap, so remove sgtk from our scope so that if we add # code that uses it after the bootstrap we have to import the # new core. del sgtk if toolkit_classic_required: engine = __start_engine_in_toolkit_classic(app, splash, user, pc, pc_path) else: engine = __start_engine_in_zero_config(app, app_bootstrap, splash, user) return __post_bootstrap_engine(splash, app_bootstrap, engine, settings)
def __restart_app_with_countdown(splash, reason): """ Restarts the app after displaying a countdown. :param splash: Splash dialog, used to display the countdown. :param reason: Reason to display in the dialog for the restart. :throws RequestRestartException: This method never returns and throws """ # Provide a countdown so the user knows that the desktop app is being restarted # on purpose because of a core update. Otherwise, the user would get a flickering # splash screen that from the user point of view looks like the app is redoing work # it already did by mistake. This makes the behavior explicit. splash.show() splash.raise_() splash.activateWindow() for i in range(3, 0, -1): splash.set_message("%s Restarting in %d seconds..." % (reason, i)) time.sleep(1) raise RequestRestartException()
def __restart_app_with_countdown(splash, reason): """ Restarts the app after displaying a countdown. :param splash: Splash dialog, used to display the countdown. :param reason: Reason to display in the dialog for the restart. :throws RequestRestartException: This method never returns and throws """ # Provide a countdown so the user knows that the desktop app is being restarted # on purpose because of a core update. Otherwise, the user would get a flickering # splash screen that from the user point of view looks like the app is redoing work # it already did by mistake. This makes the behavior explicit. splash.show() splash.raise_() splash.activateWindow() for i in range(3, 0, -1): splash.set_message("%s Restarting in %d seconds..." % (reason, i)) time.sleep(1) raise RequestRestartException()
def __launch_app(app, splash, user, app_bootstrap, settings): """ Shows the splash screen, optionally downloads and configures Toolkit, imports it, optionally updates it and then launches the desktop engine. :param app: Application object for event processing. :param splash: Splash dialog to update user on what is currently going on :param user: Current ShotgunUser. :param app_bootstrap: Application bootstrap. :param settings: The application's settings. :returns: The error code to return to the shell. """ # show the splash screen splash.show() import sgtk sgtk.set_authenticated_user(user) # Downloads an upgrade for the startup if available. startup_updated = upgrade_startup(splash, sgtk, app_bootstrap) if startup_updated: # We need to restore the global debug logging setting prior to # restarting the app so that forced debug logging is not remembered # as the startup state. Once Desktop relaunches it will resume forced # debug logging until core swap, when the original launch setting is # restored. __restore_global_debug_flag() __restart_app_with_countdown(splash, "Shotgun Desktop updated.") splash.set_message("Looking up site configuration.") connection = user.create_sg_connection() _assert_toolkit_enabled(splash, connection) logger.debug("Getting the default site configuration.") pc_path, pc, toolkit_classic_required = shotgun_desktop.paths.get_pipeline_configuration_info( connection) # We need to toggle the global debug logging setting back prior to swapping # core. Cores older than v0.18.117 do not manage the TK_DEBUG environment # variable when global debug is toggled, so we can end up in a situation # where the new core in desktopstartup toggles it on, setting the env var, # and then when the toggle off occurs we end up with the older core in the # site config NOT purging the TK_DEBUG env var. The result is that any # subprocesses spawned then end up with debug logging on when the user # didn't ask for it. This impacts engine command execution from both Desktop # and via browser integration. It is the biggest issue with browser # integration, however, as the debug logs are reported back to the web # app from the desktopserver RPC API, and the user is presented with a # dialog full of debug log messages. __restore_global_debug_flag() # We're about to bootstrap, so remove sgtk from our scope so that if we add # code that uses it after the bootstrap we have to import the # new core. del sgtk if toolkit_classic_required: engine = __start_engine_in_toolkit_classic(app, splash, user, pc, pc_path) else: engine = __start_engine_in_zero_config(app, app_bootstrap, splash, user) return __post_bootstrap_engine(splash, app_bootstrap, engine, settings)
def __launch_app(app, splash, connection, app_bootstrap, server, settings): """ Shows the splash screen, optionally downloads and configures Toolkit, imports it, optionally updates it and then launches the desktop engine. :param app: Application object for event processing. :param splash: Splash dialog to update user on what is currently going on :param connection: Connection to the Shotgun server. :param server: The tk_framework_desktopserver.Server instance. :param settings: The application's settings. :returns: The error code to return to the shell. """ # show the splash screen splash.show() splash.set_message("Looking up site configuration.") app.processEvents() _assert_toolkit_enabled(splash, connection) logger.debug("Getting the default site config") default_site_config, pc = shotgun_desktop.paths.get_default_site_config_root( connection) # try and import toolkit toolkit_imported = False config_folder_exists_at_startup = os.path.exists(default_site_config) reset_site = __extract_command_line_argument("--reset-site") # If the config folder exists at startup but the user wants to wipe it, do it. if config_folder_exists_at_startup and reset_site: logger.info("Resetting site configuration at '%s'" % default_site_config) splash.set_message("Resetting site configuration ...") shutil.rmtree(default_site_config) # It doesn't exist anymore, so we can act as if it never existed in the first place config_folder_exists_at_startup = False # Remove all occurances of --reset-site so that if we restart the app it doesn't reset it # again. # If there is no pipeline configuration but we found something on disk nonetheless. if not pc and is_toolkit_already_configured(default_site_config): raise UnexpectedConfigFound(default_site_config) try: # In we found a pipeline configuration and the path for the config exists, try to import # Toolkit. if config_folder_exists_at_startup: logger.info("Trying site config from '%s'" % default_site_config) sgtk = __import_sgtk_from_path(default_site_config) toolkit_imported = True except Exception: logger.exception("There was an error importing Toolkit:") pass else: # Toolkit was imported, we need to initialize it now. if toolkit_imported: __initialize_sgtk_authentication(sgtk, app_bootstrap) if not toolkit_imported: # sgtk not available. initialize core logger.info("Import sgtk from site config failed. ") try: app.processEvents() splash.set_message("Initializing Toolkit") logger.info("Initializing Toolkit") core_path = initialize(splash, connection, settings.default_app_store_http_proxy) except Exception, error: logger.exception(error) if "ApiUser can not be accessed" in error.message: # Login does not have permission to see Scripts, throw an informative # error how to work around this for now. raise UpdatePermissionsError() else: raise try: # try again after the initialization is done logger.debug("Importing sgtk after initialization") sgtk = __get_initialized_sgtk(core_path, app_bootstrap) if sgtk is None: # Generate a generic error message, which will suggest to contact support. raise Exception("Could not access API post initialization.") splash.set_message("Setting up default site configuration...") # Install the default site config sg = sgtk.util.shotgun.create_sg_connection() # Site config has a none project id. project_id = None # If no pipeline configuration had been found. if not pc: # This site config has never been set by anyone, so we're the first. # If pipeline configurations are still project entities, we'll have to use the # TemplateProject as the project which will host the pipeline configuration. if does_pipeline_configuration_require_project(connection): template_project = sg.find_one( "Project", [["name", "is", "Template Project"], ["layout_project", "is", None]]) # Can't find template project, so we're effectively done here, we need a project # to create a pipeline configuration. if template_project is None: # Generate a generic error message, which will suggest to contact support. raise Exception( "Error finding the Template project on your site.") logger.info( "Creating the site config using the template project.") # We'll need to use the template project's id to setup the site config in this case. project_id = template_project["id"] else: logger.info( "Creating the site config without using a project.") else: # If a project is set in the pipeline configuration, it's an old style site config tied # to the template project, so we have to use it. if pc.get("project") is not None: logger.info("Reusing the site config with a project.") project_id = pc["project"]["id"] else: logger.info("Reusing the site config without a project.") # Create the directory if not os.path.exists(default_site_config): os.makedirs(default_site_config) # Setup the command to create the config if sys.platform == "darwin": path_param = "config_path_mac" elif sys.platform == "win32": path_param = "config_path_win" elif sys.platform.startswith("linux"): path_param = "config_path_linux" # allow the config uri to be overridden for testing config_uri = os.environ.get("SGTK_SITE_CONFIG_DEBUG_LOCATION", "tk-config-site") params = { "auto_path": True, "config_uri": config_uri, "project_folder_name": "site", "project_id": project_id, path_param: default_site_config, } setup_project = sgtk.get_command("setup_project") setup_project.set_logger(logger) try: setup_project.execute(params) except Exception, error: logger.exception(error) if "CRUD ERROR" in error.message: raise UpdatePermissionsError() else: raise # and now try to load up sgtk through the config again sgtk = __get_initialized_sgtk(default_site_config, app_bootstrap) tk = sgtk.sgtk_from_path(default_site_config) # now localize the core to the config splash.set_message("Localizing core...") localize = tk.get_command("localize") localize.set_logger(logger) localize.execute({}) # Get back the pipeline configuration, this is expected to be initialized further down. _, pc = shotgun_desktop.paths.get_default_site_config_root( connection)
def __launch_app(app, splash, user, app_bootstrap, settings): """ Shows the splash screen, optionally downloads and configures Toolkit, imports it, optionally updates it and then launches the desktop engine. :param app: Application object for event processing. :param splash: Splash dialog to update user on what is currently going on :param user: Current ShotgunUser. :param app_bootstrap: Application bootstrap. :param settings: The application's settings. :returns: The error code to return to the shell. """ # show the splash screen splash.show() import sgtk sgtk.set_authenticated_user(user) # Downloads an upgrade for the startup if available. startup_updated = upgrade_startup( splash, sgtk, app_bootstrap ) if startup_updated: __restart_app_with_countdown(splash, "Shotgun Desktop updated.") splash.set_message("Looking up site configuration.") connection = user.create_sg_connection() _assert_toolkit_enabled(splash, connection) logger.debug("Getting the default site configuration.") pc_path, pc, toolkit_classic_required = shotgun_desktop.paths.get_pipeline_configuration_info(connection) # We need to toggle the global debug logging setting back prior to swapping # core. Cores older than v0.18.117 do not manage the TK_DEBUG environment # variable when global debug is toggled, so we can end up in a situation # where the new core in desktopstartup toggles it on, setting the env var, # and then when the toggle off occurs we end up with the older core in the # site config NOT purging the TK_DEBUG env var. The result is that any # subprocesses spawned then end up with debug logging on when the user # didn't ask for it. This impacts engine command execution from both Desktop # and via browser integration. It is the biggest issue with browser # integration, however, as the debug logs are reported back to the web # app from the desktopserver RPC API, and the user is presented with a # dialog full of debug log messages. __restore_global_debug_flag() # We're about to bootstrap, so remove sgtk from our scope so that if we add # code that uses it after the bootstrap we have to import the # new core. del sgtk if toolkit_classic_required: engine = __start_engine_in_toolkit_classic(app, splash, user, pc, pc_path) else: engine = __start_engine_in_zero_config(app, app_bootstrap, splash, user) return __post_bootstrap_engine(splash, app_bootstrap, engine, settings)
def __launch_app(app, splash, connection, app_bootstrap, server): """ Shows the splash screen, optionally downloads and configures Toolkit, imports it, optionally updates it and then launches the desktop engine. :param app: Application object for event processing. :param splash: Splash dialog to update user on what is currently going on :param connection: Connection to the Shotgun server. :param server: The tk_framework_desktopserver.Server instance. :returns: The error code to return to the shell. """ # show the splash screen splash.show() splash.set_message("Looking up site configuration.") app.processEvents() _assert_toolkit_enabled(splash, connection) logger.debug("Getting the default site config") default_site_config, pc = shotgun_desktop.paths.get_default_site_config_root(connection) # try and import toolkit toolkit_imported = False config_folder_exists_at_startup = os.path.exists(default_site_config) reset_site = __extract_command_line_argument("--reset-site") # If the config folder exists at startup but the user wants to wipe it, do it. if config_folder_exists_at_startup and reset_site: logger.info("Resetting site configuration at '%s'" % default_site_config) splash.set_message("Resetting site configuration ...") shutil.rmtree(default_site_config) # It doesn't exist anymore, so we can act as if it never existed in the first place config_folder_exists_at_startup = False # Remove all occurances of --reset-site so that if we restart the app it doesn't reset it # again. # If there is no pipeline configuration but we found something on disk nonetheless. if not pc and is_toolkit_already_configured(default_site_config): raise UnexpectedConfigFound(default_site_config) try: # In we found a pipeline configuration and the path for the config exists, try to import # Toolkit. if config_folder_exists_at_startup: logger.info("Trying site config from '%s'" % default_site_config) sgtk = __import_sgtk_from_path(default_site_config) toolkit_imported = True except Exception: logger.exception("There was an error importing Toolkit:") pass else: # Toolkit was imported, we need to initialize it now. if toolkit_imported: __initialize_sgtk_authentication(sgtk, app_bootstrap) if not toolkit_imported: # sgtk not available. initialize core logger.info("Import sgtk from site config failed. ") try: app.processEvents() splash.set_message("Initializing Toolkit") logger.info("Initializing Toolkit") core_path = initialize(splash, connection) except Exception, error: logger.exception(error) if "ApiUser can not be accessed" in error.message: # Login does not have permission to see Scripts, throw an informative # error how to work around this for now. raise UpdatePermissionsError() else: raise try: # try again after the initialization is done logger.debug("Importing sgtk after initialization") sgtk = __get_initialized_sgtk(core_path, app_bootstrap) if sgtk is None: # Generate a generic error message, which will suggest to contact support. raise Exception("Could not access API post initialization.") splash.set_message("Setting up default site configuration...") # Install the default site config sg = sgtk.util.shotgun.create_sg_connection() # Site config has a none project id. project_id = None # If no pipeline configuration had been found. if not pc: # This site config has never been set by anyone, so we're the first. # If pipeline configurations are still project entities, we'll have to use the # TemplateProject as the project which will host the pipeline configuration. if does_pipeline_configuration_require_project(connection): template_project = sg.find_one( "Project", [["name", "is", "Template Project"], ["layout_project", "is", None]]) # Can't find template project, so we're effectively done here, we need a project # to create a pipeline configuration. if template_project is None: # Generate a generic error message, which will suggest to contact support. raise Exception("Error finding the Template project on your site.") logger.info("Creating the site config using the template project.") # We'll need to use the template project's id to setup the site config in this case. project_id = template_project["id"] else: logger.info("Creating the site config without using a project.") else: # If a project is set in the pipeline configuration, it's an old style site config tied # to the template project, so we have to use it. if pc.get("project") is not None: logger.info("Reusing the site config with a project.") project_id = pc["project"]["id"] else: logger.info("Reusing the site config without a project.") # Create the directory if not os.path.exists(default_site_config): os.makedirs(default_site_config) # Setup the command to create the config if sys.platform == "darwin": path_param = "config_path_mac" elif sys.platform == "win32": path_param = "config_path_win" elif sys.platform.startswith("linux"): path_param = "config_path_linux" # allow the config uri to be overridden for testing config_uri = os.environ.get("SGTK_SITE_CONFIG_DEBUG_LOCATION", "tk-config-site") params = { "auto_path": True, "config_uri": config_uri, "project_folder_name": "site", "project_id": project_id, path_param: default_site_config, } setup_project = sgtk.get_command("setup_project") setup_project.set_logger(logger) try: setup_project.execute(params) except Exception, error: logger.exception(error) if "CRUD ERROR" in error.message: raise UpdatePermissionsError() else: raise # and now try to load up sgtk through the config again sgtk = __get_initialized_sgtk(default_site_config, app_bootstrap) tk = sgtk.sgtk_from_path(default_site_config) # now localize the core to the config splash.set_message("Localizing core...") localize = tk.get_command("localize") localize.set_logger(logger) localize.execute({}) # Get back the pipeline configuration, this is expected to be initialized further down. _, pc = shotgun_desktop.paths.get_default_site_config_root(connection)