builtin/multi-pack-index.c

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