Log ref updates made by fetch.
[git/git.git] / fetch.c
1 #include "fetch.h"
2
3 #include "cache.h"
4 #include "commit.h"
5 #include "tree.h"
6 #include "tag.h"
7 #include "blob.h"
8 #include "refs.h"
9
10 const char *write_ref = NULL;
11 const char *write_ref_log_details = NULL;
12
13 const unsigned char *current_ref = NULL;
14
15 int get_tree = 0;
16 int get_history = 0;
17 int get_all = 0;
18 int get_verbosely = 0;
19 int get_recover = 0;
20 static unsigned char current_commit_sha1[20];
21
22 void pull_say(const char *fmt, const char *hex)
23 {
24 if (get_verbosely)
25 fprintf(stderr, fmt, hex);
26 }
27
28 static void report_missing(const char *what, const unsigned char *missing)
29 {
30 char missing_hex[41];
31
32 strcpy(missing_hex, sha1_to_hex(missing));;
33 fprintf(stderr,
34 "Cannot obtain needed %s %s\nwhile processing commit %s.\n",
35 what, missing_hex, sha1_to_hex(current_commit_sha1));
36 }
37
38 static int process(struct object *obj);
39
40 static int process_tree(struct tree *tree)
41 {
42 struct tree_entry_list *entry;
43
44 if (parse_tree(tree))
45 return -1;
46
47 entry = tree->entries;
48 tree->entries = NULL;
49 while (entry) {
50 struct tree_entry_list *next = entry->next;
51 if (process(entry->item.any))
52 return -1;
53 free(entry->name);
54 free(entry);
55 entry = next;
56 }
57 return 0;
58 }
59
60 #define COMPLETE (1U << 0)
61 #define SEEN (1U << 1)
62 #define TO_SCAN (1U << 2)
63
64 static struct commit_list *complete = NULL;
65
66 static int process_commit(struct commit *commit)
67 {
68 if (parse_commit(commit))
69 return -1;
70
71 while (complete && complete->item->date >= commit->date) {
72 pop_most_recent_commit(&complete, COMPLETE);
73 }
74
75 if (commit->object.flags & COMPLETE)
76 return 0;
77
78 memcpy(current_commit_sha1, commit->object.sha1, 20);
79
80 pull_say("walk %s\n", sha1_to_hex(commit->object.sha1));
81
82 if (get_tree) {
83 if (process(&commit->tree->object))
84 return -1;
85 if (!get_all)
86 get_tree = 0;
87 }
88 if (get_history) {
89 struct commit_list *parents = commit->parents;
90 for (; parents; parents = parents->next) {
91 if (process(&parents->item->object))
92 return -1;
93 }
94 }
95 return 0;
96 }
97
98 static int process_tag(struct tag *tag)
99 {
100 if (parse_tag(tag))
101 return -1;
102 return process(tag->tagged);
103 }
104
105 static struct object_list *process_queue = NULL;
106 static struct object_list **process_queue_end = &process_queue;
107
108 static int process_object(struct object *obj)
109 {
110 if (obj->type == commit_type) {
111 if (process_commit((struct commit *)obj))
112 return -1;
113 return 0;
114 }
115 if (obj->type == tree_type) {
116 if (process_tree((struct tree *)obj))
117 return -1;
118 return 0;
119 }
120 if (obj->type == blob_type) {
121 return 0;
122 }
123 if (obj->type == tag_type) {
124 if (process_tag((struct tag *)obj))
125 return -1;
126 return 0;
127 }
128 return error("Unable to determine requirements "
129 "of type %s for %s",
130 obj->type, sha1_to_hex(obj->sha1));
131 }
132
133 static int process(struct object *obj)
134 {
135 if (obj->flags & SEEN)
136 return 0;
137 obj->flags |= SEEN;
138
139 if (has_sha1_file(obj->sha1)) {
140 /* We already have it, so we should scan it now. */
141 obj->flags |= TO_SCAN;
142 } else {
143 if (obj->flags & COMPLETE)
144 return 0;
145 prefetch(obj->sha1);
146 }
147
148 object_list_insert(obj, process_queue_end);
149 process_queue_end = &(*process_queue_end)->next;
150 return 0;
151 }
152
153 static int loop(void)
154 {
155 struct object_list *elem;
156
157 while (process_queue) {
158 struct object *obj = process_queue->item;
159 elem = process_queue;
160 process_queue = elem->next;
161 free(elem);
162 if (!process_queue)
163 process_queue_end = &process_queue;
164
165 /* If we are not scanning this object, we placed it in
166 * the queue because we needed to fetch it first.
167 */
168 if (! (obj->flags & TO_SCAN)) {
169 if (fetch(obj->sha1)) {
170 report_missing(obj->type
171 ? obj->type
172 : "object", obj->sha1);
173 return -1;
174 }
175 }
176 if (!obj->type)
177 parse_object(obj->sha1);
178 if (process_object(obj))
179 return -1;
180 }
181 return 0;
182 }
183
184 static int interpret_target(char *target, unsigned char *sha1)
185 {
186 if (!get_sha1_hex(target, sha1))
187 return 0;
188 if (!check_ref_format(target)) {
189 if (!fetch_ref(target, sha1)) {
190 return 0;
191 }
192 }
193 return -1;
194 }
195
196 static int mark_complete(const char *path, const unsigned char *sha1)
197 {
198 struct commit *commit = lookup_commit_reference_gently(sha1, 1);
199 if (commit) {
200 commit->object.flags |= COMPLETE;
201 insert_by_date(commit, &complete);
202 }
203 return 0;
204 }
205
206 int pull(char *target)
207 {
208 struct ref_lock *lock;
209 unsigned char sha1[20];
210 char *msg;
211 int ret;
212
213 save_commit_buffer = 0;
214 track_object_refs = 0;
215 if (write_ref) {
216 lock = lock_ref_sha1(write_ref, current_ref, 1);
217 if (!lock) {
218 error("Can't lock ref %s", write_ref);
219 return -1;
220 }
221 }
222
223 if (!get_recover) {
224 for_each_ref(mark_complete);
225 }
226
227 if (interpret_target(target, sha1)) {
228 error("Could not interpret %s as something to pull", target);
229 unlock_ref(lock);
230 return -1;
231 }
232 if (process(lookup_unknown_object(sha1))) {
233 unlock_ref(lock);
234 return -1;
235 }
236 if (loop()) {
237 unlock_ref(lock);
238 return -1;
239 }
240
241 if (write_ref) {
242 if (write_ref_log_details) {
243 msg = xmalloc(strlen(write_ref_log_details) + 12);
244 sprintf(msg, "fetch from %s", write_ref_log_details);
245 } else
246 msg = NULL;
247 ret = write_ref_sha1(lock, sha1, msg ? msg : "fetch (unknown)");
248 if (msg)
249 free(msg);
250 return ret;
251 }
252 return 0;
253 }