path: root/QtVsTools.Package/QtMsBuild/QtProjectBuild.cs

/****************************************************************************
**
** Copyright (C) 2021 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the Qt VS Tools.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Build.Evaluation;
using Microsoft.Build.Execution;
using Microsoft.Build.Framework;
using Microsoft.VisualStudio.ProjectSystem;
using Microsoft.VisualStudio.TaskStatusCenter;
using Microsoft.VisualStudio.Threading;
using Microsoft.VisualStudio.VCProjectEngine;

namespace QtVsTools.QtMsBuild
{
    using Core;
    using VisualStudio;
    using Thread = System.Threading.Thread;

    class QtProjectBuild : Concurrent<QtProjectBuild>
    {
        static PunisherQueue<QtProjectBuild> _BuildQueue;
        static PunisherQueue<QtProjectBuild> BuildQueue =>
            StaticThreadSafeInit(() => _BuildQueue,
                () => _BuildQueue = new PunisherQueue<QtProjectBuild>(
                    getItemKey: (QtProjectBuild build) =>
                    {
                        return build.ConfiguredProject;
                    })
                );

        static ConcurrentStopwatch _RequestTimer;
        static ConcurrentStopwatch RequestTimer =>
            StaticThreadSafeInit(() => _RequestTimer, () => _RequestTimer = new ConcurrentStopwatch());

        static IVsTaskStatusCenterService _StatusCenter;
        static IVsTaskStatusCenterService StatusCenter => StaticThreadSafeInit(() => _StatusCenter,
                () => _StatusCenter = VsServiceProvider
                    .GetService<SVsTaskStatusCenterService, IVsTaskStatusCenterService>());

        EnvDTE.Project Project { get; set; }
        UnconfiguredProject UnconfiguredProject { get; set; }
        ConfiguredProject ConfiguredProject { get; set; }
        Dictionary<string, string> Properties { get; set; }
        List<string> Targets { get; set; }
        LoggerVerbosity LoggerVerbosity { get; set; }

        static Task BuildDispatcher { get; set; }

        public static void StartBuild(
            EnvDTE.Project project,
            string configName,
            Dictionary<string, string> properties,
            IEnumerable<string> targets,
            LoggerVerbosity verbosity = LoggerVerbosity.Quiet)
        {
            if (project == null)
                throw new ArgumentException("Project cannot be null.");
            if (configName == null)
                throw new ArgumentException("Configuration name cannot be null.");

            _ = Task.Run(() => StartBuildAsync(project, configName, properties, targets, verbosity));
        }

        public static async Task StartBuildAsync(
            EnvDTE.Project project,
            string configName,
            Dictionary<string, string> properties,
            IEnumerable<string> targets,
            LoggerVerbosity verbosity)
        {
            if (project == null)
                throw new ArgumentException("Project cannot be null.");
            if (configName == null)
                throw new ArgumentException("Configuration name cannot be null.");

            RequestTimer.Restart();
            if (QtVsToolsPackage.Instance.Options.BuildDebugInformation) {
                Messages.Print(string.Format(
                "{0:HH:mm:ss.FFF} QtProjectBuild({1}): Request [{2}] {3}",
                DateTime.Now, Thread.CurrentThread.ManagedThreadId,
                configName, project.FullName));
            }

            var tracker = QtProjectTracker.Get(project);
            await tracker.Initialized;

            var knownConfigs = await tracker.UnconfiguredProject.Services
                .ProjectConfigurationsService.GetKnownProjectConfigurationsAsync();

            ConfiguredProject configuredProject = null;
            foreach (var config in knownConfigs) {
                var configProject = await tracker.UnconfiguredProject
                    .LoadConfiguredProjectAsync(config);
                if (configProject.ProjectConfiguration.Name == configName) {
                    configuredProject = configProject;
                    break;
                }
            }
            if (configuredProject == null)
                throw new ArgumentException(string.Format("Unknown configuration '{0}'.", configName));

            BuildQueue.Enqueue(new QtProjectBuild()
            {
                Project = project,
                UnconfiguredProject = tracker.UnconfiguredProject,
                ConfiguredProject = configuredProject,
                Properties = properties?.ToDictionary(x => x.Key, x => x.Value),
                Targets = targets?.ToList(),
                LoggerVerbosity = verbosity
            });
            StaticThreadSafeInit(() => BuildDispatcher,
                () => BuildDispatcher = Task.Run(BuildDispatcherLoopAsync))
                .Forget();
        }

        public static void Reset()
        {
            BuildQueue.Clear();
        }

        static async Task BuildDispatcherLoopAsync()
        {
            ITaskHandler2 dispatchStatus = null;
            while (!QtVsToolsPackage.Instance.Zombied) {
                while (BuildQueue.IsEmpty || RequestTimer.ElapsedMilliseconds < 1000) {
                    if (BuildQueue.IsEmpty && dispatchStatus != null) {
                        dispatchStatus.Dismiss();
                        dispatchStatus = null;
                    }
                    await Task.Delay(100);
                }
                if (BuildQueue.TryDequeue(out QtProjectBuild buildRequest)) {
                    if (dispatchStatus == null) {
                        dispatchStatus = StatusCenter.PreRegister(
                            new TaskHandlerOptions
                            {
                                Title = "Qt VS Tools",
                            },
                            new TaskProgressData
                            {
                                ProgressText = string.Format(
                                    "Refreshing IntelliSense data, {0} project(s) remaining...",
                                    BuildQueue.Count),
                                CanBeCanceled = true
                            })
                            as ITaskHandler2;
                        dispatchStatus.RegisterTask(new Task(() =>
                            throw new InvalidOperationException()));
                    } else {
                        dispatchStatus.Progress.Report(
                            new TaskProgressData
                            {
                                ProgressText = string.Format(
                                    "Refreshing IntelliSense data, {0} project(s) remaining...",
                                    BuildQueue.Count),
                                CanBeCanceled = true,
                            });
                    }
                    await buildRequest.BuildAsync();
                }
                if (BuildQueue.IsEmpty
                    || dispatchStatus?.UserCancellation.IsCancellationRequested == true) {
                    if (dispatchStatus != null) {
                        dispatchStatus.Dismiss();
                        dispatchStatus = null;
                    }
                    Reset();
                }
            }
        }

        async Task BuildAsync()
        {
            if (LoggerVerbosity != LoggerVerbosity.Quiet) {
                Messages.Print(clear: !QtVsToolsPackage.Instance.Options.BuildDebugInformation, activate: true,
                    text: string.Format(
@"== {0}: starting build...
  * Properties: {1}
  * Targets: {2}
",
                    /*{0}*/ Project.Name,
                    /*{1}*/ string.Join("", Properties
                        .Select(property => string.Format(@"
        {0} = {1}",     /*{0}*/ property.Key, /*{1}*/ property.Value))),
                    /*{2}*/ string.Join(";", Targets)));
            }

            var lockService = UnconfiguredProject.ProjectService.Services.ProjectLockService;

            bool ok = false;
            try {
                ProjectWriteLockReleaser writeAccess;
                var timer = ConcurrentStopwatch.StartNew();
                while (timer.IsRunning) {
                    try {
                        writeAccess = await lockService.WriteLockAsync();
                        timer.Stop();
                    } catch (InvalidOperationException) {
                        if (timer.ElapsedMilliseconds >= 5000)
                            throw;
                        using (var readAccess = await lockService.ReadLockAsync())
                            await readAccess.ReleaseAsync();
                    }
                }

                using (writeAccess) {
                    var msBuildProject = await writeAccess.GetProjectAsync(ConfiguredProject);

                    var solutionPath = QtProjectTracker.SolutionPath;
                    var configProps = new Dictionary<string, string>(
                        ConfiguredProject.ProjectConfiguration.Dimensions.ToImmutableDictionary())
                    {
                        { "SolutionPath", solutionPath },
                        { "SolutionFileName", Path.GetFileName(solutionPath) },
                        { "SolutionName", Path.GetFileNameWithoutExtension(solutionPath) },
                        { "SolutionExt", Path.GetExtension(solutionPath) },
                        { "SolutionDir", Path.GetDirectoryName(solutionPath).TrimEnd('\\') + '\\'  }
                    };

                    foreach (var property in Properties)
                        configProps[property.Key] = property.Value;

                    var projectInstance = new ProjectInstance(msBuildProject.Xml,
                        configProps, null, new ProjectCollection());

                    var loggerVerbosity = LoggerVerbosity;
                    if (QtVsToolsPackage.Instance.Options.BuildDebugInformation)
                        loggerVerbosity = QtVsToolsPackage.Instance.Options.BuildLoggerVerbosity;
                    var buildParams = new BuildParameters()
                    {
                        Loggers = (loggerVerbosity != LoggerVerbosity.Quiet)
                                ? new[] { new QtProjectLogger() { Verbosity = loggerVerbosity } }
                                : null
                    };

                    var buildRequest = new BuildRequestData(projectInstance,
                        Targets.ToArray(),
                        hostServices: null,
                        flags: BuildRequestDataFlags.ProvideProjectStateAfterBuild);

                    if (QtVsToolsPackage.Instance.Options.BuildDebugInformation) {
                        Messages.Print(string.Format(
                            "{0:HH:mm:ss.FFF} QtProjectBuild({1}): Build [{2}] {3}",
                            DateTime.Now, Thread.CurrentThread.ManagedThreadId,
                            ConfiguredProject.ProjectConfiguration.Name,
                            UnconfiguredProject.FullPath));
                        Messages.Print("=== Targets");
                        foreach (var target in buildRequest.TargetNames)
                            Messages.Print(string.Format("    {0}", target));
                        Messages.Print("=== Properties");
                        foreach (var property in Properties) {
                            Messages.Print(string.Format("    {0}={1}",
                                property.Key, property.Value));
                        }
                    }

                    BuildResult result = null;
                    while (result == null) {
                        try {
                            result = BuildManager.DefaultBuildManager.Build(
                                buildParams, buildRequest);
                        } catch (InvalidOperationException) {
                            if (QtVsToolsPackage.Instance.Options.BuildDebugInformation) {
                                Messages.Print(string.Format(
                                    "{0:HH:mm:ss.FFF} QtProjectBuild({1}): [{2}] "
                                    + "Warning: Another build is in progress; waiting...",
                                    DateTime.Now,
                                    Thread.CurrentThread.ManagedThreadId,
                                    ConfiguredProject.ProjectConfiguration.Name));
                            }
                            await Task.Delay(3000);
                        }
                    }

                    if (QtVsToolsPackage.Instance.Options.BuildDebugInformation) {
                        string resMsg;
                        StringBuilder resInfo = new StringBuilder();
                        if (result?.OverallResult == BuildResultCode.Success) {
                            resMsg = "Build ok";
                        } else {
                            resMsg = "Build FAIL";
                            if (result == null) {
                                resInfo.AppendLine("####### Build returned 'null'");
                            } else {
                                resInfo.AppendLine("####### Build returned 'Failure' code");
                                if (result.ResultsByTarget != null) {
                                    foreach (var tr in result.ResultsByTarget) {
                                        var res = tr.Value;
                                        if (res.ResultCode != TargetResultCode.Failure)
                                            continue;
                                        resInfo.AppendFormat("### Target '{0}' FAIL\r\n", tr.Key);
                                        if (res.Items != null && res.Items.Length > 0) {
                                            resInfo.AppendFormat(
                                                "Items: {0}\r\n", string.Join(", ", res.Items
                                                    .Select(it => it.ItemSpec)));
                                        }
                                        var e = tr.Value?.Exception;
                                        if (e != null) {
                                            resInfo.AppendFormat(
                                                "Exception: {0}\r\nStacktrace:\r\n{1}\r\n",
                                                e.Message, e.StackTrace);
                                        }
                                    }
                                }
                            }
                        }
                        Messages.Print(string.Format(
                            "{0:HH:mm:ss.FFF} QtProjectBuild({1}): [{2}] {3}\r\n{4}",
                            DateTime.Now, Thread.CurrentThread.ManagedThreadId,
                            ConfiguredProject.ProjectConfiguration.Name,
                            resMsg, resInfo.ToString()));
                    }

                    if (result == null
                        || result.ResultsByTarget == null
                        || result.OverallResult != BuildResultCode.Success) {
                        Messages.Print(string.Format("{0}: background build FAILED!",
                                Path.GetFileName(UnconfiguredProject.FullPath)));
                    } else {
                        var checkResults = result.ResultsByTarget
                            .Where(x => Targets.Contains(x.Key))
                            .Select(x => x.Value);
                        ok = checkResults.Any()
                            && checkResults.All(x => x.ResultCode == TargetResultCode.Success);
                        if (ok)
                            msBuildProject.MarkDirty();
                    }
                    await writeAccess.ReleaseAsync();
                }

                if (ok) {
                    var vcProject = Project.Object as VCProject;
                    var vcConfigs = vcProject.Configurations as IVCCollection;
                    var vcConfig = vcConfigs.Item(ConfiguredProject.ProjectConfiguration.Name) as VCConfiguration;
                    var props = vcConfig.Rules.Item("QtRule10_Settings") as IVCRulePropertyStorage;
                    props.SetPropertyValue("QtLastBackgroundBuild", DateTime.UtcNow.ToString("o"));
                }
            } catch (Exception e) {
                Messages.Print(string.Format("{0}: background build ERROR: {1}",
                        Path.GetFileName(UnconfiguredProject.FullPath), e.Message));
            }

            if (LoggerVerbosity != LoggerVerbosity.Quiet) {
                Messages.Print(string.Format(
@"
== {0}: build {1}",
                    Project.Name, ok ? "successful" : "ERROR"));
            }
        }
    }
}