|
|
|
|
#include "cache.h"
|
|
|
|
|
#include "refs.h"
|
|
|
|
|
#include "pkt-line.h"
|
|
|
|
|
#include "sideband.h"
|
|
|
|
|
#include "tag.h"
|
|
|
|
|
#include "object.h"
|
|
|
|
|
#include "commit.h"
|
|
|
|
|
#include "exec_cmd.h"
|
|
|
|
|
#include "diff.h"
|
|
|
|
|
#include "revision.h"
|
|
|
|
|
#include "list-objects.h"
|
|
|
|
|
#include "run-command.h"
|
|
|
|
|
|
|
|
|
|
static const char upload_pack_usage[] = "git-upload-pack [--strict] [--timeout=nn] <dir>";
|
|
|
|
|
|
|
|
|
|
/* bits #0..7 in revision.h, #8..10 in commit.c */
|
|
|
|
|
#define THEY_HAVE (1u << 11)
|
|
|
|
|
#define OUR_REF (1u << 12)
|
|
|
|
|
#define WANTED (1u << 13)
|
|
|
|
|
#define COMMON_KNOWN (1u << 14)
|
|
|
|
|
#define REACHABLE (1u << 15)
|
|
|
|
|
|
|
|
|
|
#define SHALLOW (1u << 16)
|
|
|
|
|
#define NOT_SHALLOW (1u << 17)
|
|
|
|
|
#define CLIENT_SHALLOW (1u << 18)
|
|
|
|
|
|
|
|
|
|
static unsigned long oldest_have;
|
|
|
|
|
|
|
|
|
|
static int multi_ack, nr_our_refs;
|
|
|
|
|
static int use_thin_pack, use_ofs_delta, use_include_tag;
|
|
|
|
|
static int no_progress;
|
|
|
|
|
static struct object_array have_obj;
|
|
|
|
|
static struct object_array want_obj;
|
|
|
|
|
static unsigned int timeout;
|
|
|
|
|
/* 0 for no sideband,
|
|
|
|
|
* otherwise maximum packet size (up to 65520 bytes).
|
|
|
|
|
*/
|
|
|
|
|
static int use_sideband;
|
|
|
|
|
static int debug_fd;
|
|
|
|
|
|
|
|
|
|
static void reset_timeout(void)
|
|
|
|
|
{
|
|
|
|
|
alarm(timeout);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int strip(char *line, int len)
|
|
|
|
|
{
|
|
|
|
|
if (len && line[len-1] == '\n')
|
|
|
|
|
line[--len] = 0;
|
|
|
|
|
return len;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static ssize_t send_client_data(int fd, const char *data, ssize_t sz)
|
|
|
|
|
{
|
|
|
|
|
if (use_sideband)
|
|
|
|
|
return send_sideband(1, fd, data, sz, use_sideband);
|
|
|
|
|
if (fd == 3)
|
|
|
|
|
/* emergency quit */
|
|
|
|
|
fd = 2;
|
|
|
|
|
if (fd == 2) {
|
|
|
|
|
/* XXX: are we happy to lose stuff here? */
|
|
|
|
|
xwrite(fd, data, sz);
|
|
|
|
|
return sz;
|
|
|
|
|
}
|
|
|
|
|
return safe_write(fd, data, sz);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static FILE *pack_pipe = NULL;
|
|
|
|
|
static void show_commit(struct commit *commit)
|
|
|
|
|
{
|
|
|
|
|
if (commit->object.flags & BOUNDARY)
|
|
|
|
|
fputc('-', pack_pipe);
|
|
|
|
|
if (fputs(sha1_to_hex(commit->object.sha1), pack_pipe) < 0)
|
|
|
|
|
die("broken output pipe");
|
|
|
|
|
fputc('\n', pack_pipe);
|
|
|
|
|
fflush(pack_pipe);
|
|
|
|
|
free(commit->buffer);
|
|
|
|
|
commit->buffer = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void show_object(struct object_array_entry *p)
|
|
|
|
|
{
|
|
|
|
|
/* An object with name "foo\n0000000..." can be used to
|
|
|
|
|
* confuse downstream git-pack-objects very badly.
|
|
|
|
|
*/
|
|
|
|
|
const char *ep = strchr(p->name, '\n');
|
|
|
|
|
if (ep) {
|
|
|
|
|
fprintf(pack_pipe, "%s %.*s\n", sha1_to_hex(p->item->sha1),
|
|
|
|
|
(int) (ep - p->name),
|
|
|
|
|
p->name);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
fprintf(pack_pipe, "%s %s\n",
|
|
|
|
|
sha1_to_hex(p->item->sha1), p->name);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void show_edge(struct commit *commit)
|
|
|
|
|
{
|
|
|
|
|
fprintf(pack_pipe, "-%s\n", sha1_to_hex(commit->object.sha1));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int do_rev_list(int fd, void *create_full_pack)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
struct rev_info revs;
|
|
|
|
|
|
|
|
|
|
pack_pipe = fdopen(fd, "w");
|
|
|
|
|
if (create_full_pack)
|
|
|
|
|
use_thin_pack = 0; /* no point doing it */
|
|
|
|
|
init_revisions(&revs, NULL);
|
|
|
|
|
revs.tag_objects = 1;
|
|
|
|
|
revs.tree_objects = 1;
|
|
|
|
|
revs.blob_objects = 1;
|
|
|
|
|
if (use_thin_pack)
|
|
|
|
|
revs.edge_hint = 1;
|
|
|
|
|
|
|
|
|
|
if (create_full_pack) {
|
|
|
|
|
const char *args[] = {"rev-list", "--all", NULL};
|
|
|
|
|
setup_revisions(2, args, &revs, NULL);
|
|
|
|
|
} else {
|
|
|
|
|
for (i = 0; i < want_obj.nr; i++) {
|
|
|
|
|
struct object *o = want_obj.objects[i].item;
|
|
|
|
|
/* why??? */
|
|
|
|
|
o->flags &= ~UNINTERESTING;
|
|
|
|
|
add_pending_object(&revs, o, NULL);
|
|
|
|
|
}
|
|
|
|
|
for (i = 0; i < have_obj.nr; i++) {
|
|
|
|
|
struct object *o = have_obj.objects[i].item;
|
|
|
|
|
o->flags |= UNINTERESTING;
|
|
|
|
|
add_pending_object(&revs, o, NULL);
|
|
|
|
|
}
|
|
|
|
|
setup_revisions(0, NULL, &revs, NULL);
|
|
|
|
|
}
|
|
|
|
|
if (prepare_revision_walk(&revs))
|
|
|
|
|
die("revision walk setup failed");
|
|
|
|
|
mark_edges_uninteresting(revs.commits, &revs, show_edge);
|
|
|
|
|
traverse_commit_list(&revs, show_commit, show_object);
|
|
|
|
|
fflush(pack_pipe);
|
|
|
|
|
fclose(pack_pipe);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void create_pack_file(void)
|
|
|
|
|
{
|
|
|
|
|
struct async rev_list;
|
|
|
|
|
struct child_process pack_objects;
|
|
|
|
|
int create_full_pack = (nr_our_refs == want_obj.nr && !have_obj.nr);
|
|
|
|
|
char data[8193], progress[128];
|
|
|
|
|
char abort_msg[] = "aborting due to possible repository "
|
|
|
|
|
"corruption on the remote side.";
|
|
|
|
|
int buffered = -1;
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
17 years ago
|
|
|
ssize_t sz;
|
|
|
|
|
const char *argv[10];
|
|
|
|
|
int arg = 0;
|
|
|
|
|
|
|
|
|
|
rev_list.proc = do_rev_list;
|
|
|
|
|
/* .data is just a boolean: any non-NULL value will do */
|
|
|
|
|
rev_list.data = create_full_pack ? &rev_list : NULL;
|
|
|
|
|
if (start_async(&rev_list))
|
|
|
|
|
die("git-upload-pack: unable to fork git-rev-list");
|
|
|
|
|
|
|
|
|
|
argv[arg++] = "pack-objects";
|
|
|
|
|
argv[arg++] = "--stdout";
|
|
|
|
|
if (!no_progress)
|
|
|
|
|
argv[arg++] = "--progress";
|
|
|
|
|
if (use_ofs_delta)
|
|
|
|
|
argv[arg++] = "--delta-base-offset";
|
|
|
|
|
if (use_include_tag)
|
|
|
|
|
argv[arg++] = "--include-tag";
|
|
|
|
|
argv[arg++] = NULL;
|
|
|
|
|
|
|
|
|
|
memset(&pack_objects, 0, sizeof(pack_objects));
|
|
|
|
|
pack_objects.in = rev_list.out; /* start_command closes it */
|
|
|
|
|
pack_objects.out = -1;
|
|
|
|
|
pack_objects.err = -1;
|
|
|
|
|
pack_objects.git_cmd = 1;
|
|
|
|
|
pack_objects.argv = argv;
|
|
|
|
|
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
17 years ago
|
|
|
if (start_command(&pack_objects))
|
|
|
|
|
die("git-upload-pack: unable to fork git-pack-objects");
|
|
|
|
|
|
|
|
|
|
/* We read from pack_objects.err to capture stderr output for
|
|
|
|
|
* progress bar, and pack_objects.out to capture the pack data.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
|
struct pollfd pfd[2];
|
|
|
|
|
int pe, pu, pollsize;
|
|
|
|
|
|
|
|
|
|
reset_timeout();
|
|
|
|
|
|
|
|
|
|
pollsize = 0;
|
|
|
|
|
pe = pu = -1;
|
|
|
|
|
|
|
|
|
|
if (0 <= pack_objects.out) {
|
|
|
|
|
pfd[pollsize].fd = pack_objects.out;
|
|
|
|
|
pfd[pollsize].events = POLLIN;
|
|
|
|
|
pu = pollsize;
|
|
|
|
|
pollsize++;
|
|
|
|
|
}
|
|
|
|
|
if (0 <= pack_objects.err) {
|
|
|
|
|
pfd[pollsize].fd = pack_objects.err;
|
|
|
|
|
pfd[pollsize].events = POLLIN;
|
|
|
|
|
pe = pollsize;
|
|
|
|
|
pollsize++;
|
|
|
|
|
}
|
|
|
|
|
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
17 years ago
|
|
|
if (!pollsize)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
if (poll(pfd, pollsize, -1) < 0) {
|
|
|
|
|
if (errno != EINTR) {
|
|
|
|
|
error("poll failed, resuming: %s",
|
|
|
|
|
strerror(errno));
|
|
|
|
|
sleep(1);
|
|
|
|
|
}
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
17 years ago
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (0 <= pu && (pfd[pu].revents & (POLLIN|POLLHUP))) {
|
|
|
|
|
/* Data ready; we keep the last byte to ourselves
|
|
|
|
|
* in case we detect broken rev-list, so that we
|
|
|
|
|
* can leave the stream corrupted. This is
|
|
|
|
|
* unfortunate -- unpack-objects would happily
|
|
|
|
|
* accept a valid packdata with trailing garbage,
|
|
|
|
|
* so appending garbage after we pass all the
|
|
|
|
|
* pack data is not good enough to signal
|
|
|
|
|
* breakage to downstream.
|
|
|
|
|
*/
|
|
|
|
|
char *cp = data;
|
|
|
|
|
ssize_t outsz = 0;
|
|
|
|
|
if (0 <= buffered) {
|
|
|
|
|
*cp++ = buffered;
|
|
|
|
|
outsz++;
|
|
|
|
|
}
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
17 years ago
|
|
|
sz = xread(pack_objects.out, cp,
|
|
|
|
|
sizeof(data) - outsz);
|
|
|
|
|
if (0 < sz)
|
|
|
|
|
;
|
|
|
|
|
else if (sz == 0) {
|
|
|
|
|
close(pack_objects.out);
|
|
|
|
|
pack_objects.out = -1;
|
|
|
|
|
}
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
17 years ago
|
|
|
else
|
|
|
|
|
goto fail;
|
|
|
|
|
sz += outsz;
|
|
|
|
|
if (1 < sz) {
|
|
|
|
|
buffered = data[sz-1] & 0xFF;
|
|
|
|
|
sz--;
|
|
|
|
|
}
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
17 years ago
|
|
|
else
|
|
|
|
|
buffered = -1;
|
|
|
|
|
sz = send_client_data(1, data, sz);
|
|
|
|
|
if (sz < 0)
|
|
|
|
|
goto fail;
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
17 years ago
|
|
|
}
|
|
|
|
|
if (0 <= pe && (pfd[pe].revents & (POLLIN|POLLHUP))) {
|
|
|
|
|
/* Status ready; we ship that in the side-band
|
|
|
|
|
* or dump to the standard error.
|
|
|
|
|
*/
|
|
|
|
|
sz = xread(pack_objects.err, progress,
|
|
|
|
|
sizeof(progress));
|
|
|
|
|
if (0 < sz)
|
|
|
|
|
send_client_data(2, progress, sz);
|
|
|
|
|
else if (sz == 0) {
|
|
|
|
|
close(pack_objects.err);
|
|
|
|
|
pack_objects.err = -1;
|
|
|
|
|
}
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
17 years ago
|
|
|
else
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
17 years ago
|
|
|
}
|
|
|
|
|
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
17 years ago
|
|
|
if (finish_command(&pack_objects)) {
|
|
|
|
|
error("git-upload-pack: git-pack-objects died with error.");
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
|
|
|
|
if (finish_async(&rev_list))
|
|
|
|
|
goto fail; /* error was already reported */
|
|
|
|
|
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
17 years ago
|
|
|
/* flush the data */
|
|
|
|
|
if (0 <= buffered) {
|
|
|
|
|
data[0] = buffered;
|
|
|
|
|
sz = send_client_data(1, data, 1);
|
|
|
|
|
if (sz < 0)
|
|
|
|
|
goto fail;
|
|
|
|
|
fprintf(stderr, "flushed.\n");
|
|
|
|
|
}
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
17 years ago
|
|
|
if (use_sideband)
|
|
|
|
|
packet_flush(1);
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
fail:
|
|
|
|
|
send_client_data(3, abort_msg, sizeof(abort_msg));
|
|
|
|
|
die("git-upload-pack: %s", abort_msg);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int got_sha1(char *hex, unsigned char *sha1)
|
|
|
|
|
{
|
|
|
|
|
struct object *o;
|
|
|
|
|
int we_knew_they_have = 0;
|
|
|
|
|
|
|
|
|
|
if (get_sha1_hex(hex, sha1))
|
|
|
|
|
die("git-upload-pack: expected SHA1 object, got '%s'", hex);
|
|
|
|
|
if (!has_sha1_file(sha1))
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
o = lookup_object(sha1);
|
|
|
|
|
if (!(o && o->parsed))
|
|
|
|
|
o = parse_object(sha1);
|
|
|
|
|
if (!o)
|
|
|
|
|
die("oops (%s)", sha1_to_hex(sha1));
|
|
|
|
|
if (o->type == OBJ_COMMIT) {
|
|
|
|
|
struct commit_list *parents;
|
|
|
|
|
struct commit *commit = (struct commit *)o;
|
|
|
|
|
if (o->flags & THEY_HAVE)
|
|
|
|
|
we_knew_they_have = 1;
|
|
|
|
|
else
|
|
|
|
|
o->flags |= THEY_HAVE;
|
|
|
|
|
if (!oldest_have || (commit->date < oldest_have))
|
|
|
|
|
oldest_have = commit->date;
|
|
|
|
|
for (parents = commit->parents;
|
|
|
|
|
parents;
|
|
|
|
|
parents = parents->next)
|
|
|
|
|
parents->item->object.flags |= THEY_HAVE;
|
|
|
|
|
}
|
|
|
|
|
if (!we_knew_they_have) {
|
|
|
|
|
add_object_array(o, NULL, &have_obj);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int reachable(struct commit *want)
|
|
|
|
|
{
|
|
|
|
|
struct commit_list *work = NULL;
|
|
|
|
|
|
|
|
|
|
insert_by_date(want, &work);
|
|
|
|
|
while (work) {
|
|
|
|
|
struct commit_list *list = work->next;
|
|
|
|
|
struct commit *commit = work->item;
|
|
|
|
|
free(work);
|
|
|
|
|
work = list;
|
|
|
|
|
|
|
|
|
|
if (commit->object.flags & THEY_HAVE) {
|
|
|
|
|
want->object.flags |= COMMON_KNOWN;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (!commit->object.parsed)
|
|
|
|
|
parse_object(commit->object.sha1);
|
|
|
|
|
if (commit->object.flags & REACHABLE)
|
|
|
|
|
continue;
|
|
|
|
|
commit->object.flags |= REACHABLE;
|
|
|
|
|
if (commit->date < oldest_have)
|
|
|
|
|
continue;
|
|
|
|
|
for (list = commit->parents; list; list = list->next) {
|
|
|
|
|
struct commit *parent = list->item;
|
|
|
|
|
if (!(parent->object.flags & REACHABLE))
|
|
|
|
|
insert_by_date(parent, &work);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
want->object.flags |= REACHABLE;
|
|
|
|
|
clear_commit_marks(want, REACHABLE);
|
|
|
|
|
free_commit_list(work);
|
|
|
|
|
return (want->object.flags & COMMON_KNOWN);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int ok_to_give_up(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (!have_obj.nr)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < want_obj.nr; i++) {
|
|
|
|
|
struct object *want = want_obj.objects[i].item;
|
|
|
|
|
|
|
|
|
|
if (want->flags & COMMON_KNOWN)
|
|
|
|
|
continue;
|
|
|
|
|
want = deref_tag(want, "a want line", 0);
|
|
|
|
|
if (!want || want->type != OBJ_COMMIT) {
|
|
|
|
|
/* no way to tell if this is reachable by
|
|
|
|
|
* looking at the ancestry chain alone, so
|
|
|
|
|
* leave a note to ourselves not to worry about
|
|
|
|
|
* this object anymore.
|
|
|
|
|
*/
|
|
|
|
|
want_obj.objects[i].item->flags |= COMMON_KNOWN;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!reachable((struct commit *)want))
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int get_common_commits(void)
|
|
|
|
|
{
|
|
|
|
|
static char line[1000];
|
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
char hex[41], last_hex[41];
|
|
|
|
|
int len;
|
|
|
|
|
|
|
|
|
|
save_commit_buffer = 0;
|
|
|
|
|
|
|
|
|
|
for(;;) {
|
|
|
|
|
len = packet_read_line(0, line, sizeof(line));
|
|
|
|
|
reset_timeout();
|
|
|
|
|
|
|
|
|
|
if (!len) {
|
|
|
|
|
if (have_obj.nr == 0 || multi_ack)
|
|
|
|
|
packet_write(1, "NAK\n");
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
len = strip(line, len);
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
18 years ago
|
|
|
if (!prefixcmp(line, "have ")) {
|
|
|
|
|
switch (got_sha1(line+5, sha1)) {
|
|
|
|
|
case -1: /* they have what we do not */
|
|
|
|
|
if (multi_ack && ok_to_give_up())
|
|
|
|
|
packet_write(1, "ACK %s continue\n",
|
|
|
|
|
sha1_to_hex(sha1));
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
memcpy(hex, sha1_to_hex(sha1), 41);
|
|
|
|
|
if (multi_ack) {
|
|
|
|
|
const char *msg = "ACK %s continue\n";
|
|
|
|
|
packet_write(1, msg, hex);
|
|
|
|
|
memcpy(last_hex, hex, 41);
|
|
|
|
|
}
|
|
|
|
|
else if (have_obj.nr == 1)
|
|
|
|
|
packet_write(1, "ACK %s\n", hex);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!strcmp(line, "done")) {
|
|
|
|
|
if (have_obj.nr > 0) {
|
|
|
|
|
if (multi_ack)
|
|
|
|
|
packet_write(1, "ACK %s\n", last_hex);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
packet_write(1, "NAK\n");
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
die("git-upload-pack: expected SHA1 list, got '%s'", line);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void receive_needs(void)
|
|
|
|
|
{
|
|
|
|
|
struct object_array shallows = {0, 0, NULL};
|
|
|
|
|
static char line[1000];
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
18 years ago
|
|
|
int len, depth = 0;
|
|
|
|
|
|
|
|
|
|
if (debug_fd)
|
|
|
|
|
write_in_full(debug_fd, "#S\n", 3);
|
|
|
|
|
for (;;) {
|
|
|
|
|
struct object *o;
|
|
|
|
|
unsigned char sha1_buf[20];
|
|
|
|
|
len = packet_read_line(0, line, sizeof(line));
|
|
|
|
|
reset_timeout();
|
|
|
|
|
if (!len)
|
|
|
|
|
break;
|
|
|
|
|
if (debug_fd)
|
|
|
|
|
write_in_full(debug_fd, line, len);
|
|
|
|
|
|
|
|
|
|
if (!prefixcmp(line, "shallow ")) {
|
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
struct object *object;
|
|
|
|
|
use_thin_pack = 0;
|
|
|
|
|
if (get_sha1(line + 8, sha1))
|
|
|
|
|
die("invalid shallow line: %s", line);
|
|
|
|
|
object = parse_object(sha1);
|
|
|
|
|
if (!object)
|
|
|
|
|
die("did not find object for %s", line);
|
|
|
|
|
object->flags |= CLIENT_SHALLOW;
|
|
|
|
|
add_object_array(object, NULL, &shallows);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!prefixcmp(line, "deepen ")) {
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
18 years ago
|
|
|
char *end;
|
|
|
|
|
use_thin_pack = 0;
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
18 years ago
|
|
|
depth = strtol(line + 7, &end, 0);
|
|
|
|
|
if (end == line + 7 || depth <= 0)
|
|
|
|
|
die("Invalid deepen: %s", line);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (prefixcmp(line, "want ") ||
|
|
|
|
|
get_sha1_hex(line+5, sha1_buf))
|
|
|
|
|
die("git-upload-pack: protocol error, "
|
|
|
|
|
"expected to get sha, not '%s'", line);
|
|
|
|
|
if (strstr(line+45, "multi_ack"))
|
|
|
|
|
multi_ack = 1;
|
|
|
|
|
if (strstr(line+45, "thin-pack"))
|
|
|
|
|
use_thin_pack = 1;
|
|
|
|
|
if (strstr(line+45, "ofs-delta"))
|
|
|
|
|
use_ofs_delta = 1;
|
|
|
|
|
if (strstr(line+45, "side-band-64k"))
|
|
|
|
|
use_sideband = LARGE_PACKET_MAX;
|
|
|
|
|
else if (strstr(line+45, "side-band"))
|
|
|
|
|
use_sideband = DEFAULT_PACKET_MAX;
|
|
|
|
|
if (strstr(line+45, "no-progress"))
|
|
|
|
|
no_progress = 1;
|
|
|
|
|
if (strstr(line+45, "include-tag"))
|
|
|
|
|
use_include_tag = 1;
|
|
|
|
|
|
|
|
|
|
/* We have sent all our refs already, and the other end
|
|
|
|
|
* should have chosen out of them; otherwise they are
|
|
|
|
|
* asking for nonsense.
|
|
|
|
|
*
|
|
|
|
|
* Hmph. We may later want to allow "want" line that
|
|
|
|
|
* asks for something like "master~10" (symbolic)...
|
|
|
|
|
* would it make sense? I don't know.
|
|
|
|
|
*/
|
|
|
|
|
o = lookup_object(sha1_buf);
|
|
|
|
|
if (!o || !(o->flags & OUR_REF))
|
|
|
|
|
die("git-upload-pack: not our ref %s", line+5);
|
|
|
|
|
if (!(o->flags & WANTED)) {
|
|
|
|
|
o->flags |= WANTED;
|
|
|
|
|
add_object_array(o, NULL, &want_obj);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (debug_fd)
|
|
|
|
|
write_in_full(debug_fd, "#E\n", 3);
|
|
|
|
|
if (depth == 0 && shallows.nr == 0)
|
|
|
|
|
return;
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
18 years ago
|
|
|
if (depth > 0) {
|
|
|
|
|
struct commit_list *result, *backup;
|
|
|
|
|
int i;
|
|
|
|
|
backup = result = get_shallow_commits(&want_obj, depth,
|
|
|
|
|
SHALLOW, NOT_SHALLOW);
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
18 years ago
|
|
|
while (result) {
|
|
|
|
|
struct object *object = &result->item->object;
|
|
|
|
|
if (!(object->flags & (CLIENT_SHALLOW|NOT_SHALLOW))) {
|
|
|
|
|
packet_write(1, "shallow %s",
|
|
|
|
|
sha1_to_hex(object->sha1));
|
|
|
|
|
register_shallow(object->sha1);
|
|
|
|
|
}
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
18 years ago
|
|
|
result = result->next;
|
|
|
|
|
}
|
|
|
|
|
free_commit_list(backup);
|
|
|
|
|
for (i = 0; i < shallows.nr; i++) {
|
|
|
|
|
struct object *object = shallows.objects[i].item;
|
|
|
|
|
if (object->flags & NOT_SHALLOW) {
|
|
|
|
|
struct commit_list *parents;
|
|
|
|
|
packet_write(1, "unshallow %s",
|
|
|
|
|
sha1_to_hex(object->sha1));
|
|
|
|
|
object->flags &= ~CLIENT_SHALLOW;
|
|
|
|
|
/* make sure the real parents are parsed */
|
|
|
|
|
unregister_shallow(object->sha1);
|
|
|
|
|
object->parsed = 0;
|
|
|
|
|
if (parse_commit((struct commit *)object))
|
|
|
|
|
die("invalid commit");
|
|
|
|
|
parents = ((struct commit *)object)->parents;
|
|
|
|
|
while (parents) {
|
|
|
|
|
add_object_array(&parents->item->object,
|
|
|
|
|
NULL, &want_obj);
|
|
|
|
|
parents = parents->next;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/* make sure commit traversal conforms to client */
|
|
|
|
|
register_shallow(object->sha1);
|
|
|
|
|
}
|
|
|
|
|
packet_flush(1);
|
|
|
|
|
} else
|
|
|
|
|
if (shallows.nr > 0) {
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < shallows.nr; i++)
|
|
|
|
|
register_shallow(shallows.objects[i].item->sha1);
|
|
|
|
|
}
|
|
|
|
|
free(shallows.objects);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int send_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
|
|
|
|
{
|
|
|
|
|
static const char *capabilities = "multi_ack thin-pack side-band"
|
|
|
|
|
" side-band-64k ofs-delta shallow no-progress"
|
|
|
|
|
" include-tag";
|
|
|
|
|
struct object *o = parse_object(sha1);
|
|
|
|
|
|
|
|
|
|
if (!o)
|
|
|
|
|
die("git-upload-pack: cannot find object %s:", sha1_to_hex(sha1));
|
|
|
|
|
|
|
|
|
|
if (capabilities)
|
|
|
|
|
packet_write(1, "%s %s%c%s\n", sha1_to_hex(sha1), refname,
|
|
|
|
|
0, capabilities);
|
|
|
|
|
else
|
|
|
|
|
packet_write(1, "%s %s\n", sha1_to_hex(sha1), refname);
|
|
|
|
|
capabilities = NULL;
|
|
|
|
|
if (!(o->flags & OUR_REF)) {
|
|
|
|
|
o->flags |= OUR_REF;
|
|
|
|
|
nr_our_refs++;
|
|
|
|
|
}
|
|
|
|
|
if (o->type == OBJ_TAG) {
|
|
|
|
|
o = deref_tag(o, refname, 0);
|
|
|
|
|
if (o)
|
|
|
|
|
packet_write(1, "%s %s^{}\n", sha1_to_hex(o->sha1), refname);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void upload_pack(void)
|
|
|
|
|
{
|
|
|
|
|
reset_timeout();
|
|
|
|
|
head_ref(send_ref, NULL);
|
|
|
|
|
for_each_ref(send_ref, NULL);
|
|
|
|
|
packet_flush(1);
|
|
|
|
|
receive_needs();
|
|
|
|
|
if (want_obj.nr) {
|
|
|
|
|
get_common_commits();
|
|
|
|
|
create_pack_file();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
|
|
|
{
|
|
|
|
|
char *dir;
|
|
|
|
|
int i;
|
|
|
|
|
int strict = 0;
|
|
|
|
|
|
|
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
|
char *arg = argv[i];
|
|
|
|
|
|
|
|
|
|
if (arg[0] != '-')
|
|
|
|
|
break;
|
|
|
|
|
if (!strcmp(arg, "--strict")) {
|
|
|
|
|
strict = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
18 years ago
|
|
|
if (!prefixcmp(arg, "--timeout=")) {
|
|
|
|
|
timeout = atoi(arg+10);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!strcmp(arg, "--")) {
|
|
|
|
|
i++;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (i != argc-1)
|
|
|
|
|
usage(upload_pack_usage);
|
|
|
|
|
|
|
|
|
|
setup_path(NULL);
|
|
|
|
|
|
|
|
|
|
dir = argv[i];
|
|
|
|
|
|
|
|
|
|
if (!enter_repo(dir, strict))
|
|
|
|
|
die("'%s': unable to chdir or not a git archive", dir);
|
|
|
|
|
if (is_repository_shallow())
|
|
|
|
|
die("attempt to fetch/clone from a shallow repository");
|
|
|
|
|
if (getenv("GIT_DEBUG_SEND_PACK"))
|
|
|
|
|
debug_fd = atoi(getenv("GIT_DEBUG_SEND_PACK"));
|
|
|
|
|
upload_pack();
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
