Don't crash fast-import if the marks cannot be exported.
[gitweb.git] / merge-recursive.c
index 9237a57f8e11e323d6f4b267e09583b3a6c9103b..fa320eb6b1a9e257167e7f843fe36cbdfd908726 100644 (file)
@@ -79,6 +79,11 @@ static struct path_list current_directory_set = {NULL, 0, 0, 1};
 static int call_depth = 0;
 static int verbosity = 2;
 static int buffer_output = 1;
+static int do_progress = 1;
+static unsigned last_percent;
+static unsigned merged_cnt;
+static unsigned total_cnt;
+static volatile sig_atomic_t progress_update;
 static struct output_buffer *output_list, *output_end;
 
 static int show (int v)
@@ -153,6 +158,39 @@ static void output_commit_title(struct commit *commit)
        }
 }
 
+static void progress_interval(int signum)
+{
+       progress_update = 1;
+}
+
+static void setup_progress_signal(void)
+{
+       struct sigaction sa;
+       struct itimerval v;
+
+       memset(&sa, 0, sizeof(sa));
+       sa.sa_handler = progress_interval;
+       sigemptyset(&sa.sa_mask);
+       sa.sa_flags = SA_RESTART;
+       sigaction(SIGALRM, &sa, NULL);
+
+       v.it_interval.tv_sec = 1;
+       v.it_interval.tv_usec = 0;
+       v.it_value = v.it_interval;
+       setitimer(ITIMER_REAL, &v, NULL);
+}
+
+static void display_progress()
+{
+       unsigned percent = total_cnt ? merged_cnt * 100 / total_cnt : 0;
+       if (progress_update || percent != last_percent) {
+               fprintf(stderr, "%4u%% (%u/%u) done\r",
+                       percent, merged_cnt, total_cnt);
+               progress_update = 0;
+               last_percent = percent;
+       }
+}
+
 static struct cache_entry *make_cache_entry(unsigned int mode,
                const unsigned char *sha1, const char *path, int stage, int refresh)
 {
@@ -315,11 +353,14 @@ static struct path_list *get_unmerged(void)
        int i;
 
        unmerged->strdup_paths = 1;
+       total_cnt += active_nr;
 
-       for (i = 0; i < active_nr; i++) {
+       for (i = 0; i < active_nr; i++, merged_cnt++) {
                struct path_list_item *item;
                struct stage_data *e;
                struct cache_entry *ce = active_cache[i];
+               if (do_progress)
+                       display_progress();
                if (!ce_stage(ce))
                        continue;
 
@@ -683,13 +724,13 @@ static void conflict_rename_rename(struct rename *ren1,
        const char *dst_name2 = ren2_dst;
        if (path_list_has_path(&current_directory_set, ren1_dst)) {
                dst_name1 = del[delp++] = unique_path(ren1_dst, branch1);
-               output(1, "%s is a directory in %s adding as %s instead",
+               output(1, "%s is a directory in %s added as %s instead",
                       ren1_dst, branch2, dst_name1);
                remove_file(0, ren1_dst, 0);
        }
        if (path_list_has_path(&current_directory_set, ren2_dst)) {
                dst_name2 = del[delp++] = unique_path(ren2_dst, branch2);
-               output(1, "%s is a directory in %s adding as %s instead",
+               output(1, "%s is a directory in %s added as %s instead",
                       ren2_dst, branch1, dst_name2);
                remove_file(0, ren2_dst, 0);
        }
@@ -703,7 +744,7 @@ static void conflict_rename_dir(struct rename *ren1,
                                const char *branch1)
 {
        char *new_path = unique_path(ren1->pair->two->path, branch1);
-       output(1, "Renaming %s to %s instead", ren1->pair->one->path, new_path);
+       output(1, "Renamed %s to %s instead", ren1->pair->one->path, new_path);
        remove_file(0, ren1->pair->two->path, 0);
        update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, new_path);
        free(new_path);
@@ -716,7 +757,7 @@ static void conflict_rename_rename_2(struct rename *ren1,
 {
        char *new_path1 = unique_path(ren1->pair->two->path, branch1);
        char *new_path2 = unique_path(ren2->pair->two->path, branch2);
-       output(1, "Renaming %s to %s and %s to %s instead",
+       output(1, "Renamed %s to %s and %s to %s instead",
               ren1->pair->one->path, new_path1,
               ren2->pair->one->path, new_path2);
        remove_file(0, ren1->pair->two->path, 0);
@@ -824,10 +865,10 @@ static int process_renames(struct path_list *a_renames,
                                                 branch1,
                                                 branch2);
                                if (mfi.merge || !mfi.clean)
-                                       output(1, "Renaming %s->%s", src, ren1_dst);
+                                       output(1, "Renamed %s->%s", src, ren1_dst);
 
                                if (mfi.merge)
-                                       output(2, "Auto-merging %s", ren1_dst);
+                                       output(2, "Auto-merged %s", ren1_dst);
 
                                if (!mfi.clean) {
                                        output(1, "CONFLICT (content): merge conflict in %s",
@@ -861,14 +902,14 @@ static int process_renames(struct path_list *a_renames,
 
                        if (path_list_has_path(&current_directory_set, ren1_dst)) {
                                clean_merge = 0;
-                               output(1, "CONFLICT (rename/directory): Rename %s->%s in %s "
+                               output(1, "CONFLICT (rename/directory): Renamed %s->%s in %s "
                                       " directory %s added in %s",
                                       ren1_src, ren1_dst, branch1,
                                       ren1_dst, branch2);
                                conflict_rename_dir(ren1, branch1);
                        } else if (sha_eq(src_other.sha1, null_sha1)) {
                                clean_merge = 0;
-                               output(1, "CONFLICT (rename/delete): Rename %s->%s in %s "
+                               output(1, "CONFLICT (rename/delete): Renamed %s->%s in %s "
                                       "and deleted in %s",
                                       ren1_src, ren1_dst, branch1,
                                       branch2);
@@ -877,19 +918,19 @@ static int process_renames(struct path_list *a_renames,
                                const char *new_path;
                                clean_merge = 0;
                                try_merge = 1;
-                               output(1, "CONFLICT (rename/add): Rename %s->%s in %s. "
+                               output(1, "CONFLICT (rename/add): Renamed %s->%s in %s. "
                                       "%s added in %s",
                                       ren1_src, ren1_dst, branch1,
                                       ren1_dst, branch2);
                                new_path = unique_path(ren1_dst, branch2);
-                               output(1, "Adding as %s instead", new_path);
+                               output(1, "Added as %s instead", new_path);
                                update_file(0, dst_other.sha1, dst_other.mode, new_path);
                        } else if ((item = path_list_lookup(ren1_dst, renames2Dst))) {
                                ren2 = item->util;
                                clean_merge = 0;
                                ren2->processed = 1;
-                               output(1, "CONFLICT (rename/rename): Rename %s->%s in %s. "
-                                      "Rename %s->%s in %s",
+                               output(1, "CONFLICT (rename/rename): Renamed %s->%s in %s. "
+                                      "Renamed %s->%s in %s",
                                       ren1_src, ren1_dst, branch1,
                                       ren2->pair->one->path, ren2->pair->two->path, branch2);
                                conflict_rename_rename_2(ren1, branch1, ren2, branch2);
@@ -913,9 +954,9 @@ static int process_renames(struct path_list *a_renames,
                                                a_branch, b_branch);
 
                                if (mfi.merge || !mfi.clean)
-                                       output(1, "Renaming %s => %s", ren1_src, ren1_dst);
+                                       output(1, "Renamed %s => %s", ren1_src, ren1_dst);
                                if (mfi.merge)
-                                       output(2, "Auto-merging %s", ren1_dst);
+                                       output(2, "Auto-merged %s", ren1_dst);
                                if (!mfi.clean) {
                                        output(1, "CONFLICT (rename/modify): Merge conflict in %s",
                                               ren1_dst);
@@ -965,7 +1006,7 @@ static int process_entry(const char *path, struct stage_data *entry,
                        /* Deleted in both or deleted in one and
                         * unchanged in the other */
                        if (a_sha)
-                               output(2, "Removing %s", path);
+                               output(2, "Removed %s", path);
                        /* do not touch working file if it did not exist */
                        remove_file(1, path, !a_sha);
                } else {
@@ -1012,12 +1053,12 @@ static int process_entry(const char *path, struct stage_data *entry,
                        const char *new_path = unique_path(path, add_branch);
                        clean_merge = 0;
                        output(1, "CONFLICT (%s): There is a directory with name %s in %s. "
-                              "Adding %s as %s",
+                              "Added %s as %s",
                               conf, path, other_branch, path, new_path);
                        remove_file(0, path, 0);
                        update_file(0, sha, mode, new_path);
                } else {
-                       output(2, "Adding %s", path);
+                       output(2, "Added %s", path);
                        update_file(1, sha, mode, path);
                }
        } else if (a_sha && b_sha) {
@@ -1031,7 +1072,7 @@ static int process_entry(const char *path, struct stage_data *entry,
                        reason = "add/add";
                        o_sha = (unsigned char *)null_sha1;
                }
-               output(2, "Auto-merging %s", path);
+               output(2, "Auto-merged %s", path);
                o.path = a.path = b.path = (char *)path;
                hashcpy(o.sha1, o_sha);
                o.mode = o_mode;
@@ -1096,13 +1137,15 @@ static int merge_trees(struct tree *head,
                re_merge = get_renames(merge, common, head, merge, entries);
                clean = process_renames(re_head, re_merge,
                                branch1, branch2);
-               for (i = 0; i < entries->nr; i++) {
+               total_cnt += entries->nr;
+               for (i = 0; i < entries->nr; i++, merged_cnt++) {
                        const char *path = entries->items[i].path;
                        struct stage_data *e = entries->items[i].util;
-                       if (e->processed)
-                               continue;
-                       if (!process_entry(path, e, branch1, branch2))
+                       if (!e->processed
+                               && !process_entry(path, e, branch1, branch2))
                                clean = 0;
+                       if (do_progress)
+                               display_progress();
                }
 
                path_list_clear(re_merge, 0);
@@ -1210,6 +1253,15 @@ static int merge(struct commit *h1,
                commit_list_insert(h1, &(*result)->parents);
                commit_list_insert(h2, &(*result)->parents->next);
        }
+       if (!call_depth && do_progress) {
+               /* Make sure we end at 100% */
+               if (!total_cnt)
+                       total_cnt = 1;
+               merged_cnt = total_cnt;
+               progress_update = 1;
+               display_progress();
+               fputc('\n', stderr);
+       }
        flush_output();
        return clean;
 }
@@ -1279,6 +1331,12 @@ int main(int argc, char *argv[])
        }
        if (argc - i != 3) /* "--" "<head>" "<remote>" */
                die("Not handling anything other than two heads merge.");
+       if (verbosity >= 5) {
+               buffer_output = 0;
+               do_progress = 0;
+       }
+       else
+               do_progress = isatty(1);
 
        branch1 = argv[++i];
        branch2 = argv[++i];
@@ -1288,8 +1346,9 @@ int main(int argc, char *argv[])
 
        branch1 = better_branch_name(branch1);
        branch2 = better_branch_name(branch2);
-       if (verbosity >= 5)
-               buffer_output = 0;
+
+       if (do_progress)
+               setup_progress_signal();
        if (show(3))
                printf("Merging %s with %s\n", branch1, branch2);