# Copyright (C) 2012 Nippon Telegraph and Telephone Corporation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# pylint: disable=unused-argument,disable=missing-function-docstring,disable=use-dict-literal
# pylint: disable=no-member,disable=invalid-name,disable=too-many-arguments,disable=too-few-public-methods
# pytype: disable=attribute-error

import os
import logging
import json
import ast

from os_ken.base import app_manager
from os_ken.controller import ofp_event
from os_ken.controller import dpset
from os_ken.controller.handler import MAIN_DISPATCHER
from os_ken.controller.handler import set_ev_cls
from os_ken.exception import OSKenException
from os_ken.ofproto import ofproto_v1_3
from os_ken.lib import ofctl_v1_3
from os_ken.lib import hub
from wsgi import ControllerBase
from wsgi import Response
from wsgi import WSGIApplication, WSGIServer

LOG = logging.getLogger("os_ken.app.ofctl_rest")

DEFAULT_WSGI_HOST = "0.0.0.0"
DEFAULT_WSGI_PORT = 8080

OFCTL_HOST = os.getenv("OFCTL_HOST", "0.0.0.0")
OFCTL_PORT = int(os.getenv("OFCTL_PORT", "8080"))

# supported ofctl versions in this restful app
supported_ofctl = {
    ofproto_v1_3.OFP_VERSION: ofctl_v1_3,
}

# REST API
#

# Retrieve the switch stats
#
# get the list of all switches
# GET /stats/switches
#
# get the desc stats of the switch
# GET /stats/desc/<dpid>
#
# get flows desc stats of the switch
# GET /stats/flowdesc/<dpid>
#
# get flows desc stats of the switch filtered by the fields
# POST /stats/flowdesc/<dpid>
#
# get flows stats of the switch
# GET /stats/flow/<dpid>
#
# get flows stats of the switch filtered by the fields
# POST /stats/flow/<dpid>
#
# get aggregate flows stats of the switch
# GET /stats/aggregateflow/<dpid>
#
# get aggregate flows stats of the switch filtered by the fields
# POST /stats/aggregateflow/<dpid>
#
# get table stats of the switch
# GET /stats/table/<dpid>
#
# get table features stats of the switch
# GET /stats/tablefeatures/<dpid>
#
# get ports stats of the switch
# GET /stats/port/<dpid>[/<port>]
# Note: Specification of port number is optional
#
# get queues stats of the switch
# GET /stats/queue/<dpid>[/<port>[/<queue_id>]]
# Note: Specification of port number and queue id are optional
#       If you want to omitting the port number and setting the queue id,
#       please specify the keyword "ALL" to the port number
#       e.g. GET /stats/queue/1/ALL/1
#
# get queues config stats of the switch
# GET /stats/queueconfig/<dpid>[/<port>]
# Note: Specification of port number is optional
#
# get queues desc stats of the switch
# GET /stats/queuedesc/<dpid>[/<port>[/<queue_id>]]
# Note: Specification of port number and queue id are optional
#       If you want to omitting the port number and setting the queue id,
#       please specify the keyword "ALL" to the port number
#       e.g. GET /stats/queuedesc/1/ALL/1
#
# get meter features stats of the switch
# GET /stats/meterfeatures/<dpid>
#
# get meter config stats of the switch
# GET /stats/meterconfig/<dpid>[/<meter_id>]
# Note: Specification of meter id is optional
#
# get meter desc stats of the switch
# GET /stats/meterdesc/<dpid>[/<meter_id>]
# Note: Specification of meter id is optional
#
# get meters stats of the switch
# GET /stats/meter/<dpid>[/<meter_id>]
# Note: Specification of meter id is optional
#
# get group features stats of the switch
# GET /stats/groupfeatures/<dpid>
#
# get groups desc stats of the switch
# GET /stats/groupdesc/<dpid>[/<group_id>]
# Note: Specification of group id is optional (OpenFlow 1.5 or later)
#
# get groups stats of the switch
# GET /stats/group/<dpid>[/<group_id>]
# Note: Specification of group id is optional
#
# get ports description of the switch
# GET /stats/portdesc/<dpid>[/<port_no>]
# Note: Specification of port number is optional (OpenFlow 1.5 or later)

# Update the switch stats
#
# add a flow entry
# POST /stats/flowentry/add
#
# modify all matching flow entries
# POST /stats/flowentry/modify
#
# modify flow entry strictly matching wildcards and priority
# POST /stats/flowentry/modify_strict
#
# delete all matching flow entries
# POST /stats/flowentry/delete
#
# delete flow entry strictly matching wildcards and priority
# POST /stats/flowentry/delete_strict
#
# delete all flow entries of the switch
# DELETE /stats/flowentry/clear/<dpid>
#
# add a meter entry
# POST /stats/meterentry/add
#
# modify a meter entry
# POST /stats/meterentry/modify
#
# delete a meter entry
# POST /stats/meterentry/delete
#
# add a group entry
# POST /stats/groupentry/add
#
# modify a group entry
# POST /stats/groupentry/modify
#
# delete a group entry
# POST /stats/groupentry/delete
#
# modify behavior of the physical port
# POST /stats/portdesc/modify
#
# modify role of controller
# POST /stats/role
#
#
# send a experimeter message
# POST /stats/experimenter/<dpid>


class CommandNotFoundError(OSKenException):
    message = "No such command : %(cmd)s"


class PortNotFoundError(OSKenException):
    message = "No such port info: %(port_no)s"


def stats_method(method):
    def wrapper(self, req, dpid, *args, **kwargs):
        # Get datapath instance from DPSet
        try:
            dp = self.dpset.get(int(str(dpid), 0))
        except ValueError:
            LOG.exception("Invalid dpid: %s", dpid)
            return Response(status=400)
        if dp is None:
            LOG.error("No such Datapath: %s", dpid)
            return Response(status=404)

        # Get lib/ofctl_* module
        try:
            ofctl = supported_ofctl.get(dp.ofproto.OFP_VERSION)
        except KeyError:
            LOG.exception("Unsupported OF version: %s", dp.ofproto.OFP_VERSION)
            return Response(status=501)

        # Invoke StatsController method
        try:
            ret = method(self, req, dp, ofctl, *args, **kwargs)
            return Response(content_type="application/json", body=json.dumps(ret))
        except ValueError:
            LOG.exception("Invalid syntax: %s", req.body)
            return Response(status=400)
        except AttributeError:
            LOG.exception(
                "Unsupported OF request in this version: %s", dp.ofproto.OFP_VERSION
            )
            return Response(status=501)

    return wrapper


def command_method(method):
    def wrapper(self, req, *args, **kwargs):
        # Parse request json body
        try:
            if req.body:
                # We use ast.literal_eval() to parse request json body
                # instead of json.loads().
                # Because we need to parse binary format body
                # in send_experimenter().
                body = ast.literal_eval(req.body.decode("utf-8"))
            else:
                body = {}
        except SyntaxError:
            LOG.exception("Invalid syntax: %s", req.body)
            return Response(status=400)

        # Get datapath_id from request parameters
        dpid = body.get("dpid", None)
        if not dpid:
            try:
                dpid = kwargs.pop("dpid")
            except KeyError:
                LOG.exception("Cannot get dpid from request parameters")
                return Response(status=400)

        # Get datapath instance from DPSet
        try:
            dp = self.dpset.get(int(str(dpid), 0))
        except ValueError:
            LOG.exception("Invalid dpid: %s", dpid)
            return Response(status=400)
        if dp is None:
            LOG.error("No such Datapath: %s", dpid)
            return Response(status=404)

        # Get lib/ofctl_* module
        try:
            ofctl = supported_ofctl.get(dp.ofproto.OFP_VERSION)
        except KeyError:
            LOG.exception("Unsupported OF version: version=%s", dp.ofproto.OFP_VERSION)
            return Response(status=501)

        # Invoke StatsController method
        try:
            method(self, req, dp, ofctl, body, *args, **kwargs)
            return Response(status=200)
        except ValueError:
            LOG.exception("Invalid syntax: %s", req.body)
            return Response(status=400)
        except AttributeError:
            LOG.exception(
                "Unsupported OF request in this version: %s", dp.ofproto.OFP_VERSION
            )
            return Response(status=501)
        except CommandNotFoundError as e:
            LOG.exception(e.message)
            return Response(status=404)
        except PortNotFoundError as e:
            LOG.exception(e.message)
            return Response(status=404)

    return wrapper


class StatsController(ControllerBase):
    def __init__(self, req, link, data, **config):
        super().__init__(req, link, data, **config)
        self.dpset = data["dpset"]
        self.waiters = data["waiters"]

    def get_dpids(self, req, **_kwargs):
        dps = list(self.dpset.dps.keys())
        body = json.dumps(dps)
        return Response(content_type="application/json", body=body)

    @stats_method
    def get_desc_stats(self, req, dp, ofctl, **kwargs):
        return ofctl.get_desc_stats(dp, self.waiters)

    @stats_method
    def get_flow_desc(self, req, dp, ofctl, **kwargs):
        flow = req.json if req.body else {}
        return ofctl.get_flow_desc(dp, self.waiters, flow)

    @stats_method
    def get_flow_stats(self, req, dp, ofctl, **kwargs):
        flow = req.json if req.body else {}
        return ofctl.get_flow_stats(dp, self.waiters, flow)

    @stats_method
    def get_aggregate_flow_stats(self, req, dp, ofctl, **kwargs):
        flow = req.json if req.body else {}
        return ofctl.get_aggregate_flow_stats(dp, self.waiters, flow)

    @stats_method
    def get_table_stats(self, req, dp, ofctl, **kwargs):
        return ofctl.get_table_stats(dp, self.waiters)

    @stats_method
    def get_table_features(self, req, dp, ofctl, **kwargs):
        return ofctl.get_table_features(dp, self.waiters)

    @stats_method
    def get_port_stats(self, req, dp, ofctl, port=None, **kwargs):
        if port == "ALL":
            port = None

        return ofctl.get_port_stats(dp, self.waiters, port)

    @stats_method
    def get_queue_stats(self, req, dp, ofctl, port=None, queue_id=None, **kwargs):
        if port == "ALL":
            port = None

        if queue_id == "ALL":
            queue_id = None

        return ofctl.get_queue_stats(dp, self.waiters, port, queue_id)

    @stats_method
    def get_queue_config(self, req, dp, ofctl, port=None, **kwargs):
        if port == "ALL":
            port = None

        return ofctl.get_queue_config(dp, self.waiters, port)

    @stats_method
    def get_queue_desc(self, req, dp, ofctl, port=None, queue=None, **_kwargs):
        if port == "ALL":
            port = None

        if queue == "ALL":
            queue = None

        return ofctl.get_queue_desc(dp, self.waiters, port, queue)

    @stats_method
    def get_meter_features(self, req, dp, ofctl, **kwargs):
        return ofctl.get_meter_features(dp, self.waiters)

    @stats_method
    def get_meter_config(self, req, dp, ofctl, meter_id=None, **kwargs):
        if meter_id == "ALL":
            meter_id = None

        return ofctl.get_meter_config(dp, self.waiters, meter_id)

    @stats_method
    def get_meter_desc(self, req, dp, ofctl, meter_id=None, **kwargs):
        if meter_id == "ALL":
            meter_id = None

        return ofctl.get_meter_desc(dp, self.waiters, meter_id)

    @stats_method
    def get_meter_stats(self, req, dp, ofctl, meter_id=None, **kwargs):
        if meter_id == "ALL":
            meter_id = None

        return ofctl.get_meter_stats(dp, self.waiters, meter_id)

    @stats_method
    def get_group_features(self, req, dp, ofctl, **kwargs):
        return ofctl.get_group_features(dp, self.waiters)

    @stats_method
    def get_group_desc(self, req, dp, ofctl, group_id=None, **kwargs):
        return ofctl.get_group_desc(dp, self.waiters)

    @stats_method
    def get_group_stats(self, req, dp, ofctl, group_id=None, **kwargs):
        if group_id == "ALL":
            group_id = None

        return ofctl.get_group_stats(dp, self.waiters, group_id)

    @stats_method
    def get_port_desc(self, req, dp, ofctl, port_no=None, **kwargs):
        return ofctl.get_port_desc(dp, self.waiters)

    @stats_method
    def get_role(self, req, dp, ofctl, **kwargs):
        return ofctl.get_role(dp, self.waiters)

    @command_method
    def mod_flow_entry(self, req, dp, ofctl, flow, cmd, **kwargs):
        cmd_convert = {
            "add": dp.ofproto.OFPFC_ADD,
            "modify": dp.ofproto.OFPFC_MODIFY,
            "modify_strict": dp.ofproto.OFPFC_MODIFY_STRICT,
            "delete": dp.ofproto.OFPFC_DELETE,
            "delete_strict": dp.ofproto.OFPFC_DELETE_STRICT,
        }
        mod_cmd = cmd_convert.get(cmd, None)
        if mod_cmd is None:
            raise CommandNotFoundError(cmd=cmd)

        ofctl.mod_flow_entry(dp, flow, mod_cmd)

    @command_method
    def delete_flow_entry(self, req, dp, ofctl, flow, **kwargs):
        flow = {"table_id": dp.ofproto.OFPTT_ALL}
        ofctl.mod_flow_entry(dp, flow, dp.ofproto.OFPFC_DELETE)

    @command_method
    def mod_meter_entry(self, req, dp, ofctl, meter, cmd, **kwargs):
        cmd_convert = {
            "add": dp.ofproto.OFPMC_ADD,
            "modify": dp.ofproto.OFPMC_MODIFY,
            "delete": dp.ofproto.OFPMC_DELETE,
        }
        mod_cmd = cmd_convert.get(cmd, None)
        if mod_cmd is None:
            raise CommandNotFoundError(cmd=cmd)

        ofctl.mod_meter_entry(dp, meter, mod_cmd)

    @command_method
    def mod_group_entry(self, req, dp, ofctl, group, cmd, **kwargs):
        cmd_convert = {
            "add": dp.ofproto.OFPGC_ADD,
            "modify": dp.ofproto.OFPGC_MODIFY,
            "delete": dp.ofproto.OFPGC_DELETE,
        }
        mod_cmd = cmd_convert.get(cmd, None)
        if mod_cmd is None:
            raise CommandNotFoundError(cmd=cmd)

        ofctl.mod_group_entry(dp, group, mod_cmd)

    @command_method
    def mod_port_behavior(self, req, dp, ofctl, port_config, cmd, **kwargs):
        port_no = port_config.get("port_no", None)
        port_no = int(str(port_no), 0)

        port_info = self.dpset.port_state[int(dp.id)].get(port_no)
        if port_info:
            port_config.setdefault("hw_addr", port_info.hw_addr)
            port_config.setdefault("advertise", port_info.advertised)
        else:
            raise PortNotFoundError(port_no=port_no)

        if cmd != "modify":
            raise CommandNotFoundError(cmd=cmd)

        ofctl.mod_port_behavior(dp, port_config)

    @command_method
    def send_experimenter(self, req, dp, ofctl, exp, **kwargs):
        ofctl.send_experimenter(dp, exp)

    @command_method
    def set_role(self, req, dp, ofctl, role, **kwargs):
        ofctl.set_role(dp, role)


class RestStatsApi(app_manager.OSKenApp):
    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]
    _CONTEXTS = {"dpset": dpset.DPSet, "wsgi": WSGIApplication}

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.dpset = kwargs["dpset"]
        wsgi = kwargs["wsgi"]
        self.waiters = {}
        self.data = {}
        self.data["dpset"] = self.dpset
        self.data["waiters"] = self.waiters
        mapper = wsgi.mapper

        wsgi.registory["StatsController"] = self.data
        path = "/stats"
        uri = path + "/switches"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_dpids",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/desc/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_desc_stats",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/flowdesc/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_flow_stats",
            conditions=dict(method=["GET", "POST"]),
        )

        uri = path + "/flow/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_flow_stats",
            conditions=dict(method=["GET", "POST"]),
        )

        uri = path + "/aggregateflow/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_aggregate_flow_stats",
            conditions=dict(method=["GET", "POST"]),
        )

        uri = path + "/table/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_table_stats",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/tablefeatures/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_table_features",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/port/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_port_stats",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/port/{dpid}/{port}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_port_stats",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/queue/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_queue_stats",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/queue/{dpid}/{port}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_queue_stats",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/queue/{dpid}/{port}/{queue_id}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_queue_stats",
            conditions=dict(method=["GET"]),
        )
        uri = path + "/queueconfig/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_queue_config",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/queueconfig/{dpid}/{port}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_queue_config",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/queuedesc/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_queue_desc",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/queuedesc/{dpid}/{port}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_queue_desc",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/queuedesc/{dpid}/{port}/{queue}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_queue_desc",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/meterfeatures/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_meter_features",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/meterconfig/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_meter_config",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/meterconfig/{dpid}/{meter_id}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_meter_config",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/meterdesc/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_meter_desc",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/meterdesc/{dpid}/{meter_id}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_meter_desc",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/meter/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_meter_stats",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/meter/{dpid}/{meter_id}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_meter_stats",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/groupfeatures/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_group_features",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/groupdesc/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_group_desc",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/groupdesc/{dpid}/{group_id}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_group_desc",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/group/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_group_stats",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/group/{dpid}/{group_id}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_group_stats",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/portdesc/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_port_desc",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/portdesc/{dpid}/{port_no}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_port_desc",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/role/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="get_role",
            conditions=dict(method=["GET"]),
        )

        uri = path + "/flowentry/{cmd}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="mod_flow_entry",
            conditions=dict(method=["POST"]),
        )

        uri = path + "/flowentry/clear/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="delete_flow_entry",
            conditions=dict(method=["DELETE"]),
        )

        uri = path + "/meterentry/{cmd}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="mod_meter_entry",
            conditions=dict(method=["POST"]),
        )

        uri = path + "/groupentry/{cmd}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="mod_group_entry",
            conditions=dict(method=["POST"]),
        )

        uri = path + "/portdesc/{cmd}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="mod_port_behavior",
            conditions=dict(method=["POST"]),
        )

        uri = path + "/experimenter/{dpid}"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="send_experimenter",
            conditions=dict(method=["POST"]),
        )

        uri = path + "/role"
        mapper.connect(
            "stats",
            uri,
            controller=StatsController,
            action="set_role",
            conditions=dict(method=["POST"]),
        )

        self.server = WSGIServer(wsgi, OFCTL_HOST, OFCTL_PORT)
        self.server_thread = hub.spawn(self.server.serve_forever)

    @set_ev_cls(
        [
            ofp_event.EventOFPStatsReply,
            ofp_event.EventOFPDescStatsReply,
            ofp_event.EventOFPFlowStatsReply,
            ofp_event.EventOFPAggregateStatsReply,
            ofp_event.EventOFPTableStatsReply,
            ofp_event.EventOFPTableFeaturesStatsReply,
            ofp_event.EventOFPPortStatsReply,
            ofp_event.EventOFPQueueStatsReply,
            ofp_event.EventOFPQueueDescStatsReply,
            ofp_event.EventOFPMeterStatsReply,
            ofp_event.EventOFPMeterFeaturesStatsReply,
            ofp_event.EventOFPMeterConfigStatsReply,
            ofp_event.EventOFPGroupStatsReply,
            ofp_event.EventOFPGroupFeaturesStatsReply,
            ofp_event.EventOFPGroupDescStatsReply,
            ofp_event.EventOFPPortDescStatsReply,
        ],
        MAIN_DISPATCHER,
    )
    def stats_reply_handler(self, ev):
        msg = ev.msg
        dp = msg.datapath

        if dp.id not in self.waiters:
            return
        if msg.xid not in self.waiters[dp.id]:
            return
        lock, msgs = self.waiters[dp.id][msg.xid]
        msgs.append(msg)

        flags = dp.ofproto.OFPMPF_REPLY_MORE

        if msg.flags & flags:
            return
        del self.waiters[dp.id][msg.xid]
        lock.set()

    @set_ev_cls(
        [
            ofp_event.EventOFPSwitchFeatures,
            ofp_event.EventOFPQueueGetConfigReply,
            ofp_event.EventOFPRoleReply,
        ],
        MAIN_DISPATCHER,
    )
    def features_reply_handler(self, ev):
        msg = ev.msg
        dp = msg.datapath

        if dp.id not in self.waiters:
            return
        if msg.xid not in self.waiters[dp.id]:
            return
        lock, msgs = self.waiters[dp.id][msg.xid]
        msgs.append(msg)

        del self.waiters[dp.id][msg.xid]
        lock.set()
