/// <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)); }