GNUnet  0.19.5
gnunet-service-fs_push.c File Reference

API to push content from our datastore to other peers ('anonymous'-content P2P migration) More...

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

Go to the source code of this file.

Data Structures

struct  MigrationReadyBlock
 Block that is ready for migration to other peers. More...
 
struct  MigrationReadyPeer
 Information about a peer waiting for migratable data. More...
 

Macros

#define MAX_MIGRATION_QUEUE   8
 Maximum number of blocks we keep in memory for migration. More...
 
#define MIGRATION_LIST_SIZE   2
 Blocks are at most migrated to this number of peers plus one, each time they are fetched from the database. More...
 
#define MIN_MIGRATION_CONTENT_LIFETIME
 How long must content remain valid for us to consider it for migration? If content will expire too soon, there is clearly no point in pushing it to other peers. More...
 

Functions

static void delete_migration_block (struct MigrationReadyBlock *mb)
 Delete the given migration block. More...
 
static void find_content (void *cls)
 Find content for migration to this peer. More...
 
static int transmit_content (struct MigrationReadyPeer *mrp, struct MigrationReadyBlock *block)
 Send the given block to the given peer. More...
 
static unsigned int count_targets (struct MigrationReadyBlock *block)
 Count the number of peers this block has already been forwarded to. More...
 
static long score_content (struct MigrationReadyPeer *mrp, struct MigrationReadyBlock *block)
 Check if sending this block to this peer would be a good idea. More...
 
static void consider_gathering (void)
 If the migration task is not currently running, consider (re)scheduling it with the appropriate delay. More...
 
static void gather_migration_blocks (void *cls)
 Task that is run periodically to obtain blocks for content migration. More...
 
static void process_migration_content (void *cls, const struct GNUNET_HashCode *key, size_t size, const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority, uint32_t anonymity, uint32_t replication, struct GNUNET_TIME_Absolute expiration, uint64_t uid)
 Process content offered for migration. More...
 
void GSF_push_start_ (struct GSF_ConnectedPeer *peer)
 A peer connected to us. More...
 
void GSF_push_stop_ (struct GSF_ConnectedPeer *peer)
 A peer disconnected from us. More...
 
void GSF_push_init_ ()
 Setup the module. More...
 
void GSF_push_done_ ()
 Shutdown the module. More...
 

Variables

static struct MigrationReadyBlockmig_head
 Head of linked list of blocks that can be migrated. More...
 
static struct MigrationReadyBlockmig_tail
 Tail of linked list of blocks that can be migrated. More...
 
static struct MigrationReadyPeerpeer_head
 Head of linked list of peers. More...
 
static struct MigrationReadyPeerpeer_tail
 Tail of linked list of peers. More...
 
static struct GNUNET_DATASTORE_QueueEntrymig_qe
 Request to datastore for migration (or NULL). More...
 
static struct GNUNET_SCHEDULER_Taskmig_task
 ID of task that collects blocks for migration. More...
 
static struct GNUNET_TIME_Relative min_migration_delay
 What is the maximum frequency at which we are allowed to poll the datastore for migration content? More...
 
static unsigned int mig_size
 Size of the doubly-linked list of migration blocks. More...
 
static int enabled
 Is this module enabled? More...
 
static int value_found
 Did we find anything in the datastore? More...
 

Detailed Description

API to push content from our datastore to other peers ('anonymous'-content P2P migration)

Author
Christian Grothoff

Definition in file gnunet-service-fs_push.c.

Macro Definition Documentation

◆ MAX_MIGRATION_QUEUE

#define MAX_MIGRATION_QUEUE   8

Maximum number of blocks we keep in memory for migration.

Definition at line 37 of file gnunet-service-fs_push.c.

◆ MIGRATION_LIST_SIZE

#define MIGRATION_LIST_SIZE   2

Blocks are at most migrated to this number of peers plus one, each time they are fetched from the database.

Definition at line 43 of file gnunet-service-fs_push.c.

◆ MIN_MIGRATION_CONTENT_LIFETIME

#define MIN_MIGRATION_CONTENT_LIFETIME
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

How long must content remain valid for us to consider it for migration? If content will expire too soon, there is clearly no point in pushing it to other peers.

This value gives the threshold for migration. Note that if this value is increased, the migration testcase may need to be adjusted as well (especially the CONTENT_LIFETIME in fs_test_lib.c).

Definition at line 52 of file gnunet-service-fs_push.c.

Function Documentation

◆ delete_migration_block()

static void delete_migration_block ( struct MigrationReadyBlock mb)
static

Delete the given migration block.

Parameters
mbblock to delete

Definition at line 189 of file gnunet-service-fs_push.c.

190 {
192  mig_tail,
193  mb);
196  mig_size--;
197  GNUNET_free (mb);
198 }
static unsigned int mig_size
Size of the doubly-linked list of migration blocks.
static struct MigrationReadyBlock * mig_tail
Tail of linked list of blocks that can be migrated.
static struct MigrationReadyBlock * mig_head
Head of linked list of blocks that can be migrated.
#define MIGRATION_LIST_SIZE
Blocks are at most migrated to this number of peers plus one, each time they are fetched from the dat...
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_PEER_decrement_rcs(const GNUNET_PEER_Id *ids, unsigned int count)
Decrement multiple RCs of peer identities by one.
Definition: peer.c:157
GNUNET_PEER_Id target_list[2]
Peers we already forwarded this block to.

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_PEER_decrement_rcs(), mig_head, mig_size, mig_tail, MIGRATION_LIST_SIZE, and MigrationReadyBlock::target_list.

Referenced by find_content(), GSF_push_done_(), and transmit_content().

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

◆ find_content()

static void find_content ( void *  cls)
static

Find content for migration to this peer.

Parameters
clsA struct MigrationReadyPeer * to find content for

Definition at line 329 of file gnunet-service-fs_push.c.

330 {
331  struct MigrationReadyPeer *mrp = cls;
332  struct MigrationReadyBlock *pos;
333  long score;
334  long best_score;
335  struct MigrationReadyBlock *best;
336 
337  mrp->env = NULL;
338  best = NULL;
339  best_score = -1;
340  pos = mig_head;
341  while (NULL != pos)
342  {
343  score = score_content (mrp, pos);
344  if (score > best_score)
345  {
346  best_score = score;
347  best = pos;
348  }
349  pos = pos->next;
350  }
351  if (NULL == best)
352  {
354  {
356  "No content found for pushing, waiting for queue to fill\n");
357  return; /* will fill up eventually... */
358  }
360  "No suitable content found, purging content from full queue\n");
361  /* failed to find migration target AND
362  * queue is full, purge most-forwarded
363  * block from queue to make room for more */
364  pos = mig_head;
365  while (NULL != pos)
366  {
367  score = count_targets (pos);
368  if (score >= best_score)
369  {
370  best_score = score;
371  best = pos;
372  }
373  pos = pos->next;
374  }
375  GNUNET_assert (NULL != best);
376  delete_migration_block (best);
378  return;
379  }
381  "Preparing to push best content to peer\n");
382  transmit_content (mrp,
383  best);
384 }
static unsigned int count_targets(struct MigrationReadyBlock *block)
Count the number of peers this block has already been forwarded to.
static long score_content(struct MigrationReadyPeer *mrp, struct MigrationReadyBlock *block)
Check if sending this block to this peer would be a good idea.
static void consider_gathering(void)
If the migration task is not currently running, consider (re)scheduling it with the appropriate delay...
#define MAX_MIGRATION_QUEUE
Maximum number of blocks we keep in memory for migration.
static int transmit_content(struct MigrationReadyPeer *mrp, struct MigrationReadyBlock *block)
Send the given block to the given peer.
static void delete_migration_block(struct MigrationReadyBlock *mb)
Delete the given migration block.
#define GNUNET_log(kind,...)
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
@ GNUNET_ERROR_TYPE_DEBUG
Block that is ready for migration to other peers.
struct MigrationReadyBlock * next
This is a doubly-linked list.
Information about a peer waiting for migratable data.
struct GNUNET_MQ_Envelope * env
Envelope of the currently pushed message.

References consider_gathering(), count_targets(), delete_migration_block(), MigrationReadyPeer::env, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, MAX_MIGRATION_QUEUE, mig_head, mig_size, MigrationReadyBlock::next, score_content(), and transmit_content().

Referenced by GSF_push_start_(), and transmit_content().

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

◆ transmit_content()

static int transmit_content ( struct MigrationReadyPeer mrp,
struct MigrationReadyBlock block 
)
static

Send the given block to the given peer.

Parameters
mrptarget peer
blockthe block
Returns
GNUNET_YES if the block was deleted (!)

Definition at line 218 of file gnunet-service-fs_push.c.

220 {
221  struct PutMessage *msg;
222  unsigned int i;
223  struct GSF_PeerPerformanceData *ppd;
224  int ret;
225 
227  GNUNET_assert (NULL == mrp->env);
228  mrp->env = GNUNET_MQ_msg_extra (msg,
229  block->size,
231  msg->type = htonl (block->type);
232  msg->expiration = GNUNET_TIME_absolute_hton (block->expiration);
233  GNUNET_memcpy (&msg[1],
234  &block[1],
235  block->size);
236  for (i = 0; i < MIGRATION_LIST_SIZE; i++)
237  {
238  if (block->target_list[i] == 0)
239  {
240  block->target_list[i] = ppd->pid;
242  1);
243  break;
244  }
245  }
246  if (MIGRATION_LIST_SIZE == i)
247  {
248  delete_migration_block (block);
249  ret = GNUNET_YES;
250  }
251  else
252  {
253  ret = GNUNET_NO;
254  }
256  &find_content,
257  mrp);
258  GSF_peer_transmit_ (mrp->peer,
259  GNUNET_NO,
260  0 /* priority */,
261  mrp->env);
262  return ret;
263 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
void GSF_peer_transmit_(struct GSF_ConnectedPeer *cp, int is_query, uint32_t priority, struct GNUNET_MQ_Envelope *env)
Transmit a message to the given peer as soon as possible.
struct GSF_PeerPerformanceData * GSF_get_peer_performance_data_(struct GSF_ConnectedPeer *cp)
Return the performance data record for the given peer.
static void find_content(void *cls)
Find content for migration to this peer.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_YES
@ GNUNET_NO
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:63
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore.
Definition: mq.c:638
void GNUNET_PEER_change_rc(GNUNET_PEER_Id id, int delta)
Change the reference counter of an interned PID.
Definition: peer.c:192
#define GNUNET_MESSAGE_TYPE_FS_PUT
P2P response with content or active migration of content.
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:638
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
Performance data kept for a peer.
GNUNET_PEER_Id pid
The peer's identity (interned version).
enum GNUNET_BLOCK_Type type
Type of the block.
size_t size
Size of the block.
struct GNUNET_TIME_Absolute expiration
When does this block expire?
struct GSF_ConnectedPeer * peer
Handle to peer.
Response from FS service with a result for a previous FS search.
Definition: fs.h:330

References delete_migration_block(), MigrationReadyPeer::env, MigrationReadyBlock::expiration, find_content(), GNUNET_assert, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_FS_PUT, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_NO, GNUNET_PEER_change_rc(), GNUNET_TIME_absolute_hton(), GNUNET_YES, GSF_get_peer_performance_data_(), GSF_peer_transmit_(), MIGRATION_LIST_SIZE, msg, MigrationReadyPeer::peer, GSF_PeerPerformanceData::pid, ret, MigrationReadyBlock::size, MigrationReadyBlock::target_list, MigrationReadyBlock::type, and GNUNET_MessageHeader::type.

Referenced by find_content(), and process_migration_content().

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

◆ count_targets()

static unsigned int count_targets ( struct MigrationReadyBlock block)
static

Count the number of peers this block has already been forwarded to.

Parameters
blockthe block
Returns
number of times block was forwarded

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

275 {
276  unsigned int i;
277 
278  for (i = 0; i < MIGRATION_LIST_SIZE; i++)
279  if (block->target_list[i] == 0)
280  return i;
281  return i;
282 }

References MIGRATION_LIST_SIZE, and MigrationReadyBlock::target_list.

Referenced by find_content().

Here is the caller graph for this function:

◆ score_content()

static long score_content ( struct MigrationReadyPeer mrp,
struct MigrationReadyBlock block 
)
static

Check if sending this block to this peer would be a good idea.

Parameters
mrptarget peer
blockthe block
Returns
score (>= 0: feasible, negative: infeasible)

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

296 {
297  unsigned int i;
298  struct GSF_PeerPerformanceData *ppd;
299  struct GNUNET_PeerIdentity id;
300  struct GNUNET_HashCode hc;
301  uint32_t dist;
302 
304  for (i = 0; i < MIGRATION_LIST_SIZE; i++)
305  if (block->target_list[i] == ppd->pid)
306  return -1;
307  GNUNET_assert (0 != ppd->pid);
308  GNUNET_PEER_resolve (ppd->pid,
309  &id);
310  GNUNET_CRYPTO_hash (&id,
311  sizeof(struct GNUNET_PeerIdentity),
312  &hc);
313  dist = GNUNET_CRYPTO_hash_distance_u32 (&block->query,
314  &hc);
315  /* closer distance, higher score: */
316  return UINT32_MAX - dist;
317 }
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
uint32_t GNUNET_CRYPTO_hash_distance_u32(const struct GNUNET_HashCode *a, const struct GNUNET_HashCode *b)
Compute the distance between 2 hashcodes.
Definition: crypto_hash.c:89
void GNUNET_PEER_resolve(GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
Convert an interned PID to a normal peer identity.
Definition: peer.c:220
A 512-bit hashcode.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_HashCode query
Query for the block.

References GNUNET_assert, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hash_distance_u32(), GNUNET_PEER_resolve(), GSF_get_peer_performance_data_(), id, MIGRATION_LIST_SIZE, MigrationReadyPeer::peer, GSF_PeerPerformanceData::pid, MigrationReadyBlock::query, and MigrationReadyBlock::target_list.

Referenced by find_content().

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

◆ consider_gathering()

static void consider_gathering ( void  )
static

If the migration task is not currently running, consider (re)scheduling it with the appropriate delay.

Definition at line 402 of file gnunet-service-fs_push.c.

403 {
405 
406  if (NULL == GSF_dsh)
407  return;
408  if (NULL != mig_qe)
409  return;
410  if (NULL != mig_task)
411  return;
413  return;
415  mig_size);
420  if (GNUNET_NO == value_found)
421  {
422  /* wait at least 5s if the datastore is empty */
426  5));
427  }
429  "Scheduling gathering task (queue size: %u)\n",
430  mig_size);
433  NULL);
434 }
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
struct GNUNET_DATASTORE_Handle * GSF_dsh
Our connection to the datastore.
static struct GNUNET_SCHEDULER_Task * mig_task
ID of task that collects blocks for migration.
static struct GNUNET_TIME_Relative min_migration_delay
What is the maximum frequency at which we are allowed to poll the datastore for migration content?
static int value_found
Did we find anything in the datastore?
static void gather_migration_blocks(void *cls)
Task that is run periodically to obtain blocks for content migration.
static struct GNUNET_DATASTORE_QueueEntry * mig_qe
Request to datastore for migration (or NULL).
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:1272
struct GNUNET_TIME_Relative GNUNET_TIME_relative_max(struct GNUNET_TIME_Relative t1, struct GNUNET_TIME_Relative t2)
Return the maximum of two relative time values.
Definition: time.c:351
#define GNUNET_TIME_UNIT_SECONDS
One second.
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
Time for relative time used by GNUnet, in microseconds.

References delay, gather_migration_blocks(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_max(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_SECONDS, GSF_dsh, MAX_MIGRATION_QUEUE, mig_qe, mig_size, mig_task, min_migration_delay, and value_found.

Referenced by find_content(), gather_migration_blocks(), GSF_push_init_(), and process_migration_content().

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

◆ gather_migration_blocks()

static void gather_migration_blocks ( void *  cls)
static

Task that is run periodically to obtain blocks for content migration.

Parameters
clsunused

Definition at line 539 of file gnunet-service-fs_push.c.

540 {
541  mig_task = NULL;
543  return;
544  if (NULL == GSF_dsh)
545  return;
547  "Asking datastore for content for replication (queue size: %u)\n",
548  mig_size);
551  0,
552  UINT_MAX,
554  NULL);
555  if (NULL == mig_qe)
557 }
static void process_migration_content(void *cls, const struct GNUNET_HashCode *key, size_t size, const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority, uint32_t anonymity, uint32_t replication, struct GNUNET_TIME_Absolute expiration, uint64_t uid)
Process content offered for migration.
struct GNUNET_DATASTORE_QueueEntry * GNUNET_DATASTORE_get_for_replication(struct GNUNET_DATASTORE_Handle *h, unsigned int queue_priority, unsigned int max_queue_size, GNUNET_DATASTORE_DatumProcessor proc, void *proc_cls)
Get a random value from the datastore for content replication.

References consider_gathering(), GNUNET_DATASTORE_get_for_replication(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GSF_dsh, MAX_MIGRATION_QUEUE, mig_qe, mig_size, mig_task, process_migration_content(), and value_found.

Referenced by consider_gathering().

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

◆ process_migration_content()

static void process_migration_content ( void *  cls,
const struct GNUNET_HashCode key,
size_t  size,
const void *  data,
enum GNUNET_BLOCK_Type  type,
uint32_t  priority,
uint32_t  anonymity,
uint32_t  replication,
struct GNUNET_TIME_Absolute  expiration,
uint64_t  uid 
)
static

Process content offered for migration.

Parameters
clsclosure
keykey for the content
sizenumber of bytes in data
datacontent stored
typetype of the content
prioritypriority of the content
anonymityanonymity-level for the content
replicationreplication-level for the content
expirationexpiration time for the content
uidunique identifier for the datum; maybe 0 if no unique identifier is available

Definition at line 453 of file gnunet-service-fs_push.c.

463 {
464  struct MigrationReadyBlock *mb;
465  struct MigrationReadyPeer *pos;
466 
467  mig_qe = NULL;
468  if (NULL == key)
469  {
471  "No content found for migration...\n");
473  return;
474  }
477  MIN_MIGRATION_CONTENT_LIFETIME.rel_value_us)
478  {
479  /* content will expire soon, don't bother */
481  return;
482  }
484  {
485  if (GNUNET_OK !=
487  size,
488  data,
489  type,
490  priority,
491  anonymity,
492  replication,
493  expiration,
494  uid,
496  NULL))
498  return;
499  }
501  "Retrieved block `%s' of type %u for migration (queue size: %u/%u)\n",
502  GNUNET_h2s (key),
503  type, mig_size + 1,
505  mb = GNUNET_malloc (sizeof(struct MigrationReadyBlock) + size);
506  mb->query = *key;
507  mb->expiration = expiration;
508  mb->size = size;
509  mb->type = type;
510  GNUNET_memcpy (&mb[1], data, size);
512  mig_tail,
513  mig_tail,
514  mb);
515  mig_size++;
516  for (pos = peer_head; NULL != pos; pos = pos->next)
517  {
519  "Preparing to push best content to peer %s\n",
521  if ((NULL == pos->env) &&
522  (GNUNET_YES == transmit_content (pos,
523  mb)))
524  {
525  break; /* 'mb' was freed! */
526  }
527  }
529 }
@ GNUNET_BLOCK_TYPE_FS_ONDEMAND
Type of a block representing a block to be encoded on demand from disk.
static char * expiration
Credential TTL.
Definition: gnunet-abd.c:96
static unsigned int replication
struct GNUNET_HashCode key
The key used in the DHT.
static unsigned int anonymity
uint32_t data
The data value.
const struct GNUNET_PeerIdentity * GSF_connected_peer_get_identity2_(const struct GSF_ConnectedPeer *cp)
Obtain the identity of a connected peer.
int GNUNET_FS_handle_on_demand_block(const struct GNUNET_HashCode *key, uint32_t size, const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority, uint32_t anonymity, uint32_t replication, struct GNUNET_TIME_Absolute expiration, uint64_t uid, GNUNET_DATASTORE_DatumProcessor cont, void *cont_cls)
We've received an on-demand encoded block from the datastore.
static struct MigrationReadyPeer * peer_head
Head of linked list of peers.
#define MIN_MIGRATION_CONTENT_LIFETIME
How long must content remain valid for us to consider it for migration? If content will expire too so...
#define GNUNET_CONTAINER_DLL_insert_after(head, tail, other, element)
Insert an element into a DLL after the given other element.
@ GNUNET_OK
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_malloc(size)
Wrapper around malloc.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:405
static unsigned int size
Size of the "table".
Definition: peer.c:68
struct MigrationReadyPeer * next
This is a doubly-linked list.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model

References anonymity, consider_gathering(), data, MigrationReadyPeer::env, expiration, MigrationReadyBlock::expiration, GNUNET_BLOCK_TYPE_FS_ONDEMAND, GNUNET_CONTAINER_DLL_insert_after, GNUNET_ERROR_TYPE_DEBUG, GNUNET_FS_handle_on_demand_block(), GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_OK, GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, GSF_connected_peer_get_identity2_(), key, MAX_MIGRATION_QUEUE, mig_head, mig_qe, mig_size, mig_tail, MIN_MIGRATION_CONTENT_LIFETIME, MigrationReadyPeer::next, MigrationReadyPeer::peer, peer_head, MigrationReadyBlock::query, replication, MigrationReadyBlock::size, size, transmit_content(), MigrationReadyBlock::type, type, and value_found.

Referenced by gather_migration_blocks().

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

◆ GSF_push_start_()

void GSF_push_start_ ( struct GSF_ConnectedPeer peer)

A peer connected to us.

A peer connected to us or we are now again allowed to push content.

Start pushing content to this peer.

Parameters
peerhandle for the peer that connected

Definition at line 567 of file gnunet-service-fs_push.c.

568 {
569  struct MigrationReadyPeer *mrp;
570 
571  if (GNUNET_YES != enabled)
572  return;
573  for (mrp = peer_head; NULL != mrp; mrp = mrp->next)
574  if (mrp->peer == peer)
575  break;
576  if (NULL != mrp)
577  {
578  /* same peer added twice, must not happen */
579  GNUNET_break (0);
580  return;
581  }
582 
584  "Adding peer %s to list for pushing\n",
586 
587  mrp = GNUNET_new (struct MigrationReadyPeer);
588  mrp->peer = peer;
589  find_content (mrp);
591  peer_tail,
592  mrp);
593 }
static int enabled
Is this module enabled?
static struct MigrationReadyPeer * peer_tail
Tail of linked list of peers.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.

References enabled, find_content(), GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_YES, GSF_connected_peer_get_identity2_(), MigrationReadyPeer::next, MigrationReadyPeer::peer, peer, peer_head, and peer_tail.

Referenced by peer_respect_cb(), and revive_migration().

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

◆ GSF_push_stop_()

void GSF_push_stop_ ( struct GSF_ConnectedPeer peer)

A peer disconnected from us.

A peer disconnected from us or asked us to stop pushing content for a while.

Stop pushing content to this peer.

Parameters
peerhandle for the peer that disconnected

Definition at line 603 of file gnunet-service-fs_push.c.

604 {
605  struct MigrationReadyPeer *pos;
606 
607  for (pos = peer_head; NULL != pos; pos = pos->next)
608  if (pos->peer == peer)
609  break;
610  if (NULL == pos)
611  return;
612  if (NULL != pos->env)
613  GNUNET_MQ_send_cancel (pos->env);
615  peer_tail,
616  pos);
617  GNUNET_free (pos);
618 }
void GNUNET_MQ_send_cancel(struct GNUNET_MQ_Envelope *ev)
Cancel sending the message.
Definition: mq.c:768

References MigrationReadyPeer::env, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_send_cancel(), MigrationReadyPeer::next, MigrationReadyPeer::peer, peer, peer_head, and peer_tail.

Referenced by GSF_peer_disconnect_handler(), and handle_p2p_migration_stop().

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

◆ GSF_push_init_()

void GSF_push_init_ ( void  )

Setup the module.

Definition at line 625 of file gnunet-service-fs_push.c.

626 {
627  enabled =
629  "FS",
630  "CONTENT_PUSHING");
631  if (GNUNET_YES != enabled)
632  return;
633 
634  if (GNUNET_OK !=
636  "fs",
637  "MIN_MIGRATION_DELAY",
639  {
641  "fs",
642  "MIN_MIGRATION_DELAY",
643  _ ("time required, content pushing disabled"));
644  return;
645  }
647 }
const struct GNUNET_CONFIGURATION_Handle * GSF_cfg
Our configuration.
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.
void GNUNET_log_config_invalid(enum GNUNET_ErrorType kind, const char *section, const char *option, const char *required)
Log error message about invalid configuration option value.
@ GNUNET_ERROR_TYPE_WARNING
#define _(String)
GNU gettext support macro.
Definition: platform.h:178

References _, consider_gathering(), enabled, GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log_config_invalid(), GNUNET_OK, GNUNET_YES, GSF_cfg, and min_migration_delay.

Referenced by run().

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

◆ GSF_push_done_()

void GSF_push_done_ ( void  )

Shutdown the module.

Definition at line 654 of file gnunet-service-fs_push.c.

655 {
656  if (NULL != mig_task)
657  {
659  mig_task = NULL;
660  }
661  if (NULL != mig_qe)
662  {
664  mig_qe = NULL;
665  }
666  while (NULL != mig_head)
668  GNUNET_assert (0 == mig_size);
669 }
void GNUNET_DATASTORE_cancel(struct GNUNET_DATASTORE_QueueEntry *qe)
Cancel a datastore operation.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975

References delete_migration_block(), GNUNET_assert, GNUNET_DATASTORE_cancel(), GNUNET_SCHEDULER_cancel(), mig_head, mig_qe, mig_size, and mig_task.

Referenced by shutdown_task().

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

Variable Documentation

◆ mig_head

struct MigrationReadyBlock* mig_head
static

Head of linked list of blocks that can be migrated.

Definition at line 134 of file gnunet-service-fs_push.c.

Referenced by delete_migration_block(), find_content(), GSF_push_done_(), and process_migration_content().

◆ mig_tail

struct MigrationReadyBlock* mig_tail
static

Tail of linked list of blocks that can be migrated.

Definition at line 139 of file gnunet-service-fs_push.c.

Referenced by delete_migration_block(), and process_migration_content().

◆ peer_head

struct MigrationReadyPeer* peer_head
static

Head of linked list of peers.

Definition at line 144 of file gnunet-service-fs_push.c.

Referenced by GSF_push_start_(), GSF_push_stop_(), and process_migration_content().

◆ peer_tail

struct MigrationReadyPeer* peer_tail
static

Tail of linked list of peers.

Definition at line 149 of file gnunet-service-fs_push.c.

Referenced by GSF_push_start_(), and GSF_push_stop_().

◆ mig_qe

struct GNUNET_DATASTORE_QueueEntry* mig_qe
static

Request to datastore for migration (or NULL).

Definition at line 154 of file gnunet-service-fs_push.c.

Referenced by consider_gathering(), gather_migration_blocks(), GSF_push_done_(), and process_migration_content().

◆ mig_task

struct GNUNET_SCHEDULER_Task* mig_task
static

ID of task that collects blocks for migration.

Definition at line 159 of file gnunet-service-fs_push.c.

Referenced by consider_gathering(), gather_migration_blocks(), and GSF_push_done_().

◆ min_migration_delay

struct GNUNET_TIME_Relative min_migration_delay
static

What is the maximum frequency at which we are allowed to poll the datastore for migration content?

Definition at line 159 of file gnunet-service-fs_push.c.

Referenced by consider_gathering(), and GSF_push_init_().

◆ mig_size

unsigned int mig_size
static

Size of the doubly-linked list of migration blocks.

Definition at line 170 of file gnunet-service-fs_push.c.

Referenced by consider_gathering(), delete_migration_block(), find_content(), gather_migration_blocks(), GSF_push_done_(), and process_migration_content().

◆ enabled

int enabled
static

Is this module enabled?

Definition at line 175 of file gnunet-service-fs_push.c.

Referenced by GSF_push_init_(), and GSF_push_start_().

◆ value_found

int value_found
static

Did we find anything in the datastore?

Definition at line 180 of file gnunet-service-fs_push.c.

Referenced by consider_gathering(), gather_migration_blocks(), and process_migration_content().