Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #include <base/logging.h>
       6             : #include <oper/nexthop.h>
       7             : #include <oper/mirror_table.h>
       8             : #include <ksync/ksync_index.h>
       9             : #include <vrouter/ksync/interface_ksync.h>
      10             : #include <vrouter/ksync/nexthop_ksync.h>
      11             : #include <vrouter/ksync/mpls_ksync.h>
      12             : #include <vrouter/ksync/ksync_init.h>
      13             : #include <ksync/ksync_sock.h>
      14             : 
      15          29 : MplsKSyncEntry::MplsKSyncEntry(MplsKSyncObject* obj, const MplsKSyncEntry *me,
      16          29 :                                uint32_t index) :
      17          29 :     KSyncNetlinkDBEntry(index), ksync_obj_(obj), label_(me->label_),
      18          29 :     nh_(NULL)  {
      19          29 : }
      20             : 
      21          29 : MplsKSyncEntry::MplsKSyncEntry(MplsKSyncObject* obj, const MplsLabel *mpls) :
      22          29 :     KSyncNetlinkDBEntry(kInvalidIndex), ksync_obj_(obj),
      23          29 :     label_(mpls->label()), nh_(NULL) {
      24          29 : }
      25             : 
      26         116 : MplsKSyncEntry::~MplsKSyncEntry() {
      27         116 : }
      28             : 
      29         301 : KSyncDBObject *MplsKSyncEntry::GetObject() const {
      30         301 :     return ksync_obj_;
      31             : }
      32             : 
      33         508 : bool MplsKSyncEntry::IsLess(const KSyncEntry &rhs) const {
      34         508 :     const MplsKSyncEntry &entry = static_cast<const MplsKSyncEntry &>(rhs);
      35         508 :     return label_ < entry.label_;
      36             : }
      37             : 
      38         176 : std::string MplsKSyncEntry::ToString() const {
      39         176 :     std::stringstream s;
      40         176 :     NHKSyncEntry *next_hop = nh();
      41             : 
      42         176 :     s << "Mpls : " << label_ << " Index : " << GetIndex();
      43         176 :     if (next_hop) {
      44         176 :         s << next_hop->ToString();
      45             :     } else {
      46           0 :         s << "NextHop :  NULL";
      47             :     }
      48         352 :     return s.str();
      49         176 : }
      50             : 
      51          37 : bool MplsKSyncEntry::Sync(DBEntry *e) {
      52          37 :     bool ret = false;
      53          37 :     const MplsLabel *mpls = static_cast<MplsLabel *>(e);
      54             : 
      55          37 :     NHKSyncObject *nh_object = ksync_obj_->ksync()->nh_ksync_obj();
      56          37 :     if (mpls->nexthop() == NULL) {
      57           0 :         LOG(DEBUG, "nexthop in mpls label is null");
      58           0 :         assert(0);
      59             :     }
      60          37 :     NHKSyncEntry next_hop(nh_object, mpls->nexthop());
      61          37 :     NHKSyncEntry *old_nh = nh();
      62             : 
      63          37 :     nh_ = nh_object->GetReference(&next_hop);
      64          37 :     if (old_nh != nh()) {
      65          37 :         ret = true;
      66             :     }
      67             : 
      68          37 :     return ret;
      69          37 : };
      70             : 
      71          66 : int MplsKSyncEntry::Encode(sandesh_op::type op, char *buf, int buf_len) {
      72          66 :     vr_mpls_req encoder;
      73             :     int encode_len;
      74          66 :     NHKSyncEntry *next_hop = nh();
      75             : 
      76          66 :     encoder.set_h_op(op);
      77          66 :     encoder.set_mr_label(label_);
      78          66 :     encoder.set_mr_rid(0);
      79          66 :     encoder.set_mr_nhid(next_hop->nh_id());
      80          66 :     int error = 0;
      81          66 :     encode_len = encoder.WriteBinary((uint8_t *)buf, buf_len, &error);
      82          66 :     assert(error == 0);
      83          66 :     assert(encode_len <= buf_len);
      84          66 :     return encode_len;
      85          66 : }
      86             : 
      87          66 : void MplsKSyncEntry::FillObjectLog(sandesh_op::type op,
      88             :                                    KSyncMplsInfo &info) const {
      89          66 :     info.set_label(label_);
      90          66 :     info.set_nh(nh()->nh_id());
      91             : 
      92          66 :     if (op == sandesh_op::ADD) {
      93          37 :         info.set_operation("ADD/CHANGE");
      94             :     } else {
      95          29 :         info.set_operation("DELETE");
      96             :     }
      97          66 : }
      98             : 
      99          29 : int MplsKSyncEntry::AddMsg(char *buf, int buf_len) {
     100          29 :     KSyncMplsInfo info;
     101          29 :     FillObjectLog(sandesh_op::ADD, info);
     102          29 :     KSYNC_TRACE(Mpls, GetObject(), info);
     103             : 
     104          58 :     return Encode(sandesh_op::ADD, buf, buf_len);
     105          29 : }
     106             : 
     107           8 : int MplsKSyncEntry::ChangeMsg(char *buf, int buf_len){
     108           8 :     KSyncMplsInfo info;
     109           8 :     FillObjectLog(sandesh_op::ADD, info);
     110           8 :     KSYNC_TRACE(Mpls, GetObject(), info);
     111             : 
     112          16 :     return Encode(sandesh_op::ADD, buf, buf_len);
     113           8 : }
     114             : 
     115          29 : int MplsKSyncEntry::DeleteMsg(char *buf, int buf_len) {
     116          29 :     KSyncMplsInfo info;
     117          29 :     FillObjectLog(sandesh_op::DEL, info);
     118          29 :     KSYNC_TRACE(Mpls, GetObject(), info);
     119             : 
     120          58 :     return Encode(sandesh_op::DEL, buf, buf_len);
     121          29 : }
     122             : 
     123          81 : KSyncEntry *MplsKSyncEntry::UnresolvedReference() {
     124          81 :     NHKSyncEntry *next_hop = nh();
     125          81 :     if (!next_hop->IsResolvedAndInSync()) {
     126          44 :         return next_hop;
     127             :     }
     128          37 :     return NULL;
     129             : }
     130             : 
     131           1 : MplsKSyncObject::MplsKSyncObject(KSync *ksync) :
     132           1 :     KSyncDBObject("KSync Mpls"), ksync_(ksync) {
     133           1 : }
     134             : 
     135           2 : MplsKSyncObject::~MplsKSyncObject() {
     136           2 : }
     137             : 
     138           1 : void MplsKSyncObject::RegisterDBClients() {
     139           1 :     RegisterDb(ksync_->agent()->mpls_table());
     140           1 : }
     141             : 
     142          29 : KSyncEntry *MplsKSyncObject::Alloc(const KSyncEntry *entry, uint32_t index) {
     143          29 :     const MplsKSyncEntry *mpls = static_cast<const MplsKSyncEntry *>(entry);
     144          29 :     MplsKSyncEntry *ksync = new MplsKSyncEntry(this, mpls, index);
     145          29 :     return static_cast<KSyncEntry *>(ksync);
     146             : };
     147             : 
     148          29 : KSyncEntry *MplsKSyncObject::DBToKSyncEntry(const DBEntry *e) {
     149          29 :     const MplsLabel *mpls = static_cast<const MplsLabel *>(e);
     150          29 :     MplsKSyncEntry *key = new MplsKSyncEntry(this, mpls);
     151          29 :     return static_cast<KSyncEntry *>(key);
     152             : }
     153             : 
     154          66 : void vr_mpls_req::Process(SandeshContext *context) {
     155          66 :     AgentSandeshContext *ioc = static_cast<AgentSandeshContext *>(context);
     156          66 :     ioc->MplsMsgHandler(this);
     157          66 : }
     158             :