public AssemblyInfoFileUpdate(Arguments args, string workingDirectory, VersionVariables variables, IFileSystem fileSystem)
{
if (!args.UpdateAssemblyInfo) return;
if (args.Output != OutputType.Json)
Console.WriteLine("Updating assembly info files");
var assemblyInfoFiles = GetAssemblyInfoFiles(workingDirectory, args, fileSystem);
foreach (var assemblyInfoFile in assemblyInfoFiles)
{
var backupAssemblyInfo = assemblyInfoFile + ".bak";
var localAssemblyInfo = assemblyInfoFile;
fileSystem.Copy(assemblyInfoFile, backupAssemblyInfo, true);
restoreBackupTasks.Add(() =>
{
if (fileSystem.Exists(localAssemblyInfo))
fileSystem.Delete(localAssemblyInfo);
fileSystem.Move(backupAssemblyInfo, localAssemblyInfo);
});
cleanupBackupTasks.Add(() => fileSystem.Delete(backupAssemblyInfo));
var assemblyVersion = variables.AssemblySemVer;
var assemblyInfoVersion = variables.InformationalVersion;
var assemblyFileVersion = variables.MajorMinorPatch + ".0";
var fileContents = fileSystem.ReadAllText(assemblyInfoFile)
.RegexReplace(@"AssemblyVersion\(""\d+.\d+.\d+(.(\d+|\*))?""\)", string.Format("AssemblyVersion(\"{0}\")", assemblyVersion))
.RegexReplace(@"AssemblyInformationalVersion\(""\d+.\d+.\d+(.(\d+|\*))?""\)", string.Format("AssemblyInformationalVersion(\"{0}\")", assemblyInfoVersion))
.RegexReplace(@"AssemblyFileVersion\(""\d+.\d+.\d+(.(\d+|\*))?""\)", string.Format("AssemblyFileVersion(\"{0}\")", assemblyFileVersion));
fileSystem.WriteAllText(assemblyInfoFile, fileContents);
}
}
public void Move(IFileSystem source, FileSystemPath sourcePath, IFileSystem destination, FileSystemPath destinationPath)
{
bool isFile;
if ((isFile = sourcePath.IsFile) != destinationPath.IsFile)
throw new ArgumentException("The specified destination-path is of a different type than the source-path.");
if (isFile)
{
using (var sourceStream = source.OpenFile(sourcePath, FileAccess.Read))
{
using (var destinationStream = destination.CreateFile(destinationPath))
{
byte[] buffer = new byte[BufferSize];
int readBytes;
while ((readBytes = sourceStream.Read(buffer, 0, buffer.Length)) > 0)
destinationStream.Write(buffer, 0, readBytes);
}
}
source.Delete(sourcePath);
}
else
{
destination.CreateDirectory(destinationPath);
foreach (var ep in source.GetEntities(sourcePath).ToArray())
{
var destinationEntityPath = ep.IsFile
? destinationPath.AppendFile(ep.EntityName)
: destinationPath.AppendDirectory(ep.EntityName);
Move(source, ep, destination, destinationEntityPath);
}
if (!sourcePath.IsRoot)
source.Delete(sourcePath);
}
}
public AssemblyInfoFileUpdate(Arguments args, string workingDirectory, VersionVariables variables, IFileSystem fileSystem)
{
if (!args.UpdateAssemblyInfo) return;
if (args.Output != OutputType.Json)
Logger.WriteInfo("Updating assembly info files");
var assemblyInfoFiles = GetAssemblyInfoFiles(workingDirectory, args, fileSystem).ToList();
Logger.WriteInfo(string.Format("Found {0} files", assemblyInfoFiles.Count));
var assemblyVersion = variables.AssemblySemVer;
var assemblyVersionRegex = new Regex(@"AssemblyVersion\s*\(\s*""[^""]*""\s*\)");
var assemblyVersionString = !string.IsNullOrWhiteSpace(assemblyVersion) ? string.Format("AssemblyVersion(\"{0}\")", assemblyVersion) : null;
var assemblyInfoVersion = variables.InformationalVersion;
var assemblyInfoVersionRegex = new Regex(@"AssemblyInformationalVersion\s*\(\s*""[^""]*""\s*\)");
var assemblyInfoVersionString = string.Format("AssemblyInformationalVersion(\"{0}\")", assemblyInfoVersion);
var assemblyFileVersion = variables.MajorMinorPatch + ".0";
var assemblyFileVersionRegex = new Regex(@"AssemblyFileVersion\s*\(\s*""[^""]*""\s*\)");
var assemblyFileVersionString = string.Format("AssemblyFileVersion(\"{0}\")", assemblyFileVersion);
foreach (var assemblyInfoFile in assemblyInfoFiles)
{
var backupAssemblyInfo = assemblyInfoFile.FullName + ".bak";
var localAssemblyInfo = assemblyInfoFile.FullName;
fileSystem.Copy(assemblyInfoFile.FullName, backupAssemblyInfo, true);
restoreBackupTasks.Add(() =>
{
if (fileSystem.Exists(localAssemblyInfo))
fileSystem.Delete(localAssemblyInfo);
fileSystem.Move(backupAssemblyInfo, localAssemblyInfo);
});
cleanupBackupTasks.Add(() => fileSystem.Delete(backupAssemblyInfo));
var fileContents = fileSystem.ReadAllText(assemblyInfoFile.FullName);
var appendedAttributes = false;
if (!string.IsNullOrWhiteSpace(assemblyVersion))
{
fileContents = ReplaceOrAppend(assemblyVersionRegex, fileContents, assemblyVersionString, assemblyInfoFile.Extension, ref appendedAttributes);
}
fileContents = ReplaceOrAppend(assemblyInfoVersionRegex, fileContents, assemblyInfoVersionString, assemblyInfoFile.Extension, ref appendedAttributes);
fileContents = ReplaceOrAppend(assemblyFileVersionRegex, fileContents, assemblyFileVersionString, assemblyInfoFile.Extension, ref appendedAttributes);
if (appendedAttributes)
{
// If we appended any attributes, put a new line after them
fileContents += Environment.NewLine;
}
fileSystem.WriteAllText(assemblyInfoFile.FullName, fileContents);
}
}
/// <summary>
/// Executes the deletion of all items contained in this object.
/// </summary>
public override void ExecuteChanges(IFileSystem fileSystem)
{
foreach (String path in Items)
{
fileSystem.Delete(path);
}
}
public AssemblyInfoFileUpdate(Arguments args, string workingDirectory, VersionVariables variables, IFileSystem fileSystem)
{
if (!args.UpdateAssemblyInfo) return;
if (args.Output != OutputType.Json)
Logger.WriteInfo("Updating assembly info files");
var assemblyInfoFiles = GetAssemblyInfoFiles(workingDirectory, args, fileSystem);
Logger.WriteInfo(string.Format("Found {0} files", assemblyInfoFiles.Count()));
var assemblyVersion = variables.AssemblySemVer;
var assemblyVersionRegex = new Regex(@"AssemblyVersion\(""[^""]*""\)");
var assemblyVersionString = string.Format("AssemblyVersion(\"{0}\")", assemblyVersion);
var assemblyInfoVersion = variables.InformationalVersion;
var assemblyInfoVersionRegex = new Regex(@"AssemblyInformationalVersion\(""[^""]*""\)");
var assemblyInfoVersionString = string.Format("AssemblyInformationalVersion(\"{0}\")", assemblyInfoVersion);
var assemblyFileVersion = variables.MajorMinorPatch + ".0";
var assemblyFileVersionRegex = new Regex(@"AssemblyFileVersion\(""[^""]*""\)");
var assemblyFileVersionString = string.Format("AssemblyFileVersion(\"{0}\")", assemblyFileVersion);
foreach (var assemblyInfoFile in assemblyInfoFiles.Select(f => new FileInfo(f)))
{
var backupAssemblyInfo = assemblyInfoFile.FullName + ".bak";
var localAssemblyInfo = assemblyInfoFile.FullName;
fileSystem.Copy(assemblyInfoFile.FullName, backupAssemblyInfo, true);
restoreBackupTasks.Add(() =>
{
if (fileSystem.Exists(localAssemblyInfo))
fileSystem.Delete(localAssemblyInfo);
fileSystem.Move(backupAssemblyInfo, localAssemblyInfo);
});
cleanupBackupTasks.Add(() => fileSystem.Delete(backupAssemblyInfo));
var fileContents = fileSystem.ReadAllText(assemblyInfoFile.FullName);
fileContents = ReplaceOrAppend(assemblyVersionRegex, fileContents, assemblyVersionString);
fileContents = ReplaceOrAppend(assemblyInfoVersionRegex, fileContents, assemblyInfoVersionString);
fileContents = ReplaceOrAppend(assemblyFileVersionRegex, fileContents, assemblyFileVersionString);
fileSystem.WriteAllText(assemblyInfoFile.FullName, fileContents);
}
}
private void MakeRemoteTestFile(IFileSystem fs, Uri path)
{
if (fs.Exists(path))
{
fs.Delete(path);
}
using (var s = fs.Create(path))
{
s.WriteByte(TestByte);
}
}
public void Execute(VersionVariables variables, AssemblyInfoContext context)
{
if (context.EnsureAssemblyInfo)
{
throw new WarningException($"Configuration setting {nameof(context.EnsureAssemblyInfo)} is not valid when updating project files!");
}
var projectFilesToUpdate = GetProjectFiles(context).ToList();
var assemblyVersion = variables.AssemblySemVer;
var assemblyInfoVersion = variables.InformationalVersion;
var assemblyFileVersion = variables.AssemblySemFileVer;
var packageVersion = variables.NuGetVersionV2;
foreach (var projectFile in projectFilesToUpdate)
{
var localProjectFile = projectFile.FullName;
var originalFileContents = fileSystem.ReadAllText(localProjectFile);
var fileXml = XElement.Parse(originalFileContents);
if (!CanUpdateProjectFile(fileXml))
{
log.Warning($"Unable to update file: {localProjectFile}");
continue;
}
log.Debug($"Update file: {localProjectFile}");
var backupProjectFile = localProjectFile + ".bak";
fileSystem.Copy(localProjectFile, backupProjectFile, true);
restoreBackupTasks.Add(() =>
{
if (fileSystem.Exists(localProjectFile))
{
fileSystem.Delete(localProjectFile);
}
fileSystem.Move(backupProjectFile, localProjectFile);
});
cleanupBackupTasks.Add(() => fileSystem.Delete(backupProjectFile));
if (!string.IsNullOrWhiteSpace(assemblyVersion))
{
UpdateProjectVersionElement(fileXml, AssemblyVersionElement, assemblyVersion);
}
if (!string.IsNullOrWhiteSpace(assemblyFileVersion))
{
UpdateProjectVersionElement(fileXml, FileVersionElement, assemblyFileVersion);
}
if (!string.IsNullOrWhiteSpace(assemblyInfoVersion))
{
UpdateProjectVersionElement(fileXml, InformationalVersionElement, assemblyInfoVersion);
}
if (!string.IsNullOrWhiteSpace(packageVersion))
{
UpdateProjectVersionElement(fileXml, VersionElement, packageVersion);
}
var outputXmlString = fileXml.ToString();
if (originalFileContents != outputXmlString)
{
fileSystem.WriteAllText(localProjectFile, outputXmlString);
}
}
CommitChanges();
}
public void Delete(string localFileFullPath)
{
_fileSystem.Delete(localFileFullPath);
}
public override bool Execute()
{
try
{
Console.WriteLine("\nCalculating coverage result...");
IFileSystem fileSystem = DependencyInjection.Current.GetService <IFileSystem>();
if (InstrumenterState is null || !fileSystem.Exists(InstrumenterState.ItemSpec))
{
_logger.LogError("Result of instrumentation task not found");
return(false);
}
Coverage coverage = null;
using (Stream instrumenterStateStream = fileSystem.NewFileStream(InstrumenterState.ItemSpec, FileMode.Open))
{
coverage = new Coverage(CoveragePrepareResult.Deserialize(instrumenterStateStream), this._logger, DependencyInjection.Current.GetService <IInstrumentationHelper>(), fileSystem);
}
try
{
fileSystem.Delete(InstrumenterState.ItemSpec);
}
catch (Exception ex)
{
// We don't want to block coverage for I/O errors
_logger.LogWarning($"Exception during instrument state deletion, file name '{InstrumenterState.ItemSpec}' exception message '{ex.Message}'");
}
CoverageResult result = coverage.GetCoverageResult();
var directory = Path.GetDirectoryName(_output);
if (directory == string.Empty)
{
directory = Directory.GetCurrentDirectory();
}
else if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
var formats = _format.Split(',');
foreach (var format in formats)
{
var reporter = new ReporterFactory(format).CreateReporter();
if (reporter == null)
{
throw new Exception($"Specified output format '{format}' is not supported");
}
if (reporter.OutputType == ReporterOutputType.Console)
{
// Output to console
Console.WriteLine(" Outputting results to console");
Console.WriteLine(reporter.Report(result));
}
else
{
// Output to file
var filename = Path.GetFileName(_output);
filename = (filename == string.Empty) ? $"coverage.{reporter.Extension}" : filename;
filename = Path.HasExtension(filename) ? filename : $"{filename}.{reporter.Extension}";
var report = Path.Combine(directory, filename);
Console.WriteLine($" Generating report '{report}'");
fileSystem.WriteAllText(report, reporter.Report(result));
}
}
var thresholdTypeFlags = ThresholdTypeFlags.None;
var thresholdStat = ThresholdStatistic.Minimum;
foreach (var thresholdType in _thresholdType.Split(',').Select(t => t.Trim()))
{
if (thresholdType.Equals("line", StringComparison.OrdinalIgnoreCase))
{
thresholdTypeFlags |= ThresholdTypeFlags.Line;
}
else if (thresholdType.Equals("branch", StringComparison.OrdinalIgnoreCase))
{
thresholdTypeFlags |= ThresholdTypeFlags.Branch;
}
else if (thresholdType.Equals("method", StringComparison.OrdinalIgnoreCase))
{
thresholdTypeFlags |= ThresholdTypeFlags.Method;
}
}
if (_thresholdStat.Equals("average", StringComparison.OrdinalIgnoreCase))
{
thresholdStat = ThresholdStatistic.Average;
}
else if (_thresholdStat.Equals("total", StringComparison.OrdinalIgnoreCase))
{
thresholdStat = ThresholdStatistic.Total;
}
var coverageTable = new ConsoleTable("Module", "Line", "Branch", "Method");
var summary = new CoverageSummary();
int numModules = result.Modules.Count;
var linePercentCalculation = summary.CalculateLineCoverage(result.Modules);
var branchPercentCalculation = summary.CalculateBranchCoverage(result.Modules);
var methodPercentCalculation = summary.CalculateMethodCoverage(result.Modules);
var totalLinePercent = linePercentCalculation.Percent;
var totalBranchPercent = branchPercentCalculation.Percent;
var totalMethodPercent = methodPercentCalculation.Percent;
var averageLinePercent = linePercentCalculation.AverageModulePercent;
var averageBranchPercent = branchPercentCalculation.AverageModulePercent;
var averageMethodPercent = methodPercentCalculation.AverageModulePercent;
foreach (var module in result.Modules)
{
var linePercent = summary.CalculateLineCoverage(module.Value).Percent;
var branchPercent = summary.CalculateBranchCoverage(module.Value).Percent;
var methodPercent = summary.CalculateMethodCoverage(module.Value).Percent;
coverageTable.AddRow(Path.GetFileNameWithoutExtension(module.Key), $"{linePercent}%", $"{branchPercent}%", $"{methodPercent}%");
}
Console.WriteLine();
Console.WriteLine(coverageTable.ToStringAlternative());
coverageTable.Columns.Clear();
coverageTable.Rows.Clear();
coverageTable.AddColumn(new[] { "", "Line", "Branch", "Method" });
coverageTable.AddRow("Total", $"{totalLinePercent}%", $"{totalBranchPercent}%", $"{totalMethodPercent}%");
coverageTable.AddRow("Average", $"{averageLinePercent}%", $"{averageBranchPercent}%", $"{averageMethodPercent}%");
Console.WriteLine(coverageTable.ToStringAlternative());
thresholdTypeFlags = result.GetThresholdTypesBelowThreshold(summary, _threshold, thresholdTypeFlags, thresholdStat);
if (thresholdTypeFlags != ThresholdTypeFlags.None)
{
var exceptionMessageBuilder = new StringBuilder();
if ((thresholdTypeFlags & ThresholdTypeFlags.Line) != ThresholdTypeFlags.None)
{
exceptionMessageBuilder.AppendLine($"The {thresholdStat.ToString().ToLower()} line coverage is below the specified {_threshold}");
}
if ((thresholdTypeFlags & ThresholdTypeFlags.Branch) != ThresholdTypeFlags.None)
{
exceptionMessageBuilder.AppendLine($"The {thresholdStat.ToString().ToLower()} branch coverage is below the specified {_threshold}");
}
if ((thresholdTypeFlags & ThresholdTypeFlags.Method) != ThresholdTypeFlags.None)
{
exceptionMessageBuilder.AppendLine($"The {thresholdStat.ToString().ToLower()} method coverage is below the specified {_threshold}");
}
throw new Exception(exceptionMessageBuilder.ToString());
}
}
catch (Exception ex)
{
_logger.LogError(ex);
return(false);
}
return(true);
}
public static void Main(string[] args)
{
{
#region Snippet_1a
IFileSystem fs = new FileSystem(@"C:\Temp\");
#endregion Snippet_1a
}
{
#region Snippet_1b
IFileSystem fs = new FileSystem("");
#endregion Snippet_1b
}
{
IFileSystem fs = new FileSystem("");
#region Snippet_2a
IDirectoryContent contents = fs.Browse("C:/Windows/");
#endregion Snippet_2a
#region Snippet_2d
foreach (IEntry entry in fs.Browse("C:/Windows/"))
{
Console.WriteLine(entry.Path);
}
#endregion Snippet_2d
#region Snippet_2e
foreach (var entry in fs.Browse("C:/Windows/").AssertExists())
{
Console.WriteLine(entry.Path);
}
#endregion Snippet_2e
{
#region Snippet_2f
IEntry e = FileSystem.OS.GetEntry("C:/Windows/win.ini");
Console.WriteLine(e.Path);
#endregion Snippet_2f
}
{
#region Snippet_2g
IEntry e = FileSystem.OS.GetEntry("C:/Windows/win.ini").AssertExists();
#endregion Snippet_2g
}
#region Snippet_3a
using (Stream s = fs.Open("file.txt", FileMode.Open, FileAccess.Read, FileShare.Read))
{
Console.WriteLine(s.Length);
}
#endregion Snippet_3a
#region Snippet_3b
using (Stream s = fs.Open("somefile.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite))
{
s.WriteByte(32);
}
#endregion Snippet_3b
#region Snippet_5
fs.CreateDirectory("dir/");
#endregion Snippet_5
#region Snippet_6
fs.Delete("dir/", recurse: true);
#endregion Snippet_6
#region Snippet_7
fs.CreateDirectory("dir/");
fs.Move("dir/", "new-name/");
#endregion Snippet_7
fs.Delete("new-name/");
}
{
IFileSystem fs = FileSystem.Temp;
if (fs.Exists("myfile"))
{
fs.SetFileAttribute("myfile", FileAttributes.Normal);
fs.Delete("myfile");
}
fs.CreateFile("myfile", new byte[] { 1 });
#region Snippet_7f
fs.SetFileAttribute("myfile", FileAttributes.ReadOnly);
#endregion Snippet_7f
fs.SetFileAttribute("myfile", FileAttributes.Normal);
fs.Delete("myfile");
}
{
#region Snippet_7x1
FileSystem.OS.GetEntry("C:/Windows/win.ini");
#endregion Snippet_7x1
}
{
#region Snippet_8a
IFileSystem fs = FileSystem.OS;
#endregion Snippet_8a
}
{
#region Snippet_8b
foreach (var line in FileSystem.OS.VisitTree(depth: 2))
{
Console.WriteLine(line);
}
#endregion Snippet_8b
}
{
#region Snippet_8b2
FileSystem.OS.PrintTo(Console.Out, depth: 2, format: PrintTree.Format.DefaultPath);
#endregion Snippet_8b2
}
{
#region Snippet_8c
FileSystem.OS.PrintTo(Console.Out, depth: 3, format: PrintTree.Format.DefaultPath);
#endregion Snippet_8c
}
{
#region Snippet_8d
FileSystem.Application.PrintTo(Console.Out);
#endregion Snippet_8d
}
{
#region Snippet_8e
FileSystem.Temp.PrintTo(Console.Out, depth: 1);
#endregion Snippet_8e
}
{
// <Snippet_8f>
foreach (var line in FileSystem.Temp.VisitTree(depth:2))
{
Console.WriteLine(line.Entry.PhysicalPath());
}
// </Snippet_8f>
}
{
// <Snippet_8g>
FileSystem.Temp.PrintTo(
output: Console.Out,
depth: 2,
format: PrintTree.Format.Default | PrintTree.Format.PhysicalPath);
// </Snippet_8g>
}
{
// <Snippet_9a>
IObserver <IEvent> observer = new Observer();
IFileSystemObserver handle = FileSystem.OS.Observe("C:/**", observer);
// </Snippet_9a>
}
{
// <Snippet_9b>
using (var handle = FileSystem.Temp.Observe("*.dat", new PrintObserver()))
{
FileSystem.Temp.CreateFile("file.dat", new byte[] { 32, 32, 32, 32 });
FileSystem.Temp.Delete("file.dat");
Thread.Sleep(1000);
}
// </Snippet_9b>
}
{
// <Snippet_9c>
IObserver <IEvent> observer = new Observer();
FileSystem.OS.Observe("C:/**", observer, eventDispatcher: EventDispatcher.Instance);
// </Snippet_9c>
}
{
// <Snippet_9d>
IObserver <IEvent> observer = new Observer();
FileSystem.OS.Observe("C:/**", observer, eventDispatcher: EventTaskDispatcher.Instance);
// </Snippet_9d>
}
{
#region Snippet_10a
// Init
object obj = new ReaderWriterLockSlim();
IFileSystemDisposable fs = new FileSystem("").AddDisposable(obj);
// ... do work ...
// Dispose both
fs.Dispose();
#endregion Snippet_10a
}
{
#region Snippet_10b
IFileSystemDisposable fs = new FileSystem("")
.AddDisposeAction(f => Console.WriteLine("Disposed"));
#endregion Snippet_10b
}
{
#region Snippet_10c
FileSystem fs = new FileSystem("");
fs.Browse("");
// Postpone dispose
IDisposable belateDisposeHandle = fs.BelateDispose();
// Start concurrent work
Task.Run(() =>
{
// Do work
Thread.Sleep(1000);
fs.GetEntry("");
// Release belate handle. Disposes here or below, depending which thread runs last.
belateDisposeHandle.Dispose();
});
// Start dispose, but postpone it until belatehandle is disposed in another thread.
fs.Dispose();
#endregion Snippet_10c
}
}
public void Update()
{
Logger.WriteInfo("Updating assembly info files");
var assemblyInfoFiles = GetAssemblyInfoFiles(workingDirectory, assemblyInfoFileNames, fileSystem, ensureAssemblyInfo).ToList();
Logger.WriteInfo($"Found {assemblyInfoFiles.Count} files");
var assemblyVersion = variables.AssemblySemVer;
var assemblyVersionRegex = new Regex(@"AssemblyVersion(Attribute)?\s*\(.*\)\s*");
var assemblyVersionString = !string.IsNullOrWhiteSpace(assemblyVersion) ? $"AssemblyVersion(\"{assemblyVersion}\")" : null;
var assemblyInfoVersion = variables.InformationalVersion;
var assemblyInfoVersionRegex = new Regex(@"AssemblyInformationalVersion(Attribute)?\s*\(.*\)\s*");
var assemblyInfoVersionString = $"AssemblyInformationalVersion(\"{assemblyInfoVersion}\")";
var assemblyFileVersion = variables.AssemblySemFileVer;
var assemblyFileVersionRegex = new Regex(@"AssemblyFileVersion(Attribute)?\s*\(.*\)\s*");
var assemblyFileVersionString = !string.IsNullOrWhiteSpace(assemblyFileVersion) ? $"AssemblyFileVersion(\"{assemblyFileVersion}\")" : null;
foreach (var assemblyInfoFile in assemblyInfoFiles)
{
var backupAssemblyInfo = assemblyInfoFile.FullName + ".bak";
var localAssemblyInfo = assemblyInfoFile.FullName;
fileSystem.Copy(assemblyInfoFile.FullName, backupAssemblyInfo, true);
restoreBackupTasks.Add(() =>
{
if (fileSystem.Exists(localAssemblyInfo))
{
fileSystem.Delete(localAssemblyInfo);
}
fileSystem.Move(backupAssemblyInfo, localAssemblyInfo);
});
cleanupBackupTasks.Add(() => fileSystem.Delete(backupAssemblyInfo));
var originalFileContents = fileSystem.ReadAllText(assemblyInfoFile.FullName);
var fileContents = originalFileContents;
var appendedAttributes = false;
if (!string.IsNullOrWhiteSpace(assemblyVersion))
{
fileContents = ReplaceOrInsertAfterLastAssemblyAttributeOrAppend(assemblyVersionRegex, fileContents, assemblyVersionString, assemblyInfoFile.Extension, ref appendedAttributes);
}
if (!string.IsNullOrWhiteSpace(assemblyFileVersion))
{
fileContents = ReplaceOrInsertAfterLastAssemblyAttributeOrAppend(assemblyFileVersionRegex, fileContents, assemblyFileVersionString, assemblyInfoFile.Extension, ref appendedAttributes);
}
fileContents = ReplaceOrInsertAfterLastAssemblyAttributeOrAppend(assemblyInfoVersionRegex, fileContents, assemblyInfoVersionString, assemblyInfoFile.Extension, ref appendedAttributes);
if (appendedAttributes)
{
// If we appended any attributes, put a new line after them
fileContents += Environment.NewLine;
}
if (originalFileContents != fileContents)
{
fileSystem.WriteAllText(assemblyInfoFile.FullName, fileContents);
}
}
}
public override OperationResult Perform()
{
var result = OperationResult.Success;
if (Context.Next.Settings.SessionMode == SessionMode.Server)
{
logger.Info("Initializing server...");
StatusChanged?.Invoke(TextKey.OperationStatus_InitializeServer);
server.Initialize(Context.Next.Settings.Server);
var(abort, fallback, success) = TryPerformWithFallback(() => server.Connect());
if (success)
{
(abort, fallback, success) = TryPerformWithFallback(() => server.GetAvailableExams(), out var exams);
if (success)
{
success = TrySelectExam(exams, out var exam);
if (success)
{
(abort, fallback, success) = TryPerformWithFallback(() => server.GetConfigurationFor(exam), out var uri);
if (success)
{
var info = server.GetConnectionInfo();
var status = TryLoadSettings(uri, UriSource.Server, out _, out var settings);
fileSystem.Delete(uri.LocalPath);
if (status == LoadStatus.Success)
{
var serverSettings = Context.Next.Settings.Server;
Context.Next.AppConfig.ServerApi = info.Api;
Context.Next.AppConfig.ServerConnectionToken = info.ConnectionToken;
Context.Next.AppConfig.ServerExamId = exam.Id;
Context.Next.AppConfig.ServerOauth2Token = info.Oauth2Token;
Context.Next.Settings = settings;
Context.Next.Settings.Browser.StartUrl = exam.Url;
Context.Next.Settings.Server = serverSettings;
Context.Next.Settings.SessionMode = SessionMode.Server;
result = OperationResult.Success;
}
else
{
result = OperationResult.Failed;
}
}
}
else
{
logger.Info("The user aborted the exam selection.");
result = OperationResult.Aborted;
}
}
}
if (abort)
{
result = OperationResult.Aborted;
}
if (fallback)
{
Context.Next.Settings.SessionMode = SessionMode.Normal;
result = OperationResult.Success;
}
}
return(result);
}
public async Task Delete(string orgSlug, string dsSlug, string path)
{
var ds = await _utils.GetDataset(orgSlug, dsSlug);
_logger.LogInformation("In Delete('{OrgSlug}/{DsSlug}')", orgSlug, dsSlug);
if (!await _authManager.IsOwnerOrAdmin(ds))
{
throw new UnauthorizedException("The current user is not allowed to edit dataset");
}
if (IsReservedPath(path))
{
throw new InvalidOperationException($"'{path}' is a reserved path");
}
var ddb = _ddbManager.Get(orgSlug, ds.InternalRef);
if (!await ddb.EntryExistsAsync(path))
{
throw new BadRequestException($"Path '{path}' not found in dataset");
}
var objs = (await ddb.SearchAsync(path, true)).ToArray();
foreach (var obj in objs.Where(item => item.Type != EntryType.Directory))
{
_logger.LogInformation("Deleting '{ObjPath}'", obj.Path);
var objLocalPath = ddb.GetLocalPath(obj.Path);
try
{
if (!_fs.Exists(objLocalPath))
{
throw new InvalidOperationException(
$"Cannot find local file '{objLocalPath}' for object '{obj.Path}'");
}
_fs.Delete(objLocalPath);
await _cacheManager.Clear(MagicStrings.ThumbnailCacheSeed, obj.Hash);
await _cacheManager.Clear(MagicStrings.TileCacheSeed, obj.Hash);
}
catch (Exception ex)
{
// We basically ignore this error, it's not critical. We should perform a cleanup later
_logger.LogWarning("Cannot delete local file '{ObjPath}': {Reason}", objLocalPath, ex.Message);
}
}
try
{
_logger.LogInformation("Removing from DDB");
await ddb.RemoveAsync(path);
}
catch (Exception ex)
{
_logger.LogWarning("Cannot delete '{ObjPath}' from DDB: {Reason}", path, ex.Message);
throw new InvalidOperationException("Cannot delete object from database", ex);
}
_logger.LogInformation("Deletion complete");
}
