Exemplo n.º 1
0
 def c_ofp_flow_info_serialization(self, resp):
     wildcard = mul_nbapi.OFPFW_ALL & ~(mul_nbapi.OFPFW_NW_SRC_MASK) & ~(mul_nbapi.OFPFW_DL_TYPE)
     flow_id = self.flow_tbl.match(resp.datapath_id, resp.flow, wildcard, resp.oport, 0)
     return {'flow_id':flow_id, 'flow_info':{'dpid':'0x%lx' % resp.datapath_id, 
             'nw_src': mul_nbapi.nbapi_parse_nw_addr_to_str(resp.flow.nw_src),
             'nw_dst': mul_nbapi.nbapi_parse_nw_addr_to_str(resp.flow.nw_dst),
             'dl_src': mul_nbapi.nbapi_parse_mac_to_str(resp.flow.dl_src),
             'dl_dst': mul_nbapi.nbapi_parse_mac_to_str(resp.flow.dl_dst),
             'vlan': resp.flow.dl_vlan,
             'in_port': resp.flow.in_port,
             'out_port': resp.oport,
             'bps': mul_nbapi.nbapi_parse_bps_to_str(resp.bps),
             'pps': mul_nbapi.nbapi_parse_bps_to_str(resp.pps),
             'pkt_count': resp.packet_count,
             'byte_count': resp.byte_count}
             }
Exemplo n.º 2
0
 def stat_port_parse(self, flow_list, port_no):
     ingress={}
     egress={}
     ingress['type']='ingress'
     ingress['pkt_count']=0.0
     ingress['byte_count']=0.0
     ingress['avg_bps']=0.0
     ingress['avg_pps']=0.0
     ingress['flow_count']=0.0
     
     egress['type']='egress'
     egress['pkt_count']=0.0
     egress['byte_count']=0.0
     egress['avg_bps']=0.0
     egress['avg_pps']=0.0
     egress['flow_count']=0.0
     
     
     for flow in flow_list:
         if flow.flow.in_port == port_no:
             ingress['pkt_count']=ingress['pkt_count']+flow.packet_count
             ingress['byte_count']=ingress['byte_count']+flow.byte_count
             ingress['avg_bps']=ingress['avg_bps']+float(mul_nbapi.nbapi_parse_bps_to_str(flow.bps))
             ingress['avg_pps']=ingress['avg_pps']+float(mul_nbapi.nbapi_parse_pps_to_str(flow.pps))
             ingress['flow_count']=ingress['flow_count']+1
             
         if flow.oport == port_no:
             egress['pkt_count']=egress['pkt_count']+flow.packet_count
             egress['byte_count']=egress['byte_count']+flow.byte_count
             egress['avg_bps']=egress['avg_bps']+float(mul_nbapi.nbapi_parse_bps_to_str(flow.bps))
             egress['avg_pps']=egress['avg_pps']+float(mul_nbapi.nbapi_parse_pps_to_str(flow.pps))
             egress['flow_count']=egress['flow_count']+1
    
     if (ingress['flow_count'] != 0): 
         ingress['avg_pps']=ingress['avg_pps']/ingress['flow_count']
     if (egress['flow_count'] != 0):    
         egress['avg_pps']=egress['avg_pps']/egress['flow_count'] 
     
     
     return {'ingress':ingress, 'egress':egress}       
Exemplo n.º 3
0
    def stat_all_port_parse(self, flow_list):
        """ Work from Chan"""
        stats = dict()
        result = list()
        port_list = dict()
        list_index = 0

        for flow in flow_list:
            
            stat = dict()

            stat['port_num'] = 0
            stat['in_pkt_count'] = 0
            stat['in_byte_count'] = 0
            stat['in_avg_bps'] = 0.0
            stat['in_avg_pps'] = 0.0
            stat['in_flow_count'] = 0
                
            stat['e_pkt_count'] = 0
            stat['e_byte_count'] = 0
            stat['e_avg_bps'] = 0.0
            stat['e_avg_pps'] = 0.0
            stat['e_flow_count'] =0
           
            if not flow.flow.in_port in port_list:
                port_list[flow.flow.in_port] = list_index
                result.append(stat.copy())
                result[list_index]['port_num'] = flow.flow.in_port
                list_index = list_index + 1
            
            if not flow.oport in port_list:
                port_list[flow.oport] = list_index
                result.append(stat.copy())
                result[list_index]['port_num'] = flow.oport
                list_index = list_index + 1
            
            in_index = port_list[flow.flow.in_port]
            result[in_index]['in_pkt_count'] += flow.packet_count
            result[in_index]['in_byte_count'] += flow.byte_count
            result[in_index]['in_avg_bps'] += float(mul_nbapi.nbapi_parse_bps_to_str(flow.bps))
            result[in_index]['in_avg_pps'] += float(mul_nbapi.nbapi_parse_bps_to_str(flow.pps))
            result[in_index]['in_flow_count'] += 1

            e_index = port_list[flow.oport]
            result[e_index]['e_pkt_count'] += flow.packet_count        
            result[e_index]['e_byte_count'] += flow.byte_count        
            result[e_index]['e_avg_bps'] += float(mul_nbapi.nbapi_parse_bps_to_str(flow.bps))
            result[e_index]['e_avg_pps'] += float(mul_nbapi.nbapi_parse_bps_to_str(flow.pps))
            result[e_index]['e_flow_count'] += 1

        for port in result:
            try:
                port['in_avg_bps'] = port['in_avg_bps'] / port['in_flow_count']
            except:
                port['in_avg_bps'] = 0

            try:
                port['in_avg_pps'] = port['in_avg_pps'] / port['in_flow_count']
            except:
                port['in_avg_pps'] = 0

            try:
                port['e_avg_bps'] = port['e_avg_bps'] / port['e_flow_count']
            except:
                port['e_avg_bps'] = 0

            try:
                port['e_avg_pps'] = port['e_avg_pps'] / port['e_flow_count']
            except:
                port['e_avg_pps'] = 0
        
        return result