1 files changed, 159 insertions, 129 deletions

diff --git a/apps/hiperf/src/common.h b/apps/hiperf/src/common.h
index 3a90f3732..5143afe31 100644
--- a/apps/hiperf/src/common.h
+++ b/apps/hiperf/src/common.h
@@ -15,17 +15,15 @@
 
 #pragma once
 
-#include <forwarder_interface.h>
 #include <hicn/transport/auth/signer.h>
 #include <hicn/transport/config.h>
 #include <hicn/transport/core/content_object.h>
 #include <hicn/transport/core/interest.h>
 #include <hicn/transport/interfaces/global_conf_interface.h>
-#include <hicn/transport/interfaces/p2psecure_socket_consumer.h>
-#include <hicn/transport/interfaces/p2psecure_socket_producer.h>
 #include <hicn/transport/interfaces/socket_consumer.h>
 #include <hicn/transport/interfaces/socket_producer.h>
 #include <hicn/transport/utils/chrono_typedefs.h>
+#include <hicn/transport/utils/color.h>
 #include <hicn/transport/utils/literals.h>
 
 #ifndef _WIN32
@@ -36,6 +34,7 @@
 #include <cmath>
 #include <fstream>
 #include <iomanip>
+#include <iostream>
 #include <sstream>
 #include <string>
 #include <unordered_set>
@@ -53,27 +52,112 @@ using namespace transport::interface;
 using namespace transport::auth;
 using namespace transport::core;
 
-static inline uint64_t _ntohll(const uint64_t *input) {
-  uint64_t return_val;
-  uint8_t *tmp = (uint8_t *)&return_val;
+namespace hiperf {
 
-  tmp[0] = *input >> 56;
-  tmp[1] = *input >> 48;
-  tmp[2] = *input >> 40;
-  tmp[3] = *input >> 32;
-  tmp[4] = *input >> 24;
-  tmp[5] = *input >> 16;
-  tmp[6] = *input >> 8;
-  tmp[7] = *input >> 0;
+/**
+ * Logger
+ */
+static std::ostream &Logger() { return std::cout; }
 
-  return return_val;
-}
+template <typename D, typename ConfType, typename ParentType>
+class Base : protected std::stringbuf, protected std::ostream {
+ protected:
+  static inline const char separator[] = "|   ";
 
-static inline uint64_t _htonll(const uint64_t *input) {
-  return (_ntohll(input));
-}
+  Base(ParentType &parent, asio::io_service &io_service, int identifier)
+      : std::stringbuf(),
+        std::ostream(this),
+        parent_(parent),
+        configuration_(parent_.getConfig()),
+        io_service_(io_service),
+        identifier_(identifier),
+        name_id_(D::getContextType() + std::to_string(identifier_)),
+        flow_name_(configuration_.name_.makeNameWithIndex(identifier_)) {
+    std::stringstream begin;
+    std::stringstream end;
+    if (configuration_.colored_) {
+      begin << color_mod_ << bold_mod_;
+      end << end_mod_;
+    } else {
+      begin << "";
+      end << "";
+    }
 
-namespace hiperf {
+    begin << "|" << name_id_ << separator;
+    begin_ = begin.str();
+    end_ = end.str();
+  }
+
+  Base(Base &&other)
+      : parent_(other.parent_),
+        configuration_(other.configuration_),
+        io_service_(other.io_service_),
+        identifier_(other.identifier_),
+        name_id_(std::move(other.name_id_)),
+        flow_name_(other.flow_name_) {}
+
+  /***************************************************************
+   * std::stringbuf sync override
+   ***************************************************************/
+
+  int sync() override {
+    auto string = str();
+    asio::post(io_service_,
+               [this, string]() { Logger() << begin_ << string << end_; });
+    str("");
+
+    return 0;
+  }
+
+  std::ostream &getOutputStream() { return *this; }
+
+  // Members initialized by the constructor
+  ParentType &parent_;
+  ConfType &configuration_;
+  asio::io_service &io_service_;
+  int identifier_;
+  std::string name_id_;
+  transport::core::Name flow_name_;
+  std::string begin_;
+  std::string end_;
+
+  // Members initialized by the in-class initializer
+  utils::ColorModifier color_mod_;
+  utils::ColorModifier bold_mod_{utils::ColorModifier::Code::BOLD};
+  utils::ColorModifier end_mod_{utils::ColorModifier::Code::RESET};
+};
+
+static inline int ensureFlows(const Prefix &prefix, std::size_t flows) {
+  int ret = ERROR_SUCCESS;
+
+  // Make sure the provided prefix length not allows to accomodate the
+  // provided number of flows.
+  uint16_t max_ip_addr_len_bits;
+  uint16_t log2_n_flow;
+  u64 max_n_flow;
+  if (prefix.getAddressFamily() == AF_INET) {
+    max_ip_addr_len_bits = IPV4_ADDR_LEN_BITS;
+  } else if (prefix.getAddressFamily() == AF_INET6) {
+    max_ip_addr_len_bits = IPV6_ADDR_LEN_BITS;
+  } else {
+    Logger() << "Error: unknown address family." << std::endl;
+    ret = ERROR_SETUP;
+    goto end;
+  }
+
+  log2_n_flow = max_ip_addr_len_bits - prefix.getPrefixLength();
+  max_n_flow = log2_n_flow < 64 ? (1 << log2_n_flow) : ~0ULL;
+
+  if (flows > max_n_flow) {
+    Logger() << "Error: the provided prefix length does not allow to "
+                "accomodate the provided number of flows ("
+             << flows << " > " << max_n_flow << ")." << std::endl;
+    ret = ERROR_SETUP;
+  }
+
+end:
+  return ret;
+}
 
 /**
  * Class to retrieve the maximum payload size given the MTU and packet headers.
@@ -90,8 +174,9 @@ class PayloadSize {
            transport_size - fec_size;
   }
 
-  static Packet::Format getFormatFromName(Name name, bool ah = false) {
-    switch (name.getAddressFamily()) {
+  static Packet::Format getFormatFromPrefix(const Prefix &prefix,
+                                            bool ah = false) {
+    switch (prefix.getAddressFamily()) {
       case AF_INET:
         return ah ? HF_INET_TCP_AH : HF_INET_TCP;
       case AF_INET6:
@@ -158,124 +243,69 @@ struct packet_t {
   uint32_t size;
 };
 
+struct Configuration {
+  Prefix name_{"b001::abcd/64"};
+  std::string passphrase_;
+  std::string aggr_interest_passphrase_;
+  bool rtc_{false};
+  uint16_t port_{0};
+  bool aggregated_data_{false};
+  Packet::Format packet_format_{default_values::packet_format};
+  uint32_t parallel_flows_{1};
+  bool colored_{true};
+};
+
 /**
  * Container for command line configuration for hiperf client.
  */
-struct ClientConfiguration {
-  ClientConfiguration()
-      : name("b001::abcd", 0),
-        beta(-1.f),
-        drop_factor(-1.f),
-        window(-1),
-        producer_certificate(""),
-        passphrase(""),
-        receive_buffer(nullptr),
-        receive_buffer_size_(128 * 1024),
-        download_size(0),
-        report_interval_milliseconds_(1000),
-        transport_protocol_(CBR),
-        rtc_(false),
-        test_mode_(false),
-        relay_(false),
-        secure_(false),
-        producer_prefix_(),
-        interest_lifetime_(500),
-        unverified_interval_(10000),
-        unverified_ratio_(0.2),
-        relay_name_("c001::abcd/64"),
-        output_stream_mode_(false),
-        port_(0),
-        recovery_strategy_(4),
-        aggregated_data_(false),
-        packet_format_(default_values::packet_format),
-        print_headers_(true),
-        nb_iterations_(std::numeric_limits<decltype(nb_iterations_)>::max()) {}
-
-  Name name;
-  double beta;
-  double drop_factor;
-  double window;
-  std::string producer_certificate;
-  std::string passphrase;
-  std::shared_ptr<utils::MemBuf> receive_buffer;
-  std::size_t receive_buffer_size_;
-  std::size_t download_size;
-  std::uint32_t report_interval_milliseconds_;
-  TransportProtocolAlgorithms transport_protocol_;
-  bool rtc_;
-  bool test_mode_;
-  bool relay_;
-  bool secure_;
+struct ClientConfiguration : public Configuration {
+  double beta_{-1.f};
+  double drop_factor_{-1.f};
+  double window_{-1.f};
+  std::string producer_certificate_;
+  std::string passphrase_;
+  std::size_t receive_buffer_size_{128 * 1024};
+  std::uint32_t report_interval_milliseconds_{1000};
+  TransportProtocolAlgorithms transport_protocol_{CBR};
+  bool test_mode_{false};
+  bool relay_{false};
   Prefix producer_prefix_;
-  uint32_t interest_lifetime_;
-  uint32_t unverified_interval_;
-  double unverified_ratio_;
-  Prefix relay_name_;
-  bool output_stream_mode_;
-  uint16_t port_;
-  uint32_t recovery_strategy_;
-  bool aggregated_data_;
-  Packet::Format packet_format_;
-  bool print_headers_;
-  std::uint32_t nb_iterations_;
-  forwarder_type_t forwarder_type_;
+  uint32_t interest_lifetime_{500};
+  uint32_t manifest_factor_relevant_{100};
+  uint32_t manifest_factor_alert_{20};
+  Prefix relay_name_{"c001::abcd/64"};
+  bool output_stream_mode_{false};
+  uint32_t recovery_strategy_{4};
+  bool print_headers_{true};
+  std::uint32_t nb_iterations_{
+      std::numeric_limits<decltype(nb_iterations_)>::max()};
+  bool content_sharing_mode_{false};
+  bool aggregated_interests_{false};
 };
 
 /**
  * Container for command line configuration for hiperf server.
  */
-struct ServerConfiguration {
-  ServerConfiguration()
-      : name("b001::abcd/64"),
-        virtual_producer(true),
-        manifest(0),
-        live_production(false),
-        content_lifetime(600000000_U32),
-        download_size(20 * 1024 * 1024),
-        hash_algorithm_(CryptoHashType::SHA256),
-        keystore_name(""),
-        passphrase(""),
-        keystore_password("cisco"),
-        multiphase_produce_(false),
-        rtc_(false),
-        interactive_(false),
-        trace_based_(false),
-        trace_index_(0),
-        trace_file_(nullptr),
-        production_rate_(std::string("2048kbps")),
-        payload_size_(1384),
-        secure_(false),
-        input_stream_mode_(false),
-        port_(0),
-        aggregated_data_(false),
-        fec_type_(""),
-        packet_format_(default_values::packet_format) {}
-
-  Prefix name;
-  bool virtual_producer;
-  std::uint32_t manifest;
-  bool live_production;
-  std::uint32_t content_lifetime;
-  std::uint32_t download_size;
-  CryptoHashType hash_algorithm_;
-  std::string keystore_name;
-  std::string passphrase;
-  std::string keystore_password;
-  bool multiphase_produce_;
-  bool rtc_;
-  bool interactive_;
-  bool trace_based_;
-  std::uint32_t trace_index_;
-  char *trace_file_;
-  Rate production_rate_;
-  std::size_t payload_size_;
-  bool secure_;
-  bool input_stream_mode_;
-  uint16_t port_;
+struct ServerConfiguration : public Configuration {
+  bool virtual_producer_{true};
+  std::uint32_t manifest_max_capacity_{0};
+  bool live_production_{false};
+  std::uint32_t content_lifetime_{
+      transport::interface::default_values::content_object_expiry_time};
+  std::uint32_t download_size_{20 * 1024 * 1024};
+  CryptoHashType hash_algorithm_{CryptoHashType::SHA256};
+  std::string keystore_name_;
+  std::string keystore_password_{"cisco"};
+  bool multiphase_produce_{false};
+  bool interactive_{false};
+  bool trace_based_{false};
+  std::uint32_t trace_index_{0};
+  char *trace_file_{nullptr};
+  Rate production_rate_{"2048kbps"};
+  std::size_t payload_size_{1384};
+  bool input_stream_mode_{false};
   std::vector<struct packet_t> trace_;
-  bool aggregated_data_;
   std::string fec_type_;
-  Packet::Format packet_format_;
 };
 
 }  // namespace hiperf