private void RunAllByVersion(IEnumerable <SolutionInfoViewModel> testSolutionInfos,
StartupConfigurationMode startupConfigurationMode, AnalysisStatus properInitialStatus)
{
var actualModels = testSolutionInfos.ToList();
var needToRun = Utils.NeedToRun(actualModels, startupConfigurationMode, properInitialStatus);
if (!needToRun)
{
return;
}
// Сконфигурируем имя директории
var currentTestingDir = CreateTestFiles(startupConfigurationMode);
var factory = new TaskFactory(new LimitedConcurrencyLevelTaskScheduler(_concurrentTestRunNumber));
try
{
Task.WaitAll(
actualModels.OrderBy(model => model.TestSolutionInfo.ReadOrder)
.Select(
solution =>
factory.StartNew(
() => Execute(startupConfigurationMode, properInitialStatus, solution, currentTestingDir)))
.ToArray());
}
catch (AggregateException aggrEx)
{
aggrEx.Handle(innerEx =>
{
AppEventLogger.Log(
string.Format("{0}: {1}", innerEx.Message, innerEx.StackTrace), EventLogEntryType.Error);
return(true);
});
}
}
/// <summary>
/// Получение текущего статуса для анализируемого решения
/// </summary>
/// <param name="startupMode">Конфигурация запуска</param>
/// <param name="solution">Модель решения</param>
/// <returns>Текущий статус</returns>
public static AnalysisStatus GetStatusValue(this StartupConfigurationMode startupMode,
SolutionInfoViewModel solution)
{
AnalysisStatus currentSlnStatus;
switch (startupMode)
{
case StartupConfigurationMode.PvsVs2010:
currentSlnStatus = solution.LaunchStatusOnPvsVs2010;
break;
case StartupConfigurationMode.PvsVs2012:
currentSlnStatus = solution.LaunchStatusOnPvsVs2012;
break;
case StartupConfigurationMode.PvsVs2013:
currentSlnStatus = solution.LaunchStatusOnPvsVs2013;
break;
case StartupConfigurationMode.PvsVs2015:
currentSlnStatus = solution.LaunchStatusOnPvsVs2015;
break;
case StartupConfigurationMode.All:
throw new ArgumentException("startupConfigurationMode");
default:
currentSlnStatus = AnalysisStatus.None;
break;
}
return(currentSlnStatus);
}
/// <summary>
/// Установка нового статуса для анализируемого решения
/// </summary>
/// <param name="startupConfigurationMode">Конфигурация запуска</param>
/// <param name="solutionInfo">Модель решения</param>
/// <param name="newStatusValue">Новый статус</param>
public static void SetStatusValue(this SolutionInfoViewModel solutionInfo,
StartupConfigurationMode startupConfigurationMode, AnalysisStatus newStatusValue)
{
switch (startupConfigurationMode)
{
case StartupConfigurationMode.PvsVs2010:
solutionInfo.LaunchStatusOnPvsVs2010 = newStatusValue;
break;
case StartupConfigurationMode.PvsVs2012:
solutionInfo.LaunchStatusOnPvsVs2012 = newStatusValue;
break;
case StartupConfigurationMode.PvsVs2013:
solutionInfo.LaunchStatusOnPvsVs2013 = newStatusValue;
break;
case StartupConfigurationMode.PvsVs2015:
solutionInfo.LaunchStatusOnPvsVs2015 = newStatusValue;
break;
case StartupConfigurationMode.All:
throw new ArgumentException("startupConfigurationMode");
default:
throw new InvalidOperationException(string.Format("Unsupported Visual Studio version: {0}",
startupConfigurationMode));
}
}
/// <summary>
/// Получает строку статуса для версии Visual Studio
/// </summary>
/// <param name="vsVersion">Версия Visual Studio</param>
/// <param name="solutionInfo">Информация о VS-решении</param>
/// <returns>Строка статуса для версии Visual Studio</returns>
public static AnalysisStatus GetLaunchStatus(StartupConfigurationMode vsVersion,
SolutionInfoViewModel solutionInfo)
{
AnalysisStatus launchStatusOn;
switch (vsVersion)
{
case StartupConfigurationMode.PvsVs2010:
launchStatusOn = solutionInfo.LaunchStatusOnPvsVs2010;
break;
case StartupConfigurationMode.PvsVs2012:
launchStatusOn = solutionInfo.LaunchStatusOnPvsVs2012;
break;
case StartupConfigurationMode.PvsVs2013:
launchStatusOn = solutionInfo.LaunchStatusOnPvsVs2013;
break;
case StartupConfigurationMode.PvsVs2015:
launchStatusOn = solutionInfo.LaunchStatusOnPvsVs2015;
break;
default:
throw new InvalidOperationException(string.Format("Unsupported Visual Studio version: {0}",
vsVersion));
}
return(launchStatusOn);
}
private void SetNewStatusValue(StartupConfigurationMode configMode, SolutionInfoViewModel localSlnInfo,
AnalysisStatus newStatus)
{
switch (configMode)
{
case StartupConfigurationMode.PvsVs2010:
RunInUiSynchronizationContext(() => localSlnInfo.LaunchStatusOnPvsVs2010 = newStatus);
break;
case StartupConfigurationMode.PvsVs2012:
RunInUiSynchronizationContext(() => localSlnInfo.LaunchStatusOnPvsVs2012 = newStatus);
break;
case StartupConfigurationMode.PvsVs2013:
RunInUiSynchronizationContext(() => localSlnInfo.LaunchStatusOnPvsVs2013 = newStatus);
break;
case StartupConfigurationMode.PvsVs2015:
RunInUiSynchronizationContext(() => localSlnInfo.LaunchStatusOnPvsVs2015 = newStatus);
break;
default:
throw new InvalidOperationException(
string.Format("Unsupported Visual Studio version: {0}", configMode));
}
}
/// <summary>
/// Нужно ли создавать конфигурацию для запуска под конкретную версию
/// </summary>
/// <param name="testSolutionInfos">VS-решения</param>
/// <param name="vsVersion">Версия VS</param>
/// <param name="properInitialStatus">Статус, под которым нужно звапускать анализ</param>
/// <returns>true, если есть хотя бы один проект для запуска под конкретную версию, false - в противном случае</returns>
public static bool NeedToRun(IEnumerable <SolutionInfoViewModel> testSolutionInfos,
StartupConfigurationMode vsVersion, AnalysisStatus properInitialStatus)
{
var needToRun = false;
switch (vsVersion)
{
case StartupConfigurationMode.PvsVs2010:
needToRun =
testSolutionInfos.Any(slnInfo => slnInfo.LaunchStatusOnPvsVs2010 == properInitialStatus);
break;
case StartupConfigurationMode.PvsVs2012:
needToRun =
testSolutionInfos.Any(slnInfo => slnInfo.LaunchStatusOnPvsVs2012 == properInitialStatus);
break;
case StartupConfigurationMode.PvsVs2013:
needToRun =
testSolutionInfos.Any(slnInfo => slnInfo.LaunchStatusOnPvsVs2013 == properInitialStatus);
break;
case StartupConfigurationMode.PvsVs2015:
needToRun =
testSolutionInfos.Any(slnInfo => slnInfo.LaunchStatusOnPvsVs2015 == properInitialStatus);
break;
}
return(needToRun);
}
private void Execute(StartupConfigurationMode startupConfigurationMode, AnalysisStatus properInitialStatus,
SolutionInfoViewModel solutionInfo, string currentTestingDir)
{
var testSolutionInfo = solutionInfo.TestSolutionInfo;
var initialStatus = Utils.GetLaunchStatus(startupConfigurationMode, solutionInfo);
if (initialStatus == AnalysisStatus.None)
{
throw new InvalidOperationException("Unable to determine the analysis status");
}
if (initialStatus != properInitialStatus)
{
return;
}
var logFileName = Utils.GetLogFileName(currentTestingDir, testSolutionInfo);
var analysisManager = new AnalysisManager(
solutionInfo, startupConfigurationMode, initialStatus, logFileName, _currentHtmlLog);
lock (_syncAnalysisManagers)
{
AnalysisManagers.Add(analysisManager);
}
analysisManager.Run();
OnCurrentAnalysisDone(
new CurrentAnalysisDoneEventArgs(Interlocked.Increment(ref _totalFinishedCount)));
}
/// <summary>
/// Выделение всего столбца для элемента управления DataGrid с заданной строкой заголовка
/// </summary>
/// <param name="startupConfigurationMode">Режим конфигурации запуска</param>
/// <param name="dataGrid">Элемент управления DataGrid</param>
public static void SelectColumnCellsByHeaderString(StartupConfigurationMode startupConfigurationMode,
DataGrid dataGrid)
{
var foundedColumnIndex = -1;
for (var i = 0; i < dataGrid.Columns.Count; i++)
{
var header = dataGrid.Columns[i].Header.ToString();
var headerMode = SlnInfoGridHeaderToStartupConfigurationMode(header);
if (headerMode == startupConfigurationMode)
{
foundedColumnIndex = i;
break;
}
}
if (foundedColumnIndex == -1)
{
return;
}
foreach (var currentItem in dataGrid.Items)
{
dataGrid.CurrentCell = new DataGridCellInfo(currentItem, dataGrid.Columns[foundedColumnIndex]);
if (!dataGrid.SelectedCells.Contains(dataGrid.CurrentCell))
{
dataGrid.SelectedCells.Add(dataGrid.CurrentCell);
}
}
}
/// <summary>
/// Конструктор аргументов события анализа
/// </summary>
/// <param name="newStatus">Новый статус анализа</param>
/// <param name="solutionInfoViewModel">Информация о VS-решении</param>
/// <param name="startupMode">Конфигурация запуска</param>
/// <param name="crashReason">Возможная причина сбоя</param>
/// <param name="devenvExitCode">Код завершения devenv.exe</param>
public TestAnalysisEventArgs(AnalysisStatus newStatus, SolutionInfoViewModel solutionInfoViewModel,
StartupConfigurationMode startupMode, CrashReason crashReason = default(CrashReason),
int devenvExitCode = default(int))
{
NewStatus = newStatus;
SolutionInfo = solutionInfoViewModel;
StartupMode = startupMode;
CrashReason = crashReason;
DevenvExitCode = devenvExitCode;
}
/// <summary>
/// Конструктор менеджера для тестового анализа
/// </summary>
/// <param name="slnInfoVm">Тестируемое решение</param>
/// <param name="startupConfigurationMode">Версия Visual Studion, для которой нужно запустить решение</param>
/// <param name="status">Начальный статус анализа</param>
/// <param name="logFileName">Файл лога с результатами работы анализатора</param>
/// <param name="htmlLog">Html-лог</param>
public AnalysisManager(SolutionInfoViewModel slnInfoVm, StartupConfigurationMode startupConfigurationMode,
AnalysisStatus status, string logFileName, string htmlLog)
{
SolutionInfo = slnInfoVm;
StartupMode = startupConfigurationMode;
_logFileName = logFileName;
_snapshotFilename = string.Format("{0}{1}", _logFileName, SnapshotExt);
_currentStatus = status;
_htmlLog = htmlLog;
}
private string CreateTestFiles(StartupConfigurationMode startupConfigurationMode)
{
var currentTestingDir = string.Format(
"{0}{1}{2}", _launchPartyFolder, Path.DirectorySeparatorChar, startupConfigurationMode);
if (!Directory.Exists(currentTestingDir))
{
Directory.CreateDirectory(currentTestingDir);
}
return(currentTestingDir);
}
/// <summary>
/// Установлена ли версия Visual Studio для конфигурации запуска
/// </summary>
/// <param name="startupConfigurationMode">Kонфигурациz запуска</param>
/// <param name="errorMessage">Сообщение об ошибке</param>
/// <returns>true, если для конфигурации запуска установлена VS, false - в противном случае</returns>
public static bool IsVsInstalled(this StartupConfigurationMode startupConfigurationMode, out string errorMessage)
{
if (startupConfigurationMode == StartupConfigurationMode.All)
{
errorMessage = string.Empty;
return(true);
}
switch (startupConfigurationMode)
{
case StartupConfigurationMode.PvsVs2010:
if (!InstallationInfo.IsInstalledVs2010)
{
errorMessage = "Visual Studio 2010 is not installed on this machine";
return(false);
}
break;
case StartupConfigurationMode.PvsVs2012:
if (!InstallationInfo.IsInstalledVs2012)
{
errorMessage = "Visual Studio 2012 is not installed on this machine";
return(false);
}
break;
case StartupConfigurationMode.PvsVs2013:
if (!InstallationInfo.IsInstalledVs2013)
{
errorMessage = "Visual Studio 2013 is not installed on this machine";
return(false);
}
break;
case StartupConfigurationMode.PvsVs2015:
if (!InstallationInfo.IsInstalledVs2015)
{
errorMessage = "Visual Studio 2015 is not installed on this machine";
return(false);
}
break;
}
errorMessage = string.Empty;
return(true);
}
/// <summary>
/// Установка свойств решения для запуска
/// </summary>
/// <param name="startupConfigurationMode">Конфигурация запуска</param>
/// <param name="slnInfo">Модель решения</param>
/// <param name="pendingStatus">Статус планирования к запуску</param>
/// <param name="currentTotalCount">Счетчик решений, запланированных к запуску</param>
public static void EstablishLaunchStatus(StartupConfigurationMode startupConfigurationMode,
SolutionInfoViewModel slnInfo, AnalysisStatus pendingStatus, ref int currentTotalCount)
{
switch (startupConfigurationMode)
{
case StartupConfigurationMode.PvsVs2010:
var pvsVs2010Stat = slnInfo.LaunchStatusOnPvsVs2010;
if (!pvsVs2010Stat.IsInDisablingStatus())
{
slnInfo.LaunchStatusOnPvsVs2010 = pendingStatus;
currentTotalCount++;
}
break;
case StartupConfigurationMode.PvsVs2012:
var pvsVs2012Stat = slnInfo.LaunchStatusOnPvsVs2012;
if (!pvsVs2012Stat.IsInDisablingStatus())
{
slnInfo.LaunchStatusOnPvsVs2012 = pendingStatus;
currentTotalCount++;
}
break;
case StartupConfigurationMode.PvsVs2013:
var pvsVs2013Stat = slnInfo.LaunchStatusOnPvsVs2013;
if (!pvsVs2013Stat.IsInDisablingStatus())
{
slnInfo.LaunchStatusOnPvsVs2013 = pendingStatus;
currentTotalCount++;
}
break;
case StartupConfigurationMode.PvsVs2015:
var pvsVs2015Stat = slnInfo.LaunchStatusOnPvsVs2015;
if (!pvsVs2015Stat.IsInDisablingStatus())
{
slnInfo.LaunchStatusOnPvsVs2015 = pendingStatus;
currentTotalCount++;
}
break;
}
}
/// <summary>
/// Извлекает путь к установленной Visual Studio
/// </summary>
/// <param name="vsVersion">Версия Visual Studio</param>
/// <returns>Путь к установленной Visual Studio</returns>
public static string RetrieveVisualStudioPath(StartupConfigurationMode vsVersion)
{
switch (vsVersion)
{
case StartupConfigurationMode.PvsVs2010:
return(Vs2010Path);
case StartupConfigurationMode.PvsVs2012:
return(Vs2012Path);
case StartupConfigurationMode.PvsVs2013:
return(Vs2013Path);
case StartupConfigurationMode.PvsVs2015:
return(Vs2015Path);
default:
throw new InvalidOperationException("Visual Studio version must be concrete here");
}
}
private static Process OpenAnalysisReportUntilWndValid(SolutionInfoViewModel currentSolution,
StartupConfigurationMode startupConfigurationMode, string selectedRunFolder, bool minimizeWindow)
{
Process devenvProc;
if (!Prepare(currentSolution, startupConfigurationMode, selectedRunFolder, out devenvProc))
{
return(null);
}
IntPtr wndHandle;
do
{
wndHandle = devenvProc.MainWindowHandle;
} while (wndHandle == IntPtr.Zero);
Unmanaged.ShowWindow(wndHandle,
minimizeWindow ? Unmanaged.ShowOptions.Minimize : Unmanaged.ShowOptions.Show);
return(devenvProc);
}
private static bool Prepare(SolutionInfoViewModel currentSolution,
StartupConfigurationMode startupConfigurationMode,
string selectedRunFolder, out Process devenvProc)
{
var absSlnFile = currentSolution.TestSolutionInfo.AbsSolutionFileName;
var vsPath = InstallationInfo.RetrieveVisualStudioPath(startupConfigurationMode);
var selfTesterRootPath = ApplicationConfigReader.SelfTesterRootPath;
var srcEtalonFolder = ApplicationConfigReader.Instance.SrcEtalonFolder;
PrepareSolution(absSlnFile, vsPath, selfTesterRootPath, srcEtalonFolder);
var selectedDiffLog = string.Format("{0}{1}{2}{1}{3}{4}_Diffs.plog", selectedRunFolder,
Path.DirectorySeparatorChar, startupConfigurationMode, Path.GetFileNameWithoutExtension(absSlnFile),
CoreExtensions.EtalonLogExt);
if (!File.Exists(selectedDiffLog))
{
devenvProc = null;
return(false);
}
var vsStartInfo = new ProcessStartInfo
{
FileName = string.Format("{0}{1}devenv.exe", vsPath, Path.DirectorySeparatorChar),
Arguments =
string.Format("\"{0}\" /command \"PVSStudio.OpenAnalysisReport {1}\"", absSlnFile, selectedDiffLog)
};
devenvProc = Process.Start(vsStartInfo);
if (devenvProc == null)
{
return(false);
}
devenvProc.WaitForInputIdle();
return(true);
}
/// <summary>
/// Открывает diff-файл лога в формате PVS-Studio
/// </summary>
/// <param name="currentSolution">Решение</param>
/// <param name="startupConfigurationMode">Конфигурация запуска</param>
/// <param name="selectedRunFolder">Директория тестового запуска</param>
private static void OpenAnalysisReportUntilWndValid(SolutionInfoViewModel currentSolution,
StartupConfigurationMode startupConfigurationMode, string selectedRunFolder)
{
Process devenvProc;
if (!Prepare(currentSolution, startupConfigurationMode, selectedRunFolder, out devenvProc))
{
return;
}
// Блокируем поток, пока не появится окно
var vsIsInVisibleState = false;
do
{
var vsWndHandle = devenvProc.MainWindowHandle;
if (vsWndHandle == IntPtr.Zero)
{
continue;
}
vsIsInVisibleState = Unmanaged.IsWindowVisible(vsWndHandle);
} while (!vsIsInVisibleState);
}
/// <summary>
/// Записывает сообщение в системный журнал событий
/// </summary>
/// <param name="totalElapsed">Время потраченное на анализ</param>
/// <param name="startup">Версия VS для запуска</param>
/// <param name="testSolutionInfo">Сущность для тестирования</param>
/// <param name="entryType">Тип сообщения</param>
public static void Log(TimeSpan totalElapsed, StartupConfigurationMode startup, TestSolutionInfo testSolutionInfo,
EventLogEntryType entryType = EventLogEntryType.Information)
{
if (!SelfTesterSourceExists)
{
return;
}
var logDocument = new XDocument();
var rootElement = new XElement("Root",
new XElement("Elapsed", totalElapsed.ToString(@"hh\:mm\:ss")),
new XElement("StartupMode", startup.ToString()),
new XElement("SolutionInfo",
new XElement("Solution", testSolutionInfo.AbsSolutionFileName),
new XElement("ConfigMode", testSolutionInfo.ConfigurationMode.ToString()),
new XElement("Platform", testSolutionInfo.Platform),
new XElement("PreprocessorType", testSolutionInfo.PreprocessorType)));
logDocument.Add(rootElement);
using (var selfTesterEventLog = new EventLog(SelfTesterEventLogName, ".", SelfTesterSourceName))
{
selfTesterEventLog.WriteEntry(logDocument.ToString(), entryType);
}
}
/// <summary>
/// Открывает diff-файл лога в формате PVS-Studio в неблокирующем режиме
/// </summary>
/// <param name="currentSolution">Решение</param>
/// <param name="startupConfigurationMode">Конфигурация запуска</param>
/// <param name="selectedRunFolder">Директория тестового запуска</param>
/// <returns>(Void)-Задача продолжения</returns>
public static Task OpenAnalysisReportUntilWndValidAsync(SolutionInfoViewModel currentSolution,
StartupConfigurationMode startupConfigurationMode, string selectedRunFolder)
{
return(Task.Run(() => OpenAnalysisReportUntilWndValid(currentSolution, startupConfigurationMode, selectedRunFolder)));
}
/// <summary>
/// Установка состояния тестовых запусков в модели
/// </summary>
/// <param name="projectStateMap">Словарь [Имя файла решения, Статус анализа]</param>
/// <param name="solutions">Модель решений</param>
/// <param name="startupConfigurationMode">Версия VS</param>
private static void SetSolutionsState(IDictionary <string, AnalysisStatus> projectStateMap,
IEnumerable <SolutionInfoViewModel> solutions, StartupConfigurationMode startupConfigurationMode)
{
var testRunSlns = projectStateMap.Keys;
foreach (var slnViewModel in solutions)
{
var solution = slnViewModel;
if (!testRunSlns.Contains(solution.SolutionFileName))
{
continue;
}
var projectState = projectStateMap[solution.SolutionFileName];
switch (startupConfigurationMode)
{
case StartupConfigurationMode.PvsVs2010:
slnViewModel.LaunchStatusOnPvsVs2010 = projectState;
break;
case StartupConfigurationMode.PvsVs2012:
slnViewModel.LaunchStatusOnPvsVs2012 = projectState;
break;
case StartupConfigurationMode.PvsVs2013:
slnViewModel.LaunchStatusOnPvsVs2013 = projectState;
break;
case StartupConfigurationMode.PvsVs2015:
slnViewModel.LaunchStatusOnPvsVs2015 = projectState;
break;
}
}
}
/// <summary>
/// Подходит ли конфигурация запуска для эталонов
/// </summary>
/// <param name="startup">Конфигурация запуска</param>
/// <returns>true, если подходит, false - в противном случае</returns>
public static bool IsSuitForEtalons(this StartupConfigurationMode startup)
{
return(EtalonSuitableConfigurationModes.Any(mode => startup == mode));
}
