Browse Source
* jk/send-pack: (24 commits) send-pack: cluster ref status reporting send-pack: fix "everything up-to-date" message send-pack: tighten remote error reporting make "find_ref_by_name" a public function Fix warning about bitfield in struct ref send-pack: assign remote errors to each ref send-pack: check ref->status before updating tracking refs send-pack: track errors for each ref git-push: add documentation for the newly added --mirror mode Add tests for git push'es mirror mode Update the tracking references only if they were succesfully updated on remote Add a test checking if send-pack updated local tracking branches correctly git-push: plumb in --mirror mode Teach send-pack a mirror mode send-pack: segfault fix on forced push Reteach builtin-ls-remote to understand remotes send-pack: require --verbose to show update of tracking refs receive-pack: don't mention successful updates more terse push output Build in ls-remote ...maint
Junio C Hamano
17 years ago
26 changed files with 1285 additions and 631 deletions
@ -0,0 +1,74 @@
@@ -0,0 +1,74 @@
|
||||
#include "builtin.h" |
||||
#include "cache.h" |
||||
#include "transport.h" |
||||
#include "remote.h" |
||||
|
||||
static const char ls_remote_usage[] = |
||||
"git-ls-remote [--upload-pack=<git-upload-pack>] [<host>:]<directory>"; |
||||
|
||||
int cmd_ls_remote(int argc, const char **argv, const char *prefix) |
||||
{ |
||||
int i; |
||||
const char *dest = NULL; |
||||
int nongit = 0; |
||||
unsigned flags = 0; |
||||
const char *uploadpack = NULL; |
||||
|
||||
struct remote *remote; |
||||
struct transport *transport; |
||||
const struct ref *ref; |
||||
|
||||
setup_git_directory_gently(&nongit); |
||||
|
||||
for (i = 1; i < argc; i++) { |
||||
const char *arg = argv[i]; |
||||
|
||||
if (*arg == '-') { |
||||
if (!prefixcmp(arg, "--upload-pack=")) { |
||||
uploadpack = arg + 14; |
||||
continue; |
||||
} |
||||
if (!prefixcmp(arg, "--exec=")) { |
||||
uploadpack = arg + 7; |
||||
continue; |
||||
} |
||||
if (!strcmp("--tags", arg)) { |
||||
flags |= REF_TAGS; |
||||
continue; |
||||
} |
||||
if (!strcmp("--heads", arg)) { |
||||
flags |= REF_HEADS; |
||||
continue; |
||||
} |
||||
if (!strcmp("--refs", arg)) { |
||||
flags |= REF_NORMAL; |
||||
continue; |
||||
} |
||||
usage(ls_remote_usage); |
||||
} |
||||
dest = arg; |
||||
break; |
||||
} |
||||
|
||||
if (!dest || i != argc - 1) |
||||
usage(ls_remote_usage); |
||||
|
||||
remote = nongit ? NULL : remote_get(dest); |
||||
if (remote && !remote->url_nr) |
||||
die("remote %s has no configured URL", dest); |
||||
transport = transport_get(remote, remote ? remote->url[0] : dest); |
||||
if (uploadpack != NULL) |
||||
transport_set_option(transport, TRANS_OPT_UPLOADPACK, uploadpack); |
||||
|
||||
ref = transport_get_remote_refs(transport); |
||||
|
||||
if (!ref) |
||||
return 1; |
||||
|
||||
while (ref) { |
||||
if (check_ref_type(ref, flags)) |
||||
printf("%s %s\n", sha1_to_hex(ref->old_sha1), ref->name); |
||||
ref = ref->next; |
||||
} |
||||
return 0; |
||||
} |
||||
@ -0,0 +1,652 @@
@@ -0,0 +1,652 @@
|
||||
#include "cache.h" |
||||
#include "commit.h" |
||||
#include "tag.h" |
||||
#include "refs.h" |
||||
#include "pkt-line.h" |
||||
#include "run-command.h" |
||||
#include "remote.h" |
||||
#include "send-pack.h" |
||||
|
||||
static const char send_pack_usage[] = |
||||
"git-send-pack [--all | --mirror] [--dry-run] [--force] [--receive-pack=<git-receive-pack>] [--verbose] [--thin] [<host>:]<directory> [<ref>...]\n" |
||||
" --all and explicit <ref> specification are mutually exclusive."; |
||||
|
||||
static struct send_pack_args args = { |
||||
/* .receivepack = */ "git-receive-pack", |
||||
}; |
||||
|
||||
/* |
||||
* Make a pack stream and spit it out into file descriptor fd |
||||
*/ |
||||
static int pack_objects(int fd, struct ref *refs) |
||||
{ |
||||
/* |
||||
* The child becomes pack-objects --revs; we feed |
||||
* the revision parameters to it via its stdin and |
||||
* let its stdout go back to the other end. |
||||
*/ |
||||
const char *argv[] = { |
||||
"pack-objects", |
||||
"--all-progress", |
||||
"--revs", |
||||
"--stdout", |
||||
NULL, |
||||
NULL, |
||||
}; |
||||
struct child_process po; |
||||
|
||||
if (args.use_thin_pack) |
||||
argv[4] = "--thin"; |
||||
memset(&po, 0, sizeof(po)); |
||||
po.argv = argv; |
||||
po.in = -1; |
||||
po.out = fd; |
||||
po.git_cmd = 1; |
||||
if (start_command(&po)) |
||||
die("git-pack-objects failed (%s)", strerror(errno)); |
||||
|
||||
/* |
||||
* We feed the pack-objects we just spawned with revision |
||||
* parameters by writing to the pipe. |
||||
*/ |
||||
while (refs) { |
||||
char buf[42]; |
||||
|
||||
if (!is_null_sha1(refs->old_sha1) && |
||||
has_sha1_file(refs->old_sha1)) { |
||||
memcpy(buf + 1, sha1_to_hex(refs->old_sha1), 40); |
||||
buf[0] = '^'; |
||||
buf[41] = '\n'; |
||||
if (!write_or_whine(po.in, buf, 42, |
||||
"send-pack: send refs")) |
||||
break; |
||||
} |
||||
if (!is_null_sha1(refs->new_sha1)) { |
||||
memcpy(buf, sha1_to_hex(refs->new_sha1), 40); |
||||
buf[40] = '\n'; |
||||
if (!write_or_whine(po.in, buf, 41, |
||||
"send-pack: send refs")) |
||||
break; |
||||
} |
||||
refs = refs->next; |
||||
} |
||||
|
||||
if (finish_command(&po)) |
||||
return error("pack-objects died with strange error"); |
||||
return 0; |
||||
} |
||||
|
||||
static void unmark_and_free(struct commit_list *list, unsigned int mark) |
||||
{ |
||||
while (list) { |
||||
struct commit_list *temp = list; |
||||
temp->item->object.flags &= ~mark; |
||||
list = temp->next; |
||||
free(temp); |
||||
} |
||||
} |
||||
|
||||
static int ref_newer(const unsigned char *new_sha1, |
||||
const unsigned char *old_sha1) |
||||
{ |
||||
struct object *o; |
||||
struct commit *old, *new; |
||||
struct commit_list *list, *used; |
||||
int found = 0; |
||||
|
||||
/* Both new and old must be commit-ish and new is descendant of |
||||
* old. Otherwise we require --force. |
||||
*/ |
||||
o = deref_tag(parse_object(old_sha1), NULL, 0); |
||||
if (!o || o->type != OBJ_COMMIT) |
||||
return 0; |
||||
old = (struct commit *) o; |
||||
|
||||
o = deref_tag(parse_object(new_sha1), NULL, 0); |
||||
if (!o || o->type != OBJ_COMMIT) |
||||
return 0; |
||||
new = (struct commit *) o; |
||||
|
||||
if (parse_commit(new) < 0) |
||||
return 0; |
||||
|
||||
used = list = NULL; |
||||
commit_list_insert(new, &list); |
||||
while (list) { |
||||
new = pop_most_recent_commit(&list, 1); |
||||
commit_list_insert(new, &used); |
||||
if (new == old) { |
||||
found = 1; |
||||
break; |
||||
} |
||||
} |
||||
unmark_and_free(list, 1); |
||||
unmark_and_free(used, 1); |
||||
return found; |
||||
} |
||||
|
||||
static struct ref *local_refs, **local_tail; |
||||
static struct ref *remote_refs, **remote_tail; |
||||
|
||||
static int one_local_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data) |
||||
{ |
||||
struct ref *ref; |
||||
int len = strlen(refname) + 1; |
||||
ref = xcalloc(1, sizeof(*ref) + len); |
||||
hashcpy(ref->new_sha1, sha1); |
||||
memcpy(ref->name, refname, len); |
||||
*local_tail = ref; |
||||
local_tail = &ref->next; |
||||
return 0; |
||||
} |
||||
|
||||
static void get_local_heads(void) |
||||
{ |
||||
local_tail = &local_refs; |
||||
for_each_ref(one_local_ref, NULL); |
||||
} |
||||
|
||||
static int receive_status(int in, struct ref *refs) |
||||
{ |
||||
struct ref *hint; |
||||
char line[1000]; |
||||
int ret = 0; |
||||
int len = packet_read_line(in, line, sizeof(line)); |
||||
if (len < 10 || memcmp(line, "unpack ", 7)) |
||||
return error("did not receive remote status"); |
||||
if (memcmp(line, "unpack ok\n", 10)) { |
||||
char *p = line + strlen(line) - 1; |
||||
if (*p == '\n') |
||||
*p = '\0'; |
||||
error("unpack failed: %s", line + 7); |
||||
ret = -1; |
||||
} |
||||
hint = NULL; |
||||
while (1) { |
||||
char *refname; |
||||
char *msg; |
||||
len = packet_read_line(in, line, sizeof(line)); |
||||
if (!len) |
||||
break; |
||||
if (len < 3 || |
||||
(memcmp(line, "ok ", 3) && memcmp(line, "ng ", 3))) { |
||||
fprintf(stderr, "protocol error: %s\n", line); |
||||
ret = -1; |
||||
break; |
||||
} |
||||
|
||||
line[strlen(line)-1] = '\0'; |
||||
refname = line + 3; |
||||
msg = strchr(refname, ' '); |
||||
if (msg) |
||||
*msg++ = '\0'; |
||||
|
||||
/* first try searching at our hint, falling back to all refs */ |
||||
if (hint) |
||||
hint = find_ref_by_name(hint, refname); |
||||
if (!hint) |
||||
hint = find_ref_by_name(refs, refname); |
||||
if (!hint) { |
||||
warning("remote reported status on unknown ref: %s", |
||||
refname); |
||||
continue; |
||||
} |
||||
if (hint->status != REF_STATUS_EXPECTING_REPORT) { |
||||
warning("remote reported status on unexpected ref: %s", |
||||
refname); |
||||
continue; |
||||
} |
||||
|
||||
if (line[0] == 'o' && line[1] == 'k') |
||||
hint->status = REF_STATUS_OK; |
||||
else { |
||||
hint->status = REF_STATUS_REMOTE_REJECT; |
||||
ret = -1; |
||||
} |
||||
if (msg) |
||||
hint->remote_status = xstrdup(msg); |
||||
/* start our next search from the next ref */ |
||||
hint = hint->next; |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
static void update_tracking_ref(struct remote *remote, struct ref *ref) |
||||
{ |
||||
struct refspec rs; |
||||
|
||||
if (ref->status != REF_STATUS_OK) |
||||
return; |
||||
|
||||
rs.src = ref->name; |
||||
rs.dst = NULL; |
||||
|
||||
if (!remote_find_tracking(remote, &rs)) { |
||||
if (args.verbose) |
||||
fprintf(stderr, "updating local tracking ref '%s'\n", rs.dst); |
||||
if (ref->deletion) { |
||||
if (delete_ref(rs.dst, NULL)) |
||||
error("Failed to delete"); |
||||
} else |
||||
update_ref("update by push", rs.dst, |
||||
ref->new_sha1, NULL, 0, 0); |
||||
free(rs.dst); |
||||
} |
||||
} |
||||
|
||||
static const char *prettify_ref(const struct ref *ref) |
||||
{ |
||||
const char *name = ref->name; |
||||
return name + ( |
||||
!prefixcmp(name, "refs/heads/") ? 11 : |
||||
!prefixcmp(name, "refs/tags/") ? 10 : |
||||
!prefixcmp(name, "refs/remotes/") ? 13 : |
||||
0); |
||||
} |
||||
|
||||
#define SUMMARY_WIDTH (2 * DEFAULT_ABBREV + 3) |
||||
|
||||
static void print_ref_status(char flag, const char *summary, struct ref *to, struct ref *from, const char *msg) |
||||
{ |
||||
fprintf(stderr, " %c %-*s ", flag, SUMMARY_WIDTH, summary); |
||||
if (from) |
||||
fprintf(stderr, "%s -> %s", prettify_ref(from), prettify_ref(to)); |
||||
else |
||||
fputs(prettify_ref(to), stderr); |
||||
if (msg) { |
||||
fputs(" (", stderr); |
||||
fputs(msg, stderr); |
||||
fputc(')', stderr); |
||||
} |
||||
fputc('\n', stderr); |
||||
} |
||||
|
||||
static const char *status_abbrev(unsigned char sha1[20]) |
||||
{ |
||||
const char *abbrev; |
||||
abbrev = find_unique_abbrev(sha1, DEFAULT_ABBREV); |
||||
return abbrev ? abbrev : sha1_to_hex(sha1); |
||||
} |
||||
|
||||
static void print_ok_ref_status(struct ref *ref) |
||||
{ |
||||
if (ref->deletion) |
||||
print_ref_status('-', "[deleted]", ref, NULL, NULL); |
||||
else if (is_null_sha1(ref->old_sha1)) |
||||
print_ref_status('*', |
||||
(!prefixcmp(ref->name, "refs/tags/") ? "[new tag]" : |
||||
"[new branch]"), |
||||
ref, ref->peer_ref, NULL); |
||||
else { |
||||
char quickref[84]; |
||||
char type; |
||||
const char *msg; |
||||
|
||||
strcpy(quickref, status_abbrev(ref->old_sha1)); |
||||
if (ref->nonfastforward) { |
||||
strcat(quickref, "..."); |
||||
type = '+'; |
||||
msg = "forced update"; |
||||
} else { |
||||
strcat(quickref, ".."); |
||||
type = ' '; |
||||
msg = NULL; |
||||
} |
||||
strcat(quickref, status_abbrev(ref->new_sha1)); |
||||
|
||||
print_ref_status(type, quickref, ref, ref->peer_ref, msg); |
||||
} |
||||
} |
||||
|
||||
static int print_one_push_status(struct ref *ref, const char *dest, int count) |
||||
{ |
||||
if (!count) |
||||
fprintf(stderr, "To %s\n", dest); |
||||
|
||||
switch(ref->status) { |
||||
case REF_STATUS_NONE: |
||||
print_ref_status('X', "[no match]", ref, NULL, NULL); |
||||
break; |
||||
case REF_STATUS_REJECT_NODELETE: |
||||
print_ref_status('!', "[rejected]", ref, NULL, |
||||
"remote does not support deleting refs"); |
||||
break; |
||||
case REF_STATUS_UPTODATE: |
||||
print_ref_status('=', "[up to date]", ref, |
||||
ref->peer_ref, NULL); |
||||
break; |
||||
case REF_STATUS_REJECT_NONFASTFORWARD: |
||||
print_ref_status('!', "[rejected]", ref, ref->peer_ref, |
||||
"non-fast forward"); |
||||
break; |
||||
case REF_STATUS_REMOTE_REJECT: |
||||
print_ref_status('!', "[remote rejected]", ref, |
||||
ref->deletion ? NULL : ref->peer_ref, |
||||
ref->remote_status); |
||||
break; |
||||
case REF_STATUS_EXPECTING_REPORT: |
||||
print_ref_status('!', "[remote failure]", ref, |
||||
ref->deletion ? NULL : ref->peer_ref, |
||||
"remote failed to report status"); |
||||
break; |
||||
case REF_STATUS_OK: |
||||
print_ok_ref_status(ref); |
||||
break; |
||||
} |
||||
|
||||
return 1; |
||||
} |
||||
|
||||
static void print_push_status(const char *dest, struct ref *refs) |
||||
{ |
||||
struct ref *ref; |
||||
int n = 0; |
||||
|
||||
if (args.verbose) { |
||||
for (ref = refs; ref; ref = ref->next) |
||||
if (ref->status == REF_STATUS_UPTODATE) |
||||
n += print_one_push_status(ref, dest, n); |
||||
} |
||||
|
||||
for (ref = refs; ref; ref = ref->next) |
||||
if (ref->status == REF_STATUS_OK) |
||||
n += print_one_push_status(ref, dest, n); |
||||
|
||||
for (ref = refs; ref; ref = ref->next) { |
||||
if (ref->status != REF_STATUS_NONE && |
||||
ref->status != REF_STATUS_UPTODATE && |
||||
ref->status != REF_STATUS_OK) |
||||
n += print_one_push_status(ref, dest, n); |
||||
} |
||||
} |
||||
|
||||
static int refs_pushed(struct ref *ref) |
||||
{ |
||||
for (; ref; ref = ref->next) { |
||||
switch(ref->status) { |
||||
case REF_STATUS_NONE: |
||||
case REF_STATUS_UPTODATE: |
||||
break; |
||||
default: |
||||
return 1; |
||||
} |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
static int do_send_pack(int in, int out, struct remote *remote, const char *dest, int nr_refspec, const char **refspec) |
||||
{ |
||||
struct ref *ref; |
||||
int new_refs; |
||||
int ask_for_status_report = 0; |
||||
int allow_deleting_refs = 0; |
||||
int expect_status_report = 0; |
||||
int flags = MATCH_REFS_NONE; |
||||
int ret; |
||||
|
||||
if (args.send_all) |
||||
flags |= MATCH_REFS_ALL; |
||||
if (args.send_mirror) |
||||
flags |= MATCH_REFS_MIRROR; |
||||
|
||||
/* No funny business with the matcher */ |
||||
remote_tail = get_remote_heads(in, &remote_refs, 0, NULL, REF_NORMAL); |
||||
get_local_heads(); |
||||
|
||||
/* Does the other end support the reporting? */ |
||||
if (server_supports("report-status")) |
||||
ask_for_status_report = 1; |
||||
if (server_supports("delete-refs")) |
||||
allow_deleting_refs = 1; |
||||
|
||||
/* match them up */ |
||||
if (!remote_tail) |
||||
remote_tail = &remote_refs; |
||||
if (match_refs(local_refs, remote_refs, &remote_tail, |
||||
nr_refspec, refspec, flags)) |
||||
return -1; |
||||
|
||||
if (!remote_refs) { |
||||
fprintf(stderr, "No refs in common and none specified; doing nothing.\n" |
||||
"Perhaps you should specify a branch such as 'master'.\n"); |
||||
return 0; |
||||
} |
||||
|
||||
/* |
||||
* Finally, tell the other end! |
||||
*/ |
||||
new_refs = 0; |
||||
for (ref = remote_refs; ref; ref = ref->next) { |
||||
const unsigned char *new_sha1; |
||||
|
||||
if (!ref->peer_ref) { |
||||
if (!args.send_mirror) |
||||
continue; |
||||
new_sha1 = null_sha1; |
||||
} |
||||
else |
||||
new_sha1 = ref->peer_ref->new_sha1; |
||||
|
||||
|
||||
ref->deletion = is_null_sha1(new_sha1); |
||||
if (ref->deletion && !allow_deleting_refs) { |
||||
ref->status = REF_STATUS_REJECT_NODELETE; |
||||
continue; |
||||
} |
||||
if (!ref->deletion && |
||||
!hashcmp(ref->old_sha1, new_sha1)) { |
||||
ref->status = REF_STATUS_UPTODATE; |
||||
continue; |
||||
} |
||||
|
||||
/* This part determines what can overwrite what. |
||||
* The rules are: |
||||
* |
||||
* (0) you can always use --force or +A:B notation to |
||||
* selectively force individual ref pairs. |
||||
* |
||||
* (1) if the old thing does not exist, it is OK. |
||||
* |
||||
* (2) if you do not have the old thing, you are not allowed |
||||
* to overwrite it; you would not know what you are losing |
||||
* otherwise. |
||||
* |
||||
* (3) if both new and old are commit-ish, and new is a |
||||
* descendant of old, it is OK. |
||||
* |
||||
* (4) regardless of all of the above, removing :B is |
||||
* always allowed. |
||||
*/ |
||||
|
||||
ref->nonfastforward = |
||||
!ref->deletion && |
||||
!is_null_sha1(ref->old_sha1) && |
||||
(!has_sha1_file(ref->old_sha1) |
||||
|| !ref_newer(new_sha1, ref->old_sha1)); |
||||
|
||||
if (ref->nonfastforward && !ref->force && !args.force_update) { |
||||
ref->status = REF_STATUS_REJECT_NONFASTFORWARD; |
||||
continue; |
||||
} |
||||
|
||||
hashcpy(ref->new_sha1, new_sha1); |
||||
if (!ref->deletion) |
||||
new_refs++; |
||||
|
||||
if (!args.dry_run) { |
||||
char *old_hex = sha1_to_hex(ref->old_sha1); |
||||
char *new_hex = sha1_to_hex(ref->new_sha1); |
||||
|
||||
if (ask_for_status_report) { |
||||
packet_write(out, "%s %s %s%c%s", |
||||
old_hex, new_hex, ref->name, 0, |
||||
"report-status"); |
||||
ask_for_status_report = 0; |
||||
expect_status_report = 1; |
||||
} |
||||
else |
||||
packet_write(out, "%s %s %s", |
||||
old_hex, new_hex, ref->name); |
||||
} |
||||
ref->status = expect_status_report ? |
||||
REF_STATUS_EXPECTING_REPORT : |
||||
REF_STATUS_OK; |
||||
} |
||||
|
||||
packet_flush(out); |
||||
if (new_refs && !args.dry_run) { |
||||
if (pack_objects(out, remote_refs) < 0) { |
||||
close(out); |
||||
return -1; |
||||
} |
||||
} |
||||
close(out); |
||||
|
||||
if (expect_status_report) |
||||
ret = receive_status(in, remote_refs); |
||||
else |
||||
ret = 0; |
||||
|
||||
print_push_status(dest, remote_refs); |
||||
|
||||
if (!args.dry_run && remote) { |
||||
for (ref = remote_refs; ref; ref = ref->next) |
||||
update_tracking_ref(remote, ref); |
||||
} |
||||
|
||||
if (!refs_pushed(remote_refs)) |
||||
fprintf(stderr, "Everything up-to-date\n"); |
||||
if (ret < 0) |
||||
return ret; |
||||
for (ref = remote_refs; 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; |
||||
} |
||||
|
||||
static void verify_remote_names(int nr_heads, const char **heads) |
||||
{ |
||||
int i; |
||||
|
||||
for (i = 0; i < nr_heads; i++) { |
||||
const char *remote = strchr(heads[i], ':'); |
||||
|
||||
remote = remote ? (remote + 1) : heads[i]; |
||||
switch (check_ref_format(remote)) { |
||||
case 0: /* ok */ |
||||
case -2: /* ok but a single level -- that is fine for |
||||
* a match pattern. |
||||
*/ |
||||
case -3: /* ok but ends with a pattern-match character */ |
||||
continue; |
||||
} |
||||
die("remote part of refspec is not a valid name in %s", |
||||
heads[i]); |
||||
} |
||||
} |
||||
|
||||
int cmd_send_pack(int argc, const char **argv, const char *prefix) |
||||
{ |
||||
int i, nr_heads = 0; |
||||
const char **heads = NULL; |
||||
const char *remote_name = NULL; |
||||
struct remote *remote = NULL; |
||||
const char *dest = NULL; |
||||
|
||||
argv++; |
||||
for (i = 1; i < argc; i++, argv++) { |
||||
const char *arg = *argv; |
||||
|
||||
if (*arg == '-') { |
||||
if (!prefixcmp(arg, "--receive-pack=")) { |
||||
args.receivepack = arg + 15; |
||||
continue; |
||||
} |
||||
if (!prefixcmp(arg, "--exec=")) { |
||||
args.receivepack = arg + 7; |
||||
continue; |
||||
} |
||||
if (!prefixcmp(arg, "--remote=")) { |
||||
remote_name = arg + 9; |
||||
continue; |
||||
} |
||||
if (!strcmp(arg, "--all")) { |
||||
args.send_all = 1; |
||||
continue; |
||||
} |
||||
if (!strcmp(arg, "--dry-run")) { |
||||
args.dry_run = 1; |
||||
continue; |
||||
} |
||||
if (!strcmp(arg, "--mirror")) { |
||||
args.send_mirror = 1; |
||||
continue; |
||||
} |
||||
if (!strcmp(arg, "--force")) { |
||||
args.force_update = 1; |
||||
continue; |
||||
} |
||||
if (!strcmp(arg, "--verbose")) { |
||||
args.verbose = 1; |
||||
continue; |
||||
} |
||||
if (!strcmp(arg, "--thin")) { |
||||
args.use_thin_pack = 1; |
||||
continue; |
||||
} |
||||
usage(send_pack_usage); |
||||
} |
||||
if (!dest) { |
||||
dest = arg; |
||||
continue; |
||||
} |
||||
heads = (const char **) argv; |
||||
nr_heads = argc - i; |
||||
break; |
||||
} |
||||
if (!dest) |
||||
usage(send_pack_usage); |
||||
/* |
||||
* --all and --mirror are incompatible; neither makes sense |
||||
* with any refspecs. |
||||
*/ |
||||
if ((heads && (args.send_all || args.send_mirror)) || |
||||
(args.send_all && args.send_mirror)) |
||||
usage(send_pack_usage); |
||||
|
||||
if (remote_name) { |
||||
remote = remote_get(remote_name); |
||||
if (!remote_has_url(remote, dest)) { |
||||
die("Destination %s is not a uri for %s", |
||||
dest, remote_name); |
||||
} |
||||
} |
||||
|
||||
return send_pack(&args, dest, remote, nr_heads, heads); |
||||
} |
||||
|
||||
int send_pack(struct send_pack_args *my_args, |
||||
const char *dest, struct remote *remote, |
||||
int nr_heads, const char **heads) |
||||
{ |
||||
int fd[2], ret; |
||||
struct child_process *conn; |
||||
|
||||
memcpy(&args, my_args, sizeof(args)); |
||||
|
||||
verify_remote_names(nr_heads, heads); |
||||
|
||||
conn = git_connect(fd, dest, args.receivepack, args.verbose ? CONNECT_VERBOSE : 0); |
||||
ret = do_send_pack(fd[0], fd[1], remote, dest, nr_heads, heads); |
||||
close(fd[0]); |
||||
close(fd[1]); |
||||
ret |= finish_connect(conn); |
||||
return !!ret; |
||||
} |
||||
@ -1,73 +0,0 @@
@@ -1,73 +0,0 @@
|
||||
#include "cache.h" |
||||
#include "refs.h" |
||||
#include "pkt-line.h" |
||||
|
||||
static const char peek_remote_usage[] = |
||||
"git-peek-remote [--upload-pack=<git-upload-pack>] [<host>:]<directory>"; |
||||
static const char *uploadpack = "git-upload-pack"; |
||||
|
||||
static int peek_remote(int fd[2], unsigned flags) |
||||
{ |
||||
struct ref *ref; |
||||
|
||||
get_remote_heads(fd[0], &ref, 0, NULL, flags); |
||||
packet_flush(fd[1]); |
||||
|
||||
while (ref) { |
||||
printf("%s %s\n", sha1_to_hex(ref->old_sha1), ref->name); |
||||
ref = ref->next; |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
int main(int argc, char **argv) |
||||
{ |
||||
int i, ret; |
||||
char *dest = NULL; |
||||
int fd[2]; |
||||
struct child_process *conn; |
||||
int nongit = 0; |
||||
unsigned flags = 0; |
||||
|
||||
setup_git_directory_gently(&nongit); |
||||
|
||||
for (i = 1; i < argc; i++) { |
||||
char *arg = argv[i]; |
||||
|
||||
if (*arg == '-') { |
||||
if (!prefixcmp(arg, "--upload-pack=")) { |
||||
uploadpack = arg + 14; |
||||
continue; |
||||
} |
||||
if (!prefixcmp(arg, "--exec=")) { |
||||
uploadpack = arg + 7; |
||||
continue; |
||||
} |
||||
if (!strcmp("--tags", arg)) { |
||||
flags |= REF_TAGS; |
||||
continue; |
||||
} |
||||
if (!strcmp("--heads", arg)) { |
||||
flags |= REF_HEADS; |
||||
continue; |
||||
} |
||||
if (!strcmp("--refs", arg)) { |
||||
flags |= REF_NORMAL; |
||||
continue; |
||||
} |
||||
usage(peek_remote_usage); |
||||
} |
||||
dest = arg; |
||||
break; |
||||
} |
||||
|
||||
if (!dest || i != argc - 1) |
||||
usage(peek_remote_usage); |
||||
|
||||
conn = git_connect(fd, dest, uploadpack, 0); |
||||
ret = peek_remote(fd, flags); |
||||
close(fd[0]); |
||||
close(fd[1]); |
||||
ret |= finish_connect(conn); |
||||
return !!ret; |
||||
} |
||||
@ -1,461 +0,0 @@
@@ -1,461 +0,0 @@
|
||||
#include "cache.h" |
||||
#include "commit.h" |
||||
#include "tag.h" |
||||
#include "refs.h" |
||||
#include "pkt-line.h" |
||||
#include "run-command.h" |
||||
#include "remote.h" |
||||
|
||||
static const char send_pack_usage[] = |
||||
"git-send-pack [--all] [--dry-run] [--force] [--receive-pack=<git-receive-pack>] [--verbose] [--thin] [<host>:]<directory> [<ref>...]\n" |
||||
" --all and explicit <ref> specification are mutually exclusive."; |
||||
static const char *receivepack = "git-receive-pack"; |
||||
static int verbose; |
||||
static int send_all; |
||||
static int force_update; |
||||
static int use_thin_pack; |
||||
static int dry_run; |
||||
|
||||
/* |
||||
* Make a pack stream and spit it out into file descriptor fd |
||||
*/ |
||||
static int pack_objects(int fd, struct ref *refs) |
||||
{ |
||||
/* |
||||
* The child becomes pack-objects --revs; we feed |
||||
* the revision parameters to it via its stdin and |
||||
* let its stdout go back to the other end. |
||||
*/ |
||||
const char *args[] = { |
||||
"pack-objects", |
||||
"--all-progress", |
||||
"--revs", |
||||
"--stdout", |
||||
NULL, |
||||
NULL, |
||||
}; |
||||
struct child_process po; |
||||
|
||||
if (use_thin_pack) |
||||
args[4] = "--thin"; |
||||
memset(&po, 0, sizeof(po)); |
||||
po.argv = args; |
||||
po.in = -1; |
||||
po.out = fd; |
||||
po.git_cmd = 1; |
||||
if (start_command(&po)) |
||||
die("git-pack-objects failed (%s)", strerror(errno)); |
||||
|
||||
/* |
||||
* We feed the pack-objects we just spawned with revision |
||||
* parameters by writing to the pipe. |
||||
*/ |
||||
while (refs) { |
||||
char buf[42]; |
||||
|
||||
if (!is_null_sha1(refs->old_sha1) && |
||||
has_sha1_file(refs->old_sha1)) { |
||||
memcpy(buf + 1, sha1_to_hex(refs->old_sha1), 40); |
||||
buf[0] = '^'; |
||||
buf[41] = '\n'; |
||||
if (!write_or_whine(po.in, buf, 42, |
||||
"send-pack: send refs")) |
||||
break; |
||||
} |
||||
if (!is_null_sha1(refs->new_sha1)) { |
||||
memcpy(buf, sha1_to_hex(refs->new_sha1), 40); |
||||
buf[40] = '\n'; |
||||
if (!write_or_whine(po.in, buf, 41, |
||||
"send-pack: send refs")) |
||||
break; |
||||
} |
||||
refs = refs->next; |
||||
} |
||||
|
||||
if (finish_command(&po)) |
||||
return error("pack-objects died with strange error"); |
||||
return 0; |
||||
} |
||||
|
||||
static void unmark_and_free(struct commit_list *list, unsigned int mark) |
||||
{ |
||||
while (list) { |
||||
struct commit_list *temp = list; |
||||
temp->item->object.flags &= ~mark; |
||||
list = temp->next; |
||||
free(temp); |
||||
} |
||||
} |
||||
|
||||
static int ref_newer(const unsigned char *new_sha1, |
||||
const unsigned char *old_sha1) |
||||
{ |
||||
struct object *o; |
||||
struct commit *old, *new; |
||||
struct commit_list *list, *used; |
||||
int found = 0; |
||||
|
||||
/* Both new and old must be commit-ish and new is descendant of |
||||
* old. Otherwise we require --force. |
||||
*/ |
||||
o = deref_tag(parse_object(old_sha1), NULL, 0); |
||||
if (!o || o->type != OBJ_COMMIT) |
||||
return 0; |
||||
old = (struct commit *) o; |
||||
|
||||
o = deref_tag(parse_object(new_sha1), NULL, 0); |
||||
if (!o || o->type != OBJ_COMMIT) |
||||
return 0; |
||||
new = (struct commit *) o; |
||||
|
||||
if (parse_commit(new) < 0) |
||||
return 0; |
||||
|
||||
used = list = NULL; |
||||
commit_list_insert(new, &list); |
||||
while (list) { |
||||
new = pop_most_recent_commit(&list, 1); |
||||
commit_list_insert(new, &used); |
||||
if (new == old) { |
||||
found = 1; |
||||
break; |
||||
} |
||||
} |
||||
unmark_and_free(list, 1); |
||||
unmark_and_free(used, 1); |
||||
return found; |
||||
} |
||||
|
||||
static struct ref *local_refs, **local_tail; |
||||
static struct ref *remote_refs, **remote_tail; |
||||
|
||||
static int one_local_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data) |
||||
{ |
||||
struct ref *ref; |
||||
int len = strlen(refname) + 1; |
||||
ref = xcalloc(1, sizeof(*ref) + len); |
||||
hashcpy(ref->new_sha1, sha1); |
||||
memcpy(ref->name, refname, len); |
||||
*local_tail = ref; |
||||
local_tail = &ref->next; |
||||
return 0; |
||||
} |
||||
|
||||
static void get_local_heads(void) |
||||
{ |
||||
local_tail = &local_refs; |
||||
for_each_ref(one_local_ref, NULL); |
||||
} |
||||
|
||||
static int receive_status(int in) |
||||
{ |
||||
char line[1000]; |
||||
int ret = 0; |
||||
int len = packet_read_line(in, line, sizeof(line)); |
||||
if (len < 10 || memcmp(line, "unpack ", 7)) { |
||||
fprintf(stderr, "did not receive status back\n"); |
||||
return -1; |
||||
} |
||||
if (memcmp(line, "unpack ok\n", 10)) { |
||||
fputs(line, stderr); |
||||
ret = -1; |
||||
} |
||||
while (1) { |
||||
len = packet_read_line(in, line, sizeof(line)); |
||||
if (!len) |
||||
break; |
||||
if (len < 3 || |
||||
(memcmp(line, "ok", 2) && memcmp(line, "ng", 2))) { |
||||
fprintf(stderr, "protocol error: %s\n", line); |
||||
ret = -1; |
||||
break; |
||||
} |
||||
if (!memcmp(line, "ok", 2)) |
||||
continue; |
||||
fputs(line, stderr); |
||||
ret = -1; |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
static void update_tracking_ref(struct remote *remote, struct ref *ref) |
||||
{ |
||||
struct refspec rs; |
||||
int will_delete_ref; |
||||
|
||||
rs.src = ref->name; |
||||
rs.dst = NULL; |
||||
|
||||
if (!ref->peer_ref) |
||||
return; |
||||
|
||||
will_delete_ref = is_null_sha1(ref->peer_ref->new_sha1); |
||||
|
||||
if (!will_delete_ref && |
||||
!hashcmp(ref->old_sha1, ref->peer_ref->new_sha1)) |
||||
return; |
||||
|
||||
if (!remote_find_tracking(remote, &rs)) { |
||||
fprintf(stderr, "updating local tracking ref '%s'\n", rs.dst); |
||||
if (is_null_sha1(ref->peer_ref->new_sha1)) { |
||||
if (delete_ref(rs.dst, NULL)) |
||||
error("Failed to delete"); |
||||
} else |
||||
update_ref("update by push", rs.dst, |
||||
ref->new_sha1, NULL, 0, 0); |
||||
free(rs.dst); |
||||
} |
||||
} |
||||
|
||||
static int send_pack(int in, int out, struct remote *remote, int nr_refspec, char **refspec) |
||||
{ |
||||
struct ref *ref; |
||||
int new_refs; |
||||
int ret = 0; |
||||
int ask_for_status_report = 0; |
||||
int allow_deleting_refs = 0; |
||||
int expect_status_report = 0; |
||||
|
||||
/* No funny business with the matcher */ |
||||
remote_tail = get_remote_heads(in, &remote_refs, 0, NULL, REF_NORMAL); |
||||
get_local_heads(); |
||||
|
||||
/* Does the other end support the reporting? */ |
||||
if (server_supports("report-status")) |
||||
ask_for_status_report = 1; |
||||
if (server_supports("delete-refs")) |
||||
allow_deleting_refs = 1; |
||||
|
||||
/* match them up */ |
||||
if (!remote_tail) |
||||
remote_tail = &remote_refs; |
||||
if (match_refs(local_refs, remote_refs, &remote_tail, |
||||
nr_refspec, refspec, send_all)) |
||||
return -1; |
||||
|
||||
if (!remote_refs) { |
||||
fprintf(stderr, "No refs in common and none specified; doing nothing.\n" |
||||
"Perhaps you should specify a branch such as 'master'.\n"); |
||||
return 0; |
||||
} |
||||
|
||||
/* |
||||
* Finally, tell the other end! |
||||
*/ |
||||
new_refs = 0; |
||||
for (ref = remote_refs; ref; ref = ref->next) { |
||||
char old_hex[60], *new_hex; |
||||
int will_delete_ref; |
||||
|
||||
if (!ref->peer_ref) |
||||
continue; |
||||
|
||||
|
||||
will_delete_ref = is_null_sha1(ref->peer_ref->new_sha1); |
||||
if (will_delete_ref && !allow_deleting_refs) { |
||||
error("remote does not support deleting refs"); |
||||
ret = -2; |
||||
continue; |
||||
} |
||||
if (!will_delete_ref && |
||||
!hashcmp(ref->old_sha1, ref->peer_ref->new_sha1)) { |
||||
if (verbose) |
||||
fprintf(stderr, "'%s': up-to-date\n", ref->name); |
||||
continue; |
||||
} |
||||
|
||||
/* This part determines what can overwrite what. |
||||
* The rules are: |
||||
* |
||||
* (0) you can always use --force or +A:B notation to |
||||
* selectively force individual ref pairs. |
||||
* |
||||
* (1) if the old thing does not exist, it is OK. |
||||
* |
||||
* (2) if you do not have the old thing, you are not allowed |
||||
* to overwrite it; you would not know what you are losing |
||||
* otherwise. |
||||
* |
||||
* (3) if both new and old are commit-ish, and new is a |
||||
* descendant of old, it is OK. |
||||
* |
||||
* (4) regardless of all of the above, removing :B is |
||||
* always allowed. |
||||
*/ |
||||
|
||||
if (!force_update && |
||||
!will_delete_ref && |
||||
!is_null_sha1(ref->old_sha1) && |
||||
!ref->force) { |
||||
if (!has_sha1_file(ref->old_sha1) || |
||||
!ref_newer(ref->peer_ref->new_sha1, |
||||
ref->old_sha1)) { |
||||
/* We do not have the remote ref, or |
||||
* we know that the remote ref is not |
||||
* an ancestor of what we are trying to |
||||
* push. Either way this can be losing |
||||
* commits at the remote end and likely |
||||
* we were not up to date to begin with. |
||||
*/ |
||||
error("remote '%s' is not an ancestor of\n" |
||||
" local '%s'.\n" |
||||
" Maybe you are not up-to-date and " |
||||
"need to pull first?", |
||||
ref->name, |
||||
ref->peer_ref->name); |
||||
ret = -2; |
||||
continue; |
||||
} |
||||
} |
||||
hashcpy(ref->new_sha1, ref->peer_ref->new_sha1); |
||||
if (!will_delete_ref) |
||||
new_refs++; |
||||
strcpy(old_hex, sha1_to_hex(ref->old_sha1)); |
||||
new_hex = sha1_to_hex(ref->new_sha1); |
||||
|
||||
if (!dry_run) { |
||||
if (ask_for_status_report) { |
||||
packet_write(out, "%s %s %s%c%s", |
||||
old_hex, new_hex, ref->name, 0, |
||||
"report-status"); |
||||
ask_for_status_report = 0; |
||||
expect_status_report = 1; |
||||
} |
||||
else |
||||
packet_write(out, "%s %s %s", |
||||
old_hex, new_hex, ref->name); |
||||
} |
||||
if (will_delete_ref) |
||||
fprintf(stderr, "deleting '%s'\n", ref->name); |
||||
else { |
||||
fprintf(stderr, "updating '%s'", ref->name); |
||||
if (strcmp(ref->name, ref->peer_ref->name)) |
||||
fprintf(stderr, " using '%s'", |
||||
ref->peer_ref->name); |
||||
fprintf(stderr, "\n from %s\n to %s\n", |
||||
old_hex, new_hex); |
||||
} |
||||
} |
||||
|
||||
packet_flush(out); |
||||
if (new_refs && !dry_run) |
||||
ret = pack_objects(out, remote_refs); |
||||
close(out); |
||||
|
||||
if (expect_status_report) { |
||||
if (receive_status(in)) |
||||
ret = -4; |
||||
} |
||||
|
||||
if (!dry_run && remote && ret == 0) { |
||||
for (ref = remote_refs; ref; ref = ref->next) |
||||
update_tracking_ref(remote, ref); |
||||
} |
||||
|
||||
if (!new_refs && ret == 0) |
||||
fprintf(stderr, "Everything up-to-date\n"); |
||||
return ret; |
||||
} |
||||
|
||||
static void verify_remote_names(int nr_heads, char **heads) |
||||
{ |
||||
int i; |
||||
|
||||
for (i = 0; i < nr_heads; i++) { |
||||
const char *remote = strchr(heads[i], ':'); |
||||
|
||||
remote = remote ? (remote + 1) : heads[i]; |
||||
switch (check_ref_format(remote)) { |
||||
case 0: /* ok */ |
||||
case -2: /* ok but a single level -- that is fine for |
||||
* a match pattern. |
||||
*/ |
||||
case -3: /* ok but ends with a pattern-match character */ |
||||
continue; |
||||
} |
||||
die("remote part of refspec is not a valid name in %s", |
||||
heads[i]); |
||||
} |
||||
} |
||||
|
||||
int main(int argc, char **argv) |
||||
{ |
||||
int i, nr_heads = 0; |
||||
char *dest = NULL; |
||||
char **heads = NULL; |
||||
int fd[2], ret; |
||||
struct child_process *conn; |
||||
char *remote_name = NULL; |
||||
struct remote *remote = NULL; |
||||
|
||||
setup_git_directory(); |
||||
git_config(git_default_config); |
||||
|
||||
argv++; |
||||
for (i = 1; i < argc; i++, argv++) { |
||||
char *arg = *argv; |
||||
|
||||
if (*arg == '-') { |
||||
if (!prefixcmp(arg, "--receive-pack=")) { |
||||
receivepack = arg + 15; |
||||
continue; |
||||
} |
||||
if (!prefixcmp(arg, "--exec=")) { |
||||
receivepack = arg + 7; |
||||
continue; |
||||
} |
||||
if (!prefixcmp(arg, "--remote=")) { |
||||
remote_name = arg + 9; |
||||
continue; |
||||
} |
||||
if (!strcmp(arg, "--all")) { |
||||
send_all = 1; |
||||
continue; |
||||
} |
||||
if (!strcmp(arg, "--dry-run")) { |
||||
dry_run = 1; |
||||
continue; |
||||
} |
||||
if (!strcmp(arg, "--force")) { |
||||
force_update = 1; |
||||
continue; |
||||
} |
||||
if (!strcmp(arg, "--verbose")) { |
||||
verbose = 1; |
||||
continue; |
||||
} |
||||
if (!strcmp(arg, "--thin")) { |
||||
use_thin_pack = 1; |
||||
continue; |
||||
} |
||||
usage(send_pack_usage); |
||||
} |
||||
if (!dest) { |
||||
dest = arg; |
||||
continue; |
||||
} |
||||
heads = argv; |
||||
nr_heads = argc - i; |
||||
break; |
||||
} |
||||
if (!dest) |
||||
usage(send_pack_usage); |
||||
if (heads && send_all) |
||||
usage(send_pack_usage); |
||||
verify_remote_names(nr_heads, heads); |
||||
|
||||
if (remote_name) { |
||||
remote = remote_get(remote_name); |
||||
if (!remote_has_url(remote, dest)) { |
||||
die("Destination %s is not a uri for %s", |
||||
dest, remote_name); |
||||
} |
||||
} |
||||
|
||||
conn = git_connect(fd, dest, receivepack, verbose ? CONNECT_VERBOSE : 0); |
||||
ret = send_pack(fd[0], fd[1], remote, nr_heads, heads); |
||||
close(fd[0]); |
||||
close(fd[1]); |
||||
ret |= finish_connect(conn); |
||||
return !!ret; |
||||
} |
||||
@ -0,0 +1,18 @@
@@ -0,0 +1,18 @@
|
||||
#ifndef SEND_PACK_H |
||||
#define SEND_PACK_H |
||||
|
||||
struct send_pack_args { |
||||
const char *receivepack; |
||||
unsigned verbose:1, |
||||
send_all:1, |
||||
send_mirror:1, |
||||
force_update:1, |
||||
use_thin_pack:1, |
||||
dry_run:1; |
||||
}; |
||||
|
||||
int send_pack(struct send_pack_args *args, |
||||
const char *dest, struct remote *remote, |
||||
int nr_heads, const char **heads); |
||||
|
||||
#endif |
||||
@ -0,0 +1,53 @@
@@ -0,0 +1,53 @@
|
||||
#!/bin/sh |
||||
|
||||
test_description='tracking branch update checks for git push' |
||||
|
||||
. ./test-lib.sh |
||||
|
||||
test_expect_success 'setup' ' |
||||
echo 1 >file && |
||||
git add file && |
||||
git commit -m 1 && |
||||
git branch b1 && |
||||
git branch b2 && |
||||
git clone . aa && |
||||
git checkout b1 && |
||||
echo b1 >>file && |
||||
git commit -a -m b1 && |
||||
git checkout b2 && |
||||
echo b2 >>file && |
||||
git commit -a -m b2 |
||||
' |
||||
|
||||
test_expect_success 'prepare pushable branches' ' |
||||
cd aa && |
||||
b1=$(git rev-parse origin/b1) && |
||||
b2=$(git rev-parse origin/b2) && |
||||
git checkout -b b1 origin/b1 && |
||||
echo aa-b1 >>file && |
||||
git commit -a -m aa-b1 && |
||||
git checkout -b b2 origin/b2 && |
||||
echo aa-b2 >>file && |
||||
git commit -a -m aa-b2 && |
||||
git checkout master && |
||||
echo aa-master >>file && |
||||
git commit -a -m aa-master |
||||
' |
||||
|
||||
test_expect_success 'mixed-success push returns error' '! git push' |
||||
|
||||
test_expect_success 'check tracking branches updated correctly after push' ' |
||||
test "$(git rev-parse origin/master)" = "$(git rev-parse master)" |
||||
' |
||||
|
||||
test_expect_success 'check tracking branches not updated for failed refs' ' |
||||
test "$(git rev-parse origin/b1)" = "$b1" && |
||||
test "$(git rev-parse origin/b2)" = "$b2" |
||||
' |
||||
|
||||
test_expect_success 'deleted branches have their tracking branches removed' ' |
||||
git push origin :b1 && |
||||
test "$(git rev-parse origin/b1)" = "origin/b1" |
||||
' |
||||
|
||||
test_done |
||||
@ -0,0 +1,42 @@
@@ -0,0 +1,42 @@
|
||||
#!/bin/sh |
||||
|
||||
test_description='forced push to replace commit we do not have' |
||||
|
||||
. ./test-lib.sh |
||||
|
||||
test_expect_success setup ' |
||||
|
||||
>file1 && git add file1 && test_tick && |
||||
git commit -m Initial && |
||||
|
||||
mkdir another && ( |
||||
cd another && |
||||
git init && |
||||
git fetch .. master:master |
||||
) && |
||||
|
||||
>file2 && git add file2 && test_tick && |
||||
git commit -m Second |
||||
|
||||
' |
||||
|
||||
test_expect_success 'non forced push should die not segfault' ' |
||||
|
||||
( |
||||
cd another && |
||||
git push .. master:master |
||||
test $? = 1 |
||||
) |
||||
|
||||
' |
||||
|
||||
test_expect_success 'forced push should succeed' ' |
||||
|
||||
( |
||||
cd another && |
||||
git push .. +master:master |
||||
) |
||||
|
||||
' |
||||
|
||||
test_done |
||||
@ -0,0 +1,24 @@
@@ -0,0 +1,24 @@
|
||||
#!/bin/sh |
||||
|
||||
test_description='remote push rejects are reported by client' |
||||
|
||||
. ./test-lib.sh |
||||
|
||||
test_expect_success 'setup' ' |
||||
mkdir .git/hooks && |
||||
(echo "#!/bin/sh" ; echo "exit 1") >.git/hooks/update && |
||||
chmod +x .git/hooks/update && |
||||
echo 1 >file && |
||||
git add file && |
||||
git commit -m 1 && |
||||
git clone . child && |
||||
cd child && |
||||
echo 2 >file && |
||||
git commit -a -m 2 |
||||
' |
||||
|
||||
test_expect_success 'push reports error' '! git push 2>stderr' |
||||
|
||||
test_expect_success 'individual ref reports error' 'grep rejected stderr' |
||||
|
||||
test_done |
||||
@ -0,0 +1,52 @@
@@ -0,0 +1,52 @@
|
||||
#!/bin/sh |
||||
|
||||
test_description='git ls-remote' |
||||
|
||||
. ./test-lib.sh |
||||
|
||||
test_expect_success setup ' |
||||
|
||||
>file && |
||||
git add file && |
||||
test_tick && |
||||
git commit -m initial && |
||||
git tag mark && |
||||
git show-ref --tags -d | sed -e "s/ / /" >expected.tag && |
||||
( |
||||
echo "$(git rev-parse HEAD) HEAD" |
||||
git show-ref -d | sed -e "s/ / /" |
||||
) >expected.all && |
||||
|
||||
git remote add self $(pwd)/.git |
||||
|
||||
' |
||||
|
||||
test_expect_success 'ls-remote --tags .git' ' |
||||
|
||||
git ls-remote --tags .git >actual && |
||||
diff -u expected.tag actual |
||||
|
||||
' |
||||
|
||||
test_expect_success 'ls-remote .git' ' |
||||
|
||||
git ls-remote .git >actual && |
||||
diff -u expected.all actual |
||||
|
||||
' |
||||
|
||||
test_expect_success 'ls-remote --tags self' ' |
||||
|
||||
git ls-remote --tags self >actual && |
||||
diff -u expected.tag actual |
||||
|
||||
' |
||||
|
||||
test_expect_success 'ls-remote self' ' |
||||
|
||||
git ls-remote self >actual && |
||||
diff -u expected.all actual |
||||
|
||||
' |
||||
|
||||
test_done |
||||
@ -0,0 +1,228 @@
@@ -0,0 +1,228 @@
|
||||
#!/bin/sh |
||||
|
||||
test_description='pushing to a mirror repository' |
||||
|
||||
. ./test-lib.sh |
||||
|
||||
D=`pwd` |
||||
|
||||
invert () { |
||||
if "$@"; then |
||||
return 1 |
||||
else |
||||
return 0 |
||||
fi |
||||
} |
||||
|
||||
mk_repo_pair () { |
||||
rm -rf master mirror && |
||||
mkdir mirror && |
||||
( |
||||
cd mirror && |
||||
git init |
||||
) && |
||||
mkdir master && |
||||
( |
||||
cd master && |
||||
git init && |
||||
git config remote.up.url ../mirror |
||||
) |
||||
} |
||||
|
||||
|
||||
# BRANCH tests |
||||
test_expect_success 'push mirror creates new branches' ' |
||||
|
||||
mk_repo_pair && |
||||
( |
||||
cd master && |
||||
echo one >foo && git add foo && git commit -m one && |
||||
git push --mirror up |
||||
) && |
||||
master_master=$(cd master && git show-ref -s --verify refs/heads/master) && |
||||
mirror_master=$(cd mirror && git show-ref -s --verify refs/heads/master) && |
||||
test "$master_master" = "$mirror_master" |
||||
|
||||
' |
||||
|
||||
test_expect_success 'push mirror updates existing branches' ' |
||||
|
||||
mk_repo_pair && |
||||
( |
||||
cd master && |
||||
echo one >foo && git add foo && git commit -m one && |
||||
git push --mirror up && |
||||
echo two >foo && git add foo && git commit -m two && |
||||
git push --mirror up |
||||
) && |
||||
master_master=$(cd master && git show-ref -s --verify refs/heads/master) && |
||||
mirror_master=$(cd mirror && git show-ref -s --verify refs/heads/master) && |
||||
test "$master_master" = "$mirror_master" |
||||
|
||||
' |
||||
|
||||
test_expect_success 'push mirror force updates existing branches' ' |
||||
|
||||
mk_repo_pair && |
||||
( |
||||
cd master && |
||||
echo one >foo && git add foo && git commit -m one && |
||||
git push --mirror up && |
||||
echo two >foo && git add foo && git commit -m two && |
||||
git push --mirror up && |
||||
git reset --hard HEAD^ |
||||
git push --mirror up |
||||
) && |
||||
master_master=$(cd master && git show-ref -s --verify refs/heads/master) && |
||||
mirror_master=$(cd mirror && git show-ref -s --verify refs/heads/master) && |
||||
test "$master_master" = "$mirror_master" |
||||
|
||||
' |
||||
|
||||
test_expect_success 'push mirror removes branches' ' |
||||
|
||||
mk_repo_pair && |
||||
( |
||||
cd master && |
||||
echo one >foo && git add foo && git commit -m one && |
||||
git branch remove master && |
||||
git push --mirror up && |
||||
git branch -D remove |
||||
git push --mirror up |
||||
) && |
||||
( |
||||
cd mirror && |
||||
invert git show-ref -s --verify refs/heads/remove |
||||
) |
||||
|
||||
' |
||||
|
||||
test_expect_success 'push mirror adds, updates and removes branches together' ' |
||||
|
||||
mk_repo_pair && |
||||
( |
||||
cd master && |
||||
echo one >foo && git add foo && git commit -m one && |
||||
git branch remove master && |
||||
git push --mirror up && |
||||
git branch -D remove && |
||||
git branch add master && |
||||
echo two >foo && git add foo && git commit -m two && |
||||
git push --mirror up |
||||
) && |
||||
master_master=$(cd master && git show-ref -s --verify refs/heads/master) && |
||||
master_add=$(cd master && git show-ref -s --verify refs/heads/add) && |
||||
mirror_master=$(cd mirror && git show-ref -s --verify refs/heads/master) && |
||||
mirror_add=$(cd mirror && git show-ref -s --verify refs/heads/add) && |
||||
test "$master_master" = "$mirror_master" && |
||||
test "$master_add" = "$mirror_add" && |
||||
( |
||||
cd mirror && |
||||
invert git show-ref -s --verify refs/heads/remove |
||||
) |
||||
|
||||
' |
||||
|
||||
|
||||
# TAG tests |
||||
test_expect_success 'push mirror creates new tags' ' |
||||
|
||||
mk_repo_pair && |
||||
( |
||||
cd master && |
||||
echo one >foo && git add foo && git commit -m one && |
||||
git tag -f tmaster master && |
||||
git push --mirror up |
||||
) && |
||||
master_master=$(cd master && git show-ref -s --verify refs/tags/tmaster) && |
||||
mirror_master=$(cd mirror && git show-ref -s --verify refs/tags/tmaster) && |
||||
test "$master_master" = "$mirror_master" |
||||
|
||||
' |
||||
|
||||
test_expect_success 'push mirror updates existing tags' ' |
||||
|
||||
mk_repo_pair && |
||||
( |
||||
cd master && |
||||
echo one >foo && git add foo && git commit -m one && |
||||
git tag -f tmaster master && |
||||
git push --mirror up && |
||||
echo two >foo && git add foo && git commit -m two && |
||||
git tag -f tmaster master && |
||||
git push --mirror up |
||||
) && |
||||
master_master=$(cd master && git show-ref -s --verify refs/tags/tmaster) && |
||||
mirror_master=$(cd mirror && git show-ref -s --verify refs/tags/tmaster) && |
||||
test "$master_master" = "$mirror_master" |
||||
|
||||
' |
||||
|
||||
test_expect_success 'push mirror force updates existing tags' ' |
||||
|
||||
mk_repo_pair && |
||||
( |
||||
cd master && |
||||
echo one >foo && git add foo && git commit -m one && |
||||
git tag -f tmaster master && |
||||
git push --mirror up && |
||||
echo two >foo && git add foo && git commit -m two && |
||||
git tag -f tmaster master && |
||||
git push --mirror up && |
||||
git reset --hard HEAD^ |
||||
git tag -f tmaster master && |
||||
git push --mirror up |
||||
) && |
||||
master_master=$(cd master && git show-ref -s --verify refs/tags/tmaster) && |
||||
mirror_master=$(cd mirror && git show-ref -s --verify refs/tags/tmaster) && |
||||
test "$master_master" = "$mirror_master" |
||||
|
||||
' |
||||
|
||||
test_expect_success 'push mirror removes tags' ' |
||||
|
||||
mk_repo_pair && |
||||
( |
||||
cd master && |
||||
echo one >foo && git add foo && git commit -m one && |
||||
git tag -f tremove master && |
||||
git push --mirror up && |
||||
git tag -d tremove |
||||
git push --mirror up |
||||
) && |
||||
( |
||||
cd mirror && |
||||
invert git show-ref -s --verify refs/tags/tremove |
||||
) |
||||
|
||||
' |
||||
|
||||
test_expect_success 'push mirror adds, updates and removes tags together' ' |
||||
|
||||
mk_repo_pair && |
||||
( |
||||
cd master && |
||||
echo one >foo && git add foo && git commit -m one && |
||||
git tag -f tmaster master && |
||||
git tag -f tremove master && |
||||
git push --mirror up && |
||||
git tag -d tremove && |
||||
git tag tadd master && |
||||
echo two >foo && git add foo && git commit -m two && |
||||
git tag -f tmaster master && |
||||
git push --mirror up |
||||
) && |
||||
master_master=$(cd master && git show-ref -s --verify refs/tags/tmaster) && |
||||
master_add=$(cd master && git show-ref -s --verify refs/tags/tadd) && |
||||
mirror_master=$(cd mirror && git show-ref -s --verify refs/tags/tmaster) && |
||||
mirror_add=$(cd mirror && git show-ref -s --verify refs/tags/tadd) && |
||||
test "$master_master" = "$mirror_master" && |
||||
test "$master_add" = "$mirror_add" && |
||||
( |
||||
cd mirror && |
||||
invert git show-ref -s --verify refs/tags/tremove |
||||
) |
||||
|
||||
' |
||||
|
||||
test_done |
||||
Loading…
Reference in new issue