/// <summary>
/// Attempts to check if the repository has uncommitted changes.
/// </summary>
/// <param name="gitRunner"></param>
/// <param name="logger"></param>
/// <returns></returns>
public static GitInfo GetGitStatus(IGitRunner gitRunner, ITaskLogger logger)
{
GitInfo status = new GitInfo();
try
{
string statusText = gitRunner.GetTextFromProcess(GitArgument.Status);
Match match = StatusBranchSearch.Match(statusText);
if (match.Success && match.Groups.Count > 1)
{
string branch = match.Groups[1].Value;
status.Branch = branch;
}
else
{
Match detatchedMatch = DetatchedBranchSearch.Match(statusText);
if (detatchedMatch.Success && detatchedMatch.Groups.Count > 1)
{
string branch = detatchedMatch.Groups[1].Value;
status.Branch = branch;
if (branch.StartsWith("pull/"))
{
status.IsPullRequest = true;
}
}
}
if (string.IsNullOrWhiteSpace(status.Branch))
{
logger.LogMessage(MessageImportance.High, $"Unable to retrieve branch name from status text: \n{statusText}");
}
statusText = statusText.ToUpper();
if (statusText.Contains(UnmodifiedText) || statusText.Contains(UntrackedOnlyText))
{
status.Modified = "Unmodified";
}
else
{
status.Modified = "Modified";
}
}
catch (GitRunnerException ex)
{
logger?.LogWarning($"Error getting 'git status': {ex.Message}");
}
try
{
status.OriginUrl = gitRunner.GetTextFromProcess(GitArgument.OriginUrl);
if (status.OriginUrl != null && status.OriginUrl.Length > 0)
{
status.GitUser = GetGitHubUser(status.OriginUrl);
}
}
catch (GitRunnerException ex)
{
logger?.LogWarning($"Error getting git origin URL: {ex.Message}");
}
return(status);
}
/// <inheritdoc/>
public string GetTextFromProcess(GitArgument command)
{
string outText = null;
string arg = GetArg(command);
try
{
using (Process process = new Process())
{
process.StartInfo = new ProcessStartInfo(Command, arg)
{
UseShellExecute = false,
WorkingDirectory = this.WorkingDirectory,
RedirectStandardOutput = true
};
process.Start();
bool exited = process.WaitForExit(1000);
if (!exited || !process.HasExited)
{
Logger?.LogWarning($"Process '{command} {arg}' timed out, killing.");
process.Kill();
}
outText = process.StandardOutput.ReadToEnd()?.Trim();
}
}
catch (Exception ex)
{
throw new GitRunnerException(ex.Message, ex);
}
return(outText);
}
/// <summary>
/// Attempts to check if the repository has uncommitted changes.
/// </summary>
/// <param name="gitRunner"></param>
/// <param name="logger"></param>
/// <returns></returns>
public static GitInfo GetGitStatus(IGitRunner gitRunner, ITaskLogger logger)
{
GitInfo status = new GitInfo();
try
{
string statusText = gitRunner.GetTextFromProcess(GitArgument.Status);
Match match = StatusBranchSearch.Match(statusText);
if (match.Success && match.Groups.Count > 1)
{
string branch = match.Groups[1].Value;
status.Branch = branch;
}
statusText = statusText.ToUpper();
if (statusText.Contains(UnmodifiedText) || statusText.Contains(UntrackedOnlyText))
{
status.Modified = "Unmodified";
}
else
{
status.Modified = "Modified";
}
}
catch (GitRunnerException ex)
{
logger?.LogWarning($"Error getting 'git status': {ex.Message}");
}
try
{
status.OriginUrl = gitRunner.GetTextFromProcess(GitArgument.OriginUrl);
if (status.OriginUrl != null && status.OriginUrl.Length > 0)
{
status.GitUser = GetGitHubUser(status.OriginUrl);
}
}
catch (GitRunnerException ex)
{
logger?.LogWarning($"Error getting git origin URL: {ex.Message}");
}
return(status);
}
/// <summary>
/// Attempts to retrieve the git commit hash using the 'git' program.
/// </summary>
/// <param name="gitRunner"></param>
/// <param name="logger"></param>
/// <param name="commitHash"></param>
/// <returns></returns>
public static bool TryGetGitCommit(IGitRunner gitRunner, ITaskLogger logger, out string commitHash)
{
commitHash = null;
try
{
string outText = gitRunner.GetTextFromProcess(GitArgument.CommitHash);
if (outText.Length > 0)
{
commitHash = outText;
return(true);
}
}
catch (GitRunnerException ex)
{
logger?.LogWarning($"Error getting commit hash from 'git' command: {ex.Message}");
}
return(false);
}
/// <summary>
/// Parses the assembly version from the given file.
/// </summary>
/// <param name="assemblyFile"></param>
/// <param name="errorOnMismatch"></param>
/// <returns></returns>
public AssemblyInfoData ParseAssembly(string assemblyFile, bool errorOnMismatch)
{
string assemblyVersionStart = "[assembly: AssemblyVersion";
string assemblyFileVersionStart = "[assembly: AssemblyFileVersion";
string assemblyVersionString = null;
string assemblyFileVersionString = null;
int asmVerLineNum = 0;
int asmFileVerLineNum = 0;
int asmVerStartColumn;
int asmVerEndColumn;
int asmFileVerStartColumn;
int asmFileVerEndColumn;
FilePosition asmVerPosition = default;
FilePosition asmFileVerPosition = default;
string line;
int currentLine = 1;
string assemblyVersion = null;
string assemblyFileVersion = null;
if (!File.Exists(assemblyFile))
{
throw new FileNotFoundException("Could not find AssemblyInfo: " + assemblyFile);
}
using (StreamReader assemblyStream = new StreamReader(assemblyFile))
{
while ((line = assemblyStream.ReadLine()) != null)
{
if (line.Trim().StartsWith(assemblyVersionStart))
{
assemblyVersionString = line;
asmVerLineNum = currentLine;
}
if (line.Trim().StartsWith(assemblyFileVersionStart))
{
assemblyFileVersionString = line;
asmFileVerLineNum = currentLine;
}
currentLine++;
}
}
if (!string.IsNullOrEmpty(assemblyVersionString))
{
asmVerStartColumn = assemblyVersionString.IndexOf('"') + 1;
asmVerEndColumn = assemblyVersionString.LastIndexOf('"');
asmVerPosition = new FilePosition(asmVerLineNum, asmVerStartColumn + 1, asmVerEndColumn + 1);
if (asmVerStartColumn > 0 && asmVerEndColumn > 0)
{
assemblyVersion = assemblyVersionString.Substring(asmVerStartColumn, asmVerEndColumn - asmVerStartColumn);
}
}
else
{
if (FailOnError)
{
throw new ParsingException(null, MessageCodes.GetAssemblyInfo.AssemblyFileVersionParseFail,
"", assemblyFile, 0, 0, 0, 0, "Unable to parse the AssemblyVersion from {0}", assemblyFile);
}
Logger.LogWarning(null, MessageCodes.GetAssemblyInfo.AssemblyFileVersionParseFail,
"", assemblyFile, 0, 0, 0, 0, "Unable to parse the AssemblyVersion from {0}", assemblyFile);
return(AssemblyInfoData.AssemblyVersionError());
}
if (!string.IsNullOrEmpty(assemblyFileVersionString))
{
asmFileVerStartColumn = assemblyFileVersionString.IndexOf('"') + 1;
asmFileVerEndColumn = assemblyFileVersionString.LastIndexOf('"');
int lenth = asmFileVerEndColumn - asmFileVerStartColumn;
if (asmFileVerStartColumn > 0 && asmFileVerEndColumn > 0 && lenth > 0)
{
assemblyFileVersion = assemblyFileVersionString.Substring(asmFileVerStartColumn, asmFileVerEndColumn - asmFileVerStartColumn);
if (assemblyVersion != assemblyFileVersion)
{
string message = "AssemblyVersion {0} does not match AssemblyFileVersion {1} in {2}";
if (errorOnMismatch)
{
throw new ParsingException(null, MessageCodes.GetAssemblyInfo.AssemblyVersionMismatch,
"", assemblyFile, asmFileVerLineNum, asmFileVerStartColumn + 1, asmFileVerLineNum,
asmFileVerEndColumn + 1, message, assemblyVersion, assemblyFileVersion, assemblyFile);
}
Logger.LogWarning(null, MessageCodes.GetAssemblyInfo.AssemblyVersionMismatch,
"", assemblyFile, asmFileVerLineNum, asmFileVerStartColumn + 1, asmFileVerLineNum,
asmFileVerEndColumn + 1, message, assemblyVersion, assemblyFileVersion, assemblyFile);
}
}
else
{
asmFileVerStartColumn = Math.Max(0, asmFileVerStartColumn);
asmFileVerEndColumn = asmFileVerStartColumn;
string message = "Unable to parse the AssemblyFileVersion from {0}";
if (errorOnMismatch)
{
throw new ParsingException(null, MessageCodes.GetAssemblyInfo.AssemblyFileVersionParseFail,
"", assemblyFile, asmFileVerLineNum, asmFileVerStartColumn,
asmFileVerLineNum, asmFileVerEndColumn, message, assemblyFile);
}
Logger.LogWarning(null, MessageCodes.GetAssemblyInfo.AssemblyFileVersionParseFail,
"", assemblyFile, asmFileVerLineNum, asmFileVerStartColumn, asmFileVerLineNum,
asmFileVerEndColumn, message, assemblyFile);
}
asmFileVerPosition = new FilePosition(asmFileVerLineNum, asmFileVerStartColumn, asmFileVerEndColumn);
}
return(new AssemblyInfoData(assemblyVersion, assemblyFileVersion, asmVerPosition, asmFileVerPosition));
}
