add collect features to port metadata

diff --git a/linkpair/collect/agent/ovs_agent.py b/linkpair/collect/agent/ovs_agent.py
index ba64ab7..f7fc1eb 100755 (executable)
--- a/linkpair/collect/agent/ovs_agent.py
+++ b/linkpair/collect/agent/ovs_agent.py
@@ -24,16 +24,16 @@ class OVSAgent(BaseAgent):
         br_meta["controller"] = ""
         br_meta["manager"] = ""
 
-        res_ctl = self._runner.exec_cmd("ovs-vsctl get-controller " + br)
-        for ctl in res_ctl:
-            br_meta["controller"] = self._u.str_join(
-                br_meta["controller"], ctl.strip(), ", ")
-
         res_mgr = self._runner.exec_cmd("ovs-vsctl get-manager")
         for mgr in res_mgr:
             br_meta["manager"] = self._u.str_join(
                 br_meta["manager"], mgr.strip(), ", ")
 
+        res_ctl = self._runner.exec_cmd("ovs-vsctl get-controller " + br)
+        for ctl in res_ctl:
+            br_meta["controller"] = self._u.str_join(
+                br_meta["controller"], ctl.strip(), ", ")
+
         res_ofsw = self._runner.exec_cmd("ovs-ofctl show " + br)
         for ofsw_spec in res_ofsw:
             ofsw_spec = ofsw_spec.strip()
@@ -50,7 +50,7 @@ class OVSAgent(BaseAgent):
 
         return br_meta
 
-    def get_port_metadata(self, port_name):
+    def get_port_metadata(self, port_name, br_name=""):
         port_meta = {}
         exist_port = self._cu.get_port(port_name)
         if exist_port != self._cu.PORT_NOT_FOUND:
@@ -72,11 +72,50 @@ class OVSAgent(BaseAgent):
                         for port_option in port_options:
                             (opt_name, opt_value) = port_option.split("=")
                             opt_name = opt_name.strip()
+                            opt_value = opt_value.replace("\""," ")
                             opt_value = opt_value.strip()
                             port_meta[opt_name] = opt_value
                     elif self._u.d_push(re.search(r'Port "*', port_spec)) is not None:
                         break
-
+        
+        if br_name != "":
+            res_ofctl = self._runner.exec_cmd("ovs-ofctl show " + br_name)
+            for i in range(0, len(res_ofctl)):
+                port_start = res_ofctl[i].strip()
+                if self._u.d_push(re.search(r'(\d+)\(%s\): addr:(.*)' % port_name, port_start)) is not None:
+                    match = self._u.d_pop()
+                    port_meta["port_no"] = match.group(1).strip()
+                    port_meta["mac_addr"] = match.group(2).strip()
+                    break
+                    
+            res_ofctl = self._runner.exec_cmd("ovs-ofctl dump-ports " + br_name)
+            if "port_no" in port_meta:
+                found_port = False
+                for i in range(0, len(res_ofctl)):
+                    port_start = res_ofctl[i].strip()
+                    if self._u.d_push(
+                        re.search(r'port\s*%s:\s*rx pkts=(\d+), bytes=(\d+), drop=(\d+), errs=(\d+), frame=(\d+), over=(\d+), crc=(\d+)'
+                            % port_meta["port_no"], port_start)) is not None:
+                        match = self._u.d_pop()
+                        port_meta["rx_pkts"] = match.group(1).strip()
+                        port_meta["rx_bytes"] = match.group(2).strip()
+                        port_meta["rx_drop"] = match.group(3).strip()
+                        port_meta["rx_errs"] = match.group(4).strip()
+                        port_meta["rx_frame"] = match.group(5).strip()
+                        port_meta["rx_over"] = match.group(6).strip()
+                        port_meta["rx_crc"] = match.group(7).strip()
+                        found_port = True
+                    elif self._u.d_push(
+                        re.search(r'\s*tx pkts=(\d+), bytes=(\d+), drop=(\d+), errs=(\d+), coll=(\d+)',
+                            port_start)) is not None and found_port:
+                        match = self._u.d_pop()
+                        port_meta["tx_pkts"] = match.group(1).strip()
+                        port_meta["tx_bytes"] = match.group(2).strip()
+                        port_meta["tx_drop"] = match.group(3).strip()
+                        port_meta["tx_errs"] = match.group(4).strip()
+                        port_meta["tx_coll"] = match.group(5).strip()
+                        break
+        
         return port_meta
 
     def get_configuration(self):
@@ -91,8 +130,9 @@ class OVSAgent(BaseAgent):
                 "ovs-vsctl list-ports " + br_src)
             for port_name in port_names:
                 port_name = port_name.rstrip()
-                port_meta = self.get_port_metadata(port_name)
+                port_meta = self.get_port_metadata(port_name, br_src)
 
+                self._port_to_br[port_name] = br_src
                 # patch port
                 if self._cu.get_port_type(port_meta) == "patch":
                     patch_src = port_name
@@ -103,12 +143,12 @@ class OVSAgent(BaseAgent):
                         continue
 
                     patch_src_meta = port_meta
-                    patch_dst_meta = self.get_port_metadata(patch_dst)
                     result3 = self._runner.exec_cmd(
                         "ovs-vsctl port-to-br " + patch_dst)
                     if result3 is not None and len(result3) > 0:
                         br_dst = result3[0].rstrip()
                         br_dst_meta = self.get_bridge_metadata(br_dst)
+                        patch_dst_meta = self.get_port_metadata(patch_dst, br_dst)
                         self._cu.add_linkpair(
                             Device(br_src, Device.BR_TYPE, br_src_meta),
                             Device(br_dst, Device.BR_TYPE, br_dst_meta),
@@ -116,6 +156,7 @@ class OVSAgent(BaseAgent):
                             Port(patch_dst, Port.DEFAULT_TYPE, patch_dst_meta),
                             self._formatter.PATCH_FORMAT)
                     else:
+                        patch_dst_meta = self.get_port_metadata(patch_dst, br_dst)
                         self._cu.add_linkpair(
                             Device(br_src, Device.BR_TYPE, br_src_meta),
                             Device("NOT CONNECTED", Device.NOT_CONNECTED_TYPE),
@@ -133,12 +174,12 @@ class OVSAgent(BaseAgent):
                         continue
 
                     peer_src_meta = port_meta
-                    peer_dst_meta = self.get_port_metadata(peer_dst)
                     result3 = self._runner.exec_cmd(
                         "ovs-vsctl port-to-br " + peer_dst)
                     if result3 is not None and len(result3) > 0:
                         br_dst = result3[0].rstrip()
                         br_dst_meta = self.get_bridge_metadata(br_dst)
+                        peer_dst_meta = self.get_port_metadata(peer_dst, br_dst)
                         self._cu.add_linkpair(
                             Device(br_src, Device.BR_TYPE, br_src_meta),
                             Device(br_dst, Device.BR_TYPE, br_dst_meta),
@@ -146,6 +187,7 @@ class OVSAgent(BaseAgent):
                             Port(peer_dst, Port.DEFAULT_TYPE, peer_dst_meta),
                             self._formatter.VETH_FORMAT)
                     else:
+                        peer_dst_meta = self.get_port_metadata(peer_dst, br_dst)
                         self._cu.add_linkpair(
                             Device(br_src, Device.BR_TYPE, br_src_meta),
                             Device("NOT CONNECTED", Device.NOT_CONNECTED_TYPE),
@@ -163,7 +205,6 @@ class OVSAgent(BaseAgent):
                             or self._u.d_push(re.match(r'^em\d+$', port_name)) \
                                 or self._u.d_push(re.match(r'^igb\d+$', port_name)) \
                                 or self._u.d_push(re.match(r'^bond\d+$', port_name)):
-                            self._cu._port_to_br[port_name] = br_src
                             self._cu.add_linkpair(
                                 Device(br_src, Device.BR_TYPE, br_src_meta),
                                 Device("Physical NW", Device.PHYNET_TYPE),
@@ -174,7 +215,6 @@ class OVSAgent(BaseAgent):
                         elif self._u.d_push(re.match(r'(vxlan\d+)', port_name)) \
                             or self._cu.get_port_type(port_meta) == "gre" \
                                 or self._cu.get_port_type(port_meta) == "stt":
-                            self._cu._port_to_br[port_name] = br_src
                             self._cu.add_linkpair(
                                 Device(br_src, Device.BR_TYPE, br_src_meta),
                                 Device("OS Routing", Device.OS_ROUTE_TYPE),
@@ -182,51 +222,41 @@ class OVSAgent(BaseAgent):
                                 Port(""),
                                 self._formatter.OS_ROUTING_FORMAT)
 
+                        # Other OVSPort
                         else:
-                            ## Other OVSPort
                             #### VLAN interface
-                            if self._cu.get_port_vlan_master_if(port_meta) != self._cu.PORT_VLAN_UNSPECIFIED:
-                                master_if = self._cu.get_port_vlan_master_if(
-                                    port_meta)
-                                if master_if in self._cu._port_to_br:
-                                    self._cu._port_to_br[port_name] = br_src
+                            if self._cu.get_port_vlan_master_if(port_name) != self._cu.PORT_VLAN_UNSPECIFIED:
+                                master_if = self._cu.get_port_vlan_master_if(port_name)
+                                if master_if in self._port_to_br:
+                                    br_dst = self._port_to_br[master_if]
+                                    br_dst_obj = self._cu.get_device(br_dst)
                                     port_src = port_name
                                     port_src_meta = port_meta
                                     port_dst = master_if
-                                    port_dst_obj = self._cu.get_port(master_if)
-                                    br_dst = self._cu._port_to_br[master_if]
-                                    br_dst_obj = self._cu.get_device(br_dst)
+                                    #port_dst_obj = self._cu.get_port(master_if)
+                                    port_dst_meta = self.get_port_metadata(port_dst, br_dst)
                                     self._cu.add_linkpair(
-                                        Device(
-                                            br_src, Device.BR_TYPE, br_src_meta),
+                                        Device(br_src, Device.BR_TYPE, br_src_meta),
                                         br_dst_obj,
-                                        Port(
-                                            port_src, Port.DEFAULT_TYPE, port_src_meta),
-                                        port_dst_obj,
+                                        Port(port_src, Port.DEFAULT_TYPE, port_src_meta),
+                                        #port_dst_obj,
+                                        Port(port_dst, Port.DEFAULT_TYPE, port_dst_meta),
                                         self._formatter.VLAN_DIST_FORMAT)
 
                                 elif self._u.d_push(re.match(r'^eth\d+$', master_if)) \
                                     or self._u.d_push(re.match(r'^em\d+$', master_if)) \
                                         or self._u.d_push(re.match(r'^igb\d+$', master_if)) \
                                         or self._u.d_push(re.match(r'^bond\d+$', master_if)):
-                                    self._cu._port_to_br[port_name] = br_src
                                     self._cu.add_linkpair(
-                                        Device(
-                                            br_src, Device.BR_TYPE, br_src_meta),
-                                        Device(
-                                            "Physical NW", Device.PHYNET_TYPE),
-                                        Port(
-                                            port_name, Port.DEFAULT_TYPE, port_meta),
+                                        Device(br_src, Device.BR_TYPE, br_src_meta),
+                                        Device("Physical NW", Device.PHYNET_TYPE),
+                                        Port(port_name, Port.DEFAULT_TYPE, port_meta),
                                         Port(""))
                             else:
-                                self._cu._port_to_br[port_name] = br_src
                                 self._cu.add_linkpair(
-                                    Device(
-                                        br_src, Device.BR_TYPE, br_src_meta),
-                                    Device(
-                                        "NOT CONNECTED", Device.NOT_CONNECTED_TYPE),
-                                    Port(
-                                        port_name, Port.DEFAULT_TYPE, port_meta),
+                                    Device(br_src, Device.BR_TYPE, br_src_meta),
+                                    Device("NOT CONNECTED", Device.NOT_CONNECTED_TYPE),
+                                    Port(port_name, Port.DEFAULT_TYPE, port_meta),
                                     Port(""))
 
                     # internal
@@ -242,12 +272,11 @@ class OVSAgent(BaseAgent):
                         else:
                             self._cu.add_linkpair(
                                 Device(br_src, Device.BR_TYPE, br_src_meta),
-                                Device(
-                                    "INTERNAL", Device.OS_ROUTE_TYPE),
+                                Device("INTERNAL", Device.OS_ROUTE_TYPE),
                                 Port(port_name, Port.DEFAULT_TYPE, port_meta),
                                 Port(""))
                     # else:
                     #        ## Other OVSPort
-                    #        self._cu._port_to_br[port_name] = br_src
+                    #        self._port_to_br[port_name] = br_src
                     else:
                         continue