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; }