Remove pack.keep after ref updates in git-fetch
[git/git.git] / transport.c
index 1e73749..0882edd 100644 (file)
@@ -5,14 +5,17 @@
 #include "pkt-line.h"
 #include "fetch-pack.h"
 #include "walker.h"
+#include "bundle.h"
 
 /* Generic functions for using commit walkers */
 
-static int fetch_objs_via_walker(const struct transport *transport,
-                                int nr_objs, char **objs)
+static int fetch_objs_via_walker(struct transport *transport,
+                                int nr_objs, struct ref **to_fetch)
 {
        char *dest = xstrdup(transport->url);
        struct walker *walker = transport->data;
+       char **objs = xmalloc(nr_objs * sizeof(*objs));
+       int i;
 
        walker->get_all = 1;
        walker->get_tree = 1;
@@ -20,9 +23,15 @@ static int fetch_objs_via_walker(const struct transport *transport,
        walker->get_verbosely = transport->verbose;
        walker->get_recover = 0;
 
+       for (i = 0; i < nr_objs; i++)
+               objs[i] = xstrdup(sha1_to_hex(to_fetch[i]->old_sha1));
+
        if (walker_fetch(walker, nr_objs, objs, NULL, dest))
                die("Fetch failed.");
 
+       for (i = 0; i < nr_objs; i++)
+               free(objs[i]);
+       free(objs);
        free(dest);
        return 0;
 }
@@ -178,13 +187,59 @@ static struct ref *get_refs_via_curl(const struct transport *transport)
 static const struct transport_ops curl_transport = {
        /* set_option */        NULL,
        /* get_refs_list */     get_refs_via_curl,
-       /* fetch_refs */        NULL,
-       /* fetch_objs */        fetch_objs_via_walker,
+       /* fetch */             fetch_objs_via_walker,
        /* push */              curl_transport_push,
        /* disconnect */        disconnect_walker
 };
 
+struct bundle_transport_data {
+       int fd;
+       struct bundle_header header;
+};
+
+static struct ref *get_refs_from_bundle(const struct transport *transport)
+{
+       struct bundle_transport_data *data = transport->data;
+       struct ref *result = NULL;
+       int i;
+
+       if (data->fd > 0)
+               close(data->fd);
+       data->fd = read_bundle_header(transport->url, &data->header);
+       if (data->fd < 0)
+               die ("Could not read bundle '%s'.", transport->url);
+       for (i = 0; i < data->header.references.nr; i++) {
+               struct ref_list_entry *e = data->header.references.list + i;
+               struct ref *ref = alloc_ref(strlen(e->name));
+               hashcpy(ref->old_sha1, e->sha1);
+               strcpy(ref->name, e->name);
+               ref->next = result;
+               result = ref;
+       }
+       return result;
+}
+
+static int fetch_refs_from_bundle(struct transport *transport,
+                              int nr_heads, struct ref **to_fetch)
+{
+       struct bundle_transport_data *data = transport->data;
+       return unbundle(&data->header, data->fd);
+}
+
+static int close_bundle(struct transport *transport)
+{
+       struct bundle_transport_data *data = transport->data;
+       if (data->fd > 0)
+               close(data->fd);
+       return 0;
+}
+
 static const struct transport_ops bundle_transport = {
+       /* set_option */        NULL,
+       /* get_refs_list */     get_refs_from_bundle,
+       /* fetch */             fetch_refs_from_bundle,
+       /* push */              NULL,
+       /* disconnect */        close_bundle
 };
 
 struct git_transport_data {
@@ -251,13 +306,15 @@ static struct ref *get_refs_via_connect(const struct transport *transport)
        return refs;
 }
 
-static int fetch_refs_via_pack(const struct transport *transport,
-                              int nr_heads, char **heads)
+static int fetch_refs_via_pack(struct transport *transport,
+                              int nr_heads, struct ref **to_fetch)
 {
        struct git_transport_data *data = transport->data;
+       char **heads = xmalloc(nr_heads * sizeof(*heads));
        struct ref *refs;
        char *dest = xstrdup(transport->url);
        struct fetch_pack_args args;
+       int i;
 
        args.uploadpack = data->uploadpack;
        args.quiet = 0;
@@ -271,14 +328,13 @@ static int fetch_refs_via_pack(const struct transport *transport,
 
        setup_fetch_pack(&args);
 
-       refs = fetch_pack(dest, nr_heads, heads);
-
-       // ???? check that refs got everything?
-
-       /* free the memory used for the refs list ... */
+       for (i = 0; i < nr_heads; i++)
+               heads[i] = xstrdup(to_fetch[i]->name);
+       refs = fetch_pack(dest, nr_heads, heads, &transport->pack_lockfile);
 
+       for (i = 0; i < nr_heads; i++)
+               free(heads[i]);
        free_refs(refs);
-
        free(dest);
        return 0;
 }
@@ -330,8 +386,7 @@ static int git_transport_push(struct transport *transport, int refspec_nr, const
 static const struct transport_ops git_transport = {
        /* set_option */        set_git_option,
        /* get_refs_list */     get_refs_via_connect,
-       /* fetch_refs */        fetch_refs_via_pack,
-       /* fetch_objs */        NULL,
+       /* fetch */             fetch_refs_via_pack,
        /* push */              git_transport_push
 };
 
@@ -367,8 +422,9 @@ struct transport *transport_get(struct remote *remote, const char *url,
                else
                        ret->data = NULL;
        } else if (is_local(url) && is_file(url)) {
+               struct bundle_transport_data *data = xcalloc(1, sizeof(*data));
                ret = xmalloc(sizeof(*ret));
-               ret->data = NULL;
+               ret->data = data;
                ret->ops = &bundle_transport;
        } else {
                struct git_transport_data *data = xcalloc(1, sizeof(*data));
@@ -389,6 +445,7 @@ struct transport *transport_get(struct remote *remote, const char *url,
                ret->url = url;
                ret->remote_refs = NULL;
                ret->fetch = !!fetch;
+               ret->pack_lockfile = NULL;
        }
        return ret;
 }
@@ -424,44 +481,33 @@ struct ref *transport_get_remote_refs(struct transport *transport)
        return transport->remote_refs;
 }
 
-#define PACK_HEADS_CHUNK_COUNT 256
-
 int transport_fetch_refs(struct transport *transport, struct ref *refs)
 {
-       int i;
-       int nr_heads = 0;
-       char **heads = xmalloc(PACK_HEADS_CHUNK_COUNT * sizeof(char *));
+       int rc;
+       int nr_heads = 0, nr_alloc = 0;
+       struct ref **heads = NULL;
        struct ref *rm;
-       int use_objs = !transport->ops->fetch_refs;
 
        for (rm = refs; rm; rm = rm->next) {
                if (rm->peer_ref &&
                    !hashcmp(rm->peer_ref->old_sha1, rm->old_sha1))
                        continue;
-               if (use_objs) {
-                       heads[nr_heads++] = xstrdup(sha1_to_hex(rm->old_sha1));
-               } else {
-                       heads[nr_heads++] = xstrdup(rm->name);
-               }
-               if (nr_heads % PACK_HEADS_CHUNK_COUNT == 0)
-                       heads = xrealloc(heads,
-                                        (nr_heads + PACK_HEADS_CHUNK_COUNT) *
-                                        sizeof(char *));
+               ALLOC_GROW(heads, nr_heads + 1, nr_alloc);
+               heads[nr_heads++] = rm;
        }
 
-       if (use_objs) {
-               if (transport->ops->fetch_objs(transport, nr_heads, heads))
-                       return -1;
-       } else {
-               if (transport->ops->fetch_refs(transport, nr_heads, heads))
-                       return -1;
-       }
-
-       /* free the memory used for the heads list ... */
-       for (i = 0; i < nr_heads; i++)
-               free(heads[i]);
+       rc = transport->ops->fetch(transport, nr_heads, heads);
        free(heads);
-       return 0;
+       return rc;
+}
+
+void transport_unlock_pack(struct transport *transport)
+{
+       if (transport->pack_lockfile) {
+               unlink(transport->pack_lockfile);
+               free(transport->pack_lockfile);
+               transport->pack_lockfile = NULL;
+       }
 }
 
 int transport_disconnect(struct transport *transport)