builtin/bundle.c

   1 #define USE_THE_REPOSITORY_VARIABLE
   2 #include "builtin.h"
   3 #include "abspath.h"
   4 #include "gettext.h"
   5 #include "setup.h"
   6 #include "strvec.h"
   7 #include "parse-options.h"
   8 #include "pkt-line.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 (!startup_info->have_repository) {
 144                 ret = error(_("need a repository to verify a bundle"));
 145                 goto cleanup;
 146         }
 147
 148         if ((bundle_fd = open_bundle(bundle_file, &header, &name)) < 0) {
 149                 ret = 1;
 150                 goto cleanup;
 151         }
 152         close(bundle_fd);
 153         if (verify_bundle(the_repository, &header,
 154                           quiet ? VERIFY_BUNDLE_QUIET : VERIFY_BUNDLE_VERBOSE)) {
 155                 ret = 1;
 156                 goto cleanup;
 157         }
 158
 159         fprintf(stderr, _("%s is okay\n"), name);
 160         ret = 0;
 161 cleanup:
 162         free(bundle_file);
 163         bundle_header_release(&header);
 164         return ret;
 165 }
 166
 167 static int cmd_bundle_list_heads(int argc, const char **argv, const char *prefix) {
 168         struct bundle_header header = BUNDLE_HEADER_INIT;
 169         int bundle_fd = -1;
 170         int ret;
 171         struct option options[] = {
 172                 OPT_END()
 173         };
 174         char *bundle_file;
 175
 176         argc = parse_options_cmd_bundle(argc, argv, prefix,
 177                         builtin_bundle_list_heads_usage, options, &bundle_file);
 178         /* bundle internals use argv[1] as further parameters */
 179
 180         if ((bundle_fd = open_bundle(bundle_file, &header, NULL)) < 0) {
 181                 ret = 1;
 182                 goto cleanup;
 183         }
 184         close(bundle_fd);
 185         ret = !!list_bundle_refs(&header, argc, argv);
 186 cleanup:
 187         free(bundle_file);
 188         bundle_header_release(&header);
 189         return ret;
 190 }
 191
 192 static int cmd_bundle_unbundle(int argc, const char **argv, const char *prefix) {
 193         struct bundle_header header = BUNDLE_HEADER_INIT;
 194         int bundle_fd = -1;
 195         int ret;
 196         int progress = isatty(2);
 197
 198         struct option options[] = {
 199                 OPT_BOOL(0, "progress", &progress,
 200                          N_("show progress meter")),
 201                 OPT_END()
 202         };
 203         char *bundle_file;
 204         struct strvec extra_index_pack_args = STRVEC_INIT;
 205
 206         argc = parse_options_cmd_bundle(argc, argv, prefix,
 207                         builtin_bundle_unbundle_usage, options, &bundle_file);
 208         /* bundle internals use argv[1] as further parameters */
 209
 210         if (!startup_info->have_repository)
 211                 die(_("Need a repository to unbundle."));
 212
 213         if ((bundle_fd = open_bundle(bundle_file, &header, NULL)) < 0) {
 214                 ret = 1;
 215                 goto cleanup;
 216         }
 217         if (progress)
 218                 strvec_pushl(&extra_index_pack_args, "-v", "--progress-title",
 219                              _("Unbundling objects"), NULL);
 220         ret = !!unbundle(the_repository, &header, bundle_fd,
 221                          &extra_index_pack_args, 0) ||
 222                 list_bundle_refs(&header, argc, argv);
 223         bundle_header_release(&header);
 224
 225 cleanup:
 226         strvec_clear(&extra_index_pack_args);
 227         free(bundle_file);
 228         return ret;
 229 }
 230
 231 int cmd_bundle(int argc,
 232                const char **argv,
 233                const char *prefix,
 234                struct repository *repo UNUSED)
 235 {
 236         parse_opt_subcommand_fn *fn = NULL;
 237         struct option options[] = {
 238                 OPT_SUBCOMMAND("create", &fn, cmd_bundle_create),
 239                 OPT_SUBCOMMAND("verify", &fn, cmd_bundle_verify),
 240                 OPT_SUBCOMMAND("list-heads", &fn, cmd_bundle_list_heads),
 241                 OPT_SUBCOMMAND("unbundle", &fn, cmd_bundle_unbundle),
 242                 OPT_END()
 243         };
 244
 245         argc = parse_options(argc, argv, prefix, options, builtin_bundle_usage,
 246                              0);
 247
 248         packet_trace_identity("bundle");
 249
 250         return !!fn(argc, argv, prefix);
 251 }