Merge branch 'master-readonly-records' into foo

Conflicts:

	Makefile.in
	tools/ctdb.c

(This used to be ctdb commit 0fedef0ffba4178126eee9544c5e2db52f5db893)

4 files changed, 562 insertions, 0 deletions

diff --git a/ctdb/tests/src/ctdb_fetch_readonly_loop.c b/ctdb/tests/src/ctdb_fetch_readonly_loop.c
new file mode 100644
index 0000000000..7d73046300
--- /dev/null
+++ b/ctdb/tests/src/ctdb_fetch_readonly_loop.c
@@ -0,0 +1,134 @@
+/* 
+   simple ctdb test tool
+   This test just fetch_locks a record and releases it in a loop.
+
+   Copyright (C) Ronnie Sahlberg 2009
+
+   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 <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "lib/tevent/tevent.h"
+#include "system/filesys.h"
+#include "popt.h"
+#include "cmdline.h"
+#include "ctdb_private.h"
+
+static struct ctdb_db_context *ctdb_db;
+
+char *TESTKEY = "testkey";
+static int count;
+
+/*
+	Just try locking/unlocking a single record once
+*/
+static void fetch_lock_once(struct ctdb_context *ctdb, struct event_context *ev)
+{
+	TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
+	TDB_DATA key, data;
+	struct ctdb_record_handle *h;
+
+	key.dptr = discard_const(TESTKEY);
+	key.dsize = strlen(TESTKEY);
+
+//	printf("Trying to fetch lock the record ...\n");
+
+	h = ctdb_fetch_readonly_lock(ctdb_db, tmp_ctx, key, &data, true);
+	if (h == NULL) {
+		printf("Failed to fetch record '%s' on node %d\n", 
+	       		(const char *)key.dptr, ctdb_get_pnn(ctdb));
+		talloc_free(tmp_ctx);
+		exit(10);
+	}
+
+	count++;
+	printf("%d   data:%.*s\n", count, data.dsize, data.dptr);
+	talloc_free(tmp_ctx);
+}
+
+/*
+  main program
+*/
+int main(int argc, const char *argv[])
+{
+	struct ctdb_context *ctdb;
+	TDB_DATA key;
+
+	struct poptOption popt_options[] = {
+		POPT_AUTOHELP
+		POPT_CTDB_CMDLINE
+		{ "record",      'r', POPT_ARG_STRING, &TESTKEY, 0, "record", "string" },
+		POPT_TABLEEND
+	};
+	int opt, ret;
+	const char **extra_argv;
+	int extra_argc = 0;
+	poptContext pc;
+	struct event_context *ev;
+
+	pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
+
+	while ((opt = poptGetNextOpt(pc)) != -1) {
+		switch (opt) {
+		default:
+			fprintf(stderr, "Invalid option %s: %s\n", 
+				poptBadOption(pc, 0), poptStrerror(opt));
+			exit(1);
+		}
+	}
+
+	/* setup the remaining options for the main program to use */
+	extra_argv = poptGetArgs(pc);
+	if (extra_argv) {
+		extra_argv++;
+		while (extra_argv[extra_argc]) extra_argc++;
+	}
+
+	ev = event_context_init(NULL);
+
+	ctdb = ctdb_cmdline_client(ev);
+
+	key.dptr  = TESTKEY;
+	key.dsize = strlen(TESTKEY);
+
+	ret = ctdb_ctrl_getvnnmap(ctdb, timeval_zero(), CTDB_CURRENT_NODE, ctdb, &ctdb->vnn_map);
+	if (ret != 0) {
+		printf("failed to get vnnmap\n");
+		exit(10);
+	}
+	printf("Record:%s\n", TESTKEY);
+	printf("Lmaster : %d\n", ctdb_lmaster(ctdb, &key)); 
+
+	/* attach to a specific database */
+	ctdb_db = ctdb_attach(ctdb, "test.tdb", false, 0);
+	if (!ctdb_db) {
+		printf("ctdb_attach failed - %s\n", ctdb_errstr(ctdb));
+		exit(1);
+	}
+
+	printf("Waiting for cluster\n");
+	while (1) {
+		uint32_t recmode=1;
+		ctdb_ctrl_getrecmode(ctdb, ctdb, timeval_zero(), CTDB_CURRENT_NODE, &recmode);
+		if (recmode == 0) break;
+		event_loop_once(ev);
+	}
+
+	while (1) {
+		fetch_lock_once(ctdb, ev);
+		usleep(10000);
+	}
+
+	return 0;
+}
diff --git a/ctdb/tests/src/ctdb_fetch_readonly_once.c b/ctdb/tests/src/ctdb_fetch_readonly_once.c
new file mode 100644
index 0000000000..662f4704d4
--- /dev/null
+++ b/ctdb/tests/src/ctdb_fetch_readonly_once.c
@@ -0,0 +1,134 @@
+/* 
+   simple ctdb test tool
+   This test just fetch_locks a record and releases it once.
+
+   Copyright (C) Ronnie Sahlberg 2009
+
+   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 <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "lib/tevent/tevent.h"
+#include "system/filesys.h"
+#include "popt.h"
+#include "cmdline.h"
+#include "ctdb_private.h"
+
+static struct ctdb_db_context *ctdb_db;
+
+char *TESTKEY = "testkey";
+
+
+/*
+	Just try locking/unlocking a single record once
+*/
+static void fetch_lock_once(struct ctdb_context *ctdb, struct event_context *ev)
+{
+	TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
+	TDB_DATA key, data;
+	struct ctdb_record_handle *h;
+
+	key.dptr = discard_const(TESTKEY);
+	key.dsize = strlen(TESTKEY);
+
+	printf("Trying to fetch lock the record ...\n");
+
+	h = ctdb_fetch_readonly_lock(ctdb_db, tmp_ctx, key, &data, true);
+	if (h == NULL) {
+		printf("Failed to fetch record '%s' on node %d\n", 
+	       		(const char *)key.dptr, ctdb_get_pnn(ctdb));
+		talloc_free(tmp_ctx);
+		exit(10);
+	}
+
+	printf("Record fetchlocked.\n");
+	printf("Press enter to release the record ...\n");
+	(void)getchar();
+
+	talloc_free(tmp_ctx);
+	printf("Record released.\n");
+}
+
+/*
+  main program
+*/
+int main(int argc, const char *argv[])
+{
+	struct ctdb_context *ctdb;
+	TDB_DATA key;
+
+	struct poptOption popt_options[] = {
+		POPT_AUTOHELP
+		POPT_CTDB_CMDLINE
+		{ "record",      'r', POPT_ARG_STRING, &TESTKEY, 0, "record", "string" },
+		POPT_TABLEEND
+	};
+	int opt, ret;
+	const char **extra_argv;
+	int extra_argc = 0;
+	poptContext pc;
+	struct event_context *ev;
+
+	pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
+
+	while ((opt = poptGetNextOpt(pc)) != -1) {
+		switch (opt) {
+		default:
+			fprintf(stderr, "Invalid option %s: %s\n", 
+				poptBadOption(pc, 0), poptStrerror(opt));
+			exit(1);
+		}
+	}
+
+	/* setup the remaining options for the main program to use */
+	extra_argv = poptGetArgs(pc);
+	if (extra_argv) {
+		extra_argv++;
+		while (extra_argv[extra_argc]) extra_argc++;
+	}
+
+	ev = event_context_init(NULL);
+
+	ctdb = ctdb_cmdline_client(ev);
+
+	key.dptr  = TESTKEY;
+	key.dsize = strlen(TESTKEY);
+
+	ret = ctdb_ctrl_getvnnmap(ctdb, timeval_zero(), CTDB_CURRENT_NODE, ctdb, &ctdb->vnn_map);
+	if (ret != 0) {
+		printf("failed to get vnnmap\n");
+		exit(10);
+	}
+	printf("Record:%s\n", TESTKEY);
+	printf("Lmaster : %d\n", ctdb_lmaster(ctdb, &key)); 
+
+	/* attach to a specific database */
+	ctdb_db = ctdb_attach(ctdb, "test.tdb", false, 0);
+	if (!ctdb_db) {
+		printf("ctdb_attach failed - %s\n", ctdb_errstr(ctdb));
+		exit(1);
+	}
+
+	printf("Waiting for cluster\n");
+	while (1) {
+		uint32_t recmode=1;
+		ctdb_ctrl_getrecmode(ctdb, ctdb, timeval_zero(), CTDB_CURRENT_NODE, &recmode);
+		if (recmode == 0) break;
+		event_loop_once(ev);
+	}
+
+	fetch_lock_once(ctdb, ev);
+
+	return 0;
+}
diff --git a/ctdb/tests/src/ctdb_trackingdb_test.c b/ctdb/tests/src/ctdb_trackingdb_test.c
new file mode 100644
index 0000000000..77eb7b9f08
--- /dev/null
+++ b/ctdb/tests/src/ctdb_trackingdb_test.c
@@ -0,0 +1,136 @@
+/* 
+   simple trackingdb test tool
+
+   This program is used to test the funcitons to manipulate and enumerate
+   the trackingdb records :
+	ctdb_trackingdb_add_pnn()
+	ctdb_trackingdb_traverse()
+
+   Copyright (C) Ronnie Sahlberg 2009
+
+   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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdlib.h>
+#include <time.h>
+#include "includes.h"
+#include "lib/tevent/tevent.h"
+#include "system/filesys.h"
+#include "popt.h"
+#include "cmdline.h"
+#include "ctdb_private.h"
+#include "db_wrap.h"
+
+#define MAXINDEX 64
+char indices[MAXINDEX];
+
+void vn_cb(struct ctdb_context *ctdb, uint32_t pnn, void *private_data)
+{
+	char *ind = private_data;
+
+	printf("Callback for node %d\n", pnn);
+	if (ind[pnn] == 0) {
+		printf("ERROR, node %d from callback was never added\n", pnn);
+		exit(10);
+	}
+	ind[pnn] = 0;
+}
+
+void verify_nodes(struct ctdb_context *ctdb, TDB_DATA data)
+{
+	int i;
+
+	printf("Verify the nodes\n");
+	ctdb_trackingdb_traverse(ctdb, data, vn_cb, indices);
+	for(i = 0; i < MAXINDEX; i++) {
+		if (indices[i] != 0) {
+			printf("Callback for %d was never invoked\n", i);
+			exit(0);
+		}
+	}
+}
+
+	
+	
+void add_node(struct ctdb_context *ctdb, TDB_DATA *data, int pnn)
+{
+	int i;
+
+	printf("Add node %d\n", pnn);
+	if (ctdb_trackingdb_add_pnn(ctdb, data, pnn)) {
+		printf("Failed to add tracking db data\n");
+		exit(10);
+	}
+	indices[pnn] = 1;
+}
+
+static void trackdb_test(struct ctdb_context *ctdb)
+{
+	TDB_DATA data = {NULL,0};
+	int i;
+
+	printf("Add 10 nodes\n");
+	srandom(time(NULL));
+	for(i=0; i<10; i++) {
+		add_node(ctdb, &data, random()%MAXINDEX);
+	}
+
+	verify_nodes(ctdb, data);
+	printf("OK all seems well\n");
+}
+
+/*
+  main program
+*/
+int main(int argc, const char *argv[])
+{
+	struct ctdb_context *ctdb;
+
+	struct poptOption popt_options[] = {
+		POPT_AUTOHELP
+		POPT_CTDB_CMDLINE
+		POPT_TABLEEND
+	};
+	int opt;
+	const char **extra_argv;
+	int extra_argc = 0;
+	poptContext pc;
+	struct event_context *ev;
+
+	pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
+
+	while ((opt = poptGetNextOpt(pc)) != -1) {
+		switch (opt) {
+		default:
+			fprintf(stderr, "Invalid option %s: %s\n", 
+				poptBadOption(pc, 0), poptStrerror(opt));
+			exit(1);
+		}
+	}
+
+	/* setup the remaining options for the main program to use */
+	extra_argv = poptGetArgs(pc);
+	if (extra_argv) {
+		extra_argv++;
+		while (extra_argv[extra_argc]) extra_argc++;
+	}
+
+	ev = event_context_init(NULL);
+
+	ctdb = ctdb_cmdline_client(ev);
+
+	trackdb_test(ctdb);
+
+	return 0;
+}
diff --git a/ctdb/tests/src/ctdb_update_record.c b/ctdb/tests/src/ctdb_update_record.c
new file mode 100644
index 0000000000..5f4b9c1e21
--- /dev/null
+++ b/ctdb/tests/src/ctdb_update_record.c
@@ -0,0 +1,158 @@
+/* 
+   simple ctdb test tool
+   This test just fetch_locks a record bumps the RSN and then writes new content
+
+   Copyright (C) Ronnie Sahlberg 2009
+
+   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 <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "lib/tevent/tevent.h"
+#include "system/filesys.h"
+#include "popt.h"
+#include "cmdline.h"
+#include "ctdb_private.h"
+
+static struct ctdb_db_context *ctdb_db;
+
+#define TESTKEY "testkey"
+
+
+/*
+	Just try locking/unlocking a single record once
+*/
+static void fetch_lock_once(struct ctdb_context *ctdb, struct event_context *ev, uint32_t generation)
+{
+	TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
+	TDB_DATA key, data;
+	struct ctdb_record_handle *h;
+	struct ctdb_ltdb_header *header;
+	int ret;
+
+	key.dptr = discard_const(TESTKEY);
+	key.dsize = strlen(TESTKEY);
+
+	printf("Trying to fetch lock the record ...\n");
+
+	h = ctdb_fetch_readonly_lock(ctdb_db, tmp_ctx, key, &data, false);
+	if (h == NULL) {
+		printf("Failed to fetch record '%s' on node %d\n", 
+	       		(const char *)key.dptr, ctdb_get_pnn(ctdb));
+		talloc_free(tmp_ctx);
+		exit(10);
+	}
+
+	printf("Record fetchlocked.\n");
+	header = talloc_memdup(tmp_ctx, ctdb_header_from_record_handle(h), sizeof(*header));
+       	printf("RSN:%d\n", (int)header->rsn);
+	talloc_free(h);
+	printf("Record released.\n");
+
+	printf("Write new record with RSN+10\n");
+	header->rsn += 10;
+	data.dptr = (void *)talloc_asprintf(tmp_ctx, "%d", (int)header->rsn);
+	data.dsize = strlen((char *)data.dptr);
+
+	ret = ctdb_ctrl_updaterecord(ctdb, ctdb, timeval_zero(), CTDB_CURRENT_NODE, ctdb_db, key, header, data);
+	if (ret != 0) {
+		printf("Failed to writerecord,  ret==%d\n", ret);	
+		exit(1);
+	}
+
+	printf("re-fetch the record\n");
+	h = ctdb_fetch_lock(ctdb_db, tmp_ctx, key, &data);
+	if (h == NULL) {
+		printf("Failed to fetch record '%s' on node %d\n", 
+	       		(const char *)key.dptr, ctdb_get_pnn(ctdb));
+		talloc_free(tmp_ctx);
+		exit(10);
+	}
+
+	printf("Record fetchlocked.\n");
+	header = talloc_memdup(tmp_ctx, ctdb_header_from_record_handle(h), sizeof(*header));
+       	printf("RSN:%d\n", (int)header->rsn);
+	talloc_free(h);
+	printf("Record released.\n");
+
+	talloc_free(tmp_ctx);
+}
+
+/*
+  main program
+*/
+int main(int argc, const char *argv[])
+{
+	struct ctdb_context *ctdb;
+
+	struct poptOption popt_options[] = {
+		POPT_AUTOHELP
+		POPT_CTDB_CMDLINE
+		POPT_TABLEEND
+	};
+	int opt;
+	const char **extra_argv;
+	int extra_argc = 0;
+	poptContext pc;
+	struct event_context *ev;
+	struct ctdb_vnn_map *vnnmap=NULL;
+
+	pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
+
+	while ((opt = poptGetNextOpt(pc)) != -1) {
+		switch (opt) {
+		default:
+			fprintf(stderr, "Invalid option %s: %s\n", 
+				poptBadOption(pc, 0), poptStrerror(opt));
+			exit(1);
+		}
+	}
+
+	/* setup the remaining options for the main program to use */
+	extra_argv = poptGetArgs(pc);
+	if (extra_argv) {
+		extra_argv++;
+		while (extra_argv[extra_argc]) extra_argc++;
+	}
+
+	ev = event_context_init(NULL);
+
+	ctdb = ctdb_cmdline_client(ev);
+
+	/* attach to a specific database */
+	ctdb_db = ctdb_attach(ctdb, "test.tdb", false, 0);
+	if (!ctdb_db) {
+		printf("ctdb_attach failed - %s\n", ctdb_errstr(ctdb));
+		exit(1);
+	}
+
+	printf("Waiting for cluster\n");
+	while (1) {
+		uint32_t recmode=1;
+		ctdb_ctrl_getrecmode(ctdb, ctdb, timeval_zero(), CTDB_CURRENT_NODE, &recmode);
+		if (recmode == 0) break;
+		event_loop_once(ev);
+	}
+
+
+	if (ctdb_ctrl_getvnnmap(ctdb, timeval_zero(), CTDB_CURRENT_NODE, ctdb, &vnnmap) != 0) {
+		printf("Unable to get vnnmap from local node\n");
+		exit(1);
+	}
+	printf("Current Generation %d\n", (int)vnnmap->generation);
+
+	fetch_lock_once(ctdb, ev, vnnmap->generation);
+
+	return 0;
+}