GNUnet  0.19.3
gnunet-service-testbed_connectionpool.c File Reference

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

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_GetHandlesearch_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_GetHandleGST_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_MultiHashMap32map
 A hashmap for quickly finding connections in the connection pool. More...
 
static struct PooledConnectionhead_lru
 DLL head for maitaining the least recently used PooledConnection objects. More...
 
static struct PooledConnectiontail_lru
 DLL tail for maitaining the least recently used PooledConnection objects. More...
 
static struct PooledConnectionhead_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 PooledConnectiontail_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
entrythe PooledConnection object

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

355 {
356  if (NULL != entry->expire_task)
357  {
359  entry->expire_task = NULL;
360  }
361 }
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:944
struct GNUNET_SCHEDULER_Task * expire_task
The task to expire this connection from the connection pool.

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
entrythe PooledConnection object

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

288 {
289  GNUNET_assert ((NULL == entry->head_notify) && (NULL == entry->tail_notify));
290  GNUNET_assert ((NULL == entry->head_waiting) &&
291  (NULL == entry->tail_waiting));
292  GNUNET_assert (0 == entry->demand);
293  expire_task_cancel (entry);
294  if (entry->in_lru)
296  if (entry->in_pool)
297  GNUNET_assert (
298  GNUNET_OK ==
300  if (NULL != entry->notify_task)
301  {
303  entry->notify_task = NULL;
304  }
305  LOG_DEBUG ("Cleaning up handles of a pooled connection\n");
306  if (NULL != entry->handle_transport)
307  GNUNET_assert (NULL != entry->op_transport);
308  if (NULL != entry->op_transport)
309  {
311  entry->op_transport = NULL;
312  }
313  if (NULL != entry->handle_ats_connectivity)
314  GNUNET_assert (NULL != entry->op_ats_connectivity);
315  if (NULL != entry->op_ats_connectivity)
316  {
318  entry->op_ats_connectivity = NULL;
319  }
320  if (NULL != entry->op_core)
321  {
323  entry->op_core = NULL;
324  }
325  GNUNET_assert (NULL == entry->handle_core);
326  GNUNET_assert (NULL == entry->handle_ats_connectivity);
327  GNUNET_assert (NULL == entry->handle_transport);
329  GNUNET_free (entry);
330 }
#define LOG_DEBUG(...)
Debug logging shorthand.
static struct GNUNET_CONTAINER_MultiHashMap32 * map
A hashmap for quickly finding connections in the connection pool.
static struct PooledConnection * tail_lru
DLL tail for maitaining the least recently used PooledConnection objects.
static struct PooledConnection * head_lru
DLL head for maitaining the least recently used PooledConnection objects.
static void expire_task_cancel(struct PooledConnection *entry)
Cancel the expiration task of the give PooledConnection object.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap32_remove(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, const void *value)
Remove the given key-value pair from the map.
@ GNUNET_OK
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2021
struct GNUNET_TESTBED_Operation * op_ats_connectivity
The operation handle for ATS handle.
struct GST_ConnectionPool_GetHandle * tail_waiting
DLL tail for the queue of GST_ConnectionPool_GetHandle requests that are waiting for this connection ...
struct GNUNET_CONFIGURATION_Handle * cfg
The configuration of the peer.
unsigned int demand
Number of active requests using this pooled connection.
struct GNUNET_ATS_ConnectivityHandle * handle_ats_connectivity
The ATS handle to the peer correspondign to this entry; can be NULL.
struct GNUNET_TRANSPORT_CoreHandle * handle_transport
The transport handle to the peer corresponding to this entry; can be NULL.
int in_pool
Is this entry present in the connection pool.
struct GST_ConnectionPool_GetHandle * head_waiting
DLL head for the queue of GST_ConnectionPool_GetHandle requests that are waiting for this connection ...
struct GNUNET_TESTBED_Operation * op_transport
The operation handle for transport handle.
struct GST_ConnectionPool_GetHandle * tail_notify
DLL tail for the queue to serve notifications when a peer is connected.
struct GNUNET_SCHEDULER_Task * notify_task
The task to notify a waiting GST_ConnectionPool_GetHandle object.
struct GNUNET_CORE_Handle * handle_core
The core handle to the peer corresponding to this entry; can be NULL.
uint32_t index
The index of this peer.
struct GST_ConnectionPool_GetHandle * head_notify
DLL head for the queue to serve notifications when a peer is connected.
struct GNUNET_TESTBED_Operation * op_core
The operation handle for core handle.

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
clsthe PooledConnection object

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

340 {
341  struct PooledConnection *entry = cls;
342 
343  entry->expire_task = NULL;
345 }
static void destroy_pooled_connection(struct PooledConnection *entry)
Destroy a PooledConnection object.

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
entrythe PooledConnection object

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

371 {
372  GNUNET_assert (0 == entry->demand);
373  GNUNET_assert (! entry->in_lru);
375  entry->in_lru = GNUNET_YES;
376  GNUNET_assert (NULL == entry->expire_task);
377  entry->expire_task =
379 }
#define CACHE_EXPIRY
Time to expire a cache entry.
static void expire(void *cls)
Expire a PooledConnection object.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
@ GNUNET_YES
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1241

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
entrythe pooled connection whose active list has to be searched
headthe 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.

396 {
398 
399  for (gh = head; NULL != gh; gh = gh->next)
400  {
401  switch (gh->service)
402  {
404  if (NULL == entry->handle_core)
405  continue;
406  if (NULL == entry->peer_identity)
407  continue; /* CORE connection isn't ready yet */
408  break;
409 
411  if (NULL == entry->handle_transport)
412  continue;
413  break;
414 
416  if (NULL == entry->handle_ats_connectivity)
417  continue;
418  break;
419  }
420  break;
421  }
422  return gh;
423 }
static struct PendingResolutions * head
Head of list of pending resolution requests.
Definition: gnunet-ats.c:230
static struct GNUNET_TRANSPORT_HelloGetHandle * gh
Pending GNUNET_TRANSPORT_hello_get() operation.
@ GST_CONNECTIONPOOL_SERVICE_TRANSPORT
Transport service.
@ GST_CONNECTIONPOOL_SERVICE_CORE
Core service.
@ GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY
ATS service.
The request handle for obtaining a pooled connection.
struct PooledConnection * entry
The pooled connection object this handle corresponds to.
struct GNUNET_PeerIdentity * peer_identity
The peer identity of this peer.

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
clsthe PooledConnection object

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

437 {
438  struct PooledConnection *entry = cls;
440  struct GST_ConnectionPool_GetHandle *gh_next;
441 
442  GNUNET_assert (NULL != entry->notify_task);
443  entry->notify_task = NULL;
445  GNUNET_assert (NULL != gh);
446  gh_next = NULL;
447  if (NULL != gh->next)
448  gh_next = search_waiting (entry, gh->next);
451  gh);
452  gh->connection_ready_called = 1;
453  if (NULL != gh_next)
455  entry);
456  if ((NULL != gh->target) && (NULL != gh->connect_notify_cb))
457  {
460  gh);
461  gh->notify_waiting = 1;
462  }
463  LOG_DEBUG ("Connection ready to %u for handle type %u\n",
464  (unsigned int) entry->index,
465  gh->service);
466  gh->cb (gh->cb_cls,
471  entry->cfg);
472 }
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 entr...
static void connection_ready(void *cls)
A handle in the PooledConnection object pointed by cls is ready and there is a GST_ConnectionPool_Get...
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1268

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
clsthe PooledConnection object
peerthe peer that connected
servicethe service where this notification has originated

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

488 {
489  struct PooledConnection *entry = cls;
491  struct GST_ConnectionPool_GetHandle *gh_next;
493  void *cb_cls;
494 
495  for (gh = entry->head_notify; NULL != gh;)
496  {
497  GNUNET_assert (NULL != gh->target);
498  GNUNET_assert (NULL != gh->connect_notify_cb);
499  GNUNET_assert (gh->connection_ready_called);
500  if (service != gh->service)
501  {
502  gh = gh->next;
503  continue;
504  }
505  if (0 != memcmp (gh->target, peer, sizeof(struct GNUNET_PeerIdentity)))
506  {
507  gh = gh->next;
508  continue;
509  }
510  cb = gh->connect_notify_cb;
511  cb_cls = gh->connect_notify_cb_cls;
512  gh_next = gh->next;
514  gh->notify_waiting = 0;
515  LOG_DEBUG ("Peer connected to peer %u at service %u\n",
516  entry->index,
517  gh->service);
518  gh = gh_next;
519  cb (cb_cls, peer);
520  }
521 }
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
void(* GST_connection_pool_peer_connect_notify)(void *cls, const struct GNUNET_PeerIdentity *target)
Callback to notify when the target peer given to GST_connection_pool_get_handle() is connected.
The identity of the host (wraps the signing key of the peer).
void * cb_cls
The closure for the above callback.
GST_connection_pool_connection_ready_cb cb
The cache callback to call when a handle is available.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.

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
clsthe PooledConnection object
peerthe peer that connected
mqqueue for sending data to peer
Returns
NULL

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

537 {
538  struct PooledConnection *entry = cls;
539 
541  return NULL;
542 }
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.

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
clsthe PooledConnection object

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

553 {
554  struct PooledConnection *entry = cls;
555 
556  GNUNET_assert (NULL != entry);
557  LOG_DEBUG ("Opening a transport connection to peer %u\n", entry->index);
558  entry->handle_transport =
560  NULL,
561  NULL,
562  entry,
564  NULL,
565  NULL);
566  if (NULL == entry->handle_transport)
567  {
568  GNUNET_break (0);
569  return;
570  }
571  if (0 == entry->demand)
572  return;
573  if (NULL != entry->notify_task)
574  return;
575  if (NULL != search_waiting (entry, entry->head_waiting))
576  {
578  return;
579  }
580 }
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.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
struct GNUNET_TRANSPORT_CoreHandle * GNUNET_TRANSPORT_core_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_PeerIdentity *self, const struct GNUNET_MQ_MessageHandler *handlers, void *cls, GNUNET_TRANSPORT_NotifyConnect nc, GNUNET_TRANSPORT_NotifyDisconnect nd)
Connect to the transport service.

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
clsthe cache entry

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

591 {
592  struct PooledConnection *entry = cls;
593 
594  if (NULL == entry->handle_transport)
595  return;
597  entry->handle_transport = NULL;
598 }
void GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
Disconnect from the transport service.

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
clsthe PooledConnection object
peerpeer identity this notification is about
mqmessage queue for talking to peer
Returns
peer

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

613 {
614  struct PooledConnection *entry = cls;
615 
617  return (void *) peer;
618 }

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
clsthe PooledConnection object
my_identityID of this peer, NULL if we failed

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

636 {
637  struct PooledConnection *entry = cls;
638 
639  if (NULL == my_identity)
640  {
641  GNUNET_break (0);
642  return;
643  }
644  GNUNET_assert (NULL == entry->peer_identity);
645  entry->peer_identity = GNUNET_new (struct GNUNET_PeerIdentity);
646  *entry->peer_identity = *my_identity;
648  "Established CORE connection for peer %s (%u)\n",
650  (unsigned int) entry->index);
651  if (0 == entry->demand)
652  return;
653  if (NULL != entry->notify_task)
654  return;
655  if (NULL != search_waiting (entry, entry->head_waiting))
656  {
658  return;
659  }
660 }
static struct GNUNET_PeerIdentity my_identity
Identity of this peer.
#define GNUNET_log(kind,...)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.

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
clsthe PooledConnection object

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

671 {
672  struct PooledConnection *entry = cls;
673 
674  GNUNET_assert (NULL != entry);
675  LOG_DEBUG ("Opening a CORE connection to peer %u\n", entry->index);
676  entry->handle_core =
677  GNUNET_CORE_connect (entry->cfg,
678  entry, /* closure */
679  &core_startup_cb, /* core startup notify */
680  &core_peer_connect_cb, /* peer connect notify */
681  NULL, /* peer disconnect notify */
682  NULL);
683 }
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).
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.
struct GNUNET_CORE_Handle * GNUNET_CORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls, GNUNET_CORE_StartupCallback init, GNUNET_CORE_ConnectEventHandler connects, GNUNET_CORE_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Connect to the core service.
Definition: core_api.c:691

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
clsthe PooledConnection object

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

694 {
695  struct PooledConnection *entry = cls;
696 
697  if (NULL == entry->handle_core)
698  return;
700  entry->handle_core = NULL;
701  GNUNET_free (entry->peer_identity);
702  entry->peer_identity = NULL;
703 }
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
Definition: core_api.c:729

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
clsthe PooledConnection object

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

714 {
715  struct PooledConnection *entry = cls;
716 
718 }
struct GNUNET_ATS_ConnectivityHandle * GNUNET_ATS_connectivity_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the ATS connectivity suggestion client handle.

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
clsthe PooledConnection object

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

729 {
730  struct PooledConnection *entry = cls;
731 
732  if (NULL == entry->handle_ats_connectivity)
733  return;
735  entry->handle_ats_connectivity = NULL;
736 }
void GNUNET_ATS_connectivity_done(struct GNUNET_ATS_ConnectivityHandle *ch)
Client is done with ATS connectivity management, release resources.

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
clsNULL
keycurrent key code
valuethe 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.

751 {
752  struct PooledConnection *entry = value;
753 
754  GNUNET_assert (NULL != entry);
756  return GNUNET_YES;
757 }
static char * value
Value of the record to add/remove.

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
sizethe 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.

769 {
770  max_size = size;
771  if (0 == max_size)
772  return;
773  GNUNET_assert (NULL == map);
774  map = GNUNET_CONTAINER_multihashmap32_create (((size * 3) / 4) + 1);
775 }
static unsigned int max_size
The maximum number of entries that can be present in the connection pool.
struct GNUNET_CONTAINER_MultiHashMap32 * GNUNET_CONTAINER_multihashmap32_create(unsigned int len)
Create a 32-bit key multi hash map.
static unsigned int size
Size of the "table".
Definition: peer.c:68

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.

783 {
784  struct PooledConnection *entry;
785 
786  if (NULL != map)
787  {
788  GNUNET_assert (
789  GNUNET_SYSERR !=
792  map = NULL;
793  }
794  while (NULL != (entry = head_lru))
795  {
798  }
799  GNUNET_assert (NULL == head_not_pooled);
800 }
static int cleanup_iterator(void *cls, uint32_t key, void *value)
This function will be called for every PooledConnection object in map.
static struct PooledConnection * head_not_pooled
DLL head for maintaining PooledConnection objects that are not added into the connection pool as it w...
void GNUNET_CONTAINER_multihashmap32_destroy(struct GNUNET_CONTAINER_MultiHashMap32 *map)
Destroy a 32-bit key hash map.
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MultiHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
@ GNUNET_SYSERR

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_idthe index of the peer
cfgthe configuration with which the transport handle has to be created if it was not present in the cache
servicethe service of interest
cbthe callback to notify when the transport handle is available
cb_clsthe closure for cb
targetthe peer identify of the peer whose connection to our TRANSPORT subsystem will be notified through the connect_notify_cb. Can be NULL
connect_notify_cbthe 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_clsthe 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.

845 {
847  struct PooledConnection *entry;
849  void *handle;
850  uint32_t peer_id32;
851 
852  peer_id32 = (uint32_t) peer_id;
853  handle = NULL;
854  entry = NULL;
855  if (NULL != map)
856  entry = GNUNET_CONTAINER_multihashmap32_get (map, peer_id32);
857  if (NULL != entry)
858  {
859  if (entry->in_lru)
860  {
861  GNUNET_assert (0 == entry->demand);
862  expire_task_cancel (entry);
864  entry->in_lru = GNUNET_NO;
865  }
866  switch (service)
867  {
869  handle = entry->handle_transport;
870  if (NULL != handle)
871  LOG_DEBUG ("Found TRANSPORT handle for peer %u\n",
872  entry->index);
873  break;
875  handle = entry->handle_core;
876  if (NULL != handle)
877  LOG_DEBUG ("Found CORE handle for peer %u\n",
878  entry->index);
879  break;
882  if (NULL != handle)
883  LOG_DEBUG ("Found ATS CONNECTIVITY handle for peer %u\n",
884  entry->index);
885  break;
886  }
887  }
888  else
889  {
890  entry = GNUNET_new (struct PooledConnection);
891  entry->index = peer_id32;
892  if ((NULL != map) &&
894  {
897  map,
898  entry->index,
899  entry,
901  entry->in_pool = GNUNET_YES;
902  }
903  else
904  {
907  entry);
908  }
909  entry->cfg = GNUNET_CONFIGURATION_dup (cfg);
910  }
911  entry->demand++;
913  gh->entry = entry;
914  gh->cb = cb;
915  gh->cb_cls = cb_cls;
916  gh->target = target;
917  gh->connect_notify_cb = connect_notify_cb;
918  gh->connect_notify_cb_cls = connect_notify_cb_cls;
919  gh->service = service;
921  entry->tail_waiting,
922  gh);
923  if (NULL != handle)
924  {
925  if (NULL == entry->notify_task)
926  {
927  if (NULL != search_waiting (entry, entry->head_waiting))
928  entry->notify_task =
930  }
931  return gh;
932  }
933  op = NULL;
934  switch (gh->service)
935  {
937  if (NULL != entry->op_transport)
938  return gh; /* Operation pending */
942  entry->op_transport = op;
943  break;
944 
946  if (NULL != entry->op_core)
947  return gh; /* Operation pending */
951  entry->op_core = op;
952  break;
953 
955  if (NULL != entry->op_ats_connectivity)
956  return gh; /* Operation pending */
957  op =
961  entry->op_ats_connectivity = op;
962  break;
963  }
966  return gh;
967 }
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
struct OperationQueue * GST_opq_openfds
Operation queue for open file descriptors.
static void oprelease_get_handle_ats_connectivity(void *cls)
Function called when the operation responsible for opening a ATS connection is marked as done.
static void opstart_get_handle_ats_connectivity(void *cls)
Function called when resources for opening a connection to ATS are available.
static struct PooledConnection * tail_not_pooled
DLL tail for maintaining PooledConnection objects that are not added into the connection pool as it w...
static void oprelease_get_handle_core(void *cls)
Function called when the operation responsible for opening a CORE connection is marked as done.
static void opstart_get_handle_transport(void *cls)
Function called when resources for opening a connection to TRANSPORT are available.
static void opstart_get_handle_core(void *cls)
Function called when resources for opening a connection to CORE are available.
static void oprelease_get_handle_transport(void *cls)
Function called when the operation responsible for opening a TRANSPORT connection is marked as done.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap32_put(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
unsigned int GNUNET_CONTAINER_multihashmap32_size(const struct GNUNET_CONTAINER_MultiHashMap32 *map)
Get the number of key-value pairs in the map.
void * GNUNET_CONTAINER_multihashmap32_get(const struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key)
Given a key find a value in the map matching the key.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
@ GNUNET_NO
Opaque handle to an abstract operation to be executed by the testing framework.
void * cb_cls
Closure for callbacks.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_operation_create_(void *cls, OperationStart start, OperationRelease release)
Create an 'operation' to be performed.
void GNUNET_TESTBED_operation_queue_insert_(struct OperationQueue *queue, struct GNUNET_TESTBED_Operation *op)
Add an operation to a queue.
void GNUNET_TESTBED_operation_begin_wait_(struct GNUNET_TESTBED_Operation *op)
Marks the given operation as waiting on the queues.

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
ghthe handle

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

984 {
985  struct PooledConnection *entry;
986 
987  if (NULL == gh)
988  return;
989  entry = gh->entry;
990  LOG_DEBUG ("Cleaning up get handle %p for service %u, peer %u\n",
991  gh,
992  gh->service,
993  entry->index);
994  if (! gh->connection_ready_called)
995  {
997  if ((NULL == search_waiting (entry, entry->head_waiting)) &&
998  (NULL != entry->notify_task))
999  {
1001  entry->notify_task = NULL;
1002  }
1003  }
1004  if (gh->notify_waiting)
1005  {
1007  gh->notify_waiting = 0;
1008  }
1009  GNUNET_free (gh);
1010  gh = NULL;
1011  GNUNET_assert (! entry->in_lru);
1012  if (! entry->in_pool)
1014  if (NULL != map)
1015  {
1016  if (GNUNET_YES ==
1018  goto unallocate;
1020  {
1021  if (NULL == head_lru)
1022  goto unallocate;
1024  }
1027  map,
1028  entry->index,
1029  entry,
1031  entry->in_pool = GNUNET_YES;
1032  }
1033 
1034 unallocate:
1035  GNUNET_assert (0 < entry->demand);
1036  entry->demand--;
1037  if (0 != entry->demand)
1038  return;
1039  if (entry->in_pool)
1040  {
1041  add_to_lru (entry);
1042  return;
1043  }
1044  destroy_pooled_connection (entry);
1045 }
static void add_to_lru(struct PooledConnection *entry)
Function to add a PooledConnection object into LRU and begin the expiry task.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap32_contains(const struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key)
Check if the map contains any value under the given key (including values that are NULL).
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...

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

◆ 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().