extras/vom/vom/gbp_contract.cpp

   1 /*
   2  * Copyright (c) 2017 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include "vom/gbp_contract.hpp"
  17 #include "vom/api_types.hpp"
  18 #include "vom/gbp_contract_cmds.hpp"
  19 #include "vom/singular_db_funcs.hpp"
  20
  21 namespace VOM {
  22
  23 singular_db<gbp_contract::key_t, gbp_contract> gbp_contract::m_db;
  24
  25 gbp_contract::event_handler gbp_contract::m_evh;
  26
  27 gbp_contract::gbp_contract(epg_id_t src_epg_id,
  28                            epg_id_t dst_epg_id,
  29                            const ACL::l3_list& acl)
  30   : m_hw(false)
  31   , m_src_epg_id(src_epg_id)
  32   , m_dst_epg_id(dst_epg_id)
  33   , m_acl(acl.singular())
  34 {
  35 }
  36
  37 gbp_contract::gbp_contract(const gbp_contract& gbpc)
  38   : m_hw(gbpc.m_hw)
  39   , m_src_epg_id(gbpc.m_src_epg_id)
  40   , m_dst_epg_id(gbpc.m_dst_epg_id)
  41   , m_acl(gbpc.m_acl)
  42 {
  43 }
  44
  45 gbp_contract::~gbp_contract()
  46 {
  47   sweep();
  48
  49   // not in the DB anymore.
  50   m_db.release(key(), this);
  51 }
  52
  53 const gbp_contract::key_t
  54 gbp_contract::key() const
  55 {
  56   return (std::make_pair(m_src_epg_id, m_dst_epg_id));
  57 }
  58
  59 bool
  60 gbp_contract::operator==(const gbp_contract& gbpc) const
  61 {
  62   return ((key() == gbpc.key()) && (m_acl->handle() == gbpc.m_acl->handle()));
  63 }
  64
  65 void
  66 gbp_contract::sweep()
  67 {
  68   if (m_hw) {
  69     HW::enqueue(
  70       new gbp_contract_cmds::delete_cmd(m_hw, m_src_epg_id, m_dst_epg_id));
  71   }
  72   HW::write();
  73 }
  74
  75 void
  76 gbp_contract::replay()
  77 {
  78   if (m_hw) {
  79     HW::enqueue(new gbp_contract_cmds::create_cmd(
  80       m_hw, m_src_epg_id, m_dst_epg_id, m_acl->handle(), m_gbp_rules));
  81   }
  82 }
  83
  84 std::string
  85 gbp_contract::to_string() const
  86 {
  87   std::ostringstream s;
  88   s << "gbp-contract:[{" << m_src_epg_id << ", " << m_dst_epg_id << "}, "
  89     << m_acl->to_string();
  90   if (m_gbp_rules.size()) {
  91     auto it = m_gbp_rules.cbegin();
  92     while (it != m_gbp_rules.cend()) {
  93       s << it->to_string();
  94       ++it;
  95     }
  96   }
  97   s << "]";
  98
  99   return (s.str());
 100 }
 101
 102 void
 103 gbp_contract::set_gbp_rules(const gbp_contract::gbp_rules_t& gbp_rules)
 104 {
 105   m_gbp_rules = gbp_rules;
 106 }
 107
 108 void
 109 gbp_contract::update(const gbp_contract& r)
 110 {
 111   /*
 112    * create the table if it is not yet created
 113    */
 114   if (rc_t::OK != m_hw.rc()) {
 115     HW::enqueue(new gbp_contract_cmds::create_cmd(
 116       m_hw, m_src_epg_id, m_dst_epg_id, m_acl->handle(), m_gbp_rules));
 117   }
 118 }
 119
 120 std::shared_ptr<gbp_contract>
 121 gbp_contract::find_or_add(const gbp_contract& temp)
 122 {
 123   return (m_db.find_or_add(temp.key(), temp));
 124 }
 125
 126 std::shared_ptr<gbp_contract>
 127 gbp_contract::find(const key_t& k)
 128 {
 129   return (m_db.find(k));
 130 }
 131
 132 std::shared_ptr<gbp_contract>
 133 gbp_contract::singular() const
 134 {
 135   return find_or_add(*this);
 136 }
 137
 138 void
 139 gbp_contract::dump(std::ostream& os)
 140 {
 141   db_dump(m_db, os);
 142 }
 143
 144 gbp_contract::event_handler::event_handler()
 145 {
 146   OM::register_listener(this);
 147   inspect::register_handler({ "gbp-contract" }, "GBP Contract", this);
 148 }
 149
 150 void
 151 gbp_contract::event_handler::handle_replay()
 152 {
 153   m_db.replay();
 154 }
 155
 156 void
 157 gbp_contract::event_handler::handle_populate(const client_db::key_t& key)
 158 {
 159   std::shared_ptr<gbp_contract_cmds::dump_cmd> cmd =
 160     std::make_shared<gbp_contract_cmds::dump_cmd>();
 161
 162   HW::enqueue(cmd);
 163   HW::write();
 164
 165   for (auto& record : *cmd) {
 166     auto& payload = record.get_payload();
 167
 168     std::shared_ptr<ACL::l3_list> acl =
 169       ACL::l3_list::find(payload.contract.acl_index);
 170
 171     if (acl) {
 172       gbp_contract gbpc(payload.contract.src_epg, payload.contract.dst_epg,
 173                         *acl);
 174       OM::commit(key, gbpc);
 175       if (payload.contract.n_rules) {
 176         gbp_contract::gbp_rules_t rules;
 177         for (u8 i = 0; i < payload.contract.n_rules; i++) {
 178           const gbp_rule::action_t action =
 179             gbp_rule::action_t::from_int(payload.contract.rules[i].action);
 180           const gbp_rule::hash_mode_t hm = gbp_rule::hash_mode_t::from_int(
 181             payload.contract.rules[i].nh_set.hash_mode);
 182           gbp_rule::next_hops_t nhs;
 183           for (u8 j = 0; j < payload.contract.rules[i].nh_set.n_nhs; j++) {
 184             gbp_rule::next_hop_t nh(
 185               from_api(payload.contract.rules[i].nh_set.nhs[j].ip),
 186               from_api(payload.contract.rules[i].nh_set.nhs[j].mac),
 187               payload.contract.rules[i].nh_set.nhs[j].bd_id,
 188               payload.contract.rules[i].nh_set.nhs[j].rd_id);
 189             nhs.insert(nh);
 190           }
 191           gbp_rule::next_hop_set_t next_hop_set(hm, nhs);
 192           gbp_rule gr(i, next_hop_set, action);
 193           rules.insert(gr);
 194         }
 195         gbpc.set_gbp_rules(rules);
 196       }
 197       VOM_LOG(log_level_t::DEBUG) << "read: " << gbpc.to_string();
 198     }
 199   }
 200 }
 201
 202 dependency_t
 203 gbp_contract::event_handler::order() const
 204 {
 205   return (dependency_t::ENTRY);
 206 }
 207
 208 void
 209 gbp_contract::event_handler::show(std::ostream& os)
 210 {
 211   db_dump(m_db, os);
 212 }
 213
 214 std::ostream&
 215 operator<<(std::ostream& os, const gbp_contract::key_t& key)
 216 {
 217   os << "{ " << key.first << "," << key.second << "}";
 218
 219   return (os);
 220 }
 221
 222 } // namespace VOM
 223
 224 /*
 225  * fd.io coding-style-patch-verification: ON
 226  *
 227  * Local Variables:
 228  * eval: (c-set-style "mozilla")
 229  * End:
 230  */