2007-09-11 05:03:15 +02:00
|
|
|
#include "cache.h"
|
2014-10-01 12:28:42 +02:00
|
|
|
#include "lockfile.h"
|
2007-09-11 05:03:15 +02:00
|
|
|
#include "bundle.h"
|
2018-05-16 01:42:15 +02:00
|
|
|
#include "object-store.h"
|
2018-06-29 03:21:51 +02:00
|
|
|
#include "repository.h"
|
2007-09-11 05:03:15 +02:00
|
|
|
#include "object.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "revision.h"
|
|
|
|
#include "list-objects.h"
|
|
|
|
#include "run-command.h"
|
2007-11-23 01:51:18 +01:00
|
|
|
#include "refs.h"
|
2013-11-12 22:32:11 +01:00
|
|
|
#include "argv-array.h"
|
2007-09-11 05:03:15 +02:00
|
|
|
|
|
|
|
static const char bundle_signature[] = "# v2 git bundle\n";
|
|
|
|
|
2017-05-01 04:28:59 +02:00
|
|
|
static void add_to_ref_list(const struct object_id *oid, const char *name,
|
2007-09-11 05:03:15 +02:00
|
|
|
struct ref_list *list)
|
|
|
|
{
|
2014-03-03 23:31:50 +01:00
|
|
|
ALLOC_GROW(list->list, list->nr + 1, list->alloc);
|
2017-05-01 04:28:59 +02:00
|
|
|
oidcpy(&list->list[list->nr].oid, oid);
|
2007-09-11 05:03:15 +02:00
|
|
|
list->list[list->nr].name = xstrdup(name);
|
|
|
|
list->nr++;
|
|
|
|
}
|
|
|
|
|
2011-10-14 00:19:31 +02:00
|
|
|
static int parse_bundle_header(int fd, struct bundle_header *header,
|
|
|
|
const char *report_path)
|
2007-11-09 00:35:32 +01:00
|
|
|
{
|
2011-10-14 00:12:02 +02:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int status = 0;
|
2007-09-11 05:03:15 +02:00
|
|
|
|
2011-10-14 00:12:02 +02:00
|
|
|
/* The bundle header begins with the signature */
|
2012-02-22 20:34:22 +01:00
|
|
|
if (strbuf_getwholeline_fd(&buf, fd, '\n') ||
|
2011-10-14 00:12:02 +02:00
|
|
|
strcmp(buf.buf, bundle_signature)) {
|
2011-10-14 00:19:31 +02:00
|
|
|
if (report_path)
|
2012-04-23 14:30:30 +02:00
|
|
|
error(_("'%s' does not look like a v2 bundle file"),
|
2011-10-14 00:19:31 +02:00
|
|
|
report_path);
|
2011-10-14 00:12:02 +02:00
|
|
|
status = -1;
|
|
|
|
goto abort;
|
2007-09-11 05:03:15 +02:00
|
|
|
}
|
2011-10-14 00:12:02 +02:00
|
|
|
|
|
|
|
/* The bundle header ends with an empty line */
|
2012-02-22 20:34:22 +01:00
|
|
|
while (!strbuf_getwholeline_fd(&buf, fd, '\n') &&
|
2011-10-14 00:12:02 +02:00
|
|
|
buf.len && buf.buf[0] != '\n') {
|
2017-05-01 04:28:59 +02:00
|
|
|
struct object_id oid;
|
2011-10-14 00:12:02 +02:00
|
|
|
int is_prereq = 0;
|
2017-05-01 04:28:59 +02:00
|
|
|
const char *p;
|
2011-10-14 00:12:02 +02:00
|
|
|
|
|
|
|
if (*buf.buf == '-') {
|
|
|
|
is_prereq = 1;
|
|
|
|
strbuf_remove(&buf, 0, 1);
|
2007-09-11 05:03:15 +02:00
|
|
|
}
|
2011-10-14 00:12:02 +02:00
|
|
|
strbuf_rtrim(&buf);
|
2007-09-11 05:03:15 +02:00
|
|
|
|
2011-10-14 00:12:02 +02:00
|
|
|
/*
|
|
|
|
* Tip lines have object name, SP, and refname.
|
|
|
|
* Prerequisites have object name that is optionally
|
|
|
|
* followed by SP and subject line.
|
|
|
|
*/
|
2017-05-01 04:28:59 +02:00
|
|
|
if (parse_oid_hex(buf.buf, &oid, &p) ||
|
|
|
|
(*p && !isspace(*p)) ||
|
|
|
|
(!is_prereq && !*p)) {
|
2011-10-14 00:19:31 +02:00
|
|
|
if (report_path)
|
2012-04-23 14:30:30 +02:00
|
|
|
error(_("unrecognized header: %s%s (%d)"),
|
2011-10-14 00:19:31 +02:00
|
|
|
(is_prereq ? "-" : ""), buf.buf, (int)buf.len);
|
2011-10-14 00:12:02 +02:00
|
|
|
status = -1;
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
if (is_prereq)
|
2017-05-01 04:28:59 +02:00
|
|
|
add_to_ref_list(&oid, "", &header->prerequisites);
|
2011-10-14 00:12:02 +02:00
|
|
|
else
|
2017-05-01 04:28:59 +02:00
|
|
|
add_to_ref_list(&oid, p + 1, &header->references);
|
2007-09-11 05:03:15 +02:00
|
|
|
}
|
|
|
|
}
|
2011-10-14 00:12:02 +02:00
|
|
|
|
|
|
|
abort:
|
|
|
|
if (status) {
|
|
|
|
close(fd);
|
|
|
|
fd = -1;
|
2007-09-11 05:03:15 +02:00
|
|
|
}
|
2011-10-14 00:12:02 +02:00
|
|
|
strbuf_release(&buf);
|
2007-09-11 05:03:15 +02:00
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
2011-10-14 00:19:31 +02:00
|
|
|
int read_bundle_header(const char *path, struct bundle_header *header)
|
|
|
|
{
|
|
|
|
int fd = open(path, O_RDONLY);
|
|
|
|
|
2007-09-11 05:03:15 +02:00
|
|
|
if (fd < 0)
|
2012-04-23 14:30:30 +02:00
|
|
|
return error(_("could not open '%s'"), path);
|
2011-10-14 00:19:31 +02:00
|
|
|
return parse_bundle_header(fd, header, path);
|
|
|
|
}
|
|
|
|
|
|
|
|
int is_bundle(const char *path, int quiet)
|
|
|
|
{
|
|
|
|
struct bundle_header header;
|
|
|
|
int fd = open(path, O_RDONLY);
|
|
|
|
|
|
|
|
if (fd < 0)
|
|
|
|
return 0;
|
|
|
|
memset(&header, 0, sizeof(header));
|
|
|
|
fd = parse_bundle_header(fd, &header, quiet ? NULL : path);
|
|
|
|
if (fd >= 0)
|
|
|
|
close(fd);
|
|
|
|
return (fd >= 0);
|
2007-09-11 05:03:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int list_refs(struct ref_list *r, int argc, const char **argv)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < r->nr; i++) {
|
|
|
|
if (argc > 1) {
|
|
|
|
int j;
|
|
|
|
for (j = 1; j < argc; j++)
|
|
|
|
if (!strcmp(r->list[i].name, argv[j]))
|
|
|
|
break;
|
|
|
|
if (j == argc)
|
|
|
|
continue;
|
|
|
|
}
|
2017-05-01 04:28:59 +02:00
|
|
|
printf("%s %s\n", oid_to_hex(&r->list[i].oid),
|
2007-09-11 05:03:15 +02:00
|
|
|
r->list[i].name);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-25 14:23:26 +01:00
|
|
|
/* Remember to update object flag allocation in object.h */
|
2007-09-11 05:03:15 +02:00
|
|
|
#define PREREQ_MARK (1u<<16)
|
|
|
|
|
|
|
|
int verify_bundle(struct bundle_header *header, int verbose)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Do fast check, then if any prereqs are missing then go line by line
|
|
|
|
* to be verbose about the errors
|
|
|
|
*/
|
|
|
|
struct ref_list *p = &header->prerequisites;
|
|
|
|
struct rev_info revs;
|
2009-05-21 11:32:44 +02:00
|
|
|
const char *argv[] = {NULL, "--all", NULL};
|
2007-09-11 05:03:15 +02:00
|
|
|
struct commit *commit;
|
|
|
|
int i, ret = 0, req_nr;
|
2012-04-23 14:30:30 +02:00
|
|
|
const char *message = _("Repository lacks these prerequisite commits:");
|
2007-09-11 05:03:15 +02:00
|
|
|
|
2018-09-21 17:57:38 +02:00
|
|
|
repo_init_revisions(the_repository, &revs, NULL);
|
2007-09-11 05:03:15 +02:00
|
|
|
for (i = 0; i < p->nr; i++) {
|
|
|
|
struct ref_list_entry *e = p->list + i;
|
2018-06-29 03:21:51 +02:00
|
|
|
struct object *o = parse_object(the_repository, &e->oid);
|
2007-09-11 05:03:15 +02:00
|
|
|
if (o) {
|
|
|
|
o->flags |= PREREQ_MARK;
|
|
|
|
add_pending_object(&revs, o, e->name);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (++ret == 1)
|
2008-11-10 22:07:52 +01:00
|
|
|
error("%s", message);
|
2017-05-01 04:28:59 +02:00
|
|
|
error("%s %s", oid_to_hex(&e->oid), e->name);
|
2007-09-11 05:03:15 +02:00
|
|
|
}
|
|
|
|
if (revs.pending.nr != p->nr)
|
|
|
|
return ret;
|
|
|
|
req_nr = revs.pending.nr;
|
|
|
|
setup_revisions(2, argv, &revs, NULL);
|
|
|
|
|
2008-02-18 08:31:56 +01:00
|
|
|
if (prepare_revision_walk(&revs))
|
2012-04-23 14:30:30 +02:00
|
|
|
die(_("revision walk setup failed"));
|
2007-09-11 05:03:15 +02:00
|
|
|
|
|
|
|
i = req_nr;
|
|
|
|
while (i && (commit = get_revision(&revs)))
|
|
|
|
if (commit->object.flags & PREREQ_MARK)
|
|
|
|
i--;
|
|
|
|
|
2017-12-25 18:46:14 +01:00
|
|
|
for (i = 0; i < p->nr; i++) {
|
|
|
|
struct ref_list_entry *e = p->list + i;
|
2018-06-29 03:21:51 +02:00
|
|
|
struct object *o = parse_object(the_repository, &e->oid);
|
2017-12-25 18:46:14 +01:00
|
|
|
assert(o); /* otherwise we'd have returned early */
|
|
|
|
if (o->flags & SHOWN)
|
|
|
|
continue;
|
|
|
|
if (++ret == 1)
|
|
|
|
error("%s", message);
|
|
|
|
error("%s %s", oid_to_hex(&e->oid), e->name);
|
|
|
|
}
|
2007-09-11 05:03:15 +02:00
|
|
|
|
2017-09-23 01:34:51 +02:00
|
|
|
/* Clean up objects used, as they will be reused. */
|
2017-12-25 18:46:14 +01:00
|
|
|
for (i = 0; i < p->nr; i++) {
|
|
|
|
struct ref_list_entry *e = p->list + i;
|
2018-06-29 03:21:57 +02:00
|
|
|
commit = lookup_commit_reference_gently(the_repository, &e->oid, 1);
|
2017-12-25 18:46:14 +01:00
|
|
|
if (commit)
|
|
|
|
clear_commit_marks(commit, ALL_REV_FLAGS);
|
|
|
|
}
|
2007-09-11 05:03:15 +02:00
|
|
|
|
|
|
|
if (verbose) {
|
|
|
|
struct ref_list *r;
|
|
|
|
|
|
|
|
r = &header->references;
|
2013-03-08 19:01:26 +01:00
|
|
|
printf_ln(Q_("The bundle contains this ref:",
|
|
|
|
"The bundle contains these %d refs:",
|
2012-04-23 14:30:30 +02:00
|
|
|
r->nr),
|
|
|
|
r->nr);
|
2007-09-11 05:03:15 +02:00
|
|
|
list_refs(r, 0, NULL);
|
2013-03-07 01:56:35 +01:00
|
|
|
r = &header->prerequisites;
|
2012-06-04 20:51:13 +02:00
|
|
|
if (!r->nr) {
|
|
|
|
printf_ln(_("The bundle records a complete history."));
|
|
|
|
} else {
|
2013-03-08 19:01:26 +01:00
|
|
|
printf_ln(Q_("The bundle requires this ref:",
|
|
|
|
"The bundle requires these %d refs:",
|
2012-06-04 20:51:13 +02:00
|
|
|
r->nr),
|
|
|
|
r->nr);
|
|
|
|
list_refs(r, 0, NULL);
|
|
|
|
}
|
2007-09-11 05:03:15 +02:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int list_bundle_refs(struct bundle_header *header, int argc, const char **argv)
|
|
|
|
{
|
|
|
|
return list_refs(&header->references, argc, argv);
|
|
|
|
}
|
|
|
|
|
2009-01-02 19:08:46 +01:00
|
|
|
static int is_tag_in_date_range(struct object *tag, struct rev_info *revs)
|
|
|
|
{
|
|
|
|
unsigned long size;
|
|
|
|
enum object_type type;
|
2014-10-04 00:40:24 +02:00
|
|
|
char *buf = NULL, *line, *lineend;
|
2017-04-26 21:29:31 +02:00
|
|
|
timestamp_t date;
|
2014-10-04 00:40:24 +02:00
|
|
|
int result = 1;
|
2009-01-02 19:08:46 +01:00
|
|
|
|
|
|
|
if (revs->max_age == -1 && revs->min_age == -1)
|
2014-10-04 00:40:24 +02:00
|
|
|
goto out;
|
2009-01-02 19:08:46 +01:00
|
|
|
|
sha1_file: convert read_sha1_file to struct object_id
Convert read_sha1_file to take a pointer to struct object_id and rename
it read_object_file. Do the same for read_sha1_file_extended.
Convert one use in grep.c to use the new function without any other code
change, since the pointer being passed is a void pointer that is already
initialized with a pointer to struct object_id. Update the declaration
and definitions of the modified functions, and apply the following
semantic patch to convert the remaining callers:
@@
expression E1, E2, E3;
@@
- read_sha1_file(E1.hash, E2, E3)
+ read_object_file(&E1, E2, E3)
@@
expression E1, E2, E3;
@@
- read_sha1_file(E1->hash, E2, E3)
+ read_object_file(E1, E2, E3)
@@
expression E1, E2, E3, E4;
@@
- read_sha1_file_extended(E1.hash, E2, E3, E4)
+ read_object_file_extended(&E1, E2, E3, E4)
@@
expression E1, E2, E3, E4;
@@
- read_sha1_file_extended(E1->hash, E2, E3, E4)
+ read_object_file_extended(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 03:27:53 +01:00
|
|
|
buf = read_object_file(&tag->oid, &type, &size);
|
2009-01-02 19:08:46 +01:00
|
|
|
if (!buf)
|
2014-10-04 00:40:24 +02:00
|
|
|
goto out;
|
2009-01-02 19:08:46 +01:00
|
|
|
line = memmem(buf, size, "\ntagger ", 8);
|
|
|
|
if (!line++)
|
2014-10-04 00:40:24 +02:00
|
|
|
goto out;
|
2014-08-02 10:39:06 +02:00
|
|
|
lineend = memchr(line, '\n', buf + size - line);
|
|
|
|
line = memchr(line, '>', lineend ? lineend - line : buf + size - line);
|
2009-01-02 19:08:46 +01:00
|
|
|
if (!line++)
|
2014-10-04 00:40:24 +02:00
|
|
|
goto out;
|
2017-04-21 12:45:44 +02:00
|
|
|
date = parse_timestamp(line, NULL, 10);
|
2014-10-04 00:40:24 +02:00
|
|
|
result = (revs->max_age == -1 || revs->max_age < date) &&
|
2009-01-02 19:08:46 +01:00
|
|
|
(revs->min_age == -1 || revs->min_age > date);
|
2014-10-04 00:40:24 +02:00
|
|
|
out:
|
|
|
|
free(buf);
|
|
|
|
return result;
|
2009-01-02 19:08:46 +01:00
|
|
|
}
|
|
|
|
|
2015-08-10 11:47:37 +02:00
|
|
|
|
bundle: dup() output descriptor closer to point-of-use
When writing a bundle to a file, the bundle code actually creates
"your.bundle.lock" using our lockfile interface. We feed that output
descriptor to a child git-pack-objects via run-command, which has the
quirk that it closes the output descriptor in the parent.
To avoid confusing the lockfile code (which still thinks the descriptor
is valid), we dup() it, and operate on the duplicate.
However, this has a confusing side effect: after the dup() but before we
call pack-objects, we have _two_ descriptors open to the lockfile. If we
call die() during that time, the lockfile code will try to clean up the
partially-written file. It knows to close() the file before unlinking,
since on some platforms (i.e., Windows) the open file would block the
deletion. But it doesn't know about the duplicate descriptor. On
Windows, triggering an error at the right part of the code will result
in the cleanup failing and the lockfile being left in the filesystem.
We can solve this by moving the dup() much closer to start_command(),
shrinking the window in which we have the second descriptor open. It's
easy to place this in such a way that no die() is possible. We could
still die due to a signal in the exact wrong moment, but we already
tolerate races there (e.g., a signal could come before we manage to put
the file on the cleanup list in the first place).
As a bonus, this shields create_bundle() itself from the duplicate-fd
trick, and we can simplify its error handling (note that the lock
rollback now happens unconditionally, but that's OK; it's a noop if we
didn't open the lock in the first place).
The included test uses an empty bundle to cause a failure at the right
spot in the code, because that's easy to trigger (the other likely
errors are write() problems like ENOSPC). Note that it would already
pass on non-Windows systems (because they are happy to unlink an
already-open file).
Based-on-a-patch-by: Gaël Lhez <gael.lhez@gmail.com>
Signed-off-by: Jeff King <peff@peff.net>
Tested-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-16 10:43:59 +01:00
|
|
|
/* Write the pack data to bundle_fd */
|
2015-08-10 11:47:37 +02:00
|
|
|
static int write_pack_data(int bundle_fd, struct rev_info *revs)
|
2014-10-30 18:45:41 +01:00
|
|
|
{
|
|
|
|
struct child_process pack_objects = CHILD_PROCESS_INIT;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
argv_array_pushl(&pack_objects.args,
|
|
|
|
"pack-objects", "--all-progress-implied",
|
|
|
|
"--stdout", "--thin", "--delta-base-offset",
|
|
|
|
NULL);
|
|
|
|
pack_objects.in = -1;
|
|
|
|
pack_objects.out = bundle_fd;
|
|
|
|
pack_objects.git_cmd = 1;
|
bundle: dup() output descriptor closer to point-of-use
When writing a bundle to a file, the bundle code actually creates
"your.bundle.lock" using our lockfile interface. We feed that output
descriptor to a child git-pack-objects via run-command, which has the
quirk that it closes the output descriptor in the parent.
To avoid confusing the lockfile code (which still thinks the descriptor
is valid), we dup() it, and operate on the duplicate.
However, this has a confusing side effect: after the dup() but before we
call pack-objects, we have _two_ descriptors open to the lockfile. If we
call die() during that time, the lockfile code will try to clean up the
partially-written file. It knows to close() the file before unlinking,
since on some platforms (i.e., Windows) the open file would block the
deletion. But it doesn't know about the duplicate descriptor. On
Windows, triggering an error at the right part of the code will result
in the cleanup failing and the lockfile being left in the filesystem.
We can solve this by moving the dup() much closer to start_command(),
shrinking the window in which we have the second descriptor open. It's
easy to place this in such a way that no die() is possible. We could
still die due to a signal in the exact wrong moment, but we already
tolerate races there (e.g., a signal could come before we manage to put
the file on the cleanup list in the first place).
As a bonus, this shields create_bundle() itself from the duplicate-fd
trick, and we can simplify its error handling (note that the lock
rollback now happens unconditionally, but that's OK; it's a noop if we
didn't open the lock in the first place).
The included test uses an empty bundle to cause a failure at the right
spot in the code, because that's easy to trigger (the other likely
errors are write() problems like ENOSPC). Note that it would already
pass on non-Windows systems (because they are happy to unlink an
already-open file).
Based-on-a-patch-by: Gaël Lhez <gael.lhez@gmail.com>
Signed-off-by: Jeff King <peff@peff.net>
Tested-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-16 10:43:59 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* start_command() will close our descriptor if it's >1. Duplicate it
|
|
|
|
* to avoid surprising the caller.
|
|
|
|
*/
|
|
|
|
if (pack_objects.out > 1) {
|
|
|
|
pack_objects.out = dup(pack_objects.out);
|
|
|
|
if (pack_objects.out < 0) {
|
|
|
|
error_errno(_("unable to dup bundle descriptor"));
|
|
|
|
child_process_clear(&pack_objects);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-30 18:45:41 +01:00
|
|
|
if (start_command(&pack_objects))
|
|
|
|
return error(_("Could not spawn pack-objects"));
|
|
|
|
|
|
|
|
for (i = 0; i < revs->pending.nr; i++) {
|
|
|
|
struct object *object = revs->pending.objects[i].item;
|
|
|
|
if (object->flags & UNINTERESTING)
|
|
|
|
write_or_die(pack_objects.in, "^", 1);
|
2015-11-10 03:22:28 +01:00
|
|
|
write_or_die(pack_objects.in, oid_to_hex(&object->oid), GIT_SHA1_HEXSZ);
|
2014-10-30 18:45:41 +01:00
|
|
|
write_or_die(pack_objects.in, "\n", 1);
|
|
|
|
}
|
|
|
|
close(pack_objects.in);
|
|
|
|
if (finish_command(&pack_objects))
|
|
|
|
return error(_("pack-objects died"));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-10-30 19:01:37 +01:00
|
|
|
static int compute_and_write_prerequisites(int bundle_fd,
|
|
|
|
struct rev_info *revs,
|
|
|
|
int argc, const char **argv)
|
2007-09-11 05:03:15 +02:00
|
|
|
{
|
2014-08-19 21:09:35 +02:00
|
|
|
struct child_process rls = CHILD_PROCESS_INIT;
|
2014-10-30 19:01:37 +01:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2007-09-11 05:03:15 +02:00
|
|
|
FILE *rls_fout;
|
2014-10-30 19:01:37 +01:00
|
|
|
int i;
|
2007-09-11 05:03:15 +02:00
|
|
|
|
2014-07-18 01:27:41 +02:00
|
|
|
argv_array_pushl(&rls.args,
|
2013-11-12 22:32:11 +01:00
|
|
|
"rev-list", "--boundary", "--pretty=oneline",
|
|
|
|
NULL);
|
|
|
|
for (i = 1; i < argc; i++)
|
2014-07-18 01:27:41 +02:00
|
|
|
argv_array_push(&rls.args, argv[i]);
|
2007-09-11 05:03:15 +02:00
|
|
|
rls.out = -1;
|
|
|
|
rls.git_cmd = 1;
|
|
|
|
if (start_command(&rls))
|
|
|
|
return -1;
|
2009-09-12 10:43:27 +02:00
|
|
|
rls_fout = xfdopen(rls.out, "r");
|
2012-02-22 20:34:23 +01:00
|
|
|
while (strbuf_getwholeline(&buf, rls_fout, '\n') != EOF) {
|
2017-05-01 04:28:59 +02:00
|
|
|
struct object_id oid;
|
2012-02-22 20:34:23 +01:00
|
|
|
if (buf.len > 0 && buf.buf[0] == '-') {
|
|
|
|
write_or_die(bundle_fd, buf.buf, buf.len);
|
2017-05-01 04:28:59 +02:00
|
|
|
if (!get_oid_hex(buf.buf + 1, &oid)) {
|
object: convert parse_object* to take struct object_id
Make parse_object, parse_object_or_die, and parse_object_buffer take a
pointer to struct object_id. Remove the temporary variables inserted
earlier, since they are no longer necessary. Transform all of the
callers using the following semantic patch:
@@
expression E1;
@@
- parse_object(E1.hash)
+ parse_object(&E1)
@@
expression E1;
@@
- parse_object(E1->hash)
+ parse_object(E1)
@@
expression E1, E2;
@@
- parse_object_or_die(E1.hash, E2)
+ parse_object_or_die(&E1, E2)
@@
expression E1, E2;
@@
- parse_object_or_die(E1->hash, E2)
+ parse_object_or_die(E1, E2)
@@
expression E1, E2, E3, E4, E5;
@@
- parse_object_buffer(E1.hash, E2, E3, E4, E5)
+ parse_object_buffer(&E1, E2, E3, E4, E5)
@@
expression E1, E2, E3, E4, E5;
@@
- parse_object_buffer(E1->hash, E2, E3, E4, E5)
+ parse_object_buffer(E1, E2, E3, E4, E5)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-07 00:10:38 +02:00
|
|
|
struct object *object = parse_object_or_die(&oid,
|
|
|
|
buf.buf);
|
2007-09-11 05:03:15 +02:00
|
|
|
object->flags |= UNINTERESTING;
|
2014-10-30 19:01:37 +01:00
|
|
|
add_pending_object(revs, object, buf.buf);
|
2007-09-11 05:03:15 +02:00
|
|
|
}
|
2017-05-01 04:28:59 +02:00
|
|
|
} else if (!get_oid_hex(buf.buf, &oid)) {
|
object: convert parse_object* to take struct object_id
Make parse_object, parse_object_or_die, and parse_object_buffer take a
pointer to struct object_id. Remove the temporary variables inserted
earlier, since they are no longer necessary. Transform all of the
callers using the following semantic patch:
@@
expression E1;
@@
- parse_object(E1.hash)
+ parse_object(&E1)
@@
expression E1;
@@
- parse_object(E1->hash)
+ parse_object(E1)
@@
expression E1, E2;
@@
- parse_object_or_die(E1.hash, E2)
+ parse_object_or_die(&E1, E2)
@@
expression E1, E2;
@@
- parse_object_or_die(E1->hash, E2)
+ parse_object_or_die(E1, E2)
@@
expression E1, E2, E3, E4, E5;
@@
- parse_object_buffer(E1.hash, E2, E3, E4, E5)
+ parse_object_buffer(&E1, E2, E3, E4, E5)
@@
expression E1, E2, E3, E4, E5;
@@
- parse_object_buffer(E1->hash, E2, E3, E4, E5)
+ parse_object_buffer(E1, E2, E3, E4, E5)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-07 00:10:38 +02:00
|
|
|
struct object *object = parse_object_or_die(&oid,
|
|
|
|
buf.buf);
|
2007-09-11 05:03:15 +02:00
|
|
|
object->flags |= SHOWN;
|
|
|
|
}
|
|
|
|
}
|
2012-02-22 20:34:23 +01:00
|
|
|
strbuf_release(&buf);
|
2007-09-11 05:03:15 +02:00
|
|
|
fclose(rls_fout);
|
|
|
|
if (finish_command(&rls))
|
2012-04-23 14:30:30 +02:00
|
|
|
return error(_("rev-list died"));
|
2014-10-30 19:01:37 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-10-30 22:35:24 +01:00
|
|
|
/*
|
|
|
|
* Write out bundle refs based on the tips already
|
|
|
|
* parsed into revs.pending. As a side effect, may
|
|
|
|
* manipulate revs.pending to include additional
|
|
|
|
* necessary objects (like tags).
|
|
|
|
*
|
|
|
|
* Returns the number of refs written, or negative
|
|
|
|
* on error.
|
|
|
|
*/
|
|
|
|
static int write_bundle_refs(int bundle_fd, struct rev_info *revs)
|
2014-10-30 19:01:37 +01:00
|
|
|
{
|
2014-10-30 22:35:24 +01:00
|
|
|
int i;
|
|
|
|
int ref_count = 0;
|
2009-01-18 07:27:08 +01:00
|
|
|
|
2014-10-30 22:35:24 +01:00
|
|
|
for (i = 0; i < revs->pending.nr; i++) {
|
|
|
|
struct object_array_entry *e = revs->pending.objects + i;
|
2015-11-10 03:22:28 +01:00
|
|
|
struct object_id oid;
|
2007-09-11 05:03:15 +02:00
|
|
|
char *ref;
|
2007-11-23 01:51:18 +01:00
|
|
|
const char *display_ref;
|
|
|
|
int flag;
|
2007-09-11 05:03:15 +02:00
|
|
|
|
|
|
|
if (e->item->flags & UNINTERESTING)
|
|
|
|
continue;
|
2017-10-16 00:06:57 +02:00
|
|
|
if (dwim_ref(e->name, strlen(e->name), &oid, &ref) != 1)
|
2015-03-11 00:51:48 +01:00
|
|
|
goto skip_write_ref;
|
2017-10-16 00:06:56 +02:00
|
|
|
if (read_ref_full(e->name, RESOLVE_REF_READING, &oid, &flag))
|
2007-11-23 01:51:18 +01:00
|
|
|
flag = 0;
|
|
|
|
display_ref = (flag & REF_ISSYMREF) ? e->name : ref;
|
|
|
|
|
2009-01-02 19:08:46 +01:00
|
|
|
if (e->item->type == OBJ_TAG &&
|
2014-10-30 22:35:24 +01:00
|
|
|
!is_tag_in_date_range(e->item, revs)) {
|
2009-01-02 19:08:46 +01:00
|
|
|
e->item->flags |= UNINTERESTING;
|
2015-03-11 00:51:48 +01:00
|
|
|
goto skip_write_ref;
|
2009-01-02 19:08:46 +01:00
|
|
|
}
|
|
|
|
|
2007-09-11 05:03:15 +02:00
|
|
|
/*
|
|
|
|
* Make sure the refs we wrote out is correct; --max-count and
|
|
|
|
* other limiting options could have prevented all the tips
|
|
|
|
* from getting output.
|
|
|
|
*
|
|
|
|
* Non commit objects such as tags and blobs do not have
|
|
|
|
* this issue as they are not affected by those extra
|
|
|
|
* constraints.
|
|
|
|
*/
|
|
|
|
if (!(e->item->flags & SHOWN) && e->item->type == OBJ_COMMIT) {
|
2012-04-23 14:30:30 +02:00
|
|
|
warning(_("ref '%s' is excluded by the rev-list options"),
|
2007-09-11 05:03:15 +02:00
|
|
|
e->name);
|
2015-03-11 00:51:48 +01:00
|
|
|
goto skip_write_ref;
|
2007-09-11 05:03:15 +02:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If you run "git bundle create bndl v1.0..v2.0", the
|
|
|
|
* name of the positive ref is "v2.0" but that is the
|
|
|
|
* commit that is referenced by the tag, and not the tag
|
|
|
|
* itself.
|
|
|
|
*/
|
2018-08-28 23:22:48 +02:00
|
|
|
if (!oideq(&oid, &e->item->oid)) {
|
2007-09-11 05:03:15 +02:00
|
|
|
/*
|
|
|
|
* Is this the positive end of a range expressed
|
|
|
|
* in terms of a tag (e.g. v2.0 from the range
|
|
|
|
* "v1.0..v2.0")?
|
|
|
|
*/
|
2018-06-29 03:21:58 +02:00
|
|
|
struct commit *one = lookup_commit_reference(the_repository,
|
|
|
|
&oid);
|
2007-09-11 05:03:15 +02:00
|
|
|
struct object *obj;
|
|
|
|
|
|
|
|
if (e->item == &(one->object)) {
|
|
|
|
/*
|
|
|
|
* Need to include e->name as an
|
|
|
|
* independent ref to the pack-objects
|
|
|
|
* input, so that the tag is included
|
|
|
|
* in the output; otherwise we would
|
|
|
|
* end up triggering "empty bundle"
|
|
|
|
* error.
|
|
|
|
*/
|
object: convert parse_object* to take struct object_id
Make parse_object, parse_object_or_die, and parse_object_buffer take a
pointer to struct object_id. Remove the temporary variables inserted
earlier, since they are no longer necessary. Transform all of the
callers using the following semantic patch:
@@
expression E1;
@@
- parse_object(E1.hash)
+ parse_object(&E1)
@@
expression E1;
@@
- parse_object(E1->hash)
+ parse_object(E1)
@@
expression E1, E2;
@@
- parse_object_or_die(E1.hash, E2)
+ parse_object_or_die(&E1, E2)
@@
expression E1, E2;
@@
- parse_object_or_die(E1->hash, E2)
+ parse_object_or_die(E1, E2)
@@
expression E1, E2, E3, E4, E5;
@@
- parse_object_buffer(E1.hash, E2, E3, E4, E5)
+ parse_object_buffer(&E1, E2, E3, E4, E5)
@@
expression E1, E2, E3, E4, E5;
@@
- parse_object_buffer(E1->hash, E2, E3, E4, E5)
+ parse_object_buffer(E1, E2, E3, E4, E5)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-07 00:10:38 +02:00
|
|
|
obj = parse_object_or_die(&oid, e->name);
|
2007-09-11 05:03:15 +02:00
|
|
|
obj->flags |= SHOWN;
|
2014-10-30 22:35:24 +01:00
|
|
|
add_pending_object(revs, obj, e->name);
|
2007-09-11 05:03:15 +02:00
|
|
|
}
|
2015-03-11 00:51:48 +01:00
|
|
|
goto skip_write_ref;
|
2007-09-11 05:03:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
ref_count++;
|
2015-11-10 03:22:28 +01:00
|
|
|
write_or_die(bundle_fd, oid_to_hex(&e->item->oid), 40);
|
2007-09-11 05:03:15 +02:00
|
|
|
write_or_die(bundle_fd, " ", 1);
|
2007-11-23 01:51:18 +01:00
|
|
|
write_or_die(bundle_fd, display_ref, strlen(display_ref));
|
2007-09-11 05:03:15 +02:00
|
|
|
write_or_die(bundle_fd, "\n", 1);
|
2015-03-11 00:51:48 +01:00
|
|
|
skip_write_ref:
|
2007-09-11 05:03:15 +02:00
|
|
|
free(ref);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* end header */
|
|
|
|
write_or_die(bundle_fd, "\n", 1);
|
2014-10-30 22:35:24 +01:00
|
|
|
return ref_count;
|
|
|
|
}
|
|
|
|
|
|
|
|
int create_bundle(struct bundle_header *header, const char *path,
|
|
|
|
int argc, const char **argv)
|
|
|
|
{
|
2018-05-09 22:55:38 +02:00
|
|
|
struct lock_file lock = LOCK_INIT;
|
2014-10-30 22:35:24 +01:00
|
|
|
int bundle_fd = -1;
|
|
|
|
int bundle_to_stdout;
|
|
|
|
int ref_count = 0;
|
|
|
|
struct rev_info revs;
|
|
|
|
|
|
|
|
bundle_to_stdout = !strcmp(path, "-");
|
|
|
|
if (bundle_to_stdout)
|
|
|
|
bundle_fd = 1;
|
bundle: dup() output descriptor closer to point-of-use
When writing a bundle to a file, the bundle code actually creates
"your.bundle.lock" using our lockfile interface. We feed that output
descriptor to a child git-pack-objects via run-command, which has the
quirk that it closes the output descriptor in the parent.
To avoid confusing the lockfile code (which still thinks the descriptor
is valid), we dup() it, and operate on the duplicate.
However, this has a confusing side effect: after the dup() but before we
call pack-objects, we have _two_ descriptors open to the lockfile. If we
call die() during that time, the lockfile code will try to clean up the
partially-written file. It knows to close() the file before unlinking,
since on some platforms (i.e., Windows) the open file would block the
deletion. But it doesn't know about the duplicate descriptor. On
Windows, triggering an error at the right part of the code will result
in the cleanup failing and the lockfile being left in the filesystem.
We can solve this by moving the dup() much closer to start_command(),
shrinking the window in which we have the second descriptor open. It's
easy to place this in such a way that no die() is possible. We could
still die due to a signal in the exact wrong moment, but we already
tolerate races there (e.g., a signal could come before we manage to put
the file on the cleanup list in the first place).
As a bonus, this shields create_bundle() itself from the duplicate-fd
trick, and we can simplify its error handling (note that the lock
rollback now happens unconditionally, but that's OK; it's a noop if we
didn't open the lock in the first place).
The included test uses an empty bundle to cause a failure at the right
spot in the code, because that's easy to trigger (the other likely
errors are write() problems like ENOSPC). Note that it would already
pass on non-Windows systems (because they are happy to unlink an
already-open file).
Based-on-a-patch-by: Gaël Lhez <gael.lhez@gmail.com>
Signed-off-by: Jeff King <peff@peff.net>
Tested-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-16 10:43:59 +01:00
|
|
|
else
|
2014-10-30 22:35:24 +01:00
|
|
|
bundle_fd = hold_lock_file_for_update(&lock, path,
|
|
|
|
LOCK_DIE_ON_ERROR);
|
|
|
|
|
|
|
|
/* write signature */
|
|
|
|
write_or_die(bundle_fd, bundle_signature, strlen(bundle_signature));
|
|
|
|
|
|
|
|
/* init revs to list objects for pack-objects later */
|
|
|
|
save_commit_buffer = 0;
|
2018-09-21 17:57:38 +02:00
|
|
|
repo_init_revisions(the_repository, &revs, NULL);
|
2014-10-30 22:35:24 +01:00
|
|
|
|
|
|
|
/* write prerequisites */
|
|
|
|
if (compute_and_write_prerequisites(bundle_fd, &revs, argc, argv))
|
2016-04-01 02:35:45 +02:00
|
|
|
goto err;
|
2014-10-30 22:35:24 +01:00
|
|
|
|
|
|
|
argc = setup_revisions(argc, argv, &revs, NULL);
|
|
|
|
|
2016-04-01 02:35:45 +02:00
|
|
|
if (argc > 1) {
|
|
|
|
error(_("unrecognized argument: %s"), argv[1]);
|
|
|
|
goto err;
|
|
|
|
}
|
2014-10-30 22:35:24 +01:00
|
|
|
|
|
|
|
object_array_remove_duplicates(&revs.pending);
|
|
|
|
|
|
|
|
ref_count = write_bundle_refs(bundle_fd, &revs);
|
|
|
|
if (!ref_count)
|
|
|
|
die(_("Refusing to create empty bundle."));
|
|
|
|
else if (ref_count < 0)
|
2016-04-01 02:35:45 +02:00
|
|
|
goto err;
|
2007-09-11 05:03:15 +02:00
|
|
|
|
|
|
|
/* write pack */
|
bundle: dup() output descriptor closer to point-of-use
When writing a bundle to a file, the bundle code actually creates
"your.bundle.lock" using our lockfile interface. We feed that output
descriptor to a child git-pack-objects via run-command, which has the
quirk that it closes the output descriptor in the parent.
To avoid confusing the lockfile code (which still thinks the descriptor
is valid), we dup() it, and operate on the duplicate.
However, this has a confusing side effect: after the dup() but before we
call pack-objects, we have _two_ descriptors open to the lockfile. If we
call die() during that time, the lockfile code will try to clean up the
partially-written file. It knows to close() the file before unlinking,
since on some platforms (i.e., Windows) the open file would block the
deletion. But it doesn't know about the duplicate descriptor. On
Windows, triggering an error at the right part of the code will result
in the cleanup failing and the lockfile being left in the filesystem.
We can solve this by moving the dup() much closer to start_command(),
shrinking the window in which we have the second descriptor open. It's
easy to place this in such a way that no die() is possible. We could
still die due to a signal in the exact wrong moment, but we already
tolerate races there (e.g., a signal could come before we manage to put
the file on the cleanup list in the first place).
As a bonus, this shields create_bundle() itself from the duplicate-fd
trick, and we can simplify its error handling (note that the lock
rollback now happens unconditionally, but that's OK; it's a noop if we
didn't open the lock in the first place).
The included test uses an empty bundle to cause a failure at the right
spot in the code, because that's easy to trigger (the other likely
errors are write() problems like ENOSPC). Note that it would already
pass on non-Windows systems (because they are happy to unlink an
already-open file).
Based-on-a-patch-by: Gaël Lhez <gael.lhez@gmail.com>
Signed-off-by: Jeff King <peff@peff.net>
Tested-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-16 10:43:59 +01:00
|
|
|
if (write_pack_data(bundle_fd, &revs))
|
2016-04-01 02:35:45 +02:00
|
|
|
goto err;
|
2008-01-16 20:12:46 +01:00
|
|
|
|
2010-08-27 22:31:47 +02:00
|
|
|
if (!bundle_to_stdout) {
|
|
|
|
if (commit_lock_file(&lock))
|
2012-04-23 14:30:30 +02:00
|
|
|
die_errno(_("cannot create '%s'"), path);
|
2010-08-27 22:31:47 +02:00
|
|
|
}
|
2008-02-21 23:42:56 +01:00
|
|
|
return 0;
|
2016-04-01 02:35:45 +02:00
|
|
|
err:
|
bundle: dup() output descriptor closer to point-of-use
When writing a bundle to a file, the bundle code actually creates
"your.bundle.lock" using our lockfile interface. We feed that output
descriptor to a child git-pack-objects via run-command, which has the
quirk that it closes the output descriptor in the parent.
To avoid confusing the lockfile code (which still thinks the descriptor
is valid), we dup() it, and operate on the duplicate.
However, this has a confusing side effect: after the dup() but before we
call pack-objects, we have _two_ descriptors open to the lockfile. If we
call die() during that time, the lockfile code will try to clean up the
partially-written file. It knows to close() the file before unlinking,
since on some platforms (i.e., Windows) the open file would block the
deletion. But it doesn't know about the duplicate descriptor. On
Windows, triggering an error at the right part of the code will result
in the cleanup failing and the lockfile being left in the filesystem.
We can solve this by moving the dup() much closer to start_command(),
shrinking the window in which we have the second descriptor open. It's
easy to place this in such a way that no die() is possible. We could
still die due to a signal in the exact wrong moment, but we already
tolerate races there (e.g., a signal could come before we manage to put
the file on the cleanup list in the first place).
As a bonus, this shields create_bundle() itself from the duplicate-fd
trick, and we can simplify its error handling (note that the lock
rollback now happens unconditionally, but that's OK; it's a noop if we
didn't open the lock in the first place).
The included test uses an empty bundle to cause a failure at the right
spot in the code, because that's easy to trigger (the other likely
errors are write() problems like ENOSPC). Note that it would already
pass on non-Windows systems (because they are happy to unlink an
already-open file).
Based-on-a-patch-by: Gaël Lhez <gael.lhez@gmail.com>
Signed-off-by: Jeff King <peff@peff.net>
Tested-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-16 10:43:59 +01:00
|
|
|
rollback_lock_file(&lock);
|
2016-04-01 02:35:45 +02:00
|
|
|
return -1;
|
2007-09-11 05:03:15 +02:00
|
|
|
}
|
|
|
|
|
2011-09-19 01:52:32 +02:00
|
|
|
int unbundle(struct bundle_header *header, int bundle_fd, int flags)
|
2007-09-11 05:03:15 +02:00
|
|
|
{
|
|
|
|
const char *argv_index_pack[] = {"index-pack",
|
2011-09-19 01:52:32 +02:00
|
|
|
"--fix-thin", "--stdin", NULL, NULL};
|
2014-08-19 21:09:35 +02:00
|
|
|
struct child_process ip = CHILD_PROCESS_INIT;
|
2007-09-11 05:03:15 +02:00
|
|
|
|
2011-09-19 01:52:32 +02:00
|
|
|
if (flags & BUNDLE_VERBOSE)
|
|
|
|
argv_index_pack[3] = "-v";
|
|
|
|
|
2007-09-11 05:03:15 +02:00
|
|
|
if (verify_bundle(header, 0))
|
|
|
|
return -1;
|
|
|
|
ip.argv = argv_index_pack;
|
|
|
|
ip.in = bundle_fd;
|
|
|
|
ip.no_stdout = 1;
|
|
|
|
ip.git_cmd = 1;
|
|
|
|
if (run_command(&ip))
|
2012-04-23 14:30:30 +02:00
|
|
|
return error(_("index-pack died"));
|
2007-09-11 05:03:15 +02:00
|
|
|
return 0;
|
|
|
|
}
|