基于Ryu的流量采集代码实现

 

from __future__ import division
import time
import math
import xlwt
from ryu.controller import ofp_event
from ryu.controller.handler import MAIN_DISPATCHER, DEAD_DISPATCHER
from ryu.controller.handler import set_ev_cls
from ryu.ofproto import ofproto_v1_3
from ryu.lib import hub

FEATURE = {}


class FlowFeatureExaction(RyuApp):

    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]

    def __init__(self, *args, **kwargs):
        super(FlowFeatureExaction, self).__init__(*args, **kwargs)

        self.name = 'flow_feature_exaction'
        self.datapaths = {}

        self.src_to_dst = {}
        self.flows = []
        self.flow_feature = {}

        self.monitor_thread = hub.spawn(self._monitor)

    @set_ev_cls(ofp_event.EventOFPStateChange, [MAIN_DISPATCHER, DEAD_DISPATCHER])
    def _state_change_handler(self, ev):
        global FEATURE
        datapath = ev.datapath
        dpid = datapath.id
        if ev.state == MAIN_DISPATCHER:
            if datapath.id not in self.datapaths:
                self.logger.debug('register datapath: %016x', datapath.id)
                self.datapaths[datapath.id] = datapath
                FEATURE.setdefault(dpid, {})
                FEATURE[dpid].setdefault('flow_feature', {})

        elif ev.state == DEAD_DISPATCHER:
            if datapath.id in self.datapaths:
                self.logger.debug('unregister datapath: %016x', datapath.id)
                del self.datapaths[datapath.id]
                FEATURE.pop(dpid)

    def _monitor(self):
        while True:
            for dp in self.datapaths.values():
                self.send_flow_stats_request(dp)

            self.flows = []
            hub.sleep(10)
            # self.print_feature()

    def send_flow_stats_request(self, datapath):
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser
        req = parser.OFPFlowStatsRequest(datapath)
        datapath.send_msg(req)

    @set_ev_cls(ofp_event.EventOFPFlowStatsReply, MAIN_DISPATCHER)
    def flow_stats_reply_handler(self, ev):

        flow_counter = 0
        current_time = time.time()
        dpid = ev.msg.datapath.id
        self.flow_feature.setdefault(dpid, {})
        for stat in ev.msg.body:
            self.flows.append('time=%s datapath=%d table_id=%s '
                              'duration_sec=%d duration_nsec=%d '
                              'priority=%d '
                              'idle_timeout=%d hard_timeout=%d flags=0x%04x '
                              'cookie=%d packet_count=%d byte_count=%d '
                              'match=%s instructions=%s ' %
                              (time.time(), dpid, stat.table_id,
                               stat.duration_sec, stat.duration_nsec,
                               stat.priority,
                               stat.idle_timeout, stat.hard_timeout, stat.flags,
                               stat.cookie, stat.packet_count, stat.byte_count,
                               stat.match, stat.instructions))
            # flow_no = stat.match['eth_type'] + stat.match['ipv4_src'] + stat.match['in_port'] + stat.match['ipv4_dst']
            flow_no = flow_counter
            if (dpid in self.flow_feature) and (flow_no not in self.flow_feature[dpid]):
                self.flow_feature[dpid].setdefault(flow_no, {})
                self.flow_feature[dpid][flow_no] = {'datapath': 0, 'duration': 0,'priority': 0,
                                                    'packet_count': 0, 'byte_count': 0,
                                                    'ipv4_src': 0, 'ipv4_dst': 0,
                                                    'in_port': 0,'output': 0,
                                                    'pkt_rate': 0, 'byte_rate': 0,
                                                    'pkt_asym': 0, 'byte_asym': 0,
                                                    'growth_flow_interval': 0, 'switch_flow_count': 0,
                                                    'mean_bytes_per_pkt': 0, 'time': 0}

            time_interval = current_time-self.flow_feature[dpid][flow_no]['time']
            pkt_rate = (stat.packet_count-self.flow_feature[dpid][flow_no]['packet_count'])/time_interval
            byte_rate = (stat.byte_count-self.flow_feature[dpid][flow_no]['byte_count'])/time_interval
            self.flow_feature[dpid][flow_no] = {'datapath': dpid, 'duration': stat.duration_sec, 'priority': stat.priority,
                                                'packet_count': stat.packet_count, 'byte_count': stat.byte_count,
                                                'ipv4_src': 0, 'ipv4_dst': 0,
                                                'in_port': 0,'output': stat.instructions[0].actions[0].port,
                                                'pkt_rate': pkt_rate,'byte_rate': byte_rate,
                                                'pkt_asym': 0, 'byte_asym': 0,
                                                'growth_flow_interval': 0, 'switch_flow_count': 0,
                                                'mean_bytes_per_pkt': 0, 'time': current_time}

            for key, value in stat.match.items():
                self.flow_feature[dpid][flow_no][key] = value

            if pkt_rate != 0:
                self.flow_feature[dpid][flow_no]['mean_bytes_per_pkt'] = byte_rate/pkt_rate

            if self.flow_feature[dpid][flow_no]['ipv4_src'] != 0:
                src = self.flow_feature[dpid][flow_no]['ipv4_src']
                dst = self.flow_feature[dpid][flow_no]['ipv4_dst']
                self.src_to_dst.setdefault(src, {})
                self.src_to_dst[src].setdefault(dst, {})
                self.src_to_dst[src][dst] = {'pkt_count': stat.packet_count, 'byte_count': stat.byte_count,}
            flow_counter += 1

        for flow_no in self.flow_feature[dpid].keys():
            self.flow_feature[dpid][flow_no]['growth_flow_interval'] = \
                flow_counter - self.flow_feature[dpid][flow_no]['switch_flow_count']
            self.flow_feature[dpid][flow_no]['switch_flow_count'] = flow_counter
            if 'ipv4_src' in self.flow_feature[dpid][flow_no].keys():
                for src in self.src_to_dst.keys():
                    if src == self.flow_feature[dpid][flow_no]['ipv4_dst']:
                        for dst in self.src_to_dst[src].keys():
                            if dst == self.flow_feature[dpid][flow_no]['ipv4_src']:
                                self.flow_feature[dpid][flow_no]['pkt_asym'] = \
                                    self.src_to_dst[src][dst]['pkt_count']/(1+self.flow_feature[dpid][flow_no]['packet_count'])
                                self.flow_feature[dpid][flow_no]['bytes_asym'] = \
                                    self.src_to_dst[src][dst]['byte_count'] / (1+self.flow_feature[dpid][flow_no]['byte_count'])
        global FEATURE
        FEATURE[dpid]['flow_feature'] = self.flow_feature[dpid]

        # data = open("switch_flows", mode='w+')
        # for flow in self.flows:
        #      data.write(str(flow) + '\n')
        # data.close()

        data = open("feature", 'w')
        for dpid in FEATURE.keys():
            data.write('DatapathId ' + str(dpid) + ':{')
            for feature_type in FEATURE[dpid].keys():
                data.write('\n        '+str(feature_type)+':')
                data.write(str(FEATURE[dpid][feature_type]) + '}\n')
            data.write('\n')
        data.close()

        # workbook = xlwt.Workbook(encoding='utf-8')
        # worksheet = workbook.add_sheet('Flow Feature')
        # worksheet.write()
        # workbook.save('flow_feature.xls')
        pass