Data Cache library

Simple, transient hash table of bounded size with content expiration. More...

Collaboration diagram for Data Cache library:

Data Structures
struct	GNUNET_DATACACHE_Block
	Information about a block stored in the datacache. More...

Typedefs
typedef enum GNUNET_GenericReturnValue(*	GNUNET_DATACACHE_Iterator) (void *cls, const struct GNUNET_DATACACHE_Block *block)
	An iterator over a set of items stored in the datacache. More...

Functions
struct GNUNET_DATACACHE_Handle *	GNUNET_DATACACHE_create (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section)
	Create a data cache. More...
void	GNUNET_DATACACHE_destroy (struct GNUNET_DATACACHE_Handle *h)
	Destroy a data cache (and free associated resources). More...
enum GNUNET_GenericReturnValue	GNUNET_DATACACHE_put (struct GNUNET_DATACACHE_Handle *h, uint32_t xor_distance, const struct GNUNET_DATACACHE_Block *block)
	Store an item in the datacache. More...
unsigned int	GNUNET_DATACACHE_get (struct GNUNET_DATACACHE_Handle *h, const struct GNUNET_HashCode *key, enum GNUNET_BLOCK_Type type, GNUNET_DATACACHE_Iterator iter, void *iter_cls)
	Iterate over the results for a particular key in the datacache. More...
unsigned int	GNUNET_DATACACHE_get_closest (struct GNUNET_DATACACHE_Handle *h, const struct GNUNET_HashCode *key, enum GNUNET_BLOCK_Type type, unsigned int num_results, GNUNET_DATACACHE_Iterator iter, void *iter_cls)
	Iterate over the results that are "close" to a particular key in the datacache. More...

Detailed Description

Simple, transient hash table of bounded size with content expiration.

In contrast to the sqstore there is no prioritization, deletion or iteration. All of the data is discarded when the peer shuts down!

Typedef Documentation

GNUNET_DATACACHE_Iterator

typedef enum GNUNET_GenericReturnValue(* GNUNET_DATACACHE_Iterator) (void *cls, const struct GNUNET_DATACACHE_Block *block)

An iterator over a set of items stored in the datacache.

Parameters

cls	closure
block	a block from the datacache

Returns

GNUNET_OK to continue iterating, GNUNET_SYSERR to abort

Definition at line 133 of file gnunet_datacache_lib.h.

Function Documentation

GNUNET_DATACACHE_create()

struct GNUNET_DATACACHE_Handle* GNUNET_DATACACHE_create	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section
	)

Create a data cache.

Parameters

cfg	configuration to use
section	section in the configuration that contains our options

Returns

handle to use to access the service

Definition at line 128 of file datacache.c.

{
  unsigned int bf_size;
  unsigned long long quota;
  struct GNUNET_DATACACHE_Handle *ret;
  char *libname;
  char *name;
  const struct GNUNET_OS_ProjectData *pd;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_size (cfg,
                                           section,
                                           "QUOTA",
                                           &quota))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               section,
                               "QUOTA");
    return NULL;
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             section,
                                             "DATABASE",
                                             &name))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               section,
                               "DATABASE");
    return NULL;
  }
  bf_size = quota / 32; /* 8 bit per entry, 1 bit per 32 kb in DB */
 
  ret = GNUNET_new (struct GNUNET_DATACACHE_Handle);
 
  if (GNUNET_YES !=
      GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                            section,
                                            "DISABLE_BF"))
  {
    if (GNUNET_YES !=
        GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                              section,
                                              "DISABLE_BF_RC"))
    {
      ret->bloom_name = GNUNET_DISK_mktemp ("gnunet-datacachebloom");
    }
    if (NULL != ret->bloom_name)
    {
      ret->filter = GNUNET_CONTAINER_bloomfilter_load (
        ret->bloom_name,
        quota / 1024,     /* 8 bit per entry in DB, expect 1k entries */
        5);
    }
    if (NULL == ret->filter)
    {
      ret->filter =
        GNUNET_CONTAINER_bloomfilter_init (NULL,
                                           bf_size,
                                           5);    /* approx. 3% false positives at max use */
    }
  }
  ret->stats = GNUNET_STATISTICS_create ("datacache",
                                         cfg);
  ret->section = GNUNET_strdup (section);
  ret->env.cfg = cfg;
  ret->env.delete_notify = &env_delete_notify;
  ret->env.section = ret->section;
  ret->env.cls = ret;
  ret->env.delete_notify = &env_delete_notify;
  ret->env.quota = quota;
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Loading `%s' datacache plugin\n",
       name);
  GNUNET_asprintf (&libname,
                   "libgnunet_plugin_datacache_%s",
                   name);
  ret->short_name = name;
  ret->lib_name = libname;
  /* Load the plugin within GNUnet's default context */
  pd = GNUNET_OS_project_data_get ();
  GNUNET_OS_init (GNUNET_OS_project_data_default ());
  ret->api = GNUNET_PLUGIN_load (libname,
                                 &ret->env);
  GNUNET_OS_init (pd);
  if (NULL == ret->api)
  {
    /* Try to load the plugin within the application's context
       This normally happens when the application is not GNUnet itself but a
       third party; inside GNUnet this is effectively a double failure. */
    ret->api = GNUNET_PLUGIN_load (libname,
                                   &ret->env);
    if (NULL == ret->api)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Failed to load datacache plugin for `%s'\n",
           name);
      GNUNET_DATACACHE_destroy (ret);
      return NULL;
    }
  }
  return ret;
}

References cfg, env_delete_notify(), GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_size(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONTAINER_bloomfilter_init(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_DATACACHE_destroy(), GNUNET_DISK_mktemp(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log_config_missing(), GNUNET_new, GNUNET_OK, GNUNET_OS_init(), GNUNET_OS_project_data_default(), GNUNET_OS_project_data_get(), GNUNET_PLUGIN_load(), GNUNET_STATISTICS_create(), GNUNET_strdup, GNUNET_YES, GNUNET_OS_ProjectData::libname, LOG, name, quota, and ret.

Referenced by GDS_DATACACHE_init().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DATACACHE_destroy()

void GNUNET_DATACACHE_destroy

(

struct GNUNET_DATACACHE_Handle *

h

)

Destroy a data cache (and free associated resources).

Parameters

h	handle to the datastore

Definition at line 235 of file datacache.c.

{
  if (NULL != h->filter)
    GNUNET_CONTAINER_bloomfilter_free (h->filter);
  if (NULL != h->api)
    GNUNET_break (NULL ==
                  GNUNET_PLUGIN_unload (h->lib_name,
                                        h->api));
  GNUNET_free (h->lib_name);
  GNUNET_free (h->short_name);
  GNUNET_free (h->section);
  if (NULL != h->bloom_name)
  {
    if (0 != unlink (h->bloom_name))
      GNUNET_log_from_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                                     "datacache",
                                     "unlink",
                                     h->bloom_name);
    GNUNET_free (h->bloom_name);
  }
  GNUNET_STATISTICS_destroy (h->stats, GNUNET_NO);
  GNUNET_free (h);
}

References GNUNET_break, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_from_strerror_file, GNUNET_NO, GNUNET_PLUGIN_unload(), GNUNET_STATISTICS_destroy(), and h.

Referenced by GDS_DATACACHE_done(), and GNUNET_DATACACHE_create().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DATACACHE_put()

enum GNUNET_GenericReturnValue GNUNET_DATACACHE_put	(	struct GNUNET_DATACACHE_Handle *	h,
		uint32_t	xor_distance,
		const struct GNUNET_DATACACHE_Block *	block
	)

Store an item in the datacache.

Parameters

h	handle to the datacache
xor_distance	how close is the block's key to our pid?
block	actual block data to store

Returns

GNUNET_OK on success, GNUNET_SYSERR on error, GNUNET_NO if duplicate

Definition at line 235 of file datacache.c.

{
  ssize_t used;
 
  used = h->api->put (h->api->cls,
                      xor_distance,
                      block);
  if (-1 == used)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (0 == used)
  {
    /* duplicate */
    return GNUNET_NO;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Stored data under key `%s' in cache\n",
       GNUNET_h2s (&block->key));
  if (NULL != h->filter)
    GNUNET_CONTAINER_bloomfilter_add (h->filter,
                                      &block->key);
  GNUNET_STATISTICS_update (h->stats,
                            "# bytes stored",
                            used,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (h->stats,
                            "# items stored",
                            1,
                            GNUNET_NO);
  while (h->utilization + used > h->env.quota)
    GNUNET_assert (GNUNET_OK ==
                   h->api->del (h->api->cls));
  h->utilization += used;
  return GNUNET_OK;
}

Referenced by datacache_get_iterator().

Here is the caller graph for this function:

GNUNET_DATACACHE_get()

unsigned int GNUNET_DATACACHE_get	(	struct GNUNET_DATACACHE_Handle *	h,
		const struct GNUNET_HashCode *	key,
		enum GNUNET_BLOCK_Type	type,
		GNUNET_DATACACHE_Iterator	iter,
		void *	iter_cls
	)

Iterate over the results for a particular key in the datacache.

Parameters

h	handle to the datacache
key	what to look up
type	entries of which type are relevant?
iter	maybe NULL (to just count)
iter_cls	closure for iter

Returns

the number of results found

Definition at line 303 of file datacache.c.

{
  GNUNET_STATISTICS_update (h->stats,
                            "# requests received",
                            1,
                            GNUNET_NO);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Processing request for key `%s'\n",
       GNUNET_h2s (key));
  if ( (NULL != h->filter) &&
       (GNUNET_OK !=
        GNUNET_CONTAINER_bloomfilter_test (h->filter,
                                           key)) )
  {
    GNUNET_STATISTICS_update (h->stats,
                              "# requests filtered by bloom filter",
                              1,
                              GNUNET_NO);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Bloomfilter filters request for key `%s'\n",
         GNUNET_h2s (key));
    return 0;   /* can not be present */
  }
  return h->api->get (h->api->cls,
                      key,
                      type,
                      iter, iter_cls);
}

References GNUNET_CONTAINER_bloomfilter_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), h, key, LOG, and type.

Here is the call graph for this function:

GNUNET_DATACACHE_get_closest()

unsigned int GNUNET_DATACACHE_get_closest	(	struct GNUNET_DATACACHE_Handle *	h,
		const struct GNUNET_HashCode *	key,
		enum GNUNET_BLOCK_Type	type,
		unsigned int	num_results,
		GNUNET_DATACACHE_Iterator	iter,
		void *	iter_cls
	)

Iterate over the results that are "close" to a particular key in the datacache.

"close" is defined as numerically larger than key (when interpreted as a circular address space), with small distance.

Parameters

h	handle to the datacache
key	area of the keyspace to look into
type	entries of which type are relevant?
num_results	number of results that should be returned to iter
iter	maybe NULL (to just count)
iter_cls	closure for iter

Returns

the number of results found

Definition at line 338 of file datacache.c.

{
  GNUNET_STATISTICS_update (h->stats,
                            "# proximity search requests received",
                            1,
                            GNUNET_NO);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Processing proximity search at `%s'\n",
       GNUNET_h2s (key));
  return h->api->get_closest (h->api->cls,
                              key,
                              type,
                              num_results,
                              iter,
                              iter_cls);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_NO, GNUNET_STATISTICS_update(), h, key, LOG, and type.

Here is the call graph for this function: