public string Rename(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, IDev2CRUDOperationTO args)
{
string performRename()
{
if (src.PathIs(src.IOPath) != dst.PathIs(dst.IOPath))
{
throw new Exception(ErrorResource.SourceAndDestinationNOTFilesOrDirectory);
}
if (dst.PathExist(dst.IOPath))
{
if (!args.Overwrite)
{
throw new Exception(ErrorResource.DestinationDirectoryExist);
}
dst.Delete(dst.IOPath);
}
return(Move(src, dst, args));
}
try
{
return(performRename());
}
finally
{
RemoveAllTmpFiles();
}
}
void CreateSourceFileWithSomeDummyData()
{
try
{
Dev2Logger.Log.Debug(string.Format("Source File: {0}", ScenarioContext.Current.Get <string>(ActualSourceHolder)));
var broker = ActivityIOFactory.CreateOperationsBroker();
IActivityIOPath source = ActivityIOFactory.CreatePathFromString(ScenarioContext.Current.Get <string>(ActualSourceHolder),
ScenarioContext.Current.Get <string>(SourceUsernameHolder),
ScenarioContext.Current.Get <string>(SourcePasswordHolder),
true);
var ops = ActivityIOFactory.CreatePutRawOperationTO(WriteType.Overwrite, Guid.NewGuid().ToString());
IActivityIOOperationsEndPoint sourceEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(source);
if (sourceEndPoint.PathIs(sourceEndPoint.IOPath) == enPathType.File)
{
var result = broker.PutRaw(sourceEndPoint, ops);
if (result != "Success")
{
result = broker.PutRaw(sourceEndPoint, ops);
if (result != "Success")
{
Dev2Logger.Log.Debug("Create Source File for file op test error");
}
}
}
}
catch (Exception e)
{
Dev2Logger.Log.Debug("Create Source File for file op test error", e);
}
}
public void ActivityIOBroker_Zip_WhenOverwriteSetTrue_ShouldOverwriteFile()
{
//------------Setup for test--------------------------
tempFile = Path.GetTempFileName();
var zipPathName = Path.GetTempPath() + NewFileName + ".zip";
IActivityIOOperationsEndPoint scrEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ActivityIOFactory.CreatePathFromString(tempFile, string.Empty, null, true, ""));
IActivityIOOperationsEndPoint dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ActivityIOFactory.CreatePathFromString(zipPathName, string.Empty, null, true, ""));
Dev2ZipOperationTO zipTO = ActivityIOFactory.CreateZipTO(null, null, null, true);
File.WriteAllText(zipPathName, "");
//------------Assert Preconditions-------------------
Assert.IsTrue(zipTO.Overwrite);
Assert.IsTrue(File.Exists(zipPathName));
var readAllBytes = File.ReadAllBytes(zipPathName);
Assert.AreEqual(0, readAllBytes.Length);
//------------Execute Test---------------------------
ActivityIOFactory.CreateOperationsBroker().Zip(scrEndPoint, dstEndPoint, zipTO);
//------------Assert Results-------------------------
Assert.IsTrue(File.Exists(zipPathName));
readAllBytes = File.ReadAllBytes(zipPathName);
Assert.AreNotEqual(0, readAllBytes.Length);
File.Delete(tempFile);
File.Delete(zipPathName);
}
private bool CreateDirectoriesForPath(IActivityIOOperationsEndPoint dst, IDev2CRUDOperationTO args, IList <string> dirParts)
{
var maxDepth = dirParts.Count - 1;
var pos = 0;
var origPath = dst.IOPath;
try
{
while (pos <= maxDepth)
{
var toCreate = ActivityIOFactory.CreatePathFromString(dirParts[pos], dst.IOPath.Username,
dst.IOPath.Password, true, dst.IOPath.PrivateKeyFile);
if (dst.PathExist(toCreate))
{
pos++;
continue;
}
dst.IOPath = toCreate;
if (!CreateDirectory(dst, args))
{
return(false);
}
pos++;
}
}
finally
{
dst.IOPath = origPath;
}
return(true);
}
public string Zip(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, IDev2ZipOperationTO args)
{
string status;
try
{
status = ValidateZipSourceDestinationFileOperation(src, dst, args, () =>
{
string tempFileName;
if (src.PathIs(src.IOPath) == enPathType.Directory || Dev2ActivityIOPathUtils.IsStarWildCard(src.IOPath.Path))
{
tempFileName = ZipDirectoryToALocalTempFile(src, args);
}
else
{
tempFileName = ZipFileToALocalTempFile(src, args);
}
return(TransferTempZipFileToDestination(src, dst, args, tempFileName));
});
}
finally
{
_filesToDelete.ForEach(RemoveTmpFile);
}
return(status);
}
static internal void Execute(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst)
{
var sourceParts = VerifyAndCleanInputs(src, dst);
if (IsDestinationSubdirectoryOfSource(dst, sourceParts))
{
if (dst.PathIs(dst.IOPath) == enPathType.Directory)
{
var strings = src.IOPath.Path.Split(src.PathSeperator().ToCharArray(),
StringSplitOptions.RemoveEmptyEntries);
var lastPart = strings.Last();
dst.IOPath.Path = src.PathIs(src.IOPath) == enPathType.Directory
? Path.Combine(dst.IOPath.Path, lastPart)
: dst.IOPath.Path.Replace(lastPart, "");
}
}
else
{
if (dst.PathIs(dst.IOPath) == enPathType.Directory && src.PathIs(src.IOPath) == enPathType.Directory)
{
var strings = src.IOPath.Path.Split(src.PathSeperator().ToCharArray(),
StringSplitOptions.RemoveEmptyEntries);
var lastPart = strings.Last();
dst.IOPath.Path = dst.Combine(lastPart);
}
}
}
void WriteToLocalTempStorage(IActivityIOOperationsEndPoint dst, IDev2PutRawOperationTO args, string tmp)
{
switch (args.WriteType)
{
case WriteType.AppendBottom:
using (var s = dst.Get(dst.IOPath, _filesToDelete))
{
_fileWrapper.WriteAllBytes(tmp, s.ToByteArray());
_fileWrapper.AppendAllText(tmp, args.FileContents);
}
break;
case WriteType.AppendTop:
using (var s = dst.Get(dst.IOPath, _filesToDelete))
{
_fileWrapper.WriteAllText(tmp, args.FileContents);
_common.AppendToTemp(s, tmp);
}
break;
default:
_fileWrapper.AppendAllText(tmp, args.FileContents);
break;
}
}
public void PutWithOverwriteTrue_UNCPathValidUser_File_Present_FileInStream()
{
Dev2CRUDOperationTO opTO = new Dev2CRUDOperationTO(true);
string tmp = TestResource.PathOperations_UNC_Path_Secure + Guid.NewGuid() + ".test";
string tmp2 = TestResource.PathOperations_UNC_Path_Secure + Guid.NewGuid() + ".test";
PathIOTestingUtils.CreateAuthedUNCPath(tmp, false, _inDomain);
IActivityIOPath dst = ActivityIOFactory.CreatePathFromString(tmp, (_inDomain ? "DEV2\\" : ".\\") + TestResource.PathOperations_Correct_Username, TestResource.PathOperations_Correct_Password);
IActivityIOPath src = ActivityIOFactory.CreatePathFromString(tmp2, (_inDomain ? "DEV2\\" : ".\\") + TestResource.PathOperations_Correct_Username, TestResource.PathOperations_Correct_Password);
IActivityIOOperationsEndPoint FileSystemPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
Stream stream = new MemoryStream(File.ReadAllBytes(_tmpfile1));
var directoryInfo = new FileInfo(src.Path).Directory;
if (directoryInfo != null)
{
int len = FileSystemPro.Put(stream, dst, opTO, directoryInfo.ToString(), new List <string>());
stream.Close();
PathIOTestingUtils.DeleteAuthedUNCPath(tmp);
PathIOTestingUtils.DeleteAuthedUNCPath(tmp2);
Assert.IsTrue(len > 0);
}
else
{
Assert.Fail();
}
}
protected bool TransferDirectoryContents(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, IDev2CRUDOperationTO args)
{
if (!args.Overwrite)
{
ValidateSourceAndDestinationContents(src, dst, args);
}
if (args.DoRecursiveCopy)
{
RecursiveCopy(src, dst, args);
}
var srcContents = src.ListFilesInDirectory(src.IOPath);
var result = true;
var origDstPath = Dev2ActivityIOPathUtils.ExtractFullDirectoryPath(dst.IOPath.Path);
if (!dst.PathExist(dst.IOPath))
{
CreateDirectory(dst, args);
}
// TODO: cleanup this code so that result is easier to follow
foreach (var p in srcContents)
{
result = PerformTransfer(src, dst, args, origDstPath, p, result);
}
Dev2Logger.Debug($"Transfered: {src.IOPath.Path}", GlobalConstants.WarewolfDebug);
return(result);
}
void DoFileTransfer(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, IDev2CRUDOperationTO args, IActivityIOPath dstPath, IActivityIOPath p, string path, ref bool result)
{
if (args.Overwrite || !dst.PathExist(dstPath))
{
result = TransferFile(src, dst, args, path, p, result);
}
}
public string Move(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, Dev2CRUDOperationTO args)
{
Source = src;
Destination = dst;
Dev2CRUDOperationTO = args;
return("Successful");
}
static void RunCopy()
{
IActivityIOPath source = ActivityIOFactory.CreatePathFromString(ScenarioContext.Current.Get <string>(CommonSteps.ActualSourceHolder),
ScenarioContext.Current.Get <string>(CommonSteps.SourceUsernameHolder),
ScenarioContext.Current.Get <string>(CommonSteps.SourcePasswordHolder),
true);
IActivityIOOperationsEndPoint sourceEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(source);
string resourceName = "Dev2.Activities.Specs.Toolbox.FileAndFolder.Unzip.Test.zip";
if (ScenarioContext.Current.ContainsKey("WhenTheUnzipFileToolIsExecutedWithASingleFile"))
{
resourceName = "TestFile.zip";
}
Assembly assembly = Assembly.GetExecutingAssembly();
List <string> filesToCleanup = new List <string>();
using (Stream stream = assembly.GetManifestResourceStream(resourceName))
{
if (stream != null)
{
sourceEndPoint.Put(stream, sourceEndPoint.IOPath, new Dev2CRUDOperationTO(true), null, filesToCleanup);
}
}
filesToCleanup.ForEach(File.Delete);
}
public string Create(IActivityIOOperationsEndPoint dst, Dev2CRUDOperationTO args, bool createToFile)
{
CreateToFile = createToFile;
Destination = dst;
Dev2CRUDOperationTO = args;
return("Successful");
}
public string UnZip(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, IDev2UnZipOperationTO args)
{
Source = src;
Destination = dst;
Dev2UnZipOperationTO = args;
return("Successful");
}
/// <summary>
/// Renames a file or folder from src to dst as per the value of args
/// </summary>
/// <param name="src"></param>
/// <param name="dst"></param>
/// <param name="args"></param>
public string Rename(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, Dev2CRUDOperationTO args)
{
Source = src;
Destination = dst;
Dev2CRUDOperationTO = args;
return "Successful";
}
string ZipFileToALocalTempFile(IActivityIOOperationsEndPoint src, IDev2ZipOperationTO args)
{
var packFile = src.IOPath.Path;
var tempFileName = CreateTmpFile();
if (src.RequiresLocalTmpStorage())
{
var tempDir = _common.CreateTmpDirectory();
var tmpFile = Path.Combine(tempDir,
src.IOPath.Path.Split(src.PathSeperator().ToCharArray(),
StringSplitOptions.RemoveEmptyEntries)
.Last());
packFile = tmpFile;
using (var s = src.Get(src.IOPath, _filesToDelete))
{
_fileWrapper.WriteAllBytes(tmpFile, s.ToByteArray());
}
}
using (var zip = new ZipFile())
{
if (args.ArchivePassword != string.Empty)
{
zip.Password = args.ArchivePassword;
}
zip.CompressionLevel = _common.ExtractZipCompressionLevel(args.CompressionRatio);
zip.AddFile(packFile, ".");
zip.Save(tempFileName);
}
return(tempFileName);
}
public string WriteToRemoteTempStorage(IActivityIOOperationsEndPoint dst, IDev2PutRawOperationTO args, string tmp)
{
switch (args.WriteType)
{
case WriteType.AppendBottom:
var fileContent = Encoding.ASCII.GetBytes(args.FileContents);
var putResult = PerformPut(fileContent, dst, false);
return(putResult ? ResultOk : ResultBad);
case WriteType.AppendTop:
using (var s = dst.Get(dst.IOPath, _filesToDelete))
{
_fileWrapper.WriteAllText(tmp, args.FileContents);
using (var temp = new FileStream(tmp, FileMode.Append))
{
s.CopyTo(temp);
}
return(MoveTmpFileToDestination(dst, tmp));
}
default:
var res = WriteDataToFile(args, dst);
return(res ? ResultOk : ResultBad);
}
}
void ValidateSourceAndDestinationContents(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, IDev2CRUDOperationTO args)
{
if (!args.Overwrite)
{
var srcContentsFolders = src.ListFoldersInDirectory(src.IOPath);
foreach (var sourcePath in srcContentsFolders)
{
var sourceEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(sourcePath);
IList <string> dirParts = sourceEndPoint.IOPath.Path.Split(sourceEndPoint.PathSeperator().ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
var directory = dirParts.Last();
var destinationPath = ActivityIOFactory.CreatePathFromString(dst.Combine(directory), dst.IOPath.Username, dst.IOPath.Password, true, dst.IOPath.PrivateKeyFile);
var destinationEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(destinationPath);
if (destinationEndPoint.PathExist(destinationEndPoint.IOPath))
{
ValidateSourceAndDestinationContents(sourceEndPoint, destinationEndPoint, args);
}
}
var srcContents = src.ListFilesInDirectory(src.IOPath);
var dstContents = dst.ListFilesInDirectory(dst.IOPath);
var sourceFileNames = srcContents.Select(srcFile => GetFileNameFromEndPoint(src, srcFile)).ToList();
var destinationFileNames = dstContents.Select(dstFile => GetFileNameFromEndPoint(dst, dstFile)).ToList();
if (destinationFileNames.Count > 0)
{
var commonFiles = sourceFileNames.Where(destinationFileNames.Contains).ToList();
if (commonFiles.Count > 0)
{
var fileNames = commonFiles.Aggregate("",
(current, commonFile) =>
current + "\r\n" + commonFile);
throw new Exception(string.Format(ErrorResource.FileExistInDestinationFolder, fileNames));
}
}
}
}
public void WriteToLocalTempStorage(IActivityIOOperationsEndPoint dst, IDev2PutRawOperationTO args, string tmp)
{
switch (args.WriteType)
{
case WriteType.AppendBottom:
using (var s = dst.Get(dst.IOPath, _filesToDelete))
{
_fileWrapper.WriteAllBytes(tmp, s.ToByteArray());
_fileWrapper.AppendAllText(tmp, args.FileContents);
}
return;
case WriteType.AppendTop:
using (var s = dst.Get(dst.IOPath, _filesToDelete))
{
_fileWrapper.WriteAllText(tmp, args.FileContents);
using (var temp = new FileStream(tmp, FileMode.Append))
{
s.CopyTo(temp);
}
}
return;
default:
_fileWrapper.AppendAllText(tmp, args.FileContents);
return;
}
}
bool PerformTransfer(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, IDev2CRUDOperationTO args, string origDstPath, IActivityIOPath p, bool result)
{
try
{
if (dst.PathIs(dst.IOPath) == enPathType.Directory)
{
var cpPath =
ActivityIOFactory.CreatePathFromString(
$"{origDstPath}{dst.PathSeperator()}{Dev2ActivityIOPathUtils.ExtractFileName(p.Path)}",
dst.IOPath.Username,
dst.IOPath.Password, true, dst.IOPath.PrivateKeyFile);
var path = cpPath.Path;
DoFileTransfer(src, dst, args, cpPath, p, path, ref result);
}
else
{
if (args.Overwrite || !dst.PathExist(dst.IOPath))
{
var tmp = origDstPath + @"\\" + Dev2ActivityIOPathUtils.ExtractFileName(p.Path);
var path = ActivityIOFactory.CreatePathFromString(tmp, dst.IOPath.Username, dst.IOPath.Password, dst.IOPath.PrivateKeyFile);
DoFileTransfer(src, dst, args, path, p, path.Path, ref result);
}
}
}
catch (Exception ex)
{
Dev2Logger.Error(ex, GlobalConstants.WarewolfError);
}
return(result);
}
// See interfaces summary's for more detail
public string Get(IActivityIOOperationsEndPoint path, bool deferredRead = false)
{
string result;
try
{
// TODO : we need to chunk this in
if(!deferredRead)
{
byte[] bytes;
using(var s = path.Get(path.IOPath, _filesToDelete))
{
bytes = new byte[s.Length];
s.Position = 0;
s.Read(bytes, 0, (int)s.Length);
}
// TODO : Remove the need for this ;(
return Encoding.UTF8.GetString(bytes);
}
// If we want to defer the read of data, just return the file name ;)
// Serialize to binary and return
BinaryDataListUtil bdlUtil = new BinaryDataListUtil();
result = bdlUtil.SerializeDeferredItem(path);
}
finally
{
_filesToDelete.ForEach(RemoveTmpFile);
}
return result;
}
string WriteToRemoteTempStorage(IActivityIOOperationsEndPoint dst, IDev2PutRawOperationTO args, string result, string tmp)
{
switch (args.WriteType)
{
case WriteType.AppendBottom:
var fileContent = Encoding.ASCII.GetBytes(args.FileContents);
var putResult = PerformPut(fileContent, dst, false);
result = putResult ? ResultOk : ResultBad;
break;
case WriteType.AppendTop:
using (var s = dst.Get(dst.IOPath, _filesToDelete))
{
_fileWrapper.WriteAllText(tmp, args.FileContents);
_common.AppendToTemp(s, tmp);
result = MoveTmpFileToDestination(dst, tmp, result);
}
break;
case WriteType.Overwrite:
default:
var res = WriteDataToFile(args, dst);
result = res ? ResultOk : ResultBad;
break;
}
return(result);
}
private void BootstrapPersistence(string baseDir)
{
lock (InitLock)
{
if (_debugPath == null)
{
if (baseDir != null)
{
_rootPath = baseDir;
}
if (_rootPath.EndsWith("\\"))
{
_debugPersistPath = _rootPath + SavePath;
}
else
{
_debugPersistPath = _rootPath + "\\" + SavePath;
}
_debugPath = ActivityIOFactory.CreatePathFromString(_debugPersistPath, "", "");
_debugOptsEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(_debugPath);
}
}
}
public void PutWithOverwriteTrue_FileNot_Present_Expect_FileReadAndDataInputToStream()
{
Dev2CRUDOperationTO opTO = new Dev2CRUDOperationTO(true);
string tmp = Path.GetTempFileName();
File.Delete(tmp);
IActivityIOPath dst = ActivityIOFactory.CreatePathFromString(tmp, "", "");
IActivityIOPath src = ActivityIOFactory.CreatePathFromString(_tmpfile2, "", "");
IActivityIOOperationsEndPoint FileSystemPro = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
Stream stream = FileSystemPro.Get(src, new List <string>());
var directoryInfo = new FileInfo(src.Path).Directory;
if (directoryInfo != null)
{
int len = FileSystemPro.Put(stream, dst, opTO, directoryInfo.ToString(), new List <string>());
stream.Close();
File.Delete(tmp);
Assert.IsTrue(len > 0);
}
else
{
Assert.Fail();
}
}
protected override string ExecuteBroker(IActivityOperationsBroker broker, IActivityIOOperationsEndPoint scrEndPoint, IActivityIOOperationsEndPoint dstEndPoint)
{
var opTo = new Dev2CRUDOperationTO(Overwrite);
var result = broker.Rename(scrEndPoint, dstEndPoint, opTo);
return(result.Replace("Move", "Rename"));
}
static List <string> VerifyAndCleanInputs(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst)
{
if (src.IOPath.Path.Trim().Length == 0)
{
throw new Exception(ErrorResource.SourceCannotBeAnEmptyString);
}
var sourceParts = src.IOPath.Path.Split(src.PathSeperator().ToCharArray(),
StringSplitOptions.RemoveEmptyEntries).ToList();
if (dst.IOPath.Path.Trim().Length == 0)
{
dst.IOPath.Path = src.IOPath.Path;
}
else
{
// TODO: verify if this condition is possible, UNC paths start with @"\\" but @"\\file" is always rooted
if (!Path.IsPathRooted(dst.IOPath.Path) && IsNotFtpTypePath(dst.IOPath) && IsUncFileTypePath(dst.IOPath.Path))
{
var lastPart = sourceParts.Last();
dst.IOPath.Path =
Path.Combine(src.PathIs(dst.IOPath) == enPathType.Directory
? src.IOPath.Path
: src.IOPath.Path.Replace(lastPart, ""), dst.IOPath.Path);
}
}
return(sourceParts);
}
public string CreateEndPoint(IActivityIOOperationsEndPoint dst, IDev2CRUDOperationTO args, bool createToFile)
{
var activityIOPath = dst.IOPath;
var dirParts = MakeDirectoryParts(activityIOPath, dst.PathSeperator());
var ok = CreateDirectoriesForPath(dst, args, dirParts);
if (!ok)
{
return(ResultBad);
}
var shouldCreateFile = dst.PathIs(dst.IOPath) == enPathType.File && createToFile;
if (shouldCreateFile)
{
if (CreateFile(dst, args))
{
return(ResultOk);
}
}
else
{
return(ResultOk);
}
return(ResultBad);
}
public string Create(IActivityIOOperationsEndPoint dst, Dev2CRUDOperationTO args, bool createToFile)
{
CreateToFile = createToFile;
Destination = dst;
Dev2CRUDOperationTO = args;
return "Successful";
}
protected override string ExecuteBroker(IActivityOperationsBroker broker, IActivityIOOperationsEndPoint scrEndPoint, IActivityIOOperationsEndPoint dstEndPoint)
{
Dev2UnZipOperationTO zipTo =
ActivityIOFactory.CreateUnzipTO(ColItr.FetchNextValue(_archPassItr),
Overwrite);
return broker.UnZip(scrEndPoint, dstEndPoint, zipTo);
}
protected static void RemovedFilesCreatedForTesting()
{
// ReSharper disable EmptyGeneralCatchClause
Dev2Logger.Log.Debug("Cleanup");
var broker = ActivityIOFactory.CreateOperationsBroker();
string destLocation;
if (ScenarioContext.Current != null && ScenarioContext.Current.TryGetValue(CommonSteps.ActualDestinationHolder, out destLocation))
{
IActivityIOPath dst = ActivityIOFactory.CreatePathFromString(destLocation,
ScenarioContext.Current.Get <string>(CommonSteps.DestinationUsernameHolder),
ScenarioContext.Current.Get <string>(CommonSteps.DestinationPasswordHolder),
true);
IActivityIOOperationsEndPoint dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
try
{
if (dstEndPoint.PathIs(dstEndPoint.IOPath) == enPathType.File)
{
broker.Delete(dstEndPoint);
}
}
catch (Exception)
{
Dev2Logger.Log.Debug("Cleanup Error");
// throw;
}
}
string sourceLocation;
if (ScenarioContext.Current != null && ScenarioContext.Current.TryGetValue(CommonSteps.ActualSourceHolder, out sourceLocation))
{
IActivityIOPath source = ActivityIOFactory.CreatePathFromString(sourceLocation,
ScenarioContext.Current.Get <string>(CommonSteps.SourceUsernameHolder),
ScenarioContext.Current.Get <string>(CommonSteps.SourcePasswordHolder),
true);
IActivityIOOperationsEndPoint sourceEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(source);
try
{
if (sourceEndPoint.PathIs(sourceEndPoint.IOPath) == enPathType.File)
{
broker.Delete(sourceEndPoint);
}
}
catch (Exception)
{
Dev2Logger.Log.Debug("Cleanup Error");
//The file may already be deleted
// throw;
}
}
// SOME SILLY CHICKEN BUNDLED TWO DIS-JOIN OPERATIONS IN THIS METHOD.
// THIS CAUSED THE SFTP SERVER TO NEVER SHUTDOWN WHEN THE COMMONSTEPS.ACTUALSOURCEHOLDER KEY WAS NOT PRESENT!
// ;)
}
protected override IList <OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors, int update)
{
IList <OutputTO> outputs = new List <OutputTO>();
allErrors = new ErrorResultTO();
var colItr = new WarewolfListIterator();
//get all the possible paths for all the string variables
var inputItr = new WarewolfIterator(dataObject.Environment.Eval(InputPath, update));
colItr.AddVariableToIterateOn(inputItr);
var unameItr = new WarewolfIterator(dataObject.Environment.Eval(Username, update));
colItr.AddVariableToIterateOn(unameItr);
var passItr = new WarewolfIterator(dataObject.Environment.Eval(DecryptedPassword, update));
colItr.AddVariableToIterateOn(passItr);
var privateKeyItr = new WarewolfIterator(dataObject.Environment.Eval(PrivateKeyFile, update));
colItr.AddVariableToIterateOn(privateKeyItr);
outputs.Add(DataListFactory.CreateOutputTO(Result));
if (dataObject.IsDebugMode())
{
AddDebugInputItem(InputPath, "Input Path", dataObject.Environment, update);
AddDebugInputItemUserNamePassword(dataObject.Environment, update);
if (!string.IsNullOrEmpty(PrivateKeyFile))
{
AddDebugInputItem(PrivateKeyFile, "Private Key File", dataObject.Environment, update);
}
}
while (colItr.HasMoreData())
{
IActivityOperationsBroker broker = ActivityIOFactory.CreateOperationsBroker();
IActivityIOPath ioPath = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(inputItr),
colItr.FetchNextValue(unameItr),
colItr.FetchNextValue(passItr),
true, colItr.FetchNextValue(privateKeyItr));
IActivityIOOperationsEndPoint endpoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ioPath);
try
{
string result = broker.Get(endpoint);
outputs[0].OutputStrings.Add(result);
}
catch (Exception e)
{
outputs[0].OutputStrings.Add(null);
allErrors.AddError(e.Message);
break;
}
}
return(outputs);
}
public IList <IActivityIOPath> ListDirectory(IActivityIOOperationsEndPoint src, ReadTypes readTypes)
{
if (readTypes == ReadTypes.FilesAndFolders)
{
return(src.ListDirectory(src.IOPath));
}
return(readTypes == ReadTypes.Files ? src.ListFilesInDirectory(src.IOPath) : src.ListFoldersInDirectory(src.IOPath));
}
protected override string ExecuteBroker(IActivityOperationsBroker broker, IActivityIOOperationsEndPoint scrEndPoint, IActivityIOOperationsEndPoint dstEndPoint)
{
Dev2UnZipOperationTO zipTo =
ActivityIOFactory.CreateUnzipTO(ColItr.FetchNextValue(_archPassItr),
Overwrite);
return(broker.UnZip(scrEndPoint, dstEndPoint, zipTo));
}
public static string Combine(this IActivityIOOperationsEndPoint endpoint, string with)
{
if (endpoint.IOPath.Path.EndsWith(endpoint.PathSeperator()))
{
return(endpoint.IOPath.Path + with);
}
return(endpoint.IOPath.Path + endpoint.PathSeperator() + with);
}
// See interfaces summary's for more detail
public string Get(IActivityIOOperationsEndPoint path, bool deferredRead = false)
{
try
{
byte[] bytes;
using(var s = path.Get(path.IOPath, _filesToDelete))
{
bytes = new byte[s.Length];
s.Position = 0;
s.Read(bytes, 0, (int)s.Length);
}
// TODO : Remove the need for this ;(
return Encoding.UTF8.GetString(bytes);
}
finally
{
_filesToDelete.ForEach(RemoveTmpFile);
}
}
bool CreateDirectory(IActivityIOOperationsEndPoint dst, Dev2CRUDOperationTO args)
{
var result = dst.CreateDirectory(dst.IOPath, args);
return result;
}
bool CreateFile(IActivityIOOperationsEndPoint dst, Dev2CRUDOperationTO args)
{
var result = true;
var tmp = CreateTmpFile();
using(Stream s = new MemoryStream(File.ReadAllBytes(tmp)))
{
if(dst.Put(s, dst.IOPath, args, null, _filesToDelete) < 0)
{
result = false;
}
s.Close();
}
return result;
}
/// <summary>
/// Transfer the contents of the directory
/// </summary>
/// <param name="src"></param>
/// <param name="dst"></param>
/// <param name="args"></param>
bool TransferDirectoryContents(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst,
Dev2CRUDOperationTO args)
{
ValidateSourceAndDestinationContents(src, dst, args);
if(args.DoRecursiveCopy)
{
RecursiveCopy(src, dst, args);
}
var srcContents = src.ListFilesInDirectory(src.IOPath);
var result = true;
var origDstPath = Dev2ActivityIOPathUtils.ExtractFullDirectoryPath(dst.IOPath.Path);
if(!dst.PathExist(dst.IOPath))
{
CreateDirectory(dst, args);
}
// get each file, then put it to the correct location
// ReSharper disable once LoopCanBeConvertedToQuery
foreach(var p in srcContents)
{
result = PerformTransfer(src, dst, args, origDstPath, p, result);
}
Dev2Logger.Log.Debug(string.Format("Transfered: {0}", src.IOPath.Path));
return result;
}
public string PutRaw(IActivityIOOperationsEndPoint dst, Dev2PutRawOperationTO args)
{
var result = ResultOk;
// directory put?
// wild char put?
try
{
_fileLock.EnterWriteLock();
if(dst.RequiresLocalTmpStorage())
{
var tmp = CreateTmpFile();
switch(args.WriteType)
{
case WriteType.AppendBottom:
using(var s = dst.Get(dst.IOPath, _filesToDelete))
{
File.WriteAllBytes(tmp, s.ToByteArray());
File.AppendAllText(tmp, args.FileContents);
}
break;
case WriteType.AppendTop:
using(var s = dst.Get(dst.IOPath, _filesToDelete))
{
File.WriteAllText(tmp, args.FileContents);
AppendToTemp(s, tmp);
}
break;
default:
if(IsBase64(args.FileContents))
{
var data = Convert.FromBase64String(args.FileContents.Replace("Content-Type:BASE64", ""));
File.WriteAllBytes(tmp, data);
}
else
{
File.WriteAllText(tmp, args.FileContents);
}
break;
}
result = MoveTmpFileToDestination(dst, tmp, result);
}
else
{
if(File.Exists(dst.IOPath.Path))
{
var tmp = CreateTmpFile();
switch(args.WriteType)
{
case WriteType.AppendBottom:
File.AppendAllText(dst.IOPath.Path, args.FileContents);
result = ResultOk;
break;
case WriteType.AppendTop:
using(var s = dst.Get(dst.IOPath, _filesToDelete))
{
File.WriteAllText(tmp, args.FileContents);
AppendToTemp(s, tmp);
result = MoveTmpFileToDestination(dst, tmp, result);
RemoveTmpFile(tmp);
}
break;
default:
if(IsBase64(args.FileContents))
{
var data = Convert.FromBase64String(args.FileContents.Replace("Content-Type:BASE64", ""));
File.WriteAllBytes(tmp, data);
}
else
{
File.WriteAllText(tmp, args.FileContents);
}
result = MoveTmpFileToDestination(dst, tmp, result);
RemoveTmpFile(tmp);
break;
}
}
else
{
// we can write directly to the file
Dev2CRUDOperationTO newArgs = new Dev2CRUDOperationTO(true);
CreateEndPoint(dst, newArgs, true);
if(IsBase64(args.FileContents))
{
var data = Convert.FromBase64String(args.FileContents.Replace("Content-Type:BASE64", ""));
File.WriteAllBytes(dst.IOPath.Path, data);
}
else
{
File.WriteAllText(dst.IOPath.Path, args.FileContents);
}
}
}
}
finally
{
_fileLock.ExitWriteLock();
for(var index = _filesToDelete.Count-1; index > 0; index--)
{
var name = _filesToDelete[index];
RemoveTmpFile(name);
}
}
return result;
}
string ZipFileToALocalTempFile(IActivityIOOperationsEndPoint src, Dev2ZipOperationTO args)
{
// normal not wild char file && not directory
var packFile = src.IOPath.Path;
var tempFileName = CreateTmpFile();
if(src.RequiresLocalTmpStorage())
{
string tempDir = CreateTmpDirectory();
var tmpFile = Path.Combine(tempDir,
src.IOPath.Path.Split(src.PathSeperator().ToCharArray(),
StringSplitOptions.RemoveEmptyEntries)
.Last());
packFile = tmpFile;
using(var s = src.Get(src.IOPath, _filesToDelete))
{
File.WriteAllBytes(tmpFile, s.ToByteArray());
}
}
using(var zip = new ZipFile())
{
// set password if exist
if(args.ArchivePassword != string.Empty)
{
zip.Password = args.ArchivePassword;
}
// compression ratio
zip.CompressionLevel = ExtractZipCompressionLevel(args.CompressionRatio);
// add all files to archive
zip.AddFile(packFile, ".");
zip.Save(tempFileName);
}
return tempFileName;
}
public string Copy(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst,
Dev2CRUDOperationTO args)
{
string status;
try
{
status = ValidateCopySourceDestinationFileOperation(src, dst, args, () =>
{
if(src.RequiresLocalTmpStorage())
{
if(dst.PathIs(dst.IOPath) == enPathType.Directory)
{
dst.IOPath.Path = dst.Combine(GetFileNameFromEndPoint(src));
}
using(var s = src.Get(src.IOPath, _filesToDelete))
{
// for flips sake quite putting short-hand notation in-line it causes bugs!!! ;)
dst.Put(s, dst.IOPath, args, Path.IsPathRooted(src.IOPath.Path) ? Path.GetDirectoryName(src.IOPath.Path) : null, _filesToDelete);
s.Close();
s.Dispose();
}
}
else
{
var sourceFile = new FileInfo(src.IOPath.Path);
if(dst.PathIs(dst.IOPath) == enPathType.Directory)
{
dst.IOPath.Path = dst.Combine(sourceFile.Name);
}
using(var s = src.Get(src.IOPath, _filesToDelete))
{
if(sourceFile.Directory != null)
{
dst.Put(s, dst.IOPath, args, sourceFile.Directory.ToString(), _filesToDelete);
}
}
}
return ResultOk;
});
}
finally
{
_filesToDelete.ForEach(RemoveTmpFile);
}
return status;
}
public string UnZip(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst,
Dev2UnZipOperationTO args)
{
string status;
try
{
status = ValidateUnzipSourceDestinationFileOperation(src, dst, args, () =>
{
ZipFile zip;
var tempFile = "";
if(src.RequiresLocalTmpStorage())
{
var tmpZip = CreateTmpFile();
using(var s = src.Get(src.IOPath, _filesToDelete))
{
File.WriteAllBytes(tmpZip, s.ToByteArray());
}
tempFile = tmpZip;
zip = ZipFile.Read(tempFile);
}
else
{
zip = ZipFile.Read(src.Get(src.IOPath, _filesToDelete));
}
if(dst.RequiresLocalTmpStorage())
{
// unzip locally then Put the contents of the archive to the dst end-point
var tempPath = CreateTmpDirectory();
ExtractFile(args, zip, tempPath);
var endPointPath = ActivityIOFactory.CreatePathFromString(tempPath, "", "","");
var endPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(endPointPath);
Move(endPoint, dst, new Dev2CRUDOperationTO(args.Overwrite));
}
else
{
ExtractFile(args, zip, dst.IOPath.Path);
}
if(src.RequiresLocalTmpStorage())
{
File.Delete(tempFile);
}
return ResultOk;
});
}
finally
{
_filesToDelete.ForEach(RemoveTmpFile);
}
return status;
}
protected override string ExecuteBroker(IActivityOperationsBroker broker, IActivityIOOperationsEndPoint scrEndPoint, IActivityIOOperationsEndPoint dstEndPoint)
{
ExecuteBrokerCalled = true;
return "";
}
static string GetFileNameFromEndPoint(IActivityIOOperationsEndPoint endPoint, IActivityIOPath path)
{
var pathSeperator = endPoint.PathSeperator();
return path.Path.Split(pathSeperator.ToCharArray(), StringSplitOptions.RemoveEmptyEntries).Last();
}
static bool TransferFile(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, Dev2CRUDOperationTO args, string path, IActivityIOPath p, bool result)
{
var tmpPath = ActivityIOFactory.CreatePathFromString(path, dst.IOPath.Username, dst.IOPath.Password, true, dst.IOPath.PrivateKeyFile);
var tmpEp = ActivityIOFactory.CreateOperationEndPointFromIOPath(tmpPath);
var whereToPut = GetWhereToPut(src, dst);
using(var s = src.Get(p, _filesToDelete))
{
if(tmpEp.Put(s, tmpEp.IOPath, args, whereToPut, _filesToDelete) < 0)
{
result = false;
}
s.Close();
s.Dispose();
}
return result;
}
void RecursiveCopy(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, Dev2CRUDOperationTO args)
{
try
{
// List directory contents
var srcContentsFolders = src.ListFoldersInDirectory(src.IOPath);
Task.WaitAll(srcContentsFolders.Select(sourcePath => Task.Run(() =>
{
var sourceEndPoint =
ActivityIOFactory.CreateOperationEndPointFromIOPath(sourcePath);
IList<string> dirParts =
sourceEndPoint.IOPath.Path.Split(sourceEndPoint.PathSeperator().ToCharArray(),
StringSplitOptions.RemoveEmptyEntries);
var destinationPath =
ActivityIOFactory.CreatePathFromString(dst.Combine(dirParts.Last()), dst.IOPath.Username,
dst.IOPath.Password, true, dst.IOPath.PrivateKeyFile);
var destinationEndPoint =
ActivityIOFactory.CreateOperationEndPointFromIOPath(destinationPath);
dst.CreateDirectory(destinationPath, args);
TransferDirectoryContents(sourceEndPoint, destinationEndPoint, args);
})).ToArray());
}
catch(AggregateException e)
{
var message = e.InnerExceptions.Where(exception => exception != null && !string.IsNullOrEmpty(exception.Message)).Aggregate("", (current, exception) => current + exception.Message + "\r\n");
throw new Exception(message, e);
}
}
protected override string ExecuteBroker(IActivityOperationsBroker broker, IActivityIOOperationsEndPoint scrEndPoint, IActivityIOOperationsEndPoint dstEndPoint)
{
Dev2CRUDOperationTO opTo = new Dev2CRUDOperationTO(Overwrite);
var result = broker.Rename(scrEndPoint, dstEndPoint, opTo);
return result.Replace("Move", "Rename");
}
string ZipDirectoryToALocalTempFile(IActivityIOOperationsEndPoint src, Dev2ZipOperationTO args)
{
// tmp dir for files required
var tmpDir = CreateTmpDirectory();
var tempFilename = CreateTmpFile();
var tmpPath = ActivityIOFactory.CreatePathFromString(tmpDir, "", "","");
var tmpEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(tmpPath);
// stage contents to local folder
TransferDirectoryContents(src, tmpEndPoint, new Dev2CRUDOperationTO(true));
using(var zip = new ZipFile())
{
zip.SaveProgress += (sender, eventArgs) =>
{
if(eventArgs.CurrentEntry != null)
{
Dev2Logger.Log.Debug(string.Format("Event Type: {0} Total Entries: {1} Entries Saved: {2} Current Entry: {3}", eventArgs.EventType, eventArgs.EntriesTotal, eventArgs.EntriesSaved, eventArgs.CurrentEntry.FileName));
}
};
// set password if exist
if(args.ArchivePassword != string.Empty)
{
zip.Password = args.ArchivePassword;
}
// compression ratio
zip.CompressionLevel = ExtractZipCompressionLevel(args.CompressionRatio);
var toAdd = ListDirectory(tmpEndPoint, ReadTypes.FilesAndFolders);
// add all files to archive
foreach(var p in toAdd)
{
if(tmpEndPoint.PathIs(p) == enPathType.Directory)
{
var directoryPathInArchive = p.Path.Replace(tmpPath.Path, "");
zip.AddDirectory(p.Path, directoryPathInArchive);
}
else
{
zip.AddFile(p.Path, ".");
}
}
zip.Save(tempFilename);
}
// remove locally staged files
DirectoryHelper.CleanUp(tmpDir);
return tempFilename;
}
string CreateEndPoint(IActivityIOOperationsEndPoint dst, Dev2CRUDOperationTO args, bool createToFile)
{
var result = ResultOk;
// check the the dir strucutre exist
var activityIOPath = dst.IOPath;
var dirParts = MakeDirectoryParts(activityIOPath, dst.PathSeperator());
// check from lowest path part up
var deepestIndex = -1;
var startDepth = dirParts.Count - 1;
var pos = startDepth;
while(pos >= 0 && deepestIndex == -1)
{
var tmpPath = ActivityIOFactory.CreatePathFromString(dirParts[pos], activityIOPath.Username,
activityIOPath.Password, true,activityIOPath.PrivateKeyFile);
try
{
if(dst.ListDirectory(tmpPath) != null)
{
deepestIndex = pos;
}
}
// ReSharper disable EmptyGeneralCatchClause
catch(Exception)
// ReSharper restore EmptyGeneralCatchClause
{
//Note that we doing a recursive create should the directory not exists
}
finally
{
pos--;
}
}
// now create all the directories we need ;)
pos = deepestIndex + 1;
var ok = true;
var origPath = dst.IOPath;
while(pos <= startDepth && ok)
{
var toCreate = ActivityIOFactory.CreatePathFromString(dirParts[pos], dst.IOPath.Username,
dst.IOPath.Password, true, dst.IOPath.PrivateKeyFile);
dst.IOPath = toCreate;
ok = CreateDirectory(dst, args);
pos++;
}
dst.IOPath = origPath;
// dir create failed
if(!ok)
{
result = ResultBad;
}
else if(dst.PathIs(dst.IOPath) == enPathType.File && createToFile)
{
if(!CreateFile(dst, args))
{
result = ResultBad;
}
}
return result;
}
static void DoFileTransfer(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, Dev2CRUDOperationTO args, IActivityIOPath dstPath, IActivityIOPath p, string path, ref bool result)
{
if(args.Overwrite || !dst.PathExist(dstPath))
{
result = TransferFile(src, dst, args, path, p, result);
}
}
public string Move(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst,
Dev2CRUDOperationTO args)
{
string result;
try
{
result = Copy(src, dst, args);
if(result.Equals("Success"))
{
src.Delete(src.IOPath);
}
}
finally
{
_filesToDelete.ForEach(RemoveTmpFile);
}
return result;
}
public string Rename(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst,
Dev2CRUDOperationTO args)
{
string result;
try
{
result = ValidateRenameSourceAndDesinationTypes(src, dst, args);
}
finally
{
_filesToDelete.ForEach(RemoveTmpFile);
}
return result;
}
private void BootstrapPersistence(string baseDir)
{
lock (InitLock)
{
if (_debugPath == null)
{
if (baseDir != null)
{
_rootPath = baseDir;
}
if (_rootPath.EndsWith("\\"))
{
_debugPersistPath = _rootPath + SavePath;
}
else
{
_debugPersistPath = _rootPath + "\\" + SavePath;
}
_debugPath = ActivityIOFactory.CreatePathFromString(_debugPersistPath, "", "","");
_debugOptsEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(_debugPath);
}
}
}
public string Zip(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, Dev2ZipOperationTO args)
{
string status;
try
{
status = ValidateZipSourceDestinationFileOperation(src, dst, args, () =>
{
string tempFileName;
if(src.PathIs(src.IOPath) == enPathType.Directory || Dev2ActivityIOPathUtils.IsStarWildCard(src.IOPath.Path))
{
tempFileName = ZipDirectoryToALocalTempFile(src, args);
}
else
{
tempFileName = ZipFileToALocalTempFile(src, args);
}
return TransferTempZipFileToDestination(src, dst, args, tempFileName);
});
}
finally
{
_filesToDelete.ForEach(RemoveTmpFile);
}
return status;
}
public string Create(IActivityIOOperationsEndPoint dst, Dev2CRUDOperationTO args, bool createToFile)
{
string result;
try
{
ValidateEndPoint(dst, args);
result = CreateEndPoint(dst, args, createToFile);
}
finally
{
_filesToDelete.ForEach(RemoveTmpFile);
}
return result;
}
protected override string ExecuteBroker(IActivityOperationsBroker broker, IActivityIOOperationsEndPoint scrEndPoint, IActivityIOOperationsEndPoint dstEndPoint)
{
Dev2CRUDOperationTO opTO = new Dev2CRUDOperationTO(Overwrite);
return broker.Copy(scrEndPoint, dstEndPoint, opTO);
}
static bool PerformTransfer(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, Dev2CRUDOperationTO args, string origDstPath, IActivityIOPath p, bool result)
{
try
{
if(dst.PathIs(dst.IOPath) == enPathType.Directory)
{
var cpPath =
ActivityIOFactory.CreatePathFromString(
string.Format("{0}{1}{2}", origDstPath, dst.PathSeperator(),
Dev2ActivityIOPathUtils.ExtractFileName(p.Path)),
dst.IOPath.Username,
dst.IOPath.Password, true,dst.IOPath.PrivateKeyFile);
var path = cpPath.Path;
DoFileTransfer(src, dst, args, cpPath, p, path, ref result);
}
else if(args.Overwrite || !dst.PathExist(dst.IOPath))
{
var tmp = origDstPath + "\\" + Dev2ActivityIOPathUtils.ExtractFileName(p.Path);
var path = ActivityIOFactory.CreatePathFromString(tmp, dst.IOPath.Username, dst.IOPath.Password, dst.IOPath.PrivateKeyFile);
DoFileTransfer(src, dst, args, path, p, path.Path, ref result);
}
}
catch(Exception ex)
{
Dev2Logger.Log.Error(ex);
}
return result;
}
/// <summary>
/// Transfer the contents of the directory
/// </summary>
/// <param name="src"></param>
/// <param name="dst"></param>
/// <param name="args"></param>
void ValidateSourceAndDestinationContents(IActivityIOOperationsEndPoint src,
IActivityIOOperationsEndPoint dst,
Dev2CRUDOperationTO args)
{
if(!args.Overwrite)
{
var srcContentsFolders = src.ListFoldersInDirectory(src.IOPath);
foreach(var sourcePath in srcContentsFolders)
{
var sourceEndPoint =
ActivityIOFactory.CreateOperationEndPointFromIOPath(sourcePath);
IList<string> dirParts =
sourceEndPoint.IOPath.Path.Split(sourceEndPoint.PathSeperator().ToCharArray(),
StringSplitOptions.RemoveEmptyEntries);
var directory = dirParts.Last();
var destinationPath =
ActivityIOFactory.CreatePathFromString(dst.Combine(directory),
dst.IOPath.Username,
dst.IOPath.Password, true, dst.IOPath.PrivateKeyFile);
var destinationEndPoint =
ActivityIOFactory.CreateOperationEndPointFromIOPath(destinationPath);
if(destinationEndPoint.PathExist(destinationEndPoint.IOPath))
{
ValidateSourceAndDestinationContents(sourceEndPoint, destinationEndPoint, args);
}
}
var srcContents = src.ListFilesInDirectory(src.IOPath);
var dstContents = dst.ListFilesInDirectory(dst.IOPath);
var sourceFileNames = srcContents.Select(srcFile => GetFileNameFromEndPoint(src, srcFile)).ToList();
var destinationFileNames = dstContents.Select(dstFile => GetFileNameFromEndPoint(dst, dstFile)).ToList();
if(destinationFileNames.Count > 0)
{
var commonFiles = sourceFileNames.Where(destinationFileNames.Contains).ToList();
if(commonFiles.Count > 0)
{
var fileNames = commonFiles.Aggregate("",
(current, commonFile) =>
current + "\r\n" + commonFile);
throw new Exception(
"The following file(s) exist in the destination folder and overwrite is set to false:- " +
fileNames);
}
}
}
}
static string GetWhereToPut(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst)
{
if(src.IOPath.PathType == enActivityIOPathType.FileSystem)
{
// some silly chicken is not getting the directory correctly ?!
return Path.GetDirectoryName(src.IOPath.Path);
}
if(dst.IOPath.PathType == enActivityIOPathType.FileSystem)
{
return Path.GetDirectoryName(src.IOPath.Path);
}
return null; // this means that neither the src or destination where local files
}
static void EnsureFilesDontExists(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst)
{
if(dst.PathExist(dst.IOPath))
{
// destination is a file
if(dst.PathIs(dst.IOPath) == enPathType.File)
{
throw new Exception(
"A file with the same name exists on the destination and overwrite is set to false");
}
//destination is a folder
var dstContents = dst.ListDirectory(dst.IOPath);
var destinationFileNames = dstContents.Select(dstFile => GetFileNameFromEndPoint(dst, dstFile));
var sourceFile = GetFileNameFromEndPoint(src);
if(destinationFileNames.Contains(sourceFile))
{
throw new Exception(
"The following file(s) exist in the destination folder and overwrite is set to false :- " +
sourceFile);
}
}
}
