GlobalJobPreLoad

def get_ayon_executable():
    """Return AYON Executable from Event Plug-in Settings

    Returns:
        list[str]: AYON executable paths.

    Raises:
        RuntimeError: When no path configured at all.

    """
    config = RepositoryUtils.GetPluginConfig("Ayon")
    exe_list = config.GetConfigEntryWithDefault("AyonExecutable", "")

    if not exe_list:
        raise RuntimeError(
            "Path to AYON executable not configured."
            "Please set it in AYON Deadline Plugin."
        )

    # clean '\ ' for MacOS pasting
    if platform.system().lower() == "darwin":
        exe_list = exe_list.replace("\\ ", " ")

    # Expand user paths
    expanded_paths = []
    for path in exe_list.split(";"):
        if path.startswith("~"):
            path = os.path.expanduser(path)
        expanded_paths.append(path)
    return ";".join(expanded_paths)

def get_openpype_executable():
    """Return OpenPype Executable from Event Plug-in Settings"""
    config = RepositoryUtils.GetPluginConfig("OpenPype")
    exe_list = config.GetConfigEntryWithDefault("OpenPypeExecutable", "")
    dir_list = config.GetConfigEntryWithDefault(
        "OpenPypeInstallationDirs", "")

    # clean '\ ' for MacOS pasting
    if platform.system().lower() == "darwin":
        exe_list = exe_list.replace("\\ ", " ")
        dir_list = dir_list.replace("\\ ", " ")
    return exe_list, dir_list

def get_openpype_version_from_path(path, build=True):
    """Get OpenPype version from provided path.
         path (str): Path to scan.
         build (bool, optional): Get only builds, not sources

    Returns:
        Union[OpenPypeVersion, None]: version of OpenPype if found.
    """

    # fix path for application bundle on macos
    if platform.system().lower() == "darwin":
        path = os.path.join(path, "MacOS")

    version_file = os.path.join(path, "openpype", "version.py")
    if not os.path.isfile(version_file):
        return None

    # skip if the version is not build
    exe = os.path.join(path, "openpype_console.exe")
    if platform.system().lower() in ["linux", "darwin"]:
        exe = os.path.join(path, "openpype_console")

    # if only builds are requested
    if build and not os.path.isfile(exe):  # noqa: E501
        print("   ! path is not a build: {}".format(path))
        return None

    version = {}
    with open(version_file, "r") as vf:
        exec(vf.read(), version)

    version_str = version.get("__version__")
    if version_str:
        return OpenPypeVersion.from_string(version_str)
    return None

def handle_credentials(job):
    """Returns a tuple of values for AYON_SERVER_URL and AYON_API_KEY

    AYON_API_KEY might be overridden directly from job environments.
    Or specific AYON_SERVER_URL might be attached to job to pick corespondent
    AYON_API_KEY from plugin configuration.
    """
    config = RepositoryUtils.GetPluginConfig("Ayon")
    ayon_server_url = config.GetConfigEntryWithDefault("AyonServerUrl", "")
    ayon_api_key = config.GetConfigEntryWithDefault("AyonApiKey", "")

    job_ayon_server_url = job.GetJobEnvironmentKeyValue("AYON_SERVER_URL")
    job_ayon_api_key = job.GetJobEnvironmentKeyValue("AYON_API_KEY")

    # API key submitted with job environment will always take priority
    if job_ayon_api_key:
        ayon_api_key = job_ayon_api_key

    # Allow custom AYON API key per server URL if server URL is submitted
    # along with the job. The custom API keys can be configured on the
    # Deadline Repository AYON Plug-in settings, in the format of
    # `SERVER:PORT@APIKEY` per line.
    elif job_ayon_server_url and job_ayon_server_url != ayon_server_url:
        api_key = _get_ayon_api_key_from_additional_servers(
            config, job_ayon_server_url)
        if api_key:
            ayon_api_key = api_key
            print(">>> Using API key from Additional AYON Servers.")
        else:
            print(
                ">>> AYON Server URL submitted with job "
                f"'{job_ayon_server_url}' has no API key defined "
                "in AYON Deadline plugin configuration,"
                " `Additional AYON Servers` section."
                " Use Deadline monitor to modify the values."
                "Falling back to `AYON API key` set in `AYON Credentials`"
                " section of AYON plugin configuration."
            )
        ayon_server_url = job_ayon_server_url
    if not all([ayon_server_url, ayon_api_key]):
        raise RuntimeError(
            "Missing required values for server url and api key. "
            "Please fill in AYON Deadline plugin or provide by "
            "AYON_SERVER_URL and AYON_API_KEY"
        )
    return ayon_server_url, ayon_api_key

def inject_ayon_environment(deadlinePlugin):
    """ Pull env vars from AYON and push them to rendering process.

        Used for correct paths, configuration from AYON etc.
    """
    job = deadlinePlugin.GetJob()

    print(">>> Injecting AYON environments ...")
    try:
        exe_list = get_ayon_executable()
        exe = FileUtils.SearchFileList(exe_list)

        if not exe:
            raise RuntimeError((
               "AYON executable was not found in the semicolon "
               "separated list \"{}\"."
               "The path to the render executable can be configured"
               " from the Plugin Configuration in the Deadline Monitor."
            ).format(exe_list))

        print("--- AYON executable: {}".format(exe))

        ayon_bundle_name = job.GetJobEnvironmentKeyValue("AYON_BUNDLE_NAME")
        if not ayon_bundle_name:
            raise RuntimeError(
                "Missing env var in job properties AYON_BUNDLE_NAME"
            )

        ayon_server_url, ayon_api_key = handle_credentials(job)

        site_id = os.environ.get("AYON_SITE_ID")
        shared_env_group = None
        if site_id:
            hash_base = f"{site_id}|{getpass.getuser()}"
            hash_sha256 = sha256(hash_base.encode())
            shared_env_group = hash_sha256.hexdigest()[-10:]
        # drive caching of environment variables with env var
        # it is recommended to use same value AYON_SITE_ID for 'same'
        # render nodes (eg. same OS etc.)
        if shared_env_group:
            print(">>> Caching of environment file will be used.")
            output_dir = _get_output_dir(job)
            environment_file_name = f"env_{job.JobId}_{shared_env_group}.json"
            export_dir_url = os.path.join(
                output_dir,
                ".ayon_env_cache"
            )

            if not os.path.exists(export_dir_url):
                os.makedirs(export_dir_url, exist_ok=True)

            export_path = os.path.join(
                export_dir_url,
                environment_file_name)
            _wait_for_in_progress(job, export_path)
        else:
            # no caching - default behavior
            temp_file_name = "{}_{}.json".format(
                datetime.utcnow().strftime("%Y%m%d%H%M%S%f"),
                str(uuid.uuid1())
            )
            export_path = os.path.join(tempfile.gettempdir(), temp_file_name)

        if not os.path.exists(export_path):
            print(
                f">>> '{export_path}' with extracted environment doesn't "
                "exist yet, running extraction process..."
            )
            temp_export_path = f"{export_path}.tmp"
            with open(temp_export_path, "w"):
                pass
            try:
                _extract_environments(
                    ayon_server_url,
                    ayon_api_key,
                    ayon_bundle_name,
                    deadlinePlugin,
                    exe,
                    temp_export_path,
                    job
                )
                if (not os.path.exists(export_path) and
                        os.path.exists(temp_export_path)):
                    print(f"Creating env var file {export_path}")
                    os.rename(temp_export_path, export_path)
            finally:
                if os.path.exists(temp_export_path):
                    os.remove(temp_export_path)

        print(f">>> Loading file '{export_path}' ...")
        with open(export_path) as fp:
            contents = json.load(fp)

        for key, value in sorted(contents.items()):
            deadlinePlugin.SetProcessEnvironmentVariable(key, value)

        if "PATH" in contents:
            # Set os.environ[PATH] so studio settings' path entries
            # can be used to define search path for executables.
            print(f">>> Setting 'PATH' Environment to: {contents['PATH']}")
            os.environ["PATH"] = contents["PATH"]

        script_url = job.GetJobPluginInfoKeyValue("ScriptFilename")
        if script_url:
            script_url = script_url.format(**contents).replace("\\", "/")
            print(">>> Setting script path {}".format(script_url))
            job.SetJobPluginInfoKeyValue("ScriptFilename", script_url)

        print(">> Injection end.")
    except Exception as e:
        if hasattr(e, "output"):
            print(">>> Exception {}".format(e.output))
        import traceback
        print(traceback.format_exc())
        print("!!! Injection failed.")
        raise

def inject_openpype_environment(deadlinePlugin):
    """ Pull env vars from OpenPype and push them to rendering process.

        Used for correct paths, configuration from OpenPype etc.
    """
    job = deadlinePlugin.GetJob()

    print(">>> Injecting OpenPype environments ...")
    try:
        exe_list, dir_list = get_openpype_executable()
        exe = FileUtils.SearchFileList(exe_list)

        requested_version = job.GetJobEnvironmentKeyValue("OPENPYPE_VERSION")
        if requested_version:
            exe = get_requested_openpype_executable(
                exe, dir_list, requested_version
            )
            if exe is None:
                raise RuntimeError((
                    "Cannot find compatible version available for version {}"
                    " requested by the job. Please add it through plugin"
                    " configuration in Deadline or install it to configured"
                    " directory."
                ).format(requested_version))

        if not exe:
            raise RuntimeError((
                "OpenPype executable was not found in the semicolon "
                "separated list \"{}\"."
                "The path to the render executable can be configured"
                " from the Plugin Configuration in the Deadline Monitor."
            ).format(";".join(exe_list)))

        print("--- OpenPype executable: {}".format(exe))

        # tempfile.TemporaryFile cannot be used because of locking
        temp_file_name = "{}_{}.json".format(
            datetime.utcnow().strftime("%Y%m%d%H%M%S%f"),
            str(uuid.uuid1())
        )
        export_path = os.path.join(tempfile.gettempdir(), temp_file_name)
        print(">>> Temporary path: {}".format(export_path))

        args = [
            "--headless",
            "extractenvironments",
            export_path
        ]

        add_kwargs = {
            "project": job.GetJobEnvironmentKeyValue("AVALON_PROJECT"),
            "asset": job.GetJobEnvironmentKeyValue("AVALON_ASSET"),
            "task": job.GetJobEnvironmentKeyValue("AVALON_TASK"),
            "app": job.GetJobEnvironmentKeyValue("AVALON_APP_NAME"),
            "envgroup": "farm"
        }

        # use legacy IS_TEST env var to mark automatic tests for OP
        if job.GetJobEnvironmentKeyValue("IS_TEST"):
            args.append("--automatic-tests")

        if all(add_kwargs.values()):
            for key, value in add_kwargs.items():
                args.extend(["--{}".format(key), value])
        else:
            raise RuntimeError((
                "Missing required env vars: AVALON_PROJECT, AVALON_ASSET,"
                " AVALON_TASK, AVALON_APP_NAME"
            ))

        openpype_mongo = job.GetJobEnvironmentKeyValue("OPENPYPE_MONGO")
        if openpype_mongo:
            # inject env var for OP extractenvironments
            # SetEnvironmentVariable is important, not SetProcessEnv...
            deadlinePlugin.SetEnvironmentVariable("OPENPYPE_MONGO",
                                                  openpype_mongo)

        if not os.environ.get("OPENPYPE_MONGO"):
            print(">>> Missing OPENPYPE_MONGO env var, process won't work")

        os.environ["AVALON_TIMEOUT"] = "5000"

        args_str = subprocess.list2cmdline(args)
        print(">>> Executing: {} {}".format(exe, args_str))
        process_exitcode = deadlinePlugin.RunProcess(
            exe, args_str, os.path.dirname(exe), -1
        )

        if process_exitcode != 0:
            raise RuntimeError(
                "Failed to run OpenPype process to extract environments."
            )

        print(">>> Loading file ...")
        with open(export_path) as fp:
            contents = json.load(fp)

        for key, value in sorted(contents.items()):
            deadlinePlugin.SetProcessEnvironmentVariable(key, value)

        if "PATH" in contents:
            # Set os.environ[PATH] so studio settings' path entries
            # can be used to define search path for executables.
            print(f">>> Setting 'PATH' Environment to: {contents['PATH']}")
            os.environ["PATH"] = contents["PATH"]

        script_url = job.GetJobPluginInfoKeyValue("ScriptFilename")
        if script_url:
            script_url = script_url.format(**contents).replace("\\", "/")
            print(">>> Setting script path {}".format(script_url))
            job.SetJobPluginInfoKeyValue("ScriptFilename", script_url)

        print(">>> Removing temporary file")
        os.remove(export_path)

        print(">> Injection end.")
    except Exception as e:
        if hasattr(e, "output"):
            print(">>> Exception {}".format(e.output))
        import traceback
        print(traceback.format_exc())
        print("!!! Injection failed.")
        raise

def inject_render_job_id(deadlinePlugin):
    """Inject dependency ids to publish process as env var for validation."""
    print(">>> Injecting render job id ...")
    job = deadlinePlugin.GetJob()

    dependency_ids = job.JobDependencyIDs
    print(">>> Dependency IDs: {}".format(dependency_ids))
    render_job_ids = ",".join(dependency_ids)
    deadlinePlugin.SetProcessEnvironmentVariable(
        "RENDER_JOB_IDS", render_job_ids
    )

    ayon_server_url, ayon_api_key = handle_credentials(job)

    credentials = {
        "AYON_SERVER_URL": ayon_server_url,
        "AYON_API_KEY": ayon_api_key
    }
    for env, val in credentials.items():
        job.SetJobEnvironmentKeyValue(env, val)
    print(">>> Injection end.")