t/helper/test-ref-store.c

   1 #include "test-tool.h"
   2 #include "cache.h"
   3 #include "refs.h"
   4 #include "worktree.h"
   5 #include "object-store.h"
   6 #include "repository.h"
   7
   8 static const char *notnull(const char *arg, const char *name)
   9 {
  10         if (!arg)
  11                 die("%s required", name);
  12         return arg;
  13 }
  14
  15 static unsigned int arg_flags(const char *arg, const char *name)
  16 {
  17         return atoi(notnull(arg, name));
  18 }
  19
  20 static const char **get_store(const char **argv, struct ref_store **refs)
  21 {
  22         const char *gitdir;
  23
  24         if (!argv[0]) {
  25                 die("ref store required");
  26         } else if (!strcmp(argv[0], "main")) {
  27                 *refs = get_main_ref_store(the_repository);
  28         } else if (skip_prefix(argv[0], "submodule:", &gitdir)) {
  29                 struct strbuf sb = STRBUF_INIT;
  30                 int ret;
  31
  32                 ret = strbuf_git_path_submodule(&sb, gitdir, "objects/");
  33                 if (ret)
  34                         die("strbuf_git_path_submodule failed: %d", ret);
  35                 add_to_alternates_memory(sb.buf);
  36                 strbuf_release(&sb);
  37
  38                 *refs = get_submodule_ref_store(gitdir);
  39         } else if (skip_prefix(argv[0], "worktree:", &gitdir)) {
  40                 struct worktree **p, **worktrees = get_worktrees();
  41
  42                 for (p = worktrees; *p; p++) {
  43                         struct worktree *wt = *p;
  44
  45                         if (!wt->id) {
  46                                 /* special case for main worktree */
  47                                 if (!strcmp(gitdir, "main"))
  48                                         break;
  49                         } else if (!strcmp(gitdir, wt->id))
  50                                 break;
  51                 }
  52                 if (!*p)
  53                         die("no such worktree: %s", gitdir);
  54
  55                 *refs = get_worktree_ref_store(*p);
  56         } else
  57                 die("unknown backend %s", argv[0]);
  58
  59         if (!*refs)
  60                 die("no ref store");
  61
  62         /* consume store-specific optional arguments if needed */
  63
  64         return argv + 1;
  65 }
  66
  67
  68 static int cmd_pack_refs(struct ref_store *refs, const char **argv)
  69 {
  70         unsigned int flags = arg_flags(*argv++, "flags");
  71
  72         return refs_pack_refs(refs, flags);
  73 }
  74
  75 static int cmd_create_symref(struct ref_store *refs, const char **argv)
  76 {
  77         const char *refname = notnull(*argv++, "refname");
  78         const char *target = notnull(*argv++, "target");
  79         const char *logmsg = *argv++;
  80
  81         return refs_create_symref(refs, refname, target, logmsg);
  82 }
  83
  84 static int cmd_delete_refs(struct ref_store *refs, const char **argv)
  85 {
  86         unsigned int flags = arg_flags(*argv++, "flags");
  87         const char *msg = *argv++;
  88         struct string_list refnames = STRING_LIST_INIT_NODUP;
  89
  90         while (*argv)
  91                 string_list_append(&refnames, *argv++);
  92
  93         return refs_delete_refs(refs, msg, &refnames, flags);
  94 }
  95
  96 static int cmd_rename_ref(struct ref_store *refs, const char **argv)
  97 {
  98         const char *oldref = notnull(*argv++, "oldref");
  99         const char *newref = notnull(*argv++, "newref");
 100         const char *logmsg = *argv++;
 101
 102         return refs_rename_ref(refs, oldref, newref, logmsg);
 103 }
 104
 105 static int each_ref(const char *refname, const struct object_id *oid,
 106                     int flags, void *cb_data)
 107 {
 108         printf("%s %s 0x%x\n", oid_to_hex(oid), refname, flags);
 109         return 0;
 110 }
 111
 112 static int cmd_for_each_ref(struct ref_store *refs, const char **argv)
 113 {
 114         const char *prefix = notnull(*argv++, "prefix");
 115
 116         return refs_for_each_ref_in(refs, prefix, each_ref, NULL);
 117 }
 118
 119 static int cmd_resolve_ref(struct ref_store *refs, const char **argv)
 120 {
 121         struct object_id oid = *null_oid();
 122         const char *refname = notnull(*argv++, "refname");
 123         int resolve_flags = arg_flags(*argv++, "resolve-flags");
 124         int flags;
 125         const char *ref;
 126         int ignore_errno;
 127
 128         ref = refs_werrres_ref_unsafe(refs, refname, resolve_flags,
 129                                       &oid, &flags, &ignore_errno);
 130         printf("%s %s 0x%x\n", oid_to_hex(&oid), ref ? ref : "(null)", flags);
 131         return ref ? 0 : 1;
 132 }
 133
 134 static int cmd_verify_ref(struct ref_store *refs, const char **argv)
 135 {
 136         const char *refname = notnull(*argv++, "refname");
 137         struct strbuf err = STRBUF_INIT;
 138         int ret;
 139
 140         ret = refs_verify_refname_available(refs, refname, NULL, NULL, &err);
 141         if (err.len)
 142                 puts(err.buf);
 143         return ret;
 144 }
 145
 146 static int cmd_for_each_reflog(struct ref_store *refs, const char **argv)
 147 {
 148         return refs_for_each_reflog(refs, each_ref, NULL);
 149 }
 150
 151 static int each_reflog(struct object_id *old_oid, struct object_id *new_oid,
 152                        const char *committer, timestamp_t timestamp,
 153                        int tz, const char *msg, void *cb_data)
 154 {
 155         printf("%s %s %s %"PRItime" %d %s\n",
 156                oid_to_hex(old_oid), oid_to_hex(new_oid),
 157                committer, timestamp, tz, msg);
 158         return 0;
 159 }
 160
 161 static int cmd_for_each_reflog_ent(struct ref_store *refs, const char **argv)
 162 {
 163         const char *refname = notnull(*argv++, "refname");
 164
 165         return refs_for_each_reflog_ent(refs, refname, each_reflog, refs);
 166 }
 167
 168 static int cmd_for_each_reflog_ent_reverse(struct ref_store *refs, const char **argv)
 169 {
 170         const char *refname = notnull(*argv++, "refname");
 171
 172         return refs_for_each_reflog_ent_reverse(refs, refname, each_reflog, refs);
 173 }
 174
 175 static int cmd_reflog_exists(struct ref_store *refs, const char **argv)
 176 {
 177         const char *refname = notnull(*argv++, "refname");
 178
 179         return !refs_reflog_exists(refs, refname);
 180 }
 181
 182 static int cmd_create_reflog(struct ref_store *refs, const char **argv)
 183 {
 184         const char *refname = notnull(*argv++, "refname");
 185         int force_create = arg_flags(*argv++, "force-create");
 186         struct strbuf err = STRBUF_INIT;
 187         int ret;
 188
 189         ret = refs_create_reflog(refs, refname, force_create, &err);
 190         if (err.len)
 191                 puts(err.buf);
 192         return ret;
 193 }
 194
 195 static int cmd_delete_reflog(struct ref_store *refs, const char **argv)
 196 {
 197         const char *refname = notnull(*argv++, "refname");
 198
 199         return refs_delete_reflog(refs, refname);
 200 }
 201
 202 static int cmd_reflog_expire(struct ref_store *refs, const char **argv)
 203 {
 204         die("not supported yet");
 205 }
 206
 207 static int cmd_delete_ref(struct ref_store *refs, const char **argv)
 208 {
 209         const char *msg = notnull(*argv++, "msg");
 210         const char *refname = notnull(*argv++, "refname");
 211         const char *sha1_buf = notnull(*argv++, "old-sha1");
 212         unsigned int flags = arg_flags(*argv++, "flags");
 213         struct object_id old_oid;
 214
 215         if (get_oid_hex(sha1_buf, &old_oid))
 216                 die("not sha-1");
 217
 218         return refs_delete_ref(refs, msg, refname, &old_oid, flags);
 219 }
 220
 221 static int cmd_update_ref(struct ref_store *refs, const char **argv)
 222 {
 223         const char *msg = notnull(*argv++, "msg");
 224         const char *refname = notnull(*argv++, "refname");
 225         const char *new_sha1_buf = notnull(*argv++, "new-sha1");
 226         const char *old_sha1_buf = notnull(*argv++, "old-sha1");
 227         unsigned int flags = arg_flags(*argv++, "flags");
 228         struct object_id old_oid;
 229         struct object_id new_oid;
 230
 231         if (get_oid_hex(old_sha1_buf, &old_oid) ||
 232             get_oid_hex(new_sha1_buf, &new_oid))
 233                 die("not sha-1");
 234
 235         return refs_update_ref(refs, msg, refname,
 236                                &new_oid, &old_oid,
 237                                flags, UPDATE_REFS_DIE_ON_ERR);
 238 }
 239
 240 struct command {
 241         const char *name;
 242         int (*func)(struct ref_store *refs, const char **argv);
 243 };
 244
 245 static struct command commands[] = {
 246         { "pack-refs", cmd_pack_refs },
 247         { "create-symref", cmd_create_symref },
 248         { "delete-refs", cmd_delete_refs },
 249         { "rename-ref", cmd_rename_ref },
 250         { "for-each-ref", cmd_for_each_ref },
 251         { "resolve-ref", cmd_resolve_ref },
 252         { "verify-ref", cmd_verify_ref },
 253         { "for-each-reflog", cmd_for_each_reflog },
 254         { "for-each-reflog-ent", cmd_for_each_reflog_ent },
 255         { "for-each-reflog-ent-reverse", cmd_for_each_reflog_ent_reverse },
 256         { "reflog-exists", cmd_reflog_exists },
 257         { "create-reflog", cmd_create_reflog },
 258         { "delete-reflog", cmd_delete_reflog },
 259         { "reflog-expire", cmd_reflog_expire },
 260         /*
 261          * backend transaction functions can't be tested separately
 262          */
 263         { "delete-ref", cmd_delete_ref },
 264         { "update-ref", cmd_update_ref },
 265         { NULL, NULL }
 266 };
 267
 268 int cmd__ref_store(int argc, const char **argv)
 269 {
 270         struct ref_store *refs;
 271         const char *func;
 272         struct command *cmd;
 273
 274         setup_git_directory();
 275
 276         argv = get_store(argv + 1, &refs);
 277
 278         func = *argv++;
 279         if (!func)
 280                 die("ref function required");
 281         for (cmd = commands; cmd->name; cmd++) {
 282                 if (!strcmp(func, cmd->name))
 283                         return cmd->func(refs, argv);
 284         }
 285         die("unknown function %s", func);
 286         return 0;
 287 }