[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] r9112 - in gnunet: . src/arm src/core src/include src/testi
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] r9112 - in gnunet: . src/arm src/core src/include src/testing src/transport |
|
Date: |
Mon, 5 Oct 2009 03:56:26 -0600 |
Author: grothoff
Date: 2009-10-05 03:56:25 -0600 (Mon, 05 Oct 2009)
New Revision: 9112
Modified:
gnunet/BUGS
gnunet/src/arm/arm_api.c
gnunet/src/arm/gnunet-arm.c
gnunet/src/arm/gnunet-service-arm.c
gnunet/src/arm/test_arm_api.c
gnunet/src/core/test_core_api.c
gnunet/src/core/test_core_api_start_only.c
gnunet/src/include/gnunet_arm_service.h
gnunet/src/testing/testing.c
gnunet/src/transport/transport_api.c
Log:
improving ARM API
Modified: gnunet/BUGS
===================================================================
--- gnunet/BUGS 2009-10-05 06:40:40 UTC (rev 9111)
+++ gnunet/BUGS 2009-10-05 09:56:25 UTC (rev 9112)
@@ -92,8 +92,6 @@
- implement exponential back-off for service restarts
- better tracking of which config changes actually need to cause process
restarts by ARM.
- have way to specify dependencies between services (to manage ARM restarts
better)
- - client-API is inefficient since it opens a TCP connection per service that
is started
- (instead of re-using connections).
* CORE:
- code currently notifies clients about "encrypted" connections being up
well before
we get the encrypted PONG; sometimes this may be OK (for topology killing
Modified: gnunet/src/arm/arm_api.c
===================================================================
--- gnunet/src/arm/arm_api.c 2009-10-05 06:40:40 UTC (rev 9111)
+++ gnunet/src/arm/arm_api.c 2009-10-05 09:56:25 UTC (rev 9112)
@@ -32,88 +32,203 @@
#include "gnunet_server_lib.h"
#include "arm.h"
+/**
+ * How often do we re-try tranmsitting requests to ARM before
+ * giving up? Note that if we succeeded transmitting a request
+ * but failed to read a response, we do NOT re-try (since that
+ * might result in ARM getting a request twice).
+ */
+#define MAX_ATTEMPTS 4
/**
- * FIXME: document.
+ * Minimum delay between attempts to talk to ARM.
*/
-struct ArmContext
+#define MIN_RETRY_DELAY GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MILLISECONDS, 100)
+
+
+/**
+ * How long are we willing to wait for a service operation during the
multi-operation
+ * request processing?
+ */
+#define MULTI_TIMEOUT GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 5)
+
+
+/**
+ * Handle for interacting with ARM.
+ */
+struct GNUNET_ARM_Handle
{
/**
- * FIXME: document.
+ * Our connection to the ARM service.
*/
+ struct GNUNET_CLIENT_Connection *client;
+
+ /**
+ * The configuration that we are using.
+ */
+ const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+ /**
+ * Scheduler to use.
+ */
+ struct GNUNET_SCHEDULER_Handle *sched;
+
+};
+
+
+/**
+ * Setup a context for communicating with ARM. Note that this
+ * can be done even if the ARM service is not yet running.
+ *
+ * @param cfg configuration to use (needed to contact ARM;
+ * the ARM service may internally use a different
+ * configuration to determine how to start the service).
+ * @param sched scheduler to use
+ * @param service service that *this* process is implementing/providing, can
be NULL
+ * @return context to use for further ARM operations, NULL on error
+ */
+struct GNUNET_ARM_Handle *
+GNUNET_ARM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ struct GNUNET_SCHEDULER_Handle *sched,
+ const char *service)
+{
+ struct GNUNET_ARM_Handle *ret;
+ struct GNUNET_CLIENT_Connection *client;
+
+ client = GNUNET_CLIENT_connect (sched, "arm", cfg);
+ if (client == NULL)
+ return NULL;
+ ret = GNUNET_malloc (sizeof (struct GNUNET_ARM_Handle));
+ ret->cfg = cfg;
+ ret->sched = sched;
+ ret->client = client;
+ return ret;
+}
+
+
+/**
+ * Disconnect from the ARM service.
+ *
+ * @param h the handle that was being used
+ */
+void
+GNUNET_ARM_disconnect (struct GNUNET_ARM_Handle *h)
+{
+ if (h->client != NULL)
+ GNUNET_CLIENT_disconnect (h->client);
+ GNUNET_free (h);
+}
+
+
+/**
+ * Internal state for a request with ARM.
+ */
+struct RequestContext
+{
+
+ /**
+ * Pointer to our handle with ARM.
+ */
+ struct GNUNET_ARM_Handle *h;
+
+ /**
+ * Function to call with a status code for the requested operation.
+ */
GNUNET_ARM_Callback callback;
/**
- * FIXME: document.
+ * Closure for "callback".
*/
void *cls;
/**
- * FIXME: document.
+ * The service that is being manipulated. Do not free.
*/
- char *service_name;
+ const char *service_name;
/**
- * FIXME: document.
+ * Timeout for the operation.
*/
- struct GNUNET_CLIENT_Connection *client;
+ struct GNUNET_TIME_Absolute timeout;
/**
- * FIXME: document.
+ * Length of service_name plus one.
*/
- const struct GNUNET_CONFIGURATION_Handle *cfg;
+ size_t slen;
/**
- * FIXME: document.
+ * Number of attempts left for transmitting the request to ARM.
+ * We may fail the first time (say because ARM is not yet up),
+ * in which case we wait a bit and re-try (timeout permitting).
*/
- struct GNUNET_TIME_Absolute timeout;
+ unsigned int attempts_left;
/**
- * FIXME: document.
+ * Type of the request expressed as a message type (start or stop).
*/
uint16_t type;
+
};
/**
- * FIXME: document.
+ * A client specifically requested starting of ARM itself.
+ * This function is called with information about whether
+ * or not ARM is running; if it is, report success. If
+ * it is not, start the ARM process.
+ *
+ * @param cls the context for the request that we will report on (struct
RequestContext*)
+ * @param tc why were we called (reason says if ARM is running)
*/
static void
-arm_service_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+arm_service_report (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- struct ArmContext *pos = cls;
+ struct RequestContext *pos = cls;
pid_t pid;
char *binary;
char *config;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
{
+ /* arm is running! */
if (pos->callback != NULL)
pos->callback (pos->cls, GNUNET_YES);
GNUNET_free (pos);
return;
}
- binary = NULL;
- config = NULL;
+ /* FIXME: should we check that HOSTNAME for 'arm' is localhost? */
/* start service */
- if ((GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_string (pos->cfg,
- "arm",
- "BINARY",
- &binary)) ||
- (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (pos->cfg,
- "arm", "CONFIG", &config)))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_string (pos->h->cfg,
+ "arm",
+ "BINARY",
+ &binary))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Configuration file or binary for ARM not known!\n"));
+ _("Configuration failes to specify option `%s' in section
`%s'!\n"),
+ "BINARY",
+ "arm");
if (pos->callback != NULL)
pos->callback (pos->cls, GNUNET_SYSERR);
- GNUNET_free_non_null (binary);
GNUNET_free (pos);
return;
}
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_filename (pos->h->cfg,
+ "arm", "CONFIG", &config))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Configuration fails to specify option `%s' in section
`%s'!\n"),
+ "CONFIG",
+ "arm");
+ if (pos->callback != NULL)
+ pos->callback (pos->cls, GNUNET_SYSERR);
+ GNUNET_free (binary);
+ GNUNET_free (pos);
+ return;
+ }
pid = GNUNET_OS_start_process (binary, binary, "-d", "-c", config,
#if DEBUG_ARM
"-L", "DEBUG",
@@ -128,24 +243,34 @@
GNUNET_free (pos);
return;
}
- /* FIXME: consider checking again to see if it worked!? */
if (pos->callback != NULL)
pos->callback (pos->cls, GNUNET_YES);
GNUNET_free (pos);
}
+/**
+ * Process a response from ARM to a request for a change in service
+ * status.
+ *
+ * @param cls the request context
+ * @param msg the response
+ */
static void
handle_response (void *cls, const struct GNUNET_MessageHeader *msg)
{
- struct ArmContext *sc = cls;
+ struct RequestContext *sc = cls;
int ret;
if (msg == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("Error receiving response from ARM service\n"));
- GNUNET_CLIENT_disconnect (sc->client);
+ GNUNET_CLIENT_disconnect (sc->h->client);
+ sc->h->client = GNUNET_CLIENT_connect (sc->h->sched,
+ "arm",
+ sc->h->cfg);
+ GNUNET_assert (NULL != sc->h->client);
if (sc->callback != NULL)
sc->callback (sc->cls, GNUNET_SYSERR);
GNUNET_free (sc);
@@ -170,73 +295,144 @@
GNUNET_break (0);
ret = GNUNET_SYSERR;
}
- GNUNET_CLIENT_disconnect (sc->client);
if (sc->callback != NULL)
sc->callback (sc->cls, ret);
GNUNET_free (sc);
}
+/**
+ * We've failed to transmit the request to the ARM service.
+ * Report our failure and clean up the state.
+ *
+ * @param sctx the state of the (now failed) request
+ */
+static void
+report_transmit_failure (struct RequestContext *sctx)
+{
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Error while trying to transmit to ARM service\n"));
+ if (sctx->callback != NULL)
+ sctx->callback (sctx->cls, GNUNET_SYSERR);
+ GNUNET_free (sctx);
+}
+
+
+/**
+ * Transmit a request for a service status change to the
+ * ARM service.
+ *
+ * @param cls the "struct RequestContext" identifying the request
+ * @param size how many bytes are available in buf
+ * @param buf where to write the request, NULL on error
+ * @return number of bytes written to buf
+ */
static size_t
+send_service_msg (void *cls, size_t size, void *buf);
+
+
+/**
+ * We've failed to transmit the request to the ARM service but
+ * are now going to try again.
+ *
+ * @param cls state of the request
+ * @param tc task context (unused)
+ */
+static void
+retry_request (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ struct RequestContext *sctx = cls;
+
+ if (NULL ==
+ GNUNET_CLIENT_notify_transmit_ready (sctx->h->client,
+ sctx->slen +
+ sizeof (struct
+ GNUNET_MessageHeader),
+ GNUNET_TIME_absolute_get_remaining
(sctx->timeout),
+ &send_service_msg,
+ sctx))
+ {
+ report_transmit_failure (sctx);
+ return;
+ }
+}
+
+
+/**
+ * Transmit a request for a service status change to the
+ * ARM service.
+ *
+ * @param cls the "struct RequestContext" identifying the request
+ * @param size how many bytes are available in buf
+ * @param buf where to write the request, NULL on error
+ * @return number of bytes written to buf
+ */
+static size_t
send_service_msg (void *cls, size_t size, void *buf)
{
- struct ArmContext *sctx = cls;
+ struct RequestContext *sctx = cls;
struct GNUNET_MessageHeader *msg;
- size_t slen;
+ struct GNUNET_TIME_Relative rem;
if (buf == NULL)
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Error while trying to transmit to ARM service\n"));
- GNUNET_CLIENT_disconnect (sctx->client);
- if (sctx->callback != NULL)
- sctx->callback (sctx->cls, GNUNET_SYSERR);
- GNUNET_free (sctx->service_name);
- GNUNET_free (sctx);
+ GNUNET_CLIENT_disconnect (sctx->h->client);
+ sctx->h->client = GNUNET_CLIENT_connect (sctx->h->sched,
+ "arm",
+ sctx->h->cfg);
+ GNUNET_assert (sctx->h->client != NULL);
+ rem = GNUNET_TIME_absolute_get_remaining (sctx->timeout);
+ if ( (sctx->attempts_left-- > 0) &&
+ (rem.value > 0) )
+ {
+ GNUNET_SCHEDULER_add_delayed (sctx->h->sched,
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_relative_min
(MIN_RETRY_DELAY,
+ rem),
+ &retry_request,
+ sctx);
+ return 0;
+ }
+ report_transmit_failure (sctx);
return 0;
}
#if DEBUG_ARM
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Transmitting service request to ARM.\n"));
#endif
- slen = strlen (sctx->service_name) + 1;
- GNUNET_assert (size >= slen);
+ GNUNET_assert (size >= sctx->slen);
msg = buf;
- msg->size = htons (sizeof (struct GNUNET_MessageHeader) + slen);
+ msg->size = htons (sizeof (struct GNUNET_MessageHeader) + sctx->slen);
msg->type = htons (sctx->type);
- memcpy (&msg[1], sctx->service_name, slen);
- GNUNET_free (sctx->service_name);
- sctx->service_name = NULL;
- GNUNET_CLIENT_receive (sctx->client,
+ memcpy (&msg[1], sctx->service_name, sctx->slen);
+ GNUNET_CLIENT_receive (sctx->h->client,
&handle_response,
sctx,
GNUNET_TIME_absolute_get_remaining (sctx->timeout));
- return slen + sizeof (struct GNUNET_MessageHeader);
+ return sctx->slen + sizeof (struct GNUNET_MessageHeader);
}
/**
* Start or stop a service.
*
+ * @param h handle to ARM
* @param service_name name of the service
- * @param cfg configuration to use (needed to contact ARM;
- * the ARM service may internally use a different
- * configuration to determine how to start the service).
- * @param sched scheduler to use
* @param timeout how long to wait before failing for good
* @param cb callback to invoke when service is ready
* @param cb_cls closure for callback
* @param type type of the request
*/
static void
-change_service (const char *service_name,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_SCHEDULER_Handle *sched,
+change_service (struct GNUNET_ARM_Handle *h,
+ const char *service_name,
struct GNUNET_TIME_Relative timeout,
GNUNET_ARM_Callback cb, void *cb_cls, uint16_t type)
{
- struct GNUNET_CLIENT_Connection *client;
- struct ArmContext *sctx;
+ struct RequestContext *sctx;
size_t slen;
slen = strlen (service_name) + 1;
@@ -248,128 +444,248 @@
cb (cb_cls, GNUNET_NO);
return;
}
- client = GNUNET_CLIENT_connect (sched, "arm", cfg);
- if (client == NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Failed to connect to ARM service\n"));
- if (cb != NULL)
- cb (cb_cls, GNUNET_SYSERR);
- return;
- }
#if DEBUG_ARM
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("ARM requests starting of service `%s'.\n"), service_name);
#endif
- sctx = GNUNET_malloc (sizeof (struct ArmContext));
+ sctx = GNUNET_malloc (sizeof (struct RequestContext) + slen);
+ sctx->h = h;
sctx->callback = cb;
sctx->cls = cb_cls;
- sctx->client = client;
- sctx->service_name = GNUNET_strdup (service_name);
+ sctx->service_name = (const char*) &sctx[1];
+ memcpy (&sctx[1],
+ service_name,
+ slen);
sctx->timeout = GNUNET_TIME_relative_to_absolute (timeout);
+ sctx->slen = slen;
+ sctx->attempts_left = MAX_ATTEMPTS;
sctx->type = type;
- if (NULL ==
- GNUNET_CLIENT_notify_transmit_ready (client,
- slen +
- sizeof (struct
- GNUNET_MessageHeader),
- timeout, &send_service_msg, sctx))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Failed to transmit request to ARM service\n"));
- GNUNET_free (sctx->service_name);
- GNUNET_free (sctx);
- if (cb != NULL)
- cb (cb_cls, GNUNET_SYSERR);
- GNUNET_CLIENT_disconnect (client);
- return;
- }
+ retry_request (sctx, NULL);
}
/**
* Start a service.
*
+ * @param h handle to ARM
* @param service_name name of the service
- * @param cfg configuration to use (needed to contact ARM;
- * the ARM service may internally use a different
- * configuration to determine how to start the service).
- * @param sched scheduler to use
* @param timeout how long to wait before failing for good
* @param cb callback to invoke when service is ready
* @param cb_cls closure for callback
*/
void
-GNUNET_ARM_start_service (const char *service_name,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_SCHEDULER_Handle *sched,
+GNUNET_ARM_start_service (struct GNUNET_ARM_Handle *h,
+ const char *service_name,
struct GNUNET_TIME_Relative timeout,
GNUNET_ARM_Callback cb, void *cb_cls)
{
- struct ArmContext *sctx;
+ struct RequestContext *sctx;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Starting service `%s'\n"), service_name);
if (0 == strcmp ("arm", service_name))
{
- sctx = GNUNET_malloc (sizeof (struct ArmContext));
+ sctx = GNUNET_malloc (sizeof (struct RequestContext));
+ sctx->h = h;
sctx->callback = cb;
sctx->cls = cb_cls;
- sctx->cfg = cfg;
- GNUNET_CLIENT_service_test (sched,
+ sctx->timeout = GNUNET_TIME_relative_to_absolute (timeout);
+ GNUNET_CLIENT_service_test (h->sched,
"arm",
- cfg, timeout, &arm_service_report, sctx);
+ h->cfg, timeout, &arm_service_report, sctx);
return;
}
- change_service (service_name,
- cfg,
- sched, timeout, cb, cb_cls, GNUNET_MESSAGE_TYPE_ARM_START);
+ change_service (h, service_name, timeout, cb, cb_cls,
GNUNET_MESSAGE_TYPE_ARM_START);
}
-
-
/**
* Stop a service.
*
+ * @param h handle to ARM
* @param service_name name of the service
- * @param cfg configuration to use (needed to contact ARM;
- * the ARM service may internally use a different
- * configuration to determine how to start the service).
- * @param sched scheduler to use
* @param timeout how long to wait before failing for good
* @param cb callback to invoke when service is ready
* @param cb_cls closure for callback
*/
void
-GNUNET_ARM_stop_service (const char *service_name,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_SCHEDULER_Handle *sched,
+GNUNET_ARM_stop_service (struct GNUNET_ARM_Handle *h,
+ const char *service_name,
struct GNUNET_TIME_Relative timeout,
GNUNET_ARM_Callback cb, void *cb_cls)
{
- struct GNUNET_CLIENT_Connection *client;
-
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Stopping service `%s'\n"), service_name);
if (0 == strcmp ("arm", service_name))
{
- client = GNUNET_CLIENT_connect (sched, "arm", cfg);
- if (client == NULL)
- {
- if (cb != NULL)
- cb (cb_cls, GNUNET_SYSERR);
- return;
- }
- GNUNET_CLIENT_service_shutdown (client);
- GNUNET_CLIENT_disconnect (client);
+ GNUNET_CLIENT_service_shutdown (h->client);
if (cb != NULL)
cb (cb_cls, GNUNET_NO);
return;
}
- change_service (service_name,
- cfg,
- sched, timeout, cb, cb_cls, GNUNET_MESSAGE_TYPE_ARM_STOP);
+ change_service (h, service_name, timeout, cb, cb_cls,
GNUNET_MESSAGE_TYPE_ARM_STOP);
}
+
+/**
+ * Function to call for each service.
+ *
+ * @param h handle to ARM
+ * @param service_name name of the service
+ * @param timeout how long to wait before failing for good
+ * @param cb callback to invoke when service is ready
+ * @param cb_cls closure for callback
+ */
+typedef void (*ServiceOperation) (struct GNUNET_ARM_Handle *h,
+ const char *service_name,
+ struct GNUNET_TIME_Relative timeout,
+ GNUNET_ARM_Callback cb, void *cb_cls);
+
+
+/**
+ * Context for starting or stopping multiple services.
+ */
+struct MultiContext
+{
+ /**
+ * NULL-terminated array of services to start or stop.
+ */
+ char **services;
+
+ /**
+ * Our handle to ARM.
+ */
+ struct GNUNET_ARM_Handle *h;
+
+ /**
+ * Identifies the operation (start or stop).
+ */
+ ServiceOperation op;
+
+ /**
+ * Current position in "services".
+ */
+ unsigned int pos;
+};
+
+
+/**
+ * Run the operation for the next service in the multi-service
+ * request.
+ *
+ * @param cls the "struct MultiContext" that is being processed
+ * @param success status of the previous operation (ignored)
+ */
+static void
+next_operation (void *cls,
+ int success)
+{
+ struct MultiContext *mc = cls;
+ char *pos;
+
+ if (NULL == (pos = mc->services[mc->pos]))
+ {
+ GNUNET_free (mc->services);
+ GNUNET_ARM_disconnect (mc->h);
+ GNUNET_free (mc);
+ return;
+ }
+ mc->pos++;
+ mc->op (mc->h, pos, MULTI_TIMEOUT, &next_operation, mc);
+ GNUNET_free (pos);
+}
+
+
+/**
+ * Run a multi-service request.
+ *
+ * @param cfg configuration to use (needed to contact ARM;
+ * the ARM service may internally use a different
+ * configuration to determine how to start the service).
+ * @param sched scheduler to use
+ * @param op the operation to perform for each service
+ * @param va NULL-terminated list of services
+ */
+static void
+run_multi_request (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ struct GNUNET_SCHEDULER_Handle *sched,
+ ServiceOperation op,
+ va_list va)
+{
+ va_list cp;
+ unsigned int total;
+ struct MultiContext *mc;
+ struct GNUNET_ARM_Handle *h;
+ const char *c;
+
+ h = GNUNET_ARM_connect (cfg, sched, NULL);
+ if (NULL == h)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Error while trying to transmit to ARM service\n"));
+ return;
+ }
+ total = 1;
+ va_copy (cp, va);
+ while (NULL != (va_arg (cp, const char*))) total++;
+ va_end (cp);
+ mc = GNUNET_malloc (sizeof(struct MultiContext));
+ mc->services = GNUNET_malloc (total * sizeof (char*));
+ mc->h = h;
+ mc->op = op;
+ total = 0;
+ va_copy (cp, va);
+ while (NULL != (c = va_arg (cp, const char*)))
+ mc->services[total++] = GNUNET_strdup (c);
+ va_end (cp);
+ next_operation (mc, GNUNET_YES);
+}
+
+
+/**
+ * Start multiple services in the specified order. Convenience
+ * function. Works asynchronously, failures are not reported.
+ *
+ * @param cfg configuration to use (needed to contact ARM;
+ * the ARM service may internally use a different
+ * configuration to determine how to start the service).
+ * @param sched scheduler to use
+ * @param ... NULL-terminated list of service names (const char*)
+ */
+void
+GNUNET_ARM_start_services (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ struct GNUNET_SCHEDULER_Handle *sched,
+ ...)
+{
+ va_list ap;
+
+ va_start (ap, sched);
+ run_multi_request (cfg, sched, &GNUNET_ARM_start_service, ap);
+ va_end (ap);
+}
+
+
+/**
+ * Stop multiple services in the specified order. Convenience
+ * function. Works asynchronously, failures are not reported.
+ *
+ * @param cfg configuration to use (needed to contact ARM;
+ * the ARM service may internally use a different
+ * configuration to determine how to start the service).
+ * @param sched scheduler to use
+ * @param ... NULL-terminated list of service names (const char*)
+ */
+void
+GNUNET_ARM_stop_services (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ struct GNUNET_SCHEDULER_Handle *sched,
+ ...)
+{
+ va_list ap;
+
+ va_start (ap, sched);
+ run_multi_request (cfg, sched, &GNUNET_ARM_stop_service, ap);
+ va_end (ap);
+}
+
+
/* end of arm_api.c */
Modified: gnunet/src/arm/gnunet-arm.c
===================================================================
--- gnunet/src/arm/gnunet-arm.c 2009-10-05 06:40:40 UTC (rev 9111)
+++ gnunet/src/arm/gnunet-arm.c 2009-10-05 09:56:25 UTC (rev 9112)
@@ -65,8 +65,47 @@
*/
static int ret;
+/**
+ * Connection with ARM.
+ */
+static struct GNUNET_ARM_Handle *h;
+/**
+ * Our scheduler.
+ */
+static struct GNUNET_SCHEDULER_Handle *sched;
+
+/**
+ * Our configuration.
+ */
+const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Processing stage that we are in. Simple counter.
+ */
+static unsigned int phase;
+
+
+/**
+ * Main continuation-passing-style loop. Runs the various
+ * jobs that we've been asked to do in order.
+ *
+ * @param cls closure, unused
+ * @param tc context, unused
+ */
static void
+cps_loop (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc);
+
+
+/**
+ * Callback invoked with the status of the last operation. Reports to the
+ * user and then runs the next phase in the FSM.
+ *
+ * @param cls pointer to "const char*" identifying service that was manipulated
+ * @param success GNUNET_OK if service is now running, GNUNET_NO if not,
GNUNET_SYSERR on error
+ */
+static void
confirm_cb (void *cls, int success)
{
const char *service = cls;
@@ -83,9 +122,21 @@
_("Error updating service `%s': ARM not running\n"), service);
break;
}
+ GNUNET_SCHEDULER_add_continuation (sched,
+ GNUNET_NO,
+ &cps_loop,
+ NULL,
+ GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
+/**
+ * Function called to confirm that a service is running (or that
+ * it is not running).
+ *
+ * @param cls pointer to "const char*" identifying service that was manipulated
+ * @param tc reason determines if service is now running
+ */
static void
confirm_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
@@ -95,6 +146,11 @@
fprintf (stdout, _("Service `%s' is running.\n"), service);
else
fprintf (stdout, _("Service `%s' is not running.\n"), service);
+ GNUNET_SCHEDULER_add_continuation (sched,
+ GNUNET_NO,
+ &cps_loop,
+ NULL,
+ GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
@@ -102,41 +158,91 @@
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param sched the scheduler to use
+ * @param s the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be
NULL!)
- * @param cfg configuration
+ * @param c configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
+ struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
- const struct GNUNET_CONFIGURATION_Handle *cfg)
+ const struct GNUNET_CONFIGURATION_Handle *c)
{
- if (term != NULL)
+ sched = s;
+ cfg = c;
+ h = GNUNET_ARM_connect (cfg, sched, NULL);
+ if (h == NULL)
{
- GNUNET_ARM_stop_service (term, cfg, sched, TIMEOUT, &confirm_cb, term);
+ fprintf (stderr,
+ _("Fatal error initializing ARM API.\n"));
+ ret = 1;
+ return;
}
- if (end)
+ GNUNET_SCHEDULER_add_continuation (sched,
+ GNUNET_NO,
+ &cps_loop,
+ NULL,
+ GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+}
+
+
+/**
+ * Main continuation-passing-style loop. Runs the various
+ * jobs that we've been asked to do in order.
+ *
+ * @param cls closure, unused
+ * @param tc context, unused
+ */
+static void
+cps_loop (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ while (1)
{
- GNUNET_ARM_stop_service ("arm",
- cfg, sched, TIMEOUT, &confirm_cb, "arm");
+ switch (phase++)
+ {
+ case 0:
+ if (term != NULL)
+ {
+ GNUNET_ARM_stop_service (h, term, TIMEOUT, &confirm_cb, term);
+ return;
+ }
+ break;
+ case 1:
+ if (end)
+ {
+ GNUNET_ARM_stop_service (h, "arm", TIMEOUT, &confirm_cb, "arm");
+ return;
+ }
+ break;
+ case 2:
+ if (start)
+ {
+ GNUNET_ARM_start_service (h, "arm", TIMEOUT, &confirm_cb, "arm");
+ return;
+ }
+ break;
+ case 3:
+ if (init != NULL)
+ {
+ GNUNET_ARM_start_service (h, init, TIMEOUT, &confirm_cb, init);
+ return;
+ }
+ break;
+ case 4:
+ if (test != NULL)
+ {
+ GNUNET_CLIENT_service_test (sched, test, cfg, TIMEOUT,
&confirm_task, test);
+ return;
+ }
+ break;
+ default: /* last phase */
+ GNUNET_ARM_disconnect (h);
+ return;
+ }
}
- if (start)
- {
- GNUNET_ARM_start_service ("arm",
- cfg, sched, TIMEOUT, &confirm_cb, "arm");
- }
- if (init != NULL)
- {
- GNUNET_ARM_start_service (init, cfg, sched, TIMEOUT, &confirm_cb, init);
- }
- if (test != NULL)
- {
- GNUNET_CLIENT_service_test (sched,
- test, cfg, TIMEOUT, &confirm_task, test);
- }
}
Modified: gnunet/src/arm/gnunet-service-arm.c
===================================================================
--- gnunet/src/arm/gnunet-service-arm.c 2009-10-05 06:40:40 UTC (rev 9111)
+++ gnunet/src/arm/gnunet-service-arm.c 2009-10-05 09:56:25 UTC (rev 9112)
@@ -46,18 +46,34 @@
/**
- * Run maintenance every second.
+ * Run normal maintenance every 2s.
*/
-#define MAINT_FREQUENCY GNUNET_TIME_UNIT_SECONDS
+#define MAINT_FREQUENCY GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 2)
/**
+ * Run fast maintenance after 100ms. This is used for an extra-job
+ * that is run to check for a process that we just killed.
+ */
+#define MAINT_FAST_FREQUENCY GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MILLISECONDS, 100)
+
+/**
* How long do we wait until we decide that a service
* did not start?
*/
#define CHECK_TIMEOUT GNUNET_TIME_UNIT_MINUTES
+/**
+ * List of our services.
+ */
struct ServiceList;
+/**
+ * Function to call if waitpid informs us that
+ * a process has died.
+ *
+ * @param cls closure
+ * @param pos entry in the service list of the process that died
+ */
typedef void (*CleanCallback) (void *cls, struct ServiceList * pos);
/**
@@ -137,6 +153,24 @@
static char *prefix_command;
+/**
+ * Background task doing maintenance.
+ *
+ * @param cls closure, NULL if we need to self-restart
+ * @param tc context
+ */
+static void
+maint (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+
+
+/**
+ * Transmit a status result message.
+ *
+ * @param cls pointer to "unit16_t*" with message type
+ * @param size number of bytes available in buf
+ * @param buf where to copy the message, NULL on error
+ * @return number of bytes copied to buf
+ */
static size_t
write_result (void *cls, size_t size, void *buf)
{
@@ -159,6 +193,9 @@
* Signal our client that we will start or stop the
* service.
*
+ * @param client who is being signalled
+ * @param name name of the service
+ * @param result message type to send
* @return NULL if it was not found
*/
static void
@@ -188,6 +225,7 @@
* Find the process with the given service
* name in the given list, remove it and return it.
*
+ * @param name which service entry to look up
* @return NULL if it was not found
*/
static struct ServiceList *
@@ -216,6 +254,11 @@
}
+/**
+ * Free an entry in the service list.
+ *
+ * @param pos entry to free
+ */
static void
free_entry (struct ServiceList *pos)
{
@@ -226,8 +269,6 @@
}
-
-
/**
* Actually start the process for the given service.
*
@@ -335,6 +376,9 @@
/**
* Start the specified service.
+ *
+ * @param client who is asking for this
+ * @param servicename name of the service to start
*/
static void
start_service (struct GNUNET_SERVER_Client *client, const char *servicename)
@@ -394,6 +438,13 @@
}
+/**
+ * Free the given entry in the service list and signal
+ * the given client that the service is now down.
+ *
+ * @param cls pointer to the client ("struct GNUNET_SERVER_Client*")
+ * @param pos entry for the service
+ */
static void
free_and_signal (void *cls, struct ServiceList *pos)
{
@@ -409,9 +460,13 @@
/**
* Stop the specified service.
+ *
+ * @param client who is asking for this
+ * @param servicename name of the service to stop
*/
static void
-stop_service (struct GNUNET_SERVER_Client *client, const char *servicename)
+stop_service (struct GNUNET_SERVER_Client *client,
+ const char *servicename)
{
struct ServiceList *pos;
struct GNUNET_CLIENT_Connection *sc;
@@ -445,6 +500,11 @@
pos->kill_continuation = &free_and_signal;
pos->kill_continuation_cls = client;
GNUNET_SERVER_client_keep (client);
+ GNUNET_SCHEDULER_add_delayed (sched,
+ GNUNET_YES,
+ GNUNET_SCHEDULER_PRIORITY_IDLE,
+ GNUNET_SCHEDULER_NO_TASK,
+ MAINT_FAST_FREQUENCY, &maint, NULL);
}
else
{
@@ -529,11 +589,10 @@
}
-
/**
* Background task doing maintenance.
*
- * @param cls closure
+ * @param cls closure, NULL if we need to self-restart
* @param tc context
*/
static void
@@ -561,11 +620,12 @@
}
return;
}
- GNUNET_SCHEDULER_add_delayed (tc->sched,
- GNUNET_YES,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
- GNUNET_SCHEDULER_NO_TASK,
- MAINT_FREQUENCY, &maint, NULL);
+ if (cls == NULL)
+ GNUNET_SCHEDULER_add_delayed (tc->sched,
+ GNUNET_YES,
+ GNUNET_SCHEDULER_PRIORITY_IDLE,
+ GNUNET_SCHEDULER_NO_TASK,
+ MAINT_FREQUENCY, &maint, NULL);
/* check for services that died (WAITPID) */
prev = NULL;
@@ -656,8 +716,7 @@
/**
- * List of handlers for the messages understood by this
- * service.
+ * List of handlers for the messages understood by this service.
*/
static struct GNUNET_SERVER_MessageHandler handlers[] = {
{&handle_start, NULL, GNUNET_MESSAGE_TYPE_ARM_START, 0},
Modified: gnunet/src/arm/test_arm_api.c
===================================================================
--- gnunet/src/arm/test_arm_api.c 2009-10-05 06:40:40 UTC (rev 9111)
+++ gnunet/src/arm/test_arm_api.c 2009-10-05 09:56:25 UTC (rev 9112)
@@ -40,17 +40,28 @@
static const struct GNUNET_CONFIGURATION_Handle *cfg;
+static struct GNUNET_ARM_Handle *arm;
+
static int ok = 1;
+
static void
+arm_notify_stop (void *cls, int success)
+{
+ GNUNET_assert (success == GNUNET_NO);
+#if START_ARM
+ GNUNET_ARM_stop_service (arm, "arm", TIMEOUT, NULL, NULL);
+#endif
+}
+
+
+static void
dns_notify (void *cls, const struct sockaddr *addr, socklen_t addrlen)
{
if (addr == NULL)
{
GNUNET_assert (ok == 0);
-#if START_ARM
- GNUNET_ARM_stop_service ("arm", cfg, sched, TIMEOUT, NULL, NULL);
-#endif
+ GNUNET_ARM_stop_service (arm, "resolver", TIMEOUT, &arm_notify_stop,
NULL);
return;
}
GNUNET_assert (addr != NULL);
@@ -62,21 +73,17 @@
resolver_notify (void *cls, int success)
{
GNUNET_assert (success == GNUNET_YES);
- sleep (1); /* FIXME: that we need to do this is a
problem... */
GNUNET_RESOLVER_ip_get (sched,
cfg,
"localhost", AF_INET, TIMEOUT, &dns_notify, NULL);
}
+
static void
arm_notify (void *cls, int success)
{
GNUNET_assert (success == GNUNET_YES);
-#if START_ARM
- sleep (1); /* FIXME: that we need to do this is a
problem... */
-#endif
- GNUNET_ARM_start_service ("resolver",
- cfg, sched, TIMEOUT, &resolver_notify, NULL);
+ GNUNET_ARM_start_service (arm, "resolver", TIMEOUT, &resolver_notify, NULL);
}
@@ -89,8 +96,9 @@
{
cfg = c;
sched = s;
+ arm = GNUNET_ARM_connect (cfg, sched, NULL);
#if START_ARM
- GNUNET_ARM_start_service ("arm", cfg, sched, TIMEOUT, &arm_notify, NULL);
+ GNUNET_ARM_start_service (arm, "arm", TIMEOUT, &arm_notify, NULL);
#else
arm_notify (NULL, GNUNET_YES);
#endif
Modified: gnunet/src/core/test_core_api.c
===================================================================
--- gnunet/src/core/test_core_api.c 2009-10-05 06:40:40 UTC (rev 9111)
+++ gnunet/src/core/test_core_api.c 2009-10-05 09:56:25 UTC (rev 9112)
@@ -82,8 +82,8 @@
GNUNET_CORE_disconnect (p2.ch);
GNUNET_TRANSPORT_disconnect (p1.th);
GNUNET_TRANSPORT_disconnect (p2.th);
- GNUNET_ARM_stop_service ("core", p1.cfg, sched, TIMEOUT, NULL, NULL);
- GNUNET_ARM_stop_service ("core", p2.cfg, sched, TIMEOUT, NULL, NULL);
+ GNUNET_ARM_stop_services (p1.cfg, sched, "core", NULL);
+ GNUNET_ARM_stop_services (p2.cfg, sched, "core", NULL);
ok = 0;
}
@@ -96,8 +96,8 @@
GNUNET_CORE_disconnect (p2.ch);
GNUNET_TRANSPORT_disconnect (p1.th);
GNUNET_TRANSPORT_disconnect (p2.th);
- GNUNET_ARM_stop_service ("core", p1.cfg, sched, TIMEOUT, NULL, NULL);
- GNUNET_ARM_stop_service ("core", p2.cfg, sched, TIMEOUT, NULL, NULL);
+ GNUNET_ARM_stop_services (p1.cfg, sched, "core", NULL);
+ GNUNET_ARM_stop_services (p2.cfg, sched, "core", NULL);
ok = 42;
}
@@ -303,7 +303,7 @@
sleep (1); /* allow ARM to start */
#endif
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
- GNUNET_ARM_start_service ("core", p->cfg, sched, TIMEOUT, NULL, NULL);
+ GNUNET_ARM_start_services (p->cfg, sched, "core", NULL);
p->th = GNUNET_TRANSPORT_connect (sched, p->cfg, p, NULL, NULL, NULL);
GNUNET_assert (p->th != NULL);
GNUNET_TRANSPORT_get_hello (p->th, TIMEOUT, &process_hello, p);
Modified: gnunet/src/core/test_core_api_start_only.c
===================================================================
--- gnunet/src/core/test_core_api_start_only.c 2009-10-05 06:40:40 UTC (rev
9111)
+++ gnunet/src/core/test_core_api_start_only.c 2009-10-05 09:56:25 UTC (rev
9112)
@@ -147,8 +147,8 @@
GNUNET_assert (cls == &p2);
GNUNET_CORE_disconnect (p1.ch);
GNUNET_CORE_disconnect (p2.ch);
- GNUNET_ARM_stop_service ("core", p1.cfg, sched, TIMEOUT, NULL, NULL);
- GNUNET_ARM_stop_service ("core", p2.cfg, sched, TIMEOUT, NULL, NULL);
+ GNUNET_ARM_stop_services (p1.cfg, sched, "core", NULL);
+ GNUNET_ARM_stop_services (p2.cfg, sched, "core", NULL);
ok = 0;
}
@@ -169,7 +169,7 @@
sleep (1); /* allow ARM to start */
#endif
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
- GNUNET_ARM_start_service ("core", p->cfg, sched, TIMEOUT, NULL, NULL);
+ GNUNET_ARM_start_services (p->cfg, sched, "core", NULL);
}
Modified: gnunet/src/include/gnunet_arm_service.h
===================================================================
--- gnunet/src/include/gnunet_arm_service.h 2009-10-05 06:40:40 UTC (rev
9111)
+++ gnunet/src/include/gnunet_arm_service.h 2009-10-05 09:56:25 UTC (rev
9112)
@@ -58,46 +58,112 @@
/**
- * Start a service.
+ * Handle for interacting with ARM.
+ */
+struct GNUNET_ARM_Handle;
+
+
+/**
+ * Setup a context for communicating with ARM. Note that this
+ * can be done even if the ARM service is not yet running.
*
- * @param service_name name of the service
* @param cfg configuration to use (needed to contact ARM;
* the ARM service may internally use a different
* configuration to determine how to start the service).
* @param sched scheduler to use
+ * @param service service that *this* process is implementing/providing, can
be NULL
+ * @return context to use for further ARM operations, NULL on error
+ */
+struct GNUNET_ARM_Handle *
+GNUNET_ARM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ struct GNUNET_SCHEDULER_Handle *sched,
+ const char *service);
+
+
+/**
+ * Disconnect from the ARM service.
+ *
+ * @param h the handle that was being used
+ */
+void
+GNUNET_ARM_disconnect (struct GNUNET_ARM_Handle *h);
+
+
+/**
+ * Start a service. Note that this function merely asks ARM to start
+ * the service and that ARM merely confirms that it forked the
+ * respective process. The specified callback may thus return before
+ * the service has started to listen on the server socket and it may
+ * also be that the service has crashed in the meantime. Clients
+ * should repeatedly try to connect to the service at the respective
+ * port (with some delays in between) before assuming that the service
+ * actually failed to start. Note that if an error is returned to the
+ * callback, clients obviously should not bother with trying to
+ * contact the service.
+ *
+ * @param h handle to ARM
+ * @param service_name name of the service
* @param timeout how long to wait before failing for good
* @param cb callback to invoke when service is ready
* @param cb_cls closure for callback
*/
void
-GNUNET_ARM_start_service (const char *service_name,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_SCHEDULER_Handle *sched,
+GNUNET_ARM_start_service (struct GNUNET_ARM_Handle *h,
+ const char *service_name,
struct GNUNET_TIME_Relative timeout,
GNUNET_ARM_Callback cb, void *cb_cls);
/**
- * Stop a service.
+ * Stop a service. Note that the callback is invoked as soon
+ * as ARM confirms that it will ask the service to terminate.
+ * The actual termination may still take some time.
*
+ * @param h handle to ARM
* @param service_name name of the service
- * @param cfg configuration to use (needed to contact ARM;
- * the ARM service may internally use a different
- * configuration to determine how to start the service).
- * @param sched scheduler to use
* @param timeout how long to wait before failing for good
* @param cb callback to invoke when service is ready
* @param cb_cls closure for callback
*/
void
-GNUNET_ARM_stop_service (const char *service_name,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_SCHEDULER_Handle *sched,
+GNUNET_ARM_stop_service (struct GNUNET_ARM_Handle *h,
+ const char *service_name,
struct GNUNET_TIME_Relative timeout,
GNUNET_ARM_Callback cb, void *cb_cls);
+/**
+ * Start multiple services in the specified order. Convenience
+ * function. Works asynchronously, failures are not reported.
+ *
+ * @param cfg configuration to use (needed to contact ARM;
+ * the ARM service may internally use a different
+ * configuration to determine how to start the service).
+ * @param sched scheduler to use
+ * @param ... NULL-terminated list of service names (const char*)
+ */
+void
+GNUNET_ARM_start_services (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ struct GNUNET_SCHEDULER_Handle *sched,
+ ...);
+
+/**
+ * Stop multiple services in the specified order. Convenience
+ * function. Works asynchronously, failures are not reported.
+ *
+ * @param cfg configuration to use (needed to contact ARM;
+ * the ARM service may internally use a different
+ * configuration to determine how to start the service).
+ * @param sched scheduler to use
+ * @param ... NULL-terminated list of service names (const char*)
+ */
+void
+GNUNET_ARM_stop_services (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ struct GNUNET_SCHEDULER_Handle *sched,
+ ...);
+
+
#if 0 /* keep Emacsens' auto-indent happy */
{
#endif
Modified: gnunet/src/testing/testing.c
===================================================================
--- gnunet/src/testing/testing.c 2009-10-05 06:40:40 UTC (rev 9111)
+++ gnunet/src/testing/testing.c 2009-10-05 09:56:25 UTC (rev 9112)
@@ -49,9 +49,8 @@
#define ARM_START_WAIT GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 120)
/**
- * How many times are we willing to try to
- * wait for "scp" or "gnunet-service-arm" to
- * complete (waitpid) before giving up?
+ * How many times are we willing to try to wait for "scp" or
+ * "gnunet-service-arm" to complete (waitpid) before giving up?
*/
#define MAX_EXEC_WAIT_RUNS 50
@@ -60,12 +59,39 @@
*/
enum StartPhase
{
+ /**
+ * FIXME.
+ */
SP_COPYING,
+
+ /**
+ * FIXME.
+ */
SP_COPIED,
+
+ /**
+ * FIXME.
+ */
SP_START_ARMING,
+
+ /**
+ * FIXME.
+ */
SP_START_CORE,
+
+ /**
+ * FIXME.
+ */
SP_START_DONE,
+
+ /**
+ * FIXME.
+ */
SP_CLEANUP,
+
+ /**
+ * FIXME.
+ */
SP_CONFIG_UPDATE
};
@@ -839,21 +865,56 @@
d);
}
-
+/**
+ * FIXME.
+ */
struct ConnectContext
{
+ /**
+ * FIXME.
+ */
struct GNUNET_TESTING_Daemon *d1;
+
+ /**
+ * FIXME.
+ */
struct GNUNET_TESTING_Daemon *d2;
+
+ /**
+ * FIXME.
+ */
struct GNUNET_TRANSPORT_Handle *d1th;
+
+ /**
+ * FIXME.
+ */
struct GNUNET_TRANSPORT_Handle *d2th;
+
+ /**
+ * When should this operation be complete (or we must trigger
+ * a timeout).
+ */
struct GNUNET_TIME_Absolute timeout;
+
+ /**
+ * Function to call once we are done (or have timed out).
+ */
GNUNET_TESTING_NotifyCompletion cb;
+
+ /**
+ * Closure for "nb".
+ */
void *cb_cls;
};
/**
* Success, connection is up. Signal client our success.
+ *
+ * @param cls FIXME
+ * @param size number of bytes available in buf
+ * @param buf where to copy the message, NULL on error
+ * @return number of bytes copied to buf
*/
static size_t
transmit_ready (void *cls, size_t size, void *buf)
Modified: gnunet/src/transport/transport_api.c
===================================================================
--- gnunet/src/transport/transport_api.c 2009-10-05 06:40:40 UTC (rev
9111)
+++ gnunet/src/transport/transport_api.c 2009-10-05 09:56:25 UTC (rev
9112)
@@ -1458,10 +1458,7 @@
{
struct GNUNET_TRANSPORT_Handle *ret;
- GNUNET_ARM_start_service ("peerinfo",
- cfg, sched, START_SERVICE_TIMEOUT, NULL, NULL);
- GNUNET_ARM_start_service ("transport",
- cfg, sched, START_SERVICE_TIMEOUT, NULL, NULL);
+ GNUNET_ARM_start_services (cfg, sched, "peerinfo", "transport", NULL);
ret = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_Handle));
ret->sched = sched;
ret->cfg = cfg;
@@ -1483,12 +1480,8 @@
stop_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_TRANSPORT_Handle *handle = cls;
- GNUNET_ARM_stop_service ("transport",
- handle->cfg,
- tc->sched, STOP_SERVICE_TIMEOUT, NULL, NULL);
- GNUNET_ARM_stop_service ("peerinfo",
- handle->cfg,
- tc->sched, STOP_SERVICE_TIMEOUT, NULL, NULL);
+
+ GNUNET_ARM_stop_services (handle->cfg, handle->sched, "transport",
"peerinfo", NULL);
}
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] r9112 - in gnunet: . src/arm src/core src/include src/testing src/transport,
gnunet <=