When we add a new name, up all of the cache limits, because we're probably

2002-03-25  Not Zed  <NotZed@Ximian.com>

        * camel-text-index.c (text_index_add_name): When we add a new
        name, up all of the cache limits, because we're probably going to
        be adding more.
        (text_index_sync): Drop the cache limits back down again, we dont
        need them when looking words up.

        ** MERGE camel_index branch.

        * camel-text-index.[ch]: Added files i forgot to add (eep nearly
        lost all this work!)

        * camel-block-file.c (sync_nolock): Fix an infinite loop in syncing.

svn path=/trunk/; revision=16242

1 files changed, 212 insertions, 0 deletions

diff --git a/camel/camel-index-control.c b/camel/camel-index-control.c
new file mode 100644
index 0000000000..9968278446
--- /dev/null
+++ b/camel/camel-index-control.c
@@ -0,0 +1,212 @@
+
+/* Command to manually force a compression/dump of an index file */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <ctype.h>
+#include <sys/stat.h>
+#include <sys/uio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "e-util/e-msgport.h"
+#include "e-util/e-memory.h"
+
+#include "camel/camel-object.h"
+
+#include "camel-text-index.h"
+
+#include <stdio.h>
+
+static void
+do_usage(char *argv0)
+{
+	fprintf(stderr, "Usage: %s [ compress | dump | info ] file(s) ...\n", argv0);
+	fprintf(stderr, " compress - compress (an) index file(s)\n");
+	fprintf(stderr, " dump - dump (an) index file's content to stdout\n");
+	fprintf(stderr, " info - dump summary info to stdout\n");
+	exit(1);
+}
+
+static int
+do_compress(int argc, char **argv)
+{
+	int i;
+	CamelIndex *idx;
+
+	for (i=2;i<argc;i++) {
+		printf("Opening index file: %s\n", argv[i]);
+		idx = (CamelIndex *)camel_text_index_new(argv[i], O_RDWR);
+		if (idx) {
+			printf(" Compressing ...\n");
+			if (camel_index_compress(idx) == -1) {
+				camel_object_unref((CamelObject *)idx);
+				return 1;
+			}
+			camel_object_unref((CamelObject *)idx);
+		} else {
+			printf(" Failed: %s\n", strerror(errno));
+			return 1;
+		}
+	}
+	return 0;
+}
+
+static int
+do_dump(int argc, char **argv)
+{
+	int i;
+	CamelIndex *idx;
+
+	for (i=2;i<argc;i++) {
+		printf("Opening index file: %s\n", argv[i]);
+		idx = (CamelIndex *)camel_text_index_new(argv[i], O_RDONLY);
+		if (idx) {
+			printf(" Dumping ...\n");
+			camel_text_index_dump(idx);
+			camel_object_unref((CamelObject *)idx);
+		} else {
+			printf(" Failed: %s\n", strerror(errno));
+			return 1;
+		}
+	}
+	return 0;
+}
+
+static int
+do_info(int argc, char **argv)
+{
+	int i;
+	CamelIndex *idx;
+
+	for (i=2;i<argc;i++) {
+		printf("Opening index file: %s\n", argv[i]);
+		idx = (CamelIndex *)camel_text_index_new(argv[i], O_RDONLY);
+		if (idx) {
+			camel_text_index_info(idx);
+			camel_object_unref((CamelObject *)idx);
+		} else {
+			printf(" Failed: %s\n", strerror(errno));
+			return 0;
+		}
+	}
+	return 1;
+}
+
+static int
+do_check(int argc, char **argv)
+{
+	int i;
+	CamelIndex *idx;
+
+	for (i=2;i<argc;i++) {
+		printf("Opening index file: %s\n", argv[i]);
+		idx = (CamelIndex *)camel_text_index_new(argv[i], O_RDONLY);
+		if (idx) {
+			camel_text_index_validate(idx);
+			camel_object_unref((CamelObject *)idx);
+		} else {
+			printf(" Failed: %s\n", strerror(errno));
+			return 0;
+		}
+	}
+	return 1;
+}
+
+static int do_perf(int argc, char **argv);
+
+int main(int argc, char **argv)
+{
+	if (argc<2)
+		do_usage(argv[0]);
+
+	g_thread_init(NULL);
+	camel_init(NULL, 0);
+
+	if (!strcmp(argv[1], "compress"))
+		return do_compress(argc, argv);
+	else if (!strcmp(argv[1], "dump"))
+		return do_dump(argc, argv);
+	else if (!strcmp(argv[1], "info"))
+		return do_info(argc, argv);
+	else if (!strcmp(argv[1], "check"))
+		return do_check(argc, argv);
+	else if (!strcmp(argv[1], "perf"))
+		return do_perf(argc, argv);
+
+	do_usage(argv[0]);
+	return 1;
+}
+
+#include <sys/types.h>
+#include <dirent.h>
+#include "camel-stream-null.h"
+#include "camel-stream-filter.h"
+#include "camel-mime-filter-index.h"
+#include "camel-stream-fs.h"
+
+static int
+do_perf(int argc, char **argv)
+{
+	CamelIndex *idx;
+	DIR *dir;
+	char *path = "/home/notzed/evolution/local/Inbox/mbox/cur";
+	struct dirent *d;
+	CamelStream *null, *filter, *stream;
+	CamelMimeFilterIndex *filter_index;
+	char *name;
+	CamelIndexName *idn;
+
+	dir = opendir(path);
+	if (dir == NULL) {
+		perror("open dir");
+		return 1;
+	}
+
+	idx = (CamelIndex *)camel_text_index_new("/tmp/index", O_TRUNC|O_CREAT|O_RDWR);
+	if (idx == NULL) {
+		perror("open index");
+		return 1;
+	}
+
+	null = camel_stream_null_new();
+	filter = (CamelStream *)camel_stream_filter_new_with_stream(null);
+	camel_object_unref((CamelObject *)null);
+	filter_index = camel_mime_filter_index_new_index(idx);
+	camel_stream_filter_add((CamelStreamFilter *)filter, (CamelMimeFilter *)filter_index);
+
+	while ((d = readdir(dir))) {
+		printf("indexing '%s'\n", d->d_name);
+
+		idn = camel_index_add_name(idx, d->d_name);
+		camel_mime_filter_index_set_name(filter_index, idn);
+		name = g_strdup_printf("%s/%s", path, d->d_name);
+		stream = camel_stream_fs_new_with_name(name, O_RDONLY, 0);
+		camel_stream_write_to_stream(stream, filter);
+		camel_object_unref((CamelObject *)stream);
+		g_free(name);
+
+		camel_index_write_name(idx, idn);
+		camel_object_unref((CamelObject *)idn);
+		camel_mime_filter_index_set_name(filter_index, NULL);
+	}
+
+	closedir(dir);
+
+	camel_index_sync(idx);
+	camel_object_unref((CamelObject *)idx);
+
+	camel_object_unref((CamelObject *)filter);
+	camel_object_unref((CamelObject *)filter_index);
+
+	return 0;
+}
+