gnunet-service-testbed_connectionpool.c File Reference

connection pooling for connections to peers' services More...

#include "platform.h"
#include "gnunet-service-testbed.h"
#include "gnunet-service-testbed_connectionpool.h"
#include "testbed_api_operations.h"
#include "gnunet_transport_service.h"

Include dependency graph for gnunet-service-testbed_connectionpool.c:

Go to the source code of this file.

Data Structures
struct	PooledConnection
	A pooled connection. More...
struct	GST_ConnectionPool_GetHandle
	The request handle for obtaining a pooled connection. More...

Macros
#define	LOG(kind, ...)    GNUNET_log_from (kind, "testbed-connectionpool", __VA_ARGS__)
	Redefine LOG with a changed log component string. More...
#define	CACHE_EXPIRY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
	Time to expire a cache entry. More...

Functions
static void	expire_task_cancel (struct PooledConnection *entry)
	Cancel the expiration task of the give PooledConnection object. More...
static void	destroy_pooled_connection (struct PooledConnection *entry)
	Destroy a PooledConnection object. More...
static void	expire (void *cls)
	Expire a PooledConnection object. More...
static void	add_to_lru (struct PooledConnection *entry)
	Function to add a PooledConnection object into LRU and begin the expiry task. More...
static struct GST_ConnectionPool_GetHandle *	search_waiting (const struct PooledConnection *entry, struct GST_ConnectionPool_GetHandle *head)
	Function to find a GST_ConnectionPool_GetHandle which is waiting for one of the handles in given entry which are now available. More...
static void	connection_ready (void *cls)
	A handle in the PooledConnection object pointed by cls is ready and there is a GST_ConnectionPool_GetHandle object waiting in the waiting list. More...
static void	peer_connect_notify_cb (void *cls, const struct GNUNET_PeerIdentity *peer, const enum GST_ConnectionPool_Service service)
	Function called from peer connect notify callbacks from CORE and TRANSPORT connections. More...
static void *	transport_peer_connect_notify_cb (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
	Function called to notify transport users that another peer connected to us. More...
static void	opstart_get_handle_transport (void *cls)
	Function called when resources for opening a connection to TRANSPORT are available. More...
static void	oprelease_get_handle_transport (void *cls)
	Function called when the operation responsible for opening a TRANSPORT connection is marked as done. More...
static void *	core_peer_connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
	Method called whenever a given peer connects at CORE level. More...
static void	core_startup_cb (void *cls, const struct GNUNET_PeerIdentity *my_identity)
	Function called after GNUNET_CORE_connect() has succeeded (or failed for good). More...
static void	opstart_get_handle_core (void *cls)
	Function called when resources for opening a connection to CORE are available. More...
static void	oprelease_get_handle_core (void *cls)
	Function called when the operation responsible for opening a CORE connection is marked as done. More...
static void	opstart_get_handle_ats_connectivity (void *cls)
	Function called when resources for opening a connection to ATS are available. More...
static void	oprelease_get_handle_ats_connectivity (void *cls)
	Function called when the operation responsible for opening a ATS connection is marked as done. More...
static int	cleanup_iterator (void *cls, uint32_t key, void *value)
	This function will be called for every PooledConnection object in map. More...
void	GST_connection_pool_init (unsigned int size)
	Initialise the connection pool. More...
void	GST_connection_pool_destroy ()
	Cleanup the connection pool. More...
struct GST_ConnectionPool_GetHandle *	GST_connection_pool_get_handle (unsigned int peer_id, const struct GNUNET_CONFIGURATION_Handle *cfg, enum GST_ConnectionPool_Service service, GST_connection_pool_connection_ready_cb cb, void *cb_cls, const struct GNUNET_PeerIdentity *target, GST_connection_pool_peer_connect_notify connect_notify_cb, void *connect_notify_cb_cls)
	Get a connection handle to service. More...
void	GST_connection_pool_get_handle_done (struct GST_ConnectionPool_GetHandle *gh)
	Relinquish a GST_ConnectionPool_GetHandle object. More...

Variables
static struct GNUNET_CONTAINER_MultiHashMap32 *	map
	A hashmap for quickly finding connections in the connection pool. More...
static struct PooledConnection *	head_lru
	DLL head for maitaining the least recently used PooledConnection objects. More...
static struct PooledConnection *	tail_lru
	DLL tail for maitaining the least recently used PooledConnection objects. More...
static struct PooledConnection *	head_not_pooled
	DLL head for maintaining PooledConnection objects that are not added into the connection pool as it was full at the time the object's creation FIXME. More...
static struct PooledConnection *	tail_not_pooled
	DLL tail for maintaining PooledConnection objects that are not added into the connection pool as it was full at the time the object's creation. More...
static unsigned int	max_size
	The maximum number of entries that can be present in the connection pool. More...

Detailed Description

connection pooling for connections to peers' services

Author

Sree Harsha Totakura sreeh.nosp@m.arsh.nosp@m.a@tot.nosp@m.akur.nosp@m.a.in

Definition in file gnunet-service-testbed_connectionpool.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "testbed-connectionpool", __VA_ARGS__)

Redefine LOG with a changed log component string.

Definition at line 39 of file gnunet-service-testbed_connectionpool.c.

CACHE_EXPIRY

#define CACHE_EXPIRY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)

Time to expire a cache entry.

Definition at line 46 of file gnunet-service-testbed_connectionpool.c.

Function Documentation

expire_task_cancel()

static void expire_task_cancel ( struct PooledConnection *  entry )

static

Cancel the expiration task of the give PooledConnection object.

Parameters

entry

the PooledConnection object

Definition at line 354 of file gnunet-service-testbed_connectionpool.c.

{
  if (NULL != entry->expire_task)
  {
    GNUNET_SCHEDULER_cancel (entry->expire_task);
    entry->expire_task = NULL;
  }
}

References PooledConnection::expire_task, and GNUNET_SCHEDULER_cancel().

Referenced by destroy_pooled_connection(), and GST_connection_pool_get_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_pooled_connection()

static void destroy_pooled_connection ( struct PooledConnection *  entry )

static

Destroy a PooledConnection object.

Parameters

entry

the PooledConnection object

Definition at line 287 of file gnunet-service-testbed_connectionpool.c.

{
  GNUNET_assert ((NULL == entry->head_notify) && (NULL == entry->tail_notify));
  GNUNET_assert ((NULL == entry->head_waiting) &&
                 (NULL == entry->tail_waiting));
  GNUNET_assert (0 == entry->demand);
  expire_task_cancel (entry);
  if (entry->in_lru)
    GNUNET_CONTAINER_DLL_remove (head_lru, tail_lru, entry);
  if (entry->in_pool)
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_CONTAINER_multihashmap32_remove (map, entry->index, entry));
  if (NULL != entry->notify_task)
  {
    GNUNET_SCHEDULER_cancel (entry->notify_task);
    entry->notify_task = NULL;
  }
  LOG_DEBUG ("Cleaning up handles of a pooled connection\n");
  if (NULL != entry->handle_transport)
    GNUNET_assert (NULL != entry->op_transport);
  if (NULL != entry->op_transport)
  {
    GNUNET_TESTBED_operation_done (entry->op_transport);
    entry->op_transport = NULL;
  }
  if (NULL != entry->handle_ats_connectivity)
    GNUNET_assert (NULL != entry->op_ats_connectivity);
  if (NULL != entry->op_ats_connectivity)
  {
    GNUNET_TESTBED_operation_done (entry->op_ats_connectivity);
    entry->op_ats_connectivity = NULL;
  }
  if (NULL != entry->op_core)
  {
    GNUNET_TESTBED_operation_done (entry->op_core);
    entry->op_core = NULL;
  }
  GNUNET_assert (NULL == entry->handle_core);
  GNUNET_assert (NULL == entry->handle_ats_connectivity);
  GNUNET_assert (NULL == entry->handle_transport);
  GNUNET_CONFIGURATION_destroy (entry->cfg);
  GNUNET_free (entry);
}

References PooledConnection::cfg, PooledConnection::demand, expire_task_cancel(), GNUNET_assert, GNUNET_CONFIGURATION_destroy(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap32_remove(), GNUNET_free, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_TESTBED_operation_done(), PooledConnection::handle_ats_connectivity, PooledConnection::handle_core, PooledConnection::handle_transport, head_lru, PooledConnection::head_notify, PooledConnection::head_waiting, PooledConnection::in_lru, PooledConnection::in_pool, PooledConnection::index, LOG_DEBUG, map, PooledConnection::notify_task, PooledConnection::op_ats_connectivity, PooledConnection::op_core, PooledConnection::op_transport, tail_lru, PooledConnection::tail_notify, and PooledConnection::tail_waiting.

Referenced by cleanup_iterator(), expire(), GST_connection_pool_destroy(), and GST_connection_pool_get_handle_done().

Here is the call graph for this function:

Here is the caller graph for this function:

expire()

static void expire ( void *  cls )

static

Expire a PooledConnection object.

Parameters

cls	the PooledConnection object

Definition at line 339 of file gnunet-service-testbed_connectionpool.c.

{
  struct PooledConnection *entry = cls;
 
  entry->expire_task = NULL;
  destroy_pooled_connection (entry);
}

References destroy_pooled_connection(), and PooledConnection::expire_task.

Referenced by add_to_lru().

Here is the call graph for this function:

Here is the caller graph for this function:

add_to_lru()

static void add_to_lru ( struct PooledConnection *  entry )

static

Function to add a PooledConnection object into LRU and begin the expiry task.

Parameters

entry

the PooledConnection object

Definition at line 370 of file gnunet-service-testbed_connectionpool.c.

{
  GNUNET_assert (0 == entry->demand);
  GNUNET_assert (! entry->in_lru);
  GNUNET_CONTAINER_DLL_insert_tail (head_lru, tail_lru, entry);
  entry->in_lru = GNUNET_YES;
  GNUNET_assert (NULL == entry->expire_task);
  entry->expire_task =
    GNUNET_SCHEDULER_add_delayed (CACHE_EXPIRY, &expire, entry);
}

References CACHE_EXPIRY, PooledConnection::demand, expire(), PooledConnection::expire_task, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_SCHEDULER_add_delayed(), GNUNET_YES, head_lru, PooledConnection::in_lru, and tail_lru.

Referenced by GST_connection_pool_get_handle_done().

Here is the call graph for this function:

Here is the caller graph for this function:

search_waiting()

static struct GST_ConnectionPool_GetHandle* search_waiting ( const struct PooledConnection *  entry, struct GST_ConnectionPool_GetHandle *  head  )

static

Function to find a GST_ConnectionPool_GetHandle which is waiting for one of the handles in given entry which are now available.

Parameters

entry	the pooled connection whose active list has to be searched
head	the starting list element in the GSTCacheGetHandle where the search has to be begin

Returns

a suitable GSTCacheGetHandle whose handle ready notify callback hasn't been called yet. NULL if no such suitable GSTCacheGetHandle is found

Definition at line 394 of file gnunet-service-testbed_connectionpool.c.

{
  struct GST_ConnectionPool_GetHandle *gh;
 
  for (gh = head; NULL != gh; gh = gh->next)
  {
    switch (gh->service)
    {
    case GST_CONNECTIONPOOL_SERVICE_CORE:
      if (NULL == entry->handle_core)
        continue;
      if (NULL == entry->peer_identity)
        continue;     /* CORE connection isn't ready yet */
      break;
 
    case GST_CONNECTIONPOOL_SERVICE_TRANSPORT:
      if (NULL == entry->handle_transport)
        continue;
      break;
 
    case GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY:
      if (NULL == entry->handle_ats_connectivity)
        continue;
      break;
    }
    break;
  }
  return gh;
}

References GST_ConnectionPool_GetHandle::entry, gh, GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY, GST_CONNECTIONPOOL_SERVICE_CORE, GST_CONNECTIONPOOL_SERVICE_TRANSPORT, PooledConnection::handle_ats_connectivity, PooledConnection::handle_core, PooledConnection::handle_transport, head, and PooledConnection::peer_identity.

Referenced by connection_ready(), core_startup_cb(), GST_connection_pool_get_handle(), GST_connection_pool_get_handle_done(), and opstart_get_handle_transport().

Here is the caller graph for this function:

connection_ready()

static void connection_ready ( void *  cls )

static

A handle in the PooledConnection object pointed by cls is ready and there is a GST_ConnectionPool_GetHandle object waiting in the waiting list.

This function retrieves that object and calls the handle ready callback. It further schedules itself if there are similar waiting objects which can be notified.

Parameters

cls	the PooledConnection object

Definition at line 436 of file gnunet-service-testbed_connectionpool.c.

{
  struct PooledConnection *entry = cls;
  struct GST_ConnectionPool_GetHandle *gh;
  struct GST_ConnectionPool_GetHandle *gh_next;
 
  GNUNET_assert (NULL != entry->notify_task);
  entry->notify_task = NULL;
  gh = search_waiting (entry, entry->head_waiting);
  GNUNET_assert (NULL != gh);
  gh_next = NULL;
  if (NULL != gh->next)
    gh_next = search_waiting (entry, gh->next);
  GNUNET_CONTAINER_DLL_remove (entry->head_waiting,
                               entry->tail_waiting,
                               gh);
  gh->connection_ready_called = 1;
  if (NULL != gh_next)
    entry->notify_task = GNUNET_SCHEDULER_add_now (&connection_ready,
                                                   entry);
  if ((NULL != gh->target) && (NULL != gh->connect_notify_cb))
  {
    GNUNET_CONTAINER_DLL_insert_tail (entry->head_notify,
                                      entry->tail_notify,
                                      gh);
    gh->notify_waiting = 1;
  }
  LOG_DEBUG ("Connection ready to %u for handle type %u\n",
             (unsigned int) entry->index,
             gh->service);
  gh->cb (gh->cb_cls,
          entry->handle_core,
          entry->handle_transport,
          entry->handle_ats_connectivity,
          entry->peer_identity,
          entry->cfg);
}

References PooledConnection::cfg, GST_ConnectionPool_GetHandle::entry, gh, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_SCHEDULER_add_now(), PooledConnection::handle_ats_connectivity, PooledConnection::handle_core, PooledConnection::handle_transport, PooledConnection::head_notify, PooledConnection::head_waiting, PooledConnection::index, LOG_DEBUG, PooledConnection::notify_task, PooledConnection::peer_identity, search_waiting(), PooledConnection::tail_notify, and PooledConnection::tail_waiting.

Referenced by core_startup_cb(), GST_connection_pool_get_handle(), and opstart_get_handle_transport().

Here is the call graph for this function:

Here is the caller graph for this function:

peer_connect_notify_cb()

static void peer_connect_notify_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer, const enum GST_ConnectionPool_Service  service  )

static

Function called from peer connect notify callbacks from CORE and TRANSPORT connections.

This function calls the pending peer connect notify callbacks which are queued in an entry.

Parameters

cls	the PooledConnection object
peer	the peer that connected
service	the service where this notification has originated

Definition at line 485 of file gnunet-service-testbed_connectionpool.c.

{
  struct PooledConnection *entry = cls;
  struct GST_ConnectionPool_GetHandle *gh;
  struct GST_ConnectionPool_GetHandle *gh_next;
  GST_connection_pool_peer_connect_notify cb;
  void *cb_cls;
 
  for (gh = entry->head_notify; NULL != gh;)
  {
    GNUNET_assert (NULL != gh->target);
    GNUNET_assert (NULL != gh->connect_notify_cb);
    GNUNET_assert (gh->connection_ready_called);
    if (service != gh->service)
    {
      gh = gh->next;
      continue;
    }
    if (0 != memcmp (gh->target, peer, sizeof(struct GNUNET_PeerIdentity)))
    {
      gh = gh->next;
      continue;
    }
    cb = gh->connect_notify_cb;
    cb_cls = gh->connect_notify_cb_cls;
    gh_next = gh->next;
    GNUNET_CONTAINER_DLL_remove (entry->head_notify, entry->tail_notify, gh);
    gh->notify_waiting = 0;
    LOG_DEBUG ("Peer connected to peer %u at service %u\n",
               entry->index,
               gh->service);
    gh = gh_next;
    cb (cb_cls, peer);
  }
}

References GST_ConnectionPool_GetHandle::cb, GST_ConnectionPool_GetHandle::cb_cls, GST_ConnectionPool_GetHandle::entry, gh, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, PooledConnection::head_notify, PooledConnection::index, LOG_DEBUG, peer, service, and PooledConnection::tail_notify.

Referenced by core_peer_connect_cb(), and transport_peer_connect_notify_cb().

Here is the caller graph for this function:

transport_peer_connect_notify_cb()

static void* transport_peer_connect_notify_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_MQ_Handle *  mq  )

static

Function called to notify transport users that another peer connected to us.

Parameters

cls	the PooledConnection object
peer	the peer that connected
mq	queue for sending data to peer

Returns

NULL

Definition at line 534 of file gnunet-service-testbed_connectionpool.c.

{
  struct PooledConnection *entry = cls;
 
  peer_connect_notify_cb (entry, peer, GST_CONNECTIONPOOL_SERVICE_TRANSPORT);
  return NULL;
}

References GST_CONNECTIONPOOL_SERVICE_TRANSPORT, peer, and peer_connect_notify_cb().

Referenced by opstart_get_handle_transport().

Here is the call graph for this function:

Here is the caller graph for this function:

opstart_get_handle_transport()

static void opstart_get_handle_transport ( void *  cls )

static

Function called when resources for opening a connection to TRANSPORT are available.

Parameters

cls	the PooledConnection object

Definition at line 552 of file gnunet-service-testbed_connectionpool.c.

{
  struct PooledConnection *entry = cls;
 
  GNUNET_assert (NULL != entry);
  LOG_DEBUG ("Opening a transport connection to peer %u\n", entry->index);
  entry->handle_transport =
    GNUNET_TRANSPORT_core_connect (entry->cfg,
                                   NULL,
                                   NULL,
                                   entry,
                                   &transport_peer_connect_notify_cb,
                                   NULL,
                                   NULL);
  if (NULL == entry->handle_transport)
  {
    GNUNET_break (0);
    return;
  }
  if (0 == entry->demand)
    return;
  if (NULL != entry->notify_task)
    return;
  if (NULL != search_waiting (entry, entry->head_waiting))
  {
    entry->notify_task = GNUNET_SCHEDULER_add_now (&connection_ready, entry);
    return;
  }
}

References PooledConnection::cfg, connection_ready(), PooledConnection::demand, GNUNET_assert, GNUNET_break, GNUNET_SCHEDULER_add_now(), GNUNET_TRANSPORT_core_connect(), PooledConnection::handle_transport, PooledConnection::head_waiting, PooledConnection::index, LOG_DEBUG, PooledConnection::notify_task, search_waiting(), and transport_peer_connect_notify_cb().

Referenced by GST_connection_pool_get_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

oprelease_get_handle_transport()

static void oprelease_get_handle_transport ( void *  cls )

static

Function called when the operation responsible for opening a TRANSPORT connection is marked as done.

Parameters

cls	the cache entry

Definition at line 590 of file gnunet-service-testbed_connectionpool.c.

{
  struct PooledConnection *entry = cls;
 
  if (NULL == entry->handle_transport)
    return;
  GNUNET_TRANSPORT_core_disconnect (entry->handle_transport);
  entry->handle_transport = NULL;
}

References GNUNET_TRANSPORT_core_disconnect(), and PooledConnection::handle_transport.

Referenced by GST_connection_pool_get_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

core_peer_connect_cb()

static void* core_peer_connect_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_MQ_Handle *  mq  )

static

Method called whenever a given peer connects at CORE level.

Parameters

cls	the PooledConnection object
peer	peer identity this notification is about
mq	message queue for talking to peer

Returns

peer

Definition at line 610 of file gnunet-service-testbed_connectionpool.c.

{
  struct PooledConnection *entry = cls;
 
  peer_connect_notify_cb (entry, peer, GST_CONNECTIONPOOL_SERVICE_CORE);
  return (void *) peer;
}

References GST_CONNECTIONPOOL_SERVICE_CORE, peer, and peer_connect_notify_cb().

Referenced by opstart_get_handle_core().

Here is the call graph for this function:

Here is the caller graph for this function:

core_startup_cb()

static void core_startup_cb ( void *  cls, const struct GNUNET_PeerIdentity *  my_identity  )

static

Function called after GNUNET_CORE_connect() has succeeded (or failed for good).

Note that the private key of the peer is intentionally not exposed here; if you need it, your process should try to read the private key file directly (which should work if you are authorized...). Implementations of this function must not call GNUNET_CORE_disconnect() (other than by scheduling a new task to do this later).

Parameters

cls	the PooledConnection object
my_identity	ID of this peer, NULL if we failed

Definition at line 634 of file gnunet-service-testbed_connectionpool.c.

{
  struct PooledConnection *entry = cls;
 
  if (NULL == my_identity)
  {
    GNUNET_break (0);
    return;
  }
  GNUNET_assert (NULL == entry->peer_identity);
  entry->peer_identity = GNUNET_new (struct GNUNET_PeerIdentity);
  *entry->peer_identity = *my_identity;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Established CORE connection for peer %s (%u)\n",
              GNUNET_i2s (my_identity),
              (unsigned int) entry->index);
  if (0 == entry->demand)
    return;
  if (NULL != entry->notify_task)
    return;
  if (NULL != search_waiting (entry, entry->head_waiting))
  {
    entry->notify_task = GNUNET_SCHEDULER_add_now (&connection_ready, entry);
    return;
  }
}

References connection_ready(), PooledConnection::demand, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_now(), PooledConnection::head_waiting, PooledConnection::index, my_identity, PooledConnection::notify_task, PooledConnection::peer_identity, and search_waiting().

Referenced by opstart_get_handle_core().

Here is the call graph for this function:

Here is the caller graph for this function:

opstart_get_handle_core()

static void opstart_get_handle_core ( void *  cls )

static

Function called when resources for opening a connection to CORE are available.

Parameters

cls	the PooledConnection object

Definition at line 670 of file gnunet-service-testbed_connectionpool.c.

{
  struct PooledConnection *entry = cls;
 
  GNUNET_assert (NULL != entry);
  LOG_DEBUG ("Opening a CORE connection to peer %u\n", entry->index);
  entry->handle_core =
    GNUNET_CORE_connect (entry->cfg,
                         entry, /* closure */
                         &core_startup_cb, /* core startup notify */
                         &core_peer_connect_cb, /* peer connect notify */
                         NULL, /* peer disconnect notify */
                         NULL);
}

References PooledConnection::cfg, core_peer_connect_cb(), core_startup_cb(), GNUNET_assert, GNUNET_CORE_connect(), PooledConnection::handle_core, PooledConnection::index, and LOG_DEBUG.

Referenced by GST_connection_pool_get_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

oprelease_get_handle_core()

static void oprelease_get_handle_core ( void *  cls )

static

Function called when the operation responsible for opening a CORE connection is marked as done.

Parameters

cls	the PooledConnection object

Definition at line 693 of file gnunet-service-testbed_connectionpool.c.

{
  struct PooledConnection *entry = cls;
 
  if (NULL == entry->handle_core)
    return;
  GNUNET_CORE_disconnect (entry->handle_core);
  entry->handle_core = NULL;
  GNUNET_free (entry->peer_identity);
  entry->peer_identity = NULL;
}

References GNUNET_CORE_disconnect(), GNUNET_free, PooledConnection::handle_core, and PooledConnection::peer_identity.

Referenced by GST_connection_pool_get_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

opstart_get_handle_ats_connectivity()

static void opstart_get_handle_ats_connectivity ( void *  cls )

static

Function called when resources for opening a connection to ATS are available.

Parameters

cls	the PooledConnection object

Definition at line 713 of file gnunet-service-testbed_connectionpool.c.

{
  struct PooledConnection *entry = cls;
 
  entry->handle_ats_connectivity = GNUNET_ATS_connectivity_init (entry->cfg);
}

References PooledConnection::cfg, GNUNET_ATS_connectivity_init(), and PooledConnection::handle_ats_connectivity.

Referenced by GST_connection_pool_get_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

oprelease_get_handle_ats_connectivity()

static void oprelease_get_handle_ats_connectivity ( void *  cls )

static

Function called when the operation responsible for opening a ATS connection is marked as done.

Parameters

cls	the PooledConnection object

Definition at line 728 of file gnunet-service-testbed_connectionpool.c.

{
  struct PooledConnection *entry = cls;
 
  if (NULL == entry->handle_ats_connectivity)
    return;
  GNUNET_ATS_connectivity_done (entry->handle_ats_connectivity);
  entry->handle_ats_connectivity = NULL;
}

References GNUNET_ATS_connectivity_done(), and PooledConnection::handle_ats_connectivity.

Referenced by GST_connection_pool_get_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_iterator()

static int cleanup_iterator ( void *  cls, uint32_t  key, void *  value  )

static

This function will be called for every PooledConnection object in map.

Parameters

cls	NULL
key	current key code
value	the PooledConnection object

Returns

GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 750 of file gnunet-service-testbed_connectionpool.c.

{
  struct PooledConnection *entry = value;
 
  GNUNET_assert (NULL != entry);
  destroy_pooled_connection (entry);
  return GNUNET_YES;
}

References destroy_pooled_connection(), GNUNET_assert, GNUNET_YES, and value.

Referenced by GST_connection_pool_destroy().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_connection_pool_init()

void GST_connection_pool_init

(

unsigned int

size

)

Initialise the connection pool.

Parameters

size	the size of the connection pool. Each entry in the connection pool can handle a connection to each of the services enumerated in GST_ConnectionPool_Service

Definition at line 768 of file gnunet-service-testbed_connectionpool.c.

{
  max_size = size;
  if (0 == max_size)
    return;
  GNUNET_assert (NULL == map);
  map = GNUNET_CONTAINER_multihashmap32_create (((size * 3) / 4) + 1);
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap32_create(), map, max_size, and size.

Referenced by testbed_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_connection_pool_destroy()

void GST_connection_pool_destroy

(

void

)

Cleanup the connection pool.

Definition at line 782 of file gnunet-service-testbed_connectionpool.c.

{
  struct PooledConnection *entry;
 
  if (NULL != map)
  {
    GNUNET_assert (
      GNUNET_SYSERR !=
      GNUNET_CONTAINER_multihashmap32_iterate (map, &cleanup_iterator, NULL));
    GNUNET_CONTAINER_multihashmap32_destroy (map);
    map = NULL;
  }
  while (NULL != (entry = head_lru))
  {
    GNUNET_CONTAINER_DLL_remove (head_lru, tail_lru, entry);
    destroy_pooled_connection (entry);
  }
  GNUNET_assert (NULL == head_not_pooled);
}

References cleanup_iterator(), destroy_pooled_connection(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap32_destroy(), GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_SYSERR, head_lru, head_not_pooled, map, and tail_lru.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_connection_pool_get_handle()

struct GST_ConnectionPool_GetHandle* GST_connection_pool_get_handle	(	unsigned int	peer_id,
		const struct GNUNET_CONFIGURATION_Handle *	cfg,
		enum GST_ConnectionPool_Service	service,
		GST_connection_pool_connection_ready_cb	cb,
		void *	cb_cls,
		const struct GNUNET_PeerIdentity *	target,
		GST_connection_pool_peer_connect_notify	connect_notify_cb,
		void *	connect_notify_cb_cls
	)

Get a connection handle to service.

If the connection is opened before and the connection handle is present in the connection pool, it is returned through cb. peer_id is used for the lookup in the connection pool. If the connection handle is not present in the connection pool, a new connection handle is opened for the service using cfg. Additionally, target, connect_notify_cb can be specified to get notified when target is connected at service.

Note

connect_notify_cb will not be called if target is already connected service level. Use GNUNET_TRANSPORT_check_peer_connected() or a similar function from the respective service's API to check if the target peer is already connected or not. connect_notify_cb will be called only once or never (in case target cannot be connected or is already connected).

Parameters

peer_id	the index of the peer
cfg	the configuration with which the transport handle has to be created if it was not present in the cache
service	the service of interest
cb	the callback to notify when the transport handle is available
cb_cls	the closure for cb
target	the peer identify of the peer whose connection to our TRANSPORT subsystem will be notified through the connect_notify_cb. Can be NULL
connect_notify_cb	the callback to call when the target peer is connected. This callback will only be called once or never again (in case the target peer cannot be connected). Can be NULL
connect_notify_cb_cls	the closure for connect_notify_cb

Returns

the handle which can be used cancel or mark that the handle is no longer being used

Definition at line 836 of file gnunet-service-testbed_connectionpool.c.

{
  struct GST_ConnectionPool_GetHandle *gh;
  struct PooledConnection *entry;
  struct GNUNET_TESTBED_Operation *op;
  void *handle;
  uint32_t peer_id32;
 
  peer_id32 = (uint32_t) peer_id;
  handle = NULL;
  entry = NULL;
  if (NULL != map)
    entry = GNUNET_CONTAINER_multihashmap32_get (map, peer_id32);
  if (NULL != entry)
  {
    if (entry->in_lru)
    {
      GNUNET_assert (0 == entry->demand);
      expire_task_cancel (entry);
      GNUNET_CONTAINER_DLL_remove (head_lru, tail_lru, entry);
      entry->in_lru = GNUNET_NO;
    }
    switch (service)
    {
    case GST_CONNECTIONPOOL_SERVICE_TRANSPORT:
      handle = entry->handle_transport;
      if (NULL != handle)
        LOG_DEBUG ("Found TRANSPORT handle for peer %u\n",
                   entry->index);
      break;
    case GST_CONNECTIONPOOL_SERVICE_CORE:
      handle = entry->handle_core;
      if (NULL != handle)
        LOG_DEBUG ("Found CORE handle for peer %u\n",
                   entry->index);
      break;
    case GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY:
      handle = entry->handle_ats_connectivity;
      if (NULL != handle)
        LOG_DEBUG ("Found ATS CONNECTIVITY handle for peer %u\n",
                   entry->index);
      break;
    }
  }
  else
  {
    entry = GNUNET_new (struct PooledConnection);
    entry->index = peer_id32;
    if ((NULL != map) &&
        (GNUNET_CONTAINER_multihashmap32_size (map) < max_size))
    {
      GNUNET_assert (GNUNET_OK ==
                     GNUNET_CONTAINER_multihashmap32_put (
                       map,
                       entry->index,
                       entry,
                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
      entry->in_pool = GNUNET_YES;
    }
    else
    {
      GNUNET_CONTAINER_DLL_insert_tail (head_not_pooled,
                                        tail_not_pooled,
                                        entry);
    }
    entry->cfg = GNUNET_CONFIGURATION_dup (cfg);
  }
  entry->demand++;
  gh = GNUNET_new (struct GST_ConnectionPool_GetHandle);
  gh->entry = entry;
  gh->cb = cb;
  gh->cb_cls = cb_cls;
  gh->target = target;
  gh->connect_notify_cb = connect_notify_cb;
  gh->connect_notify_cb_cls = connect_notify_cb_cls;
  gh->service = service;
  GNUNET_CONTAINER_DLL_insert (entry->head_waiting,
                               entry->tail_waiting,
                               gh);
  if (NULL != handle)
  {
    if (NULL == entry->notify_task)
    {
      if (NULL != search_waiting (entry, entry->head_waiting))
        entry->notify_task =
          GNUNET_SCHEDULER_add_now (&connection_ready, entry);
    }
    return gh;
  }
  op = NULL;
  switch (gh->service)
  {
  case GST_CONNECTIONPOOL_SERVICE_TRANSPORT:
    if (NULL != entry->op_transport)
      return gh;   /* Operation pending */
    op = GNUNET_TESTBED_operation_create_ (entry,
                                           &opstart_get_handle_transport,
                                           &oprelease_get_handle_transport);
    entry->op_transport = op;
    break;
 
  case GST_CONNECTIONPOOL_SERVICE_CORE:
    if (NULL != entry->op_core)
      return gh;   /* Operation pending */
    op = GNUNET_TESTBED_operation_create_ (entry,
                                           &opstart_get_handle_core,
                                           &oprelease_get_handle_core);
    entry->op_core = op;
    break;
 
  case GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY:
    if (NULL != entry->op_ats_connectivity)
      return gh;   /* Operation pending */
    op =
      GNUNET_TESTBED_operation_create_ (entry,
                                        &opstart_get_handle_ats_connectivity,
                                        &oprelease_get_handle_ats_connectivity);
    entry->op_ats_connectivity = op;
    break;
  }
  GNUNET_TESTBED_operation_queue_insert_ (GST_opq_openfds, op);
  GNUNET_TESTBED_operation_begin_wait_ (op);
  return gh;
}

References GNUNET_TESTBED_Operation::cb_cls, cfg, PooledConnection::cfg, connection_ready(), PooledConnection::demand, expire_task_cancel(), gh, GNUNET_assert, GNUNET_CONFIGURATION_dup(), GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap32_get(), GNUNET_CONTAINER_multihashmap32_put(), GNUNET_CONTAINER_multihashmap32_size(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_TESTBED_operation_begin_wait_(), GNUNET_TESTBED_operation_create_(), GNUNET_TESTBED_operation_queue_insert_(), GNUNET_YES, GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY, GST_CONNECTIONPOOL_SERVICE_CORE, GST_CONNECTIONPOOL_SERVICE_TRANSPORT, GST_opq_openfds, handle, PooledConnection::handle_ats_connectivity, PooledConnection::handle_core, PooledConnection::handle_transport, head_lru, head_not_pooled, PooledConnection::head_waiting, PooledConnection::in_lru, PooledConnection::in_pool, PooledConnection::index, LOG_DEBUG, map, max_size, PooledConnection::notify_task, op, PooledConnection::op_ats_connectivity, PooledConnection::op_core, PooledConnection::op_transport, oprelease_get_handle_ats_connectivity(), oprelease_get_handle_core(), oprelease_get_handle_transport(), opstart_get_handle_ats_connectivity(), opstart_get_handle_core(), opstart_get_handle_transport(), peer_id, search_waiting(), service, tail_lru, tail_not_pooled, and PooledConnection::tail_waiting.

Referenced by handle_overlay_connect(), handle_remote_overlay_connect(), occ_cache_get_handle_core_cb(), occ_hello_sent_cb(), overlay_connect_get_config(), p2_transport_connect(), and rocc_hello_sent_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_connection_pool_get_handle_done()

void GST_connection_pool_get_handle_done

(

struct GST_ConnectionPool_GetHandle *

gh

)

Relinquish a GST_ConnectionPool_GetHandle object.

If the connection associated with the object is currently being used by other GST_ConnectionPool_GetHandle objects, it is left in the connection pool. If no other objects are using the connection and the connection pool is not full then it is placed in a LRU queue. If the connection pool is full, then connections from the LRU queue are evicted and closed to create place for this connection. If the connection pool if full and the LRU queue is empty, then the connection is closed.

Parameters

gh	the handle

Definition at line 983 of file gnunet-service-testbed_connectionpool.c.

{
  struct PooledConnection *entry;
 
  if (NULL == gh)
    return;
  entry = gh->entry;
  LOG_DEBUG ("Cleaning up get handle %p for service %u, peer %u\n",
             gh,
             gh->service,
             entry->index);
  if (! gh->connection_ready_called)
  {
    GNUNET_CONTAINER_DLL_remove (entry->head_waiting, entry->tail_waiting, gh);
    if ((NULL == search_waiting (entry, entry->head_waiting)) &&
        (NULL != entry->notify_task))
    {
      GNUNET_SCHEDULER_cancel (entry->notify_task);
      entry->notify_task = NULL;
    }
  }
  if (gh->notify_waiting)
  {
    GNUNET_CONTAINER_DLL_remove (entry->head_notify, entry->tail_notify, gh);
    gh->notify_waiting = 0;
  }
  GNUNET_free (gh);
  gh = NULL;
  GNUNET_assert (! entry->in_lru);
  if (! entry->in_pool)
    GNUNET_CONTAINER_DLL_remove (head_not_pooled, tail_not_pooled, entry);
  if (NULL != map)
  {
    if (GNUNET_YES ==
        GNUNET_CONTAINER_multihashmap32_contains (map, entry->index))
      goto unallocate;
    if (GNUNET_CONTAINER_multihashmap32_size (map) == max_size)
    {
      if (NULL == head_lru)
        goto unallocate;
      destroy_pooled_connection (head_lru);
    }
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CONTAINER_multihashmap32_put (
                     map,
                     entry->index,
                     entry,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    entry->in_pool = GNUNET_YES;
  }
 
unallocate:
  GNUNET_assert (0 < entry->demand);
  entry->demand--;
  if (0 != entry->demand)
    return;
  if (entry->in_pool)
  {
    add_to_lru (entry);
    return;
  }
  destroy_pooled_connection (entry);
}

References add_to_lru(), PooledConnection::demand, destroy_pooled_connection(), gh, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap32_contains(), GNUNET_CONTAINER_multihashmap32_put(), GNUNET_CONTAINER_multihashmap32_size(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_free, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_YES, head_lru, head_not_pooled, PooledConnection::head_notify, PooledConnection::head_waiting, PooledConnection::in_lru, PooledConnection::in_pool, PooledConnection::index, LOG_DEBUG, map, max_size, PooledConnection::notify_task, search_waiting(), tail_not_pooled, PooledConnection::tail_notify, and PooledConnection::tail_waiting.

Referenced by cleanup_occ(), cleanup_occ_lp2c(), cleanup_rocc(), and hello_update_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

map

struct GNUNET_CONTAINER_MultiHashMap32* map

static

A hashmap for quickly finding connections in the connection pool.

Definition at line 240 of file gnunet-service-testbed_connectionpool.c.

Referenced by destroy_pooled_connection(), GST_connection_pool_destroy(), GST_connection_pool_get_handle(), GST_connection_pool_get_handle_done(), and GST_connection_pool_init().

head_lru

struct PooledConnection* head_lru

static

DLL head for maitaining the least recently used PooledConnection objects.

The head is the least recently used object.

Definition at line 246 of file gnunet-service-testbed_connectionpool.c.

Referenced by add_to_lru(), destroy_pooled_connection(), GST_connection_pool_destroy(), GST_connection_pool_get_handle(), and GST_connection_pool_get_handle_done().

tail_lru

struct PooledConnection* tail_lru

static

DLL tail for maitaining the least recently used PooledConnection objects.

Definition at line 251 of file gnunet-service-testbed_connectionpool.c.

Referenced by add_to_lru(), destroy_pooled_connection(), GST_connection_pool_destroy(), and GST_connection_pool_get_handle().

head_not_pooled

struct PooledConnection* head_not_pooled

static

DLL head for maintaining PooledConnection objects that are not added into the connection pool as it was full at the time the object's creation FIXME.

Definition at line 258 of file gnunet-service-testbed_connectionpool.c.

Referenced by GST_connection_pool_destroy(), GST_connection_pool_get_handle(), and GST_connection_pool_get_handle_done().

tail_not_pooled

struct PooledConnection* tail_not_pooled

static

DLL tail for maintaining PooledConnection objects that are not added into the connection pool as it was full at the time the object's creation.

Definition at line 264 of file gnunet-service-testbed_connectionpool.c.

Referenced by GST_connection_pool_get_handle(), and GST_connection_pool_get_handle_done().

max_size

unsigned int max_size

static

The maximum number of entries that can be present in the connection pool.

Definition at line 269 of file gnunet-service-testbed_connectionpool.c.

Referenced by GST_connection_pool_get_handle(), GST_connection_pool_get_handle_done(), and GST_connection_pool_init().