/// <inheritdoc />
public TRepository AddRepository(TRepository repository, Signature signature, string message, Func <OdbBackend> backend = null, bool isBare = false)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
if (signature == null)
{
throw new ArgumentNullException(nameof(signature));
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
using (_logger.BeginScope("Adding repository '{Repository}'.", repository.Id))
{
var repositoryDescription = new RepositoryDescription(System.IO.Path.Combine(Path, repository.Id.ToString()), backend);
EnsureNewRepository(repository, repositoryDescription);
LibGit2Sharp.Repository.Init(repositoryDescription.Path, isBare);
return(_repositoryProvider.Execute(repositoryDescription, r =>
{
var all = repository.Flatten().Select(o => new ObjectRepositoryEntryChanges(o.GetDataPath(), ChangeKind.Added, @new: o));
var changes = new ObjectRepositoryChangeCollection(repository, all.ToImmutableList());
var commit = r.CommitChanges(changes, _serializerFactory(), message, signature, signature, _hooks);
if (commit == null)
{
return null;
}
return ReloadRepository(repositoryDescription, commit.Id);
}));
}
}
/// <summary>
/// Called when a merge is about to be processed.
/// </summary>
/// <param name="changes">The changes.</param>
/// <returns>The <see cref="CancelEventArgs"/>.</returns>
internal bool OnMergeStarted(ObjectRepositoryChangeCollection changes)
{
var args = new MergeStartedEventArgs(changes);
MergeStarted?.Invoke(this, args);
return(!args.Cancel);
}
/// <summary>
/// Called when a commit has been completed successfully.
/// </summary>
/// <param name="changes">The changes.</param>
/// <param name="message">The message.</param>
/// <param name="commitId">The commit identifier.</param>
internal void OnCommitCompleted(ObjectRepositoryChangeCollection changes, string message, ObjectId commitId)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var args = new CommitCompletedEventArgs(changes, message, commitId);
CommitCompleted?.Invoke(this, args);
}
/// <summary>
/// Called when a commit is about to be started.
/// </summary>
/// <param name="changes">The changes.</param>
/// <param name="message">The message.</param>
/// <returns>The <see cref="CancelEventArgs"/>.</returns>
internal bool OnCommitStarted(ObjectRepositoryChangeCollection changes, string message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var args = new CommitStartedEventArgs(changes, message);
CommitStarted?.Invoke(this, args);
return(!args.Cancel);
}
private static void UpdateIndexTreeDefinitions(IRepository repository, ObjectRepositoryChangeCollection changes, TreeDefinition definition, IObjectRepositorySerializer serializer)
{
var buffer = new StringBuilder();
foreach (var index in changes.NewRepository.Indexes)
{
var fullScan = changes.Added.Any(c => c.New.Id == index.Id);
if (UpdateAndSerializerIndex(index, changes, serializer, buffer, fullScan))
{
definition.Add(index.GetDataPath(), repository.CreateBlob(buffer), Mode.NonExecutableFile);
}
}
}
private ObjectId CommitChanges(Signature merger, IRepository repository, ObjectRepositoryChangeCollection treeChanges)
{
if (_merge.RequiresMergeCommit)
{
var message = $"Merge branch {_merge.BranchName} into {repository.Head.FriendlyName}";
return(repository.CommitChanges(treeChanges, _merge.Serializer, message, merger, merger, hooks: _hooks, mergeParent: repository.Lookup <Commit>(_merge.MergeCommitId)).Id);
}
else
{
var commit = repository.Lookup <Commit>(_merge.MergeCommitId);
var logMessage = commit.BuildCommitLogMessage(false, false, false);
repository.UpdateHeadAndTerminalReference(commit, logMessage);
return(_merge.MergeCommitId);
}
}
internal static void UpdateTreeDefinition(this IRepository repository, ObjectRepositoryChangeCollection changes, TreeDefinition definition, IObjectRepositorySerializer serializer, Commit oldCommit = null)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
if (definition == null)
{
throw new ArgumentNullException(nameof(definition));
}
UpdateChangeTreeDefinitions(repository, changes.Modified, definition, serializer);
UpdateChangeTreeDefinitions(repository, changes.Added, definition, serializer);
UpdateDeletionTreeDefinitions(changes.Deleted, definition, oldCommit);
UpdateIndexTreeDefinitions(repository, changes, definition, serializer);
}
private static bool UpdateAndSerializerIndex(IObjectRepositoryIndex index, ObjectRepositoryChangeCollection changes, IObjectRepositorySerializer serializer, StringBuilder buffer, bool fullScan)
{
buffer.Clear();
var binding = index.DataAccessor.ConstructorParameterBinding;
var updatedIndex = fullScan ? index.FullScan() : index.Update(changes);
if (updatedIndex == null)
{
return(false);
}
var cloned = (IObjectRepositoryIndex)binding.Cloner(index,
(instance, propertyName, type, fallback) =>
propertyName == nameof(IObjectRepositoryIndex.Values) ? updatedIndex : fallback,
(childProperty, children, @new, dataAccessor) =>
throw new NotSupportedException("Index should not contain child properties."));
serializer.Serialize(cloned, buffer);
return(true);
}
/// <inheritdoc/>
public ObjectRepositoryChangeCollection Compare(IObjectRepository original, IObjectRepository newRepository)
{
if (original == null)
{
throw new ArgumentNullException(nameof(original));
}
if (newRepository == null)
{
throw new ArgumentNullException(nameof(newRepository));
}
var changes = new List <ObjectRepositoryEntryChanges>();
CompareNode(original, newRepository, changes, new Stack <string>());
var result = new ObjectRepositoryChangeCollection(newRepository, changes.ToImmutableList(), original);
_logger.ChangesComputed(result.Modified.Count, result.Added.Count, result.Deleted.Count, original.CommitId, original.CommitId);
return(result);
}
internal static Commit CommitChanges(this IRepository repository, ObjectRepositoryChangeCollection changes, IObjectRepositorySerializer serializer, string message, Signature author, Signature committer, GitHooks hooks, CommitOptions options = null, Commit mergeParent = null)
{
TreeDefinition definition;
Commit startCommit;
if (changes.OldRepository?.CommitId != null)
{
if (repository.Head.Tip.Id != changes.OldRepository.CommitId)
{
throw new GitObjectDbException("Changes are not based on the HEAD commit.");
}
startCommit = repository.Lookup <Commit>(changes.OldRepository.CommitId);
definition = TreeDefinition.From(startCommit);
}
else if (repository.Info.IsHeadUnborn)
{
startCommit = null;
definition = new TreeDefinition();
}
else
{
throw new GitObjectDbException("Changes are not based on the HEAD commit.");
}
if (!hooks.OnCommitStarted(changes, message))
{
return(null);
}
repository.UpdateTreeDefinition(changes, definition, serializer, startCommit);
var result = Commit(repository, definition, message, author, committer, options, mergeParent);
hooks.OnCommitCompleted(changes, message, result.Id);
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="MergeStartedEventArgs"/> class.
/// </summary>
/// <param name="changes">The changes.</param>
public MergeStartedEventArgs(ObjectRepositoryChangeCollection changes)
{
Changes = changes ?? throw new ArgumentNullException(nameof(changes));
}
/// <summary>
/// Initializes a new instance of the <see cref="CommitCompletedEventArgs"/> class.
/// </summary>
/// <param name="changes">The changes.</param>
/// <param name="message">The message.</param>
/// <param name="commitId">The commit identifier.</param>
public CommitCompletedEventArgs(ObjectRepositoryChangeCollection changes, string message, ObjectId commitId)
{
Changes = changes ?? throw new ArgumentNullException(nameof(changes));
Message = message ?? throw new ArgumentNullException(nameof(message));
CommitId = commitId ?? throw new ArgumentNullException(nameof(commitId));
}
/// <summary>
/// Called when a merge has been completed successfully.
/// </summary>
/// <param name="changes">The changes.</param>
/// <param name="commitId">The commit identifier.</param>
internal void OnMergeCompleted(ObjectRepositoryChangeCollection changes, ObjectId commitId)
{
var args = new MergeCompletedEventArgs(changes, commitId);
MergeCompleted?.Invoke(this, args);
}
/// <summary>
/// Initializes a new instance of the <see cref="CommitStartedEventArgs"/> class.
/// </summary>
/// <param name="changes">The changes.</param>
/// <param name="message">The message.</param>
public CommitStartedEventArgs(ObjectRepositoryChangeCollection changes, string message)
{
Changes = changes ?? throw new ArgumentNullException(nameof(changes));
Message = message ?? throw new ArgumentNullException(nameof(message));
}
/// <summary>
/// Initializes a new instance of the <see cref="MergeCompletedEventArgs"/> class.
/// </summary>
/// <param name="changes">The changes.</param>
/// <param name="commitId">The commit identifier.</param>
public MergeCompletedEventArgs(ObjectRepositoryChangeCollection changes, ObjectId commitId)
{
Changes = changes ?? throw new ArgumentNullException(nameof(changes));
CommitId = commitId ?? throw new ArgumentNullException(nameof(commitId));
}
