[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] r21184 - gnunet/src/lockmanager
From: |
gnunet |
Subject: |
[GNUnet-SVN] r21184 - gnunet/src/lockmanager |
Date: |
Thu, 26 Apr 2012 22:49:58 +0200 |
Author: harsha
Date: 2012-04-26 22:49:58 +0200 (Thu, 26 Apr 2012)
New Revision: 21184
Modified:
gnunet/src/lockmanager/lockmanager_api.c
Log:
-extended lockmanager api
Modified: gnunet/src/lockmanager/lockmanager_api.c
===================================================================
--- gnunet/src/lockmanager/lockmanager_api.c 2012-04-26 17:45:06 UTC (rev
21183)
+++ gnunet/src/lockmanager/lockmanager_api.c 2012-04-26 20:49:58 UTC (rev
21184)
@@ -28,12 +28,18 @@
#include "gnunet_common.h"
#include "gnunet_protocols.h"
#include "gnunet_client_lib.h"
+#include "gnunet_lockmanager_service.h"
#include "lockmanager.h"
#define LOG(kind,...) \
- GNUNET_log_from (kind, "gnunet-service-lockmanager",__VA_ARGS__)
+ GNUNET_log_from (kind, "lockmanager-api",__VA_ARGS__)
+#define TIME_REL_MINS(min) \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, min)
+
+#define TIMEOUT TIME_REL_MINS(3)
+
/**
* Handler for the lockmanager service
*/
@@ -47,6 +53,121 @@
/**
+ * Structure for Locking Request
+ */
+struct GNUNET_LOCKMANAGER_LockingRequest
+{
+ /**
+ * The handle associated with this request
+ */
+ struct GNUNET_LOCKMANAGER_Handle *handle;
+
+ /**
+ * The status callback
+ */
+ GNUNET_LOCKMANAGER_StatusCallback status_cb;
+
+ /**
+ * Closure for the status callback
+ */
+ void *status_cb_cls;
+
+ /**
+ * The pending transmit handle for the ACQUIRE message
+ */
+ struct GNUNET_CLIENT_TransmitHandle *transmit_handle;
+
+ /**
+ * The locking domain of this request
+ */
+ char *domain;
+
+ /**
+ * The lock
+ */
+ uint32_t lock;
+
+ /**
+ * The status of the lock
+ */
+ enum GNUNET_LOCKMANAGER_Status status;
+
+ /**
+ * The length of the locking domain string including the trailing NULL
+ */
+ uint16_t domain_name_length;
+};
+
+
+/**
+ * Message handler for SUCCESS messages
+ *
+ * @param cls the LOCKMANAGER_Handle
+ * @param msg message received, NULL on timeout or fatal error
+ */
+static void
+handle_success (void *cls,
+ const struct GNUNET_MessageHeader *msg)
+{
+ if (NULL == msg)
+ return;
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Received SUCCESS message\n");
+}
+
+
+/**
+ * We wait for DUMMY message which will never be sent by the server. However,
+ * in case the server shuts-down/crashes/restarts we are notified by this call
+ * back with a NULL for msg.
+ *
+ * @param cls closure
+ * @param msg message received, NULL on timeout or fatal error
+ */
+static void
+handle_server_crash (void *cls,
+ const struct GNUNET_MessageHeader *msg)
+{
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Lockmanger service went down\n");
+
+}
+
+
+/**
+ * Transmit notify for sending message to server
+ *
+ * @param cls the message to send
+ * @param size number of bytes available in buf
+ * @param buf where the callee should write the message
+ * @return number of bytes written to buf
+ */
+static size_t
+transmit_notify (void *cls, size_t size, void *buf)
+{
+ struct GNUNET_LOCKMANAGER_Message *msg = cls;
+ uint16_t msg_size;
+
+ if ((0 == size) || (NULL == buf))
+ {
+ /* FIXME: Timed out -- requeue? */
+ return 0;
+ }
+ msg_size = ntohs (msg->header.size);
+ GNUNET_assert (size >= msg_size);
+ memcpy (buf, msg, msg_size);
+ GNUNET_free (msg);
+ return msg_size;
+}
+
+
+
+/*******************/
+/* API Definitions */
+/*******************/
+
+/**
* Connect to the lockmanager service
*
* @param cfg the configuration to use
@@ -65,9 +186,20 @@
GNUNET_free (h);
return NULL;
}
- return NULL;
+
+ GNUNET_CLIENT_receive (h->conn,
+ &handle_server_crash,
+ NULL,
+ GNUNET_TIME_UNIT_FOREVER_REL);
+
+ GNUNET_CLIENT_receive (h->conn,
+ &handle_success,
+ h,
+ GNUNET_TIME_UNIT_FOREVER_REL);
+ return h;
}
+
/**
* Disconnect from the lockmanager service
*
@@ -76,5 +208,106 @@
void
GNUNET_LOCKMANAGER_disconnect (struct GNUNET_LOCKMANAGER_Handle *handle)
{
+ GNUNET_CLIENT_disconnect (handle->conn);
+ GNUNET_free (handle);
+}
+
+
+/**
+ * Tries to acquire the given lock(even if the lock has been lost) until the
+ * request is called. If the lock is available the status_cb will be
+ * called. If the lock is busy then the request is queued and status_cb
+ * will be called when the lock has been made available and acquired by us.
+ *
+ * @param handle the handle to the lockmanager service
+ *
+ * @param domain_name name of the locking domain. Clients who want to share
+ * locks must use the same name for the locking domain. Also the
+ * domain_name should be selected with the prefix
+ * "GNUNET_<PROGRAM_NAME>_" to avoid domain name collisions.
+ *
+ *
+ * @param lock which lock to lock
+ *
+ * @param status_cb the callback for signalling when the lock is acquired and
+ * when it is lost
+ *
+ * @param status_cb_cls the closure to the above callback
+ *
+ * @return the locking request handle for this request. It will be invalidated
+ * when status_cb is called.
+ */
+struct GNUNET_LOCKMANAGER_LockingRequest *
+GNUNET_LOCKMANAGER_acquire_lock (struct GNUNET_LOCKMANAGER_Handle *handle,
+ const char *domain_name,
+ uint32_t lock,
+ GNUNET_LOCKMANAGER_StatusCallback
+ status_cb,
+ void *status_cb_cls)
+{
+ struct GNUNET_LOCKMANAGER_LockingRequest *r;
+ struct GNUNET_LOCKMANAGER_Message *msg;
+ uint16_t msg_size;
+
+ r = GNUNET_malloc (sizeof (struct GNUNET_LOCKMANAGER_LockingRequest));
+ r->domain_name_length = strlen (domain_name) + 1;
+ r->handle = handle;
+ r->lock = lock;
+ r->domain = GNUNET_malloc (r->domain_name_length);
+ memcpy (r->domain, domain_name, r->domain_name_length);
+
+ msg_size = sizeof (struct GNUNET_LOCKMANAGER_Message) +
r->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, r->domain_name_length);
+
+ r->transmit_handle =
+ GNUNET_CLIENT_notify_transmit_ready (r->handle->conn,
+ msg_size,
+ TIMEOUT,
+ GNUNET_NO,
+ *transmit_notify,
+ msg);
+ return r;
}
+
+
+
+/**
+ * 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
+ * status changes resulting due to this call.
+ *
+ * @param request the LockingRequest to cancel
+ */
+void
+GNUNET_LOCKMANAGER_cancel_request (struct GNUNET_LOCKMANAGER_LockingRequest
+ *request)
+{
+ /* FIXME: Stop ACQUIRE retransmissions */
+ if (GNUNET_LOCKMANAGER_SUCCESS == request->status)
+ {
+ struct GNUNET_LOCKMANAGER_Message *msg;
+ uint16_t msg_size;
+
+ msg_size = sizeof (struct GNUNET_LOCKMANAGER_Message)
+ + request->domain_name_length;
+ msg = GNUNET_malloc (msg_size);
+ msg->header.type = htons (GNUNET_MESSAGE_TYPE_LOCKMANAGER_RELEASE);
+ msg->header.size = htons (msg_size);
+ msg->lock = htonl (request->lock);
+ memcpy (&msg[1], request->domain, request->domain_name_length);
+
+ GNUNET_CLIENT_notify_transmit_ready (request->handle->conn,
+ msg_size,
+ TIMEOUT, /* What if this fails */
+ GNUNET_NO,
+ &transmit_notify,
+ msg);
+ }
+ GNUNET_free (request);
+}
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] r21184 - gnunet/src/lockmanager,
gnunet <=