builtin/bundle.c

   1 #include "builtin.h"
   2 #include "abspath.h"
   3 #include "gettext.h"
   4 #include "setup.h"
   5 #include "strvec.h"
   6 #include "parse-options.h"
   7 #include "pkt-line.h"
   8 #include "repository.h"
   9 #include "bundle.h"
  10
  11 /*
  12  * Basic handler for bundle files to connect repositories via sneakernet.
  13  * Invocation must include action.
  14  * This function can create a bundle or provide information on an existing
  15  * bundle supporting "fetch", "pull", and "ls-remote".
  16  */
  17
  18 #define BUILTIN_BUNDLE_CREATE_USAGE \
  19         N_("git bundle create [-q | --quiet | --progress]\n" \
  20            "                  [--version=<version>] <file> <git-rev-list-args>")
  21 #define BUILTIN_BUNDLE_VERIFY_USAGE \
  22         N_("git bundle verify [-q | --quiet] <file>")
  23 #define BUILTIN_BUNDLE_LIST_HEADS_USAGE \
  24         N_("git bundle list-heads <file> [<refname>...]")
  25 #define BUILTIN_BUNDLE_UNBUNDLE_USAGE \
  26         N_("git bundle unbundle [--progress] <file> [<refname>...]")
  27
  28 static char const * const builtin_bundle_usage[] = {
  29         BUILTIN_BUNDLE_CREATE_USAGE,
  30         BUILTIN_BUNDLE_VERIFY_USAGE,
  31         BUILTIN_BUNDLE_LIST_HEADS_USAGE,
  32         BUILTIN_BUNDLE_UNBUNDLE_USAGE,
  33         NULL,
  34 };
  35
  36 static const char * const builtin_bundle_create_usage[] = {
  37         BUILTIN_BUNDLE_CREATE_USAGE,
  38         NULL
  39 };
  40
  41 static const char * const builtin_bundle_verify_usage[] = {
  42         BUILTIN_BUNDLE_VERIFY_USAGE,
  43         NULL
  44 };
  45
  46 static const char * const builtin_bundle_list_heads_usage[] = {
  47         BUILTIN_BUNDLE_LIST_HEADS_USAGE,
  48         NULL
  49 };
  50
  51 static const char * const builtin_bundle_unbundle_usage[] = {
  52         BUILTIN_BUNDLE_UNBUNDLE_USAGE,
  53         NULL
  54 };
  55
  56 static int parse_options_cmd_bundle(int argc,
  57                 const char **argv,
  58                 const char* prefix,
  59                 const char * const usagestr[],
  60                 const struct option options[],
  61                 char **bundle_file) {
  62         argc = parse_options(argc, argv, NULL, options, usagestr,
  63                              PARSE_OPT_STOP_AT_NON_OPTION);
  64         if (!argc)
  65                 usage_msg_opt(_("need a <file> argument"), usagestr, options);
  66         *bundle_file = prefix_filename_except_for_dash(prefix, argv[0]);
  67         return argc;
  68 }
  69
  70 static int cmd_bundle_create(int argc, const char **argv, const char *prefix) {
  71         struct strvec pack_opts = STRVEC_INIT;
  72         int version = -1;
  73         int ret;
  74         struct option options[] = {
  75                 OPT_PASSTHRU_ARGV('q', "quiet", &pack_opts, NULL,
  76                                   N_("do not show progress meter"),
  77                                   PARSE_OPT_NOARG),
  78                 OPT_PASSTHRU_ARGV(0, "progress", &pack_opts, NULL,
  79                                   N_("show progress meter"),
  80                                   PARSE_OPT_NOARG),
  81                 OPT_PASSTHRU_ARGV(0, "all-progress", &pack_opts, NULL,
  82                                   N_("historical; same as --progress"),
  83                                   PARSE_OPT_NOARG | PARSE_OPT_HIDDEN),
  84                 OPT_PASSTHRU_ARGV(0, "all-progress-implied", &pack_opts, NULL,
  85                                   N_("historical; does nothing"),
  86                                   PARSE_OPT_NOARG | PARSE_OPT_HIDDEN),
  87                 OPT_INTEGER(0, "version", &version,
  88                             N_("specify bundle format version")),
  89                 OPT_END()
  90         };
  91         char *bundle_file;
  92
  93         if (isatty(STDERR_FILENO))
  94                 strvec_push(&pack_opts, "--progress");
  95         strvec_push(&pack_opts, "--all-progress-implied");
  96
  97         argc = parse_options_cmd_bundle(argc, argv, prefix,
  98                         builtin_bundle_create_usage, options, &bundle_file);
  99         /* bundle internals use argv[1] as further parameters */
 100
 101         if (!startup_info->have_repository)
 102                 die(_("Need a repository to create a bundle."));
 103         ret = !!create_bundle(the_repository, bundle_file, argc, argv, &pack_opts, version);
 104         strvec_clear(&pack_opts);
 105         free(bundle_file);
 106         return ret;
 107 }
 108
 109 /*
 110  * Similar to read_bundle_header(), but handle "-" as stdin.
 111  */
 112 static int open_bundle(const char *path, struct bundle_header *header,
 113                        const char **name)
 114 {
 115         if (!strcmp(path, "-")) {
 116                 if (name)
 117                         *name = "<stdin>";
 118                 return read_bundle_header_fd(0, header, "<stdin>");
 119         }
 120
 121         if (name)
 122                 *name = path;
 123         return read_bundle_header(path, header);
 124 }
 125
 126 static int cmd_bundle_verify(int argc, const char **argv, const char *prefix) {
 127         struct bundle_header header = BUNDLE_HEADER_INIT;
 128         int bundle_fd = -1;
 129         int quiet = 0;
 130         int ret;
 131         struct option options[] = {
 132                 OPT_BOOL('q', "quiet", &quiet,
 133                             N_("do not show bundle details")),
 134                 OPT_END()
 135         };
 136         char *bundle_file;
 137         const char *name;
 138
 139         argc = parse_options_cmd_bundle(argc, argv, prefix,
 140                         builtin_bundle_verify_usage, options, &bundle_file);
 141         /* bundle internals use argv[1] as further parameters */
 142
 143         if ((bundle_fd = open_bundle(bundle_file, &header, &name)) < 0) {
 144                 ret = 1;
 145                 goto cleanup;
 146         }
 147         close(bundle_fd);
 148         if (verify_bundle(the_repository, &header,
 149                           quiet ? VERIFY_BUNDLE_QUIET : VERIFY_BUNDLE_VERBOSE)) {
 150                 ret = 1;
 151                 goto cleanup;
 152         }
 153
 154         fprintf(stderr, _("%s is okay\n"), name);
 155         ret = 0;
 156 cleanup:
 157         free(bundle_file);
 158         bundle_header_release(&header);
 159         return ret;
 160 }
 161
 162 static int cmd_bundle_list_heads(int argc, const char **argv, const char *prefix) {
 163         struct bundle_header header = BUNDLE_HEADER_INIT;
 164         int bundle_fd = -1;
 165         int ret;
 166         struct option options[] = {
 167                 OPT_END()
 168         };
 169         char *bundle_file;
 170
 171         argc = parse_options_cmd_bundle(argc, argv, prefix,
 172                         builtin_bundle_list_heads_usage, options, &bundle_file);
 173         /* bundle internals use argv[1] as further parameters */
 174
 175         if ((bundle_fd = open_bundle(bundle_file, &header, NULL)) < 0) {
 176                 ret = 1;
 177                 goto cleanup;
 178         }
 179         close(bundle_fd);
 180         ret = !!list_bundle_refs(&header, argc, argv);
 181 cleanup:
 182         free(bundle_file);
 183         bundle_header_release(&header);
 184         return ret;
 185 }
 186
 187 static int cmd_bundle_unbundle(int argc, const char **argv, const char *prefix) {
 188         struct bundle_header header = BUNDLE_HEADER_INIT;
 189         int bundle_fd = -1;
 190         int ret;
 191         int progress = isatty(2);
 192
 193         struct option options[] = {
 194                 OPT_BOOL(0, "progress", &progress,
 195                          N_("show progress meter")),
 196                 OPT_END()
 197         };
 198         char *bundle_file;
 199         struct strvec extra_index_pack_args = STRVEC_INIT;
 200
 201         argc = parse_options_cmd_bundle(argc, argv, prefix,
 202                         builtin_bundle_unbundle_usage, options, &bundle_file);
 203         /* bundle internals use argv[1] as further parameters */
 204
 205         if ((bundle_fd = open_bundle(bundle_file, &header, NULL)) < 0) {
 206                 ret = 1;
 207                 goto cleanup;
 208         }
 209         if (!startup_info->have_repository)
 210                 die(_("Need a repository to unbundle."));
 211         if (progress)
 212                 strvec_pushl(&extra_index_pack_args, "-v", "--progress-title",
 213                              _("Unbundling objects"), NULL);
 214         ret = !!unbundle(the_repository, &header, bundle_fd,
 215                          &extra_index_pack_args, 0) ||
 216                 list_bundle_refs(&header, argc, argv);
 217         bundle_header_release(&header);
 218 cleanup:
 219         free(bundle_file);
 220         return ret;
 221 }
 222
 223 int cmd_bundle(int argc, const char **argv, const char *prefix)
 224 {
 225         parse_opt_subcommand_fn *fn = NULL;
 226         struct option options[] = {
 227                 OPT_SUBCOMMAND("create", &fn, cmd_bundle_create),
 228                 OPT_SUBCOMMAND("verify", &fn, cmd_bundle_verify),
 229                 OPT_SUBCOMMAND("list-heads", &fn, cmd_bundle_list_heads),
 230                 OPT_SUBCOMMAND("unbundle", &fn, cmd_bundle_unbundle),
 231                 OPT_END()
 232         };
 233
 234         argc = parse_options(argc, argv, prefix, options, builtin_bundle_usage,
 235                              0);
 236
 237         packet_trace_identity("bundle");
 238
 239         return !!fn(argc, argv, prefix);
 240 }