/// <summary>
/// Initializes with the argument that was provided with the command.
/// </summary>
/// <param name="argument">Argument that was provided with the command.</param>
public void Initialize(string argument)
{
if (string.IsNullOrWhiteSpace(argument))
{
HandleInvalidArgument(argument);
}
else
{
string loggerIdentifier = null;
Dictionary <string, string> parameters = null;
var parseSucceeded = LoggerUtilities.TryParseLoggerArgument(argument, out loggerIdentifier, out parameters);
if (parseSucceeded)
{
if (loggerIdentifier.Equals(ConsoleLogger.FriendlyName, StringComparison.OrdinalIgnoreCase))
{
this.loggerManager.AddLogger(new ConsoleLogger(), ConsoleLogger.ExtensionUri, parameters);
}
else
{
this.loggerManager.UpdateLoggerList(argument, loggerIdentifier, parameters);
}
}
else
{
HandleInvalidArgument(argument);
}
}
}
/// <summary>
/// Applies the document actions to the given set of documents.
/// </summary>
public async Task ApplyDocumentActionsAsync(IEnumerable <string> paths)
{
if (paths == null)
{
throw new ArgumentNullException(nameof(paths));
}
var remainingPaths = new HashSet <string>(paths);
try
{
var activeWindow = _dte.ActiveWindow;
foreach (var path in paths)
{
await ApplyDocumentActionsAsync(path);
remainingPaths.Remove(path);
}
if (activeWindow != null)
{
activeWindow.Activate();
}
}
finally
{
if (remainingPaths.Any())
{
string ErrorMessageFormat = @"The following files were not formatted: " + Environment.NewLine + "{0}";
LoggerUtilities.LogError(string.Format(CultureInfo.CurrentCulture, ErrorMessageFormat, string.Join(Environment.NewLine, remainingPaths)));
}
}
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
LoggerUtilities.ConfigureLogger(env, loggerFactory, Configuration);
app.ConfigureSwagger();
app.UseHttpsRedirection();
app.UseRouting();
//app.UseAuthentication();
//app.UseAuthorization();
app.UseSecurityMiddlewares();
app.UseCorsMiddleware();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
/// <summary>
/// Initializes with the argument that was provided with the command.
/// </summary>
/// <param name="argument">Argument that was provided with the command.</param>
public void Initialize(string argument)
{
string exceptionMessage = string.Format(CultureInfo.CurrentUICulture, CommandLineResources.LoggerUriInvalid, argument);
// Throw error in case logger argument null or empty.
if (string.IsNullOrWhiteSpace(argument))
{
throw new CommandLineException(exceptionMessage);
}
// Get logger argument list.
var loggerArgumentList = ArgumentProcessorUtilities.GetArgumentList(argument, ArgumentProcessorUtilities.SemiColonArgumentSeparator, exceptionMessage);
// Get logger identifier.
var loggerIdentifier = loggerArgumentList[0];
if (loggerIdentifier.Contains("="))
{
throw new CommandLineException(exceptionMessage);
}
// Get logger parameters
var loggerParameterArgs = loggerArgumentList.Skip(1);
var loggerParameters = ArgumentProcessorUtilities.GetArgumentParameters(loggerParameterArgs, ArgumentProcessorUtilities.EqualNameValueSeparator, exceptionMessage);
// Add logger to run settings.
LoggerUtilities.AddLoggerToRunSettings(loggerIdentifier, loggerParameters, runSettingsManager);
}
/// <summary>
/// Save Log to a txt file. File Path needed in app.config
/// </summary>
/// <param name="loglevel">Depends on the severity of the log</param>
/// <param name="message">Any text the user would like to add</param>
/// <param name="exception">Can be null, when logging in trace or debug mode</param>
/// <returns>Boolean for unit test purpose</returns>
private Boolean File(LogObject loglevel, String message, Exception exception = null)
{
Boolean response = false;
try
{
if (message == null || message.Length == 0 || loglevel == null)
{
return(response);
}
LoggerUtilities.GetLogObject(loglevel, message, exception);
String currentPath = String.Format("{0}{1}{2}", MainPath, DateTime.Now.ToShortDateString().Replace("/", "_"), ".txt");
using (StreamWriter logFile = System.IO.File.AppendText(currentPath))
{
String logMessage = LoggerUtilities.FormatLogMessage(loglevel);
logFile.WriteLine(logMessage);
response = true;
}
}
catch (Exception ex)
{
LoggerUtilities.ShowUnexpectedError("file", ex);
}
return(response);
}
private bool RunTests(IRequestData requestData, TestRunCriteria testRunCriteria, ITestRunEventsRegistrar testRunEventsRegistrar)
{
// Make sure to run the run request inside a lock as the below section is not thread-safe
// TranslationLayer can process faster as it directly gets the raw unserialized messages whereas
// below logic needs to deserialize and do some cleanup
// While this section is cleaning up, TranslationLayer can trigger run causing multiple threads to run the below section at the same time
lock (syncobject)
{
bool success = true;
try
{
using (ITestRunRequest testRunRequest = this.testPlatform.CreateTestRunRequest(requestData, testRunCriteria))
{
this.currentTestRunRequest = testRunRequest;
this.runRequestCreatedEventHandle.Set();
try
{
this.testLoggerManager.RegisterTestRunEvents(testRunRequest);
this.testRunResultAggregator.RegisterTestRunEvents(testRunRequest);
testRunEventsRegistrar?.RegisterTestRunEvents(testRunRequest);
this.testPlatformEventSource.ExecutionRequestStart();
testRunRequest.ExecuteAsync();
// Wait for the run completion event
testRunRequest.WaitForCompletion();
}
finally
{
this.testLoggerManager.UnregisterTestRunEvents(testRunRequest);
this.testRunResultAggregator.UnregisterTestRunEvents(testRunRequest);
testRunEventsRegistrar?.UnregisterTestRunEvents(testRunRequest);
}
}
}
catch (Exception ex)
{
EqtTrace.Error("TestRequestManager.RunTests: failed to run tests: {0}", ex);
if (ex is TestPlatformException ||
ex is SettingsException ||
ex is InvalidOperationException)
{
LoggerUtilities.RaiseTestRunError(this.testLoggerManager, this.testRunResultAggregator, ex);
success = false;
}
else
{
throw;
}
}
this.currentTestRunRequest = null;
return(success);
}
}
/// <summary>
/// Returns the given pending change if it should be undone, otherwise null.
/// </summary>
private Task <PendingChange> ShouldUndoPendingChangeAsync(PendingChange pendingChange)
{
return(Task.Run(() =>
{
if (pendingChange.IsAdd || pendingChange.IsDelete || pendingChange.IsLocalItemDelete || pendingChange.IsUndelete)
{
return null;
}
byte[] baseItemHashCode;
try
{
using (var baseFileStream = pendingChange.DownloadBaseFile())
{
using (var hashAlgorithem = new SHA1Cng())
{
baseItemHashCode = hashAlgorithem.ComputeHash(baseFileStream);
}
}
}
catch (Exception ex)
{
const string ErrorMessageFormat = "Error occurred during computing hash for the base item of {0}: {1}";
LoggerUtilities.LogError(string.Format(CultureInfo.CurrentCulture, ErrorMessageFormat, pendingChange.ServerItem, ex.ToString()));
return null;
}
byte[] localItemHashCode;
try
{
using (var localFileStream = new FileStream(Path.GetFullPath(pendingChange.LocalItem), FileMode.Open, FileAccess.Read))
{
using (var hashAlgorithem = new SHA1Cng())
{
localItemHashCode = hashAlgorithem.ComputeHash(localFileStream);
}
}
}
catch (Exception ex)
{
const string ErrorMessageFormat = "Error occurred during computing hash for the local item of {0}: {1}";
LoggerUtilities.LogError(string.Format(CultureInfo.CurrentCulture, ErrorMessageFormat, pendingChange.ServerItem, ex.ToString()));
return null;
}
return Enumerable.SequenceEqual(baseItemHashCode, localItemHashCode) ? pendingChange : null;
}));
}
/// <summary>
/// Initialize blame.
/// </summary>
/// <param name="enableDump">Enable dump.</param>
/// <param name="blameParameters">Blame parameters.</param>
private void InitializeBlame(bool enableDump, Dictionary <string, string> collectDumpParameters)
{
// Add Blame Logger
LoggerUtilities.AddLoggerToRunSettings(BlameFriendlyName, null, this.runSettingsManager);
// Add Blame Data Collector
CollectArgumentExecutor.AddDataCollectorToRunSettings(BlameFriendlyName, this.runSettingsManager, this.fileHelper);
// Add default run settings if required.
if (this.runSettingsManager.ActiveRunSettings?.SettingsXml == null)
{
this.runSettingsManager.AddDefaultRunSettings();;
}
var settings = this.runSettingsManager.ActiveRunSettings?.SettingsXml;
// Get results directory from RunSettingsManager
var resultsDirectory = GetResultsDirectory(settings);
// Get data collection run settings. Create if not present.
var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settings);
if (dataCollectionRunSettings == null)
{
dataCollectionRunSettings = new DataCollectionRunSettings();
}
// Create blame configuration element.
var XmlDocument = new XmlDocument();
var outernode = XmlDocument.CreateElement("Configuration");
var node = XmlDocument.CreateElement("ResultsDirectory");
outernode.AppendChild(node);
node.InnerText = resultsDirectory;
// Add collect dump node in configuration element.
if (enableDump)
{
AddCollectDumpNode(collectDumpParameters, XmlDocument, outernode);
}
// Add blame configuration element to blame collector.
foreach (var item in dataCollectionRunSettings.DataCollectorSettingsList)
{
if (item.FriendlyName.Equals(BlameFriendlyName))
{
item.Configuration = outernode;
}
}
// Update run settings.
runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.DataCollectionRunSettingsName, dataCollectionRunSettings.ToXml().InnerXml);
}
/// <summary>
/// Initializes with the argument that was provided with the command.
/// </summary>
/// <param name="argument">Argument that was provided with the command.</param>
public void Initialize(string argument)
{
if (string.IsNullOrWhiteSpace(argument))
{
HandleInvalidArgument(argument);
}
else
{
string loggerIdentifier = null;
Dictionary <string, string> parameters = null;
var parseSucceeded = LoggerUtilities.TryParseLoggerArgument(argument, out loggerIdentifier, out parameters);
if (parseSucceeded)
{
if (loggerIdentifier.Equals(ConsoleLogger.FriendlyName, StringComparison.OrdinalIgnoreCase))
{
this.loggerManager.AddLogger(new ConsoleLogger(), ConsoleLogger.ExtensionUri, parameters);
}
else
{
// First assume the logger is specified by URI. If that fails try with friendly name.
try
{
this.AddLoggerByUri(loggerIdentifier, parameters);
}
catch (CommandLineException)
{
string loggerUri;
if (this.loggerManager.TryGetUriFromFriendlyName(loggerIdentifier, out loggerUri))
{
this.AddLoggerByUri(loggerUri, parameters);
}
else
{
throw new CommandLineException(
String.Format(
CultureInfo.CurrentUICulture,
CommandLineResources.LoggerNotFound,
argument));
}
}
}
}
else
{
HandleInvalidArgument(argument);
}
}
}
internal static void Log(LogType logType, string message, bool logToConsole = true, bool logToFile = true, bool logToDb = false)
{
if (!_initialized)
{
Console.WriteLine("The logger must be initialized");
return;
}
if (!LoggerUtilities.CanBeLogged(logType))
{
return;
}
Core.Core.Log(logType, message, logToConsole, logToFile, logToDb, _context);
}
private bool RunTests(TestRunCriteria testRunCriteria, ITestRunEventsRegistrar testRunEventsRegistrar)
{
bool success = true;
using (this.currentTestRunRequest = this.testPlatform.CreateTestRunRequest(testRunCriteria))
{
this.runRequestCreatedEventHandle.Set();
try
{
this.testLoggerManager.RegisterTestRunEvents(this.currentTestRunRequest);
this.testRunResultAggregator.RegisterTestRunEvents(this.currentTestRunRequest);
testRunEventsRegistrar?.RegisterTestRunEvents(this.currentTestRunRequest);
this.testPlatformEventSource.ExecutionRequestStart();
this.currentTestRunRequest.ExecuteAsync();
// Wait for the run completion event
this.currentTestRunRequest.WaitForCompletion();
this.testPlatformEventSource.ExecutionRequestStop();
}
catch (Exception ex)
{
if (ex is TestPlatformException ||
ex is SettingsException ||
ex is InvalidOperationException)
{
LoggerUtilities.RaiseTestRunError(this.testLoggerManager, this.testRunResultAggregator, ex);
success = false;
}
else
{
throw;
}
}
finally
{
this.testLoggerManager.UnregisterTestRunEvents(this.currentTestRunRequest);
this.testRunResultAggregator.UnregisterTestRunEvents(this.currentTestRunRequest);
testRunEventsRegistrar?.UnregisterTestRunEvents(this.currentTestRunRequest);
}
}
this.currentTestRunRequest = null;
return(success);
}
public sealed override async Task ExecuteAsync(ProjectItem projectItem)
{
const int MAX_RETRY = 5;
const int E_FAIL = unchecked ((int)0x80004005);
const int RPC_E_CALL_REJECTED = unchecked ((int)0x80010001);
if (projectItem != null)
{
var statusBar = _serviceProvider.GetService(typeof(SVsStatusbar)) as IVsStatusbar;
statusBar.SetText("Updating " + projectItem.get_FileNames(1));
for (int retry = 0; retry < MAX_RETRY; retry++)
{
try
{
projectItem.Document.DTE.ExecuteCommand(_command);
break;
}
catch (Exception ex)
{
if (ex is COMException &&
(((COMException)ex).ErrorCode == E_FAIL || ((COMException)ex).ErrorCode == RPC_E_CALL_REJECTED) &&
retry < MAX_RETRY - 1)
{
await Task.Delay(TimeSpan.FromSeconds(1));
continue;
}
else
{
const string ErrorMessageFormat = "Error occurred during the command {0} running on the item {1}: {2}";
LoggerUtilities.LogError(string.Format(CultureInfo.CurrentCulture, ErrorMessageFormat, _command, projectItem.get_FileNames(1), ex.ToString()));
break;
}
}
}
}
}
/// <summary>
/// Save Log to a database. Settings needed in app.config for connectivity
/// </summary>
/// <param name="loglevel">Depends on the severity of the log</param>
/// <param name="message">Any text the user would like to add</param>
/// <param name="exception">Can be null, when logging in trace or debug mode</param>
/// <returns>Boolean for unit test purpose</returns>
private Boolean Database(LogObject loglevel, String message, Exception exception = null)
{
Boolean response = false;
try
{
if (message == null || message.Length == 0 || loglevel == null)
{
return(response);
}
LoggerUtilities.GetLogObject(loglevel, message, exception);
response = logDao.LogSave(loglevel);
}
catch (Exception ex)
{
LoggerUtilities.ShowUnexpectedError("database", ex);
}
return(response);
}
/// <summary>
/// Show Log in console
/// </summary>
/// <param name="logLevel">Depends on the severity of the log</param>
/// <param name="message">Any text the user would like to add</param>
/// <param name="exception">Can be null, when logging in trace or debug mode</param>
/// <returns>Boolean for unit test purpose</returns>
private Boolean Console(LogObject logLevel, String message, Exception exception = null)
{
Boolean response = false;
try
{
if (message == null || message.Length == 0 || logLevel == null)
{
return(response);
}
LoggerUtilities.GetLogObject(logLevel, message, exception);
String logMessage = LoggerUtilities.FormatLogMessage(logLevel);
System.Console.ForegroundColor = logLevel.Level.Color;
System.Console.WriteLine(logMessage);
response = true;
}
catch (Exception ex)
{
LoggerUtilities.ShowUnexpectedError("console", ex);
}
return(response);
}
/// <summary>
/// Send message for selected log files.
/// </summary>
/// <param name="email"></param>
/// <param name="subject"></param>
/// <param name="text"></param>
/// <param name="selectedFiles"></param>
public static void SendSelectedLogFiles(string email, string subject, string text, List <object> selectedFiles)
{
FileInfo[] filesList = LoggerUtilities.GetSelectedLogFiles(selectedFiles);
SendLogFiles(email, subject, text, filesList);
}
/// <summary>
/// Add logger to runsettings.
/// </summary>
/// <param name="loggerArgument"></param>
/// <param name="runSettingsManager"></param>
public static void AddLoggerToRunSettings(string loggerArgument, IRunSettingsProvider runSettingsManager)
{
if (string.IsNullOrWhiteSpace(loggerArgument))
{
HandleInvalidArgument(loggerArgument);
}
var settings = runSettingsManager.ActiveRunSettings?.SettingsXml;
if (settings == null)
{
runSettingsManager.AddDefaultRunSettings();
settings = runSettingsManager.ActiveRunSettings?.SettingsXml;
}
var loggerRunSettings = XmlRunSettingsUtilities.GetLoggerRunSettings(settings) ?? new LoggerRunSettings();
string loggerIdentifier = null;
Dictionary <string, string> parameters = null;
var parseSucceeded = LoggerUtilities.TryParseLoggerArgument(loggerArgument, out loggerIdentifier, out parameters);
if (parseSucceeded)
{
var logger = default(LoggerSettings);
try
{
// Logger as uri in command line.
var loggerUri = new Uri(loggerIdentifier);
logger = new LoggerSettings
{
Uri = loggerUri,
IsEnabled = true
};
}
catch (UriFormatException)
{
// Logger as friendlyName in command line.
logger = new LoggerSettings
{
FriendlyName = loggerIdentifier,
IsEnabled = true
};
}
// Converting logger console params to Configuration element
if (parameters != null && parameters.Count > 0)
{
var XmlDocument = new XmlDocument();
var outerNode = XmlDocument.CreateElement("Configuration");
foreach (KeyValuePair <string, string> entry in parameters)
{
var node = XmlDocument.CreateElement(entry.Key);
node.InnerText = entry.Value;
outerNode.AppendChild(node);
}
logger.Configuration = outerNode;
}
// Remove existing logger.
var existingLoggerIndex = loggerRunSettings.GetExistingLoggerIndex(logger);
if (existingLoggerIndex >= 0)
{
loggerRunSettings.LoggerSettingsList.RemoveAt(existingLoggerIndex);
}
loggerRunSettings.LoggerSettingsList.Add(logger);
}
else
{
HandleInvalidArgument(loggerArgument);
}
runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.LoggerRunSettingsName, loggerRunSettings.ToXml().InnerXml);
}
private bool UpdateRunSettingsIfRequired(string runsettingsXml, List <string> sources, out string updatedRunSettingsXml)
{
bool settingsUpdated = false;
updatedRunSettingsXml = runsettingsXml;
IDictionary <string, Architecture> sourcePlatforms = new Dictionary <string, Architecture>();
IDictionary <string, Framework> sourceFrameworks = new Dictionary <string, Framework>();
if (!string.IsNullOrEmpty(runsettingsXml))
{
// TargetFramework is full CLR. Set DesignMode based on current context.
using (var stream = new StringReader(runsettingsXml))
using (var reader = XmlReader.Create(stream, XmlRunSettingsUtilities.ReaderSettings))
{
var document = new XmlDocument();
document.Load(reader);
var navigator = document.CreateNavigator();
var inferedFramework = inferHelper.AutoDetectFramework(sources, sourceFrameworks);
Framework chosenFramework;
var inferedPlatform = inferHelper.AutoDetectArchitecture(sources, sourcePlatforms);
Architecture chosenPlatform;
// Update frmaework and platform if required. For commandline scenario update happens in ArgumentProcessor.
bool updateFramework = IsAutoFrameworkDetectRequired(navigator, out chosenFramework);
bool updatePlatform = IsAutoPlatformDetectRequired(navigator, out chosenPlatform);
if (updateFramework)
{
InferRunSettingsHelper.UpdateTargetFramework(document, inferedFramework?.ToString(), overwrite: true);
chosenFramework = inferedFramework;
settingsUpdated = true;
}
if (updatePlatform)
{
InferRunSettingsHelper.UpdateTargetPlatform(document, inferedPlatform.ToString(), overwrite: true);
chosenPlatform = inferedPlatform;
settingsUpdated = true;
}
var compatibleSources = InferRunSettingsHelper.FilterCompatibleSources(chosenPlatform, chosenFramework, sourcePlatforms, sourceFrameworks, out var incompatibleSettingWarning);
if (!string.IsNullOrEmpty(incompatibleSettingWarning))
{
EqtTrace.Info(incompatibleSettingWarning);
LoggerUtilities.RaiseTestRunWarning(this.testLoggerManager, this.testRunResultAggregator, incompatibleSettingWarning);
}
if (EqtTrace.IsInfoEnabled)
{
EqtTrace.Info("Compatible sources list : ");
EqtTrace.Info(string.Join("\n", compatibleSources.ToArray()));
}
// If user is already setting DesignMode via runsettings or CLI args; we skip.
var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(runsettingsXml);
if (!runConfiguration.DesignModeSet)
{
InferRunSettingsHelper.UpdateDesignMode(document, this.commandLineOptions.IsDesignMode);
settingsUpdated = true;
}
if (!runConfiguration.CollectSourceInformationSet)
{
InferRunSettingsHelper.UpdateCollectSourceInformation(document, this.commandLineOptions.ShouldCollectSourceInformation);
settingsUpdated = true;
}
if (InferRunSettingsHelper.TryGetDeviceXml(navigator, out string deviceXml))
{
InferRunSettingsHelper.UpdateTargetDevice(document, deviceXml);
settingsUpdated = true;
}
updatedRunSettingsXml = navigator.OuterXml;
}
}
return(settingsUpdated);
}
/// <summary>
/// Discover Tests given a list of sources, run settings.
/// </summary>
/// <param name="discoveryPayload">Discovery payload</param>
/// <param name="discoveryEventsRegistrar">EventHandler for discovered tests</param>
/// <param name="protocolConfig">Protocol related information</param>
/// <returns>True, if successful</returns>
public bool DiscoverTests(DiscoveryRequestPayload discoveryPayload, ITestDiscoveryEventsRegistrar discoveryEventsRegistrar, ProtocolConfig protocolConfig)
{
EqtTrace.Info("TestRequestManager.DiscoverTests: Discovery tests started.");
bool success = false;
var runsettings = discoveryPayload.RunSettings;
if (discoveryPayload.TestPlatformOptions != null)
{
this.telemetryOptedIn = discoveryPayload.TestPlatformOptions.CollectMetrics;
}
var requestData = this.GetRequestData(protocolConfig);
if (this.UpdateRunSettingsIfRequired(runsettings, discoveryPayload.Sources?.ToList(), out string updatedRunsettings))
{
runsettings = updatedRunsettings;
}
var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(runsettings);
var batchSize = runConfiguration.BatchSize;
if (requestData.IsTelemetryOptedIn)
{
// Collect Metrics
this.CollectMetrics(requestData, runConfiguration);
// Collect Commands
this.LogCommandsTelemetryPoints(requestData);
}
// create discovery request
var criteria = new DiscoveryCriteria(discoveryPayload.Sources, batchSize, this.commandLineOptions.TestStatsEventTimeout, runsettings);
criteria.TestCaseFilter = this.commandLineOptions.TestCaseFilterValue;
try
{
using (IDiscoveryRequest discoveryRequest = this.testPlatform.CreateDiscoveryRequest(requestData, criteria))
{
try
{
this.testLoggerManager?.RegisterDiscoveryEvents(discoveryRequest);
discoveryEventsRegistrar?.RegisterDiscoveryEvents(discoveryRequest);
this.testPlatformEventSource.DiscoveryRequestStart();
discoveryRequest.DiscoverAsync();
discoveryRequest.WaitForCompletion();
success = true;
}
finally
{
this.testLoggerManager?.UnregisterDiscoveryEvents(discoveryRequest);
discoveryEventsRegistrar?.UnregisterDiscoveryEvents(discoveryRequest);
}
}
}
catch (Exception ex)
{
if (ex is TestPlatformException ||
ex is SettingsException ||
ex is InvalidOperationException)
{
LoggerUtilities.RaiseTestRunError(testLoggerManager, null, ex);
success = false;
}
else
{
throw;
}
}
EqtTrace.Info("TestRequestManager.DiscoverTests: Discovery tests completed, successful: {0}.", success);
this.testPlatformEventSource.DiscoveryRequestStop();
// Posts the Discovery Complete event.
this.metricsPublisher.Result.PublishMetrics(TelemetryDataConstants.TestDiscoveryCompleteEvent, requestData.MetricsCollection.Metrics);
return(success);
}
public LoggerDao()
{
_connection = LoggerUtilities.GetConnection();
}
// Delete logs methods
#region DeleteAllLogFiles
/// <summary>
/// Delete all log files.
/// </summary>
public static void DeleteAllLogFiles()
{
FileInfo[] filesList = LoggerUtilities.GetAllLogFiles();
LoggerUtilities.DeleteLogFiles(filesList);
}
/// <summary>
/// Initialize blame.
/// </summary>
/// <param name="enableCrashDump">Enable dump.</param>
/// <param name="blameParameters">Blame parameters.</param>
private void InitializeBlame(bool enableCrashDump, bool enableHangDump, Dictionary <string, string> collectDumpParameters)
{
// Add Blame Logger
LoggerUtilities.AddLoggerToRunSettings(BlameFriendlyName, null, this.runSettingsManager);
// Add Blame Data Collector
CollectArgumentExecutor.AddDataCollectorToRunSettings(BlameFriendlyName, this.runSettingsManager, this.fileHelper);
// Add default run settings if required.
if (this.runSettingsManager.ActiveRunSettings?.SettingsXml == null)
{
this.runSettingsManager.AddDefaultRunSettings();;
}
var settings = this.runSettingsManager.ActiveRunSettings?.SettingsXml;
// Get results directory from RunSettingsManager
var resultsDirectory = GetResultsDirectory(settings);
// Get data collection run settings. Create if not present.
var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settings);
if (dataCollectionRunSettings == null)
{
dataCollectionRunSettings = new DataCollectionRunSettings();
}
// Create blame configuration element.
var XmlDocument = new XmlDocument();
var outernode = XmlDocument.CreateElement("Configuration");
var node = XmlDocument.CreateElement("ResultsDirectory");
outernode.AppendChild(node);
node.InnerText = resultsDirectory;
// Add collect dump node in configuration element.
if (enableCrashDump)
{
var dumpParameters = collectDumpParameters
.Where(p => new[] { "CollectAlways", "DumpType" }.Contains(p.Key))
.ToDictionary(p => p.Key, p => p.Value);
if (!dumpParameters.ContainsKey("DumpType"))
{
dumpParameters.Add("DumpType", "Full");
}
AddCollectDumpNode(dumpParameters, XmlDocument, outernode);
}
// Add collect hang dump node in configuration element.
if (enableHangDump)
{
var hangDumpParameters = collectDumpParameters
.Where(p => new[] { "TestTimeout", "HangDumpType" }.Contains(p.Key))
.ToDictionary(p => p.Key, p => p.Value);
if (!hangDumpParameters.ContainsKey("TestTimeout"))
{
hangDumpParameters.Add("TestTimeout", TimeSpan.FromHours(1).TotalMilliseconds.ToString());
}
if (!hangDumpParameters.ContainsKey("HangDumpType"))
{
hangDumpParameters.Add("HangDumpType", "Full");
}
AddCollectHangDumpNode(hangDumpParameters, XmlDocument, outernode);
}
// Add blame configuration element to blame collector.
foreach (var item in dataCollectionRunSettings.DataCollectorSettingsList)
{
if (item.FriendlyName.Equals(BlameFriendlyName))
{
item.Configuration = outernode;
}
}
// Update run settings.
runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.DataCollectionRunSettingsName, dataCollectionRunSettings.ToXml().InnerXml);
}
/// <summary>
/// Delete selected log files.
/// </summary>
/// <param name="selectedFiles"></param>
public static void DeleteSelectedLogFiles(List <object> selectedFiles)
{
FileInfo[] filesList = LoggerUtilities.GetSelectedLogFiles(selectedFiles);
LoggerUtilities.DeleteLogFiles(filesList);
}
/// <summary>
/// Delete log files, older than specified date.
/// </summary>
/// <param name="olderThanDate"></param>
public static void DeleteOlderLogFiles(DateTime olderThanDate)
{
FileInfo[] filesList = LoggerUtilities.GetOlderLogFiles(olderThanDate);
LoggerUtilities.DeleteLogFiles(filesList);
}
/// <summary>
/// Send message for log files, older than specified date.
/// </summary>
/// <param name="email"></param>
/// <param name="subject"></param>
/// <param name="text"></param>
/// <param name="olderThanDate"></param>
public static void SendOlderLogFiles(string email, string subject, string text, DateTime olderThanDate)
{
FileInfo[] filesList = LoggerUtilities.GetOlderLogFiles(olderThanDate);
SendLogFiles(email, subject, text, filesList);
}
// Send logs methods
#region SendAllLogFiles
/// <summary>
/// Send message for all log files.
/// </summary>
/// <param name="email"></param>
/// <param name="subject"></param>
/// <param name="text"></param>
public static void SendAllLogFiles(string email, string subject, string text)
{
FileInfo[] filesList = LoggerUtilities.GetAllLogFiles();
SendLogFiles(email, subject, text, filesList);
}
