39 #define LOG(kind, ...) \
40 GNUNET_log_from (kind, "testbed-connectionpool", __VA_ARGS__)
46 #define CACHE_EXPIRY \
47 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
305 LOG_DEBUG (
"Cleaning up handles of a pooled connection\n");
447 if (NULL !=
gh->next)
452 gh->connection_ready_called = 1;
456 if ((NULL !=
gh->target) && (NULL !=
gh->connect_notify_cb))
461 gh->notify_waiting = 1;
463 LOG_DEBUG (
"Connection ready to %u for handle type %u\n",
510 cb =
gh->connect_notify_cb;
514 gh->notify_waiting = 0;
515 LOG_DEBUG (
"Peer connected to peer %u at service %u\n",
557 LOG_DEBUG (
"Opening a transport connection to peer %u\n", entry->
index);
617 return (
void *)
peer;
648 "Established CORE connection for peer %s (%u)\n",
650 (
unsigned int) entry->
index);
675 LOG_DEBUG (
"Opening a CORE connection to peer %u\n", entry->
index);
852 peer_id32 = (uint32_t)
peer_id;
871 LOG_DEBUG (
"Found TRANSPORT handle for peer %u\n",
877 LOG_DEBUG (
"Found CORE handle for peer %u\n",
883 LOG_DEBUG (
"Found ATS CONNECTIVITY handle for peer %u\n",
891 entry->
index = peer_id32;
917 gh->connect_notify_cb = connect_notify_cb;
918 gh->connect_notify_cb_cls = connect_notify_cb_cls;
990 LOG_DEBUG (
"Cleaning up get handle %p for service %u, peer %u\n",
994 if (!
gh->connection_ready_called)
1004 if (
gh->notify_waiting)
1007 gh->notify_waiting = 0;
struct GNUNET_MQ_Handle * mq
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
static struct GNUNET_ARM_Operation * op
Current operation.
static struct PendingResolutions * head
Head of list of pending resolution requests.
static char * peer_id
Option –peer.
struct GNUNET_PeerIdentity my_identity
Our peer identity.
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static char * value
Value of the record to add/remove.
#define LOG_DEBUG(...)
Debug logging shorthand.
static struct GNUNET_TRANSPORT_HelloGetHandle * gh
Pending GNUNET_TRANSPORT_hello_get() operation.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
struct OperationQueue * GST_opq_openfds
Operation queue for open file descriptors.
data structures shared amongst components of TESTBED service
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.
static struct GNUNET_CONTAINER_MultiHashMap32 * map
A hashmap for quickly finding connections in the connection pool.
static void destroy_pooled_connection(struct PooledConnection *entry)
Destroy a PooledConnection object.
static void add_to_lru(struct PooledConnection *entry)
Function to add a PooledConnection object into LRU and begin the expiry task.
static unsigned int max_size
The maximum number of entries that can be present in the connection pool.
#define CACHE_EXPIRY
Time to expire a cache entry.
static struct PooledConnection * tail_lru
DLL tail for maitaining the least recently used PooledConnection objects.
void GST_connection_pool_destroy()
Cleanup the connection pool.
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 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 int cleanup_iterator(void *cls, uint32_t key, void *value)
This function will be called for every PooledConnection object in map.
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).
void GST_connection_pool_get_handle_done(struct GST_ConnectionPool_GetHandle *gh)
Relinquish a GST_ConnectionPool_GetHandle object.
static struct PooledConnection * head_not_pooled
DLL head for maintaining PooledConnection objects that are not added into the connection pool as it w...
static void connection_ready(void *cls)
A handle in the PooledConnection object pointed by cls is ready and there is a GST_ConnectionPool_Get...
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.
static struct PooledConnection * tail_not_pooled
DLL tail for maintaining PooledConnection objects that are not added into the connection pool as it w...
static struct PooledConnection * head_lru
DLL head for maitaining the least recently used PooledConnection objects.
static void expire(void *cls)
Expire a PooledConnection object.
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 * 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.
static void expire_task_cancel(struct PooledConnection *entry)
Cancel the expiration task of the give PooledConnection object.
static void opstart_get_handle_core(void *cls)
Function called when resources for opening a connection to CORE are available.
void GST_connection_pool_init(unsigned int size)
Initialise the connection pool.
static void oprelease_get_handle_transport(void *cls)
Function called when the operation responsible for opening a TRANSPORT connection is marked as done.
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.
Interface for connection pooling subroutines.
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.
GST_ConnectionPool_Service
The type of service.
@ GST_CONNECTIONPOOL_SERVICE_TRANSPORT
Transport service.
@ GST_CONNECTIONPOOL_SERVICE_CORE
Core service.
@ GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY
ATS service.
void(* GST_connection_pool_connection_ready_cb)(void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *peer_id, const struct GNUNET_CONFIGURATION_Handle *cfg)
Functions of this type are called when the needed handle is available for usage.
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.
void GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
Disconnect from the transport service.
struct GNUNET_ATS_ConnectivityHandle * GNUNET_ATS_connectivity_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the ATS connectivity suggestion client handle.
void GNUNET_ATS_connectivity_done(struct GNUNET_ATS_ConnectivityHandle *ch)
Client is done with ATS connectivity management, release resources.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
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.
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
#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.
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).
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.
unsigned int GNUNET_CONTAINER_multihashmap32_size(const struct GNUNET_CONTAINER_MultiHashMap32 *map)
Get the number of key-value pairs in the map.
struct GNUNET_CONTAINER_MultiHashMap32 * GNUNET_CONTAINER_multihashmap32_create(unsigned int len)
Create a 32-bit key multi hash 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.
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_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
@ 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...
#define GNUNET_log(kind,...)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
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.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
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.
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...
static unsigned int size
Size of the "table".
Handle to the ATS subsystem for connectivity management.
Internal representation of the hash map.
Context for the core service connection.
Handle to a message queue.
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Opaque handle to an abstract operation to be executed by the testing framework.
void * cb_cls
Closure for callbacks.
Handle for the transport service (includes all of the state for the transport service).
The request handle for obtaining a pooled connection.
const struct GNUNET_PeerIdentity * target
The peer identity of the target peer.
void * cb_cls
The closure for the above callback.
enum GST_ConnectionPool_Service service
The service we want to connect to.
struct PooledConnection * entry
The pooled connection object this handle corresponds to.
struct GST_ConnectionPool_GetHandle * next
The next ptr for inclusion in the notification DLLs.
int notify_waiting
Are we waiting for any peer connect notifications?
GST_connection_pool_connection_ready_cb cb
The cache callback to call when a handle is available.
struct GST_ConnectionPool_GetHandle * prev
The prev ptr for inclusion in the notification DLLs.
GST_connection_pool_peer_connect_notify connect_notify_cb
The callback to be called for serving notification that the target peer is connected.
void * connect_notify_cb_cls
The closure for the notify callback.
int connection_ready_called
Did we call the pool_connection_ready_cb already?
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 ...
int in_lru
Is this entry in LRU.
struct GNUNET_CONFIGURATION_Handle * cfg
The configuration of the peer.
struct PooledConnection * next
Next ptr for placing this object in the DLL of least recently used pooled connections.
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.
struct PooledConnection * prev
Prev ptr for placing this object in the DLL of the least recently used pooled connections.
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_SCHEDULER_Task * expire_task
The task to expire this connection from the connection pool.
struct GNUNET_PeerIdentity * peer_identity
The peer identity of this peer.
struct GNUNET_TESTBED_Operation * op_core
The operation handle for core handle.
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.
internal API to access the 'operations' subsystem
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.