2005-04-30 23:53:56 +00:00
|
|
|
#include "cache.h"
|
2007-09-11 03:02:45 +00:00
|
|
|
#include "walker.h"
|
2018-06-29 01:21:51 +00:00
|
|
|
#include "repository.h"
|
2018-05-15 23:42:15 +00:00
|
|
|
#include "object-store.h"
|
2005-04-30 23:53:56 +00:00
|
|
|
#include "commit.h"
|
|
|
|
#include "tree.h"
|
2006-05-29 19:20:48 +00:00
|
|
|
#include "tree-walk.h"
|
2005-06-22 00:35:53 +00:00
|
|
|
#include "tag.h"
|
|
|
|
#include "blob.h"
|
2005-06-06 20:38:26 +00:00
|
|
|
#include "refs.h"
|
|
|
|
|
2017-10-15 22:06:48 +00:00
|
|
|
static struct object_id current_commit_oid;
|
2005-04-30 23:53:56 +00:00
|
|
|
|
2016-07-08 09:25:23 +00:00
|
|
|
void walker_say(struct walker *walker, const char *fmt, ...)
|
2005-08-02 23:46:10 +00:00
|
|
|
{
|
2016-07-08 09:25:23 +00:00
|
|
|
if (walker->get_verbosely) {
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vfprintf(stderr, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
2005-05-06 08:37:21 +00:00
|
|
|
}
|
|
|
|
|
2006-12-12 17:34:02 +00:00
|
|
|
static void report_missing(const struct object *obj)
|
2005-05-04 08:26:24 +00:00
|
|
|
{
|
2006-12-12 17:34:02 +00:00
|
|
|
fprintf(stderr, "Cannot obtain needed %s %s\n",
|
2018-02-14 18:59:24 +00:00
|
|
|
obj->type ? type_name(obj->type): "object",
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&obj->oid));
|
2017-10-15 22:06:48 +00:00
|
|
|
if (!is_null_oid(¤t_commit_oid))
|
2006-12-12 17:34:02 +00:00
|
|
|
fprintf(stderr, "while processing commit %s.\n",
|
2017-10-15 22:06:48 +00:00
|
|
|
oid_to_hex(¤t_commit_oid));
|
2005-05-04 08:26:24 +00:00
|
|
|
}
|
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
static int process(struct walker *walker, struct object *obj);
|
2005-06-22 00:35:53 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
static int process_tree(struct walker *walker, struct tree *tree)
|
2005-04-30 23:53:56 +00:00
|
|
|
{
|
2006-05-29 19:20:48 +00:00
|
|
|
struct tree_desc desc;
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
struct name_entry entry;
|
2005-04-30 23:53:56 +00:00
|
|
|
|
|
|
|
if (parse_tree(tree))
|
|
|
|
return -1;
|
|
|
|
|
2007-03-21 17:08:25 +00:00
|
|
|
init_tree_desc(&desc, tree->buffer, tree->size);
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
while (tree_entry(&desc, &entry)) {
|
2006-06-02 22:23:47 +00:00
|
|
|
struct object *obj = NULL;
|
|
|
|
|
2007-06-26 21:19:41 +00:00
|
|
|
/* submodule commits are not stored in the superproject */
|
2007-06-27 01:33:24 +00:00
|
|
|
if (S_ISGITLINK(entry.mode))
|
2007-06-26 21:19:41 +00:00
|
|
|
continue;
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
if (S_ISDIR(entry.mode)) {
|
2018-06-29 01:21:56 +00:00
|
|
|
struct tree *tree = lookup_tree(the_repository,
|
|
|
|
entry.oid);
|
2006-06-02 22:23:47 +00:00
|
|
|
if (tree)
|
|
|
|
obj = &tree->object;
|
|
|
|
}
|
|
|
|
else {
|
2018-06-29 01:21:55 +00:00
|
|
|
struct blob *blob = lookup_blob(the_repository,
|
|
|
|
entry.oid);
|
2006-06-02 22:23:47 +00:00
|
|
|
if (blob)
|
|
|
|
obj = &blob->object;
|
2006-05-29 19:18:33 +00:00
|
|
|
}
|
2007-09-11 03:02:45 +00:00
|
|
|
if (!obj || process(walker, obj))
|
2005-04-30 23:53:56 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2013-06-05 22:37:39 +00:00
|
|
|
free_tree_buffer(tree);
|
2005-04-30 23:53:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-25 13:23:26 +00:00
|
|
|
/* Remember to update object flag allocation in object.h */
|
2005-09-21 16:34:24 +00:00
|
|
|
#define COMPLETE (1U << 0)
|
|
|
|
#define SEEN (1U << 1)
|
|
|
|
#define TO_SCAN (1U << 2)
|
2005-09-18 08:01:07 +00:00
|
|
|
|
2005-09-16 21:30:29 +00:00
|
|
|
static struct commit_list *complete = NULL;
|
2005-09-15 01:31:42 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
static int process_commit(struct walker *walker, struct commit *commit)
|
2005-04-30 23:53:56 +00:00
|
|
|
{
|
2018-04-22 18:12:50 +00:00
|
|
|
struct commit_list *parents;
|
|
|
|
|
2005-08-02 23:46:10 +00:00
|
|
|
if (parse_commit(commit))
|
2005-04-30 23:53:56 +00:00
|
|
|
return -1;
|
|
|
|
|
2005-09-15 01:31:42 +00:00
|
|
|
while (complete && complete->item->date >= commit->date) {
|
2005-09-16 21:30:29 +00:00
|
|
|
pop_most_recent_commit(&complete, COMPLETE);
|
2005-09-15 01:31:42 +00:00
|
|
|
}
|
|
|
|
|
2005-09-16 21:30:29 +00:00
|
|
|
if (commit->object.flags & COMPLETE)
|
2005-09-15 01:31:42 +00:00
|
|
|
return 0;
|
|
|
|
|
2017-10-15 22:06:48 +00:00
|
|
|
oidcpy(¤t_commit_oid, &commit->object.oid);
|
2005-04-30 23:53:56 +00:00
|
|
|
|
2015-11-10 02:22:28 +00:00
|
|
|
walker_say(walker, "walk %s\n", oid_to_hex(&commit->object.oid));
|
2005-09-18 08:01:07 +00:00
|
|
|
|
2018-05-23 05:38:13 +00:00
|
|
|
if (process(walker, &get_commit_tree(commit)->object))
|
2018-04-22 18:12:50 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
for (parents = commit->parents; parents; parents = parents->next) {
|
|
|
|
if (process(walker, &parents->item->object))
|
2005-04-30 23:53:56 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2018-04-22 18:12:50 +00:00
|
|
|
|
2005-04-30 23:53:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
static int process_tag(struct walker *walker, struct tag *tag)
|
2005-06-22 00:35:53 +00:00
|
|
|
{
|
2005-08-02 23:46:10 +00:00
|
|
|
if (parse_tag(tag))
|
2005-06-22 00:35:53 +00:00
|
|
|
return -1;
|
2007-09-11 03:02:45 +00:00
|
|
|
return process(walker, tag->tagged);
|
2005-06-22 00:35:53 +00:00
|
|
|
}
|
|
|
|
|
2005-08-02 23:46:10 +00:00
|
|
|
static struct object_list *process_queue = NULL;
|
|
|
|
static struct object_list **process_queue_end = &process_queue;
|
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
static int process_object(struct walker *walker, struct object *obj)
|
2005-06-22 00:35:53 +00:00
|
|
|
{
|
2006-07-12 03:45:31 +00:00
|
|
|
if (obj->type == OBJ_COMMIT) {
|
2007-09-11 03:02:45 +00:00
|
|
|
if (process_commit(walker, (struct commit *)obj))
|
2005-08-11 23:38:09 +00:00
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
2006-07-12 03:45:31 +00:00
|
|
|
if (obj->type == OBJ_TREE) {
|
2007-09-11 03:02:45 +00:00
|
|
|
if (process_tree(walker, (struct tree *)obj))
|
2005-08-11 23:38:09 +00:00
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
2006-07-12 03:45:31 +00:00
|
|
|
if (obj->type == OBJ_BLOB) {
|
2005-08-11 23:38:09 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2006-07-12 03:45:31 +00:00
|
|
|
if (obj->type == OBJ_TAG) {
|
2007-09-11 03:02:45 +00:00
|
|
|
if (process_tag(walker, (struct tag *)obj))
|
2005-08-11 23:38:09 +00:00
|
|
|
return -1;
|
2005-06-22 00:35:53 +00:00
|
|
|
return 0;
|
2005-08-11 23:38:09 +00:00
|
|
|
}
|
|
|
|
return error("Unable to determine requirements "
|
|
|
|
"of type %s for %s",
|
2018-02-14 18:59:24 +00:00
|
|
|
type_name(obj->type), oid_to_hex(&obj->oid));
|
2005-08-11 23:38:09 +00:00
|
|
|
}
|
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
static int process(struct walker *walker, struct object *obj)
|
2005-08-11 23:38:09 +00:00
|
|
|
{
|
2005-09-21 16:33:59 +00:00
|
|
|
if (obj->flags & SEEN)
|
|
|
|
return 0;
|
|
|
|
obj->flags |= SEEN;
|
|
|
|
|
2015-11-10 02:22:28 +00:00
|
|
|
if (has_object_file(&obj->oid)) {
|
2005-08-11 23:38:09 +00:00
|
|
|
/* We already have it, so we should scan it now. */
|
2005-09-18 08:01:07 +00:00
|
|
|
obj->flags |= TO_SCAN;
|
2006-06-06 21:04:17 +00:00
|
|
|
}
|
|
|
|
else {
|
2005-09-21 16:34:14 +00:00
|
|
|
if (obj->flags & COMPLETE)
|
|
|
|
return 0;
|
2015-11-10 02:22:29 +00:00
|
|
|
walker->prefetch(walker, obj->oid.hash);
|
2005-08-11 23:38:09 +00:00
|
|
|
}
|
2007-06-07 07:04:01 +00:00
|
|
|
|
2005-08-02 23:46:10 +00:00
|
|
|
object_list_insert(obj, process_queue_end);
|
|
|
|
process_queue_end = &(*process_queue_end)->next;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
static int loop(struct walker *walker)
|
2005-08-02 23:46:10 +00:00
|
|
|
{
|
2005-09-18 08:01:07 +00:00
|
|
|
struct object_list *elem;
|
|
|
|
|
2005-08-02 23:46:10 +00:00
|
|
|
while (process_queue) {
|
|
|
|
struct object *obj = process_queue->item;
|
2005-09-18 08:01:07 +00:00
|
|
|
elem = process_queue;
|
|
|
|
process_queue = elem->next;
|
|
|
|
free(elem);
|
2005-08-02 23:46:10 +00:00
|
|
|
if (!process_queue)
|
|
|
|
process_queue_end = &process_queue;
|
|
|
|
|
2005-09-18 08:01:07 +00:00
|
|
|
/* If we are not scanning this object, we placed it in
|
|
|
|
* the queue because we needed to fetch it first.
|
|
|
|
*/
|
|
|
|
if (! (obj->flags & TO_SCAN)) {
|
2015-11-10 02:22:29 +00:00
|
|
|
if (walker->fetch(walker, obj->oid.hash)) {
|
2006-12-12 17:34:02 +00:00
|
|
|
report_missing(obj);
|
2005-09-18 08:01:07 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2005-08-02 23:46:10 +00:00
|
|
|
if (!obj->type)
|
2018-06-29 01:21:51 +00:00
|
|
|
parse_object(the_repository, &obj->oid);
|
2007-09-11 03:02:45 +00:00
|
|
|
if (process_object(walker, obj))
|
2005-08-11 23:38:09 +00:00
|
|
|
return -1;
|
2005-08-02 23:46:10 +00:00
|
|
|
}
|
|
|
|
return 0;
|
2005-06-22 00:35:53 +00:00
|
|
|
}
|
|
|
|
|
2017-10-15 22:06:48 +00:00
|
|
|
static int interpret_target(struct walker *walker, char *target, struct object_id *oid)
|
2005-06-06 20:38:26 +00:00
|
|
|
{
|
2017-10-15 22:06:48 +00:00
|
|
|
if (!get_oid_hex(target, oid))
|
2005-06-06 20:38:26 +00:00
|
|
|
return 0;
|
2011-09-15 21:10:25 +00:00
|
|
|
if (!check_refname_format(target, 0)) {
|
2008-10-18 08:44:18 +00:00
|
|
|
struct ref *ref = alloc_ref(target);
|
Make walker.fetch_ref() take a struct ref.
This simplifies a few things, makes a few things slightly more
complicated, but, more importantly, allows that, when struct ref can
represent a symref, http_fetch_ref() can return one.
Incidentally makes the string that http_fetch_ref() gets include "refs/"
(if appropriate), because that's how the name field of struct ref works.
As far as I can tell, the usage in walker:interpret_target() wouldn't have
worked previously, if it ever would have been used, which it wouldn't
(since the fetch process uses the hash instead of the name of the ref
there).
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-04-26 19:53:09 +00:00
|
|
|
if (!walker->fetch_ref(walker, ref)) {
|
2017-10-15 22:06:48 +00:00
|
|
|
oidcpy(oid, &ref->old_oid);
|
Make walker.fetch_ref() take a struct ref.
This simplifies a few things, makes a few things slightly more
complicated, but, more importantly, allows that, when struct ref can
represent a symref, http_fetch_ref() can return one.
Incidentally makes the string that http_fetch_ref() gets include "refs/"
(if appropriate), because that's how the name field of struct ref works.
As far as I can tell, the usage in walker:interpret_target() wouldn't have
worked previously, if it ever would have been used, which it wouldn't
(since the fetch process uses the hash instead of the name of the ref
there).
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-04-26 19:53:09 +00:00
|
|
|
free(ref);
|
2005-06-06 20:38:26 +00:00
|
|
|
return 0;
|
|
|
|
}
|
Make walker.fetch_ref() take a struct ref.
This simplifies a few things, makes a few things slightly more
complicated, but, more importantly, allows that, when struct ref can
represent a symref, http_fetch_ref() can return one.
Incidentally makes the string that http_fetch_ref() gets include "refs/"
(if appropriate), because that's how the name field of struct ref works.
As far as I can tell, the usage in walker:interpret_target() wouldn't have
worked previously, if it ever would have been used, which it wouldn't
(since the fetch process uses the hash instead of the name of the ref
there).
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-04-26 19:53:09 +00:00
|
|
|
free(ref);
|
2005-06-06 20:38:26 +00:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2015-05-25 18:39:14 +00:00
|
|
|
static int mark_complete(const char *path, const struct object_id *oid,
|
|
|
|
int flag, void *cb_data)
|
2005-09-15 01:31:42 +00:00
|
|
|
{
|
2018-06-29 01:21:57 +00:00
|
|
|
struct commit *commit = lookup_commit_reference_gently(the_repository,
|
|
|
|
oid, 1);
|
2015-05-25 18:39:14 +00:00
|
|
|
|
2005-09-16 21:30:29 +00:00
|
|
|
if (commit) {
|
|
|
|
commit->object.flags |= COMPLETE;
|
2014-08-21 18:30:24 +00:00
|
|
|
commit_list_insert(commit, &complete);
|
2005-09-15 01:31:42 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2005-06-06 20:38:26 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
int walker_targets_stdin(char ***target, const char ***write_ref)
|
2006-07-27 21:56:19 +00:00
|
|
|
{
|
|
|
|
int targets = 0, targets_alloc = 0;
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2006-07-27 21:56:19 +00:00
|
|
|
*target = NULL; *write_ref = NULL;
|
|
|
|
while (1) {
|
|
|
|
char *rf_one = NULL;
|
|
|
|
char *tg_one;
|
|
|
|
|
2016-01-13 23:31:17 +00:00
|
|
|
if (strbuf_getline_lf(&buf, stdin) == EOF)
|
2006-07-27 21:56:19 +00:00
|
|
|
break;
|
|
|
|
tg_one = buf.buf;
|
|
|
|
rf_one = strchr(tg_one, '\t');
|
|
|
|
if (rf_one)
|
|
|
|
*rf_one++ = 0;
|
|
|
|
|
|
|
|
if (targets >= targets_alloc) {
|
|
|
|
targets_alloc = targets_alloc ? targets_alloc * 2 : 64;
|
2014-09-16 18:56:57 +00:00
|
|
|
REALLOC_ARRAY(*target, targets_alloc);
|
|
|
|
REALLOC_ARRAY(*write_ref, targets_alloc);
|
2006-07-27 21:56:19 +00:00
|
|
|
}
|
2006-09-02 04:16:31 +00:00
|
|
|
(*target)[targets] = xstrdup(tg_one);
|
2015-01-13 01:59:09 +00:00
|
|
|
(*write_ref)[targets] = xstrdup_or_null(rf_one);
|
2006-07-27 21:56:19 +00:00
|
|
|
targets++;
|
|
|
|
}
|
2007-09-17 09:19:04 +00:00
|
|
|
strbuf_release(&buf);
|
2006-07-27 21:56:19 +00:00
|
|
|
return targets;
|
|
|
|
}
|
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
void walker_targets_free(int targets, char **target, const char **write_ref)
|
2006-07-27 21:56:19 +00:00
|
|
|
{
|
|
|
|
while (targets--) {
|
|
|
|
free(target[targets]);
|
2009-07-22 21:51:55 +00:00
|
|
|
if (write_ref)
|
2006-07-27 21:56:19 +00:00
|
|
|
free((char *) write_ref[targets]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
int walker_fetch(struct walker *walker, int targets, char **target,
|
|
|
|
const char **write_ref, const char *write_ref_log_details)
|
2005-04-30 23:53:56 +00:00
|
|
|
{
|
2014-04-17 18:31:06 +00:00
|
|
|
struct strbuf refname = STRBUF_INIT;
|
|
|
|
struct strbuf err = STRBUF_INIT;
|
|
|
|
struct ref_transaction *transaction = NULL;
|
2017-10-15 22:06:48 +00:00
|
|
|
struct object_id *oids = xmalloc(targets * sizeof(struct object_id));
|
2014-04-17 18:31:06 +00:00
|
|
|
char *msg = NULL;
|
|
|
|
int i, ret = -1;
|
2005-06-06 20:38:26 +00:00
|
|
|
|
2005-09-15 22:06:39 +00:00
|
|
|
save_commit_buffer = 0;
|
2006-07-27 21:56:17 +00:00
|
|
|
|
2014-04-17 18:31:06 +00:00
|
|
|
if (write_ref) {
|
|
|
|
transaction = ref_transaction_begin(&err);
|
|
|
|
if (!transaction) {
|
|
|
|
error("%s", err.buf);
|
|
|
|
goto done;
|
2006-05-19 07:29:26 +00:00
|
|
|
}
|
2005-06-06 20:38:26 +00:00
|
|
|
}
|
|
|
|
|
2014-08-21 18:30:24 +00:00
|
|
|
if (!walker->get_recover) {
|
2015-05-25 18:39:14 +00:00
|
|
|
for_each_ref(mark_complete, NULL);
|
2014-08-21 18:30:24 +00:00
|
|
|
commit_list_sort_by_date(&complete);
|
|
|
|
}
|
2005-09-15 01:31:42 +00:00
|
|
|
|
2006-07-27 21:56:17 +00:00
|
|
|
for (i = 0; i < targets; i++) {
|
2017-10-15 22:06:48 +00:00
|
|
|
if (interpret_target(walker, target[i], oids + i)) {
|
2007-12-17 12:00:43 +00:00
|
|
|
error("Could not interpret response from server '%s' as something to pull", target[i]);
|
2014-04-17 18:31:06 +00:00
|
|
|
goto done;
|
2006-07-27 21:56:17 +00:00
|
|
|
}
|
2017-10-15 22:06:48 +00:00
|
|
|
if (process(walker, lookup_unknown_object(oids[i].hash)))
|
2014-04-17 18:31:06 +00:00
|
|
|
goto done;
|
2006-05-17 09:55:02 +00:00
|
|
|
}
|
2006-07-27 21:56:17 +00:00
|
|
|
|
2007-09-11 03:02:45 +00:00
|
|
|
if (loop(walker))
|
2014-04-17 18:31:06 +00:00
|
|
|
goto done;
|
|
|
|
if (!write_ref) {
|
|
|
|
ret = 0;
|
|
|
|
goto done;
|
|
|
|
}
|
2006-07-27 21:56:17 +00:00
|
|
|
if (write_ref_log_details) {
|
2014-09-11 17:33:30 +00:00
|
|
|
msg = xstrfmt("fetch from %s", write_ref_log_details);
|
2006-07-27 21:56:17 +00:00
|
|
|
} else {
|
|
|
|
msg = NULL;
|
2006-05-17 09:55:02 +00:00
|
|
|
}
|
2006-07-27 21:56:17 +00:00
|
|
|
for (i = 0; i < targets; i++) {
|
2014-04-17 18:31:06 +00:00
|
|
|
if (!write_ref[i])
|
2006-07-27 21:56:17 +00:00
|
|
|
continue;
|
2014-04-17 18:31:06 +00:00
|
|
|
strbuf_reset(&refname);
|
|
|
|
strbuf_addf(&refname, "refs/%s", write_ref[i]);
|
|
|
|
if (ref_transaction_update(transaction, refname.buf,
|
2017-10-15 22:06:53 +00:00
|
|
|
oids + i, NULL, 0,
|
2014-04-30 19:22:42 +00:00
|
|
|
msg ? msg : "fetch (unknown)",
|
2014-04-17 18:31:06 +00:00
|
|
|
&err)) {
|
|
|
|
error("%s", err.buf);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
2014-04-30 19:22:42 +00:00
|
|
|
if (ref_transaction_commit(transaction, &err)) {
|
2014-04-17 18:31:06 +00:00
|
|
|
error("%s", err.buf);
|
|
|
|
goto done;
|
2006-05-17 09:55:02 +00:00
|
|
|
}
|
2006-07-27 21:56:17 +00:00
|
|
|
|
2014-04-17 18:31:06 +00:00
|
|
|
ret = 0;
|
2007-09-11 03:02:45 +00:00
|
|
|
|
2014-04-17 18:31:06 +00:00
|
|
|
done:
|
|
|
|
ref_transaction_free(transaction);
|
|
|
|
free(msg);
|
2017-10-15 22:06:48 +00:00
|
|
|
free(oids);
|
2014-04-17 18:31:06 +00:00
|
|
|
strbuf_release(&err);
|
|
|
|
strbuf_release(&refname);
|
|
|
|
return ret;
|
2005-04-30 23:53:56 +00:00
|
|
|
}
|
2007-09-11 03:02:45 +00:00
|
|
|
|
|
|
|
void walker_free(struct walker *walker)
|
|
|
|
{
|
|
|
|
walker->cleanup(walker);
|
|
|
|
free(walker);
|
|
|
|
}
|