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