/// <summary>
/// This method is called when the processing of an Event has completed. Events have associated Cabs, Scripts and notes which
/// may all be reported during a MANUAL Bug Report. This call effectively delimits the reporting of all
/// information associated with an event so, if desired, the plug-in can gather all of the information together in one
/// go for sending to the fault database. This may improve performance for events with large amounts of stored data.
///
/// The plug-in may thus see...
/// EventAdded
/// EventNoteAdded, EventNoteAdded,...
/// CabAdded, CabAdded,...
/// CabNoteAdded, CabNoteAdded,...
/// ScriptResultAdded, ScriptResultAdded,...
/// EventManualUpdateCompleted.
///
/// A Plugin Bug Reference is stored with the Event data in the StackHash database. This can be manually changed
/// by the StackHash client user. The plug-in can also change the plugin bug reference by returning the desired
/// bug reference from this call.
/// Return null if you do NOT want to change the bug reference stored in the StackHash database.
/// Return any other string (including an empty string) and this value will be used to overwrite the
/// plugin bug reference in the StackHash database.
/// Note that there are 2 bug references:
/// The BugReference can be set by the StackHash client user manually. This cannot be changed by the plugin.
/// The PlugInBugReference can be set by the StackHash client user manually AND/OR set by the plugin.
///
/// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync
/// is happening at the same time as a manual report is requested.
/// </summary>
/// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param>
/// <param name="product">The product to which the file belongs.</param>
/// <param name="file">The file to which the event belongs.</param>
/// <param name="theEvent">The event whose details have now been reported.</param>
/// <returns>Null - if the plugin bug reference in the StackHash database should not be changed, Otherwise the new value for the plugin bug reference.</returns>
public string EventManualUpdateCompleted(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent)
{
if (m_disposed)
{
throw new ObjectDisposedException("EmailPluginContext");
}
if (product == null)
{
throw new ArgumentNullException("product");
}
if (file == null)
{
throw new ArgumentNullException("file");
}
if (theEvent == null)
{
throw new ArgumentNullException("theEvent");
}
// Don't change the plugin bug reference. Setting this to any other value will update the plugin bug reference in the
// StackHash database.
String pluginBugReference = null;
return(pluginBugReference);
}
/// <summary>
/// If the report type is automatic then this call indicates that an Event note has been added to the
/// StackHash database by a StackHash client.
///
/// If the report type is manual then this call indicates that an Event note already exists in the
/// StackHash database. This is the result of a BugReport task being run.
///
/// Note that it is possible that the event note existence has already been reported, so the
/// code here should check, if necessary, that this is not a duplicate before creating new items in
/// the destination bug tracking system.
///
/// Important Note: AN EVENT IS IDENTIFIED BY ITS ID AND EVENTTYPENAME TOGETHER. Therefore it is possible to
/// have events with the same ID but different EventTypeName.
///
/// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync
/// is happening at the same time as a manual report is requested.
///
/// A Plugin Bug Reference is stored with the Event data in the StackHash database. This can be manually changed
/// by the StackHash client user. The plug-in can also change the plugin bug reference by returning the desired
/// bug reference from this call.
/// Return null if you do NOT want to change the bug reference stored in the StackHash database.
/// Return any other string (including an empty string) and this value will be used to overwrite the
/// plugin bug reference in the StackHash database.
/// Note that there are 2 bug references:
/// The BugReference can be set by the StackHash client user manually. This cannot be changed by the plugin.
/// The PlugInBugReference can be set by the StackHash client user manually AND/OR set by the plugin.
/// </summary>
/// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param>
/// <param name="product">The product to which the file belongs.</param>
/// <param name="file">The file to which the event belongs.</param>
/// <param name="theEvent">The event to which the note belongs.</param>
/// <param name="note">The event note to add.</param>
/// <returns>Null - if the plugin bug reference in the StackHash database should not be changed, Otherwise the new value for the plugin bug reference.</returns>
public string EventNoteAdded(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent, BugTrackerNote note)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
if (file == null)
{
throw new ArgumentNullException("file");
}
if (theEvent == null)
{
throw new ArgumentNullException("theEvent");
}
if (note == null)
{
throw new ArgumentNullException("note");
}
// Note that all of the interface objects have a built in ToString() which formats the fields suitably.
BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, m_Control.PlugInName, "Event Note Added: " + note.ToString());
// Don't change the bug reference.
return(null);
}
public string EventAdded(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
if (file == null)
{
throw new ArgumentNullException("file");
}
if (theEvent == null)
{
throw new ArgumentNullException("theEvent");
}
m_EventAddedCount++;
String bugId = theEvent.BugReference;
if (m_Properties["SetBugId"] == "True")
{
bugId = "TestPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture);
}
BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, s_PlugInName, "Event Added: " + theEvent.ToString());
return(bugId);
}
public void ScriptResultsAddedNullScriptData()
{
IBugTrackerV1Control plugInControl = new FaultDatabaseControl();
Assert.AreNotEqual(null, plugInControl);
IBugTrackerV1Context context = plugInControl.CreateContext();
Assert.AreNotEqual(null, context);
Assert.AreEqual(1, GetNumberOfActiveProfiles(plugInControl));
BugTrackerProduct product = new BugTrackerProduct("StackHash", "1.2.3.4", 1234568);
BugTrackerFile file = new BugTrackerFile("StackHash.dll", "1.2.3.4", 234567);
BugTrackerEvent theEvent = new BugTrackerEvent("Reference", "Plugin bug ref", 1111111, "CLR20 - Crash", 122, new NameValueCollection());
theEvent.Signature["Exception"] = "0x23434";
BugTrackerCab cab = new BugTrackerCab(12243, 12121, false, true, new NameValueCollection(), "c:\\test\\my.cab");
cab.AnalysisData["New1"] = "Data1";
cab.AnalysisData["New2"] = "Data2";
BugTrackerScriptResult result = new BugTrackerScriptResult("ScriptName", 1, DateTime.Now, DateTime.Now, null);
context.DebugScriptExecuted(BugTrackerReportType.Automatic, product, file, theEvent, cab, result);
plugInControl.ReleaseContext(context);
Assert.AreEqual(0, GetNumberOfActiveProfiles(plugInControl));
}
/// <summary>
/// Processes a specific product.
/// </summary>
private void processProduct(StackHashBugReportData request, StackHashProduct product)
{
if (this.CurrentTaskState.AbortRequested)
{
throw new OperationCanceledException("Reporting events to Bug Tracker plug-ins");
}
BugTrackerProduct btProduct = new BugTrackerProduct(product.Name, product.Version, product.Id);
if (((request.Options & StackHashReportOptions.IncludeProducts) != 0) ||
((request.Options & StackHashReportOptions.IncludeAllObjects) != 0))
{
m_TaskParameters.PlugInContext.ProductAdded(m_PlugIns, m_ReportType, btProduct);
checkPlugInStatus(m_PlugIns);
}
if (request.File == null)
{
StackHashFileCollection allFiles = m_Index.LoadFileList(product);
foreach (StackHashFile file in allFiles)
{
processFile(request, product, file);
}
}
else
{
StackHashFile file = m_Index.GetFile(product, request.File.Id);
if (file != null)
{
processFile(request, product, file);
}
}
}
/// <summary>
/// If the report type is automatic then this call indicates that a Debug Script Result has been added to the
/// StackHash database by way the Cab Analysis task running or the StackHash client manually running a script
/// on a cab.
///
/// If the report type is manual then this call indicates that an Debug Script Result already exists in the
/// StackHash database. This is the result of a BugReport task being run.
///
/// scriptResult.ToString() can be used to format the string for addition to a Fault Database system.
///
/// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync
/// is happening at the same time as a manual report is requested.
///
/// A Plugin Bug Reference is stored with the Event data in the StackHash database. This can be manually changed
/// by the StackHash client user. The plug-in can also change the plugin bug reference by returning the desired
/// bug reference from this call.
/// Return null if you do NOT want to change the bug reference stored in the StackHash database.
/// Return any other string (including an empty string) and this value will be used to overwrite the
/// plugin bug reference in the StackHash database.
/// Note that there are 2 bug references:
/// The BugReference can be set by the StackHash client user manually. This cannot be changed by the plugin.
/// The PlugInBugReference can be set by the StackHash client user manually AND/OR set by the plugin.
/// </summary>
/// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param>
/// <param name="product">The product to which the file belongs.</param>
/// <param name="file">The file to which the event belongs.</param>
/// <param name="theEvent">The event to which the cab belongs.</param>
/// <param name="cab">The cab to which the debug script result belongs.</param>
/// <param name="scriptResult">The result of running a debug script on the cab dump file.</param>
/// <returns>Null - if the plugin bug reference in the StackHash database should not be changed, Otherwise the new value for the plugin bug reference.</returns>
public string DebugScriptExecuted(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent, BugTrackerCab cab, BugTrackerScriptResult scriptResult)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
if (file == null)
{
throw new ArgumentNullException("file");
}
if (theEvent == null)
{
throw new ArgumentNullException("theEvent");
}
if (cab == null)
{
throw new ArgumentNullException("cab");
}
if (scriptResult == null)
{
throw new ArgumentNullException("scriptResult");
}
// Note that all of the interface objects have a built in ToString() which formats the fields suitably.
BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, m_Control.PlugInName, "Debug Script Added: " + scriptResult.ToString());
// Don't change the plugin bug reference.
return(null);
}
public string EventNoteAdded(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent, BugTrackerNote note)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
if (file == null)
{
throw new ArgumentNullException("file");
}
if (theEvent == null)
{
throw new ArgumentNullException("theEvent");
}
if (note == null)
{
throw new ArgumentNullException("note");
}
m_LastEventNote = note.Note;
BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, s_PlugInName, "Event Note Added: " + note.ToString());
// If the SetBugId is set then the plugin should have set the bug reference so subsequent calls using that event should
// also contain the bug reference.
if (m_Properties["SetBugId"] == "True")
{
if (theEvent.PlugInBugReference != "TestPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture))
{
throw new ArgumentException("Bug ref not set", "theEvent");
}
}
m_EventNoteAddedCount++;
return(null);
}
public string CabAdded(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent, BugTrackerCab cab)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
if (file == null)
{
throw new ArgumentNullException("file");
}
if (theEvent == null)
{
throw new ArgumentNullException("theEvent");
}
if (cab == null)
{
throw new ArgumentNullException("cab");
}
if (cab.CabPathAndFileName == null)
{
throw new ArgumentException("Cab path is null", "cab");
}
BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, s_PlugInName, "Cab Added: " + cab.ToString());
// If the SetBugId is set then the plugin should have set the bug reference so subsequent calls using that event should
// also contain the bug reference.
if (m_Properties["SetBugId"] == "True")
{
if (theEvent.PlugInBugReference != "TestPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture))
{
throw new ArgumentException("Bug ref not set", "theEvent");
}
}
String bugId = null;
if (m_Properties["CabAddedSetBugId"] == "True")
{
bugId = "TestCabAddedPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture);
}
if ((m_Properties["ManualCabAddedSetBugId"] == "True") && (reportType != BugTrackerReportType.Automatic))
{
if (m_CabsPerEvent.ContainsKey(theEvent.EventId))
{
if (!theEvent.PlugInBugReference.StartsWith("ManualCabAddedSetBugId", StringComparison.OrdinalIgnoreCase))
{
throw new ArgumentException("Plug-in bug reference should be set already", "theEvent");
}
m_CabsPerEvent[theEvent.EventId]++;
}
else
{
m_CabsPerEvent[theEvent.EventId] = 1;
}
bugId = "ManualCabAddedSetBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture);
}
m_CabAddedCount++;
return(bugId);
}
/// <summary>
/// Process a file table update. This may indicate a new item or the change to an existing item.
/// </summary>
private bool processFileUpdate(StackHashBugTrackerUpdate update)
{
// Get the associated product and file information.
StackHashProduct product = m_Index.GetProduct((int)update.ProductId);
StackHashFile file = m_Index.GetFile(product, (int)update.FileId);
if (product == null)
{
DiagnosticsHelper.LogMessage(DiagSeverity.Warning, "Processing File: Inconsistent Update Table Entry = product not found: " + update.ProductId.ToString(CultureInfo.InvariantCulture));
return(false);
}
if (file == null)
{
DiagnosticsHelper.LogMessage(DiagSeverity.Warning, "Processing File: Inconsistent Update Table Entry = file not found: " + update.FileId.ToString(CultureInfo.InvariantCulture));
return(false);
}
BugTrackerProduct btProduct = new BugTrackerProduct(product.Name, product.Version, product.Id);
BugTrackerFile btFile = new BugTrackerFile(file.Name, file.Version, file.Id);
if (update.TypeOfChange == StackHashChangeType.NewEntry)
{
m_TaskParameters.PlugInContext.FileAdded(null, BugTrackerReportType.Automatic, btProduct, btFile);
}
else
{
m_TaskParameters.PlugInContext.FileUpdated(null, BugTrackerReportType.Automatic, btProduct, btFile);
}
return(true);
}
public void ProductAdded(BugTrackerReportType reportType, BugTrackerProduct product)
{
m_ProductAddedCount++;
if (product == null)
{
throw new ArgumentNullException("product");
}
if (m_Properties["ProductAddedException"] != null)
{
throw new ArgumentException("Test exception");
}
if (m_Properties["UnhandledException"] != null)
{
// Spawn a new thread to cause the exception.
Thread exceptionThread = new Thread(delegate()
{
throw new ArgumentException("Thread exception");
});
exceptionThread.Start();
Thread.Sleep(2000);
return;
}
BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, s_PlugInName, "Product Added: " + product.ToString());
}
public void ProductToString()
{
BugTrackerProduct product = new BugTrackerProduct("StackHash", "1.2.3.4", 12345678);
String result = product.ToString();
Assert.AreEqual("Product: Id=12345678, Name=StackHash, Version=1.2.3.4\r\n", result);
}
/// <summary>
/// If the report type is automatic then this call indicates that a Product has been changed in the
/// StackHash database by way of a Synchronize with the WinQual web site.
/// The change may include the number of events stored has increased.
///
/// This method is not currently called for manual reports.
///
/// Note that it is possible that an Updated is reported when no Added has been invoked. This can happen if the
/// plug-in has been installed after the StackHash database has been created. Performing a manual Bug Report of
/// the entire database when the plug-in is installed will limit the likelihood of this case.
///
/// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync
/// is happening at the same time as a manual report is requested.
/// </summary>
/// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param>
/// <param name="product">The product being updated.</param>
public void ProductUpdated(BugTrackerReportType reportType, BugTrackerProduct product)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
// Note that all of the interface objects have a built in ToString() which formats the fields suitably.
BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, m_Control.PlugInName, "Product Updated: " + product.ToString());
}
/// <summary>
/// If the report type is automatic then this call indicates that a Product has been changed in the
/// StackHash database by way of a Synchronize with the WinQual web site.
/// The change may include the number of events stored has increased.
///
/// This method is not currently called for manual reports.
///
/// Note that it is possible that an Updated is reported when no Added has been invoked. This can happen if the
/// plug-in has been installed after the StackHash database has been created. Performing a manual Bug Report of
/// the entire database when the plug-in is installed will limit the likelihood of this case.
///
/// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync
/// is happening at the same time as a manual report is requested.
/// </summary>
/// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param>
/// <param name="product">The product being updated.</param>
public void ProductUpdated(BugTrackerReportType reportType, BugTrackerProduct product)
{
if (m_disposed)
{
throw new ObjectDisposedException("EmailPluginContext");
}
if (product == null)
{
throw new ArgumentNullException("product");
}
}
public string CabNoteAdded(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent, BugTrackerCab cab, BugTrackerNote note)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
if (file == null)
{
throw new ArgumentNullException("file");
}
if (theEvent == null)
{
throw new ArgumentNullException("theEvent");
}
if (cab == null)
{
throw new ArgumentNullException("cab");
}
if (note == null)
{
throw new ArgumentNullException("note");
}
if (cab.CabPathAndFileName == null)
{
throw new ArgumentException("Cab path is null", "cab");
}
m_LastCabNote = note.Note;
BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, s_PlugInName, "Cab Note Added: " + note.ToString());
// If the SetBugId is set then the plugin should have set the bug reference so subsequent calls using that event should
// also contain the bug reference.
if (m_Properties["SetBugId"] == "True")
{
if (theEvent.PlugInBugReference != "TestPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture))
{
throw new ArgumentException("Bug ref not set", "theEvent");
}
}
m_CabNoteAddedCount++;
String bugId = null;
if (m_Properties["CabNoteAddedBugId"] == "True")
{
bugId = "TestCabNoteAddedPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture);
}
if ((m_Properties["ManualCabAddedSetBugId"] == "True") && (reportType != BugTrackerReportType.Automatic))
{
bugId = "ManualCabAddedSetBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture);
}
return(bugId);
}
/// <summary>
/// Process a cab note table update. This may indicate a new item or the change to an existing item.
/// </summary>
private bool processCabNoteUpdate(StackHashBugTrackerUpdate update)
{
// Get the associated product and file information.
StackHashProduct product = m_Index.GetProduct((int)update.ProductId);
StackHashFile file = m_Index.GetFile(product, (int)update.FileId);
StackHashEvent theEvent = m_Index.GetEvent(product, file, new StackHashEvent((int)update.EventId, update.EventTypeName));
StackHashCab cab = m_Index.GetCab(product, file, theEvent, (int)update.CabId);
StackHashNoteEntry note = m_Index.GetCabNote((int)update.ChangedObjectId);
if ((product == null) || (file == null) || (theEvent == null) || (cab == null) || (note == null))
{
DiagnosticsHelper.LogMessage(DiagSeverity.Warning, "Processing Cab Note: Inconsistent Update Table Entry");
return(false);
}
BugTrackerProduct btProduct = new BugTrackerProduct(product.Name, product.Version, product.Id);
BugTrackerFile btFile = new BugTrackerFile(file.Name, file.Version, file.Id);
NameValueCollection eventSignature = new NameValueCollection();
foreach (StackHashParameter param in theEvent.EventSignature.Parameters)
{
eventSignature.Add(param.Name, param.Value);
}
BugTrackerEvent btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName,
theEvent.TotalHits, eventSignature);
NameValueCollection analysis = new NameValueCollection();
analysis.Add("DotNetVersion", cab.DumpAnalysis.DotNetVersion);
analysis.Add("MachineArchitecture", cab.DumpAnalysis.MachineArchitecture);
analysis.Add("OSVersion", cab.DumpAnalysis.OSVersion);
analysis.Add("ProcessUpTime", cab.DumpAnalysis.ProcessUpTime);
analysis.Add("SystemUpTime", cab.DumpAnalysis.SystemUpTime);
String cabFileName = m_Index.GetCabFileName(product, file, theEvent, cab);
BugTrackerCab btCab = new BugTrackerCab(cab.Id, cab.SizeInBytes, cab.CabDownloaded, cab.Purged, analysis, cabFileName);
BugTrackerNote btCabNote = new BugTrackerNote(note.TimeOfEntry, note.Source, note.User, note.Note);
String newBugId = null;
if (update.TypeOfChange == StackHashChangeType.NewEntry)
{
newBugId = m_TaskParameters.PlugInContext.CabNoteAdded(null, BugTrackerReportType.Automatic, btProduct, btFile, btEvent, btCab, btCabNote);
}
setPlugInBugReference(product, file, theEvent, newBugId);
return(true);
}
public void FileAdded(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
if (file == null)
{
throw new ArgumentNullException("file");
}
BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, s_PlugInName, "File Added: " + file.ToString());
m_FileAddedCount++;
}
public void ProductUpdated(BugTrackerReportType reportType, BugTrackerProduct product)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, s_PlugInName, "Product Updated: " + product.ToString());
if (product == null)
{
throw new ArgumentNullException("product");
}
m_ProductUpdatedCount++;
}
/// <summary>
/// If the report type is automatic then this call indicates that a Product has been added to the
/// StackHash database by way of a Synchronize with the WinQual web site.
///
/// If the report type is manual then this call indicates that a Product already exists in the
/// StackHash database. This is the result of a BugReport task being run.
///
/// Note that it is therefore possible that the product existence has already been reported, so the
/// code here should check, if necessary, that this is not a duplicate before creating new items in
/// the destination bug tracking system.
///
/// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync
/// is happening at the same time as a manual report is requested.
/// </summary>
/// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param>
/// <param name="product">The product being added.</param>
public void ProductAdded(BugTrackerReportType reportType, BugTrackerProduct product)
{
if (m_disposed)
{
throw new ObjectDisposedException("EmailPluginContext");
}
if (product == null)
{
throw new ArgumentNullException("product");
}
// report new products during sync (not during manual reporting) if configured to in settings
if ((reportType == BugTrackerReportType.Automatic) &&
(m_Settings.ReportProducts) &&
(!m_Settings.IsManualOnly))
{
try
{
string subject = string.Format(CultureInfo.CurrentCulture,
StackHash.EmailPlugin.Properties.Resources.ProductAdded_SubjectTemplate,
product.ProductName,
product.ProductVersion);
string message = string.Format(CultureInfo.CurrentCulture,
StackHash.EmailPlugin.Properties.Resources.ProductAdded_MessageTemplate,
product.ProductName,
product.ProductVersion,
product.ProductId);
m_Settings.SendEmail(subject, message);
m_EmailsSent++;
}
catch (Exception ex)
{
BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.ComponentFatal,
m_Control.PlugInName,
string.Format(CultureInfo.InvariantCulture,
"Failed to send new product email: {0}",
ex));
m_FailedEmails++;
m_LastException = ex;
throw;
}
}
}
/// <summary>
/// If the report type is automatic then this call indicates that a File has been added to the
/// StackHash database by way of a Synchronize with the WinQual web site.
///
/// If the report type is manual then this call indicates that a File already exists in the
/// StackHash database. This is the result of a BugReport task being run.
///
/// Files are mapped to products on the WinQual site. Note that the same file may be mapped to one
/// or more products and therefore the same event (associated with a file) may "belong" refer to more
/// than one product.
///
/// Note that it is therefore possible that the file existence has already been reported, so the
/// code here should check, if necessary, that this is not a duplicate before creating new items in
/// the destination bug tracking system.
///
/// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync
/// is happening at the same time as a manual report is requested.
/// </summary>
/// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param>
/// <param name="product">The product to which the file belongs.</param>
/// <param name="file">The file being added.</param>
public void FileAdded(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file)
{
if (m_disposed)
{
throw new ObjectDisposedException("EmailPluginContext");
}
if (product == null)
{
throw new ArgumentNullException("product");
}
if (file == null)
{
throw new ArgumentNullException("file");
}
}
public void ProductUpdated()
{
IBugTrackerV1Control plugInControl = new FaultDatabaseControl();
Assert.AreNotEqual(null, plugInControl);
IBugTrackerV1Context context = plugInControl.CreateContext();
Assert.AreNotEqual(null, context);
Assert.AreEqual(1, GetNumberOfActiveProfiles(plugInControl));
BugTrackerProduct product = new BugTrackerProduct("StackHash", "1.2.3.4", 1234568);
context.ProductUpdated(BugTrackerReportType.Automatic, product);
plugInControl.ReleaseContext(context);
Assert.AreEqual(0, GetNumberOfActiveProfiles(plugInControl));
}
/// <summary>
/// If the report type is automatic then this call indicates that a Product has been added to the
/// StackHash database by way of a Synchronize with the WinQual web site.
///
/// If the report type is manual then this call indicates that a Product already exists in the
/// StackHash database. This is the result of a BugReport task being run.
///
/// Note that it is therefore possible that the product existence has already been reported, so the
/// code here should check, if necessary, that this is not a duplicate before creating new items in
/// the destination bug tracking system.
///
/// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync
/// is happening at the same time as a manual report is requested.
/// </summary>
/// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param>
/// <param name="product">The product being added.</param>
public void ProductAdded(BugTrackerReportType reportType, BugTrackerProduct product)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
if (reportType == BugTrackerReportType.Automatic)
{
// Do automatic processing here. i.e. the result of a WinQualSync Task.
}
else
{
// Do manual processing here. i.e. the result of a manual BugReport Task.
}
// Note that all of the interface objects have a built in ToString() which formats the fields suitably.
BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, m_Control.PlugInName, "Product Added: " + product.ToString());
}
public string DebugScriptExecuted(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent, BugTrackerCab cab, BugTrackerScriptResult scriptResult)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
if (file == null)
{
throw new ArgumentNullException("file");
}
if (theEvent == null)
{
throw new ArgumentNullException("theEvent");
}
if (cab == null)
{
throw new ArgumentNullException("cab");
}
if (scriptResult == null)
{
throw new ArgumentNullException("scriptResult");
}
BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, s_PlugInName, "Script Added: " + scriptResult.ToString());
// If the SetBugId is set then the plugin should have set the bug reference so subsequent calls using that event should
// also contain the bug reference.
if (m_Properties["SetBugId"] == "True")
{
if (theEvent.PlugInBugReference != "TestPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture))
{
throw new ArgumentException("Bug ref not set", "theEvent");
}
}
m_ScriptRunCount++;
String bugId = null;
if (m_Properties["DebugScriptExecutedBugId"] == "True")
{
bugId = "TestDebugScriptExecutedPlugInBugId" + theEvent.EventId.ToString(CultureInfo.InvariantCulture);
}
return(bugId);
}
public string EventManualUpdateCompleted(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
if (file == null)
{
throw new ArgumentNullException("file");
}
if (theEvent == null)
{
throw new ArgumentNullException("theEvent");
}
BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, s_PlugInName, "Event Manual Update Completed: " + theEvent.ToString());
m_EventCompleteCount++;
return(theEvent.BugReference);
}
public void EventAddedNoEventSignature()
{
IBugTrackerV1Control plugInControl = new FaultDatabaseControl();
Assert.AreNotEqual(null, plugInControl);
IBugTrackerV1Context context = plugInControl.CreateContext();
Assert.AreNotEqual(null, context);
Assert.AreEqual(1, GetNumberOfActiveProfiles(plugInControl));
BugTrackerProduct product = new BugTrackerProduct("StackHash", "1.2.3.4", 1234568);
BugTrackerFile file = new BugTrackerFile("StackHash.dll", "1.2.3.4", 234567);
BugTrackerEvent theEvent = new BugTrackerEvent("Reference", "Plugin bug ref", 1111111, "CLR20 - Crash", 122, new NameValueCollection());
context.EventAdded(BugTrackerReportType.Automatic, product, file, theEvent);
plugInControl.ReleaseContext(context);
Assert.AreEqual(0, GetNumberOfActiveProfiles(plugInControl));
}
/// <summary>
/// Process an event note table update. This may indicate a new item or the change to an existing item.
/// </summary>
private bool processEventNoteUpdate(StackHashBugTrackerUpdate update)
{
// Get the associated product and file information.
StackHashProduct product = m_Index.GetProduct((int)update.ProductId);
StackHashFile file = m_Index.GetFile(product, (int)update.FileId);
StackHashEvent theEvent = m_Index.GetEvent(product, file, new StackHashEvent((int)update.EventId, update.EventTypeName));
StackHashNoteEntry note = m_Index.GetEventNote((int)update.ChangedObjectId);
if ((product == null) || (file == null) || (theEvent == null) || (note == null))
{
DiagnosticsHelper.LogMessage(DiagSeverity.Warning, "Processing Event Note: Inconsistent Update Table Entry");
return(false);
}
BugTrackerProduct btProduct = new BugTrackerProduct(product.Name, product.Version, product.Id);
BugTrackerFile btFile = new BugTrackerFile(file.Name, file.Version, file.Id);
NameValueCollection eventSignature = new NameValueCollection();
foreach (StackHashParameter param in theEvent.EventSignature.Parameters)
{
eventSignature.Add(param.Name, param.Value);
}
BugTrackerEvent btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName,
theEvent.TotalHits, eventSignature);
BugTrackerNote btEventNote = new BugTrackerNote(note.TimeOfEntry, note.Source, note.User, note.Note);
String newBugId = null;
if (update.TypeOfChange == StackHashChangeType.NewEntry)
{
newBugId = m_TaskParameters.PlugInContext.EventNoteAdded(null, BugTrackerReportType.Automatic, btProduct, btFile, btEvent, btEventNote);
}
setPlugInBugReference(product, file, theEvent, newBugId);
return(true);
}
public void EventNoteAdded()
{
IBugTrackerV1Control plugInControl = new FaultDatabaseControl();
Assert.AreNotEqual(null, plugInControl);
IBugTrackerV1Context context = plugInControl.CreateContext();
Assert.AreNotEqual(null, context);
Assert.AreEqual(1, GetNumberOfActiveProfiles(plugInControl));
BugTrackerProduct product = new BugTrackerProduct("StackHash", "1.2.3.4", 1234568);
BugTrackerFile file = new BugTrackerFile("StackHash.dll", "1.2.3.4", 234567);
BugTrackerEvent theEvent = new BugTrackerEvent("Reference", "Plugin bug ref", 1111111, "CLR20 - Crash", 122, new NameValueCollection());
theEvent.Signature["Exception"] = "0x23434";
BugTrackerNote note = new BugTrackerNote(DateTime.Now, "Source", "MarkJ", "Hello from me");
context.EventNoteAdded(BugTrackerReportType.Automatic, product, file, theEvent, note);
plugInControl.ReleaseContext(context);
Assert.AreEqual(0, GetNumberOfActiveProfiles(plugInControl));
}
/// <summary>
/// This method is called when the processing of an Event has completed. Events have associated Cabs, Scripts and notes which
/// may all be reported during a MANUAL Bug Report. This call effectively delimits the reporting of all
/// information associated with an event so, if desired, the plug-in can gather all of the information together in one
/// go for sending to the fault database. This may improve performance for events with large amounts of stored data.
///
/// The plug-in may thus see...
/// EventAdded
/// EventNoteAdded, EventNoteAdded,...
/// CabAdded, CabAdded,...
/// CabNoteAdded, CabNoteAdded,...
/// ScriptResultAdded, ScriptResultAdded,...
/// EventManualUpdateCompleted.
///
/// A Plugin Bug Reference is stored with the Event data in the StackHash database. This can be manually changed
/// by the StackHash client user. The plug-in can also change the plugin bug reference by returning the desired
/// bug reference from this call.
/// Return null if you do NOT want to change the bug reference stored in the StackHash database.
/// Return any other string (including an empty string) and this value will be used to overwrite the
/// plugin bug reference in the StackHash database.
/// Note that there are 2 bug references:
/// The BugReference can be set by the StackHash client user manually. This cannot be changed by the plugin.
/// The PlugInBugReference can be set by the StackHash client user manually AND/OR set by the plugin.
///
/// Automatic reports may arrived interleaved with manual reports. This may happen when, say a WinQual sync
/// is happening at the same time as a manual report is requested.
/// </summary>
/// <param name="reportType">Manual or automatic. If manual identifies what level of report is taking place.</param>
/// <param name="product">The product to which the file belongs.</param>
/// <param name="file">The file to which the event belongs.</param>
/// <param name="theEvent">The event whose details have now been reported.</param>
/// <returns>Null - if the plugin bug reference in the StackHash database should not be changed, Otherwise the new value for the plugin bug reference.</returns>
public string EventManualUpdateCompleted(BugTrackerReportType reportType, BugTrackerProduct product, BugTrackerFile file, BugTrackerEvent theEvent)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
if (file == null)
{
throw new ArgumentNullException("file");
}
if (theEvent == null)
{
throw new ArgumentNullException("theEvent");
}
// Don't change the bug reference. Setting this to any other value will update the bug reference in the
// StackHash database.
String plugInBugId = null;
// Note that all of the interface objects have a built in ToString() which formats the fields suitably.
BugTrackerTrace.LogMessage(BugTrackerTraceSeverity.Information, m_Control.PlugInName, "Event Completed: " + theEvent.ToString());
return(plugInBugId);
}
/// <summary>
/// Process a product table update. This may indicate a new item or the change to an existing item.
/// </summary>
private bool processProductUpdate(StackHashBugTrackerUpdate update)
{
// Get the associated product information.
StackHashProduct product = m_Index.GetProduct((int)update.ProductId);
if (product == null)
{
DiagnosticsHelper.LogMessage(DiagSeverity.Warning, "Processing Product: Inconsistent Update Table Entry");
return(false);
}
BugTrackerProduct btProduct = new BugTrackerProduct(product.Name, product.Version, product.Id);
if (update.TypeOfChange == StackHashChangeType.NewEntry)
{
m_TaskParameters.PlugInContext.ProductAdded(null, BugTrackerReportType.Automatic, btProduct);
}
else
{
m_TaskParameters.PlugInContext.ProductUpdated(null, BugTrackerReportType.Automatic, btProduct);
}
return(true);
}
/// <summary>
/// Processes a specific file.
/// </summary>
private void processFile(StackHashBugReportData request, StackHashProduct product, StackHashFile file)
{
if (this.CurrentTaskState.AbortRequested)
{
throw new OperationCanceledException("Reporting events to Bug Tracker plug-ins");
}
BugTrackerProduct btProduct = new BugTrackerProduct(product.Name, product.Version, product.Id);
BugTrackerFile btFile = new BugTrackerFile(file.Name, file.Version, file.Id);
if (((request.Options & StackHashReportOptions.IncludeFiles) != 0) ||
((request.Options & StackHashReportOptions.IncludeAllObjects) != 0))
{
m_TaskParameters.PlugInContext.FileAdded(m_PlugIns, m_ReportType, btProduct, btFile);
checkPlugInStatus(m_PlugIns);
}
if (request.TheEvent == null)
{
// Parse the events.
StackHashSortOrderCollection sortOrder = new StackHashSortOrderCollection()
{
new StackHashSortOrder(StackHashObjectType.Event, "Id", true),
new StackHashSortOrder(StackHashObjectType.Event, "EventTypeName", true)
};
StackHashSearchOptionCollection searchOptions = new StackHashSearchOptionCollection()
{
new IntSearchOption(StackHashObjectType.Product, "Id", StackHashSearchOptionType.Equal, product.Id, 0),
new IntSearchOption(StackHashObjectType.File, "Id", StackHashSearchOptionType.Equal, file.Id, 0),
};
StackHashSearchCriteriaCollection allCriteria = new StackHashSearchCriteriaCollection()
{
new StackHashSearchCriteria(searchOptions)
};
int startRow = 1;
int numberOfRows = 100;
StackHashEventPackageCollection allPackages = null;
do
{
allPackages = m_Index.GetEvents(allCriteria, startRow, numberOfRows, sortOrder, null);
foreach (StackHashEventPackage eventPackage in allPackages)
{
processEventPackage(request, product, file, eventPackage);
}
startRow += numberOfRows;
} while (allPackages.Count > 0);
}
else
{
StackHashSearchOptionCollection searchOptions = new StackHashSearchOptionCollection()
{
new IntSearchOption(StackHashObjectType.Product, "Id", StackHashSearchOptionType.Equal, product.Id, 0),
new IntSearchOption(StackHashObjectType.File, "Id", StackHashSearchOptionType.Equal, file.Id, 0),
new IntSearchOption(StackHashObjectType.Event, "Id", StackHashSearchOptionType.Equal, request.TheEvent.Id, 0),
new StringSearchOption(StackHashObjectType.Event, "EventTypeName", StackHashSearchOptionType.Equal, request.TheEvent.EventTypeName, request.TheEvent.EventTypeName, false),
};
StackHashSearchCriteriaCollection allCriteria = new StackHashSearchCriteriaCollection()
{
new StackHashSearchCriteria(searchOptions)
};
StackHashEventPackageCollection eventPackages = m_Index.GetEvents(allCriteria, null);
if ((eventPackages != null) && (eventPackages.Count == 1))
{
processEventPackage(request, product, file, eventPackages[0]);
}
}
}
/// <summary>
/// Processes a specific event.
/// </summary>
private void processEventPackage(StackHashBugReportData request, StackHashProduct product, StackHashFile file,
StackHashEventPackage eventPackage)
{
if (this.CurrentTaskState.AbortRequested)
{
throw new OperationCanceledException("Reporting events to Bug Tracker plug-ins");
}
StackHashEvent theEvent = eventPackage.EventData;
BugTrackerProduct btProduct = new BugTrackerProduct(product.Name, product.Version, product.Id);
BugTrackerFile btFile = new BugTrackerFile(file.Name, file.Version, file.Id);
NameValueCollection eventSignature = new NameValueCollection();
foreach (StackHashParameter param in theEvent.EventSignature.Parameters)
{
eventSignature.Add(param.Name, param.Value);
}
BugTrackerEvent btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, eventSignature);
if (((request.Options & StackHashReportOptions.IncludeEvents) != 0) ||
((request.Options & StackHashReportOptions.IncludeAllObjects) != 0))
{
String newBugId = m_TaskParameters.PlugInContext.EventAdded(m_PlugIns, m_ReportType, btProduct, btFile, btEvent);
checkPlugInStatus(m_PlugIns);
theEvent = setPlugInBugReference(product, file, theEvent, newBugId);
// Reset this in case it has changed.
btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, eventSignature);
}
if (((request.Options & StackHashReportOptions.IncludeEventNotes) != 0) ||
((request.Options & StackHashReportOptions.IncludeAllObjects) != 0))
{
StackHashNotes notes = m_Index.GetEventNotes(product, file, theEvent);
foreach (StackHashNoteEntry note in notes)
{
if (this.CurrentTaskState.AbortRequested)
{
throw new OperationCanceledException("Reporting events to Bug Tracker plug-ins");
}
BugTrackerNote btEventNote = new BugTrackerNote(note.TimeOfEntry, note.Source, note.User, note.Note);
String newBugId = m_TaskParameters.PlugInContext.EventNoteAdded(m_PlugIns, m_ReportType, btProduct, btFile, btEvent, btEventNote);
checkPlugInStatus(m_PlugIns);
theEvent = setPlugInBugReference(product, file, theEvent, newBugId);
// Reset this in case it has changed.
btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, eventSignature);
}
}
if (request.Cab == null)
{
foreach (StackHashCabPackage cab in eventPackage.Cabs)
{
processCab(request, product, file, theEvent, cab.Cab, btProduct, btFile, btEvent);
// Reset this in case it has changed.
btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, eventSignature);
}
}
else
{
StackHashCab cab = m_Index.GetCab(product, file, theEvent, request.Cab.Id);
if (cab != null)
{
theEvent = processCab(request, product, file, theEvent, cab, btProduct, btFile, btEvent);
// Reset this in case it has changed.
btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, eventSignature);
}
}
// Signal the completion of this event.
if (((request.Options & StackHashReportOptions.IncludeEvents) != 0) ||
((request.Options & StackHashReportOptions.IncludeAllObjects) != 0))
{
String newBugId = m_TaskParameters.PlugInContext.EventManualUpdateCompleted(m_PlugIns, m_ReportType, btProduct, btFile, btEvent);
checkPlugInStatus(m_PlugIns);
theEvent = setPlugInBugReference(product, file, theEvent, newBugId);
// Reset this in case it has changed.
btEvent = new BugTrackerEvent(theEvent.BugId, theEvent.PlugInBugId, theEvent.Id, theEvent.EventTypeName, theEvent.TotalHits, eventSignature);
}
m_CurrentEvent++;
reportProgress(m_CurrentEvent, m_TotalEvents, eventPackage.EventData.Id);
}
