2005-06-06 20:31:29 +00:00
|
|
|
#ifndef REFS_H
|
|
|
|
#define REFS_H
|
|
|
|
|
2006-05-17 09:55:02 +00:00
|
|
|
struct ref_lock {
|
Enable the packed refs file format
This actually "turns on" the packed ref file format, now that the
infrastructure to do so sanely exists (ie notably the change to make the
reference reading logic take refnames rather than pathnames to the loose
objects that no longer necessarily even exist).
In particular, when the ref lookup hits a refname that has no loose file
associated with it, it falls back on the packed-ref information. Also, the
ref-locking code, while still using a loose file for the locking itself
(and _creating_ a loose file for the new ref) no longer requires that the
old ref be in such an unpacked state.
Finally, this does a minimal hack to git-checkout.sh to rather than check
the ref-file directly, do a "git-rev-parse" on the "heads/$refname".
That's not really wonderful - we should rather really have a special
routine to verify the names as proper branch head names, but it is a
workable solution for now.
With this, I can literally do something like
git pack-refs
find .git/refs -type f -print0 | xargs -0 rm -f --
and the end result is a largely working repository (ie I've done two
commits - which creates _one_ unpacked ref file - done things like run
"gitk" and "git log" etc, and it all looks ok).
There are probably things missing, but I'm hoping that the missing things
are now of the "small and obvious" kind, and that somebody else might want
to start looking at this too. Hint hint ;)
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-14 17:14:47 +00:00
|
|
|
char *ref_name;
|
2007-01-26 22:26:06 +00:00
|
|
|
char *orig_ref_name;
|
2006-06-06 20:54:14 +00:00
|
|
|
struct lock_file *lk;
|
2006-05-17 09:55:02 +00:00
|
|
|
unsigned char old_sha1[20];
|
|
|
|
int lock_fd;
|
2006-05-19 07:29:05 +00:00
|
|
|
int force_write;
|
2006-05-17 09:55:02 +00:00
|
|
|
};
|
|
|
|
|
2011-10-19 20:45:50 +00:00
|
|
|
#define REF_ISSYMREF 0x01
|
|
|
|
#define REF_ISPACKED 0x02
|
|
|
|
#define REF_ISBROKEN 0x04
|
2006-11-22 07:36:35 +00:00
|
|
|
|
2005-07-03 03:23:36 +00:00
|
|
|
/*
|
|
|
|
* Calls the specified function for each ref file until it returns nonzero,
|
|
|
|
* and returns the value
|
|
|
|
*/
|
2006-09-21 05:02:01 +00:00
|
|
|
typedef int each_ref_fn(const char *refname, const unsigned char *sha1, int flags, void *cb_data);
|
2006-09-21 04:47:42 +00:00
|
|
|
extern int head_ref(each_ref_fn, void *);
|
|
|
|
extern int for_each_ref(each_ref_fn, void *);
|
2009-03-30 03:07:15 +00:00
|
|
|
extern int for_each_ref_in(const char *, each_ref_fn, void *);
|
2006-09-21 04:47:42 +00:00
|
|
|
extern int for_each_tag_ref(each_ref_fn, void *);
|
|
|
|
extern int for_each_branch_ref(each_ref_fn, void *);
|
|
|
|
extern int for_each_remote_ref(each_ref_fn, void *);
|
2009-01-23 09:06:38 +00:00
|
|
|
extern int for_each_replace_ref(each_ref_fn, void *);
|
2010-01-20 09:48:25 +00:00
|
|
|
extern int for_each_glob_ref(each_ref_fn, const char *pattern, void *);
|
2010-01-20 09:48:26 +00:00
|
|
|
extern int for_each_glob_ref_in(each_ref_fn, const char *pattern, const char* prefix, void *);
|
2005-07-03 03:23:36 +00:00
|
|
|
|
2010-07-07 13:39:12 +00:00
|
|
|
extern int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data);
|
|
|
|
extern int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data);
|
|
|
|
extern int for_each_ref_in_submodule(const char *submodule, const char *prefix,
|
|
|
|
each_ref_fn fn, void *cb_data);
|
|
|
|
extern int for_each_tag_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data);
|
|
|
|
extern int for_each_branch_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data);
|
|
|
|
extern int for_each_remote_ref_submodule(const char *submodule, 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
|
|
|
extern int head_ref_namespaced(each_ref_fn fn, void *cb_data);
|
|
|
|
extern int for_each_namespaced_ref(each_ref_fn fn, void *cb_data);
|
|
|
|
|
2010-03-12 17:04:26 +00:00
|
|
|
static inline const char *has_glob_specials(const char *pattern)
|
|
|
|
{
|
|
|
|
return strpbrk(pattern, "?*[");
|
|
|
|
}
|
|
|
|
|
2009-02-09 07:27:10 +00:00
|
|
|
/* can be used to learn about broken ref and symref */
|
|
|
|
extern int for_each_rawref(each_ref_fn, void *);
|
|
|
|
|
2009-11-10 05:03:32 +00:00
|
|
|
extern void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname);
|
2009-02-09 07:27:10 +00:00
|
|
|
|
2008-04-27 17:39:24 +00:00
|
|
|
/*
|
|
|
|
* Extra refs will be listed by for_each_ref() before any actual refs
|
|
|
|
* for the duration of this process or until clear_extra_refs() is
|
|
|
|
* called. Only extra refs added before for_each_ref() is called will
|
|
|
|
* be listed on a given call of for_each_ref().
|
|
|
|
*/
|
|
|
|
extern void add_extra_ref(const char *refname, const unsigned char *sha1, int flags);
|
|
|
|
extern void clear_extra_refs(void);
|
2011-06-06 05:17:04 +00:00
|
|
|
extern int ref_exists(char *);
|
2008-04-27 17:39:24 +00:00
|
|
|
|
2006-11-19 21:22:44 +00:00
|
|
|
extern int peel_ref(const char *, unsigned char *);
|
|
|
|
|
2006-05-17 09:55:02 +00:00
|
|
|
/** Locks a "refs/" ref returning the lock on success and NULL on failure. **/
|
2006-09-27 08:09:18 +00:00
|
|
|
extern struct ref_lock *lock_ref_sha1(const char *ref, const unsigned char *old_sha1);
|
2006-05-17 09:55:02 +00:00
|
|
|
|
|
|
|
/** Locks any ref (for 'HEAD' type refs). */
|
2007-05-09 10:33:20 +00:00
|
|
|
#define REF_NODEREF 0x01
|
|
|
|
extern struct ref_lock *lock_any_ref_for_update(const char *ref, const unsigned char *old_sha1, int flags);
|
2005-06-06 20:31:29 +00:00
|
|
|
|
2008-02-22 18:57:30 +00:00
|
|
|
/** Close the file descriptor owned by a lock and return the status */
|
|
|
|
extern int close_ref(struct ref_lock *lock);
|
|
|
|
|
|
|
|
/** Close and commit the ref locked by the lock */
|
|
|
|
extern int commit_ref(struct ref_lock *lock);
|
|
|
|
|
2006-05-17 09:55:02 +00:00
|
|
|
/** Release any lock taken but not written. **/
|
2006-06-06 21:04:17 +00:00
|
|
|
extern void unlock_ref(struct ref_lock *lock);
|
2005-06-06 20:31:29 +00:00
|
|
|
|
2006-05-17 09:55:02 +00:00
|
|
|
/** Writes sha1 into the ref specified by the lock. **/
|
|
|
|
extern int write_ref_sha1(struct ref_lock *lock, const unsigned char *sha1, const char *msg);
|
2005-06-06 20:31:29 +00:00
|
|
|
|
2010-05-22 00:28:36 +00:00
|
|
|
/** Setup reflog before using. **/
|
2010-06-10 12:54:03 +00:00
|
|
|
int log_ref_setup(const char *ref_name, char *logfile, int bufsize);
|
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. **/
|
2007-01-19 09:19:05 +00:00
|
|
|
extern int read_ref_at(const char *ref, unsigned long at_time, int cnt, unsigned char *sha1, char **msg, unsigned long *cutoff_time, int *cutoff_tz, int *cutoff_cnt);
|
2006-05-17 09:56:09 +00:00
|
|
|
|
2006-12-18 09:18:16 +00:00
|
|
|
/* iterate over reflog entries */
|
2007-01-08 00:59:54 +00:00
|
|
|
typedef int each_reflog_ent_fn(unsigned char *osha1, unsigned char *nsha1, const char *, unsigned long, int, const char *, void *);
|
|
|
|
int for_each_reflog_ent(const char *ref, each_reflog_ent_fn fn, void *cb_data);
|
2009-01-20 06:18:29 +00:00
|
|
|
int for_each_recent_reflog_ent(const char *ref, each_reflog_ent_fn fn, long, 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,
|
|
|
|
* and returns the value
|
|
|
|
*/
|
|
|
|
extern int for_each_reflog(each_ref_fn, void *);
|
|
|
|
|
2011-09-15 21:10:25 +00:00
|
|
|
#define REFNAME_ALLOW_ONELEVEL 1
|
|
|
|
#define REFNAME_REFSPEC_PATTERN 2
|
2011-09-15 21:10:43 +00:00
|
|
|
#define REFNAME_DOT_COMPONENT 4
|
2011-09-15 21:10:25 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Return 0 iff ref 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
|
|
|
|
* reference names. If REFNAME_REFSPEC_PATTERN is set in flags, then
|
|
|
|
* allow a "*" wildcard character in place of one of the name
|
2011-09-15 21:10:43 +00:00
|
|
|
* components. No leading or repeated slashes are accepted. If
|
|
|
|
* REFNAME_DOT_COMPONENT is set in flags, then allow refname
|
|
|
|
* components to start with "." (but not a whole component equal to
|
|
|
|
* "." or "..").
|
2011-09-15 21:10:25 +00:00
|
|
|
*/
|
|
|
|
extern int check_refname_format(const char *ref, int flags);
|
2005-06-06 20:31:29 +00:00
|
|
|
|
2009-05-13 21:22:04 +00:00
|
|
|
extern const char *prettify_refname(const char *refname);
|
2009-04-13 10:25:46 +00:00
|
|
|
extern char *shorten_unambiguous_ref(const char *ref, int strict);
|
2009-03-09 01:06:05 +00:00
|
|
|
|
2006-11-28 14:47:40 +00:00
|
|
|
/** rename ref, return 0 on success **/
|
2006-11-30 02:16:56 +00:00
|
|
|
extern int rename_ref(const char *oldref, const char *newref, const char *logmsg);
|
2006-11-28 14:47:40 +00:00
|
|
|
|
2007-04-10 04:14:26 +00:00
|
|
|
/** resolve ref in nested "gitlink" repository */
|
|
|
|
extern int resolve_gitlink_ref(const char *name, const char *refname, unsigned char *result);
|
|
|
|
|
2007-09-05 01:38:24 +00:00
|
|
|
/** lock a ref and then write its file */
|
|
|
|
enum action_on_err { MSG_ON_ERR, DIE_ON_ERR, QUIET_ON_ERR };
|
|
|
|
int update_ref(const char *action, const char *refname,
|
|
|
|
const unsigned char *sha1, const unsigned char *oldval,
|
|
|
|
int flags, enum action_on_err onerr);
|
|
|
|
|
2005-06-06 20:31:29 +00:00
|
|
|
#endif /* REFS_H */
|