Line data    Source code

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