/// <summary>
/// Called when an event is found.
/// </summary>
/// <param name="sender">The task manager reporting the event.</param>
/// <param name="e">The event arguments.</param>
private void processEvent(Object sender, ErrorIndexParseEventsEventArgs e)
{
StackHashEvent currentEvent = e.Parser.CurrentEvent;
// Which purge options should be used for this event.
StackHashPurgeOptions purgeOptions = findPurgeOptions(e.Parser.Product, e.Parser.File, e.Parser.CurrentEvent);
if (purgeOptions != null)
{
// Now purge according to the policy specified.
purgeEvent(e.Parser.Product, e.Parser.File, e.Parser.CurrentEvent, purgeOptions);
}
}
public void SaveLoadSettings()
{
StackHashSettings settings = new StackHashSettings();
settings.ContextCollection = new StackHashContextCollection();
settings.ProxySettings = new StackHashProxySettings(true, true, "host", 9000, "UserName", "Password", "Domain");
StackHashContextSettings context1 = new StackHashContextSettings();
context1.CabFilePurgeSchedule = new ScheduleCollection();
context1.CabFilePurgeSchedule.Add(new Schedule());
context1.CabFilePurgeSchedule[0].DaysOfWeek = DaysOfWeek.Monday;
context1.CabFilePurgeSchedule[0].Period = SchedulePeriod.Hourly;
context1.CabFilePurgeSchedule[0].Time = new ScheduleTime(1, 2, 3);
context1.ErrorIndexSettings = new ErrorIndexSettings();
context1.ErrorIndexSettings.Folder = "C:\\test1";
context1.ErrorIndexSettings.Name = "Name1";
context1.ErrorIndexSettings.Type = ErrorIndexType.Xml;
context1.Id = 1;
StackHashProductSyncDataCollection productsToSync = new StackHashProductSyncDataCollection();
productsToSync.Add(new StackHashProductSyncData(23));
context1.WinQualSettings = new WinQualSettings("username", "password", "cucku", 90, productsToSync, true, 30 * 60, 1,
WinQualSettings.DefaultSyncsBeforeResync, true);
context1.WinQualSyncSchedule = new ScheduleCollection();
context1.WinQualSyncSchedule.Add(new Schedule());
context1.WinQualSyncSchedule[0].DaysOfWeek = DaysOfWeek.Tuesday;
context1.WinQualSyncSchedule[0].Period = SchedulePeriod.Weekly;
context1.WinQualSyncSchedule[0].Time = new ScheduleTime(4, 5, 6);
context1.DebuggerSettings = new StackHashDebuggerSettings();
context1.DebuggerSettings.BinaryPath = new StackHashSearchPath();
context1.DebuggerSettings.BinaryPath.Add("C:\\Binary");
context1.DebuggerSettings.BinaryPath.Add("C:\\Path");
context1.DebuggerSettings.SymbolPath = new StackHashSearchPath();
context1.DebuggerSettings.SymbolPath.Add("C:\\Symbol");
context1.DebuggerSettings.SymbolPath.Add("C:\\Path2");
context1.DebuggerSettings.BinaryPath64Bit = new StackHashSearchPath();
context1.DebuggerSettings.BinaryPath64Bit.Add("C:\\Binary64");
context1.DebuggerSettings.BinaryPath64Bit.Add("C:\\Path64");
context1.DebuggerSettings.SymbolPath64Bit = new StackHashSearchPath();
context1.DebuggerSettings.SymbolPath64Bit.Add("C:\\Symbol64");
context1.DebuggerSettings.SymbolPath64Bit.Add("C:\\Path264");
context1.DebuggerSettings.DebuggerPathAndFileName = "C:\\debugger64.exe";
context1.DebuggerSettings.DebuggerPathAndFileName64Bit = "C:\\debugger64.exe";
context1.PurgeOptionsCollection = new StackHashPurgeOptionsCollection();
context1.BugTrackerSettings = new StackHashBugTrackerPlugInSettings();
context1.BugTrackerSettings.PlugInSettings = new StackHashBugTrackerPlugInCollection();
context1.BugTrackerSettings.PlugInSettings.Add(new StackHashBugTrackerPlugIn());
context1.BugTrackerSettings.PlugInSettings[0].Enabled = true;
context1.BugTrackerSettings.PlugInSettings[0].Name = "TestPlugIn";
context1.BugTrackerSettings.PlugInSettings[0].Properties = new StackHashNameValueCollection();
context1.BugTrackerSettings.PlugInSettings[0].Properties.Add(new StackHashNameValuePair("Name1", "Value1"));
context1.BugTrackerSettings.PlugInSettings[0].Properties.Add(new StackHashNameValuePair("Longer name with spaces", "Longer text la la la la la "));
context1.BugTrackerSettings.PlugInSettings[0].Properties.Add(new StackHashNameValuePair("$pec1al &^%$&\"£! mbols", "Hehhijugiuyhg*(&^%*&^%"));
StackHashPurgeOptions purgeOptions = new StackHashPurgeOptions();
purgeOptions.Id = 22;
purgeOptions.AgeToPurge = 90;
purgeOptions.PurgeCabFiles = true;
purgeOptions.PurgeDumpFiles = true;
purgeOptions.PurgeObject = StackHashPurgeObject.PurgeFile;
context1.PurgeOptionsCollection.Add(purgeOptions);
settings.ContextCollection.Add(context1);
// Now save the settings to an XML file.
string tempFile = m_TempPath + "\\testsettings.xml";
StackHashSettings.Save(settings, tempFile);
// Now load the new settings and compare them.
StackHashSettings loadedSettings = StackHashSettings.Load(tempFile);
Assert.AreEqual(settings.ProxySettings.UseProxy, loadedSettings.ProxySettings.UseProxy);
Assert.AreEqual(settings.ProxySettings.UseProxyAuthentication, loadedSettings.ProxySettings.UseProxyAuthentication);
Assert.AreEqual(settings.ProxySettings.ProxyHost, loadedSettings.ProxySettings.ProxyHost);
Assert.AreEqual(settings.ProxySettings.ProxyPort, loadedSettings.ProxySettings.ProxyPort);
Assert.AreEqual(settings.ProxySettings.ProxyDomain, loadedSettings.ProxySettings.ProxyDomain);
Assert.AreEqual(settings.ProxySettings.ProxyUserName, loadedSettings.ProxySettings.ProxyUserName);
Assert.AreEqual(settings.ProxySettings.ProxyPassword, loadedSettings.ProxySettings.ProxyPassword);
Assert.AreEqual(settings.ContextCollection.Count, loadedSettings.ContextCollection.Count);
for (int i = 0; i < settings.ContextCollection.Count; i++)
{
StackHashContextSettings contextOriginal = settings.ContextCollection[i];
StackHashContextSettings contextLoaded = loadedSettings.ContextCollection[i];
Assert.AreEqual(contextOriginal.CabFilePurgeSchedule.Count, contextLoaded.CabFilePurgeSchedule.Count);
for (int j = 0; j < contextOriginal.CabFilePurgeSchedule.Count; j++)
{
Schedule scheduleOriginal = settings.ContextCollection[i].CabFilePurgeSchedule[0];
Schedule scheduleLoaded = loadedSettings.ContextCollection[i].CabFilePurgeSchedule[0];
Assert.AreEqual(scheduleOriginal.DaysOfWeek, scheduleLoaded.DaysOfWeek);
Assert.AreEqual(scheduleOriginal.Period, scheduleLoaded.Period);
Assert.AreEqual(scheduleOriginal.Time.Hour, scheduleLoaded.Time.Hour);
Assert.AreEqual(scheduleOriginal.Time.Minute, scheduleLoaded.Time.Minute);
Assert.AreEqual(scheduleOriginal.Time.Second, scheduleLoaded.Time.Second);
}
Assert.AreEqual(contextOriginal.ErrorIndexSettings.Folder, contextLoaded.ErrorIndexSettings.Folder);
Assert.AreEqual(contextOriginal.ErrorIndexSettings.Name, contextLoaded.ErrorIndexSettings.Name);
Assert.AreEqual(contextOriginal.ErrorIndexSettings.Type, contextLoaded.ErrorIndexSettings.Type);
Assert.AreEqual(contextOriginal.Id, contextLoaded.Id);
Assert.AreEqual(contextOriginal.WinQualSettings.CompanyName, contextLoaded.WinQualSettings.CompanyName);
Assert.AreEqual(contextOriginal.WinQualSettings.Password, contextLoaded.WinQualSettings.Password);
Assert.AreEqual(contextOriginal.WinQualSettings.UserName, contextLoaded.WinQualSettings.UserName);
Assert.AreEqual(1, contextOriginal.WinQualSettings.ProductsToSynchronize.Count);
Assert.AreEqual(23, contextOriginal.WinQualSettings.ProductsToSynchronize[0].ProductId);
Assert.AreEqual(true, contextOriginal.WinQualSettings.EnableNewProductsAutomatically);
Assert.AreEqual(contextOriginal.WinQualSyncSchedule.Count, contextLoaded.WinQualSyncSchedule.Count);
for (int j = 0; j < contextOriginal.CabFilePurgeSchedule.Count; j++)
{
Schedule scheduleOriginal = settings.ContextCollection[i].CabFilePurgeSchedule[0];
Schedule scheduleLoaded = loadedSettings.ContextCollection[i].CabFilePurgeSchedule[0];
Assert.AreEqual(scheduleOriginal.DaysOfWeek, scheduleLoaded.DaysOfWeek);
Assert.AreEqual(scheduleOriginal.Period, scheduleLoaded.Period);
Assert.AreEqual(scheduleOriginal.Time.Hour, scheduleLoaded.Time.Hour);
Assert.AreEqual(scheduleOriginal.Time.Minute, scheduleLoaded.Time.Minute);
Assert.AreEqual(scheduleOriginal.Time.Second, scheduleLoaded.Time.Second);
}
Assert.AreEqual(contextOriginal.DebuggerSettings.DebuggerPathAndFileName, contextLoaded.DebuggerSettings.DebuggerPathAndFileName);
Assert.AreEqual(contextOriginal.DebuggerSettings.BinaryPath[0], contextLoaded.DebuggerSettings.BinaryPath[0]);
Assert.AreEqual(contextOriginal.DebuggerSettings.BinaryPath[1], contextLoaded.DebuggerSettings.BinaryPath[1]);
Assert.AreEqual(contextOriginal.DebuggerSettings.SymbolPath[0], contextLoaded.DebuggerSettings.SymbolPath[0]);
Assert.AreEqual(contextOriginal.DebuggerSettings.SymbolPath[1], contextLoaded.DebuggerSettings.SymbolPath[1]);
Assert.AreEqual(contextOriginal.DebuggerSettings.DebuggerPathAndFileName64Bit, contextLoaded.DebuggerSettings.DebuggerPathAndFileName64Bit);
Assert.AreEqual(contextOriginal.DebuggerSettings.BinaryPath64Bit[0], contextLoaded.DebuggerSettings.BinaryPath64Bit[0]);
Assert.AreEqual(contextOriginal.DebuggerSettings.BinaryPath64Bit[1], contextLoaded.DebuggerSettings.BinaryPath64Bit[1]);
Assert.AreEqual(contextOriginal.DebuggerSettings.SymbolPath64Bit[0], contextLoaded.DebuggerSettings.SymbolPath64Bit[0]);
Assert.AreEqual(contextOriginal.DebuggerSettings.SymbolPath64Bit[1], contextLoaded.DebuggerSettings.SymbolPath64Bit[1]);
Assert.AreEqual(contextOriginal.PurgeOptionsCollection.Count, contextLoaded.PurgeOptionsCollection.Count);
int purgeOptionIndex = 0;
foreach (StackHashPurgeOptions oldPurgeOptions in contextOriginal.PurgeOptionsCollection)
{
StackHashPurgeOptions loadedPurgeOptions = contextLoaded.PurgeOptionsCollection[purgeOptionIndex++];
Assert.AreEqual(oldPurgeOptions.Id, loadedPurgeOptions.Id);
Assert.AreEqual(oldPurgeOptions.AgeToPurge, loadedPurgeOptions.AgeToPurge);
Assert.AreEqual(oldPurgeOptions.PurgeCabFiles, loadedPurgeOptions.PurgeCabFiles);
Assert.AreEqual(oldPurgeOptions.PurgeDumpFiles, loadedPurgeOptions.PurgeDumpFiles);
Assert.AreEqual(oldPurgeOptions.PurgeObject, loadedPurgeOptions.PurgeObject);
}
if (contextOriginal.BugTrackerSettings != null)
{
for (int j = 0; j < contextOriginal.BugTrackerSettings.PlugInSettings.Count; j++)
{
StackHashBugTrackerPlugIn bugTrackerSettings = contextOriginal.BugTrackerSettings.PlugInSettings[j];
Assert.AreEqual(contextOriginal.BugTrackerSettings.PlugInSettings[j].Enabled, bugTrackerSettings.Enabled);
for (int k = 0; k < bugTrackerSettings.Properties.Count; k++)
{
Assert.AreEqual(contextOriginal.BugTrackerSettings.PlugInSettings[j].Properties[k],
bugTrackerSettings.Properties[k]);
}
}
}
}
}
/// <summary>
/// Finds the appropriate purge options for the specified product, file, event.
/// </summary>
/// <param name="product">The product owning the event.</param>
/// <param name="file">The file owning the event.</param>
/// <param name="theEvent">The event to be purged.</param>
/// <returns>Options to use for purge.</returns>
private StackHashPurgeOptions findPurgeOptions(StackHashProduct product, StackHashFile file, StackHashEvent theEvent)
{
StackHashPurgeOptions globalPurgeOptions = null;
StackHashPurgeOptions productPurgeOptions = null;
StackHashPurgeOptions filePurgeOptions = null;
StackHashPurgeOptions eventPurgeOptions = null;
foreach (StackHashPurgeOptions purgeOptions in m_TaskParameters.PurgeOptions)
{
switch (purgeOptions.PurgeObject)
{
case StackHashPurgeObject.PurgeGlobal:
globalPurgeOptions = purgeOptions;
break;
case StackHashPurgeObject.PurgeProduct:
if (purgeOptions.Id == product.Id)
{
productPurgeOptions = purgeOptions;
}
break;
case StackHashPurgeObject.PurgeFile:
if (purgeOptions.Id == file.Id)
{
filePurgeOptions = purgeOptions;
}
break;
case StackHashPurgeObject.PurgeEvent:
if (purgeOptions.Id == theEvent.Id)
{
eventPurgeOptions = purgeOptions;
}
break;
default:
throw new InvalidOperationException("Purge option not known");
}
}
// Prioritize from event up.
if (eventPurgeOptions != null)
{
return(eventPurgeOptions);
}
else if (filePurgeOptions != null)
{
return(filePurgeOptions);
}
else if (productPurgeOptions != null)
{
return(productPurgeOptions);
}
else if (globalPurgeOptions != null)
{
return(globalPurgeOptions);
}
else
{
return(null);
}
}
private void purgeEvent(StackHashProduct product, StackHashFile file, StackHashEvent theEvent, StackHashPurgeOptions purgeOptions)
{
IErrorIndex errorIndex = m_TaskParameters.ErrorIndex;
// Get a list of all cabs for the event.
StackHashCabCollection cabs = errorIndex.LoadCabList(product, file, theEvent);
bool error = false;
foreach (StackHashCab cab in cabs)
{
String cabFileFolder = errorIndex.GetCabFolder(product, file, theEvent, cab);
// Check if anything to purge.
if (!Directory.Exists(cabFileFolder))
{
continue;
}
// Don't purge if files not that old.
int daysOld = (DateTime.Now.ToUniversalTime() - cab.DateCreatedLocal).Days;
if (daysOld < purgeOptions.AgeToPurge)
{
continue;
}
if (purgeOptions.PurgeDumpFiles)
{
String[] dumpFiles = Directory.GetFiles(cabFileFolder, "*.*dmp*");
foreach (String dumpFile in dumpFiles)
{
try
{
// Update the statistics.
FileInfo fileInfo = new FileInfo(dumpFile);
m_Statistics.NumberOfDumpFiles++;
m_Statistics.DumpFilesTotalSize += fileInfo.Length;
DiagnosticsHelper.LogMessage(DiagSeverity.Information,
String.Format(CultureInfo.InvariantCulture, "Purged File {0}, {1}, {2}, {3}, {4}", dumpFile, product.Id, file.Id, theEvent.Id, cab.Id));
File.Delete(dumpFile);
}
catch (System.Exception ex)
{
error = true;
DiagnosticsHelper.LogException(DiagSeverity.Warning, "Failed to purge dump file " + dumpFile, ex);
}
}
}
if (purgeOptions.PurgeCabFiles)
{
String cabFileName = errorIndex.GetCabFileName(product, file, theEvent, cab);
if (File.Exists(cabFileName))
{
try
{
// Update the statistics.
FileInfo fileInfo = new FileInfo(cabFileName);
m_Statistics.NumberOfCabs++;
m_Statistics.CabsTotalSize += fileInfo.Length;
DiagnosticsHelper.LogMessage(DiagSeverity.Information,
String.Format(CultureInfo.InvariantCulture, "Purged Cab File {0}, {1}, {2}, {3}, {4}", cabFileName, product.Id, file.Id, theEvent.Id, cab.Id));
File.Delete(cabFileName);
}
catch (System.Exception ex)
{
error = true;
DiagnosticsHelper.LogException(DiagSeverity.Warning, "Failed to purge cab file " + cabFileName, ex);
}
}
}
if (!error)
{
// Mark the cab as purged and no longer downloaded.
cab.Purged = true;
cab.CabDownloaded = false;
errorIndex.AddCab(product, file, theEvent, cab, false);
}
}
}
