Exemple #1
0
        private static void OutputGenerateLog(bool result, string csFilePath, ProcessExecute processExecute)
        {
            using (new DisableStackTraceScope())
            {
                var logBuilder = new StringBuilder();

                logBuilder.AppendLine();
                logBuilder.AppendLine();
                logBuilder.AppendFormat("MessagePack file : {0}", csFilePath).AppendLine();
                logBuilder.AppendLine();
                logBuilder.AppendFormat("Execute:").AppendLine();
                logBuilder.AppendLine($"{processExecute.Command} {processExecute.Arguments}");

                if (result)
                {
                    logBuilder.Insert(0, "MessagePack code generate success!");

                    Debug.Log(logBuilder.ToString());
                }
                else
                {
                    logBuilder.Insert(0, "MessagePack code generate failed.");

                    Debug.LogError(logBuilder.ToString());
                }
            }
        }
Exemple #2
0
        private static async Task <Tuple <int, string> > ExecuteProcess(TextDataConfig.GenerateAssetSetting setting, Mode mode, bool displayConsole)
        {
            var config = TextDataConfig.Instance;

            var arguments = new StringBuilder();

            arguments.AppendFormat("--workspace {0} ", setting.GetTextDataWorkspacePath());

            switch (mode)
            {
            case Mode.Import:
                arguments.Append("--mode import ");
                break;

            case Mode.Export:
                arguments.Append("--mode export ");
                break;
            }

            var processExecute = new ProcessExecute(config.ConverterPath, arguments.ToString())
            {
                Encoding         = Encoding.GetEncoding("Shift_JIS"),
                WorkingDirectory = setting.GetTextDataWorkspacePath(),
                UseShellExecute  = displayConsole,
                Hide             = !displayConsole,
            };

            var result = await processExecute.StartAsync();

            return(Tuple.Create(result.ExitCode, result.Error));
        }
Exemple #3
0
    public Execute()
    {
        FunctionsCollection f = new FunctionsCollection();

        dayTimeFunc   = new DayTimeFunc();
        directoryFunc = new DirectoryFunc();
        networkFunc   = new NetworkFunc();
        zipFunc       = new ZipFunc();
        processFunc   = new ProcessExecute();
    }
Exemple #4
0
        /// <summary>
        /// Получение стандартного вывода из программы
        /// </summary>
        private static List <string> GetOutput(ProcessExecute prog)
        {
            var output = new List <string>();

            using var fs = prog.Output;
            while (!fs.EndOfStream)
            {
                var line = fs.ReadLine()?.Split(' ').SelectMany(elem => elem.Split()).Where(elem => elem != String.Empty);
                output.AddRange(line);
            }

            return(output);
        }
Exemple #5
0
        private IEnumerator FindDotnet()
        {
            if (isDotnetInstalled)
            {
                yield break;
            }

            dotnetVersion = string.Empty;

            var processTitle   = "MessagePackConfig";
            var processMessage = "Find .NET Core SDK";

            EditorUtility.DisplayProgressBar(processTitle, processMessage, 0f);

            Tuple <bool, string> result = null;

            var commandLineProcess = new ProcessExecute("dotnet", "--version");

            var findYield = commandLineProcess.StartAsync().ToObservable()
                            .Do(x => result        = Tuple.Create(true, x.Output))
                            .DoOnError(x => result = Tuple.Create(false, (string)null))
                            .Select(_ => result)
                            .ToYieldInstruction();

            while (!findYield.IsDone)
            {
                yield return(null);
            }

            if (findYield.HasResult)
            {
                dotnetVersion = findYield.Result.Item2;

                isDotnetInstalled = findYield.Result.Item1 && !string.IsNullOrEmpty(dotnetVersion);
            }

            if (string.IsNullOrEmpty(dotnetVersion))
            {
                Debug.LogError("Failed get .NET Core SDK version.");
            }

            EditorUtility.DisplayProgressBar(processTitle, processMessage, 1f);

            Repaint();

            EditorApplication.delayCall += EditorUtility.ClearProgressBar;
        }
Exemple #6
0
        private static ProcessExecute CreateMpcProcess(MessagePackCodeGenerateInfo generateInfo)
        {
            var messagePackConfig = MessagePackConfig.Instance;

            var mpc = messagePackConfig.MpcRelativePath;

            if (string.IsNullOrEmpty(mpc))
            {
                mpc = "mpc";
            }

            var processExecute = new ProcessExecute(mpc, generateInfo.MpcArgument)
            {
                Encoding = Encoding.GetEncoding("Shift_JIS"),
            };

            return(processExecute);
        }
Exemple #7
0
        public static async Task <string> GetCommitHash()
        {
            var masterConfig = MasterConfig.Instance;

            if (string.IsNullOrEmpty(masterConfig.SourceDirectory))
            {
                return(null);
            }

            var processExecute = new ProcessExecute("git", "log --pretty=%H -n 1")
            {
                WorkingDirectory = masterConfig.SourceDirectory,
            };

            var result = await processExecute.StartAsync();

            if (string.IsNullOrEmpty(result.Output))
            {
                return(null);
            }

            // 改行コードを削除.
            return(result.Output.Replace("\r", "").Replace("\n", ""));
        }
Exemple #8
0
 void Initialize()
 {
     this.ProcExec             = new ProcessExecute();
     this.ProcExec.OutputData += ProcExec_OutputData;
 }
        public override void DiscoverTests(
            IEnumerable <string> sources,
            PythonProjectSettings settings,
            IMessageLogger logger,
            ITestCaseDiscoverySink discoverySink
            )
        {
            if (sources is null)
            {
                throw new ArgumentNullException(nameof(sources));
            }

            if (discoverySink is null)
            {
                throw new ArgumentNullException(nameof(discoverySink));
            }

            _logger = logger ?? throw new ArgumentNullException(nameof(logger));

            var workspaceText = settings.IsWorkspace ? Strings.WorkspaceText : Strings.ProjectText;

            LogInfo(Strings.PythonTestDiscovererStartedMessage.FormatUI(PythonConstants.PytestText, settings.ProjectName, workspaceText, settings.DiscoveryWaitTimeInSeconds));

            var env            = InitializeEnvironment(sources, settings);
            var outputFilePath = Path.GetTempFileName();
            var arguments      = GetArguments(sources, settings, outputFilePath);

            LogInfo("cd " + settings.WorkingDirectory);
            LogInfo("set " + settings.PathEnv + "=" + env[settings.PathEnv]);
            LogInfo($"{settings.InterpreterPath} {string.Join(" ", arguments)}");

            try {
                var stdout = ProcessExecute.RunWithTimeout(
                    settings.InterpreterPath,
                    env,
                    arguments,
                    settings.WorkingDirectory,
                    settings.PathEnv,
                    settings.DiscoveryWaitTimeInSeconds
                    );
                if (!String.IsNullOrEmpty(stdout))
                {
                    Error(stdout);
                }
            } catch (TimeoutException) {
                Error(Strings.PythonTestDiscovererTimeoutErrorMessage);
                return;
            }

            if (!File.Exists(outputFilePath))
            {
                Error(Strings.PythonDiscoveryResultsNotFound.FormatUI(outputFilePath));
                return;
            }

            string json = File.ReadAllText(outputFilePath);

            if (string.IsNullOrEmpty(json))
            {
                return;
            }

            try {
                var results   = JsonConvert.DeserializeObject <List <PytestDiscoveryResults> >(json);
                var testcases = ParseDiscoveryResults(results, settings.ProjectHome);

                foreach (var tc in testcases)
                {
                    // Note: Test Explorer will show a key not found exception if we use a source path that doesn't match a test container's source.
                    if (settings.TestContainerSources.TryGetValue(tc.CodeFilePath, out _))
                    {
                        discoverySink.SendTestCase(tc);
                    }
                }
            } catch (InvalidOperationException ex) {
                Error("Failed to parse: {0}".FormatInvariant(ex.Message));
                Error(json);
            } catch (JsonException ex) {
                Error("Failed to parse: {0}".FormatInvariant(ex.Message));
                Error(json);
            }
        }
Exemple #10
0
        public void DiscoverTests(
            IEnumerable <string> sources,
            IMessageLogger logger,
            ITestCaseDiscoverySink discoverySink
            )
        {
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
            var workspaceText = _settings.IsWorkspace ? Strings.WorkspaceText : Strings.ProjectText;

            LogInfo(Strings.PythonTestDiscovererStartedMessage.FormatUI(PythonConstants.PytestText, _settings.ProjectName, workspaceText, _settings.DiscoveryWaitTimeInSeconds));

            var env            = InitializeEnvironment(sources, _settings);
            var outputFilePath = Path.GetTempFileName();
            var arguments      = GetArguments(sources, _settings, outputFilePath);

            LogInfo("cd " + _settings.WorkingDirectory);
            LogInfo("set " + _settings.PathEnv + "=" + env[_settings.PathEnv]);
            LogInfo($"{_settings.InterpreterPath} {string.Join(" ", arguments)}");

            try {
                var stdout = ProcessExecute.RunWithTimeout(
                    _settings.InterpreterPath,
                    env,
                    arguments,
                    _settings.WorkingDirectory,
                    _settings.PathEnv,
                    _settings.DiscoveryWaitTimeInSeconds
                    );
                if (!String.IsNullOrEmpty(stdout))
                {
                    Error(stdout);
                }
            } catch (TimeoutException) {
                Error(Strings.PythonTestDiscovererTimeoutErrorMessage);
                return;
            }

            if (!File.Exists(outputFilePath))
            {
                Error(Strings.PythonDiscoveryResultsNotFound.FormatUI(outputFilePath));
                return;
            }

            string json = File.ReadAllText(outputFilePath);

            if (string.IsNullOrEmpty(json))
            {
                return;
            }

            List <PytestDiscoveryResults> results = null;

            try {
                results = JsonConvert.DeserializeObject <List <PytestDiscoveryResults> >(json);
                CreateVsTests(results, discoverySink);
            } catch (InvalidOperationException ex) {
                Error("Failed to parse: {0}".FormatInvariant(ex.Message));
                Error(json);
            } catch (JsonException ex) {
                Error("Failed to parse: {0}".FormatInvariant(ex.Message));
                Error(json);
            }
        }