extras/vom/vom/vxlan_tunnel.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/vxlan_tunnel.hpp"
  17 #include "vom/logger.hpp"
  18 #include "vom/singular_db_funcs.hpp"
  19 #include "vom/vxlan_tunnel_cmds.hpp"
  20
  21 namespace VOM {
  22 const std::string VXLAN_TUNNEL_NAME = "vxlan-tunnel-itf";
  23
  24 vxlan_tunnel::event_handler vxlan_tunnel::m_evh;
  25
  26 /**
  27  * A DB of all vxlan_tunnels
  28  * this does not register as a listener for replay events, since the tunnels
  29  * are also in the base-class interface DB and so will be poked from there.
  30  */
  31 singular_db<vxlan_tunnel::endpoint_t, vxlan_tunnel> vxlan_tunnel::m_db;
  32
  33 vxlan_tunnel::endpoint_t::endpoint_t(const boost::asio::ip::address& src,
  34                                      const boost::asio::ip::address& dst,
  35                                      uint32_t vni)
  36   : src(src)
  37   , dst(dst)
  38   , vni(vni)
  39 {
  40 }
  41
  42 vxlan_tunnel::endpoint_t::endpoint_t()
  43   : src()
  44   , dst()
  45   , vni(0)
  46 {
  47 }
  48
  49 bool
  50 vxlan_tunnel::endpoint_t::operator==(const endpoint_t& other) const
  51 {
  52   return ((src == other.src) && (dst == other.dst) && (vni == other.vni));
  53 }
  54
  55 bool
  56 vxlan_tunnel::endpoint_t::operator<(const vxlan_tunnel::endpoint_t& o) const
  57 {
  58   if (src < o.src)
  59     return true;
  60   if (dst < o.dst)
  61     return true;
  62   if (vni < o.vni)
  63     return true;
  64
  65   return false;
  66 }
  67
  68 std::string
  69 vxlan_tunnel::endpoint_t::to_string() const
  70 {
  71   std::ostringstream s;
  72
  73   s << "ep:["
  74     << "src:" << src.to_string() << " dst:" << dst.to_string() << " vni:" << vni
  75     << "]";
  76
  77   return (s.str());
  78 }
  79
  80 std::ostream&
  81 operator<<(std::ostream& os, const vxlan_tunnel::endpoint_t& ep)
  82 {
  83   os << ep.to_string();
  84
  85   return (os);
  86 }
  87
  88 std::string
  89 vxlan_tunnel::mk_name(const boost::asio::ip::address& src,
  90                       const boost::asio::ip::address& dst,
  91                       uint32_t vni)
  92 {
  93   std::ostringstream s;
  94
  95   s << VXLAN_TUNNEL_NAME << "-" << src << "-" << dst << ":" << vni;
  96
  97   return (s.str());
  98 }
  99
 100 vxlan_tunnel::vxlan_tunnel(const boost::asio::ip::address& src,
 101                            const boost::asio::ip::address& dst,
 102                            uint32_t vni)
 103   : interface(mk_name(src, dst, vni),
 104               interface::type_t::VXLAN,
 105               interface::admin_state_t::UP)
 106   , m_tep(src, dst, vni)
 107 {
 108 }
 109
 110 vxlan_tunnel::vxlan_tunnel(const vxlan_tunnel& o)
 111   : interface(o)
 112   , m_tep(o.m_tep)
 113 {
 114 }
 115
 116 const handle_t&
 117 vxlan_tunnel::handle() const
 118 {
 119   return (m_hdl.data());
 120 }
 121
 122 void
 123 vxlan_tunnel::sweep()
 124 {
 125   if (m_hdl) {
 126     HW::enqueue(new vxlan_tunnel_cmds::delete_cmd(m_hdl, m_tep));
 127   }
 128   HW::write();
 129 }
 130
 131 void
 132 vxlan_tunnel::replay()
 133 {
 134   if (m_hdl) {
 135     HW::enqueue(new vxlan_tunnel_cmds::create_cmd(m_hdl, name(), m_tep));
 136   }
 137 }
 138
 139 vxlan_tunnel::~vxlan_tunnel()
 140 {
 141   sweep();
 142
 143   /*
 144  * release from both DBs
 145  */
 146   release();
 147   m_db.release(m_tep, this);
 148 }
 149
 150 std::string
 151 vxlan_tunnel::to_string() const
 152 {
 153   std::ostringstream s;
 154   s << "vxlan-tunnel: " << m_hdl.to_string() << " " << m_tep.to_string();
 155
 156   return (s.str());
 157 }
 158
 159 void
 160 vxlan_tunnel::update(const vxlan_tunnel& desired)
 161 {
 162   /*
 163    * the desired state is always that the interface should be created
 164    */
 165   if (!m_hdl) {
 166     HW::enqueue(new vxlan_tunnel_cmds::create_cmd(m_hdl, name(), m_tep));
 167   }
 168 }
 169
 170 std::shared_ptr<vxlan_tunnel>
 171 vxlan_tunnel::find_or_add(const vxlan_tunnel& temp)
 172 {
 173   /*
 174    * a VXLAN tunnel needs to be in both the interface-find-by-name
 175    * and the vxlan_tunnel-find-by-endpoint singular databases
 176    */
 177   std::shared_ptr<vxlan_tunnel> sp;
 178
 179   sp = m_db.find_or_add(temp.m_tep, temp);
 180
 181   interface::m_db.add(temp.name(), sp);
 182
 183   return (sp);
 184 }
 185
 186 std::shared_ptr<vxlan_tunnel>
 187 vxlan_tunnel::singular() const
 188 {
 189   return (find_or_add(*this));
 190 }
 191
 192 std::shared_ptr<interface>
 193 vxlan_tunnel::singular_i() const
 194 {
 195   return find_or_add(*this);
 196 }
 197
 198 void
 199 vxlan_tunnel::dump(std::ostream& os)
 200 {
 201   db_dump(m_db, os);
 202 }
 203
 204 void
 205 vxlan_tunnel::event_handler::handle_populate(const client_db::key_t& key)
 206 {
 207   /*
 208    * dump VPP current states
 209    */
 210   std::shared_ptr<vxlan_tunnel_cmds::dump_cmd> cmd =
 211     std::make_shared<vxlan_tunnel_cmds::dump_cmd>();
 212
 213   HW::enqueue(cmd);
 214   HW::write();
 215
 216   for (auto& record : *cmd) {
 217     auto& payload = record.get_payload();
 218     handle_t hdl(payload.sw_if_index);
 219     boost::asio::ip::address src =
 220       from_bytes(payload.is_ipv6, payload.src_address);
 221     boost::asio::ip::address dst =
 222       from_bytes(payload.is_ipv6, payload.dst_address);
 223
 224     std::shared_ptr<vxlan_tunnel> vt =
 225       vxlan_tunnel(src, dst, payload.vni).singular();
 226     vt->set(hdl);
 227
 228     VOM_LOG(log_level_t::DEBUG) << "dump: " << vt->to_string();
 229
 230     OM::commit(key, *vt);
 231   }
 232 }
 233
 234 vxlan_tunnel::event_handler::event_handler()
 235 {
 236   OM::register_listener(this);
 237   inspect::register_handler({ "vxlan" }, "VXLAN Tunnels", this);
 238 }
 239
 240 void
 241 vxlan_tunnel::event_handler::handle_replay()
 242 {
 243   // replay is handled from the interface DB
 244 }
 245
 246 dependency_t
 247 vxlan_tunnel::event_handler::order() const
 248 {
 249   return (dependency_t::VIRTUAL_INTERFACE);
 250 }
 251
 252 void
 253 vxlan_tunnel::event_handler::show(std::ostream& os)
 254 {
 255   // dumped by the interface handler
 256 }
 257
 258 }; // namespace VOM
 259
 260 /*
 261  * fd.io coding-style-patch-verification: ON
 262  *
 263  * Local Variables:
 264  * eval: (c-set-style "mozilla")
 265  * End:
 266  */