-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
* Double linked list tail for message queue
*/
struct MessageQueue *mq_tail;
+
+ /**
+ * Are we currently handling replies?
+ */
+ int in_replies;
};
};
+/**
+ * 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
*
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);
&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;
}
/**
- * 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
* 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_Handle *h = cls;
struct GNUNET_LOCKMANAGER_LockingRequest *r = value;
+ struct GNUNET_LOCKMANAGER_Handle *h = cls;
+ 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;
}
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;
}
&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);
&handle_replies,
h,
GNUNET_TIME_UNIT_FOREVER_REL);
-
+ h->in_replies = GNUNET_YES;
LOG (GNUNET_ERROR_TYPE_DEBUG, "%s() END\n", __func__);
return h;
}
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__);
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);
/**
* 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
{
int ret;
- char *const argv2[] = { "test-lockmanager-api",
+ char *const argv2[] = { "test_lockmanager_api",
"-c", "test_lockmanager_api.conf",
#if VERBOSE
"-L", "DEBUG",
GNUNET_GETOPT_OPTION_END
};
- GNUNET_log_setup ("test-lockmanager-api",
+ GNUNET_log_setup ("test_lockmanager_api",
#if VERBOSE
"DEBUG",
#else
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)
{
--- /dev/null
+/*
+ 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;
+}
{
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",
GNUNET_GETOPT_OPTION_END
};
- GNUNET_log_setup ("test-lockmanager-api-lockrelease",
+ GNUNET_log_setup ("test_lockmanager_api_lockrelease",
#if VERBOSE
"DEBUG",
#else
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)
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);
{
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",
GNUNET_GETOPT_OPTION_END
};
- GNUNET_log_setup ("test-lockmanager-api-servercrash",
+ GNUNET_log_setup ("test_lockmanager_api_servercrash",
#if VERBOSE
"DEBUG",
#else
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)
projects / oweals / gnunet.git / commitdiff