Commits on Jun 22, 2011
  1. upload-archive: allow user to turn off filters

    peff authored and gitster committed Jun 22, 2011
    Some tar filters may be very expensive to run, so sites do
    not want to expose them via upload-archive. This patch lets
    users configure tar.<filter>.remote to turn them off.
    
    By default, gzip filters are left on, as they are about as
    expensive as creating zip archives.
    
    Signed-off-by: Jeff King <peff@peff.net>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
  2. archive: move file extension format-guessing lower

    peff authored and gitster committed Jun 22, 2011
    The process for guessing an archive output format based on
    the filename is something like this:
    
      a. parse --output in cmd_archive; check the filename
         against a static set of mapping heuristics (right now
         it just matches ".zip" for zip files).
    
      b. if found, stick a fake "--format=zip" at the beginning
         of the arguments list (if the user did specify a
         --format manually, the later option will override our
         fake one)
    
      c. if it's a remote call, ship the arguments to the remote
         (including the fake), which will call write_archive on
         their end
    
      d. if it's local, ship the arguments to write_archive
         locally
    
    There are two problems:
    
      1. The set of mappings is static and at too high a level.
         The write_archive level is going to check config for
         user-defined formats, some of which will specify
         extensions. We need to delay lookup until those are
         parsed, so we can match against them.
    
      2. For a remote archive call, our set of mappings (or
         formats) may not match the remote side's. This is OK in
         practice right now, because all versions of git
         understand "zip" and "tar". But as new formats are
         added, there is going to be a mismatch between what the
         client can do and what the remote server can do.
    
    To fix (1), this patch refactors the location guessing to
    happen at the write_archive level, instead of the
    cmd_archive level. So instead of sticking a fake --format
    field in the argv list, we actually pass a "name hint" down
    the callchain; this hint is used at the appropriate time to
    guess the format (if one hasn't been given already).
    
    This patch leaves (2) unfixed. The name_hint is converted to
    a "--format" option as before, and passed to the remote.
    This means the local side's idea of how extensions map to
    formats will take precedence.
    
    Another option would be to pass the name hint to the remote
    side and let the remote choose. This isn't a good idea for
    two reasons:
    
      1. There's no room in the protocol for passing that
         information. We can pass a new argument, but older
         versions of git on the server will choke on it.
    
      2. Letting the remote side decide creates a silent
         inconsistency in user experience. Consider the case
         that the locally installed git knows about the "tar.gz"
         format, but a remote server doesn't.
    
         Running "git archive -o foo.tar.gz" will use the tar.gz
         format. If we use --remote, and the local side chooses
         the format, then we send "--format=tar.gz" to the
         remote, which will complain about the unknown format.
         But if we let the remote side choose the format, then
         it will realize that it doesn't know about "tar.gz" and
         output uncompressed tar without even issuing a warning.
    
    Signed-off-by: Jeff King <peff@peff.net>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
  3. archive: pass archiver struct to write_archive callback

    peff authored and gitster committed Jun 22, 2011
    The current archivers are very static; when you are in the
    write_tar_archive function, you know you are writing a tar.
    However, to facilitate runtime-configurable archivers
    that will share a common write function we need to tell the
    function which archiver was used.
    
    As a convenience, we also provide an opaque data pointer in
    the archiver struct so that individual archivers can put
    something useful there when they register themselves.
    Technically they could just use the "name" field to look in
    an internal map of names to data, but this is much simpler.
    
    Signed-off-by: Jeff King <peff@peff.net>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>
  4. archive: refactor list of archive formats

    peff authored and gitster committed Jun 22, 2011
    Most of the tar and zip code was nicely split out into two
    abstracted files which knew only about their specific
    formats. The entry point to this code was a single "write
    archive" function.
    
    However, as these basic formats grow more complex (e.g., by
    handling multiple file extensions and format names), a
    static list of the entry point functions won't be enough.
    Instead, let's provide a way for the tar and zip code to
    tell the main archive code what they support by registering
    archiver names and functions.
    
    Signed-off-by: Jeff King <peff@peff.net>
    Signed-off-by: Junio C Hamano <gitster@pobox.com>