RYU SDN controller - want to use rest_router function with event

Question

I'm studying SDN with mininet and ryu controller.
What I'm trying to do is developing custom routing protocol ryu app that works with rest_router app. For the performance issue, I want to use event-driven method instead of REST API. https://github.com/faucetsdn/ryu/blob/master/ryu/app/rest_router.py

Procedure

1. custom routing protocol calculate the path
2. custom routing protocol app create the custom event
3. RestRouterAPI app in rest_router receive the event
4. Execute set_data action.

I've succeed with step 2 and 3, but couldn't find the solution for step 4. Is there any way to do this?

    class RestRouterAPI(app_manager.RyuApp):
    
        OFP_VERSIONS = [ofproto_v1_0.OFP_VERSION,
                        ofproto_v1_2.OFP_VERSION,
                        ofproto_v1_3.OFP_VERSION]
    
        _CONTEXTS = {'dpset': dpset.DPSet,
                     'wsgi': WSGIApplication}
    
        def __init__(self, *args, **kwargs):
            super(RestRouterAPI, self).__init__(*args, **kwargs)
    
            # logger configure
            RouterController.set_logger(self.logger)
    
            wsgi = kwargs['wsgi']
            self.waiters = {}
            self.data = {'waiters': self.waiters}
    
            mapper = wsgi.mapper
            wsgi.registory['RouterController'] = self.data
            requirements = {'switch_id': SWITCHID_PATTERN,
                            'vlan_id': VLANID_PATTERN}
    
            # For no vlan data
            path = '/router/{switch_id}'
            mapper.connect('router', path, controller=RouterController,
                           requirements=requirements,
                           action='get_data',
                           conditions=dict(method=['GET']))
            mapper.connect('router', path, controller=RouterController,
                           requirements=requirements,
                           action='set_data',
                           conditions=dict(method=['POST']))
            mapper.connect('router', path, controller=RouterController,
                           requirements=requirements,
                           action='delete_data',
                           conditions=dict(method=['DELETE']))
            # For vlan data
            path = '/router/{switch_id}/{vlan_id}'
            mapper.connect('router', path, controller=RouterController,
                           requirements=requirements,
                           action='get_vlan_data',
                           conditions=dict(method=['GET']))
            mapper.connect('router', path, controller=RouterController,
                           requirements=requirements,
                           action='set_vlan_data',
                           conditions=dict(method=['POST']))
            mapper.connect('router', path, controller=RouterController,
                           requirements=requirements,
                           action='delete_vlan_data',
                           conditions=dict(method=['DELETE']))
    
        @set_ev_cls(dpset.EventDP, dpset.DPSET_EV_DISPATCHER)
        def datapath_handler(self, ev):
            if ev.enter:
                RouterController.register_router(ev.dp)
            else:
                RouterController.unregister_router(ev.dp)
    
        @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
        def packet_in_handler(self, ev):
            RouterController.packet_in_handler(ev.msg)
    
        def _stats_reply_handler(self, ev):
            msg = ev.msg
            dp = msg.datapath
    
            if (dp.id not in self.waiters
                    or msg.xid not in self.waiters[dp.id]):
                return
            event, msgs = self.waiters[dp.id][msg.xid]
            msgs.append(msg)
    
            if ofproto_v1_3.OFP_VERSION == dp.ofproto.OFP_VERSION:
                more = dp.ofproto.OFPMPF_REPLY_MORE
            else:
                more = dp.ofproto.OFPSF_REPLY_MORE
            if msg.flags & more:
                return
            del self.waiters[dp.id][msg.xid]
            event.set()
    
        # for OpenFlow version1.0
        @set_ev_cls(ofp_event.EventOFPFlowStatsReply, MAIN_DISPATCHER)
        def stats_reply_handler_v1_0(self, ev):
            self._stats_reply_handler(ev)
    
        # for OpenFlow version1.2/1.3
        @set_ev_cls(ofp_event.EventOFPStatsReply, MAIN_DISPATCHER)
        def stats_reply_handler_v1_2(self, ev):
            self._stats_reply_handler(ev)
    
        @set_ev_cls(custom_event.EventRouteSetRequest)
        def route_set_request_handler(self, req):
            return_msg = []
            
            // I want to use set_data in RouterController class
            
            rep = route_event.EventRouteSetReply(req.src, return_msg)
            self.reply_to_request(req, rep)
    
    
    class RouterController(ControllerBase):
    
        _ROUTER_LIST = {}
        _LOGGER = None
    
        def __init__(self, req, link, data, **config):
            super(RouterController, self).__init__(req, link, data, **config)
            self.waiters = data['waiters']
    
        # POST /router/{switch_id}
        @rest_command
        def set_data(self, req, switch_id, **_kwargs):
            return self._access_router(switch_id, VLANID_NONE,
                                       'set_data', req)