675 lines
23 KiB
C#
675 lines
23 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Diagnostics;
|
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
|
using NLog;
|
|
using Perforce.P4;
|
|
using System.Net.Sockets;
|
|
using System.Net;
|
|
|
|
namespace p4api.net.unit.test
|
|
{
|
|
class ResetServerType
|
|
{
|
|
private bool unicodeReset = false;
|
|
private bool nonUnicodeReset = false;
|
|
public bool IsResetRequired(bool unicode)
|
|
{
|
|
if (unicode)
|
|
return unicodeReset;
|
|
return nonUnicodeReset;
|
|
}
|
|
public void SetResetRequired(bool unicode, bool value)
|
|
{
|
|
if (unicode)
|
|
unicodeReset = value;
|
|
else
|
|
nonUnicodeReset = value;
|
|
}
|
|
|
|
}
|
|
|
|
class Utilities
|
|
{
|
|
private static Logger logger = LogManager.GetCurrentClassLogger();
|
|
private static ResetServerType ResetServer = new ResetServerType();
|
|
private static Stopwatch stopWatchAllTests = null;
|
|
private static Stopwatch stopWatch = null;
|
|
private static int testCount = 0;
|
|
private static string[] settings = new string[] { "P4CLIENT", "P4CONFIG", "P4IGNORE", "P4PASSWD", "P4PORT", "P4TRUST", "P4TICKETS", "P4USER" };
|
|
private static string[] settingValues;
|
|
private static string[] envValues;
|
|
private static string cwd;
|
|
private static int[] preTestObjectCount;
|
|
private static P4CallBacks.LogMessageDelegate logDelegate = null;
|
|
private static LogFile.LogMessageDelgate logFileDelegate = null;
|
|
private static long allocs = 0;
|
|
private static long frees = 0;
|
|
|
|
private static void LogFunction(int log_level, string file, int line, string message)
|
|
{
|
|
logger.Debug(String.Format("{0}({1}): {2}", file, line, message));
|
|
}
|
|
|
|
private static void LogFileFunction(int log_level, string src, string message)
|
|
{
|
|
logger.Debug(String.Format("{0}: {1}", src, message));
|
|
}
|
|
|
|
private static void SaveP4Prefs()
|
|
{
|
|
settingValues = new string[settings.Length];
|
|
envValues = new string[settings.Length];
|
|
for (int i = 0; i < settings.Length; i++)
|
|
{
|
|
settingValues[i] = P4Server.Get(settings[i]);
|
|
// also clear the value
|
|
P4Server.Set(settings[i], "");
|
|
}
|
|
}
|
|
|
|
private static void RestoreP4Prefs()
|
|
{
|
|
P4Bridge.ReloadEnviro();
|
|
|
|
for (int i = 0; i < settings.Length; i++)
|
|
{
|
|
P4Server.Set(settings[i], settingValues[i]);
|
|
}
|
|
}
|
|
|
|
public static void LogTestStart(TestContext testContext)
|
|
{
|
|
// save and restore the p4config env variable and the cwd
|
|
SaveP4Prefs();
|
|
allocs = P4Debugging.GetStringAllocs();
|
|
frees = P4Debugging.GetStringReleases();
|
|
|
|
cwd = System.IO.Directory.GetCurrentDirectory();
|
|
|
|
logDelegate = new P4CallBacks.LogMessageDelegate(LogFunction);
|
|
logFileDelegate = new LogFile.LogMessageDelgate(LogFileFunction);
|
|
|
|
LogFile.SetLoggingFunction(logFileDelegate);
|
|
|
|
P4Debugging.SetBridgeLogFunction(logDelegate);
|
|
preTestObjectCount = new int[P4Debugging.GetAllocObjectCount()];
|
|
|
|
for (int i = 0; i < preTestObjectCount.Length; i++)
|
|
{
|
|
preTestObjectCount[i] = P4Debugging.GetAllocObject(i);
|
|
}
|
|
|
|
// reset the p4d_cmd variable to the default
|
|
p4d_cmd = _p4d_cmd;
|
|
|
|
testCount++;
|
|
logger.Info("====== TestName: {0}", testContext.TestName);
|
|
stopWatch = Stopwatch.StartNew();
|
|
if (stopWatchAllTests == null)
|
|
stopWatchAllTests = Stopwatch.StartNew();
|
|
}
|
|
|
|
public static void LogTestFinish(TestContext testContext)
|
|
{
|
|
System.IO.Directory.SetCurrentDirectory(cwd);
|
|
RestoreP4Prefs();
|
|
|
|
logger.Info("------ {0}: {1}, {2} ms", testContext.TestName, testContext.CurrentTestOutcome, stopWatch.ElapsedMilliseconds);
|
|
|
|
int iExtraObjects = 0;
|
|
for (int i = 0; i < P4Debugging.GetAllocObjectCount(); i++)
|
|
{
|
|
int postTest = P4Debugging.GetAllocObject(i);
|
|
if (preTestObjectCount[i] != postTest)
|
|
{
|
|
iExtraObjects += postTest - preTestObjectCount[i];
|
|
logger.Info(String.Format("<<<<*** Item count for {0} mismatch: {1}/{2}",
|
|
P4Debugging.GetAllocObjectName(i), preTestObjectCount[i], postTest));
|
|
}
|
|
}
|
|
|
|
long postAllocs = P4Debugging.GetStringAllocs();
|
|
long postFrees = P4Debugging.GetStringReleases();
|
|
|
|
if (postAllocs - allocs != postFrees - frees)
|
|
{
|
|
logger.Info(String.Format("<<<<*** String alloc mismatch: {0}/{1}", postAllocs - allocs, postFrees - frees));
|
|
Assert.AreEqual(postAllocs - allocs, postFrees - frees);
|
|
}
|
|
|
|
Assert.AreEqual(0, iExtraObjects);
|
|
}
|
|
|
|
public static void LogAllTestsFinish()
|
|
{
|
|
logger.Info("@@@@@@ Time for tests: {0} - {1} s", testCount, stopWatchAllTests.Elapsed);
|
|
}
|
|
|
|
public static void ClobberDirectory(String path)
|
|
{
|
|
DirectoryInfo di = new DirectoryInfo(path);
|
|
|
|
ClobberDirectory(di);
|
|
}
|
|
|
|
public static void ClobberDirectory(DirectoryInfo di)
|
|
{
|
|
string comSpec = Environment.GetEnvironmentVariable("ComSpec");
|
|
Process Zapper = new Process();
|
|
ProcessStartInfo si = new ProcessStartInfo(comSpec, "/c rd /S /Q " + di.FullName);
|
|
si.WorkingDirectory = Path.GetDirectoryName(di.FullName);
|
|
si.UseShellExecute = true;
|
|
|
|
Zapper.StartInfo = si;
|
|
try
|
|
{
|
|
Zapper.Start();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Info("In ClobberDirectory, Zapper.Start() failed: {0}", ex.Message);
|
|
}
|
|
if (Zapper.HasExited == false)
|
|
{
|
|
Zapper.WaitForExit();
|
|
}
|
|
if (Directory.Exists(di.FullName))
|
|
{
|
|
bool worked = false;
|
|
int retries = 0;
|
|
do
|
|
{
|
|
if (!di.Exists)
|
|
return;
|
|
|
|
try
|
|
{
|
|
FileInfo[] files = di.GetFiles();
|
|
|
|
foreach (FileInfo fi in files)
|
|
{
|
|
if (fi.IsReadOnly)
|
|
fi.IsReadOnly = false;
|
|
fi.Delete();
|
|
}
|
|
DirectoryInfo[] subDirs = di.GetDirectories();
|
|
foreach (DirectoryInfo sdi in subDirs)
|
|
{
|
|
ClobberDirectory(sdi);
|
|
}
|
|
|
|
di.Delete();
|
|
|
|
worked = true;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
System.Threading.Thread.Sleep(100);
|
|
}
|
|
retries++;
|
|
}
|
|
while (!worked && retries < 2);
|
|
}
|
|
}
|
|
|
|
static string p4d_exe = System.Environment.GetEnvironmentVariable("P4DPATH");
|
|
//const String _p4d_cmd = "-vrpc=3 -vnet=9 -p localhost:6666 -Id {1} -r {0} -L p4d.log -vserver=3";
|
|
const String _p4d_cmd = "-p localhost:6666 -Id {1} -r {0} -L p4d.log";
|
|
static String p4d_cmd = null;
|
|
static String rsh_p4d_cmd = "rsh:" + p4d_exe + " -r {0} -L p4d.log -vserver=3 -i";
|
|
static String restore_cmd = "-r {0} -jr checkpoint.{1}";
|
|
static String upgrade_cmd = "-r {0} -xu";
|
|
static String generate_key_cmd = string.Empty;
|
|
static string rubbishBin = "c:\\MyTestDir-rubbish-bin";
|
|
|
|
|
|
|
|
|
|
public static Process DeploySSLP4TestServer(string path, bool Unicode)
|
|
{
|
|
System.Environment.SetEnvironmentVariable("P4SSLDIR", path);
|
|
string test = System.Environment.GetEnvironmentVariable("P4SSLDIR");
|
|
p4d_cmd = "-p ssl:6666 -Id UnitTestServer -r {0}";
|
|
generate_key_cmd = "-Gc";
|
|
return DeployP4TestServer(path, 1, Unicode);
|
|
}
|
|
|
|
public static Process DeployIPv6P4TestServer(string path, string tcp, bool Unicode)
|
|
{
|
|
p4d_cmd = "-p " + tcp + ":::1:6666 -Id UnitTestServer -r {0}";
|
|
return DeployP4TestServer(path, 1, Unicode);
|
|
}
|
|
|
|
public static Process DeployP4TestServer(string path, bool unicode, string testName="")
|
|
{
|
|
return DeployP4TestServer(path, 1, unicode, testName);
|
|
}
|
|
|
|
public static string TestServerRoot(string baseRoot, bool Unicode)
|
|
{
|
|
String extra = "a";
|
|
if (Unicode)
|
|
{
|
|
extra = "u";
|
|
}
|
|
var root = Path.Combine(baseRoot, extra, "server");
|
|
logger.Debug("Server root: {0}", root);
|
|
return root;
|
|
}
|
|
|
|
public static string TestRshServerPort(string baseRoot, bool Unicode)
|
|
{
|
|
String extra = "a";
|
|
if (Unicode)
|
|
{
|
|
extra = "u";
|
|
}
|
|
var root = Path.Combine(baseRoot, extra, "server");
|
|
root = String.Format(rsh_p4d_cmd, root);
|
|
logger.Debug("Server root: {0}", root);
|
|
return root;
|
|
}
|
|
|
|
public static string TestClientRoot(string baseRoot, bool Unicode)
|
|
{
|
|
String extra = "a";
|
|
if (Unicode)
|
|
{
|
|
extra = "u";
|
|
}
|
|
var root = Path.Combine(baseRoot, extra, "clients");
|
|
logger.Debug("Client root: {0}", root);
|
|
return root;
|
|
}
|
|
|
|
public static void SetClientRoot(Repository rep, string TestDir, bool unicode, string ws_client)
|
|
{
|
|
Client c = rep.GetClient(ws_client, null);
|
|
c.Root = Path.Combine(TestClientRoot(TestDir, unicode), ws_client);
|
|
rep.UpdateClient(c);
|
|
var syncOpts = new SyncFilesCmdOptions(SyncFilesCmdFlags.Force, 0);
|
|
rep.Connection.Client.SyncFiles(syncOpts, new FileSpec(new DepotPath("//...")));
|
|
}
|
|
|
|
|
|
public static Process DeployP4TestServer(string path, int checkpointRev, bool unicode, string testName = "")
|
|
{
|
|
String zippedFile = "a.exe";
|
|
string currentPath = Directory.GetCurrentDirectory();
|
|
if (unicode)
|
|
{
|
|
zippedFile = "u.exe";
|
|
}
|
|
return DeployP4TestServer(path, checkpointRev, zippedFile, unicode, testName);
|
|
}
|
|
|
|
public static Process DeployP4TestServer(string path, int checkpointRev, string zippedFile, bool unicode, string testName = "")
|
|
{
|
|
return DeployP4TestServer(path, checkpointRev, zippedFile, null, unicode, testName);
|
|
}
|
|
|
|
public static Process DeployP4TestServer(string testRoot, int checkpointRev, string zippedFile, string P4DCmd,
|
|
bool unicode, string testName = "")
|
|
{
|
|
logger.Info("DeployP4TestServer");
|
|
if (!Directory.Exists(rubbishBin))
|
|
{
|
|
Directory.CreateDirectory(rubbishBin);
|
|
}
|
|
|
|
string assemblyFile = typeof(Utilities).Assembly.CodeBase;
|
|
String unitTestDir = Path.GetDirectoryName(assemblyFile);
|
|
|
|
String EnvPath = Environment.GetEnvironmentVariable("path");
|
|
String CurWDir = Environment.CurrentDirectory;
|
|
|
|
var zipBase = Path.GetFileNameWithoutExtension(zippedFile); // a or u
|
|
var unzippedContentsDir = Path.Combine(rubbishBin, zipBase);
|
|
var testServerRoot = Path.Combine(testRoot, zipBase, "server");
|
|
var testClientsRoot = Path.Combine(testRoot, zipBase, "clients");
|
|
CreateDir(testServerRoot, 10);
|
|
try
|
|
{
|
|
Environment.CurrentDirectory = testServerRoot;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
bool dirExists = Directory.Exists(testServerRoot);
|
|
logger.Error("Can't cd to {0}, {1}", testServerRoot, ex.Message);
|
|
return null;
|
|
}
|
|
using (StreamWriter sw = new StreamWriter("CmdLog.txt", false))
|
|
{
|
|
int idx;
|
|
if (unitTestDir.ToLower().StartsWith("file:\\"))
|
|
{
|
|
// cut off the file:\\
|
|
idx = unitTestDir.IndexOf("\\") + 1;
|
|
unitTestDir = unitTestDir.Substring(idx);
|
|
}
|
|
// if ((idx = unitTestDir.IndexOf("TestResults")) > 0)
|
|
// {
|
|
// unitTestDir = unitTestDir.Substring(0, idx);
|
|
//if (unitTestDir.ToLower().Contains("bin\\debug") == false) // is this needed?
|
|
//{
|
|
// unitTestDir = Path.Combine(unitTestDir, "bin\\debug");
|
|
//}
|
|
//}
|
|
|
|
// Decide whether to reset server
|
|
bool resetServerDir = ResetServer.IsResetRequired(unicode);
|
|
ResetServer.SetResetRequired(unicode, false);
|
|
|
|
ProcessStartInfo si;
|
|
String msg;
|
|
string unitTestZip = Path.Combine(unitTestDir, zippedFile);
|
|
string targetTestZip = Path.Combine(unzippedContentsDir, zippedFile);
|
|
if (!Directory.Exists(unzippedContentsDir))
|
|
{
|
|
// Copy file and unzip it
|
|
CreateDir(unzippedContentsDir, 5);
|
|
CopyFile(unitTestZip, targetTestZip);
|
|
FileInfo fi = new FileInfo(targetTestZip);
|
|
|
|
Process Unzipper = new Process();
|
|
|
|
// unpack the zip
|
|
si = new ProcessStartInfo(zippedFile);
|
|
si.WorkingDirectory = unzippedContentsDir;
|
|
si.Arguments = "-y";
|
|
|
|
logger.Info("Unzipping {0} {1}", si.FileName, si.Arguments);
|
|
|
|
Unzipper.StartInfo = si;
|
|
Unzipper.Start();
|
|
Unzipper.WaitForExit();
|
|
|
|
// Copy unzipped directory tree
|
|
CopyDirTree(unzippedContentsDir, testServerRoot);
|
|
}
|
|
else if (resetServerDir)
|
|
{
|
|
CopyDirTree(unzippedContentsDir, testServerRoot);
|
|
}
|
|
|
|
// Make sure no db.* files present
|
|
logger.Info("Removing db.* from {0}", testServerRoot);
|
|
try
|
|
{
|
|
foreach (string fname in Directory.GetFiles(testServerRoot, "db.*", SearchOption.TopDirectoryOnly))
|
|
{
|
|
System.IO.File.Delete(fname);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error(ex.Message);
|
|
logger.Error(ex.StackTrace);
|
|
}
|
|
// Reset client directories
|
|
DelDir(testClientsRoot);
|
|
CreateDir(testClientsRoot, 5);
|
|
foreach (
|
|
string fname in Directory.GetDirectories(unzippedContentsDir, "*space*", SearchOption.TopDirectoryOnly)
|
|
)
|
|
{
|
|
var dirOnly = Path.GetFileName(fname);
|
|
CopyDirTree(fname, Path.Combine(testClientsRoot, dirOnly));
|
|
}
|
|
|
|
if (p4d_cmd.Contains("ssl:"))
|
|
{
|
|
Process GenKeyandCert = new Process();
|
|
|
|
// generate private key and certificate
|
|
si = new ProcessStartInfo(p4d_exe);
|
|
si.Arguments = generate_key_cmd;
|
|
si.WorkingDirectory = testServerRoot;
|
|
si.UseShellExecute = false;
|
|
si.CreateNoWindow = true;
|
|
si.RedirectStandardOutput = true;
|
|
|
|
msg = si.Arguments;
|
|
logger.Info(msg);
|
|
|
|
GenKeyandCert.StartInfo = si;
|
|
GenKeyandCert.Start();
|
|
GenKeyandCert.WaitForExit();
|
|
}
|
|
|
|
// restore the checkpoint
|
|
Process RestoreCheckPoint = new Process();
|
|
si = new ProcessStartInfo(p4d_exe);
|
|
si.Arguments = String.Format(restore_cmd, testServerRoot, checkpointRev);
|
|
//si.FileName = "p4d.exe";
|
|
si.WorkingDirectory = testServerRoot;
|
|
si.UseShellExecute = false;
|
|
si.RedirectStandardOutput = true;
|
|
si.CreateNoWindow = true;
|
|
|
|
logger.Info("{0} {1}", si.FileName, si.Arguments);
|
|
|
|
RestoreCheckPoint.StartInfo = si;
|
|
RestoreCheckPoint.Start();
|
|
RestoreCheckPoint.WaitForExit();
|
|
|
|
if (RestoreCheckPoint.ExitCode != 0)
|
|
return null;
|
|
|
|
// upgrade the db tables
|
|
Process UpgradeTables = new Process();
|
|
si = new ProcessStartInfo(p4d_exe);
|
|
si.Arguments = String.Format(upgrade_cmd, testServerRoot);
|
|
si.WorkingDirectory = testServerRoot;
|
|
si.UseShellExecute = false;
|
|
si.CreateNoWindow = true;
|
|
si.RedirectStandardOutput = true;
|
|
|
|
logger.Info("{0} {1}", si.FileName, si.Arguments);
|
|
|
|
UpgradeTables.StartInfo = si;
|
|
UpgradeTables.Start();
|
|
UpgradeTables.WaitForExit();
|
|
|
|
if (UpgradeTables.ExitCode != 0)
|
|
return null;
|
|
|
|
Process p4d = new Process();
|
|
|
|
if (P4DCmd != null)
|
|
{
|
|
string P4DCmdSrc = Path.Combine(unitTestDir, P4DCmd);
|
|
string P4DCmdTarget = Path.Combine(testServerRoot, P4DCmd);
|
|
System.IO.File.Copy(P4DCmdSrc, P4DCmdTarget);
|
|
|
|
// run the command to start p4d
|
|
si = new ProcessStartInfo(P4DCmdTarget);
|
|
si.Arguments = String.Format(testServerRoot);
|
|
si.WorkingDirectory = testServerRoot;
|
|
si.UseShellExecute = false;
|
|
si.CreateNoWindow = true;
|
|
si.RedirectStandardOutput = true;
|
|
|
|
logger.Info("{0} {1}", si.FileName, si.Arguments);
|
|
|
|
p4d.StartInfo = si;
|
|
p4d.Start();
|
|
}
|
|
else
|
|
{
|
|
//start p4d
|
|
si = new ProcessStartInfo(p4d_exe);
|
|
if (string.IsNullOrEmpty(testName))
|
|
testName = "UnitTestServer";
|
|
si.Arguments = String.Format(p4d_cmd, testServerRoot, testName);
|
|
si.WorkingDirectory = testServerRoot;
|
|
si.UseShellExecute = false;
|
|
si.RedirectStandardOutput = true;
|
|
si.CreateNoWindow = true;
|
|
|
|
logger.Info("{0} {1}", si.FileName, si.Arguments);
|
|
|
|
p4d.StartInfo = si;
|
|
p4d.Start();
|
|
}
|
|
Environment.CurrentDirectory = CurWDir;
|
|
|
|
// Give p4d time to start up
|
|
DateTime started = DateTime.UtcNow;
|
|
TcpClient client = new TcpClient();
|
|
while (DateTime.UtcNow.Subtract(started).Milliseconds < 500)
|
|
{
|
|
client.Connect("localhost", 6666);
|
|
if (client.Connected)
|
|
return p4d;
|
|
}
|
|
|
|
// that didn't work
|
|
return p4d;
|
|
}
|
|
}
|
|
|
|
private static void CopyDirTree(string srcDir, string targDir)
|
|
{
|
|
logger.Info("Copying directory {0} to {1}", srcDir, targDir);
|
|
// First Create all of the directories
|
|
foreach (string dirPath in Directory.GetDirectories(srcDir, "*",
|
|
SearchOption.AllDirectories))
|
|
Directory.CreateDirectory(dirPath.Replace(srcDir, targDir));
|
|
|
|
// Then copy all the files & Replaces any files with the same name
|
|
foreach (string fname in Directory.GetFiles(srcDir, "*.*", SearchOption.AllDirectories))
|
|
{
|
|
var target = fname.Replace(srcDir, targDir);
|
|
try
|
|
{
|
|
System.IO.File.Copy(fname, target, true);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Debug(ex.Message);
|
|
}
|
|
}
|
|
logger.Info("Finished copying {0} to {1}", srcDir, targDir);
|
|
}
|
|
|
|
private static void CopyFile(string srcFile, string targetFile)
|
|
{
|
|
int retries = 3;
|
|
int delay = 1000; // initial delay 1 second
|
|
while (retries > 0)
|
|
{
|
|
try
|
|
{
|
|
System.IO.File.Copy(srcFile, targetFile);
|
|
break; //success
|
|
} catch (Exception)
|
|
{
|
|
System.Threading.Thread.Sleep(delay);
|
|
delay *= 2; // wait twice as long next time
|
|
retries--;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void CreateDir(string path, int retries)
|
|
{
|
|
while ((Directory.Exists(path) == false) && (retries > 0))
|
|
{
|
|
try
|
|
{
|
|
Directory.CreateDirectory(path);
|
|
if (Directory.Exists(path))
|
|
{
|
|
break;
|
|
}
|
|
retries--;
|
|
System.Threading.Thread.Sleep(1000);
|
|
} catch (Exception ex)
|
|
{
|
|
retries--;
|
|
bool dirExists = Directory.Exists(path);
|
|
Trace.WriteLine(ex.Message);
|
|
if (dirExists)
|
|
{
|
|
break;
|
|
}
|
|
System.Threading.Thread.Sleep(200);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private static void DelDir(string dirPath)
|
|
{
|
|
if (!Directory.Exists(dirPath))
|
|
return;
|
|
try
|
|
{
|
|
Directory.Delete(dirPath, true);
|
|
} catch
|
|
{
|
|
try
|
|
{
|
|
// delete failed, try to rename it
|
|
Directory.Move(dirPath, string.Format("{0}-{1}", dirPath, DateTime.Now.Ticks));
|
|
} catch
|
|
{
|
|
// rename failed, try to clobber it (can be slow so last resort)
|
|
Utilities.ClobberDirectory(dirPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void RemoveTestServer(Process p, String testRoot, bool resetDepot=false, bool unicode=false)
|
|
{
|
|
logger.Info("RemoveTestServer");
|
|
if (p != null)
|
|
{
|
|
if (!p.HasExited)
|
|
p.Kill();
|
|
p.WaitForExit();
|
|
// sleep for a second to let the system clean up
|
|
// System.Threading.Thread.Sleep(100);
|
|
}
|
|
MainTest.RememberToCleanup(rubbishBin);
|
|
MainTest.RememberToCleanup(testRoot);
|
|
// Flag for next unit test to reset depot - see DeployP4TestServer
|
|
ResetServer.SetResetRequired(unicode, resetDepot);
|
|
}
|
|
|
|
private static void MoveDir(string srcDir, string targDir)
|
|
{
|
|
logger.Info("Moving {0} to {1}", srcDir, targDir);
|
|
try
|
|
{
|
|
int retries = 60;
|
|
while ((Directory.Exists(srcDir)) && (retries > 0))
|
|
{
|
|
try
|
|
{
|
|
// Try to rename it
|
|
Directory.Move(srcDir, targDir);
|
|
//must have worked
|
|
break;
|
|
} catch
|
|
{
|
|
retries--;
|
|
System.Threading.Thread.Sleep(1000);
|
|
if (retries <= 0)
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
} catch (Exception ex)
|
|
{
|
|
logger.Info("In DeployP4TestServer, Directory.Move failed: {0}", ex.Message);
|
|
// rename failed, try to clobber it (can be slow so last resort)
|
|
Utilities.ClobberDirectory(srcDir);
|
|
}
|
|
}
|
|
}
|
|
}
|