Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #include <cmn/agent.h>
       6             : #include <agent_types.h>
       7             : #include <vnc_cfg_types.h>
       8             : #include <oper/agent_sandesh.h>
       9             : #include <oper_db.h>
      10             : #include <oper/config_manager.h>
      11             : #include <qos_queue.h>
      12             : #include <init/agent_param.h>
      13             : 
      14           0 : QosQueue::QosQueue(const boost::uuids::uuid &uuid):
      15           0 :     uuid_(uuid), id_(QosQueueTable::kInvalidIndex) {
      16           0 : }
      17             : 
      18           0 : QosQueue::~QosQueue() {
      19           0 : }
      20             : 
      21           0 : DBEntryBase::KeyPtr QosQueue::GetDBRequestKey() const {
      22           0 :     QosQueueKey *key = new QosQueueKey(uuid_);
      23           0 :     return DBEntryBase::KeyPtr(key);
      24             : }
      25             : 
      26           0 : std::string QosQueue::ToString() const {
      27           0 :     std::ostringstream buffer;
      28           0 :     buffer << uuid_;
      29           0 :     return buffer.str();
      30           0 : }
      31             : 
      32           0 : bool QosQueue::DBEntrySandesh(Sandesh *sresp, std::string &name) const {
      33           0 :     QosQueueSandeshResp *resp = static_cast<QosQueueSandeshResp *>(sresp);
      34           0 :     QosQueueSandeshData data;
      35           0 :     data.set_uuid(UuidToString(uuid_));
      36           0 :     data.set_id(id_);
      37           0 :     data.set_name(name_);
      38             : 
      39             :     std::vector<QosQueueSandeshData> &list =
      40           0 :         const_cast<std::vector<QosQueueSandeshData>&>(resp->get_qos_queue_list());
      41           0 :     list.push_back(data);
      42           0 :     return true;
      43           0 : }
      44             : 
      45           0 : bool QosQueue::IsLess(const DBEntry &rhs) const {
      46           0 :     const QosQueue &qos_q = static_cast<const QosQueue &>(rhs);
      47           0 :     return (uuid_ < qos_q.uuid_);
      48             : }
      49             : 
      50           0 : void QosQueue::PostAdd() {
      51           0 :     AgentDBTable *table = static_cast<AgentDBTable *>(get_table());
      52           0 :     nic_queue_id_ = table->agent()->params()->get_nic_queue(id_);
      53           0 : }
      54             : 
      55           0 : bool QosQueue::Change(const DBRequest *req) {
      56           0 :     const AgentDBTable *table = static_cast<const AgentDBTable *>(get_table());
      57           0 :     const QosQueueData *data = static_cast<const QosQueueData *>(req->data.get());
      58           0 :     bool ret = false;
      59             : 
      60           0 :     if (name_ != data->name_) {
      61           0 :         name_ = data->name_;
      62           0 :         ret = true;
      63             :     }
      64             : 
      65           0 :     if (id_ != data->id_) {
      66           0 :         id_ = data->id_;
      67           0 :         if (table) {
      68           0 :             nic_queue_id_ = table->agent()->params()->get_nic_queue(id_);
      69             :         }
      70           0 :         ret = true;
      71             :     }
      72             : 
      73           0 :     return ret;
      74             : }
      75             : 
      76           0 : void QosQueue::Delete(const DBRequest *req) {
      77           0 : }
      78             : 
      79           0 : void QosQueue::SetKey(const DBRequestKey *key) {
      80           0 :     const QosQueueKey *qos_q_key =
      81             :         static_cast<const QosQueueKey *>(key);
      82           0 :     uuid_ = qos_q_key->uuid_;
      83           0 : }
      84             : 
      85           1 : QosQueueTable::QosQueueTable(Agent *agent,
      86           1 :                              DB *db, const std::string &name):
      87           1 :     AgentOperDBTable(db, name) {
      88           1 :     set_agent(agent);
      89           1 : }
      90             : 
      91           2 : QosQueueTable::~QosQueueTable() {
      92           2 : }
      93             : 
      94             : DBTableBase*
      95           1 : QosQueueTable::CreateTable(Agent *agent, DB *db, const std::string &name) {
      96           1 :     QosQueueTable *qos_q_table = new QosQueueTable(agent, db, name);
      97           1 :     (static_cast<DBTable *>(qos_q_table))->Init();
      98           1 :     return qos_q_table;
      99             : }
     100             : 
     101             : std::unique_ptr<DBEntry>
     102           0 : QosQueueTable::AllocEntry(const DBRequestKey *k) const {
     103           0 :     const QosQueueKey *key =
     104             :         static_cast<const QosQueueKey *>(k);
     105           0 :     QosQueue *qos_q = new QosQueue(key->uuid_);
     106           0 :     return std::unique_ptr<DBEntry>(static_cast<DBEntry *>(qos_q));
     107             : }
     108             : 
     109           0 : DBEntry* QosQueueTable::OperDBAdd(const DBRequest *req) {
     110             :     const QosQueueKey *key =
     111           0 :         static_cast<const QosQueueKey *>(req->key.get());
     112           0 :     QosQueue *qos_q = new QosQueue(key->uuid_);
     113           0 :     qos_q->set_id(index_table_.Insert(qos_q));
     114           0 :     qos_q->Change(req);
     115           0 :     return static_cast<DBEntry *>(qos_q);
     116             : }
     117             : 
     118           0 : bool QosQueueTable::OperDBOnChange(DBEntry *entry, const DBRequest *req) {
     119           0 :     QosQueue *qos_q = static_cast<QosQueue *>(entry);
     120           0 :     return qos_q->Change(req);
     121             : }
     122             : 
     123           0 : bool QosQueueTable::OperDBResync(DBEntry *entry, const DBRequest *req) {
     124           0 :     return OperDBOnChange(entry, req);
     125             : }
     126             : 
     127           0 : bool QosQueueTable::OperDBDelete(DBEntry *entry, const DBRequest *req) {
     128           0 :     return true;
     129             : }
     130             : 
     131           0 : bool QosQueueTable::IFNodeToReq(IFMapNode *node, DBRequest &req,
     132             :                                       const boost::uuids::uuid &u) {
     133           0 :     assert(!u.is_nil());
     134           0 :     if ((req.oper == DBRequest::DB_ENTRY_DELETE) || node->IsDeleted()) {
     135           0 :         req.key.reset(new QosQueueKey(u));
     136           0 :         req.oper = DBRequest::DB_ENTRY_DELETE;
     137           0 :         Enqueue(&req);
     138           0 :         return false;
     139             :     }
     140             : 
     141           0 :     agent()->config_manager()->AddQosQueueNode(node);
     142           0 :     return false;
     143             : }
     144             : 
     145           0 : bool QosQueueTable::IFNodeToUuid(IFMapNode *node, boost::uuids::uuid &u) {
     146           0 :     autogen::QosQueue *cfg = static_cast <autogen::QosQueue *> (node->GetObject());
     147           0 :     assert(cfg);
     148           0 :     autogen::IdPermsType id_perms = cfg->id_perms();
     149           0 :     CfgUuidSet(id_perms.uuid.uuid_mslong, id_perms.uuid.uuid_lslong, u);
     150           0 :     return true;
     151           0 : }
     152             : 
     153             : 
     154           0 : bool QosQueueTable::ProcessConfig(IFMapNode *node, DBRequest &req,
     155             :                                   const boost::uuids::uuid &u) {
     156           0 :     if (node->IsDeleted()) {
     157           0 :         return false;
     158             :     }
     159             : 
     160           0 :     autogen::QosQueue *cfg = static_cast <autogen::QosQueue *> (node->GetObject());
     161           0 :     req.oper = DBRequest::DB_ENTRY_ADD_CHANGE;
     162           0 :     req.key.reset(new QosQueueKey(u));
     163           0 :     req.data.reset(new QosQueueData(agent(), node, node->name(),
     164           0 :                                     cfg->identifier()));
     165           0 :     Enqueue(&req);
     166           0 :     return false;
     167             : }
     168             : 
     169           0 : void QosQueueTable::ReleaseIndex(QosQueue *qos_q) {
     170           0 : }
     171             : 
     172             : AgentSandeshPtr
     173           0 : QosQueueTable::GetAgentSandesh(const AgentSandeshArguments *args,
     174             :                                const std::string &context) {
     175             :     return AgentSandeshPtr(new QosQueueSandesh(context,
     176           0 :                 args->GetString("uuid"), args->GetString("name"),
     177           0 :                 args->GetString("id")));
     178             : }
     179             : 
     180           0 : void QosQueueSandeshReq::HandleRequest() const {
     181           0 :     AgentSandeshPtr sand(new QosQueueSandesh(context(), get_uuid(),
     182           0 :                                              get_name(), get_id()));
     183           0 :     sand->DoSandesh(sand);
     184           0 : }
     185             : 
     186           0 : void AddQosQueue::HandleRequest() const {
     187           0 :     QosResponse *resp = new QosResponse();
     188           0 :     resp->set_context(context());
     189           0 :     resp->set_resp("Success");
     190             : 
     191           0 :     DBTable *table = Agent::GetInstance()->qos_queue_table();
     192           0 :     DBRequest req;
     193             :     char str[50];
     194           0 :     sprintf(str, "00000000-0000-0000-0000-00%010x", get_uuid());
     195           0 :     boost::uuids::uuid u1 = StringToUuid(std::string(str));
     196           0 :     req.oper = DBRequest::DB_ENTRY_ADD_CHANGE;
     197           0 :     req.key.reset(new QosQueueKey(u1));
     198           0 :     req.data.reset(new QosQueueData(NULL, NULL, get_name(), get_id()));
     199           0 :     table->Enqueue(&req);
     200           0 :     resp->Response();
     201           0 : }
     202             : 
     203           0 : void DeleteQosQueue::HandleRequest() const {
     204           0 :     QosResponse *resp = new QosResponse();
     205           0 :     resp->set_context(context());
     206           0 :     resp->set_resp("Success");
     207             : 
     208             :     char str[50];
     209           0 :     sprintf(str, "00000000-0000-0000-0000-00%010x", get_uuid());
     210           0 :     boost::uuids::uuid u1 = StringToUuid(std::string(str));
     211             : 
     212           0 :     DBTable *table = Agent::GetInstance()->qos_queue_table();
     213           0 :     DBRequest req;
     214           0 :     req.oper = DBRequest::DB_ENTRY_DELETE;
     215           0 :     req.key.reset(new QosQueueKey(u1));
     216           0 :     req.data.reset(NULL);
     217           0 :     table->Enqueue(&req);
     218           0 :     resp->Response();
     219           0 : }