Daniel Barkalow | 95fc751 | 2005-06-06 16:31:29 -0400 | [diff] [blame] | 1 | #ifndef REFS_H |
| 2 | #define REFS_H |
| 3 | |
Ronnie Sahlberg | b416af5 | 2014-04-16 15:26:44 -0700 | [diff] [blame] | 4 | /* |
| 5 | * A ref_transaction represents a collection of ref updates |
| 6 | * that should succeed or fail together. |
| 7 | * |
| 8 | * Calling sequence |
| 9 | * ---------------- |
| 10 | * - Allocate and initialize a `struct ref_transaction` by calling |
| 11 | * `ref_transaction_begin()`. |
| 12 | * |
| 13 | * - List intended ref updates by calling functions like |
| 14 | * `ref_transaction_update()` and `ref_transaction_create()`. |
| 15 | * |
| 16 | * - Call `ref_transaction_commit()` to execute the transaction. |
| 17 | * If this succeeds, the ref updates will have taken place and |
| 18 | * the transaction cannot be rolled back. |
| 19 | * |
| 20 | * - At any time call `ref_transaction_free()` to discard the |
| 21 | * transaction and free associated resources. In particular, |
| 22 | * this rolls back the transaction if it has not been |
| 23 | * successfully committed. |
| 24 | * |
| 25 | * Error handling |
| 26 | * -------------- |
| 27 | * |
| 28 | * On error, transaction functions append a message about what |
| 29 | * went wrong to the 'err' argument. The message mentions what |
| 30 | * ref was being updated (if any) when the error occurred so it |
| 31 | * can be passed to 'die' or 'error' as-is. |
| 32 | * |
| 33 | * The message is appended to err without first clearing err. |
| 34 | * err will not be '\n' terminated. |
| 35 | */ |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 36 | struct ref_transaction; |
| 37 | |
Michael Haggerty | 89df9c8 | 2013-04-14 14:54:16 +0200 | [diff] [blame] | 38 | /* |
| 39 | * Bit values set in the flags argument passed to each_ref_fn(): |
| 40 | */ |
| 41 | |
| 42 | /* Reference is a symbolic reference. */ |
Junio C Hamano | 98ac34b | 2011-10-19 13:45:50 -0700 | [diff] [blame] | 43 | #define REF_ISSYMREF 0x01 |
Michael Haggerty | 89df9c8 | 2013-04-14 14:54:16 +0200 | [diff] [blame] | 44 | |
| 45 | /* Reference is a packed reference. */ |
Junio C Hamano | 98ac34b | 2011-10-19 13:45:50 -0700 | [diff] [blame] | 46 | #define REF_ISPACKED 0x02 |
Michael Haggerty | 89df9c8 | 2013-04-14 14:54:16 +0200 | [diff] [blame] | 47 | |
| 48 | /* |
| 49 | * Reference cannot be resolved to an object name: dangling symbolic |
Ronnie Sahlberg | d0f810f | 2014-09-03 11:45:43 -0700 | [diff] [blame] | 50 | * reference (directly or indirectly), corrupt reference file, |
| 51 | * reference exists but name is bad, or symbolic reference refers to |
| 52 | * ill-formatted reference name. |
Michael Haggerty | 89df9c8 | 2013-04-14 14:54:16 +0200 | [diff] [blame] | 53 | */ |
Junio C Hamano | 98ac34b | 2011-10-19 13:45:50 -0700 | [diff] [blame] | 54 | #define REF_ISBROKEN 0x04 |
Junio C Hamano | f4204ab | 2006-11-21 23:36:35 -0800 | [diff] [blame] | 55 | |
Linus Torvalds | 8a65ff7 | 2005-07-02 20:23:36 -0700 | [diff] [blame] | 56 | /* |
Ronnie Sahlberg | d0f810f | 2014-09-03 11:45:43 -0700 | [diff] [blame] | 57 | * Reference name is not well formed. |
| 58 | * |
| 59 | * See git-check-ref-format(1) for the definition of well formed ref names. |
| 60 | */ |
| 61 | #define REF_BAD_NAME 0x08 |
| 62 | |
| 63 | /* |
Michael Haggerty | 4f78c24 | 2013-05-25 11:08:24 +0200 | [diff] [blame] | 64 | * The signature for the callback function for the for_each_*() |
| 65 | * functions below. The memory pointed to by the refname and sha1 |
| 66 | * arguments is only guaranteed to be valid for the duration of a |
| 67 | * single callback invocation. |
Linus Torvalds | 8a65ff7 | 2005-07-02 20:23:36 -0700 | [diff] [blame] | 68 | */ |
Michael Haggerty | 4f78c24 | 2013-05-25 11:08:24 +0200 | [diff] [blame] | 69 | typedef int each_ref_fn(const char *refname, |
Michael Haggerty | 2b2a5be | 2015-05-25 18:38:28 +0000 | [diff] [blame] | 70 | const struct object_id *oid, int flags, void *cb_data); |
| 71 | |
Michael Haggerty | 4f78c24 | 2013-05-25 11:08:24 +0200 | [diff] [blame] | 72 | /* |
| 73 | * The following functions invoke the specified callback function for |
| 74 | * each reference indicated. If the function ever returns a nonzero |
| 75 | * value, stop the iteration and return that value. Please note that |
| 76 | * it is not safe to modify references while an iteration is in |
| 77 | * progress, unless the same callback function invocation that |
| 78 | * modifies the reference also returns a nonzero value to immediately |
| 79 | * stop the iteration. |
| 80 | */ |
Junio C Hamano | cb5d709 | 2006-09-20 21:47:42 -0700 | [diff] [blame] | 81 | extern int head_ref(each_ref_fn, void *); |
| 82 | extern int for_each_ref(each_ref_fn, void *); |
Christian Couder | 2a8177b | 2009-03-30 05:07:15 +0200 | [diff] [blame] | 83 | extern int for_each_ref_in(const char *, each_ref_fn, void *); |
Junio C Hamano | cb5d709 | 2006-09-20 21:47:42 -0700 | [diff] [blame] | 84 | extern int for_each_tag_ref(each_ref_fn, void *); |
| 85 | extern int for_each_branch_ref(each_ref_fn, void *); |
| 86 | extern int for_each_remote_ref(each_ref_fn, void *); |
Christian Couder | 2926870 | 2009-01-23 10:06:38 +0100 | [diff] [blame] | 87 | extern int for_each_replace_ref(each_ref_fn, void *); |
Ilari Liusvaara | d08bae7 | 2010-01-20 11:48:25 +0200 | [diff] [blame] | 88 | extern int for_each_glob_ref(each_ref_fn, const char *pattern, void *); |
Ilari Liusvaara | b09fe97 | 2010-01-20 11:48:26 +0200 | [diff] [blame] | 89 | extern int for_each_glob_ref_in(each_ref_fn, const char *pattern, const char* prefix, void *); |
Linus Torvalds | 8a65ff7 | 2005-07-02 20:23:36 -0700 | [diff] [blame] | 90 | |
Heiko Voigt | 9ef6aeb | 2010-07-07 15:39:12 +0200 | [diff] [blame] | 91 | extern int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data); |
| 92 | extern int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data); |
| 93 | extern int for_each_ref_in_submodule(const char *submodule, const char *prefix, |
| 94 | each_ref_fn fn, void *cb_data); |
| 95 | extern int for_each_tag_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data); |
| 96 | extern int for_each_branch_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data); |
| 97 | extern int for_each_remote_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data); |
| 98 | |
Josh Triplett | a1bea2c | 2011-07-05 10:54:44 -0700 | [diff] [blame] | 99 | extern int head_ref_namespaced(each_ref_fn fn, void *cb_data); |
| 100 | extern int for_each_namespaced_ref(each_ref_fn fn, void *cb_data); |
| 101 | |
Thomas Rast | 894a9d3 | 2010-03-12 18:04:26 +0100 | [diff] [blame] | 102 | static inline const char *has_glob_specials(const char *pattern) |
| 103 | { |
| 104 | return strpbrk(pattern, "?*["); |
| 105 | } |
| 106 | |
Junio C Hamano | f8948e2 | 2009-02-08 23:27:10 -0800 | [diff] [blame] | 107 | /* can be used to learn about broken ref and symref */ |
| 108 | extern int for_each_rawref(each_ref_fn, void *); |
| 109 | |
Jay Soffian | 3cf6134 | 2009-11-10 00:03:32 -0500 | [diff] [blame] | 110 | extern void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname); |
David Aguilar | 24d36f1 | 2014-08-31 13:11:31 -0700 | [diff] [blame] | 111 | extern void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames); |
Junio C Hamano | f8948e2 | 2009-02-08 23:27:10 -0800 | [diff] [blame] | 112 | |
Daniel Barkalow | e142a3c | 2008-04-27 13:39:24 -0400 | [diff] [blame] | 113 | /* |
Michael Haggerty | 9f69d29 | 2013-06-20 10:37:46 +0200 | [diff] [blame] | 114 | * Lock the packed-refs file for writing. Flags is passed to |
| 115 | * hold_lock_file_for_update(). Return 0 on success. |
Ronnie Sahlberg | 447ff1b | 2014-06-20 07:42:48 -0700 | [diff] [blame] | 116 | * Errno is set to something meaningful on error. |
Michael Haggerty | 9f69d29 | 2013-06-20 10:37:46 +0200 | [diff] [blame] | 117 | */ |
| 118 | extern int lock_packed_refs(int flags); |
| 119 | |
| 120 | /* |
| 121 | * Add a reference to the in-memory packed reference cache. This may |
| 122 | * only be called while the packed-refs file is locked (see |
| 123 | * lock_packed_refs()). To actually write the packed-refs file, call |
| 124 | * commit_packed_refs(). |
Michael Haggerty | 30249ee | 2012-01-17 06:50:33 +0100 | [diff] [blame] | 125 | */ |
| 126 | extern void add_packed_ref(const char *refname, const unsigned char *sha1); |
| 127 | |
Michael Haggerty | 32d462c | 2013-04-22 21:52:32 +0200 | [diff] [blame] | 128 | /* |
Michael Haggerty | 9f69d29 | 2013-06-20 10:37:46 +0200 | [diff] [blame] | 129 | * Write the current version of the packed refs cache from memory to |
| 130 | * disk. The packed-refs file must already be locked for writing (see |
| 131 | * lock_packed_refs()). Return zero on success. |
Ronnie Sahlberg | d3f6655 | 2014-06-20 07:42:53 -0700 | [diff] [blame] | 132 | * Sets errno to something meaningful on error. |
Michael Haggerty | 9f69d29 | 2013-06-20 10:37:46 +0200 | [diff] [blame] | 133 | */ |
| 134 | extern int commit_packed_refs(void); |
| 135 | |
| 136 | /* |
| 137 | * Rollback the lockfile for the packed-refs file, and discard the |
| 138 | * in-memory packed reference cache. (The packed-refs file will be |
| 139 | * read anew if it is needed again after this function is called.) |
| 140 | */ |
| 141 | extern void rollback_packed_refs(void); |
| 142 | |
| 143 | /* |
Michael Haggerty | 32d462c | 2013-04-22 21:52:32 +0200 | [diff] [blame] | 144 | * Flags for controlling behaviour of pack_refs() |
| 145 | * PACK_REFS_PRUNE: Prune loose refs after packing |
| 146 | * PACK_REFS_ALL: Pack _all_ refs, not just tags and already packed refs |
| 147 | */ |
| 148 | #define PACK_REFS_PRUNE 0x0001 |
| 149 | #define PACK_REFS_ALL 0x0002 |
| 150 | |
| 151 | /* |
| 152 | * Write a packed-refs file for the current repository. |
| 153 | * flags: Combination of the above PACK_REFS_* flags. |
| 154 | */ |
| 155 | int pack_refs(unsigned int flags); |
| 156 | |
Michael Haggerty | 4a45b2f | 2014-11-25 09:02:32 +0100 | [diff] [blame] | 157 | /* |
| 158 | * Rewrite the packed-refs file, omitting any refs listed in |
| 159 | * 'refnames'. On error, packed-refs will be unchanged, the return |
| 160 | * value is nonzero, and a message about the error is written to the |
| 161 | * 'err' strbuf. |
| 162 | * |
| 163 | * The refs in 'refnames' needn't be sorted. `err` must not be NULL. |
| 164 | */ |
| 165 | extern int repack_without_refs(struct string_list *refnames, |
Ronnie Sahlberg | 60bca08 | 2014-06-20 07:42:49 -0700 | [diff] [blame] | 166 | struct strbuf *err); |
Jens Lindström | c9e768b | 2014-05-23 12:29:45 +0200 | [diff] [blame] | 167 | |
Junio C Hamano | 2c5c66b | 2011-10-10 15:56:19 -0700 | [diff] [blame] | 168 | extern int ref_exists(const char *); |
Daniel Barkalow | e142a3c | 2008-04-27 13:39:24 -0400 | [diff] [blame] | 169 | |
Ronnie Sahlberg | e7e0f26 | 2014-07-15 16:02:38 -0700 | [diff] [blame] | 170 | extern int is_branch(const char *refname); |
| 171 | |
Michael Haggerty | 2312a79 | 2013-04-22 21:52:21 +0200 | [diff] [blame] | 172 | /* |
| 173 | * If refname is a non-symbolic reference that refers to a tag object, |
| 174 | * and the tag can be (recursively) dereferenced to a non-tag object, |
| 175 | * store the SHA1 of the referred-to object to sha1 and return 0. If |
| 176 | * any of these conditions are not met, return a non-zero value. |
| 177 | * Symbolic references are considered unpeelable, even if they |
| 178 | * ultimately resolve to a peelable tag. |
| 179 | */ |
Michael Haggerty | dfefa93 | 2011-12-12 06:38:09 +0100 | [diff] [blame] | 180 | extern int peel_ref(const char *refname, unsigned char *sha1); |
Junio C Hamano | cf0adba | 2006-11-19 13:22:44 -0800 | [diff] [blame] | 181 | |
Ronnie Sahlberg | 835e3c9 | 2014-06-20 07:42:51 -0700 | [diff] [blame] | 182 | /* |
Michael Haggerty | 31e07f7 | 2014-12-12 09:57:01 +0100 | [diff] [blame] | 183 | * Flags controlling ref_transaction_update(), ref_transaction_create(), etc. |
Ronnie Sahlberg | 029cdb4 | 2014-04-30 09:03:36 -0700 | [diff] [blame] | 184 | * REF_NODEREF: act on the ref directly, instead of dereferencing |
| 185 | * symbolic references. |
| 186 | * |
Michael Haggerty | 581d4e0 | 2015-02-12 12:12:12 +0100 | [diff] [blame] | 187 | * Other flags are reserved for internal use. |
Ronnie Sahlberg | 835e3c9 | 2014-06-20 07:42:51 -0700 | [diff] [blame] | 188 | */ |
Sven Verdoolaege | 68db31c | 2007-05-09 12:33:20 +0200 | [diff] [blame] | 189 | #define REF_NODEREF 0x01 |
Shawn Pearce | 4bd18c4 | 2006-05-17 05:55:02 -0400 | [diff] [blame] | 190 | |
Ronnie Sahlberg | bd3b02d | 2014-06-20 07:42:50 -0700 | [diff] [blame] | 191 | /* |
| 192 | * Setup reflog before using. Set errno to something meaningful on failure. |
| 193 | */ |
Nguyễn Thái Ngọc Duy | 1a83c24 | 2014-11-30 15:24:28 +0700 | [diff] [blame] | 194 | int log_ref_setup(const char *refname, struct strbuf *logfile); |
Erick Mattos | 859c301 | 2010-05-21 21:28:36 -0300 | [diff] [blame] | 195 | |
Shawn Pearce | d556fae | 2006-05-17 05:56:09 -0400 | [diff] [blame] | 196 | /** Reads log for the value of ref during at_time. **/ |
David Aguilar | c41a87d | 2014-09-18 20:45:37 -0700 | [diff] [blame] | 197 | extern int read_ref_at(const char *refname, unsigned int flags, |
| 198 | unsigned long at_time, int cnt, |
Michael Haggerty | dfefa93 | 2011-12-12 06:38:09 +0100 | [diff] [blame] | 199 | unsigned char *sha1, char **msg, |
| 200 | unsigned long *cutoff_time, int *cutoff_tz, int *cutoff_cnt); |
Shawn Pearce | d556fae | 2006-05-17 05:56:09 -0400 | [diff] [blame] | 201 | |
Ronnie Sahlberg | 4da5883 | 2014-05-06 15:45:52 -0700 | [diff] [blame] | 202 | /** Check if a particular reflog exists */ |
| 203 | extern int reflog_exists(const char *refname); |
| 204 | |
| 205 | /** Delete a reflog */ |
| 206 | extern int delete_reflog(const char *refname); |
| 207 | |
Junio C Hamano | 2ff8166 | 2006-12-18 01:18:16 -0800 | [diff] [blame] | 208 | /* iterate over reflog entries */ |
Johannes Schindelin | 883d60f | 2007-01-08 01:59:54 +0100 | [diff] [blame] | 209 | typedef int each_reflog_ent_fn(unsigned char *osha1, unsigned char *nsha1, const char *, unsigned long, int, const char *, void *); |
Michael Haggerty | dfefa93 | 2011-12-12 06:38:09 +0100 | [diff] [blame] | 210 | int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, void *cb_data); |
Junio C Hamano | 98f85ff | 2013-03-08 13:27:37 -0800 | [diff] [blame] | 211 | int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, void *cb_data); |
Junio C Hamano | 2ff8166 | 2006-12-18 01:18:16 -0800 | [diff] [blame] | 212 | |
Nicolas Pitre | eb8381c | 2007-02-03 13:25:43 -0500 | [diff] [blame] | 213 | /* |
| 214 | * Calls the specified function for each reflog file until it returns nonzero, |
| 215 | * and returns the value |
| 216 | */ |
| 217 | extern int for_each_reflog(each_ref_fn, void *); |
| 218 | |
Michael Haggerty | 8d9c501 | 2011-09-15 23:10:25 +0200 | [diff] [blame] | 219 | #define REFNAME_ALLOW_ONELEVEL 1 |
| 220 | #define REFNAME_REFSPEC_PATTERN 2 |
| 221 | |
| 222 | /* |
Michael Haggerty | dfefa93 | 2011-12-12 06:38:09 +0100 | [diff] [blame] | 223 | * Return 0 iff refname has the correct format for a refname according |
| 224 | * to the rules described in Documentation/git-check-ref-format.txt. |
| 225 | * If REFNAME_ALLOW_ONELEVEL is set in flags, then accept one-level |
Michael Haggerty | 8d9c501 | 2011-09-15 23:10:25 +0200 | [diff] [blame] | 226 | * reference names. If REFNAME_REFSPEC_PATTERN is set in flags, then |
| 227 | * allow a "*" wildcard character in place of one of the name |
Jonathan Nieder | f3cc52d | 2014-09-26 12:22:22 -0700 | [diff] [blame] | 228 | * components. No leading or repeated slashes are accepted. |
Michael Haggerty | 8d9c501 | 2011-09-15 23:10:25 +0200 | [diff] [blame] | 229 | */ |
Michael Haggerty | dfefa93 | 2011-12-12 06:38:09 +0100 | [diff] [blame] | 230 | extern int check_refname_format(const char *refname, int flags); |
Daniel Barkalow | 95fc751 | 2005-06-06 16:31:29 -0400 | [diff] [blame] | 231 | |
Felipe Contreras | 4577e48 | 2009-05-14 00:22:04 +0300 | [diff] [blame] | 232 | extern const char *prettify_refname(const char *refname); |
Michael Haggerty | dfefa93 | 2011-12-12 06:38:09 +0100 | [diff] [blame] | 233 | extern char *shorten_unambiguous_ref(const char *refname, int strict); |
Daniel Barkalow | a9c37a7 | 2009-03-08 21:06:05 -0400 | [diff] [blame] | 234 | |
Lars Hjemli | c976d41 | 2006-11-28 15:47:40 +0100 | [diff] [blame] | 235 | /** rename ref, return 0 on success **/ |
Lars Hjemli | 678d0f4 | 2006-11-30 03:16:56 +0100 | [diff] [blame] | 236 | extern int rename_ref(const char *oldref, const char *newref, const char *logmsg); |
Lars Hjemli | c976d41 | 2006-11-28 15:47:40 +0100 | [diff] [blame] | 237 | |
Michael Haggerty | 7f820bd | 2011-12-12 06:38:18 +0100 | [diff] [blame] | 238 | /** |
| 239 | * Resolve refname in the nested "gitlink" repository that is located |
| 240 | * at path. If the resolution is successful, return 0 and set sha1 to |
| 241 | * the name of the object; otherwise, return a non-zero value. |
| 242 | */ |
| 243 | extern int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1); |
Linus Torvalds | 0ebde32 | 2007-04-09 21:14:26 -0700 | [diff] [blame] | 244 | |
Michael Haggerty | f412411 | 2014-04-07 15:47:56 +0200 | [diff] [blame] | 245 | enum action_on_err { |
| 246 | UPDATE_REFS_MSG_ON_ERR, |
| 247 | UPDATE_REFS_DIE_ON_ERR, |
| 248 | UPDATE_REFS_QUIET_ON_ERR |
| 249 | }; |
| 250 | |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 251 | /* |
| 252 | * Begin a reference transaction. The reference transaction must |
Ronnie Sahlberg | 33f9fc5 | 2014-06-20 07:42:43 -0700 | [diff] [blame] | 253 | * be freed by calling ref_transaction_free(). |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 254 | */ |
Ronnie Sahlberg | 93a644e | 2014-05-19 10:42:34 -0700 | [diff] [blame] | 255 | struct ref_transaction *ref_transaction_begin(struct strbuf *err); |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 256 | |
| 257 | /* |
Michael Haggerty | d1dd721 | 2015-02-17 18:00:23 +0100 | [diff] [blame] | 258 | * Reference transaction updates |
| 259 | * |
| 260 | * The following four functions add a reference check or update to a |
| 261 | * ref_transaction. They have some common similar parameters: |
| 262 | * |
| 263 | * transaction -- a pointer to an open ref_transaction, obtained |
| 264 | * from ref_transaction_begin(). |
| 265 | * |
| 266 | * refname -- the name of the reference to be affected. |
| 267 | * |
| 268 | * flags -- flags affecting the update, passed to |
| 269 | * update_ref_lock(). Can be REF_NODEREF, which means that |
| 270 | * symbolic references should not be followed. |
| 271 | * |
| 272 | * msg -- a message describing the change (for the reflog). |
| 273 | * |
| 274 | * err -- a strbuf for receiving a description of any error that |
| 275 | * might have occured. |
| 276 | * |
| 277 | * The functions make internal copies of refname and msg, so the |
| 278 | * caller retains ownership of these parameters. |
| 279 | * |
| 280 | * The functions return 0 on success and non-zero on failure. A |
| 281 | * failure means that the transaction as a whole has failed and needs |
| 282 | * to be rolled back. |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 283 | */ |
| 284 | |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 285 | /* |
Michael Haggerty | 1618033 | 2015-02-17 18:00:21 +0100 | [diff] [blame] | 286 | * Add a reference update to transaction. new_sha1 is the value that |
| 287 | * the reference should have after the update, or null_sha1 if it |
| 288 | * should be deleted. If new_sha1 is NULL, then the reference is not |
| 289 | * changed at all. old_sha1 is the value that the reference must have |
| 290 | * before the update, or null_sha1 if it must not have existed |
| 291 | * beforehand. The old value is checked after the lock is taken to |
| 292 | * prevent races. If the old value doesn't agree with old_sha1, the |
| 293 | * whole transaction fails. If old_sha1 is NULL, then the previous |
| 294 | * value is not checked. |
| 295 | * |
Michael Haggerty | d1dd721 | 2015-02-17 18:00:23 +0100 | [diff] [blame] | 296 | * See the above comment "Reference transaction updates" for more |
| 297 | * information. |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 298 | */ |
Ronnie Sahlberg | 8e34800 | 2014-06-20 07:43:00 -0700 | [diff] [blame] | 299 | int ref_transaction_update(struct ref_transaction *transaction, |
| 300 | const char *refname, |
| 301 | const unsigned char *new_sha1, |
| 302 | const unsigned char *old_sha1, |
Michael Haggerty | 1d147bd | 2015-02-17 18:00:15 +0100 | [diff] [blame] | 303 | unsigned int flags, const char *msg, |
Ronnie Sahlberg | 8e34800 | 2014-06-20 07:43:00 -0700 | [diff] [blame] | 304 | struct strbuf *err); |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 305 | |
| 306 | /* |
Michael Haggerty | d1dd721 | 2015-02-17 18:00:23 +0100 | [diff] [blame] | 307 | * Add a reference creation to transaction. new_sha1 is the value that |
| 308 | * the reference should have after the update; it must not be |
| 309 | * null_sha1. It is verified that the reference does not exist |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 310 | * already. |
Michael Haggerty | d1dd721 | 2015-02-17 18:00:23 +0100 | [diff] [blame] | 311 | * |
| 312 | * See the above comment "Reference transaction updates" for more |
| 313 | * information. |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 314 | */ |
Ronnie Sahlberg | b416af5 | 2014-04-16 15:26:44 -0700 | [diff] [blame] | 315 | int ref_transaction_create(struct ref_transaction *transaction, |
| 316 | const char *refname, |
| 317 | const unsigned char *new_sha1, |
Michael Haggerty | fec14ec | 2015-02-17 18:00:13 +0100 | [diff] [blame] | 318 | unsigned int flags, const char *msg, |
Ronnie Sahlberg | b416af5 | 2014-04-16 15:26:44 -0700 | [diff] [blame] | 319 | struct strbuf *err); |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 320 | |
| 321 | /* |
Michael Haggerty | d1dd721 | 2015-02-17 18:00:23 +0100 | [diff] [blame] | 322 | * Add a reference deletion to transaction. If old_sha1 is non-NULL, |
| 323 | * then it holds the value that the reference should have had before |
| 324 | * the update (which must not be null_sha1). |
| 325 | * |
| 326 | * See the above comment "Reference transaction updates" for more |
| 327 | * information. |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 328 | */ |
Ronnie Sahlberg | 8c8bdc0 | 2014-04-16 15:27:45 -0700 | [diff] [blame] | 329 | int ref_transaction_delete(struct ref_transaction *transaction, |
| 330 | const char *refname, |
| 331 | const unsigned char *old_sha1, |
Michael Haggerty | fb5a6bb | 2015-02-17 18:00:16 +0100 | [diff] [blame] | 332 | unsigned int flags, const char *msg, |
Ronnie Sahlberg | 8c8bdc0 | 2014-04-16 15:27:45 -0700 | [diff] [blame] | 333 | struct strbuf *err); |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 334 | |
| 335 | /* |
Michael Haggerty | 1618033 | 2015-02-17 18:00:21 +0100 | [diff] [blame] | 336 | * Verify, within a transaction, that refname has the value old_sha1, |
| 337 | * or, if old_sha1 is null_sha1, then verify that the reference |
Michael Haggerty | d1dd721 | 2015-02-17 18:00:23 +0100 | [diff] [blame] | 338 | * doesn't exist. old_sha1 must be non-NULL. |
| 339 | * |
| 340 | * See the above comment "Reference transaction updates" for more |
| 341 | * information. |
Michael Haggerty | 1618033 | 2015-02-17 18:00:21 +0100 | [diff] [blame] | 342 | */ |
| 343 | int ref_transaction_verify(struct ref_transaction *transaction, |
| 344 | const char *refname, |
| 345 | const unsigned char *old_sha1, |
| 346 | unsigned int flags, |
| 347 | struct strbuf *err); |
| 348 | |
| 349 | /* |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 350 | * Commit all of the changes that have been queued in transaction, as |
Ronnie Sahlberg | 28e6a97 | 2014-05-16 14:14:38 -0700 | [diff] [blame] | 351 | * atomically as possible. |
| 352 | * |
| 353 | * Returns 0 for success, or one of the below error codes for errors. |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 354 | */ |
Ronnie Sahlberg | 28e6a97 | 2014-05-16 14:14:38 -0700 | [diff] [blame] | 355 | /* Naming conflict (for example, the ref names A and A/B conflict). */ |
| 356 | #define TRANSACTION_NAME_CONFLICT -1 |
| 357 | /* All other errors. */ |
| 358 | #define TRANSACTION_GENERIC_ERROR -2 |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 359 | int ref_transaction_commit(struct ref_transaction *transaction, |
Ronnie Sahlberg | db7516a | 2014-04-30 12:22:42 -0700 | [diff] [blame] | 360 | struct strbuf *err); |
Michael Haggerty | caa4046 | 2014-04-07 15:48:10 +0200 | [diff] [blame] | 361 | |
Ronnie Sahlberg | 026bd1d | 2014-06-20 07:42:42 -0700 | [diff] [blame] | 362 | /* |
| 363 | * Free an existing transaction and all associated data. |
| 364 | */ |
| 365 | void ref_transaction_free(struct ref_transaction *transaction); |
| 366 | |
Michael Haggerty | 4b7b520 | 2015-02-17 18:00:22 +0100 | [diff] [blame] | 367 | /** |
| 368 | * Lock, update, and unlock a single reference. This function |
| 369 | * basically does a transaction containing a single call to |
| 370 | * ref_transaction_update(). The parameters to this function have the |
| 371 | * same meaning as the corresponding parameters to |
| 372 | * ref_transaction_update(). Handle errors as requested by the `onerr` |
| 373 | * argument. |
| 374 | */ |
| 375 | int update_ref(const char *msg, const char *refname, |
| 376 | const unsigned char *new_sha1, const unsigned char *old_sha1, |
Michael Haggerty | fec14ec | 2015-02-17 18:00:13 +0100 | [diff] [blame] | 377 | unsigned int flags, enum action_on_err onerr); |
Carlos Rica | 3d9f037 | 2007-09-05 03:38:24 +0200 | [diff] [blame] | 378 | |
Junio C Hamano | daebaa7 | 2013-01-18 16:08:30 -0800 | [diff] [blame] | 379 | extern int parse_hide_refs_config(const char *var, const char *value, const char *); |
| 380 | extern int ref_is_hidden(const char *); |
| 381 | |
Michael Haggerty | fa5b183 | 2014-12-12 09:56:59 +0100 | [diff] [blame] | 382 | enum expire_reflog_flags { |
| 383 | EXPIRE_REFLOGS_DRY_RUN = 1 << 0, |
| 384 | EXPIRE_REFLOGS_UPDATE_REF = 1 << 1, |
| 385 | EXPIRE_REFLOGS_VERBOSE = 1 << 2, |
| 386 | EXPIRE_REFLOGS_REWRITE = 1 << 3 |
| 387 | }; |
| 388 | |
| 389 | /* |
| 390 | * The following interface is used for reflog expiration. The caller |
| 391 | * calls reflog_expire(), supplying it with three callback functions, |
| 392 | * of the following types. The callback functions define the |
| 393 | * expiration policy that is desired. |
| 394 | * |
| 395 | * reflog_expiry_prepare_fn -- Called once after the reference is |
| 396 | * locked. |
| 397 | * |
| 398 | * reflog_expiry_should_prune_fn -- Called once for each entry in the |
| 399 | * existing reflog. It should return true iff that entry should be |
| 400 | * pruned. |
| 401 | * |
| 402 | * reflog_expiry_cleanup_fn -- Called once before the reference is |
| 403 | * unlocked again. |
| 404 | */ |
| 405 | typedef void reflog_expiry_prepare_fn(const char *refname, |
| 406 | const unsigned char *sha1, |
| 407 | void *cb_data); |
| 408 | typedef int reflog_expiry_should_prune_fn(unsigned char *osha1, |
| 409 | unsigned char *nsha1, |
| 410 | const char *email, |
| 411 | unsigned long timestamp, int tz, |
| 412 | const char *message, void *cb_data); |
| 413 | typedef void reflog_expiry_cleanup_fn(void *cb_data); |
| 414 | |
| 415 | /* |
| 416 | * Expire reflog entries for the specified reference. sha1 is the old |
| 417 | * value of the reference. flags is a combination of the constants in |
| 418 | * enum expire_reflog_flags. The three function pointers are described |
| 419 | * above. On success, return zero. |
| 420 | */ |
| 421 | extern int reflog_expire(const char *refname, const unsigned char *sha1, |
| 422 | unsigned int flags, |
| 423 | reflog_expiry_prepare_fn prepare_fn, |
| 424 | reflog_expiry_should_prune_fn should_prune_fn, |
| 425 | reflog_expiry_cleanup_fn cleanup_fn, |
| 426 | void *policy_cb_data); |
| 427 | |
Daniel Barkalow | 95fc751 | 2005-06-06 16:31:29 -0400 | [diff] [blame] | 428 | #endif /* REFS_H */ |