YandexSdkUpdaterLauncher.cs

using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
#if UNITY_EDITOR_LINUX
using System.Collections.Generic;
#endif
#if UNITY_EDITOR_LINUX
using System.Threading;
#endif
using UnityEditor;
using UnityEngine;
using Debug = UnityEngine.Debug;
 
namespace SCG.SpaceAdMobile
{
    internal static class YandexSdkUpdaterLauncher
    {
        #region Constants
 
        private const string Python3Command = "python3";
        private const string PythonCommand = "python";

        internal const string MinimumPythonVersion = "3.7";
        private const int MinimumPythonMajorVersion = 3;
        private const int MinimumPythonMinorVersion = 7;
 
#if UNITY_EDITOR_WIN
        private const string WindowsPythonLauncherCommand = "py";
        private const string Python3PrefixArguments = "-3";
#endif
 
        private const string UpdaterScriptFileName = "update_yandex_sdk.py";
#if UNITY_EDITOR_OSX || UNITY_EDITOR_LINUX
        private const string UpdaterBridgeDirectoryName = "YandexSdkUpdater";
        private const string ControllerStartupAttemptEnvironmentVariable = "YANDEX_SDK_UPDATER_STARTUP_ATTEMPT";
        private const string ControllerStartupStartedExtension = ".started";
        private const string ControllerStartupCancelledExtension = ".cancelled";
#endif
#if UNITY_EDITOR_LINUX
        private const int ControllerStartupTimeoutMilliseconds = 5000;
        private const int ControllerStartupPollIntervalMilliseconds = 100;
#endif
#if UNITY_EDITOR_OSX
        private const int MacControllerStartupExitGraceMilliseconds = 30000;
#endif
        private const int InterpreterProbeTimeoutMilliseconds = 2000;
#if UNITY_EDITOR_LINUX
        private const string LinuxShellPath = "/bin/sh";
#endif
 
        #endregion
 
        #region State
 
        private static string s_pythonExecutable;
        private static string s_pythonPrefixArguments;
        private static Task<(string Executable, string PrefixArguments)> s_pythonAvailabilityTask;
        private static Action s_pythonAvailabilityCompleted;
 
#if UNITY_EDITOR_OSX
        private static Process s_macTerminalProcess;
        private static string s_macStartupAttemptPath;
        private static Action<bool, string> s_macStartupCompleted;
        private static DateTime? s_macTerminalExitTime;
        private static string s_macStartupError;
#endif
 
#if UNITY_EDITOR_LINUX
        private static readonly (string Executable, string ArgumentPrefix)[] s_linuxTerminalCandidates =
        {
            ("x-terminal-emulator", "-e"),
            ("gnome-terminal", "--"),
            ("konsole", "-e"),
            ("xterm", "-e")
        };
#endif
 
        #endregion
 
        #region Availability

        internal static bool IsPythonAvailable => IsPythonAvailabilityChecked && !string.IsNullOrEmpty(s_pythonExecutable);

        internal static bool IsPythonAvailabilityChecked { get; private set; }

        internal static void RefreshPythonAvailability(Action onCompleted)
        {
            if (s_pythonAvailabilityTask != null)
            {
                s_pythonAvailabilityCompleted = onCompleted;
                return;
            }
 
            IsPythonAvailabilityChecked = false;
            s_pythonExecutable = null;
            s_pythonPrefixArguments = null;
            s_pythonAvailabilityCompleted = onCompleted;
            s_pythonAvailabilityTask = Task.Run(DetectPython3);
            EditorApplication.update -= CompletePythonAvailabilityCheck;
            EditorApplication.update += CompletePythonAvailabilityCheck;
        }

        internal static bool TryLaunch(Action<bool, string> onCompleted, out string error)
        {
            error = null;
 
#if UNITY_EDITOR_OSX
            if (!string.IsNullOrEmpty(s_macStartupAttemptPath))
            {
                error = "The updater is already waiting for Terminal to start.";
                return false;
            }
#endif
 
            if (!IsPythonAvailabilityChecked)
            {
                error = "Python availability is still being checked.";
                return false;
            }
 
            if (string.IsNullOrEmpty(s_pythonExecutable))
            {
                error = $"Python {MinimumPythonVersion} or newer was not found. Add python, python3, or the Windows Python Launcher to PATH.";
                return false;
            }
 
            var projectRoot = Path.GetFullPath(Path.Combine(Application.dataPath, ".."));
            var scriptPath = Path.GetFullPath(Path.Combine(Application.dataPath, "YandexMobileAds", UpdaterScriptFileName));
            if (!File.Exists(scriptPath))
            {
                error = $"The Yandex SDK updater script was not found: {scriptPath}";
                return false;
            }
 
            try
            {
#if UNITY_EDITOR_WIN
                var started = TryStartTerminal(projectRoot, scriptPath, out error);
                if (started)
                    onCompleted?.Invoke(true, null);
 
                return started;
#elif UNITY_EDITOR_OSX || UNITY_EDITOR_LINUX
                return TryStartShellTerminal(projectRoot, scriptPath, onCompleted, out error);
#else
                error = "Opening an interactive terminal is not supported on this Editor platform.";
                return false;
#endif
            }
            catch (Exception exception)
            {
                error = $"Unable to start the Yandex SDK updater: {exception.Message}";
                return false;
            }
        }
 
        #endregion
 
        #region Interpreter Detection

        private static (string Executable, string PrefixArguments) DetectPython3()
        {
            if (TryVerifyPython3(Python3Command, string.Empty))
                return (Python3Command, string.Empty);
 
            if (TryVerifyPython3(PythonCommand, string.Empty))
                return (PythonCommand, string.Empty);
 
#if UNITY_EDITOR_WIN
            return TryVerifyPython3(WindowsPythonLauncherCommand, Python3PrefixArguments)
                ? (WindowsPythonLauncherCommand, Python3PrefixArguments)
                : (null, null);
#else
            return (null, null);
#endif
        }

        private static void CompletePythonAvailabilityCheck()
        {
            if (s_pythonAvailabilityTask is not { IsCompleted: true })
                return;
 
            EditorApplication.update -= CompletePythonAvailabilityCheck;
 
            try
            {
                var (pythonExecutable, pythonPrefixArguments)= s_pythonAvailabilityTask.GetAwaiter().GetResult();
                s_pythonExecutable = pythonExecutable;
                s_pythonPrefixArguments = pythonPrefixArguments;
            }
            catch (Exception exception)
            {
                Debug.LogException(exception);
                s_pythonExecutable = null;
                s_pythonPrefixArguments = null;
            }
 
            s_pythonAvailabilityTask = null;
            IsPythonAvailabilityChecked = true;
            var onCompleted = s_pythonAvailabilityCompleted;
            s_pythonAvailabilityCompleted = null;
            onCompleted?.Invoke();
        }

        private static bool TryVerifyPython3(string executable, string prefixArguments)
        {
            try
            {
                var arguments = string.IsNullOrEmpty(prefixArguments)
                    ? "--version"
                    : $"{prefixArguments} --version";
                var startInfo = new ProcessStartInfo
                {
                    FileName = executable,
                    Arguments = arguments,
                    CreateNoWindow = true,
                    UseShellExecute = false,
                    RedirectStandardOutput = true,
                    RedirectStandardError = true
                };
 
                using var process = Process.Start(startInfo);
                if (process == null)
                    return false;
 
                if (!process.WaitForExit(InterpreterProbeTimeoutMilliseconds))
                {
                    process.Kill();
                    process.WaitForExit();
                    return false;
                }
 
                var version = process.StandardOutput.ReadToEnd() + process.StandardError.ReadToEnd();
                return process.ExitCode == 0 &&
                    (from line in version.Split(new[]
                    { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
                     select line.TrimStart() into trimmedLine
                     where trimmedLine.StartsWith("Python ", StringComparison.OrdinalIgnoreCase)
                     select trimmedLine["Python ".Length..].Split('.') into versionParts
                     select versionParts.Length >= 2 && int.TryParse(versionParts[0], out var majorVersion) &&
                     int.TryParse(versionParts[1], out var minorVersion) &&
                     majorVersion == MinimumPythonMajorVersion && minorVersion >= MinimumPythonMinorVersion)
                     .FirstOrDefault();
            }
            catch (Exception)
            {
                return false;
            }
        }
 
        #endregion
 
        #region Terminal Launch
 
#if UNITY_EDITOR_WIN
        private static bool TryStartTerminal(string projectRoot, string scriptPath, out string error)
        {
            var arguments = string.IsNullOrEmpty(s_pythonPrefixArguments)
                ? QuoteProcessArgument(scriptPath)
                : $"{s_pythonPrefixArguments} {QuoteProcessArgument(scriptPath)}";
            return TryStartProcess(new ProcessStartInfo
            {
                FileName = s_pythonExecutable,
                Arguments = arguments,
                WorkingDirectory = projectRoot,
                UseShellExecute = true,
                CreateNoWindow = false
            }, out error);
        }
#endif
 
#if UNITY_EDITOR_OSX || UNITY_EDITOR_LINUX
        private static bool TryStartShellTerminal(
            string projectRoot,
            string scriptPath,
            Action<bool, string> onCompleted,
            out string error)
        {
#if UNITY_EDITOR_OSX
            string startupAttemptPath = null;
            try
            {
                startupAttemptPath = CreateControllerStartupAttemptPath(projectRoot);
                var shellCommand = BuildShellCommand(projectRoot, scriptPath, startupAttemptPath);
                var appleScript =
                    "tell application \"Terminal\"\n" +
                    "activate\n" +
                    $"do script \"{EscapeAppleScriptString(shellCommand)}\"\n" +
                    "end tell";
                var process = Process.Start(new ProcessStartInfo
                {
                    FileName = "/usr/bin/osascript",
                    Arguments = $"-e {QuoteProcessArgument(appleScript)}",
                    WorkingDirectory = projectRoot,
                    UseShellExecute = false,
                    CreateNoWindow = true,
                    RedirectStandardError = true
                });
                if (process == null)
                    return CompleteMacStartupFailure(
                        startupAttemptPath,
                        "The operating system did not start the macOS terminal launcher.",
                        onCompleted,
                        out error);
 
                s_macTerminalProcess = process;
                s_macStartupAttemptPath = startupAttemptPath;
                s_macStartupCompleted = onCompleted;
                s_macTerminalExitTime = null;
                s_macStartupError = null;
                EditorApplication.update -= CheckMacTerminalStartup;
                EditorApplication.update += CheckMacTerminalStartup;
                AssemblyReloadEvents.beforeAssemblyReload -= CancelMacStartupBeforeAssemblyReload;
                AssemblyReloadEvents.beforeAssemblyReload += CancelMacStartupBeforeAssemblyReload;
                error = null;
                return true;
            }
            catch (Exception exception)
            {
                if (string.IsNullOrEmpty(startupAttemptPath))
                {
                    error = exception.Message;
                    return false;
                }
 
                return CompleteMacStartupFailure(
                    startupAttemptPath,
                    exception.Message,
                    onCompleted,
                    out error);
            }
#elif UNITY_EDITOR_LINUX
            var errors = new List<string>();
            foreach (var candidate in s_linuxTerminalCandidates)
            {
                var startupAttemptPath = CreateControllerStartupAttemptPath(projectRoot);
                try
                {
                    var shellCommand = BuildShellCommand(projectRoot, scriptPath, startupAttemptPath);
                    var started = TryStartLinuxTerminal(
                            candidate.Executable,
                            candidate.ArgumentPrefix,
                            projectRoot,
                            shellCommand,
                            startupAttemptPath,
                            out var attemptRevoked,
                            out var candidateError);
                    if (started)
                    {
                        error = null;
                        onCompleted?.Invoke(true, null);
                        return true;
                    }
 
                    errors.Add($"{candidate.Executable}: {candidateError}");
                    if (!attemptRevoked)
                    {
                        error = "Unable to safely continue to another terminal because the previous startup attempt could not be revoked. " +
                                string.Join(" ", errors);
                        return false;
                    }
                }
                finally
                {
                    DeleteControllerStartupAttemptFiles(startupAttemptPath);
                }
            }
 
            error = "Unable to start the updater in a supported terminal. " + string.Join(" ", errors);
            return false;
#endif
        }
#endif
 
#if UNITY_EDITOR_LINUX
        private static bool TryStartLinuxTerminal(
            string terminalExecutable,
            string argumentPrefix,
            string projectRoot,
            string shellCommand,
            string startupAttemptPath,
            out bool attemptRevoked,
            out string error)
        {
            var arguments = $"{argumentPrefix} {LinuxShellPath} -c {QuoteProcessArgument(shellCommand)}";
            return TryStartProcessAndConfirmController(new ProcessStartInfo
            {
                FileName = terminalExecutable,
                Arguments = arguments,
                WorkingDirectory = projectRoot,
                UseShellExecute = false,
                CreateNoWindow = false
            }, startupAttemptPath, out attemptRevoked, out error);
        }
#endif
 
#if UNITY_EDITOR_OSX || UNITY_EDITOR_LINUX
        private static string CreateControllerStartupAttemptPath(string projectRoot)
        {
            var directory = Path.Combine(projectRoot, "Library", UpdaterBridgeDirectoryName);
            Directory.CreateDirectory(directory);
            var attemptPath = Path.Combine(directory, $"launcher-{Guid.NewGuid():N}.pending");
            using (File.Create(attemptPath))
            {
            }
 
            return attemptPath;
        }

        private static void DeleteControllerStartupAttemptFiles(string startupAttemptPath)
        {
            DeleteTemporaryStartupFile(startupAttemptPath);
            DeleteTemporaryStartupFile(Path.ChangeExtension(startupAttemptPath, ControllerStartupStartedExtension));
            DeleteTemporaryStartupFile(Path.ChangeExtension(startupAttemptPath, ControllerStartupCancelledExtension));
        }

        private static void DeleteTemporaryStartupFile(string path)
        {
            try
            {
                File.Delete(path);
            }
            catch (IOException exception)
            {
                Debug.LogWarning($"Could not remove updater startup file '{path}': {exception.Message}");
            }
            catch (UnauthorizedAccessException exception)
            {
                Debug.LogWarning($"Could not remove updater startup file '{path}': {exception.Message}");
            }
        }

        private static bool TryResolveControllerStartupAttempt(
            string startupAttemptPath,
            out bool controllerStarted,
            out string error)
        {
            var startedPath = Path.ChangeExtension(startupAttemptPath, ControllerStartupStartedExtension);
            var cancelledPath = Path.ChangeExtension(startupAttemptPath, ControllerStartupCancelledExtension);
 
            if (File.Exists(startedPath))
            {
                controllerStarted = true;
                error = null;
                return true;
            }
 
            if (File.Exists(cancelledPath))
            {
                controllerStarted = false;
                error = null;
                return true;
            }
 
            try
            {
                File.Move(startupAttemptPath, cancelledPath);
                controllerStarted = false;
                error = null;
                return true;
            }
            catch (Exception exception) when (exception is IOException || exception is UnauthorizedAccessException)
            {
                controllerStarted = File.Exists(startedPath);
                if (controllerStarted || File.Exists(cancelledPath))
                {
                    error = null;
                    return true;
                }
 
                error = exception.Message;
                return false;
            }
        }
 
#if UNITY_EDITOR_LINUX
        private static bool TryStartProcessAndConfirmController(
            ProcessStartInfo startInfo,
            string startupAttemptPath,
            out bool attemptRevoked,
            out string error)
        {
            try
            {
                using (var process = Process.Start(startInfo))
                {
                    if (process == null)
                    {
                        return ResolveFailedControllerStartupAttempt(
                            startupAttemptPath,
                            "The operating system did not start the terminal process.",
                            out attemptRevoked,
                            out error);
                    }
 
                    var timeout = DateTime.UtcNow.AddMilliseconds(ControllerStartupTimeoutMilliseconds);
                    var startedPath = Path.ChangeExtension(startupAttemptPath, ControllerStartupStartedExtension);
                    while (DateTime.UtcNow < timeout)
                    {
                        if (File.Exists(startedPath))
                        {
                            error = null;
                            attemptRevoked = false;
                            return true;
                        }
 
                        if (process.HasExited && process.ExitCode != 0)
                        {
                            var details = startInfo.RedirectStandardError
                                ? process.StandardError.ReadToEnd().Trim()
                                : string.Empty;
                            return ResolveFailedControllerStartupAttempt(
                                startupAttemptPath,
                                $"The terminal launcher exited with code {process.ExitCode}." +
                                (string.IsNullOrEmpty(details) ? string.Empty : $" {details}"),
                                out attemptRevoked,
                                out error);
                        }
 
                        Thread.Sleep(ControllerStartupPollIntervalMilliseconds);
                    }
                }
 
                return ResolveFailedControllerStartupAttempt(
                    startupAttemptPath,
                    $"The terminal did not confirm that the updater controller started within {ControllerStartupTimeoutMilliseconds / 1000} seconds.",
                    out attemptRevoked,
                    out error);
            }
            catch (Exception exception)
            {
                return ResolveFailedControllerStartupAttempt(
                    startupAttemptPath,
                    exception.Message,
                    out attemptRevoked,
                    out error);
            }
        }
#endif

        private static bool ResolveFailedControllerStartupAttempt(
            string startupAttemptPath,
            string failure,
            out bool attemptRevoked,
            out string error)
        {
            if (!TryResolveControllerStartupAttempt(startupAttemptPath, out var controllerStarted, out var revokeError))
            {
                error = $"{failure} The pending startup attempt could not be revoked: {revokeError}";
                attemptRevoked = false;
                return false;
            }
 
            if (controllerStarted)
            {
                error = null;
                attemptRevoked = false;
                return true;
            }
 
            error = failure;
            attemptRevoked = true;
            return false;
        }
#endif
 
#if UNITY_EDITOR_OSX
        internal static void CancelPendingLaunch()
        {
            if (!TryCancelMacStartup(out var error) && !string.IsNullOrEmpty(error))
                Debug.LogError($"Unable to cancel the pending Yandex updater launch: {error}");
        }
 
        private static void CancelMacStartupBeforeAssemblyReload()
        {
            if (!TryCancelMacStartup(out var error) && !string.IsNullOrEmpty(error))
                Debug.LogError($"Unable to cancel the pending Yandex updater launch before assembly reload: {error}");
        }
 
        private static bool TryCancelMacStartup(out string error)
        {
            var startupAttemptPath = s_macStartupAttemptPath;
            if (string.IsNullOrEmpty(startupAttemptPath))
            {
                error = null;
                return true;
            }
 
            if (!TryResolveControllerStartupAttempt(startupAttemptPath, out var controllerStarted, out error))
                return false;
 
            EditorApplication.update -= CheckMacTerminalStartup;
            AssemblyReloadEvents.beforeAssemblyReload -= CancelMacStartupBeforeAssemblyReload;
            var process = s_macTerminalProcess;
            s_macTerminalProcess = null;
            s_macStartupAttemptPath = null;
            s_macStartupCompleted = null;
            s_macTerminalExitTime = null;
            s_macStartupError = null;
 
            if (!controllerStarted)
                StopMacTerminalProcess(process);
 
            process?.Dispose();
            DeleteControllerStartupAttemptFiles(startupAttemptPath);
            error = null;
            return true;
        }
 
        private static void StopMacTerminalProcess(Process process)
        {
            if (process == null)
                return;
 
            try
            {
                if (!process.HasExited)
                    process.Kill();
            }
            catch (Exception exception)
            {
                Debug.LogWarning($"Could not stop the macOS terminal launcher: {exception.Message}");
            }
        }

        private static bool CompleteMacStartupFailure(
            string startupAttemptPath,
            string failure,
            Action<bool, string> onCompleted,
            out string error)
        {
            var started = ResolveFailedControllerStartupAttempt(
                startupAttemptPath,
                failure,
                out var attemptRevoked,
                out error);
            if (started)
            {
                DeleteControllerStartupAttemptFiles(startupAttemptPath);
                onCompleted?.Invoke(true, null);
                return true;
            }
 
            if (attemptRevoked)
                DeleteControllerStartupAttemptFiles(startupAttemptPath);
 
            return false;
        }

        private static void CheckMacTerminalStartup()
        {
            var process = s_macTerminalProcess;
            var startupAttemptPath = s_macStartupAttemptPath;
            if (process == null || string.IsNullOrEmpty(startupAttemptPath))
            {
                EditorApplication.update -= CheckMacTerminalStartup;
                return;
            }
 
            try
            {
                var startedPath = Path.ChangeExtension(startupAttemptPath, ControllerStartupStartedExtension);
                if (File.Exists(startedPath))
                {
                    CompleteMacTerminalStartup(true, null);
                    return;
                }
 
                if (!process.HasExited)
                    return;
 
                if (s_macTerminalExitTime == null)
                {
                    s_macTerminalExitTime = DateTime.UtcNow;
                    if (process.ExitCode != 0)
                    {
                        var details = process.StandardError.ReadToEnd().Trim();
                        s_macStartupError = $"The terminal launcher exited with code {process.ExitCode}." +
                                            (string.IsNullOrEmpty(details) ? string.Empty : $" {details}");
                    }
                }
 
                if (s_macStartupError == null &&
                    DateTime.UtcNow - s_macTerminalExitTime.Value <
                    TimeSpan.FromMilliseconds(MacControllerStartupExitGraceMilliseconds))
                {
                    return;
                }
 
                s_macStartupError ??= "The terminal launcher exited before the updater controller started.";
                var controllerStarted = ResolveFailedControllerStartupAttempt(
                    startupAttemptPath,
                    s_macStartupError,
                    out var attemptRevoked,
                    out var error);
                if (controllerStarted)
                    CompleteMacTerminalStartup(true, null);
                else if (attemptRevoked)
                    CompleteMacTerminalStartup(false, error);
            }
            catch (Exception exception)
            {
                var controllerStarted = ResolveFailedControllerStartupAttempt(
                    startupAttemptPath,
                    exception.Message,
                    out var attemptRevoked,
                    out var error);
                if (controllerStarted)
                    CompleteMacTerminalStartup(true, null);
                else if (attemptRevoked)
                    CompleteMacTerminalStartup(false, error);
            }
        }

        private static void CompleteMacTerminalStartup(bool started, string error)
        {
            EditorApplication.update -= CheckMacTerminalStartup;
            AssemblyReloadEvents.beforeAssemblyReload -= CancelMacStartupBeforeAssemblyReload;
            var startupAttemptPath = s_macStartupAttemptPath;
            var process = s_macTerminalProcess;
            var onCompleted = s_macStartupCompleted;
            s_macStartupAttemptPath = null;
            s_macTerminalProcess = null;
            s_macStartupCompleted = null;
            s_macTerminalExitTime = null;
            s_macStartupError = null;
            process?.Dispose();
 
            if (!string.IsNullOrEmpty(startupAttemptPath))
                DeleteControllerStartupAttemptFiles(startupAttemptPath);
 
            onCompleted?.Invoke(started, error);
        }
#endif
 
#if UNITY_EDITOR_WIN
        private static bool TryStartProcess(ProcessStartInfo startInfo, out string error)
        {
            try
            {
                using (var process = Process.Start(startInfo))
                {
                    if (process == null)
                    {
                        error = "The operating system did not start the updater process.";
                        return false;
                    }
                }
 
                error = null;
                return true;
            }
            catch (Exception exception)
            {
                error = exception.Message;
                return false;
            }
        }
#endif
 
#if UNITY_EDITOR_OSX || UNITY_EDITOR_LINUX
        private static string BuildShellCommand(string projectRoot, string scriptPath, string startupAttemptPath)
        {
            var interpreter = QuoteShellArgument(s_pythonExecutable);
            var prefixArguments = string.IsNullOrEmpty(s_pythonPrefixArguments)
                ? string.Empty
                : $"{s_pythonPrefixArguments} ";
            return $"cd {QuoteShellArgument(projectRoot)} && " +
                   $"export {ControllerStartupAttemptEnvironmentVariable}={QuoteShellArgument(startupAttemptPath)} && " +
                   $"exec {interpreter} {prefixArguments}{QuoteShellArgument(scriptPath)}";
        }

        private static string QuoteShellArgument(string value) =>
            $"'{value.Replace("'", "'\\''")}'";
#endif

        private static string QuoteProcessArgument(string value) =>
            $"\"{value.Replace("\\", @"\\").Replace("\"", "\\\"")}\"";
 
#if UNITY_EDITOR_OSX
        private static string EscapeAppleScriptString(string value) =>
            value.Replace("\\", "\\\\").Replace("\"", "\\\"");
#endif
 
        #endregion
    }
}