Handle arbitrary data items during session initialization

Before, only metrics and IP data items could be sent to peers
during session initialization.  Extensions may want to pass other
data items, so now anything is handled.

Author: davidpwiggins

DlepService.h

@@ -143,13 +143,14 @@ class DlepService
     virtual ReturnStatus destination_down(const DlepMac & mac_address,
                               const DataItems & data_items = DataItems()) = 0;
 
-    /// Notify the DLEP service that the local peer's metrics or IP
-    /// addresses have changed.
+    /// Notify the DLEP service that the local peer's metrics, IP
+    /// addresses, and other data items have changed.
     ///
     /// The DLEP service will issue a Peer Update to the peer with the
     /// new information.  If there is no extant peer session, the DLEP
-    /// protocol remembers the metrics/addresses so that they can be
-    /// sent to a future peer.
+    /// protocol remembers the data items so that they can be
+    /// sent to a future peer.  The set of data items so remembered is
+    /// referred to as the set of session initialization data items.
     ///
     /// @param[in] data_items
     ///            data items (metrics and IP addresses) associated with
@@ -158,6 +159,21 @@ class DlepService
     /// @return ok if no error, else as described in DlepService::ReturnStatus
     virtual ReturnStatus peer_update(const DataItems & data_items) = 0;
 
+    /// Remove data items that were previously given in a peer_update().
+    ///
+    /// The specified data items are removed from DLEP service's
+    /// session initialization data items.  Future peers will not see
+    /// these data items sent during session initialization.  This
+    /// does not issue a Peer Update to the peer.
+    ///
+    /// @param[in] data_items
+    ///            data items associated with the local peer to be removed
+    ///
+    /// @return ok if no error, else as described in DlepService::ReturnStatus
+    /// It is not an error to specify a data item that is not in the DlepService's
+    /// set of session initialization data items.
+    virtual ReturnStatus peer_remove_data_items(const DataItems & data_items) = 0;
+
     /// Get a list of all existing peer ids.
     ///
     /// @param[out] peers

DlepServiceImpl.cpp

@@ -1,7 +1,7 @@
 /*
  * Dynamic Link Exchange Protocol (DLEP)
  *
- * Copyright (C) 2015, 2016, 2018 Massachusetts Institute of Technology
+ * Copyright (C) 2015, 2016, 2018, 2019 Massachusetts Institute of Technology
  */
 
 /// @file
@@ -276,6 +276,15 @@ DlepServiceImpl::peer_update(const LLDLEP::DataItems & data_items)
     }
 }
 
+DlepServiceImpl::ReturnStatus
+DlepServiceImpl::peer_remove_data_items(const DataItems & data_items)
+{
+    boost::recursive_mutex::scoped_lock lock(dlep->mutex);
+
+    dlep->local_pdp->remove_data_items(data_items);
+    return ReturnStatus::ok;
+}
+
 DlepServiceImpl::ReturnStatus
 DlepServiceImpl::get_peers(std::vector<std::string> & peers)
 {

DlepServiceImpl.h

@@ -42,6 +42,8 @@ class DlepServiceImpl : public LLDLEP::DlepService
 
     ReturnStatus peer_update(const LLDLEP::DataItems & data_items) override;
 
+    ReturnStatus peer_remove_data_items(const DataItems & data_items) override;
+
     ReturnStatus get_peers(std::vector<std::string> & peers) override;
 
     ReturnStatus get_peer_info(const std::string & peer_id,

InfoBaseMgr.cpp

@@ -1,7 +1,7 @@
 /*
  * Dynamic Link Exchange Protocol (DLEP)
  *
- * Copyright (C) 2013, 2015, 2016, 2018 Massachusetts Institute of Technology
+ * Copyright (C) 2013, 2015, 2016, 2018, 2019 Massachusetts Institute of Technology
  */
 #include "InfoBaseMgr.h"
 
@@ -212,22 +212,49 @@ PeerData::PeerData(const std::string & id, const DataItems & initial_data_items,
     dlep(dlep),
     logger(dlep->logger)
 {
-    for (auto const & di : initial_data_items)
+    (void)update_data_items_helper(initial_data_items, dlep);
+}
+
+PeerData::~PeerData()
+{
+}
+
+DataItems
+PeerData::update_data_items_helper(const DataItems & data_items,
+                                   DlepPtr dlep)
+{
+    // We don't need to remember the Status data item because it is
+    // transient/throwaway state.  We'll remember all the other data
+    // items, though.
+    DataItemIdType status_id =
+        dlep->protocfg->get_data_item_id(ProtocolStrings::Status);
+
+    // Gather up the data items that might need to be sent to all
+    // destinations here.
+    DataItems destination_updates;
+
+    for (auto const & di : data_items)
     {
         if (dlep->protocfg->is_metric(di.id))
         {
             metric_data_items[di.id] = di;
+            destination_updates.push_back(di);
         }
         else if (dlep->protocfg->is_ipaddr(di.id))
         {
             update_ip_data_items("peer=" + peer_id,
                                  ip_data_items, di, logger);
+
+            // IP addresses don't propagate to all destinations,
+            // so don't add this di to destination_updates
         }
-    }
-}
+        else if (di.id != status_id)
+        {
+            other_data_items.push_back(di);
+        }
+    } // for each data item
 
-PeerData::~PeerData()
-{
+    return destination_updates;
 }
 
 bool
@@ -416,23 +443,7 @@ PeerData::update_data_items(const DataItems & updates, bool tell_peers)
     // If we get here, the data items are all OK, so we can apply the changes.
 
     // Collect updates to apply to all destinations here
-    DataItems destination_updates;
-
-    for (auto const & di : updates)
-    {
-        if (dlep->protocfg->is_metric(di.id))
-        {
-            metric_data_items[di.id] = di;
-            destination_updates.push_back(di);
-        }
-        else if (dlep->protocfg->is_ipaddr(di.id))
-        {
-            update_ip_data_items("peer=" + peer_id,
-                                 ip_data_items, di, logger);
-
-            // IP addresses don't propagate to all destinations
-        }
-    } // for each data item in updates
+    DataItems destination_updates = update_data_items_helper(updates, dlep);
 
     if (!destination_updates.empty())
     {
@@ -466,6 +477,41 @@ PeerData::update_data_items(const DataItems & updates, bool tell_peers)
     return ProtocolStrings::Success;
 }
 
+void
+PeerData::remove_data_items(const DataItems & data_items)
+{
+    for (const auto & di : data_items)
+    {
+        auto it1 = metric_data_items.find(di.id);
+        if (it1 != metric_data_items.end())
+        {
+            if (it1->second == di)
+            {
+                metric_data_items.erase(it1);
+                continue;
+            }
+        }
+
+        auto it2 = std::find(ip_data_items.begin(),
+                             ip_data_items.end(), di);
+        if (it2 != ip_data_items.end())
+        {
+            ip_data_items.erase(it2);
+            continue;
+        }
+
+
+        auto it3 = std::find(other_data_items.begin(),
+                             other_data_items.end(), di);
+        if (it3 != other_data_items.end())
+        {
+            other_data_items.erase(it3);
+            continue;
+        }
+    }
+}
+
+
 DataItems
 PeerData::get_data_items()
 {
@@ -481,6 +527,11 @@ PeerData::get_data_items()
         return_data_items.push_back(di);
     }
 
+    for (auto const & di : other_data_items)
+    {
+        return_data_items.push_back(di);
+    }
+
     return return_data_items;
 }
 
@@ -507,6 +558,12 @@ PeerData::log_data_items()
         msg << di.to_string();
         LOG(DLEP_LOG_DEBUG, msg);
     }
+
+    for (auto const & di : other_data_items)
+    {
+        msg << di.to_string();
+        LOG(DLEP_LOG_DEBUG, msg);
+    }
 }
 
 void

InfoBaseMgr.h

@@ -1,7 +1,7 @@
 /*
  * Dynamic Link Exchange Protocol (DLEP)
  *
- * Copyright (C) 2013, 2015, 2016 Massachusetts Institute of Technology
+ * Copyright (C) 2013, 2015, 2016, 2019 Massachusetts Institute of Technology
  */
 #ifndef _INFO_BASE_MGR_
 #define _INFO_BASE_MGR_
@@ -18,6 +18,7 @@
 #include <map>
 #include <vector>
 #include <iterator>
+#include <algorithm>
 #include <libxml/xmlmemory.h>
 #include <libxml/parser.h>
 #include <boost/thread/recursive_mutex.hpp>
@@ -135,6 +136,7 @@ class PeerData
 
     std::string update_data_items(const LLDLEP::DataItems & updates,
                                   bool tell_peers);
+    void remove_data_items(const DataItems & data_items);
     LLDLEP::DataItems get_data_items();
 
     /// Get a list of all of this peer's data items containing
@@ -154,22 +156,32 @@ class PeerData
     std::string find_ip_data_item(const DataItem & ip_data_item) const;
 
 private:
+
+    DataItems update_data_items_helper(const DataItems & data_items,
+                                       DlepPtr dlep);
+
     /// peer_id is a combination of the TCP remote IP and port of the session
     std::string peer_id;
 
     /// Map destination mac to Destination Data
     std::map<LLDLEP::DlepMac, DestinationDataPtr> destination_data;
 
+    /// The combination of the metric_data_items, ip_data_items, and
+    /// other_data_items fields below constitute the set of session
+    /// initialization data items referred to in the DlepService API.
+
     /// Metric data items that this peer supports, and their default
     /// values.  Only one data item per metric type is allowed, so
     /// this is a map.
     DataItemMap metric_data_items;
 
-    /// IP address data items associated with this destination.
-    /// There can be multiple IP addresses of each type, so this
-    /// is a vector.
+    /// IP address data items associated with this peer.  There can be
+    /// multiple IP addresses of each type, so this is a vector.
     DataItems ip_data_items;
 
+    // Other data items associated with this peer.
+    DataItems other_data_items;
+
     /// back-pointer to dlep instance
     DlepPtr dlep;
 

Peer.cpp

@@ -1069,10 +1069,13 @@ Peer::send_peer_initialization_response()
 
     pm.add_allowed_data_items(dlep->local_pdp->get_data_items());
 
-    // A freshly built message should be parsable.
+    // A freshly built message should be parsable.  However, this
+    // message contains data items that originated from the client, and
+    // they could be invalid.  So we parse and validate the message before
+    // sending so that problems get logged, but we don't do anything
+    // drastic (assert/throw/exit) if it fails.
 
-    std::string err = pm.parse_and_validate(dlep->is_modem(), __func__);
-    assert(err == "");
+    pm.parse_and_validate(dlep->is_modem(), __func__);
 
     if (should_send_response(ProtocolStrings::Session_Initialization_Response))
     {
@@ -1288,10 +1291,10 @@ Peer::handle_peer_initialization_response(ProtocolMessage & pm)
         /* no-op */
     }
 
-    DataItems metrics_and_ip_items = pm.get_metrics_and_ipaddrs();
+    DataItems data_items = pm.get_data_items();
 
-    peer_pdp = dlep->info_base_manager->addPeer(peer_id,
-                                                metrics_and_ip_items);
+    // filter out Status
+    peer_pdp = dlep->info_base_manager->addPeer(peer_id, data_items);
 
     // Now that we've received a PEER_INITIALIZATION_Response,
     // we consider this session to be up.
@@ -1301,7 +1304,7 @@ Peer::handle_peer_initialization_response(ProtocolMessage & pm)
 
     LLDLEP::PeerInfo peer_info;
     get_info(peer_info);
-    peer_info.data_items = metrics_and_ip_items;
+    peer_info.data_items = data_items;
     dlep->dlep_client.peer_up(peer_info);
 
     // Send the peer all of our destinations

tests/TestClientImpl.h

@@ -164,6 +164,9 @@ class TestClientImpl : public LLDLEP::DlepClient
             cv.notify_one();
         }
 
+        /// Return the information recorded in notify().
+        T get_result() { return result; }
+
         /// Compare the information recorded in notify() with the expected result.
         /// @return true if they are equal, else false
         bool check_result(const T & expected_result)