testing a startup.py to open a terminal in windows.

Author: kramester

engine.py

@@ -16,7 +16,6 @@
 import tank
 import inspect
 import logging
-import sys
 import os
 import platform
 
@@ -179,8 +178,8 @@ def execute_command(self, cmd_key, args):
                 # This resolves issues with mismatched Qt libraries between the OS and the
                 # application being launched if it is a DCC that comes with a bundled Qt.
                 if (
-                    tank.util.is_linux()
-                    and os.environ.get("KDE_FULL_SESSION") is not None
+                    tank.util.is_linux() and
+                    os.environ.get("KDE_FULL_SESSION") is not None
                 ):
                     QtGui.QApplication.setLibraryPaths([])
 

startup.py

@@ -0,0 +1,79 @@
+import os
+import sys
+import sgtk.context
+from sgtk.platform import SoftwareLauncher, SoftwareVersion, LaunchInformation
+
+
+class ShellLauncher(SoftwareLauncher):
+
+    def scan_software(self):
+
+        ICON_LOCATION = os.path.join(self.disk_location, "icon_256.png")
+        TERMINAL_SOFTWARE = {
+            "darwin": [
+                SoftwareVersion(
+                    "MacOS",
+                    "Terminal",
+                    "/Applications/Utilities/Terminal.app/Contents/MacOS/Terminal",
+                    icon=ICON_LOCATION,
+                    args=None
+                ),
+                # SoftwareVersion(
+                #     "2",
+                #     "iTerm",
+                #     "/Applications/iTerm.app/Contents/MacOS/iTerm2",
+                #     icon=ICON_LOCATION,
+                #     args=None
+                # )
+            ],
+            "win32": [
+                SoftwareVersion(
+                    "Windows",
+                    "Terminal",
+                    r"C:\WINDOWS\system32\cmd.exe",
+                    icon=ICON_LOCATION,
+                    args=None
+                )
+            ],
+            "linux2": [
+                SoftwareVersion(
+                    "Gnome",
+                    "Terminal",
+                    r"/usr/bin/gnome-terminal",
+                    icon=ICON_LOCATION,
+                    args=None
+                )
+            ]
+        }
+
+        return TERMINAL_SOFTWARE[sys.platform]
+
+    def prepare_launch(self, exec_path, args, file_to_open=None):
+        # Construct an environment to launch the DCC in,
+        # confirm the correct executable path to
+        # launch, and provide required command line args.
+        # Return this information as a
+        # LaunchInformation instance.
+        correct_executable_path = "python"
+        command_line_args = "{}".format(os.path.join(self.disk_location, "startup", "bootstrap.py"))
+        # command_line_args = ""
+        launch_environment = {}
+
+        # once the software has launched, execute
+        # startup script startup/userSetup.py
+        # launch_environment["PYTHONPATH"] = os.path.join(self.disk_location, "startup")
+        launch_environment["PATH"] = os.environ["PATH"] + os.pathsep + os.path.dirname(sys.executable)
+        launch_environment["SGTK_ENGINE"] = self.engine_name
+        launch_environment["SGTK_CONTEXT"] = sgtk.context.serialize(self.context)
+        launch_environment["SGTK_TERMINAL"] = exec_path
+
+        # make sure to include some standard fields describing the current context and site
+        std_env = self.get_standard_plugin_environment()
+        launch_environment.update(std_env)
+
+        launch_information = LaunchInformation(
+            correct_executable_path,
+            command_line_args,
+            launch_environment
+        )
+        return launch_information

startup/bootstrap.py

@@ -0,0 +1,69 @@
+import os
+import subprocess
+
+
+def start_toolkit():
+    """
+    Import Toolkit and start up a tk-shell engine based on
+    environment variables.
+    """
+
+    # Verify sgtk can be loaded.
+    try:
+        import sgtk
+    except Exception as e:
+        print "Shotgun: Could not import sgtk! Disabling for now: {}".format(e)
+        return
+
+    # start up toolkit logging to file
+    sgtk.LogManager().initialize_base_file_handler("tk-shell")
+    logger = sgtk.LogManager.get_logger(__name__)
+
+    logger.debug("Launching toolkit in classic mode.")
+
+    # Get the name of the engine to start from the environement
+    env_engine = os.environ.get("SGTK_ENGINE")
+    if not env_engine:
+        print "Shotgun: Missing required environment variable SGTK_ENGINE."
+        return
+
+    # Get the context load from the environment.
+    env_context = os.environ.get("SGTK_CONTEXT")
+    if not env_context:
+        print "Shotgun: Missing required environment variable SGTK_CONTEXT."
+        return
+    try:
+        # Deserialize the environment context
+        context = sgtk.context.deserialize(env_context)
+    except Exception as e:
+        print "Shotgun: Could not create context! Shotgun Pipeline Toolkit will " \
+              "be disabled. Details: {}".format(e)
+        return
+
+    try:
+        # Start up the toolkit engine from the environment data
+        logger.debug(
+            "Launching engine instance '%s' for context %s" % (env_engine, env_context)
+        )
+        print "Starting Toolkit, please be patent..."
+        sgtk.platform.start_engine(env_engine, context.sgtk, context)
+        print sgtk.platform.current_engine()
+        subprocess.Popen(os.environ.get("SGTK_TERMINAL"), shell=True, env=os.environ)
+    except Exception as e:
+        print "Shotgun: Could not start engine: {}".format(e)
+        return
+
+    # # Clean up temp env variables.
+    # del_vars = [
+    #     "SGTK_ENGINE",
+    #     "SGTK_CONTEXT",
+    #     "SGTK_FILE_TO_OPEN",
+    #     "SGTK_LOAD_MAYA_PLUGINS",
+    # ]
+    # for var in del_vars:
+    #     if var in os.environ:
+    #         del os.environ[var]
+
+
+if __name__ == "__main__":
+    start_toolkit()