extras/vom/vom/gbp_bridge_domain.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_bridge_domain.hpp"
  17 #include "vom/gbp_bridge_domain_cmds.hpp"
  18 #include "vom/interface.hpp"
  19 #include "vom/l2_binding.hpp"
  20 #include "vom/singular_db_funcs.hpp"
  21
  22 namespace VOM {
  23
  24 const gbp_bridge_domain::flags_t gbp_bridge_domain::flags_t::NONE(0, "none");
  25 const gbp_bridge_domain::flags_t gbp_bridge_domain::flags_t::DO_NOT_LEARN(
  26   1,
  27   "do-not-learn");
  28
  29 gbp_bridge_domain::flags_t::flags_t(int v, const std::string& s)
  30   : enum_base<gbp_bridge_domain::flags_t>(v, s)
  31 {
  32 }
  33
  34 /**
  35  * A DB of al the interfaces, key on the name
  36  */
  37 singular_db<uint32_t, gbp_bridge_domain> gbp_bridge_domain::m_db;
  38
  39 gbp_bridge_domain::event_handler gbp_bridge_domain::m_evh;
  40
  41 /**
  42  * Construct a new object matching the desried state
  43  */
  44 gbp_bridge_domain::gbp_bridge_domain(const bridge_domain& bd,
  45                                      const interface& bvi,
  46                                      const flags_t& flags)
  47   : m_id(bd.id())
  48   , m_bd(bd.singular())
  49   , m_bvi(bvi.singular())
  50   , m_uu_fwd()
  51   , m_bm_flood()
  52   , m_flags(flags)
  53 {
  54 }
  55
  56 gbp_bridge_domain::gbp_bridge_domain(const bridge_domain& bd,
  57                                      const interface& bvi,
  58                                      const interface& uu_fwd,
  59                                      const interface& bm_flood,
  60                                      const flags_t& flags)
  61   : m_id(bd.id())
  62   , m_bd(bd.singular())
  63   , m_bvi(bvi.singular())
  64   , m_uu_fwd(uu_fwd.singular())
  65   , m_bm_flood(bm_flood.singular())
  66   , m_flags(flags)
  67 {
  68 }
  69
  70 gbp_bridge_domain::gbp_bridge_domain(const bridge_domain& bd,
  71                                      const std::shared_ptr<interface> bvi,
  72                                      const std::shared_ptr<interface> uu_fwd,
  73                                      const std::shared_ptr<interface> bm_flood,
  74                                      const flags_t& flags)
  75   : m_id(bd.id())
  76   , m_bd(bd.singular())
  77   , m_bvi(bvi)
  78   , m_uu_fwd(uu_fwd)
  79   , m_bm_flood(bm_flood)
  80   , m_flags(flags)
  81 {
  82   if (m_bvi)
  83     m_bvi = m_bvi->singular();
  84   if (m_uu_fwd)
  85     m_uu_fwd = m_uu_fwd->singular();
  86   if (m_bm_flood)
  87     m_bm_flood = m_bm_flood->singular();
  88 }
  89
  90 gbp_bridge_domain::gbp_bridge_domain(const bridge_domain& bd,
  91                                      const interface& bvi,
  92                                      const std::shared_ptr<interface> uu_fwd,
  93                                      const std::shared_ptr<interface> bm_flood,
  94                                      const flags_t& flags)
  95   : m_id(bd.id())
  96   , m_bd(bd.singular())
  97   , m_bvi(bvi.singular())
  98   , m_uu_fwd(uu_fwd)
  99   , m_bm_flood(bm_flood)
 100   , m_flags(flags)
 101 {
 102   if (m_uu_fwd)
 103     m_uu_fwd = m_uu_fwd->singular();
 104   if (m_bm_flood)
 105     m_bm_flood = m_bm_flood->singular();
 106 }
 107
 108 gbp_bridge_domain::gbp_bridge_domain(const gbp_bridge_domain& bd)
 109   : m_id(bd.id())
 110   , m_bd(bd.m_bd)
 111   , m_bvi(bd.m_bvi)
 112   , m_uu_fwd(bd.m_uu_fwd)
 113   , m_bm_flood(bd.m_bm_flood)
 114   , m_flags(bd.m_flags)
 115 {
 116 }
 117
 118 const gbp_bridge_domain::key_t
 119 gbp_bridge_domain::key() const
 120 {
 121   return (m_bd->key());
 122 }
 123
 124 uint32_t
 125 gbp_bridge_domain::id() const
 126 {
 127   return (m_bd->id());
 128 }
 129
 130 const std::shared_ptr<bridge_domain>
 131 gbp_bridge_domain::get_bridge_domain() const
 132 {
 133   return m_bd;
 134 }
 135
 136 const std::shared_ptr<interface>
 137 gbp_bridge_domain::get_bvi() const
 138 {
 139   return m_bvi;
 140 }
 141
 142 bool
 143 gbp_bridge_domain::operator==(const gbp_bridge_domain& b) const
 144 {
 145   bool equal = true;
 146
 147   if (m_bvi && b.m_bvi)
 148     equal &= (m_bvi->key() == b.m_bvi->key());
 149   else if (!m_bvi && !b.m_bvi)
 150     ;
 151   else
 152     equal = false;
 153
 154   if (m_uu_fwd && b.m_uu_fwd)
 155     equal &= (m_uu_fwd->key() == b.m_uu_fwd->key());
 156   else if (!m_uu_fwd && !b.m_uu_fwd)
 157     ;
 158   else
 159     equal = false;
 160
 161   if (m_bm_flood && b.m_bm_flood)
 162     equal &= (m_bm_flood->key() == b.m_bm_flood->key());
 163   else if (!m_bm_flood && !b.m_bm_flood)
 164     ;
 165   else
 166     equal = false;
 167
 168   return ((m_bd->key() == b.m_bd->key()) && equal);
 169 }
 170
 171 void
 172 gbp_bridge_domain::sweep()
 173 {
 174   if (rc_t::OK == m_id.rc()) {
 175     HW::enqueue(new gbp_bridge_domain_cmds::delete_cmd(m_id));
 176   }
 177   HW::write();
 178 }
 179
 180 void
 181 gbp_bridge_domain::replay()
 182 {
 183   if (rc_t::OK == m_id.rc()) {
 184     HW::enqueue(new gbp_bridge_domain_cmds::create_cmd(
 185       m_id, (m_bvi ? m_bvi->handle() : handle_t::INVALID),
 186       (m_uu_fwd ? m_uu_fwd->handle() : handle_t::INVALID),
 187       (m_bm_flood ? m_bm_flood->handle() : handle_t::INVALID), m_flags));
 188   }
 189 }
 190
 191 gbp_bridge_domain::~gbp_bridge_domain()
 192 {
 193   sweep();
 194
 195   // not in the DB anymore.
 196   m_db.release(m_id.data(), this);
 197 }
 198
 199 std::string
 200 gbp_bridge_domain::to_string() const
 201 {
 202   std::ostringstream s;
 203   s << "gbp-bridge-domain:[" << m_bd->to_string()
 204     << " flags:" << m_flags.to_string();
 205
 206   if (m_bvi)
 207     s << " bvi:" << m_bvi->to_string();
 208   if (m_uu_fwd)
 209     s << " uu-fwd:" << m_uu_fwd->to_string();
 210
 211   s << "]";
 212
 213   return (s.str());
 214 }
 215
 216 std::shared_ptr<gbp_bridge_domain>
 217 gbp_bridge_domain::find(const key_t& key)
 218 {
 219   return (m_db.find(key));
 220 }
 221
 222 void
 223 gbp_bridge_domain::update(const gbp_bridge_domain& desired)
 224 {
 225   /*
 226    * the desired state is always that the interface should be created
 227    */
 228   if (rc_t::OK != m_id.rc()) {
 229     HW::enqueue(new gbp_bridge_domain_cmds::create_cmd(
 230       m_id, (m_bvi ? m_bvi->handle() : handle_t::INVALID),
 231       (m_uu_fwd ? m_uu_fwd->handle() : handle_t::INVALID),
 232       (m_bm_flood ? m_bm_flood->handle() : handle_t::INVALID), m_flags));
 233   }
 234 }
 235
 236 std::shared_ptr<gbp_bridge_domain>
 237 gbp_bridge_domain::find_or_add(const gbp_bridge_domain& temp)
 238 {
 239   return (m_db.find_or_add(temp.m_id.data(), temp));
 240 }
 241
 242 std::shared_ptr<gbp_bridge_domain>
 243 gbp_bridge_domain::singular() const
 244 {
 245   return find_or_add(*this);
 246 }
 247
 248 void
 249 gbp_bridge_domain::dump(std::ostream& os)
 250 {
 251   db_dump(m_db, os);
 252 }
 253
 254 void
 255 gbp_bridge_domain::event_handler::handle_populate(const client_db::key_t& key)
 256 {
 257   /*
 258    * dump GBP Bridge domains
 259    */
 260   std::shared_ptr<gbp_bridge_domain_cmds::dump_cmd> cmd =
 261     std::make_shared<gbp_bridge_domain_cmds::dump_cmd>();
 262
 263   HW::enqueue(cmd);
 264   HW::write();
 265
 266   for (auto& record : *cmd) {
 267     auto& payload = record.get_payload();
 268
 269     std::shared_ptr<interface> uu_fwd =
 270       interface::find(payload.bd.uu_fwd_sw_if_index);
 271     std::shared_ptr<interface> bm_flood =
 272       interface::find(payload.bd.bm_flood_sw_if_index);
 273     std::shared_ptr<interface> bvi =
 274       interface::find(payload.bd.bvi_sw_if_index);
 275
 276     if (uu_fwd && bm_flood && bvi) {
 277       gbp_bridge_domain bd(payload.bd.bd_id, bvi, uu_fwd, bm_flood);
 278       OM::commit(key, bd);
 279       VOM_LOG(log_level_t::DEBUG) << "dump: " << bd.to_string();
 280     } else if (bvi) {
 281       gbp_bridge_domain bd(payload.bd.bd_id, *bvi);
 282       OM::commit(key, bd);
 283       VOM_LOG(log_level_t::DEBUG) << "dump: " << bd.to_string();
 284     } else {
 285       VOM_LOG(log_level_t::ERROR)
 286         << "no BVI:" << payload.bd.bvi_sw_if_index
 287         << " nor uu-fwd:" << payload.bd.uu_fwd_sw_if_index;
 288     }
 289   }
 290 }
 291
 292 gbp_bridge_domain::event_handler::event_handler()
 293 {
 294   OM::register_listener(this);
 295   inspect::register_handler({ "gbd", "gbridge" }, "GBP Bridge Domains", this);
 296 }
 297
 298 void
 299 gbp_bridge_domain::event_handler::handle_replay()
 300 {
 301   m_db.replay();
 302 }
 303
 304 dependency_t
 305 gbp_bridge_domain::event_handler::order() const
 306 {
 307   return (dependency_t::VIRTUAL_TABLE);
 308 }
 309
 310 void
 311 gbp_bridge_domain::event_handler::show(std::ostream& os)
 312 {
 313   db_dump(m_db, os);
 314 }
 315 }
 316
 317 /*
 318  * fd.io coding-style-patch-verification: ON
 319  *
 320  * Local Variables:
 321  * eval: (c-set-style "mozilla")
 322  * End:
 323  */