2007-10-30 01:05:43 +00:00
|
|
|
#include "builtin.h"
|
2005-07-24 00:54:03 +00:00
|
|
|
#include "cache.h"
|
2007-10-30 01:05:43 +00:00
|
|
|
#include "transport.h"
|
2018-04-09 01:42:26 +00:00
|
|
|
#include "ref-filter.h"
|
2007-10-30 01:05:43 +00:00
|
|
|
#include "remote.h"
|
2018-03-15 17:31:24 +00:00
|
|
|
#include "refs.h"
|
2005-07-24 00:54:03 +00:00
|
|
|
|
2016-01-18 23:20:49 +00:00
|
|
|
static const char * const ls_remote_usage[] = {
|
|
|
|
N_("git ls-remote [--heads] [--tags] [--refs] [--upload-pack=<exec>]\n"
|
2016-01-18 23:20:50 +00:00
|
|
|
" [-q | --quiet] [--exit-code] [--get-url]\n"
|
|
|
|
" [--symref] [<repository> [<refs>...]]"),
|
2016-01-18 23:20:49 +00:00
|
|
|
NULL
|
|
|
|
};
|
2005-07-24 00:54:03 +00:00
|
|
|
|
2007-12-09 06:52:59 +00:00
|
|
|
/*
|
2007-12-09 20:16:55 +00:00
|
|
|
* Is there one among the list of patterns that match the tail part
|
|
|
|
* of the path?
|
2007-12-09 06:52:59 +00:00
|
|
|
*/
|
|
|
|
static int tail_match(const char **pattern, const char *path)
|
|
|
|
{
|
|
|
|
const char *p;
|
2017-03-28 19:46:30 +00:00
|
|
|
char *pathbuf;
|
2007-12-09 06:52:59 +00:00
|
|
|
|
2007-12-09 20:16:55 +00:00
|
|
|
if (!pattern)
|
2007-12-09 06:52:59 +00:00
|
|
|
return 1; /* no restriction */
|
|
|
|
|
2017-03-28 19:46:30 +00:00
|
|
|
pathbuf = xstrfmt("/%s", path);
|
2007-12-09 20:16:55 +00:00
|
|
|
while ((p = *(pattern++)) != NULL) {
|
2017-06-22 21:38:08 +00:00
|
|
|
if (!wildmatch(p, pathbuf, 0)) {
|
2017-03-28 19:46:30 +00:00
|
|
|
free(pathbuf);
|
2007-12-09 20:16:55 +00:00
|
|
|
return 1;
|
2017-03-28 19:46:30 +00:00
|
|
|
}
|
2007-12-09 06:52:59 +00:00
|
|
|
}
|
2017-03-28 19:46:30 +00:00
|
|
|
free(pathbuf);
|
2007-12-09 06:52:59 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-11-04 20:51:17 +00:00
|
|
|
int cmd_ls_remote(int argc, const char **argv, const char *prefix)
|
2005-07-24 00:54:03 +00:00
|
|
|
{
|
2007-10-30 01:05:43 +00:00
|
|
|
const char *dest = NULL;
|
Improve git-peek-remote
This makes git-peek-remote able to basically do everything that
git-ls-remote does (but obviously just for the native protocol, so no
http[s]: or rsync: support).
The default behaviour is the same, but you can now give a mixture of
"--refs", "--tags" and "--heads" flags, where "--refs" forces
git-peek-remote to only show real refs (ie none of the fakey tag lookups,
but also not the special pseudo-refs like HEAD and MERGE_HEAD).
The "--tags" and "--heads" flags respectively limit the output to just
regular tags and heads, of course.
You can still also ask to limit them by name too.
You can combine the flags, so
git peek-remote --refs --tags .
will show all local _true_ tags, without the generated tag lookups
(compare the output without the "--refs" flag).
And "--tags --heads" will show both tags and heads, but will avoid (for
example) any special refs outside of the standard locations.
I'm also planning on adding a "--ignore-local" flag that allows us to ask
it to ignore any refs that we already have in the local tree, but that's
an independent thing.
All this is obviously gearing up to making "git fetch" cheaper.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-07-04 19:29:10 +00:00
|
|
|
unsigned flags = 0;
|
2011-03-01 09:21:36 +00:00
|
|
|
int get_url = 0;
|
2010-05-11 17:20:23 +00:00
|
|
|
int quiet = 0;
|
2011-05-18 20:06:00 +00:00
|
|
|
int status = 0;
|
2016-01-18 23:20:50 +00:00
|
|
|
int show_symref_target = 0;
|
2007-10-30 01:05:43 +00:00
|
|
|
const char *uploadpack = NULL;
|
2007-12-09 06:52:59 +00:00
|
|
|
const char **pattern = NULL;
|
2018-03-15 17:31:24 +00:00
|
|
|
struct argv_array ref_prefixes = ARGV_ARRAY_INIT;
|
2018-04-09 01:42:26 +00:00
|
|
|
int i;
|
2018-04-23 22:46:23 +00:00
|
|
|
struct string_list server_options = STRING_LIST_INIT_DUP;
|
2007-10-30 01:05:43 +00:00
|
|
|
|
2007-11-07 01:29:20 +00:00
|
|
|
struct remote *remote;
|
2007-10-30 01:05:43 +00:00
|
|
|
struct transport *transport;
|
|
|
|
const struct ref *ref;
|
2018-04-09 01:42:26 +00:00
|
|
|
struct ref_array ref_array;
|
|
|
|
static struct ref_sorting *sorting = NULL, **sorting_tail = &sorting;
|
2005-11-26 07:50:21 +00:00
|
|
|
|
2016-01-18 23:20:49 +00:00
|
|
|
struct option options[] = {
|
|
|
|
OPT__QUIET(&quiet, N_("do not print remote URL")),
|
|
|
|
OPT_STRING(0, "upload-pack", &uploadpack, N_("exec"),
|
|
|
|
N_("path of git-upload-pack on the remote host")),
|
|
|
|
{ OPTION_STRING, 0, "exec", &uploadpack, N_("exec"),
|
|
|
|
N_("path of git-upload-pack on the remote host"),
|
|
|
|
PARSE_OPT_HIDDEN },
|
|
|
|
OPT_BIT('t', "tags", &flags, N_("limit to tags"), REF_TAGS),
|
|
|
|
OPT_BIT('h', "heads", &flags, N_("limit to heads"), REF_HEADS),
|
|
|
|
OPT_BIT(0, "refs", &flags, N_("do not show peeled tags"), REF_NORMAL),
|
|
|
|
OPT_BOOL(0, "get-url", &get_url,
|
|
|
|
N_("take url.<base>.insteadOf into account")),
|
2018-04-09 01:42:26 +00:00
|
|
|
OPT_CALLBACK(0 , "sort", sorting_tail, N_("key"),
|
|
|
|
N_("field name to sort on"), &parse_opt_ref_sorting),
|
2018-02-09 11:02:03 +00:00
|
|
|
OPT_SET_INT_F(0, "exit-code", &status,
|
|
|
|
N_("exit with exit code 2 if no matching refs are found"),
|
|
|
|
2, PARSE_OPT_NOCOMPLETE),
|
2016-01-18 23:20:50 +00:00
|
|
|
OPT_BOOL(0, "symref", &show_symref_target,
|
|
|
|
N_("show underlying ref in addition to the object pointed by it")),
|
2018-04-23 22:46:23 +00:00
|
|
|
OPT_STRING_LIST('o', "server-option", &server_options, N_("server-specific"), N_("option to transmit")),
|
2016-01-18 23:20:49 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
2011-09-16 18:14:27 +00:00
|
|
|
|
2018-04-09 01:42:26 +00:00
|
|
|
memset(&ref_array, 0, sizeof(ref_array));
|
|
|
|
|
2016-01-18 23:20:49 +00:00
|
|
|
argc = parse_options(argc, argv, prefix, options, ls_remote_usage,
|
|
|
|
PARSE_OPT_STOP_AT_NON_OPTION);
|
|
|
|
dest = argv[0];
|
2005-07-24 00:54:03 +00:00
|
|
|
|
2016-01-18 23:20:49 +00:00
|
|
|
if (argc > 1) {
|
|
|
|
int i;
|
|
|
|
pattern = xcalloc(argc, sizeof(const char *));
|
2018-03-15 17:31:24 +00:00
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
const char *glob;
|
2016-01-18 23:20:49 +00:00
|
|
|
pattern[i - 1] = xstrfmt("*/%s", argv[i]);
|
2018-03-15 17:31:24 +00:00
|
|
|
|
|
|
|
glob = strchr(argv[i], '*');
|
|
|
|
if (glob)
|
|
|
|
argv_array_pushf(&ref_prefixes, "%.*s",
|
|
|
|
(int)(glob - argv[i]), argv[i]);
|
|
|
|
else
|
|
|
|
expand_ref_prefix(&ref_prefixes, argv[i]);
|
|
|
|
}
|
2005-07-24 00:54:03 +00:00
|
|
|
}
|
Improve git-peek-remote
This makes git-peek-remote able to basically do everything that
git-ls-remote does (but obviously just for the native protocol, so no
http[s]: or rsync: support).
The default behaviour is the same, but you can now give a mixture of
"--refs", "--tags" and "--heads" flags, where "--refs" forces
git-peek-remote to only show real refs (ie none of the fakey tag lookups,
but also not the special pseudo-refs like HEAD and MERGE_HEAD).
The "--tags" and "--heads" flags respectively limit the output to just
regular tags and heads, of course.
You can still also ask to limit them by name too.
You can combine the flags, so
git peek-remote --refs --tags .
will show all local _true_ tags, without the generated tag lookups
(compare the output without the "--refs" flag).
And "--tags --heads" will show both tags and heads, but will avoid (for
example) any special refs outside of the standard locations.
I'm also planning on adding a "--ignore-local" flag that allows us to ask
it to ignore any refs that we already have in the local tree, but that's
an independent thing.
All this is obviously gearing up to making "git fetch" cheaper.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-07-04 19:29:10 +00:00
|
|
|
|
2009-11-04 02:38:51 +00:00
|
|
|
remote = remote_get(dest);
|
ls-remote: fall-back to default remotes when no remote specified
Instead of breaking execution when no remote (as specified in the
variable dest) is specified when git-ls-remote is invoked, continue on
and let remote_get() handle it.
This way, we are able to use the default remotes (eg. "origin",
branch.<name>.remote), as git-fetch, git-push, and other users of
remote_get(), do.
If no suitable remote is found, exit with a message describing the
issue, instead of just the usage text, as we do previously.
Add several tests to check that git-ls-remote handles the
no-remote-specified situation.
Also add a test that "git ls-remote <pattern>" does not work; we are
unable to guess the remote in that situation, as are git-fetch and
git-push.
In that test, we are testing for messages coming from two separate
processes, but we should be OK, because the second message is triggered
by closing the fd which must happen after the first message is printed.
(analysis by Jeff King.)
Signed-off-by: Tay Ray Chuan <rctay89@gmail.com>
Acked-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-04-08 17:21:13 +00:00
|
|
|
if (!remote) {
|
|
|
|
if (dest)
|
|
|
|
die("bad repository '%s'", dest);
|
|
|
|
die("No remote configured to list refs from.");
|
|
|
|
}
|
2009-11-04 02:38:51 +00:00
|
|
|
if (!remote->url_nr)
|
2007-11-07 01:29:20 +00:00
|
|
|
die("remote %s has no configured URL", dest);
|
2011-03-01 09:21:36 +00:00
|
|
|
|
|
|
|
if (get_url) {
|
|
|
|
printf("%s\n", *remote->url);
|
2018-04-09 01:42:26 +00:00
|
|
|
UNLEAK(sorting);
|
2011-03-01 09:21:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-18 01:42:22 +00:00
|
|
|
transport = transport_get(remote, NULL);
|
2007-10-30 01:05:43 +00:00
|
|
|
if (uploadpack != NULL)
|
|
|
|
transport_set_option(transport, TRANS_OPT_UPLOADPACK, uploadpack);
|
2018-04-23 22:46:23 +00:00
|
|
|
if (server_options.nr)
|
|
|
|
transport->server_options = &server_options;
|
2007-10-30 01:05:43 +00:00
|
|
|
|
2018-03-15 17:31:24 +00:00
|
|
|
ref = transport_get_remote_refs(transport, &ref_prefixes);
|
2018-04-09 01:42:26 +00:00
|
|
|
if (transport_disconnect(transport)) {
|
|
|
|
UNLEAK(sorting);
|
2007-10-30 01:05:43 +00:00
|
|
|
return 1;
|
2018-04-09 01:42:26 +00:00
|
|
|
}
|
2010-05-11 17:20:23 +00:00
|
|
|
|
|
|
|
if (!dest && !quiet)
|
|
|
|
fprintf(stderr, "From %s\n", *remote->url);
|
2007-12-09 06:52:59 +00:00
|
|
|
for ( ; ref; ref = ref->next) {
|
2018-04-09 01:42:26 +00:00
|
|
|
struct ref_array_item *item;
|
2007-12-09 06:52:59 +00:00
|
|
|
if (!check_ref_type(ref, flags))
|
|
|
|
continue;
|
|
|
|
if (!tail_match(pattern, ref->name))
|
|
|
|
continue;
|
2018-04-09 01:42:26 +00:00
|
|
|
item = ref_array_push(&ref_array, ref->name, &ref->old_oid);
|
|
|
|
item->symref = xstrdup_or_null(ref->symref);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sorting)
|
|
|
|
ref_array_sort(sorting, &ref_array);
|
|
|
|
|
|
|
|
for (i = 0; i < ref_array.nr; i++) {
|
|
|
|
const struct ref_array_item *ref = ref_array.items[i];
|
2016-01-18 23:20:50 +00:00
|
|
|
if (show_symref_target && ref->symref)
|
2018-04-09 01:42:26 +00:00
|
|
|
printf("ref: %s\t%s\n", ref->symref, ref->refname);
|
|
|
|
printf("%s\t%s\n", oid_to_hex(&ref->objectname), ref->refname);
|
2011-05-18 20:06:00 +00:00
|
|
|
status = 0; /* we found something */
|
2007-10-30 01:05:43 +00:00
|
|
|
}
|
2018-04-09 01:42:26 +00:00
|
|
|
|
|
|
|
UNLEAK(sorting);
|
2018-10-18 07:28:54 +00:00
|
|
|
ref_array_clear(&ref_array);
|
2011-05-18 20:06:00 +00:00
|
|
|
return status;
|
2005-07-24 00:54:03 +00:00
|
|
|
}
|