Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #include "ifmap/ifmap_link_table.h"
       6             : 
       7             : #include <boost/bind/bind.hpp>
       8             : 
       9             : #include "db/db.h"
      10             : #include "db/db_graph.h"
      11             : #include "db/db_table_partition.h"
      12             : #include "ifmap/ifmap_link.h"
      13             : #include "ifmap/ifmap_log.h"
      14             : #include "ifmap/ifmap_log_types.h"
      15             : 
      16             : using namespace std;
      17             : using namespace boost::placeholders;
      18             : 
      19         219 : IFMapLinkTable::IFMapLinkTable(DB *db, const string &name, DBGraph *graph)
      20         219 :         : DBGraphTable(db, name, graph) {
      21         219 : }
      22             : 
      23           0 : void IFMapLinkTable::Input(DBTablePartition *partition, DBClient *client,
      24             :                            DBRequest *req) {
      25           0 :     assert(false);
      26             : }
      27             : 
      28        6828 : std::unique_ptr<DBEntry> IFMapLinkTable::AllocEntry(
      29             :         const DBRequestKey *key) const {
      30        6828 :     const RequestKey *rkey = static_cast<const RequestKey *>(key);
      31        6828 :     unique_ptr<DBEntry> entry(new IFMapLink(rkey->name));
      32        6828 :     return entry;
      33             : }
      34             : 
      35             : // Generate an unique name for the link node and it should
      36             : // be independent of the order in which the right and left nodes are specified
      37        6802 : std::string IFMapLinkTable::LinkKey(const string &metadata,
      38             :                                         IFMapNode *left, IFMapNode *right) {
      39        6802 :     ostringstream oss;
      40        6802 :     if (left->ToString() < right->ToString()) {
      41        3100 :         oss << metadata << "," << left->ToString() << "," << right->ToString();
      42             :     } else {
      43        3702 :         oss << metadata << "," << right->ToString() << "," << left->ToString();
      44             :     }
      45       13604 :     return oss.str();
      46        6802 : }
      47             : 
      48        3218 : IFMapLink *IFMapLinkTable::AddLink(IFMapNode *left, IFMapNode *right,
      49             :                              const string &metadata, uint64_t sequence_number,
      50             :                              const IFMapOrigin &origin) {
      51             :     DBTablePartition *partition =
      52        3218 :         static_cast<DBTablePartition *>(GetTablePartition(0));
      53             : 
      54        3218 :     string link_name = LinkKey(metadata, left, right);
      55        3218 :     IFMapLink *link = FindLink(link_name);
      56        3218 :     if (link) {
      57           4 :         assert(link->IsDeleted());
      58           4 :         link->SetLinkRevival(true);
      59           4 :         link->ClearDelete();
      60           4 :         link->set_last_change_at_to_now();
      61           4 :         partition->Change(link);
      62             :     } else {
      63        3214 :         link = new IFMapLink(link_name);
      64        3214 :         partition->Add(link);
      65             :     }
      66        3218 :     link->SetProperties(left, right, metadata, sequence_number, origin);
      67        3218 :     assert(dynamic_cast<IFMapNode *>(left));
      68        3218 :     assert(dynamic_cast<IFMapNode *>(right));
      69        3218 :     return link;
      70        3218 : }
      71             : 
      72        3552 : IFMapLink *IFMapLinkTable::FindLink(const string &metadata, IFMapNode *left, IFMapNode *right) {
      73        3552 :     string link_name = LinkKey(metadata, left, right);
      74        7104 :     return FindLink(link_name);
      75        3552 : }
      76             : 
      77        6828 : IFMapLink *IFMapLinkTable::FindLink(const string &name) {
      78             : 
      79             :     DBTablePartition *partition =
      80        6828 :         static_cast<DBTablePartition *>(GetTablePartition(0));
      81        6828 :     RequestKey key;
      82        6828 :     key.name = name;
      83       13656 :     return static_cast<IFMapLink *>(partition->Find(&key));
      84        6828 : }
      85             : 
      86           0 : IFMapLink *IFMapLinkTable::FindNextLink(const string &name) {
      87             : 
      88             :     DBTablePartition *partition =
      89           0 :         static_cast<DBTablePartition *>(GetTablePartition(0));
      90           0 :     RequestKey key;
      91           0 :     key.name = name;
      92           0 :     return static_cast<IFMapLink *>(partition->FindNext(&key));
      93           0 : }
      94             : 
      95         166 : void IFMapLinkTable::DeleteLink(IFMapLink *link) {
      96         166 :     DBGraphEdge *edge = static_cast<DBGraphEdge *>(link);
      97         166 :     graph()->Unlink(edge);
      98         166 :     link->set_last_change_at_to_now();
      99         166 :     link->ClearNodes();
     100             :     DBTablePartition *partition =
     101         166 :         static_cast<DBTablePartition *>(GetTablePartition(0));
     102         166 :     partition->Delete(edge);
     103         166 : }
     104             : 
     105         172 : void IFMapLinkTable::DeleteLink(IFMapLink *link, const IFMapOrigin &origin) {
     106         172 :     link->RemoveOriginInfo(origin.origin);
     107         172 :     if (link->is_origin_empty()) {
     108         166 :         DeleteLink(link);
     109             :     }
     110         172 : }
     111             : 
     112         219 : DBTable *IFMapLinkTable::CreateTable(DB *db, const string &name,
     113             :                                      DBGraph *graph) {
     114         219 :     IFMapLinkTable *table = new IFMapLinkTable(db, name, graph);
     115         219 :     table->Init();
     116         219 :     return table;
     117             : }
     118             : 
     119         219 : void IFMapLinkTable::Clear() {
     120             :     DBTablePartition *partition = static_cast<DBTablePartition *>(
     121         219 :         GetTablePartition(0));
     122             : 
     123         219 :     assert(!HasListeners());
     124         219 :     for (IFMapLink *link = static_cast<IFMapLink *>(partition->GetFirst()),
     125        3271 :                  *next = NULL; link != NULL; link = next) {
     126        3052 :         next = static_cast<IFMapLink *>(partition->GetNext(link));
     127        3052 :         if (link->IsDeleted()) {
     128           0 :             continue;
     129             :         }
     130        3052 :         graph()->Unlink(link);
     131        3052 :         partition->Delete(link);
     132             :     }
     133         219 : }
     134             : 
     135         219 : void IFMapLinkTable_Init(DB *db, DBGraph *graph) {
     136             :     DBTable *table =
     137         219 :             IFMapLinkTable::CreateTable(db, "__ifmap_metadata__.0", graph);
     138         219 :     db->AddTable(table);
     139         219 : }
     140             : 
     141         160 : void IFMapLinkTable_Clear(DB *db) {
     142             :     IFMapLinkTable *ltable = static_cast<IFMapLinkTable *>(
     143         160 :             db->FindTable("__ifmap_metadata__.0"));
     144         160 :     ltable->Clear();
     145         160 : }