Package org.projectnessie.versioned

Class EventsVersionStore

java.lang.Object

org.projectnessie.versioned.EventsVersionStore

All Implemented Interfaces:

VersionStore

public class EventsVersionStore
extends java.lang.Object
implements VersionStore

A VersionStore wrapper that publishes results when a method is called that changes the catalog state.

Nested Class Summary

Nested classes/interfaces inherited from interface org.projectnessie.versioned.VersionStore

VersionStore.CommitValidator, VersionStore.KeyRestrictions, VersionStore.MergeOp, VersionStore.MergeTransplantOpBase, VersionStore.TransplantOp

Constructor Summary

Constructors

Constructor	Description
EventsVersionStore(VersionStore delegate, java.util.function.Consumer<Result> resultSink)	Takes the VersionStore instance to enrich with events.

Method Summary

Modifier and Type	Method	Description
ReferenceAssignedResult	assign(NamedRef ref, java.util.Optional<Hash> expectedHash, Hash targetHash)	Assign the NamedRef to point to a particular hash.
CommitResult<Commit>	commit(BranchName branch, java.util.Optional<Hash> referenceHash, org.projectnessie.model.CommitMeta metadata, java.util.List<Operation> operations, VersionStore.CommitValidator validator, java.util.function.BiConsumer<org.projectnessie.model.ContentKey,java.lang.String> addedContents)	Create a new commit and add to a branch.
ReferenceCreatedResult	create(NamedRef ref, java.util.Optional<Hash> targetHash)	Assign the NamedRef to point to a particular hash.
ReferenceDeletedResult	delete(NamedRef ref, java.util.Optional<Hash> hash)	Delete the provided NamedRef
PaginationIterator<Commit>	getCommits(Ref ref, boolean fetchAdditionalInfo)	Get a stream of all ancestor commits to a provided ref.
PaginationIterator<Diff>	getDiffs(Ref from, Ref to, java.lang.String pagingToken, VersionStore.KeyRestrictions keyRestrictions)	Get list of diffs between two refs.
java.util.List<org.projectnessie.model.IdentifiedContentKey>	getIdentifiedKeys(Ref ref, java.util.Collection<org.projectnessie.model.ContentKey> keys)
PaginationIterator<KeyEntry>	getKeys(Ref ref, java.lang.String pagingToken, boolean withContent, VersionStore.KeyRestrictions keyRestrictions)	Get a stream of all available keys for the given ref.
ReferenceInfo<org.projectnessie.model.CommitMeta>	getNamedRef(java.lang.String ref, GetNamedRefsParams params)	Resolve the given NamedRef and return information about it, which at least contains the current HEAD commit hash plus, optionally, additional information.
PaginationIterator<ReferenceInfo<org.projectnessie.model.CommitMeta>>	getNamedRefs(GetNamedRefsParams params, java.lang.String pagingToken)	List named refs.
java.util.stream.Stream<RefLogDetails>	getRefLog(Hash refLogId)	Deprecated.
java.util.List<org.projectnessie.model.RepositoryConfig>	getRepositoryConfig(java.util.Set<org.projectnessie.model.RepositoryConfig.Type> repositoryConfigTypes)
RepositoryInformation	getRepositoryInformation()
ContentResult	getValue(Ref ref, org.projectnessie.model.ContentKey key)	Get the value for a provided ref.
java.util.Map<org.projectnessie.model.ContentKey,ContentResult>	getValues(Ref ref, java.util.Collection<org.projectnessie.model.ContentKey> keys)	Get the values for a list of keys.
Hash	hashOnReference(NamedRef namedReference, java.util.Optional<Hash> hashOnReference, java.util.List<RelativeCommitSpec> relativeLookups)	Verifies that the given namedReference exists and that hashOnReference, if present, is reachable via that reference.
MergeResult<Commit>	merge(VersionStore.MergeOp mergeOp)	Merge items from an existing hash into the requested branch.
Hash	noAncestorHash()	Retrieve the hash for "no ancestor" (or "beginning of time"), which is a hash for which no commit exists.
MergeResult<Commit>	transplant(VersionStore.TransplantOp transplantOp)	Transplant a series of commits to a target branch.
org.projectnessie.model.RepositoryConfig	updateRepositoryConfig(org.projectnessie.model.RepositoryConfig repositoryConfig)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.projectnessie.versioned.VersionStore

commit

Constructor Detail

EventsVersionStore

public EventsVersionStore(VersionStore delegate,
                          java.util.function.Consumer<Result> resultSink)

Takes the VersionStore instance to enrich with events.

Parameters:

delegate - backing/delegate VersionStore.

resultSink - a consumer for results.

Method Detail

commit

public CommitResult<Commit> commit(@Nonnull @Nonnull
                                   BranchName branch,
                                   @Nonnull @Nonnull
                                   java.util.Optional<Hash> referenceHash,
                                   @Nonnull @Nonnull
                                   org.projectnessie.model.CommitMeta metadata,
                                   @Nonnull @Nonnull
                                   java.util.List<Operation> operations,
                                   @Nonnull @Nonnull
                                   VersionStore.CommitValidator validator,
                                   @Nonnull @Nonnull
                                   java.util.function.BiConsumer<org.projectnessie.model.ContentKey,java.lang.String> addedContents)
                            throws ReferenceNotFoundException,
                                   ReferenceConflictException

Description copied from interface: VersionStore

Create a new commit and add to a branch.

If referenceHash is not empty, for each key referenced by one of the operations, the current key's value is compared with the stored value for referenceHash's tree, and ReferenceConflictException is thrown if values are not matching.

Specified by:

commit in interface VersionStore

Parameters:

branch - The branch to commit to.

referenceHash - The hash to use as a reference for conflict detection. If not present, do not perform conflict detection

metadata - The metadata associated with the commit.

operations - The set of operations to apply.

validator - Gets called during the atomic commit operations, callers can implement validation logic.

addedContents - callback that receives the content-ID of _new_ content per content-key

Throws:

ReferenceNotFoundException - if branch is not present in the store

ReferenceConflictException - if referenceHash values do not match the stored values for branch

transplant

public MergeResult<Commit> transplant(VersionStore.TransplantOp transplantOp)
                               throws ReferenceNotFoundException,
                                      ReferenceConflictException

Description copied from interface: VersionStore

Transplant a series of commits to a target branch.

This is done as an atomic operation such that only the last of the sequence is ever visible to concurrent readers/writers. The sequence to transplant must be contiguous, in order and share a common ancestor with the target branch.

Specified by:

transplant in interface VersionStore

Returns:

merge result

Throws:

ReferenceNotFoundException - if branch or if any of the hashes from sequenceToTransplant is not present in the store.

ReferenceConflictException - if referenceHash values do not match the stored values for branch

merge

public MergeResult<Commit> merge(VersionStore.MergeOp mergeOp)
                          throws ReferenceNotFoundException,
                                 ReferenceConflictException

Description copied from interface: VersionStore

Merge items from an existing hash into the requested branch. The merge is always a rebase + fast-forward merge and is only completed if the rebase is conflict free. The set of commits added to the branch will be all of those until we arrive at a common ancestor. Depending on the underlying implementation, the number of commits allowed as part of this operation may be limited

Throws if any of the following are true:

• the hash or the branch do not exists
• the rebase has conflicts
• the expected branch hash does not match the actual branch hash

Specified by:

merge in interface VersionStore

Returns:

merge result

Throws:

ReferenceNotFoundException - if toBranch or fromHash is not present in the store.

ReferenceConflictException - if expectedBranchHash doesn't match the stored hash for toBranch

assign

public ReferenceAssignedResult assign(NamedRef ref,
                                      java.util.Optional<Hash> expectedHash,
                                      Hash targetHash)
                               throws ReferenceNotFoundException,
                                      ReferenceConflictException

Description copied from interface: VersionStore

Assign the NamedRef to point to a particular hash.

ref should already exists. If expectedHash is not empty, its value is compared with the current stored value for ref and an exception is thrown if values do not match.

Specified by:

assign in interface VersionStore

Parameters:

ref - The named ref to be assigned

expectedHash - The current head of the NamedRef to validate before updating. If not present, force assignment.

targetHash - The hash that this ref should refer to.

Returns:

A ReferenceAssignedResult containing the previous and current head of the reference

Throws:

ReferenceNotFoundException - if ref is not present in the store or if targetHash is not present in the store

ReferenceConflictException - if expectedHash is not empty and its value doesn't match the stored hash for ref

create

public ReferenceCreatedResult create(NamedRef ref,
                                     java.util.Optional<Hash> targetHash)
                              throws ReferenceNotFoundException,
                                     ReferenceAlreadyExistsException

Description copied from interface: VersionStore

Assign the NamedRef to point to a particular hash. If the NamedRef does not exist, it will be created.

Specified by:

create in interface VersionStore

Parameters:

ref - The named ref we're assigning

targetHash - The hash that this ref should refer to (optional). Otherwise will reference the beginning of time.

Returns:

A ReferenceCreatedResult containing the head of the created reference

Throws:

ReferenceNotFoundException - if targetHash is not empty and not present in the store

ReferenceAlreadyExistsException - if ref already exists

delete

public ReferenceDeletedResult delete(NamedRef ref,
                                     java.util.Optional<Hash> hash)
                              throws ReferenceNotFoundException,
                                     ReferenceConflictException

Description copied from interface: VersionStore

Delete the provided NamedRef

Throws exception if the optional hash does not match the provided ref.

Specified by:

delete in interface VersionStore

Parameters:

ref - The NamedRef to be deleted.

hash - An optional hash. If provided, this operation will only succeed if the branch is pointing at the provided

Returns:

A ReferenceDeletedResult containing the head of the deleted reference

Throws:

ReferenceNotFoundException - if ref is not present in the store

ReferenceConflictException - if hash doesn't match the stored hash for ref

getRepositoryInformation

@Nonnull
@Nonnull
public RepositoryInformation getRepositoryInformation()

Specified by:

getRepositoryInformation in interface VersionStore

hashOnReference

public Hash hashOnReference(NamedRef namedReference,
                            java.util.Optional<Hash> hashOnReference,
                            java.util.List<RelativeCommitSpec> relativeLookups)
                     throws ReferenceNotFoundException

Description copied from interface: VersionStore

Verifies that the given namedReference exists and that hashOnReference, if present, is reachable via that reference.

Specified by:

hashOnReference in interface VersionStore

Returns:

verified hashOnReference or, if hashOnReference is not present, the current HEAD of namedReference

Throws:

ReferenceNotFoundException - if namedReference does not exist or hashOnReference, if present, is not reachable from that reference

noAncestorHash

@Nonnull
@Nonnull
public Hash noAncestorHash()

Description copied from interface: VersionStore

Retrieve the hash for "no ancestor" (or "beginning of time"), which is a hash for which no commit exists. "no ancestor" or "beginning of time" are the initial hash of the default branch and branches that are created via VersionStore.create(NamedRef, Optional) without specifying the targetHash.

This "no ancestor" value is readable for all users, and it is a valid hash for every named reference.

The result of this function must not change for any store instance, but it can be different for different backends and even for different instances of the same backend.

Specified by:

noAncestorHash in interface VersionStore

getNamedRef

public ReferenceInfo<org.projectnessie.model.CommitMeta> getNamedRef(java.lang.String ref,
                                                                     GetNamedRefsParams params)
                                                              throws ReferenceNotFoundException

Description copied from interface: VersionStore

Resolve the given NamedRef and return information about it, which at least contains the current HEAD commit hash plus, optionally, additional information.

This is a functionally equivalent to hashOnReference(ref, Optional.empty(), Collections.emptyList()).

Specified by:

getNamedRef in interface VersionStore

Parameters:

ref - The branch or tag to lookup.

params - options that control which information shall be returned in ReferenceInfo, see GetNamedRefsParams for details.

Returns:

Requested information about the requested reference.

Throws:

ReferenceNotFoundException - if the reference cannot be found

getNamedRefs

public PaginationIterator<ReferenceInfo<org.projectnessie.model.CommitMeta>> getNamedRefs(GetNamedRefsParams params,
                                                                                          java.lang.String pagingToken)
                                                                                   throws ReferenceNotFoundException

Description copied from interface: VersionStore

List named refs.

IMPORTANT NOTE: The returned Stream must be closed!

Specified by:

getNamedRefs in interface VersionStore

Parameters:

params - options that control which information shall be returned in each ReferenceInfo, see ReferenceInfo for details.

pagingToken - paging token to start at

Returns:

All refs and their associated hashes.

Throws:

ReferenceNotFoundException

getCommits

public PaginationIterator<Commit> getCommits(Ref ref,
                                             boolean fetchAdditionalInfo)
                                      throws ReferenceNotFoundException

Description copied from interface: VersionStore

Get a stream of all ancestor commits to a provided ref.

Specified by:

getCommits in interface VersionStore

Parameters:

ref - the stream to get commits for.

fetchAdditionalInfo - include additional information like operations and parent hash

Returns:

A stream of commits.

Throws:

ReferenceNotFoundException - if ref is not present in the store

getKeys

public PaginationIterator<KeyEntry> getKeys(Ref ref,
                                            java.lang.String pagingToken,
                                            boolean withContent,
                                            VersionStore.KeyRestrictions keyRestrictions)
                                     throws ReferenceNotFoundException

Description copied from interface: VersionStore

Get a stream of all available keys for the given ref.

Specified by:

getKeys in interface VersionStore

Parameters:

ref - The ref to get keys for.

pagingToken - paging token to start at

withContent - whether to populate KeyEntry.getContent()

Returns:

The stream of keys available for this ref.

Throws:

ReferenceNotFoundException - if ref is not present in the store

getIdentifiedKeys

public java.util.List<org.projectnessie.model.IdentifiedContentKey> getIdentifiedKeys(Ref ref,
                                                                                      java.util.Collection<org.projectnessie.model.ContentKey> keys)
                                                                               throws ReferenceNotFoundException

Specified by:

getIdentifiedKeys in interface VersionStore

Throws:

ReferenceNotFoundException

getValue

public ContentResult getValue(Ref ref,
                              org.projectnessie.model.ContentKey key)
                       throws ReferenceNotFoundException

Description copied from interface: VersionStore

Get the value for a provided ref.

Specified by:

getValue in interface VersionStore

Parameters:

ref - Any ref type allowed

key - The key for the specific value

Returns:

The value.

Throws:

ReferenceNotFoundException - if ref is not present in the store

getValues

public java.util.Map<org.projectnessie.model.ContentKey,ContentResult> getValues(Ref ref,
                                                                                       java.util.Collection<org.projectnessie.model.ContentKey> keys)
                                                                                throws ReferenceNotFoundException

Description copied from interface: VersionStore

Get the values for a list of keys.

Specified by:

getValues in interface VersionStore

Parameters:

ref - The ref to use.

keys - An ordered list of keys to retrieve within the provided ref.

Returns:

A parallel list of values.

Throws:

ReferenceNotFoundException - if ref is not present in the store

getDiffs

public PaginationIterator<Diff> getDiffs(Ref from,
                                         Ref to,
                                         java.lang.String pagingToken,
                                         VersionStore.KeyRestrictions keyRestrictions)
                                  throws ReferenceNotFoundException

Description copied from interface: VersionStore

Get list of diffs between two refs.

Specified by:

getDiffs in interface VersionStore

Parameters:

from - The from part of the diff.

to - The to part of the diff.

pagingToken - paging token to start at

Returns:

A stream of values that are different.

Throws:

ReferenceNotFoundException

getRefLog

@Deprecated
public java.util.stream.Stream<RefLogDetails> getRefLog(Hash refLogId)
                                                 throws RefLogNotFoundException

Deprecated.

Description copied from interface: VersionStore

Get a stream of all reflog entries from the initial refLogId.

Specified by:

getRefLog in interface VersionStore

Parameters:

refLogId - initial reflog id to be used

Returns:

A stream of reflog entries.

Throws:

RefLogNotFoundException

getRepositoryConfig

public java.util.List<org.projectnessie.model.RepositoryConfig> getRepositoryConfig(java.util.Set<org.projectnessie.model.RepositoryConfig.Type> repositoryConfigTypes)

Specified by:

getRepositoryConfig in interface VersionStore

updateRepositoryConfig

public org.projectnessie.model.RepositoryConfig updateRepositoryConfig(org.projectnessie.model.RepositoryConfig repositoryConfig)
                                                                throws ReferenceConflictException

Specified by:

updateRepositoryConfig in interface VersionStore

Throws:

ReferenceConflictException