2005-06-06 20:31:29 +00:00
|
|
|
#ifndef REFS_H
|
|
|
|
#define REFS_H
|
|
|
|
|
2017-03-18 02:03:11 +00:00
|
|
|
struct object_id;
|
2017-03-26 02:42:29 +00:00
|
|
|
struct ref_store;
|
2017-03-18 02:03:11 +00:00
|
|
|
struct strbuf;
|
|
|
|
struct string_list;
|
2017-04-24 10:01:22 +00:00
|
|
|
struct worktree;
|
2017-03-18 02:03:11 +00:00
|
|
|
|
2015-06-22 14:03:05 +00:00
|
|
|
/*
|
|
|
|
* Resolve a reference, recursively following symbolic refererences.
|
|
|
|
*
|
|
|
|
* Store the referred-to object's name in sha1 and return the name of
|
|
|
|
* the non-symbolic reference that ultimately pointed at it. The
|
|
|
|
* return value, if not NULL, is a pointer into either a static buffer
|
|
|
|
* or the input ref.
|
|
|
|
*
|
|
|
|
* If the reference cannot be resolved to an object, the behavior
|
|
|
|
* depends on the RESOLVE_REF_READING flag:
|
|
|
|
*
|
|
|
|
* - If RESOLVE_REF_READING is set, return NULL.
|
|
|
|
*
|
|
|
|
* - If RESOLVE_REF_READING is not set, clear sha1 and return the name of
|
|
|
|
* the last reference name in the chain, which will either be a non-symbolic
|
|
|
|
* reference or an undefined reference. If this is a prelude to
|
|
|
|
* "writing" to the ref, the return value is the name of the ref
|
|
|
|
* that will actually be created or changed.
|
|
|
|
*
|
|
|
|
* If the RESOLVE_REF_NO_RECURSE flag is passed, only resolves one
|
|
|
|
* level of symbolic reference. The value stored in sha1 for a symbolic
|
|
|
|
* reference will always be null_sha1 in this case, and the return
|
|
|
|
* value is the reference that the symref refers to directly.
|
|
|
|
*
|
|
|
|
* If flags is non-NULL, set the value that it points to the
|
|
|
|
* combination of REF_ISPACKED (if the reference was found among the
|
|
|
|
* packed references), REF_ISSYMREF (if the initial reference was a
|
|
|
|
* symbolic reference), REF_BAD_NAME (if the reference name is ill
|
|
|
|
* formed --- see RESOLVE_REF_ALLOW_BAD_NAME below), and REF_ISBROKEN
|
|
|
|
* (if the ref is malformed or has a bad name). See refs.h for more detail
|
|
|
|
* on each flag.
|
|
|
|
*
|
|
|
|
* If ref is not a properly-formatted, normalized reference, return
|
|
|
|
* NULL. If more than MAXDEPTH recursive symbolic lookups are needed,
|
|
|
|
* give up and return NULL.
|
|
|
|
*
|
|
|
|
* RESOLVE_REF_ALLOW_BAD_NAME allows resolving refs even when their
|
|
|
|
* name is invalid according to git-check-ref-format(1). If the name
|
|
|
|
* is bad then the value stored in sha1 will be null_sha1 and the two
|
|
|
|
* flags REF_ISBROKEN and REF_BAD_NAME will be set.
|
|
|
|
*
|
|
|
|
* Even with RESOLVE_REF_ALLOW_BAD_NAME, names that escape the refs/
|
|
|
|
* directory and do not consist of all caps and underscores cannot be
|
|
|
|
* resolved. The function returns NULL for such ref names.
|
|
|
|
* Caps and underscores refers to the special refs, such as HEAD,
|
|
|
|
* FETCH_HEAD and friends, that all live outside of the refs/ directory.
|
|
|
|
*/
|
|
|
|
#define RESOLVE_REF_READING 0x01
|
|
|
|
#define RESOLVE_REF_NO_RECURSE 0x02
|
|
|
|
#define RESOLVE_REF_ALLOW_BAD_NAME 0x04
|
|
|
|
|
2017-03-26 02:42:34 +00:00
|
|
|
const char *refs_resolve_ref_unsafe(struct ref_store *refs,
|
|
|
|
const char *refname,
|
|
|
|
int resolve_flags,
|
|
|
|
unsigned char *sha1,
|
|
|
|
int *flags);
|
2016-03-31 04:19:22 +00:00
|
|
|
const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
|
|
|
|
unsigned char *sha1, int *flags);
|
2015-06-22 14:03:05 +00:00
|
|
|
|
2017-03-26 02:42:34 +00:00
|
|
|
char *refs_resolve_refdup(struct ref_store *refs,
|
|
|
|
const char *refname, int resolve_flags,
|
|
|
|
unsigned char *sha1, int *flags);
|
2016-03-31 04:19:22 +00:00
|
|
|
char *resolve_refdup(const char *refname, int resolve_flags,
|
|
|
|
unsigned char *sha1, int *flags);
|
2015-06-22 14:03:05 +00:00
|
|
|
|
2017-03-26 02:42:34 +00:00
|
|
|
int refs_read_ref_full(struct ref_store *refs, const char *refname,
|
|
|
|
int resolve_flags, unsigned char *sha1, int *flags);
|
2016-03-31 04:19:22 +00:00
|
|
|
int read_ref_full(const char *refname, int resolve_flags,
|
|
|
|
unsigned char *sha1, int *flags);
|
|
|
|
int read_ref(const char *refname, unsigned char *sha1);
|
2015-06-22 14:03:05 +00:00
|
|
|
|
2017-03-26 02:42:34 +00:00
|
|
|
/*
|
|
|
|
* Return 0 if a reference named refname could be created without
|
|
|
|
* conflicting with the name of an existing reference. Otherwise,
|
|
|
|
* return a negative value and write an explanation to err. If extras
|
|
|
|
* is non-NULL, it is a list of additional refnames with which refname
|
|
|
|
* is not allowed to conflict. If skip is non-NULL, ignore potential
|
|
|
|
* conflicts with refs in skip (e.g., because they are scheduled for
|
|
|
|
* deletion in the same operation). Behavior is undefined if the same
|
|
|
|
* name is listed in both extras and skip.
|
|
|
|
*
|
|
|
|
* Two reference names conflict if one of them exactly matches the
|
|
|
|
* leading components of the other; e.g., "foo/bar" conflicts with
|
|
|
|
* both "foo" and with "foo/bar/baz" but not with "foo/bar" or
|
|
|
|
* "foo/barbados".
|
|
|
|
*
|
|
|
|
* extras and skip must be sorted.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int refs_verify_refname_available(struct ref_store *refs,
|
|
|
|
const char *refname,
|
2017-04-16 06:41:26 +00:00
|
|
|
const struct string_list *extras,
|
2017-03-26 02:42:34 +00:00
|
|
|
const struct string_list *skip,
|
|
|
|
struct strbuf *err);
|
|
|
|
|
2016-03-31 04:19:22 +00:00
|
|
|
int ref_exists(const char *refname);
|
2015-06-22 14:03:05 +00:00
|
|
|
|
2017-01-27 10:09:47 +00:00
|
|
|
int should_autocreate_reflog(const char *refname);
|
|
|
|
|
2016-03-31 04:19:22 +00:00
|
|
|
int is_branch(const char *refname);
|
2015-06-22 14:03:05 +00:00
|
|
|
|
2016-09-04 16:08:41 +00:00
|
|
|
extern int refs_init_db(struct strbuf *err);
|
|
|
|
|
2015-06-22 14:03:05 +00:00
|
|
|
/*
|
|
|
|
* If refname is a non-symbolic reference that refers to a tag object,
|
|
|
|
* and the tag can be (recursively) dereferenced to a non-tag object,
|
|
|
|
* store the SHA1 of the referred-to object to sha1 and return 0. If
|
|
|
|
* any of these conditions are not met, return a non-zero value.
|
|
|
|
* Symbolic references are considered unpeelable, even if they
|
|
|
|
* ultimately resolve to a peelable tag.
|
|
|
|
*/
|
2017-03-26 02:42:34 +00:00
|
|
|
int refs_peel_ref(struct ref_store *refs, const char *refname,
|
|
|
|
unsigned char *sha1);
|
2016-03-31 04:19:22 +00:00
|
|
|
int peel_ref(const char *refname, unsigned char *sha1);
|
2015-06-22 14:03:05 +00:00
|
|
|
|
|
|
|
/**
|
2016-09-04 16:08:24 +00:00
|
|
|
* Resolve refname in the nested "gitlink" repository in the specified
|
|
|
|
* submodule (which must be non-NULL). If the resolution is
|
|
|
|
* successful, return 0 and set sha1 to the name of the object;
|
|
|
|
* otherwise, return a non-zero value.
|
2015-06-22 14:03:05 +00:00
|
|
|
*/
|
2016-09-04 16:08:24 +00:00
|
|
|
int resolve_gitlink_ref(const char *submodule, const char *refname,
|
2016-03-31 04:19:22 +00:00
|
|
|
unsigned char *sha1);
|
2015-06-22 14:03:05 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Return true iff abbrev_name is a possible abbreviation for
|
|
|
|
* full_name according to the rules defined by ref_rev_parse_rules in
|
|
|
|
* refs.c.
|
|
|
|
*/
|
2016-03-31 04:19:22 +00:00
|
|
|
int refname_match(const char *abbrev_name, const char *full_name);
|
2015-06-22 14:03:05 +00:00
|
|
|
|
2016-10-10 21:03:50 +00:00
|
|
|
int expand_ref(const char *str, int len, unsigned char *sha1, char **ref);
|
2016-03-31 04:19:22 +00:00
|
|
|
int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref);
|
|
|
|
int dwim_log(const char *str, int len, unsigned char *sha1, char **ref);
|
2015-06-22 14:03:05 +00:00
|
|
|
|
2014-04-16 22:26:44 +00:00
|
|
|
/*
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
* A ref_transaction represents a collection of reference updates that
|
|
|
|
* should succeed or fail together.
|
2014-04-16 22:26:44 +00:00
|
|
|
*
|
|
|
|
* Calling sequence
|
|
|
|
* ----------------
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
*
|
2014-04-16 22:26:44 +00:00
|
|
|
* - Allocate and initialize a `struct ref_transaction` by calling
|
|
|
|
* `ref_transaction_begin()`.
|
|
|
|
*
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
* - Specify the intended ref updates by calling one or more of the
|
|
|
|
* following functions:
|
|
|
|
* - `ref_transaction_update()`
|
|
|
|
* - `ref_transaction_create()`
|
|
|
|
* - `ref_transaction_delete()`
|
|
|
|
* - `ref_transaction_verify()`
|
|
|
|
*
|
|
|
|
* - Then either:
|
|
|
|
*
|
|
|
|
* - Optionally call `ref_transaction_prepare()` to prepare the
|
|
|
|
* transaction. This locks all references, checks preconditions,
|
|
|
|
* etc. but doesn't finalize anything. If this step fails, the
|
|
|
|
* transaction has been closed and can only be freed. If this step
|
|
|
|
* succeeds, then `ref_transaction_commit()` is almost certain to
|
|
|
|
* succeed. However, you can still call `ref_transaction_abort()`
|
|
|
|
* if you decide not to commit the transaction after all.
|
|
|
|
*
|
|
|
|
* - Call `ref_transaction_commit()` to execute the transaction,
|
|
|
|
* make the changes permanent, and release all locks. If you
|
|
|
|
* haven't already called `ref_transaction_prepare()`, then
|
|
|
|
* `ref_transaction_commit()` calls it for you.
|
|
|
|
*
|
|
|
|
* Or
|
|
|
|
*
|
|
|
|
* - Call `initial_ref_transaction_commit()` if the ref database is
|
|
|
|
* known to be empty and have no other writers (e.g. during
|
|
|
|
* clone). This is likely to be much faster than
|
|
|
|
* `ref_transaction_commit()`. `ref_transaction_prepare()` should
|
|
|
|
* *not* be called before `initial_ref_transaction_commit()`.
|
|
|
|
*
|
|
|
|
* - Then finally, call `ref_transaction_free()` to free the
|
|
|
|
* `ref_transaction` data structure.
|
|
|
|
*
|
|
|
|
* At any time before calling `ref_transaction_commit()`, you can call
|
|
|
|
* `ref_transaction_abort()` to abort the transaction, rollback any
|
|
|
|
* locks, and free any associated resources (including the
|
|
|
|
* `ref_transaction` data structure).
|
|
|
|
*
|
|
|
|
* Putting it all together, a complete reference update looks like
|
|
|
|
*
|
|
|
|
* struct ref_transaction *transaction;
|
|
|
|
* struct strbuf err = STRBUF_INIT;
|
|
|
|
* int ret = 0;
|
|
|
|
*
|
|
|
|
* transaction = ref_store_transaction_begin(refs, &err);
|
|
|
|
* if (!transaction ||
|
|
|
|
* ref_transaction_update(...) ||
|
|
|
|
* ref_transaction_create(...) ||
|
|
|
|
* ...etc... ||
|
|
|
|
* ref_transaction_commit(transaction, &err)) {
|
|
|
|
* error("%s", err.buf);
|
|
|
|
* ret = -1;
|
|
|
|
* }
|
|
|
|
* ref_transaction_free(transaction);
|
|
|
|
* strbuf_release(&err);
|
|
|
|
* return ret;
|
2014-04-16 22:26:44 +00:00
|
|
|
*
|
|
|
|
* Error handling
|
|
|
|
* --------------
|
|
|
|
*
|
|
|
|
* On error, transaction functions append a message about what
|
|
|
|
* went wrong to the 'err' argument. The message mentions what
|
|
|
|
* ref was being updated (if any) when the error occurred so it
|
|
|
|
* can be passed to 'die' or 'error' as-is.
|
|
|
|
*
|
|
|
|
* The message is appended to err without first clearing err.
|
|
|
|
* err will not be '\n' terminated.
|
2016-02-25 20:05:46 +00:00
|
|
|
*
|
|
|
|
* Caveats
|
|
|
|
* -------
|
|
|
|
*
|
|
|
|
* Note that no locks are taken, and no refs are read, until
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
* `ref_transaction_prepare()` or `ref_transaction_commit()` is
|
|
|
|
* called. So, for example, `ref_transaction_verify()` won't report a
|
|
|
|
* verification failure until the commit is attempted.
|
2014-04-16 22:26:44 +00:00
|
|
|
*/
|
2014-04-07 13:48:10 +00:00
|
|
|
struct ref_transaction;
|
|
|
|
|
2013-04-14 12:54:16 +00:00
|
|
|
/*
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
* Bit values set in the flags argument passed to each_ref_fn() and
|
|
|
|
* stored in ref_iterator::flags. Other bits are for internal use
|
|
|
|
* only:
|
2013-04-14 12:54:16 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/* Reference is a symbolic reference. */
|
2011-10-19 20:45:50 +00:00
|
|
|
#define REF_ISSYMREF 0x01
|
2013-04-14 12:54:16 +00:00
|
|
|
|
|
|
|
/* Reference is a packed reference. */
|
2011-10-19 20:45:50 +00:00
|
|
|
#define REF_ISPACKED 0x02
|
2013-04-14 12:54:16 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Reference cannot be resolved to an object name: dangling symbolic
|
refs.c: allow listing and deleting badly named refs
We currently do not handle badly named refs well:
$ cp .git/refs/heads/master .git/refs/heads/master.....@\*@\\.
$ git branch
fatal: Reference has invalid format: 'refs/heads/master.....@*@\.'
$ git branch -D master.....@\*@\\.
error: branch 'master.....@*@\.' not found.
Users cannot recover from a badly named ref without manually finding
and deleting the loose ref file or appropriate line in packed-refs.
Making that easier will make it easier to tweak the ref naming rules
in the future, for example to forbid shell metacharacters like '`'
and '"', without putting people in a state that is hard to get out of.
So allow "branch --list" to show these refs and allow "branch -d/-D"
and "update-ref -d" to delete them. Other commands (for example to
rename refs) will continue to not handle these refs but can be changed
in later patches.
Details:
In resolving functions, refuse to resolve refs that don't pass the
git-check-ref-format(1) check unless the new RESOLVE_REF_ALLOW_BAD_NAME
flag is passed. Even with RESOLVE_REF_ALLOW_BAD_NAME, refuse to
resolve refs that escape the refs/ directory and do not match the
pattern [A-Z_]* (think "HEAD" and "MERGE_HEAD").
In locking functions, refuse to act on badly named refs unless they
are being deleted and either are in the refs/ directory or match [A-Z_]*.
Just like other invalid refs, flag resolved, badly named refs with the
REF_ISBROKEN flag, treat them as resolving to null_sha1, and skip them
in all iteration functions except for for_each_rawref.
Flag badly named refs (but not symrefs pointing to badly named refs)
with a REF_BAD_NAME flag to make it easier for future callers to
notice and handle them specially. For example, in a later patch
for-each-ref will use this flag to detect refs whose names can confuse
callers parsing for-each-ref output.
In the transaction API, refuse to create or update badly named refs,
but allow deleting them (unless they try to escape refs/ and don't match
[A-Z_]*).
Signed-off-by: Ronnie Sahlberg <sahlberg@google.com>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-09-03 18:45:43 +00:00
|
|
|
* reference (directly or indirectly), corrupt reference file,
|
|
|
|
* reference exists but name is bad, or symbolic reference refers to
|
|
|
|
* ill-formatted reference name.
|
2013-04-14 12:54:16 +00:00
|
|
|
*/
|
2011-10-19 20:45:50 +00:00
|
|
|
#define REF_ISBROKEN 0x04
|
2006-11-22 07:36:35 +00:00
|
|
|
|
refs.c: allow listing and deleting badly named refs
We currently do not handle badly named refs well:
$ cp .git/refs/heads/master .git/refs/heads/master.....@\*@\\.
$ git branch
fatal: Reference has invalid format: 'refs/heads/master.....@*@\.'
$ git branch -D master.....@\*@\\.
error: branch 'master.....@*@\.' not found.
Users cannot recover from a badly named ref without manually finding
and deleting the loose ref file or appropriate line in packed-refs.
Making that easier will make it easier to tweak the ref naming rules
in the future, for example to forbid shell metacharacters like '`'
and '"', without putting people in a state that is hard to get out of.
So allow "branch --list" to show these refs and allow "branch -d/-D"
and "update-ref -d" to delete them. Other commands (for example to
rename refs) will continue to not handle these refs but can be changed
in later patches.
Details:
In resolving functions, refuse to resolve refs that don't pass the
git-check-ref-format(1) check unless the new RESOLVE_REF_ALLOW_BAD_NAME
flag is passed. Even with RESOLVE_REF_ALLOW_BAD_NAME, refuse to
resolve refs that escape the refs/ directory and do not match the
pattern [A-Z_]* (think "HEAD" and "MERGE_HEAD").
In locking functions, refuse to act on badly named refs unless they
are being deleted and either are in the refs/ directory or match [A-Z_]*.
Just like other invalid refs, flag resolved, badly named refs with the
REF_ISBROKEN flag, treat them as resolving to null_sha1, and skip them
in all iteration functions except for for_each_rawref.
Flag badly named refs (but not symrefs pointing to badly named refs)
with a REF_BAD_NAME flag to make it easier for future callers to
notice and handle them specially. For example, in a later patch
for-each-ref will use this flag to detect refs whose names can confuse
callers parsing for-each-ref output.
In the transaction API, refuse to create or update badly named refs,
but allow deleting them (unless they try to escape refs/ and don't match
[A-Z_]*).
Signed-off-by: Ronnie Sahlberg <sahlberg@google.com>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-09-03 18:45:43 +00:00
|
|
|
/*
|
|
|
|
* Reference name is not well formed.
|
|
|
|
*
|
|
|
|
* See git-check-ref-format(1) for the definition of well formed ref names.
|
|
|
|
*/
|
|
|
|
#define REF_BAD_NAME 0x08
|
|
|
|
|
2005-07-03 03:23:36 +00:00
|
|
|
/*
|
2013-05-25 09:08:24 +00:00
|
|
|
* The signature for the callback function for the for_each_*()
|
|
|
|
* functions below. The memory pointed to by the refname and sha1
|
|
|
|
* arguments is only guaranteed to be valid for the duration of a
|
|
|
|
* single callback invocation.
|
|
|
|
*/
|
|
|
|
typedef int each_ref_fn(const char *refname,
|
2015-05-25 18:38:28 +00:00
|
|
|
const struct object_id *oid, int flags, void *cb_data);
|
|
|
|
|
2013-05-25 09:08:24 +00:00
|
|
|
/*
|
|
|
|
* The following functions invoke the specified callback function for
|
|
|
|
* each reference indicated. If the function ever returns a nonzero
|
|
|
|
* value, stop the iteration and return that value. Please note that
|
|
|
|
* it is not safe to modify references while an iteration is in
|
|
|
|
* progress, unless the same callback function invocation that
|
|
|
|
* modifies the reference also returns a nonzero value to immediately
|
2017-03-26 02:42:41 +00:00
|
|
|
* stop the iteration. Returned references are sorted.
|
2005-07-03 03:23:36 +00:00
|
|
|
*/
|
2017-03-26 02:42:34 +00:00
|
|
|
int refs_for_each_ref(struct ref_store *refs,
|
|
|
|
each_ref_fn fn, void *cb_data);
|
|
|
|
int refs_for_each_ref_in(struct ref_store *refs, const char *prefix,
|
|
|
|
each_ref_fn fn, void *cb_data);
|
|
|
|
int refs_for_each_tag_ref(struct ref_store *refs,
|
|
|
|
each_ref_fn fn, void *cb_data);
|
|
|
|
int refs_for_each_branch_ref(struct ref_store *refs,
|
|
|
|
each_ref_fn fn, void *cb_data);
|
|
|
|
int refs_for_each_remote_ref(struct ref_store *refs,
|
|
|
|
each_ref_fn fn, void *cb_data);
|
|
|
|
|
2016-03-31 04:19:22 +00:00
|
|
|
int head_ref(each_ref_fn fn, void *cb_data);
|
|
|
|
int for_each_ref(each_ref_fn fn, void *cb_data);
|
|
|
|
int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data);
|
|
|
|
int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data,
|
|
|
|
unsigned int broken);
|
|
|
|
int for_each_tag_ref(each_ref_fn fn, void *cb_data);
|
|
|
|
int for_each_branch_ref(each_ref_fn fn, void *cb_data);
|
|
|
|
int for_each_remote_ref(each_ref_fn fn, void *cb_data);
|
|
|
|
int for_each_replace_ref(each_ref_fn fn, void *cb_data);
|
|
|
|
int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data);
|
|
|
|
int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
|
|
|
|
const char *prefix, void *cb_data);
|
|
|
|
|
|
|
|
int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data);
|
|
|
|
int for_each_ref_submodule(const char *submodule,
|
|
|
|
each_ref_fn fn, void *cb_data);
|
|
|
|
int for_each_ref_in_submodule(const char *submodule, const char *prefix,
|
2017-06-18 13:39:41 +00:00
|
|
|
each_ref_fn fn, void *cb_data);
|
|
|
|
int for_each_fullref_in_submodule(const char *submodule, const char *prefix,
|
|
|
|
each_ref_fn fn, void *cb_data,
|
|
|
|
unsigned int broken);
|
2016-03-31 04:19:22 +00:00
|
|
|
int for_each_tag_ref_submodule(const char *submodule,
|
|
|
|
each_ref_fn fn, void *cb_data);
|
|
|
|
int for_each_branch_ref_submodule(const char *submodule,
|
|
|
|
each_ref_fn fn, void *cb_data);
|
|
|
|
int for_each_remote_ref_submodule(const char *submodule,
|
|
|
|
each_ref_fn fn, void *cb_data);
|
2010-07-07 13:39:12 +00:00
|
|
|
|
2016-03-31 04:19:22 +00:00
|
|
|
int head_ref_namespaced(each_ref_fn fn, void *cb_data);
|
|
|
|
int for_each_namespaced_ref(each_ref_fn fn, void *cb_data);
|
ref namespaces: infrastructure
Add support for dividing the refs of a single repository into multiple
namespaces, each of which can have its own branches, tags, and HEAD.
Git can expose each namespace as an independent repository to pull from
and push to, while sharing the object store, and exposing all the refs
to operations such as git-gc.
Storing multiple repositories as namespaces of a single repository
avoids storing duplicate copies of the same objects, such as when
storing multiple branches of the same source. The alternates mechanism
provides similar support for avoiding duplicates, but alternates do not
prevent duplication between new objects added to the repositories
without ongoing maintenance, while namespaces do.
To specify a namespace, set the GIT_NAMESPACE environment variable to
the namespace. For each ref namespace, git stores the corresponding
refs in a directory under refs/namespaces/. For example,
GIT_NAMESPACE=foo will store refs under refs/namespaces/foo/. You can
also specify namespaces via the --namespace option to git.
Note that namespaces which include a / will expand to a hierarchy of
namespaces; for example, GIT_NAMESPACE=foo/bar will store refs under
refs/namespaces/foo/refs/namespaces/bar/. This makes paths in
GIT_NAMESPACE behave hierarchically, so that cloning with
GIT_NAMESPACE=foo/bar produces the same result as cloning with
GIT_NAMESPACE=foo and cloning from that repo with GIT_NAMESPACE=bar. It
also avoids ambiguity with strange namespace paths such as
foo/refs/heads/, which could otherwise generate directory/file conflicts
within the refs directory.
Add the infrastructure for ref namespaces: handle the GIT_NAMESPACE
environment variable and --namespace option, and support iterating over
refs in a namespace.
Signed-off-by: Josh Triplett <josh@joshtriplett.org>
Signed-off-by: Jamey Sharp <jamey@minilop.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-07-05 17:54:44 +00:00
|
|
|
|
2015-06-22 14:03:05 +00:00
|
|
|
/* can be used to learn about broken ref and symref */
|
2017-03-26 02:42:34 +00:00
|
|
|
int refs_for_each_rawref(struct ref_store *refs, each_ref_fn fn, void *cb_data);
|
2016-03-31 04:19:22 +00:00
|
|
|
int for_each_rawref(each_ref_fn fn, void *cb_data);
|
2015-06-22 14:03:05 +00:00
|
|
|
|
2010-03-12 17:04:26 +00:00
|
|
|
static inline const char *has_glob_specials(const char *pattern)
|
|
|
|
{
|
|
|
|
return strpbrk(pattern, "?*[");
|
|
|
|
}
|
|
|
|
|
2016-03-31 04:19:22 +00:00
|
|
|
void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname);
|
|
|
|
void warn_dangling_symrefs(FILE *fp, const char *msg_fmt,
|
|
|
|
const struct string_list *refnames);
|
2009-02-09 07:27:10 +00:00
|
|
|
|
2013-04-22 19:52:32 +00:00
|
|
|
/*
|
|
|
|
* Flags for controlling behaviour of pack_refs()
|
|
|
|
* PACK_REFS_PRUNE: Prune loose refs after packing
|
|
|
|
* PACK_REFS_ALL: Pack _all_ refs, not just tags and already packed refs
|
|
|
|
*/
|
|
|
|
#define PACK_REFS_PRUNE 0x0001
|
|
|
|
#define PACK_REFS_ALL 0x0002
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write a packed-refs file for the current repository.
|
|
|
|
* flags: Combination of the above PACK_REFS_* flags.
|
|
|
|
*/
|
2017-03-26 02:42:34 +00:00
|
|
|
int refs_pack_refs(struct ref_store *refs, unsigned int flags);
|
2013-04-22 19:52:32 +00:00
|
|
|
|
2014-06-20 14:42:51 +00:00
|
|
|
/*
|
2014-12-12 08:57:01 +00:00
|
|
|
* Flags controlling ref_transaction_update(), ref_transaction_create(), etc.
|
2014-04-30 16:03:36 +00:00
|
|
|
* REF_NODEREF: act on the ref directly, instead of dereferencing
|
|
|
|
* symbolic references.
|
|
|
|
*
|
2015-02-12 11:12:12 +00:00
|
|
|
* Other flags are reserved for internal use.
|
2014-06-20 14:42:51 +00:00
|
|
|
*/
|
2007-05-09 10:33:20 +00:00
|
|
|
#define REF_NODEREF 0x01
|
2015-07-21 21:04:54 +00:00
|
|
|
#define REF_FORCE_CREATE_REFLOG 0x40
|
2005-06-06 20:31:29 +00:00
|
|
|
|
refs: strip out not allowed flags from ref_transaction_update
Callers are only allowed to pass certain flags into
ref_transaction_update, other flags are internal to it. To prevent
mistakes from the callers, strip the internal only flags out before
continuing.
This was noticed because of a compiler warning gcc 7.1.1 issued about
passing a NULL parameter as second parameter to memcpy (through
hashcpy):
In file included from refs.c:5:0:
refs.c: In function ‘ref_transaction_verify’:
cache.h:948:2: error: argument 2 null where non-null expected [-Werror=nonnull]
memcpy(sha_dst, sha_src, GIT_SHA1_RAWSZ);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from git-compat-util.h:165:0,
from cache.h:4,
from refs.c:5:
/usr/include/string.h:43:14: note: in a call to function ‘memcpy’ declared here
extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
^~~~~~
The call to hascpy in ref_transaction_add_update is protected by the
passed in flags, but as we only add flags there, gcc notices
REF_HAVE_NEW or REF_HAVE_OLD flags could be passed in from the outside,
which would potentially result in passing in NULL as second parameter to
memcpy.
Fix both the compiler warning, and make the interface safer for its
users by stripping the internal flags out.
Suggested-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Thomas Gummerer <t.gummerer@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-12 22:59:21 +00:00
|
|
|
/*
|
|
|
|
* Flags that can be passed in to ref_transaction_update
|
|
|
|
*/
|
|
|
|
#define REF_TRANSACTION_UPDATE_ALLOWED_FLAGS \
|
|
|
|
REF_ISPRUNING | \
|
|
|
|
REF_FORCE_CREATE_REFLOG | \
|
|
|
|
REF_NODEREF
|
|
|
|
|
2014-06-20 14:42:50 +00:00
|
|
|
/*
|
2015-07-21 21:04:50 +00:00
|
|
|
* Setup reflog before using. Fill in err and return -1 on failure.
|
2014-06-20 14:42:50 +00:00
|
|
|
*/
|
2017-03-26 02:42:34 +00:00
|
|
|
int refs_create_reflog(struct ref_store *refs, const char *refname,
|
|
|
|
int force_create, struct strbuf *err);
|
2015-07-21 21:04:52 +00:00
|
|
|
int safe_create_reflog(const char *refname, int force_create, struct strbuf *err);
|
2010-05-22 00:28:36 +00:00
|
|
|
|
2006-05-17 09:56:09 +00:00
|
|
|
/** Reads log for the value of ref during at_time. **/
|
2016-03-31 04:19:22 +00:00
|
|
|
int read_ref_at(const char *refname, unsigned int flags,
|
2017-04-26 19:29:31 +00:00
|
|
|
timestamp_t at_time, int cnt,
|
2016-03-31 04:19:22 +00:00
|
|
|
unsigned char *sha1, char **msg,
|
2017-04-26 19:29:31 +00:00
|
|
|
timestamp_t *cutoff_time, int *cutoff_tz, int *cutoff_cnt);
|
2006-05-17 09:56:09 +00:00
|
|
|
|
2014-05-06 22:45:52 +00:00
|
|
|
/** Check if a particular reflog exists */
|
2017-03-26 02:42:34 +00:00
|
|
|
int refs_reflog_exists(struct ref_store *refs, const char *refname);
|
2016-03-31 04:19:22 +00:00
|
|
|
int reflog_exists(const char *refname);
|
2014-05-06 22:45:52 +00:00
|
|
|
|
2015-06-22 14:02:52 +00:00
|
|
|
/*
|
2015-06-22 14:03:10 +00:00
|
|
|
* Delete the specified reference. If old_sha1 is non-NULL, then
|
|
|
|
* verify that the current value of the reference is old_sha1 before
|
|
|
|
* deleting it. If old_sha1 is NULL, delete the reference if it
|
|
|
|
* exists, regardless of its old value. It is an error for old_sha1 to
|
2017-05-22 14:17:38 +00:00
|
|
|
* be NULL_SHA1. msg and flags are passed through to
|
|
|
|
* ref_transaction_delete().
|
2015-06-22 14:02:52 +00:00
|
|
|
*/
|
2017-03-26 02:42:35 +00:00
|
|
|
int refs_delete_ref(struct ref_store *refs, const char *msg,
|
|
|
|
const char *refname,
|
|
|
|
const unsigned char *old_sha1,
|
|
|
|
unsigned int flags);
|
2017-02-21 01:10:32 +00:00
|
|
|
int delete_ref(const char *msg, const char *refname,
|
|
|
|
const unsigned char *old_sha1, unsigned int flags);
|
2015-06-22 14:02:52 +00:00
|
|
|
|
2015-06-22 14:02:55 +00:00
|
|
|
/*
|
|
|
|
* Delete the specified references. If there are any problems, emit
|
|
|
|
* errors but attempt to keep going (i.e., the deletes are not done in
|
2017-05-22 14:17:38 +00:00
|
|
|
* an all-or-nothing transaction). msg and flags are passed through to
|
2016-06-18 04:15:10 +00:00
|
|
|
* ref_transaction_delete().
|
2015-06-22 14:02:55 +00:00
|
|
|
*/
|
2017-05-22 14:17:38 +00:00
|
|
|
int refs_delete_refs(struct ref_store *refs, const char *msg,
|
|
|
|
struct string_list *refnames, unsigned int flags);
|
|
|
|
int delete_refs(const char *msg, struct string_list *refnames,
|
|
|
|
unsigned int flags);
|
2015-06-22 14:02:55 +00:00
|
|
|
|
2014-05-06 22:45:52 +00:00
|
|
|
/** Delete a reflog */
|
2017-03-26 02:42:34 +00:00
|
|
|
int refs_delete_reflog(struct ref_store *refs, const char *refname);
|
2016-03-31 04:19:22 +00:00
|
|
|
int delete_reflog(const char *refname);
|
2014-05-06 22:45:52 +00:00
|
|
|
|
2006-12-18 09:18:16 +00:00
|
|
|
/* iterate over reflog entries */
|
2016-03-31 04:19:22 +00:00
|
|
|
typedef int each_reflog_ent_fn(
|
2017-02-21 23:47:32 +00:00
|
|
|
struct object_id *old_oid, struct object_id *new_oid,
|
2017-04-26 19:29:31 +00:00
|
|
|
const char *committer, timestamp_t timestamp,
|
2016-03-31 04:19:22 +00:00
|
|
|
int tz, const char *msg, void *cb_data);
|
|
|
|
|
2017-03-26 02:42:34 +00:00
|
|
|
int refs_for_each_reflog_ent(struct ref_store *refs, const char *refname,
|
|
|
|
each_reflog_ent_fn fn, void *cb_data);
|
|
|
|
int refs_for_each_reflog_ent_reverse(struct ref_store *refs,
|
|
|
|
const char *refname,
|
|
|
|
each_reflog_ent_fn fn,
|
|
|
|
void *cb_data);
|
2011-12-12 05:38:09 +00:00
|
|
|
int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, void *cb_data);
|
2013-03-08 21:27:37 +00:00
|
|
|
int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, void *cb_data);
|
2006-12-18 09:18:16 +00:00
|
|
|
|
2007-02-03 18:25:43 +00:00
|
|
|
/*
|
|
|
|
* Calls the specified function for each reflog file until it returns nonzero,
|
2017-03-26 02:42:41 +00:00
|
|
|
* and returns the value. Reflog file order is unspecified.
|
2007-02-03 18:25:43 +00:00
|
|
|
*/
|
2017-03-26 02:42:34 +00:00
|
|
|
int refs_for_each_reflog(struct ref_store *refs, each_ref_fn fn, void *cb_data);
|
2016-03-31 04:19:22 +00:00
|
|
|
int for_each_reflog(each_ref_fn fn, void *cb_data);
|
2007-02-03 18:25:43 +00:00
|
|
|
|
2011-09-15 21:10:25 +00:00
|
|
|
#define REFNAME_ALLOW_ONELEVEL 1
|
|
|
|
#define REFNAME_REFSPEC_PATTERN 2
|
|
|
|
|
|
|
|
/*
|
2011-12-12 05:38:09 +00:00
|
|
|
* Return 0 iff refname has the correct format for a refname according
|
|
|
|
* to the rules described in Documentation/git-check-ref-format.txt.
|
|
|
|
* If REFNAME_ALLOW_ONELEVEL is set in flags, then accept one-level
|
2011-09-15 21:10:25 +00:00
|
|
|
* reference names. If REFNAME_REFSPEC_PATTERN is set in flags, then
|
2015-07-22 21:05:33 +00:00
|
|
|
* allow a single "*" wildcard character in the refspec. No leading or
|
|
|
|
* repeated slashes are accepted.
|
2011-09-15 21:10:25 +00:00
|
|
|
*/
|
2016-03-31 04:19:22 +00:00
|
|
|
int check_refname_format(const char *refname, int flags);
|
2005-06-06 20:31:29 +00:00
|
|
|
|
2016-03-31 04:19:22 +00:00
|
|
|
const char *prettify_refname(const char *refname);
|
2015-06-22 14:03:05 +00:00
|
|
|
|
2016-03-31 04:19:22 +00:00
|
|
|
char *shorten_unambiguous_ref(const char *refname, int strict);
|
2009-03-09 01:06:05 +00:00
|
|
|
|
2006-11-28 14:47:40 +00:00
|
|
|
/** rename ref, return 0 on success **/
|
2017-03-26 02:42:34 +00:00
|
|
|
int refs_rename_ref(struct ref_store *refs, const char *oldref,
|
|
|
|
const char *newref, const char *logmsg);
|
2016-03-31 04:19:22 +00:00
|
|
|
int rename_ref(const char *oldref, const char *newref, const char *logmsg);
|
2006-11-28 14:47:40 +00:00
|
|
|
|
2017-03-26 02:42:34 +00:00
|
|
|
int refs_create_symref(struct ref_store *refs, const char *refname,
|
|
|
|
const char *target, const char *logmsg);
|
2016-03-31 04:19:22 +00:00
|
|
|
int create_symref(const char *refname, const char *target, const char *logmsg);
|
2007-04-10 04:14:26 +00:00
|
|
|
|
2014-04-07 13:47:56 +00:00
|
|
|
enum action_on_err {
|
|
|
|
UPDATE_REFS_MSG_ON_ERR,
|
|
|
|
UPDATE_REFS_DIE_ON_ERR,
|
|
|
|
UPDATE_REFS_QUIET_ON_ERR
|
|
|
|
};
|
|
|
|
|
2014-04-07 13:48:10 +00:00
|
|
|
/*
|
|
|
|
* Begin a reference transaction. The reference transaction must
|
2014-06-20 14:42:43 +00:00
|
|
|
* be freed by calling ref_transaction_free().
|
2014-04-07 13:48:10 +00:00
|
|
|
*/
|
2017-03-26 02:42:35 +00:00
|
|
|
struct ref_transaction *ref_store_transaction_begin(struct ref_store *refs,
|
|
|
|
struct strbuf *err);
|
2014-05-19 17:42:34 +00:00
|
|
|
struct ref_transaction *ref_transaction_begin(struct strbuf *err);
|
2014-04-07 13:48:10 +00:00
|
|
|
|
|
|
|
/*
|
2015-02-17 17:00:23 +00:00
|
|
|
* Reference transaction updates
|
|
|
|
*
|
|
|
|
* The following four functions add a reference check or update to a
|
|
|
|
* ref_transaction. They have some common similar parameters:
|
|
|
|
*
|
|
|
|
* transaction -- a pointer to an open ref_transaction, obtained
|
|
|
|
* from ref_transaction_begin().
|
|
|
|
*
|
|
|
|
* refname -- the name of the reference to be affected.
|
|
|
|
*
|
2017-05-22 14:17:32 +00:00
|
|
|
* new_sha1 -- the SHA-1 that should be set to be the new value of
|
|
|
|
* the reference. Some functions allow this parameter to be
|
|
|
|
* NULL, meaning that the reference is not changed, or
|
|
|
|
* null_sha1, meaning that the reference should be deleted. A
|
|
|
|
* copy of this value is made in the transaction.
|
|
|
|
*
|
|
|
|
* old_sha1 -- the SHA-1 value that the reference must have before
|
|
|
|
* the update. Some functions allow this parameter to be NULL,
|
|
|
|
* meaning that the old value of the reference is not checked,
|
|
|
|
* or null_sha1, meaning that the reference must not exist
|
|
|
|
* before the update. A copy of this value is made in the
|
|
|
|
* transaction.
|
|
|
|
*
|
2015-02-17 17:00:23 +00:00
|
|
|
* flags -- flags affecting the update, passed to
|
|
|
|
* update_ref_lock(). Can be REF_NODEREF, which means that
|
|
|
|
* symbolic references should not be followed.
|
|
|
|
*
|
|
|
|
* msg -- a message describing the change (for the reflog).
|
|
|
|
*
|
|
|
|
* err -- a strbuf for receiving a description of any error that
|
2016-06-10 19:05:26 +00:00
|
|
|
* might have occurred.
|
2015-02-17 17:00:23 +00:00
|
|
|
*
|
|
|
|
* The functions make internal copies of refname and msg, so the
|
|
|
|
* caller retains ownership of these parameters.
|
|
|
|
*
|
|
|
|
* The functions return 0 on success and non-zero on failure. A
|
|
|
|
* failure means that the transaction as a whole has failed and needs
|
|
|
|
* to be rolled back.
|
2014-04-07 13:48:10 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2015-02-17 17:00:21 +00:00
|
|
|
* Add a reference update to transaction. new_sha1 is the value that
|
|
|
|
* the reference should have after the update, or null_sha1 if it
|
|
|
|
* should be deleted. If new_sha1 is NULL, then the reference is not
|
|
|
|
* changed at all. old_sha1 is the value that the reference must have
|
|
|
|
* before the update, or null_sha1 if it must not have existed
|
|
|
|
* beforehand. The old value is checked after the lock is taken to
|
|
|
|
* prevent races. If the old value doesn't agree with old_sha1, the
|
|
|
|
* whole transaction fails. If old_sha1 is NULL, then the previous
|
|
|
|
* value is not checked.
|
|
|
|
*
|
2015-02-17 17:00:23 +00:00
|
|
|
* See the above comment "Reference transaction updates" for more
|
|
|
|
* information.
|
2014-04-07 13:48:10 +00:00
|
|
|
*/
|
2014-06-20 14:43:00 +00:00
|
|
|
int ref_transaction_update(struct ref_transaction *transaction,
|
|
|
|
const char *refname,
|
|
|
|
const unsigned char *new_sha1,
|
|
|
|
const unsigned char *old_sha1,
|
2015-02-17 17:00:15 +00:00
|
|
|
unsigned int flags, const char *msg,
|
2014-06-20 14:43:00 +00:00
|
|
|
struct strbuf *err);
|
2014-04-07 13:48:10 +00:00
|
|
|
|
|
|
|
/*
|
2015-02-17 17:00:23 +00:00
|
|
|
* Add a reference creation to transaction. new_sha1 is the value that
|
|
|
|
* the reference should have after the update; it must not be
|
|
|
|
* null_sha1. It is verified that the reference does not exist
|
2014-04-07 13:48:10 +00:00
|
|
|
* already.
|
2015-02-17 17:00:23 +00:00
|
|
|
*
|
|
|
|
* See the above comment "Reference transaction updates" for more
|
|
|
|
* information.
|
2014-04-07 13:48:10 +00:00
|
|
|
*/
|
2014-04-16 22:26:44 +00:00
|
|
|
int ref_transaction_create(struct ref_transaction *transaction,
|
|
|
|
const char *refname,
|
|
|
|
const unsigned char *new_sha1,
|
2015-02-17 17:00:13 +00:00
|
|
|
unsigned int flags, const char *msg,
|
2014-04-16 22:26:44 +00:00
|
|
|
struct strbuf *err);
|
2014-04-07 13:48:10 +00:00
|
|
|
|
|
|
|
/*
|
2015-02-17 17:00:23 +00:00
|
|
|
* Add a reference deletion to transaction. If old_sha1 is non-NULL,
|
|
|
|
* then it holds the value that the reference should have had before
|
|
|
|
* the update (which must not be null_sha1).
|
|
|
|
*
|
|
|
|
* See the above comment "Reference transaction updates" for more
|
|
|
|
* information.
|
2014-04-07 13:48:10 +00:00
|
|
|
*/
|
2014-04-16 22:27:45 +00:00
|
|
|
int ref_transaction_delete(struct ref_transaction *transaction,
|
|
|
|
const char *refname,
|
|
|
|
const unsigned char *old_sha1,
|
2015-02-17 17:00:16 +00:00
|
|
|
unsigned int flags, const char *msg,
|
2014-04-16 22:27:45 +00:00
|
|
|
struct strbuf *err);
|
2014-04-07 13:48:10 +00:00
|
|
|
|
2015-02-17 17:00:21 +00:00
|
|
|
/*
|
|
|
|
* Verify, within a transaction, that refname has the value old_sha1,
|
|
|
|
* or, if old_sha1 is null_sha1, then verify that the reference
|
2015-02-17 17:00:23 +00:00
|
|
|
* doesn't exist. old_sha1 must be non-NULL.
|
|
|
|
*
|
|
|
|
* See the above comment "Reference transaction updates" for more
|
|
|
|
* information.
|
2015-02-17 17:00:21 +00:00
|
|
|
*/
|
|
|
|
int ref_transaction_verify(struct ref_transaction *transaction,
|
|
|
|
const char *refname,
|
|
|
|
const unsigned char *old_sha1,
|
|
|
|
unsigned int flags,
|
|
|
|
struct strbuf *err);
|
|
|
|
|
2014-05-16 21:14:38 +00:00
|
|
|
/* Naming conflict (for example, the ref names A and A/B conflict). */
|
|
|
|
#define TRANSACTION_NAME_CONFLICT -1
|
|
|
|
/* All other errors. */
|
|
|
|
#define TRANSACTION_GENERIC_ERROR -2
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
|
|
|
|
/*
|
2017-06-25 10:20:41 +00:00
|
|
|
* Perform the preparatory stages of committing `transaction`. Acquire
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
* any needed locks, check preconditions, etc.; basically, do as much
|
|
|
|
* as possible to ensure that the transaction will be able to go
|
|
|
|
* through, stopping just short of making any irrevocable or
|
|
|
|
* user-visible changes. The updates that this function prepares can
|
|
|
|
* be finished up by calling `ref_transaction_commit()` or rolled back
|
|
|
|
* by calling `ref_transaction_abort()`.
|
|
|
|
*
|
|
|
|
* On success, return 0 and leave the transaction in "prepared" state.
|
|
|
|
* On failure, abort the transaction, write an error message to `err`,
|
|
|
|
* and return one of the `TRANSACTION_*` constants.
|
|
|
|
*
|
2017-06-25 10:20:41 +00:00
|
|
|
* Callers who don't need such fine-grained control over committing
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
* reference transactions should just call `ref_transaction_commit()`.
|
|
|
|
*/
|
|
|
|
int ref_transaction_prepare(struct ref_transaction *transaction,
|
|
|
|
struct strbuf *err);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Commit all of the changes that have been queued in transaction, as
|
|
|
|
* atomically as possible. On success, return 0 and leave the
|
|
|
|
* transaction in "closed" state. On failure, roll back the
|
|
|
|
* transaction, write an error message to `err`, and return one of the
|
|
|
|
* `TRANSACTION_*` constants
|
|
|
|
*/
|
2014-04-07 13:48:10 +00:00
|
|
|
int ref_transaction_commit(struct ref_transaction *transaction,
|
2014-04-30 19:22:42 +00:00
|
|
|
struct strbuf *err);
|
2014-04-07 13:48:10 +00:00
|
|
|
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
/*
|
|
|
|
* Abort `transaction`, which has been begun and possibly prepared,
|
|
|
|
* but not yet committed.
|
|
|
|
*/
|
|
|
|
int ref_transaction_abort(struct ref_transaction *transaction,
|
|
|
|
struct strbuf *err);
|
|
|
|
|
2015-06-22 14:03:01 +00:00
|
|
|
/*
|
|
|
|
* Like ref_transaction_commit(), but optimized for creating
|
|
|
|
* references when originally initializing a repository (e.g., by "git
|
|
|
|
* clone"). It writes the new references directly to packed-refs
|
|
|
|
* without locking the individual references.
|
|
|
|
*
|
|
|
|
* It is a bug to call this function when there might be other
|
|
|
|
* processes accessing the repository or if there are existing
|
|
|
|
* references that might conflict with the ones being created. All
|
|
|
|
* old_sha1 values must either be absent or NULL_SHA1.
|
|
|
|
*/
|
|
|
|
int initial_ref_transaction_commit(struct ref_transaction *transaction,
|
|
|
|
struct strbuf *err);
|
|
|
|
|
2014-06-20 14:42:42 +00:00
|
|
|
/*
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
* Free `*transaction` and all associated data.
|
2014-06-20 14:42:42 +00:00
|
|
|
*/
|
|
|
|
void ref_transaction_free(struct ref_transaction *transaction);
|
|
|
|
|
2015-02-17 17:00:22 +00:00
|
|
|
/**
|
|
|
|
* Lock, update, and unlock a single reference. This function
|
|
|
|
* basically does a transaction containing a single call to
|
|
|
|
* ref_transaction_update(). The parameters to this function have the
|
|
|
|
* same meaning as the corresponding parameters to
|
|
|
|
* ref_transaction_update(). Handle errors as requested by the `onerr`
|
|
|
|
* argument.
|
|
|
|
*/
|
2017-03-26 02:42:35 +00:00
|
|
|
int refs_update_ref(struct ref_store *refs, const char *msg, const char *refname,
|
|
|
|
const unsigned char *new_sha1, const unsigned char *old_sha1,
|
|
|
|
unsigned int flags, enum action_on_err onerr);
|
2015-02-17 17:00:22 +00:00
|
|
|
int update_ref(const char *msg, const char *refname,
|
|
|
|
const unsigned char *new_sha1, const unsigned char *old_sha1,
|
2015-02-17 17:00:13 +00:00
|
|
|
unsigned int flags, enum action_on_err onerr);
|
2016-09-05 20:08:08 +00:00
|
|
|
int update_ref_oid(const char *msg, const char *refname,
|
|
|
|
const struct object_id *new_oid, const struct object_id *old_oid,
|
|
|
|
unsigned int flags, enum action_on_err onerr);
|
2007-09-05 01:38:24 +00:00
|
|
|
|
2016-03-31 04:19:22 +00:00
|
|
|
int parse_hide_refs_config(const char *var, const char *value, const char *);
|
2015-06-22 14:03:05 +00:00
|
|
|
|
2015-11-03 07:58:16 +00:00
|
|
|
/*
|
|
|
|
* Check whether a ref is hidden. If no namespace is set, both the first and
|
|
|
|
* the second parameter point to the full ref name. If a namespace is set and
|
|
|
|
* the ref is inside that namespace, the first parameter is a pointer to the
|
|
|
|
* name of the ref with the namespace prefix removed. If a namespace is set and
|
|
|
|
* the ref is outside that namespace, the first parameter is NULL. The second
|
|
|
|
* parameter always points to the full ref name.
|
|
|
|
*/
|
2016-03-31 04:19:22 +00:00
|
|
|
int ref_is_hidden(const char *, const char *);
|
upload/receive-pack: allow hiding ref hierarchies
A repository may have refs that are only used for its internal
bookkeeping purposes that should not be exposed to the others that
come over the network.
Teach upload-pack to omit some refs from its initial advertisement
by paying attention to the uploadpack.hiderefs multi-valued
configuration variable. Do the same to receive-pack via the
receive.hiderefs variable. As a convenient short-hand, allow using
transfer.hiderefs to set the value to both of these variables.
Any ref that is under the hierarchies listed on the value of these
variable is excluded from responses to requests made by "ls-remote",
"fetch", etc. (for upload-pack) and "push" (for receive-pack).
Because these hidden refs do not count as OUR_REF, an attempt to
fetch objects at the tip of them will be rejected, and because these
refs do not get advertised, "git push :" will not see local branches
that have the same name as them as "matching" ones to be sent.
An attempt to update/delete these hidden refs with an explicit
refspec, e.g. "git push origin :refs/hidden/22", is rejected. This
is not a new restriction. To the pusher, it would appear that there
is no such ref, so its push request will conclude with "Now that I
sent you all the data, it is time for you to update the refs. I saw
that the ref did not exist when I started pushing, and I want the
result to point at this commit". The receiving end will apply the
compare-and-swap rule to this request and rejects the push with
"Well, your update request conflicts with somebody else; I see there
is such a ref.", which is the right thing to do. Otherwise a push to
a hidden ref will always be "the last one wins", which is not a good
default.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-19 00:08:30 +00:00
|
|
|
|
2015-07-31 06:06:18 +00:00
|
|
|
enum ref_type {
|
|
|
|
REF_TYPE_PER_WORKTREE,
|
|
|
|
REF_TYPE_PSEUDOREF,
|
|
|
|
REF_TYPE_NORMAL,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum ref_type ref_type(const char *refname);
|
|
|
|
|
2014-12-12 08:56:59 +00:00
|
|
|
enum expire_reflog_flags {
|
|
|
|
EXPIRE_REFLOGS_DRY_RUN = 1 << 0,
|
|
|
|
EXPIRE_REFLOGS_UPDATE_REF = 1 << 1,
|
|
|
|
EXPIRE_REFLOGS_VERBOSE = 1 << 2,
|
|
|
|
EXPIRE_REFLOGS_REWRITE = 1 << 3
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The following interface is used for reflog expiration. The caller
|
|
|
|
* calls reflog_expire(), supplying it with three callback functions,
|
|
|
|
* of the following types. The callback functions define the
|
|
|
|
* expiration policy that is desired.
|
|
|
|
*
|
|
|
|
* reflog_expiry_prepare_fn -- Called once after the reference is
|
|
|
|
* locked.
|
|
|
|
*
|
|
|
|
* reflog_expiry_should_prune_fn -- Called once for each entry in the
|
|
|
|
* existing reflog. It should return true iff that entry should be
|
|
|
|
* pruned.
|
|
|
|
*
|
|
|
|
* reflog_expiry_cleanup_fn -- Called once before the reference is
|
|
|
|
* unlocked again.
|
|
|
|
*/
|
|
|
|
typedef void reflog_expiry_prepare_fn(const char *refname,
|
2017-05-06 22:10:00 +00:00
|
|
|
const struct object_id *oid,
|
2014-12-12 08:56:59 +00:00
|
|
|
void *cb_data);
|
2017-05-06 22:10:00 +00:00
|
|
|
typedef int reflog_expiry_should_prune_fn(struct object_id *ooid,
|
|
|
|
struct object_id *noid,
|
2014-12-12 08:56:59 +00:00
|
|
|
const char *email,
|
2017-04-26 19:29:31 +00:00
|
|
|
timestamp_t timestamp, int tz,
|
2014-12-12 08:56:59 +00:00
|
|
|
const char *message, void *cb_data);
|
|
|
|
typedef void reflog_expiry_cleanup_fn(void *cb_data);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Expire reflog entries for the specified reference. sha1 is the old
|
|
|
|
* value of the reference. flags is a combination of the constants in
|
|
|
|
* enum expire_reflog_flags. The three function pointers are described
|
|
|
|
* above. On success, return zero.
|
|
|
|
*/
|
2017-03-26 02:42:34 +00:00
|
|
|
int refs_reflog_expire(struct ref_store *refs,
|
|
|
|
const char *refname,
|
|
|
|
const unsigned char *sha1,
|
|
|
|
unsigned int flags,
|
|
|
|
reflog_expiry_prepare_fn prepare_fn,
|
|
|
|
reflog_expiry_should_prune_fn should_prune_fn,
|
|
|
|
reflog_expiry_cleanup_fn cleanup_fn,
|
|
|
|
void *policy_cb_data);
|
2016-03-31 04:19:22 +00:00
|
|
|
int reflog_expire(const char *refname, const unsigned char *sha1,
|
|
|
|
unsigned int flags,
|
|
|
|
reflog_expiry_prepare_fn prepare_fn,
|
|
|
|
reflog_expiry_should_prune_fn should_prune_fn,
|
|
|
|
reflog_expiry_cleanup_fn cleanup_fn,
|
|
|
|
void *policy_cb_data);
|
2014-12-12 08:56:59 +00:00
|
|
|
|
2016-09-04 16:08:10 +00:00
|
|
|
int ref_storage_backend_exists(const char *name);
|
|
|
|
|
2017-03-26 02:42:29 +00:00
|
|
|
struct ref_store *get_main_ref_store(void);
|
2017-03-26 02:42:33 +00:00
|
|
|
/*
|
|
|
|
* Return the ref_store instance for the specified submodule. For the
|
|
|
|
* main repository, use submodule==NULL; such a call cannot fail. For
|
|
|
|
* a submodule, the submodule must exist and be a nonbare repository,
|
|
|
|
* otherwise return NULL. If the requested reference store has not yet
|
|
|
|
* been initialized, initialize it first.
|
|
|
|
*
|
|
|
|
* For backwards compatibility, submodule=="" is treated the same as
|
|
|
|
* submodule==NULL.
|
|
|
|
*/
|
|
|
|
struct ref_store *get_submodule_ref_store(const char *submodule);
|
2017-04-24 10:01:22 +00:00
|
|
|
struct ref_store *get_worktree_ref_store(const struct worktree *wt);
|
2017-03-26 02:42:29 +00:00
|
|
|
|
2005-06-06 20:31:29 +00:00
|
|
|
#endif /* REFS_H */
|