kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

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>
maint
Michael Haggerty 2017-09-08 15:51:52 +02:00 committed by Junio C Hamano
parent dc39e09942
commit 9939b33d6a
2 changed files with 0 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

193
refs/packed-backend.c
View File

@ -91,19 +91,6 @@ struct ref_store *packed_ref_store_create(const char *path,
return ref_store; 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 * 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 * 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)); 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 * Return the ref_entry for the given refname from the packed
* references. If it does not exist, return NULL. * 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[] = static const char PACKED_REFS_HEADER[] =
"# pack-refs with: peeled fully-peeled \n"; "# 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) static int packed_init_db(struct ref_store *ref_store, struct strbuf *err)
{ {
/* Nothing to do. */ /* Nothing to do. */

8
refs/packed-backend.h
View File

@ -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); void packed_refs_unlock(struct ref_store *ref_store);
int packed_refs_is_locked(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 */ #endif /* REFS_PACKED_BACKEND_H */