* Re: [PATCH] Port git-tag.sh to C.
From: Junio C Hamano @ 2007-06-09 18:26 UTC (permalink / raw)
To: Kristian Høgsberg; +Cc: git
In-Reply-To: <11813427591137-git-send-email-krh@redhat.com>
Kristian Høgsberg <krh@redhat.com> writes:
> Content-Type: TEXT/PLAIN; charset=ISO-8859-1
>
> From: Kristian Høgsberg <krh@redhat.com>
>
> A more or less straight-forward port of git-tag.sh to C.
>
> Signed-off-by: Kristian Høgsberg <krh@redhat.com>
> Cc: Johannes Schindelin <Johannes.Schindelin@gmx.de>
I think your name in your commit message is in UTF-8 but munged your
mail was mismarked as iso-8859-1.
> +static int launch_editor(const char *path, const char *template,
> + char *buffer, size_t size)
> +{
It would have been nicer to have this in editor.c or somesuch,
as other commands will be redone in C in the future.
We could do the moving later, but the problem is that later is
conditional: "if we are lucky enough to remember that we already
have this function in builtin-tag when doing so".
> + fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0644);
I would understand an argument to use 0666 (honor umask) or 0600
(this is a temporary file and others have no business looking at
it while an edit is in progress), but I cannot justify 0644.
> + fd = open(path, O_RDONLY, 0644);
Open for reading with mode ;-)?
> + if (fd == -1)
> + die("could not read %s.", path);
> + len = read_in_full(fd, buffer, size);
> + if (len < 0)
> + die("failed to read '%s', %m", path);
> + close(fd);
> +
> + blank_lines = 1;
> + for (i = 0, j = 0; i < len; i++) {
> ...
> + }
> +
> + if (buffer[j - 1] != '\n')
> + buffer[j++] = '\n';
> +
> + unlink(path);
> +
> + return j;
> +}
I really think this function needs to be refactored into three.
* A generic "spawn an editor with this initial seed template,
return the result of editing in memory and also give exit
status of the editor" function that does not take path
parameter (instead perhaps mkstemp a temporary file on your
own);
* A function that does what git-stripspace does in core;
* A function for builtin-tag to use, that calls the above two
and uses the result (e.g. "did the user kill the editor?
does the resulting buffer have any nonempty line?") to decide
what it does.
> +static void create_tag(const unsigned char *object, const char *tag,
> + const char *message, int sign, unsigned char *result)
> +{
> + enum object_type type;
> + char buffer[4096];
> + int header, body, total;
> +
> + type = sha1_object_info(object, NULL);
> + if (type <= 0)
> + die("bad object type.");
> +
> + header = snprintf(buffer, sizeof buffer,
> + "object %s\n"
> + "type %s\n"
> + "tag %s\n"
> + "tagger %s\n\n",
> + sha1_to_hex(object),
> + typename(type),
> + tag,
> + git_committer_info(1));
> +
> + if (message == NULL)
> + body = launch_editor(git_path("TAGMSG"), tag_template,
> + buffer + header, sizeof buffer - header);
> + else
> + body = snprintf(buffer + header, sizeof buffer - header,
> + "%s\n", message);
> +
> + if (body == 0)
> + die("no tag message?");
> +
> + if (header + body > sizeof buffer)
> + die("tag message too big.");
Two issues:
* It used to be a tag had limit of 8kB which was lifted some
time ago; now it is limited to 4kB. Fixing this implies that
the "launch editor and get results in core" function I
mentioned above may need to realloc, and probably the buffer
is better passed as (char *, ulong) pair as done everywhere
else (although we know this is text so you can pass only a
pointer and have the user run strlen() when needed).
* I do not see any validation on the value of "tag". Do we want
to allow passing "" to it? What about "my\ntag"?
^ permalink raw reply
* [PATCH] Change softrefs file format from text (82 bytes per entry) to binary (40 bytes per entry)
From: Johan Herland @ 2007-06-09 18:25 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Linus Torvalds
In-Reply-To: <200706092019.13185.johan@herland.net>
The text-based softrefs file format uses 82 bytes per entry (40 bytes
from_sha1 in hex, 1 byte SP, 40 bytes to_sha1 in hex, 1 byte LF).
The binary softrefs file format uses 40 bytes per entry (20 bytes
from_sha1, 20 bytes to_sha1).
Moving to a binary format increases performance slightly, but sacrifices
easy readability of the softrefs files.
Signed-off-by: Johan Herland <johan@herland.net>
---
To illustrate the change in performance from changing the softrefs file
format, I prepared a linux repo (holding 57274 commits) with 10 tag
objects, and created softrefs from every commit to every tag object
(572740 softrefs in total). The resulting softrefs db was 46964680 bytes
when using the text format, and 22909600 bytes when using the binary
format. The experiment was done on a 32-bit Intel Pentium 4
(3 GHz w/HyperThreading) with 1 GB RAM:
========
Operations on unsorted softrefs:
(572740 (10 per commit) entries in random/unsorted order)
========
Listing all softrefs
(sequential reading of unsorted softrefs file)
--------
[text format]
$ /usr/bin/time git softref --list > /dev/null
0.44user 0.02system 0:00.47elapsed 98%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+11786minor)pagefaults 0swaps
[binary format]
$ /usr/bin/time git softref --list > /dev/null
0.35user 0.01system 0:00.38elapsed 97%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+5913minor)pagefaults 0swaps
Listing HEAD's softrefs
(sequential reading of unsorted softrefs file)
--------
[text format]
$ /usr/bin/time git softref --list HEAD > /dev/null
0.11user 0.01system 0:00.14elapsed 94%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+11790minor)pagefaults 0swaps
[binary format]
$ /usr/bin/time git softref --list HEAD > /dev/null
0.02user 0.01system 0:00.03elapsed 97%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+5918minor)pagefaults 0swaps
Sorting softrefs
--------
[text format]
$ /usr/bin/time git softref --merge-unsorted
2.73user 4.97system 0:07.77elapsed 99%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+15833minor)pagefaults 0swaps
[binary format]
$ /usr/bin/time git softref --merge-unsorted
1.78user 5.00system 0:06.79elapsed 99%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+9961minor)pagefaults 0swaps
Sorting softrefs into existing sorted file
(throwing away duplicates)
--------
[text format]
$ /usr/bin/time git softref --merge-unsorted
3.49user 5.12system 0:08.64elapsed 99%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+27300minor)pagefaults 0swaps
[binary format]
$ /usr/bin/time git softref --merge-unsorted
2.03user 4.92system 0:07.05elapsed 98%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+15556minor)pagefaults 0swaps
========
Operations on sorted softrefs:
(572740 (10 per commit) entries in sorted order)
========
Listing all softrefs
(sequential reading of sorted softrefs file)
--------
[text format]
$ /usr/bin/time git softref --list > /dev/null
0.43user 0.02system 0:00.48elapsed 96%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+11786minor)pagefaults 0swaps
[binary format]
$ /usr/bin/time git softref --list > /dev/null
0.37user 0.00system 0:00.38elapsed 98%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+5914minor)pagefaults 0swaps
Listing HEAD's softrefs
(256-fanout followed by binary search in sorted softrefs file)
--------
[text format]
$/usr/bin/time git softref --list HEAD > /dev/null
0.00user 0.00system 0:00.00elapsed 0%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+334minor)pagefaults 0swaps
[binary format]
$ /usr/bin/time git softref --list HEAD > /dev/null
0.00user 0.00system 0:00.00elapsed 0%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+333minor)pagefaults 0swaps
Sorting softrefs
(no-op)
--------
[text format]
$ /usr/bin/time git softref --merge-unsorted
0.00user 0.00system 0:00.00elapsed 0%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+312minor)pagefaults 0swaps
[binary format]
$ /usr/bin/time git softref --merge-unsorted
0.00user 0.00system 0:00.00elapsed 100%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+312minor)pagefaults 0swaps
As expected, the binary format almost halved the number of pagefaults for
cases causing the entire softrefs db to be read (the reason for this, of
course, being the halved size of the db).
For the most common use case (looking up a given commit in a sorted db)
the binary format has no measurable effect on performance.
...Johan
Documentation/git-softref.txt | 6 ++--
softrefs.c | 78 +++++++++++------------------------------
softrefs.h | 7 ++--
3 files changed, 27 insertions(+), 64 deletions(-)
diff --git a/Documentation/git-softref.txt b/Documentation/git-softref.txt
index 6a3e13b..e21aaf3 100644
--- a/Documentation/git-softref.txt
+++ b/Documentation/git-softref.txt
@@ -93,9 +93,9 @@ Also, softrefs are stored in a way that makes it easy and quick to find all
the "to" objects reachable from a given "from" object.
The softrefs db consists of two files: `.git/softrefs.unsorted` and
-`.git/softrefs.sorted`. Both files use the same format; one softref per line
-of the form "`<from-sha1> <to-sha1>\n`". Each sha1 sum is 40 bytes long; this
-makes each entry exactly 82 bytes long.
+`.git/softrefs.sorted`. Both files use the same binary format; `<from-sha1>`
+followed by `<to-sha1>` per entry. Each sha1 sum is 20 bytes long; this
+makes each entry exactly 40 bytes long.
The entries in `.git/softrefs.sorted` are sorted on `<from-sha1>`, in order to
make lookup fast. This file is also known as the "sorted softrefs db".
diff --git a/softrefs.c b/softrefs.c
index c7308c8..8bb3a83 100644
--- a/softrefs.c
+++ b/softrefs.c
@@ -9,10 +9,8 @@ static const unsigned int MAX_UNSORTED_ENTRIES = 1000;
/* softref entry as it appears in a softrefs file */
struct softrefs_entry {
- char from_sha1_hex[40];
- char space;
- char to_sha1_hex[40];
- char lf;
+ unsigned char from_sha1[20];
+ unsigned char to_sha1[20];
};
/* simple encapsulation of a softrefs file */
@@ -106,8 +104,9 @@ static int write_entry(int fd, const struct softrefs_entry *entry)
if (write(fd, (const void *) entry, sizeof(struct softrefs_entry))
< sizeof(struct softrefs_entry))
{
- return error("Failed to write entry '%.40s -> %.40s' to softrefs file descriptor %i: %s",
- entry->from_sha1_hex, entry->to_sha1_hex,
+ return error("Failed to write entry '%s -> %s' to softrefs file descriptor %i: %s",
+ sha1_to_hex(entry->from_sha1),
+ sha1_to_hex(entry->to_sha1),
fd, strerror(errno));
}
return 0;
@@ -139,29 +138,13 @@ void deinit_softrefs_access()
internal_file = 0;
}
-/* comparison between a SHA1 sum and a softrefs entry */
-static int sha1_to_entry_cmp(
- const unsigned char *from_sha1, const struct softrefs_entry *entry)
-{
- unsigned char sha1[20];
- get_sha1_hex(entry->from_sha1_hex, sha1);
- return hashcmp(from_sha1, sha1);
-}
-
/* comparison between softrefs entries */
static int softrefs_entry_cmp(
const struct softrefs_entry *a, const struct softrefs_entry *b)
{
- unsigned char sa[20], sb[20];
- int ret;
- get_sha1_hex(a->from_sha1_hex, sa);
- get_sha1_hex(b->from_sha1_hex, sb);
- ret = hashcmp(sa, sb);
- if (!ret) {
- get_sha1_hex(a->to_sha1_hex, sa);
- get_sha1_hex(b->to_sha1_hex, sb);
- ret = hashcmp(sa, sb);
- }
+ int ret = hashcmp(a->from_sha1, b->from_sha1);
+ if (!ret)
+ ret = hashcmp(a->to_sha1, b->to_sha1);
return ret;
}
@@ -193,26 +176,15 @@ static int do_for_each_sequential(
unsigned long i,
int stop_at_first_non_match)
{
- unsigned char f_sha1[20], t_sha1[20]; /* Holds sha1 per entry */
int ret = 0;
for (; i < file->data_len; ++i) { /* Step through file, starting at i */
- /* sanity check entry */
- if (file->data[i].space != ' ' || file->data[i].lf != '\n') {
- ret = error("Entry #%lu in softrefs file %s failed sanity check",
- i, file->filename);
- break;
- }
- /* retrieve SHA1 values */
- if (get_sha1_hex(file->data[i].from_sha1_hex, f_sha1) ||
- get_sha1_hex(file->data[i].to_sha1_hex, t_sha1)) {
- ret = error("Failed to read SHA1 values from entry #%lu in softrefs file %s",
- i, file->filename);
- break;
- }
/* Compare to lookup value */
- if (!from_sha1 || !hashcmp(from_sha1, f_sha1)) {
- if ((ret = fn(f_sha1, t_sha1, cb_data)))
+ if (!from_sha1 || !hashcmp(from_sha1, file->data[i].from_sha1)) {
+ if ((ret = fn(file->data[i].from_sha1,
+ file->data[i].to_sha1, cb_data)))
+ {
break; /* bail out if callback returns != 0 */
+ }
}
else if (stop_at_first_non_match)
break;
@@ -277,7 +249,7 @@ static int do_for_each_sorted(
i = (from_sha1[0] * file->data_len) / 256;
/* Binary search */
- while ((cmp_result = sha1_to_entry_cmp(from_sha1, &(file->data[i])))) {
+ while ((cmp_result = hashcmp(from_sha1, file->data[i].from_sha1))) {
if (right - left <= 1) /* not found; give up */
goto done;
if (cmp_result > 0) /* go right */
@@ -288,7 +260,7 @@ static int do_for_each_sorted(
}
/* i points to a matching entry, but not necessarily the first */
- while (i >= 1 && sha1_to_entry_cmp(from_sha1, &(file->data[i - 1])) == 0)
+ while (i >= 1 && !hashcmp(from_sha1, file->data[i - 1].from_sha1))
--i;
/* i points to the first matching entry */
@@ -432,7 +404,6 @@ static int merge_unsorted_into_sorted(
while (!ret && (i < unsorted.data_len || j < sorted.data_len)) {
/* there are still entries in either list */
struct softrefs_entry *cur;
- unsigned char from_sha1[20], to_sha1[20];
if (i < unsorted.data_len && j < sorted.data_len) {
/* there are still entries in _both_ lists */
/* choose "lowest" entry from either list */
@@ -451,10 +422,8 @@ static int merge_unsorted_into_sorted(
prev = cur;
/* skip writing if softref involves a non-existing object */
- if (get_sha1_hex(cur->from_sha1_hex, from_sha1) ||
- !has_sha1_file(from_sha1) ||
- get_sha1_hex(cur->to_sha1_hex, to_sha1) ||
- !has_sha1_file( to_sha1))
+ if (!has_sha1_file(cur->from_sha1) ||
+ !has_sha1_file(cur->to_sha1))
{
continue;
}
@@ -523,7 +492,6 @@ static int merge_sorted_into_sorted(const char *from_file, const char *to_file)
while (!ret && (i < file1.data_len || j < file2.data_len)) {
/* there are still entries in either list */
struct softrefs_entry *cur;
- unsigned char from_sha1[20], to_sha1[20];
if (i < file1.data_len && j < file2.data_len) {
/* there are still entries in _both_ lists */
/* choose "lowest" entry from either list */
@@ -542,10 +510,8 @@ static int merge_sorted_into_sorted(const char *from_file, const char *to_file)
prev = cur;
/* skip writing if softref involves a non-existing object */
- if (get_sha1_hex(cur->from_sha1_hex, from_sha1) ||
- !has_sha1_file(from_sha1) ||
- get_sha1_hex(cur->to_sha1_hex, to_sha1) ||
- !has_sha1_file( to_sha1))
+ if (!has_sha1_file(cur->from_sha1) ||
+ !has_sha1_file(cur->to_sha1))
{
continue;
}
@@ -608,10 +574,8 @@ int add_softrefs(const struct softref_list *list)
/* nada */;
}
else { /* softref is ok */
- strcpy(entry.from_sha1_hex, sha1_to_hex(list->from_sha1));
- strcpy(entry.to_sha1_hex, sha1_to_hex(list->to_sha1));
- entry.space = ' ';
- entry.lf = '\n';
+ hashcpy(entry.from_sha1, list->from_sha1);
+ hashcpy(entry.to_sha1, list->to_sha1);
if (write_entry(fd, &entry))
error("Failed to write entry to softrefs file %s: %s",
git_path(UNSORTED_FILENAME),
diff --git a/softrefs.h b/softrefs.h
index db0f8b9..89d25ce 100644
--- a/softrefs.h
+++ b/softrefs.h
@@ -19,10 +19,9 @@
* the "to" objects reachable from a given "from" object.
*
* The softrefs db consists of two files: .git/softrefs.unsorted and
- * .git/softrefs.sorted. Both files use the same format; one softref per line
- * of the form "<from-sha1> <to-sha1>\n". Each sha1 sum is 40 bytes long; this
- * makes each entry exactly 82 bytes long (including the space between the sha1
- * sums and the terminating linefeed).
+ * .git/softrefs.sorted. Both files use the same binary format; <from-sha1>
+ * followed by <to-sha1> per entry. Each sha1 sum is 20 bytes long; this
+ * makes each entry exactly 40 bytes long.
*
* The entries in .git/softrefs.sorted are sorted on <from-sha1>, in order to
* make lookup fast.
--
1.5.2.1.144.gabc40
^ permalink raw reply related
* [PATCH 7/7] Teach git-mktag to register softrefs for all tag objects
From: Johan Herland @ 2007-06-09 18:24 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Linus Torvalds
In-Reply-To: <200706092019.13185.johan@herland.net>
For each tag object created, we create a corresponding softref from the
tagged object to the tag object itself. This is needed to enable efficient
lookup of which tag objects that point to a given commit/object.
Signed-off-by: Johan Herland <johan@herland.net>
---
mktag.c | 11 ++++++++++-
1 files changed, 10 insertions(+), 1 deletions(-)
diff --git a/mktag.c b/mktag.c
index af0cfa6..db8a6b8 100644
--- a/mktag.c
+++ b/mktag.c
@@ -1,5 +1,6 @@
#include "cache.h"
#include "tag.h"
+#include "softrefs.h"
/*
* Tag object data has the following format: two mandatory lines of
@@ -32,6 +33,7 @@ int main(int argc, char **argv)
{
unsigned long size = 4096;
char *buffer = xmalloc(size);
+ struct tag result_tag;
unsigned char result_sha1[20];
if (argc != 1)
@@ -46,7 +48,7 @@ int main(int argc, char **argv)
buffer[size] = 0;
/* Verify tag object data */
- if (parse_and_verify_tag_buffer(0, buffer, size, 1)) {
+ if (parse_and_verify_tag_buffer(&result_tag, buffer, size, 1)) {
free(buffer);
die("invalid tag data file");
}
@@ -57,6 +59,13 @@ int main(int argc, char **argv)
}
free(buffer);
+
+ /* Create reverse mapping softref */
+ if (add_softref(result_tag.tagged->sha1, result_sha1) < 0) {
+ die("unable to create softref for resulting tag object %s",
+ sha1_to_hex(result_sha1));
+ }
+
printf("%s\n", sha1_to_hex(result_sha1));
return 0;
}
--
1.5.2.1.144.gabc40
^ permalink raw reply related
* [PATCH 6/7] Softrefs: Administrivia associated with softrefs subsystem and git-softref builtin
From: Johan Herland @ 2007-06-09 18:24 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Linus Torvalds
In-Reply-To: <200706092019.13185.johan@herland.net>
Also cleans up sorting and whitespace in Documentation/cmd-list.perl
Signed-off-by: Johan Herland <johan@herland.net>
---
.gitignore | 1 +
Documentation/cmd-list.perl | 7 ++++---
Makefile | 6 ++++--
builtin.h | 1 +
git.c | 1 +
5 files changed, 11 insertions(+), 5 deletions(-)
diff --git a/.gitignore b/.gitignore
index 27e5aeb..7fd6904 100644
--- a/.gitignore
+++ b/.gitignore
@@ -119,6 +119,7 @@ git-show
git-show-branch
git-show-index
git-show-ref
+git-softref
git-ssh-fetch
git-ssh-pull
git-ssh-push
diff --git a/Documentation/cmd-list.perl b/Documentation/cmd-list.perl
index a181f75..4e1f45b 100755
--- a/Documentation/cmd-list.perl
+++ b/Documentation/cmd-list.perl
@@ -90,6 +90,7 @@ git-clean mainporcelain
git-clone mainporcelain
git-commit mainporcelain
git-commit-tree plumbingmanipulators
+git-config ancillarymanipulators
git-convert-objects ancillarymanipulators
git-count-objects ancillaryinterrogators
git-cvsexportcommit foreignscminterface
@@ -101,13 +102,13 @@ git-diff-files plumbinginterrogators
git-diff-index plumbinginterrogators
git-diff mainporcelain
git-diff-tree plumbinginterrogators
-git-fast-import ancillarymanipulators
+git-fast-import ancillarymanipulators
git-fetch mainporcelain
git-fetch-pack synchingrepositories
git-fmt-merge-msg purehelpers
git-for-each-ref plumbinginterrogators
git-format-patch mainporcelain
-git-fsck ancillaryinterrogators
+git-fsck ancillaryinterrogators
git-gc mainporcelain
git-get-tar-commit-id ancillaryinterrogators
git-grep mainporcelain
@@ -155,7 +156,6 @@ git-receive-pack synchelpers
git-reflog ancillarymanipulators
git-relink ancillarymanipulators
git-repack ancillarymanipulators
-git-config ancillarymanipulators
git-remote ancillarymanipulators
git-request-pull foreignscminterface
git-rerere ancillaryinterrogators
@@ -174,6 +174,7 @@ git-show-branch ancillaryinterrogators
git-show-index plumbinginterrogators
git-show-ref plumbinginterrogators
git-sh-setup purehelpers
+git-softref ancillarymanipulators
git-ssh-fetch synchingrepositories
git-ssh-upload synchingrepositories
git-status mainporcelain
diff --git a/Makefile b/Makefile
index 0f75955..22e3e53 100644
--- a/Makefile
+++ b/Makefile
@@ -296,7 +296,7 @@ LIB_H = \
run-command.h strbuf.h tag.h tree.h git-compat-util.h revision.h \
tree-walk.h log-tree.h dir.h path-list.h unpack-trees.h builtin.h \
utf8.h reflog-walk.h patch-ids.h attr.h decorate.h progress.h \
- mailmap.h remote.h
+ mailmap.h remote.h softrefs.h
DIFF_OBJS = \
diff.o diff-lib.o diffcore-break.o diffcore-order.o \
@@ -318,7 +318,8 @@ LIB_OBJS = \
write_or_die.o trace.o list-objects.o grep.o match-trees.o \
alloc.o merge-file.o path-list.o help.o unpack-trees.o $(DIFF_OBJS) \
color.o wt-status.o archive-zip.o archive-tar.o shallow.o utf8.o \
- convert.o attr.o decorate.o progress.o mailmap.o symlinks.o remote.o
+ convert.o attr.o decorate.o progress.o mailmap.o symlinks.o remote.o \
+ softrefs.o
BUILTIN_OBJS = \
builtin-add.o \
@@ -370,6 +371,7 @@ BUILTIN_OBJS = \
builtin-runstatus.o \
builtin-shortlog.o \
builtin-show-branch.o \
+ builtin-softref.o \
builtin-stripspace.o \
builtin-symbolic-ref.o \
builtin-tar-tree.o \
diff --git a/builtin.h b/builtin.h
index da4834c..beae52c 100644
--- a/builtin.h
+++ b/builtin.h
@@ -67,6 +67,7 @@ extern int cmd_runstatus(int argc, const char **argv, const char *prefix);
extern int cmd_shortlog(int argc, const char **argv, const char *prefix);
extern int cmd_show(int argc, const char **argv, const char *prefix);
extern int cmd_show_branch(int argc, const char **argv, const char *prefix);
+extern int cmd_softref(int argc, const char **argv, const char *prefix);
extern int cmd_stripspace(int argc, const char **argv, const char *prefix);
extern int cmd_symbolic_ref(int argc, const char **argv, const char *prefix);
extern int cmd_tar_tree(int argc, const char **argv, const char *prefix);
diff --git a/git.c b/git.c
index 29b55a1..96cc0b8 100644
--- a/git.c
+++ b/git.c
@@ -283,6 +283,7 @@ static void handle_internal_command(int argc, const char **argv, char **envp)
{ "shortlog", cmd_shortlog, RUN_SETUP | USE_PAGER },
{ "show-branch", cmd_show_branch, RUN_SETUP },
{ "show", cmd_show, RUN_SETUP | USE_PAGER },
+ { "softref", cmd_softref, RUN_SETUP },
{ "stripspace", cmd_stripspace },
{ "symbolic-ref", cmd_symbolic_ref, RUN_SETUP },
{ "tar-tree", cmd_tar_tree },
--
1.5.2.1.144.gabc40
^ permalink raw reply related
* [PATCH 5/7] Softrefs: Add testcases for basic softrefs behaviour
From: Johan Herland @ 2007-06-09 18:23 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Linus Torvalds
In-Reply-To: <200706092019.13185.johan@herland.net>
Adds testing of the basic options available to the git-softref command.
Signed-off-by: Johan Herland <johan@herland.net>
---
t/t3050-softrefs.sh | 314 +++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 314 insertions(+), 0 deletions(-)
create mode 100755 t/t3050-softrefs.sh
diff --git a/t/t3050-softrefs.sh b/t/t3050-softrefs.sh
new file mode 100755
index 0000000..a925178
--- /dev/null
+++ b/t/t3050-softrefs.sh
@@ -0,0 +1,314 @@
+#!/bin/sh
+#
+# Copyright (c) 2007 Johan Herland
+#
+
+test_description='Basic functionality of soft references'
+. ./test-lib.sh
+
+
+# Prepare repo and create some notes
+
+test_expect_success 'Populating repo with test data' '
+ echo "foo" > foo &&
+ git-add foo &&
+ test_tick &&
+ git-commit -m "Initial commit" &&
+ git-tag -a -m "Tagging initial commit" footag &&
+ echo "bar" >> foo &&
+ test_tick &&
+ git-commit -m "Second commit" foo &&
+ git-tag -a -m "Tagging second commit" bartag
+'
+
+# At this point we should have:
+# - commit @ 301711b66fe71164f646b798706a2c1f7024da8d ("Initial commit")
+# - tag @ ad60bc179c6874af6d97f181c67f11adcca5122b ("footag")
+# - commit @ 9671cbee7ad26528645b2665c8f74d39a6288864 ("Second commit")
+# - tag @ a927fc832d42f1f64d8318e8acec43545d9562de ("bartag")
+# - The tag creation should also have created softrefs:
+# - From "Initial commit" to "footag"
+# - From "Second commit" to "bartag"
+
+# Testing git-softref --list
+
+test_expect_success 'Testing git-softref --list on initial test data (1)' '
+ cat > expected_output << EOF &&
+301711b66fe71164f646b798706a2c1f7024da8d ad60bc179c6874af6d97f181c67f11adcca5122b
+9671cbee7ad26528645b2665c8f74d39a6288864 a927fc832d42f1f64d8318e8acec43545d9562de
+EOF
+ git-softref > actual_output 2>&1 &&
+ cmp actual_output expected_output &&
+ git-softref --list > actual_output 2>&1 &&
+ cmp actual_output expected_output
+'
+
+test_expect_success 'Testing git-softref --list on initial test data (2)' '
+ cat > expected_output << EOF &&
+9671cbee7ad26528645b2665c8f74d39a6288864 a927fc832d42f1f64d8318e8acec43545d9562de
+EOF
+ git-softref --list 9671cbee7ad26528645b2665c8f74d39a6288864 > actual_output 2>&1 &&
+ cmp actual_output expected_output &&
+ git-softref --list HEAD > actual_output 2>&1 &&
+ cmp actual_output expected_output
+'
+
+test_expect_success 'Testing git-softref --list on initial test data (3)' '
+ cat > expected_output << EOF &&
+301711b66fe71164f646b798706a2c1f7024da8d ad60bc179c6874af6d97f181c67f11adcca5122b
+EOF
+ git-softref --list 301711b66fe71164f646b798706a2c1f7024da8d > actual_output 2>&1 &&
+ cmp actual_output expected_output &&
+ git-softref --list HEAD^ > actual_output 2>&1 &&
+ cmp actual_output expected_output
+'
+
+test_expect_success 'Testing git-softref --list on initial test data (4)' '
+ cat > expected_output << EOF &&
+EOF
+ git-softref --list footag > actual_output 2>&1 &&
+ cmp actual_output expected_output &&
+ git-softref --list bartag > actual_output 2>&1 &&
+ cmp actual_output expected_output
+'
+
+# Testing git-softref --has
+
+test_expect_success 'Testing git-softref --has on initial test data' '
+ (git-softref --has 301711b66fe71164f646b798706a2c1f7024da8d ad60bc179c6874af6d97f181c67f11adcca5122b;
+ test "$?" = "1") &&
+ (git-softref --has HEAD^ footag;
+ test "$?" = "1") &&
+ (git-softref --has footag^{} footag;
+ test "$?" = "1") &&
+ (git-softref --has 9671cbee7ad26528645b2665c8f74d39a6288864 a927fc832d42f1f64d8318e8acec43545d9562de;
+ test "$?" = "1") &&
+ (git-softref --has HEAD bartag;
+ test "$?" = "1") &&
+ (git-softref --has bartag^{} bartag;
+ test "$?" = "1") &&
+ (git-softref --has ad60bc179c6874af6d97f181c67f11adcca5122b 301711b66fe71164f646b798706a2c1f7024da8d;
+ test "$?" = "0") &&
+ (git-softref --has a927fc832d42f1f64d8318e8acec43545d9562de 9671cbee7ad26528645b2665c8f74d39a6288864;
+ test "$?" = "0") &&
+ (git-softref --has HEAD HEAD^;
+ test "$?" = "0") &&
+ (git-softref --has HEAD^ HEAD;
+ test "$?" = "0") &&
+ (git-softref --has footag HEAD;
+ test "$?" = "0") &&
+ (git-softref --has bartag HEAD;
+ test "$?" = "0") &&
+ (git-softref --has footag HEAD^;
+ test "$?" = "0") &&
+ (git-softref --has bartag HEAD^;
+ test "$?" = "0") &&
+ (git-softref --has footag bartag;
+ test "$?" = "0") &&
+ (git-softref --has bartag footag;
+ test "$?" = "0")
+'
+
+# Testing git-softref --rebuild-tags
+
+test_expect_success 'Testing git-softref --rebuild-tags on initial test data' '
+ cat > expected_output << EOF &&
+Added 0 missing softrefs for tag objects.
+EOF
+ cat .git/softrefs.* | sort > expected_softrefs &&
+ git-softref --rebuild-tags > actual_output 2>&1 &&
+ cat .git/softrefs.* | sort > actual_softrefs &&
+ cmp actual_output expected_output &&
+ cmp actual_softrefs expected_softrefs
+'
+
+# Testing git-softref --add
+
+test_expect_success 'Testing git-softref --add with existing softref' '
+ cat > expected_output << EOF &&
+EOF
+ cat .git/softrefs.* | sort > expected_softrefs &&
+ git-softref --add HEAD bartag > actual_output 2>&1 &&
+ cat .git/softrefs.* | sort > actual_softrefs &&
+ cmp actual_output expected_output &&
+ cmp actual_softrefs expected_softrefs
+'
+
+test_expect_success 'Testing git-softref --add with self-refential softref' '
+ cat > expected_output << EOF &&
+error: Cannot add self-reference (9671cbee7ad26528645b2665c8f74d39a6288864 -> 9671cbee7ad26528645b2665c8f74d39a6288864)
+fatal: Failed to create softref from HEAD to HEAD
+EOF
+ cat .git/softrefs.* | sort > expected_softrefs &&
+ (git-softref --add HEAD HEAD > actual_output 2>&1; test "$?" != "0") &&
+ cat .git/softrefs.* | sort > actual_softrefs &&
+ cmp actual_output expected_output &&
+ cmp actual_softrefs expected_softrefs
+'
+
+test_expect_success 'Testing git-softref --add with non-existing objects (1)' '
+ cat > expected_output << EOF &&
+fatal: Not a valid object name 1234567890123456789012345678901234567890
+EOF
+ cat .git/softrefs.* | sort > expected_softrefs &&
+ (git-softref --add 1234567890123456789012345678901234567890 HEAD > actual_output 2>&1;
+ test "$?" != "0") &&
+ cat .git/softrefs.* | sort > actual_softrefs &&
+ cmp actual_output expected_output &&
+ cmp actual_softrefs expected_softrefs &&
+ (git-softref --add HEAD 1234567890123456789012345678901234567890 > actual_output 2>&1;
+ test "$?" != "0") &&
+ cat .git/softrefs.* | sort > actual_softrefs &&
+ cmp actual_output expected_output &&
+ cmp actual_softrefs expected_softrefs
+'
+
+test_expect_success 'Testing git-softref --add with non-existing objects (2)' '
+ cat > expected_output << EOF &&
+fatal: Not a valid object name HEAD^^^
+EOF
+ cat .git/softrefs.* | sort > expected_softrefs &&
+ (git-softref --add HEAD^^^ HEAD > actual_output 2>&1; test "$?" != "0") &&
+ cat .git/softrefs.* | sort > actual_softrefs &&
+ cmp actual_output expected_output &&
+ cmp actual_softrefs expected_softrefs
+'
+
+test_expect_success 'Testing git-softref --add with valid arguments (1)' '
+ cat > expected_output << EOF &&
+EOF
+ cat > new_softref << EOF
+301711b66fe71164f646b798706a2c1f7024da8d 9671cbee7ad26528645b2665c8f74d39a6288864
+EOF
+ cat .git/softrefs.* new_softref | sort > expected_softrefs &&
+ git-softref --add HEAD^ HEAD > actual_output 2>&1 &&
+ cat .git/softrefs.* | sort > actual_softrefs &&
+ cmp actual_output expected_output &&
+ cmp actual_softrefs expected_softrefs
+'
+
+test_expect_success 'Testing git-softref --add with valid arguments (2)' '
+ cat > expected_output << EOF &&
+EOF
+ cat > new_softref << EOF
+ad60bc179c6874af6d97f181c67f11adcca5122b a927fc832d42f1f64d8318e8acec43545d9562de
+EOF
+ cat .git/softrefs.* new_softref | sort > expected_softrefs &&
+ git-softref --add footag bartag > actual_output 2>&1 &&
+ cat .git/softrefs.* | sort > actual_softrefs &&
+ cmp actual_output expected_output &&
+ cmp actual_softrefs expected_softrefs
+'
+
+# Removing softrefs
+
+test_expect_success 'Removing all softrefs' '
+ rm .git/softrefs.*
+'
+
+# Testing git-softref --list and --has
+
+test_expect_success 'Testing git-softref with no softrefs' '
+ cat > expected_output << EOF &&
+EOF
+ git-softref > actual_output 2>&1 &&
+ cmp actual_output expected_output &&
+ git-softref --list > actual_output 2>&1 &&
+ cmp actual_output expected_output &&
+ git-softref --list 9671cbee7ad26528645b2665c8f74d39a6288864 > actual_output 2>&1 &&
+ cmp actual_output expected_output &&
+ git-softref --list HEAD > actual_output 2>&1 &&
+ cmp actual_output expected_output &&
+ git-softref --list HEAD^ > actual_output 2>&1 &&
+ cmp actual_output expected_output &&
+ git-softref --list footag > actual_output 2>&1 &&
+ cmp actual_output expected_output &&
+ git-softref --list bartag > actual_output 2>&1 &&
+ cmp actual_output expected_output &&
+ git-softref --has HEAD bartag > actual_output 2>&1 &&
+ cmp actual_output expected_output &&
+ git-softref --has HEAD^ footag > actual_output 2>&1 &&
+ cmp actual_output expected_output
+'
+
+# Testing git-softref --rebuild-tags
+# (Should recreated missing softrefs for tag objects reachable from 'refs/tags')
+
+test_expect_success 'Testing git-softref --rebuild-tags to rebuild missing tag softrefs' '
+ cat > expected_output << EOF &&
+Added 2 missing softrefs for tag objects.
+EOF
+ cat > new_softref << EOF
+301711b66fe71164f646b798706a2c1f7024da8d ad60bc179c6874af6d97f181c67f11adcca5122b
+9671cbee7ad26528645b2665c8f74d39a6288864 a927fc832d42f1f64d8318e8acec43545d9562de
+EOF
+ cat .git/softrefs.* new_softref | sort > expected_softrefs &&
+ git-softref --rebuild-tags > actual_output 2>&1 &&
+ cat .git/softrefs.* | sort > actual_softrefs &&
+ cmp actual_output expected_output &&
+ cmp actual_softrefs expected_softrefs
+'
+
+# Testing git-softref --merge-unsorted
+
+test_expect_success 'Testing git-softref --merge-unsorted' '
+ cat > expected_output << EOF &&
+EOF
+ rm .git/softrefs*
+ cat > .git/softrefs.unsorted << EOF
+9671cbee7ad26528645b2665c8f74d39a6288864 a927fc832d42f1f64d8318e8acec43545d9562de
+301711b66fe71164f646b798706a2c1f7024da8d ad60bc179c6874af6d97f181c67f11adcca5122b
+EOF
+ cat > expected_softrefs << EOF
+301711b66fe71164f646b798706a2c1f7024da8d ad60bc179c6874af6d97f181c67f11adcca5122b
+9671cbee7ad26528645b2665c8f74d39a6288864 a927fc832d42f1f64d8318e8acec43545d9562de
+EOF
+ git-softref --merge-unsorted > actual_output 2>&1 &&
+ cmp actual_output expected_output &&
+ cmp .git/softrefs.sorted expected_softrefs &&
+ test ! -e .git/softrefs.unsorted
+'
+
+# Testing git-softref --merge-unsorted <filename>
+
+test_expect_success 'Testing git-softref --merge-unsorted <filename>' '
+ cat > expected_output << EOF &&
+EOF
+ rm .git/softrefs*
+ cat > new_softrefs << EOF
+9671cbee7ad26528645b2665c8f74d39a6288864 a927fc832d42f1f64d8318e8acec43545d9562de
+301711b66fe71164f646b798706a2c1f7024da8d ad60bc179c6874af6d97f181c67f11adcca5122b
+EOF
+ cat > expected_softrefs << EOF
+301711b66fe71164f646b798706a2c1f7024da8d ad60bc179c6874af6d97f181c67f11adcca5122b
+9671cbee7ad26528645b2665c8f74d39a6288864 a927fc832d42f1f64d8318e8acec43545d9562de
+EOF
+ git-softref --merge-unsorted new_softrefs > actual_output 2>&1 &&
+ cmp actual_output expected_output &&
+ cmp .git/softrefs.sorted expected_softrefs &&
+ test -e new_softrefs
+'
+
+# Testing git-softref --merge-sorted <filename>
+
+test_expect_success 'Testing git-softref --merge-sorted <filename>' '
+ cat > expected_output << EOF &&
+EOF
+ rm .git/softrefs*
+ cat > new_softrefs << EOF
+301711b66fe71164f646b798706a2c1f7024da8d ad60bc179c6874af6d97f181c67f11adcca5122b
+9671cbee7ad26528645b2665c8f74d39a6288864 a927fc832d42f1f64d8318e8acec43545d9562de
+EOF
+ cat > expected_softrefs << EOF
+301711b66fe71164f646b798706a2c1f7024da8d ad60bc179c6874af6d97f181c67f11adcca5122b
+9671cbee7ad26528645b2665c8f74d39a6288864 a927fc832d42f1f64d8318e8acec43545d9562de
+EOF
+ git-softref --merge-sorted new_softrefs > actual_output 2>&1 &&
+ cmp actual_output expected_output &&
+ cmp .git/softrefs.sorted expected_softrefs &&
+ test -e new_softrefs
+'
+
+# FIXME: More testing needed on how softrefs interact with the rest of git
+
+test_done
--
1.5.2.1.144.gabc40
^ permalink raw reply related
* [PATCH 4/7] Softrefs: Add manual page documenting git-softref and softrefs subsystem in general
From: Johan Herland @ 2007-06-09 18:23 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Linus Torvalds
In-Reply-To: <200706092019.13185.johan@herland.net>
Signed-off-by: Johan Herland <johan@herland.net>
---
Documentation/git-softref.txt | 119 +++++++++++++++++++++++++++++++++++++++++
1 files changed, 119 insertions(+), 0 deletions(-)
create mode 100644 Documentation/git-softref.txt
diff --git a/Documentation/git-softref.txt b/Documentation/git-softref.txt
new file mode 100644
index 0000000..6a3e13b
--- /dev/null
+++ b/Documentation/git-softref.txt
@@ -0,0 +1,119 @@
+git-softref(1)
+==============
+
+NAME
+----
+git-softref - Create, list and administer soft references
+
+
+SYNOPSIS
+--------
+[verse]
+'git-softref' --list [<from-object>]
+'git-softref' --has <from-object> <to-object>
+'git-softref' --add <from-object> <to-object>
+'git-softref' --rebuild-tags
+'git-softref' --merge-unsorted [<softrefs-file>]
+'git-softref' --merge-sorted <softrefs-file>
+
+
+DESCRIPTION
+-----------
+Query and administer soft references in a git repository.
+
+Soft references are used to declare reachability between already existing
+objects. An object (called the 'to-object') may be declared reachable from
+another object (the 'from-object') without affecting the immutability of either
+object.
+
+The `--list` option will list existing softrefs in the database. If given the
+optional <from-object>, the list is limited to softrefs from the given object.
+The `--has` option is used to check for the existence of a softref between two
+given objects, similarly the `--add` option is used to add such a softref.
+
+The `--rebuild-tags` option is used to generate softrefs for all tag objects in
+the repository reachable from tag refs. Tag objects use softrefs to declare
+reachability 'from' the tagged object, 'to' the tag object. This allows for tag
+objects to the cloned/fetched/pushed along with their associated objects.
+
+Finally, the `--merge-unsorted` and `--merge-sorted` options are used to merge
+softrefs files into the sorted softrefs db. The filename argument must point
+to an existing file in unsorted/sorted softrefs format. The softrefs entries
+in this file will be merged into the sorted softrefs db. The `--merge-unsorted`
+option may be used 'without' a filename, in which case the currently unsorted
+portion of the softrefs db will be merged into the sorted db. Note that this
+last operation is also done regularly by default when adding softrefs, so
+there is no need to invoke this option during regular use.
+
+
+OPTIONS
+-------
+--list [<from-object>]::
+ List all softrefs that have the given '<from-object>'.
+ If '<from-object>' is not given, list 'all' softrefs in the repository.
+
+--has <from-object> <to-object>::
+ Return with exit code 1 if the given softref exists in the repository.
+ Return with exit code 0 otherwise.
+
+--add <from-object> <to-object>::
+ Add a softref from the given '<from-object>' to the given '<to-object>'.
+ The '<to-object>' will from now on be considered reachable from the
+ '<from-object>'.
+
+--rebuild-tags::
+ Automatically generate softrefs for all tag objects reachable from
+ tag refs in the repository.
+
+--merge-unsorted [<softrefs-file>]::
+ Merge the softrefs in the given unsorted '<softrefs-file>' into the
+ sorted softrefs db. If a filename is not given, force a merge of the
+ internal unsorted softrefs store into the sorted softrefs db.
+
+--merge-sorted <softrefs-file>::
+ Merge the softrefs in the given sorted '<softrefs-file>' into the
+ sorted softrefs db.
+
+
+DISCUSSION
+----------
+Soft references (softrefs) is a general mechanism for declaring a relationship
+between two existing arbitrary objects in the repo. Softrefs differ from the
+existing reachability relationship in that a softref may be created after
+'both' of the involved objects have been added to the repo. In contrast,
+regular reachability depends on the reachable object's name being stored
+'inside' the other object. A reachability relationship can therefore not be
+created at a later time without violating the immutability of git objects.
+
+Softrefs are defined as going 'from' one object 'to' another object. Once
+a softref between two objects has been created, the "to" object is considered
+reachable from the "from" object.
+
+Also, softrefs are stored in a way that makes it easy and quick to find all
+the "to" objects reachable from a given "from" object.
+
+The softrefs db consists of two files: `.git/softrefs.unsorted` and
+`.git/softrefs.sorted`. Both files use the same format; one softref per line
+of the form "`<from-sha1> <to-sha1>\n`". Each sha1 sum is 40 bytes long; this
+makes each entry exactly 82 bytes long.
+
+The entries in `.git/softrefs.sorted` are sorted on `<from-sha1>`, in order to
+make lookup fast. This file is also known as the "sorted softrefs db".
+
+The entries in `.git/softrefs.unsorted` are 'not' sorted. This is to make
+insertion fast. This file is also known as the "unsorted softrefs db".
+
+When softrefs are created, they are appended to `.git/softrefs.unsorted`.
+When `.git/softrefs.unsorted` reach a certain number of entries, all the
+entries in `.git/softrefs.unsorted` are automatically merged into
+`.git/softrefs.sorted`.
+
+
+Author
+------
+Written by Johan Herland <johan@herland.net>.
+
+
+GIT
+---
+Part of the gitlink:git[7] suite
--
1.5.2.1.144.gabc40
^ permalink raw reply related
* [PATCH 3/7] Softrefs: Add git-softref, a builtin command for adding, listing and administering softrefs
From: Johan Herland @ 2007-06-09 18:22 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Linus Torvalds
In-Reply-To: <200706092019.13185.johan@herland.net>
git-softref is meant to be used from shell scripts that need to interact
with the softrefs database. The builtin command provides most of the
functionality present in the softrefs C API.
Documentation to follow in a subsequent patch.
Signed-off-by: Johan Herland <johan@herland.net>
---
builtin-softref.c | 167 +++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 167 insertions(+), 0 deletions(-)
create mode 100644 builtin-softref.c
diff --git a/builtin-softref.c b/builtin-softref.c
new file mode 100644
index 0000000..f95db4e
--- /dev/null
+++ b/builtin-softref.c
@@ -0,0 +1,167 @@
+/*
+ * git softref builtin command
+ *
+ * Add, list and administer soft references (softrefs)
+ *
+ * Copyright (c) 2007 Johan Herland
+ */
+
+#include "cache.h"
+#include "tag.h"
+#include "refs.h"
+#include "softrefs.h"
+
+static const char builtin_softref_usage[] =
+ "git-softref [ --list [<from-object>]"
+ " | --has <from-object> <to-object>"
+ " | --add <from-object> <to-object>"
+ " | --rebuild-tags"
+ " | --merge-unsorted [<softrefs-file>]"
+ " | --merge-sorted <softrefs-file> ]";
+
+static int list_helper(
+ const unsigned char *from_sha1,
+ const unsigned char *to_sha1,
+ void *cb_data)
+{
+ printf("%s %s\n", sha1_to_hex(from_sha1), sha1_to_hex(to_sha1));
+ return 0;
+}
+
+int rebuild_tags_helper(
+ const char *refname,
+ const unsigned char *sha1,
+ int flags,
+ void *cb_data)
+{
+ struct object *o = parse_object(sha1);
+ if (o && o->type == OBJ_TAG) {
+ struct tag *t = (struct tag *) o;
+ struct softref_list **prev = (struct softref_list **) cb_data;
+ struct softref_list *current = xmalloc(sizeof(struct softref_list));
+ current->next = *prev;
+ hashcpy(current->from_sha1, t->tagged->sha1);
+ hashcpy(current->to_sha1, t->object.sha1);
+ *prev = current;
+ }
+ return 0;
+}
+
+int cmd_softref(int argc, const char **argv, const char *prefix)
+{
+ int i;
+ int show_usage = 0, list = 0, has = 0, add = 0, rebuild_tags = 0,
+ merge_unsorted = 0, merge_sorted = 0;
+ const char *from_name = NULL, *to_name = NULL, *softrefs_file = NULL;
+ unsigned char from_sha1[20], to_sha1[20];
+
+ git_config(git_default_config);
+
+ for (i = 1; i < argc; i++) {
+ const char *arg = argv[i];
+ if (!strcmp(arg, "--list")) {
+ list = 1;
+ if (i + 1 < argc) /* <from-object> given */
+ from_name = argv[++i];
+ }
+ else if (!strcmp(arg, "--has")) {
+ has = 1;
+ if (i + 2 >= argc)
+ show_usage = error("--has needs two arguments: <from-object> and <to-object>");
+ else {
+ from_name = argv[++i];
+ to_name = argv[++i];
+ }
+ }
+ else if (!strcmp(arg, "--add")) {
+ add = 1;
+ if (i + 2 >= argc)
+ show_usage = error("--add needs two arguments: <from-object> and <to-object>");
+ else {
+ from_name = argv[++i];
+ to_name = argv[++i];
+ }
+ }
+ else if (!strcmp(arg, "--rebuild-tags"))
+ rebuild_tags = 1;
+ else if (!strcmp(arg, "--merge-unsorted")) {
+ merge_unsorted = 1;
+ if (i + 1 < argc) /* <softrefs-file> given */
+ softrefs_file = argv[++i];
+ }
+ else if (!strcmp(arg, "--merge-sorted")) {
+ merge_sorted = 1;
+ if (i + 1 >= argc)
+ show_usage = error("--merge-sorted needs one argument: <softrefs-file>");
+ else
+ softrefs_file = argv[++i];
+ }
+ else
+ show_usage = error("Unknown argument '%s'", arg);
+ }
+
+ /* default to --list if no command given; fail if more than one */
+ switch(list + has + add + rebuild_tags + merge_unsorted + merge_sorted) {
+ case 0: list = 1; break;
+ case 1: break;
+ default: show_usage = 1;
+ }
+ if (show_usage)
+ usage(builtin_softref_usage);
+
+ if (list) {
+ if (from_name) { /* show from_name's softrefs */
+ if (get_sha1(from_name, from_sha1))
+ die("Not a valid object name %s", from_name);
+ if (for_each_softref_with_from(from_sha1, list_helper, 0))
+ die("Error encountered while listing softrefs");
+ }
+ else if (for_each_softref(list_helper, 0)) /* show all softrefs */
+ die("Error encountered while listing softrefs");
+ }
+ else if (has) {
+ if (get_sha1(from_name, from_sha1) || !has_sha1_file(from_sha1))
+ die("Not a valid object name %s", from_name);
+ if (get_sha1(to_name, to_sha1) || !has_sha1_file(to_sha1))
+ die("Not a valid object name %s", to_name);
+ return has_softref(from_sha1, to_sha1);
+ }
+ else if (add) {
+ if (get_sha1(from_name, from_sha1) || !has_sha1_file(from_sha1))
+ die("Not a valid object name %s", from_name);
+ if (get_sha1(to_name, to_sha1) || !has_sha1_file(to_sha1))
+ die("Not a valid object name %s", to_name);
+ if (add_softref(from_sha1, to_sha1) < 0)
+ die("Failed to create softref from %s to %s",
+ from_name, to_name);
+ }
+ else if (rebuild_tags) {
+ /*
+ * Find all tag objects, and add their corresponding softrefs
+ *
+ * For now, we'll have to settle for referenced tag objects as
+ * it seems to be non-trivial to find _all_ the tag objects in
+ * the db (including unreachables).
+ */
+ struct softref_list *to_add = NULL;
+ struct softref_list **p = &to_add;
+ int ret;
+ if (for_each_tag_ref(rebuild_tags_helper, (void *) p)) {
+ delete_softref_list(to_add);
+ die("Failed to find tag objects");
+ }
+ ret = add_softrefs(to_add);
+ delete_softref_list(to_add);
+ if (ret < 0)
+ die("Failed to add softrefs for tag objects");
+ printf("Added %i missing softrefs for tag objects.\n", ret);
+ }
+ else if (merge_unsorted) {
+ return merge_unsorted_softrefs(softrefs_file, 1);
+ }
+ else if (merge_sorted) {
+ return merge_sorted_softrefs(softrefs_file);
+ }
+
+ return 0;
+}
--
1.5.2.1.144.gabc40
^ permalink raw reply related
* [PATCH 2/7] Softrefs: Add implementation of softrefs API
From: Johan Herland @ 2007-06-09 18:22 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Linus Torvalds
In-Reply-To: <200706092019.13185.johan@herland.net>
This code tries to implement the softrefs API as straightforwardly as
possible. Virtually no optimization has been done, although I do have
a feeling the code has ok performance as is.
All functions that do not appear in the API docs have some comments
attached to them.
There are also a couple of things to be considered before inclusion:
- File locking. Currently no locking is performed on softrefs files
before reading or writing entries.
- Packing. We need a plan for how softrefs should be included in packs,
at which supporting code must be added to this implementation.
Signed-off-by: Johan Herland <johan@herland.net>
---
softrefs.c | 712 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 712 insertions(+), 0 deletions(-)
create mode 100644 softrefs.c
diff --git a/softrefs.c b/softrefs.c
new file mode 100644
index 0000000..c7308c8
--- /dev/null
+++ b/softrefs.c
@@ -0,0 +1,712 @@
+#include "cache.h"
+#include "softrefs.h"
+
+/* constants */
+static const char * UNSORTED_FILENAME = "softrefs.unsorted";
+static const char * SORTED_FILENAME = "softrefs.sorted";
+static const unsigned int MAX_UNSORTED_ENTRIES = 1000;
+
+
+/* softref entry as it appears in a softrefs file */
+struct softrefs_entry {
+ char from_sha1_hex[40];
+ char space;
+ char to_sha1_hex[40];
+ char lf;
+};
+
+/* simple encapsulation of a softrefs file */
+struct softrefs_file {
+ char *filename;
+ int fd;
+ struct softrefs_entry *data; /* mmap()ed softrefs_entry objects */
+ unsigned long data_len; /* # of softrefs_entry objects in data */
+};
+
+/* Internal file opened/closed by (de)init_softrefs_access() */
+static struct softrefs_file *internal_file = 0;
+
+/*
+ * Open and mmap() the given filename, Assign the file descriptior, data
+ * pointer and data length to the given softrefs_file object.
+ * Return 0 on success, -1 on failure.
+ *
+ * Note that a non-existing file is not a failure per se, but is rather treated
+ * as an empty file, i.e. there will be no data in the file structure
+ * (data_len == 0), but 0/sucess will be returned.
+ *
+ * The caller must _always_ call close_softrefs_file() with the same
+ * softrefs_file argument after processing the file data, even if no file
+ * is actually opened and/or this function returns -1.
+ */
+static int open_softrefs_file(const char *filename, struct softrefs_file *file)
+{
+ struct stat st;
+
+ /* Default "failure" values */
+ file->filename = xstrdup(filename);
+ file->fd = -1;
+ file->data = MAP_FAILED;
+ file->data_len = 0;
+
+ /* FIXME: File locking!? */
+ if (access(file->filename, F_OK))
+ return 0;
+ file->fd = open(file->filename, O_RDONLY);
+ if (file->fd < 0)
+ return error("Failed to open softrefs file %s: %s",
+ file->filename, strerror(errno));
+ if (fstat(file->fd, &st))
+ return error("Failed to fstat softrefs file %s: %s",
+ file->filename, strerror(errno));
+ if (st.st_size == 0) /* Empty file. No need to call mmap() */
+ return 0;
+ if (st.st_size % sizeof(struct softrefs_entry))
+ return error("Refuse to mmap softrefs file %s: File does not have whole number of softref entries",
+ file->filename);
+
+ file->data = xmmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, file->fd, 0);
+ if (file->data == MAP_FAILED)
+ return error("Failed to mmap softrefs file %s: %s",
+ file->filename, strerror(errno));
+
+ file->data_len = st.st_size / sizeof(struct softrefs_entry);
+
+ return 0;
+}
+
+/*
+ * Close the softrefs file identified by the given softrefs_file object.
+ * Return 0 on success, non-zero on failure.
+ */
+static int close_softrefs_file(const struct softrefs_file *file)
+{
+ int ret = 0;
+ if (file->data != MAP_FAILED &&
+ munmap(file->data, file->data_len * sizeof(struct softrefs_entry)))
+ {
+ ret = error("Failed to munmap softrefs file %s: %s",
+ file->filename, strerror(errno));
+ }
+ if (file->fd != -1 && close(file->fd))
+ ret = error("Failed to close softrefs file %s: %s",
+ file->filename, strerror(errno));
+ free(file->filename);
+ return ret;
+}
+
+/*
+ * Write the given softrefs_entry to the given file descriptor, which must be
+ * open and writable.
+ *
+ * Returns 0 on success, non-zero on failure.
+ */
+static int write_entry(int fd, const struct softrefs_entry *entry)
+{
+ if (write(fd, (const void *) entry, sizeof(struct softrefs_entry))
+ < sizeof(struct softrefs_entry))
+ {
+ return error("Failed to write entry '%.40s -> %.40s' to softrefs file descriptor %i: %s",
+ entry->from_sha1_hex, entry->to_sha1_hex,
+ fd, strerror(errno));
+ }
+ return 0;
+}
+
+/* See softrefs.h for documentation */
+void init_softrefs_access()
+{
+ if (internal_file) /* already initialized */
+ return;
+
+ /* Force merge into sorted, so that we only have one file to search */
+ if (merge_unsorted_softrefs(NULL, 1))
+ return; /* merge failed */
+
+ internal_file = xmalloc(sizeof(struct softrefs_file));
+ if (open_softrefs_file(git_path(SORTED_FILENAME), internal_file)) {
+ free(internal_file);
+ internal_file = 0;
+ }
+}
+
+/* See softrefs.h for documentation */
+void deinit_softrefs_access()
+{
+ if (!internal_file) /* already deinitialized */
+ return;
+ close_softrefs_file(internal_file);
+ internal_file = 0;
+}
+
+/* comparison between a SHA1 sum and a softrefs entry */
+static int sha1_to_entry_cmp(
+ const unsigned char *from_sha1, const struct softrefs_entry *entry)
+{
+ unsigned char sha1[20];
+ get_sha1_hex(entry->from_sha1_hex, sha1);
+ return hashcmp(from_sha1, sha1);
+}
+
+/* comparison between softrefs entries */
+static int softrefs_entry_cmp(
+ const struct softrefs_entry *a, const struct softrefs_entry *b)
+{
+ unsigned char sa[20], sb[20];
+ int ret;
+ get_sha1_hex(a->from_sha1_hex, sa);
+ get_sha1_hex(b->from_sha1_hex, sb);
+ ret = hashcmp(sa, sb);
+ if (!ret) {
+ get_sha1_hex(a->to_sha1_hex, sa);
+ get_sha1_hex(b->to_sha1_hex, sb);
+ ret = hashcmp(sa, sb);
+ }
+ return ret;
+}
+
+/* comparison between softrefs entries as invoked by qsort() */
+static int softrefs_entry_qsort_cmp(const void *a, const void *b)
+{
+ const struct softrefs_entry *na = *((const struct softrefs_entry **) a);
+ const struct softrefs_entry *nb = *((const struct softrefs_entry **) b);
+ return softrefs_entry_cmp(na, nb);
+}
+
+
+/*
+ * Sequentially process given 'file' starting at index 'i'
+ *
+ * For each entry matching 'from_sha1' (if NULL, match all entries), invoke
+ * callback function 'fn' with the from_sha1 and to_sha1 of the matching
+ * softref. Keep going until 'fn' returns non-zero, or end of file is reached.
+ *
+ * If the 'stop_at_first_non_match' flag is set, processing will stop when the
+ * first non-matching entry is encountered.
+ *
+ * Returns result of 'fn' if non-zero; otherwise 0 on success and -1 on failure.
+ */
+static int do_for_each_sequential(
+ const unsigned char *from_sha1,
+ each_softref_fn fn, void *cb_data,
+ struct softrefs_file *file,
+ unsigned long i,
+ int stop_at_first_non_match)
+{
+ unsigned char f_sha1[20], t_sha1[20]; /* Holds sha1 per entry */
+ int ret = 0;
+ for (; i < file->data_len; ++i) { /* Step through file, starting at i */
+ /* sanity check entry */
+ if (file->data[i].space != ' ' || file->data[i].lf != '\n') {
+ ret = error("Entry #%lu in softrefs file %s failed sanity check",
+ i, file->filename);
+ break;
+ }
+ /* retrieve SHA1 values */
+ if (get_sha1_hex(file->data[i].from_sha1_hex, f_sha1) ||
+ get_sha1_hex(file->data[i].to_sha1_hex, t_sha1)) {
+ ret = error("Failed to read SHA1 values from entry #%lu in softrefs file %s",
+ i, file->filename);
+ break;
+ }
+ /* Compare to lookup value */
+ if (!from_sha1 || !hashcmp(from_sha1, f_sha1)) {
+ if ((ret = fn(f_sha1, t_sha1, cb_data)))
+ break; /* bail out if callback returns != 0 */
+ }
+ else if (stop_at_first_non_match)
+ break;
+ }
+ return ret;
+}
+
+/* Invoke callback 'fn' for each matching entry in UNSORTED_FILENAME */
+static int do_for_each_unsorted(
+ const unsigned char *from_sha1,
+ each_softref_fn fn, void *cb_data)
+{
+ struct softrefs_file file;
+ int ret = 0;
+
+ if (internal_file)
+ /*
+ * internal_file is open. Unsorted entries are merged just
+ * before opening internal_file (in init_softrefs_access()).
+ * Since internal_file is still open, no entries have been
+ * added since last merge, meaning that there can be no
+ * unsorted entries in the db, and thus no unsorted file.
+ * Therefore return immediate success.
+ */
+ return 0;
+
+ if (!(ret = open_softrefs_file(git_path(UNSORTED_FILENAME), &file)))
+ ret = do_for_each_sequential(from_sha1, fn, cb_data, &file, 0, 0);
+
+ close_softrefs_file(&file);
+ return ret;
+}
+
+/* Invoke callback 'fn' for each matching entry in SORTED_FILENAME */
+static int do_for_each_sorted(
+ const unsigned char *from_sha1,
+ each_softref_fn fn, void *cb_data)
+{
+ struct softrefs_file *file;
+ unsigned long i, left, right;
+ int cmp_result;
+ int ret = 0;
+
+ if (internal_file) /* use already open internal_file */
+ file = internal_file;
+ else { /* open file ourselves */
+ file = xmalloc(sizeof(struct softrefs_file));
+ if ((ret = open_softrefs_file(git_path(SORTED_FILENAME), file)))
+ goto done;
+ }
+ if (!file->data_len) /* no entries */
+ goto done;
+
+ if (!from_sha1) { /* match _all_ entries; do sequential walk instead */
+ ret = do_for_each_sequential(from_sha1, fn, cb_data, file, 0, 0);
+ goto done;
+ }
+
+ /* Calculate first index by 256-fanout */
+ left = 0;
+ right = file->data_len;
+ i = (from_sha1[0] * file->data_len) / 256;
+
+ /* Binary search */
+ while ((cmp_result = sha1_to_entry_cmp(from_sha1, &(file->data[i])))) {
+ if (right - left <= 1) /* not found; give up */
+ goto done;
+ if (cmp_result > 0) /* go right */
+ left = i + 1;
+ else /* go left */
+ right = i;
+ i = (left + right) / 2;
+ }
+
+ /* i points to a matching entry, but not necessarily the first */
+ while (i >= 1 && sha1_to_entry_cmp(from_sha1, &(file->data[i - 1])) == 0)
+ --i;
+
+ /* i points to the first matching entry */
+ /* do sequential processing from i, stopping at first non-match */
+ ret = do_for_each_sequential(from_sha1, fn, cb_data, file, i, 1);
+
+done:
+ if (!internal_file) { /* only close if we opened ourselves */
+ close_softrefs_file(file);
+ free(file);
+ }
+ return ret;
+}
+
+/* See softrefs.h for documentation */
+int for_each_softref_with_from(
+ const unsigned char *from_sha1,
+ each_softref_fn fn, void *cb_data)
+{
+ int ret = do_for_each_unsorted(from_sha1, fn, cb_data);
+ if (ret)
+ return ret;
+ ret = do_for_each_sorted(from_sha1, fn, cb_data);
+ return ret;
+}
+
+/* See softrefs.h for documentation */
+int for_each_softref(each_softref_fn fn, void *cb_data)
+{
+ return for_each_softref_with_from(0, fn, cb_data);
+}
+
+static int lookup_softref_helper(
+ const unsigned char *from_sha1, const unsigned char *to_sha1,
+ void *cb_data)
+{
+ struct softref_list **prev = (struct softref_list **) cb_data;
+
+ struct softref_list *current = xmalloc(sizeof(struct softref_list));
+ current->next = *prev;
+ hashcpy(current->from_sha1, from_sha1);
+ hashcpy(current->to_sha1, to_sha1);
+ *prev = current;
+ return 0;
+}
+
+/* See softrefs.h for documentation */
+struct softref_list *lookup_softref(const unsigned char *from_sha1)
+{
+ struct softref_list *result = NULL;
+ struct softref_list **p = &result;
+ if (for_each_softref_with_from(
+ from_sha1, lookup_softref_helper, (void *) p))
+ {
+ delete_softref_list(result);
+ result = NULL;
+ }
+ return result;
+}
+
+/* See softrefs.h for documentation */
+void delete_softref_list(struct softref_list *list)
+{
+ while (list) {
+ struct softref_list *next = list->next;
+ free(list);
+ list = next;
+ }
+}
+
+static int has_softref_helper(
+ const unsigned char *from_sha1, const unsigned char *to_sha1,
+ void *cb_data)
+{
+ const unsigned char *needle = (const unsigned char *) cb_data;
+ if (!hashcmp(to_sha1, needle))
+ return 1; /* found */
+ return 0; /* keep going */
+}
+
+/* See softrefs.h for documentation */
+int has_softref(const unsigned char *from_sha1, const unsigned char *to_sha1)
+{
+ int ret = for_each_softref_with_from(
+ from_sha1, has_softref_helper, (void *) to_sha1);
+ return ret == 1 ? 1 : 0;
+}
+
+
+/*
+ * Merge the unsorted softref entries in unsorted_filename into sorted_filename
+ *
+ * Returns 0 on success; non-zero on failure.
+ *
+ * If sorted_filename does not exist, the entries in unsorted_filename will be
+ * sorted and stored into sorted_filename.
+ * If unsorted_filename does not exist, this function will do nothing and
+ * return 0.
+ */
+static int merge_unsorted_into_sorted(
+ const char *unsorted_filename, const char *sorted_filename)
+{
+ struct softrefs_file unsorted, sorted;
+ char *result_filename = 0;
+ int result_fd = -1;
+ int ret = 0;
+ unsigned long i, j;
+ /* array of pointers to softrefs_entries in unsorted file */
+ struct softrefs_entry **to_insert;
+ /* keep track of last processed entry, to remove duplicates */
+ struct softrefs_entry *prev = NULL;
+
+ /* Open input files */
+ deinit_softrefs_access();
+ open_softrefs_file(unsorted_filename, &unsorted);
+ if (!unsorted.data_len) { /* no unsorted entries; nothing to do */
+ close_softrefs_file(&unsorted);
+ return 0;
+ }
+ open_softrefs_file(sorted_filename, &sorted);
+
+ /* Sort the unsorted entries */
+ to_insert = xmalloc(sizeof(struct softrefs_entry *) * unsorted.data_len);
+ for (i = 0; i < unsorted.data_len; ++i)
+ to_insert[i] = &(unsorted.data[i]);
+ qsort(to_insert, unsorted.data_len, sizeof(struct softrefs_entry *),
+ softrefs_entry_qsort_cmp);
+
+ /* Create result file */
+ result_filename = xmalloc(strlen(sorted_filename) + 4);
+ sprintf(result_filename, "%s.new", sorted_filename);
+ result_fd = open(result_filename, O_WRONLY|O_CREAT|O_EXCL|O_TRUNC, 0666);
+ if (result_fd < 0) {
+ ret = error("Failed to open merge result file %s: %s",
+ result_filename, strerror(errno));
+ goto done;
+ }
+
+ i = 0; /* index into to_insert (the sorted version of unsorted.data) */
+ j = 0; /* index into sorted.data */
+ while (!ret && (i < unsorted.data_len || j < sorted.data_len)) {
+ /* there are still entries in either list */
+ struct softrefs_entry *cur;
+ unsigned char from_sha1[20], to_sha1[20];
+ if (i < unsorted.data_len && j < sorted.data_len) {
+ /* there are still entries in _both_ lists */
+ /* choose "lowest" entry from either list */
+ if (softrefs_entry_cmp(to_insert[i], &(sorted.data[j])) < 0)
+ cur = to_insert[i++];
+ else
+ cur = &(sorted.data[j++]);
+ }
+ else if (i < unsorted.data_len) /* entries left in to_insert */
+ cur = to_insert[i++];
+ else /* entries left in sorted.data */
+ cur = &(sorted.data[j++]);
+
+ if (prev && !softrefs_entry_cmp(prev, cur))
+ continue; /* skip writing if prev == cur */
+ prev = cur;
+
+ /* skip writing if softref involves a non-existing object */
+ if (get_sha1_hex(cur->from_sha1_hex, from_sha1) ||
+ !has_sha1_file(from_sha1) ||
+ get_sha1_hex(cur->to_sha1_hex, to_sha1) ||
+ !has_sha1_file( to_sha1))
+ {
+ continue;
+ }
+
+ ret = write_entry(result_fd, cur);
+ }
+
+done:
+ if (result_fd >= 0 && close(result_fd))
+ ret = error("Failed to close merge result file %s: %s",
+ result_filename, strerror(errno));
+ close_softrefs_file(&sorted);
+ close_softrefs_file(&unsorted);
+ if (ret) { /* Failure. Delete result_filename */
+ if (result_filename && unlink(result_filename))
+ error("Failed to remove merge result file %s: %s",
+ result_filename, strerror(errno));
+ }
+ else { /* Success. Replace sorted_filename with result_filename */
+ if (rename(result_filename, sorted_filename))
+ ret = error("Failed to replace sorted softrefs file %s: %s",
+ sorted_filename, strerror(errno));
+ }
+ return ret;
+}
+
+/*
+ * Merge the sorted softref entries in 'from_file' into 'to_file'
+ *
+ * Returns 0 on success; non-zero on failure.
+ *
+ * If to_file does not exist, from_file will be copied into to_file.
+ * If from_file does not exist, this function will do nothing and return 0.
+ */
+static int merge_sorted_into_sorted(const char *from_file, const char *to_file)
+{
+ struct softrefs_file file1, file2;
+ char *result_filename = 0;
+ int result_fd = -1;
+ int ret = 0;
+ unsigned long i, j;
+ /* keep track of last processed entry, to remove duplicates */
+ struct softrefs_entry *prev = NULL;
+
+ /* Open input files */
+ deinit_softrefs_access();
+ open_softrefs_file(from_file, &file1);
+ if (!file1.data_len) { /* no entries; nothing to do */
+ close_softrefs_file(&file1);
+ return 0;
+ }
+ open_softrefs_file(to_file, &file2);
+
+ /* Create result file */
+ result_filename = xmalloc(strlen(to_file) + 4);
+ sprintf(result_filename, "%s.new", to_file);
+ result_fd = open(result_filename, O_WRONLY|O_CREAT|O_EXCL|O_TRUNC, 0666);
+ if (result_fd < 0) {
+ ret = error("Failed to open merge result file %s: %s",
+ result_filename, strerror(errno));
+ goto done;
+ }
+
+ i = 0; /* index into file1.data */
+ j = 0; /* index into file2.data */
+ while (!ret && (i < file1.data_len || j < file2.data_len)) {
+ /* there are still entries in either list */
+ struct softrefs_entry *cur;
+ unsigned char from_sha1[20], to_sha1[20];
+ if (i < file1.data_len && j < file2.data_len) {
+ /* there are still entries in _both_ lists */
+ /* choose "lowest" entry from either list */
+ if (softrefs_entry_cmp(&(file1.data[i]), &(file2.data[j])) < 0)
+ cur = &(file1.data[i++]);
+ else
+ cur = &(file2.data[j++]);
+ }
+ else if (i < file1.data_len) /* entries left in file1.data */
+ cur = &(file1.data[i++]);
+ else /* entries left in file2.data */
+ cur = &(file2.data[j++]);
+
+ if (prev && !softrefs_entry_cmp(prev, cur))
+ continue; /* skip writing if cur and prev are duplicates */
+ prev = cur;
+
+ /* skip writing if softref involves a non-existing object */
+ if (get_sha1_hex(cur->from_sha1_hex, from_sha1) ||
+ !has_sha1_file(from_sha1) ||
+ get_sha1_hex(cur->to_sha1_hex, to_sha1) ||
+ !has_sha1_file( to_sha1))
+ {
+ continue;
+ }
+
+ ret = write_entry(result_fd, cur);
+ }
+
+done:
+ if (result_fd >= 0 && close(result_fd))
+ ret = error("Failed to close merge result file %s: %s",
+ result_filename, strerror(errno));
+ close_softrefs_file(&file2);
+ close_softrefs_file(&file1);
+ if (ret) { /* Failure. Delete result_filename */
+ if (result_filename && unlink(result_filename))
+ error("Failed to remove merge result file %s: %s",
+ result_filename, strerror(errno));
+ }
+ else { /* Success. Replace to_file with result_filename */
+ if (rename(result_filename, to_file))
+ ret = error("Failed to replace sorted softrefs file %s: %s",
+ to_file, strerror(errno));
+ }
+ return ret;
+}
+
+/* See softrefs.h for documentation */
+int add_softrefs(const struct softref_list *list)
+{
+ struct softrefs_entry entry;
+ int fd;
+ struct stat st;
+ int ret = 0;
+
+ /* Close internal softrefs file, if initialized. */
+ deinit_softrefs_access();
+
+ /* FIXME: File locking!? */
+ fd = open(git_path(UNSORTED_FILENAME), O_WRONLY|O_APPEND|O_CREAT, 0666);
+ if (fd < 0)
+ return error("Failed to open softrefs file %s: %s",
+ git_path(UNSORTED_FILENAME), strerror(errno));
+ if (fstat(fd, &st))
+ return error("Failed to fstat softrefs file %s: %s",
+ git_path(UNSORTED_FILENAME), strerror(errno));
+ if (st.st_size % sizeof(struct softrefs_entry))
+ return error("Refuse to edit softrefs file %s: File does not have whole number of softref entries",
+ git_path(UNSORTED_FILENAME));
+
+ /* File is open; start writing entries */
+ while (list) {
+ if (!hashcmp(list->from_sha1, list->to_sha1)) {
+ /* self-reference: from_sha1 == to_sha1 */
+ error("Cannot add self-reference (%s -> %s)",
+ sha1_to_hex(list->from_sha1),
+ sha1_to_hex(list->to_sha1));
+ }
+ else if (has_softref(list->from_sha1, list->to_sha1)) {
+ /* softref exists already */
+ /* nada */;
+ }
+ else { /* softref is ok */
+ strcpy(entry.from_sha1_hex, sha1_to_hex(list->from_sha1));
+ strcpy(entry.to_sha1_hex, sha1_to_hex(list->to_sha1));
+ entry.space = ' ';
+ entry.lf = '\n';
+ if (write_entry(fd, &entry))
+ error("Failed to write entry to softrefs file %s: %s",
+ git_path(UNSORTED_FILENAME),
+ strerror(errno));
+ else /* write_entry() succeeded */
+ ret++;
+ }
+ list = list->next;
+ }
+
+ /* finished writing entries */
+ if (close(fd))
+ return error("Failed to close softrefs file %s: %s",
+ git_path(UNSORTED_FILENAME), strerror(errno));
+
+ merge_unsorted_softrefs(NULL, 0);
+ return ret;
+}
+
+/* See softrefs.h for documentation */
+int add_softref(const unsigned char *from_sha1, const unsigned char *to_sha1)
+{
+ struct softref_list l;
+ int ret;
+
+ if (!hashcmp(from_sha1, to_sha1))
+ return error("Cannot add self-reference (%s -> %s)",
+ sha1_to_hex(from_sha1), sha1_to_hex(to_sha1));
+
+ hashcpy(l.from_sha1, from_sha1);
+ hashcpy(l.to_sha1, to_sha1);
+ l.next = NULL;
+ ret = add_softrefs(&l);
+ switch (ret) {
+ case 0: return 1;
+ case 1: return 0;
+ default: return -1;
+ }
+}
+
+/* See softrefs.h for documentation */
+int merge_unsorted_softrefs(const char *unsorted_file, int force)
+{
+ struct stat st;
+ int num_entries;
+ int delete_file = 0; /* set to true to delete unsorted_file afterwards */
+ int ret = 0;
+
+ if (unsorted_file == NULL) { /* use UNSORTED_FILENAME */
+ unsorted_file = git_path(UNSORTED_FILENAME);
+ delete_file = 1;
+ if (access(unsorted_file, F_OK))
+ /* UNSORTED_FILENAME doesn't exist; nothing to do */
+ return 0;
+ }
+ else {
+ force = 1; /* no threshold on merging external file */
+ if (access(unsorted_file, F_OK))
+ /* external unsorted file doesn't exist; failure */
+ return error("Failed to access softrefs file %s: %s",
+ unsorted_file, strerror(errno));
+ }
+
+ if (stat(unsorted_file, &st))
+ return error("Failed to stat() softrefs file %s: %s",
+ unsorted_file, strerror(errno));
+ if (st.st_size % sizeof(struct softrefs_entry))
+ return error("Corrupt softrefs file %s: Aborting",
+ unsorted_file);
+ if (st.st_size == 0) /* file is empty; nothing to do */
+ return 0;
+ num_entries = st.st_size / sizeof(struct softrefs_entry);
+ if (force || num_entries > MAX_UNSORTED_ENTRIES) { /* do it */
+ ret = merge_unsorted_into_sorted(
+ unsorted_file, git_path(SORTED_FILENAME));
+ if (!ret && delete_file && unlink(unsorted_file))
+ error("Failed to remove unsorted softrefs file %s: %s",
+ unsorted_file, strerror(errno));
+ }
+ return ret;
+}
+
+/* See softrefs.h for documentation */
+int merge_sorted_softrefs(const char *sorted_file)
+{
+ struct stat st;
+ if (access(sorted_file, F_OK)) /* external file doesn't exist; FAIL */
+ return error("Failed to access softrefs file %s: %s",
+ sorted_file, strerror(errno));
+ if (stat(sorted_file, &st))
+ return error("Failed to stat() softrefs file %s: %s",
+ sorted_file, strerror(errno));
+ if (st.st_size % sizeof(struct softrefs_entry))
+ return error("Corrupt softrefs file %s: Aborting", sorted_file);
+ if (st.st_size == 0) /* file is empty; nothing to do */
+ return 0;
+ return merge_sorted_into_sorted(sorted_file, git_path(SORTED_FILENAME));
+}
--
1.5.2.1.144.gabc40
^ permalink raw reply related
* [PATCH 1/7] Softrefs: Add softrefs header file with API documentation
From: Johan Herland @ 2007-06-09 18:21 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Linus Torvalds
In-Reply-To: <200706092019.13185.johan@herland.net>
See patch for documentation.
Signed-off-by: Johan Herland <johan@herland.net>
---
softrefs.h | 188 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 188 insertions(+), 0 deletions(-)
create mode 100644 softrefs.h
diff --git a/softrefs.h b/softrefs.h
new file mode 100644
index 0000000..db0f8b9
--- /dev/null
+++ b/softrefs.h
@@ -0,0 +1,188 @@
+#ifndef SOFTREFS_H
+#define SOFTREFS_H
+
+/*
+ * Softrefs is a general mechanism for declaring a relationship between two
+ * existing arbitrary objects in the repo. Softrefs differ from the existing
+ * reachability relationship in that a softref may be created after _both_ of
+ * the involved objects have been added to the repo. In contrast, the regular
+ * reachability relationship depends on the reachable object's name being
+ * stored _inside_ the other object. A reachability relationship can therefore
+ * not be created at a later time without violating the immutability of git
+ * objects.
+ *
+ * Softrefs are defined as going _from_ one object _to_ another object. Once
+ * a softref between two objects has been created, the "to" object is
+ * considered reachable from the "from" object.
+ *
+ * Also, softrefs are stored in a way that makes it easy and quick to find all
+ * the "to" objects reachable from a given "from" object.
+ *
+ * The softrefs db consists of two files: .git/softrefs.unsorted and
+ * .git/softrefs.sorted. Both files use the same format; one softref per line
+ * of the form "<from-sha1> <to-sha1>\n". Each sha1 sum is 40 bytes long; this
+ * makes each entry exactly 82 bytes long (including the space between the sha1
+ * sums and the terminating linefeed).
+ *
+ * The entries in .git/softrefs.sorted are sorted on <from-sha1>, in order to
+ * make lookup fast.
+ *
+ * The entries in .git/softrefs.unsorted are _not_ sorted. This is to make
+ * insertion fast.
+ *
+ * When softrefs are created (by calling add_softref()/add_softrefs()), they
+ * are appended to .git/softrefs.unsorted. When .git/softrefs.unsorted reach a
+ * certain number of entries (determined by MAX_UNSORTED_ENTRIES), all the
+ * entries in .git/softrefs.unsorted are merged into .git/softrefs.sorted.
+ *
+ * Soft references are used as a reverse mapping between tag objects and their
+ * corresponding tagged objects. For each tag object, a soft reference _to_
+ * the tag object _from_ the tagged object is created. Given an arbitrary
+ * object X in the database, softrefs allow for easy lookup of which tag
+ * objects that point to object X.
+ */
+
+/*
+ * Simple list of softrefs
+ */
+struct softref_list {
+ struct softref_list *next;
+ unsigned char from_sha1[20];
+ unsigned char to_sha1[20];
+};
+
+/* Callback function type; used as parameter to for_each_softref()
+ *
+ * The functions takes the following arguments:
+ * - from_sha1 - The SHA1 of the 'from' object in the current softref
+ * - to_sha1 - The SHA1 of the 'to' object in the current softref
+ * - cb_data - as passed to for_each_softref()
+ *
+ * Return non-zero to stop for_each_softref() from iterating through.
+ */
+typedef int each_softref_fn(
+ const unsigned char *from_sha1,
+ const unsigned char *to_sha1,
+ void *cb_data);
+
+/*
+ * Invoke 'fn' with 'cb_data' for each object pointed to by 'from_sha1'
+ *
+ * If 'from_sha1' is NULL, 'fn' is invoked for _all_ softrefs in the db.
+ *
+ * If 'fn' returns non-zero for any given softref, iteration is stopped and the
+ * same return value is returned from this function. If other problems are
+ * encountered while iterating, -1 is returned. If all matching entries were
+ * iterated successfully, and 'fn' returned 0 for all of them, 0 is returned.
+ */
+extern int for_each_softref_with_from(
+ const unsigned char *from_sha1, each_softref_fn fn, void *cb_data);
+
+/*
+ * Invoke 'fn' with 'cb_data' for each softref stored in the db
+ *
+ * This function is identical to calling for_each_softref_with_from() with
+ * NULL as the first parameter.
+ */
+extern int for_each_softref(each_softref_fn fn, void *cb_data);
+
+/*
+ * Initialize/prepare the softrefs db for a lot of read-only access
+ *
+ * You may call this function before doing repeated calls to accessor functions
+ * such as:
+ * - for_each_softref_with_from()
+ * - for_each_softref()
+ * - lookup_softref()
+ * - has_softref()
+ *
+ * This function is purely optional, although it may improve performance when
+ * accessor functions are called repeatedly. The change in performance is
+ * caused by:
+ * 1. Merging unsorted softref entries into the sorted db file,
+ * 2. Doing open() and mmap() on the sorted db file (in order to avoid doing
+ * this on each subsequent call to an accessor function).
+ *
+ * When done accessing the softrefs db, the caller _must_ call
+ * deinit_softrefs_access() to properly deinitialize internal structures.
+ */
+extern void init_softrefs_access();
+
+/*
+ * Deinitialize internal structures associated with init_softrefs_access()
+ *
+ * Call this function when finished accessing softrefs after a call to
+ * init_softrefs_access().
+ */
+extern void deinit_softrefs_access();
+
+/*
+ * Look up the given object id in the softrefs db
+ *
+ * Returns a list of all the matching softrefs, i.e. softrefs whose from_sha1
+ * is identical to the given. If the given from_sha1 is NULL, all softrefs are
+ * returned.
+ *
+ * The entired softref_list returned (i.e. all elements retrievable by
+ * following the next pointer) must be free()d by the caller.
+ *
+ * You should consider using one of the for_each_softref*() functions instead,
+ * as those might save you some memory.
+ */
+extern struct softref_list *lookup_softref(const unsigned char *from_sha1);
+
+/*
+ * Delete (i.e. free()) all elements in the given softref_list
+ */
+extern void delete_softref_list(struct softref_list *list);
+
+/*
+ * Return 1 if there exists a softref between 'from_sha1' and 'to_sha1'
+ *
+ * Otherwise, return 0.
+ */
+extern int has_softref(
+ const unsigned char *from_sha1, const unsigned char *to_sha1);
+
+/*
+ * Add all the softrefs given in the given 'list' to the db.
+ *
+ * Returns the number of softrefs added, or -1 on failure to add any softrefs.
+ */
+extern int add_softrefs(const struct softref_list *list);
+
+/*
+ * Add a softref between 'from_sha1' and 'to_sha1'
+ *
+ * 'from_sha1' and 'to_sha1' are two 20-byte object ids.
+ * Returns 0 on success, 1 if the softref already exists, -1 on failure.
+ */
+extern int add_softref(
+ const unsigned char *from_sha1, const unsigned char *to_sha1);
+
+/*
+ * Merge softrefs found in the given unsorted softrefs file into the sorted db
+ *
+ * If 'unsorted_file' is NULL, the internal unsorted db file is merged.
+ *
+ * Note that this routine is automatically invoked by add_softrefs() and
+ * add_softref() to control the size of the unsorted db file.
+ *
+ * If 'unsorted_file' is NULL, the merging is only done if the number of
+ * softrefs in the unsorted db file exceed a fixed threshold (see
+ * MAX_UNSORTED_ENTRIES). However, if 'force' is set, the merging will be done
+ * regardless. Passing anything other than NULL for 'unsorted_file'
+ * automatically turns on 'force'.
+ *
+ * Returns 0 on success; non-zero if problems were encountered.
+ */
+extern int merge_unsorted_softrefs(const char *unsorted_file, int force);
+
+/*
+ * Merge softrefs found in the given sorted softrefs file into the sorted db
+ *
+ * Returns 0 on success; non-zero if problems were encountered.
+ */
+extern int merge_sorted_softrefs(const char *sorted_file);
+
+#endif /* SOFTREFS_H */
--
1.5.2.1.144.gabc40
^ permalink raw reply related
* [PATCH 0/7] Introduce soft references (softrefs)
From: Johan Herland @ 2007-06-09 18:19 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Linus Torvalds
In-Reply-To: <200706040251.05286.johan@herland.net>
This patch series introduces soft references (softrefs); a mechanism for
declaring reachability between arbitrary (but existing) git objects.
Softrefs are meant to provide the mechanism for "reverse mapping" that
we determined was needed for tag objects (especially 'notes'). The patch
series also teaches git-mktag to create softrefs for all tag objects.
See the Discussion section in the git-softref manual page (patch #4/7) or
the comments in the header file (patch #1/7) for more details on the
design of softrefs.
I've added some informal performance data at the bottom of this mail [1].
Note that this patch series is incomplete in that the following things
have yet to be implemented:
1. Clone/fetch/push of softrefs
2. Packing of softrefs
3. General integration of softrefs into parts of git where they might be
useful
4. Find appropriate value for MAX_UNSORTED_ENTRIES
There are also some questions connected to the above list of todos:
1. Just how should softrefs affect reachability? Should softrefs be
used/followed in _all_ reachability computations? If not, which?
2. How should softrefs propagate. I suggest they are pretty much always
propagated under clone/fetch/push. (Note that the softrefs merge
algorithm in softrefs.c removes duplicates and softrefs between
non-existing objects, so pre-filtering of the softrefs to be
clones/fetched/pushed may not be necessary)
3. Where can softrefs be used to improve performance by replacing existing
techniques?
4. How to best pack softrefs? Keeping them in the same pack as the objects
they refer to seems to be a good idea, but more thought needs to be put
into this before we can make an implementation
5. How to find _all_ (even unreachable) tag objects in repo for
'git-softref --rebuild-tags'?
6. Optimization. Pretty much nothing has been done so far. Performance
seems to be acceptable for now. Probably needs more testing to
determine bottlenecks
NOTE: After the 7 patches, I will send an _optional_ patch
that changes the softrefs entries from text format (82 bytes per entry)
to binary format (40 bytes per entry). The patch is optional, because
I want the list to decide if we want the (marginal) speedup and
simplified code provided by the patch, or if we want to keep the
read-/maintainability of the text format. Currently I'm in favour of
keeping the text format, but I'm far from sure.
Finally, here's the shortlog: (This patch series of course goes on top of
the previous "Refactor the tag object" patch series, although there isn't
really that many dependencies between them):
Johan Herland (7):
Softrefs: Add softrefs header file with API documentation
Softrefs: Add implementation of softrefs API
Softrefs: Add git-softref, a builtin command for adding, listing and administering softrefs
Softrefs: Add manual page documenting git-softref and softrefs subsystem in general
Softrefs: Add testcases for basic softrefs behaviour
Softrefs: Administrivia associated with softrefs subsystem and git-softref builtin
Teach git-mktag to register softrefs for all tag objects
.gitignore | 1 +
Documentation/cmd-list.perl | 7 +-
Documentation/git-softref.txt | 119 +++++++
Makefile | 6 +-
builtin-softref.c | 167 ++++++++++
builtin.h | 1 +
git.c | 1 +
mktag.c | 11 +-
softrefs.c | 712 +++++++++++++++++++++++++++++++++++++++++
softrefs.h | 188 +++++++++++
t/t3050-softrefs.sh | 314 ++++++++++++++++++
11 files changed, 1521 insertions(+), 6 deletions(-)
create mode 100644 Documentation/git-softref.txt
create mode 100644 builtin-softref.c
create mode 100644 softrefs.c
create mode 100644 softrefs.h
create mode 100755 t/t3050-softrefs.sh
Have fun!
...Johan
[1] Informal performance measurements
I prepared a linux kernel repo (holding 57274 commits) with 10 tag objects,
and created softrefs from every commit to every tag object (572740 softrefs
in total). The resulting softrefs db was 46964680 bytes. The experiment was
done on a 32-bit Intel Pentium 4 (3 GHz w/HyperThreading) with 1 GB RAM:
========
Operations on unsorted softrefs:
(572740 (10 per commit) entries in random/unsorted order)
========
Listing all softrefs
(sequential reading of unsorted softrefs file)
--------
$ /usr/bin/time git softref --list > /dev/null
0.44user 0.02system 0:00.47elapsed 98%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+11786minor)pagefaults 0swaps
Listing HEAD's softrefs
(sequential reading of unsorted softrefs file)
--------
$ /usr/bin/time git softref --list HEAD > /dev/null
0.11user 0.01system 0:00.14elapsed 94%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+11790minor)pagefaults 0swaps
Sorting softrefs
--------
$ /usr/bin/time git softref --merge-unsorted
2.73user 4.97system 0:07.77elapsed 99%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+15833minor)pagefaults 0swaps
Sorting softrefs into existing sorted file
(throwing away duplicates)
--------
$ /usr/bin/time git softref --merge-unsorted
3.49user 5.12system 0:08.64elapsed 99%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+27300minor)pagefaults 0swaps
========
Operations on sorted softrefs:
(572740 (10 per commit) entries in sorted order)
========
Listing all softrefs
(sequential reading of sorted softrefs file)
--------
$ /usr/bin/time git softref --list > /dev/null
0.43user 0.02system 0:00.48elapsed 96%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+11786minor)pagefaults 0swaps
Listing HEAD's softrefs
(256-fanout followed by binary search in sorted softrefs file)
--------
$/usr/bin/time git softref --list HEAD > /dev/null
0.00user 0.00system 0:00.00elapsed 0%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+334minor)pagefaults 0swaps
Sorting softrefs
(no-op)
--------
$ /usr/bin/time git softref --merge-unsorted
0.00user 0.00system 0:00.00elapsed 0%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+312minor)pagefaults 0swaps
--
Johan Herland, <johan@herland.net>
www.herland.net
^ permalink raw reply
* Re: [PATCH 04/21] Refactor verification of "tagger" line to be more similar to verification of "type" and "tagger" lines
From: Junio C Hamano @ 2007-06-09 18:01 UTC (permalink / raw)
To: Johan Herland; +Cc: git, Johannes Schindelin
In-Reply-To: <200706090214.11589.johan@herland.net>
Johan Herland <johan@herland.net> writes:
> Also update selftests to reflect that verification of "tagger" now
> happens _before_ verification of type name, object sha1 and tag name.
>
> Signed-off-by: Johan Herland <johan@herland.net>
> ---
> mktag.c | 16 ++++++++--------
> t/t3800-mktag.sh | 3 +++
> tag.c | 6 +++---
> 3 files changed, 14 insertions(+), 11 deletions(-)
>
> diff --git a/mktag.c b/mktag.c
> index 0bc20c8..4dbefab 100644
> --- a/mktag.c
> +++ b/mktag.c
> @@ -62,12 +62,18 @@ static int verify_tag(char *data, unsigned long size)
>
> /* Verify tag-line */
> tag_line = strchr(type_line, '\n');
> - if (!tag_line)
> + if (!tag_line++)
> return error("char" PD_FMT ": could not find next \"\\n\"", type_line - data);
> - tag_line++;
Code churn "while we are at it" makes reviewing the rest more
cumbersome. A clean-up like this should be a separate patch.
> diff --git a/tag.c b/tag.c
> index 8d31603..19c66cd 100644
> --- a/tag.c
> +++ b/tag.c
> @@ -73,10 +73,10 @@ static int parse_tag_buffer_internal(struct tag *item, const char *data, const u
> if (memcmp(tag_line, "tag ", 4) || tag_line[4] == '\n')
> return error("char" PD_FMT ": no \"tag \" found", tag_line - data);
>
> + /* Verify the tagger line */
> tagger_line = strchr(tag_line, '\n');
> - if (!tagger_line)
> - return -1;
> - tagger_line++;
> + if (!tagger_line++)
> + return error("char" PD_FMT ": could not find next \"\\n\"", tag_line - data);
>
> /* Get the actual type */
> type_len = tag_line - type_line - strlen("type \n");
Same comments on extra verbosity, as for [2/21].
^ permalink raw reply
* Re: [PATCH 05/21] Make parse_tag_buffer_internal() handle item == NULL
From: Junio C Hamano @ 2007-06-09 18:01 UTC (permalink / raw)
To: Johan Herland; +Cc: git, Johannes Schindelin
In-Reply-To: <200706090214.39337.johan@herland.net>
Johan Herland <johan@herland.net> writes:
> This is in preparation for unifying verify_tag() and
> parse_tag_buffer_internal().
>
> Signed-off-by: Johan Herland <johan@herland.net>
> ---
> tag.c | 54 +++++++++++++++++++++++++++++-------------------------
> 1 files changed, 29 insertions(+), 25 deletions(-)
>
> diff --git a/tag.c b/tag.c
> index 19c66cd..b134967 100644
> --- a/tag.c
> +++ b/tag.c
> @@ -46,9 +46,11 @@ static int parse_tag_buffer_internal(struct tag *item, const char *data, const u
> const char *type_line, *tag_line, *tagger_line;
> unsigned long type_len, tag_len;
>
> - if (item->object.parsed)
> - return 0;
> - item->object.parsed = 1;
> + if (item) {
> + if (item->object.parsed)
> + return 0;
> + item->object.parsed = 1;
> + }
>
> if (size < 64)
> return error("failed preliminary size check");
Passing both item and data does not feel right. If you are
trying to make the factored out function to do the verification
of data, then perhaps the caller should do the "don't handle the
same data twice" optimization using item?
^ permalink raw reply
* Re: [PATCH 02/21] Return error messages when parsing fails.
From: Junio C Hamano @ 2007-06-09 18:01 UTC (permalink / raw)
To: Johan Herland; +Cc: git, Johannes Schindelin
In-Reply-To: <200706090213.16031.johan@herland.net>
Johan Herland <johan@herland.net> writes:
> This patch brings the already similar tag.c:parse_tag_buffer() and
> mktag.c:verify_tag() a little bit closer to eachother.
While I would agree that it makes sense to have the same
definition of what is and is not a 100% well formatted tag
object for producer side and consumer side, I do not necessarily
think it is a good idea to make parse_tag_buffer() chattier on
errors. mktag.c:verify_tag() can afford to be verbose in its
diagnosis, because it is used when the user is _creating_ the
tag, and it is generally a good idea to be strict when we
create.
On the other hand, parse_tag_buffer() is on the side of users
who use existing tag objects that were produced by somebody
else. It is generally a good practice to be more lenient when
you are consuming.
Also, callers of parse_tag_buffer() know the function is silent
on errors (unless there is something seriously wrong with the
repository); they do their own error messages when they get an
error return.
^ permalink raw reply
* [PATCH] Introduce light weight commit annotations
From: Johannes Schindelin @ 2007-06-09 17:55 UTC (permalink / raw)
To: git, gitster, Johan Herland
With the provided script, edit-commit-annotations, you can add
after-the-fact annotations to commits, which will be shown by
the log if the config variable core.showannotations is set.
The annotations are tracked in a new ref, refs/annotations/commits,
in the same fan-out style as .git/objects/??/*, only that they only
exist in the object database now.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
I have the hunch that this will be relatively fast and scalable,
since the tree objects are sorted by name (the name being the
object name of the to-be-annotated commit).
I'm on the run for 15 hours now, but please feel free to discuss
and / or trash it while I'm away.
cache.h | 1 +
commit.c | 48 ++++++++++++++++++++++++++++++++++++++++-
config.c | 5 ++++
environment.c | 1 +
git-edit-commit-annotation.sh | 46 +++++++++++++++++++++++++++++++++++++++
5 files changed, 100 insertions(+), 1 deletions(-)
create mode 100755 git-edit-commit-annotation.sh
diff --git a/cache.h b/cache.h
index bc6b8e8..4166888 100644
--- a/cache.h
+++ b/cache.h
@@ -288,6 +288,7 @@ extern size_t packed_git_window_size;
extern size_t packed_git_limit;
extern size_t delta_base_cache_limit;
extern int auto_crlf;
+extern int show_commit_annotations;
#define GIT_REPO_VERSION 0
extern int repository_format_version;
diff --git a/commit.c b/commit.c
index 4ca4d44..409ebc8 100644
--- a/commit.c
+++ b/commit.c
@@ -911,6 +911,48 @@ static long format_commit_message(const struct commit *commit,
return strlen(buf);
}
+static unsigned long show_annotations(const struct commit *commit,
+ char *buf, unsigned long space)
+{
+ char name[80];
+ const char *hex = sha1_to_hex(commit->object.sha1);
+ unsigned char sha1[20];
+ char *msg;
+ unsigned long offset = 0, msgoffset = 0, msglen;
+ enum object_type type;
+
+ snprintf(name, sizeof(name),
+ "refs/annotations/commits:%.*s/%.*s",
+ 2, hex, 38, hex + 2);
+ if (get_sha1(name, sha1))
+ return 0;
+
+ if (!(msg = read_sha1_file(sha1, &type, &msglen)) || !msglen)
+ return 0;
+ /* we will end the annotation by a newline anyway. */
+ if (msg[msglen - 1] == '\n')
+ msglen--;
+
+ offset += snprintf(buf + offset, space - offset - 1,
+ "\nAnnotation:\n");
+
+ for (msgoffset = 0; msgoffset < msglen;) {
+ int linelen = get_one_line(msg + msgoffset, msglen);
+
+ offset += snprintf(buf + offset, space - offset - 1,
+ " %.*s", linelen, msg + msgoffset);
+
+ if (offset + 1 >= space)
+ break;
+
+ msgoffset += linelen;
+ }
+ buf[offset++] = '\n';
+ free(msg);
+
+ return offset;
+}
+
unsigned long pretty_print_commit(enum cmit_fmt fmt,
const struct commit *commit,
unsigned long len,
@@ -1098,8 +1140,12 @@ unsigned long pretty_print_commit(enum cmit_fmt fmt,
*/
if (fmt == CMIT_FMT_EMAIL && !body)
buf[offset++] = '\n';
- buf[offset] = '\0';
+ if (fmt != CMIT_FMT_ONELINE && show_commit_annotations)
+ offset += show_annotations(commit,
+ buf + offset, space - offset);
+
+ buf[offset] = '\0';
free(reencoded);
return offset;
}
diff --git a/config.c b/config.c
index 58d3ed5..34db9b2 100644
--- a/config.c
+++ b/config.c
@@ -356,6 +356,11 @@ int git_default_config(const char *var, const char *value)
return 0;
}
+ if (!strcmp(var, "core.showannotaions")) {
+ show_commit_annotations = git_config_bool(var, value);
+ return 0;
+ }
+
if (!strcmp(var, "user.name")) {
strlcpy(git_default_name, value, sizeof(git_default_name));
return 0;
diff --git a/environment.c b/environment.c
index 8b9b89d..c649f19 100644
--- a/environment.c
+++ b/environment.c
@@ -32,6 +32,7 @@ size_t delta_base_cache_limit = 16 * 1024 * 1024;
int pager_in_use;
int pager_use_color = 1;
int auto_crlf = 0; /* 1: both ways, -1: only when adding git objects */
+int show_commit_annotations;
static const char *git_dir;
static char *git_object_dir, *git_index_file, *git_refs_dir, *git_graft_file;
diff --git a/git-edit-commit-annotation.sh b/git-edit-commit-annotation.sh
new file mode 100755
index 0000000..2abcd34
--- /dev/null
+++ b/git-edit-commit-annotation.sh
@@ -0,0 +1,46 @@
+#!/bin/sh
+
+USAGE="[commit-name]"
+. git-sh-setup
+
+test -n "$2" && usage
+COMMIT=$(git rev-parse --verify --default HEAD "$@")
+NAME=$(echo $COMMIT | sed "s/^../&\//")
+
+MESSAGE="$GIT_DIR"/COMMIT_ANNOTATION.$$
+git log -1 $COMMIT | sed "s/^/#/" > "$MESSAGE"
+
+GIT_INDEX_FILE="$MESSAGE".idx
+export GIT_INDEX_FILE
+
+TIPNAME=refs/annotations/commits
+OLDTIP=$(git show-ref $TIPNAME | cut -f 1 -d ' ')
+if [ -z "$OLDTIP" ]; then
+ OLDTIP=0000000000000000000000000000000000000000
+else
+ PARENT="-p $OLDTIP"
+ git read-tree $TIPNAME || die "Could not read index"
+ git cat-file blob :$NAME >> "$MESSAGE" 2> /dev/null
+fi
+
+${VISUAL:-${EDITOR:-vi}} "$MESSAGE"
+
+grep -v ^# < "$MESSAGE" | git stripspace > "$MESSAGE".processed
+mv "$MESSAGE".processed "$MESSAGE"
+if [ -z "$(cat "$MESSAGE")" ]; then
+ case $OLDTIP in 0000000000000000000000000000000000000000)
+ echo "Will not initialise with empty tree"
+ exit 1
+ esac
+ git update-index --force-remove $NAME ||
+ die "Could not update index"
+else
+ BLOB=$(git hash-object -w "$MESSAGE") ||
+ die "Could not write into object database"
+ git update-index --add --cacheinfo 0644 $BLOB $NAME ||
+ die "Could not write index"
+fi
+
+TREE=$(git write-tree) || die "Could not write tree"
+NEWTIP=$(date | git commit-tree $TREE $PARENT) || die "Could not annotate"
+git update-ref $TIPNAME $NEWTIP $OLDTIP
--
1.5.2.1.2713.gbb6a-dirty
^ permalink raw reply related
* Re: [PATCH] Add autoconf-based build infrastructure for tig
From: Steven Grimm @ 2007-06-09 17:47 UTC (permalink / raw)
To: Jonas Fonseca; +Cc: git
In-Reply-To: <20070609093101.GA25039@diku.dk>
Jonas Fonseca wrote:
> I've only played little with this patch, but overall I like most of the
> changes. I would, however, want to look into making the dependency on
> autoconf optional (like it is for git) and avoid using automake at all.
> It would make the autoconf.sh bootstrap script obsolete, since the
> Makefile can just take care of it, and it would keep the build system
> simple.
>
> So the idea is for configure to also generate a Makefile.config that can
> be sourced by the Makefile. Then of course inclusion of the config.h
> file should depend on some -DHAVE_CONFIG_H flag for the compiler.
>
> What do you think? You are of course welcome to come up with a patch for
> this proposal, but else I would like to get your permission/sign-off to
> include the configure.ac script and the tig.c changes you made.
That sounds perfectly sensible to me. Not sure when I'll have time to
work on that proposal, but in the meantime you can use whatever bits of
my original patch you like. Sorry about the lack of a Signed-off-by line
in the original post -- I use git for private stuff at work 99% of the
time and it sometimes slips my mind to add that extra header line for
public changes. So, retroactively (though if you like I can resend the
whole patch with this line):
Signed-off-by: Steven Grimm <koreth@midwinter.com>
-Steve
^ permalink raw reply
* [StGIT PATCH 2/2] Have mail take the default for --prefix from stgit.mail.prefix.
From: Yann Dirson @ 2007-06-09 17:25 UTC (permalink / raw)
To: Catalin Marinas; +Cc: git
In-Reply-To: <20070609172520.30912.80799.stgit@gandelf.nowhere.earth>
It is more convenient to set the prefix once and for all in the config
file than each time on command line.
---
stgit/commands/mail.py | 12 ++++++++++--
1 files changed, 10 insertions(+), 2 deletions(-)
diff --git a/stgit/commands/mail.py b/stgit/commands/mail.py
index cec1828..899cb1a 100644
--- a/stgit/commands/mail.py
+++ b/stgit/commands/mail.py
@@ -296,7 +296,11 @@ def __build_cover(tmpl, total_nr, msg_id, options):
if options.prefix:
prefix_str = options.prefix + ' '
else:
- prefix_str = ''
+ confprefix = config.get('stgit.mail.prefix')
+ if confprefix:
+ prefix_str = confprefix + ' '
+ else:
+ prefix_str = ''
total_nr_str = str(total_nr)
patch_nr_str = '0'.zfill(len(total_nr_str))
@@ -374,7 +378,11 @@ def __build_message(tmpl, patch, patch_nr, total_nr, msg_id, ref_id, options):
if options.prefix:
prefix_str = options.prefix + ' '
else:
- prefix_str = ''
+ confprefix = config.get('stgit.mail.prefix')
+ if confprefix:
+ prefix_str = confprefix + ' '
+ else:
+ prefix_str = ''
if options.diff_opts:
diff_flags = options.diff_opts.split()
^ permalink raw reply related
* [StGIT PATCH 1/2] Have series show empty hidden patches as hidden rather than empty.
From: Yann Dirson @ 2007-06-09 17:25 UTC (permalink / raw)
To: Catalin Marinas; +Cc: git
It is probably more important to show the hidden status of an empty
patch, since "clean" will not delete it anyway, and the display would
be ambiguous for a patch tagged "0" just before a patch tagged "!".
---
stgit/commands/series.py | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/stgit/commands/series.py b/stgit/commands/series.py
index 402356c..fe4e468 100644
--- a/stgit/commands/series.py
+++ b/stgit/commands/series.py
@@ -215,4 +215,4 @@ def func(parser, options, args):
__print_patch(p, branch_str, '- ', '0 ', max_len, options)
for p in hidden:
- __print_patch(p, branch_str, '! ', '0 ', max_len, options)
+ __print_patch(p, branch_str, '! ', '! ', max_len, options)
^ permalink raw reply related
* Re: [PATCH] git-mergetool: Allow gvimdiff to be used as a mergetool
From: Dan McGee @ 2007-06-09 17:17 UTC (permalink / raw)
To: Theodore Tso; +Cc: git
In-Reply-To: <20070606024545.GA32603@thunk.org>
On 6/5/07, Theodore Tso <tytso@mit.edu> wrote:
> Dan, your patch didn't add a gvimdiff check to the code which
> determins which merge tool to use if one isn't specified in the config
> file:
Here is an updated patch with that fix, and another that I just
discovered. gvim by default forks and does not run in the foreground,
so we need to call it with the '-f' flag to prevent this.
-Dan
>From b9c8873d63365c55b75bb2ec3d76c208f327b620 Mon Sep 17 00:00:00 2001
From: Dan McGee <dpmcgee@gmail.com>
Date: Tue, 5 Jun 2007 21:19:47 -0400
Subject: [PATCH] git-mergetool: Allow gvimdiff to be used as a mergetool
Signed-off-by: Dan McGee <dpmcgee@gmail.com>
---
Documentation/config.txt | 2 +-
Documentation/git-mergetool.txt | 2 +-
git-mergetool.sh | 12 ++++++++++--
3 files changed, 12 insertions(+), 4 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 5868d58..3ca01af 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -531,7 +531,7 @@ merge.summary::
merge.tool::
Controls which merge resolution program is used by
gitlink:git-mergetool[l]. Valid values are: "kdiff3", "tkdiff",
- "meld", "xxdiff", "emerge", "vimdiff", and "opendiff"
+ "meld", "xxdiff", "emerge", "vimdiff", "gvimdiff", and "opendiff".
merge.verbosity::
Controls the amount of output shown by the recursive merge
diff --git a/Documentation/git-mergetool.txt b/Documentation/git-mergetool.txt
index add01e8..34c4c1c 100644
--- a/Documentation/git-mergetool.txt
+++ b/Documentation/git-mergetool.txt
@@ -25,7 +25,7 @@ OPTIONS
-t or --tool=<tool>::
Use the merge resolution program specified by <tool>.
Valid merge tools are:
- kdiff3, tkdiff, meld, xxdiff, emerge, vimdiff, and opendiff
+ kdiff3, tkdiff, meld, xxdiff, emerge, vimdiff, gvimdiff, and opendiff
+
If a merge resolution program is not specified, 'git mergetool'
will use the configuration variable merge.tool. If the
diff --git a/git-mergetool.sh b/git-mergetool.sh
index bb21b03..c9a90cd 100755
--- a/git-mergetool.sh
+++ b/git-mergetool.sh
@@ -215,6 +215,12 @@ merge_file () {
check_unchanged
save_backup
;;
+ gvimdiff)
+ touch "$BACKUP"
+ gvimdiff -f -- "$LOCAL" "$path" "$REMOTE"
+ check_unchanged
+ save_backup
+ ;;
xxdiff)
touch "$BACKUP"
if base_present ; then
@@ -293,7 +299,7 @@ done
if test -z "$merge_tool"; then
merge_tool=`git-config merge.tool`
case "$merge_tool" in
- kdiff3 | tkdiff | xxdiff | meld | opendiff | emerge | vimdiff | "")
+ kdiff3 | tkdiff | xxdiff | meld | opendiff | emerge | vimdiff | gvimdiff | "")
;; # happy
*)
echo >&2 "git config option merge.tool set to unknown tool: $merge_tool"
@@ -312,6 +318,8 @@ if test -z "$merge_tool" ; then
merge_tool=xxdiff
elif type meld >/dev/null 2>&1 && test -n "$DISPLAY"; then
merge_tool=meld
+ elif type gvimdiff >/dev/null 2>&1 && test -n "$DISPLAY"; then
+ merge_tool=gvimdiff
elif type opendiff >/dev/null 2>&1; then
merge_tool=opendiff
elif type emacs >/dev/null 2>&1; then
@@ -325,7 +333,7 @@ if test -z "$merge_tool" ; then
fi
case "$merge_tool" in
- kdiff3|tkdiff|meld|xxdiff|vimdiff|opendiff)
+ kdiff3|tkdiff|meld|xxdiff|vimdiff|gvimdiff|opendiff)
if ! type "$merge_tool" > /dev/null 2>&1; then
echo "The merge tool $merge_tool is not available"
exit 1
--
1.5.2.1
^ permalink raw reply related
* Re: [PATCH] Correct tenses in documentation.
From: Junio C Hamano @ 2007-06-09 17:05 UTC (permalink / raw)
To: william pursell; +Cc: git
In-Reply-To: <466ACACC.3070801@gmail.com>
william pursell <bill.pursell@gmail.com> writes:
> In several of the text messages, the tense of the verb
> is inconsistent. For example, "Add" vs "Creates". This
> patch to the .txt files makes all of the verbs for
> the summaries be present tense. eg, "Creates" becomes
> "Create".
I find this sensible and matches the convention to use
imperative form; I do not think it is "present tense", but in
English they look the same.
Thanks.
^ permalink raw reply
* Re: [RFC] git integrated bugtracking
From: Jakub Narebski @ 2007-06-09 16:23 UTC (permalink / raw)
To: git
In-Reply-To: <20070609121244.GA2951@artemis>
Pierre Habouzit wrote:
> FWIW I've begun to work on this (for real). I've called the tool
> "grit". You can follow the developpement on:
>
> * gitweb: http://git.madism.org/?p=grit.git;a=summary
> * git: git://git.madism.org/grit.git/
I have added info about it at the bottom of
http://git.or.cz/gitwiki/InterfacesFrontendsAndTools
Feel free to correct and extend info.
--
Jakub Narebski
Warsaw, Poland
ShadeHawk on #git
^ permalink raw reply
* Re: problems with cloning; http vs git protocols?
From: A.J. Rossini @ 2007-06-09 15:57 UTC (permalink / raw)
To: Jeff King; +Cc: git
In-Reply-To: <20070609155521.GA3577@sigill.intra.peff.net>
Thanks much for politely pointing out my cluelessness. Honestly much
appreciated!
best,
-tony
On 6/9/07, Jeff King <peff@peff.net> wrote:
> On Sat, Jun 09, 2007 at 05:06:05PM +0200, A.J. Rossini wrote:
>
> > I've been working to verify it to write instructions for friends, and
> > here is the basic problem:
> >
> > git clone http://repo.or.cz/w/rclg.git
>
> That's the gitweb URL. Try visiting it in your web browser. The
> git-over-http URL is:
> http://repo.or.cz/r/rclg.git
>
> -Peff
>
--
best,
-tony
blindglobe@gmail.com
Muttenz, Switzerland.
"Commit early,commit often, and commit in a repository from which we
can easily roll-back your mistakes" (AJR, 4Jan05).
^ permalink raw reply
* Re: problems with cloning; http vs git protocols?
From: Jeff King @ 2007-06-09 15:55 UTC (permalink / raw)
To: A.J. Rossini; +Cc: git
In-Reply-To: <1abe3fa90706090806m4014a680x89178bc5698fefda@mail.gmail.com>
On Sat, Jun 09, 2007 at 05:06:05PM +0200, A.J. Rossini wrote:
> I've been working to verify it to write instructions for friends, and
> here is the basic problem:
>
> git clone http://repo.or.cz/w/rclg.git
That's the gitweb URL. Try visiting it in your web browser. The
git-over-http URL is:
http://repo.or.cz/r/rclg.git
-Peff
^ permalink raw reply
* [PATCH] Correct tenses in documentation.
From: william pursell @ 2007-06-09 15:44 UTC (permalink / raw)
To: git
In several of the text messages, the tense of the verb
is inconsistent. For example, "Add" vs "Creates". This
patch to the .txt files makes all of the verbs for
the summaries be present tense. eg, "Creates" becomes
"Create".
---
Documentation/git-archive.txt | 2 +-
Documentation/git-clone.txt | 2 +-
Documentation/git-prune.txt | 2 +-
3 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/Documentation/git-archive.txt b/Documentation/git-archive.txt
index 721e035..4da07c1 100644
--- a/Documentation/git-archive.txt
+++ b/Documentation/git-archive.txt
@@ -3,7 +3,7 @@ git-archive(1)
NAME
----
-git-archive - Creates an archive of files from a named tree
+git-archive - Create an archive of files from a named tree
SYNOPSIS
diff --git a/Documentation/git-clone.txt b/Documentation/git-clone.txt
index 2461c0e..4a5bab5 100644
--- a/Documentation/git-clone.txt
+++ b/Documentation/git-clone.txt
@@ -3,7 +3,7 @@ git-clone(1)
NAME
----
-git-clone - Clones a repository into a new directory
+git-clone - Clone a repository into a new directory
SYNOPSIS
diff --git a/Documentation/git-prune.txt b/Documentation/git-prune.txt
index 50ee5bd..0ace233 100644
--- a/Documentation/git-prune.txt
+++ b/Documentation/git-prune.txt
@@ -3,7 +3,7 @@ git-prune(1)
NAME
----
-git-prune - Prunes all unreachable objects from the object database
+git-prune - Prune all unreachable objects from the object database
SYNOPSIS
--
1.4.4.4
^ permalink raw reply related
* problems with cloning; http vs git protocols?
From: A.J. Rossini @ 2007-06-09 15:06 UTC (permalink / raw)
To: git
Greetings -
I've been working on a project that I'm finally making available to
others, and have set it up on repo.or.cz.
It originated as an SVN project on a private repository, and I've been
using git-svn for communication with the original repo.
After having pushed it up
( git push -v git+ssh://repo.or.cz/srv/git/rclg.git master:master
tonylocal:tonylocal )
I've been working to verify it to write instructions for friends, and
here is the basic problem:
git clone http://repo.or.cz/w/rclg.git
fails:
$ cd /tmp
$ git clone http://repo.or.cz/w/rclg.git/
Initialized empty Git repository in /tmp/rclg/.git/
/usr/bin/git-clone: line 381: cd: /tmp/rclg/.git/refs/remotes/origin:
No such file or directory
fatal: Not a valid object name HEAD
but
git clone git://repo.or.cz/rclg.git
works:
$ rm -rf rclg
$ git clone git://repo.or.cz/rclg.git
Initialized empty Git repository in /tmp/rclg/.git/
remote: Generating pack...
remote: Done counting 446 objects.
remote: Deltifying 446 objects...
remote: 100% (446/446) done
Indexing 446 objects...
remote: Total 446 (delta 239), reused 446 (delta 239)
100% (446/446) done
Resolving 239 deltas...
100% (239/239) done
?? Is there something I'm doing wrong with the push statement, or with
my git-svn work, or is it a bug, or have I just forgotten/misread a
step??
(I'd like to get http working for a few corporate firewall-hindered friends).
best,
-tony
blindglobe@gmail.com
Muttenz, Switzerland.
"Commit early,commit often, and commit in a repository from which we
can easily roll-back your mistakes" (AJR, 4Jan05).
^ permalink raw reply
* [PATCH 1/2] Show html help with git-help --html
From: Nguyen Thai Ngoc Duy @ 2007-06-09 15:03 UTC (permalink / raw)
To: git; +Cc: Frank Lichtenheld, junkio
In-Reply-To: <20070605183420.GA8450@localhost>
This patch was inspired by ClearCase command 'ct man', which
opens an html help file on Windows. I at first attempted to
implement it for MinGW port only but found it so useful that I
wanted to have it even in Linux.
A new option '--html' is added to git. When git-help is called
with --html, it will try to open an html file located at
$(docdir)/html using xdg-open. HTML files are not installed
by default so users have to install them manually or have their
distributors to do that.
There are two new config options introduced in this patch. The
first is core.help. It has one of three values: html, auto or
man. 'html' has the same effect as git-help --html. 'auto'
will in addition fall back to man pages if possible. 'man'
is 'I hate html, give me my man pages'. The second option is
core.htmlviewer, used to specify the program you want to
open html files instead of xdg-open. You can override the default
program by appending HTML_VIEWER=blah when calling make.
core.htmlviewer can contain %p, %f or %b. If none is given,
%p will be appended.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
This patch changes core.htmlprogram to core.htmlviewer and
mentions 'man' as default value for core.help as suggested
by Frank.
It also fixes a bug ignoring the remaining string after the
last %x in html command
Documentation/config.txt | 16 +++++
Documentation/git.txt | 5 +-
Makefile | 5 +-
cache.h | 2 +
config.c | 17 +++++
config.mak.in | 2 +
environment.c | 2 +
git.c | 2 +-
help.c | 161 +++++++++++++++++++++++++++++++++++++++++++++-
9 files changed, 207 insertions(+), 5 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index de408b6..2489b8e 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -262,6 +262,22 @@ core.excludeFile::
of files which are not meant to be tracked. See
gitlink:gitignore[5].
+core.help::
+ If 'html', it is equivalent to 'git-help' with option --html.
+ If 'auto', it tries to open html files first. If that attempt fails
+ (the html program does not exist or the program return non-zero
+ value), then it will fall back to man pages. If 'man', always use
+ man pages as usual. Default is 'man'.
+
+core.htmlviewer::
+ Specify the program used to open html help files when 'git-help'
+ is called with option --html or core.help is other than 'man'.
+ By default, xdg-open will be used.
+ Special strings '%p', '%f' and '%b' will be replaced with html
+ full path, file name and git command (without .html suffix)
+ respectively. If none is given, '%p' will be automatically appended
+ to the command line.
+
alias.*::
Command aliases for the gitlink:git[1] command wrapper - e.g.
after defining "alias.last = cat-file commit HEAD", the invocation
diff --git a/Documentation/git.txt b/Documentation/git.txt
index ba077c3..f1df402 100644
--- a/Documentation/git.txt
+++ b/Documentation/git.txt
@@ -10,7 +10,7 @@ SYNOPSIS
--------
[verse]
'git' [--version] [--exec-path[=GIT_EXEC_PATH]] [-p|--paginate]
- [--bare] [--git-dir=GIT_DIR] [--help] COMMAND [ARGS]
+ [--bare] [--git-dir=GIT_DIR] [--help [--html]] COMMAND [ARGS]
DESCRIPTION
-----------
@@ -87,6 +87,9 @@ OPTIONS
commands. If a git command is named this option will bring up
the man-page for that command. If the option '--all' or '-a' is
given then all available commands are printed.
+ If option '--html' is given, try opening html files instead of
+ using 'man'. The default program to open html files is xdg-open.
+ See 'git-config' to know how to change html program.
--exec-path::
Path to wherever your core git programs are installed.
diff --git a/Makefile b/Makefile
index 0f75955..7b3180a 100644
--- a/Makefile
+++ b/Makefile
@@ -186,6 +186,7 @@ export TCL_PATH TCLTK_PATH
# explicitly what architecture to check for. Fix this up for yours..
SPARSE_FLAGS = -D__BIG_ENDIAN__ -D__powerpc__
+HTML_VIEWER=xdg-open
### --- END CONFIGURATION SECTION ---
@@ -692,6 +693,7 @@ ETC_GITCONFIG_SQ = $(subst ','\'',$(ETC_GITCONFIG))
DESTDIR_SQ = $(subst ','\'',$(DESTDIR))
bindir_SQ = $(subst ','\'',$(bindir))
gitexecdir_SQ = $(subst ','\'',$(gitexecdir))
+html_dir_SQ = $(subst ','\'',$(html_dir))
template_dir_SQ = $(subst ','\'',$(template_dir))
prefix_SQ = $(subst ','\'',$(prefix))
@@ -740,7 +742,8 @@ git$X: git.c common-cmds.h $(BUILTIN_OBJS) $(GITLIBS) GIT-CFLAGS
$(ALL_CFLAGS) -o $@ $(filter %.c,$^) \
$(BUILTIN_OBJS) $(ALL_LDFLAGS) $(LIBS)
-help.o: common-cmds.h
+help.o: help.c common-cmds.h
+ $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) -DHTML_DIR='"$(html_dir_SQ)"' -DHTML_VIEWER='"$(HTML_VIEWER)"' $<
git-merge-subtree$X: git-merge-recursive$X
$(QUIET_BUILT_IN)rm -f $@ && ln git-merge-recursive$X $@
diff --git a/cache.h b/cache.h
index 5e7381e..60e586c 100644
--- a/cache.h
+++ b/cache.h
@@ -288,6 +288,8 @@ extern size_t packed_git_window_size;
extern size_t packed_git_limit;
extern size_t delta_base_cache_limit;
extern int auto_crlf;
+extern int show_html_help;
+extern const char *html_help_program;
#define GIT_REPO_VERSION 0
extern int repository_format_version;
diff --git a/config.c b/config.c
index 58d3ed5..9d91a06 100644
--- a/config.c
+++ b/config.c
@@ -382,6 +382,23 @@ int git_default_config(const char *var, const char *value)
return 0;
}
+ if (!strcmp(var, "core.help")) {
+ if (!strcmp(value, "auto"))
+ show_html_help = 2;
+ else if (!strcmp(value, "html"))
+ show_html_help = 1;
+ else if (!strcmp(value, "man"))
+ show_html_help = 0;
+ else
+ return 1;
+ return 0;
+ }
+
+ if (!strcmp(var, "core.htmlviewer")) {
+ html_help_program = xstrdup(value);
+ return 0;
+ }
+
/* Add other config variables here and to Documentation/config.txt. */
return 0;
}
diff --git a/config.mak.in b/config.mak.in
index a3032e3..c3e410d 100644
--- a/config.mak.in
+++ b/config.mak.in
@@ -8,12 +8,14 @@ TAR = @TAR@
#INSTALL = @INSTALL@ # needs install-sh or install.sh in sources
TCLTK_PATH = @TCLTK_PATH@
+PACKAGE_TARNAME=@PACKAGE_TARNAME@
prefix = @prefix@
exec_prefix = @exec_prefix@
bindir = @bindir@
#gitexecdir = @libexecdir@/git-core/
datarootdir = @datarootdir@
template_dir = @datadir@/git-core/templates/
+html_dir = @docdir@/html/
mandir=@mandir@
diff --git a/environment.c b/environment.c
index 8b9b89d..aa22c68 100644
--- a/environment.c
+++ b/environment.c
@@ -32,6 +32,8 @@ size_t delta_base_cache_limit = 16 * 1024 * 1024;
int pager_in_use;
int pager_use_color = 1;
int auto_crlf = 0; /* 1: both ways, -1: only when adding git objects */
+int show_html_help = 0;
+const char *html_help_program = NULL;
static const char *git_dir;
static char *git_object_dir, *git_index_file, *git_refs_dir, *git_graft_file;
diff --git a/git.c b/git.c
index 29b55a1..c3c0fe8 100644
--- a/git.c
+++ b/git.c
@@ -4,7 +4,7 @@
#include "quote.h"
const char git_usage_string[] =
- "git [--version] [--exec-path[=GIT_EXEC_PATH]] [-p|--paginate] [--bare] [--git-dir=GIT_DIR] [--help] COMMAND [ARGS]";
+ "git [--version] [--exec-path[=GIT_EXEC_PATH]] [-p|--paginate] [--bare] [--git-dir=GIT_DIR] [--help [--html]] COMMAND [ARGS]";
static void prepend_to_path(const char *dir, int len)
{
diff --git a/help.c b/help.c
index 1cd33ec..52474e9 100644
--- a/help.c
+++ b/help.c
@@ -9,6 +9,14 @@
#include "common-cmds.h"
#include <sys/ioctl.h>
+#ifndef HTML_DIR
+#define HTML_DIR "/usr/share/html/"
+#endif
+
+#ifndef HTML_VIEWER
+#define HTML_VIEWER "xdg-open"
+#endif
+
/* most GUI terminals set COLUMNS (although some don't export it) */
static int term_columns(void)
{
@@ -183,6 +191,140 @@ static void show_man_page(const char *git_cmd)
execlp("man", "man", page, NULL);
}
+static void show_html_page(const char *git_cmd)
+{
+ const char *html_dir;
+ int len, ret, nr_quotes;
+ char *p, *p2;
+ const char *cp, *cp2;
+ struct stat st;
+ char *quoted_git_cmd;
+ const char *command;
+
+ html_dir = HTML_DIR;
+ command = html_help_program ? html_help_program : HTML_VIEWER;
+
+ nr_quotes = 0;
+ for (cp = git_cmd; *cp; cp++)
+ if (*cp == '\'') nr_quotes ++;
+
+ len = strlen(git_cmd) + nr_quotes*2 + 2 + 4; /* two quotes and git- */
+ quoted_git_cmd = p2 = xmalloc(len + 1);
+ *p2++ = '\'';
+ if (prefixcmp(git_cmd, "git")) {
+ strcpy(p2,"git-");
+ p2 += 4;
+ }
+ for (cp = git_cmd; *cp; cp ++) {
+ if (*cp == '\'')
+ *p2++ = '\\';
+ *p2++ = *cp;
+ }
+ *p2++ = '\'';
+ *p2 = 0;
+
+ /* first pass, calculate command length */
+ cp = command;
+ len = 0;
+ while (*cp && (cp2 = strchr(cp, '%'))) {
+ len += cp2 - cp;
+
+ if (!cp2[1]) break;
+
+ switch (cp2[1]) {
+ case 'p':
+ len += strlen(html_dir) + strlen(quoted_git_cmd) + 5; /* .html */
+ break;
+
+ case 'f':
+ len += strlen(quoted_git_cmd) + 5; /* .html */
+ break;
+
+ case 'b':
+ len += strlen(quoted_git_cmd);
+ break;
+
+ default:
+ len += 2;
+ }
+ cp = cp2 + 2;
+ }
+ if (!len) /* no expansion, append %p */
+ len += 1 + strlen(html_dir) + strlen(quoted_git_cmd) + 5;
+ if (*cp)
+ len += strlen(cp);
+
+ /* second pass */
+ cp = command;
+ p = p2 = xmalloc(len + 1);
+ while (*cp && (cp2 = strchr(cp, '%'))) {
+ len = cp2 - cp;
+ memcpy(p2, cp, len);
+ p2 += len;
+
+ if (!cp2[1]) break;
+
+ switch (cp2[1]) {
+ case 'p':
+ len = strlen(html_dir);
+ memcpy(p2, html_dir, len);
+ p2 += len;
+
+ len = strlen(quoted_git_cmd);
+ memcpy(p2, quoted_git_cmd, len);
+ p2 += len;
+
+ memcpy(p2, ".html", 5);
+ p2 += 5;
+ break;
+
+ case 'f':
+ len = strlen(quoted_git_cmd);
+ memcpy(p2, quoted_git_cmd, len);
+ p2 += len;
+
+ memcpy(p2, ".html", 5);
+ p2 += 5;
+ break;
+
+ case 'b':
+ len = strlen(quoted_git_cmd);
+ memcpy(p2, quoted_git_cmd, len);
+ p2 += len;
+ break;
+
+ default:
+ *p2++ = cp2[0];
+ *p2++ = cp2[1];
+ }
+ cp = cp2+2;
+ }
+ if (*cp)
+ strcpy(p2,cp);
+ else
+ *p2 = 0;
+ if (p == p2) { /* no expansion, append %p */
+ strcat(p2, " ");
+ strcat(p2, html_dir);
+ strcat(p2, quoted_git_cmd);
+ strcat(p2, ".html");
+ }
+
+ free(quoted_git_cmd);
+
+ ret = system(p);
+
+ if (ret == -1)
+ error("Failed to run %s", p);
+
+ free(p);
+
+ /* fallback to man pages */
+ if (show_html_help > 1 && (ret == -1 || ret > 0))
+ show_man_page(git_cmd);
+ exit(ret);
+}
+
void help_unknown_cmd(const char *cmd)
{
printf("git: '%s' is not a git-command\n\n", cmd);
@@ -214,8 +356,23 @@ int cmd_help(int argc, const char **argv, const char *prefix)
exit(1);
}
- else
- show_man_page(help_cmd);
+ else {
+ git_config(git_default_config);
+ if (!strcmp(help_cmd, "--html")) {
+ help_cmd = argc > 2 ? argv[2] : NULL;
+ if (!help_cmd) {
+ printf("usage: %s\n\n", git_usage_string);
+ list_common_cmds_help();
+ exit(1);
+ }
+ show_html_help = 1;
+ }
+
+ if (show_html_help)
+ show_html_page(help_cmd);
+ else
+ show_man_page(help_cmd);
+ }
return 0;
}
--
1.5.2
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox