polycubed: fix list validation

The validation code for the list was not testing all the elements of the list,
it instead was testing the list as a container.  Due to this complex commands
issued with a rest client were failing, for instance:

curl -L -X POST --data '{"name":"hw0","ports":[{"name":"pippo"}]}' \
  "http://localhost:9000/polycube/v1/helloworld/hw0/"

curl -L -X POST --data \
  '[{"name":"toveth1", "peer":"veth1"}, {"name":"toveth2", "peer":"veth2"}]' \
  "http://localhost:9000/polycube/v1/helloworld/hw0/ports/

This commit implements a new logic that tests all the elements in a list, also
a new logic fill the keys in json body of a list request is added as well.

This failure was unnoticed because polycubectl does not allow to perform such
complex operations in a single command.

Fixes: d8d280c ("Added new REST API and validation code")
Fixes: 795ce96 ("move help generation from services to daemon")

Signed-off-by: Mauricio Vasquez B <[email protected]>

Author: mauriciovasquezbernal

src/polycubed/src/server/Resources/Body/ListResource.cpp

@@ -105,6 +105,46 @@ void ListResource::SetDefaultIfMissing(nlohmann::json &body,
   }
 }
 
+void ListResource::FillKeys(nlohmann::json &body, const ListKeyValues &keys) {
+  // TODO: is there a more efficient implementation of this?
+  for (auto &key: keys_) {
+    for (auto &kv : keys) {
+      if (key.Name() == kv.name) {
+        // TODO: check if the key is present in the body and compare the data
+        body[key.OriginalName()] = kv.value;
+        break;
+      }
+    }
+  }
+}
+
+std::vector<Response> ListResource::BodyValidateMultiple(
+    const std::string &cube_name, const ListKeyValues &keys,
+    nlohmann::json &body, bool initialization) const {
+  std::vector<Response> errors;
+
+  nlohmann::json jbody;
+  if (body.empty()) {
+    jbody = nlohmann::json::parse("[]");
+  } else {
+    jbody = body;
+  }
+
+  if (!body.is_array()) {
+    errors.push_back({ErrorTag::kInvalidValue, nullptr});
+    return errors;
+  }
+
+  for (auto &elem : jbody) {
+    SetDefaultIfMissing(elem, initialization);
+    auto body = BodyValidate(cube_name, keys, elem, initialization);
+    errors.reserve(errors.size() + body.size());
+    std::copy(std::begin(body), std::end(body), std::back_inserter(errors));
+  }
+
+  return errors;
+}
+
 bool ListResource::IsMandatory() const {
   return false;
 }

src/polycubed/src/server/Resources/Body/ListResource.h

@@ -48,6 +48,16 @@ class ListResource : public virtual ParentResource {
   void SetDefaultIfMissing(nlohmann::json &body,
                            bool initialization) const final;
 
+  /*
+   * This function takes the keys (parsed from the url in "keys") and save
+   * them in the body of the request
+   */
+  void FillKeys(nlohmann::json &body, const ListKeyValues &keys);
+
+  std::vector<Response> BodyValidateMultiple(
+      const std::string &cube_name, const ListKeyValues &keys,
+      nlohmann::json &body, bool initialization) const;
+
   const std::vector<ListKey> keys_;
 
   nlohmann::json ToHelpJson() const override;

src/polycubed/src/server/Resources/Body/ParentResource.cpp

@@ -61,11 +61,6 @@ std::vector<Response> ParentResource::BodyValidate(const std::string &cube_name,
   for (auto &child : children_) {
     const auto &child_name = child->Name();
 
-    // TODO: what are the implications of it?
-    if (child->IsKey()) {
-      continue;
-    }
-
     // Choices are a special case
     if (std::dynamic_pointer_cast<ChoiceResource>(child) != nullptr) {
       choices.push_back(child);
@@ -86,9 +81,18 @@ std::vector<Response> ParentResource::BodyValidate(const std::string &cube_name,
           errors.push_back(
               {ErrorTag::kInvalidValue, ::strdup(child_name.data())});
         } else {
-          auto child_errors = child->BodyValidate(
-              cube_name, keys, body_copy[child_name], initialization);
+          std::vector<Response> child_errors;
+          // if the child is a list, perform the check over all elements
+          if (auto list = std::dynamic_pointer_cast<ListResource>(child)) {
+            child_errors = list->BodyValidateMultiple(
+                cube_name, keys, body_copy[child_name], initialization);
+          } else {
+            child_errors = child->BodyValidate(
+                cube_name, keys, body_copy[child_name], initialization);
+          }
+
           errors.reserve(errors.size() + child_errors.size());
+
           // remove current parsed element from the body so that in the
           // eventuality of choices, they will operate only on unparsed
           // elements. moreover, this is required for detecting unparsed

src/polycubed/src/server/Resources/Endpoint/ParentResource.cpp

@@ -105,6 +105,12 @@ void ParentResource::CreateReplaceUpdate(
   const auto &cube_name = Service::Cube(request);
   ListKeyValues keys{};
   Keys(request, keys);
+
+  // fill keys if they are missing
+  if (auto list = dynamic_cast<ListResource*>(this)) {
+    list->FillKeys(jbody, keys);
+  }
+
   auto body_errors = BodyValidate(cube_name, keys, jbody, initialization);
   errors.reserve(errors.size() + body_errors.size());
   std::move(std::begin(body_errors), std::end(body_errors),