builtin/multi-pack-index.c

   1 #include "builtin.h"
   2 #include "abspath.h"
   3 #include "config.h"
   4 #include "environment.h"
   5 #include "gettext.h"
   6 #include "parse-options.h"
   7 #include "midx.h"
   8 #include "strbuf.h"
   9 #include "trace2.h"
  10 #include "object-store-ll.h"
  11 #include "replace-object.h"
  12
  13 #define BUILTIN_MIDX_WRITE_USAGE \
  14         N_("git multi-pack-index [<options>] write [--preferred-pack=<pack>]" \
  15            "[--refs-snapshot=<path>]")
  16
  17 #define BUILTIN_MIDX_VERIFY_USAGE \
  18         N_("git multi-pack-index [<options>] verify")
  19
  20 #define BUILTIN_MIDX_EXPIRE_USAGE \
  21         N_("git multi-pack-index [<options>] expire")
  22
  23 #define BUILTIN_MIDX_REPACK_USAGE \
  24         N_("git multi-pack-index [<options>] repack [--batch-size=<size>]")
  25
  26 static char const * const builtin_multi_pack_index_write_usage[] = {
  27         BUILTIN_MIDX_WRITE_USAGE,
  28         NULL
  29 };
  30 static char const * const builtin_multi_pack_index_verify_usage[] = {
  31         BUILTIN_MIDX_VERIFY_USAGE,
  32         NULL
  33 };
  34 static char const * const builtin_multi_pack_index_expire_usage[] = {
  35         BUILTIN_MIDX_EXPIRE_USAGE,
  36         NULL
  37 };
  38 static char const * const builtin_multi_pack_index_repack_usage[] = {
  39         BUILTIN_MIDX_REPACK_USAGE,
  40         NULL
  41 };
  42 static char const * const builtin_multi_pack_index_usage[] = {
  43         BUILTIN_MIDX_WRITE_USAGE,
  44         BUILTIN_MIDX_VERIFY_USAGE,
  45         BUILTIN_MIDX_EXPIRE_USAGE,
  46         BUILTIN_MIDX_REPACK_USAGE,
  47         NULL
  48 };
  49
  50 static struct opts_multi_pack_index {
  51         char *object_dir;
  52         const char *preferred_pack;
  53         char *refs_snapshot;
  54         unsigned long batch_size;
  55         unsigned flags;
  56         int stdin_packs;
  57 } opts;
  58
  59
  60 static int parse_object_dir(const struct option *opt, const char *arg,
  61                             int unset)
  62 {
  63         char **value = opt->value;
  64         free(*value);
  65         if (unset)
  66                 *value = xstrdup(get_object_directory());
  67         else
  68                 *value = real_pathdup(arg, 1);
  69         return 0;
  70 }
  71
  72 static struct option common_opts[] = {
  73         OPT_CALLBACK(0, "object-dir", &opts.object_dir,
  74           N_("directory"),
  75           N_("object directory containing set of packfile and pack-index pairs"),
  76           parse_object_dir),
  77         OPT_END(),
  78 };
  79
  80 static struct option *add_common_options(struct option *prev)
  81 {
  82         return parse_options_concat(common_opts, prev);
  83 }
  84
  85 static int git_multi_pack_index_write_config(const char *var, const char *value,
  86                                              const struct config_context *ctx UNUSED,
  87                                              void *cb UNUSED)
  88 {
  89         if (!strcmp(var, "pack.writebitmaphashcache")) {
  90                 if (git_config_bool(var, value))
  91                         opts.flags |= MIDX_WRITE_BITMAP_HASH_CACHE;
  92                 else
  93                         opts.flags &= ~MIDX_WRITE_BITMAP_HASH_CACHE;
  94         }
  95
  96         if (!strcmp(var, "pack.writebitmaplookuptable")) {
  97                 if (git_config_bool(var, value))
  98                         opts.flags |= MIDX_WRITE_BITMAP_LOOKUP_TABLE;
  99                 else
 100                         opts.flags &= ~MIDX_WRITE_BITMAP_LOOKUP_TABLE;
 101         }
 102
 103         /*
 104          * We should never make a fall-back call to 'git_default_config', since
 105          * this was already called in 'cmd_multi_pack_index()'.
 106          */
 107         return 0;
 108 }
 109
 110 static void read_packs_from_stdin(struct string_list *to)
 111 {
 112         struct strbuf buf = STRBUF_INIT;
 113         while (strbuf_getline(&buf, stdin) != EOF)
 114                 string_list_append(to, buf.buf);
 115         string_list_sort(to);
 116
 117         strbuf_release(&buf);
 118 }
 119
 120 static int cmd_multi_pack_index_write(int argc, const char **argv,
 121                                       const char *prefix)
 122 {
 123         struct option *options;
 124         static struct option builtin_multi_pack_index_write_options[] = {
 125                 OPT_STRING(0, "preferred-pack", &opts.preferred_pack,
 126                            N_("preferred-pack"),
 127                            N_("pack for reuse when computing a multi-pack bitmap")),
 128                 OPT_BIT(0, "bitmap", &opts.flags, N_("write multi-pack bitmap"),
 129                         MIDX_WRITE_BITMAP | MIDX_WRITE_REV_INDEX),
 130                 OPT_BIT(0, "progress", &opts.flags,
 131                         N_("force progress reporting"), MIDX_PROGRESS),
 132                 OPT_BOOL(0, "stdin-packs", &opts.stdin_packs,
 133                          N_("write multi-pack index containing only given indexes")),
 134                 OPT_FILENAME(0, "refs-snapshot", &opts.refs_snapshot,
 135                              N_("refs snapshot for selecting bitmap commits")),
 136                 OPT_END(),
 137         };
 138         int ret;
 139
 140         opts.flags |= MIDX_WRITE_BITMAP_HASH_CACHE;
 141
 142         git_config(git_multi_pack_index_write_config, NULL);
 143
 144         options = add_common_options(builtin_multi_pack_index_write_options);
 145
 146         trace2_cmd_mode(argv[0]);
 147
 148         if (isatty(2))
 149                 opts.flags |= MIDX_PROGRESS;
 150         argc = parse_options(argc, argv, prefix,
 151                              options, builtin_multi_pack_index_write_usage,
 152                              0);
 153         if (argc)
 154                 usage_with_options(builtin_multi_pack_index_write_usage,
 155                                    options);
 156
 157         FREE_AND_NULL(options);
 158
 159         if (opts.stdin_packs) {
 160                 struct string_list packs = STRING_LIST_INIT_DUP;
 161
 162                 read_packs_from_stdin(&packs);
 163
 164                 ret = write_midx_file_only(opts.object_dir, &packs,
 165                                            opts.preferred_pack,
 166                                            opts.refs_snapshot, opts.flags);
 167
 168                 string_list_clear(&packs, 0);
 169                 free(opts.refs_snapshot);
 170
 171                 return ret;
 172
 173         }
 174
 175         ret = write_midx_file(opts.object_dir, opts.preferred_pack,
 176                               opts.refs_snapshot, opts.flags);
 177
 178         free(opts.refs_snapshot);
 179         return ret;
 180 }
 181
 182 static int cmd_multi_pack_index_verify(int argc, const char **argv,
 183                                        const char *prefix)
 184 {
 185         struct option *options;
 186         static struct option builtin_multi_pack_index_verify_options[] = {
 187                 OPT_BIT(0, "progress", &opts.flags,
 188                         N_("force progress reporting"), MIDX_PROGRESS),
 189                 OPT_END(),
 190         };
 191         options = add_common_options(builtin_multi_pack_index_verify_options);
 192
 193         trace2_cmd_mode(argv[0]);
 194
 195         if (isatty(2))
 196                 opts.flags |= MIDX_PROGRESS;
 197         argc = parse_options(argc, argv, prefix,
 198                              options, builtin_multi_pack_index_verify_usage,
 199                              0);
 200         if (argc)
 201                 usage_with_options(builtin_multi_pack_index_verify_usage,
 202                                    options);
 203
 204         FREE_AND_NULL(options);
 205
 206         return verify_midx_file(the_repository, opts.object_dir, opts.flags);
 207 }
 208
 209 static int cmd_multi_pack_index_expire(int argc, const char **argv,
 210                                        const char *prefix)
 211 {
 212         struct option *options;
 213         static struct option builtin_multi_pack_index_expire_options[] = {
 214                 OPT_BIT(0, "progress", &opts.flags,
 215                         N_("force progress reporting"), MIDX_PROGRESS),
 216                 OPT_END(),
 217         };
 218         options = add_common_options(builtin_multi_pack_index_expire_options);
 219
 220         trace2_cmd_mode(argv[0]);
 221
 222         if (isatty(2))
 223                 opts.flags |= MIDX_PROGRESS;
 224         argc = parse_options(argc, argv, prefix,
 225                              options, builtin_multi_pack_index_expire_usage,
 226                              0);
 227         if (argc)
 228                 usage_with_options(builtin_multi_pack_index_expire_usage,
 229                                    options);
 230
 231         FREE_AND_NULL(options);
 232
 233         return expire_midx_packs(the_repository, opts.object_dir, opts.flags);
 234 }
 235
 236 static int cmd_multi_pack_index_repack(int argc, const char **argv,
 237                                        const char *prefix)
 238 {
 239         struct option *options;
 240         static struct option builtin_multi_pack_index_repack_options[] = {
 241                 OPT_MAGNITUDE(0, "batch-size", &opts.batch_size,
 242                   N_("during repack, collect pack-files of smaller size into a batch that is larger than this size")),
 243                 OPT_BIT(0, "progress", &opts.flags,
 244                   N_("force progress reporting"), MIDX_PROGRESS),
 245                 OPT_END(),
 246         };
 247
 248         options = add_common_options(builtin_multi_pack_index_repack_options);
 249
 250         trace2_cmd_mode(argv[0]);
 251
 252         if (isatty(2))
 253                 opts.flags |= MIDX_PROGRESS;
 254         argc = parse_options(argc, argv, prefix,
 255                              options,
 256                              builtin_multi_pack_index_repack_usage,
 257                              0);
 258         if (argc)
 259                 usage_with_options(builtin_multi_pack_index_repack_usage,
 260                                    options);
 261
 262         FREE_AND_NULL(options);
 263
 264         return midx_repack(the_repository, opts.object_dir,
 265                            (size_t)opts.batch_size, opts.flags);
 266 }
 267
 268 int cmd_multi_pack_index(int argc, const char **argv,
 269                          const char *prefix)
 270 {
 271         int res;
 272         parse_opt_subcommand_fn *fn = NULL;
 273         struct option builtin_multi_pack_index_options[] = {
 274                 OPT_SUBCOMMAND("repack", &fn, cmd_multi_pack_index_repack),
 275                 OPT_SUBCOMMAND("write", &fn, cmd_multi_pack_index_write),
 276                 OPT_SUBCOMMAND("verify", &fn, cmd_multi_pack_index_verify),
 277                 OPT_SUBCOMMAND("expire", &fn, cmd_multi_pack_index_expire),
 278                 OPT_END(),
 279         };
 280         struct option *options = parse_options_concat(builtin_multi_pack_index_options, common_opts);
 281
 282         disable_replace_refs();
 283
 284         git_config(git_default_config, NULL);
 285
 286         if (the_repository &&
 287             the_repository->objects &&
 288             the_repository->objects->odb)
 289                 opts.object_dir = xstrdup(the_repository->objects->odb->path);
 290
 291         argc = parse_options(argc, argv, prefix, options,
 292                              builtin_multi_pack_index_usage, 0);
 293         FREE_AND_NULL(options);
 294
 295         res = fn(argc, argv, prefix);
 296
 297         free(opts.object_dir);
 298         return res;
 299 }