packed-backend: rip out some now-unused code
Now the outside world interacts with the packed ref store only via the generic refs API plus a few lock-related functions. This allows us to delete some functions that are no longer used, thereby completing the encapsulation of the packed ref store. Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu> Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Michael Haggerty
Junio C Hamano
parent
dc39e09942
commit
9939b33d6a
@ -91,19 +91,6 @@ struct ref_store *packed_ref_store_create(const char *path,
|
||||
return ref_store;
|
||||
}
|
||||
|
||||
/*
|
||||
* Die if refs is not the main ref store. caller is used in any
|
||||
* necessary error messages.
|
||||
*/
|
||||
static void packed_assert_main_repository(struct packed_ref_store *refs,
|
||||
const char *caller)
|
||||
{
|
||||
if (refs->store_flags & REF_STORE_MAIN)
|
||||
return;
|
||||
|
||||
die("BUG: operation %s only allowed for main ref store", caller);
|
||||
}
|
||||
|
||||
/*
|
||||
* Downcast `ref_store` to `packed_ref_store`. Die if `ref_store` is
|
||||
* not a `packed_ref_store`. Also die if `packed_ref_store` doesn't
|
||||
@ -321,40 +308,6 @@ static struct ref_dir *get_packed_refs(struct packed_ref_store *refs)
|
||||
return get_packed_ref_dir(get_packed_ref_cache(refs));
|
||||
}
|
||||
|
||||
/*
|
||||
* Add or overwrite a reference in the in-memory packed reference
|
||||
* cache. This may only be called while the packed-refs file is locked
|
||||
* (see packed_refs_lock()). To actually write the packed-refs file,
|
||||
* call commit_packed_refs().
|
||||
*/
|
||||
void add_packed_ref(struct ref_store *ref_store,
|
||||
const char *refname, const struct object_id *oid)
|
||||
{
|
||||
struct packed_ref_store *refs =
|
||||
packed_downcast(ref_store, REF_STORE_WRITE,
|
||||
"add_packed_ref");
|
||||
struct ref_dir *packed_refs;
|
||||
struct ref_entry *packed_entry;
|
||||
|
||||
if (!is_lock_file_locked(&refs->lock))
|
||||
die("BUG: packed refs not locked");
|
||||
|
||||
if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))
|
||||
die("Reference has invalid format: '%s'", refname);
|
||||
|
||||
packed_refs = get_packed_refs(refs);
|
||||
packed_entry = find_ref_entry(packed_refs, refname);
|
||||
if (packed_entry) {
|
||||
/* Overwrite the existing entry: */
|
||||
oidcpy(&packed_entry->u.value.oid, oid);
|
||||
packed_entry->flag = REF_ISPACKED;
|
||||
oidclr(&packed_entry->u.value.peeled);
|
||||
} else {
|
||||
packed_entry = create_ref_entry(refname, oid, REF_ISPACKED);
|
||||
add_ref_entry(packed_refs, packed_entry);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Return the ref_entry for the given refname from the packed
|
||||
* references. If it does not exist, return NULL.
|
||||
@ -596,152 +549,6 @@ int packed_refs_is_locked(struct ref_store *ref_store)
|
||||
static const char PACKED_REFS_HEADER[] =
|
||||
"# pack-refs with: peeled fully-peeled \n";
|
||||
|
||||
/*
|
||||
* Write the current version of the packed refs cache from memory to
|
||||
* disk. The packed-refs file must already be locked for writing (see
|
||||
* packed_refs_lock()). Return zero on success. On errors, rollback
|
||||
* the lockfile, write an error message to `err`, and return a nonzero
|
||||
* value.
|
||||
*/
|
||||
int commit_packed_refs(struct ref_store *ref_store, struct strbuf *err)
|
||||
{
|
||||
struct packed_ref_store *refs =
|
||||
packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN,
|
||||
"commit_packed_refs");
|
||||
struct packed_ref_cache *packed_ref_cache =
|
||||
get_packed_ref_cache(refs);
|
||||
int ok;
|
||||
int ret = -1;
|
||||
struct strbuf sb = STRBUF_INIT;
|
||||
FILE *out;
|
||||
struct ref_iterator *iter;
|
||||
char *packed_refs_path;
|
||||
|
||||
if (!is_lock_file_locked(&refs->lock))
|
||||
die("BUG: commit_packed_refs() called when unlocked");
|
||||
|
||||
/*
|
||||
* If packed-refs is a symlink, we want to overwrite the
|
||||
* symlinked-to file, not the symlink itself. Also, put the
|
||||
* staging file next to it:
|
||||
*/
|
||||
packed_refs_path = get_locked_file_path(&refs->lock);
|
||||
strbuf_addf(&sb, "%s.new", packed_refs_path);
|
||||
if (create_tempfile(&refs->tempfile, sb.buf) < 0) {
|
||||
strbuf_addf(err, "unable to create file %s: %s",
|
||||
sb.buf, strerror(errno));
|
||||
strbuf_release(&sb);
|
||||
goto out;
|
||||
}
|
||||
strbuf_release(&sb);
|
||||
|
||||
out = fdopen_tempfile(&refs->tempfile, "w");
|
||||
if (!out) {
|
||||
strbuf_addf(err, "unable to fdopen packed-refs tempfile: %s",
|
||||
strerror(errno));
|
||||
goto error;
|
||||
}
|
||||
|
||||
if (fprintf(out, "%s", PACKED_REFS_HEADER) < 0) {
|
||||
strbuf_addf(err, "error writing to %s: %s",
|
||||
get_tempfile_path(&refs->tempfile), strerror(errno));
|
||||
goto error;
|
||||
}
|
||||
|
||||
iter = cache_ref_iterator_begin(packed_ref_cache->cache, NULL, 0);
|
||||
while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
|
||||
struct object_id peeled;
|
||||
int peel_error = ref_iterator_peel(iter, &peeled);
|
||||
|
||||
if (write_packed_entry(out, iter->refname, iter->oid->hash,
|
||||
peel_error ? NULL : peeled.hash)) {
|
||||
strbuf_addf(err, "error writing to %s: %s",
|
||||
get_tempfile_path(&refs->tempfile),
|
||||
strerror(errno));
|
||||
ref_iterator_abort(iter);
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
|
||||
if (ok != ITER_DONE) {
|
||||
strbuf_addf(err, "unable to rewrite packed-refs file: "
|
||||
"error iterating over old contents");
|
||||
goto error;
|
||||
}
|
||||
|
||||
if (rename_tempfile(&refs->tempfile, packed_refs_path)) {
|
||||
strbuf_addf(err, "error replacing %s: %s",
|
||||
refs->path, strerror(errno));
|
||||
goto out;
|
||||
}
|
||||
|
||||
ret = 0;
|
||||
goto out;
|
||||
|
||||
error:
|
||||
delete_tempfile(&refs->tempfile);
|
||||
|
||||
out:
|
||||
free(packed_refs_path);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Rewrite the packed-refs file, omitting any refs listed in
|
||||
* 'refnames'. On error, leave packed-refs unchanged, write an error
|
||||
* message to 'err', and return a nonzero value. The packed refs lock
|
||||
* must be held when calling this function; it will still be held when
|
||||
* the function returns.
|
||||
*
|
||||
* The refs in 'refnames' needn't be sorted. `err` must not be NULL.
|
||||
*/
|
||||
int repack_without_refs(struct ref_store *ref_store,
|
||||
struct string_list *refnames, struct strbuf *err)
|
||||
{
|
||||
struct packed_ref_store *refs =
|
||||
packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN,
|
||||
"repack_without_refs");
|
||||
struct ref_dir *packed;
|
||||
struct string_list_item *refname;
|
||||
int needs_repacking = 0, removed = 0;
|
||||
|
||||
packed_assert_main_repository(refs, "repack_without_refs");
|
||||
assert(err);
|
||||
|
||||
if (!is_lock_file_locked(&refs->lock))
|
||||
die("BUG: repack_without_refs called without holding lock");
|
||||
|
||||
/* Look for a packed ref */
|
||||
for_each_string_list_item(refname, refnames) {
|
||||
if (get_packed_ref(refs, refname->string)) {
|
||||
needs_repacking = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Avoid locking if we have nothing to do */
|
||||
if (!needs_repacking)
|
||||
return 0; /* no refname exists in packed refs */
|
||||
|
||||
packed = get_packed_refs(refs);
|
||||
|
||||
/* Remove refnames from the cache */
|
||||
for_each_string_list_item(refname, refnames)
|
||||
if (remove_entry_from_dir(packed, refname->string) != -1)
|
||||
removed = 1;
|
||||
if (!removed) {
|
||||
/*
|
||||
* All packed entries disappeared while we were
|
||||
* acquiring the lock.
|
||||
*/
|
||||
clear_packed_ref_cache(refs);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Write what remains */
|
||||
return commit_packed_refs(&refs->base, err);
|
||||
}
|
||||
|
||||
static int packed_init_db(struct ref_store *ref_store, struct strbuf *err)
|
||||
{
|
||||
/* Nothing to do. */
|
||||
|
||||
@ -23,12 +23,4 @@ int packed_refs_lock(struct ref_store *ref_store, int flags, struct strbuf *err)
|
||||
void packed_refs_unlock(struct ref_store *ref_store);
|
||||
int packed_refs_is_locked(struct ref_store *ref_store);
|
||||
|
||||
void add_packed_ref(struct ref_store *ref_store,
|
||||
const char *refname, const struct object_id *oid);
|
||||
|
||||
int commit_packed_refs(struct ref_store *ref_store, struct strbuf *err);
|
||||
|
||||
int repack_without_refs(struct ref_store *ref_store,
|
||||
struct string_list *refnames, struct strbuf *err);
|
||||
|
||||
#endif /* REFS_PACKED_BACKEND_H */
|
||||
|
||||
Loading…
Reference in New Issue
Block a user