repack_without_refs(): make the refnames argument a string_list
[gitweb.git] / bundle.c
index fa67057e60fe638825cc80e65cb1fa0be5b26ed9..2e2dbd50efbf2eca2b36f6dd7ceeb68bbecc90ba 100644 (file)
--- a/bundle.c
+++ b/bundle.c
@@ -235,33 +235,50 @@ static int is_tag_in_date_range(struct object *tag, struct rev_info *revs)
        return result;
 }
 
-int create_bundle(struct bundle_header *header, const char *path,
-                 int argc, const char **argv)
+static int write_pack_data(int bundle_fd, struct lock_file *lock, struct rev_info *revs)
 {
-       static struct lock_file lock;
-       int bundle_fd = -1;
-       int bundle_to_stdout;
-       int i, ref_count = 0;
-       struct strbuf buf = STRBUF_INIT;
-       struct rev_info revs;
-       struct child_process rls = CHILD_PROCESS_INIT;
-       FILE *rls_fout;
+       struct child_process pack_objects = CHILD_PROCESS_INIT;
+       int i;
 
-       bundle_to_stdout = !strcmp(path, "-");
-       if (bundle_to_stdout)
-               bundle_fd = 1;
-       else
-               bundle_fd = hold_lock_file_for_update(&lock, path,
-                                                     LOCK_DIE_ON_ERROR);
+       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;
+       if (start_command(&pack_objects))
+               return error(_("Could not spawn pack-objects"));
 
-       /* write signature */
-       write_or_die(bundle_fd, bundle_signature, strlen(bundle_signature));
+       /*
+        * start_command closed bundle_fd if it was > 1
+        * so set the lock fd to -1 so commit_lock_file()
+        * won't fail trying to close it.
+        */
+       lock->fd = -1;
 
-       /* init revs to list objects for pack-objects later */
-       save_commit_buffer = 0;
-       init_revisions(&revs, NULL);
+       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);
+               write_or_die(pack_objects.in, sha1_to_hex(object->sha1), 40);
+               write_or_die(pack_objects.in, "\n", 1);
+       }
+       close(pack_objects.in);
+       if (finish_command(&pack_objects))
+               return error(_("pack-objects died"));
+       return 0;
+}
+
+static int compute_and_write_prerequisites(int bundle_fd,
+                                          struct rev_info *revs,
+                                          int argc, const char **argv)
+{
+       struct child_process rls = CHILD_PROCESS_INIT;
+       struct strbuf buf = STRBUF_INIT;
+       FILE *rls_fout;
+       int i;
 
-       /* write prerequisites */
        argv_array_pushl(&rls.args,
                         "rev-list", "--boundary", "--pretty=oneline",
                         NULL);
@@ -279,7 +296,7 @@ int create_bundle(struct bundle_header *header, const char *path,
                        if (!get_sha1_hex(buf.buf + 1, sha1)) {
                                struct object *object = parse_object_or_die(sha1, buf.buf);
                                object->flags |= UNINTERESTING;
-                               add_pending_object(&revs, object, buf.buf);
+                               add_pending_object(revs, object, buf.buf);
                        }
                } else if (!get_sha1_hex(buf.buf, sha1)) {
                        struct object *object = parse_object_or_die(sha1, buf.buf);
@@ -290,17 +307,25 @@ int create_bundle(struct bundle_header *header, const char *path,
        fclose(rls_fout);
        if (finish_command(&rls))
                return error(_("rev-list died"));
+       return 0;
+}
 
-       /* write references */
-       argc = setup_revisions(argc, argv, &revs, NULL);
-
-       if (argc > 1)
-               return error(_("unrecognized argument: %s"), argv[1]);
-
-       object_array_remove_duplicates(&revs.pending);
+/*
+ * 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)
+{
+       int i;
+       int ref_count = 0;
 
-       for (i = 0; i < revs.pending.nr; i++) {
-               struct object_array_entry *e = revs.pending.objects + i;
+       for (i = 0; i < revs->pending.nr; i++) {
+               struct object_array_entry *e = revs->pending.objects + i;
                unsigned char sha1[20];
                char *ref;
                const char *display_ref;
@@ -315,7 +340,7 @@ int create_bundle(struct bundle_header *header, const char *path,
                display_ref = (flag & REF_ISSYMREF) ? e->name : ref;
 
                if (e->item->type == OBJ_TAG &&
-                               !is_tag_in_date_range(e->item, &revs)) {
+                               !is_tag_in_date_range(e->item, revs)) {
                        e->item->flags |= UNINTERESTING;
                        continue;
                }
@@ -361,7 +386,7 @@ int create_bundle(struct bundle_header *header, const char *path,
                                 */
                                obj = parse_object_or_die(sha1, e->name);
                                obj->flags |= SHOWN;
-                               add_pending_object(&revs, obj, e->name);
+                               add_pending_object(revs, obj, e->name);
                        }
                        free(ref);
                        continue;
@@ -374,41 +399,56 @@ int create_bundle(struct bundle_header *header, const char *path,
                write_or_die(bundle_fd, "\n", 1);
                free(ref);
        }
-       if (!ref_count)
-               die(_("Refusing to create empty bundle."));
 
        /* end header */
        write_or_die(bundle_fd, "\n", 1);
+       return ref_count;
+}
 
-       /* write pack */
-       memset(&rls, 0, sizeof(rls));
-       argv_array_pushl(&rls.args,
-                        "pack-objects", "--all-progress-implied",
-                        "--stdout", "--thin", "--delta-base-offset",
-                        NULL);
-       rls.in = -1;
-       rls.out = bundle_fd;
-       rls.git_cmd = 1;
-       if (start_command(&rls))
-               return error(_("Could not spawn pack-objects"));
+int create_bundle(struct bundle_header *header, const char *path,
+                 int argc, const char **argv)
+{
+       static struct lock_file lock;
+       int bundle_fd = -1;
+       int bundle_to_stdout;
+       int ref_count = 0;
+       struct rev_info revs;
 
-       /*
-        * start_command closed bundle_fd if it was > 1
-        * so set the lock fd to -1 so commit_lock_file()
-        * won't fail trying to close it.
-        */
-       lock.fd = -1;
+       bundle_to_stdout = !strcmp(path, "-");
+       if (bundle_to_stdout)
+               bundle_fd = 1;
+       else
+               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;
+       init_revisions(&revs, NULL);
+
+       /* write prerequisites */
+       if (compute_and_write_prerequisites(bundle_fd, &revs, argc, argv))
+               return -1;
+
+       argc = setup_revisions(argc, argv, &revs, NULL);
+
+       if (argc > 1)
+               return error(_("unrecognized argument: %s"), argv[1]);
+
+       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)
+               return -1;
+
+       /* write pack */
+       if (write_pack_data(bundle_fd, &lock, &revs))
+               return -1;
 
-       for (i = 0; i < revs.pending.nr; i++) {
-               struct object *object = revs.pending.objects[i].item;
-               if (object->flags & UNINTERESTING)
-                       write_or_die(rls.in, "^", 1);
-               write_or_die(rls.in, sha1_to_hex(object->sha1), 40);
-               write_or_die(rls.in, "\n", 1);
-       }
-       close(rls.in);
-       if (finish_command(&rls))
-               return error(_("pack-objects died"));
        if (!bundle_to_stdout) {
                if (commit_lock_file(&lock))
                        die_errno(_("cannot create '%s'"), path);