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         const 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
 139         opts.flags |= MIDX_WRITE_BITMAP_HASH_CACHE;
 140
 141         git_config(git_multi_pack_index_write_config, NULL);
 142
 143         options = add_common_options(builtin_multi_pack_index_write_options);
 144
 145         trace2_cmd_mode(argv[0]);
 146
 147         if (isatty(2))
 148                 opts.flags |= MIDX_PROGRESS;
 149         argc = parse_options(argc, argv, prefix,
 150                              options, builtin_multi_pack_index_write_usage,
 151                              0);
 152         if (argc)
 153                 usage_with_options(builtin_multi_pack_index_write_usage,
 154                                    options);
 155
 156         FREE_AND_NULL(options);
 157
 158         if (opts.stdin_packs) {
 159                 struct string_list packs = STRING_LIST_INIT_DUP;
 160                 int ret;
 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
 170                 return ret;
 171
 172         }
 173         return write_midx_file(opts.object_dir, opts.preferred_pack,
 174                                opts.refs_snapshot, opts.flags);
 175 }
 176
 177 static int cmd_multi_pack_index_verify(int argc, const char **argv,
 178                                        const char *prefix)
 179 {
 180         struct option *options;
 181         static struct option builtin_multi_pack_index_verify_options[] = {
 182                 OPT_BIT(0, "progress", &opts.flags,
 183                         N_("force progress reporting"), MIDX_PROGRESS),
 184                 OPT_END(),
 185         };
 186         options = add_common_options(builtin_multi_pack_index_verify_options);
 187
 188         trace2_cmd_mode(argv[0]);
 189
 190         if (isatty(2))
 191                 opts.flags |= MIDX_PROGRESS;
 192         argc = parse_options(argc, argv, prefix,
 193                              options, builtin_multi_pack_index_verify_usage,
 194                              0);
 195         if (argc)
 196                 usage_with_options(builtin_multi_pack_index_verify_usage,
 197                                    options);
 198
 199         FREE_AND_NULL(options);
 200
 201         return verify_midx_file(the_repository, opts.object_dir, opts.flags);
 202 }
 203
 204 static int cmd_multi_pack_index_expire(int argc, const char **argv,
 205                                        const char *prefix)
 206 {
 207         struct option *options;
 208         static struct option builtin_multi_pack_index_expire_options[] = {
 209                 OPT_BIT(0, "progress", &opts.flags,
 210                         N_("force progress reporting"), MIDX_PROGRESS),
 211                 OPT_END(),
 212         };
 213         options = add_common_options(builtin_multi_pack_index_expire_options);
 214
 215         trace2_cmd_mode(argv[0]);
 216
 217         if (isatty(2))
 218                 opts.flags |= MIDX_PROGRESS;
 219         argc = parse_options(argc, argv, prefix,
 220                              options, builtin_multi_pack_index_expire_usage,
 221                              0);
 222         if (argc)
 223                 usage_with_options(builtin_multi_pack_index_expire_usage,
 224                                    options);
 225
 226         FREE_AND_NULL(options);
 227
 228         return expire_midx_packs(the_repository, opts.object_dir, opts.flags);
 229 }
 230
 231 static int cmd_multi_pack_index_repack(int argc, const char **argv,
 232                                        const char *prefix)
 233 {
 234         struct option *options;
 235         static struct option builtin_multi_pack_index_repack_options[] = {
 236                 OPT_MAGNITUDE(0, "batch-size", &opts.batch_size,
 237                   N_("during repack, collect pack-files of smaller size into a batch that is larger than this size")),
 238                 OPT_BIT(0, "progress", &opts.flags,
 239                   N_("force progress reporting"), MIDX_PROGRESS),
 240                 OPT_END(),
 241         };
 242
 243         options = add_common_options(builtin_multi_pack_index_repack_options);
 244
 245         trace2_cmd_mode(argv[0]);
 246
 247         if (isatty(2))
 248                 opts.flags |= MIDX_PROGRESS;
 249         argc = parse_options(argc, argv, prefix,
 250                              options,
 251                              builtin_multi_pack_index_repack_usage,
 252                              0);
 253         if (argc)
 254                 usage_with_options(builtin_multi_pack_index_repack_usage,
 255                                    options);
 256
 257         FREE_AND_NULL(options);
 258
 259         return midx_repack(the_repository, opts.object_dir,
 260                            (size_t)opts.batch_size, opts.flags);
 261 }
 262
 263 int cmd_multi_pack_index(int argc, const char **argv,
 264                          const char *prefix)
 265 {
 266         int res;
 267         parse_opt_subcommand_fn *fn = NULL;
 268         struct option builtin_multi_pack_index_options[] = {
 269                 OPT_SUBCOMMAND("repack", &fn, cmd_multi_pack_index_repack),
 270                 OPT_SUBCOMMAND("write", &fn, cmd_multi_pack_index_write),
 271                 OPT_SUBCOMMAND("verify", &fn, cmd_multi_pack_index_verify),
 272                 OPT_SUBCOMMAND("expire", &fn, cmd_multi_pack_index_expire),
 273                 OPT_END(),
 274         };
 275         struct option *options = parse_options_concat(builtin_multi_pack_index_options, common_opts);
 276
 277         disable_replace_refs();
 278
 279         git_config(git_default_config, NULL);
 280
 281         if (the_repository &&
 282             the_repository->objects &&
 283             the_repository->objects->odb)
 284                 opts.object_dir = xstrdup(the_repository->objects->odb->path);
 285
 286         argc = parse_options(argc, argv, prefix, options,
 287                              builtin_multi_pack_index_usage, 0);
 288         FREE_AND_NULL(options);
 289
 290         res = fn(argc, argv, prefix);
 291
 292         free(opts.object_dir);
 293         return res;
 294 }