public void WriteVariablesToDiskCache(IGitPreparer gitPreparer, GitVersionCacheKey cacheKey, VersionVariables variablesFromCache)
{
var cacheDir = PrepareCacheDirectory(gitPreparer);
var cacheFileName = GetCacheFileName(cacheKey, cacheDir);
variablesFromCache.FileName = cacheFileName;
Dictionary <string, string> dictionary;
using (log.IndentLog("Creating dictionary"))
{
dictionary = variablesFromCache.ToDictionary(x => x.Key, x => x.Value);
}
void WriteCacheOperation()
{
using var stream = fileSystem.OpenWrite(cacheFileName);
using var sw = new StreamWriter(stream);
using (log.IndentLog("Storing version variables to cache file " + cacheFileName))
{
var serializer = new Serializer();
serializer.Serialize(sw, dictionary);
}
}
var retryOperation = new OperationWithExponentialBackoff <IOException>(new ThreadSleep(), log, WriteCacheOperation, maxRetries: 6);
retryOperation.ExecuteAsync().Wait();
}
public string GetCacheDirectory(IGitPreparer gitPreparer)
{
var gitDir = gitPreparer.GetDotGitDirectory();
var cacheDir = Path.Combine(gitDir, "gitversion_cache");
return(cacheDir);
}
public string SelectConfigFilePath(IGitPreparer gitPreparer)
{
var workingDirectory = gitPreparer.GetWorkingDirectory();
var projectRootDirectory = gitPreparer.GetProjectRootDirectory();
return(GetConfigFilePath(HasConfigFileAt(workingDirectory) ? workingDirectory : projectRootDirectory));
}
public GitVersionCacheKeyFactory(IFileSystem fileSystem, ILog log, IGitPreparer gitPreparer, IConfigFileLocator configFileLocator)
{
this.fileSystem = fileSystem;
this.log = log;
this.gitPreparer = gitPreparer;
this.configFileLocator = configFileLocator;
}
public ConfigProvider(IFileSystem fileSystem, ILog log, IConfigFileLocator configFileLocator, IGitPreparer gitPreparer, IConfigInitWizard configInitWizard)
{
this.fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
this.log = log ?? throw new ArgumentNullException(nameof(log));
this.configFileLocator = configFileLocator ?? throw new ArgumentNullException(nameof(configFileLocator));
this.gitPreparer = gitPreparer ?? throw new ArgumentNullException(nameof(gitPreparer));
this.configInitWizard = configInitWizard ?? throw new ArgumentNullException(nameof(this.configInitWizard));
}
private static string GetGitSystemHash(IGitPreparer gitPreparer, ILog log)
{
var dotGitDirectory = gitPreparer.GetDotGitDirectory();
// traverse the directory and get a list of files, use that for GetHash
var contents = CalculateDirectoryContents(log, Path.Combine(dotGitDirectory, "refs"));
return(GetHash(contents.ToArray()));
}
private string PrepareCacheDirectory(IGitPreparer gitPreparer)
{
var cacheDir = GetCacheDirectory(gitPreparer);
// If the cacheDir already exists, CreateDirectory just won't do anything (it won't fail). @asbjornu
fileSystem.CreateDirectory(cacheDir);
return(cacheDir);
}
public static GitVersionCacheKey Create(IFileSystem fileSystem, ILog log, IGitPreparer gitPreparer, IConfigFileLocator configFileLocator, Config overrideConfig)
{
var gitSystemHash = GetGitSystemHash(gitPreparer, log);
var configFileHash = GetConfigFileHash(fileSystem, gitPreparer, configFileLocator);
var repositorySnapshotHash = GetRepositorySnapshotHash(gitPreparer);
var overrideConfigHash = GetOverrideConfigHash(overrideConfig);
var compositeHash = GetHash(gitSystemHash, configFileHash, repositorySnapshotHash, overrideConfigHash);
return(new GitVersionCacheKey(compositeHash));
}
private IGitVersionCalculator GetGitVersionCalculator(Arguments arguments, ILog logger = null)
{
sp = GetServiceProvider(arguments, logger);
fileSystem = sp.GetService <IFileSystem>();
log = sp.GetService <ILog>();
gitVersionCache = sp.GetService <IGitVersionCache>();
gitPreparer = sp.GetService <IGitPreparer>();
return(sp.GetService <IGitVersionCalculator>());
}
private IGitVersionCalculateTool GetGitVersionCalculator(GitVersionOptions gitVersionOptions, ILog logger = null, IRepository repository = null, IFileSystem fs = null)
{
sp = GetServiceProvider(gitVersionOptions, logger, repository, fs);
fileSystem = sp.GetService <IFileSystem>();
log = sp.GetService <ILog>();
gitVersionCache = sp.GetService <IGitVersionCache>();
gitPreparer = sp.GetService <IGitPreparer>();
return(sp.GetService <IGitVersionCalculateTool>());
}
public GitVersionExecutor(ILog log, IConfigFileLocator configFileLocator, IVersionWriter versionWriter, IHelpWriter helpWriter,
IExecCommand execCommand, IConfigProvider configProvider, IBuildServerResolver buildServerResolver, IGitPreparer gitPreparer)
{
this.log = log ?? throw new ArgumentNullException(nameof(log));
this.configFileLocator = configFileLocator ?? throw new ArgumentNullException(nameof(configFileLocator));
this.versionWriter = versionWriter ?? throw new ArgumentNullException(nameof(versionWriter));
this.helpWriter = helpWriter ?? throw new ArgumentNullException(nameof(helpWriter));
this.execCommand = execCommand ?? throw new ArgumentNullException(nameof(execCommand));
this.configProvider = configProvider ?? throw new ArgumentNullException(nameof(configFileLocator));
this.buildServerResolver = buildServerResolver ?? throw new ArgumentNullException(nameof(buildServerResolver));
this.gitPreparer = gitPreparer;
}
public GitVersionCalculator(ILog log, IConfigProvider configProvider, IBuildServerResolver buildServerResolver,
IGitVersionCache gitVersionCache, INextVersionCalculator nextVersionCalculator, IGitPreparer gitPreparer, IVariableProvider variableProvider,
IOptions <Arguments> options, IGitVersionCacheKeyFactory cacheKeyFactory)
{
this.log = log ?? throw new ArgumentNullException(nameof(log));
this.configProvider = configProvider ?? throw new ArgumentNullException(nameof(configProvider));
this.buildServerResolver = buildServerResolver ?? throw new ArgumentNullException(nameof(buildServerResolver));
this.gitVersionCache = gitVersionCache ?? throw new ArgumentNullException(nameof(gitVersionCache));
this.nextVersionCalculator = nextVersionCalculator ?? throw new ArgumentNullException(nameof(nextVersionCalculator));
this.gitPreparer = gitPreparer ?? throw new ArgumentNullException(nameof(gitPreparer));
this.variableProvider = variableProvider ?? throw new ArgumentNullException(nameof(variableProvider));
this.options = options ?? throw new ArgumentNullException(nameof(options));
this.cacheKeyFactory = cacheKeyFactory ?? throw new ArgumentNullException(nameof(cacheKeyFactory));
}
private static string GetRepositorySnapshotHash(IGitPreparer gitPreparer)
{
var repositorySnapshot = gitPreparer.WithRepository(repo => {
var head = repo.Head;
if (head.Tip == null)
{
return(head.CanonicalName);
}
var hash = string.Join(":", head.CanonicalName, head.Tip.Sha);
return(hash);
});
return(GetHash(repositorySnapshot));
}
public void Verify(IGitPreparer gitPreparer)
{
if (!string.IsNullOrWhiteSpace(gitPreparer.TargetUrl))
{
// Assuming this is a dynamic repository. At this stage it's unsure whether we have
// any .git info so we need to skip verification
return;
}
var workingDirectory = gitPreparer.WorkingDirectory;
var projectRootDirectory = gitPreparer.GetProjectRootDirectory();
Verify(workingDirectory, projectRootDirectory);
}
private static string GetConfigFileHash(IFileSystem fileSystem, IGitPreparer gitPreparer, IConfigFileLocator configFileLocator)
{
// will return the same hash even when config file will be moved
// from workingDirectory to rootProjectDirectory. It's OK. Config essentially is the same.
var configFilePath = configFileLocator.SelectConfigFilePath(gitPreparer);
if (!fileSystem.Exists(configFilePath))
{
return(string.Empty);
}
var configFileContent = fileSystem.ReadAllText(configFilePath);
return(GetHash(configFileContent));
}
public GitVersionCalculator(IFileSystem fileSystem, ILog log, IConfigFileLocator configFileLocator,
IConfigProvider configProvider,
IBuildServerResolver buildServerResolver, IGitVersionCache gitVersionCache,
IGitVersionFinder gitVersionFinder, IGitPreparer gitPreparer, IVariableProvider variableProvider, IOptions <Arguments> options)
{
this.fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
this.log = log ?? throw new ArgumentNullException(nameof(log));
this.configFileLocator = configFileLocator ?? throw new ArgumentNullException(nameof(configFileLocator));
this.configProvider = configProvider ?? throw new ArgumentNullException(nameof(configProvider));
this.buildServerResolver = buildServerResolver ?? throw new ArgumentNullException(nameof(buildServerResolver));
this.gitVersionCache = gitVersionCache ?? throw new ArgumentNullException(nameof(gitVersionCache));
this.gitVersionFinder = gitVersionFinder ?? throw new ArgumentNullException(nameof(gitVersionFinder));
this.gitPreparer = gitPreparer ?? throw new ArgumentNullException(nameof(gitPreparer));
this.variableProvider = variableProvider ?? throw new ArgumentNullException(nameof(variableProvider));
this.arguments = options.Value;
}
public GitVersionCalculateTool(ILog log, INextVersionCalculator nextVersionCalculator,
IVariableProvider variableProvider, IGitPreparer gitPreparer,
IGitVersionCache gitVersionCache, IGitVersionCacheKeyFactory cacheKeyFactory,
IOptions <GitVersionOptions> options, Lazy <GitVersionContext> versionContext)
{
this.log = log.NotNull();
this.nextVersionCalculator = nextVersionCalculator.NotNull();
this.variableProvider = variableProvider.NotNull();
this.gitPreparer = gitPreparer.NotNull();
this.cacheKeyFactory = cacheKeyFactory.NotNull();
this.gitVersionCache = gitVersionCache.NotNull();
this.options = options.NotNull();
this.versionContext = versionContext.NotNull();
}
public GitVersionCalculateTool(ILog log, INextVersionCalculator nextVersionCalculator,
IVariableProvider variableProvider, IGitPreparer gitPreparer,
IGitVersionCache gitVersionCache, IGitVersionCacheKeyFactory cacheKeyFactory,
IOptions <GitVersionOptions> options, Lazy <GitVersionContext> versionContext)
{
this.log = log ?? throw new ArgumentNullException(nameof(log));
this.nextVersionCalculator = nextVersionCalculator ?? throw new ArgumentNullException(nameof(nextVersionCalculator));
this.variableProvider = variableProvider ?? throw new ArgumentNullException(nameof(variableProvider));
this.gitPreparer = gitPreparer ?? throw new ArgumentNullException(nameof(gitPreparer));
this.cacheKeyFactory = cacheKeyFactory ?? throw new ArgumentNullException(nameof(cacheKeyFactory));
this.gitVersionCache = gitVersionCache ?? throw new ArgumentNullException(nameof(gitVersionCache));
this.options = options ?? throw new ArgumentNullException(nameof(options));
this.versionContext = versionContext ?? throw new ArgumentNullException(nameof(versionContext));
}
public GitVersionTool(ILog log, INextVersionCalculator nextVersionCalculator, IVariableProvider variableProvider, IGitPreparer gitPreparer,
IGitVersionCache gitVersionCache, IGitVersionCacheKeyFactory cacheKeyFactory,
IOutputGenerator outputGenerator, IWixVersionFileUpdater wixVersionFileUpdater, IGitVersionInfoGenerator gitVersionInfoGenerator, IAssemblyInfoFileUpdater assemblyInfoFileUpdater,
IOptions <GitVersionOptions> options, Lazy <GitVersionContext> versionContext)
{
this.log = log ?? throw new ArgumentNullException(nameof(log));
this.nextVersionCalculator = nextVersionCalculator ?? throw new ArgumentNullException(nameof(nextVersionCalculator));
this.variableProvider = variableProvider ?? throw new ArgumentNullException(nameof(variableProvider));
this.gitPreparer = gitPreparer ?? throw new ArgumentNullException(nameof(gitPreparer));
this.cacheKeyFactory = cacheKeyFactory ?? throw new ArgumentNullException(nameof(cacheKeyFactory));
this.gitVersionCache = gitVersionCache ?? throw new ArgumentNullException(nameof(gitVersionCache));
this.outputGenerator = outputGenerator ?? throw new ArgumentNullException(nameof(outputGenerator));
this.wixVersionFileUpdater = wixVersionFileUpdater ?? throw new ArgumentNullException(nameof(wixVersionFileUpdater));
this.gitVersionInfoGenerator = gitVersionInfoGenerator ?? throw new ArgumentNullException(nameof(gitVersionInfoGenerator));
this.assemblyInfoFileUpdater = assemblyInfoFileUpdater ?? throw new ArgumentNullException(nameof(gitVersionInfoGenerator));
this.options = options ?? throw new ArgumentNullException(nameof(options));
this.versionContext = versionContext ?? throw new ArgumentNullException(nameof(versionContext));
}
public VersionVariables LoadVersionVariablesFromDiskCache(IGitPreparer gitPreparer, GitVersionCacheKey key)
{
using (log.IndentLog("Loading version variables from disk cache"))
{
var cacheDir = PrepareCacheDirectory(gitPreparer);
var cacheFileName = GetCacheFileName(key, cacheDir);
if (!fileSystem.Exists(cacheFileName))
{
log.Info("Cache file " + cacheFileName + " not found.");
return(null);
}
using (log.IndentLog("Deserializing version variables from cache file " + cacheFileName))
{
try
{
var loadedVariables = VersionVariables.FromFile(cacheFileName, fileSystem);
return(loadedVariables);
}
catch (Exception ex)
{
log.Warning("Unable to read cache file " + cacheFileName + ", deleting it.");
log.Info(ex.ToString());
try
{
fileSystem.Delete(cacheFileName);
}
catch (Exception deleteEx)
{
log.Warning($"Unable to delete corrupted version cache file {cacheFileName}. Got {deleteEx.GetType().FullName} exception.");
}
return(null);
}
}
}
}
private static IRepository InitRepository(IOptions <Arguments> options, IGitPreparer preparer)
{
preparer.Prepare(); //we need to prepare the repository before using it for version calculation
return(new Repository(options.Value.DotGitDirectory));
}
public GitRepository(IOptions <Arguments> options, IGitPreparer preparer)
{
repositoryLazy = new Lazy <IRepository>(() => InitRepository(options, preparer));
}
public GitVersionTaskExecutor(IFileSystem fileSystem, ILog log, IBuildServerResolver buildServerResolver, IGitVersionCalculator gitVersionCalculator, IGitPreparer preparer)
{
this.fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
this.log = log ?? throw new ArgumentNullException(nameof(log));
this.buildServerResolver = buildServerResolver ?? throw new ArgumentNullException(nameof(buildServerResolver));
preparer.Prepare();
versionVariables = gitVersionCalculator.CalculateVersionVariables();
}
public GitVersionCache(IFileSystem fileSystem, ILog log, IGitPreparer gitPreparer)
{
this.fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
this.log = log ?? throw new ArgumentNullException(nameof(log));
this.gitPreparer = gitPreparer ?? throw new ArgumentNullException(nameof(gitPreparer));
}
