extras/vom/vom/tap_interface.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/tap_interface.hpp"
  17 #include "vom/tap_interface_cmds.hpp"
  18
  19 #include <vapi/vpe.api.vapi.hpp>
  20
  21 namespace VOM {
  22 tap_interface::event_handler tap_interface::m_evh;
  23
  24 /**
  25  * Construct a new object matching the desried state
  26  */
  27 tap_interface::tap_interface(const std::string& name,
  28                              type_t type,
  29                              admin_state_t state,
  30                              route::prefix_t prefix)
  31   : interface(name, type, state)
  32   , m_prefix(prefix)
  33   , m_l2_address(l2_address_t::ZERO)
  34 {
  35 }
  36
  37 tap_interface::tap_interface(const std::string& name,
  38                              type_t type,
  39                              admin_state_t state,
  40                              route::prefix_t prefix,
  41                              const l2_address_t& l2_address)
  42   : interface(name, type, state)
  43   , m_prefix(prefix)
  44   , m_l2_address(l2_address)
  45 {
  46 }
  47
  48 tap_interface::~tap_interface()
  49 {
  50   sweep();
  51   release();
  52 }
  53
  54 tap_interface::tap_interface(const tap_interface& o)
  55   : interface(o)
  56   , m_prefix(o.m_prefix)
  57   , m_l2_address(o.m_l2_address)
  58 {
  59 }
  60
  61 std::queue<cmd*>&
  62 tap_interface::mk_create_cmd(std::queue<cmd*>& q)
  63 {
  64   if (type_t::TAPV2 == type())
  65     q.push(new tap_interface_cmds::tapv2_create_cmd(m_hdl, name(), m_prefix,
  66                                                     m_l2_address));
  67   else
  68     q.push(new tap_interface_cmds::tap_create_cmd(m_hdl, name(), m_prefix,
  69                                                   m_l2_address));
  70
  71   return (q);
  72 }
  73
  74 std::queue<cmd*>&
  75 tap_interface::mk_delete_cmd(std::queue<cmd*>& q)
  76 {
  77   if (type_t::TAPV2 == type())
  78     q.push(new tap_interface_cmds::tapv2_delete_cmd(m_hdl));
  79   else
  80     q.push(new tap_interface_cmds::tap_delete_cmd(m_hdl));
  81
  82   return (q);
  83 }
  84
  85 std::shared_ptr<tap_interface>
  86 tap_interface::singular() const
  87 {
  88   return std::dynamic_pointer_cast<tap_interface>(singular_i());
  89 }
  90
  91 std::shared_ptr<interface>
  92 tap_interface::singular_i() const
  93 {
  94   return m_db.find_or_add(name(), *this);
  95 }
  96
  97 void
  98 tap_interface::event_handler::handle_populate(const client_db::key_t& key)
  99 {
 100   // It will be polulate by interface handler
 101 }
 102
 103 tap_interface::event_handler::event_handler()
 104 {
 105   OM::register_listener(this);
 106   inspect::register_handler({ "tap" }, "tap_interfaces", this);
 107 }
 108
 109 void
 110 tap_interface::event_handler::handle_replay()
 111 {
 112   // It will be replayed by interface handler
 113 }
 114
 115 dependency_t
 116 tap_interface::event_handler::order() const
 117 {
 118   return (dependency_t::INTERFACE);
 119 }
 120
 121 void
 122 tap_interface::event_handler::show(std::ostream& os)
 123 {
 124   // dumped by the interface handler
 125 }
 126
 127 }; // namespace VOM
 128
 129 /*
 130  * fd.io coding-style-patch-verification: ON
 131  *
 132  * Local Variables:
 133  * eval: (c-set-style "mozilla")
 134  * End:
 135  */