This is closely based on git-remote-nm (in ruby) by Felipe Contreras. Initially just implement the commands 'capabilites' and 'list'. This isn't enough to do anything useful so start some unit tests. Testing of URL passing will be done after clone (import command) support is added. --- Makefile.local | 7 +- git-remote-notmuch.c | 314 ++++++++++++++++++++++++++++++++++++++++ test/T860-git-remote.sh | 46 ++++++ 3 files changed, 366 insertions(+), 1 deletion(-) create mode 100644 git-remote-notmuch.c create mode 100755 test/T860-git-remote.sh diff --git a/Makefile.local b/Makefile.local index 7699c208..ffeb0d00 100644 --- a/Makefile.local +++ b/Makefile.local @@ -1,7 +1,8 @@ # -*- makefile-gmake -*- .PHONY: all -all: notmuch notmuch-shared build-man build-info ruby-bindings python-cffi-bindings notmuch-git nmbug +all: notmuch notmuch-shared git-remote-notmuch \ + build-man build-info ruby-bindings python-cffi-bindings notmuch-git nmbug ifeq ($(MAKECMDGOALS),) ifeq ($(shell cat .first-build-message 2>/dev/null),) @NOTMUCH_FIRST_BUILD=1 $(MAKE) --no-print-directory all @@ -274,6 +275,9 @@ notmuch: $(notmuch_client_modules) lib/libnotmuch.a util/libnotmuch_util.a parse notmuch-shared: $(notmuch_client_modules) lib/$(LINKER_NAME) $(call quiet,$(FINAL_NOTMUCH_LINKER) $(CFLAGS)) $(notmuch_client_modules) $(FINAL_NOTMUCH_LDFLAGS) -o $@ +git-remote-notmuch: git-remote-notmuch.o status.o tag-util.o query-string.o + $(call quiet,$(FINAL_NOTMUCH_LINKER) $(CFLAGS)) $^ $(FINAL_NOTMUCH_LDFLAGS) -o $@ + .PHONY: install install: all install-man install-info mkdir -p "$(DESTDIR)$(prefix)/bin/" @@ -302,6 +306,7 @@ endif SRCS := $(SRCS) $(notmuch_client_srcs) CLEAN := $(CLEAN) notmuch notmuch-shared $(notmuch_client_modules) +CLEAN := $(CLEAN) git-remote-notmuch git-remote-notmuch.o CLEAN := $(CLEAN) version.stamp notmuch-*.tar.gz.tmp CLEAN := $(CLEAN) .deps diff --git a/git-remote-notmuch.c b/git-remote-notmuch.c new file mode 100644 index 00000000..4afd198c --- /dev/null +++ b/git-remote-notmuch.c @@ -0,0 +1,314 @@ +/* notmuch - Not much of an email program, (just index and search) + * + * Copyright © 2023 Felipe Contreras + * Copyright © 2024 David Bremner + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see https://www.gnu.org/licenses/ . + * + * Authors: Felipe Contreras + * David Bremner <david@tethera.net> + */ + +#include <assert.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <notmuch.h> +#include "notmuch-client.h" +#include "path-util.h" +#include "hex-escape.h" +#include "string-util.h" +#include "tag-util.h" + +#define ASSERT(x) assert ((x)) + +/* File scope globals */ +const char *debug_flags = NULL; +FILE *log_file = NULL; + +/* For use with getline. */ +char *buffer = NULL; +size_t buffer_len = 0; + +static inline bool +equal_lastmod (const char *uuid1, unsigned long counter1, + const char *uuid2, unsigned long counter2) +{ + return (strcmp_null (uuid1, uuid2) == 0) && (counter1 == counter2); +} + +/* Error handling */ +static void +ensure (bool condition, const char *format, ...) +{ + va_list va_args; + + if (! condition) { + va_start (va_args, format); + vfprintf (stderr, format, va_args); + va_end (va_args); + fprintf (stderr, "\n"); + exit (EXIT_FAILURE); + } +} + +/* It is a (protocol) error to call this at/after EOF */ +static void +buffer_line (FILE *stream) +{ + ssize_t nread; + + nread = getline (&buffer, &buffer_len, stream); + ensure (nread >= 0, "getline %s", strerror (errno)); + chomp_newline (buffer); +} + +static GStrv +tokenize_buffer () +{ + char *tok = buffer; + size_t tok_len = 0; + + g_autoptr (GStrvBuilder) builder = g_strv_builder_new (); + + while ((tok = strtok_len (tok + tok_len, " \t\n", &tok_len))) { + g_strv_builder_take (builder, g_strndup (tok, tok_len)); + } + + return g_strv_builder_end (builder); +} + +static void +flog (const char *format, ...) +{ + va_list va_args; + + if (log_file) { + va_start (va_args, format); + vfprintf (log_file, format, va_args); + fflush (log_file); + va_end (va_args); + } +} + +static const char * +gmessage (GError *err) +{ + if (err) + return err->message; + else + return NULL; +} + +static void +str2ul (const char *str, unsigned long int *num_p) +{ + gboolean ret; + + g_autoptr (GError) gerror = NULL; + + ret = g_ascii_string_to_unsigned (str, 10, 0, G_MAXUINT64, num_p, &gerror); + ensure (ret, "converting %s to unsigned long: %s", str, gmessage (gerror)); +} + +static void +read_lastmod (const char *dir, char **uuid_out, unsigned long *counter_out) +{ + g_autoptr (GString) filename = g_string_new (dir); + unsigned long num = 0; + FILE *in; + + assert (uuid_out); + assert (counter_out); + + g_string_append (filename, "/lastmod"); + + in = fopen (filename->str, "r"); + if (! in) { + ensure (errno == ENOENT, "error opening lastmod file"); + *uuid_out = NULL; + *counter_out = 0; + } else { + g_auto (GStrv) tokens = NULL; + buffer_line (in); + + tokens = tokenize_buffer (); + + *uuid_out = tokens[0]; + str2ul (tokens[1], &num); + + flog ("loaded uuid = %s\tlastmod = %zu\n", tokens[0], num); + } + + *counter_out = num; + +} + +static void +cmd_capabilities () +{ + fputs ("import\nexport\nrefspec refs/heads/*:refs/notmuch/*\n\n", stdout); + fflush (stdout); +} + +static void +cmd_list (notmuch_database_t *db, const char *uuid, unsigned long lastmod) +{ + unsigned long db_lastmod; + const char *db_uuid; + + db_lastmod = notmuch_database_get_revision (db, &db_uuid); + + printf ("? refs/heads/master%s\n\n", + equal_lastmod (uuid, lastmod, db_uuid, db_lastmod) ? " unchanged" : ""); +} + +/* stubs since we cannot link with notmuch.o */ +const notmuch_opt_desc_t notmuch_shared_options[] = { + { } +}; + +const char *notmuch_requested_db_uuid = NULL; + +void +notmuch_process_shared_options (unused (notmuch_database_t *notmuch), + unused (const char *dummy)) +{ +} + +int +notmuch_minimal_options (unused (const char *subcommand), + unused (int argc), + unused (char **argv)) +{ + return 0; +} + +static notmuch_database_t * +open_database (const char *arg) +{ + notmuch_status_t status; + notmuch_database_t *notmuch; + const char *path = NULL; + const char *config = NULL; + const char *profile = NULL; + const char *scheme = NULL; + const char *uriquery = NULL; + g_autofree char *status_string = NULL; + + g_autoptr (GUri) uri = NULL; + g_autoptr (GHashTable) params = NULL; + g_autoptr (GError) gerror = NULL; + g_autoptr (GString) address = NULL; + + address = g_string_new (arg); + + scheme = g_uri_peek_scheme (address->str); + if (! scheme || (strcmp (scheme, "notmuch") != 0)) { + ASSERT (g_string_prepend (address, "notmuch://")); + } + + uri = g_uri_parse (address->str, G_URI_FLAGS_ENCODED_QUERY, &gerror); + ensure (uri, "unable to parse URL/address %s: %s\n", address->str, gmessage (gerror)); + + uriquery = g_uri_get_query (uri); + if (uriquery) { + flog ("uriquery = %s\n", uriquery); + params = g_uri_parse_params (uriquery, -1, "&", G_URI_PARAMS_NONE, &gerror); + ensure (params, "unable to parse parameters %s: %s\n", uriquery, gmessage (gerror)); + } + + if (strlen (g_uri_get_path (uri)) > 0) { + path = g_uri_get_path (uri); + config = ""; + } + + if (params) { + if (! path) + path = g_hash_table_lookup (params, "path"); + config = g_hash_table_lookup (params, "config"); + profile = g_hash_table_lookup (params, "profile"); + } + + flog ("url = %s\npath = %s\nconfig = %s\nprofile = %s\n", + address->str, path, config, profile); + + status = notmuch_database_open_with_config (path, + NOTMUCH_DATABASE_MODE_READ_WRITE, + config, + profile, + ¬much, + &status_string); + + ensure (status == 0, "open database: %s", status_string); + + return notmuch; +} + +int +main (int argc, char *argv[]) +{ + notmuch_status_t status; + notmuch_database_t *db; + unsigned long lastmod = 0; + char *uuid = NULL; + const char *nm_dir = NULL; + g_autofree char *status_string = NULL; + const char *git_dir; + ssize_t nread; + const char *log_file_name; + + debug_flags = getenv ("GIT_REMOTE_NM_DEBUG"); + log_file_name = getenv ("GIT_REMOTE_NM_LOG"); + + if (log_file_name) + log_file = fopen (log_file_name, "w"); + + ensure (argc >= 3, "usage: %s ALIAS URL\n", argv[0]); + + db = open_database (argv[2]); + + git_dir = getenv ("GIT_DIR"); + ensure (git_dir, "GIT_DIR not set"); + flog ("GIT_DIR=%s\n", git_dir); + + ASSERT (nm_dir = talloc_asprintf (db, "%s/%s", git_dir, "notmuch")); + + status = mkdir_recursive (db, nm_dir, 0700, &status_string); + ensure (status == 0, "mkdir: %s", status_string); + + read_lastmod (nm_dir, &uuid, &lastmod); + + while ((nread = getline (&buffer, &buffer_len, stdin)) != -1) { + char *s = buffer; + flog ("command = %s\n", buffer); + + /* skip leading space */ + while (*s && isspace (*s)) s++; + + if (! *s) + break; + + if (STRNCMP_LITERAL (s, "capabilities") == 0) + cmd_capabilities (); + else if (STRNCMP_LITERAL (s, "list") == 0) + cmd_list (db, uuid, lastmod); + + fflush (stdout); + flog ("finished command = %s\n", s); + } + flog ("finished loop\n"); + + notmuch_database_destroy (db); +} diff --git a/test/T860-git-remote.sh b/test/T860-git-remote.sh new file mode 100755 index 00000000..1a087611 --- /dev/null +++ b/test/T860-git-remote.sh @@ -0,0 +1,46 @@ +#!/usr/bin/env bash +test_description='git-remote-notmuch' +. $(dirname "$0")/test-lib.sh || exit 1 + +notmuch_sanitize_git() { + sed 's/^committer \(.*\) \(<[^>]*>\) [1-9][0-9]* [-+][0-9]*/committer \1 \2 TIMESTAMP TIMEZONE/' +} + +add_email_corpus + +mkdir repo + +git_tmp=$(mktemp -d gitXXXXXXXX) + +run_helper () { + env -u NOTMUCH_CONFIG GIT_DIR=${git_tmp} git-remote-notmuch dummy-alias "?config=${NOTMUCH_CONFIG}" +} + +export GIT_COMMITTER_NAME="Notmuch Test Suite" +export GIT_COMMITTER_EMAIL="notmuch@example.com" +export GIT_REMOTE_NM_DEBUG="s" +export GIT_REMOTE_NM_LOG=grn-log.txt +EXPECTED=$NOTMUCH_SRCDIR/test/git-remote.expected-output +MAKE_EXPORT_PY=$NOTMUCH_SRCDIR/test/make-export.py + +TAG_FILE="87/b1/4EFC743A.3060609@april.org/tags" + +test_begin_subtest 'capabilities' +echo capabilities | run_helper > OUTPUT +cat <<EOF > EXPECTED +import +export +refspec refs/heads/*:refs/notmuch/* + +EOF +test_expect_equal_file EXPECTED OUTPUT + +test_begin_subtest 'list' +echo list | run_helper > OUTPUT +cat <<EOF > EXPECTED +? refs/heads/master + +EOF +test_expect_equal_file EXPECTED OUTPUT + +test_done -- 2.43.0 _______________________________________________ notmuch mailing list -- notmuch@notmuchmail.org To unsubscribe send an email to notmuch-leave@notmuchmail.org