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);
}
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);
}
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 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();
}
}
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);
}
/// <summary>
/// Boot strap the Session
/// </summary>
private void InitPersistSettings()
{
lock (SettingsLock)
{
if (!_debugOptsEndPoint.PathExist(_debugPath))
{
var args = new Dev2PutRawOperationTO(WriteType.Overwrite, "");
ActivityIOFactory.CreateOperationsBroker().PutRaw(_debugOptsEndPoint, args);
}
else
{
// fetch from disk
var filesToCleanup = new List <string>();
using (Stream s = _debugOptsEndPoint.Get(_debugPath, filesToCleanup))
{
if (s.Length > 0)
{
var bf = new XmlSerializer(typeof(List <SaveDebugTO>));
try
{
var settings = (List <SaveDebugTO>)bf.Deserialize(s);
_debugPersistSettings.Values.ToList().ForEach(a => a.CleanUp());
_debugPersistSettings.Clear();
// now push back into the Dictionary
foreach (SaveDebugTO dto in settings)
{
if (dto.ServiceName.Length > 0)
{
var tmp = new DebugTO();
tmp.CopyFromSaveDebugTO(dto);
string error;
tmp.BinaryDataList = DeSerialize(tmp.XmlData, tmp.DataList,
enTranslationTypes.XML, out error);
_debugPersistSettings[dto.WorkflowID] = tmp;
}
}
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
}
}
else
{
Dev2Logger.Log.Error("No debug data stream [ " + _debugPath + " ] ");
}
s.Close();
s.Dispose();
filesToCleanup.ForEach(File.Delete);
}
}
}
}
public void ValidateEndPoint(IActivityIOOperationsEndPoint endPoint, IDev2CRUDOperationTO args)
{
if (endPoint.IOPath?.Path.Trim().Length == 0)
{
throw new Exception(ErrorResource.SourceCannotBeAnEmptyString);
}
if (endPoint.PathExist(endPoint.IOPath) && !args.Overwrite)
{
throw new Exception(ErrorResource.DestinationDirectoryExist);
}
}
void InitPersistSettings(DebugTO to)
{
if (!_debugOptsEndPoint.PathExist(_debugPath))
{
var args = new Dev2PutRawOperationTO(WriteType.Overwrite, "");
ActivityIOFactory.CreateOperationsBroker().PutRaw(_debugOptsEndPoint, args);
}
else
{
FetchFromDisk(to);
}
}
string ValidateZipSourceDestinationFileOperation(IActivityIOOperationsEndPoint src,
IActivityIOOperationsEndPoint dst,
IDev2ZipOperationTO args,
Func <string> performAfterValidation)
{
_common.AddMissingFileDirectoryParts(src, dst);
if (dst.PathIs(dst.IOPath) == enPathType.Directory)
{
var sourcePart =
src.IOPath.Path.Split(src.PathSeperator().ToCharArray(), StringSplitOptions.RemoveEmptyEntries)
.Last();
if (src.PathIs(src.IOPath) == enPathType.File)
{
var fileInfo = new FileInfo(sourcePart);
dst.IOPath.Path = dst.Combine(sourcePart.Replace(fileInfo.Extension, ".zip"));
}
else
{
dst.IOPath.Path = dst.IOPath.Path + ".zip";
}
}
else
{
var sourcePart =
dst.IOPath.Path.Split(dst.PathSeperator().ToCharArray(), StringSplitOptions.RemoveEmptyEntries)
.Last();
var fileInfo = new FileInfo(sourcePart);
dst.IOPath.Path = dst.IOPath.Path.Replace(fileInfo.Extension, ".zip");
}
if (!args.Overwrite && dst.PathExist(dst.IOPath))
{
throw new Exception(ErrorResource.DestinationFileAlreadyExists);
}
var opStatus = CreateEndPoint(dst, new Dev2CRUDOperationTO(args.Overwrite),
dst.PathIs(dst.IOPath) == enPathType.Directory);
if (!opStatus.Equals(ResultOk))
{
throw new Exception(string.Format(ErrorResource.RecursiveDirectoryCreateFailed, dst.IOPath.Path));
}
return(performAfterValidation());
}
string MoveTmpFileToDestination(IActivityIOOperationsEndPoint dst, string tmp, string result)
{
using (Stream s = new MemoryStream(_fileWrapper.ReadAllBytes(tmp)))
{
var newArgs = new Dev2CRUDOperationTO(true);
if (!dst.PathExist(dst.IOPath))
{
CreateEndPoint(dst, newArgs, true);
}
if (dst.Put(s, dst.IOPath, newArgs, null, _filesToDelete) < 0)
{
result = ResultBad;
}
}
return(result);
}
void EnsureFilesDontExists(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst)
{
if (dst.PathExist(dst.IOPath))
{
if (dst.PathIs(dst.IOPath) == enPathType.File)
{
throw new Exception(ErrorResource.FileWithSameNameExist);
}
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(string.Format(ErrorResource.FileExistInDestinationFolder, sourceFile));
}
}
}
string ValidateRenameSourceAndDesinationTypes(IActivityIOOperationsEndPoint src,
IActivityIOOperationsEndPoint dst,
IDev2CRUDOperationTO args)
{
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));
}
public string PutRaw(IActivityIOOperationsEndPoint dst, IDev2PutRawOperationTO args)
{
var result = ResultOk;
try
{
FileLock.EnterWriteLock();
if (dst.RequiresLocalTmpStorage())
{
var tmp = CreateTmpFile();
WriteToLocalTempStorage(dst, args, tmp);
result = MoveTmpFileToDestination(dst, tmp, result);
}
else
{
if (dst.PathExist(dst.IOPath))
{
var tmp = CreateTmpFile();
result = WriteToRemoteTempStorage(dst, args, result, tmp);
RemoveTmpFile(tmp);
}
else
{
var newArgs = new Dev2CRUDOperationTO(true);
CreateEndPoint(dst, newArgs, true);
WriteDataToFile(args, dst);
}
}
}
finally
{
FileLock.ExitWriteLock();
for (var index = _filesToDelete.Count - 1; index > 0; index--)
{
var name = _filesToDelete[index];
RemoveTmpFile(name);
}
}
return(result);
}
public string PutRaw(IActivityIOOperationsEndPoint dst, IDev2PutRawOperationTO args)
{
string tmpFileName = null;
try
{
FileLock.EnterWriteLock();
if (dst.RequiresLocalTmpStorage())
{
var tmp = _implementation.CreateTmpFile();
_implementation.WriteToLocalTempStorage(dst, args, tmp);
return(_implementation.MoveTmpFileToDestination(dst, tmp));
}
else
{
if (dst.PathExist(dst.IOPath))
{
tmpFileName = _implementation.CreateTmpFile();
return(_implementation.WriteToRemoteTempStorage(dst, args, tmpFileName));
}
else
{
return(CreateEndPointAndWriteData(dst, args));
}
}
}
finally
{
if (tmpFileName != null)
{
_implementation.RemoveTmpFile(tmpFileName);
}
FileLock.ExitWriteLock();
RemoveAllTmpFiles();
}
}
string ValidateUnzipSourceDestinationFileOperation(IActivityIOOperationsEndPoint src,
IActivityIOOperationsEndPoint dst,
IDev2UnZipOperationTO args,
Func <string> performAfterValidation)
{
_common.ValidateSourceAndDestinationPaths(src, dst);
if (dst.PathIs(dst.IOPath) != enPathType.Directory)
{
throw new Exception(ErrorResource.DestinationMustBeADirectory);
}
if (src.PathIs(src.IOPath) != enPathType.File)
{
throw new Exception(ErrorResource.SourceMustBeAFile);
}
if (!args.Overwrite && dst.PathExist(dst.IOPath))
{
throw new Exception(ErrorResource.DestinationDirectoryExist);
}
return(performAfterValidation?.Invoke());
}
/// <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, IDev2CRUDOperationTO 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);
}
foreach (var p in srcContents)
{
result = PerformTransfer(src, dst, args, origDstPath, p, result);
}
Dev2Logger.Debug($"Transfered: {src.IOPath.Path}");
return(result);
}
string ValidateRenameSourceAndDesinationTypes(IActivityIOOperationsEndPoint src,
IActivityIOOperationsEndPoint dst,
Dev2CRUDOperationTO args)
{
//ensures that the source and destination locations are of the same type
if(src.PathIs(src.IOPath) != dst.PathIs(dst.IOPath))
{
throw new Exception("Source and destination need to be both files or directories");
}
//Rename Tool if the file/folder exists then delete it and put the source there
if(dst.PathExist(dst.IOPath))
{
if(!args.Overwrite)
{
throw new Exception("Destination directory already exists and overwrite is set to false");
}
//Clear the existing folder
dst.Delete(dst.IOPath);
}
return Move(src, dst, args);
}
string ValidateUnzipSourceDestinationFileOperation(IActivityIOOperationsEndPoint src,
IActivityIOOperationsEndPoint dst,
Dev2UnZipOperationTO args,
Func<string> performAfterValidation)
{
ValidateSourceAndDestinationPaths(src, dst);
if(dst.PathIs(dst.IOPath) != enPathType.Directory)
{
throw new Exception("Destination must be a directory");
}
if(src.PathIs(src.IOPath) != enPathType.File)
{
throw new Exception("Source must be a file");
}
if(!args.Overwrite && dst.PathExist(dst.IOPath))
{
throw new Exception("Destination directory already exists and overwrite is set to false");
}
return performAfterValidation();
}
string ValidateZipSourceDestinationFileOperation(IActivityIOOperationsEndPoint src,
IActivityIOOperationsEndPoint dst,
Dev2ZipOperationTO args,
Func<string> performAfterValidation)
{
AddMissingFileDirectoryParts(src, dst);
if(dst.PathIs(dst.IOPath) == enPathType.Directory)
{
var sourcePart =
src.IOPath.Path.Split(src.PathSeperator().ToCharArray(), StringSplitOptions.RemoveEmptyEntries)
.Last();
if(src.PathIs(src.IOPath) == enPathType.File)
{
var fileInfo = new FileInfo(sourcePart);
dst.IOPath.Path = dst.Combine(sourcePart.Replace(fileInfo.Extension, ".zip"));
}
else
{
dst.IOPath.Path = dst.IOPath.Path + ".zip";
}
}
else
{
var sourcePart =
dst.IOPath.Path.Split(dst.PathSeperator().ToCharArray(), StringSplitOptions.RemoveEmptyEntries)
.Last();
var fileInfo = new FileInfo(sourcePart);
dst.IOPath.Path = dst.IOPath.Path.Replace(fileInfo.Extension, ".zip");
}
if(!args.Overwrite && dst.PathExist(dst.IOPath))
{
throw new Exception("Destination file already exists and overwrite is set to false");
}
//ensures destination folder structure exists
var opStatus = CreateEndPoint(dst, new Dev2CRUDOperationTO(args.Overwrite),
dst.PathIs(dst.IOPath) == enPathType.Directory);
if(!opStatus.Equals("Success"))
{
throw new Exception("Recursive Directory Create Failed For [ " + dst.IOPath.Path + " ]");
}
return performAfterValidation();
}
void ValidateEndPoint(IActivityIOOperationsEndPoint endPoint, Dev2CRUDOperationTO args)
{
if(endPoint.IOPath.Path.Trim().Length == 0)
{
throw new Exception("Source can not be an empty string");
}
if(endPoint.PathExist(endPoint.IOPath) && !args.Overwrite)
{
var type = endPoint.PathIs(endPoint.IOPath) == enPathType.Directory ? "Directory" : "File";
throw new Exception(string.Format("Destination {0} already exists and overwrite is set to false",
type));
}
}
string MoveTmpFileToDestination(IActivityIOOperationsEndPoint dst, string tmp, string result)
{
using(Stream s = new MemoryStream(File.ReadAllBytes(tmp)))
{
Dev2CRUDOperationTO newArgs = new Dev2CRUDOperationTO(true);
//MO : 22-05-2012 : If the file doesnt exist then create the file
if(!dst.PathExist(dst.IOPath))
{
CreateEndPoint(dst, newArgs, true);
}
if(dst.Put(s, dst.IOPath, newArgs, null, _filesToDelete) < 0)
{
result = ResultBad;
}
}
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;
}
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);
}
}
}
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);
}
}
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;
}
