2007-09-11 03:03:04 +00:00
|
|
|
#include "cache.h"
|
|
|
|
#include "transport.h"
|
|
|
|
#include "run-command.h"
|
2007-09-11 03:03:11 +00:00
|
|
|
#include "pkt-line.h"
|
|
|
|
#include "fetch-pack.h"
|
2007-10-30 02:03:42 +00:00
|
|
|
#include "send-pack.h"
|
2007-09-11 03:03:11 +00:00
|
|
|
#include "walker.h"
|
2007-09-11 03:03:21 +00:00
|
|
|
#include "bundle.h"
|
2007-09-30 23:59:39 +00:00
|
|
|
#include "dir.h"
|
|
|
|
#include "refs.h"
|
2010-01-16 21:45:31 +00:00
|
|
|
#include "branch.h"
|
2010-05-23 09:17:55 +00:00
|
|
|
#include "url.h"
|
2011-08-19 22:08:47 +00:00
|
|
|
#include "submodule.h"
|
2012-03-29 07:21:23 +00:00
|
|
|
#include "string-list.h"
|
2007-09-30 23:59:39 +00:00
|
|
|
|
|
|
|
/* rsync support */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We copy packed-refs and refs/ into a temporary file, then read the
|
|
|
|
* loose refs recursively (sorting whenever possible), and then inserting
|
|
|
|
* those packed refs that are not yet in the list (not validating, but
|
|
|
|
* assuming that the file is sorted).
|
|
|
|
*
|
|
|
|
* Appears refactoring this from refs.c is too cumbersome.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int str_cmp(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
const char *s1 = a;
|
|
|
|
const char *s2 = b;
|
|
|
|
|
|
|
|
return strcmp(s1, s2);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* path->buf + name_offset is expected to point to "refs/" */
|
|
|
|
|
|
|
|
static int read_loose_refs(struct strbuf *path, int name_offset,
|
|
|
|
struct ref **tail)
|
|
|
|
{
|
|
|
|
DIR *dir = opendir(path->buf);
|
|
|
|
struct dirent *de;
|
|
|
|
struct {
|
|
|
|
char **entries;
|
|
|
|
int nr, alloc;
|
|
|
|
} list;
|
|
|
|
int i, pathlen;
|
|
|
|
|
|
|
|
if (!dir)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
memset (&list, 0, sizeof(list));
|
|
|
|
|
|
|
|
while ((de = readdir(dir))) {
|
2009-01-10 12:07:50 +00:00
|
|
|
if (is_dot_or_dotdot(de->d_name))
|
2007-09-30 23:59:39 +00:00
|
|
|
continue;
|
|
|
|
ALLOC_GROW(list.entries, list.nr + 1, list.alloc);
|
|
|
|
list.entries[list.nr++] = xstrdup(de->d_name);
|
|
|
|
}
|
|
|
|
closedir(dir);
|
|
|
|
|
|
|
|
/* sort the list */
|
|
|
|
|
|
|
|
qsort(list.entries, list.nr, sizeof(char *), str_cmp);
|
|
|
|
|
|
|
|
pathlen = path->len;
|
|
|
|
strbuf_addch(path, '/');
|
|
|
|
|
|
|
|
for (i = 0; i < list.nr; i++, strbuf_setlen(path, pathlen + 1)) {
|
|
|
|
strbuf_addstr(path, list.entries[i]);
|
|
|
|
if (read_loose_refs(path, name_offset, tail)) {
|
|
|
|
int fd = open(path->buf, O_RDONLY);
|
|
|
|
char buffer[40];
|
|
|
|
struct ref *next;
|
|
|
|
|
|
|
|
if (fd < 0)
|
|
|
|
continue;
|
2008-10-18 08:44:18 +00:00
|
|
|
next = alloc_ref(path->buf + name_offset);
|
2007-09-30 23:59:39 +00:00
|
|
|
if (read_in_full(fd, buffer, 40) != 40 ||
|
|
|
|
get_sha1_hex(buffer, next->old_sha1)) {
|
|
|
|
close(fd);
|
|
|
|
free(next);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
(*tail)->next = next;
|
|
|
|
*tail = next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
strbuf_setlen(path, pathlen);
|
|
|
|
|
|
|
|
for (i = 0; i < list.nr; i++)
|
|
|
|
free(list.entries[i]);
|
|
|
|
free(list.entries);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* insert the packed refs for which no loose refs were found */
|
|
|
|
|
|
|
|
static void insert_packed_refs(const char *packed_refs, struct ref **list)
|
|
|
|
{
|
|
|
|
FILE *f = fopen(packed_refs, "r");
|
|
|
|
static char buffer[PATH_MAX];
|
|
|
|
|
|
|
|
if (!f)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (;;) {
|
2013-03-25 19:51:50 +00:00
|
|
|
int cmp = 0; /* assigned before used */
|
|
|
|
int len;
|
2007-09-30 23:59:39 +00:00
|
|
|
|
|
|
|
if (!fgets(buffer, sizeof(buffer), f)) {
|
|
|
|
fclose(f);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hexval(buffer[0]) > 0xf)
|
|
|
|
continue;
|
|
|
|
len = strlen(buffer);
|
2008-01-04 17:37:41 +00:00
|
|
|
if (len && buffer[len - 1] == '\n')
|
2007-09-30 23:59:39 +00:00
|
|
|
buffer[--len] = '\0';
|
|
|
|
if (len < 41)
|
|
|
|
continue;
|
|
|
|
while ((*list)->next &&
|
|
|
|
(cmp = strcmp(buffer + 41,
|
|
|
|
(*list)->next->name)) > 0)
|
|
|
|
list = &(*list)->next;
|
|
|
|
if (!(*list)->next || cmp < 0) {
|
2008-10-18 08:44:18 +00:00
|
|
|
struct ref *next = alloc_ref(buffer + 41);
|
2007-09-30 23:59:39 +00:00
|
|
|
buffer[40] = '\0';
|
|
|
|
if (get_sha1_hex(buffer, next->old_sha1)) {
|
|
|
|
warning ("invalid SHA-1: %s", buffer);
|
|
|
|
free(next);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
next->next = (*list)->next;
|
|
|
|
(*list)->next = next;
|
|
|
|
list = &(*list)->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-16 21:45:31 +00:00
|
|
|
static void set_upstreams(struct transport *transport, struct ref *refs,
|
|
|
|
int pretend)
|
|
|
|
{
|
|
|
|
struct ref *ref;
|
|
|
|
for (ref = refs; ref; ref = ref->next) {
|
|
|
|
const char *localname;
|
|
|
|
const char *tmp;
|
|
|
|
const char *remotename;
|
|
|
|
unsigned char sha[20];
|
|
|
|
int flag = 0;
|
|
|
|
/*
|
|
|
|
* Check suitability for tracking. Must be successful /
|
|
|
|
* already up-to-date ref create/modify (not delete).
|
|
|
|
*/
|
|
|
|
if (ref->status != REF_STATUS_OK &&
|
|
|
|
ref->status != REF_STATUS_UPTODATE)
|
|
|
|
continue;
|
|
|
|
if (!ref->peer_ref)
|
|
|
|
continue;
|
2011-05-26 13:58:16 +00:00
|
|
|
if (is_null_sha1(ref->new_sha1))
|
2010-01-16 21:45:31 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Follow symbolic refs (mainly for HEAD). */
|
|
|
|
localname = ref->peer_ref->name;
|
|
|
|
remotename = ref->name;
|
2011-12-12 11:20:32 +00:00
|
|
|
tmp = resolve_ref_unsafe(localname, sha, 1, &flag);
|
2010-01-16 21:45:31 +00:00
|
|
|
if (tmp && flag & REF_ISSYMREF &&
|
|
|
|
!prefixcmp(tmp, "refs/heads/"))
|
|
|
|
localname = tmp;
|
|
|
|
|
|
|
|
/* Both source and destination must be local branches. */
|
|
|
|
if (!localname || prefixcmp(localname, "refs/heads/"))
|
|
|
|
continue;
|
|
|
|
if (!remotename || prefixcmp(remotename, "refs/heads/"))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!pretend)
|
|
|
|
install_branch_config(BRANCH_CONFIG_VERBOSE,
|
|
|
|
localname + 11, transport->remote->name,
|
|
|
|
remotename);
|
|
|
|
else
|
|
|
|
printf("Would set upstream of '%s' to '%s' of '%s'\n",
|
|
|
|
localname + 11, remotename + 11,
|
|
|
|
transport->remote->name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-09 18:44:55 +00:00
|
|
|
static const char *rsync_url(const char *url)
|
|
|
|
{
|
|
|
|
return prefixcmp(url, "rsync://") ? skip_prefix(url, "rsync:") : url;
|
|
|
|
}
|
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
static struct ref *get_refs_via_rsync(struct transport *transport, int for_push)
|
2007-09-30 23:59:39 +00:00
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT, temp_dir = STRBUF_INIT;
|
Fix sparse warnings
Fix warnings from 'make check'.
- These files don't include 'builtin.h' causing sparse to complain that
cmd_* isn't declared:
builtin/clone.c:364, builtin/fetch-pack.c:797,
builtin/fmt-merge-msg.c:34, builtin/hash-object.c:78,
builtin/merge-index.c:69, builtin/merge-recursive.c:22
builtin/merge-tree.c:341, builtin/mktag.c:156, builtin/notes.c:426
builtin/notes.c:822, builtin/pack-redundant.c:596,
builtin/pack-refs.c:10, builtin/patch-id.c:60, builtin/patch-id.c:149,
builtin/remote.c:1512, builtin/remote-ext.c:240,
builtin/remote-fd.c:53, builtin/reset.c:236, builtin/send-pack.c:384,
builtin/unpack-file.c:25, builtin/var.c:75
- These files have symbols which should be marked static since they're
only file scope:
submodule.c:12, diff.c:631, replace_object.c:92, submodule.c:13,
submodule.c:14, trace.c:78, transport.c:195, transport-helper.c:79,
unpack-trees.c:19, url.c:3, url.c:18, url.c:104, url.c:117, url.c:123,
url.c:129, url.c:136, thread-utils.c:21, thread-utils.c:48
- These files redeclare symbols to be different types:
builtin/index-pack.c:210, parse-options.c:564, parse-options.c:571,
usage.c:49, usage.c:58, usage.c:63, usage.c:72
- These files use a literal integer 0 when they really should use a NULL
pointer:
daemon.c:663, fast-import.c:2942, imap-send.c:1072, notes-merge.c:362
While we're in the area, clean up some unused #includes in builtin files
(mostly exec_cmd.h).
Signed-off-by: Stephen Boyd <bebarino@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-22 07:51:05 +00:00
|
|
|
struct ref dummy = {NULL}, *tail = &dummy;
|
2007-09-30 23:59:39 +00:00
|
|
|
struct child_process rsync;
|
|
|
|
const char *args[5];
|
|
|
|
int temp_dir_len;
|
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
if (for_push)
|
|
|
|
return NULL;
|
|
|
|
|
2007-09-30 23:59:39 +00:00
|
|
|
/* copy the refs to the temporary directory */
|
|
|
|
|
|
|
|
strbuf_addstr(&temp_dir, git_path("rsync-refs-XXXXXX"));
|
|
|
|
if (!mkdtemp(temp_dir.buf))
|
2009-06-27 15:58:47 +00:00
|
|
|
die_errno ("Could not make temporary directory");
|
2007-09-30 23:59:39 +00:00
|
|
|
temp_dir_len = temp_dir.len;
|
|
|
|
|
2009-03-09 18:44:55 +00:00
|
|
|
strbuf_addstr(&buf, rsync_url(transport->url));
|
2007-09-30 23:59:39 +00:00
|
|
|
strbuf_addstr(&buf, "/refs");
|
|
|
|
|
|
|
|
memset(&rsync, 0, sizeof(rsync));
|
|
|
|
rsync.argv = args;
|
|
|
|
rsync.stdout_to_stderr = 1;
|
|
|
|
args[0] = "rsync";
|
make "git push -v" actually verbose
Providing a single "-v" to "git push" currently does
nothing. Giving two flags ("git push -v -v") turns on the
first level of verbosity.
This is caused by a regression introduced in 8afd8dc (push:
support multiple levels of verbosity, 2010-02-24). Before
the series containing 8afd8dc, the verbosity handling for
fetching and pushing was completely separate. Commit bde873c
refactored the verbosity handling out of the fetch side, and
then 8afd8dc converted push to use the refactored code.
However, the fetch and push sides numbered and passed along
their verbosity levels differently. For both, a verbosity
level of "-1" meant "quiet", and "0" meant "default output".
But from there they differed.
For fetch, a verbosity level of "1" indicated to the "fetch"
program that it should make the status table slightly more
verbose, showing up-to-date entries. A verbosity level of
"2" meant that we should pass a verbose flag to the
transport; in the case of fetch-pack, this displays protocol
debugging information.
As a result, the refactored code in bde873c checks for
"verbosity >= 2", and only then passes it on to the
transport. From the transport code's perspective, a
verbosity of 0 or 1 both meant "0".
Push, on the other hand, does not show its own status table;
that is always handled by the transport layer or below
(originally send-pack itself, but these days it is done by
the transport code). So a verbosity level of 1 meant that we
should pass the verbose flag to send-pack, so that it knows
we want a verbose status table. However, once 8afd8dc
switched it to the refactored fetch code, a verbosity level
of 1 was now being ignored. Thus, you needed to
artificially bump the verbosity to 2 (via "-v -v") to have
any effect.
We can fix this by letting the transport code know about the
true verbosity level (i.e., let it distinguish level 0 or
1).
We then have to also make an adjustment to any transport
methods that assumed "verbose > 0" meant they could spew
lots of debugging information. Before, they could only get
"0" or "2", but now they will also receive "1". They need to
adjust their condition for turning on such spew from
"verbose > 0" to "verbose > 1".
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-12-17 09:37:15 +00:00
|
|
|
args[1] = (transport->verbose > 1) ? "-rv" : "-r";
|
2007-09-30 23:59:39 +00:00
|
|
|
args[2] = buf.buf;
|
|
|
|
args[3] = temp_dir.buf;
|
|
|
|
args[4] = NULL;
|
|
|
|
|
|
|
|
if (run_command(&rsync))
|
|
|
|
die ("Could not run rsync to get refs");
|
|
|
|
|
|
|
|
strbuf_reset(&buf);
|
2009-03-09 18:44:55 +00:00
|
|
|
strbuf_addstr(&buf, rsync_url(transport->url));
|
2007-09-30 23:59:39 +00:00
|
|
|
strbuf_addstr(&buf, "/packed-refs");
|
|
|
|
|
|
|
|
args[2] = buf.buf;
|
|
|
|
|
|
|
|
if (run_command(&rsync))
|
|
|
|
die ("Could not run rsync to get refs");
|
|
|
|
|
|
|
|
/* read the copied refs */
|
|
|
|
|
|
|
|
strbuf_addstr(&temp_dir, "/refs");
|
|
|
|
read_loose_refs(&temp_dir, temp_dir_len + 1, &tail);
|
|
|
|
strbuf_setlen(&temp_dir, temp_dir_len);
|
|
|
|
|
|
|
|
tail = &dummy;
|
|
|
|
strbuf_addstr(&temp_dir, "/packed-refs");
|
|
|
|
insert_packed_refs(temp_dir.buf, &tail);
|
|
|
|
strbuf_setlen(&temp_dir, temp_dir_len);
|
|
|
|
|
|
|
|
if (remove_dir_recursively(&temp_dir, 0))
|
|
|
|
warning ("Error removing temporary directory %s.",
|
|
|
|
temp_dir.buf);
|
|
|
|
|
|
|
|
strbuf_release(&buf);
|
|
|
|
strbuf_release(&temp_dir);
|
|
|
|
|
|
|
|
return dummy.next;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fetch_objs_via_rsync(struct transport *transport,
|
2009-11-18 01:42:24 +00:00
|
|
|
int nr_objs, struct ref **to_fetch)
|
2007-09-30 23:59:39 +00:00
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
struct child_process rsync;
|
|
|
|
const char *args[8];
|
|
|
|
int result;
|
|
|
|
|
2009-03-09 18:44:55 +00:00
|
|
|
strbuf_addstr(&buf, rsync_url(transport->url));
|
2007-09-30 23:59:39 +00:00
|
|
|
strbuf_addstr(&buf, "/objects/");
|
|
|
|
|
|
|
|
memset(&rsync, 0, sizeof(rsync));
|
|
|
|
rsync.argv = args;
|
|
|
|
rsync.stdout_to_stderr = 1;
|
|
|
|
args[0] = "rsync";
|
make "git push -v" actually verbose
Providing a single "-v" to "git push" currently does
nothing. Giving two flags ("git push -v -v") turns on the
first level of verbosity.
This is caused by a regression introduced in 8afd8dc (push:
support multiple levels of verbosity, 2010-02-24). Before
the series containing 8afd8dc, the verbosity handling for
fetching and pushing was completely separate. Commit bde873c
refactored the verbosity handling out of the fetch side, and
then 8afd8dc converted push to use the refactored code.
However, the fetch and push sides numbered and passed along
their verbosity levels differently. For both, a verbosity
level of "-1" meant "quiet", and "0" meant "default output".
But from there they differed.
For fetch, a verbosity level of "1" indicated to the "fetch"
program that it should make the status table slightly more
verbose, showing up-to-date entries. A verbosity level of
"2" meant that we should pass a verbose flag to the
transport; in the case of fetch-pack, this displays protocol
debugging information.
As a result, the refactored code in bde873c checks for
"verbosity >= 2", and only then passes it on to the
transport. From the transport code's perspective, a
verbosity of 0 or 1 both meant "0".
Push, on the other hand, does not show its own status table;
that is always handled by the transport layer or below
(originally send-pack itself, but these days it is done by
the transport code). So a verbosity level of 1 meant that we
should pass the verbose flag to send-pack, so that it knows
we want a verbose status table. However, once 8afd8dc
switched it to the refactored fetch code, a verbosity level
of 1 was now being ignored. Thus, you needed to
artificially bump the verbosity to 2 (via "-v -v") to have
any effect.
We can fix this by letting the transport code know about the
true verbosity level (i.e., let it distinguish level 0 or
1).
We then have to also make an adjustment to any transport
methods that assumed "verbose > 0" meant they could spew
lots of debugging information. Before, they could only get
"0" or "2", but now they will also receive "1". They need to
adjust their condition for turning on such spew from
"verbose > 0" to "verbose > 1".
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-12-17 09:37:15 +00:00
|
|
|
args[1] = (transport->verbose > 1) ? "-rv" : "-r";
|
2007-09-30 23:59:39 +00:00
|
|
|
args[2] = "--ignore-existing";
|
|
|
|
args[3] = "--exclude";
|
|
|
|
args[4] = "info";
|
|
|
|
args[5] = buf.buf;
|
|
|
|
args[6] = get_object_directory();
|
|
|
|
args[7] = NULL;
|
|
|
|
|
|
|
|
/* NEEDSWORK: handle one level of alternates */
|
|
|
|
result = run_command(&rsync);
|
|
|
|
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int write_one_ref(const char *name, const unsigned char *sha1,
|
|
|
|
int flags, void *data)
|
|
|
|
{
|
|
|
|
struct strbuf *buf = data;
|
|
|
|
int len = buf->len;
|
|
|
|
FILE *f;
|
|
|
|
|
|
|
|
/* when called via for_each_ref(), flags is non-zero */
|
|
|
|
if (flags && prefixcmp(name, "refs/heads/") &&
|
|
|
|
prefixcmp(name, "refs/tags/"))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
strbuf_addstr(buf, name);
|
|
|
|
if (safe_create_leading_directories(buf->buf) ||
|
|
|
|
!(f = fopen(buf->buf, "w")) ||
|
|
|
|
fprintf(f, "%s\n", sha1_to_hex(sha1)) < 0 ||
|
|
|
|
fclose(f))
|
|
|
|
return error("problems writing temporary file %s", buf->buf);
|
|
|
|
strbuf_setlen(buf, len);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int write_refs_to_temp_dir(struct strbuf *temp_dir,
|
|
|
|
int refspec_nr, const char **refspec)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < refspec_nr; i++) {
|
|
|
|
unsigned char sha1[20];
|
|
|
|
char *ref;
|
|
|
|
|
|
|
|
if (dwim_ref(refspec[i], strlen(refspec[i]), sha1, &ref) != 1)
|
|
|
|
return error("Could not get ref %s", refspec[i]);
|
|
|
|
|
|
|
|
if (write_one_ref(ref, sha1, 0, temp_dir)) {
|
|
|
|
free(ref);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
free(ref);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rsync_transport_push(struct transport *transport,
|
|
|
|
int refspec_nr, const char **refspec, int flags)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT, temp_dir = STRBUF_INIT;
|
|
|
|
int result = 0, i;
|
|
|
|
struct child_process rsync;
|
2007-10-16 04:28:32 +00:00
|
|
|
const char *args[10];
|
2007-09-30 23:59:39 +00:00
|
|
|
|
2007-11-09 23:32:25 +00:00
|
|
|
if (flags & TRANSPORT_PUSH_MIRROR)
|
|
|
|
return error("rsync transport does not support mirror mode");
|
|
|
|
|
2007-09-30 23:59:39 +00:00
|
|
|
/* first push the objects */
|
|
|
|
|
2009-03-09 18:44:55 +00:00
|
|
|
strbuf_addstr(&buf, rsync_url(transport->url));
|
2007-09-30 23:59:39 +00:00
|
|
|
strbuf_addch(&buf, '/');
|
|
|
|
|
|
|
|
memset(&rsync, 0, sizeof(rsync));
|
|
|
|
rsync.argv = args;
|
|
|
|
rsync.stdout_to_stderr = 1;
|
2007-10-16 04:28:32 +00:00
|
|
|
i = 0;
|
|
|
|
args[i++] = "rsync";
|
|
|
|
args[i++] = "-a";
|
|
|
|
if (flags & TRANSPORT_PUSH_DRY_RUN)
|
|
|
|
args[i++] = "--dry-run";
|
make "git push -v" actually verbose
Providing a single "-v" to "git push" currently does
nothing. Giving two flags ("git push -v -v") turns on the
first level of verbosity.
This is caused by a regression introduced in 8afd8dc (push:
support multiple levels of verbosity, 2010-02-24). Before
the series containing 8afd8dc, the verbosity handling for
fetching and pushing was completely separate. Commit bde873c
refactored the verbosity handling out of the fetch side, and
then 8afd8dc converted push to use the refactored code.
However, the fetch and push sides numbered and passed along
their verbosity levels differently. For both, a verbosity
level of "-1" meant "quiet", and "0" meant "default output".
But from there they differed.
For fetch, a verbosity level of "1" indicated to the "fetch"
program that it should make the status table slightly more
verbose, showing up-to-date entries. A verbosity level of
"2" meant that we should pass a verbose flag to the
transport; in the case of fetch-pack, this displays protocol
debugging information.
As a result, the refactored code in bde873c checks for
"verbosity >= 2", and only then passes it on to the
transport. From the transport code's perspective, a
verbosity of 0 or 1 both meant "0".
Push, on the other hand, does not show its own status table;
that is always handled by the transport layer or below
(originally send-pack itself, but these days it is done by
the transport code). So a verbosity level of 1 meant that we
should pass the verbose flag to send-pack, so that it knows
we want a verbose status table. However, once 8afd8dc
switched it to the refactored fetch code, a verbosity level
of 1 was now being ignored. Thus, you needed to
artificially bump the verbosity to 2 (via "-v -v") to have
any effect.
We can fix this by letting the transport code know about the
true verbosity level (i.e., let it distinguish level 0 or
1).
We then have to also make an adjustment to any transport
methods that assumed "verbose > 0" meant they could spew
lots of debugging information. Before, they could only get
"0" or "2", but now they will also receive "1". They need to
adjust their condition for turning on such spew from
"verbose > 0" to "verbose > 1".
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-12-17 09:37:15 +00:00
|
|
|
if (transport->verbose > 1)
|
2007-10-16 04:28:32 +00:00
|
|
|
args[i++] = "-v";
|
|
|
|
args[i++] = "--ignore-existing";
|
|
|
|
args[i++] = "--exclude";
|
|
|
|
args[i++] = "info";
|
|
|
|
args[i++] = get_object_directory();
|
|
|
|
args[i++] = buf.buf;
|
|
|
|
args[i++] = NULL;
|
2007-09-30 23:59:39 +00:00
|
|
|
|
|
|
|
if (run_command(&rsync))
|
2009-03-09 18:44:55 +00:00
|
|
|
return error("Could not push objects to %s",
|
|
|
|
rsync_url(transport->url));
|
2007-09-30 23:59:39 +00:00
|
|
|
|
|
|
|
/* copy the refs to the temporary directory; they could be packed. */
|
|
|
|
|
|
|
|
strbuf_addstr(&temp_dir, git_path("rsync-refs-XXXXXX"));
|
|
|
|
if (!mkdtemp(temp_dir.buf))
|
2009-06-27 15:58:47 +00:00
|
|
|
die_errno ("Could not make temporary directory");
|
2007-09-30 23:59:39 +00:00
|
|
|
strbuf_addch(&temp_dir, '/');
|
|
|
|
|
|
|
|
if (flags & TRANSPORT_PUSH_ALL) {
|
|
|
|
if (for_each_ref(write_one_ref, &temp_dir))
|
|
|
|
return -1;
|
|
|
|
} else if (write_refs_to_temp_dir(&temp_dir, refspec_nr, refspec))
|
|
|
|
return -1;
|
|
|
|
|
2007-10-16 04:28:32 +00:00
|
|
|
i = 2;
|
|
|
|
if (flags & TRANSPORT_PUSH_DRY_RUN)
|
|
|
|
args[i++] = "--dry-run";
|
|
|
|
if (!(flags & TRANSPORT_PUSH_FORCE))
|
|
|
|
args[i++] = "--ignore-existing";
|
2007-09-30 23:59:39 +00:00
|
|
|
args[i++] = temp_dir.buf;
|
2009-03-09 18:44:55 +00:00
|
|
|
args[i++] = rsync_url(transport->url);
|
2007-09-30 23:59:39 +00:00
|
|
|
args[i++] = NULL;
|
|
|
|
if (run_command(&rsync))
|
2009-03-09 18:44:55 +00:00
|
|
|
result = error("Could not push to %s",
|
|
|
|
rsync_url(transport->url));
|
2007-09-30 23:59:39 +00:00
|
|
|
|
|
|
|
if (remove_dir_recursively(&temp_dir, 0))
|
|
|
|
warning ("Could not remove temporary directory %s.",
|
|
|
|
temp_dir.buf);
|
|
|
|
|
|
|
|
strbuf_release(&buf);
|
|
|
|
strbuf_release(&temp_dir);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2007-09-11 03:03:11 +00:00
|
|
|
|
2007-09-11 03:03:21 +00:00
|
|
|
struct bundle_transport_data {
|
|
|
|
int fd;
|
|
|
|
struct bundle_header header;
|
|
|
|
};
|
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
static struct ref *get_refs_from_bundle(struct transport *transport, int for_push)
|
2007-09-11 03:03:21 +00:00
|
|
|
{
|
|
|
|
struct bundle_transport_data *data = transport->data;
|
|
|
|
struct ref *result = NULL;
|
|
|
|
int i;
|
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
if (for_push)
|
|
|
|
return NULL;
|
|
|
|
|
2007-09-11 03:03:21 +00:00
|
|
|
if (data->fd > 0)
|
|
|
|
close(data->fd);
|
|
|
|
data->fd = read_bundle_header(transport->url, &data->header);
|
|
|
|
if (data->fd < 0)
|
|
|
|
die ("Could not read bundle '%s'.", transport->url);
|
|
|
|
for (i = 0; i < data->header.references.nr; i++) {
|
|
|
|
struct ref_list_entry *e = data->header.references.list + i;
|
2008-10-18 08:44:18 +00:00
|
|
|
struct ref *ref = alloc_ref(e->name);
|
2007-09-11 03:03:21 +00:00
|
|
|
hashcpy(ref->old_sha1, e->sha1);
|
|
|
|
ref->next = result;
|
|
|
|
result = ref;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2007-09-14 07:31:23 +00:00
|
|
|
static int fetch_refs_from_bundle(struct transport *transport,
|
2009-11-18 01:42:24 +00:00
|
|
|
int nr_heads, struct ref **to_fetch)
|
2007-09-11 03:03:21 +00:00
|
|
|
{
|
|
|
|
struct bundle_transport_data *data = transport->data;
|
2011-09-18 23:52:32 +00:00
|
|
|
return unbundle(&data->header, data->fd,
|
|
|
|
transport->progress ? BUNDLE_VERBOSE : 0);
|
2007-09-11 03:03:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int close_bundle(struct transport *transport)
|
|
|
|
{
|
|
|
|
struct bundle_transport_data *data = transport->data;
|
|
|
|
if (data->fd > 0)
|
|
|
|
close(data->fd);
|
2007-09-19 04:49:42 +00:00
|
|
|
free(data);
|
2007-09-11 03:03:21 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-11 03:03:04 +00:00
|
|
|
struct git_transport_data {
|
2009-12-09 15:26:30 +00:00
|
|
|
struct git_transport_options options;
|
2008-02-04 18:26:23 +00:00
|
|
|
struct child_process *conn;
|
|
|
|
int fd[2];
|
2009-12-09 15:26:31 +00:00
|
|
|
unsigned got_remote_heads : 1;
|
2009-03-09 01:06:07 +00:00
|
|
|
struct extra_have_objects extra_have;
|
2007-09-11 03:03:04 +00:00
|
|
|
};
|
|
|
|
|
2009-12-09 15:26:30 +00:00
|
|
|
static int set_git_option(struct git_transport_options *opts,
|
2007-09-11 03:03:04 +00:00
|
|
|
const char *name, const char *value)
|
|
|
|
{
|
2007-09-11 03:03:11 +00:00
|
|
|
if (!strcmp(name, TRANS_OPT_UPLOADPACK)) {
|
2009-12-09 15:26:30 +00:00
|
|
|
opts->uploadpack = value;
|
2007-09-11 03:03:11 +00:00
|
|
|
return 0;
|
|
|
|
} else if (!strcmp(name, TRANS_OPT_RECEIVEPACK)) {
|
2009-12-09 15:26:30 +00:00
|
|
|
opts->receivepack = value;
|
2007-09-11 03:03:04 +00:00
|
|
|
return 0;
|
|
|
|
} else if (!strcmp(name, TRANS_OPT_THIN)) {
|
2009-12-09 15:26:30 +00:00
|
|
|
opts->thin = !!value;
|
2007-09-11 03:03:04 +00:00
|
|
|
return 0;
|
2008-03-04 03:27:40 +00:00
|
|
|
} else if (!strcmp(name, TRANS_OPT_FOLLOWTAGS)) {
|
2009-12-09 15:26:30 +00:00
|
|
|
opts->followtags = !!value;
|
2008-03-04 03:27:40 +00:00
|
|
|
return 0;
|
2007-09-11 03:03:11 +00:00
|
|
|
} else if (!strcmp(name, TRANS_OPT_KEEP)) {
|
2009-12-09 15:26:30 +00:00
|
|
|
opts->keep = !!value;
|
2007-09-11 03:03:11 +00:00
|
|
|
return 0;
|
|
|
|
} else if (!strcmp(name, TRANS_OPT_DEPTH)) {
|
|
|
|
if (!value)
|
2009-12-09 15:26:30 +00:00
|
|
|
opts->depth = 0;
|
2012-01-04 10:01:55 +00:00
|
|
|
else {
|
|
|
|
char *end;
|
|
|
|
opts->depth = strtol(value, &end, 0);
|
|
|
|
if (*end)
|
|
|
|
die("transport: invalid depth option '%s'", value);
|
|
|
|
}
|
2007-09-11 03:03:11 +00:00
|
|
|
return 0;
|
2007-09-11 03:03:04 +00:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
static int connect_setup(struct transport *transport, int for_push, int verbose)
|
2008-02-04 18:26:23 +00:00
|
|
|
{
|
|
|
|
struct git_transport_data *data = transport->data;
|
2009-12-09 15:26:31 +00:00
|
|
|
|
|
|
|
if (data->conn)
|
|
|
|
return 0;
|
|
|
|
|
2011-09-06 18:06:32 +00:00
|
|
|
data->conn = git_connect(data->fd, transport->url,
|
|
|
|
for_push ? data->options.receivepack :
|
|
|
|
data->options.uploadpack,
|
2009-03-09 01:06:07 +00:00
|
|
|
verbose ? CONNECT_VERBOSE : 0);
|
2009-12-09 15:26:31 +00:00
|
|
|
|
2008-02-04 18:26:23 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
static struct ref *get_refs_via_connect(struct transport *transport, int for_push)
|
2007-09-11 03:03:11 +00:00
|
|
|
{
|
|
|
|
struct git_transport_data *data = transport->data;
|
|
|
|
struct ref *refs;
|
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
connect_setup(transport, for_push, 0);
|
2013-02-20 20:06:45 +00:00
|
|
|
get_remote_heads(data->fd[0], NULL, 0, &refs,
|
2009-03-09 01:06:07 +00:00
|
|
|
for_push ? REF_NORMAL : 0, &data->extra_have);
|
2009-12-09 15:26:31 +00:00
|
|
|
data->got_remote_heads = 1;
|
2007-09-11 03:03:11 +00:00
|
|
|
|
|
|
|
return refs;
|
|
|
|
}
|
|
|
|
|
2007-09-14 07:31:23 +00:00
|
|
|
static int fetch_refs_via_pack(struct transport *transport,
|
2009-11-18 01:42:24 +00:00
|
|
|
int nr_heads, struct ref **to_fetch)
|
2007-09-11 03:03:11 +00:00
|
|
|
{
|
|
|
|
struct git_transport_data *data = transport->data;
|
2008-02-04 18:26:23 +00:00
|
|
|
const struct ref *refs;
|
2007-09-11 03:03:11 +00:00
|
|
|
char *dest = xstrdup(transport->url);
|
|
|
|
struct fetch_pack_args args;
|
2008-02-28 16:10:51 +00:00
|
|
|
struct ref *refs_tmp = NULL;
|
2007-09-11 03:03:11 +00:00
|
|
|
|
2007-09-19 04:49:35 +00:00
|
|
|
memset(&args, 0, sizeof(args));
|
2009-12-09 15:26:30 +00:00
|
|
|
args.uploadpack = data->options.uploadpack;
|
|
|
|
args.keep_pack = data->options.keep;
|
2007-09-19 04:49:35 +00:00
|
|
|
args.lock_pack = 1;
|
2009-12-09 15:26:30 +00:00
|
|
|
args.use_thin_pack = data->options.thin;
|
|
|
|
args.include_tag = data->options.followtags;
|
make "git push -v" actually verbose
Providing a single "-v" to "git push" currently does
nothing. Giving two flags ("git push -v -v") turns on the
first level of verbosity.
This is caused by a regression introduced in 8afd8dc (push:
support multiple levels of verbosity, 2010-02-24). Before
the series containing 8afd8dc, the verbosity handling for
fetching and pushing was completely separate. Commit bde873c
refactored the verbosity handling out of the fetch side, and
then 8afd8dc converted push to use the refactored code.
However, the fetch and push sides numbered and passed along
their verbosity levels differently. For both, a verbosity
level of "-1" meant "quiet", and "0" meant "default output".
But from there they differed.
For fetch, a verbosity level of "1" indicated to the "fetch"
program that it should make the status table slightly more
verbose, showing up-to-date entries. A verbosity level of
"2" meant that we should pass a verbose flag to the
transport; in the case of fetch-pack, this displays protocol
debugging information.
As a result, the refactored code in bde873c checks for
"verbosity >= 2", and only then passes it on to the
transport. From the transport code's perspective, a
verbosity of 0 or 1 both meant "0".
Push, on the other hand, does not show its own status table;
that is always handled by the transport layer or below
(originally send-pack itself, but these days it is done by
the transport code). So a verbosity level of 1 meant that we
should pass the verbose flag to send-pack, so that it knows
we want a verbose status table. However, once 8afd8dc
switched it to the refactored fetch code, a verbosity level
of 1 was now being ignored. Thus, you needed to
artificially bump the verbosity to 2 (via "-v -v") to have
any effect.
We can fix this by letting the transport code know about the
true verbosity level (i.e., let it distinguish level 0 or
1).
We then have to also make an adjustment to any transport
methods that assumed "verbose > 0" meant they could spew
lots of debugging information. Before, they could only get
"0" or "2", but now they will also receive "1". They need to
adjust their condition for turning on such spew from
"verbose > 0" to "verbose > 1".
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-12-17 09:37:15 +00:00
|
|
|
args.verbose = (transport->verbose > 1);
|
2008-10-05 13:53:00 +00:00
|
|
|
args.quiet = (transport->verbose < 0);
|
2010-02-24 12:50:26 +00:00
|
|
|
args.no_progress = !transport->progress;
|
2009-12-09 15:26:30 +00:00
|
|
|
args.depth = data->options.depth;
|
2013-05-26 01:16:17 +00:00
|
|
|
args.check_self_contained_and_connected =
|
|
|
|
data->options.check_self_contained_and_connected;
|
2007-09-11 03:03:11 +00:00
|
|
|
|
2009-12-09 15:26:31 +00:00
|
|
|
if (!data->got_remote_heads) {
|
2009-03-09 01:06:07 +00:00
|
|
|
connect_setup(transport, 0, 0);
|
2013-02-20 20:06:45 +00:00
|
|
|
get_remote_heads(data->fd[0], NULL, 0, &refs_tmp, 0, NULL);
|
2009-12-09 15:26:31 +00:00
|
|
|
data->got_remote_heads = 1;
|
2008-02-04 18:26:23 +00:00
|
|
|
}
|
|
|
|
|
2008-02-28 16:10:51 +00:00
|
|
|
refs = fetch_pack(&args, data->fd, data->conn,
|
|
|
|
refs_tmp ? refs_tmp : transport->remote_refs,
|
2013-01-29 22:02:15 +00:00
|
|
|
dest, to_fetch, nr_heads,
|
|
|
|
&transport->pack_lockfile);
|
2008-02-04 18:26:23 +00:00
|
|
|
close(data->fd[0]);
|
|
|
|
close(data->fd[1]);
|
|
|
|
if (finish_connect(data->conn))
|
|
|
|
refs = NULL;
|
|
|
|
data->conn = NULL;
|
2009-12-09 15:26:31 +00:00
|
|
|
data->got_remote_heads = 0;
|
2013-05-26 01:16:17 +00:00
|
|
|
data->options.self_contained_and_connected =
|
|
|
|
args.self_contained_and_connected;
|
2007-09-11 03:03:11 +00:00
|
|
|
|
2008-02-28 16:10:51 +00:00
|
|
|
free_refs(refs_tmp);
|
|
|
|
|
2007-09-11 03:03:11 +00:00
|
|
|
free(dest);
|
2007-12-05 07:01:19 +00:00
|
|
|
return (refs ? 0 : -1);
|
2007-09-11 03:03:11 +00:00
|
|
|
}
|
|
|
|
|
2009-08-05 20:23:26 +00:00
|
|
|
static int push_had_errors(struct ref *ref)
|
|
|
|
{
|
|
|
|
for (; ref; ref = ref->next) {
|
|
|
|
switch (ref->status) {
|
|
|
|
case REF_STATUS_NONE:
|
|
|
|
case REF_STATUS_UPTODATE:
|
|
|
|
case REF_STATUS_OK:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-02-16 23:42:52 +00:00
|
|
|
int transport_refs_pushed(struct ref *ref)
|
2009-03-09 01:06:07 +00:00
|
|
|
{
|
|
|
|
for (; ref; ref = ref->next) {
|
|
|
|
switch(ref->status) {
|
|
|
|
case REF_STATUS_NONE:
|
|
|
|
case REF_STATUS_UPTODATE:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-02-16 23:42:52 +00:00
|
|
|
void transport_update_tracking_ref(struct remote *remote, struct ref *ref, int verbose)
|
2009-03-09 01:06:07 +00:00
|
|
|
{
|
|
|
|
struct refspec rs;
|
|
|
|
|
|
|
|
if (ref->status != REF_STATUS_OK && ref->status != REF_STATUS_UPTODATE)
|
|
|
|
return;
|
|
|
|
|
|
|
|
rs.src = ref->name;
|
|
|
|
rs.dst = NULL;
|
|
|
|
|
|
|
|
if (!remote_find_tracking(remote, &rs)) {
|
|
|
|
if (verbose)
|
|
|
|
fprintf(stderr, "updating local tracking ref '%s'\n", rs.dst);
|
|
|
|
if (ref->deletion) {
|
|
|
|
delete_ref(rs.dst, NULL, 0);
|
|
|
|
} else
|
|
|
|
update_ref("update by push", rs.dst,
|
|
|
|
ref->new_sha1, NULL, 0, 0);
|
|
|
|
free(rs.dst);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-23 01:10:01 +00:00
|
|
|
static void print_ref_status(char flag, const char *summary, struct ref *to, struct ref *from, const char *msg, int porcelain)
|
2009-03-09 01:06:07 +00:00
|
|
|
{
|
2009-06-23 01:10:01 +00:00
|
|
|
if (porcelain) {
|
|
|
|
if (from)
|
|
|
|
fprintf(stdout, "%c\t%s:%s\t", flag, from->name, to->name);
|
|
|
|
else
|
|
|
|
fprintf(stdout, "%c\t:%s\t", flag, to->name);
|
|
|
|
if (msg)
|
|
|
|
fprintf(stdout, "%s (%s)\n", summary, msg);
|
|
|
|
else
|
|
|
|
fprintf(stdout, "%s\n", summary);
|
|
|
|
} else {
|
2010-02-16 23:42:52 +00:00
|
|
|
fprintf(stderr, " %c %-*s ", flag, TRANSPORT_SUMMARY_WIDTH, summary);
|
2009-06-23 01:10:01 +00:00
|
|
|
if (from)
|
|
|
|
fprintf(stderr, "%s -> %s", prettify_refname(from->name), prettify_refname(to->name));
|
|
|
|
else
|
|
|
|
fputs(prettify_refname(to->name), stderr);
|
|
|
|
if (msg) {
|
|
|
|
fputs(" (", stderr);
|
|
|
|
fputs(msg, stderr);
|
|
|
|
fputc(')', stderr);
|
|
|
|
}
|
|
|
|
fputc('\n', stderr);
|
2009-03-09 01:06:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *status_abbrev(unsigned char sha1[20])
|
|
|
|
{
|
|
|
|
return find_unique_abbrev(sha1, DEFAULT_ABBREV);
|
|
|
|
}
|
|
|
|
|
2009-06-23 01:10:01 +00:00
|
|
|
static void print_ok_ref_status(struct ref *ref, int porcelain)
|
2009-03-09 01:06:07 +00:00
|
|
|
{
|
|
|
|
if (ref->deletion)
|
2009-06-23 01:10:01 +00:00
|
|
|
print_ref_status('-', "[deleted]", ref, NULL, NULL, porcelain);
|
2009-03-09 01:06:07 +00:00
|
|
|
else if (is_null_sha1(ref->old_sha1))
|
|
|
|
print_ref_status('*',
|
|
|
|
(!prefixcmp(ref->name, "refs/tags/") ? "[new tag]" :
|
2009-06-23 01:10:01 +00:00
|
|
|
"[new branch]"),
|
|
|
|
ref, ref->peer_ref, NULL, porcelain);
|
2009-03-09 01:06:07 +00:00
|
|
|
else {
|
|
|
|
char quickref[84];
|
|
|
|
char type;
|
|
|
|
const char *msg;
|
|
|
|
|
|
|
|
strcpy(quickref, status_abbrev(ref->old_sha1));
|
2013-01-22 04:24:07 +00:00
|
|
|
if (ref->forced_update) {
|
2009-03-09 01:06:07 +00:00
|
|
|
strcat(quickref, "...");
|
|
|
|
type = '+';
|
|
|
|
msg = "forced update";
|
|
|
|
} else {
|
|
|
|
strcat(quickref, "..");
|
|
|
|
type = ' ';
|
|
|
|
msg = NULL;
|
|
|
|
}
|
|
|
|
strcat(quickref, status_abbrev(ref->new_sha1));
|
|
|
|
|
2009-06-23 01:10:01 +00:00
|
|
|
print_ref_status(type, quickref, ref, ref->peer_ref, msg, porcelain);
|
2009-03-09 01:06:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-23 01:10:01 +00:00
|
|
|
static int print_one_push_status(struct ref *ref, const char *dest, int count, int porcelain)
|
2009-03-09 01:06:07 +00:00
|
|
|
{
|
|
|
|
if (!count)
|
2010-02-27 04:52:14 +00:00
|
|
|
fprintf(porcelain ? stdout : stderr, "To %s\n", dest);
|
2009-03-09 01:06:07 +00:00
|
|
|
|
|
|
|
switch(ref->status) {
|
|
|
|
case REF_STATUS_NONE:
|
2009-06-23 01:10:01 +00:00
|
|
|
print_ref_status('X', "[no match]", ref, NULL, NULL, porcelain);
|
2009-03-09 01:06:07 +00:00
|
|
|
break;
|
|
|
|
case REF_STATUS_REJECT_NODELETE:
|
|
|
|
print_ref_status('!', "[rejected]", ref, NULL,
|
2009-06-23 01:10:01 +00:00
|
|
|
"remote does not support deleting refs", porcelain);
|
2009-03-09 01:06:07 +00:00
|
|
|
break;
|
|
|
|
case REF_STATUS_UPTODATE:
|
|
|
|
print_ref_status('=', "[up to date]", ref,
|
2009-06-23 01:10:01 +00:00
|
|
|
ref->peer_ref, NULL, porcelain);
|
2009-03-09 01:06:07 +00:00
|
|
|
break;
|
|
|
|
case REF_STATUS_REJECT_NONFASTFORWARD:
|
|
|
|
print_ref_status('!', "[rejected]", ref, ref->peer_ref,
|
2009-10-24 08:31:32 +00:00
|
|
|
"non-fast-forward", porcelain);
|
2009-03-09 01:06:07 +00:00
|
|
|
break;
|
2012-11-30 01:41:37 +00:00
|
|
|
case REF_STATUS_REJECT_ALREADY_EXISTS:
|
|
|
|
print_ref_status('!', "[rejected]", ref, ref->peer_ref,
|
|
|
|
"already exists", porcelain);
|
|
|
|
break;
|
push: introduce REJECT_FETCH_FIRST and REJECT_NEEDS_FORCE
When we push to update an existing ref, if:
* the object at the tip of the remote is not a commit; or
* the object we are pushing is not a commit,
it won't be correct to suggest to fetch, integrate and push again,
as the old and new objects will not "merge". We should explain that
the push must be forced when there is a non-committish object is
involved in such a case.
If we do not have the current object at the tip of the remote, we do
not even know that object, when fetched, is something that can be
merged. In such a case, suggesting to pull first just like
non-fast-forward case may not be technically correct, but in
practice, most such failures are seen when you try to push your work
to a branch without knowing that somebody else already pushed to
update the same branch since you forked, so "pull first" would work
as a suggestion most of the time. And if the object at the tip is
not a commit, "pull first" will fail, without making any permanent
damage. As a side effect, it also makes the error message the user
will get during the next "push" attempt easier to understand, now
the user is aware that a non-commit object is involved.
In these cases, the current code already rejects such a push on the
client end, but we used the same error and advice messages as the
ones used when rejecting a non-fast-forward push, i.e. pull from
there and integrate before pushing again.
Introduce new rejection reasons and reword the messages
appropriately.
[jc: with help by Peff on message details]
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-23 21:55:30 +00:00
|
|
|
case REF_STATUS_REJECT_FETCH_FIRST:
|
|
|
|
print_ref_status('!', "[rejected]", ref, ref->peer_ref,
|
|
|
|
"fetch first", porcelain);
|
|
|
|
break;
|
|
|
|
case REF_STATUS_REJECT_NEEDS_FORCE:
|
|
|
|
print_ref_status('!', "[rejected]", ref, ref->peer_ref,
|
|
|
|
"needs force", porcelain);
|
|
|
|
break;
|
2009-03-09 01:06:07 +00:00
|
|
|
case REF_STATUS_REMOTE_REJECT:
|
|
|
|
print_ref_status('!', "[remote rejected]", ref,
|
2009-06-23 01:10:01 +00:00
|
|
|
ref->deletion ? NULL : ref->peer_ref,
|
|
|
|
ref->remote_status, porcelain);
|
2009-03-09 01:06:07 +00:00
|
|
|
break;
|
|
|
|
case REF_STATUS_EXPECTING_REPORT:
|
|
|
|
print_ref_status('!', "[remote failure]", ref,
|
2009-06-23 01:10:01 +00:00
|
|
|
ref->deletion ? NULL : ref->peer_ref,
|
|
|
|
"remote failed to report status", porcelain);
|
2009-03-09 01:06:07 +00:00
|
|
|
break;
|
|
|
|
case REF_STATUS_OK:
|
2009-06-23 01:10:01 +00:00
|
|
|
print_ok_ref_status(ref, porcelain);
|
2009-03-09 01:06:07 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2010-02-16 23:42:52 +00:00
|
|
|
void transport_print_push_status(const char *dest, struct ref *refs,
|
2012-11-30 01:41:33 +00:00
|
|
|
int verbose, int porcelain, unsigned int *reject_reasons)
|
2009-03-09 01:06:07 +00:00
|
|
|
{
|
|
|
|
struct ref *ref;
|
|
|
|
int n = 0;
|
push: Provide situational hints for non-fast-forward errors
Pushing a non-fast-forward update to a remote repository will result in
an error, but the hint text doesn't provide the correct resolution in
every case. Give better resolution advice in three push scenarios:
1) If you push your current branch and it triggers a non-fast-forward
error, you should merge remote changes with 'git pull' before pushing
again.
2) If you push to a shared repository others push to, and your local
tracking branches are not kept up to date, the 'matching refs' default
will generate non-fast-forward errors on outdated branches. If this is
your workflow, the 'matching refs' default is not for you. Consider
setting the 'push.default' configuration variable to 'current' or
'upstream' to ensure only your current branch is pushed.
3) If you explicitly specify a ref that is not your current branch or
push matching branches with ':', you will generate a non-fast-forward
error if any pushed branch tip is out of date. You should checkout the
offending branch and merge remote changes before pushing again.
Teach transport.c to recognize these scenarios and configure push.c
to hint for them. If 'git push's default behavior changes or we
discover more scenarios, extension is easy. Standardize on the
advice API and add three new advice variables, 'pushNonFFCurrent',
'pushNonFFDefault', and 'pushNonFFMatching'. Setting any of these
to 'false' will disable their affiliated advice. Setting
'pushNonFastForward' to false will disable all three, thus preserving the
config option for users who already set it, but guaranteeing new
users won't disable push advice accidentally.
Based-on-patch-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Christopher Tiwald <christiwald@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-03-20 04:31:33 +00:00
|
|
|
unsigned char head_sha1[20];
|
|
|
|
char *head;
|
|
|
|
|
|
|
|
head = resolve_refdup("HEAD", head_sha1, 1, NULL);
|
2009-03-09 01:06:07 +00:00
|
|
|
|
|
|
|
if (verbose) {
|
|
|
|
for (ref = refs; ref; ref = ref->next)
|
|
|
|
if (ref->status == REF_STATUS_UPTODATE)
|
2009-06-23 01:10:01 +00:00
|
|
|
n += print_one_push_status(ref, dest, n, porcelain);
|
2009-03-09 01:06:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (ref = refs; ref; ref = ref->next)
|
|
|
|
if (ref->status == REF_STATUS_OK)
|
2009-06-23 01:10:01 +00:00
|
|
|
n += print_one_push_status(ref, dest, n, porcelain);
|
2009-03-09 01:06:07 +00:00
|
|
|
|
2012-11-30 01:41:33 +00:00
|
|
|
*reject_reasons = 0;
|
2009-03-09 01:06:07 +00:00
|
|
|
for (ref = refs; ref; ref = ref->next) {
|
|
|
|
if (ref->status != REF_STATUS_NONE &&
|
|
|
|
ref->status != REF_STATUS_UPTODATE &&
|
|
|
|
ref->status != REF_STATUS_OK)
|
2009-06-23 01:10:01 +00:00
|
|
|
n += print_one_push_status(ref, dest, n, porcelain);
|
2012-11-30 01:41:33 +00:00
|
|
|
if (ref->status == REF_STATUS_REJECT_NONFASTFORWARD) {
|
2013-01-31 12:22:51 +00:00
|
|
|
if (head != NULL && !strcmp(head, ref->name))
|
2012-11-30 01:41:33 +00:00
|
|
|
*reject_reasons |= REJECT_NON_FF_HEAD;
|
push: Provide situational hints for non-fast-forward errors
Pushing a non-fast-forward update to a remote repository will result in
an error, but the hint text doesn't provide the correct resolution in
every case. Give better resolution advice in three push scenarios:
1) If you push your current branch and it triggers a non-fast-forward
error, you should merge remote changes with 'git pull' before pushing
again.
2) If you push to a shared repository others push to, and your local
tracking branches are not kept up to date, the 'matching refs' default
will generate non-fast-forward errors on outdated branches. If this is
your workflow, the 'matching refs' default is not for you. Consider
setting the 'push.default' configuration variable to 'current' or
'upstream' to ensure only your current branch is pushed.
3) If you explicitly specify a ref that is not your current branch or
push matching branches with ':', you will generate a non-fast-forward
error if any pushed branch tip is out of date. You should checkout the
offending branch and merge remote changes before pushing again.
Teach transport.c to recognize these scenarios and configure push.c
to hint for them. If 'git push's default behavior changes or we
discover more scenarios, extension is easy. Standardize on the
advice API and add three new advice variables, 'pushNonFFCurrent',
'pushNonFFDefault', and 'pushNonFFMatching'. Setting any of these
to 'false' will disable their affiliated advice. Setting
'pushNonFastForward' to false will disable all three, thus preserving the
config option for users who already set it, but guaranteeing new
users won't disable push advice accidentally.
Based-on-patch-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Christopher Tiwald <christiwald@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-03-20 04:31:33 +00:00
|
|
|
else
|
2012-11-30 01:41:33 +00:00
|
|
|
*reject_reasons |= REJECT_NON_FF_OTHER;
|
2012-11-30 01:41:37 +00:00
|
|
|
} else if (ref->status == REF_STATUS_REJECT_ALREADY_EXISTS) {
|
|
|
|
*reject_reasons |= REJECT_ALREADY_EXISTS;
|
push: introduce REJECT_FETCH_FIRST and REJECT_NEEDS_FORCE
When we push to update an existing ref, if:
* the object at the tip of the remote is not a commit; or
* the object we are pushing is not a commit,
it won't be correct to suggest to fetch, integrate and push again,
as the old and new objects will not "merge". We should explain that
the push must be forced when there is a non-committish object is
involved in such a case.
If we do not have the current object at the tip of the remote, we do
not even know that object, when fetched, is something that can be
merged. In such a case, suggesting to pull first just like
non-fast-forward case may not be technically correct, but in
practice, most such failures are seen when you try to push your work
to a branch without knowing that somebody else already pushed to
update the same branch since you forked, so "pull first" would work
as a suggestion most of the time. And if the object at the tip is
not a commit, "pull first" will fail, without making any permanent
damage. As a side effect, it also makes the error message the user
will get during the next "push" attempt easier to understand, now
the user is aware that a non-commit object is involved.
In these cases, the current code already rejects such a push on the
client end, but we used the same error and advice messages as the
ones used when rejecting a non-fast-forward push, i.e. pull from
there and integrate before pushing again.
Introduce new rejection reasons and reword the messages
appropriately.
[jc: with help by Peff on message details]
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-23 21:55:30 +00:00
|
|
|
} else if (ref->status == REF_STATUS_REJECT_FETCH_FIRST) {
|
|
|
|
*reject_reasons |= REJECT_FETCH_FIRST;
|
|
|
|
} else if (ref->status == REF_STATUS_REJECT_NEEDS_FORCE) {
|
|
|
|
*reject_reasons |= REJECT_NEEDS_FORCE;
|
push: Provide situational hints for non-fast-forward errors
Pushing a non-fast-forward update to a remote repository will result in
an error, but the hint text doesn't provide the correct resolution in
every case. Give better resolution advice in three push scenarios:
1) If you push your current branch and it triggers a non-fast-forward
error, you should merge remote changes with 'git pull' before pushing
again.
2) If you push to a shared repository others push to, and your local
tracking branches are not kept up to date, the 'matching refs' default
will generate non-fast-forward errors on outdated branches. If this is
your workflow, the 'matching refs' default is not for you. Consider
setting the 'push.default' configuration variable to 'current' or
'upstream' to ensure only your current branch is pushed.
3) If you explicitly specify a ref that is not your current branch or
push matching branches with ':', you will generate a non-fast-forward
error if any pushed branch tip is out of date. You should checkout the
offending branch and merge remote changes before pushing again.
Teach transport.c to recognize these scenarios and configure push.c
to hint for them. If 'git push's default behavior changes or we
discover more scenarios, extension is easy. Standardize on the
advice API and add three new advice variables, 'pushNonFFCurrent',
'pushNonFFDefault', and 'pushNonFFMatching'. Setting any of these
to 'false' will disable their affiliated advice. Setting
'pushNonFastForward' to false will disable all three, thus preserving the
config option for users who already set it, but guaranteeing new
users won't disable push advice accidentally.
Based-on-patch-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Christopher Tiwald <christiwald@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-03-20 04:31:33 +00:00
|
|
|
}
|
2009-03-09 01:06:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-16 23:42:52 +00:00
|
|
|
void transport_verify_remote_names(int nr_heads, const char **heads)
|
2009-03-09 01:06:07 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < nr_heads; i++) {
|
|
|
|
const char *local = heads[i];
|
|
|
|
const char *remote = strrchr(heads[i], ':');
|
|
|
|
|
|
|
|
if (*local == '+')
|
|
|
|
local++;
|
|
|
|
|
|
|
|
/* A matching refspec is okay. */
|
|
|
|
if (remote == local && remote[1] == '\0')
|
|
|
|
continue;
|
|
|
|
|
|
|
|
remote = remote ? (remote + 1) : local;
|
2011-09-15 21:10:25 +00:00
|
|
|
if (check_refname_format(remote,
|
|
|
|
REFNAME_ALLOW_ONELEVEL|REFNAME_REFSPEC_PATTERN))
|
|
|
|
die("remote part of refspec is not a valid name in %s",
|
|
|
|
heads[i]);
|
2009-03-09 01:06:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int git_transport_push(struct transport *transport, struct ref *remote_refs, int flags)
|
2007-11-08 23:35:32 +00:00
|
|
|
{
|
2007-09-11 03:03:04 +00:00
|
|
|
struct git_transport_data *data = transport->data;
|
2007-10-30 02:03:42 +00:00
|
|
|
struct send_pack_args args;
|
2009-03-09 01:06:07 +00:00
|
|
|
int ret;
|
|
|
|
|
2009-12-09 15:26:31 +00:00
|
|
|
if (!data->got_remote_heads) {
|
2009-03-09 01:06:07 +00:00
|
|
|
struct ref *tmp_refs;
|
|
|
|
connect_setup(transport, 1, 0);
|
|
|
|
|
2013-02-20 20:06:45 +00:00
|
|
|
get_remote_heads(data->fd[0], NULL, 0, &tmp_refs, REF_NORMAL, NULL);
|
2009-12-09 15:26:31 +00:00
|
|
|
data->got_remote_heads = 1;
|
2009-03-09 01:06:07 +00:00
|
|
|
}
|
2007-09-11 03:03:04 +00:00
|
|
|
|
2009-10-31 00:47:41 +00:00
|
|
|
memset(&args, 0, sizeof(args));
|
2007-11-09 23:32:25 +00:00
|
|
|
args.send_mirror = !!(flags & TRANSPORT_PUSH_MIRROR);
|
2007-10-30 02:03:42 +00:00
|
|
|
args.force_update = !!(flags & TRANSPORT_PUSH_FORCE);
|
2009-12-09 15:26:30 +00:00
|
|
|
args.use_thin_pack = data->options.thin;
|
2010-02-24 12:50:24 +00:00
|
|
|
args.verbose = (transport->verbose > 0);
|
|
|
|
args.quiet = (transport->verbose < 0);
|
2010-10-16 18:37:03 +00:00
|
|
|
args.progress = transport->progress;
|
2007-10-30 02:03:42 +00:00
|
|
|
args.dry_run = !!(flags & TRANSPORT_PUSH_DRY_RUN);
|
2010-02-27 04:52:15 +00:00
|
|
|
args.porcelain = !!(flags & TRANSPORT_PUSH_PORCELAIN);
|
2007-10-30 02:03:42 +00:00
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
ret = send_pack(&args, data->fd, data->conn, remote_refs,
|
|
|
|
&data->extra_have);
|
|
|
|
|
|
|
|
close(data->fd[1]);
|
|
|
|
close(data->fd[0]);
|
|
|
|
ret |= finish_connect(data->conn);
|
|
|
|
data->conn = NULL;
|
2009-12-09 15:26:31 +00:00
|
|
|
data->got_remote_heads = 0;
|
2009-03-09 01:06:07 +00:00
|
|
|
|
|
|
|
return ret;
|
2007-09-11 03:03:04 +00:00
|
|
|
}
|
|
|
|
|
2009-12-09 15:26:33 +00:00
|
|
|
static int connect_git(struct transport *transport, const char *name,
|
|
|
|
const char *executable, int fd[2])
|
|
|
|
{
|
|
|
|
struct git_transport_data *data = transport->data;
|
|
|
|
data->conn = git_connect(data->fd, transport->url,
|
|
|
|
executable, 0);
|
|
|
|
fd[0] = data->fd[0];
|
|
|
|
fd[1] = data->fd[1];
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-19 04:49:42 +00:00
|
|
|
static int disconnect_git(struct transport *transport)
|
|
|
|
{
|
2008-02-04 18:26:23 +00:00
|
|
|
struct git_transport_data *data = transport->data;
|
|
|
|
if (data->conn) {
|
2009-12-09 15:26:31 +00:00
|
|
|
if (data->got_remote_heads)
|
|
|
|
packet_flush(data->fd[1]);
|
2008-02-04 18:26:23 +00:00
|
|
|
close(data->fd[0]);
|
|
|
|
close(data->fd[1]);
|
|
|
|
finish_connect(data->conn);
|
|
|
|
}
|
|
|
|
|
|
|
|
free(data);
|
2007-09-19 04:49:42 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-09 15:26:31 +00:00
|
|
|
void transport_take_over(struct transport *transport,
|
|
|
|
struct child_process *child)
|
|
|
|
{
|
|
|
|
struct git_transport_data *data;
|
|
|
|
|
|
|
|
if (!transport->smart_options)
|
|
|
|
die("Bug detected: Taking over transport requires non-NULL "
|
|
|
|
"smart_options field.");
|
|
|
|
|
|
|
|
data = xcalloc(1, sizeof(*data));
|
|
|
|
data->options = *transport->smart_options;
|
|
|
|
data->conn = child;
|
|
|
|
data->fd[0] = data->conn->out;
|
|
|
|
data->fd[1] = data->conn->in;
|
|
|
|
data->got_remote_heads = 0;
|
|
|
|
transport->data = data;
|
|
|
|
|
|
|
|
transport->set_option = NULL;
|
|
|
|
transport->get_refs_list = get_refs_via_connect;
|
|
|
|
transport->fetch = fetch_refs_via_pack;
|
|
|
|
transport->push = NULL;
|
|
|
|
transport->push_refs = git_transport_push;
|
|
|
|
transport->disconnect = disconnect_git;
|
|
|
|
transport->smart_options = &(data->options);
|
fetch: work around "transport-take-over" hack
A Git-aware "connect" transport allows the "transport_take_over" to
redirect generic transport requests like fetch(), push_refs() and
get_refs_list() to the native Git transport handling methods. The
take-over process replaces transport->data with a fake data that
these method implementations understand.
While this hack works OK for a single request, it breaks when the
transport needs to make more than one requests. transport->data
that used to hold necessary information for the specific helper to
work correctly is destroyed during the take-over process.
One codepath that this matters is "git fetch" in auto-follow mode;
when it does not get all the tags that ought to point at the history
it got (which can be determined by looking at the peeled tags in the
initial advertisement) from the primary transfer, it internally
makes a second request to complete the fetch. Because "take-over"
hack has already destroyed the data necessary to talk to the
transport helper by the time this happens, the second request cannot
make a request to the helper to make another connection to fetch
these additional tags.
Mark such a transport as "cannot_reuse", and use a separate
transport to perform the backfill fetch in order to work around
this breakage.
Note that this problem does not manifest itself when running t5802,
because our upload-pack gives you all the necessary auto-followed
tags during the primary transfer. You would need to step through
"git fetch" in a debugger, stop immediately after the primary
transfer finishes and writes these auto-followed tags, remove the
tag references and repack/prune the repository to convince the
"find-non-local-tags" procedure that the primary transfer failed to
give us all the necessary tags, and then let it continue, in order
to trigger the bug in the secondary transfer this patch fixes.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-08-07 22:47:18 +00:00
|
|
|
|
|
|
|
transport->cannot_reuse = 1;
|
2009-12-09 15:26:31 +00:00
|
|
|
}
|
|
|
|
|
2007-09-11 03:03:04 +00:00
|
|
|
static int is_local(const char *url)
|
|
|
|
{
|
|
|
|
const char *colon = strchr(url, ':');
|
|
|
|
const char *slash = strchr(url, '/');
|
2007-11-30 21:51:10 +00:00
|
|
|
return !colon || (slash && slash < colon) ||
|
|
|
|
has_dos_drive_prefix(url);
|
2007-09-11 03:03:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int is_file(const char *url)
|
|
|
|
{
|
|
|
|
struct stat buf;
|
|
|
|
if (stat(url, &buf))
|
|
|
|
return 0;
|
|
|
|
return S_ISREG(buf.st_mode);
|
|
|
|
}
|
|
|
|
|
2009-12-09 15:26:29 +00:00
|
|
|
static int external_specification_len(const char *url)
|
|
|
|
{
|
|
|
|
return strchr(url, ':') - url;
|
|
|
|
}
|
|
|
|
|
2007-09-15 07:23:14 +00:00
|
|
|
struct transport *transport_get(struct remote *remote, const char *url)
|
2007-09-11 03:03:04 +00:00
|
|
|
{
|
2010-01-27 17:53:17 +00:00
|
|
|
const char *helper;
|
2007-09-15 07:23:07 +00:00
|
|
|
struct transport *ret = xcalloc(1, sizeof(*ret));
|
|
|
|
|
2010-02-24 12:50:26 +00:00
|
|
|
ret->progress = isatty(2);
|
|
|
|
|
2009-11-04 02:38:51 +00:00
|
|
|
if (!remote)
|
|
|
|
die("No remote provided to transport_get()");
|
|
|
|
|
2010-02-16 07:18:21 +00:00
|
|
|
ret->got_remote_refs = 0;
|
2007-09-15 07:23:07 +00:00
|
|
|
ret->remote = remote;
|
2010-01-27 17:53:17 +00:00
|
|
|
helper = remote->foreign_vcs;
|
2009-11-18 01:42:22 +00:00
|
|
|
|
2010-01-27 20:22:37 +00:00
|
|
|
if (!url && remote->url)
|
2009-11-18 01:42:22 +00:00
|
|
|
url = remote->url[0];
|
2007-09-15 07:23:07 +00:00
|
|
|
ret->url = url;
|
|
|
|
|
2009-11-18 01:42:26 +00:00
|
|
|
/* maybe it is a foreign URL? */
|
|
|
|
if (url) {
|
|
|
|
const char *p = url;
|
|
|
|
|
2010-05-23 09:17:55 +00:00
|
|
|
while (is_urlschemechar(p == url, *p))
|
2009-11-18 01:42:26 +00:00
|
|
|
p++;
|
|
|
|
if (!prefixcmp(p, "::"))
|
2010-01-27 17:53:17 +00:00
|
|
|
helper = xstrndup(url, p - url);
|
2009-11-18 01:42:26 +00:00
|
|
|
}
|
|
|
|
|
2010-01-27 17:53:17 +00:00
|
|
|
if (helper) {
|
|
|
|
transport_helper_init(ret, helper);
|
2009-12-09 15:26:29 +00:00
|
|
|
} else if (!prefixcmp(url, "rsync:")) {
|
2007-09-30 23:59:39 +00:00
|
|
|
ret->get_refs_list = get_refs_via_rsync;
|
|
|
|
ret->fetch = fetch_objs_via_rsync;
|
|
|
|
ret->push = rsync_transport_push;
|
2009-12-09 15:26:30 +00:00
|
|
|
ret->smart_options = NULL;
|
2011-10-13 22:19:31 +00:00
|
|
|
} else if (is_local(url) && is_file(url) && is_bundle(url, 1)) {
|
2007-09-11 03:03:21 +00:00
|
|
|
struct bundle_transport_data *data = xcalloc(1, sizeof(*data));
|
|
|
|
ret->data = data;
|
2007-09-19 04:49:31 +00:00
|
|
|
ret->get_refs_list = get_refs_from_bundle;
|
|
|
|
ret->fetch = fetch_refs_from_bundle;
|
|
|
|
ret->disconnect = close_bundle;
|
2009-12-09 15:26:30 +00:00
|
|
|
ret->smart_options = NULL;
|
2009-12-09 15:26:29 +00:00
|
|
|
} else if (!is_url(url)
|
|
|
|
|| !prefixcmp(url, "file://")
|
|
|
|
|| !prefixcmp(url, "git://")
|
|
|
|
|| !prefixcmp(url, "ssh://")
|
|
|
|
|| !prefixcmp(url, "git+ssh://")
|
|
|
|
|| !prefixcmp(url, "ssh+git://")) {
|
|
|
|
/* These are builtin smart transports. */
|
2007-09-11 03:03:04 +00:00
|
|
|
struct git_transport_data *data = xcalloc(1, sizeof(*data));
|
|
|
|
ret->data = data;
|
2009-12-09 15:26:30 +00:00
|
|
|
ret->set_option = NULL;
|
2007-09-19 04:49:31 +00:00
|
|
|
ret->get_refs_list = get_refs_via_connect;
|
|
|
|
ret->fetch = fetch_refs_via_pack;
|
2009-03-09 01:06:07 +00:00
|
|
|
ret->push_refs = git_transport_push;
|
2009-12-09 15:26:33 +00:00
|
|
|
ret->connect = connect_git;
|
2007-09-19 04:49:42 +00:00
|
|
|
ret->disconnect = disconnect_git;
|
2009-12-09 15:26:30 +00:00
|
|
|
ret->smart_options = &(data->options);
|
2007-09-19 04:49:31 +00:00
|
|
|
|
2008-02-04 18:26:23 +00:00
|
|
|
data->conn = NULL;
|
2009-12-09 15:26:31 +00:00
|
|
|
data->got_remote_heads = 0;
|
2009-12-09 15:26:29 +00:00
|
|
|
} else {
|
|
|
|
/* Unknown protocol in URL. Pass to external handler. */
|
|
|
|
int len = external_specification_len(url);
|
|
|
|
char *handler = xmalloc(len + 1);
|
|
|
|
handler[len] = 0;
|
|
|
|
strncpy(handler, url, len);
|
|
|
|
transport_helper_init(ret, handler);
|
2007-09-11 03:03:04 +00:00
|
|
|
}
|
2007-09-15 07:23:07 +00:00
|
|
|
|
2009-12-09 15:26:30 +00:00
|
|
|
if (ret->smart_options) {
|
|
|
|
ret->smart_options->thin = 1;
|
|
|
|
ret->smart_options->uploadpack = "git-upload-pack";
|
|
|
|
if (remote->uploadpack)
|
|
|
|
ret->smart_options->uploadpack = remote->uploadpack;
|
|
|
|
ret->smart_options->receivepack = "git-receive-pack";
|
|
|
|
if (remote->receivepack)
|
|
|
|
ret->smart_options->receivepack = remote->receivepack;
|
|
|
|
}
|
|
|
|
|
2007-09-11 03:03:04 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int transport_set_option(struct transport *transport,
|
|
|
|
const char *name, const char *value)
|
|
|
|
{
|
2009-12-09 15:26:30 +00:00
|
|
|
int git_reports = 1, protocol_reports = 1;
|
|
|
|
|
|
|
|
if (transport->smart_options)
|
|
|
|
git_reports = set_git_option(transport->smart_options,
|
|
|
|
name, value);
|
|
|
|
|
2007-09-19 04:49:31 +00:00
|
|
|
if (transport->set_option)
|
2009-12-09 15:26:30 +00:00
|
|
|
protocol_reports = transport->set_option(transport, name,
|
|
|
|
value);
|
|
|
|
|
|
|
|
/* If either report is 0, report 0 (success). */
|
|
|
|
if (!git_reports || !protocol_reports)
|
|
|
|
return 0;
|
|
|
|
/* If either reports -1 (invalid value), report -1. */
|
|
|
|
if ((git_reports == -1) || (protocol_reports == -1))
|
|
|
|
return -1;
|
|
|
|
/* Otherwise if both report unknown, report unknown. */
|
2007-09-18 08:54:57 +00:00
|
|
|
return 1;
|
2007-09-11 03:03:04 +00:00
|
|
|
}
|
|
|
|
|
2010-02-24 12:50:26 +00:00
|
|
|
void transport_set_verbosity(struct transport *transport, int verbosity,
|
|
|
|
int force_progress)
|
2010-02-24 12:50:23 +00:00
|
|
|
{
|
make "git push -v" actually verbose
Providing a single "-v" to "git push" currently does
nothing. Giving two flags ("git push -v -v") turns on the
first level of verbosity.
This is caused by a regression introduced in 8afd8dc (push:
support multiple levels of verbosity, 2010-02-24). Before
the series containing 8afd8dc, the verbosity handling for
fetching and pushing was completely separate. Commit bde873c
refactored the verbosity handling out of the fetch side, and
then 8afd8dc converted push to use the refactored code.
However, the fetch and push sides numbered and passed along
their verbosity levels differently. For both, a verbosity
level of "-1" meant "quiet", and "0" meant "default output".
But from there they differed.
For fetch, a verbosity level of "1" indicated to the "fetch"
program that it should make the status table slightly more
verbose, showing up-to-date entries. A verbosity level of
"2" meant that we should pass a verbose flag to the
transport; in the case of fetch-pack, this displays protocol
debugging information.
As a result, the refactored code in bde873c checks for
"verbosity >= 2", and only then passes it on to the
transport. From the transport code's perspective, a
verbosity of 0 or 1 both meant "0".
Push, on the other hand, does not show its own status table;
that is always handled by the transport layer or below
(originally send-pack itself, but these days it is done by
the transport code). So a verbosity level of 1 meant that we
should pass the verbose flag to send-pack, so that it knows
we want a verbose status table. However, once 8afd8dc
switched it to the refactored fetch code, a verbosity level
of 1 was now being ignored. Thus, you needed to
artificially bump the verbosity to 2 (via "-v -v") to have
any effect.
We can fix this by letting the transport code know about the
true verbosity level (i.e., let it distinguish level 0 or
1).
We then have to also make an adjustment to any transport
methods that assumed "verbose > 0" meant they could spew
lots of debugging information. Before, they could only get
"0" or "2", but now they will also receive "1". They need to
adjust their condition for turning on such spew from
"verbose > 0" to "verbose > 1".
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-12-17 09:37:15 +00:00
|
|
|
if (verbosity >= 1)
|
2010-02-24 12:50:23 +00:00
|
|
|
transport->verbose = verbosity <= 3 ? verbosity : 3;
|
|
|
|
if (verbosity < 0)
|
|
|
|
transport->verbose = -1;
|
2010-02-24 12:50:26 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Rules used to determine whether to report progress (processing aborts
|
|
|
|
* when a rule is satisfied):
|
|
|
|
*
|
2012-02-13 20:17:15 +00:00
|
|
|
* . Report progress, if force_progress is 1 (ie. --progress).
|
|
|
|
* . Don't report progress, if force_progress is 0 (ie. --no-progress).
|
|
|
|
* . Don't report progress, if verbosity < 0 (ie. -q/--quiet ).
|
|
|
|
* . Report progress if isatty(2) is 1.
|
2010-02-24 12:50:26 +00:00
|
|
|
**/
|
2012-02-13 20:17:15 +00:00
|
|
|
if (force_progress >= 0)
|
|
|
|
transport->progress = !!force_progress;
|
|
|
|
else
|
|
|
|
transport->progress = verbosity >= 0 && isatty(2);
|
2010-02-24 12:50:23 +00:00
|
|
|
}
|
|
|
|
|
2012-03-29 07:21:23 +00:00
|
|
|
static void die_with_unpushed_submodules(struct string_list *needs_pushing)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
fprintf(stderr, "The following submodule paths contain changes that can\n"
|
|
|
|
"not be found on any remote:\n");
|
|
|
|
for (i = 0; i < needs_pushing->nr; i++)
|
|
|
|
printf(" %s\n", needs_pushing->items[i].string);
|
2012-03-29 07:21:24 +00:00
|
|
|
fprintf(stderr, "\nPlease try\n\n"
|
|
|
|
" git push --recurse-submodules=on-demand\n\n"
|
|
|
|
"or cd to the path and use\n\n"
|
|
|
|
" git push\n\n"
|
|
|
|
"to push them to a remote.\n\n");
|
2012-03-29 07:21:23 +00:00
|
|
|
|
|
|
|
string_list_clear(needs_pushing, 0);
|
|
|
|
|
|
|
|
die("Aborting.");
|
|
|
|
}
|
|
|
|
|
2013-01-13 05:17:03 +00:00
|
|
|
static int run_pre_push_hook(struct transport *transport,
|
|
|
|
struct ref *remote_refs)
|
|
|
|
{
|
|
|
|
int ret = 0, x;
|
|
|
|
struct ref *r;
|
|
|
|
struct child_process proc;
|
|
|
|
struct strbuf buf;
|
|
|
|
const char *argv[4];
|
|
|
|
|
|
|
|
if (!(argv[0] = find_hook("pre-push")))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
argv[1] = transport->remote->name;
|
|
|
|
argv[2] = transport->url;
|
|
|
|
argv[3] = NULL;
|
|
|
|
|
|
|
|
memset(&proc, 0, sizeof(proc));
|
|
|
|
proc.argv = argv;
|
|
|
|
proc.in = -1;
|
|
|
|
|
|
|
|
if (start_command(&proc)) {
|
|
|
|
finish_command(&proc);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_init(&buf, 256);
|
|
|
|
|
|
|
|
for (r = remote_refs; r; r = r->next) {
|
|
|
|
if (!r->peer_ref) continue;
|
|
|
|
if (r->status == REF_STATUS_REJECT_NONFASTFORWARD) continue;
|
|
|
|
if (r->status == REF_STATUS_UPTODATE) continue;
|
|
|
|
|
|
|
|
strbuf_reset(&buf);
|
|
|
|
strbuf_addf( &buf, "%s %s %s %s\n",
|
|
|
|
r->peer_ref->name, sha1_to_hex(r->new_sha1),
|
|
|
|
r->name, sha1_to_hex(r->old_sha1));
|
|
|
|
|
|
|
|
if (write_in_full(proc.in, buf.buf, buf.len) != buf.len) {
|
|
|
|
ret = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
|
|
|
x = close(proc.in);
|
|
|
|
if (!ret)
|
|
|
|
ret = x;
|
|
|
|
|
|
|
|
x = finish_command(&proc);
|
|
|
|
if (!ret)
|
|
|
|
ret = x;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-09-11 03:03:04 +00:00
|
|
|
int transport_push(struct transport *transport,
|
2009-08-08 07:51:08 +00:00
|
|
|
int refspec_nr, const char **refspec, int flags,
|
2012-11-30 01:41:33 +00:00
|
|
|
unsigned int *reject_reasons)
|
2007-09-11 03:03:04 +00:00
|
|
|
{
|
2012-11-30 01:41:33 +00:00
|
|
|
*reject_reasons = 0;
|
2010-02-16 23:42:52 +00:00
|
|
|
transport_verify_remote_names(refspec_nr, refspec);
|
2009-03-09 01:06:07 +00:00
|
|
|
|
2009-12-09 15:26:31 +00:00
|
|
|
if (transport->push) {
|
2010-01-16 21:45:31 +00:00
|
|
|
/* Maybe FIXME. But no important transport uses this case. */
|
|
|
|
if (flags & TRANSPORT_PUSH_SET_UPSTREAM)
|
|
|
|
die("This transport does not support using --set-upstream");
|
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
return transport->push(transport, refspec_nr, refspec, flags);
|
2009-12-09 15:26:31 +00:00
|
|
|
} else if (transport->push_refs) {
|
2009-03-09 01:06:07 +00:00
|
|
|
struct ref *remote_refs =
|
|
|
|
transport->get_refs_list(transport, 1);
|
|
|
|
struct ref *local_refs = get_local_heads();
|
|
|
|
int match_flags = MATCH_REFS_NONE;
|
2010-02-24 12:50:24 +00:00
|
|
|
int verbose = (transport->verbose > 0);
|
|
|
|
int quiet = (transport->verbose < 0);
|
2009-06-23 01:10:01 +00:00
|
|
|
int porcelain = flags & TRANSPORT_PUSH_PORCELAIN;
|
2010-01-16 21:45:31 +00:00
|
|
|
int pretend = flags & TRANSPORT_PUSH_DRY_RUN;
|
2010-02-27 04:52:15 +00:00
|
|
|
int push_ret, ret, err;
|
2009-03-09 01:06:07 +00:00
|
|
|
|
|
|
|
if (flags & TRANSPORT_PUSH_ALL)
|
|
|
|
match_flags |= MATCH_REFS_ALL;
|
|
|
|
if (flags & TRANSPORT_PUSH_MIRROR)
|
|
|
|
match_flags |= MATCH_REFS_MIRROR;
|
2012-02-22 22:43:41 +00:00
|
|
|
if (flags & TRANSPORT_PUSH_PRUNE)
|
|
|
|
match_flags |= MATCH_REFS_PRUNE;
|
2013-03-04 20:09:50 +00:00
|
|
|
if (flags & TRANSPORT_PUSH_FOLLOW_TAGS)
|
|
|
|
match_flags |= MATCH_REFS_FOLLOW_TAGS;
|
2009-03-09 01:06:07 +00:00
|
|
|
|
2011-09-09 18:54:58 +00:00
|
|
|
if (match_push_refs(local_refs, &remote_refs,
|
|
|
|
refspec_nr, refspec, match_flags)) {
|
2009-03-09 01:06:07 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-01-08 02:12:42 +00:00
|
|
|
set_ref_status_for_push(remote_refs,
|
|
|
|
flags & TRANSPORT_PUSH_MIRROR,
|
|
|
|
flags & TRANSPORT_PUSH_FORCE);
|
|
|
|
|
2013-01-13 05:17:03 +00:00
|
|
|
if (!(flags & TRANSPORT_PUSH_NO_HOOK))
|
|
|
|
if (run_pre_push_hook(transport, remote_refs))
|
|
|
|
return -1;
|
|
|
|
|
2012-03-29 07:21:24 +00:00
|
|
|
if ((flags & TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND) && !is_bare_repository()) {
|
2011-08-19 22:08:47 +00:00
|
|
|
struct ref *ref = remote_refs;
|
|
|
|
for (; ref; ref = ref->next)
|
|
|
|
if (!is_null_sha1(ref->new_sha1) &&
|
2012-03-29 07:21:24 +00:00
|
|
|
!push_unpushed_submodules(ref->new_sha1,
|
|
|
|
transport->remote->name))
|
|
|
|
die ("Failed to push all needed submodules!");
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((flags & (TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND |
|
|
|
|
TRANSPORT_RECURSE_SUBMODULES_CHECK)) && !is_bare_repository()) {
|
2011-08-19 22:08:47 +00:00
|
|
|
struct ref *ref = remote_refs;
|
2012-03-29 07:21:23 +00:00
|
|
|
struct string_list needs_pushing;
|
|
|
|
|
|
|
|
memset(&needs_pushing, 0, sizeof(struct string_list));
|
|
|
|
needs_pushing.strdup_strings = 1;
|
2011-08-19 22:08:47 +00:00
|
|
|
for (; ref; ref = ref->next)
|
|
|
|
if (!is_null_sha1(ref->new_sha1) &&
|
2012-03-29 07:21:23 +00:00
|
|
|
find_unpushed_submodules(ref->new_sha1,
|
|
|
|
transport->remote->name, &needs_pushing))
|
|
|
|
die_with_unpushed_submodules(&needs_pushing);
|
2011-08-19 22:08:47 +00:00
|
|
|
}
|
|
|
|
|
2010-02-27 04:52:15 +00:00
|
|
|
push_ret = transport->push_refs(transport, remote_refs, flags);
|
2010-01-08 02:12:43 +00:00
|
|
|
err = push_had_errors(remote_refs);
|
2010-02-27 04:52:15 +00:00
|
|
|
ret = push_ret | err;
|
2009-03-09 01:06:07 +00:00
|
|
|
|
2010-01-08 02:12:43 +00:00
|
|
|
if (!quiet || err)
|
2010-02-16 23:42:52 +00:00
|
|
|
transport_print_push_status(transport->url, remote_refs,
|
2009-08-12 23:36:04 +00:00
|
|
|
verbose | porcelain, porcelain,
|
2012-11-30 01:41:33 +00:00
|
|
|
reject_reasons);
|
2009-03-09 01:06:07 +00:00
|
|
|
|
2010-01-16 21:45:31 +00:00
|
|
|
if (flags & TRANSPORT_PUSH_SET_UPSTREAM)
|
|
|
|
set_upstreams(transport, remote_refs, pretend);
|
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
if (!(flags & TRANSPORT_PUSH_DRY_RUN)) {
|
|
|
|
struct ref *ref;
|
|
|
|
for (ref = remote_refs; ref; ref = ref->next)
|
2010-02-16 23:42:52 +00:00
|
|
|
transport_update_tracking_ref(transport->remote, ref, verbose);
|
2009-03-09 01:06:07 +00:00
|
|
|
}
|
|
|
|
|
2010-02-27 04:52:15 +00:00
|
|
|
if (porcelain && !push_ret)
|
|
|
|
puts("Done");
|
2010-03-15 07:58:24 +00:00
|
|
|
else if (!quiet && !ret && !transport_refs_pushed(remote_refs))
|
2009-03-09 01:06:07 +00:00
|
|
|
fprintf(stderr, "Everything up-to-date\n");
|
2010-02-27 04:52:15 +00:00
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
return 1;
|
2007-09-11 03:03:04 +00:00
|
|
|
}
|
|
|
|
|
2007-10-30 01:05:40 +00:00
|
|
|
const struct ref *transport_get_remote_refs(struct transport *transport)
|
2007-09-11 03:03:11 +00:00
|
|
|
{
|
2010-02-16 07:18:21 +00:00
|
|
|
if (!transport->got_remote_refs) {
|
2009-03-09 01:06:07 +00:00
|
|
|
transport->remote_refs = transport->get_refs_list(transport, 0);
|
2010-02-16 07:18:21 +00:00
|
|
|
transport->got_remote_refs = 1;
|
|
|
|
}
|
2009-12-09 15:26:31 +00:00
|
|
|
|
2007-09-11 03:03:11 +00:00
|
|
|
return transport->remote_refs;
|
|
|
|
}
|
|
|
|
|
2009-11-18 01:42:24 +00:00
|
|
|
int transport_fetch_refs(struct transport *transport, struct ref *refs)
|
2007-09-11 03:03:11 +00:00
|
|
|
{
|
2007-09-14 07:31:21 +00:00
|
|
|
int rc;
|
2009-08-24 04:04:09 +00:00
|
|
|
int nr_heads = 0, nr_alloc = 0, nr_refs = 0;
|
2009-11-18 01:42:24 +00:00
|
|
|
struct ref **heads = NULL;
|
|
|
|
struct ref *rm;
|
2007-09-11 03:03:11 +00:00
|
|
|
|
|
|
|
for (rm = refs; rm; rm = rm->next) {
|
2009-08-24 04:04:09 +00:00
|
|
|
nr_refs++;
|
2007-09-11 03:03:11 +00:00
|
|
|
if (rm->peer_ref &&
|
2009-11-18 01:42:24 +00:00
|
|
|
!is_null_sha1(rm->old_sha1) &&
|
2007-09-11 03:03:11 +00:00
|
|
|
!hashcmp(rm->peer_ref->old_sha1, rm->old_sha1))
|
|
|
|
continue;
|
2007-09-14 07:31:18 +00:00
|
|
|
ALLOC_GROW(heads, nr_heads + 1, nr_alloc);
|
2007-09-14 07:31:21 +00:00
|
|
|
heads[nr_heads++] = rm;
|
2007-09-11 03:03:11 +00:00
|
|
|
}
|
|
|
|
|
2009-08-24 04:04:09 +00:00
|
|
|
if (!nr_heads) {
|
|
|
|
/*
|
|
|
|
* When deepening of a shallow repository is requested,
|
|
|
|
* then local and remote refs are likely to still be equal.
|
|
|
|
* Just feed them all to the fetch method in that case.
|
|
|
|
* This condition shouldn't be met in a non-deepening fetch
|
2013-06-18 17:44:58 +00:00
|
|
|
* (see builtin/fetch.c:quickfetch()).
|
2009-08-24 04:04:09 +00:00
|
|
|
*/
|
|
|
|
heads = xmalloc(nr_refs * sizeof(*heads));
|
|
|
|
for (rm = refs; rm; rm = rm->next)
|
|
|
|
heads[nr_heads++] = rm;
|
|
|
|
}
|
|
|
|
|
2007-09-19 04:49:31 +00:00
|
|
|
rc = transport->fetch(transport, nr_heads, heads);
|
2009-12-09 15:26:31 +00:00
|
|
|
|
2007-09-11 03:03:11 +00:00
|
|
|
free(heads);
|
2007-09-14 07:31:21 +00:00
|
|
|
return rc;
|
2007-09-11 03:03:11 +00:00
|
|
|
}
|
|
|
|
|
2007-09-14 07:31:23 +00:00
|
|
|
void transport_unlock_pack(struct transport *transport)
|
|
|
|
{
|
|
|
|
if (transport->pack_lockfile) {
|
2009-04-29 21:22:56 +00:00
|
|
|
unlink_or_warn(transport->pack_lockfile);
|
2007-09-14 07:31:23 +00:00
|
|
|
free(transport->pack_lockfile);
|
|
|
|
transport->pack_lockfile = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-09 15:26:33 +00:00
|
|
|
int transport_connect(struct transport *transport, const char *name,
|
|
|
|
const char *exec, int fd[2])
|
|
|
|
{
|
|
|
|
if (transport->connect)
|
|
|
|
return transport->connect(transport, name, exec, fd);
|
|
|
|
else
|
|
|
|
die("Operation not supported by protocol");
|
|
|
|
}
|
|
|
|
|
2007-09-11 03:03:04 +00:00
|
|
|
int transport_disconnect(struct transport *transport)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
2007-09-19 04:49:31 +00:00
|
|
|
if (transport->disconnect)
|
|
|
|
ret = transport->disconnect(transport);
|
2007-09-11 03:03:04 +00:00
|
|
|
free(transport);
|
|
|
|
return ret;
|
|
|
|
}
|
2009-04-17 08:20:11 +00:00
|
|
|
|
|
|
|
/*
|
2012-03-28 08:41:54 +00:00
|
|
|
* Strip username (and password) from a URL and return
|
2009-04-17 08:20:11 +00:00
|
|
|
* it in a newly allocated string.
|
|
|
|
*/
|
|
|
|
char *transport_anonymize_url(const char *url)
|
|
|
|
{
|
|
|
|
char *anon_url, *scheme_prefix, *anon_part;
|
|
|
|
size_t anon_len, prefix_len = 0;
|
|
|
|
|
|
|
|
anon_part = strchr(url, '@');
|
|
|
|
if (is_local(url) || !anon_part)
|
|
|
|
goto literal_copy;
|
|
|
|
|
|
|
|
anon_len = strlen(++anon_part);
|
|
|
|
scheme_prefix = strstr(url, "://");
|
|
|
|
if (!scheme_prefix) {
|
|
|
|
if (!strchr(anon_part, ':'))
|
|
|
|
/* cannot be "me@there:/path/name" */
|
|
|
|
goto literal_copy;
|
|
|
|
} else {
|
|
|
|
const char *cp;
|
|
|
|
/* make sure scheme is reasonable */
|
|
|
|
for (cp = url; cp < scheme_prefix; cp++) {
|
|
|
|
switch (*cp) {
|
|
|
|
/* RFC 1738 2.1 */
|
|
|
|
case '+': case '.': case '-':
|
|
|
|
break; /* ok */
|
|
|
|
default:
|
|
|
|
if (isalnum(*cp))
|
|
|
|
break;
|
|
|
|
/* it isn't */
|
|
|
|
goto literal_copy;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* @ past the first slash does not count */
|
|
|
|
cp = strchr(scheme_prefix + 3, '/');
|
|
|
|
if (cp && cp < anon_part)
|
|
|
|
goto literal_copy;
|
|
|
|
prefix_len = scheme_prefix - url + 3;
|
|
|
|
}
|
|
|
|
anon_url = xcalloc(1, 1 + prefix_len + anon_len);
|
|
|
|
memcpy(anon_url, url, prefix_len);
|
|
|
|
memcpy(anon_url + prefix_len, anon_part, anon_len);
|
|
|
|
return anon_url;
|
|
|
|
literal_copy:
|
|
|
|
return xstrdup(url);
|
|
|
|
}
|
2011-03-11 19:32:53 +00:00
|
|
|
|
refactor refs_from_alternate_cb to allow passing extra data
The foreach_alt_odb function triggers a callback for each
alternate object db we have, with room for a single void
pointer as data. Currently, we always call refs_from_alternate_cb
as the callback function, and then pass another callback (to
receive each ref individually) as the void pointer.
This has two problems:
1. C technically forbids stuffing a function pointer into
a "void *". In practice, this probably doesn't matter
on any architectures git runs on, but it never hurts to
follow the letter of the law.
2. There is no room for an extra data pointer. Indeed, the
alternate_ref_fn that refs_from_alternate_cb calls
takes a void* for data, but we always pass it NULL.
Instead, let's properly stuff our function pointer into a
data struct, which also leaves room for an extra
caller-supplied data pointer. And to keep things simple for
existing callers, let's make a for_each_alternate_ref
function that takes care of creating the extra struct.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-19 21:33:17 +00:00
|
|
|
struct alternate_refs_data {
|
|
|
|
alternate_ref_fn *fn;
|
|
|
|
void *data;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int refs_from_alternate_cb(struct alternate_object_database *e,
|
|
|
|
void *data)
|
2011-03-11 19:32:53 +00:00
|
|
|
{
|
|
|
|
char *other;
|
|
|
|
size_t len;
|
|
|
|
struct remote *remote;
|
|
|
|
struct transport *transport;
|
|
|
|
const struct ref *extra;
|
refactor refs_from_alternate_cb to allow passing extra data
The foreach_alt_odb function triggers a callback for each
alternate object db we have, with room for a single void
pointer as data. Currently, we always call refs_from_alternate_cb
as the callback function, and then pass another callback (to
receive each ref individually) as the void pointer.
This has two problems:
1. C technically forbids stuffing a function pointer into
a "void *". In practice, this probably doesn't matter
on any architectures git runs on, but it never hurts to
follow the letter of the law.
2. There is no room for an extra data pointer. Indeed, the
alternate_ref_fn that refs_from_alternate_cb calls
takes a void* for data, but we always pass it NULL.
Instead, let's properly stuff our function pointer into a
data struct, which also leaves room for an extra
caller-supplied data pointer. And to keep things simple for
existing callers, let's make a for_each_alternate_ref
function that takes care of creating the extra struct.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-19 21:33:17 +00:00
|
|
|
struct alternate_refs_data *cb = data;
|
2011-03-11 19:32:53 +00:00
|
|
|
|
|
|
|
e->name[-1] = '\0';
|
2011-03-23 04:37:53 +00:00
|
|
|
other = xstrdup(real_path(e->base));
|
2011-03-11 19:32:53 +00:00
|
|
|
e->name[-1] = '/';
|
|
|
|
len = strlen(other);
|
|
|
|
|
|
|
|
while (other[len-1] == '/')
|
|
|
|
other[--len] = '\0';
|
|
|
|
if (len < 8 || memcmp(other + len - 8, "/objects", 8))
|
|
|
|
return 0;
|
|
|
|
/* Is this a git repository with refs? */
|
|
|
|
memcpy(other + len - 8, "/refs", 6);
|
|
|
|
if (!is_directory(other))
|
|
|
|
return 0;
|
|
|
|
other[len - 8] = '\0';
|
|
|
|
remote = remote_get(other);
|
|
|
|
transport = transport_get(remote, other);
|
|
|
|
for (extra = transport_get_remote_refs(transport);
|
|
|
|
extra;
|
|
|
|
extra = extra->next)
|
refactor refs_from_alternate_cb to allow passing extra data
The foreach_alt_odb function triggers a callback for each
alternate object db we have, with room for a single void
pointer as data. Currently, we always call refs_from_alternate_cb
as the callback function, and then pass another callback (to
receive each ref individually) as the void pointer.
This has two problems:
1. C technically forbids stuffing a function pointer into
a "void *". In practice, this probably doesn't matter
on any architectures git runs on, but it never hurts to
follow the letter of the law.
2. There is no room for an extra data pointer. Indeed, the
alternate_ref_fn that refs_from_alternate_cb calls
takes a void* for data, but we always pass it NULL.
Instead, let's properly stuff our function pointer into a
data struct, which also leaves room for an extra
caller-supplied data pointer. And to keep things simple for
existing callers, let's make a for_each_alternate_ref
function that takes care of creating the extra struct.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-19 21:33:17 +00:00
|
|
|
cb->fn(extra, cb->data);
|
2011-03-11 19:32:53 +00:00
|
|
|
transport_disconnect(transport);
|
|
|
|
free(other);
|
|
|
|
return 0;
|
|
|
|
}
|
refactor refs_from_alternate_cb to allow passing extra data
The foreach_alt_odb function triggers a callback for each
alternate object db we have, with room for a single void
pointer as data. Currently, we always call refs_from_alternate_cb
as the callback function, and then pass another callback (to
receive each ref individually) as the void pointer.
This has two problems:
1. C technically forbids stuffing a function pointer into
a "void *". In practice, this probably doesn't matter
on any architectures git runs on, but it never hurts to
follow the letter of the law.
2. There is no room for an extra data pointer. Indeed, the
alternate_ref_fn that refs_from_alternate_cb calls
takes a void* for data, but we always pass it NULL.
Instead, let's properly stuff our function pointer into a
data struct, which also leaves room for an extra
caller-supplied data pointer. And to keep things simple for
existing callers, let's make a for_each_alternate_ref
function that takes care of creating the extra struct.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-19 21:33:17 +00:00
|
|
|
|
|
|
|
void for_each_alternate_ref(alternate_ref_fn fn, void *data)
|
|
|
|
{
|
|
|
|
struct alternate_refs_data cb;
|
|
|
|
cb.fn = fn;
|
|
|
|
cb.data = data;
|
|
|
|
foreach_alt_odb(refs_from_alternate_cb, &cb);
|
|
|
|
}
|