stuff

1 files changed, 153 insertions, 52 deletions

diff --git a/src/fs/gnunet-service-fs_cp.h b/src/fs/gnunet-service-fs_cp.h
index f6d6e7a0a..8886199b5 100644
--- a/src/fs/gnunet-service-fs_cp.h
+++ b/src/fs/gnunet-service-fs_cp.h
@@ -30,16 +30,90 @@
 
 
 /**
- * A peer connected to us.  Setup the connected peer
- * records.
+ * Performance data kept for a peer.
+ */
+struct GSF_PeerPerformanceData
+{
+
+  /**
+   * Transport performance data.
+   */
+  struct GNUNET_TRANSPORT_ATS_Information *atsi;
+
+  /**
+   * List of the last clients for which this peer successfully
+   * answered a query.
+   */
+  struct GSF_LocalClient *last_client_replies[CS2P_SUCCESS_LIST_SIZE];
+
+  /**
+   * List of the last PIDs for which
+   * this peer successfully answered a query;
+   * We use 0 to indicate no successful reply.
+   */
+  GNUNET_PEER_Id last_p2p_replies[P2P_SUCCESS_LIST_SIZE];
+
+  /**
+   * Average delay between sending the peer a request and
+   * getting a reply (only calculated over the requests for
+   * which we actually got a reply).   Calculated
+   * as a moving average: new_delay = ((n-1)*last_delay+curr_delay) / n
+   */ 
+  struct GNUNET_TIME_Relative avg_reply_delay;
+
+  /**
+   * Point in time until which this peer does not want us to migrate content
+   * to it.
+   */
+  struct GNUNET_TIME_Absolute migration_blocked_until;
+
+  /**
+   * Transmission times for the last MAX_QUEUE_PER_PEER
+   * requests for this peer.  Used as a ring buffer, current
+   * offset is stored in 'last_request_times_off'.  If the
+   * oldest entry is more recent than the 'avg_delay', we should
+   * not send any more requests right now.
+   */
+  struct GNUNET_TIME_Absolute last_request_times[MAX_QUEUE_PER_PEER];
+
+  /**
+   * How long does it typically take for us to transmit a message
+   * to this peer?  (delay between the request being issued and
+   * the callback being invoked).
+   */
+  struct GNUNET_LOAD_Value *transmission_delay;
+
+  /**
+   * Average priority of successful replies.  Calculated
+   * as a moving average: new_avg = ((n-1)*last_avg+curr_prio) / n
+   */
+  double avg_priority;
+
+  /**
+   * Number of pending queries (replies are not counted)
+   */
+  unsigned int pending_queries;
+
+  /**
+   * Number of pending replies (queries are not counted)
+   */
+  unsigned int pending_replies;
+
+};
+
+
+/**
+ * Signature of function called on a connected peer.
  *
- * @param peer identity of peer that connected
- * @param atsi performance data for the connection
- * @return handle to connected peer entry
+ * @param cls closure
+ * @param peer identity of the peer
+ * @param cp handle to the connected peer record
+ * @param perf peer performance data
  */
-struct GSF_ConnectedPeer *
-GSF_peer_connect_handler_ (const struct GNUNET_PeerIdentity *peer,
-                           const struct GNUNET_TRANSPORT_ATS_Information *atsi);
+typedef void (*GSF_ConnectedPeerIterator)(void *cls,
+                                          const struct GNUNET_PeerIdentity *peer,
+                                          struct GSF_ConnectedPeer *cp,
+                                          const struct GSF_PeerPerformanceData *ppd);
 
 
 /**
@@ -56,23 +130,85 @@ typedef size_t (*GSF_GetMessageCallback)(void *cls,
 
 
 /**
+ * Signature of function called on a reservation success or failure.
+ *
+ * @param cls closure
+ * @param cp handle to the connected peer record
+ * @param success GNUNET_YES on success, GNUNET_NO on failure
+ */
+typedef void (*GSF_PeerReserveCallback)(void *cls,
+                                        struct GSF_ConnectedPeer *cp,
+                                        int success);
+
+
+/**
+ * Handle to cancel a transmission request.
+ */
+struct GSF_PeerTransmitHandle;
+
+
+/**
+ * A peer connected to us.  Setup the connected peer
+ * records.
+ *
+ * @param peer identity of peer that connected
+ * @param atsi performance data for the connection
+ * @return handle to connected peer entry
+ */
+struct GSF_ConnectedPeer *
+GSF_peer_connect_handler_ (const struct GNUNET_PeerIdentity *peer,
+                           const struct GNUNET_TRANSPORT_ATS_Information *atsi);
+
+
+/**
  * Transmit a message to the given peer as soon as possible.
  * If the peer disconnects before the transmission can happen,
  * the callback is invoked with a 'NULL' buffer.
  *
  * @param peer target peer
+ * @param is_query is this a query (GNUNET_YES) or content (GNUNET_NO)
+ * @param priority how important is this request?
+ * @param timeout when does this request timeout (call gmc with error)
  * @param size number of bytes we would like to send to the peer
  * @param gmc function to call to get the message
  * @param gmc_cls closure for gmc
+ * @return handle to cancel request
  */
-void
+struct GSF_PeerTransmitHandle *
 GSF_peer_transmit_ (struct GSF_ConnectedPeer *peer,
+                    int is_query,
+                    uint32_t priority,
+                    struct GNUNET_TIME_Relative timeout,
                     size_t size,
                     GSF_GetMessageCallback gmc,
                     void *gmc_cls);
 
 
 /**
+ * Cancel an earlier request for transmission.
+ */
+void
+GSF_peer_transmit_cancel_ (struct GSF_PeerTransmitHandle *pth);
+
+
+/**
+ * Report on receiving a reply; update the performance record of the given peer.
+ *
+ * @param peer responding peer (will be updated)
+ * @param request_time time at which the original query was transmitted
+ * @param request_priority priority of the original request
+ * @param initiator_client local client on responsible for query (or NULL)
+ * @param initiator_peer other peer responsible for query (or NULL)
+ */
+void
+GSF_peer_update_performance_ (struct GSF_ConnectedPeer *peer,
+                              GNUNET_TIME_Absolute request_time,
+                              uint32_t request_priority,
+                              const struct GSF_LocalClient *initiator_client,
+                              const struct GSF_ConnectedPeer *initiator_peer);
+
+
+/**
  * Method called whenever a given peer has a status change.
  *
  * @param cls closure
@@ -105,15 +241,13 @@ GSF_peer_disconnect_handler_ (void *cls,
 
 
 /**
- * Signature of function called on a connected peer.
+ * Notification that a local client disconnected.  Clean up all of our
+ * references to the given handle.
  *
- * @param cls closure
- * @param peer identity of the peer
- * @param cp handle to the connected peer record
+ * @param lc handle to the local client (henceforth invalid)
  */
-typedef void (*GSF_ConnectedPeerIterator)(void *cls,
-                                          const struct GNUNET_PeerIdentity *peer,
-                                          struct GSF_ConnectedPeer *cp);
+void
+GSF_handle_local_client_disconnect_ (const struct GSF_LocalClient *lc);
 
 
 /**
@@ -127,42 +261,9 @@ GSF_iterate_connected_peers_ (GSF_ConnectedPeerIterator it,
                               void *it_cls);
 
 
-/**
- * Register callback to invoke on peer disconnect.
- *
- * @param cp peer to monitor
- * @param it function to call on disconnect
- * @param it_cls closure for it
- */
-void
-GSF_connected_peer_register_disconnect_callback_ (struct GSF_ConnectedPeer *cp,
-                                                  GSF_ConnectedPeerIterator it,
-                                                  void *it_cls);
-
-
-/**
- * Unregister callback to invoke on peer disconnect.
- *
- * @param cp peer to stop monitoring
- * @param it function to no longer call on disconnect
- * @param it_cls closure for it
- */
-void
-GSF_connected_peer_unregister_disconnect_callback_ (struct GSF_ConnectedPeer *cp,
-                                                    GSF_ConnectedPeerIterator it,
-                                                    void *it_cls);
-
-
-/**
- * Signature of function called on a reservation success.
- *
- * @param cls closure
- * @param cp handle to the connected peer record
- */
-typedef void (*GSF_PeerReserveCallback)(void *cls,
-                                        struct GSF_ConnectedPeer *cp);
-
-
+// FIXME: should we allow queueing multiple reservation requests?
+// FIXME: what about cancellation?
+// FIXME: change docu on peer disconnect handling?
 /**
  * Try to reserve bandwidth (to receive data FROM the given peer).
  * This function must only be called ONCE per connected peer at a