private void MoveToTrash(string filePath, CancellationToken token)
{
ShouldExecute((t) =>
{
Ensure(_trashFolder, t);
//new ZlpFileInfo(filePath).Attributes = FileAttributes.Normal;
if (_fs.FileExist(filePath, t))
{
var newPath = GetTmpFile(_trashFolder, t);
_fs.SetAttributes(filePath, FileAttributes.Normal, t);
_fs.Move(filePath, newPath, t);
}
}, token);
}
public AssemblyInfoUpdate(IFileSystem fileSystem, GitHubFlowVersionContext context)
{
if (!context.Arguments.UpdateAssemblyInfo)
{
return;
}
var assemblyInfoFiles = fileSystem.GetFiles(context.RepositoryRoot, "AssemblyInfo.cs",
SearchOption.AllDirectories);
foreach (var assemblyInfoFile in assemblyInfoFiles)
{
var destFileName = assemblyInfoFile + ".bak";
var sourceFileName = assemblyInfoFile;
fileSystem.Copy(assemblyInfoFile, destFileName, true);
_restoreBackupTasks.Add(() => fileSystem.Move(destFileName, sourceFileName, true));
_cleanupBackupTasks.Add(() => fileSystem.DeleteFile(destFileName));
var assemblyVersion = context.Variables[VariableProvider.AssemblyVersion];
var assemblyInfoVersion = context.Variables[VariableProvider.AssemblyInformationalVersion];
var assemblyFileVersion = context.Variables[VariableProvider.AssemblyFileVersion];
var fileContents = fileSystem.ReadAllText(sourceFileName)
.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(sourceFileName, fileContents);
}
}
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 async Task FileRenamed()
{
_fs.Create(_dir);
_fs.Create(_file).Dispose();
var tmpFile = _file.Rename(Guid.NewGuid() + ".txt");
var renamed = _fs.Watch(_file).Take(1).ToTask();
_fs.Move(_file, tmpFile);
Assert.AreEqual(Unit.Default, await renamed.TimeoutAfter(TimeSpan.FromSeconds(2)), "Did not get file moved event!");
var renamedBack = _fs.Watch(_file).Take(1).ToTask();
_fs.Move(tmpFile, _file);
Assert.AreEqual(Unit.Default, await renamedBack.TimeoutAfter(TimeSpan.FromSeconds(2)), "Did not get file moved event!");
}
public void Restore()
{
if (_fileSystem.Exists(_backup))
{
_fileSystem.Delete(_original);
_fileSystem.Move(_backup, _original);
}
}
static void CreateNew(this IFileSystem fileSystem, AbsoluteDirectoryPath path)
{
var tempDirectory = path.ContainingDirectory / DirectoryName.GetRandomDirectoryName();
Directory.CreateDirectory(tempDirectory.NativePath);
fileSystem.Create(path.ContainingDirectory);
fileSystem.Move(tempDirectory, 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).ToList();
Logger.WriteInfo(string.Format("Found {0} files", assemblyInfoFiles.Count));
var assemblyVersion = variables.AssemblySemVer;
var assemblyVersionRegex = new Regex(@"AssemblyVersion(Attribute)?\s*\(\s*""[^""]*""\s*\)");
var assemblyVersionString = !string.IsNullOrWhiteSpace(assemblyVersion) ? string.Format("AssemblyVersion(\"{0}\")", assemblyVersion) : null;
var assemblyInfoVersion = variables.InformationalVersion;
var assemblyInfoVersionRegex = new Regex(@"AssemblyInformationalVersion(Attribute)?\s*\(\s*""[^""]*""\s*\)");
var assemblyInfoVersionString = string.Format("AssemblyInformationalVersion(\"{0}\")", assemblyInfoVersion);
var assemblyFileVersion = variables.MajorMinorPatch + ".0";
var assemblyFileVersionRegex = new Regex(@"AssemblyFileVersion(Attribute)?\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);
}
}
private void CopyFiles(IEnumerable <string> filesForRule, string targetDirectory)
{
foreach (var sourceFile in filesForRule)
{
string fileName = Path.GetFileName(sourceFile);
string target = Path.Combine(targetDirectory, fileName);
_fileSystem.Move(sourceFile, target);
}
}
/// <summary>
/// 移动文件
/// </summary>
/// <param name="_sourceFilePath"></param>
/// <param name="_targetFilePath"></param>
public void MoveFile(string _sourceFilePath, string _targetFilePath)
{
if (false == CheckNullPath(_sourceFilePath) || false == CheckNullPath(_targetFilePath))
{
return;
}
fileSystem.Move(_sourceFilePath, _targetFilePath);
}
public void MakeFilename(Mp3File file)
{
var newPath = Path.GetDirectoryName(file.path) + "\\" + file.Artist + " - " + file.Title + Path.GetExtension(file.path);
if (!_fileSystem.Exists(newPath))
{
_fileSystem.Move(file.path, newPath);
file.path = newPath;
}
}
public static BackedUpFile BackupAndDeleteFile(this IFileSystem fileSystem, AbsoluteFilePath path)
{
var backup = fileSystem.MakeUnique(path.AddExtension("bak"));
if (fileSystem.Exists(path))
{
fileSystem.Move(path, backup);
}
return(new BackedUpFile(fileSystem, path, backup));
}
private void MovePackageFile(string externalPackageUri, string tempPath, Package package, string fileExtension)
{
if (string.IsNullOrWhiteSpace(externalPackageUri))
{
string fullPackagePath = Path.Combine(_configSettings.PhysicalSitePath, _configSettings.RelativePackageDirectory);
string packagePath = string.Format(@"{0}\{1}\{1}-{2}.{3}", fullPackagePath, package.Id, package.Version, fileExtension);
_fileSystem.Move(tempPath, packagePath, true);
}
else
{
package.ExternalPackageUrl = externalPackageUri;
}
}
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);
}
}
/// <inheritdoc cref="IDownloader.Install(IPackage, string)" />
/// <param name="output">Whether is display the output message.</param>
public virtual void Install(IPackage package, string cwd, bool output)
{
if (output)
{
io.WriteError($" - Installing <info>{package.GetName()}</info> (<comment>{package.GetVersionPrettyFull()}</comment>)");
}
var uri = new Uri(package.GetDistUri());
var downloadedFilePath = GetDownloadedFilePath(package, cwd);
var installPath = Path.Combine(cwd, Path.GetFileName(uri.AbsolutePath));
fileSystem.Delete(cwd);
fileSystem.Move(downloadedFilePath, installPath);
}
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);
Console.WriteLine("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);
}
}
public AssemblyInfoFileUpdate(Arguments args, string workingDirectory, Dictionary <string, string> 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));
string assemblyVersion;
if (!string.IsNullOrWhiteSpace(args.AssemblyVersionFormat))
{
assemblyVersion = variables[args.AssemblyVersionFormat];
}
else
{
assemblyVersion = string.Format("{0}.{1}.0.0", variables[VariableProvider.Major], variables[VariableProvider.Minor]);
}
var assemblyInfoVersion = variables[VariableProvider.InformationalVersion];
var assemblyFileVersion = variables[VariableProvider.AssemblySemVer];
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);
}
}
internal static SMBCommand GetRenameResponse(SMBHeader header, RenameRequest request, FileSystemShare share, StateObject state)
{
string userName = state.GetConnectedUserName(header.UID);
if (!share.HasWriteAccess(userName))
{
header.Status = NTStatus.STATUS_ACCESS_DENIED;
return(new ErrorResponse(CommandName.SMB_COM_RENAME));
}
IFileSystem fileSystem = share.FileSystem;
FileSystemEntry sourceEntry = fileSystem.GetEntry(request.OldFileName);
if (sourceEntry == null)
{
header.Status = NTStatus.STATUS_NO_SUCH_FILE;
return(new ErrorResponse(CommandName.SMB_COM_RENAME));
}
// The file must not already exist unless we just want to upcase / downcase a filename letter
FileSystemEntry destinationEntry = fileSystem.GetEntry(request.NewFileName);
if (destinationEntry != null &&
!String.Equals(request.OldFileName, request.NewFileName, StringComparison.InvariantCultureIgnoreCase))
{
// The new file already exists.
header.Status = NTStatus.STATUS_OBJECT_NAME_COLLISION;
return(new ErrorResponse(CommandName.SMB_COM_RENAME));
}
try
{
fileSystem.Move(request.OldFileName, request.NewFileName);
return(new RenameResponse());
}
catch (IOException)
{
header.Status = NTStatus.STATUS_SHARING_VIOLATION;
return(new ErrorResponse(CommandName.SMB_COM_RENAME));
}
catch (UnauthorizedAccessException)
{
header.Status = NTStatus.STATUS_ACCESS_DENIED;
return(new ErrorResponse(CommandName.SMB_COM_RENAME));
}
}
public async Task TransferFile(string source, string destinationFile, Action <ProgressUpdatedEvent> progressCallback)
{
using (var resp = await _httpClient.GetAsync(new Uri(source), Timeout.InfiniteTimeSpan, HttpCompletionOption.ResponseHeadersRead))
{
var contentType = resp.Content.Headers.ContentType;
if (contentType != null && contentType.MediaType.Contains("text"))
{
throw new InvalidDownloadUrlException(source, $"[ContentType={contentType.MediaType}]");
}
if (_fileSystem.FileExists(destinationFile))
{
_fileSystem.DeleteFile(destinationFile);
}
var maxValue = resp.Content.Headers.ContentLength ?? 0;
var progress = new ProgressUpdatedEvent
{
MaxValue = maxValue
};
using (var httpStream = await resp.Content.ReadAsStreamAsync())
{
var tempFile = $"{destinationFile}.APPGET_DOWNLOAD";
using (var tempFileStream = _fileSystem.Open(tempFile, FileMode.Create, FileAccess.ReadWrite))
{
var buffer = new byte[BUFFER_LENGTH];
int len;
while ((len = httpStream.Read(buffer, 0, BUFFER_LENGTH)) > 0)
{
tempFileStream.Write(buffer, 0, len);
progress.Value += len;
progressCallback(progress);
}
}
progress.IsCompleted = true;
progressCallback(progress);
_fileSystem.Move(tempFile, destinationFile);
}
}
}
public void Rename(string path, Dictionary <string, string> state)
{
var newPath = path;
foreach (var item in state)
{
newPath = newPath.Replace(TokenDelimiter + item.Key + TokenDelimiter, item.Value);
}
if (path != newPath)
{
if ((!fileSystem.DirectoryExists(newPath)) && (fileSystem.IsDirectory(path)))
{
fileSystem.CreateFolder(newPath);
}
fileSystem.Move(path, newPath);
}
}
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);
}
}
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);
}
}
/// <summary>
/// Update the library file.
/// </summary>
protected virtual void UpdateLibrary(IPackage initial, IPackage target)
{
var initialPath = GetInstallPath(initial);
var targetPath = GetInstallPath(target);
if (initialPath != targetPath)
{
// if the target and initial dirs intersect, we force a
// remove + install to avoid the rename wiping the target
// dir as part of the initial dir cleanup.
if (initialPath.StartsWith(targetPath, StringComparison.Ordinal) ||
targetPath.StartsWith(initialPath, StringComparison.Ordinal))
{
RemoveLibrary(initial);
InstallLibaray(target);
return;
}
fileSystem.Move(initialPath, targetPath);
}
downloadManager.Update(initial, target, targetPath);
}
public void Update()
{
Logger.WriteInfo("Updating assembly info files");
var headerFiles = GetHeaderFiles(workingDirectory, headerFileNames, fileSystem).ToList();
Logger.WriteInfo($"Found {headerFiles.Count} files");
var assemblyVersion = variables.AssemblySemVer;
var assemblyVersionRegex = new Regex(@"\s*#define VERSION_FULL\s*(.*)");
var assemblyVersionString = !string.IsNullOrWhiteSpace(assemblyVersion) ? $"\r\n#define VERSION_FULL {assemblyVersion.Replace('.', ',')}\r\n" : "0,0,0,0";
var assemblyInfoVersion = variables.InformationalVersion;
var assemblyInfoVersionRegex = new Regex(@"\s*#define VERSION_STRING\s*(.*)");
var assemblyInfoVersionString = $"\r\n#define VERSION_STRING VERSION_XSTR({assemblyInfoVersion}) VERSION_BLANK \"\\0\"\r\n";
foreach (var headerFile in headerFiles)
{
var backupAssemblyInfo = headerFile.FullName + ".bak";
var localAssemblyInfo = headerFile.FullName;
fileSystem.Copy(headerFile.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(headerFile.FullName);
var fileContents = originalFileContents;
var appendedAttributes = false;
if (!string.IsNullOrWhiteSpace(assemblyVersion))
{
fileContents = ReplaceOrAppend(assemblyVersionRegex, fileContents, assemblyVersionString, headerFile.Extension, ref appendedAttributes);
}
//if (!string.IsNullOrWhiteSpace(headerFile))
//{
// fileContents = ReplaceOrAppend(assemblyFileVersionRegex, fileContents, assemblyFileVersionString, assemblyInfoFile.Extension, ref appendedAttributes);
//}
fileContents = ReplaceOrAppend(assemblyInfoVersionRegex, fileContents, assemblyInfoVersionString, headerFile.Extension, ref appendedAttributes);
if (appendedAttributes)
{
// If we appended any attributes, put a new line after them
fileContents += Environment.NewLine;
}
if (originalFileContents != fileContents)
{
fileSystem.WriteAllText(headerFile.FullName, fileContents);
}
}
}
public async Task Move(string orgSlug, string dsSlug, string source, string dest)
{
var ds = await _utils.GetDataset(orgSlug, dsSlug);
_logger.LogInformation("In Move('{OrgSlug}/{DsSlug}')", orgSlug, dsSlug);
if (!await _authManager.IsOwnerOrAdmin(ds))
{
throw new UnauthorizedException("The current user is not allowed to edit dataset");
}
var ddb = _ddbManager.Get(orgSlug, ds.InternalRef);
var sourceEntry = await ddb.GetEntryAsync(source);
// Checking if source exists
if (sourceEntry == null)
{
throw new InvalidOperationException("Cannot find source entry: '" + source + "'");
}
if (IsReservedPath(dest))
{
throw new InvalidOperationException($"'{dest}' is a reserved path");
}
// Short circuit!
if ((dest + "/").StartsWith(source + "/"))
{
throw new InvalidOperationException("Cannot move a path onto itself or one of its descendants");
}
var destEntry = await ddb.GetEntryAsync(dest);
if (destEntry != null)
{
if (sourceEntry.Type == EntryType.Directory && destEntry.Type != EntryType.Directory)
{
throw new ArgumentException("Cannot move a folder on a file");
}
if (sourceEntry.Type != EntryType.Directory && destEntry.Type == EntryType.Directory)
{
throw new ArgumentException("Cannot move a file on a folder");
}
}
switch (sourceEntry.Type)
{
case EntryType.Directory:
{
var sourceLocalFilePath = ddb.GetLocalPath(source);
var destLocalFilePath = ddb.GetLocalPath(dest);
_logger.LogInformation("Moving directory '{Source}' to '{Dest}'", source, dest);
CommonUtils.EnsureSafePath(destLocalFilePath);
_fs.FolderMove(sourceLocalFilePath, destLocalFilePath);
_logger.LogInformation("FS move OK");
break;
}
case EntryType.DroneDB:
throw new InvalidOperationException("Cannot move a DroneDB file");
default:
{
var sourceLocalFilePath = ddb.GetLocalPath(source);
var destLocalFilePath = ddb.GetLocalPath(dest);
_logger.LogInformation("Moving file '{Source}' to '{Dest}'", source, dest);
CommonUtils.EnsureSafePath(destLocalFilePath);
_fs.Move(sourceLocalFilePath, destLocalFilePath);
_logger.LogInformation("FS move OK");
break;
}
}
_logger.LogInformation("Performing ddb move");
await ddb.MoveAsync(source, dest);
if (!await ddb.EntryExistsAsync(dest))
{
throw new InvalidOperationException(
$"Cannot find destination '{dest}' after move, something wrong with ddb");
}
_logger.LogInformation("Move OK");
}
/// <inheritdoc />
public override void Install(IPackage package, string cwd, bool output)
{
if (output)
{
io.WriteError($" - Installing <info>{package.GetName()}</info> (<comment>{package.GetVersionPrettyFull()}</comment>): Extracting archive");
}
else
{
io.WriteError("Extracting archive", false);
}
fileSystem.Delete(cwd);
var temporaryDir = Path.Combine(
GetTempDirectory(),
"extract",
Security.Md5(Guid.NewGuid().ToString()).Substring(0, 7));
var downloadedFilePath = GetDownloadedFilePath(package, cwd);
try
{
FileSystemLocal.EnsureDirectory(temporaryDir);
try
{
Extract(package, downloadedFilePath, temporaryDir);
}
catch
{
// remove cache if the file was corrupted.
ClearLastCacheWrite(package);
throw;
}
// Expand a single top-level directory for a
// better experience.
string ExtractSingleDirAtTopLevel(string path)
{
var contents = fileSystem.GetContents(path);
var files = contents.GetFiles();
var dirs = contents.GetDirectories();
files = Arr.Filter(files, (file) => !file.EndsWith(".DS_Store", StringComparison.Ordinal));
if ((dirs.Length + files.Length) != 1 || files.Length == 1)
{
return(path);
}
return(ExtractSingleDirAtTopLevel(dirs[0]));
}
fileSystem.Move(ExtractSingleDirAtTopLevel(temporaryDir), cwd);
}
catch
{
fileSystem.Delete(cwd);
throw;
}
finally
{
fileSystem.Delete(temporaryDir);
fileSystem.Delete(downloadedFilePath);
}
}
public void Move()
{
// Arrange
PermutationSetup permutation = new PermutationSetup();
permutation.Add(blockpool_1TB);
permutation.Add(blockpool_Pseudo);
permutation.Add(case_ms);
//permutation.Add(decor_fs);
permutation.Add(case_decor_ms);
permutation.Add(case_vfs_ms);
permutation.Add(case_vfs_2ms);
//permutation.Add(vfs_fsms);
permutation.Add(init);
// Act & Assert
foreach (Scenario scenario in permutation.Scenarios)
{
using (Run run = scenario.Run().Initialize())
{
IFileSystem fs = run.Parameters["Class"] as IFileSystem;
fs.Observe("**", observer = new Observer());
observer.events.Clear();
// Rename to same file
fs.Move("/tmp/helloworld.txt", "/tmp/../tmp/helloworld.txt");
Assert.IsTrue(observer.events.Count == 0);
// Move to non-existing dir
try { fs.Move("/tmp/helloworld.txt", "/nonexisting/helloworld.txt"); Assert.Fail(); } catch (IOException) { }
// Move non-existing file
try { fs.Move("/tmp/nonexisting.txt", "/tmp/somefile.txt"); Assert.Fail(); } catch (IOException) { }
// Move over to directory
try { fs.Move("/tmp/helloworld.txt", "c:"); Assert.Fail(); } catch (IOException) { }
// Move a file
Assert.IsFalse(fs.Browse("c:").Any(e => e.Path == "c:/helloworld.txt"));
Assert.IsTrue(fs.Browse("/tmp").Any(e => e.Path == "/tmp/helloworld.txt"));
fs.Move("/tmp/helloworld.txt", "c:/helloworld.txt");
Assert.IsTrue(fs.Browse("c:").Any(e => e.Path == "c:/helloworld.txt"));
Assert.IsFalse(fs.Browse("/tmp").Any(e => e.Path == "/tmp/helloworld.txt"));
Assert.IsTrue(observer.Last is IRenameEvent);
Assert.IsTrue(DateTimeOffset.UtcNow - observer.Last.EventTime < TimeSpan.FromSeconds(2));
Assert.AreEqual(fs, observer.Last.Observer.FileSystem);
// Move whole tree
Assert.IsFalse(fs.Browse("c:").Any(e => e.Path == "c:/tmp/"));
Assert.IsTrue(fs.Browse("/").Any(e => e.Path == "/tmp/"));
fs.Move("/tmp/", "c:/tmp/");
Assert.IsTrue(fs.Browse("c:").Any(e => e.Path == "c:/tmp/"));
Assert.IsFalse(fs.Browse("/").Any(e => e.Path == "/tmp/"));
Assert.IsNull(fs.GetEntry("/tmp/"));
Assert.IsTrue(fs.Browse("c:/tmp/").Count >= 3);
Assert.IsTrue(observer.Last is IRenameEvent);
Assert.IsTrue(DateTimeOffset.UtcNow - observer.Last.EventTime < TimeSpan.FromSeconds(2));
Assert.AreEqual(fs, observer.Last.Observer.FileSystem);
Assert.IsTrue(observer.Last.Path.StartsWith("/tmp/"));
Assert.IsTrue(observer.Last.NewPath().StartsWith("c:/tmp/"));
fs.Observe("**", observer = new Observer());
observer.events.Clear();
}
}
}
public static void Move(this IFileSystem fileSystem, IAbsolutePath source, IAbsolutePath destination)
{
source.Do(
(AbsoluteFilePath file) => fileSystem.Move(file, (AbsoluteFilePath)destination),
(AbsoluteDirectoryPath dir) => fileSystem.Move(dir, (AbsoluteDirectoryPath)destination));
}
/// <summary>
/// Executes the changes recorded for the associated file in chronological order.
/// </summary>
public override void ExecuteChanges(IFileSystem fileSystem)
{
string newPath;
if (fileSystem.IsDirectory(AssociatedPath) && _newName != null)
{
string tmp = AssociatedPath.Substring(0, AssociatedPath.Length - FileSystem.PathSeparator.Length);
newPath = "\\" + tmp.Substring(0, tmp.LastIndexOf("\\")) + "\\" + _newName;
newPath = newPath.Replace("\\\\", "\\");
fileSystem.Move(AssociatedPath, newPath);
return;
}
String[] fileContent = fileSystem.ReadAllLines(AssociatedPath);
IList<String> updatedFileContent = new List<String>();
if (_newName != null)
{
newPath = AssociatedPath.Substring(0, AssociatedPath.LastIndexOf("\\")) + "\\" + _newName;
newPath = newPath.Replace("\\\\", "\\");
fileSystem.Move(AssociatedPath, newPath);
}
else
{
newPath = AssociatedPath;
}
if (_modificationList.Count > 0)
{
int contentPointer = 0;
foreach (AbstractModification modification in _modificationList)
{
for (; contentPointer < modification.LineNumber && contentPointer < fileContent.Length; contentPointer++)
{
updatedFileContent.Add(fileContent[contentPointer]);
}
if (modification is DeletionModification)
{
if (modification.LineNumber != contentPointer)
Debug.WriteLine("modification.LineNumber != contentPointer => " + modification.LineNumber + ", " +
contentPointer);
contentPointer++;
}
else if (modification is InsertionModification)
{
InsertionModification insertion = modification as InsertionModification;
updatedFileContent.Add(insertion.Line);
}
}
fileContent = updatedFileContent.ToArray();
}
fileSystem.WriteAllLines(newPath, fileContent);
}
public void Execute(VersionVariables variables, AssemblyInfoContext context)
{
var assemblyInfoFiles = GetAssemblyInfoFiles(context).ToList();
log.Info("Updating assembly info files");
log.Info($"Found {assemblyInfoFiles.Count} files");
var assemblyVersion = variables.AssemblySemVer;
var assemblyVersionString = !string.IsNullOrWhiteSpace(assemblyVersion) ? $"AssemblyVersion(\"{assemblyVersion}\")" : null;
var assemblyInfoVersion = variables.InformationalVersion;
var assemblyInfoVersionString = !string.IsNullOrWhiteSpace(assemblyInfoVersion) ? $"AssemblyInformationalVersion(\"{assemblyInfoVersion}\")" : null;
var assemblyFileVersion = variables.AssemblySemFileVer;
var assemblyFileVersionString = !string.IsNullOrWhiteSpace(assemblyFileVersion) ? $"AssemblyFileVersion(\"{assemblyFileVersion}\")" : null;
foreach (var assemblyInfoFile in assemblyInfoFiles)
{
var localAssemblyInfo = assemblyInfoFile.FullName;
var backupAssemblyInfo = localAssemblyInfo + ".bak";
fileSystem.Copy(localAssemblyInfo, backupAssemblyInfo, true);
restoreBackupTasks.Add(() =>
{
if (fileSystem.Exists(localAssemblyInfo))
{
fileSystem.Delete(localAssemblyInfo);
}
fileSystem.Move(backupAssemblyInfo, localAssemblyInfo);
});
cleanupBackupTasks.Add(() => fileSystem.Delete(backupAssemblyInfo));
var originalFileContents = fileSystem.ReadAllText(localAssemblyInfo);
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);
}
if (!string.IsNullOrWhiteSpace(assemblyInfoVersion))
{
fileContents = ReplaceOrInsertAfterLastAssemblyAttributeOrAppend(assemblyInfoVersionRegex, fileContents, assemblyInfoVersionString, assemblyInfoFile.Extension, ref appendedAttributes);
}
if (appendedAttributes)
{
// If we appended any attributes, put a new line after them
fileContents += NewLine;
}
if (originalFileContents != fileContents)
{
fileSystem.WriteAllText(localAssemblyInfo, fileContents);
}
}
CommitChanges();
}
public void Act()
{
fileSystem.Move(oldPath, newPath);
notifyAct?.Invoke(oldPath, newPath);
}
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 void MoveTo(string path)
{
FileSystem.Move(FullName, path);
FullName = path;
}
public static Task Rename(this IFileSystem fileSystem, FileExplorerEntry entry, string newName)
{
var directory = Path.GetDirectoryName(entry.Path);
return(fileSystem.Move(entry, Path.Combine(directory, newName)));
}
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;
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;
}
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);
}
var outputXmlString = fileXml.ToString();
if (originalFileContents != outputXmlString)
{
fileSystem.WriteAllText(localProjectFile, outputXmlString);
}
}
CommitChanges();
}
