move files. Simplify. RFC 5737

Author: anderspkd

include/scl/net/config.h include/scl/net/tcp/config.hinclude/scl/net/config.h renamed to include/scl/net/tcp/config.h

@@ -24,15 +24,17 @@
 
 /**
  * @brief Default port offset used when all parties are running locally.
+ * @ingroup net-tcp
  */
-#ifndef DEFAULT_PORT_OFFSET
-#define DEFAULT_PORT_OFFSET 9900
+#ifndef DEFAULT_LOCALHOST_PORT_OFFSET
+#define DEFAULT_LOCALHOST_PORT_OFFSET 9900
 #endif
 
 namespace scl {
 
 /**
  * @brief Connection information for a party.
+ * @ingroup net-tcp
  */
 struct ConnectionInfo {
   /**
@@ -53,6 +55,7 @@ struct ConnectionInfo {
 
 /**
  * @brief Network configuration.
+ * @ingroup net-tcp
  *
  * A NetworkConfig is needed whenever by network objects in order to establish
  * connections to other nodes.
@@ -61,45 +64,56 @@ class NetworkConfig {
  public:
   /**
    * @brief Load a network config from a file.
-   * @param id the identity of this party
-   * @param filename the filename
+   *
+   * This method creates a NetworkConfig from a file containing connection
+   * information of the different parties. The file should be a CSV filed with
+   * three columns. Each row in the file contains a party's IPv4 address and the
+   * port to use, in that order. An example is given below for three parties
+   *
+   * \code{.unparsed}
+   * $ cat 3_parties.txt
+   * 192.0.2.1, 8000
+   * 192.0.2.2, 5000
+   * 192.0.2.3, 3000
+   * $
+   * \endcode{.unparsed}
+   *
+   * The order in which parties information occurs will correspond to their
+   * identifier in the NetworkConfig that will be created.
+   *
+   * @code
+   * auto nc = NetworkConfig::load(1, "3_parties.txt");
+   * assert(nc.id() == 1);
+   * assert(nc.networkSize() == 3);
+   *
+   * auto me = nc.party(1);
+   * assert(me.hostname == "192.0.2.2");
+   * assert(me.port == 5000);
+   * @endcode
    */
   static NetworkConfig load(std::size_t id, const std::string& filename);
 
   /**
    * @brief Create a network config where all parties are running locally.
-   *
-   * Because different processes cannot reuse the same port, the port argument
-   * denotes a base from which a party's actual port is computed. Specifically,
-   * party <code>i</code> will listen on <code>port_base + i</code> and connect
-   * (as a client) to party <code>j</code> on <code>port_base + j</code>.
-   *
-   * @param id the identity of this party
-   * @param size the size of the network
-   * @param port_base the base port
    */
   static NetworkConfig localhost(std::size_t id,
                                  std::size_t size,
                                  std::size_t port_base);
 
   /**
    * @brief Create a network config where all parties are running locally.
-   * @param id the identity of this party
-   * @param size the size of the network
    */
   static NetworkConfig localhost(std::size_t id, std::size_t size) {
-    return NetworkConfig::localhost(id, size, DEFAULT_PORT_OFFSET);
+    return NetworkConfig::localhost(id, size, DEFAULT_LOCALHOST_PORT_OFFSET);
   };
 
   /**
    * @brief Create a config from a list of parties.
-   * @param id the id of the local party
-   * @param parties a list of parties
    */
   NetworkConfig(std::size_t id, const std::vector<ConnectionInfo>& parties)
       : m_id(id), m_parties(parties) {
     validate();
-  };
+  }
 
   /**
    * @brief Gets the identity of this party.

src/scl/net/config.cc src/scl/net/tcp/config.ccsrc/scl/net/config.cc renamed to src/scl/net/tcp/config.cc

@@ -15,26 +15,12 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-#include "scl/net/config.h"
+#include "scl/net/tcp/config.h"
 
 #include <fstream>
 #include <stdexcept>
 #include <string>
 
-namespace {
-
-void validateIdAndSize(std::size_t id, std::size_t n) {
-  if (n == 0) {
-    throw std::invalid_argument("n cannot be zero");
-  }
-
-  if (n <= id) {
-    throw std::invalid_argument("invalid id");
-  }
-}
-
-}  // namespace
-
 scl::NetworkConfig scl::NetworkConfig::load(std::size_t id,
                                             const std::string& filename) {
   std::ifstream file(filename);
@@ -46,32 +32,35 @@ scl::NetworkConfig scl::NetworkConfig::load(std::size_t id,
   std::string line;
   std::vector<ConnectionInfo> info;
 
-  while (std::getline(file, line)) {
-    auto a_ = line.find(',');
-    auto b_ = line.rfind(',');
+  std::size_t i = 0;
 
-    if (a_ == std::string::npos || a_ == b_) {
+  while (std::getline(file, line)) {
+    auto split = line.find(',');
+    
+    if (split == std::string::npos) {
       throw std::invalid_argument("invalid entry in config file");
     }
 
-    auto a = static_cast<std::string::difference_type>(a_);
-    auto b = static_cast<std::string::difference_type>(b_);
+    auto s = static_cast<std::string::difference_type>(split);
+    auto host = std::string(line.begin(), line.begin() + s);
+    auto port = std::stoul(std::string(line.begin() + s + 1, line.end()));
 
-    auto id = std::stoul(std::string(line.begin(), line.begin() + a));
-    auto hostname = std::string(line.begin() + a + 1, line.begin() + b);
-    auto port = std::stoul(std::string(line.begin() + b + 1, line.end()));
-    info.emplace_back(ConnectionInfo{id, hostname, port});
+    info.emplace_back(ConnectionInfo{i++, host, port});
   }
 
-  validateIdAndSize(id, info.size());
+  if (id >= info.size()) {
+    throw std::invalid_argument("invalid id");
+  }
 
   return NetworkConfig(id, info);
 }
 
 scl::NetworkConfig scl::NetworkConfig::localhost(std::size_t id,
                                                  std::size_t size,
                                                  std::size_t port_base) {
-  validateIdAndSize(id, size);
+  if (id >= size) {
+    throw std::invalid_argument("invalid id");
+  }
 
   std::vector<ConnectionInfo> info;
   for (std::size_t i = 0; i < size; ++i) {

test/data/3_parties.txt

@@ -1,3 +1,3 @@
-1,1.2.3.4,8000
-0,2.3.4.5,5000
-2,5.5.5.5,3000
+192.0.2.1, 8000
+192.0.2.2, 5000
+192.0.2.3, 3000

test/data/invalid_entry.txt

@@ -1 +1 @@
-a,b
+abc

test/scl/net/test_config.cc test/scl/net/tcp/test_config.cctest/scl/net/test_config.cc renamed to test/scl/net/tcp/test_config.cc

@@ -17,7 +17,6 @@
 
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_exception.hpp>
-#include <iostream>
 #include <stdexcept>
 
 #include "scl/net/config.h"
@@ -31,17 +30,17 @@ TEST_CASE("Config read from file", "[net]") {
   REQUIRE(cfg.networkSize() == 3);
   REQUIRE(cfg.id() == 0);
   auto parties = cfg.parties();
-  REQUIRE(parties[0].hostname == "1.2.3.4");
+  REQUIRE(parties[0].hostname == "192.0.2.1");
   REQUIRE(parties[0].port == 8000);
-  REQUIRE(parties[1].hostname == "2.3.4.5");
+  REQUIRE(parties[1].hostname == "192.0.2.2");
   REQUIRE(parties[1].port == 5000);
-  REQUIRE(parties[2].hostname == "5.5.5.5");
+  REQUIRE(parties[2].hostname == "192.0.2.3");
   REQUIRE(parties[2].port == 3000);
 
   std::string invalid_empty = SCL_TEST_DATA_DIR "invalid_no_entries.txt";
   REQUIRE_THROWS_MATCHES(NetworkConfig::load(0, invalid_empty),
                          std::invalid_argument,
-                         Catch::Matchers::Message("n cannot be zero"));
+                         Catch::Matchers::Message("invalid id"));
 
   std::string valid = SCL_TEST_DATA_DIR "3_parties.txt";
   REQUIRE_THROWS_MATCHES(NetworkConfig::load(4, valid),
@@ -54,7 +53,7 @@ TEST_CASE("Config read from file", "[net]") {
       std::invalid_argument,
       Catch::Matchers::Message("invalid entry in config file"));
 
-  std::string invalid_non_existing_file;
+  std::string invalid_non_existing_file = "";
   REQUIRE_THROWS_MATCHES(NetworkConfig::load(0, invalid_non_existing_file),
                          std::invalid_argument,
                          Catch::Matchers::Message("could not open file"));