static int VerifyArgumentsAndRun() { Arguments arguments = null; try { var fileSystem = new FileSystem(); var argumentsWithoutExeName = GetArgumentsWithoutExeName(); try { arguments = ArgumentParser.ParseArguments(argumentsWithoutExeName); } catch (WarningException ex) { Console.WriteLine("Failed to parse arguments: {0}", string.Join(" ", argumentsWithoutExeName)); if (!string.IsNullOrWhiteSpace(ex.Message)) { Console.WriteLine(); Console.WriteLine(ex.Message); Console.WriteLine(); } HelpWriter.Write(); return(1); } catch (Exception) { Console.WriteLine("Failed to parse arguments: {0}", string.Join(" ", argumentsWithoutExeName)); HelpWriter.Write(); return(1); } if (arguments.IsHelp) { HelpWriter.Write(); return(0); } ConfigureLogging(arguments); if (arguments.Init) { ConfigurationProvider.Init(arguments.TargetPath, fileSystem, new ConsoleAdapter()); return(0); } if (arguments.ShowConfig) { Console.WriteLine(ConfigurationProvider.GetEffectiveConfigAsString(arguments.TargetPath, fileSystem)); return(0); } if (!string.IsNullOrEmpty(arguments.Proj) || !string.IsNullOrEmpty(arguments.Exec)) { arguments.Output = OutputType.BuildServer; } Logger.WriteInfo("Working directory: " + arguments.TargetPath); SpecifiedArgumentRunner.Run(arguments, fileSystem); } catch (WarningException exception) { var error = string.Format("An error occurred:\r\n{0}", exception.Message); Logger.WriteWarning(error); return(1); } catch (Exception exception) { var error = string.Format("An unexpected error occurred:\r\n{0}", exception); Logger.WriteError(error); if (arguments != null) { Logger.WriteInfo(string.Empty); Logger.WriteInfo("Here is the current git graph (please include in issue): "); Logger.WriteInfo("Showing max of 100 commits"); GitTools.LibGitExtensions.DumpGraph(arguments.TargetPath, Logger.WriteInfo, 100); } return(1); } return(0); }
private static bool Log(LogLevel loglevel, Func <string> messagefunc, Exception exception, object[] formatparameters) { // Create the main message. Careful of string format errors. string message; if (messagefunc == null) { message = null; } else { if (formatparameters == null || formatparameters.Length == 0) { message = messagefunc(); } else { try { message = string.Format(messagefunc(), formatparameters); } catch (FormatException) { message = messagefunc(); Logger.WriteError(string.Format("LoggerWrapper.Log(): Incorrectly formatted string: message: '{0}'; formatparameters: {1}", message, string.Join(";", formatparameters))); } } } if (exception != null) { // Append the exception to the end of the message. message = string.IsNullOrEmpty(message) ? exception.ToString() : string.Format("{0}\n{1}", message, exception); } if (!string.IsNullOrEmpty(message)) { switch (loglevel) { case LogLevel.Trace: case LogLevel.Debug: Logger.WriteDebug(message); break; case LogLevel.Info: Logger.WriteInfo(message); break; case LogLevel.Warn: Logger.WriteWarning(message); break; case LogLevel.Error: case LogLevel.Fatal: Logger.WriteError(message); break; } } return(true); }
static void ConfigureLogging(Arguments arguments) { var writeActions = new List <Action <string> > { s => log.AppendLine(s) }; if (arguments.Output == OutputType.BuildServer || arguments.LogFilePath == "console" || arguments.Init) { writeActions.Add(Console.WriteLine); } Exception exception = null; if (arguments.LogFilePath != null && arguments.LogFilePath != "console") { try { var logFileFullPath = Path.GetFullPath(arguments.LogFilePath); var logFile = new FileInfo(logFileFullPath); // NOTE: logFile.Directory will be null if the path is i.e. C:\logfile.log. @asbjornu if (logFile.Directory != null) { logFile.Directory.Create(); } using (logFile.CreateText()) { } writeActions.Add(x => WriteLogEntry(arguments, x)); } catch (Exception ex) { exception = ex; } } Logger.SetLoggers( s => writeActions.ForEach(a => { if (arguments.Verbosity >= VerbosityLevel.Debug) { a(s); } }), s => writeActions.ForEach(a => { if (arguments.Verbosity >= VerbosityLevel.Info) { a(s); } }), s => writeActions.ForEach(a => { if (arguments.Verbosity >= VerbosityLevel.Warn) { a(s); } }), s => writeActions.ForEach(a => { if (arguments.Verbosity >= VerbosityLevel.Error) { a(s); } })); if (exception != null) { Logger.WriteError(string.Format("Failed to configure logging for '{0}': {1}", arguments.LogFilePath, exception.Message)); } }
static int VerifyArgumentsAndRun() { Arguments arguments = null; try { var fileSystem = new FileSystem(); var argumentsWithoutExeName = GetArgumentsWithoutExeName(); try { arguments = ArgumentParser.ParseArguments(argumentsWithoutExeName); } catch (Exception exception) { Console.WriteLine("Failed to parse arguments: {0}", string.Join(" ", argumentsWithoutExeName)); if (!string.IsNullOrWhiteSpace(exception.Message)) { Console.WriteLine(); Console.WriteLine(exception.Message); Console.WriteLine(); } HelpWriter.Write(); return(1); } if (arguments.IsVersion) { var assembly = Assembly.GetExecutingAssembly(); VersionWriter.Write(assembly); return(0); } if (arguments.IsHelp) { HelpWriter.Write(); return(0); } if (arguments.Diag) { arguments.NoCache = true; arguments.Output = OutputType.BuildServer; } ConfigureLogging(arguments); #if NETDESKTOP if (arguments.Diag) { Logger.WriteInfo("Dumping commit graph: "); LibGitExtensions.DumpGraph(arguments.TargetPath, Logger.WriteInfo, 100); } #endif if (!Directory.Exists(arguments.TargetPath)) { Logger.WriteWarning(string.Format("The working directory '{0}' does not exist.", arguments.TargetPath)); } else { Logger.WriteInfo("Working directory: " + arguments.TargetPath); } VerifyConfiguration(arguments, fileSystem); if (arguments.Init) { ConfigurationProvider.Init(arguments.TargetPath, fileSystem, new ConsoleAdapter(), arguments.ConfigFileLocator); return(0); } if (arguments.ShowConfig) { Console.WriteLine(ConfigurationProvider.GetEffectiveConfigAsString(arguments.TargetPath, fileSystem, arguments.ConfigFileLocator)); return(0); } if (!string.IsNullOrEmpty(arguments.Proj) || !string.IsNullOrEmpty(arguments.Exec)) { arguments.Output = OutputType.BuildServer; } SpecifiedArgumentRunner.Run(arguments, fileSystem); } catch (WarningException exception) { var error = string.Format("An error occurred:\r\n{0}", exception.Message); Logger.WriteWarning(error); return(1); } catch (Exception exception) { var error = string.Format("An unexpected error occurred:\r\n{0}", exception); Logger.WriteError(error); if (arguments != null) { Logger.WriteInfo(string.Empty); Logger.WriteInfo("Attempting to show the current git graph (please include in issue): "); Logger.WriteInfo("Showing max of 100 commits"); try { #if NETDESKTOP LibGitExtensions.DumpGraph(arguments.TargetPath, Logger.WriteInfo, 100); #endif } catch (Exception dumpGraphException) { Logger.WriteError("Couldn't dump the git graph due to the following error: " + dumpGraphException); } } return(1); } return(0); }
static void Main() { int?exitCode = null; try { Arguments arguments; var argumentsWithoutExeName = GetArgumentsWithoutExeName(); try { arguments = ArgumentParser.ParseArguments(argumentsWithoutExeName); } catch (Exception) { Console.WriteLine("Failed to parse arguments: {0}", string.Join(" ", argumentsWithoutExeName)); HelpWriter.Write(); return; } if (arguments.IsHelp) { HelpWriter.Write(); return; } if (!string.IsNullOrEmpty(arguments.Proj) || !string.IsNullOrEmpty(arguments.Exec)) { arguments.Output = OutputType.BuildServer; } ConfigureLogging(arguments); var gitPreparer = new GitPreparer(arguments); var gitDirectory = gitPreparer.Prepare(); if (string.IsNullOrEmpty(gitDirectory)) { Console.Error.WriteLine("Failed to prepare or find the .git directory in path '{0}'", arguments.TargetPath); Environment.Exit(1); } var workingDirectory = Directory.GetParent(gitDirectory).FullName; Logger.WriteInfo("Working directory: " + workingDirectory); var applicableBuildServers = GetApplicableBuildServers(arguments.Authentication).ToList(); foreach (var buildServer in applicableBuildServers) { buildServer.PerformPreProcessingSteps(gitDirectory); } SemanticVersion semanticVersion; using (var repo = RepositoryLoader.GetRepo(gitDirectory)) { semanticVersion = GitVersionFinder.GetSemanticVersion(repo); } if (arguments.Output == OutputType.BuildServer) { foreach (var buildServer in applicableBuildServers) { buildServer.WriteIntegration(semanticVersion, Console.WriteLine); } } var variables = VariableProvider.GetVariablesFor(semanticVersion); if (arguments.Output == OutputType.Json) { switch (arguments.VersionPart) { case null: Console.WriteLine(JsonOutputFormatter.ToJson(variables)); break; default: string part; if (!variables.TryGetValue(arguments.VersionPart, out part)) { throw new WarningException(string.Format("Could not extract '{0}' from the available parts.", arguments.VersionPart)); } Console.WriteLine(part); break; } } using (var assemblyInfoUpdate = new AssemblyInfoFileUpdate(arguments, workingDirectory, variables)) { var execRun = RunExecCommandIfNeeded(arguments, workingDirectory, variables); var msbuildRun = RunMsBuildIfNeeded(arguments, workingDirectory, variables); if (!execRun && !msbuildRun) { assemblyInfoUpdate.DoNotRestoreAssemblyInfo(); //TODO Put warning back //if (!context.CurrentBuildServer.IsRunningInBuildAgent()) //{ // Console.WriteLine("WARNING: Not running in build server and /ProjectFile or /Exec arguments not passed"); // Console.WriteLine(); // Console.WriteLine("Run GitVersion.exe /? for help"); //} } } if (gitPreparer.IsDynamicGitRepository) { DeleteHelper.DeleteGitRepository(gitPreparer.DynamicGitRepositoryPath); } } catch (WarningException exception) { var error = string.Format("An error occurred:\r\n{0}", exception.Message); Logger.WriteWarning(error); exitCode = 1; } catch (Exception exception) { var error = string.Format("An unexpected error occurred:\r\n{0}", exception); Logger.WriteError(error); exitCode = 1; } if (Debugger.IsAttached) { Console.ReadKey(); } if (!exitCode.HasValue) { exitCode = 0; } else { // Dump log to console if we fail to complete successfully Console.Write(log.ToString()); } Environment.Exit(exitCode.Value); }
// based on https://msdn.microsoft.com/en-us/library/bb513869.aspx static List <string> CalculateDirectoryContents(string root) { var result = new List <string>(); // Data structure to hold names of subfolders to be // examined for files. var dirs = new Stack <string>(); if (!Directory.Exists(root)) { throw new ArgumentException(); } dirs.Push(root); while (dirs.Any()) { string currentDir = dirs.Pop(); var di = new DirectoryInfo(currentDir); result.Add(di.Name); string[] subDirs; try { subDirs = Directory.GetDirectories(currentDir); } // An UnauthorizedAccessException exception will be thrown if we do not have // discovery permission on a folder or file. It may or may not be acceptable // to ignore the exception and continue enumerating the remaining files and // folders. It is also possible (but unlikely) that a DirectoryNotFound exception // will be raised. This will happen if currentDir has been deleted by // another application or thread after our call to Directory.Exists. The // choice of which exceptions to catch depends entirely on the specific task // you are intending to perform and also on how much you know with certainty // about the systems on which this code will run. catch (UnauthorizedAccessException e) { Logger.WriteError(e.Message); continue; } catch (DirectoryNotFoundException e) { Logger.WriteError(e.Message); continue; } string[] files; try { files = Directory.GetFiles(currentDir); } catch (UnauthorizedAccessException e) { Logger.WriteError(e.Message); continue; } catch (DirectoryNotFoundException e) { Logger.WriteError(e.Message); continue; } foreach (var file in files) { try { var fi = new FileInfo(file); result.Add(fi.Name); result.Add(File.ReadAllText(file)); } catch (IOException e) { Logger.WriteError(e.Message); } } // Push the subdirectories onto the stack for traversal. // This could also be done before handing the files. // push in reverse order for (var i = subDirs.Length - 1; i >= 0; i--) { dirs.Push(subDirs[i]); } } return(result); }
static int VerifyArgumentsAndRun() { try { var fileSystem = new FileSystem(); Arguments arguments; var argumentsWithoutExeName = GetArgumentsWithoutExeName(); try { arguments = ArgumentParser.ParseArguments(argumentsWithoutExeName); } catch (Exception) { Console.WriteLine("Failed to parse arguments: {0}", string.Join(" ", argumentsWithoutExeName)); HelpWriter.Write(); return(1); } if (arguments.IsHelp) { HelpWriter.Write(); return(0); } ConfigureLogging(arguments); if (arguments.Init) { ConfigurationProvider.WriteSample(arguments.TargetPath, fileSystem); return(0); } if (arguments.ShowConfig) { Console.WriteLine(ConfigurationProvider.GetEffectiveConfigAsString(arguments.TargetPath, fileSystem)); return(0); } if (!string.IsNullOrEmpty(arguments.Proj) || !string.IsNullOrEmpty(arguments.Exec)) { arguments.Output = OutputType.BuildServer; } Logger.WriteInfo("Working directory: " + arguments.TargetPath); SpecifiedArgumentRunner.Run(arguments, fileSystem); } catch (WarningException exception) { var error = string.Format("An error occurred:\r\n{0}", exception.Message); Logger.WriteWarning(error); return(1); } catch (Exception exception) { var error = string.Format("An unexpected error occurred:\r\n{0}", exception); Logger.WriteError(error); return(1); } return(0); }