Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #include <cmn/agent_factory.h>
       6             : #include <cmn/agent_cmn.h>
       7             : #include <init/agent_param.h>
       8             : #include <db/db.h>
       9             : #include <base/task_trigger.h>
      10             : #include <sandesh/sandesh_types.h>
      11             : #include <sandesh/sandesh_constants.h>
      12             : #include <sandesh/sandesh.h>
      13             : #include <sandesh/sandesh_trace.h>
      14             : #include <cfg/cfg_init.h>
      15             : #include <oper/route_common.h>
      16             : #include <oper/operdb_init.h>
      17             : #include <oper/metadata_ip.h>
      18             : #include <oper/interface_common.h>
      19             : #include <oper/health_check.h>
      20             : #include <oper/nexthop.h>
      21             : #include <oper/vrf.h>
      22             : #include <oper/mpls.h>
      23             : #include <oper/vm.h>
      24             : #include <oper/vn.h>
      25             : #include <oper/sg.h>
      26             : #include <oper/tag.h>
      27             : #include <oper/mirror_table.h>
      28             : #include <oper/vrf_assign.h>
      29             : #include <oper/vxlan.h>
      30             : #include <oper/multicast_policy.h>
      31             : #include <oper/multicast.h>
      32             : #include <oper/global_vrouter.h>
      33             : #include <oper/path_preference.h>
      34             : #include <oper/tsn_elector.h>
      35             : #include <oper/vxlan_routing_manager.h>
      36             : #include <filter/acl.h>
      37             : #include <filter/policy_set.h>
      38             : #include <oper/ifmap_dependency_manager.h>
      39             : #include <base/task_trigger.h>
      40             : #include <oper/instance_manager.h>
      41             : #include <oper/physical_device.h>
      42             : #include <oper/physical_device_vn.h>
      43             : #include <oper/config_manager.h>
      44             : #include <oper/agent_profile.h>
      45             : #include <oper/agent_sandesh.h>
      46             : #include <oper/vrouter.h>
      47             : #include <oper/bgp_as_service.h>
      48             : #include <oper/bgp_router.h>
      49             : #include <oper/agent_route_walker.h>
      50             : #include <nexthop_server/nexthop_manager.h>
      51             : #include <oper/forwarding_class.h>
      52             : #include <oper/qos_config.h>
      53             : #include <oper/qos_queue.h>
      54             : #include <oper/global_qos_config.h>
      55             : #include <oper/global_system_config.h>
      56             : #include <oper/bridge_domain.h>
      57             : #include <oper/agent_route_walker.h>
      58             : #include <oper/security_logging_object.h>
      59             : #include <oper/route_leak.h>
      60             : #include <oper/crypt_tunnel.h>
      61             : #include <oper/hbf.h>
      62             : 
      63             : using boost::assign::map_list_of;
      64             : using boost::assign::list_of;
      65             : 
      66             : SandeshTraceBufferPtr OperConfigTraceBuf(SandeshTraceBufferCreate("OperIfmap",
      67             :                                                                   1000));
      68             : 
      69             : template<typename T>
      70           2 : T *DBTableCreate(DB *db, Agent *agent, OperDB *oper,
      71             :                    const std::string &db_name) {
      72           2 :     DB::RegisterFactory(db_name, &T::CreateTable);
      73           2 :     T *table = static_cast<T *>(db->CreateTable(db_name));
      74           2 :     assert(table);
      75           2 :     table->set_agent(agent);
      76           2 :     return table;
      77             : }
      78             : 
      79           1 : void OperDB::CreateDBTables(DB *db) {
      80           1 :     DB::RegisterFactory("db.interface.0", &InterfaceTable::CreateTable);
      81           1 :     DB::RegisterFactory("db.nexthop.0", &NextHopTable::CreateTable);
      82           1 :     DB::RegisterFactory("db.crypttunnel.0",
      83             :                         boost::bind(&CryptTunnelTable::CreateTable,
      84             :                                     agent_, _1, _2));
      85           1 :     DB::RegisterFactory("uc.route.0",
      86             :                         &InetUnicastAgentRouteTable::CreateTable);
      87           1 :     DB::RegisterFactory("uc.route.3",
      88             :                         &InetUnicastAgentRouteTable::CreateTable);
      89           1 :     DB::RegisterFactory("mc.route.0",
      90             :                         &Inet4MulticastAgentRouteTable::CreateTable);
      91           1 :     DB::RegisterFactory("evpn.route.0", &EvpnAgentRouteTable::CreateTable);
      92           1 :     DB::RegisterFactory("l2.route.0", &BridgeAgentRouteTable::CreateTable);
      93           1 :     DB::RegisterFactory("uc.route6.0",
      94             :                         &InetUnicastAgentRouteTable::CreateTable);
      95           1 :     DB::RegisterFactory("db.vrf.0", &VrfTable::CreateTable);
      96           1 :     DB::RegisterFactory("db.vn.0", &VnTable::CreateTable);
      97           1 :     DB::RegisterFactory("db.vm.0", &VmTable::CreateTable);
      98           1 :     DB::RegisterFactory("db.sg.0", &SgTable::CreateTable);
      99           1 :     DB::RegisterFactory("db.tag.0", &TagTable::CreateTable);
     100           1 :     DB::RegisterFactory("db.mpls.0", &MplsTable::CreateTable);
     101           1 :     DB::RegisterFactory("db.acl.0", &AclTable::CreateTable);
     102           1 :     DB::RegisterFactory("db.mirror_table.0", &MirrorTable::CreateTable);
     103           1 :     DB::RegisterFactory("db.vrf_assign.0", &VrfAssignTable::CreateTable);
     104           1 :     DB::RegisterFactory("db.vxlan.0", &VxLanTable::CreateTable);
     105           1 :     DB::RegisterFactory("db.service-instance.0",
     106             :                         &ServiceInstanceTable::CreateTable);
     107           1 :     DB::RegisterFactory("db.physical_devices.0",
     108             :                         &PhysicalDeviceTable::CreateTable);
     109           1 :     DB::RegisterFactory("db.healthcheck.0",
     110             :                         boost::bind(&HealthCheckTable::CreateTable,
     111             :                                     agent_, _1, _2));
     112           1 :     DB::RegisterFactory("db.qos_queue.0",
     113             :                         boost::bind(&QosQueueTable::CreateTable,
     114             :                         agent_, _1, _2));
     115           1 :     DB::RegisterFactory("db.forwardingclass.0",
     116             :                         boost::bind(&ForwardingClassTable::CreateTable,
     117             :                         agent_, _1, _2));
     118           1 :     DB::RegisterFactory("db.qos_config.0",
     119             :                         boost::bind(&AgentQosConfigTable::CreateTable,
     120             :                         agent_, _1, _2));
     121           1 :     DB::RegisterFactory("db.bridge_domain.0",
     122             :                         boost::bind(&BridgeDomainTable::CreateTable,
     123             :                                     agent_, _1, _2));
     124           1 :     DB::RegisterFactory("db.security_logging_object.0",
     125             :                         boost::bind(&SecurityLoggingObjectTable::CreateTable,
     126             :                         agent_, _1, _2));
     127           1 :     DB::RegisterFactory("db.policy_set.0", &PolicySetTable::CreateTable);
     128           1 :     DB::RegisterFactory("db.multicast_policy.0",
     129             :                         &MulticastPolicyTable::CreateTable);
     130             : 
     131             :     InterfaceTable *intf_table;
     132           1 :     intf_table = static_cast<InterfaceTable *>(db->CreateTable("db.interface.0"));
     133           1 :     assert(intf_table);
     134           1 :     agent_->set_interface_table(intf_table);
     135           1 :     intf_table->Init(this);
     136           1 :     intf_table->set_agent(agent_);
     137             : 
     138             :     // Allocate Range to be used for MetaDataIPAllocator
     139           1 :     agent_->set_metadata_ip_allocator(
     140           1 :             new MetaDataIpAllocator(agent_, 1, max_linklocal_addresses - 1));
     141           1 :     agent_->set_metadata_ip6_allocator(
     142           1 :             new MetaDataIpAllocator(agent_, 1, max_linklocal_addresses - 1));
     143             : 
     144             :     HealthCheckTable *hc_table;
     145             :     hc_table =
     146           1 :         static_cast<HealthCheckTable *>(db->CreateTable("db.healthcheck.0"));
     147           1 :     assert(hc_table);
     148           1 :     agent_->set_health_check_table(hc_table);
     149             : 
     150             :     CryptTunnelTable *crypt_tunnel_table;
     151           1 :     crypt_tunnel_table = static_cast<CryptTunnelTable *>(db->CreateTable("db.crypttunnel.0"));
     152           1 :     assert(crypt_tunnel_table);
     153           1 :     agent_->set_crypt_tunnel_table(crypt_tunnel_table);
     154             : 
     155             :     NextHopTable *nh_table;
     156           1 :     nh_table = static_cast<NextHopTable *>(db->CreateTable("db.nexthop.0"));
     157           1 :     assert(nh_table);
     158           1 :     agent_->set_nexthop_table(nh_table);
     159           1 :     nh_table->set_agent(agent_);
     160             : 
     161             :     VrfTable *vrf_table;
     162           1 :     vrf_table = static_cast<VrfTable *>(db->CreateTable("db.vrf.0"));
     163           1 :     assert(vrf_table);
     164           1 :     agent_->set_vrf_table(vrf_table);
     165           1 :     vrf_table->set_agent(agent_);
     166             : 
     167             :     VmTable *vm_table;
     168           1 :     vm_table = static_cast<VmTable *>(db->CreateTable("db.vm.0"));
     169           1 :     assert(vm_table);
     170           1 :     agent_->set_vm_table(vm_table);
     171           1 :     vm_table->set_agent(agent_);
     172             : 
     173             :     SgTable *sg_table;
     174           1 :     sg_table = static_cast<SgTable *>(db->CreateTable("db.sg.0"));
     175           1 :     assert(sg_table);
     176           1 :     agent_->set_sg_table(sg_table);
     177           1 :     sg_table->set_agent(agent_);
     178             : 
     179             :     TagTable *tag_table;
     180           1 :     tag_table = static_cast<TagTable *>(db->CreateTable("db.tag.0"));
     181           1 :     assert(tag_table);
     182           1 :     agent_->set_tag_table(tag_table);
     183           1 :     tag_table->set_agent(agent_);
     184             : 
     185             :     VnTable *vn_table;
     186           1 :     vn_table = static_cast<VnTable *>(db->CreateTable("db.vn.0"));
     187           1 :     assert(vn_table);
     188           1 :     agent_->set_vn_table(vn_table);
     189           1 :     vn_table->set_agent(agent_);
     190             : 
     191             :     MplsTable *mpls_table;
     192           1 :     mpls_table = static_cast<MplsTable *>(db->CreateTable("db.mpls.0"));
     193           1 :     assert(mpls_table);
     194           1 :     agent_->set_mpls_table(mpls_table);
     195           1 :     mpls_table->set_agent(agent_);
     196           1 :     mpls_table->ReserveLabel(0, MplsTable::kStartLabel - 1);
     197             : 
     198             :     AclTable *acl_table;
     199           1 :     acl_table = static_cast<AclTable *>(db->CreateTable("db.acl.0"));
     200           1 :     assert(acl_table);
     201           1 :     agent_->set_acl_table(acl_table);
     202           1 :     acl_table->set_agent(agent_);
     203             : 
     204             :     MirrorTable *mirror_table;
     205             :     mirror_table = static_cast<MirrorTable *>
     206           1 :                    (db->CreateTable("db.mirror_table.0"));
     207           1 :     assert(mirror_table);
     208           1 :     agent_->set_mirror_table(mirror_table);
     209           1 :     mirror_table->set_agent(agent_);
     210           1 :     mirror_table->Initialize();
     211             : 
     212             :     VrfAssignTable *vassign_table = static_cast<VrfAssignTable *>
     213           1 :                    (db->CreateTable("db.vrf_assign.0"));
     214           1 :     assert(vassign_table);
     215           1 :     agent_->set_vrf_assign_table(vassign_table);
     216           1 :     vassign_table->set_agent(agent_);
     217             : 
     218             :     PolicySetTable *policy_set =
     219           1 :         static_cast<PolicySetTable *>(db->CreateTable("db.policy_set.0"));
     220           1 :     assert(policy_set);
     221           1 :     agent_->set_policy_set_table(policy_set);
     222           1 :     policy_set->set_agent(agent_);
     223             : 
     224           1 :     domain_config_.reset(new DomainConfig(agent_));
     225             : 
     226             :     VxLanTable *vxlan_table;
     227           1 :     vxlan_table = static_cast<VxLanTable *>(db->CreateTable("db.vxlan.0"));
     228           1 :     assert(vxlan_table);
     229           1 :     agent_->set_vxlan_table(vxlan_table);
     230           1 :     vxlan_table->set_agent(agent_);
     231           1 :     vxlan_table->Initialize();
     232             : 
     233             :     QosQueueTable *qos_queue_table;
     234             :     qos_queue_table =
     235           1 :         static_cast<QosQueueTable *>(db->CreateTable("db.qos_queue.0"));
     236           1 :     agent_->set_qos_queue_table(qos_queue_table);
     237             : 
     238             :     ForwardingClassTable *forwarding_class_table;
     239             :     forwarding_class_table = static_cast<ForwardingClassTable *>(
     240           1 :                                  db->CreateTable("db.forwardingclass.0"));
     241           1 :     agent_->set_forwarding_class_table(forwarding_class_table);
     242             : 
     243             :     SecurityLoggingObjectTable *slo_table;
     244             :     slo_table = static_cast<SecurityLoggingObjectTable *>(
     245           1 :                                  db->CreateTable("db.security_logging_object.0"));
     246           1 :     agent_->set_slo_table(slo_table);
     247             : 
     248             :     AgentQosConfigTable *qos_config_table;
     249             :     qos_config_table =
     250           1 :         static_cast<AgentQosConfigTable *>(db->CreateTable("db.qos_config.0"));
     251           1 :     agent_->set_qos_config_table(qos_config_table);
     252             : 
     253             :     BridgeDomainTable *bd_table;
     254             :     bd_table =
     255           1 :         static_cast<BridgeDomainTable *>(db->CreateTable("db.bridge_domain.0"));
     256           1 :     assert(bd_table);
     257           1 :     agent_->set_bridge_domain_table(bd_table);
     258             : 
     259             :     MulticastPolicyTable *mp_table;
     260             :     mp_table = static_cast<MulticastPolicyTable *>(
     261           1 :                                 db->CreateTable("db.multicast_policy.0"));
     262           1 :     assert(mp_table);
     263           1 :     agent_->set_mp_table(mp_table);
     264           1 :     mp_table->set_agent(agent_);
     265             : 
     266           1 :     acl_table->ListenerInit();
     267             : 
     268             :     route_walk_manager_ =
     269           1 :         std::unique_ptr<AgentRouteWalkerManager>(new AgentRouteWalkerManager(agent_));
     270           1 :     multicast_ = std::unique_ptr<MulticastHandler>(new MulticastHandler(agent_));
     271           1 :     global_vrouter_ = std::unique_ptr<GlobalVrouter> (new GlobalVrouter(agent_));
     272             :     route_preference_module_ =
     273           1 :         std::unique_ptr<PathPreferenceModule>(new PathPreferenceModule(agent_));
     274           1 :     route_preference_module_->Init();
     275             : 
     276             :     ServiceInstanceTable *si_table =
     277             :         static_cast<ServiceInstanceTable *>(
     278           1 :             db->CreateTable("db.service-instance.0"));
     279           1 :     agent_->set_service_instance_table(si_table);
     280           1 :     si_table->Initialize(agent_->cfg()->cfg_graph(), dependency_manager_.get());
     281           1 :     si_table->set_agent(agent_);
     282             : 
     283             :     PhysicalDeviceTable *dev_table =
     284           1 :         DBTableCreate<PhysicalDeviceTable>(db, agent_, this,
     285             :                                            "db.physical_devices.0");
     286           1 :     agent_->set_physical_device_table(dev_table);
     287             : 
     288             :     PhysicalDeviceVnTable *dev_vn_table =
     289           1 :         DBTableCreate<PhysicalDeviceVnTable>(db, agent_, this,
     290             :                                              "db.physical_device_vn.0");
     291           1 :     agent_->set_physical_device_vn_table(dev_vn_table);
     292           1 :     profile_.reset(new AgentProfile(agent_, true));
     293             : 
     294           1 :     bgp_as_a_service_ = std::unique_ptr<BgpAsAService>(new BgpAsAService(agent_));
     295             :     bgp_router_config_ =
     296           1 :         std::unique_ptr<BgpRouterConfig> (new BgpRouterConfig(agent_));
     297             : 
     298           1 :     vrouter_ = std::unique_ptr<VRouter> (new VRouter(agent_));
     299             :     global_qos_config_ =
     300           1 :         std::unique_ptr<GlobalQosConfig>(new GlobalQosConfig(agent_));
     301             :     global_system_config_ =
     302           1 :         std::unique_ptr<GlobalSystemConfig>(new GlobalSystemConfig(agent_));
     303           2 :     network_ipam_ = std::unique_ptr<OperNetworkIpam>
     304           2 :         (new OperNetworkIpam(agent_, domain_config_.get()));
     305           2 :     virtual_dns_ = std::unique_ptr<OperVirtualDns>
     306           2 :         (new OperVirtualDns(agent_, domain_config_.get()));
     307           1 :     tsn_elector_ = std::unique_ptr<TsnElector>(new TsnElector(agent_));
     308           2 :     vxlan_routing_manager_= std::unique_ptr<VxlanRoutingManager>
     309           2 :         (new VxlanRoutingManager(agent_));
     310           2 :     hbf_handler_= std::unique_ptr<HBFHandler>
     311           2 :         (new HBFHandler(agent_));
     312           1 : }
     313             : 
     314           1 : void OperDB::Init() {
     315           1 :     dependency_manager_->Initialize(agent());
     316             : 
     317             :     // Unit tests may not initialize the agent configuration parameters.
     318           1 :     std::string netns_cmd;
     319           1 :     std::string docker_cmd;
     320           1 :     int netns_workers = -1;
     321           1 :     int netns_timeout = -1;
     322           1 :     if (agent_->params()) {
     323           1 :         netns_cmd = agent_->params()->si_netns_command();
     324           1 :         docker_cmd = agent_->params()->si_docker_command();
     325           1 :         netns_workers = agent_->params()->si_netns_workers();
     326           1 :         netns_timeout = agent_->params()->si_netns_timeout();
     327             :     }
     328           1 :     instance_manager_->Initialize(agent_->db(), netns_cmd,
     329             :                     docker_cmd, netns_workers, netns_timeout);
     330           1 :     if (nexthop_manager_.get()) {
     331           0 :         nexthop_manager_->Initialize(agent_->db());
     332             :     }
     333             : 
     334           1 :     if (agent_sandesh_manager_.get()) {
     335           1 :         agent_sandesh_manager_->Init();
     336             :     }
     337             : 
     338           1 :     agent_->config_manager()->Init();
     339           1 :     domain_config_->Init();
     340           1 : }
     341             : 
     342           1 : void OperDB::InitDone() {
     343           1 :     profile_->InitDone();
     344           1 : }
     345             : 
     346           1 : void OperDB::RegisterDBClients() {
     347           1 :     IFMapDependencyManager *mgr = agent_->oper_db()->dependency_manager();
     348           1 :     agent_->physical_device_table()->RegisterDBClients(mgr);
     349           1 :     agent_->interface_table()->RegisterDBClients(mgr);
     350             : 
     351           1 :     multicast_.get()->Register();
     352           1 :     global_vrouter_.get()->CreateDBClients();
     353           1 :     route_leak_manager_.reset(new RouteLeakManager(agent_));
     354           1 :     tsn_elector_.get()->Register();
     355           1 :     vxlan_routing_manager_.get()->Register();
     356           1 :     hbf_handler_.get()->Register();
     357           1 : }
     358             : 
     359           1 : OperDB::OperDB(Agent *agent)
     360           1 :         : agent_(agent),
     361           1 :           dependency_manager_(
     362             :               AgentStaticObjectFactory::Create<IFMapDependencyManager>(
     363             :                   agent->db(), agent->cfg()->cfg_graph())),
     364           1 :           instance_manager_(
     365           2 :                   AgentStaticObjectFactory::Create<InstanceManager>(agent)) {
     366           2 :     if (agent_->params() &&
     367           2 :         agent_->params()->nexthop_server_endpoint().length() > 0) {
     368           0 :         nexthop_manager_.reset(new NexthopManager(agent_->event_manager(),
     369           0 :                                agent->params()->nexthop_server_endpoint()));
     370             :     }
     371             : 
     372           1 :     agent_sandesh_manager_.reset(new AgentSandeshManager(agent));
     373           1 : }
     374             : 
     375           2 : OperDB::~OperDB() {
     376           2 : }
     377             : 
     378           1 : void OperDB::Shutdown() {
     379           1 :     agent_->mpls_table()->FreeReserveLabel(0, MplsTable::kStartLabel - 1);
     380           1 :     instance_manager_->Terminate();
     381           1 :     if (nexthop_manager_.get()) {
     382           0 :         nexthop_manager_->Terminate();
     383             :     }
     384           1 :     dependency_manager_->Terminate();
     385           1 :     global_vrouter_.reset();
     386             : 
     387           1 :     bgp_router_config_.reset();
     388             : 
     389           1 :     global_qos_config_.reset();
     390           1 :     global_system_config_.reset();
     391             : 
     392           1 :     route_preference_module_->Shutdown();
     393           1 :     multicast_->Shutdown();
     394           1 :     multicast_->Terminate();
     395           1 :     route_walk_manager_->Shutdown();
     396           1 :     tsn_elector_->Shutdown();
     397           1 :     vxlan_routing_manager_->Shutdown();
     398           1 :     hbf_handler_->Terminate();
     399             : 
     400           1 :     if (agent_sandesh_manager_.get()) {
     401           1 :         agent_sandesh_manager_->Shutdown();
     402             :     }
     403             : #if 0
     404             :     agent_->interface_table()->Clear();
     405             :     agent_->nexthop_table()->Clear();
     406             :     agent_->vrf_table()->Clear();
     407             :     agent_->vn_table()->Clear();
     408             :     agent_->sg_table()->Clear();
     409             :     agent_->vm_table()->Clear();
     410             :     agent_->mpls_table()->Clear();
     411             :     agent_->acl_table()->Clear();
     412             :     agent_->mirror_table()->Clear();
     413             :     agent_->vrf_assign_table()->Clear();
     414             :     agent_->vxlan_table()->Clear();
     415             :     agent_->service_instance_table()->Clear();
     416             :     agent_->mp_table()->Clear();
     417             : #endif
     418             : 
     419           1 :     route_preference_module_->Shutdown();
     420           1 :     domain_config_->Terminate();
     421           1 :     if (vrouter_.get()) {
     422           1 :         vrouter_->Shutdown();
     423           1 :         vrouter_.reset();
     424             :     }
     425           1 :     if (agent()->mirror_table()) {
     426           1 :         agent()->mirror_table()->Shutdown();
     427             :     }
     428             : 
     429           1 :     if (agent()->vxlan_table()) {
     430           1 :         agent()->vxlan_table()->Shutdown();
     431             :     }
     432             : 
     433             :     //route_walk_manager_.reset();
     434           1 :     profile_.reset();
     435           1 :     route_leak_manager_.reset();
     436           1 :     vxlan_routing_manager_.reset();
     437           1 :     hbf_handler_.reset();
     438           1 : }
     439             : 
     440           1 : void OperDB::DeleteRoutes() {
     441           1 :     agent_->vrf_table()->DeleteRoutes();
     442           1 : }