/// <summary> /// An impersonation safe way to get the time for which to base aging /// </summary> /// <param name="targetSource">The target of the time</param> /// <returns>The time to use for ageing sources</returns> public virtual DateTime GetAgeBasis(string targetSource) { try { STEM.Sys.IO.Listing.FileInfo fi = null; try { fi = GetFileInfo(targetSource); } catch { } if (fi == null) { STEM.Sys.IO.Listing.DirectoryInfo di = GetDirectoryInfo(targetSource); if (di == null) { return(DateTime.MinValue); } switch (SelectedOrigin) { case STEM.Surge.AgeOrigin.LastWriteTime: return(di.LastWriteTimeUtc); case STEM.Surge.AgeOrigin.LastAccessTime: return(di.LastAccessTimeUtc); case STEM.Surge.AgeOrigin.CreationTime: return(di.CreationTimeUtc); } } else { switch (SelectedOrigin) { case STEM.Surge.AgeOrigin.LastWriteTime: return(fi.LastWriteTimeUtc); case STEM.Surge.AgeOrigin.LastAccessTime: return(fi.LastAccessTimeUtc); case STEM.Surge.AgeOrigin.CreationTime: return(fi.CreationTimeUtc); } } } catch { } return(DateTime.MinValue); }
bool Execute() { try { if (Direction == S3Direction.ToS3Bucket) { ExpandDestination = false; } else { ExpandSource = false; } List <string> sources = new List <string>(); if (ExpandSource) { sources = STEM.Sys.IO.Path.ExpandRangedPath(SourcePath); } else { sources.Add(SourcePath); } List <string> destinations = new List <string>(); if (ExpandDestination) { destinations = STEM.Sys.IO.Path.ExpandRangedPath(DestinationPath); } else { destinations.Add(DestinationPath); } List <string> sourceFiles = new List <string>(); int filesActioned = 0; foreach (string src in sources) { List <S3Object> items = new List <S3Object>(); if (Direction == S3Direction.ToS3Bucket) { sourceFiles = STEM.Sys.IO.Directory.STEM_GetFiles(src, FileFilter, DirectoryFilter, (RecurseSource ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly), false); } else { string bucket = Authentication.BucketFromPath(src); string prefix = Authentication.PrefixFromPath(src); if (PopulatePostMortemMeta) { PostMortemMetaData["Bucket"] = bucket; PostMortemMetaData["Prefix"] = prefix; } items = Authentication.ListObjects(bucket, prefix, STEM.Sys.IO.Listing.ListingType.File, RecurseSource, DirectoryFilter, FileFilter); sourceFiles = items.Select(i => Authentication.ToString(i)).ToList(); } foreach (string s in sourceFiles) { try { bool success = false; Exception lastEX = null; foreach (string d in destinations) { try { string dFile = ""; long fileSz = 0; if (Direction == S3Direction.ToS3Bucket) { fileSz = new FileInfo(s).Length; } else { fileSz = Authentication.GetFileInfo(s).Size; } _PartSize[s] = (int)Math.Max(MinimumPartSize, fileSz / MaximumNumberOfParts); try { if (PopulatePostMortemMeta) { PostMortemMetaData["SourceIP"] = STEM.Sys.IO.Path.IPFromPath(s); PostMortemMetaData["DestinationIP"] = STEM.Sys.IO.Path.IPFromPath(d); PostMortemMetaData["FileSize"] = fileSz.ToString(); } } catch { } if (Direction == S3Direction.ToS3Bucket) { string dPath = STEM.Sys.IO.Path.AdjustPath(d); if (RecurseSource && RecreateTree) { dPath = System.IO.Path.Combine(dPath, STEM.Sys.IO.Path.GetDirectoryName(s).Replace(STEM.Sys.IO.Path.AdjustPath(src), "").Trim(System.IO.Path.DirectorySeparatorChar)); } dPath = System.IO.Path.Combine(dPath, DestinationFilename); if (dPath.Contains("*.*")) { dPath = dPath.Replace("*.*", STEM.Sys.IO.Path.GetFileName(s)); } if (dPath.Contains("*")) { dPath = dPath.Replace("*", STEM.Sys.IO.Path.GetFileNameWithoutExtension(s)); } if (!Authentication.DirectoryExists(STEM.Sys.IO.Path.GetDirectoryName(dPath))) { Authentication.CreateDirectory(STEM.Sys.IO.Path.GetDirectoryName(dPath)); } if (Authentication.FileExists(dPath)) { switch (ExistsAction) { case Sys.IO.FileExistsAction.Overwrite: Authentication.DeleteFile(dPath); dFile = dPath; break; case Sys.IO.FileExistsAction.OverwriteIfNewer: if (Authentication.GetFileInfo(dPath).LastWriteTimeUtc >= File.GetLastWriteTimeUtc(s)) { continue; } Authentication.DeleteFile(dPath); dFile = dPath; break; case Sys.IO.FileExistsAction.Skip: continue; case Sys.IO.FileExistsAction.Throw: throw new IOException("Destination file exists. (" + dPath + ")"); case Sys.IO.FileExistsAction.MakeUnique: dFile = Authentication.UniqueFilename(dPath); break; } } else { dFile = dPath; } string bucket = Authentication.BucketFromPath(dFile); string prefix = Authentication.PrefixFromPath(dFile); if (PopulatePostMortemMeta) { PostMortemMetaData["Bucket"] = bucket; PostMortemMetaData["Prefix"] = prefix; } TransferUtilityUpload(bucket, prefix, s, s); } else { string dPath = STEM.Sys.IO.Path.AdjustPath(d); if (RecurseSource && RecreateTree) { dPath = System.IO.Path.Combine(dPath, STEM.Sys.IO.Path.GetDirectoryName(s).Replace(STEM.Sys.IO.Path.AdjustPath(src), "").Trim(System.IO.Path.DirectorySeparatorChar)); } dPath = System.IO.Path.Combine(dPath, DestinationFilename); if (dPath.Contains("*.*")) { dPath = dPath.Replace("*.*", STEM.Sys.IO.Path.GetFileName(s)); } if (dPath.Contains("*")) { dPath = dPath.Replace("*", STEM.Sys.IO.Path.GetFileNameWithoutExtension(s)); } if (File.Exists(dPath)) { switch (ExistsAction) { case Sys.IO.FileExistsAction.Overwrite: File.Delete(dPath); dFile = dPath; break; case Sys.IO.FileExistsAction.OverwriteIfNewer: if (File.GetLastWriteTimeUtc(dPath) >= Authentication.GetFileInfo(s).LastWriteTimeUtc) { continue; } File.Delete(dPath); dFile = dPath; break; case Sys.IO.FileExistsAction.Skip: continue; case Sys.IO.FileExistsAction.Throw: throw new IOException("Destination file exists. (" + dPath + ")"); case Sys.IO.FileExistsAction.MakeUnique: dFile = STEM.Sys.IO.File.UniqueFilename(dPath); break; } } else { dFile = dPath; } if (!Directory.Exists(STEM.Sys.IO.Path.GetDirectoryName(dFile))) { Directory.CreateDirectory(STEM.Sys.IO.Path.GetDirectoryName(dFile)); } string bucket = Authentication.BucketFromPath(s); string prefix = Authentication.PrefixFromPath(s); if (PopulatePostMortemMeta) { PostMortemMetaData["Bucket"] = bucket; PostMortemMetaData["Prefix"] = prefix; } STEM.Sys.IO.Listing.FileInfo fi = Authentication.GetFileInfo(s); if (fi != null) { string tmp = ""; try { tmp = Path.Combine(STEM.Sys.IO.Path.GetDirectoryName(dFile), "TEMP"); if (!Directory.Exists(tmp)) { Directory.CreateDirectory(tmp); } tmp = Path.Combine(tmp, STEM.Sys.IO.Path.GetFileName(dFile)); TransferUtilityDownload(bucket, prefix, tmp); try { File.SetLastWriteTimeUtc(tmp, fi.LastWriteTimeUtc); } catch { } File.Move(tmp, STEM.Sys.IO.Path.AdjustPath(dFile)); } finally { try { if (File.Exists(tmp)) { File.Delete(tmp); } } catch { } } } else { throw new System.IO.FileNotFoundException(s); } } if (!String.IsNullOrEmpty(dFile)) { filesActioned++; _FilesActioned[s] = dFile; if (Action == ActionType.Move) { AppendToMessage(s + " moved to " + dFile); } else { AppendToMessage(s + " copied to " + dFile); } } success = true; if (DestinationActionRule == DestinationRule.FirstSuccess) { break; } } catch (Exception ex) { lastEX = ex; if (DestinationActionRule == DestinationRule.AllOrNone) { throw ex; } } } if (!success) { throw new Exception("No successful actions taken for " + s, lastEX); // + "\r\n" + ((lastEX == null) ? "No additional information." : lastEX.ToString())); } if (Action == ActionType.Move) { if (Direction == S3Direction.ToS3Bucket) { File.Delete(s); } else { Authentication.DeleteFile(s); } } } catch (AggregateException ex) { foreach (Exception e in ex.InnerExceptions) { AppendToMessage(e.Message); } Exceptions.Add(ex); //add the entire message to the collection to maintain the top level exception's stack } catch (Exception ex) { AppendToMessage(ex.Message); Exceptions.Add(ex); } } } if (PopulatePostMortemMeta) { PostMortemMetaData["FilesActioned"] = filesActioned.ToString(); } } catch (AggregateException ex) { foreach (Exception e in ex.InnerExceptions) { AppendToMessage(e.Message); } Exceptions.Add(ex); //add the entire message to the collection to maintain the top level exception's stack } catch (Exception ex) { AppendToMessage(ex.Message); Exceptions.Add(ex); } if (_FilesActioned.Count == 0) { switch (ZeroFilesAction) { case FailureAction.SkipRemaining: SkipRemaining(); return(true); case FailureAction.SkipNext: SkipNext(); return(true); case FailureAction.SkipToLabel: SkipForwardToFlowControlLabel(FailureActionLabel); return(true); case FailureAction.Rollback: RollbackAllPreceedingAndSkipRemaining(); break; case FailureAction.Continue: return(true); } Message = "0 Files Actioned\r\n" + Message; } return(Exceptions.Count == 0); }
/// <summary> /// Customize an iSetTemplate by applying the TemplateKVP map to the InstructionsXml /// </summary> /// <param name="iSetTemplate">A clone of the template to be modified in this method</param> /// <param name="map">The TemplateKVP map used to modify the iSetTemplate</param> /// <param name="branchIP">The branchIP this will be assigned to</param> /// <param name="initiationSource">The initiationSource passed in to GenerateDeploymentDetails()</param> /// <param name="cloneMap">Should the map be cloned as it will be modified in this method</param> public override void CustomizeInstructionSet(_InstructionSet iSetTemplate, System.Collections.Generic.Dictionary <string, string> map, string branchIP, string initiationSource, bool cloneMap = true) { if (iSetTemplate == null) { throw new ArgumentNullException(nameof(iSetTemplate)); } if (map == null) { throw new ArgumentNullException(nameof(map)); } if (String.IsNullOrEmpty(branchIP)) { throw new ArgumentNullException(nameof(branchIP)); } if (String.IsNullOrEmpty(initiationSource)) { throw new ArgumentNullException(nameof(initiationSource)); } System.Collections.Generic.Dictionary <string, string> kvp = map; if (cloneMap) { kvp = new System.Collections.Generic.Dictionary <string, string>(map); } kvp["[TargetPath]"] = STEM.Sys.IO.Path.GetDirectoryName(initiationSource); if (!String.IsNullOrEmpty(kvp["[TargetPath]"])) { kvp["[TargetDirectoryName]"] = STEM.Sys.IO.Path.GetFileName(kvp["[TargetPath]"]); kvp["[TargetName]"] = STEM.Sys.IO.Path.GetFileName(initiationSource); kvp["[TargetNameWithoutExt]"] = STEM.Sys.IO.Path.GetFileNameWithoutExtension(initiationSource); kvp["[TargetExt]"] = STEM.Sys.IO.Path.GetExtension(initiationSource); } else { kvp["[TargetPath]"] = ""; kvp["[TargetDirectoryName]"] = ""; kvp["[TargetName]"] = ""; kvp["[TargeteNameWithoutExt]"] = ""; kvp["[TargetExt]"] = ""; } kvp["[SourceAddress]"] = STEM.Sys.IO.Path.IPFromPath(initiationSource); kvp["[SourceMachineName]"] = STEM.Sys.IO.Net.MachineName(kvp["[SourceAddress]"]); string xml = iSetTemplate.SerializationSourceInstructionDocument; bool getFileInfo = false; if (xml.IndexOf("[LastWriteTimeUtc]", StringComparison.InvariantCultureIgnoreCase) >= 0) { getFileInfo = true; } if (getFileInfo == false) { if (xml.IndexOf("[LastAccessTimeUtc]", StringComparison.InvariantCultureIgnoreCase) >= 0) { getFileInfo = true; } } if (getFileInfo == false) { if (xml.IndexOf("[CreationTimeUtc]", StringComparison.InvariantCultureIgnoreCase) >= 0) { getFileInfo = true; } } if (getFileInfo == false) { if (xml.IndexOf("[FileSize]", StringComparison.InvariantCultureIgnoreCase) >= 0) { getFileInfo = true; } } if (getFileInfo == false) { foreach (string k in kvp.Keys) { if (kvp[k] != null) { if (kvp[k].IndexOf("[LastWriteTimeUtc]", StringComparison.InvariantCultureIgnoreCase) >= 0) { getFileInfo = true; break; } if (kvp[k].IndexOf("[LastAccessTimeUtc]", StringComparison.InvariantCultureIgnoreCase) >= 0) { getFileInfo = true; break; } if (kvp[k].IndexOf("[CreationTimeUtc]", StringComparison.InvariantCultureIgnoreCase) >= 0) { getFileInfo = true; break; } if (kvp[k].IndexOf("[FileSize]", StringComparison.InvariantCultureIgnoreCase) >= 0) { getFileInfo = true; break; } } } } if (getFileInfo) { STEM.Sys.IO.Listing.FileInfo info = GetFileInfo(initiationSource); if (info == null) { info = new STEM.Sys.IO.Listing.FileInfo { CreationTimeUtc = DateTime.MinValue, LastAccessTimeUtc = DateTime.MinValue, LastWriteTimeUtc = DateTime.MinValue, Size = 0 } } ; foreach (string key in kvp.Keys.Where(i => i.Equals("[LastWriteTimeUtc]", StringComparison.InvariantCultureIgnoreCase)).ToList()) { try { kvp[key] = info.LastWriteTimeUtc.ToString(kvp[key], System.Globalization.CultureInfo.CurrentCulture); } catch { } } foreach (string key in kvp.Keys.Where(i => i.Equals("[LastAccessTimeUtc]", StringComparison.InvariantCultureIgnoreCase)).ToList()) { try { kvp[key] = info.LastAccessTimeUtc.ToString(kvp[key], System.Globalization.CultureInfo.CurrentCulture); } catch { } } foreach (string key in kvp.Keys.Where(i => i.Equals("[CreationTimeUtc]", StringComparison.InvariantCultureIgnoreCase)).ToList()) { try { kvp[key] = info.CreationTimeUtc.ToString(kvp[key], System.Globalization.CultureInfo.CurrentCulture); } catch { } } foreach (string key in kvp.Keys.Where(i => i.Equals("[FileSize]", StringComparison.InvariantCultureIgnoreCase)).ToList()) { try { kvp[key] = info.Size.ToString(); } catch { } } } string subDir = null; if (!String.IsNullOrEmpty(RecreateSubFromRootOf) && RecreateSubFromRootOf.Trim().Length > 0) { if (initiationSource.ToUpper(System.Globalization.CultureInfo.CurrentCulture).IndexOf(RecreateSubFromRootOf.ToUpper(System.Globalization.CultureInfo.CurrentCulture), StringComparison.InvariantCultureIgnoreCase) >= 0) { int startIndex = initiationSource.ToUpper(System.Globalization.CultureInfo.CurrentCulture).IndexOf(RecreateSubFromRootOf.ToUpper(System.Globalization.CultureInfo.CurrentCulture), StringComparison.InvariantCultureIgnoreCase) + RecreateSubFromRootOf.Length + 1; if (startIndex < STEM.Sys.IO.Path.GetDirectoryName(initiationSource).Length) { subDir = initiationSource.Substring(startIndex, STEM.Sys.IO.Path.GetDirectoryName(initiationSource).Length - startIndex); } } } if (subDir == null) { subDir = ""; } kvp["[SubDir]"] = subDir; base.CustomizeInstructionSet(iSetTemplate, kvp, branchIP, initiationSource, false); }
protected override void _Rollback() { if (ExecutionMode == ExecuteOn.ForwardExecution) { foreach (string d in _FilesActioned.Keys) { try { string s = _FilesActioned[d]; if (Action == ActionType.Move) { if (Direction == S3Direction.ToS3Bucket) { string bucket = Authentication.BucketFromPath(s); string prefix = Authentication.PrefixFromPath(s); STEM.Sys.IO.Listing.FileInfo fi = Authentication.GetFileInfo(s); if (fi != null) { string tmp = ""; try { tmp = Path.Combine(STEM.Sys.IO.Path.GetDirectoryName(d), "TEMP"); if (!Directory.Exists(tmp)) { Directory.CreateDirectory(tmp); } tmp = Path.Combine(tmp, STEM.Sys.IO.Path.GetFileName(d)); TransferUtilityDownload(bucket, prefix, tmp); try { File.SetLastWriteTimeUtc(tmp, fi.LastWriteTimeUtc); } catch { } File.Move(tmp, STEM.Sys.IO.Path.AdjustPath(d)); } finally { try { if (File.Exists(tmp)) { File.Delete(tmp); } } catch { } } } else { throw new System.IO.FileNotFoundException(s); } } else { string bucket = Authentication.BucketFromPath(d); string prefix = Authentication.PrefixFromPath(d); TransferUtilityUpload(bucket, prefix, s, d); } } if (Direction == S3Direction.ToS3Bucket) { Authentication.DeleteFile(s); } else { STEM.Sys.IO.File.STEM_Delete(s, false, Retry, RetryDelaySeconds); } } catch { } } } else { Execute(); } }