|
|
|
|
#ifndef REFS_H
|
|
|
|
|
#define REFS_H
|
|
|
|
|
|
|
|
|
|
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>
19 years ago
|
|
|
char *ref_name;
|
|
|
|
|
char *orig_ref_name;
|
|
|
|
|
struct lock_file *lk;
|
|
|
|
|
unsigned char old_sha1[20];
|
|
|
|
|
int lock_fd;
|
|
|
|
|
int force_write;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define REF_ISSYMREF 01
|
|
|
|
|
#define REF_ISPACKED 02
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Calls the specified function for each ref file until it returns nonzero,
|
|
|
|
|
* and returns the value
|
|
|
|
|
*/
|
|
|
|
|
typedef int each_ref_fn(const char *refname, const unsigned char *sha1, int flags, void *cb_data);
|
|
|
|
|
extern int head_ref(each_ref_fn, void *);
|
|
|
|
|
extern int for_each_ref(each_ref_fn, void *);
|
|
|
|
|
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 *);
|
|
|
|
|
|
|
|
|
|
/* can be used to learn about broken ref and symref */
|
|
|
|
|
extern int for_each_rawref(each_ref_fn, void *);
|
|
|
|
|
|
|
|
|
|
extern void warn_dangling_symref(const char *msg_fmt, const char *refname);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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);
|
|
|
|
|
|
|
|
|
|
extern int peel_ref(const char *, unsigned char *);
|
|
|
|
|
|
|
|
|
|
/** Locks a "refs/" ref returning the lock on success and NULL on failure. **/
|
|
|
|
|
extern struct ref_lock *lock_ref_sha1(const char *ref, const unsigned char *old_sha1);
|
|
|
|
|
|
|
|
|
|
/** Locks any ref (for 'HEAD' type refs). */
|
|
|
|
|
#define REF_NODEREF 0x01
|
|
|
|
|
extern struct ref_lock *lock_any_ref_for_update(const char *ref, const unsigned char *old_sha1, int flags);
|
|
|
|
|
|
|
|
|
|
/** 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);
|
|
|
|
|
|
|
|
|
|
/** Release any lock taken but not written. **/
|
|
|
|
|
extern void unlock_ref(struct ref_lock *lock);
|
|
|
|
|
|
|
|
|
|
/** 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);
|
|
|
|
|
|
|
|
|
|
/** Reads log for the value of ref during at_time. **/
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
/* iterate over reflog entries */
|
|
|
|
|
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);
|
|
|
|
|
int for_each_recent_reflog_ent(const char *ref, each_reflog_ent_fn fn, long, void *cb_data);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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 *);
|
|
|
|
|
|
|
|
|
|
#define CHECK_REF_FORMAT_OK 0
|
|
|
|
|
#define CHECK_REF_FORMAT_ERROR (-1)
|
|
|
|
|
#define CHECK_REF_FORMAT_ONELEVEL (-2)
|
|
|
|
|
#define CHECK_REF_FORMAT_WILDCARD (-3)
|
|
|
|
|
extern int check_ref_format(const char *target);
|
|
|
|
|
|
|
|
|
|
extern const char *prettify_ref(const struct ref *ref);
|
|
|
|
|
|
|
|
|
|
/** rename ref, return 0 on success **/
|
|
|
|
|
extern int rename_ref(const char *oldref, const char *newref, const char *logmsg);
|
|
|
|
|
|
|
|
|
|
/** resolve ref in nested "gitlink" repository */
|
|
|
|
|
extern int resolve_gitlink_ref(const char *name, const char *refname, unsigned char *result);
|
|
|
|
|
|
|
|
|
|
/** 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);
|
|
|
|
|
|
|
|
|
|
#endif /* REFS_H */
|
