Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #include "kstate.h"
       6             : #include "interface_kstate.h"
       7             : #include "route_kstate.h"
       8             : #include "nh_kstate.h"
       9             : #include "mpls_kstate.h"
      10             : #include "flow_kstate.h"
      11             : #include "mirror_kstate.h"
      12             : #include "vxlan_kstate.h"
      13             : #include "vrf_assign_kstate.h"
      14             : #include "vrf_stats_kstate.h"
      15             : #include "drop_stats_kstate.h"
      16             : #include "forwarding_class_kstate.h"
      17             : #include "qos_config_kstate.h"
      18             : #include "vrf_kstate.h"
      19             : 
      20           0 : void KInterfaceReq::HandleRequest() const {
      21           0 :     vr_interface_req req;
      22           0 :     KInterfaceResp *resp = new KInterfaceResp();
      23           0 :     resp->set_context(context());
      24             : 
      25           0 :     InterfaceKState *kstate = new InterfaceKState(resp, context(), req,
      26           0 :                                                   get_if_id());
      27           0 :     kstate->EncodeAndSend(req);
      28           0 : }
      29             : 
      30           0 : void KRouteReq::HandleRequest() const {
      31           0 :     vr_route_req req;
      32             :     int prefix_size, family_id;
      33           0 :     std::string family = get_family();
      34             : 
      35           0 :     if(family == "inet6") {
      36           0 :         prefix_size = 16;
      37           0 :         family_id = AF_INET6;
      38           0 :     } else if(family == "bridge") {
      39           0 :         prefix_size = 6;
      40           0 :         family_id = AF_BRIDGE;
      41           0 :     } else if(family == "inet") {
      42           0 :         prefix_size = 4;
      43           0 :         family_id = AF_INET;
      44             :     } else {
      45           0 :         std::string msg("Allowed options for family are inet, inet6, bridge");
      46           0 :         ErrResp *resp = new ErrResp();
      47           0 :         resp->set_resp(msg);
      48           0 :         resp->set_context(context());
      49           0 :         resp->Response();
      50           0 :         return;
      51           0 :     }
      52             : 
      53           0 :     std::vector<int8_t> marker(prefix_size, 0);
      54           0 :     if(family_id == AF_BRIDGE) {
      55           0 :         req.set_rtr_mac(marker);
      56             :     } else {
      57             :         // rtr_prefix needs to be initialized
      58           0 :         req.set_rtr_prefix(marker);
      59           0 :         req.set_rtr_marker_plen(0);
      60             :     }
      61           0 :     req.set_rtr_marker(marker);
      62           0 :     KRouteResp *resp = new KRouteResp();
      63           0 :     resp->set_context(context());
      64             : 
      65           0 :     RouteKState *kstate = new RouteKState(resp, context(), req, get_vrf_id(), family_id, sandesh_op::DUMP, prefix_size);
      66           0 :     kstate->EncodeAndSend(req);
      67           0 : }
      68             : 
      69           0 : void KRouteGetReq::HandleRequest() const {
      70           0 :     vr_route_req req;
      71             :     int family_id, prefix_size;
      72           0 :     boost::system::error_code ec;
      73           0 :     IpAddress addr(IpAddress::from_string(get_prefix(), ec));
      74             : 
      75           0 :     if(addr.is_v4()) {
      76           0 :         family_id = AF_INET;
      77           0 :         prefix_size = 4;
      78           0 :         Ip4Address::bytes_type bytes = addr.to_v4().to_bytes();
      79           0 :         std::vector<int8_t> rtr_prefix(bytes.begin(), bytes.end());
      80           0 :         req.set_rtr_prefix(rtr_prefix);
      81           0 :     } else if(addr.is_v6()) {
      82           0 :         family_id = AF_INET6;
      83           0 :         prefix_size = 16;
      84           0 :         Ip6Address::bytes_type bytes = addr.to_v6().to_bytes();
      85           0 :         std::vector<int8_t> rtr_prefix(bytes.begin(), bytes.end());
      86           0 :         req.set_rtr_prefix(rtr_prefix);
      87           0 :     } else {
      88           0 :         std::string msg("Allowed options for family are inet, inet6");
      89           0 :         ErrResp *resp = new ErrResp();
      90           0 :         resp->set_resp(msg);
      91           0 :         resp->set_context(context());
      92           0 :         resp->Response();
      93           0 :         return;
      94           0 :     }
      95           0 :     std::vector<int8_t> marker(prefix_size, 0);
      96             :     // rtr_prefix needs to be initialized
      97           0 :     req.set_rtr_marker(marker);
      98           0 :     req.set_rtr_marker_plen(0);
      99           0 :     req.set_rtr_prefix_len(get_prefix_len());
     100           0 :     KRouteResp *resp = new KRouteResp();
     101           0 :     resp->set_context(context());
     102             : 
     103           0 :     RouteKState *kstate = new RouteKState(resp, context(), req, get_vrf_id(), family_id, sandesh_op::GET, 0);
     104           0 :     kstate->EncodeAndSend(req);
     105           0 : }
     106             : 
     107           0 : void KNHReq::HandleRequest() const {
     108           0 :     vr_nexthop_req req;
     109           0 :     KNHResp *resp = new KNHResp();
     110           0 :     resp->set_context(context());
     111             : 
     112           0 :     NHKState *kstate = new NHKState(resp, context(), req, get_nh_id());
     113           0 :     kstate->EncodeAndSend(req);
     114           0 : }
     115             : 
     116           0 : void KMplsReq::HandleRequest() const {
     117           0 :     vr_mpls_req req;
     118           0 :     KMplsResp *resp = new KMplsResp();
     119           0 :     resp->set_context(context());
     120             : 
     121           0 :     MplsKState *kstate = new MplsKState(resp, context(), req, get_mpls_label());
     122           0 :     kstate->EncodeAndSend(req);
     123           0 : }
     124             : 
     125           0 : void NextKFlowReq::HandleRequest() const {
     126           0 :     FlowKState *task = new FlowKState(Agent::GetInstance(), context(),
     127           0 :                                       get_flow_handle());
     128           0 :     vector<string> tokens;
     129           0 :     boost::split(tokens, get_flow_handle(), boost::is_any_of(" "));
     130           0 :     if (tokens.size() == 2) {
     131           0 :         task->set_evicted_flag(true);
     132             :     }
     133           0 :     TaskScheduler *scheduler = TaskScheduler::GetInstance();
     134           0 :     scheduler->Enqueue(task);
     135           0 : }
     136             : 
     137           0 : void KFlowReq::HandleRequest() const {
     138           0 :     FlowKState *task = new FlowKState(Agent::GetInstance(), context(),
     139           0 :                                       get_flow_idx());
     140           0 :     task->set_evicted_flag(get_show_evicted());
     141           0 :     TaskScheduler *scheduler = TaskScheduler::GetInstance();
     142           0 :     scheduler->Enqueue(task);
     143           0 : }
     144             : 
     145           0 : void KMirrorReq::HandleRequest() const {
     146           0 :     vr_mirror_req req;
     147           0 :     KMirrorResp *resp = new KMirrorResp();
     148           0 :     resp->set_context(context());
     149             : 
     150           0 :     MirrorKState *kstate = new MirrorKState(resp, context(), req,
     151           0 :                                             get_mirror_id());
     152           0 :     kstate->EncodeAndSend(req);
     153           0 : }
     154             : 
     155           0 : void KVrfAssignReq::HandleRequest() const {
     156           0 :     vr_vrf_assign_req req;
     157           0 :     KVrfAssignResp *resp = new KVrfAssignResp();
     158           0 :     resp->set_context(context());
     159             : 
     160           0 :     VrfAssignKState *kstate = new VrfAssignKState(resp, context(), req,
     161           0 :                                                   get_vif_index());
     162           0 :     kstate->EncodeAndSend(req);
     163           0 : }
     164             : 
     165           0 : void KVrfReq::HandleRequest() const {
     166           0 :     vr_vrf_req req;
     167           0 :     KVrfResp *resp = new KVrfResp();
     168           0 :     resp->set_context(context());
     169             : 
     170           0 :     VrfKState *kstate = new VrfKState(resp, context(), req,
     171           0 :                                           get_vrf_idx());
     172           0 :     kstate->EncodeAndSend(req);
     173           0 : }
     174             : 
     175           0 : void KVrfStatsReq::HandleRequest() const {
     176           0 :     vr_vrf_stats_req req;
     177           0 :     KVrfStatsResp *resp = new KVrfStatsResp();
     178           0 :     resp->set_context(context());
     179             : 
     180           0 :     VrfStatsKState *kstate = new VrfStatsKState(resp, context(), req,
     181           0 :                                                 get_vrf_index());
     182           0 :     kstate->EncodeAndSend(req);
     183           0 : }
     184             : 
     185           0 : void KDropStatsReq::HandleRequest() const {
     186           0 :     vr_drop_stats_req req;
     187           0 :     KDropStatsResp *resp = new KDropStatsResp();
     188           0 :     resp->set_context(context());
     189             : 
     190           0 :     DropStatsKState *kstate = new DropStatsKState(resp, context(), req);
     191           0 :     kstate->EncodeAndSend(req);
     192           0 : }
     193             : 
     194           0 : void KVxLanReq::HandleRequest() const {
     195           0 :     vr_vxlan_req req;
     196           0 :     KVxLanResp *resp = new KVxLanResp();
     197           0 :     resp->set_context(context());
     198             : 
     199           0 :     VxLanKState *kstate = new VxLanKState(resp, context(), req,
     200           0 :                                           get_vxlan_label());
     201           0 :     kstate->EncodeAndSend(req);
     202           0 : }
     203             : 
     204           0 : void KQosConfigReq::HandleRequest() const {
     205             : 
     206           0 :     vr_qos_map_req req;
     207           0 :     KQosConfigResp *resp = new KQosConfigResp();
     208           0 :     resp->set_context(context());
     209             : 
     210           0 :     QosConfigKState *kstate = new QosConfigKState(resp, context(), req,
     211           0 :                                                   get_index());
     212           0 :     kstate->EncodeAndSend(req);
     213           0 : }
     214             : 
     215           0 : void KForwardingClassReq::HandleRequest() const {
     216           0 :     vr_fc_map_req req;
     217           0 :     KForwardingClassResp *resp = new KForwardingClassResp();
     218           0 :     resp->set_context(context());
     219             : 
     220           0 :     ForwardingClassKState *kstate = new ForwardingClassKState(resp, context(),
     221             :                                                   req,
     222           0 :                                                   get_index());
     223           0 :     kstate->EncodeAndSend(req);
     224           0 : }