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          82 : MplsKSyncEntry::MplsKSyncEntry(MplsKSyncObject* obj, const MplsKSyncEntry *me,
      16          82 :                                uint32_t index) :
      17          82 :     KSyncNetlinkDBEntry(index), ksync_obj_(obj), label_(me->label_),
      18          82 :     nh_(NULL)  {
      19          82 : }
      20             : 
      21          82 : MplsKSyncEntry::MplsKSyncEntry(MplsKSyncObject* obj, const MplsLabel *mpls) :
      22          82 :     KSyncNetlinkDBEntry(kInvalidIndex), ksync_obj_(obj),
      23          82 :     label_(mpls->label()), nh_(NULL) {
      24          82 : }
      25             : 
      26         328 : MplsKSyncEntry::~MplsKSyncEntry() {
      27         328 : }
      28             : 
      29         833 : KSyncDBObject *MplsKSyncEntry::GetObject() const {
      30         833 :     return ksync_obj_;
      31             : }
      32             : 
      33        1510 : bool MplsKSyncEntry::IsLess(const KSyncEntry &rhs) const {
      34        1510 :     const MplsKSyncEntry &entry = static_cast<const MplsKSyncEntry &>(rhs);
      35        1510 :     return label_ < entry.label_;
      36             : }
      37             : 
      38         489 : std::string MplsKSyncEntry::ToString() const {
      39         489 :     std::stringstream s;
      40         489 :     NHKSyncEntry *next_hop = nh();
      41             : 
      42         489 :     s << "Mpls : " << label_ << " Index : " << GetIndex();
      43         489 :     if (next_hop) {
      44         489 :         s << next_hop->ToString();
      45             :     } else {
      46           0 :         s << "NextHop :  NULL";
      47             :     }
      48         978 :     return s.str();
      49         489 : }
      50             : 
      51         102 : bool MplsKSyncEntry::Sync(DBEntry *e) {
      52         102 :     bool ret = false;
      53         102 :     const MplsLabel *mpls = static_cast<MplsLabel *>(e);
      54             : 
      55         102 :     NHKSyncObject *nh_object = ksync_obj_->ksync()->nh_ksync_obj();
      56         102 :     if (mpls->nexthop() == NULL) {
      57           0 :         LOG(DEBUG, "nexthop in mpls label is null");
      58           0 :         assert(0);
      59             :     }
      60         102 :     NHKSyncEntry next_hop(nh_object, mpls->nexthop());
      61         102 :     NHKSyncEntry *old_nh = nh();
      62             : 
      63         102 :     nh_ = nh_object->GetReference(&next_hop);
      64         102 :     if (old_nh != nh()) {
      65         102 :         ret = true;
      66             :     }
      67             : 
      68         102 :     return ret;
      69         102 : };
      70             : 
      71         184 : int MplsKSyncEntry::Encode(sandesh_op::type op, char *buf, int buf_len) {
      72         184 :     vr_mpls_req encoder;
      73             :     int encode_len;
      74         184 :     NHKSyncEntry *next_hop = nh();
      75             : 
      76         184 :     encoder.set_h_op(op);
      77         184 :     encoder.set_mr_label(label_);
      78         184 :     encoder.set_mr_rid(0);
      79         184 :     encoder.set_mr_nhid(next_hop->nh_id());
      80         184 :     int error = 0;
      81         184 :     encode_len = encoder.WriteBinary((uint8_t *)buf, buf_len, &error);
      82         184 :     assert(error == 0);
      83         184 :     assert(encode_len <= buf_len);
      84         184 :     return encode_len;
      85         184 : }
      86             : 
      87         184 : void MplsKSyncEntry::FillObjectLog(sandesh_op::type op,
      88             :                                    KSyncMplsInfo &info) const {
      89         184 :     info.set_label(label_);
      90         184 :     info.set_nh(nh()->nh_id());
      91             : 
      92         184 :     if (op == sandesh_op::ADD) {
      93         102 :         info.set_operation("ADD/CHANGE");
      94             :     } else {
      95          82 :         info.set_operation("DELETE");
      96             :     }
      97         184 : }
      98             : 
      99          82 : int MplsKSyncEntry::AddMsg(char *buf, int buf_len) {
     100          82 :     KSyncMplsInfo info;
     101          82 :     FillObjectLog(sandesh_op::ADD, info);
     102          82 :     KSYNC_TRACE(Mpls, GetObject(), info);
     103             : 
     104         164 :     return Encode(sandesh_op::ADD, buf, buf_len);
     105          82 : }
     106             : 
     107          20 : int MplsKSyncEntry::ChangeMsg(char *buf, int buf_len){
     108          20 :     KSyncMplsInfo info;
     109          20 :     FillObjectLog(sandesh_op::ADD, info);
     110          20 :     KSYNC_TRACE(Mpls, GetObject(), info);
     111             : 
     112          40 :     return Encode(sandesh_op::ADD, buf, buf_len);
     113          20 : }
     114             : 
     115          82 : int MplsKSyncEntry::DeleteMsg(char *buf, int buf_len) {
     116          82 :     KSyncMplsInfo info;
     117          82 :     FillObjectLog(sandesh_op::DEL, info);
     118          82 :     KSYNC_TRACE(Mpls, GetObject(), info);
     119             : 
     120         164 :     return Encode(sandesh_op::DEL, buf, buf_len);
     121          82 : }
     122             : 
     123         223 : KSyncEntry *MplsKSyncEntry::UnresolvedReference() {
     124         223 :     NHKSyncEntry *next_hop = nh();
     125         223 :     if (!next_hop->IsResolvedAndInSync()) {
     126         121 :         return next_hop;
     127             :     }
     128         102 :     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          82 : KSyncEntry *MplsKSyncObject::Alloc(const KSyncEntry *entry, uint32_t index) {
     143          82 :     const MplsKSyncEntry *mpls = static_cast<const MplsKSyncEntry *>(entry);
     144          82 :     MplsKSyncEntry *ksync = new MplsKSyncEntry(this, mpls, index);
     145          82 :     return static_cast<KSyncEntry *>(ksync);
     146             : };
     147             : 
     148          82 : KSyncEntry *MplsKSyncObject::DBToKSyncEntry(const DBEntry *e) {
     149          82 :     const MplsLabel *mpls = static_cast<const MplsLabel *>(e);
     150          82 :     MplsKSyncEntry *key = new MplsKSyncEntry(this, mpls);
     151          82 :     return static_cast<KSyncEntry *>(key);
     152             : }
     153             : 
     154         184 : void vr_mpls_req::Process(SandeshContext *context) {
     155         184 :     AgentSandeshContext *ioc = static_cast<AgentSandeshContext *>(context);
     156         184 :     ioc->MplsMsgHandler(this);
     157         184 : }
     158             :