mirror of
https://github.com/git/git.git
synced 2026-10-11 02:49:27 +02:00
Jeff King
567e62b1b9
A remote object-info request needs three things: the transport for contacting the remote, the list of oids to request, and a place to store the output. Rather than take these as function parameters, we take only the transport object, and expect the caller to have placed the other two into special fields in the transport struct. But this doesn't make much sense. The set of oids and results are really only valid for one request. There is no reason the transport would need to hang on to them outside of the single function call. Even though we save a few lines passing the parameters around through the various vtable functions, the result is harder to understand (for example, who is responsible for cleaning up results, and when should it happen?). It also opens up the possibility of a subtle bug. A caller is likely to point those fields to stack variables which could go out of scope, and the transport struct would be left holding invalid pointers. This is mostly harmless now, as we disconnect the transport immediately after the sole caller of transport_fetch_object_info(). But conceptually we could keep the transport open and make multiple fetch calls (and reuse the same connection to the helper, to a remote HTTP server, and so on). So let's pull these out of the struct and pass them as function parameters. It's a little more verbose, but I think more clearly illustrates the intent. I've also tweaked a few function signatures to mark the input oid array as const, since it is purely an input to the function. Signed-off-by: Jeff King <peff@peff.net> Signed-off-by: Pablo Sabater <pabloosabaterr@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
87 lines
2.8 KiB
C
87 lines
2.8 KiB
C
#ifndef TRANSPORT_INTERNAL_H
|
|
#define TRANSPORT_INTERNAL_H
|
|
|
|
#include "connect.h"
|
|
|
|
struct ref;
|
|
struct transport;
|
|
struct strvec;
|
|
struct transport_ls_refs_options;
|
|
struct oid_array;
|
|
struct fetch_object_info_results;
|
|
|
|
struct transport_vtable {
|
|
/**
|
|
* Returns 0 if successful, positive if the option is not
|
|
* recognized or is inapplicable, and negative if the option
|
|
* is applicable but the value is invalid.
|
|
**/
|
|
int (*set_option)(struct transport *connection, const char *name,
|
|
const char *value);
|
|
/**
|
|
* Returns a list of the remote side's refs. In order to allow
|
|
* the transport to try to share connections, for_push is a
|
|
* hint as to whether the ultimate operation is a push or a fetch.
|
|
*
|
|
* If the transport is able to determine the remote hash for
|
|
* the ref without a huge amount of effort, it should store it
|
|
* in the ref's old_sha1 field; otherwise it should be all 0.
|
|
**/
|
|
struct ref *(*get_refs_list)(struct transport *transport, int for_push,
|
|
struct transport_ls_refs_options *transport_options);
|
|
|
|
/**
|
|
* Populates the remote side's bundle-uri under protocol v2,
|
|
* if the "bundle-uri" capability was advertised. Returns 0 if
|
|
* OK, negative values on error.
|
|
*/
|
|
int (*get_bundle_uri)(struct transport *transport);
|
|
|
|
/**
|
|
* Fetch the objects for the given refs. Note that this gets
|
|
* an array, and should ignore the list structure.
|
|
*
|
|
* If the transport did not get hashes for refs in
|
|
* get_refs_list(), it should set the old_sha1 fields in the
|
|
* provided refs now.
|
|
**/
|
|
int (*fetch_refs)(struct transport *transport, int refs_nr, struct ref **refs);
|
|
|
|
/*
|
|
* Fetch object info (only size currently) from remote without
|
|
* downloading the objects.
|
|
*
|
|
* Uses object-info capability of v2 protocol.
|
|
*/
|
|
int (*fetch_object_info)(struct transport *transport,
|
|
const struct oid_array *oids,
|
|
struct fetch_object_info_results *results);
|
|
|
|
/**
|
|
* Push the objects and refs. Send the necessary objects, and
|
|
* then, for any refs where peer_ref is set and
|
|
* peer_ref->new_oid is different from old_oid, tell the
|
|
* remote side to update each ref in the list from old_oid to
|
|
* peer_ref->new_oid.
|
|
*
|
|
* Where possible, set the status for each ref appropriately.
|
|
*
|
|
* The transport must modify new_sha1 in the ref to the new
|
|
* value if the remote accepted the change. Note that this
|
|
* could be a different value from peer_ref->new_oid if the
|
|
* process involved generating new commits.
|
|
**/
|
|
int (*push_refs)(struct transport *transport, struct ref *refs, int flags);
|
|
int (*connect)(struct transport *connection,
|
|
enum git_connect_service service,
|
|
const char *executable, int fd[2]);
|
|
|
|
/** get_refs_list(), fetch(), and push_refs() can keep
|
|
* resources (such as a connection) reserved for further
|
|
* use. disconnect() releases these resources.
|
|
**/
|
|
int (*disconnect)(struct transport *connection);
|
|
};
|
|
|
|
#endif
|