private async void OnSlnInfoDataGrid_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
var dependencyObject = e.OriginalSource as DependencyObject;
if (dependencyObject == null)
{
return;
}
var currentGridCell = UiUtils.FindProperDependencyElement <DataGridCell>(dependencyObject);
if (currentGridCell == null)
{
return;
}
var currentSolution = currentGridCell.DataContext as SolutionInfoViewModel;
var headerString = currentGridCell.Column.Header.ToString();
var startupConfigurationMode = UiUtils.SlnInfoGridHeaderToStartupConfigurationMode(headerString);
if (currentSolution == null || startupConfigurationMode == StartupConfigurationMode.All)
{
return;
}
var currentSolutionStatus = startupConfigurationMode.GetStatusValue(currentSolution);
if (_selectedRunFolder == string.Empty || !Directory.Exists(_selectedRunFolder))
{
MessageBox.Show(this, Properties.Resources.SelectRunMsg, _selfTesterAppName, MessageBoxButton.OK,
MessageBoxImage.Warning);
return;
}
if (currentSolutionStatus != AnalysisStatus.DiffFinished)
{
return;
}
var runFolderClosure = _selectedRunFolder;
try
{
this.BlurApply(UiUtils.DefaultBlurRadius, TimeSpan.FromMilliseconds(200), TimeSpan.Zero);
var waitWindow = new WaitWindow(_selfTesterAppName, Properties.Resources.DevenvStarting)
{
Owner = this
};
await ShowWaitingDialogAsync(waitWindow).ConfigureAwait(true);
await
AnalyzerUtilities.OpenAnalysisReportUntilWndValidAsync(currentSolution, startupConfigurationMode,
runFolderClosure)
.ConfigureAwait(true);
waitWindow.Close();
}
finally
{
this.BlurDisable(TimeSpan.FromSeconds(1), TimeSpan.Zero);
}
}
public MainWindow()
{
RenderOptions.ProcessRenderMode = RenderMode.SoftwareOnly;
var freeSpace = AnalyzerUtilities.GetCurrentFreeSpace();
var minRequiredSpace = ApplicationConfigReader.Instance.MinRecommendedWorkingDiskSpace;
if (freeSpace <= minRequiredSpace)
{
var messageBoxResult = MessageBox.Show(this,
string.Format(Properties.Resources.FreeSpaceWarn, Math.Round(freeSpace, 2), minRequiredSpace,
Environment.NewLine), _selfTesterAppName, MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (messageBoxResult == MessageBoxResult.No)
{
Application.Current.Shutdown();
}
}
InitializeComponent();
ConfigureFileSystemWatcher();
var slnViewModel = SetupSolutionInfoDataGrid();
SetupSolutionAutocomplete(slnViewModel);
RefreshTestingRuns();
SelectLastTestingRun();
TesterTimer = new TimerViewModel();
TimerLabel.DataContext = TesterTimer;
StartStopImage.Source = UiUtils.GetStatusImage(ButtonState.Stopped);
DisableSelectionColumnsForNotInstalledStudios();
SelectDefaultStartupColumn();
}
private bool IsSelfExit()
{
var isSelfExit = false;
try
{
var startTime = _upgradeSlnProcess.StartTime;
isSelfExit = _upgradeSlnProcess.WaitForExit(HangTimeMilliseconds);
var workingTime = (_upgradeSlnProcess.ExitTime - startTime).Duration();
var staleDuration = TimeSpan.FromMilliseconds(HangTimeMilliseconds).Duration();
if (workingTime >= staleDuration)
{
try
{
AnalyzerUtilities.GetScreenSnapshot(_snapshot);
}
catch (Win32Exception win32Ex)
{
AppEventLogger.Log(
string.Format("Message {0}. Error code: {1}", win32Ex.Message, win32Ex.NativeErrorCode),
EventLogEntryType.Warning);
}
}
}
catch (InvalidOperationException invOpEx)
{
AppEventLogger.Log(invOpEx.Message, EventLogEntryType.Warning);
}
return(isSelfExit);
}
private static void TakeScreenshot(string solutionName)
{
var lastSessionDir = LastSessionDir;
if (lastSessionDir != null)
{
AnalyzerUtilities.GetScreenSnapshot(Path.Combine(lastSessionDir.FullName, string.Format("{0}.png", solutionName)));
}
}
/// <summary>
/// Обновление решения
/// </summary>
/// <param name="isHangout">
/// true, если время на обновление вышло, а процесс все еще не завершен, false - если процесс
/// завершился
/// </param>
/// <param name="devenvExitCode"></param>
/// <returns>true, если обновление прошло успешно, false - в противном случае</returns>
public bool Upgrade(out bool isHangout, out int devenvExitCode)
{
var restoreResult = AnalyzerUtilities.IndividualRestore(_solutionFileName, _selfTesterRootPath,
_srcEtalonFolder);
if (!restoreResult.Item1)
{
isHangout = false;
devenvExitCode = default(int);
AppEventLogger.Log(restoreResult.Item2, EventLogEntryType.Error);
return(false);
}
try
{
ConfigureUpgradeProcess();
_upgradeSlnProcess.Start();
var isSelfExit = IsSelfExit();
if (!isSelfExit) // Если сам не завершился, значит завис
{
ProcessUtils.MandatoryKill(_upgradeSlnProcess);
isHangout = true;
if (_upgradeSlnProcess.HasExited)
{
devenvExitCode = _upgradeSlnProcess.ExitCode;
return(false);
}
}
isHangout = false;
devenvExitCode = _upgradeSlnProcess.HasExited ? _upgradeSlnProcess.ExitCode : default(int);
return(devenvExitCode == 0);
}
catch (Exception ex)
{
AppEventLogger.Log(
string.Format("Error message: {0}{1}{2}", ex.Message, Environment.NewLine, ToString()),
EventLogEntryType.Error);
isHangout = false;
devenvExitCode = default(int);
return(false);
}
}
private void ConfigureFileSystemWatcher()
{
var newTestWatcher = new FileSystemWatcher(ApplicationConfigReader.Instance.Viva64Logs)
{
NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName
};
newTestWatcher.Created += (sender, args) =>
{
if (args.ChangeType != WatcherChangeTypes.Created)
{
return;
}
var newDirName = args.Name;
string machineName;
DateTime testingDateTime;
AnalyzerUtilities.ExtractLaunchPartyComponents(newDirName, out machineName, out testingDateTime);
var newRunEntity = new TestRunEntity
{
MachineName = machineName,
RunningDateTime = testingDateTime,
TestRunDirectory = args.FullPath
};
RunInUiSynchronizationContext(() =>
{
var newItem = new MenuItem {
Header = newRunEntity.ToString()
};
TestingRunMenuItem.Items.Insert(0, newItem);
HighlightFirstMenuItem();
UiUtils.SetMenuItemsEnabled(TestingRunMenuItem, false);
});
_selectedRunFolder = newRunEntity.TestRunDirectory;
};
newTestWatcher.EnableRaisingEvents = true;
}
private async void BatchOpeningLogsButton_OnClick(object sender, RoutedEventArgs e)
{
var openingButton = sender as Button;
if (openingButton == null)
{
return;
}
openingButton.IsEnabled = false;
bool success;
string caption, errorMessage;
var deferred = ExistSelectedSolutions(out success, out caption, out errorMessage);
if (!success)
{
MessageBox.Show(this, caption, errorMessage, MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
var solutions =
await AnalyzerUtilities.FilterSolutionsAsync(deferred, AnalysisStatus.DiffFinished).ConfigureAwait(true);
if (solutions.Length == 0)
{
MessageBox.Show(this, Properties.Resources.NoSelDiffs, _selfTesterAppName, MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
SlnInfoDataGrid.SelectedCells.Clear();
var runFolderClosure = _selectedRunFolder;
await
AnalyzerUtilities.OpenAnalysisReportsAsync(solutions, runFolderClosure, false,
() => RunInUiSynchronizationContext(() => openingButton.IsEnabled = true)).ConfigureAwait(true);
}
/// <summary>
/// Установка логики анализа в "фоне"
/// </summary>
private void TuneBackgroundWorker()
{
if (_testWorker != null)
{
_testWorker.Dispose();
_testWorker = null;
}
_testWorker = new BackgroundWorker
{
WorkerReportsProgress = true,
WorkerSupportsCancellation = true
};
_testWorker.DoWork += (workerSender, workEventArgs) =>
{
Interlocked.Exchange(ref _isRunningNow, 1);
using (var controller = new AnalyzerController(_currentSelectedSolutions))
{
controller.AnalysisManagers.CollectionChanged +=
(ctrlSender, changedEventArgs) => // "Подписываемся" на добавление менеджера анализа
{
if (changedEventArgs.Action != NotifyCollectionChangedAction.Add)
{
return;
}
var newManager = changedEventArgs.NewItems.Cast <AnalysisManager>().FirstOrDefault();
if (newManager == null)
{
throw new InvalidOperationException("newManager can't be null");
}
newManager.AnalysisStatusChanged += (manSender, analysisEventArgs) =>
// "Подписываемся" на смену статуса анализа для очередного добавленного менеджера
{
SetNewStatusValue(
analysisEventArgs.StartupMode, analysisEventArgs.SolutionInfo, analysisEventArgs.NewStatus);
if (_testWorker.IsBusy && _testWorker.CancellationPending)
{
workEventArgs.Cancel = true;
}
};
};
controller.CurrentAnalysisDone += (ctrl, currentAnalysisDoneEventArgs) =>
// "Подписываемся" на завершение анализа для текущего менеджера
{
var currentFinishedCount = currentAnalysisDoneEventArgs.CurrentFinishedCount;
var progress = (int)(currentFinishedCount / (double)_currentTotalCount * 100);
_testWorker.ReportProgress(progress);
};
controller.RunAll(AnalysisStatus.InPending);
}
};
_testWorker.RunWorkerCompleted += (sender, completedEventArgs) =>
{
var ex = completedEventArgs.Error;
if (ex != null)
{
AppEventLogger.Log(ex.ToString(), EventLogEntryType.Warning);
}
if (!completedEventArgs.Cancelled)
{
SetUiCompletedState();
UiUtils.ResetActiveStatuses(_currentSelectedSolutions);
}
else
{
UiUtils.ResetActiveStatuses(_currentSelectedSolutions, true);
}
ProcessUtils.MandatoryKill(Process.GetCurrentProcess(), false);
if (!StartStopButton.IsEnabled)
{
StartStopButton.IsEnabled = true;
}
UiUtils.TurnButtonState(ButtonState.Running, StartStopButton, StartStopImage);
if (!completedEventArgs.Cancelled && ShutdownCheckBox.IsChecked == true)
{
AnalyzerUtilities.ShutdownPc();
}
};
_testWorker.ProgressChanged +=
(sender, changedEventArgs) => { TestingProgressBar.Value = changedEventArgs.ProgressPercentage; };
}
private async void ApproveButton_OnClick(object sender, RoutedEventArgs e)
{
bool success;
string caption, errorMessage;
var selectedSolutions = ExistSelectedSolutions(out success, out caption, out errorMessage);
var filteredSolutions = new List <Tuple <StartupConfigurationMode, SolutionInfoViewModel> >();
var solutions = selectedSolutions as Tuple <StartupConfigurationMode, SolutionInfoViewModel>[] ??
selectedSolutions.ToArray();
// Фильтруем решения, с подходящей конфигурацией для замены эталонов и с подходящим статусом анализа
foreach (var selectedSolution
in solutions.Where(selectedSolution => selectedSolution.Item1.IsSuitForEtalons()))
{
switch (selectedSolution.Item1)
{
case StartupConfigurationMode.PvsVs2010:
if (selectedSolution.Item2.LaunchStatusOnPvsVs2010.IsInApproveSuitableStatus())
{
filteredSolutions.Add(selectedSolution);
}
break;
case StartupConfigurationMode.PvsVs2012:
if (selectedSolution.Item2.LaunchStatusOnPvsVs2012.IsInApproveSuitableStatus())
{
filteredSolutions.Add(selectedSolution);
}
break;
case StartupConfigurationMode.PvsVs2013:
if (selectedSolution.Item2.LaunchStatusOnPvsVs2013.IsInApproveSuitableStatus())
{
filteredSolutions.Add(selectedSolution);
}
break;
case StartupConfigurationMode.PvsVs2015:
if (selectedSolution.Item2.LaunchStatusOnPvsVs2015.IsInApproveSuitableStatus())
{
filteredSolutions.Add(selectedSolution);
}
break;
}
}
if (!success)
{
MessageBox.Show(this, caption, errorMessage, MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
if (filteredSolutions.Count == 0)
{
MessageBox.Show(this, Properties.Resources.NoSuitableSolutionsMsg, _selfTesterAppName, MessageBoxButton.OK,
MessageBoxImage.Warning);
return;
}
var messageBoxResult = MessageBox.Show(this,
string.Format(Properties.Resources.WannaContinue, Environment.NewLine), _selfTesterAppName,
MessageBoxButton.YesNo, MessageBoxImage.Exclamation);
if (messageBoxResult != MessageBoxResult.Yes)
{
return;
}
// Заменяем эталонные логи локально...
var logsToReplace =
await AnalyzerUtilities.GetLogsToReplaceAsync(filteredSolutions, _selectedRunFolder).ConfigureAwait(true);
var localReplaceExecutor = new ReplaceEtalonsExecutor(ApplicationConfigReader.Instance.EtalonLogFolder,
logsToReplace);
await localReplaceExecutor.UpdateEtalonsAsync().ConfigureAwait(true);
// ... И на build-сервере
if (Directory.Exists(ApplicationConfigReader.Instance.BldSrvEtalonsFolder))
{
var buildServerReplaceExecutor =
new ReplaceEtalonsExecutor(ApplicationConfigReader.Instance.BldSrvEtalonsFolder, logsToReplace);
await buildServerReplaceExecutor.UpdateEtalonsAsync().ConfigureAwait(true);
}
else
{
MessageBox.Show(this,
string.Format(Properties.Resources.EtalonApproveBuildServerPathNotFound,
ApplicationConfigReader.Instance.BldSrvEtalonsFolder), _selfTesterAppName, MessageBoxButton.OK,
MessageBoxImage.Error);
}
var sourceVerticalOffset = 0.0;
var slnScrollViewer = UiUtils.GetScrollViewer(SlnInfoDataGrid) as ScrollViewer;
if (slnScrollViewer != null)
{
sourceVerticalOffset = slnScrollViewer.ContentVerticalOffset;
}
SetupSolutionInfoDataGrid(TestedSolutionsManager.RefreshTestingRunModel(_selectedRunFolder));
RefreshTestingRuns();
HighlightSelectedRun();
if (slnScrollViewer != null)
{
slnScrollViewer.ScrollToVerticalOffset(sourceVerticalOffset);
}
}
/// <summary>
/// Анализ решения
/// </summary>
/// <param name="isHangout">
/// true, если время, отведенное для анализа вышло, а процесс все еще не завершен, false - если
/// процесс завершился
/// </param>
/// <param name="devenvExitCode"></param>
/// <returns>true, если процесс анализа прошел успешно, false - в противном случае</returns>
public bool ProcessAnalysis(out bool isHangout, out int devenvExitCode)
{
const string errorDetectedSuffix = ".plog.exception_messages.txt";
try
{
ConfigureAnalisysProcess();
var start = DateTime.Now;
_analyzerProcess.Start();
var runningQuota = TimeSpan.FromMinutes(ApplicationConfigReader.Instance.HangTime).Duration();
var plogPath = Path.GetDirectoryName(_plog);
Debug.Assert(plogPath != null, "plogPath != null");
var destinationPlog = Path.GetFileName(_plog);
var plogCreatedEvent = new ManualResetEventSlim();
var plogWatcher = new FileSystemWatcher(plogPath, "*.plog")
{
EnableRaisingEvents = true,
IncludeSubdirectories = false,
NotifyFilter = NotifyFilters.FileName
};
plogWatcher.Created += (sender, args) =>
{
var createdName = args.Name;
if (string.Equals(createdName, destinationPlog))
{
plogCreatedEvent.Set();
}
};
var destinationErrorPlog = string.Format("{0}{1}", Path.GetFileNameWithoutExtension(_plog), errorDetectedSuffix);
var errorCreatedEvent = new ManualResetEventSlim();
var errorWatcher = new FileSystemWatcher(plogPath, string.Format("*{0}", errorDetectedSuffix))
{
EnableRaisingEvents = true,
IncludeSubdirectories = false,
NotifyFilter = NotifyFilters.FileName
};
errorWatcher.Created += (sender, args) =>
{
var createdName = args.Name;
if (string.Equals(destinationErrorPlog, createdName))
{
errorCreatedEvent.Set();
}
};
var waitingIndex = WaitHandle.WaitAny(
new[]
{
plogCreatedEvent.WaitHandle,
errorCreatedEvent.WaitHandle
}, TimeSpan.FromMinutes(ApplicationConfigReader.Instance.HangTime));
var plogAppeared = waitingIndex == 0;
if (plogAppeared)
{
plogAppeared = AnalyzerUtilities.WaitForFileReleased(_plog, start, runningQuota);
AppEventLogger.Log(
string.Format("File {0} is {1}", _plog, (plogAppeared ? "Released" : "Time out")),
plogAppeared ? EventLogEntryType.SuccessAudit : EventLogEntryType.FailureAudit);
}
isHangout = !plogAppeared;
ProcessUtils.MandatoryKill(_analyzerProcess);
devenvExitCode = default(int);
return(!isHangout);
}
catch (Exception ex)
{
AppEventLogger.Log(
string.Format("Error message: {0}. Stack trace: {1}{2}{3}", ex.Message, ex.StackTrace,
Environment.NewLine, ToString()), EventLogEntryType.Error);
devenvExitCode = default(int);
return(isHangout = !File.Exists(_plog));
}
}
