public static string GetPropertyValue(FilePath svnExecutableFilePath, AbsolutePath path, string propertyName, ILogger logger) { logger.LogDebug($"Getting value of SVN property {propertyName} for {path}..."); var arguments = $@"propget {propertyName} ""{path}"" --xml"; var outputCollector = SvnCommandServicesProvider.Run(svnExecutableFilePath, arguments); // Parse output. var svnOutput = outputCollector.GetOutputText(); var document = XDocument.Parse(svnOutput); var properties = document.Element("properties"); if (!properties.Elements().Any()) { throw new Exception($"SVN automation failure.\nReceived:\n{svnOutput}"); } var expectedPath = PathUtilities.EnsureNonWindowsDirectorySeparator(path.Value); // Path value is converted to a non-Windows path. var property = properties.Elements("target").Where(x => x.Attribute("path").Value == expectedPath).Single().Element("property"); if (property.Attribute("name").Value != propertyName) { throw new Exception($"SVN automation failure.\nReceived:\n{svnOutput}"); } var output = property.Value; logger.LogInformation($"Got value of SVN property {propertyName} for {path}."); return(output); }
public static int Update(FilePath svnExecutableFilePath, AbsolutePath path, ILogger logger) { var nonDirectoryIndicatedPath = PathUtilities.EnsurePathIsNotDirectoryIndicated(path.Value).AsAbsolutePath(); logger.LogDebug($"SVN updating {path}..."); // Use the specified path. var arguments = $@"update ""{nonDirectoryIndicatedPath}"""; // Use the non-directory indicated path. var outputCollector = SvnCommandServicesProvider.Run(svnExecutableFilePath, arguments); var lines = new List <string>(); using (var reader = outputCollector.GetOutputReader()) { while (!reader.ReadLineIsEnd(out var line)) { lines.Add(line); } } var lastLine = lines.Last(); var trimmedLastLine = lastLine.TrimEnd('.'); var tokens = trimmedLastLine.Split(' '); var revisionNumber = tokens[tokens.Length - 1]; var revision = Int32.Parse(revisionNumber); logger.LogInformation($"SVN updated {path}.\nRevision: {revision}"); return(revision); }
public static string[] ListProperties(FilePath svnExecutableFilePath, AbsolutePath path, ILogger logger) { logger.LogDebug($"Listing SVN properties of {path}..."); var arguments = $@"proplist ""{path}"" --xml"; var outputCollector = SvnCommandServicesProvider.Run(svnExecutableFilePath, arguments); var svnOutput = outputCollector.GetOutputText(); var document = XDocument.Parse(svnOutput); var properties = document.Element("properties"); if (!properties.Elements().Any()) { return(Array.Empty <string>()); } var expectedPath = path.Value; // This method does not convert paths to non-Windows. var target = properties.Elements("target").Where(x => x.Attribute("path").Value == expectedPath).Single(); var output = target.Elements("property").Attributes("name").Select(x => x.Value).ToArray(); logger.LogInformation($"Listed SVN properties of {path}."); return(output); }
public static void Delete(FilePath svnExecutableFilePath, AbsolutePath path, ILogger logger, bool force = false) { logger.LogDebug($"SVN deleting path {path}..."); var arguments = $@"delete ""{path}"""; if (force) { arguments = arguments.Append(" --force"); } var outputCollector = SvnCommandServicesProvider.Run(svnExecutableFilePath, arguments); bool success = false; var expectedOutput = $"D {path}"; using (var reader = outputCollector.GetOutputReader()) { while (!reader.ReadLineIsEnd(out var line)) { if (expectedOutput == line) { success = true; break; } } } if (!success) { throw new Exception($"SVN automation failure.\nReceived:\n{outputCollector.GetOutputText()}"); } logger.LogInformation($"SVN deleted path {path}."); }
public static IArgumentsBuilder GetStatusVerbose(AbsolutePath path) { var argumentsBuilder = SvnCommandServicesProvider.GetStatus(path) .AddVerbose(); return(argumentsBuilder); }
public static IArgumentsBuilder GetStatusVerboseForInstanceOnly(AbsolutePath path) { var argumentsBuilder = SvnCommandServicesProvider.GetStatusVerbose(path) .ForInstanceOnly(); return(argumentsBuilder); }
public static IArgumentsBuilder GetStatusVerboseDepthInfinity(AbsolutePath path) { var argumentsBuilder = SvnCommandServicesProvider.GetStatusVerbose(path) .SetDepth("infinity"); return(argumentsBuilder); }
/// <summary> /// Sets command flags to get an infinite-depth SVN status command that includes ignored items (does not respect svn:ignore and global ignore properties). /// </summary> public static IArgumentsBuilder GetStatusVerboseDepthInfinityNoIgnore(AbsolutePath path) { var argumentsBuilder = SvnCommandServicesProvider.GetStatusVerboseDepthInfinity(path) .AddFlagFull("no-ignore"); return(argumentsBuilder); }
public static string RunGetText(FilePath svnExecutableFilePath, IArgumentsBuilder argumentsBuilder, bool throwIfAnyError = true) { var outputCollector = SvnCommandServicesProvider.Run(svnExecutableFilePath, argumentsBuilder, throwIfAnyError); var text = outputCollector.GetOutputText(); return(text); }
public static ProcessOutputCollector Run(FilePath svnExecutableFilePath, IArgumentsBuilder argumentsBuilder, bool throwIfAnyError = true) { var arguments = argumentsBuilder.Build(); var outputCollector = SvnCommandServicesProvider.Run(svnExecutableFilePath, arguments, throwIfAnyError); return(outputCollector); }
public static string AddPath(string svnArguments, string path) { var token = $@"""{path}"""; var output = SvnCommandServicesProvider.AddToken(svnArguments, token); return(output); }
/// <summary> /// The default SVN status method. /// </summary> public static SvnStringPathStatus[] GetStatuses(FilePath svnExecutableFilePath, IArgumentsBuilder argumentsBuilder) { var xmlStatusType = SvnCommandServicesProvider.GetXmlStatusType(svnExecutableFilePath, argumentsBuilder); var statuses = SvnCommandServicesProvider.GetStatuses(xmlStatusType); return(statuses); }
public static string AddStatus(string svnArguments, string path) { var token = "status"; var output = SvnCommandServicesProvider.AddToken(svnArguments, token); output = SvnCommandServicesProvider.AddPath(svnArguments, path); return(output); }
public static string RunGetXmlText(FilePath svnExecutableFilePath, IArgumentsBuilder argumentsBuilder, bool throwIfAnyError = true) { argumentsBuilder .AddXml(); ; var textXml = SvnCommandServicesProvider.RunGetText(svnExecutableFilePath, argumentsBuilder, throwIfAnyError); return(textXml); }
public static TXmlType RunGetXmlType <TXmlType>(FilePath svnExecutableFilePath, IArgumentsBuilder argumentsBuilder, bool throwIfAnyError = true) { var xmlText = SvnCommandServicesProvider.RunGetXmlText(svnExecutableFilePath, argumentsBuilder, throwIfAnyError); using (var stream = StreamHelper.FromString(xmlText)) { var xmlType = XmlStreamSerializer.Deserialize <TXmlType>(stream, SvnXml.DefaultNamespace); return(xmlType); } }
public static SvnStringPathStatus[] Statuses(this SvnCommand svnCommand, IArgumentsBuilder argumentsBuilder) { svnCommand.Logger.LogDebug($"Getting all SVN status results..."); var statuses = SvnCommandServicesProvider.GetStatuses(svnCommand.SvnExecutableFilePath, argumentsBuilder); svnCommand.Logger.LogInformation($"Got all SVN status results ({statuses.Count()} results)."); return(statuses); }
public static StatusType GetStatusXmlType(FilePath svnExecutableFilePath, AbsolutePath path, ILogger logger) { //var statusXmlText = SvnCommandServicesProvider.GetStatusXmlText(svnExecutableFilePath, path, logger); var statusXmlText = SvnCommandServicesProvider.GetStatusXmlText2(svnExecutableFilePath, path, logger); using (var stream = StreamHelper.FromString(statusXmlText)) { var statusXmlType = XmlStreamSerializer.Deserialize <StatusType>(stream, SvnXml.DefaultNamespace); return(statusXmlType); } }
/// <summary> /// Get the SVN status results for a file or directory. /// If the specified path is a file, a single result will be returned. /// If the specified path is a directory, possibly many results will be returned. /// If the path does not exist, zero results will be returned. /// </summary> public static SvnStringPathStatus[] Statuses(this SvnCommand svnCommand, AbsolutePath path) { svnCommand.Logger.LogDebug($"Getting all SVN status results for path {path}..."); var arguments = SvnCommandServicesProvider.GetStatusVerbose(path); var statuses = SvnCommandServicesProvider.GetStatuses(svnCommand.SvnExecutableFilePath, arguments); svnCommand.Logger.LogInformation($"Got all SVN status results for path {path} ({statuses.Count()} results)."); return(statuses); }
/// <summary> /// Gets SVN status values for all directory contents recursively, disregarding any SVN ignore properties and the global SVN ignore values. /// </summary> public static SvnStringPathStatus[] StatusesInfinityNoIgnore(this SvnCommand svnCommand, DirectoryPath directoryPath) { svnCommand.Logger.LogDebug($"Getting all SVN status results for directory path {directoryPath}..."); var arguments = SvnCommandServicesProvider.GetStatusVerboseDepthInfinityNoIgnore(directoryPath); var statuses = SvnCommandServicesProvider.GetStatuses(svnCommand.SvnExecutableFilePath, arguments); svnCommand.Logger.LogInformation($"Got all SVN status results for directroy path {directoryPath} ({statuses.Count()} results)."); return(statuses); }
public static bool HasProperty(FilePath svnExecutableFilePath, AbsolutePath path, string propertyName, ILogger logger) { logger.LogDebug($"Testing existence of SVN property {propertyName} for {path}..."); var properties = SvnCommandServicesProvider.ListProperties(svnExecutableFilePath, path, logger); var hasProperty = properties.Contains(propertyName); logger.LogInformation($"Tested existence of SVN property {propertyName} for {path}."); return(hasProperty); }
private static SvnStringPathStatus StatusRobust_Internal(this SvnCommand svnCommand, AbsolutePath absolutePath) { var arguments = SvnCommandServicesProvider.GetStatusVerboseForInstanceOnly(absolutePath) .AddXml(); // Get XML. var outputCollector = SvnCommandServicesProvider.Run(svnCommand.SvnExecutableFilePath, arguments, false); if (outputCollector.AnyError) { var errorText = outputCollector.GetErrorText().Trim(); var notWorkingCopyText = $"svn: warning: W155007: '{absolutePath}' is not a working copy"; if (errorText == notWorkingCopyText) { var output = new SvnStringPathStatus { Path = absolutePath.Value, ItemStatus = ItemStatus.NotWorkingCopy }; return(output); } var notFoundText = $"svn: warning: W155010: The node '{absolutePath}' was not found."; if (errorText == notFoundText) { var output = new SvnStringPathStatus { Path = absolutePath.Value, ItemStatus = ItemStatus.NotFound }; return(output); } throw new Exception($"Unknown SVN error:\n{errorText}"); } var xmlText = outputCollector.GetOutputText(); using (var stream = StreamHelper.FromString(xmlText)) { var xmlStatusType = XmlStreamSerializer.Deserialize <StatusType>(stream, SvnXml.DefaultNamespace); var statuses = SvnCommandServicesProvider.GetStatuses(xmlStatusType); var status = statuses.Count() < 1 ? new SvnStringPathStatus { Path = absolutePath.Value, ItemStatus = ItemStatus.None } : statuses.Single() // Should be only 1. ; return(status); } }
public static string GetStatusXmlText(FilePath svnExecutableFilePath, AbsolutePath path, ILogger logger) { logger.LogDebug($"Getting SVN status XML text for path {path}..."); var arguments = $@"status ""{path}"" -v --xml"; var outputCollector = SvnCommandServicesProvider.Run(svnExecutableFilePath, arguments); logger.LogInformation($"Got SVN status XML text of path {path}."); var output = outputCollector.GetOutputText(); return(output); }
public static SvnStringPathStatus[] GetStatus(FilePath svnExecutableFilePath, AbsolutePath path, ILogger logger) { var statusXmlType = SvnCommandServicesProvider.GetStatusXmlType(svnExecutableFilePath, path, logger); var output = statusXmlType.target .Where(x => x.entry != null) .SelectMany(x => x.entry) .Select(x => new SvnStringPathStatus { Path = x.path, ItemStatus = x.wcstatus.item.ToItemStatus() }) .ToArray(); return(output); }
public static CheckoutResult Checkout(this SvnCommand svnCommand, string repositoryUrl, string localDirectoryPath) { svnCommand.Logger.LogDebug($"SVN checkout of '{repositoryUrl}' to '{localDirectoryPath}'..."); // Need to ensure the local directory path is NOT directory indicated (does NOT end with a directory separator). var correctedLocalDirectoryPath = PathUtilities.EnsureFilePathNotDirectoryIndicated(localDirectoryPath); var arguments = SvnCommandServicesProvider.GetCheckoutArguments(repositoryUrl, correctedLocalDirectoryPath); var commandOutput = SvnCommandServicesProvider.Run(svnCommand.SvnExecutableFilePath, arguments); var lines = commandOutput.GetOutputLines().ToList(); var lastLine = lines.Last(); var lastLineTokens = lastLine.Split(' '); var revisionNumberToken = lastLineTokens.Last().TrimEnd('.'); var revisionNumber = Int32.Parse(revisionNumberToken); var entryUpdateLines = lines.ExceptLast(); var statuses = new List <EntryUpdateStatus>(); foreach (var line in entryUpdateLines) { var lineTokens = line.Split(new[] { " " }, 2, StringSplitOptions.RemoveEmptyEntries); var statusToken = lineTokens[0]; var relativePath = lineTokens[1]; var updateStatus = statusToken.ToUpdateStatus(); var status = new EntryUpdateStatus { UpdateStatus = updateStatus, RelativePath = relativePath, }; statuses.Add(status); } var result = new CheckoutResult { RevisionNumber = revisionNumber, Statuses = statuses.ToArray(), }; svnCommand.Logger.LogInformation($"SVN checkout of '{repositoryUrl}' to '{localDirectoryPath}' complete."); return(result); }
public static string GetStatusXmlText2(FilePath svnExecutableFilePath, AbsolutePath path, ILogger logger) { logger.LogDebug($"Getting SVN status XML text for path {path}..."); var arguments = SvnCommandServicesProvider.GetStatusVerboseForInstanceOnly(path) .AddFlagFull("xml") .Build(); var outputCollector = SvnCommandServicesProvider.Run(svnExecutableFilePath, arguments); logger.LogInformation($"Got SVN status XML text of path {path}."); var output = outputCollector.GetOutputText(); return(output); }
public static Version GetVersion(FilePath svnExecutableFilePath, ILogger logger) { logger.LogDebug("Getting svn version..."); var arguments = "--version --quiet"; var outputCollector = SvnCommandServicesProvider.Run(svnExecutableFilePath, arguments); var line = outputCollector.GetOutputText(); var versionString = line; var version = Version.Parse(versionString); logger.LogInformation("Got svn version."); return(version); }
public static void Add(FilePath svnExecutableFilePath, AbsolutePath path, ILogger logger) { logger.LogDebug($"Adding changes for {path}..."); var arguments = $@"add ""{path}"""; var outputCollector = SvnCommandServicesProvider.Run(svnExecutableFilePath, arguments); var svnOutput = outputCollector.GetOutputText(); var expectedOutput = $"A {path}\r\n"; if (svnOutput != expectedOutput) { throw new Exception($"SVN automation failure.\nReceived:\n{svnOutput}"); } logger.LogInformation($"Added changes for {path}."); }
/// <summary>s /// Get only the SVN status of a specific directory, and not its children. /// If the directory path does not exist, returns a result with status <see cref="ItemStatus.None"/>. /// </summary> public static SvnStringPathStatus Status(this SvnCommand svnCommand, DirectoryPath directoryPath) { svnCommand.Logger.LogDebug($"Getting SVN status of directory path {directoryPath}..."); var arguments = SvnCommandServicesProvider.GetStatusVerboseForInstanceOnly(directoryPath); var statuses = SvnCommandServicesProvider.GetStatuses(svnCommand.SvnExecutableFilePath, arguments); var status = statuses.Count() < 1 ? new SvnStringPathStatus { Path = directoryPath.Value, ItemStatus = ItemStatus.None } : statuses.Single() // Should be only 1. ; svnCommand.Logger.LogDebug($"Got SVN status of directory path {directoryPath}."); return(status); }
public static void SetPropertyValue(FilePath svnExecutableFilePath, AbsolutePath path, string propertyName, string ignoreValue, ILogger logger) { logger.LogDebug($"Setting value of SVN property {propertyName} for {path}..."); var arguments = $@"propset {propertyName} {ignoreValue} ""{path}"""; var outputCollector = SvnCommandServicesProvider.Run(svnExecutableFilePath, arguments); // Test for success. var line = outputCollector.GetOutputTextTrimmed(); var expectedLine = $"property '{propertyName}' set on '{path}'"; if (expectedLine != line) { throw new Exception($"SVN automation failure.\nExpected output:\n{expectedLine}\nReceived:\n{line}"); } logger.LogInformation($"Set value of SVN property {propertyName} for {path}."); }
public static void Revert(FilePath svnExecutableFilePath, AbsolutePath path, ILogger logger) { logger.LogDebug($"SVN reverting {path}..."); var arguments = $@"revert ""{path}"""; var outputCollector = SvnCommandServicesProvider.Run(svnExecutableFilePath, arguments); // Check for success. var line = outputCollector.GetOutputTextTrimmed(); var expectedLine = $"Reverted '{path}'"; if (expectedLine != line) { throw new Exception($"SVN automation failure.\nReceived:\n{outputCollector.GetOutputText()}"); } logger.LogInformation($"SVN reverted {path}."); }