mirror of
https://github.com/git/git.git
synced 2024-11-24 02:17:02 +08:00
b3970c702c
ls-refs performs a single revision walk over the whole ref namespace, and sends ones that match with one of the given ref prefixes down to the user. This can be expensive if there are many refs overall, but the portion of them covered by the given prefixes is small by comparison. To attempt to reduce the difference between the number of refs traversed, and the number of refs sent, only traverse references which are in the longest common prefix of the given prefixes. This is very reminiscent of the approach taken inb31e2680c4(ref-filter.c: find disjoint pattern prefixes, 2019-06-26) which does an analogous thing for multi-patterned 'git for-each-ref' invocations. The callback 'send_ref' is resilient to ignore extra patterns by discarding any arguments which do not begin with at least one of the specified prefixes. Similarly, the code introduced inb31e2680c4is resilient to stop early at metacharacters, but we only pass strict prefixes here. At worst we would return too many results, but the double checking done by send_ref will throw away anything that doesn't start with something in the prefix list. Finally, if no prefixes were provided, then implicitly add the empty string (which will match all references) since this matches the existing behavior (see the "no restrictions" comment in "ls-refs.c:ref_match()"). Original-patch-by: Jacob Vosmaer <jacob@gitlab.com> Signed-off-by: Taylor Blau <me@ttaylorr.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
121 lines
2.8 KiB
C
121 lines
2.8 KiB
C
#include "cache.h"
|
|
#include "repository.h"
|
|
#include "refs.h"
|
|
#include "remote.h"
|
|
#include "strvec.h"
|
|
#include "ls-refs.h"
|
|
#include "pkt-line.h"
|
|
#include "config.h"
|
|
|
|
/*
|
|
* Check if one of the prefixes is a prefix of the ref.
|
|
* If no prefixes were provided, all refs match.
|
|
*/
|
|
static int ref_match(const struct strvec *prefixes, const char *refname)
|
|
{
|
|
int i;
|
|
|
|
if (!prefixes->nr)
|
|
return 1; /* no restriction */
|
|
|
|
for (i = 0; i < prefixes->nr; i++) {
|
|
const char *prefix = prefixes->v[i];
|
|
|
|
if (starts_with(refname, prefix))
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct ls_refs_data {
|
|
unsigned peel;
|
|
unsigned symrefs;
|
|
struct strvec prefixes;
|
|
};
|
|
|
|
static int send_ref(const char *refname, const struct object_id *oid,
|
|
int flag, void *cb_data)
|
|
{
|
|
struct ls_refs_data *data = cb_data;
|
|
const char *refname_nons = strip_namespace(refname);
|
|
struct strbuf refline = STRBUF_INIT;
|
|
|
|
if (ref_is_hidden(refname_nons, refname))
|
|
return 0;
|
|
|
|
if (!ref_match(&data->prefixes, refname_nons))
|
|
return 0;
|
|
|
|
strbuf_addf(&refline, "%s %s", oid_to_hex(oid), refname_nons);
|
|
if (data->symrefs && flag & REF_ISSYMREF) {
|
|
struct object_id unused;
|
|
const char *symref_target = resolve_ref_unsafe(refname, 0,
|
|
&unused,
|
|
&flag);
|
|
|
|
if (!symref_target)
|
|
die("'%s' is a symref but it is not?", refname);
|
|
|
|
strbuf_addf(&refline, " symref-target:%s",
|
|
strip_namespace(symref_target));
|
|
}
|
|
|
|
if (data->peel) {
|
|
struct object_id peeled;
|
|
if (!peel_ref(refname, &peeled))
|
|
strbuf_addf(&refline, " peeled:%s", oid_to_hex(&peeled));
|
|
}
|
|
|
|
strbuf_addch(&refline, '\n');
|
|
packet_write(1, refline.buf, refline.len);
|
|
|
|
strbuf_release(&refline);
|
|
return 0;
|
|
}
|
|
|
|
static int ls_refs_config(const char *var, const char *value, void *data)
|
|
{
|
|
/*
|
|
* We only serve fetches over v2 for now, so respect only "uploadpack"
|
|
* config. This may need to eventually be expanded to "receive", but we
|
|
* don't yet know how that information will be passed to ls-refs.
|
|
*/
|
|
return parse_hide_refs_config(var, value, "uploadpack");
|
|
}
|
|
|
|
int ls_refs(struct repository *r, struct strvec *keys,
|
|
struct packet_reader *request)
|
|
{
|
|
struct ls_refs_data data;
|
|
|
|
memset(&data, 0, sizeof(data));
|
|
strvec_init(&data.prefixes);
|
|
|
|
git_config(ls_refs_config, NULL);
|
|
|
|
while (packet_reader_read(request) == PACKET_READ_NORMAL) {
|
|
const char *arg = request->line;
|
|
const char *out;
|
|
|
|
if (!strcmp("peel", arg))
|
|
data.peel = 1;
|
|
else if (!strcmp("symrefs", arg))
|
|
data.symrefs = 1;
|
|
else if (skip_prefix(arg, "ref-prefix ", &out))
|
|
strvec_push(&data.prefixes, out);
|
|
}
|
|
|
|
if (request->status != PACKET_READ_FLUSH)
|
|
die(_("expected flush after ls-refs arguments"));
|
|
|
|
head_ref_namespaced(send_ref, &data);
|
|
if (!data.prefixes.nr)
|
|
strvec_push(&data.prefixes, "");
|
|
for_each_fullref_in_prefixes(get_git_namespace(), data.prefixes.v,
|
|
send_ref, &data, 0);
|
|
packet_flush(1);
|
|
strvec_clear(&data.prefixes);
|
|
return 0;
|
|
}
|