[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] r22135 - gnunet/src/lockmanager
From: |
gnunet |
Subject: |
[GNUnet-SVN] r22135 - gnunet/src/lockmanager |
Date: |
Wed, 20 Jun 2012 12:04:02 +0200 |
Author: harsha
Date: 2012-06-20 12:04:01 +0200 (Wed, 20 Jun 2012)
New Revision: 22135
Added:
gnunet/src/lockmanager/test_lockmanager_api_acquireretry.c
Modified:
gnunet/src/lockmanager/
gnunet/src/lockmanager/Makefile.am
gnunet/src/lockmanager/lockmanager_api.c
gnunet/src/lockmanager/test_lockmanager_api.c
gnunet/src/lockmanager/test_lockmanager_api_lockrelease.c
gnunet/src/lockmanager/test_lockmanager_api_servercrash.c
Log:
-changes required for acquire retry
Property changes on: gnunet/src/lockmanager
___________________________________________________________________
Modified: svn:ignore
- Makefile
Makefile.in
lockmanager.conf
gnunet-service-lockmanager
.deps
test-lockmanager-api
test-lockmanager-api-lockrelease
test-lockmanager-api-servercrash
+ Makefile
Makefile.in
lockmanager.conf
gnunet-service-lockmanager
.deps
test_lockmanager_api
test_lockmanager_api_lockrelease
test_lockmanager_api_servercrash
Modified: gnunet/src/lockmanager/Makefile.am
===================================================================
--- gnunet/src/lockmanager/Makefile.am 2012-06-20 09:36:46 UTC (rev 22134)
+++ gnunet/src/lockmanager/Makefile.am 2012-06-20 10:04:01 UTC (rev 22135)
@@ -39,9 +39,9 @@
-version-info 0:0:0
check_PROGRAMS = \
- test-lockmanager-api \
- test-lockmanager-api-lockrelease \
- test-lockmanager-api-servercrash
+ test_lockmanager_api \
+ test_lockmanager_api_lockrelease \
+ test_lockmanager_api_servercrash
EXTRA_DIST = \
test_lockmanager_api.conf
Modified: gnunet/src/lockmanager/lockmanager_api.c
===================================================================
--- gnunet/src/lockmanager/lockmanager_api.c 2012-06-20 09:36:46 UTC (rev
22134)
+++ gnunet/src/lockmanager/lockmanager_api.c 2012-06-20 10:04:01 UTC (rev
22135)
@@ -100,6 +100,11 @@
* Double linked list tail for message queue
*/
struct MessageQueue *mq_tail;
+
+ /**
+ * Are we currently handling replies?
+ */
+ int in_replies;
};
@@ -163,6 +168,17 @@
/**
+ * Handler for server replies
+ *
+ * @param cls the LOCKMANAGER_Handle
+ * @param msg received message, NULL on timeout or fatal error
+ */
+static void
+handle_replies (void *cls,
+ const struct GNUNET_MessageHeader *msg);
+
+
+/**
* Transmit notify for sending message to server
*
* @param cls the lockmanager handle
@@ -178,13 +194,20 @@
uint16_t msg_size;
handle->transmit_handle = NULL;
+ queue_entity = handle->mq_head;
+ GNUNET_assert (NULL != queue_entity);
if ((0 == size) || (NULL == buf))
{
- /* FIXME: Timed out -- requeue? */
+ handle->transmit_handle =
+ GNUNET_CLIENT_notify_transmit_ready (handle->conn,
+ ntohs
+ (queue_entity->msg->header.size),
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_YES,
+ &transmit_notify,
+ handle);
return 0;
- }
- queue_entity = handle->mq_head;
- GNUNET_assert (NULL != queue_entity);
+ }
msg_size = ntohs (queue_entity->msg->header.size);
GNUNET_assert (size >= msg_size);
memcpy (buf, queue_entity->msg, msg_size);
@@ -207,6 +230,14 @@
&transmit_notify,
handle);
}
+ if (GNUNET_NO == handle->in_replies)
+ {
+ GNUNET_CLIENT_receive (handle->conn,
+ &handle_replies,
+ handle,
+ GNUNET_TIME_UNIT_FOREVER_REL);
+ handle->in_replies = GNUNET_YES;
+ }
return msg_size;
}
@@ -344,8 +375,33 @@
/**
- * Iterator to call relase and free all LockingRequest entries
+ * Function to generate acquire message for a lock
*
+ * @param domain_name the domain name of the lock
+ * @param lock the lock number
+ * @return the generated GNUNET_LOCKMANAGER_Message
+ */
+static struct GNUNET_LOCKMANAGER_Message *
+generate_acquire_msg (const char *domain_name, uint32_t lock)
+{
+ struct GNUNET_LOCKMANAGER_Message *msg;
+ size_t domain_name_len;
+ uint16_t msg_size;
+
+ domain_name_len = strlen (domain_name) + 1;
+ msg_size = sizeof (struct GNUNET_LOCKMANAGER_Message) + domain_name_len;
+ msg = GNUNET_malloc (msg_size);
+ msg->header.type = htons (GNUNET_MESSAGE_TYPE_LOCKMANAGER_ACQUIRE);
+ msg->header.size = htons (msg_size);
+ msg->lock = htonl (lock);
+ memcpy (&msg[1], domain_name, domain_name_len);
+ return msg;
+}
+
+
+/**
+ * Iterator to call relase on locks
+ *
* @param cls the lockmanager handle
* @param key current key code
* @param value the Locking request
@@ -354,29 +410,29 @@
* GNUNET_NO if not.
*/
static int
-release_iterator(void *cls,
- const struct GNUNET_HashCode * key,
- void *value)
+release_n_retry_iterator (void *cls,
+ const struct GNUNET_HashCode * key,
+ void *value)
{
+ struct GNUNET_LOCKMANAGER_LockingRequest *r = value;
struct GNUNET_LOCKMANAGER_Handle *h = cls;
- struct GNUNET_LOCKMANAGER_LockingRequest *r = value;
+ struct GNUNET_LOCKMANAGER_Message *msg;
+ if (GNUNET_LOCKMANAGER_RELEASE == r->status)
+ return GNUNET_YES;
if (NULL != r->status_cb)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Calling status change for RELEASE on lock num: %d, domain: %s\n",
r->lock, r->domain);
+ r->status = GNUNET_LOCKMANAGER_RELEASE;
r->status_cb (r->status_cb_cls,
r->domain,
r->lock,
- GNUNET_LOCKMANAGER_RELEASE);
+ GNUNET_LOCKMANAGER_RELEASE);
}
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multihashmap_remove (h->hashmap,
- key,
- value));
- GNUNET_free (r->domain);
- GNUNET_free (r);
+ msg = generate_acquire_msg (r->domain, r->lock);
+ queue_message (h, msg);
return GNUNET_YES;
}
@@ -398,14 +454,15 @@
struct GNUNET_HashCode hash;
uint32_t lock;
uint16_t msize;
-
+
+ handle->in_replies = GNUNET_NO;
if (NULL == msg)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Lockmanager service not available or went down\n");
- /* Should release all locks and free its locking requests */
+ "Lockmanager service not available or went down\n");
+ /* Should release all locks and retry to acquire them */
GNUNET_CONTAINER_multihashmap_iterate (handle->hashmap,
- &release_iterator,
+ &release_n_retry_iterator,
handle);
return;
}
@@ -413,6 +470,7 @@
&handle_replies,
handle,
GNUNET_TIME_UNIT_FOREVER_REL);
+ handle->in_replies = GNUNET_YES;
if (GNUNET_MESSAGE_TYPE_LOCKMANAGER_SUCCESS != ntohs(msg->type))
{
GNUNET_break (0);
@@ -522,7 +580,7 @@
&handle_replies,
h,
GNUNET_TIME_UNIT_FOREVER_REL);
-
+ h->in_replies = GNUNET_YES;
LOG (GNUNET_ERROR_TYPE_DEBUG, "%s() END\n", __func__);
return h;
}
@@ -604,7 +662,6 @@
struct GNUNET_LOCKMANAGER_LockingRequest *r;
struct GNUNET_LOCKMANAGER_Message *msg;
struct GNUNET_HashCode hash;
- uint16_t msg_size;
size_t domain_name_length;
LOG (GNUNET_ERROR_TYPE_DEBUG, "%s()\n", __func__);
@@ -617,12 +674,7 @@
r->status_cb = status_cb;
r->status_cb_cls = status_cb_cls;
memcpy (r->domain, domain_name, domain_name_length);
- msg_size = sizeof (struct GNUNET_LOCKMANAGER_Message) + domain_name_length;
- msg = GNUNET_malloc (msg_size);
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_LOCKMANAGER_ACQUIRE);
- msg->header.size = htons (msg_size);
- msg->lock = htonl (lock);
- memcpy (&msg[1], r->domain, domain_name_length);
+ msg = generate_acquire_msg (r->domain, r->lock);
LOG (GNUNET_ERROR_TYPE_DEBUG, "Queueing ACQUIRE message\n");
queue_message (handle, msg);
get_key (r->domain, r->lock, &hash);
@@ -638,8 +690,8 @@
/**
* Function to cancel the locking request generated by
- * GNUNET_LOCKMANAGER_acquire_lock. If the lock is acquired us then the lock is
- * released. GNUNET_LOCKMANAGER_StatusCallback will not be called upon any
+ * GNUNET_LOCKMANAGER_acquire_lock. If the lock is acquired by us then the lock
+ * is released. GNUNET_LOCKMANAGER_StatusCallback will not be called upon any
* status changes resulting due to this call.
*
* @param request the LockingRequest to cancel
Modified: gnunet/src/lockmanager/test_lockmanager_api.c
===================================================================
--- gnunet/src/lockmanager/test_lockmanager_api.c 2012-06-20 09:36:46 UTC
(rev 22134)
+++ gnunet/src/lockmanager/test_lockmanager_api.c 2012-06-20 10:04:01 UTC
(rev 22135)
@@ -239,7 +239,7 @@
{
int ret;
- char *const argv2[] = { "test-lockmanager-api",
+ char *const argv2[] = { "test_lockmanager_api",
"-c", "test_lockmanager_api.conf",
#if VERBOSE
"-L", "DEBUG",
@@ -251,7 +251,7 @@
GNUNET_GETOPT_OPTION_END
};
- GNUNET_log_setup ("test-lockmanager-api",
+ GNUNET_log_setup ("test_lockmanager_api",
#if VERBOSE
"DEBUG",
#else
@@ -261,7 +261,7 @@
ret =
GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2,
- "test-lockmanager-api", "nohelp", options, &run, NULL);
+ "test_lockmanager_api", "nohelp", options, &run, NULL);
if (GNUNET_OK != ret)
{
Added: gnunet/src/lockmanager/test_lockmanager_api_acquireretry.c
===================================================================
--- gnunet/src/lockmanager/test_lockmanager_api_acquireretry.c
(rev 0)
+++ gnunet/src/lockmanager/test_lockmanager_api_acquireretry.c 2012-06-20
10:04:01 UTC (rev 22135)
@@ -0,0 +1,284 @@
+/*
+ This file is part of GNUnet.
+ (C) 2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet 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 2, or (at your
+ option) any later version.
+
+ GNUnet 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 GNUnet; see the file COPYING. If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file lockmanager/test_lockmanager_api_acquireretry.c
+ * @brief Test cases for lockmanager_api where the server crashes and comes
+ * back; the api should try to acqurie the lock again
+ * @author Sree Harsha Totakura
+ */
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_lockmanager_service.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind,...) \
+ GNUNET_log (kind, __VA_ARGS__)
+
+#define TIME_REL_SECS(sec) \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, sec)
+
+/**
+ * Various stages in test
+ */
+enum Test
+ {
+ /**
+ * Signal test failure
+ */
+ TEST_FAIL,
+
+ /**
+ * Testing just began
+ */
+ TEST_INIT,
+
+ /**
+ * Client has successfully acquired the lock
+ */
+ TEST_CLIENT_LOCK_SUCESS,
+
+ /**
+ * Client has lost the lock
+ */
+ TEST_CLIENT_LOCK_RELEASE,
+
+ /**
+ * Client has again acquired the lock
+ */
+ TEST_CLIENT_LOCK_AGAIN_SUCCESS
+ };
+
+/**
+ * The process id of the GNUNET ARM process
+ */
+static struct GNUNET_OS_Process *arm_pid = NULL;
+
+/**
+ * Configuration Handle
+ */
+static struct GNUNET_CONFIGURATION_Handle *config;
+
+/**
+ * The handle to the lockmanager service
+ */
+static struct GNUNET_LOCKMANAGER_Handle *handle;
+
+/**
+ * The locking request
+ */
+static struct GNUNET_LOCKMANAGER_LockingRequest *request;
+
+/**
+ * Abort task identifier
+ */
+static GNUNET_SCHEDULER_TaskIdentifier abort_task_id;
+
+/**
+ * The test result
+ */
+enum Test result;
+
+
+/**
+ * Shutdown nicely
+ *
+ * @param cls
+ * @param tc the task context
+ */
+static void
+do_shutdown (void *cls, const const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ if (GNUNET_SCHEDULER_NO_TASK != abort_task_id)
+ {
+ GNUNET_SCHEDULER_cancel (abort_task_id);
+ abort_task_id = GNUNET_SCHEDULER_NO_TASK;
+ }
+ if (NULL != handle)
+ GNUNET_LOCKMANAGER_disconnect (handle);
+ if (NULL != arm_pid)
+ {
+ if (0 != GNUNET_OS_process_kill (arm_pid, SIGTERM))
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Kill gnunet-service-arm manually\n");
+ }
+ GNUNET_OS_process_wait (arm_pid);
+ GNUNET_OS_process_destroy (arm_pid);
+ }
+ if (NULL != config)
+ GNUNET_CONFIGURATION_destroy (config);
+}
+
+/**
+ * Abort
+ *
+ * @param cls
+ * @param tc the task context
+ */
+static void
+do_abort (void *cls, const const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Aborting test...\n");
+ abort_task_id = GNUNET_SCHEDULER_NO_TASK;
+ result = TEST_FAIL;
+ do_shutdown (cls, tc);
+}
+
+
+/**
+ * Callback for lock status changes
+ *
+ * @param cls the handle
+ *
+ * @param domain_name the locking domain of the lock
+ *
+ * @param lock the lock for which this status is relevant
+ *
+ * @param status GNUNET_LOCKMANAGER_SUCCESS if the lock has been successfully
+ * acquired; GNUNET_LOCKMANAGER_RELEASE when the acquired lock is lost
+ */
+static void
+status_cb (void *cls,
+ const char *domain_name,
+ uint32_t lock,
+ enum GNUNET_LOCKMANAGER_Status status)
+{
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Status change callback called on lock: %d of domain: %s\n",
+ lock, domain_name);
+ switch (result)
+ {
+ case TEST_INIT:
+ GNUNET_assert (handle == cls);
+ GNUNET_assert (GNUNET_LOCKMANAGER_SUCCESS == status);
+ result = TEST_CLIENT_LOCK_SUCCESS;
+ /* We should kill the lockmanager process */
+ if (0 != GNUNET_OS_process_kill (arm_pid, SIGTERM))
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Kill gnunet-service-arm manually\n");
+ }
+ GNUNET_OS_process_wait (arm_pid);
+ GNUNET_OS_process_destroy (arm_pid);
+ arm_pid =NULL;
+ break;
+ case TEST_CLIENT_LOCK_SUCCESS:
+ GNUNET_assert (handle == cls);
+ GNUNET_assert (GNUNET_LOCKMANAGER_RELEASE == status);
+ result = TEST_CLIENT_LOCK_RELEASE;
+ /* Now we should start again the lockmanager process */
+ arm_pid =
+ GNUNET_OS_start_process (GNUNET_YES, NULL, NULL, "gnunet-service-arm",
+ "gnunet-service-arm",
+ "-c", "test_lockmanager_api.conf", NULL);
+ GNUNET_assert (NULL != arm_pid);
+ break;
+ case TEST_CLIENT_LOCK_RELEASE:
+ GNUNET_asset (handle == cls);
+ GNUNET_assert (GNUNET_LOCKMANAGER_SUCCESS == status);
+ result = TEST_CLIENT_LOCK_AGAIN_SUCCESS;
+ GNUNET_LOCKMANAGER_cancel_request (request);
+ request = NULL;
+ GNUNET_SCHEDULER_add_delayed (TIME_REL_SECS(1), &do_shutdown, NULL);
+ break;
+ default:
+ GNUNET_assert (0); /* We should never reach here */
+ }
+}
+
+
+/**
+ * Testing function
+ *
+ * @param cls NULL
+ * @param tc the task context
+ */
+static void
+test (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ result = TEST_INIT;
+ handle = GNUNET_LOCKMANAGER_connect (config);
+ GNUNET_assert (NULL != handle);
+ request = GNUNET_LOCKMANAGER_acquire_lock (handle,
+ "GNUNET_LOCKMANAGER_TESTING",
+ 99,
+ &status_cb,
+ handle);
+ GNUNET_assert (NULL != request);
+ abort_task_id = GNUNET_SCHEDULER_add_delayed (TIME_REL_SECS (10),
+ &do_abort,
+ NULL);
+}
+
+
+/**
+ * Main point of test execution
+ */
+static void
+run (void *cls, char *const *args, const char *cfgfile,
+ const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+ config = cfg;
+ arm_pid =
+ GNUNET_OS_start_process (GNUNET_YES, NULL, NULL, "gnunet-service-arm",
+ "gnunet-service-arm",
+ "-c", "test_lockmanager_api.conf", NULL);
+ GNUNET_assert (NULL != arm_pid);
+ GNUNET_SCHEDULER_add_delayed (TIME_REL_SECS(3), &test, NULL);
+}
+
+
+/**
+ * Main function
+ */
+int main (int argc, char **argv)
+{
+ int ret;
+
+ char *const argv2[] = { "test_lockmanager_api_servercrash",
+ "-c", "test_lockmanager_api.conf",
+ NULL
+ };
+ struct GNUNET_GETOPT_CommandLineOption options[] = {
+ GNUNET_GETOPT_OPTION_END
+ };
+
+ ret =
+ GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2,
+ "test_lockmanager_api_servercrash",
+ "nohelp", options, &run, NULL);
+ if (GNUNET_OK != ret)
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING, "run failed with error code %d\n",
+ ret);
+ return 1;
+ }
+ if (TEST_CLIENT_LOCK_AGAIN_SUCCESS != result)
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING, "test failed\n");
+ return 1;
+ }
+ LOG (GNUNET_ERROR_TYPE_INFO, "test OK\n");
+ return 0;
+}
Modified: gnunet/src/lockmanager/test_lockmanager_api_lockrelease.c
===================================================================
--- gnunet/src/lockmanager/test_lockmanager_api_lockrelease.c 2012-06-20
09:36:46 UTC (rev 22134)
+++ gnunet/src/lockmanager/test_lockmanager_api_lockrelease.c 2012-06-20
10:04:01 UTC (rev 22135)
@@ -260,7 +260,7 @@
{
int ret;
- char *const argv2[] = { "test-lockmanager-api-lockrelease",
+ char *const argv2[] = { "test_lockmanager_api_lockrelease",
"-c", "test_lockmanager_api.conf",
#if VERBOSE
"-L", "DEBUG",
@@ -272,7 +272,7 @@
GNUNET_GETOPT_OPTION_END
};
- GNUNET_log_setup ("test-lockmanager-api-lockrelease",
+ GNUNET_log_setup ("test_lockmanager_api_lockrelease",
#if VERBOSE
"DEBUG",
#else
@@ -282,7 +282,7 @@
ret =
GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2,
- "test-lockmanager-api-lockrelease",
+ "test_lockmanager_api_lockrelease",
"nohelp", options, &run, NULL);
if (GNUNET_OK != ret)
Modified: gnunet/src/lockmanager/test_lockmanager_api_servercrash.c
===================================================================
--- gnunet/src/lockmanager/test_lockmanager_api_servercrash.c 2012-06-20
09:36:46 UTC (rev 22134)
+++ gnunet/src/lockmanager/test_lockmanager_api_servercrash.c 2012-06-20
10:04:01 UTC (rev 22135)
@@ -217,6 +217,8 @@
GNUNET_assert (99 == lock);
GNUNET_assert (0 == strcmp (domain_name, "GNUNET_LOCKMANAGER_TESTING"));
result = TEST_CLIENT2_SERVER_CRASH_SUCCESS;
+ GNUNET_LOCKMANAGER_cancel_request (request2);
+ request2 = NULL;
GNUNET_SCHEDULER_add_delayed (TIME_REL_SECONDS (1),
&do_shutdown,
NULL);
@@ -285,7 +287,7 @@
{
int ret;
- char *const argv2[] = { "test-lockmanager-api-servercrash",
+ char *const argv2[] = { "test_lockmanager_api_servercrash",
"-c", "test_lockmanager_api.conf",
#if VERBOSE
"-L", "DEBUG",
@@ -297,7 +299,7 @@
GNUNET_GETOPT_OPTION_END
};
- GNUNET_log_setup ("test-lockmanager-api-servercrash",
+ GNUNET_log_setup ("test_lockmanager_api_servercrash",
#if VERBOSE
"DEBUG",
#else
@@ -307,7 +309,7 @@
ret =
GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2,
- "test-lockmanager-api-servercrash",
+ "test_lockmanager_api_servercrash",
"nohelp", options, &run, NULL);
if (GNUNET_OK != ret)
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] r22135 - gnunet/src/lockmanager,
gnunet <=