public void WindowsFileMoveToWindowsDirectory()
{
if (!Global.TestWindows)
{
throw new Exception("Windows Tests Are Not Enabled. Set Global.TestWindows To True To Enable.");
}
ZephyrDirectory source = Global.StageTestFilesToWindows();
string path = Path.Combine(Global.WindowsWorkingPath, $"{Global.RandomDirectory}\\");
ZephyrDirectory target = new WindowsZephyrDirectory(path);
List <ZephyrFile> files = (List <ZephyrFile>)source.GetFiles();
Assert.IsNotEmpty(files);
foreach (ZephyrFile file in files)
{
String filePath = Path.Combine(target.FullName, file.Name);
file.MoveTo(target);
Assert.That(File.Exists(filePath));
Assert.That(!file.Exists);
Utilities.Delete(filePath, Global.Clients);
}
source.Delete();
}
public void AwsS3FileWriteAllText()
{
if (!Global.TestAws)
{
throw new Exception("Amazon S3 Tests Are Not Enabled. Set Global.TestAws To True To Enable.");
}
ZephyrDirectory source = Global.StageTestFilesToAws();
List <ZephyrFile> files = (List <ZephyrFile>)source.GetFiles();
Assert.IsNotEmpty(files);
foreach (ZephyrFile file in files)
{
Console.WriteLine($"File: {file.FullName}");
string content = file.ReadAllText();
string outPath = $"{source.FullName}{Global.RandomFile}";
ZephyrFile outFile = source.CreateFile(outPath);
outFile.WriteAllText(content);
string outText = outFile.ReadAllText();
Assert.AreEqual(content, outText);
outFile.Delete();
}
source.Delete();
}
public void AwsS3FileMoveToAwsS3Directory()
{
if (!Global.TestAws)
{
throw new Exception("Amazon S3 Tests Are Not Enabled. Set Global.TestAws To True To Enable.");
}
ZephyrDirectory source = Global.StageTestFilesToAws();
string path = $"{Global.AwsS3WorkingPath}{Global.RandomDirectory}/";
ZephyrDirectory target = new AwsS3ZephyrDirectory(Global.Clients.aws, path);
List <ZephyrFile> files = (List <ZephyrFile>)source.GetFiles();
Assert.IsNotEmpty(files);
foreach (ZephyrFile file in files)
{
String filePath = $"{target.FullName}{file.Name}";
file.MoveTo(target);
Assert.That(Utilities.Exists(filePath, Global.Clients));
Assert.That(!file.Exists);
Utilities.Delete(filePath, Global.Clients);
}
source.Delete();
}
public void WindowsFileWriteAllLines()
{
if (!Global.TestWindows)
{
throw new Exception("Windows Tests Are Not Enabled. Set Global.TestWindows To True To Enable.");
}
ZephyrDirectory source = Global.StageTestFilesToWindows();
List <ZephyrFile> files = (List <ZephyrFile>)source.GetFiles();
Assert.IsNotEmpty(files);
foreach (ZephyrFile file in files)
{
Console.WriteLine($"File: {file.FullName}");
string[] lines = file.ReadAllLines();
string outPath = Path.Combine(source.FullName, Global.RandomFile);
ZephyrFile outFile = source.CreateFile(outPath);
outFile.WriteAllLines(lines);
string[] outLines = outFile.ReadAllLines();
Assert.AreEqual(lines.Length, outLines.Length);
for (int i = 0; i < lines.Length; i++)
{
Assert.AreEqual(lines[i], outLines[i]);
}
outFile.Delete();
}
source.Delete();
}
public void AwsS3FileWriteAllBytes()
{
if (!Global.TestAws)
{
throw new Exception("Amazon S3 Tests Are Not Enabled. Set Global.TestAws To True To Enable.");
}
ZephyrDirectory source = Global.StageTestFilesToAws();
List <ZephyrFile> files = (List <ZephyrFile>)source.GetFiles();
Assert.IsNotEmpty(files);
foreach (ZephyrFile file in files)
{
Console.WriteLine($"File: {file.FullName}");
byte[] bytes = file.ReadAllBytes();
string outPath = $"{source.FullName}{Global.RandomFile}";
ZephyrFile outFile = source.CreateFile(outPath);
outFile.WriteAllBytes(bytes);
byte[] outBytes = outFile.ReadAllBytes();
Assert.AreEqual(bytes.Length, outBytes.Length);
for (int i = 0; i < bytes.Length; i++)
{
Assert.AreEqual(bytes[i], outBytes[i]);
}
outFile.Delete();
}
source.Delete();
}
public void AwsS3DirectoryMoveToWindowsDirectory()
{
if (!Global.TestAws)
{
throw new Exception("Amazon S3 Tests Are Not Enabled. Set Global.TestAws To True To Enable.");
}
ZephyrDirectory source = Global.StageTestFilesToAws();
Console.WriteLine($"Source : {source.FullName}");
String path = $"{Global.AwsS3WorkingPath}{Global.RandomDirectory}/";
Console.WriteLine($"Target : {path}");
ZephyrDirectory target = Global.AwsS3WorkingDirectory.CreateDirectory(path);
target.Create();
String sourceCount = Global.DirectoryObjectCounts(source);
Console.WriteLine($">> Source : [{sourceCount}]");
source.MoveTo(target);
String targetCount = Global.DirectoryObjectCounts(target);
Console.WriteLine($">> Target : [{targetCount}]");
Assert.AreEqual(sourceCount, targetCount);
Assert.That(source.IsEmpty);
target.Delete();
source.Delete();
}
public void WindowsDirectoryMoveToWindowsDirectory()
{
ZephyrDirectory source = Global.StageTestFilesToWindows();
Console.WriteLine($"Source : {source.FullName}");
String path = Path.Combine(Global.WindowsWorkingPath, $"{Global.RandomDirectory}\\");
Console.WriteLine($"Target : {path}");
ZephyrDirectory target = Global.WindowsWorkingDirectory.CreateDirectory(path);
target.Create();
String sourceCount = Global.DirectoryObjectCounts(source);
Console.WriteLine($">> Source : [{sourceCount}]");
source.MoveTo(target);
String targetCount = Global.DirectoryObjectCounts(target);
Console.WriteLine($">> Target : [{targetCount}]");
Assert.AreEqual(sourceCount, targetCount);
Assert.That(source.IsEmpty);
target.Delete();
source.Delete();
}
public override ExecuteResult Execute(HandlerStartInfo startInfo)
{
ExecuteResult result = new ExecuteResult();
result.Status = StatusType.Success;
int cheapSequence = 0;
// TODO : Implement DryRun Functionality
if (startInfo.IsDryRun)
{
throw new NotImplementedException("Dry Run Functionality Has Not Yet Been Implemented.");
}
OnProgress("DeleteFileHandler", "Handler Execution Begins.", StatusType.Running, 0, cheapSequence++);
try
{
if (startInfo.Parameters != null)
{
parameters = HandlerUtils.Deserialize <DeleteFileHandlerParameters>(startInfo.Parameters);
}
bool isValid = Validate();
if (isValid)
{
if (parameters.Targets != null)
{
OnLogMessage("DeleteFileHandler", $"Starting Delete Of [{string.Join(",", parameters.Targets.ToArray())}]");
foreach (String target in parameters.Targets)
{
if (Utilities.IsDirectory(target))
{
ZephyrDirectory dir = Utilities.GetZephyrDirectory(target, clients);
dir.Delete(config.Recurse, config.StopOnError, config.Verbose, "DeleteFileHandler", Logger);
}
else
{
ZephyrFile file = Utilities.GetZephyrFile(target, clients);
file.Delete(config.StopOnError, config.Verbose, "DeleteFileHandler", Logger);
}
}
OnLogMessage("DeleteFileHandler", $"Finished Delete Of [{string.Join(",", parameters.Targets.ToArray())}]");
}
}
else
{
OnLogMessage("DeleteFileHandler", "Validation Failed.", LogLevel.Error);
throw new Exception("Invalid Input Received");
}
}
catch (Exception e)
{
OnProgress("DeleteFileHandler", "Handler Execution Failed.", StatusType.Failed, 0, cheapSequence++, false, e);
throw e;
}
OnProgress("DeleteFileHandler", "Handler Execution Completed.", StatusType.Complete, 0, cheapSequence++);
return(result);
}
public void WindowsDirectoryCreateDirectoryMethod()
{
String path = Path.Combine(Global.WindowsWorkingPath, $"{Global.RandomDirectory}\\");
Console.WriteLine(path);
ZephyrDirectory dir = Global.WindowsWorkingDirectory.CreateDirectory(path);
Assert.That(!dir.Exists);
dir.Create();
Assert.That(dir.Exists);
dir.Delete();
}
public static ZephyrDirectory StageTestFilesToWindows()
{
String path = Path.Combine(WindowsWorkingPath, $"{RandomDirectory}\\");
Console.WriteLine($"{path}");
ZephyrDirectory dir = WindowsWorkingDirectory.CreateDirectory(path);
dir.Create();
TestFilesDirectory.CopyTo(dir, verbose: false);
return(dir);
}
public static ZephyrDirectory StageTestFilesToAws()
{
String path = $"{AwsS3WorkingPath}{RandomDirectory}/";
Console.WriteLine($"{path}");
ZephyrDirectory dir = AwsS3WorkingDirectory.CreateDirectory(path);
dir.Create();
TestFilesDirectory.CopyTo(dir, verbose: false);
return(dir);
}
public void WindowsDirectoryPathCombine()
{
String path = Path.Combine(Global.WindowsWorkingPath, $"{Global.RandomDirectory}\\");
Console.WriteLine(path);
ZephyrDirectory dir = Global.WindowsWorkingDirectory.CreateDirectory(path);
string testpath = dir.PathCombine(dir.FullName, "michael\\", "j\\", "fox\\");
Console.WriteLine($"Test Path : {testpath}");
Assert.AreEqual(testpath, $"{dir.FullName}michael\\j\\fox\\");
}
public void WindowsDirectoryPurge()
{
ZephyrDirectory dir = Global.StageTestFilesToWindows();
Assert.That(!dir.IsEmpty);
dir.Purge();
Assert.That(dir.Exists);
Assert.That(dir.IsEmpty);
dir.Delete();
}
public void WindowsDirectoryIsEmpty()
{
String path = Path.Combine(Global.WindowsWorkingPath, $"{Global.RandomDirectory}\\");
Console.WriteLine($"{path}");
ZephyrDirectory dir = Global.WindowsWorkingDirectory.CreateDirectory(path);
dir.Create();
Assert.That(dir.IsEmpty);
Global.TestFilesDirectory.CopyTo(dir, verbose: false);
Assert.That(!dir.IsEmpty);
dir.Delete();
}
public static string DirectoryObjectCounts(ZephyrDirectory dir)
{
List <ZephyrDirectory> dirs = (List <ZephyrDirectory>)dir.GetDirectories();
List <ZephyrFile> files = (List <ZephyrFile>)dir.GetFiles();
//TODO: Sort Directories To Ensure Counts Come Back In Same Order
String counts = $"{dirs.Count},{files.Count}";
foreach (ZephyrDirectory childDir in dirs)
{
counts = $"{counts},{DirectoryObjectCounts(childDir)}";
}
return(counts);
}
public void WindowsDirectoryGetDirectoriesandGetFiles()
{
ZephyrDirectory dir = Global.StageTestFilesToWindows();
List <ZephyrDirectory> dirs = (List <ZephyrDirectory>)(dir.GetDirectories());
Console.WriteLine($"Found [{dirs.Count}] Sub-directories.");
Assert.AreEqual(dirs.Count, 3);
List <ZephyrFile> files = (List <ZephyrFile>)(dir.GetFiles());
Console.WriteLine($"Found [{files.Count}] Files.");
Assert.AreEqual(files.Count, 5);
dir.Delete(verbose: false);
}
public void AwsS3DirectoryPurge()
{
if (!Global.TestAws)
{
throw new Exception("Amazon S3 Tests Are Not Enabled. Set Global.TestAws To True To Enable.");
}
ZephyrDirectory dir = Global.StageTestFilesToAws();
Assert.IsFalse(dir.IsEmpty);
dir.Purge();
Assert.IsTrue(dir.Exists);
Assert.IsTrue(dir.IsEmpty);
dir.Delete();
}
public void AwsS3DirectoryPathCombine()
{
if (!Global.TestAws)
{
throw new Exception("Amazon S3 Tests Are Not Enabled. Set Global.TestAws To True To Enable.");
}
String path = $"{Global.AwsS3WorkingPath}{Global.RandomDirectory}/";
Console.WriteLine(path);
ZephyrDirectory dir = Global.AwsS3WorkingDirectory.CreateDirectory(path);
string testpath = dir.PathCombine(dir.FullName, "michael/", "j/", "fox/");
Console.WriteLine($"Test Path : {testpath}");
Assert.AreEqual(testpath, $"{dir.FullName}michael/j/fox/");
}
public void AwsS3DirectoryCreateDirectoryMethod()
{
if (!Global.TestAws)
{
throw new Exception("Amazon S3 Tests Are Not Enabled. Set Global.TestAws To True To Enable.");
}
String path = $"{Global.AwsS3WorkingPath}{Global.RandomDirectory}/";
Console.WriteLine(path);
ZephyrDirectory dir = Global.AwsS3WorkingDirectory.CreateDirectory(path);
Assert.IsFalse(dir.Exists);
dir.Create();
Assert.IsTrue(dir.Exists);
dir.Delete();
}
public void WindowsFileCreateDirectoryMethod()
{
if (!Global.TestWindows)
{
throw new Exception("Windows Tests Are Not Enabled. Set Global.TestWindows To True To Enable.");
}
String path = Path.Combine(Global.WindowsWorkingPath, $"{Global.RandomFile}");
Console.WriteLine(path);
ZephyrFile file = new WindowsZephyrFile(path);
ZephyrDirectory dir = Global.WindowsWorkingDirectory.CreateDirectory(path);
Assert.That(!dir.Exists);
dir.Create();
Assert.That(dir.Exists);
dir.Delete();
file.Delete();
}
public void AwsS3DirectoryIsEmpty()
{
if (!Global.TestAws)
{
throw new Exception("Amazon S3 Tests Are Not Enabled. Set Global.TestAws To True To Enable.");
}
String path = $"{Global.AwsS3WorkingPath}{Global.RandomDirectory}/";
Console.WriteLine($"{path}");
ZephyrDirectory dir = Global.AwsS3WorkingDirectory.CreateDirectory(path);
dir.Create();
Assert.IsTrue(dir.IsEmpty);
Global.TestFilesDirectory.CopyTo(dir, verbose: false);
Assert.IsFalse(dir.IsEmpty);
dir.Delete();
}
public void AwsS3FileCreateDirectoryMethod()
{
if (!Global.TestAws)
{
throw new Exception("Amazon S3 Tests Are Not Enabled. Set Global.TestAws To True To Enable.");
}
String path = $"{Global.AwsS3WorkingPath}{Global.RandomFile}";
Console.WriteLine(path);
ZephyrFile file = new AwsS3ZephyrFile(Global.Clients.aws, path);
ZephyrDirectory dir = Global.AwsS3WorkingDirectory.CreateDirectory(path);
Assert.That(!dir.Exists);
dir.Create();
Assert.That(dir.Exists);
dir.Delete();
file.Delete();
}
public void AwsS3DirectoryGetDirectoriesandGetFiles()
{
if (!Global.TestAws)
{
throw new Exception("Amazon S3 Tests Are Not Enabled. Set Global.TestAws To True To Enable.");
}
ZephyrDirectory dir = Global.StageTestFilesToAws();
List <ZephyrDirectory> dirs = (List <ZephyrDirectory>)(dir.GetDirectories());
Console.WriteLine($"Found [{dirs.Count}] Sub-directories.");
Assert.AreEqual(dirs.Count, 3);
List <ZephyrFile> files = (List <ZephyrFile>)(dir.GetFiles());
Console.WriteLine($"Found [{files.Count}] Files.");
Assert.AreEqual(files.Count, 5);
dir.Delete(verbose: false);
}
public void AwsS3FileReadAllText()
{
if (!Global.TestAws)
{
throw new Exception("Amazon S3 Tests Are Not Enabled. Set Global.TestAws To True To Enable.");
}
ZephyrDirectory source = Global.StageTestFilesToAws();
List <ZephyrFile> files = (List <ZephyrFile>)source.GetFiles();
Assert.IsNotEmpty(files);
foreach (ZephyrFile file in files)
{
Console.WriteLine($"File: {file.FullName}");
String content = file.ReadAllText();
Console.WriteLine(content);
Assert.IsNotEmpty(content);
}
source.Delete();
}
public void AwsS3FileCopyToAwsS3File()
{
if (!Global.TestAws)
{
throw new Exception("Amazon S3 Tests Are Not Enabled. Set Global.TestAws To True To Enable.");
}
ZephyrDirectory source = Global.StageTestFilesToAws();
List <ZephyrFile> files = (List <ZephyrFile>)source.GetFiles();
Assert.IsNotEmpty(files);
foreach (ZephyrFile file in files)
{
String path = $"{Global.AwsS3WorkingPath}{Global.RandomFile}";
ZephyrFile dest = new AwsS3ZephyrFile(Global.Clients.aws, path);
file.CopyTo(dest);
Assert.That(Utilities.Exists(path, Global.Clients));
dest.Delete();
}
source.Delete();
}
public void WindowsFileCopyToWindowsFile()
{
if (!Global.TestWindows)
{
throw new Exception("Windows Tests Are Not Enabled. Set Global.TestWindows To True To Enable.");
}
ZephyrDirectory source = Global.StageTestFilesToWindows();
List <ZephyrFile> files = (List <ZephyrFile>)source.GetFiles();
Assert.IsNotEmpty(files);
foreach (ZephyrFile file in files)
{
String path = Path.Combine(Global.WindowsWorkingPath, Global.RandomFile);
ZephyrFile dest = new WindowsZephyrFile(path);
file.CopyTo(dest);
Assert.That(File.Exists(path));
dest.Delete();
}
source.Delete();
}
public void WindowsFileReadAllBytes()
{
if (!Global.TestWindows)
{
throw new Exception("Windows Tests Are Not Enabled. Set Global.TestWindows To True To Enable.");
}
ZephyrDirectory source = Global.StageTestFilesToWindows();
List <ZephyrFile> files = (List <ZephyrFile>)source.GetFiles();
Assert.IsNotEmpty(files);
foreach (ZephyrFile file in files)
{
Console.WriteLine($"File: {file.FullName}");
byte[] content = file.ReadAllBytes();
foreach (byte b in content)
{
Console.Write(b);
}
Assert.IsNotEmpty(content);
}
source.Delete();
}
public void Init()
{
if (TestWindows)
{
WindowsWorkingPath = Path.Combine(WindowsWorkspace, $"temp_{Global.RandomDirectory}\\");
WindowsWorkingDirectory = Utilities.CreateDirectory(WindowsWorkingPath, Clients);
}
if (TestAws)
{
Clients.aws = Utilities.InitAwsClient(AwsS3Region, AwsS3AccessKey, AwsS3SecretKey);
AwsS3WorkingPath = $"{AwsS3Workspace}{Global.RandomDirectory}/";
AwsS3WorkingDirectory = Utilities.CreateDirectory(AwsS3WorkingPath, Clients);
}
// Get Path To The Project's "TestFiles" Folder
String assemblyDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().CodeBase);
UriBuilder uri = new UriBuilder(assemblyDir);
string path = Uri.UnescapeDataString(uri.Path);
DirectoryInfo dInfo = new DirectoryInfo(Path.GetDirectoryName(path));
TestFilesPath = $"{dInfo.Parent.FullName}\\TestFiles\\";
TestFilesDirectory = new WindowsZephyrDirectory(Global.TestFilesPath);
}
public override ExecuteResult Execute(HandlerStartInfo startInfo)
{
OnProgress("CopyFileHandler", "Handler Execution Begins.", StatusType.Running, 0, cheapSequence++);
ExecuteResult result = new ExecuteResult();
result.Status = StatusType.Success;
// TODO : Implement DryRun Functionality
if (startInfo.IsDryRun)
{
throw new NotImplementedException("Dry Run Functionality Has Not Yet Been Implemented.");
}
try
{
if (startInfo.Parameters != null)
{
parameters = HandlerUtils.Deserialize <CopyFileHandlerParameters>(startInfo.Parameters);
}
bool isValid = Validate();
if (isValid)
{
if (parameters.FileSets != null)
{
foreach (FileSet set in parameters.FileSets)
{
if (set != null && set.Sources != null && set.Destinations != null)
{
OnLogMessage("CopyFileHandler", $"Starting {config.Action} From [{string.Join(",", set.Sources.ToArray())}] To [{string.Join(",", set.Destinations)}].");
foreach (String destination in set.Destinations)
{
if (Utilities.IsDirectory(destination) && config.PurgeDestination)
{
ZephyrDirectory clearDir = Utilities.GetZephyrDirectory(destination, clients);
clearDir.Purge(config.StopOnError, config.Verbose, "Purge", Logger);
OnLogMessage("CopyFileHandler", $"Directory [{destination}] Was Purged.");
}
foreach (String source in set.Sources)
{
if (Utilities.IsDirectory(source))
{
ZephyrDirectory sourceDir = Utilities.GetZephyrDirectory(source, clients);
if (Utilities.IsDirectory(destination))
{
// Copy/Move Directory To Directory
ZephyrDirectory destDir = Utilities.GetZephyrDirectory(destination, clients);
if (config.Action == FileAction.Copy)
{
sourceDir.CopyTo(destDir, config.Recurse, config.OverwriteExisting, config.StopOnError, config.Verbose, "Copy", Logger);
}
else
{
sourceDir.MoveTo(destDir, config.OverwriteExisting, config.StopOnError, config.Verbose, "Move", Logger);
}
}
else
{
// This should never occur, as this scenario is addressed in "Validate".
throw new Exception($"Can Not Copy Directory [{source}] To File [{destination}]");
}
}
else
{
ZephyrFile sourceFile = Utilities.GetZephyrFile(source, clients);
if (Utilities.IsDirectory(destination))
{
// Copy/Move File To Directory
ZephyrDirectory destDir = Utilities.GetZephyrDirectory(destination, clients);
if (config.Action == FileAction.Copy)
{
sourceFile.CopyTo(destDir, config.OverwriteExisting, true, config.StopOnError, config.Verbose, "Copy", Logger);
}
else
{
sourceFile.MoveTo(destDir, config.OverwriteExisting, true, config.StopOnError, config.Verbose, "Move", Logger);
}
}
else
{
// Copy/Move File To File
ZephyrFile destFile = Utilities.GetZephyrFile(destination, clients);
if (config.Action == FileAction.Copy)
{
sourceFile.CopyTo(destFile, config.OverwriteExisting, true, config.StopOnError, config.Verbose, "Copy", Logger);
}
else
{
sourceFile.MoveTo(destFile, config.OverwriteExisting, true, config.StopOnError, config.Verbose, "Move", Logger);
}
}
}
}
}
OnLogMessage("CopyFileHandler", $"Finished {config.Action} From [{string.Join(",", set.Sources.ToArray())}] To [{string.Join(",", set.Destinations)}].");
}
}
}
}
else
{
OnLogMessage("CopyFileHandler", "Validation Failed.", LogLevel.Error);
throw new Exception("Validation Failed.");
}
}
catch (Exception e)
{
OnProgress("CopyFileHandler", "Handler Execution Failed.", StatusType.Failed, 0, cheapSequence++, false, e);
throw e;
}
OnProgress("CopyFileHandler", "Handler Execution Completed.", StatusType.Complete, 0, cheapSequence++);
return(result);
}
