ARM service

Automatic Restart Manager. More...

Data Structures
struct	GNUNET_ARM_ServiceInfo
	Information about a service managed by ARM. More...

Macros
#define	GNUNET_ARM_VERSION   0x00000003
	Version of the arm API. More...

Typedefs
typedef void(*	GNUNET_ARM_ConnectionStatusCallback) (void *cls, int connected)
	Function called whenever we connect to or disconnect from ARM. More...
typedef void(*	GNUNET_ARM_ResultCallback) (void *cls, enum GNUNET_ARM_RequestStatus rs, enum GNUNET_ARM_Result result)
	Function called in response to a start/stop request. More...
typedef void(*	GNUNET_ARM_ServiceListCallback) (void *cls, enum GNUNET_ARM_RequestStatus rs, unsigned int count, const struct GNUNET_ARM_ServiceInfo *list)
	Callback function invoked when list operation is complete. More...
typedef void(*	GNUNET_ARM_ServiceMonitorCallback) (void *cls, const char *service, enum GNUNET_ARM_ServiceMonitorStatus status)
	Function called in when a status update arrives. More...

Enumerations
enum	GNUNET_ARM_RequestStatus { GNUNET_ARM_REQUEST_SENT_OK = 0 , GNUNET_ARM_REQUEST_DISCONNECTED = 2 }
	Statuses of the requests that client can send to ARM. More...
enum	GNUNET_ARM_ServiceMonitorStatus { GNUNET_ARM_SERVICE_MONITORING_STARTED = 0 , GNUNET_ARM_SERVICE_STOPPED = 1 , GNUNET_ARM_SERVICE_STARTING = 2 , GNUNET_ARM_SERVICE_STOPPING = 3 }
	Statuses of services. More...
enum	GNUNET_ARM_Result {   GNUNET_ARM_RESULT_STOPPED = 0 , GNUNET_ARM_RESULT_STOPPING = 1 , GNUNET_ARM_RESULT_STARTING = 2 , GNUNET_ARM_RESULT_IS_STARTING_ALREADY = 3 ,   GNUNET_ARM_RESULT_IS_STOPPING_ALREADY = 4 , GNUNET_ARM_RESULT_IS_STARTED_ALREADY = 5 , GNUNET_ARM_RESULT_IS_STOPPED_ALREADY = 6 , GNUNET_ARM_RESULT_IS_NOT_KNOWN = 7 ,   GNUNET_ARM_RESULT_START_FAILED = 8 , GNUNET_ARM_RESULT_IN_SHUTDOWN = 9 }
	Replies to ARM requests. More...
enum	GNUNET_ARM_ServiceStatus {   GNUNET_ARM_SERVICE_STATUS_STOPPED = 0 , GNUNET_ARM_SERVICE_STATUS_STARTED = 1 , GNUNET_ARM_SERVICE_STATUS_FAILED = 2 , GNUNET_ARM_SERVICE_STATUS_FINISHED = 3 ,   GNUNET_ARM_SERVICE_STATUS_STOPPING = 4 }
	Status of a service managed by ARM. More...

Functions
struct GNUNET_ARM_Handle *	GNUNET_ARM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ARM_ConnectionStatusCallback conn_status, void *conn_status_cls)
	Set up a context for communicating with ARM, then start connecting to the ARM service using that context. More...
void	GNUNET_ARM_disconnect (struct GNUNET_ARM_Handle *h)
	Disconnect from the ARM service and destroy the handle. More...
void	GNUNET_ARM_operation_cancel (struct GNUNET_ARM_Operation *op)
	Abort an operation. More...
struct GNUNET_ARM_Operation *	GNUNET_ARM_request_service_list (struct GNUNET_ARM_Handle *h, GNUNET_ARM_ServiceListCallback cont, void *cont_cls)
	Request a list of running services. More...
struct GNUNET_ARM_Operation *	GNUNET_ARM_request_service_stop (struct GNUNET_ARM_Handle *h, const char *service_name, GNUNET_ARM_ResultCallback cont, void *cont_cls)
	Request a service to be stopped. More...
struct GNUNET_ARM_Operation *	GNUNET_ARM_request_service_start (struct GNUNET_ARM_Handle *h, const char *service_name, enum GNUNET_OS_InheritStdioFlags std_inheritance, GNUNET_ARM_ResultCallback cont, void *cont_cls)
	Request for a service to be started. More...
struct GNUNET_ARM_MonitorHandle *	GNUNET_ARM_monitor_start (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ARM_ServiceMonitorCallback cont, void *cont_cls)
	Setup a context for monitoring ARM, then start connecting to the ARM service for monitoring using that context. More...
void	GNUNET_ARM_monitor_stop (struct GNUNET_ARM_MonitorHandle *h)
	Disconnect from the ARM service and destroy the handle. More...

Detailed Description

Automatic Restart Manager.

See also

Documentation

Macro Definition Documentation

GNUNET_ARM_VERSION

#define GNUNET_ARM_VERSION   0x00000003

Version of the arm API.

Definition at line 52 of file gnunet_arm_service.h.

Typedef Documentation

GNUNET_ARM_ConnectionStatusCallback

typedef void(* GNUNET_ARM_ConnectionStatusCallback) (void *cls, int connected)

Function called whenever we connect to or disconnect from ARM.

Parameters

cls	closure
connected	GNUNET_YES if connected, GNUNET_NO if disconnected, GNUNET_SYSERR if there was an error.

Definition at line 246 of file gnunet_arm_service.h.

GNUNET_ARM_ResultCallback

typedef void(* GNUNET_ARM_ResultCallback) (void *cls, enum GNUNET_ARM_RequestStatus rs, enum GNUNET_ARM_Result result)

Function called in response to a start/stop request.

Will be called when request was not sent successfully, or when a reply comes. If the request was not sent successfully, rs will indicate that, and result will be undefined.

Parameters

cls	closure
rs	status of the request
result	result of the operation

Definition at line 261 of file gnunet_arm_service.h.

GNUNET_ARM_ServiceListCallback

typedef void(* GNUNET_ARM_ServiceListCallback) (void *cls, enum GNUNET_ARM_RequestStatus rs, unsigned int count, const struct GNUNET_ARM_ServiceInfo *list)

Callback function invoked when list operation is complete.

Will be called when request was not sent successfully, or when a reply comes. If the request was not sent successfully, rs will indicate that, and count and list will be undefined.

Parameters

cls	closure
rs	status of the request
count	number of strings in the list
list	list of services managed by arm

Definition at line 278 of file gnunet_arm_service.h.

GNUNET_ARM_ServiceMonitorCallback

typedef void(* GNUNET_ARM_ServiceMonitorCallback) (void *cls, const char *service, enum GNUNET_ARM_ServiceMonitorStatus status)

Function called in when a status update arrives.

Parameters

cls	closure
service	service name
status	status of the service

Definition at line 388 of file gnunet_arm_service.h.

Enumeration Type Documentation

GNUNET_ARM_RequestStatus

enum GNUNET_ARM_RequestStatus

Statuses of the requests that client can send to ARM.

Enumerator
GNUNET_ARM_REQUEST_SENT_OK	Message was sent successfully.
GNUNET_ARM_REQUEST_DISCONNECTED	We disconnected from ARM, and request was not sent.

Definition at line 58 of file gnunet_arm_service.h.

{
  GNUNET_ARM_REQUEST_SENT_OK = 0,
 
  GNUNET_ARM_REQUEST_DISCONNECTED = 2
};

GNUNET_ARM_ServiceMonitorStatus

enum GNUNET_ARM_ServiceMonitorStatus

Statuses of services.

Enumerator
GNUNET_ARM_SERVICE_MONITORING_STARTED	Dummy message.
GNUNET_ARM_SERVICE_STOPPED	Service was stopped.
GNUNET_ARM_SERVICE_STARTING	Service starting was initiated.
GNUNET_ARM_SERVICE_STOPPING	Service stopping was initiated.

Definition at line 75 of file gnunet_arm_service.h.

{
  GNUNET_ARM_SERVICE_MONITORING_STARTED = 0,
 
  GNUNET_ARM_SERVICE_STOPPED = 1,
 
  GNUNET_ARM_SERVICE_STARTING = 2,
 
  GNUNET_ARM_SERVICE_STOPPING = 3
};

GNUNET_ARM_Result

enum GNUNET_ARM_Result

Replies to ARM requests.

Enumerator
GNUNET_ARM_RESULT_STOPPED	Service was stopped (never sent for ARM itself).
GNUNET_ARM_RESULT_STOPPING	ARM stopping was initiated (there's no "stopped" for ARM itself).
GNUNET_ARM_RESULT_STARTING	Service starting was initiated.
GNUNET_ARM_RESULT_IS_STARTING_ALREADY	Asked to start it, but it's already starting.
GNUNET_ARM_RESULT_IS_STOPPING_ALREADY	Asked to stop it, but it's already stopping.
GNUNET_ARM_RESULT_IS_STARTED_ALREADY	Asked to start it, but it's already started.
GNUNET_ARM_RESULT_IS_STOPPED_ALREADY	Asked to stop it, but it's already stopped.
GNUNET_ARM_RESULT_IS_NOT_KNOWN	Asked to start or stop a service, but it's not known.
GNUNET_ARM_RESULT_START_FAILED	Tried to start a service, but that failed for some reason.
GNUNET_ARM_RESULT_IN_SHUTDOWN	Asked to start something, but ARM is shutting down and can't comply.

Definition at line 102 of file gnunet_arm_service.h.

{
  GNUNET_ARM_RESULT_STOPPED = 0,
 
  GNUNET_ARM_RESULT_STOPPING = 1,
 
  GNUNET_ARM_RESULT_STARTING = 2,
 
  GNUNET_ARM_RESULT_IS_STARTING_ALREADY = 3,
 
  GNUNET_ARM_RESULT_IS_STOPPING_ALREADY = 4,
 
  GNUNET_ARM_RESULT_IS_STARTED_ALREADY = 5,
 
  GNUNET_ARM_RESULT_IS_STOPPED_ALREADY = 6,
 
  GNUNET_ARM_RESULT_IS_NOT_KNOWN = 7,
 
  GNUNET_ARM_RESULT_START_FAILED = 8,
 
  GNUNET_ARM_RESULT_IN_SHUTDOWN = 9
};

GNUNET_ARM_ServiceStatus

enum GNUNET_ARM_ServiceStatus

Status of a service managed by ARM.

Enumerator
GNUNET_ARM_SERVICE_STATUS_STOPPED	Service is stopped.
GNUNET_ARM_SERVICE_STATUS_STARTED	Service has been started and is currently running.
GNUNET_ARM_SERVICE_STATUS_FAILED	The service has previously failed, and will be restarted.
GNUNET_ARM_SERVICE_STATUS_FINISHED	The service was started, but then exited normally.
GNUNET_ARM_SERVICE_STATUS_STOPPING	The service was started, and we're currently waiting for it to be stopped.

Definition at line 159 of file gnunet_arm_service.h.

{
  GNUNET_ARM_SERVICE_STATUS_STOPPED = 0,
 
  GNUNET_ARM_SERVICE_STATUS_STARTED = 1,
 
  GNUNET_ARM_SERVICE_STATUS_FAILED = 2,
 
  GNUNET_ARM_SERVICE_STATUS_FINISHED = 3,
 
  GNUNET_ARM_SERVICE_STATUS_STOPPING = 4,
};

Function Documentation

GNUNET_ARM_connect()

struct GNUNET_ARM_Handle* GNUNET_ARM_connect	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		GNUNET_ARM_ConnectionStatusCallback	conn_status,
		void *	conn_status_cls
	)

Set up a context for communicating with ARM, then start connecting to the ARM service using that context.

Parameters

cfg	configuration to use (needed to contact ARM; the ARM service may internally use a different configuration to determine how to start the service).
conn_status	will be called when connecting/disconnecting
conn_status_cls	closure for conn_status

Returns

context to use for further ARM operations, NULL on error.

Definition at line 577 of file arm_api.c.

{
  struct GNUNET_ARM_Handle *h;
 
  h = GNUNET_new (struct GNUNET_ARM_Handle);
  h->cfg = cfg;
  h->conn_status = conn_status;
  h->conn_status_cls = conn_status_cls;
  if (GNUNET_OK != reconnect_arm (h))
  {
    GNUNET_free (h);
    return NULL;
  }
  return h;
}

References cfg, GNUNET_ARM_Handle::cfg, GNUNET_ARM_Handle::conn_status, conn_status(), GNUNET_ARM_Handle::conn_status_cls, GNUNET_free, GNUNET_new, GNUNET_OK, h, and reconnect_arm().

Referenced by GNUNET_TESTING_peer_stop_async(), handle_manage_peer_service(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ARM_disconnect()

void GNUNET_ARM_disconnect

(

struct GNUNET_ARM_Handle *

h

)

Disconnect from the ARM service and destroy the handle.

Parameters

h	the handle that was being used

Disconnect from the ARM service and destroy the handle.

Parameters

h	the handle that was being used

Definition at line 602 of file arm_api.c.

{
  struct GNUNET_ARM_Operation *op;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from ARM service\n");
  while (NULL != (op = h->operation_pending_head))
  {
    GNUNET_CONTAINER_DLL_remove (h->operation_pending_head,
                                 h->operation_pending_tail,
                                 op);
    if (NULL != op->result_cont)
      op->result_cont (op->cont_cls,
                       GNUNET_ARM_REQUEST_DISCONNECTED,
                       0);
    if (NULL != op->list_cont)
      op->list_cont (op->cont_cls,
                     GNUNET_ARM_REQUEST_DISCONNECTED,
                     0,
                     NULL);
    if (NULL != op->async)
    {
      GNUNET_SCHEDULER_cancel (op->async);
      op->async = NULL;
    }
    GNUNET_free (op);
  }
  if (NULL != h->mq)
  {
    GNUNET_MQ_destroy (h->mq);
    h->mq = NULL;
  }
  if (NULL != h->reconnect_task)
  {
    GNUNET_SCHEDULER_cancel (h->reconnect_task);
    h->reconnect_task = NULL;
  }
  GNUNET_free (h);
}

References GNUNET_ARM_Operation::async, GNUNET_ARM_Operation::cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), h, GNUNET_ARM_Operation::list_cont, LOG, GNUNET_ARM_Handle::mq, op, GNUNET_ARM_Handle::operation_pending_head, GNUNET_ARM_Handle::operation_pending_tail, GNUNET_ARM_Handle::reconnect_task, and GNUNET_ARM_Operation::result_cont.

Referenced by cleanup_mctx(), disconn_status(), GNUNET_TESTING_peer_destroy(), GNUNET_TESTING_peer_stop_async_cancel(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ARM_operation_cancel()

void GNUNET_ARM_operation_cancel

(

struct GNUNET_ARM_Operation *

op

)

Abort an operation.

Only prevents the callback from being called, the operation may still complete.

Parameters

op	operation to cancel

Definition at line 789 of file arm_api.c.

{
  struct GNUNET_ARM_Handle *h = op->h;
 
  if (NULL != op->async)
  {
    GNUNET_SCHEDULER_cancel (op->async);
    op->async = NULL;
  }
  if (NULL != op->rfd)
  {
    GNUNET_DISK_file_close (op->rfd);
    op->rfd = NULL;
  }
  if (h->thm == op)
  {
    op->result_cont = NULL;
    return;
  }
  GNUNET_CONTAINER_DLL_remove (h->operation_pending_head,
                               h->operation_pending_tail,
                               op);
  GNUNET_free (op);
}

References GNUNET_ARM_Operation::async, GNUNET_CONTAINER_DLL_remove, GNUNET_DISK_file_close(), GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_ARM_Operation::h, h, op, GNUNET_ARM_Handle::operation_pending_head, GNUNET_ARM_Handle::operation_pending_tail, GNUNET_ARM_Operation::result_cont, GNUNET_ARM_Operation::rfd, and GNUNET_ARM_Handle::thm.

Referenced by handle_arm_list_result(), handle_arm_result(), reconnect_arm_later(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ARM_request_service_list()

struct GNUNET_ARM_Operation* GNUNET_ARM_request_service_list	(	struct GNUNET_ARM_Handle *	h,
		GNUNET_ARM_ServiceListCallback	cont,
		void *	cont_cls
	)

Request a list of running services.

Parameters

h	handle to ARM
cont	callback to invoke after request is sent or is not sent
cont_cls	closure for cont

Returns

handle for the operation, NULL on error

Definition at line 1073 of file arm_api.c.

{
  struct GNUNET_ARM_Operation *op;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_ARM_Message *msg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Requesting LIST from ARM service\n");
  if (0 == h->request_id_counter)
    h->request_id_counter++;
  op = GNUNET_new (struct GNUNET_ARM_Operation);
  op->h = h;
  op->list_cont = cont;
  op->cont_cls = cont_cls;
  op->id = h->request_id_counter++;
  GNUNET_CONTAINER_DLL_insert_tail (h->operation_pending_head,
                                    h->operation_pending_tail,
                                    op);
  env = GNUNET_MQ_msg (msg,
                       GNUNET_MESSAGE_TYPE_ARM_LIST);
  msg->reserved = htonl (0);
  msg->request_id = GNUNET_htonll (op->id);
  GNUNET_MQ_send (h->mq, env);
  return op;
}

References GNUNET_ARM_Operation::cont_cls, env, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_htonll(), GNUNET_MESSAGE_TYPE_ARM_LIST, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, GNUNET_ARM_Operation::h, h, GNUNET_ARM_Operation::id, GNUNET_ARM_Operation::list_cont, LOG, GNUNET_ARM_Handle::mq, msg, op, GNUNET_ARM_Handle::operation_pending_head, GNUNET_ARM_Handle::operation_pending_tail, and GNUNET_ARM_Handle::request_id_counter.

Referenced by action_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ARM_request_service_stop()

struct GNUNET_ARM_Operation* GNUNET_ARM_request_service_stop	(	struct GNUNET_ARM_Handle *	h,
		const char *	service_name,
		GNUNET_ARM_ResultCallback	cont,
		void *	cont_cls
	)

Request a service to be stopped.

Stopping arm itself will not invalidate its handle, and ARM API will try to restore connection to the ARM service, even if ARM connection was lost because you asked for ARM to be stopped. Call GNUNET_ARM_disconnect() to free the handle and prevent further connection attempts.

Parameters

h	handle to ARM
service_name	name of the service
cont	callback to invoke after request is sent or is not sent
cont_cls	closure for cont

Returns

handle for the operation, NULL on error

Definition at line 1038 of file arm_api.c.

{
  struct GNUNET_ARM_Operation *op;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Stopping service `%s'\n",
       service_name);
  op = change_service (h,
                       service_name,
                       cont,
                       cont_cls,
                       GNUNET_MESSAGE_TYPE_ARM_STOP);
  if (NULL == op)
    return NULL;
  /* If the service is ARM, set a flag as we will use MQ errors
     to detect that the process is really gone. */
  if (0 == strcasecmp (service_name,
                       "arm"))
    op->is_arm_stop = GNUNET_YES;
  return op;
}

References change_service(), GNUNET_ARM_Operation::cont_cls, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_ARM_STOP, GNUNET_YES, h, GNUNET_ARM_Operation::is_arm_stop, LOG, op, and service_name.

Referenced by action_loop(), and handle_manage_peer_service().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ARM_request_service_start()

struct GNUNET_ARM_Operation* GNUNET_ARM_request_service_start	(	struct GNUNET_ARM_Handle *	h,
		const char *	service_name,
		enum GNUNET_OS_InheritStdioFlags	std_inheritance,
		GNUNET_ARM_ResultCallback	cont,
		void *	cont_cls
	)

Request for a service to be started.

Parameters

h	handle to ARM
service_name	name of the service
std_inheritance	inheritance of std streams
cont	callback to invoke after request is sent or not sent
cont_cls	closure for cont

Returns

handle for the operation, NULL on error

Definition at line 926 of file arm_api.c.

{
  struct GNUNET_ARM_Operation *op;
  enum GNUNET_ARM_Result ret;
  struct GNUNET_DISK_PipeHandle *sig;
  struct GNUNET_DISK_FileHandle *wsig;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Starting service `%s'\n",
       service_name);
  if (0 != strcasecmp ("arm",
                       service_name))
    return change_service (h,
                           service_name,
                           cont,
                           cont_cls,
                           GNUNET_MESSAGE_TYPE_ARM_START);
 
  /* Possible cases:
   * 1) We're connected to ARM already. Invoke the callback immediately.
   * 2) We're not connected to ARM.
   *    Cancel any reconnection attempts temporarily, then perform
   *    a service test.
   */
  if (GNUNET_YES == h->currently_up)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "ARM is already running\n");
    op = GNUNET_new (struct GNUNET_ARM_Operation);
    op->h = h;
    op->result_cont = cont;
    op->cont_cls = cont_cls;
    GNUNET_CONTAINER_DLL_insert_tail (h->operation_pending_head,
                                      h->operation_pending_tail,
                                      op);
    op->async = GNUNET_SCHEDULER_add_now (&notify_running, op);
    return op;
  }
  /* This is an inherently uncertain choice, as it is of course
     theoretically possible that ARM is up and we just did not
     yet complete the MQ handshake.  However, given that users
     are unlikely to hammer 'gnunet-arm -s' on a busy system,
     the above check should catch 99.99% of the cases where ARM
     is already running. */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Starting ARM service\n");
  if (NULL == (sig = GNUNET_DISK_pipe (GNUNET_DISK_PF_NONE)))
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
                         "pipe");
    ret = GNUNET_ARM_RESULT_START_FAILED;
  }
  else
  {
    wsig = GNUNET_DISK_pipe_detach_end (sig,
                                        GNUNET_DISK_PIPE_END_WRITE);
    ret = start_arm_service (h,
                             std_inheritance,
                             wsig);
    GNUNET_DISK_file_close (wsig);
    if (GNUNET_ARM_RESULT_STARTING == ret)
      reconnect_arm (h);
  }
  op = GNUNET_new (struct GNUNET_ARM_Operation);
  op->h = h;
  op->result_cont = cont;
  op->cont_cls = cont_cls;
  GNUNET_CONTAINER_DLL_insert_tail (h->operation_pending_head,
                                    h->operation_pending_tail,
                                    op);
  op->starting_ret = ret;
  if (NULL != sig)
  {
    op->rfd = GNUNET_DISK_pipe_detach_end (sig,
                                           GNUNET_DISK_PIPE_END_READ);
    /* Wait at most a minute for gnunet-service-arm to be up, as beyond
       that something clearly just went wrong */
    op->async = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_MINUTES,
                                                op->rfd,
                                                &notify_starting,
                                                op);
    GNUNET_DISK_pipe_close (sig);
  }
  else
  {
    op->async = GNUNET_SCHEDULER_add_now (&notify_starting,
                                          op);
  }
  return op;
}

References GNUNET_ARM_Operation::async, change_service(), GNUNET_ARM_Operation::cont_cls, GNUNET_ARM_Handle::currently_up, GNUNET_ARM_RESULT_START_FAILED, GNUNET_ARM_RESULT_STARTING, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_DISK_file_close(), GNUNET_DISK_PF_NONE, GNUNET_DISK_pipe(), GNUNET_DISK_pipe_close(), GNUNET_DISK_pipe_detach_end(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_PIPE_END_WRITE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log_strerror, GNUNET_MESSAGE_TYPE_ARM_START, GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_read_file(), GNUNET_TIME_UNIT_MINUTES, GNUNET_YES, GNUNET_ARM_Operation::h, h, LOG, notify_running(), notify_starting(), op, GNUNET_ARM_Handle::operation_pending_head, GNUNET_ARM_Handle::operation_pending_tail, reconnect_arm(), GNUNET_ARM_Operation::result_cont, ret, GNUNET_ARM_Operation::rfd, service_name, start_arm_service(), and GNUNET_ARM_Operation::starting_ret.

Referenced by action_loop(), and handle_manage_peer_service().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ARM_monitor_start()

struct GNUNET_ARM_MonitorHandle* GNUNET_ARM_monitor_start	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		GNUNET_ARM_ServiceMonitorCallback	cont,
		void *	cont_cls
	)

Setup a context for monitoring ARM, then start connecting to the ARM service for monitoring using that context.

Parameters

cfg	configuration to use (needed to contact ARM; the ARM service may internally use a different configuration to determine how to start the service).
cont	callback to invoke on status updates
cont_cls	closure for cont

Returns

context to use for further ARM monitor operations, NULL on error.

Definition at line 233 of file arm_monitor_api.c.

{
  struct GNUNET_ARM_MonitorHandle *h;
 
  h = GNUNET_new (struct GNUNET_ARM_MonitorHandle);
  h->cfg = cfg;
  h->service_status = cont;
  h->service_status_cls = cont_cls;
  if (GNUNET_OK != reconnect_arm_monitor (h))
  {
    GNUNET_free (h);
    return NULL;
  }
  return h;
}

References cfg, GNUNET_ARM_Handle::cfg, GNUNET_free, GNUNET_new, GNUNET_OK, h, and reconnect_arm_monitor().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ARM_monitor_stop()

void GNUNET_ARM_monitor_stop

(

struct GNUNET_ARM_MonitorHandle *

h

)

Disconnect from the ARM service and destroy the handle.

Parameters

h	the handle that was being used

Disconnect from the ARM service and destroy the handle.

Parameters

h	the handle that was being used

Definition at line 258 of file arm_monitor_api.c.

{
  if (NULL != h->mq)
  {
    GNUNET_MQ_destroy (h->mq);
    h->mq = NULL;
  }
  if (NULL != h->reconnect_task)
  {
    GNUNET_SCHEDULER_cancel (h->reconnect_task);
    h->reconnect_task = NULL;
  }
  GNUNET_free (h);
}

References GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), h, GNUNET_ARM_Handle::mq, and GNUNET_ARM_Handle::reconnect_task.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function: