add list of attached cubes to port

So far there is not a way to know what are the transparent cubes attached
to a given port.  This commit extends the base datamodel with a list of cubes
in the ports and adds all the logic to handle them.

This new resource is init-only-config, this commit also handles all the logic
when a port or a cube is created.

There are two special conditions that are handled, having in mind that when
a transparent cube is attached it can query the port for some parameters we
have that:
- if the parent cube is being created, it's is not visible yet.
- if the parent port is being created this is possible that some parameters
are not initialized yet.

The solution for both conditions is to first create the element (cube or port)
and then apply the configuration to attach the transparent cubes.  This approach
would not be necessary once a proper subscrition mechanishm is implemented.

Signed-off-by: Mauricio Vasquez B <mauriciovasquezbernal@gmail.com>

Author: mauriciovasquezbernal

src/libs/polycube/include/polycube/services/cube.h

@@ -120,6 +120,19 @@ std::shared_ptr<PortType> Cube<PortType>::add_port(const std::string &port_name,
 
     std::tie(iter, inserted) = ports_by_name_.emplace(port_name, port);
     ports_by_id_.emplace(port->index(), port);
+    /*
+     * When a transparent cube is attached to a port, it can query the service
+     * to get some port parameters (e.g., MAC address). If the transparent cube
+     * is attached while the port is being created these parameters will be not
+     * configured yet.
+     * This workaround first creates the port and then passes the configuration
+     * to attach the transparent cubes. The configuration that is passed
+     * in the constructor is ignored in the daemon.
+     * The solution for this workaround would be to implement the notification
+     * mechanishm, so when the parameters are configured those are pushed to the
+     * transparent cube.
+     */
+    port->set_conf(conf.getBase());
     return iter->second;
   } catch (const std::exception &ex) {
     cube_->remove_port(port_name);

src/polycubed/src/base_model.cpp

@@ -244,4 +244,24 @@ Response BaseModel::set_span(const std::string &cube_name,
   return Response{kOk, ::strdup("")};
 }
 
+Response BaseModel::get_port_tcubes(const std::string &cube_name,
+                                    const std::string &port_name) const {
+  auto cube_ = ServiceController::get_cube(cube_name);
+  if (cube_ == nullptr) {
+    return Response{kNoContent, ::strdup("Cube does not exist")};
+  }
+
+  // TODO: is this case even possible?
+  auto cube = std::dynamic_pointer_cast<CubeIface>(cube_);
+  if (cube == nullptr) {
+    return Response{kNoContent, ::strdup("Cube is transparent")};
+  }
+
+  auto port_ = cube->get_port(port_name);
+  auto port = std::dynamic_pointer_cast<Port>(port_);
+  nlohmann::json j = port->get_cubes_names();
+
+  return Response{kOk, ::strdup(j.dump().c_str())};
+}
+
 }  // namespace polycube::polycubed

src/polycubed/src/base_model.h

@@ -50,6 +50,8 @@ class BaseModel {
   Response get_span(const std::string &cube_name) const;
   Response set_span(const std::string &cube_name,
                       const nlohmann::json &json);
+  Response get_port_tcubes(const std::string &cube_name,
+                           const std::string &port_name) const;
 };
 
 }  // namespace polycube::polycubed

src/polycubed/src/peer_iface.cpp

@@ -111,6 +111,18 @@ void PeerIface::remove_cube(const std::string &cube_name) {
   update_indexes();
 }
 
+std::vector<std::string> PeerIface::get_cubes_names() const {
+  std::lock_guard<std::mutex> guard(mutex_);
+
+  std::vector<std::string> cubes_names;
+
+  for (auto &cube : cubes_) {
+    cubes_names.push_back(cube->get_name());
+  }
+
+  return cubes_names;
+}
+
 PeerIface::CubePositionComparison PeerIface::compare_position(
     const std::string &cube1, const std::string &cube2) {
   // cube position, index 0 is the innermost one

src/polycubed/src/peer_iface.h

@@ -43,6 +43,7 @@ class PeerIface {
   void add_cube(TransparentCube *cube, const std::string &position,
                 const std::string &other);
   void remove_cube(const std::string &type);
+  std::vector<std::string> get_cubes_names() const;
 
  protected:
   enum class CubePositionComparison {

src/polycubed/src/polycubed_core.cpp

@@ -343,7 +343,7 @@ void PolycubedCore::attach(const std::string &cube_name,
       }
       break;
     case PortType::XDP:
-      if (cube->get_type() != CubeType::XDP_DRV &&
+      if (cube->get_type() != CubeType::XDP_SKB &&
           cube->get_type() != CubeType::XDP_DRV) {
         throw std::runtime_error(cube_name + " and " + port_name +
                                  " have incompatible types");

src/polycubed/src/port.cpp

@@ -163,6 +163,13 @@ void Port::set_conf(const nlohmann::json &conf) {
   if (conf.count("peer")) {
     set_peer(conf.at("peer").get<std::string>());
   }
+
+  // attach transparent cubes present on the port
+  if (conf.count("tcubes")) {
+    for (auto &cube : conf.at("tcubes")) {
+      core->attach(cube.get<std::string>(), get_path(), "last", "");
+    }
+  }
 }
 
 nlohmann::json Port::to_json() const {
@@ -173,6 +180,11 @@ nlohmann::json Port::to_json() const {
   val["status"] = port_status_to_string(get_status());
   val["peer"] = peer();
 
+  const auto &cubes_names = get_cubes_names();
+  if (cubes_names.size()) {
+    val["tcubes"] = cubes_names;
+  }
+
   return val;
 }
 

src/polycubed/src/server/Parser/YangNodes.tcpp

@@ -395,10 +395,13 @@ void Yang::ParseLeafList(
   }
   std::shared_ptr<Resources::Body::LeafListResource> resource;
   if (generate_endpoint) {
+    auto base_model = base_model_factory_->IsBaseModel(parsed_names);
+    auto &&factory__ = base_model ? dynamic_cast<Resources::Data::AbstractFactory*>(base_model_factory_.get()) : factory_.get();
+
     const auto &e_parent =
         std::dynamic_pointer_cast<Resources::Endpoint::ParentResource>(parent);
     auto endpoint = e_parent->Endpoint() + '/' + leaflist->name;
-    resource = factory_->RestLeafList(
+    resource = factory__->RestLeafList(
         std::move(parsed_names), leaflist->name, description, cli_example,
         endpoint, parent.get(), std::move(value_field), node_fields,
         configuration, init_only_config, mandatory,

src/polycubed/src/server/Resources/Data/BaseModel/CMakeLists.txt

@@ -1,4 +1,5 @@
 set(base_model_sources
         ${CMAKE_CURRENT_LIST_DIR}/ConcreteFactory.cpp
         ${CMAKE_CURRENT_LIST_DIR}/LeafResource.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/LeafListResource.cpp
         PARENT_SCOPE)

src/polycubed/src/server/Resources/Data/BaseModel/ConcreteFactory.cpp

@@ -22,11 +22,13 @@
 #include "../../Body/JsonNodeField.h"
 
 #include "../../Endpoint/LeafResource.h"
+#include "../../Endpoint/LeafListResource.h"
 #include "../../Endpoint/ListResource.h"
 #include "../../Endpoint/ParentResource.h"
 #include "../../Endpoint/Service.h"
 
 #include "LeafResource.h"
+#include "LeafListResource.h"
 
 #include "polycubed_core.h"
 
@@ -56,7 +58,7 @@ bool ConcreteFactory::IsBaseModel(
     tree_names_.pop();
     auto leaf = tree_names_.front();
 
-    if (leaf == "uuid" || leaf == "status" || leaf == "peer") {
+    if (leaf == "uuid" || leaf == "status" || leaf == "peer" || leaf == "tcubes") {
       return true;
     }
   }
@@ -228,8 +230,42 @@ std::unique_ptr<Endpoint::LeafListResource> ConcreteFactory::RestLeafList(
     const std::vector<Body::JsonNodeField> &node_fields, bool configuration,
     bool init_only_config, bool mandatory, Types::Scalar type,
     std::vector<std::string> &&default_value) const {
-  throw std::invalid_argument(
-      "Yang case leaf-list not supported in base datamodel");
+  std::function<Response(const std::string &, const ListKeyValues &keys)>
+      read_handler_;
+  std::function<Response(const std::string &, const nlohmann::json &,
+                         const ListKeyValues &, Endpoint::Operation)>
+      replace_handler_;
+
+  // TODO: I need to capture this variable inside the lambda functions,
+  // capturing "this" for me is not working
+  auto local_core = this->core_;
+
+  auto tree_names_ = tree_names;
+  tree_names_.pop();
+
+  if (tree_names_.size() == 2) {
+    if (tree_names_.front() != "ports") {
+      throw std::runtime_error("unknown element found in base datamodel");
+    }
+
+    tree_names_.pop();
+    auto leaf = tree_names_.front();
+    if (leaf == "tcubes") {
+      read_handler_ = [local_core](const std::string &cube_name,
+                                   const ListKeyValues &keys) -> Response {
+        return local_core->base_model()->get_port_tcubes(cube_name,
+                                                         keys[0].value);
+      };
+    } else {
+      throw std::runtime_error("unknown element found in base datamodel: " +
+                               leaf);
+    }
+  }
+
+  return std::make_unique<LeafListResource>(
+    std::move(read_handler_), std::move(replace_handler_), name, description,
+    cli_example, rest_endpoint, parent, configuration, init_only_config,
+    core_, std::move(value_field), node_fields, mandatory, type, std::move(default_value));
 }
 
 std::unique_ptr<Endpoint::ListResource> ConcreteFactory::RestList(