public void ScriptNullScript()
{
String testScriptName = "Name";
// Create a script.
StackHashScriptSettings scriptSettings = new StackHashScriptSettings(testScriptName, null);
}
/// <summary>
/// Removes the specified script.
/// </summary>
/// <param name="scriptName">Name of script to remove.</param>
public void RemoveScript(String scriptName)
{
// Cannot create an autoscript from the client.
if (isAutoScript(scriptName))
{
throw new StackHashException("Cannot remove system scripts", StackHashServiceErrorCode.CannotRemoveSystemScripts);
}
String fileName = getScriptFileName(scriptName);
// Load it to see if it is read only.
if (File.Exists(fileName))
{
StackHashScriptSettings script = StackHashScriptSettings.Load(fileName);
if (!script.IsReadOnly)
{
File.Delete(fileName);
}
else
{
throw new StackHashException("Cannot remove Read Only script", StackHashServiceErrorCode.CannotRemoveSystemScripts);
}
}
}
public void ScriptGenerateNoLines()
{
String testScriptName = "Name";
// Create a script - empty.
StackHashScript script = new StackHashScript();
StackHashScriptSettings scriptSettings = new StackHashScriptSettings(testScriptName, script);
String tempFileName = m_TempPath + "\\GeneratedScript.wds";
String outputFileName = "c:\\test\\results.log";
String symPath = null;
String exePath = null;
String srcPath = null;
scriptSettings.GenerateScriptFile(tempFileName, outputFileName, ref symPath, ref exePath, ref srcPath);
Assert.AreEqual(null, symPath);
Assert.AreEqual(null, exePath);
Assert.AreEqual(null, srcPath);
// Read all of the data in.
String[] allLines = File.ReadAllLines(tempFileName);
Assert.AreEqual(true, File.Exists(tempFileName));
// Should just contain a comment line.
Assert.AreEqual(4, allLines.Length);
Assert.AreEqual(true, allLines[0].Contains(outputFileName));
Assert.AreEqual(true, allLines[1].Contains(testScriptName));
Assert.AreEqual(true, allLines[1].Contains(scriptSettings.LastModifiedDate.ToString(CultureInfo.InvariantCulture)));
Assert.AreEqual(true, allLines[2].Contains("Script Complete"));
Assert.AreEqual(true, allLines[3].Contains(".logclose"));
}
public void GetUnquotedPathFromCommandLineParamOriginalNullConcat()
{
String path = "c:\\testpath";
String command = ".sympath +";
String commandLine = command + " " + path;
String originalPath = null;
String outPath = StackHashScriptSettings.GetUnquotedPathFromCommandLine(originalPath, commandLine, ".sympath");
Assert.AreEqual(path, outPath);
}
public void GetUnquotedPathFromCommandCommandMismatch()
{
String path = "\"c:\\testpath;z:\\stuff\"";
String command = " .SymPath + ";
String commandLine = command + " " + path;
String originalPath = "c:\\original";
String outPath = StackHashScriptSettings.GetUnquotedPathFromCommandLine(originalPath, commandLine, ".srcpath");
Assert.AreEqual(originalPath, outPath);
}
public void GetUnquotedPathFromCommandLineNoParameterOriginalNull()
{
String path = "";
String command = ".sympath";
String commandLine = command + " " + path;
String originalPath = null;
String outPath = StackHashScriptSettings.GetUnquotedPathFromCommandLine(originalPath, commandLine, ".sympath");
Assert.AreEqual(null, outPath);
}
public void UpdateScriptFile()
{
bool saveAutoScript = false;
bool fileExists = File.Exists(m_ScriptFileName);
if (fileExists)
{
// Load in the script and check the version number. If there is an error during load
// then just create a new copy of the file.
try
{
StackHashScriptSettings thisScript = StackHashScriptSettings.Load(m_ScriptFileName);
saveAutoScript = !IsScriptCurrent(thisScript);
}
catch (System.Exception ex)
{
String message = String.Format(CultureInfo.InvariantCulture, "Failed to load script {0} - Reconstructing", ScriptName);
DiagnosticsHelper.LogException(DiagSeverity.Warning, message, ex);
saveAutoScript = true;
}
}
else
{
saveAutoScript = true;
}
FileAttributes currentAttributes;
if (saveAutoScript)
{
if (fileExists)
{
currentAttributes = File.GetAttributes(m_ScriptFileName);
// Turn off the readonly permission so the file can be updated.
if ((currentAttributes & FileAttributes.ReadOnly) != 0)
{
// Clear the read only flag.
File.SetAttributes(m_ScriptFileName, currentAttributes & ~FileAttributes.ReadOnly);
}
}
StackHashScriptSettings autoScript = GenerateScript();
autoScript.Save(m_ScriptFileName);
}
// Make sure the file is marked read only so the client can't delete it.
currentAttributes = File.GetAttributes(m_ScriptFileName);
if ((currentAttributes & FileAttributes.ReadOnly) == 0)
{
// Set the read only flag.
File.SetAttributes(m_ScriptFileName, currentAttributes | FileAttributes.ReadOnly);
}
}
public void GetUnquotedPathFromCommandLineNullCommand()
{
try
{
StackHashScriptSettings.GetUnquotedPathFromCommandLine(null, ".sympath", null);
}
catch (System.ArgumentNullException ex)
{
Assert.AreEqual("command", ex.ParamName);
throw;
}
}
public void GetUnquotedPathFromCommandLineQuotesNoConcat()
{
String path = "\"c:\\testpath\"";
String command = ".sympath ";
String commandLine = command + " " + path;
String originalPath = "c:\\original";
String outPath = StackHashScriptSettings.GetUnquotedPathFromCommandLine(originalPath, commandLine, ".sympath");
String expectedResult = "c:\\testpath";
Assert.AreEqual(expectedResult, outPath);
}
public void GetUnquotedPathFromCommandCalledTwiceNoConcat()
{
String path = "c:\\path";
String command = " .SymPath ";
String commandLine = command + " " + path;
String originalPath = "c:\\original";
String outPath = StackHashScriptSettings.GetUnquotedPathFromCommandLine(originalPath, commandLine, ".sympath");
outPath = StackHashScriptSettings.GetUnquotedPathFromCommandLine(outPath, commandLine, ".sympath");
Assert.AreEqual(path, outPath);
}
public void GetUnquotedPathFromCommandLineQuotesAndSpaceAndCase()
{
String path = "\"c:\\testpath;z:\\stuff\"";
String command = " .SymPath + ";
String commandLine = command + " " + path;
String originalPath = "c:\\original";
String outPath = StackHashScriptSettings.GetUnquotedPathFromCommandLine(originalPath, commandLine, ".sympath");
String expectedResult = originalPath + ";" + "c:\\testpath;z:\\stuff";
Assert.AreEqual(expectedResult, outPath);
}
/// <summary>
/// Determines if the specified version of the auto script file is up to date.
/// </summary>
/// <param name="script"></param>
/// <returns></returns>
public bool IsScriptCurrent(StackHashScriptSettings script)
{
if (script == null)
{
throw new ArgumentNullException("script");
}
if (script.Name != m_ScriptName)
{
throw new ArgumentException("Script file not specified", "script");
}
return(script.Version == CurrentVersion);
}
public void RunAllAutoScripts()
{
String dumpFileName = m_TempPath + "Cucku.exe.mdmp";
// First make a copy of the test cab file.
File.Copy(TestSettings.TestDataFolder + @"Dumps\Cucku.exe.mdmp",
dumpFileName, true);
FileAttributes attributes = File.GetAttributes(dumpFileName);
File.SetAttributes(dumpFileName, attributes & ~FileAttributes.ReadOnly);
ScriptManager scriptManager = new ScriptManager(m_TempPath);
// Now execute the script.
StackHashDebug.Windbg winDbg = new Windbg();
try
{
Collection <AutoScriptBase> autoScripts = scriptManager.AutoScripts;
foreach (AutoScriptBase autoScript in autoScripts)
{
// Generate the script settings structure in memory.
StackHashScriptSettings scriptSettings = autoScript.GenerateScript();
// Those settings are now used to create a WinDbg script file (wds). This file has a command
// to create a log file (the resultsFileName).
String resultsFileName = String.Format("{0}.log", Path.Combine(m_TempPath, autoScript.ScriptName));
String scriptFileName = String.Format("{0}.wds", Path.Combine(m_TempPath, autoScript.ScriptName));
String symPath = null;
String exePath = null;
String srcPath = null;
scriptSettings.GenerateScriptFile(scriptFileName, resultsFileName, ref symPath, ref exePath, ref srcPath);
// Run the wds file through the debugger to produce the results.log file.
winDbg.RunScript(m_DebuggerSettings, false, scriptFileName, dumpFileName, m_TempPath, symPath, exePath, srcPath);
// Load the results.log file.
StackHashScriptResult scriptResults = new StackHashScriptResult(resultsFileName);
// Analyse the results.
StackHashDumpAnalysis analysis = new StackHashDumpAnalysis();
analysis = autoScript.AnalyzeScriptResults(analysis, scriptResults);
}
}
finally
{
scriptManager.RemoveAutoScripts();
}
}
/// <summary>
/// Gets all script contexts.
/// </summary>
/// <returns>Full list of all the script settings.</returns>
private StackHashScriptCollection GetAllScripts()
{
StackHashScriptCollection allScripts = new StackHashScriptCollection();
String [] allScriptFiles = Directory.GetFiles(m_ScriptFolder, s_ScriptWildcard);
foreach (String fileName in allScriptFiles)
{
StackHashScriptSettings thisScript = StackHashScriptSettings.Load(fileName);
allScripts.Add(thisScript);
}
return(allScripts);
}
public void ScriptContainsPssCorIa64Clr4()
{
String testScriptName = "Name";
String testCommand = @".load psscor.dll";
String testComment = @"loads psscor from correct location";
StackHashScript script = new StackHashScript();
script.Add(new StackHashScriptLine(testCommand, testComment));
StackHashScriptSettings scriptSettings = new StackHashScriptSettings(testScriptName, script);
scriptSettings.FixUp(StackHashScriptDumpArchitecture.IA64, "4.0.2355.2233", "C:\\test");
Assert.AreEqual(0, String.Compare(".load C:\\test\\psscor4\\ia64\\psscor4.dll", scriptSettings.Script[0].Command, StringComparison.OrdinalIgnoreCase));
}
/// <summary>
/// Adds or edits a debugger script
/// </summary>
/// <param name="clientLogic">Client Logic</param>
/// <param name="scriptSettings">Script to edit (new blank script if add)</param>
/// <param name="add">True if this is a new script, false if an existing script is being edited</param>
public ScriptAddEdit(ClientLogic clientLogic, StackHashScriptSettings scriptSettings, bool add)
{
Debug.Assert(clientLogic != null);
Debug.Assert(scriptSettings != null);
_clientLogic = clientLogic;
_scriptSettings = scriptSettings;
_add = add;
InitializeComponent();
if (UserSettings.Settings.HaveWindow(WindowKey))
{
UserSettings.Settings.RestoreWindow(WindowKey, this);
}
}
/// <summary>
/// Generates the auto script file in memory.
/// </summary>
/// <returns>Full script settings.</returns>
public override StackHashScriptSettings GenerateScript()
{
StackHashScriptSettings scriptSettings = new StackHashScriptSettings();
scriptSettings.CreationDate = DateTime.Now.ToUniversalTime();
scriptSettings.LastModifiedDate = scriptSettings.CreationDate;
scriptSettings.Name = base.ScriptName;
scriptSettings.Owner = StackHashScriptOwner.System;
scriptSettings.RunAutomatically = true;
scriptSettings.Version = base.CurrentVersion;
scriptSettings.IsReadOnly = true;
scriptSettings.DumpType = StackHashScriptDumpType.UnmanagedAndManaged; // Run script on all types of dump.
scriptSettings.Script = new StackHashScript();
scriptSettings.Script.Add(new StackHashScriptLine(s_VerTargetCommand, s_VerTargetComment));
return(scriptSettings);
}
public void ScriptGenerate2LinesOtherWayAround()
{
String testScriptName = "Name";
String testCommand2 = @"$$ Command 1";
String testComment2 = @"Demo Comment 1";
String testCommand1 = @"$$ Command 2";
String testComment1 = @"Another comment";
// Create a script - empty.
StackHashScript script = new StackHashScript();
script.Add(new StackHashScriptLine(testCommand1, testComment1));
script.Add(new StackHashScriptLine(testCommand2, testComment2));
StackHashScriptSettings scriptSettings = new StackHashScriptSettings(testScriptName, script);
String tempFileName = m_TempPath + "\\GeneratedScript.wds";
String outputFileName = "c:\\test\\results.log";
String symPath = null;
String exePath = null;
String srcPath = null;
scriptSettings.GenerateScriptFile(tempFileName, outputFileName, ref symPath, ref exePath, ref srcPath);
Assert.AreEqual(null, symPath);
Assert.AreEqual(null, exePath);
Assert.AreEqual(null, srcPath);
// Read all of the data in.
String[] allLines = File.ReadAllLines(tempFileName);
Assert.AreEqual(true, File.Exists(tempFileName));
// Should contain the script header comment plus one command and one comment line for each command.
Assert.AreEqual(10, allLines.Length);
Assert.AreEqual(true, allLines[0].Contains(outputFileName));
Assert.AreEqual(true, allLines[1].Contains(testScriptName));
Assert.AreEqual(true, allLines[1].Contains(scriptSettings.LastModifiedDate.ToString(CultureInfo.InvariantCulture)));
Assert.AreEqual(true, allLines[2].Contains(scriptSettings.Script[0].Comment));
Assert.AreEqual(true, allLines[3].StartsWith(scriptSettings.Script[0].Command));
Assert.AreEqual(true, allLines[4].Contains(scriptSettings.Script[0].Comment));
Assert.AreEqual(true, allLines[5].Contains(scriptSettings.Script[1].Comment));
Assert.AreEqual(true, allLines[6].StartsWith(scriptSettings.Script[1].Command));
Assert.AreEqual(true, allLines[7].Contains(scriptSettings.Script[1].Comment));
Assert.AreEqual(true, allLines[8].Contains("Script Complete"));
Assert.AreEqual(true, allLines[9].Contains(".logclose"));
}
/// <summary>
/// Gets the results files for the specified cab.
/// </summary>
/// <param name="product">Product to which the cab belongs</param>
/// <param name="file">File to which the cab belongs</param>
/// <param name="theEvent">Event to which the cab belongs</param>
/// <param name="cab">Cab to get results for.</param>
/// <returns>All script results for specified cab.</returns>
public StackHashScriptResultFiles GetResultFiles(StackHashProduct product,
StackHashFile file, StackHashEvent theEvent, StackHashCab cab)
{
// Unwrap the cab if necessary.
String cabFileFolder = m_ErrorIndex.GetCabFolder(product, file, theEvent, cab);
cabFileFolder += "\\Analysis";
// Get a list of the results log files.
String[] files;
if (Directory.Exists(cabFileFolder))
{
files = Directory.GetFiles(cabFileFolder, "*.log");
}
else
{
files = new String[0];
}
StackHashScriptResultFiles resultFiles = new StackHashScriptResultFiles();
foreach (String fileName in files)
{
// Need to get whether it is an auto or user script.
String fileNameNoExtension = Path.GetFileNameWithoutExtension(fileName);
StackHashScriptSettings scriptSettings = m_ScriptManager.LoadScript(fileNameNoExtension, true);
StackHashScriptResultFile resultFile = new StackHashScriptResultFile();
resultFile.RunDate = File.GetLastWriteTimeUtc(fileName);
resultFile.ScriptName = Path.GetFileNameWithoutExtension(fileName);
if ((scriptSettings == null) || (scriptSettings.Owner == StackHashScriptOwner.System))
{
resultFile.UserName = "******";
}
else
{
resultFile.UserName = "******";
}
resultFiles.Add(resultFile);
}
return(resultFiles);
}
private void scriptSaveLoadNCommands(int numCommands, bool addComment)
{
StackHashScript script = new StackHashScript();
for (int i = 0; i < numCommands; i++)
{
String command = "command" + i.ToString();
String comment = null;
if (addComment)
{
comment = "comment" + i.ToString();
}
script.Add(new StackHashScriptLine(command, comment));
}
String testScriptName = m_TempPath + "\\scriptsettings.wds";
StackHashScriptSettings scriptSettings = new StackHashScriptSettings(testScriptName, script);
scriptSettings.Name = "TestName";
scriptSettings.CreationDate = DateTime.Now.ToUniversalTime();
scriptSettings.LastModifiedDate = DateTime.Now.ToUniversalTime();
scriptSettings.Owner = StackHashScriptOwner.System;
scriptSettings.RunAutomatically = true;
scriptSettings.Version = 2;
scriptSettings.Save(testScriptName);
// And load in again and compare.
StackHashScriptSettings loadedSettings = StackHashScriptSettings.Load(testScriptName);
Assert.AreEqual(scriptSettings.CreationDate, loadedSettings.CreationDate);
Assert.AreEqual(scriptSettings.LastModifiedDate, loadedSettings.LastModifiedDate);
Assert.AreEqual(scriptSettings.Name, loadedSettings.Name);
Assert.AreEqual(scriptSettings.Script.Count, loadedSettings.Script.Count);
Assert.AreEqual(scriptSettings.RunAutomatically, loadedSettings.RunAutomatically);
Assert.AreEqual(scriptSettings.Version, loadedSettings.Version);
Assert.AreEqual(scriptSettings.Owner, loadedSettings.Owner);
for (int i = 0; i < scriptSettings.Script.Count; i++)
{
Assert.AreEqual(scriptSettings.Script[i].Command, loadedSettings.Script[i].Command);
Assert.AreEqual(scriptSettings.Script[i].Comment, loadedSettings.Script[i].Comment);
}
}
public void RunAutoScript()
{
String dumpFileName = m_TempPath + "Cucku.exe.mdmp";
String scriptFileName = m_TempPath + "AutoScript.wds";
String resultsFileName = m_TempPath + "AutoScript.log";
// First make a copy of the test cab file.
File.Copy(TestSettings.TestDataFolder + @"Dumps\Cucku.exe.mdmp",
dumpFileName, true);
FileAttributes attributes = File.GetAttributes(dumpFileName);
File.SetAttributes(dumpFileName, attributes & ~FileAttributes.ReadOnly);
AutoScript autoScript = new AutoScript(m_TempPath);
StackHashScriptSettings scriptSettings = autoScript.GenerateScript();
String symPath = null;
String exePath = null;
String srcPath = null;
scriptSettings.GenerateScriptFile(scriptFileName, resultsFileName, ref symPath, ref exePath, ref srcPath);
Assert.AreEqual(null, symPath);
Assert.AreEqual(null, exePath);
Assert.AreEqual(null, srcPath);
// Now execute the script.
StackHashDebug.Windbg winDbg = new Windbg();
winDbg.RunScript(m_DebuggerSettings, false, scriptFileName, dumpFileName, m_TempPath, symPath, exePath, srcPath);
// Load the results file.
StackHashScriptResult scriptResults = new StackHashScriptResult(resultsFileName);
// Analyse the results.
StackHashDumpAnalysis analysis = new StackHashDumpAnalysis();
analysis = autoScript.AnalyzeScriptResults(analysis, scriptResults);
Assert.AreEqual("not available", analysis.SystemUpTime);
Assert.AreEqual("0 days 0:02:20.000", analysis.ProcessUpTime);
Assert.AreEqual("2.0.50727.3603", analysis.DotNetVersion);
}
public void ScriptConstructor()
{
String testCommand = @"$$ This is a simple command";
String testComment = @"Just a demo";
String testScriptName = "Name";
// Create a script.
StackHashScript script = new StackHashScript();
script.Add(new StackHashScriptLine(testCommand, testComment));
StackHashScriptSettings scriptSettings = new StackHashScriptSettings(testScriptName, script);
Assert.AreEqual(testCommand, script[0].Command);
Assert.AreEqual(testComment, script[0].Comment);
Assert.AreEqual(StackHashScriptDumpType.UnmanagedAndManaged, scriptSettings.DumpType);
Assert.AreEqual(testScriptName, scriptSettings.Name);
Assert.AreEqual(scriptSettings.LastModifiedDate, scriptSettings.CreationDate);
Assert.AreEqual(true, DateTime.Now.ToUniversalTime().Second - scriptSettings.CreationDate.Second <= 2);
}
/// <summary>
/// Generates the auto script file in memory.
/// </summary>
/// <returns>Full script settings.</returns>
public override StackHashScriptSettings GenerateScript()
{
StackHashScriptSettings scriptSettings = new StackHashScriptSettings();
scriptSettings.CreationDate = DateTime.Now.ToUniversalTime();
scriptSettings.LastModifiedDate = scriptSettings.CreationDate;
scriptSettings.Name = s_ScriptName;
scriptSettings.Owner = StackHashScriptOwner.System;
scriptSettings.Version = s_CurrentVersion;
scriptSettings.IsReadOnly = true;
scriptSettings.RunAutomatically = true; // This is automatic but not defined by the user.
scriptSettings.DumpType = StackHashScriptDumpType.UnmanagedAndManaged; // Run script on all types of dump.
scriptSettings.Script = new StackHashScript();
scriptSettings.Script.Add(new StackHashScriptLine(s_DebuggerVersionCommand, s_DebuggerVersionComment));
scriptSettings.Script.Add(new StackHashScriptLine(s_VerTargetCommand, s_VerTargetComment));
scriptSettings.Script.Add(new StackHashScriptLine(s_MscoreModuleCommand, s_MscoreModuleComment));
scriptSettings.Script.Add(new StackHashScriptLine(s_MscoreModuleCommand2, s_MscoreModuleComment2));
return(scriptSettings);
}
/// <summary>
/// Loads the specified script file.
/// </summary>
/// <param name="scriptName">Script to load.</param>
/// <returns>The script settings.</returns>
public StackHashScriptSettings LoadScript(string scriptName, bool noException)
{
String fileName = getScriptFileName(scriptName);
if (!File.Exists(fileName))
{
if (noException)
{
return(null);
}
else
{
throw new StackHashException("Script file does not exist when loading script.", StackHashServiceErrorCode.ScriptDoesNotExist);
}
}
StackHashScriptSettings newScriptSettings = StackHashScriptSettings.Load(fileName);
return(newScriptSettings);
}
private void DoAdd()
{
StackHashScriptSettings scriptSettings = new StackHashScriptSettings();
scriptSettings.Script = new StackHashScript();
scriptSettings.IsReadOnly = false;
scriptSettings.RunAutomatically = false;
scriptSettings.Version = 1;
scriptSettings.Owner = StackHashScriptOwner.User;
ScriptAddEdit scriptAdd = new ScriptAddEdit(_clientLogic, scriptSettings, true);
scriptAdd.Owner = this;
if (scriptAdd.ShowDialog() == true)
{
_reselectScriptName = scriptSettings.Name;
_clientLogic.AdminAddScript(scriptSettings, scriptSettings.Name, false);
}
}
public void ScriptGenerate1Line()
{
String testScriptName = "Name";
String testCommand = @"$$ This is a simple command";
String testComment = @"Just a demo";
// Create a script - empty.
StackHashScript script = new StackHashScript();
script.Add(new StackHashScriptLine(testCommand, testComment));
StackHashScriptSettings scriptSettings = new StackHashScriptSettings(testScriptName, script);
String m_TempFileName = m_TempPath + "\\GeneratedScript.wds";
String outputFileName = "c:\\test\\results.log";
String symPath = null;
String exePath = null;
String srcPath = null;
scriptSettings.GenerateScriptFile(m_TempFileName, outputFileName, ref symPath, ref exePath, ref srcPath);
Assert.AreEqual(null, symPath);
Assert.AreEqual(null, exePath);
Assert.AreEqual(null, srcPath);
// Read all of the data in.
String[] allLines = File.ReadAllLines(m_TempFileName);
Assert.AreEqual(true, File.Exists(m_TempFileName));
// Should contain the script header comment, and one command comment and one command.
Assert.AreEqual(7, allLines.Length);
Assert.AreEqual(true, allLines[0].Contains(outputFileName));
Assert.AreEqual(true, allLines[1].Contains(testScriptName));
Assert.AreEqual(true, allLines[1].Contains(scriptSettings.LastModifiedDate.ToString(CultureInfo.InvariantCulture)));
Assert.AreEqual(true, allLines[2].Contains(scriptSettings.Script[0].Comment));
Assert.AreEqual(true, allLines[3].StartsWith(scriptSettings.Script[0].Command));
Assert.AreEqual(true, allLines[4].Contains(scriptSettings.Script[0].Comment));
Assert.AreEqual(true, allLines[5].Contains("Script Complete"));
Assert.AreEqual(true, allLines[6].Contains(".logclose"));
}
public void RunSimpleScript()
{
// Create a test script.
String testScriptName = "ScriptName";
String testCommand = @"r";
String testComment = @"Just a demo";
StackHashScript script = new StackHashScript();
script.Add(new StackHashScriptLine(testCommand, testComment));
StackHashScriptSettings scriptSettings = new StackHashScriptSettings(testScriptName, script);
String scriptFileName = m_TempPath + @"\GeneratedScript.wds";
String resultsFileName = m_TempPath + @"\Results.log";
String symPath = null;
String exePath = null;
String srcPath = null;
scriptSettings.GenerateScriptFile(scriptFileName, resultsFileName, ref symPath, ref exePath, ref srcPath);
Assert.AreEqual(null, symPath);
Assert.AreEqual(null, exePath);
Assert.AreEqual(null, srcPath);
// Run the script with the debugger.
Windbg debugger = new Windbg();
String dumpFileName = TestSettings.TestDataFolder + @"Dumps\Cucku.exe.mdmp";
StackHashDebuggerSettings debuggerSettings = new StackHashDebuggerSettings();
debuggerSettings.DebuggerPathAndFileName = StackHashDebuggerSettings.Default32BitDebuggerPathAndFileName;
debuggerSettings.SymbolPath = StackHashSearchPath.DefaultSymbolPath;
debugger.RunScript(debuggerSettings, true, scriptFileName, dumpFileName, resultsFileName, symPath, exePath, srcPath);
Assert.AreEqual(true, File.Exists(resultsFileName));
String[] allResults = File.ReadAllLines(resultsFileName, Encoding.Unicode);
Assert.AreEqual(true, allResults.Length > 0);
}
/// <summary>
/// Renames the specified script.
/// </summary>
/// <param name="oldScriptName">Current name of the script.</param>
/// <param name="newScriptName">New name of the script.</param>
public void RenameScript(String oldScriptName, String newScriptName)
{
if (string.IsNullOrEmpty(oldScriptName))
{
throw new ArgumentNullException("oldScriptName");
}
if (string.IsNullOrEmpty(newScriptName))
{
throw new ArgumentNullException("newScriptName");
}
// Don't do anything if the name hasn't changed.
if (oldScriptName == newScriptName)
{
return;
}
String fileName = getScriptFileName(oldScriptName);
if (!File.Exists(fileName))
{
throw new StackHashException("Script name does not exist during rename", StackHashServiceErrorCode.ScriptDoesNotExist);
}
// Load in the script and save it to the new name.
StackHashScriptSettings thisScript = StackHashScriptSettings.Load(fileName);
thisScript.Name = newScriptName;
thisScript.LastModifiedDate = DateTime.Now.ToUniversalTime();
String newFileName = getScriptFileName(newScriptName);
thisScript.Save(newFileName);
// Delete the old script as the renamed version is now available.
File.Delete(fileName);
}
/// <summary>
/// Add a new script.
/// </summary>
/// <param name="script">Full script settings.</param>
/// <param name="overwrite">true - Overwrite any old script of the same name.</param>
/// <param name="allowReadOnlyScriptOverwrite">true - allow read only script to be overwritten.</param>
public void AddScript(StackHashScriptSettings script, bool overwrite, bool allowReadOnlyScriptOverwrite)
{
if (script == null)
{
throw new ArgumentNullException("script");
}
String fileName = getScriptFileName(script.Name);
if (File.Exists(fileName))
{
if (!overwrite)
{
throw new StackHashException("Script file already exists and overWrite not set", StackHashServiceErrorCode.CannotOverwriteScriptFile);
}
else
{
// File already exists. The Created time should remain the same. The update time should change.
StackHashScriptSettings oldScript = StackHashScriptSettings.Load(fileName);
if (oldScript.IsReadOnly && !allowReadOnlyScriptOverwrite)
{
throw new InvalidOperationException("Cannot overwrite Read Only script");
}
script.CreationDate = oldScript.CreationDate;
script.LastModifiedDate = DateTime.Now.ToUniversalTime();
}
}
else
{
script.CreationDate = DateTime.Now.ToUniversalTime();
script.LastModifiedDate = script.CreationDate;
}
script.Save(fileName);
}
public void runAnalyzeJustAutoScripts(ErrorIndexType indexType, int numberOfProducts, int numberOfFiles, int numberOfEvents, int numberOfCabs,
int numberOfAutoUnmanagedAndManagedScripts, int numberOfManualUnmanagedAndManagedScripts,
bool useUnmanagedCabs, int numberOfAutoManagedScripts, int numberOfManualManagedScripts,
int numberOfAutoUnmanagedScripts, int numberOfManualUnmanagedScripts)
{
int numberOfEventInfos = 1;
// Use the dummy winqual.
StackHashTestData testData = new StackHashTestData();
testData.DummyWinQualSettings = new StackHashTestDummyWinQualSettings();
testData.DummyWinQualSettings.UseDummyWinQual = true;
testData.DummyWinQualSettings.ObjectsToCreate = new StackHashTestIndexData();
testData.DummyWinQualSettings.ObjectsToCreate.UseLargeCab = false;
testData.DummyWinQualSettings.ObjectsToCreate.NumberOfProducts = numberOfProducts;
testData.DummyWinQualSettings.ObjectsToCreate.NumberOfFiles = numberOfFiles;
testData.DummyWinQualSettings.ObjectsToCreate.NumberOfEvents = numberOfEvents;
testData.DummyWinQualSettings.ObjectsToCreate.NumberOfEventInfos = numberOfEventInfos;
testData.DummyWinQualSettings.ObjectsToCreate.NumberOfCabs = numberOfCabs;
testData.DummyWinQualSettings.ObjectsToCreate.UseUnmanagedCab = useUnmanagedCabs;
m_Utils.SetTestData(testData);
m_Utils.RegisterForNotifications(true, m_Utils.ApplicationGuid);
m_Utils.CreateNewContext(indexType);
// Set the username and password to something valid.
GetStackHashPropertiesResponse settings = m_Utils.GetContextSettings();
String testPath = "c:\\stackhashunittest\\testindex\\";
settings.Settings.ContextCollection[0].ErrorIndexSettings.Folder = testPath;
settings.Settings.ContextCollection[0].ErrorIndexSettings.Name = "TestIndex";
settings.Settings.ContextCollection[0].WinQualSettings.UserName = m_UserName;
settings.Settings.ContextCollection[0].WinQualSettings.Password = m_Password;
m_Utils.SetContextSettings(settings.Settings.ContextCollection[0]);
// Make sure the index starts off empty.
m_Utils.DeleteIndex(0);
m_Utils.ActivateContext(0);
for (int i = 0; i < numberOfAutoUnmanagedAndManagedScripts; i++)
{
StackHashScriptSettings scriptSettings = m_Utils.MakeScriptSettings(i, true, StackHashScriptDumpType.UnmanagedAndManaged, true);
m_Utils.AddDebuggerScript(scriptSettings, false);
}
for (int i = 0; i < numberOfManualUnmanagedAndManagedScripts; i++)
{
StackHashScriptSettings scriptSettings = m_Utils.MakeScriptSettings(i + 100, true, StackHashScriptDumpType.UnmanagedAndManaged, false);
m_Utils.AddDebuggerScript(scriptSettings, false);
}
for (int i = 0; i < numberOfAutoManagedScripts; i++)
{
StackHashScriptSettings scriptSettings = m_Utils.MakeScriptSettings(i + 200, true, StackHashScriptDumpType.ManagedOnly, true);
m_Utils.AddDebuggerScript(scriptSettings, false);
}
for (int i = 0; i < numberOfManualManagedScripts; i++)
{
StackHashScriptSettings scriptSettings = m_Utils.MakeScriptSettings(i + 300, true, StackHashScriptDumpType.ManagedOnly, false);
m_Utils.AddDebuggerScript(scriptSettings, false);
}
for (int i = 0; i < numberOfAutoUnmanagedScripts; i++)
{
StackHashScriptSettings scriptSettings = m_Utils.MakeScriptSettings(i + 400, true, StackHashScriptDumpType.UnmanagedOnly, true);
m_Utils.AddDebuggerScript(scriptSettings, false);
}
for (int i = 0; i < numberOfManualUnmanagedScripts; i++)
{
StackHashScriptSettings scriptSettings = m_Utils.MakeScriptSettings(i + 500, true, StackHashScriptDumpType.UnmanagedOnly, false);
m_Utils.AddDebuggerScript(scriptSettings, false);
}
try
{
// Synchronize so we have a copy of just the product list.
StartSynchronizationResponse resp = m_Utils.StartSynchronization(0, 60000);
StackHashClientData clientData = m_Utils.LastClientData;
StackHashWinQualSyncCompleteAdminReport adminReport = m_Utils.WinQualSyncAdminReport as StackHashWinQualSyncCompleteAdminReport;
Assert.AreNotEqual(null, adminReport);
Assert.AreEqual(clientData.ApplicationGuid, adminReport.ClientData.ApplicationGuid);
Assert.AreEqual(clientData.ClientId, adminReport.ClientData.ClientId);
Assert.AreEqual(clientData.ClientName, adminReport.ClientData.ClientName);
Assert.AreEqual(clientData.ClientRequestId, adminReport.ClientData.ClientRequestId);
Assert.AreEqual(0, adminReport.ContextId);
Assert.AreEqual(null, adminReport.LastException);
Assert.AreEqual(StackHashAdminOperation.WinQualSyncCompleted, adminReport.Operation);
Assert.AreEqual(StackHashAsyncOperationResult.Success, adminReport.ResultData);
Assert.AreEqual(numberOfProducts, adminReport.ErrorIndexStatistics.Products);
Assert.AreEqual(0, adminReport.ErrorIndexStatistics.Files);
Assert.AreEqual(0, adminReport.ErrorIndexStatistics.Events);
Assert.AreEqual(0, adminReport.ErrorIndexStatistics.Cabs);
Assert.AreEqual(0, adminReport.ErrorIndexStatistics.EventInfos);
// Enable sync for all the products.
GetProductsResponse getProducts = m_Utils.GetProducts(0);
foreach (StackHashProductInfo productInfo in getProducts.Products)
{
Assert.AreEqual(false, productInfo.SynchronizeEnabled);
m_Utils.SetProductSynchronizationState(0, productInfo.Product.Id, true);
// Make sure there are no files for this product yet.
GetFilesResponse getFiles = m_Utils.GetFiles(0, productInfo.Product);
Assert.AreEqual(0, getFiles.Files.Count);
}
// Start the sync and wait for the sync and analyze to complete.
resp = m_Utils.StartSynchronization(0, 120000, false, false, null);
clientData = m_Utils.LastClientData;
adminReport = m_Utils.WinQualSyncAdminReport as StackHashWinQualSyncCompleteAdminReport;
Assert.AreNotEqual(null, adminReport);
Assert.AreEqual(clientData.ApplicationGuid, adminReport.ClientData.ApplicationGuid);
Assert.AreEqual(clientData.ClientId, adminReport.ClientData.ClientId);
Assert.AreEqual(clientData.ClientName, adminReport.ClientData.ClientName);
Assert.AreEqual(clientData.ClientRequestId, adminReport.ClientData.ClientRequestId);
Assert.AreEqual(0, adminReport.ContextId);
Assert.AreEqual(null, adminReport.LastException);
Assert.AreEqual(StackHashAdminOperation.WinQualSyncCompleted, adminReport.Operation);
Assert.AreEqual(StackHashAsyncOperationResult.Success, adminReport.ResultData);
Assert.AreEqual(0, adminReport.ErrorIndexStatistics.Products); // Should have already added the product.
Assert.AreEqual(numberOfFiles * numberOfProducts, adminReport.ErrorIndexStatistics.Files);
Assert.AreEqual(numberOfEvents * numberOfFiles * numberOfProducts, adminReport.ErrorIndexStatistics.Events);
Assert.AreEqual(numberOfCabs * numberOfEvents * numberOfFiles * numberOfProducts, adminReport.ErrorIndexStatistics.Cabs);
Assert.AreEqual(numberOfEventInfos * numberOfEvents * numberOfFiles * numberOfProducts, adminReport.ErrorIndexStatistics.EventInfos);
// Make sure the task is no longer running.
GetStackHashServiceStatusResponse statusResp = m_Utils.GetServiceStatus();
Assert.AreEqual(false, m_Utils.IsTaskRunning(statusResp.Status.ContextStatusCollection[0].TaskStatusCollection, StackHashTaskType.WinQualSynchronizeTask));
Assert.AreEqual(false, m_Utils.IsTaskRunning(statusResp.Status.ContextStatusCollection[0].TaskStatusCollection, StackHashTaskType.AnalyzeTask));
// Check that the scripts have been run ok. Both auto scripts should be run.
StackHashProductInfoCollection products = m_Utils.GetProducts(0).Products;
foreach (StackHashProductInfo product in products)
{
StackHashFileCollection files = m_Utils.GetFiles(0, product.Product).Files;
foreach (StackHashFile file in files)
{
StackHashEventCollection events = m_Utils.GetEvents(0, product.Product, file).Events;
foreach (StackHashEvent currentEvent in events)
{
StackHashEventPackage eventPackage = m_Utils.GetEventPackage(0, product.Product, file, currentEvent).EventPackage;
foreach (StackHashCabPackage cab in eventPackage.Cabs)
{
StackHashScriptResultFiles scriptResults = m_Utils.GetDebugResultFiles(0, product.Product, file, currentEvent, cab.Cab).ResultFiles;
int numberOfAutoScripts = 2;
int expectedResults = numberOfAutoScripts + numberOfAutoUnmanagedAndManagedScripts;
if (!useUnmanagedCabs)
{
expectedResults += numberOfAutoManagedScripts;
}
else
{
expectedResults += numberOfAutoUnmanagedScripts;
}
Assert.AreEqual(expectedResults, scriptResults.Count);
}
}
}
}
}
finally
{
m_Utils.DeactivateContext(0);
m_Utils.DeleteIndex(0);
}
}
