This commit extends the get_if_topology CLI to support traversing the bpf program

index chain (service chain) for each interface and dump them. Since the head
index was fetched from the data plane directly and each next service is fetched
from the cubes, the service chain can be regarded as a real reflection of service
chain in the data.

Also Fixed a few issues in existing implementation.

Signed-off-by: Jianwen Pi<jianwpi@gmail.com>

Author: goldenrye

src/polycubed/src/extiface.cpp

@@ -180,39 +180,82 @@ void ExtIface::set_next(uint16_t next, ProgramType type) {
   }
 }
 
+TransparentCube* ExtIface::get_next_cube(ProgramType type) {
+  auto next = get_next(type);
+  for (auto &it : cubes_) {
+      if (it->get_index(type) == next) {
+          return it;
+      }
+  }
+  return NULL;
+}
+
+uint16_t ExtIface::get_next(ProgramType type) {
+  int zero = 0;
+  unsigned int value = 0;
+  auto program = (type == ProgramType::INGRESS) ? &ingress_program_ : &egress_program_;
+  auto index_map = program->get_array_table<uint32_t>("index_map");
+  auto st = index_map.get_value(zero, value);
+  if (st.code() == -1) {
+    logger->error("failed to get interface {0} nexthop", get_iface_name());
+  }
+
+  return value & 0xffff;
+}
+
+std::vector<std::string> ExtIface::get_service_chain(ProgramType type) {
+  std::vector<std::string> chain;
+  TransparentCube *cube;
+  auto nh = get_next(type);
+
+  while (nh != 0xffff) {
+      cube = NULL;
+      for (auto c : cubes_) {
+          if (c->get_index(type) == nh) {
+              cube = c;
+              break;
+          }
+      }
+      chain.push_back(cube ? cube->get_name() : "unknown");
+      nh = cube->get_next(type);
+  }
+  chain.push_back(nh==0xffff ? "stack" : "unknown");
+
+  return chain;
+}
+
 void ExtIface::update_indexes() {
   int i;
 
   // TODO: could we avoid to recalculate in case there is not peer?
 
-  std::vector<uint16_t> ingress_indexes(cubes_.size());
-  std::vector<uint16_t> egress_indexes(cubes_.size());
+  std::vector<uint16_t> ingress_indexes(cubes_.size(), 0xffff) ;
+  std::vector<uint16_t> egress_indexes(cubes_.size(), 0xffff);
 
   for (i = 0; i < cubes_.size(); i++) {
     ingress_indexes[i] = cubes_[i]->get_index(ProgramType::INGRESS);
     egress_indexes[i] = cubes_[i]->get_index(ProgramType::EGRESS);
   }
 
-  // ingress chain: NIC -> cube[N-1] -> ... -> cube[0] -> stack (or peer)
+  // ingress chain: NIC -> cube[0] -> ... -> cube[n-1] -> stack (or peer)
   // CASE2: cube[0] -> stack (or)
-  for (i = 0; i < cubes_.size(); i++) {
-    if (ingress_indexes[i]) {
+  for (i = cubes_.size() - 1; i >= 0; i--) {
+    if (ingress_indexes[i] != 0xffff) {
       cubes_[i]->set_next(peer_ ? peer_->get_index() : 0xffff,
                           ProgramType::INGRESS);
       break;
     }
   }
 
-  // cube[N-1] -> ... -> cube[0]
-  for (int j = i + 1; j < cubes_.size(); j++) {
-    if (ingress_indexes[j]) {
+  for (int j = i - 1; j >= 0; j--) {
+    if (ingress_indexes[j] != 0xffff) {
       cubes_[j]->set_next(ingress_indexes[i], ProgramType::INGRESS);
       i = j;
     }
   }
 
   // CASE4: NIC -> cube[N-1] or peer
-  if (i < cubes_.size() && ingress_indexes[i]) {
+  if (i >= 0 && ingress_indexes[i] != 0xffff) {
     set_next(ingress_indexes[i], ProgramType::INGRESS);
   } else {
     set_next(peer_ ? peer_->get_index() : 0, ProgramType::INGRESS);
@@ -222,7 +265,7 @@ void ExtIface::update_indexes() {
 
   // cube[0] -> "egress"
   for (i = 0; i < cubes_.size(); i++) {
-    if (egress_indexes[i]) {
+    if (egress_indexes[i] != 0xffff) {
       cubes_[i]->set_next(0xffff, ProgramType::EGRESS);
       break;
     }
@@ -235,14 +278,14 @@ void ExtIface::update_indexes() {
 
   // cubes[N-1] -> ... -> cube[0]
   for (int j = i + 1; j < cubes_.size(); j++) {
-    if (egress_indexes[j]) {
+    if (egress_indexes[j] != 0xffff) {
       cubes_[j]->set_next(egress_indexes[i], ProgramType::EGRESS);
       i = j;
     }
   }
 
   // "nic" -> cubes[N-1] or peer
-  if (i < cubes_.size() && egress_indexes[i]) {
+  if (i < cubes_.size() && egress_indexes[i] != 0xffff) {
     set_next(egress_indexes[i], ProgramType::EGRESS);
   } else {
     Port *peer_port = dynamic_cast<Port *>(peer_);

src/polycubed/src/extiface.h

@@ -66,6 +66,9 @@ class ExtIface : public PeerIface {
   std::string get_parameter(const std::string &param_name) override;
   void set_parameter(const std::string &param_name,
                      const std::string &value) override;
+  uint16_t get_next(ProgramType type);
+  TransparentCube* get_next_cube(ProgramType type);
+  std::vector<std::string> get_service_chain(ProgramType type);
 
  protected:
   // 2 maps: one for IP events and one for MAC events

src/polycubed/src/peer_iface.cpp

@@ -124,6 +124,32 @@ std::vector<std::string> PeerIface::get_cubes_names() const {
   return cubes_names;
 }
 
+std::vector<uint16_t> PeerIface::get_cubes_ingress_index() const {
+  std::lock_guard<std::mutex> guard(mutex_);
+
+  std::vector<uint16_t> ingress_indices;
+
+  for (auto &cube : cubes_) {
+      ingress_indices.push_back(cube->get_index(ProgramType::INGRESS));
+  }
+
+  return ingress_indices;
+}
+
+std::vector<uint16_t> PeerIface::get_cubes_egress_index() const {
+  std::lock_guard<std::mutex> guard(mutex_);
+
+  std::vector<uint16_t> egress_indices;
+
+  for (auto &cube : cubes_) {
+      egress_indices.push_back(cube->get_index(ProgramType::EGRESS));
+  }
+
+  return egress_indices;
+}
+
+
+
 PeerIface::CubePositionComparison PeerIface::compare_position(
     const std::string &cube1, const std::string &cube2) {
   // cube position, index 0 is the innermost one
@@ -157,4 +183,4 @@ PeerIface::CubePositionComparison PeerIface::compare_position(
 }
 
 }  // namespace polycubed
-}  // namespace polycube
+}  // namespace polycube

src/polycubed/src/peer_iface.h

@@ -52,6 +52,8 @@ class PeerIface {
                const std::string &other);
   void remove_cube(const std::string &type);
   std::vector<std::string> get_cubes_names() const;
+  std::vector<uint16_t> get_cubes_ingress_index() const;
+  std::vector<uint16_t> get_cubes_egress_index() const;
 
  protected:
   enum class CubePositionComparison {

src/polycubed/src/polycubed_core.cpp

@@ -213,7 +213,35 @@ std::string PolycubedCore::get_if_topology(const std::string &if_name) {
 
    auto extIface = polycube::polycubed::ExtIface::get_extiface(if_name);
    if (extIface != NULL) {
-       j["cubes"] = extIface->get_cubes_names();
+       auto names = extIface->get_cubes_names();
+       auto ingress_indices = extIface->get_cubes_ingress_index();
+       auto egress_indices = extIface->get_cubes_egress_index();
+       std::vector<std::string> cubes_info;
+       std::ostringstream stream;
+       for (int i=0; i<names.size(); i++) {
+           stream.str("");
+           stream << names[i] << ",\t" << ingress_indices[i] << ",\t" << egress_indices[i];
+           cubes_info.push_back(std::string(stream.str()));
+       }
+       j["cubes, ingress_index, egress_index"] = cubes_info;
+
+       stream.str("");
+       auto i_serv_chain = extIface->get_service_chain(ProgramType::INGRESS);
+       for (auto service : i_serv_chain) {
+           stream << service;
+           if (service != std::string("stack"))
+               stream << " ---> ";
+       }
+       j["ingress service chain"] = stream.str();
+
+       stream.str("");
+       auto e_serv_chain = extIface->get_service_chain(ProgramType::EGRESS);
+       for (auto service : e_serv_chain) {
+           stream << service;
+           if (service != std::string("stack"))
+               stream << " ---> ";
+       }
+       j["egress service chain"] = stream.str();
    }
    return j.dump(4);
 }

src/polycubed/src/transparent_cube.cpp

@@ -71,6 +71,10 @@ void TransparentCube::set_next(uint16_t next, ProgramType type) {
   reload_all();
 }
 
+uint16_t TransparentCube::get_next(ProgramType type) {
+  return type == ProgramType::INGRESS ? ingress_next_ : egress_next_;
+}
+
 void TransparentCube::set_parent(PeerIface *parent) {
   parent_ = parent;
   if (parent_) {

src/polycubed/src/transparent_cube.h

@@ -36,6 +36,7 @@ class TransparentCube : public BaseCube, public TransparentCubeIface {
   virtual ~TransparentCube();
 
   void set_next(uint16_t next, ProgramType type);
+  uint16_t get_next(ProgramType type);
   void set_parent(PeerIface *parent);
   PeerIface *get_parent();
   void set_parameter(const std::string &parameter, const std::string &value);