GNUnet  0.19.3
gnunet-service-zonemaster.c File Reference

publish records from namestore to GNUnet name system More...

#include "platform.h"
#include <pthread.h>
#include "gnunet_util_lib.h"
#include "gnunet_dht_service.h"
#include "gnunet_namestore_service.h"
#include "gnunet_namecache_service.h"
#include "gnunet_statistics_service.h"
Include dependency graph for gnunet-service-zonemaster.c:

Go to the source code of this file.

Data Structures

struct  RecordPublicationJob
 
struct  CacheOperation
 Pending operation on the namecache. More...
 

Macros

#define LOG_STRERROR_FILE(kind, syscall, filename)
 
#define PUBLISH_OPS_PER_EXPIRATION   4
 How often should we (re)publish each record before it expires? More...
 
#define DELTA_INTERVAL   100
 How often do we measure the delta between desired zone iteration speed and actual speed, and tell statistics service about it? More...
 
#define NS_BLOCK_SIZE   1000
 How many records do we fetch in one shot from the namestore? More...
 
#define JOB_QUEUE_LIMIT   5000
 How many open jobs (and with it maximum amount of pending DHT operations) do we allow at most. More...
 
#define NAMESTORE_MONITOR_QUEUE_LIMIT   5
 How many events may the namestore give us before it has to wait for us to keep up? More...
 
#define INITIAL_ZONE_ITERATION_INTERVAL   GNUNET_TIME_UNIT_MILLISECONDS
 The initial interval in milliseconds btween puts in a zone iteration. More...
 
#define MAXIMUM_ZONE_ITERATION_INTERVAL
 The upper bound for the zone iteration interval (per record). More...
 
#define LATE_ITERATION_SPEEDUP_FACTOR   2
 The factor the current zone iteration interval is divided by for each additional new record. More...
 
#define DHT_GNS_REPLICATION_LEVEL   5
 What replication level do we use for DHT PUT operations? More...
 

Functions

static void free_job (struct RecordPublicationJob *job)
 
static void shutdown_task (void *cls)
 Task run during shutdown. More...
 
static void finish_cache_operation (void *cls, int32_t success, const char *emsg)
 Cache operation complete, clean up. More...
 
static void refresh_block (const struct GNUNET_GNSRECORD_Block *block)
 Refresh the (encrypted) block in the namecache. More...
 
static void publish_zone_namestore_next (void *cls)
 Method called periodically that triggers iteration over authoritative records. More...
 
static void publish_zone_dht_start (void *cls)
 Periodically iterate over our zone and store everything in dht. More...
 
static void calculate_put_interval ()
 Calculate target_iteration_velocity_per_record. More...
 
static void update_velocity (unsigned int cnt)
 Re-calculate our velocity and the desired velocity. More...
 
static void check_zone_namestore_next ()
 Check if the current zone iteration needs to be continued by calling publish_zone_namestore_next(), and if so with what delay. More...
 
static void dht_put_continuation (void *cls)
 Continuation called from DHT once the PUT operation is done. More...
 
static void dispatch_job (const struct GNUNET_IDENTITY_PrivateKey *key, const char *label, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count, const struct GNUNET_TIME_Absolute expire)
 Store GNS records in the DHT. More...
 
static void notification_pipe_cb (void *cls)
 
static void initiate_put_from_pipe_trigger (void *cls)
 
static void zone_iteration_error (void *cls)
 We encountered an error in our zone iteration. More...
 
static void zone_iteration_finished (void *cls)
 Zone iteration is completed. More...
 
static void handle_record (void *cls, const struct GNUNET_IDENTITY_PrivateKey *key, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute expire)
 Function used to put all records successively into the DHT. More...
 
static void dispatch_job_monitor (const struct GNUNET_IDENTITY_PrivateKey *key, const char *label, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count, struct GNUNET_TIME_Absolute expire)
 Store GNS records in the DHT. More...
 
static void handle_monitor_event (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute expire)
 Process a record that was stored in the namestore (invoked by the monitor). More...
 
static void handle_monitor_error (void *cls)
 The zone monitor encountered an IPC error trying to to get in sync. More...
 
static void * sign_worker (void *cls)
 
static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
 Perform zonemaster duties: watch namestore, publish records. More...
 
 GNUNET_SERVICE_MAIN ("zonemaster", GNUNET_SERVICE_OPTION_NONE, &run, NULL, NULL, NULL, GNUNET_MQ_handler_end())
 Define "main" method using service macro. More...
 

Variables

static pthread_t * worker
 Our workers. More...
 
static pthread_mutex_t sign_jobs_lock
 Lock for the sign jobs queue. More...
 
static pthread_mutex_t sign_results_lock
 Lock for the DHT put jobs queue. More...
 
static pthread_cond_t sign_jobs_cond
 Wait condition on new sign jobs. More...
 
static int in_shutdown = GNUNET_NO
 For threads to know we are shutting down. More...
 
static int monitor_halted = GNUNET_NO
 Monitor halted? More...
 
static struct GNUNET_DISK_PipeHandlenotification_pipe
 Our notification pipe. More...
 
static struct GNUNET_SCHEDULER_Taskpipe_read_task
 Pipe read task. More...
 
static struct RecordPublicationJobsign_jobs_head
 The DLL for workers to retrieve open jobs that require signing of blocks. More...
 
static struct RecordPublicationJobsign_jobs_tail
 See above. More...
 
static struct RecordPublicationJobsign_results_head
 The DLL for workers to place jobs that are signed. More...
 
static struct RecordPublicationJobsign_results_tail
 See above. More...
 
static struct RecordPublicationJobdht_jobs_head
 The DLL for jobs currently in the process of being dispatched into the DHT. More...
 
static struct RecordPublicationJobdht_jobs_tail
 See above. More...
 
static struct GNUNET_STATISTICS_Handlestatistics
 Handle to the statistics service. More...
 
static struct GNUNET_DHT_Handledht_handle
 Our handle to the DHT. More...
 
static struct GNUNET_NAMESTORE_Handlenamestore_handle
 Our handle to the namestore service. More...
 
static struct GNUNET_NAMESTORE_ZoneMonitorzmon
 Handle to monitor namestore changes to instant propagation. More...
 
static struct GNUNET_NAMECACHE_Handlenamecache
 Our handle to the namecache service. More...
 
static int disable_namecache
 Use the namecache? Doing so creates additional cryptographic operations whenever we touch a record. More...
 
static struct GNUNET_NAMESTORE_ZoneIteratornamestore_iter
 Handle to iterate over our authoritative zone in namestore. More...
 
static unsigned int job_queue_length
 Number of entries in the job queue #jobs_head. More...
 
static unsigned long long num_public_records
 Useful for zone update for DHT put. More...
 
static unsigned long long last_num_public_records
 Last seen record count. More...
 
static unsigned long long put_cnt
 Number of successful put operations performed in the current measurement cycle (as measured in check_zone_namestore_next()). More...
 
static struct GNUNET_TIME_Relative target_iteration_velocity_per_record
 What is the frequency at which we currently would like to perform DHT puts (per record)? Calculated in update_velocity() from the zone_publish_time_window() and the total number of record sets we have (so far) observed in the zone. More...
 
static struct GNUNET_TIME_Relative min_relative_record_time
 Minimum relative expiration time of records seem during the current zone iteration. More...
 
static struct GNUNET_TIME_Relative last_min_relative_record_time
 Minimum relative expiration time of records seem during the last zone iteration. More...
 
static struct GNUNET_TIME_Relative zone_publish_time_window_default
 Default time window for zone iteration. More...
 
static struct GNUNET_TIME_Relative zone_publish_time_window
 Time window for zone iteration, adjusted based on relative record expiration times in our zone. More...
 
static struct GNUNET_TIME_Absolute last_put_100
 When did we last start measuring the DELTA_INTERVAL successful DHT puts? Used for velocity calculations. More...
 
static struct GNUNET_TIME_Relative sub_delta
 By how much should we try to increase our per-record iteration speed (over the desired speed calculated directly from the #put_interval)? Basically this value corresponds to the per-record CPU time overhead we have. More...
 
static struct GNUNET_SCHEDULER_Taskzone_publish_task
 zone publish task More...
 
static unsigned int ns_iteration_left
 How many more values are left for the current query before we need to explicitly ask the namestore for more? More...
 
static int first_zone_iteration
 GNUNET_YES if zone has never been published before More...
 
static int cache_keys
 Optimize block insertion by caching map of private keys to public keys in memory? More...
 
static struct CacheOperationcop_head
 Head of cop DLL. More...
 
static struct CacheOperationcop_tail
 Tail of cop DLL. More...
 

Detailed Description

publish records from namestore to GNUnet name system

Author
Christian Grothoff

Definition in file gnunet-service-zonemaster.c.

Macro Definition Documentation

◆ LOG_STRERROR_FILE

#define LOG_STRERROR_FILE (   kind,
  syscall,
  filename 
)
Value:
syscall, \
static char * filename
#define GNUNET_log_from_strerror_file(level, component, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...

Definition at line 34 of file gnunet-service-zonemaster.c.

◆ PUBLISH_OPS_PER_EXPIRATION

#define PUBLISH_OPS_PER_EXPIRATION   4

How often should we (re)publish each record before it expires?

Definition at line 44 of file gnunet-service-zonemaster.c.

◆ DELTA_INTERVAL

#define DELTA_INTERVAL   100

How often do we measure the delta between desired zone iteration speed and actual speed, and tell statistics service about it?

Definition at line 51 of file gnunet-service-zonemaster.c.

◆ NS_BLOCK_SIZE

#define NS_BLOCK_SIZE   1000

How many records do we fetch in one shot from the namestore?

Definition at line 56 of file gnunet-service-zonemaster.c.

◆ JOB_QUEUE_LIMIT

#define JOB_QUEUE_LIMIT   5000

How many open jobs (and with it maximum amount of pending DHT operations) do we allow at most.

Definition at line 61 of file gnunet-service-zonemaster.c.

◆ NAMESTORE_MONITOR_QUEUE_LIMIT

#define NAMESTORE_MONITOR_QUEUE_LIMIT   5

How many events may the namestore give us before it has to wait for us to keep up?

Definition at line 67 of file gnunet-service-zonemaster.c.

◆ INITIAL_ZONE_ITERATION_INTERVAL

#define INITIAL_ZONE_ITERATION_INTERVAL   GNUNET_TIME_UNIT_MILLISECONDS

The initial interval in milliseconds btween puts in a zone iteration.

Definition at line 73 of file gnunet-service-zonemaster.c.

◆ MAXIMUM_ZONE_ITERATION_INTERVAL

#define MAXIMUM_ZONE_ITERATION_INTERVAL
Value:
#define GNUNET_TIME_UNIT_MINUTES
One minute.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:484

The upper bound for the zone iteration interval (per record).

Definition at line 79 of file gnunet-service-zonemaster.c.

◆ LATE_ITERATION_SPEEDUP_FACTOR

#define LATE_ITERATION_SPEEDUP_FACTOR   2

The factor the current zone iteration interval is divided by for each additional new record.

Definition at line 86 of file gnunet-service-zonemaster.c.

◆ DHT_GNS_REPLICATION_LEVEL

#define DHT_GNS_REPLICATION_LEVEL   5

What replication level do we use for DHT PUT operations?

Definition at line 91 of file gnunet-service-zonemaster.c.

Function Documentation

◆ free_job()

static void free_job ( struct RecordPublicationJob job)
static

Definition at line 382 of file gnunet-service-zonemaster.c.

383 {
384  if (job->block != job->block_priv)
385  GNUNET_free (job->block_priv);
386  GNUNET_free (job->block);
387  if (NULL != job->label)
388  GNUNET_free (job->label);
389  GNUNET_free (job);
390 }
static struct GNUNET_SCHEDULER_Task * job
Task for main job.
Definition: gnunet-cadet.c:137
#define GNUNET_free(ptr)
Wrapper around free.

References GNUNET_free, and job.

Referenced by dht_put_continuation(), initiate_put_from_pipe_trigger(), and shutdown_task().

Here is the caller graph for this function:

◆ shutdown_task()

static void shutdown_task ( void *  cls)
static

Task run during shutdown.

Parameters
clsunused
tcunused

Definition at line 399 of file gnunet-service-zonemaster.c.

400 {
401  struct CacheOperation *cop;
402  struct RecordPublicationJob *job;
403 
404  (void) cls;
407  "Shutting down!\n");
408  if (NULL != notification_pipe)
410  if (NULL != pipe_read_task)
412  while (NULL != (cop = cop_head))
413  {
415  "Aborting incomplete namecache operation\n");
418  GNUNET_free (cop);
419  }
420  GNUNET_assert (0 == pthread_mutex_lock (&sign_jobs_lock));
421  while (NULL != (job = sign_jobs_head))
422  {
424  "Removing incomplete jobs\n");
427  free_job (job);
428  }
429  GNUNET_assert (0 == pthread_mutex_unlock (&sign_jobs_lock));
430  GNUNET_assert (0 == pthread_mutex_lock (&sign_results_lock));
431  while (NULL != (job = sign_results_head))
432  {
434  "Removing incomplete jobs\n");
436  free_job (job);
437  }
438  GNUNET_assert (0 == pthread_mutex_unlock (&sign_results_lock));
439  while (NULL != (job = dht_jobs_head))
440  {
442  "Removing incomplete jobs\n");
444  if (NULL != job->ph)
446  free_job (job);
447  }
448  if (NULL != statistics)
449  {
451  GNUNET_NO);
452  statistics = NULL;
453  }
454  if (NULL != zone_publish_task)
455  {
457  zone_publish_task = NULL;
458  }
459  if (NULL != namestore_iter)
460  {
462  namestore_iter = NULL;
463  }
464  if (NULL != zmon)
465  {
467  zmon = NULL;
468  }
469  if (NULL != namestore_handle)
470  {
472  namestore_handle = NULL;
473  }
474  if (NULL != namecache)
475  {
477  namecache = NULL;
478  }
479  if (NULL != dht_handle)
480  {
482  dht_handle = NULL;
483  }
484 }
static pthread_mutex_t sign_results_lock
Lock for the DHT put jobs queue.
static struct CacheOperation * cop_head
Head of cop DLL.
static struct RecordPublicationJob * sign_results_tail
See above.
static struct GNUNET_NAMECACHE_Handle * namecache
Our handle to the namecache service.
static unsigned int job_queue_length
Number of entries in the job queue #jobs_head.
static struct RecordPublicationJob * sign_results_head
The DLL for workers to place jobs that are signed.
static struct RecordPublicationJob * dht_jobs_tail
See above.
static struct CacheOperation * cop_tail
Tail of cop DLL.
static struct GNUNET_NAMESTORE_Handle * namestore_handle
Our handle to the namestore service.
static int in_shutdown
For threads to know we are shutting down.
static struct GNUNET_STATISTICS_Handle * statistics
Handle to the statistics service.
static struct GNUNET_DISK_PipeHandle * notification_pipe
Our notification pipe.
static struct GNUNET_DHT_Handle * dht_handle
Our handle to the DHT.
static struct RecordPublicationJob * dht_jobs_head
The DLL for jobs currently in the process of being dispatched into the DHT.
static struct GNUNET_SCHEDULER_Task * zone_publish_task
zone publish task
static struct GNUNET_SCHEDULER_Task * pipe_read_task
Pipe read task.
static struct GNUNET_NAMESTORE_ZoneIterator * namestore_iter
Handle to iterate over our authoritative zone in namestore.
static void free_job(struct RecordPublicationJob *job)
static struct RecordPublicationJob * sign_jobs_head
The DLL for workers to retrieve open jobs that require signing of blocks.
static struct GNUNET_NAMESTORE_ZoneMonitor * zmon
Handle to monitor namestore changes to instant propagation.
static struct RecordPublicationJob * sign_jobs_tail
See above.
static pthread_mutex_t sign_jobs_lock
Lock for the sign jobs queue.
void GNUNET_DHT_put_cancel(struct GNUNET_DHT_PutHandle *ph)
Cancels a DHT PUT operation.
Definition: dht_api.c:1148
void GNUNET_DHT_disconnect(struct GNUNET_DHT_Handle *handle)
Shutdown connection with the DHT service.
Definition: dht_api.c:1062
enum GNUNET_GenericReturnValue GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p)
Closes an interprocess channel.
Definition: disk.c:1584
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_log(kind,...)
@ GNUNET_YES
@ GNUNET_NO
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_DEBUG
void GNUNET_NAMECACHE_disconnect(struct GNUNET_NAMECACHE_Handle *h)
Disconnect from the namecache service (and free associated resources).
void GNUNET_NAMECACHE_cancel(struct GNUNET_NAMECACHE_QueueEntry *qe)
Cancel a namecache operation.
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
void GNUNET_NAMESTORE_zone_monitor_stop(struct GNUNET_NAMESTORE_ZoneMonitor *zm)
Stop monitoring a zone for changes.
void GNUNET_NAMESTORE_zone_iteration_stop(struct GNUNET_NAMESTORE_ZoneIterator *it)
Stops iteration and releases the namestore handle for further calls.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:944
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
Pending operation on the namecache.
struct GNUNET_NAMECACHE_QueueEntry * qe
Handle to namecache queue.

References cop_head, cop_tail, dht_handle, dht_jobs_head, dht_jobs_tail, free_job(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_DHT_disconnect(), GNUNET_DHT_put_cancel(), GNUNET_DISK_pipe_close(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_NAMECACHE_cancel(), GNUNET_NAMECACHE_disconnect(), GNUNET_NAMESTORE_disconnect(), GNUNET_NAMESTORE_zone_iteration_stop(), GNUNET_NAMESTORE_zone_monitor_stop(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), GNUNET_YES, in_shutdown, job, job_queue_length, namecache, namestore_handle, namestore_iter, notification_pipe, pipe_read_task, CacheOperation::qe, sign_jobs_head, sign_jobs_lock, sign_jobs_tail, sign_results_head, sign_results_lock, sign_results_tail, statistics, zmon, and zone_publish_task.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ finish_cache_operation()

static void finish_cache_operation ( void *  cls,
int32_t  success,
const char *  emsg 
)
static

Cache operation complete, clean up.

Parameters
clsthe struct CacheOperation
successsuccess
emsgerror messages

Definition at line 495 of file gnunet-service-zonemaster.c.

496 {
497  struct CacheOperation *cop = cls;
498 
499  if (NULL != emsg)
501  _ ("Failed to replicate block in namecache: %s\n"),
502  emsg);
503  else
504  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CACHE operation completed\n");
506  GNUNET_free (cop);
507 }
#define _(String)
GNU gettext support macro.
Definition: platform.h:177

References _, cop_head, cop_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, and GNUNET_log.

Referenced by refresh_block().

Here is the caller graph for this function:

◆ refresh_block()

static void refresh_block ( const struct GNUNET_GNSRECORD_Block block)
static

Refresh the (encrypted) block in the namecache.

Parameters
zone_keyprivate key of the zone
namelabel for the records
rd_countnumber of records
rdrecords stored under the given name

Definition at line 519 of file gnunet-service-zonemaster.c.

520 {
521  struct CacheOperation *cop;
522 
524  {
526  "Namecache updates skipped (NC disabled)",
527  1,
528  GNUNET_NO);
529  return;
530  }
531  GNUNET_assert (NULL != block);
532  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Caching block in namecache\n");
534  "Namecache updates pushed",
535  1,
536  GNUNET_NO);
537  cop = GNUNET_new (struct CacheOperation);
540  block,
542  cop);
543 }
static int disable_namecache
Use the namecache? Doing so creates additional cryptographic operations whenever we touch a record.
static void finish_cache_operation(void *cls, int32_t success, const char *emsg)
Cache operation complete, clean up.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_NAMECACHE_QueueEntry * GNUNET_NAMECACHE_block_cache(struct GNUNET_NAMECACHE_Handle *h, const struct GNUNET_GNSRECORD_Block *block, GNUNET_NAMECACHE_ContinuationWithStatus cont, void *cont_cls)
Store an item in the namecache.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.

References cop_head, cop_tail, disable_namecache, finish_cache_operation(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NAMECACHE_block_cache(), GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, namecache, CacheOperation::qe, and statistics.

Referenced by initiate_put_from_pipe_trigger().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ publish_zone_namestore_next()

static void publish_zone_namestore_next ( void *  cls)
static

Method called periodically that triggers iteration over authoritative records.

Parameters
clsNULL

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

553 {
554  (void) cls;
555  zone_publish_task = NULL;
556  GNUNET_assert (NULL != namestore_iter);
560  NS_BLOCK_SIZE);
561 }
static unsigned int ns_iteration_left
How many more values are left for the current query before we need to explicitly ask the namestore fo...
#define NS_BLOCK_SIZE
How many records do we fetch in one shot from the namestore?
void GNUNET_NAMESTORE_zone_iterator_next(struct GNUNET_NAMESTORE_ZoneIterator *it, uint64_t limit)
Calls the record processor specified in GNUNET_NAMESTORE_zone_iteration_start for the next record.

References GNUNET_assert, GNUNET_NAMESTORE_zone_iterator_next(), namestore_iter, NS_BLOCK_SIZE, ns_iteration_left, and zone_publish_task.

Referenced by check_zone_namestore_next().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ publish_zone_dht_start()

static void publish_zone_dht_start ( void *  cls)
static

Periodically iterate over our zone and store everything in dht.

Periodically iterate over all zones and store everything in DHT.

Parameters
clsNULL

Definition at line 1089 of file gnunet-service-zonemaster.c.

1090 {
1091  (void) cls;
1092  zone_publish_task = NULL;
1094  "Full zone iterations launched",
1095  1,
1096  GNUNET_NO);
1098  "Starting DHT zone update!\n");
1099  /* start counting again */
1100  num_public_records = 0;
1101  GNUNET_assert (NULL == namestore_iter);
1102  ns_iteration_left = 1;
1105  NULL, /* All zones */
1107  NULL,
1108  &handle_record,
1109  NULL,
1111  NULL,
1113  GNUNET_assert (NULL != namestore_iter);
1114 }
static void zone_iteration_finished(void *cls)
Zone iteration is completed.
static unsigned long long num_public_records
Useful for zone update for DHT put.
static void handle_record(void *cls, const struct GNUNET_IDENTITY_PrivateKey *key, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute expire)
Function used to put all records successively into the DHT.
static void zone_iteration_error(void *cls)
We encountered an error in our zone iteration.
@ GNUNET_GNSRECORD_FILTER_NONE
No filter flags set.
struct GNUNET_NAMESTORE_ZoneIterator * GNUNET_NAMESTORE_zone_iteration_start2(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *zone, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordSetMonitor proc, void *proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls, enum GNUNET_GNSRECORD_Filter filter)
Starts a new zone iteration (used to periodically PUT all of our records into our DHT).

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_FILTER_NONE, GNUNET_log, GNUNET_NAMESTORE_zone_iteration_start2(), GNUNET_NO, GNUNET_STATISTICS_update(), handle_record(), namestore_handle, namestore_iter, ns_iteration_left, num_public_records, statistics, zone_iteration_error(), zone_iteration_finished(), and zone_publish_task.

Referenced by run(), zone_iteration_error(), and zone_iteration_finished().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ calculate_put_interval()

static void calculate_put_interval ( )
static

Calculate target_iteration_velocity_per_record.

If no records are known (startup) or none present we can safely set the interval to the value for a single record

Definition at line 577 of file gnunet-service-zonemaster.c.

578 {
579  if (0 == num_public_records)
587  "No records in namestore database.\n");
588  }
589  else
590  {
602  }
607  "Minimum relative record expiration (in μs)",
609  GNUNET_NO);
611  "Zone publication time window (in μs)",
613  GNUNET_NO);
615  "Target zone iteration velocity (μs)",
617  GNUNET_NO);
618 }
#define PUBLISH_OPS_PER_EXPIRATION
How often should we (re)publish each record before it expires?
static struct GNUNET_TIME_Relative target_iteration_velocity_per_record
What is the frequency at which we currently would like to perform DHT puts (per record)?...
static unsigned long long last_num_public_records
Last seen record count.
static struct GNUNET_TIME_Relative zone_publish_time_window
Time window for zone iteration, adjusted based on relative record expiration times in our zone.
static struct GNUNET_TIME_Relative min_relative_record_time
Minimum relative expiration time of records seem during the current zone iteration.
static struct GNUNET_TIME_Relative zone_publish_time_window_default
Default time window for zone iteration.
static struct GNUNET_TIME_Relative last_min_relative_record_time
Minimum relative expiration time of records seem during the last zone iteration.
#define MAXIMUM_ZONE_ITERATION_INTERVAL
The upper bound for the zone iteration interval (per record).
@ GNUNET_ERROR_TYPE_BULK
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_min(struct GNUNET_TIME_Relative t1, struct GNUNET_TIME_Relative t2)
Return the minimum of two relative time values.
Definition: time.c:343
struct GNUNET_TIME_Relative GNUNET_TIME_relative_divide(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Divide relative time by a given factor.
Definition: time.c:550
uint64_t rel_value_us
The actual value.

References GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_min(), last_min_relative_record_time, last_num_public_records, MAXIMUM_ZONE_ITERATION_INTERVAL, min_relative_record_time, num_public_records, PUBLISH_OPS_PER_EXPIRATION, GNUNET_TIME_Relative::rel_value_us, statistics, target_iteration_velocity_per_record, zone_publish_time_window, and zone_publish_time_window_default.

Referenced by update_velocity(), and zone_iteration_finished().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ update_velocity()

static void update_velocity ( unsigned int  cnt)
static

Re-calculate our velocity and the desired velocity.

We have succeeded in making DELTA_INTERVAL puts, so now calculate the new desired delay between puts.

Parameters
cnthow many records were processed since the last call?

Definition at line 629 of file gnunet-service-zonemaster.c.

630 {
632  unsigned long long pct = 0;
633 
634  if (0 == cnt)
635  return;
636  /* How fast were we really? */
638  delta.rel_value_us /= cnt;
640 
641  /* calculate expected frequency */
644  {
646  "Last record count was lower than current record count. Reducing interval.\n");
650  }
652  "Desired global zone iteration interval is %s/record!\n",
655  GNUNET_YES));
656 
657  /* Tell statistics actual vs. desired speed */
659  "Current zone iteration velocity (μs/record)",
661  GNUNET_NO);
662  /* update "sub_delta" based on difference, taking
663  previous sub_delta into account! */
665  {
666  /* We were too fast, reduce sub_delta! */
667  struct GNUNET_TIME_Relative corr;
668 
670  delta);
672  {
673  /* Reduce sub_delta by corr */
675  corr);
676  }
677  else
678  {
679  /* We're doing fine with waiting the full time, this
680  should theoretically only happen if we run at
681  infinite speed. */
683  }
684  }
687  {
688  /* We were too slow, increase sub_delta! */
689  struct GNUNET_TIME_Relative corr;
690 
694  corr);
695  if (sub_delta.rel_value_us >
697  {
698  /* CPU overload detected, we cannot go at desired speed,
699  as this would mean using a negative delay. */
700  /* compute how much faster we would want to be for
701  the desired velocity */
703  pct = UINT64_MAX; /* desired speed is infinity ... */
704  else
705  pct = (sub_delta.rel_value_us
709  }
710  }
712  "# dispatched jobs",
714  GNUNET_NO);
716  "% speed increase needed for target velocity",
717  pct,
718  GNUNET_NO);
720  "# records processed in current iteration",
722  GNUNET_NO);
723 }
static struct GNUNET_TIME_Relative sub_delta
By how much should we try to increase our per-record iteration speed (over the desired speed calculat...
static void calculate_put_interval()
Calculate target_iteration_velocity_per_record.
#define LATE_ITERATION_SPEEDUP_FACTOR
The factor the current zone iteration interval is divided by for each additional new record.
static int first_zone_iteration
GNUNET_YES if zone has never been published before
static struct GNUNET_TIME_Absolute last_put_100
When did we last start measuring the DELTA_INTERVAL successful DHT puts? Used for velocity calculatio...
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:436
struct GNUNET_TIME_Relative GNUNET_TIME_relative_subtract(struct GNUNET_TIME_Relative a1, struct GNUNET_TIME_Relative a2)
Subtract relative timestamp from the other.
Definition: time.c:603
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
struct GNUNET_TIME_Relative GNUNET_TIME_relative_add(struct GNUNET_TIME_Relative a1, struct GNUNET_TIME_Relative a2)
Add relative times together.
Definition: time.c:585
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:569
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:36
Time for relative time used by GNUnet, in microseconds.

References calculate_put_interval(), delta, first_zone_iteration, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_add(), GNUNET_TIME_relative_subtract(), GNUNET_TIME_UNIT_ZERO, GNUNET_YES, job_queue_length, last_num_public_records, last_put_100, LATE_ITERATION_SPEEDUP_FACTOR, num_public_records, GNUNET_TIME_Relative::rel_value_us, statistics, sub_delta, and target_iteration_velocity_per_record.

Referenced by check_zone_namestore_next(), and handle_record().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_zone_namestore_next()

static void check_zone_namestore_next ( )
static

Check if the current zone iteration needs to be continued by calling publish_zone_namestore_next(), and if so with what delay.

Definition at line 731 of file gnunet-service-zonemaster.c.

732 {
734 
735  if (0 != ns_iteration_left)
736  return; /* current NAMESTORE iteration not yet done */
738  {
740  "Job queue length exceeded (%u/%u). Pausing namestore iteration.\n",
743  return;
744  }
746  put_cnt = 0;
748  sub_delta);
749  /* We delay *once* per #NS_BLOCK_SIZE, so we need to multiply the
750  per-record delay calculated so far with the #NS_BLOCK_SIZE */
752  "Current artificial NAMESTORE delay (μs/record)",
754  GNUNET_NO);
756  NS_BLOCK_SIZE);
757  /* make sure we do not overshoot because of the #NS_BLOCK_SIZE factor */
759  delay);
760  /* no delays on first iteration */
766  NULL);
767 }
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
static unsigned long long put_cnt
Number of successful put operations performed in the current measurement cycle (as measured in check_...
static void publish_zone_namestore_next(void *cls)
Method called periodically that triggers iteration over authoritative records.
#define JOB_QUEUE_LIMIT
How many open jobs (and with it maximum amount of pending DHT operations) do we allow at most.
static void update_velocity(unsigned int cnt)
Re-calculate our velocity and the desired velocity.
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 delay, first_zone_iteration, GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_set(), GNUNET_TIME_relative_min(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_subtract(), GNUNET_TIME_UNIT_ZERO, GNUNET_YES, job_queue_length, JOB_QUEUE_LIMIT, MAXIMUM_ZONE_ITERATION_INTERVAL, NS_BLOCK_SIZE, ns_iteration_left, publish_zone_namestore_next(), put_cnt, GNUNET_TIME_Relative::rel_value_us, statistics, sub_delta, target_iteration_velocity_per_record, update_velocity(), and zone_publish_task.

Referenced by dht_put_continuation(), and handle_record().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ dht_put_continuation()

static void dht_put_continuation ( void *  cls)
static

Continuation called from DHT once the PUT operation is done.

Definition at line 775 of file gnunet-service-zonemaster.c.

776 {
777  struct RecordPublicationJob *job = cls;
778 
780  "PUT complete; Pending jobs: %u\n", job_queue_length - 1);
781  /* When we just fall under the limit, trigger monitor/iterator again
782  * if halted. We can only safely trigger one, prefer iterator. */
783  if (NULL == zone_publish_task)
786  {
787  if (GNUNET_YES == monitor_halted)
788  {
791  }
792  }
796  job);
797  free_job (job);
798 }
static void check_zone_namestore_next()
Check if the current zone iteration needs to be continued by calling publish_zone_namestore_next(),...
static int monitor_halted
Monitor halted?
void GNUNET_NAMESTORE_zone_monitor_next(struct GNUNET_NAMESTORE_ZoneMonitor *zm, uint64_t limit)
Calls the monitor processor specified in GNUNET_NAMESTORE_zone_monitor_start for the next record(s).

References check_zone_namestore_next(), dht_jobs_head, dht_jobs_tail, free_job(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NAMESTORE_zone_monitor_next(), GNUNET_NO, GNUNET_YES, job, job_queue_length, JOB_QUEUE_LIMIT, monitor_halted, zmon, and zone_publish_task.

Referenced by initiate_put_from_pipe_trigger().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ dispatch_job()

static void dispatch_job ( const struct GNUNET_IDENTITY_PrivateKey key,
const char *  label,
const struct GNUNET_GNSRECORD_Data rd,
unsigned int  rd_count,
const struct GNUNET_TIME_Absolute  expire 
)
static

Store GNS records in the DHT.

Parameters
keykey of the zone
labellabel to store under
rd_publicpublic record data
rd_public_countnumber of records in rd_public
mahandle for the put operation
Returns
DHT PUT handle, NULL on error

Definition at line 812 of file gnunet-service-zonemaster.c.

817 {
818  struct GNUNET_GNSRECORD_Data rd_public[rd_count];
819  struct GNUNET_GNSRECORD_Block *block;
820  struct GNUNET_GNSRECORD_Block *block_priv;
821  struct GNUNET_TIME_Absolute expire_pub;
822  size_t block_size;
823  unsigned int rd_public_count = 0;
824  char *emsg;
825 
826  if (GNUNET_OK !=
828  rd,
829  rd_count,
830  rd_public,
831  &rd_public_count,
832  &expire_pub,
834  &emsg))
835  {
837  "%s\n", emsg);
838  GNUNET_free (emsg);
839  }
840 
842  expire_pub,
843  label,
844  rd_public,
845  rd_public_count,
846  &block));
847  if (NULL == block)
848  {
849  GNUNET_break (0);
850  return; /* whoops */
851  }
852  if (rd_count != rd_public_count)
854  expire,
855  label,
856  rd,
857  rd_count,
858  &
859  block_priv));
860  else
861  block_priv = block;
862  block_size = GNUNET_GNSRECORD_block_get_size (block);
863  GNUNET_assert (0 == pthread_mutex_lock (&sign_jobs_lock));
865  job->block = block;
866  job->block_size = block_size;
867  job->block_priv = block_priv;
868  job->zone = *key;
869  job->label = GNUNET_strdup (label);
870  job->expire_pub = expire_pub;
872  GNUNET_assert (0 == pthread_cond_signal (&sign_jobs_cond));
873  GNUNET_assert (0 == pthread_mutex_unlock (&sign_jobs_lock));
875  "Creating job with %u record(s) for label `%s', expiration `%s'\n",
876  rd_public_count,
877  label,
880  return;
881 }
struct GNUNET_HashCode key
The key used in the DHT.
static char * expire
DID Document expiration Date Attribut String.
Definition: gnunet-did.c:101
static unsigned int rd_count
Number of records for currently parsed set.
static struct GNUNET_GNSRECORD_Data rd[50]
The record data under a single label.
static pthread_cond_t sign_jobs_cond
Wait condition on new sign jobs.
size_t GNUNET_GNSRECORD_block_get_size(const struct GNUNET_GNSRECORD_Block *block)
Returns the length of this block in bytes.
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_block_create_unsigned(const struct GNUNET_IDENTITY_PrivateKey *pkey, struct GNUNET_TIME_Absolute expire, const char *label, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Block **result)
Create name and records but do not sign! Sign later with GNUNET_GNSRECORD_block_sign().
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_normalize_record_set(const char *label, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Data *rd_public, unsigned int *rd_count_public, struct GNUNET_TIME_Absolute *expiry, enum GNUNET_GNSRECORD_Filter filter, char **emsg)
Normalize namestore records: Check for consistency and expirations.
@ GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE
Filter private records.
@ GNUNET_OK
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_ERROR
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:616
Time for absolute times used by GNUnet, in microseconds.
struct GNUNET_GNSRECORD_Block * block
The block to sign.
char * label
The label of the block needed for signing.
size_t block_size
The size of the public block for the DHT put.
struct GNUNET_TIME_Absolute expire_pub
The expiration time of the public block for the DHT put.
struct GNUNET_GNSRECORD_Block * block_priv
The private block to sign, may point to block in case the public and private blocks are the same.

References RecordPublicationJob::block, RecordPublicationJob::block_priv, RecordPublicationJob::block_size, expire, RecordPublicationJob::expire_pub, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GNSRECORD_block_create_unsigned(), GNUNET_GNSRECORD_block_get_size(), GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE, GNUNET_GNSRECORD_normalize_record_set(), GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_strdup, GNUNET_STRINGS_absolute_time_to_string(), job, key, RecordPublicationJob::label, num_public_records, rd, rd_count, sign_jobs_cond, sign_jobs_head, sign_jobs_lock, and sign_jobs_tail.

Referenced by handle_record().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ notification_pipe_cb()

static void notification_pipe_cb ( void *  cls)
static

Definition at line 1300 of file gnunet-service-zonemaster.c.

1301 {
1303  "Received wake up notification through pipe, checking results\n");
1305 }
static void initiate_put_from_pipe_trigger(void *cls)
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 GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_add_now(), and initiate_put_from_pipe_trigger().

Referenced by initiate_put_from_pipe_trigger(), and run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ initiate_put_from_pipe_trigger()

static void initiate_put_from_pipe_trigger ( void *  cls)
static

Definition at line 888 of file gnunet-service-zonemaster.c.

889 {
890  struct GNUNET_HashCode query;
891  struct RecordPublicationJob *job;
892  const struct GNUNET_DISK_FileHandle *np_fh;
893  char buf[100];
894  ssize_t nf_count;
895 
896  pipe_read_task = NULL;
902  np_fh,
904  NULL);
905  /* empty queue */
906  nf_count = GNUNET_DISK_file_read (np_fh, buf, sizeof (buf));
907  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Read %lld notifications from pipe\n",
908  (long long) nf_count);
909  while (true)
910  {
911  GNUNET_assert (0 == pthread_mutex_lock (&sign_results_lock));
912  if (NULL == sign_results_head)
913  {
915  "No more results. Back to sleep.\n");
916  GNUNET_assert (0 == pthread_mutex_unlock (&sign_results_lock));
917  return;
918  }
921  GNUNET_assert (0 == pthread_mutex_unlock (&sign_results_lock));
923  job->label,
924  &query);
926  &query,
930  job->block_size,
931  job->block,
932  job->expire_pub,
934  job);
935  if (NULL == job->ph)
936  {
938  "Could not perform DHT PUT, is the DHT running?\n");
939  free_job (job);
940  return;
941  }
943  "DHT put operations initiated",
944  1,
945  GNUNET_NO);
947  "Storing record(s) for label `%s' in DHT under key %s\n",
948  job->label,
949  GNUNET_h2s (&query));
950  refresh_block (job->block_priv);
952  }
953 }
@ GNUNET_BLOCK_TYPE_GNS_NAMERECORD
Block for storing GNS record data.
static char buf[2048]
static void notification_pipe_cb(void *cls)
static void refresh_block(const struct GNUNET_GNSRECORD_Block *block)
Refresh the (encrypted) block in the namecache.
#define DHT_GNS_REPLICATION_LEVEL
What replication level do we use for DHT PUT operations?
static void dht_put_continuation(void *cls)
Continuation called from DHT once the PUT operation is done.
struct GNUNET_DHT_PutHandle * GNUNET_DHT_put(struct GNUNET_DHT_Handle *handle, const struct GNUNET_HashCode *key, uint32_t desired_replication_level, enum GNUNET_DHT_RouteOption options, enum GNUNET_BLOCK_Type type, size_t size, const void *data, struct GNUNET_TIME_Absolute exp, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
Perform a PUT operation storing data in the DHT.
Definition: dht_api.c:1090
@ GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE
Each peer along the way should process the request (otherwise only peers locally closest to the key w...
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:621
const struct GNUNET_DISK_FileHandle * GNUNET_DISK_pipe_handle(const struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd n)
Get the handle to a particular pipe end.
Definition: disk.c:1615
@ GNUNET_DISK_PIPE_END_READ
The reading-end of a pipe.
void GNUNET_GNSRECORD_query_from_private_key(const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, struct GNUNET_HashCode *query)
Calculate the DHT query for a given label in a given zone.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_file(struct GNUNET_TIME_Relative delay, const struct GNUNET_DISK_FileHandle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1625
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
Handle used to access files (and pipes).
A 512-bit hashcode.

References buf, DHT_GNS_REPLICATION_LEVEL, dht_handle, dht_jobs_head, dht_jobs_tail, dht_put_continuation(), free_job(), GNUNET_assert, GNUNET_BLOCK_TYPE_GNS_NAMERECORD, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_DHT_put(), GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_DISK_file_read(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_pipe_handle(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_GNSRECORD_query_from_private_key(), GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_read_file(), GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_FOREVER_REL, job, notification_pipe, notification_pipe_cb(), pipe_read_task, refresh_block(), sign_results_head, sign_results_lock, sign_results_tail, and statistics.

Referenced by notification_pipe_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ zone_iteration_error()

static void zone_iteration_error ( void *  cls)
static

We encountered an error in our zone iteration.

Parameters
clsNULL

Definition at line 962 of file gnunet-service-zonemaster.c.

963 {
964  (void) cls;
966  "Got disconnected from namestore database, retrying.\n");
967  namestore_iter = NULL;
968  /* We end up here on error/disconnect/shutdown, so potentially
969  while a zone publish task or a DHT put is still running; hence
970  we need to cancel those. */
971  if (NULL != zone_publish_task)
972  {
974  zone_publish_task = NULL;
975  }
977  NULL);
978 }
static void publish_zone_dht_start(void *cls)
Periodically iterate over our zone and store everything in dht.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), namestore_iter, publish_zone_dht_start(), and zone_publish_task.

Referenced by publish_zone_dht_start().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ zone_iteration_finished()

static void zone_iteration_finished ( void *  cls)
static

Zone iteration is completed.

Parameters
clsNULL

Definition at line 987 of file gnunet-service-zonemaster.c.

988 {
989  (void) cls;
990  /* we're done with one iteration, calculate when to do the next one */
991  namestore_iter = NULL;
996  /* reset for next iteration */
1000  "Zone iteration finished. Adjusted zone iteration interval to %s\n",
1003  GNUNET_YES));
1005  "Target zone iteration velocity (μs)",
1007  GNUNET_NO);
1009  "Number of public records in DHT",
1011  GNUNET_NO);
1012  GNUNET_assert (NULL == zone_publish_task);
1013  if (0 == last_num_public_records)
1014  {
1018  NULL);
1019  }
1020  else
1021  {
1023  NULL);
1024  }
1025 }

References calculate_put_interval(), first_zone_iteration, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_set(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, last_min_relative_record_time, last_num_public_records, min_relative_record_time, namestore_iter, num_public_records, publish_zone_dht_start(), GNUNET_TIME_Relative::rel_value_us, statistics, target_iteration_velocity_per_record, and zone_publish_task.

Referenced by publish_zone_dht_start().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_record()

static void handle_record ( void *  cls,
const struct GNUNET_IDENTITY_PrivateKey key,
const char *  label,
unsigned int  rd_count,
const struct GNUNET_GNSRECORD_Data rd,
struct GNUNET_TIME_Absolute  expire 
)
static

Function used to put all records successively into the DHT.

Parameters
clsthe closure (NULL)
keythe private key of the authority (ours)
labelthe name of the records, NULL once the iteration is done
rd_countthe number of records in rd
rdthe record data

Definition at line 1038 of file gnunet-service-zonemaster.c.

1044 {
1045  (void) cls;
1047  if (0 == rd_count)
1048  {
1050  "Record set empty, moving to next record set\n");
1052  return;
1053  }
1054  for (unsigned int i = 0; i < rd_count; i++)
1055  {
1056  if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
1057  {
1058  /* GNUNET_GNSRECORD_block_create will convert to absolute time;
1059  we just need to adjust our iteration frequency */
1061  GNUNET_MIN (rd[i].expiration_time,
1063  }
1064  }
1065 
1066 
1067  /* We got a set of records to publish */
1069  "Starting DHT PUT\n");
1070  put_cnt++;
1071  if (0 == put_cnt % DELTA_INTERVAL)
1073  dispatch_job (key,
1074  label,
1075  rd,
1076  rd_count,
1077  expire);
1078  job_queue_length++;
1080 }
#define DELTA_INTERVAL
How often do we measure the delta between desired zone iteration speed and actual speed,...
static void dispatch_job(const struct GNUNET_IDENTITY_PrivateKey *key, const char *label, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count, const struct GNUNET_TIME_Absolute expire)
Store GNS records in the DHT.
@ GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION
This expiration time of the record is a relative time (not an absolute time).
#define GNUNET_MIN(a, b)

References check_zone_namestore_next(), DELTA_INTERVAL, dispatch_job(), expire, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_log, GNUNET_MIN, job_queue_length, key, min_relative_record_time, ns_iteration_left, put_cnt, rd, rd_count, GNUNET_TIME_Relative::rel_value_us, and update_velocity().

Referenced by publish_zone_dht_start().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ dispatch_job_monitor()

static void dispatch_job_monitor ( const struct GNUNET_IDENTITY_PrivateKey key,
const char *  label,
const struct GNUNET_GNSRECORD_Data rd,
unsigned int  rd_count,
struct GNUNET_TIME_Absolute  expire 
)
static

Store GNS records in the DHT.

Parameters
keykey of the zone
labellabel to store under
rd_publicpublic record data
rd_public_countnumber of records in rd_public

Definition at line 1126 of file gnunet-service-zonemaster.c.

1131 {
1132  struct GNUNET_GNSRECORD_Data rd_public[rd_count];
1133  struct GNUNET_GNSRECORD_Block *block;
1134  struct GNUNET_GNSRECORD_Block *block_priv;
1135  struct GNUNET_TIME_Absolute expire_pub;
1136  size_t block_size;
1137  unsigned int rd_public_count = 0;
1138  char *emsg;
1139 
1140  if (GNUNET_OK !=
1142  rd,
1143  rd_count,
1144  rd_public,
1145  &rd_public_count,
1146  &expire_pub,
1148  &emsg))
1149  {
1151  "%s\n", emsg);
1152  GNUNET_free (emsg);
1153  }
1154 
1156  expire_pub,
1157  label,
1158  rd_public,
1159  rd_public_count,
1160  &block));
1161  if (NULL == block)
1162  {
1163  GNUNET_break (0);
1164  return; /* whoops */
1165  }
1166  if (rd_count != rd_public_count)
1168  expire,
1169  label,
1170  rd,
1171  rd_count,
1172  &
1173  block_priv));
1174  else
1175  block_priv = block;
1176  block_size = GNUNET_GNSRECORD_block_get_size (block);
1177  GNUNET_assert (0 == pthread_mutex_lock (&sign_jobs_lock));
1179  job->block = block;
1180  job->block_size = block_size;
1181  job->block_priv = block_priv;
1182  job->zone = *key;
1183  job->label = GNUNET_strdup (label);
1184  job->expire_pub = expire_pub;
1186  GNUNET_assert (0 == pthread_cond_signal (&sign_jobs_cond));
1187  GNUNET_assert (0 == pthread_mutex_unlock (&sign_jobs_lock));
1188 }

References RecordPublicationJob::block, RecordPublicationJob::block_priv, RecordPublicationJob::block_size, expire, RecordPublicationJob::expire_pub, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GNSRECORD_block_create_unsigned(), GNUNET_GNSRECORD_block_get_size(), GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE, GNUNET_GNSRECORD_normalize_record_set(), GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_strdup, job, key, RecordPublicationJob::label, rd, rd_count, sign_jobs_cond, sign_jobs_head, sign_jobs_lock, and sign_jobs_tail.

Referenced by handle_monitor_event().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_monitor_event()

static void handle_monitor_event ( void *  cls,
const struct GNUNET_IDENTITY_PrivateKey zone,
const char *  label,
unsigned int  rd_count,
const struct GNUNET_GNSRECORD_Data rd,
struct GNUNET_TIME_Absolute  expire 
)
static

Process a record that was stored in the namestore (invoked by the monitor).

Parameters
clsclosure, NULL
zoneprivate key of the zone; NULL on disconnect
labellabel of the records; NULL on disconnect
rd_countnumber of entries in rd array, 0 if label was deleted
rdarray of records with data to store
expireexpiration of this record set

Definition at line 1203 of file gnunet-service-zonemaster.c.

1209 {
1210  (void) cls;
1212  "Namestore monitor events received",
1213  1,
1214  GNUNET_NO);
1216  "Received %u records for label `%s' via namestore monitor\n",
1217  rd_count,
1218  label);
1219  if (0 == rd_count)
1220  {
1222  1);
1223  return; /* nothing to do */
1224  }
1226  label,
1227  rd,
1228  rd_count,
1229  expire);
1230  job_queue_length++;
1232  {
1234  "Job queue length exceeded (%u/%u). Halting monitor.\n",
1236  JOB_QUEUE_LIMIT);
1238  return;
1239  }
1241  1);
1242 }
static char * zone
Name of the zone being managed.
static void dispatch_job_monitor(const struct GNUNET_IDENTITY_PrivateKey *key, const char *label, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count, struct GNUNET_TIME_Absolute expire)
Store GNS records in the DHT.

References dispatch_job_monitor(), expire, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NAMESTORE_zone_monitor_next(), GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, job_queue_length, JOB_QUEUE_LIMIT, RecordPublicationJob::label, monitor_halted, rd, rd_count, statistics, zmon, and zone.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_monitor_error()

static void handle_monitor_error ( void *  cls)
static

The zone monitor encountered an IPC error trying to to get in sync.

Restart from the beginning.

Parameters
clsNULL

Definition at line 1252 of file gnunet-service-zonemaster.c.

1253 {
1254  (void) cls;
1256  "Namestore monitor errors encountered",
1257  1,
1258  GNUNET_NO);
1259 }

References GNUNET_NO, GNUNET_STATISTICS_update(), and statistics.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ sign_worker()

static void* sign_worker ( void *  cls)
static

Definition at line 1263 of file gnunet-service-zonemaster.c.

1264 {
1265  struct RecordPublicationJob *job;
1266  const struct GNUNET_DISK_FileHandle *fh;
1267 
1269  while (GNUNET_YES != in_shutdown)
1270  {
1271  GNUNET_assert (0 == pthread_mutex_lock (&sign_jobs_lock));
1272  while (NULL == sign_jobs_head)
1273  GNUNET_assert (0 == pthread_cond_wait (&sign_jobs_cond, &sign_jobs_lock));
1274  if (GNUNET_YES == in_shutdown)
1275  {
1276  GNUNET_assert (0 == pthread_mutex_unlock (&sign_jobs_lock));
1277  return NULL;
1278  }
1280  "Taking on Job for %s\n", sign_jobs_head->label);
1281  job = sign_jobs_head;
1283  GNUNET_assert (0 == pthread_mutex_unlock (&sign_jobs_lock));
1284  GNUNET_GNSRECORD_block_sign (&job->zone, job->label, job->block);
1285  if (job->block != job->block_priv)
1286  GNUNET_GNSRECORD_block_sign (&job->zone, job->label, job->block_priv);
1287  GNUNET_assert (0 == pthread_mutex_lock (&sign_results_lock));
1289  GNUNET_assert (0 == pthread_mutex_unlock (&sign_results_lock));
1290  job = NULL;
1292  "Done, notifying main thread through pipe!\n");
1293  GNUNET_DISK_file_write (fh, "!", 1);
1294  }
1295  return NULL;
1296 }
static struct GNUNET_DISK_FileHandle * fh
File handle to STDIN, for reading restart/quit commands.
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:685
@ GNUNET_DISK_PIPE_END_WRITE
The writing-end of a pipe.
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_block_sign(const struct GNUNET_IDENTITY_PrivateKey *key, const char *label, struct GNUNET_GNSRECORD_Block *block)
Sign a block create with GNUNET_GNSRECORD_block_create_unsigned.

References fh, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_DISK_file_write(), GNUNET_DISK_PIPE_END_WRITE, GNUNET_DISK_pipe_handle(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_block_sign(), GNUNET_log, GNUNET_YES, in_shutdown, job, RecordPublicationJob::label, notification_pipe, sign_jobs_cond, sign_jobs_head, sign_jobs_lock, sign_jobs_tail, sign_results_head, sign_results_lock, and sign_results_tail.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ run()

static void run ( void *  cls,
const struct GNUNET_CONFIGURATION_Handle c,
struct GNUNET_SERVICE_Handle service 
)
static

Perform zonemaster duties: watch namestore, publish records.

Parameters
clsclosure
serverthe initialized server
cconfiguration to use

Start worker

Definition at line 1316 of file gnunet-service-zonemaster.c.

1319 {
1320  unsigned long long max_parallel_bg_queries = 128;
1321 
1322  (void) cls;
1323  (void) service;
1324  last_put_100 = GNUNET_TIME_absolute_get (); /* first time! */
1329  if (NULL == namestore_handle)
1330  {
1332  _ ("Failed to connect to the namestore!\n"));
1334  return;
1335  }
1337  "namecache",
1338  "DISABLE");
1340  {
1342  if (NULL == namecache)
1343  {
1345  _ ("Failed to connect to the namecache!\n"));
1347  return;
1348  }
1349  }
1351  "namestore",
1352  "CACHE_KEYS");
1354  if (GNUNET_OK ==
1356  "zonemaster",
1357  "ZONE_PUBLISH_TIME_WINDOW",
1359  {
1361  "Time window for zone iteration: %s\n",
1364  GNUNET_YES));
1365  }
1367  if (GNUNET_OK ==
1369  "zonemaster",
1370  "MAX_PARALLEL_BACKGROUND_QUERIES",
1371  &max_parallel_bg_queries))
1372  {
1374  "Number of allowed parallel background queries: %llu\n",
1375  max_parallel_bg_queries);
1376  }
1377  if (0 == max_parallel_bg_queries)
1378  max_parallel_bg_queries = 1;
1380  (unsigned int) max_parallel_bg_queries);
1381  if (NULL == dht_handle)
1382  {
1384  _ ("Could not connect to DHT!\n"));
1386  NULL);
1387  return;
1388  }
1389 
1390  /* Schedule periodic put for our records. */
1392  statistics = GNUNET_STATISTICS_create ("zonemaster",
1393  c);
1395  "Target zone iteration velocity (μs)",
1397  GNUNET_NO);
1399  NULL);
1401  NULL,
1402  GNUNET_NO,
1404  NULL,
1406  NULL,
1407  NULL /* sync_cb */,
1408  NULL,
1412  GNUNET_break (NULL != zmon);
1413 
1415  NULL);
1416 
1418  const struct GNUNET_DISK_FileHandle *np_fh = GNUNET_DISK_pipe_handle (
1422  np_fh,
1423  notification_pipe_cb, NULL);
1424 
1425  long long unsigned int worker_count = 1;
1426  if (GNUNET_OK !=
1428  "zonemaster",
1429  "WORKER_COUNT",
1430  &worker_count))
1431  {
1433  "Number of workers not defined falling back to 1\n");
1434  }
1435  worker = GNUNET_malloc (sizeof (pthread_t) * worker_count);
1437  for (int i = 0; i < worker_count; i++)
1438  {
1439  if (0 !=
1440  pthread_create (&worker[i],
1441  NULL,
1442  &sign_worker,
1443  NULL))
1444  {
1446  "pthread_create");
1448  }
1449  }
1450 }
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static void handle_monitor_error(void *cls)
The zone monitor encountered an IPC error trying to to get in sync.
#define NAMESTORE_MONITOR_QUEUE_LIMIT
How many events may the namestore give us before it has to wait for us to keep up?
static void handle_monitor_event(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute expire)
Process a record that was stored in the namestore (invoked by the monitor).
static void shutdown_task(void *cls)
Task run during shutdown.
static void * sign_worker(void *cls)
#define INITIAL_ZONE_ITERATION_INTERVAL
The initial interval in milliseconds btween puts in a zone iteration.
static int cache_keys
Optimize block insertion by caching map of private keys to public keys in memory?
static pthread_t * worker
Our workers.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_time(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
Get a configuration value that should be a relative time.
struct GNUNET_DHT_Handle * GNUNET_DHT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned int ht_len)
Initialize the connection with the DHT service.
Definition: dht_api.c:1039
#define GNUNET_DHT_DEFAULT_REPUBLISH_FREQUENCY
Default republication frequency for stored data in the DHT.
struct GNUNET_DISK_PipeHandle * GNUNET_DISK_pipe(enum GNUNET_DISK_PipeFlags pf)
Creates an interprocess channel.
Definition: disk.c:1441
@ GNUNET_DISK_PF_NONE
No special options, use non-blocking read/write operations.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
#define GNUNET_malloc(size)
Wrapper around malloc.
struct GNUNET_NAMECACHE_Handle * GNUNET_NAMECACHE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namecache service.
struct GNUNET_NAMESTORE_ZoneMonitor * GNUNET_NAMESTORE_zone_monitor_start2(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_IDENTITY_PrivateKey *zone, int iterate_first, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordSetMonitor monitor, void *monitor_cls, GNUNET_SCHEDULER_TaskCallback sync_cb, void *sync_cb_cls, enum GNUNET_GNSRECORD_Filter filter)
Begin monitoring a zone for changes.
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:534
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1303
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.

References _, cache_keys, dht_handle, disable_namecache, first_zone_iteration, GNUNET_break, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_DHT_connect(), GNUNET_DHT_DEFAULT_REPUBLISH_FREQUENCY, GNUNET_DISK_PF_NONE, GNUNET_DISK_pipe(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_pipe_handle(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_GNSRECORD_FILTER_NONE, GNUNET_log, GNUNET_log_strerror, GNUNET_malloc, GNUNET_NAMECACHE_connect(), GNUNET_NAMESTORE_connect(), GNUNET_NAMESTORE_zone_monitor_next(), GNUNET_NAMESTORE_zone_monitor_start2(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_read_file(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_STATISTICS_set(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, handle_monitor_error(), handle_monitor_event(), INITIAL_ZONE_ITERATION_INTERVAL, last_put_100, min_relative_record_time, namecache, namestore_handle, NAMESTORE_MONITOR_QUEUE_LIMIT, notification_pipe, notification_pipe_cb(), pipe_read_task, publish_zone_dht_start(), GNUNET_TIME_Relative::rel_value_us, service, shutdown_task(), sign_worker(), statistics, target_iteration_velocity_per_record, worker, zmon, zone_publish_task, zone_publish_time_window, and zone_publish_time_window_default.

Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN ( "zonemaster"  ,
GNUNET_SERVICE_OPTION_NONE  ,
run,
NULL  ,
NULL  ,
NULL  ,
GNUNET_MQ_handler_end()   
)

Define "main" method using service macro.

Variable Documentation

◆ worker

pthread_t* worker
static

Our workers.

Definition at line 96 of file gnunet-service-zonemaster.c.

Referenced by run().

◆ sign_jobs_lock

pthread_mutex_t sign_jobs_lock
static

Lock for the sign jobs queue.

Definition at line 101 of file gnunet-service-zonemaster.c.

Referenced by dispatch_job(), dispatch_job_monitor(), shutdown_task(), and sign_worker().

◆ sign_results_lock

pthread_mutex_t sign_results_lock
static

Lock for the DHT put jobs queue.

Definition at line 106 of file gnunet-service-zonemaster.c.

Referenced by initiate_put_from_pipe_trigger(), shutdown_task(), and sign_worker().

◆ sign_jobs_cond

pthread_cond_t sign_jobs_cond
static

Wait condition on new sign jobs.

Definition at line 111 of file gnunet-service-zonemaster.c.

Referenced by dispatch_job(), dispatch_job_monitor(), and sign_worker().

◆ in_shutdown

int in_shutdown = GNUNET_NO
static

For threads to know we are shutting down.

Definition at line 116 of file gnunet-service-zonemaster.c.

Referenced by shutdown_task(), and sign_worker().

◆ monitor_halted

int monitor_halted = GNUNET_NO
static

Monitor halted?

Definition at line 121 of file gnunet-service-zonemaster.c.

Referenced by dht_put_continuation(), and handle_monitor_event().

◆ notification_pipe

struct GNUNET_DISK_PipeHandle* notification_pipe
static

Our notification pipe.

Definition at line 126 of file gnunet-service-zonemaster.c.

Referenced by initiate_put_from_pipe_trigger(), run(), shutdown_task(), and sign_worker().

◆ pipe_read_task

struct GNUNET_SCHEDULER_Task* pipe_read_task
static

Pipe read task.

Definition at line 131 of file gnunet-service-zonemaster.c.

Referenced by initiate_put_from_pipe_trigger(), run(), and shutdown_task().

◆ sign_jobs_head

struct RecordPublicationJob* sign_jobs_head
static

The DLL for workers to retrieve open jobs that require signing of blocks.

Definition at line 193 of file gnunet-service-zonemaster.c.

Referenced by dispatch_job(), dispatch_job_monitor(), shutdown_task(), and sign_worker().

◆ sign_jobs_tail

struct RecordPublicationJob* sign_jobs_tail
static

See above.

Definition at line 198 of file gnunet-service-zonemaster.c.

Referenced by dispatch_job(), dispatch_job_monitor(), shutdown_task(), and sign_worker().

◆ sign_results_head

struct RecordPublicationJob* sign_results_head
static

The DLL for workers to place jobs that are signed.

Definition at line 203 of file gnunet-service-zonemaster.c.

Referenced by initiate_put_from_pipe_trigger(), shutdown_task(), and sign_worker().

◆ sign_results_tail

struct RecordPublicationJob* sign_results_tail
static

See above.

Definition at line 208 of file gnunet-service-zonemaster.c.

Referenced by initiate_put_from_pipe_trigger(), shutdown_task(), and sign_worker().

◆ dht_jobs_head

struct RecordPublicationJob* dht_jobs_head
static

The DLL for jobs currently in the process of being dispatched into the DHT.

Definition at line 214 of file gnunet-service-zonemaster.c.

Referenced by dht_put_continuation(), initiate_put_from_pipe_trigger(), and shutdown_task().

◆ dht_jobs_tail

struct RecordPublicationJob* dht_jobs_tail
static

See above.

Definition at line 219 of file gnunet-service-zonemaster.c.

Referenced by dht_put_continuation(), initiate_put_from_pipe_trigger(), and shutdown_task().

◆ statistics

◆ dht_handle

struct GNUNET_DHT_Handle* dht_handle
static

Our handle to the DHT.

Definition at line 253 of file gnunet-service-zonemaster.c.

Referenced by initiate_put_from_pipe_trigger(), run(), and shutdown_task().

◆ namestore_handle

struct GNUNET_NAMESTORE_Handle* namestore_handle
static

Our handle to the namestore service.

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

Referenced by publish_zone_dht_start(), run(), and shutdown_task().

◆ zmon

struct GNUNET_NAMESTORE_ZoneMonitor* zmon
static

Handle to monitor namestore changes to instant propagation.

Definition at line 263 of file gnunet-service-zonemaster.c.

Referenced by dht_put_continuation(), handle_monitor_event(), run(), and shutdown_task().

◆ namecache

struct GNUNET_NAMECACHE_Handle* namecache
static

Our handle to the namecache service.

Definition at line 268 of file gnunet-service-zonemaster.c.

Referenced by refresh_block(), run(), and shutdown_task().

◆ disable_namecache

int disable_namecache
static

Use the namecache? Doing so creates additional cryptographic operations whenever we touch a record.

Definition at line 274 of file gnunet-service-zonemaster.c.

Referenced by refresh_block(), and run().

◆ namestore_iter

struct GNUNET_NAMESTORE_ZoneIterator* namestore_iter
static

Handle to iterate over our authoritative zone in namestore.

Definition at line 279 of file gnunet-service-zonemaster.c.

Referenced by publish_zone_dht_start(), publish_zone_namestore_next(), shutdown_task(), zone_iteration_error(), and zone_iteration_finished().

◆ job_queue_length

unsigned int job_queue_length
static

Number of entries in the job queue #jobs_head.

Definition at line 284 of file gnunet-service-zonemaster.c.

Referenced by check_zone_namestore_next(), dht_put_continuation(), handle_monitor_event(), handle_record(), shutdown_task(), and update_velocity().

◆ num_public_records

unsigned long long num_public_records
static

Useful for zone update for DHT put.

Definition at line 289 of file gnunet-service-zonemaster.c.

Referenced by calculate_put_interval(), dispatch_job(), publish_zone_dht_start(), update_velocity(), and zone_iteration_finished().

◆ last_num_public_records

unsigned long long last_num_public_records
static

Last seen record count.

Definition at line 294 of file gnunet-service-zonemaster.c.

Referenced by calculate_put_interval(), update_velocity(), and zone_iteration_finished().

◆ put_cnt

unsigned long long put_cnt
static

Number of successful put operations performed in the current measurement cycle (as measured in check_zone_namestore_next()).

Definition at line 300 of file gnunet-service-zonemaster.c.

Referenced by check_zone_namestore_next(), and handle_record().

◆ target_iteration_velocity_per_record

struct GNUNET_TIME_Relative target_iteration_velocity_per_record
static

What is the frequency at which we currently would like to perform DHT puts (per record)? Calculated in update_velocity() from the zone_publish_time_window() and the total number of record sets we have (so far) observed in the zone.

Definition at line 300 of file gnunet-service-zonemaster.c.

Referenced by calculate_put_interval(), check_zone_namestore_next(), run(), update_velocity(), and zone_iteration_finished().

◆ min_relative_record_time

struct GNUNET_TIME_Relative min_relative_record_time
static

Minimum relative expiration time of records seem during the current zone iteration.

Definition at line 300 of file gnunet-service-zonemaster.c.

Referenced by calculate_put_interval(), handle_record(), run(), and zone_iteration_finished().

◆ last_min_relative_record_time

struct GNUNET_TIME_Relative last_min_relative_record_time
static

Minimum relative expiration time of records seem during the last zone iteration.

Definition at line 300 of file gnunet-service-zonemaster.c.

Referenced by calculate_put_interval(), and zone_iteration_finished().

◆ zone_publish_time_window_default

struct GNUNET_TIME_Relative zone_publish_time_window_default
static

Default time window for zone iteration.

Definition at line 300 of file gnunet-service-zonemaster.c.

Referenced by calculate_put_interval(), and run().

◆ zone_publish_time_window

struct GNUNET_TIME_Relative zone_publish_time_window
static

Time window for zone iteration, adjusted based on relative record expiration times in our zone.

Definition at line 300 of file gnunet-service-zonemaster.c.

Referenced by calculate_put_interval(), and run().

◆ last_put_100

struct GNUNET_TIME_Absolute last_put_100
static

When did we last start measuring the DELTA_INTERVAL successful DHT puts? Used for velocity calculations.

Definition at line 300 of file gnunet-service-zonemaster.c.

Referenced by run(), and update_velocity().

◆ sub_delta

struct GNUNET_TIME_Relative sub_delta
static

By how much should we try to increase our per-record iteration speed (over the desired speed calculated directly from the #put_interval)? Basically this value corresponds to the per-record CPU time overhead we have.

Definition at line 300 of file gnunet-service-zonemaster.c.

Referenced by check_zone_namestore_next(), and update_velocity().

◆ zone_publish_task

◆ ns_iteration_left

unsigned int ns_iteration_left
static

How many more values are left for the current query before we need to explicitly ask the namestore for more?

Definition at line 357 of file gnunet-service-zonemaster.c.

Referenced by check_zone_namestore_next(), handle_record(), publish_zone_dht_start(), and publish_zone_namestore_next().

◆ first_zone_iteration

int first_zone_iteration
static

GNUNET_YES if zone has never been published before

Definition at line 362 of file gnunet-service-zonemaster.c.

Referenced by check_zone_namestore_next(), run(), update_velocity(), and zone_iteration_finished().

◆ cache_keys

int cache_keys
static

Optimize block insertion by caching map of private keys to public keys in memory?

Definition at line 368 of file gnunet-service-zonemaster.c.

Referenced by run().

◆ cop_head

struct CacheOperation* cop_head
static

Head of cop DLL.

Definition at line 373 of file gnunet-service-zonemaster.c.

Referenced by finish_cache_operation(), refresh_block(), and shutdown_task().

◆ cop_tail

struct CacheOperation* cop_tail
static

Tail of cop DLL.

Definition at line 378 of file gnunet-service-zonemaster.c.

Referenced by finish_cache_operation(), refresh_block(), and shutdown_task().