GNUnet  0.20.0
gnunet-service-fs_pe.h File Reference

API to manage query plan. More...

Include dependency graph for gnunet-service-fs_pe.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

void GSF_plan_add_ (struct GSF_ConnectedPeer *cp, struct GSF_PendingRequest *pr)
 Create a new query plan entry. More...
 
void GSF_plan_notify_peer_disconnect_ (const struct GSF_ConnectedPeer *cp)
 Notify the plan about a peer being no longer available; destroy all entries associated with this peer. More...
 
void GSF_plan_notify_request_done_ (struct GSF_PendingRequest *pr)
 Notify the plan about a request being done; destroy all entries associated with this request. More...
 
int GSF_request_plan_reference_get_last_transmission_ (struct GSF_PendingRequestPlanBijection *pr_head, struct GSF_ConnectedPeer *sender, struct GNUNET_TIME_Absolute *result)
 Get the last transmission attempt time for the request plan list referenced by 'rpr_head', that was sent to 'sender'. More...
 
void GSF_plan_init (void)
 Initialize plan subsystem. More...
 
void GSF_plan_done (void)
 Shutdown plan subsystem. More...
 

Detailed Description

API to manage query plan.

Author
Christian Grothoff

Definition in file gnunet-service-fs_pe.h.

Function Documentation

◆ GSF_plan_add_()

void GSF_plan_add_ ( struct GSF_ConnectedPeer cp,
struct GSF_PendingRequest pr 
)

Create a new query plan entry.

Parameters
cppeer with the entry
prrequest with the entry

Definition at line 557 of file gnunet-service-fs_pe.c.

559 {
560  const struct GNUNET_PeerIdentity *id;
561  struct PeerPlan *pp;
562  struct GSF_PendingRequestData *prd;
563  struct GSF_RequestPlan *rp;
565  struct MergeContext mpc;
566 
569  GNUNET_assert (NULL != cp);
572  if (NULL == pp)
573  {
574  pp = GNUNET_new (struct PeerPlan);
576  pp->priority_heap =
578  pp->delay_heap =
580  pp->cp = cp;
583  id,
584  pp,
587  pp);
588  }
589  mpc.merged = GNUNET_NO;
590  mpc.pr = pr;
593  &prd->query,
594  &merge_pr,
595  &mpc);
596  if (GNUNET_NO != mpc.merged)
597  return;
598  plan_count++;
600  gettext_noop ("# query plan entries"),
601  1,
602  GNUNET_NO);
604  "Planning transmission of query `%s' to peer `%s'\n",
605  GNUNET_h2s (&prd->query),
606  GNUNET_i2s (id));
607  rp = GNUNET_new (struct GSF_RequestPlan);
609  bi->rp = rp;
610  bi->pr = pr;
612  prd->pr_head,
613  prd->pr_tail,
614  bi);
616  rp->pe_head,
617  rp->pe_tail,
618  bi);
619  rp->pp = pp;
622  get_rp_key (rp),
623  rp,
625  plan (pp,
626  rp);
627 }
#define gettext_noop(String)
Definition: gettext.h:70
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
static char * rp
Relying party.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
const struct GNUNET_PeerIdentity * GSF_connected_peer_get_identity2_(const struct GSF_ConnectedPeer *cp)
Obtain the identity of a connected peer.
static unsigned long long plan_count
Number of plan entries.
static int merge_pr(void *cls, const struct GNUNET_HashCode *query, void *element)
Iterator that checks if an equivalent request is already present for this peer.
static const struct GNUNET_HashCode * get_rp_key(struct GSF_RequestPlan *rp)
Return the query (key in the plan_map) for the given request plan.
static void schedule_peer_transmission(void *cls)
Figure out when and how to transmit to the given peer.
static struct GNUNET_CONTAINER_MultiPeerMap * plans
Hash map from peer identities to PeerPlans.
static void plan(struct PeerPlan *pp, struct GSF_RequestPlan *rp)
Insert the given request plan into the heap with the appropriate weight.
int GSF_pending_request_test_active_(struct GSF_PendingRequest *pr)
Check if the given request is still active.
struct GSF_PendingRequestData * GSF_pending_request_get_data_(struct GSF_PendingRequest *pr)
Obtain the public data associated with a pending request.
#define GNUNET_CONTAINER_MDLL_insert(mdll, head, tail, element)
Insert an element at the head of a MDLL.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
struct GNUNET_CONTAINER_Heap * GNUNET_CONTAINER_heap_create(enum GNUNET_CONTAINER_HeapOrder order)
Create a new heap.
@ GNUNET_CONTAINER_HEAP_ORDER_MIN
Heap with the minimum cost at the root.
@ GNUNET_CONTAINER_HEAP_ORDER_MAX
Heap with the maximum cost at the root.
#define GNUNET_log(kind,...)
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
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:1299
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
The identity of the host (wraps the signing key of the peer).
Public data (in the sense of not encapsulated within 'gnunet-service-fs_pr', not in the sense of netw...
struct GSF_PendingRequestPlanBijection * pr_head
Fields for the plan module to track a DLL with the request.
struct GSF_PendingRequestPlanBijection * pr_tail
Fields for the plan module to track a DLL with the request.
struct GNUNET_HashCode query
Primary query hash for this request.
M:N binding of plans to pending requests.
struct GSF_PendingRequest * pr
Associated pending request (identifies request details and one of the origins of the request).
struct GSF_RequestPlan * rp
Associated request plan (tells us one of the peers that we plan to forward the request to).
Information we keep per request per peer.
Closure for merge_pr().
struct GSF_PendingRequest * pr
Request we are trying to merge.
Transmission plan for a peer.
struct GNUNET_SCHEDULER_Task * task
Current task for executing the plan.
struct GNUNET_CONTAINER_Heap * priority_heap
Heap with pending queries (struct GSF_RequestPlan), higher weights mean higher priority.
struct GNUNET_CONTAINER_MultiHashMap * plan_map
Map of queries to plan entries.
struct GNUNET_CONTAINER_Heap * delay_heap
Heap with pending queries (struct GSF_RequestPlan), by transmission time, lowest first.
struct GSF_ConnectedPeer * cp
Peer for which this is the plan.

References PeerPlan::cp, PeerPlan::delay_heap, get_rp_key(), gettext_noop, GNUNET_assert, GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_HEAP_ORDER_MAX, GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_CONTAINER_MDLL_insert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_update(), GNUNET_YES, GSF_connected_peer_get_identity2_(), GSF_pending_request_get_data_(), GSF_pending_request_test_active_(), GSF_stats, id, merge_pr(), MergeContext::merged, plan(), plan_count, PeerPlan::plan_map, plans, GSF_PendingRequestPlanBijection::pr, MergeContext::pr, GSF_PendingRequestData::pr_head, GSF_PendingRequestData::pr_tail, PeerPlan::priority_heap, GSF_PendingRequestData::query, GSF_PendingRequestPlanBijection::rp, rp, schedule_peer_transmission(), and PeerPlan::task.

Referenced by consider_peer_for_forwarding(), and consider_request_for_forwarding().

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

◆ GSF_plan_notify_peer_disconnect_()

void GSF_plan_notify_peer_disconnect_ ( const struct GSF_ConnectedPeer cp)

Notify the plan about a peer being no longer available; destroy all entries associated with this peer.

Parameters
cpconnected peer

Definition at line 637 of file gnunet-service-fs_pe.c.

638 {
639  const struct GNUNET_PeerIdentity *id;
640  struct PeerPlan *pp;
641  struct GSF_RequestPlan *rp;
642  struct GSF_PendingRequestData *prd;
644 
647  if (NULL == pp)
648  return; /* nothing was ever planned for this peer */
651  pp));
652  if (NULL != pp->task)
653  {
655  pp->task = NULL;
656  }
657  while (NULL != (rp = GNUNET_CONTAINER_heap_remove_root (pp->priority_heap)))
658  {
661  get_rp_key (rp),
662  rp));
663  while (NULL != (bi = rp->pe_head))
664  {
666  rp->pe_head,
667  rp->pe_tail,
668  bi);
669  prd = GSF_pending_request_get_data_ (bi->pr);
671  prd->pr_head,
672  prd->pr_tail,
673  bi);
674  GNUNET_free (bi);
675  }
676  plan_count--;
677  GNUNET_free (rp);
678  }
680  while (NULL != (rp = GNUNET_CONTAINER_heap_remove_root (pp->delay_heap)))
681  {
684  get_rp_key (rp),
685  rp));
686  while (NULL != (bi = rp->pe_head))
687  {
688  prd = GSF_pending_request_get_data_ (bi->pr);
690  rp->pe_head,
691  rp->pe_tail,
692  bi);
694  prd->pr_head,
695  prd->pr_tail,
696  bi);
697  GNUNET_free (bi);
698  }
699  plan_count--;
700  GNUNET_free (rp);
701  }
703  gettext_noop ("# query plan entries"),
704  plan_count,
705  GNUNET_NO);
708  GNUNET_free (pp);
709 }
#define GNUNET_CONTAINER_MDLL_remove(mdll, head, tail, element)
Remove an element from a MDLL.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
void * GNUNET_CONTAINER_heap_remove_root(struct GNUNET_CONTAINER_Heap *heap)
Remove root of the heap.
void GNUNET_CONTAINER_heap_destroy(struct GNUNET_CONTAINER_Heap *heap)
Destroys the heap.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.

References PeerPlan::delay_heap, get_rp_key(), gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_heap_remove_root(), GNUNET_CONTAINER_MDLL_remove, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), GNUNET_YES, GSF_connected_peer_get_identity2_(), GSF_pending_request_get_data_(), GSF_stats, id, plan_count, PeerPlan::plan_map, plans, GSF_PendingRequestPlanBijection::pr, GSF_PendingRequestData::pr_head, GSF_PendingRequestData::pr_tail, PeerPlan::priority_heap, rp, and PeerPlan::task.

Referenced by GSF_peer_disconnect_handler().

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

◆ GSF_plan_notify_request_done_()

void GSF_plan_notify_request_done_ ( struct GSF_PendingRequest pr)

Notify the plan about a request being done; destroy all entries associated with this request.

Parameters
prrequest that is done

Definition at line 754 of file gnunet-service-fs_pe.c.

755 {
756  struct GSF_RequestPlan *rp;
757  struct GSF_PendingRequestData *prd;
759 
761  while (NULL != (bi = prd->pr_head))
762  {
763  rp = bi->rp;
765  prd->pr_head,
766  prd->pr_tail,
767  bi);
769  rp->pe_head,
770  rp->pe_tail,
771  bi);
772  GNUNET_assert (bi->pr == pr);
773  if (NULL == rp->pe_head)
774  {
776  plan_count--;
779  &prd->query,
780  rp));
781  GNUNET_free (rp);
782  }
783  GNUNET_free (bi);
784  }
786  gettext_noop ("# query plan entries"),
787  plan_count,
788  GNUNET_NO);
789 }
void * GNUNET_CONTAINER_heap_remove_node(struct GNUNET_CONTAINER_HeapNode *node)
Removes a node from the heap.

References gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_MDLL_remove, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_YES, GSF_pending_request_get_data_(), GSF_stats, plan_count, GSF_PendingRequestPlanBijection::pr, GSF_PendingRequestData::pr_head, GSF_PendingRequestData::pr_tail, GSF_PendingRequestData::query, GSF_PendingRequestPlanBijection::rp, and rp.

Referenced by clean_request(), and GSF_pending_request_cancel_().

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

◆ GSF_request_plan_reference_get_last_transmission_()

int GSF_request_plan_reference_get_last_transmission_ ( struct GSF_PendingRequestPlanBijection pr_head,
struct GSF_ConnectedPeer sender,
struct GNUNET_TIME_Absolute result 
)

Get the last transmission attempt time for the request plan list referenced by 'rpr_head', that was sent to 'sender'.

Parameters
pr_headrequest plan reference list to check.
senderthe peer that we've sent the request to.
resultthe timestamp to fill.
Returns
GNUNET_YES if 'result' was changed, GNUNET_NO otherwise.

Get the last transmission attempt time for the request plan list referenced by 'rpr_head', that was sent to 'sender'.

Parameters
pr_headrequest plan reference list to check.
senderthe peer that we've sent the request to.
resultthe timestamp to fill, set to GNUNET_TIME_UNIT_FOREVER_ABS if never transmitted
Returns
GNUNET_YES if result was changed, GNUNET_NO otherwise.

Definition at line 722 of file gnunet-service-fs_pe.c.

729 {
731 
732  for (bi = pr_head; NULL != bi; bi = bi->next_PR)
733  {
734  if (bi->rp->pp->cp == sender)
735  {
736  if (0 == bi->rp->last_transmission.abs_value_us)
738  else
739  *result = bi->rp->last_transmission;
740  return GNUNET_YES;
741  }
742  }
743  return GNUNET_NO;
744 }
static int result
Global testing status.
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
uint64_t abs_value_us
The actual value.
struct GSF_PendingRequestPlanBijection * next_PR
This is a doubly-linked list.
struct PeerPlan * pp
The transmission plan for a peer that this request is associated with.
struct GNUNET_TIME_Absolute last_transmission
When was the last time we transmitted this request to this peer? 0 for never.

References GNUNET_TIME_Absolute::abs_value_us, PeerPlan::cp, GNUNET_NO, GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_YES, GSF_RequestPlan::last_transmission, GSF_PendingRequestPlanBijection::next_PR, GSF_RequestPlan::pp, result, and GSF_PendingRequestPlanBijection::rp.

◆ GSF_plan_init()

void GSF_plan_init ( void  )

Initialize plan subsystem.

Definition at line 796 of file gnunet-service-fs_pe.c.

797 {
799  GNUNET_YES);
800 }
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).

References GNUNET_CONTAINER_multipeermap_create(), GNUNET_YES, and plans.

Referenced by run().

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

◆ GSF_plan_done()

void GSF_plan_done ( void  )

Shutdown plan subsystem.

Definition at line 807 of file gnunet-service-fs_pe.c.

808 {
811 }
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.

References GNUNET_assert, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_size(), and plans.

Referenced by shutdown_task().

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