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           6 : T *DBTableCreate(DB *db, Agent *agent, OperDB *oper,
      71             :                    const std::string &db_name) {
      72           6 :     DB::RegisterFactory(db_name, &T::CreateTable);
      73           6 :     T *table = static_cast<T *>(db->CreateTable(db_name));
      74           6 :     assert(table);
      75           6 :     table->set_agent(agent);
      76           6 :     return table;
      77             : }
      78             : 
      79           3 : void OperDB::CreateDBTables(DB *db) {
      80           3 :     DB::RegisterFactory("db.interface.0", &InterfaceTable::CreateTable);
      81           3 :     DB::RegisterFactory("db.nexthop.0", &NextHopTable::CreateTable);
      82           3 :     DB::RegisterFactory("db.crypttunnel.0",
      83             :                         boost::bind(&CryptTunnelTable::CreateTable,
      84             :                                     agent_, _1, _2));
      85           3 :     DB::RegisterFactory("uc.route.0",
      86             :                         &InetUnicastAgentRouteTable::CreateTable);
      87           3 :     DB::RegisterFactory("uc.route.3",
      88             :                         &InetUnicastAgentRouteTable::CreateTable);
      89           3 :     DB::RegisterFactory("mc.route.0",
      90             :                         &Inet4MulticastAgentRouteTable::CreateTable);
      91           3 :     DB::RegisterFactory("evpn.route.0", &EvpnAgentRouteTable::CreateTable);
      92           3 :     DB::RegisterFactory("l2.route.0", &BridgeAgentRouteTable::CreateTable);
      93           3 :     DB::RegisterFactory("uc.route6.0",
      94             :                         &InetUnicastAgentRouteTable::CreateTable);
      95           3 :     DB::RegisterFactory("db.vrf.0", &VrfTable::CreateTable);
      96           3 :     DB::RegisterFactory("db.vn.0", &VnTable::CreateTable);
      97           3 :     DB::RegisterFactory("db.vm.0", &VmTable::CreateTable);
      98           3 :     DB::RegisterFactory("db.sg.0", &SgTable::CreateTable);
      99           3 :     DB::RegisterFactory("db.tag.0", &TagTable::CreateTable);
     100           3 :     DB::RegisterFactory("db.mpls.0", &MplsTable::CreateTable);
     101           3 :     DB::RegisterFactory("db.acl.0", &AclTable::CreateTable);
     102           3 :     DB::RegisterFactory("db.mirror_table.0", &MirrorTable::CreateTable);
     103           3 :     DB::RegisterFactory("db.vrf_assign.0", &VrfAssignTable::CreateTable);
     104           3 :     DB::RegisterFactory("db.vxlan.0", &VxLanTable::CreateTable);
     105           3 :     DB::RegisterFactory("db.service-instance.0",
     106             :                         &ServiceInstanceTable::CreateTable);
     107           3 :     DB::RegisterFactory("db.physical_devices.0",
     108             :                         &PhysicalDeviceTable::CreateTable);
     109           3 :     DB::RegisterFactory("db.healthcheck.0",
     110             :                         boost::bind(&HealthCheckTable::CreateTable,
     111             :                                     agent_, _1, _2));
     112           3 :     DB::RegisterFactory("db.qos_queue.0",
     113             :                         boost::bind(&QosQueueTable::CreateTable,
     114             :                         agent_, _1, _2));
     115           3 :     DB::RegisterFactory("db.forwardingclass.0",
     116             :                         boost::bind(&ForwardingClassTable::CreateTable,
     117             :                         agent_, _1, _2));
     118           3 :     DB::RegisterFactory("db.qos_config.0",
     119             :                         boost::bind(&AgentQosConfigTable::CreateTable,
     120             :                         agent_, _1, _2));
     121           3 :     DB::RegisterFactory("db.bridge_domain.0",
     122             :                         boost::bind(&BridgeDomainTable::CreateTable,
     123             :                                     agent_, _1, _2));
     124           3 :     DB::RegisterFactory("db.security_logging_object.0",
     125             :                         boost::bind(&SecurityLoggingObjectTable::CreateTable,
     126             :                         agent_, _1, _2));
     127           3 :     DB::RegisterFactory("db.policy_set.0", &PolicySetTable::CreateTable);
     128           3 :     DB::RegisterFactory("db.multicast_policy.0",
     129             :                         &MulticastPolicyTable::CreateTable);
     130             : 
     131             :     InterfaceTable *intf_table;
     132           3 :     intf_table = static_cast<InterfaceTable *>(db->CreateTable("db.interface.0"));
     133           3 :     assert(intf_table);
     134           3 :     agent_->set_interface_table(intf_table);
     135           3 :     intf_table->Init(this);
     136           3 :     intf_table->set_agent(agent_);
     137             : 
     138             :     // Allocate Range to be used for MetaDataIPAllocator
     139           3 :     agent_->set_metadata_ip_allocator(
     140           3 :             new MetaDataIpAllocator(agent_, 1, max_linklocal_addresses - 1));
     141           3 :     agent_->set_metadata_ip6_allocator(
     142           3 :             new MetaDataIpAllocator(agent_, 1, max_linklocal_addresses - 1));
     143             : 
     144             :     HealthCheckTable *hc_table;
     145             :     hc_table =
     146           3 :         static_cast<HealthCheckTable *>(db->CreateTable("db.healthcheck.0"));
     147           3 :     assert(hc_table);
     148           3 :     agent_->set_health_check_table(hc_table);
     149             : 
     150             :     CryptTunnelTable *crypt_tunnel_table;
     151           3 :     crypt_tunnel_table = static_cast<CryptTunnelTable *>(db->CreateTable("db.crypttunnel.0"));
     152           3 :     assert(crypt_tunnel_table);
     153           3 :     agent_->set_crypt_tunnel_table(crypt_tunnel_table);
     154             : 
     155             :     NextHopTable *nh_table;
     156           3 :     nh_table = static_cast<NextHopTable *>(db->CreateTable("db.nexthop.0"));
     157           3 :     assert(nh_table);
     158           3 :     agent_->set_nexthop_table(nh_table);
     159           3 :     nh_table->set_agent(agent_);
     160             : 
     161             :     VrfTable *vrf_table;
     162           3 :     vrf_table = static_cast<VrfTable *>(db->CreateTable("db.vrf.0"));
     163           3 :     assert(vrf_table);
     164           3 :     agent_->set_vrf_table(vrf_table);
     165           3 :     vrf_table->set_agent(agent_);
     166             : 
     167             :     VmTable *vm_table;
     168           3 :     vm_table = static_cast<VmTable *>(db->CreateTable("db.vm.0"));
     169           3 :     assert(vm_table);
     170           3 :     agent_->set_vm_table(vm_table);
     171           3 :     vm_table->set_agent(agent_);
     172             : 
     173             :     SgTable *sg_table;
     174           3 :     sg_table = static_cast<SgTable *>(db->CreateTable("db.sg.0"));
     175           3 :     assert(sg_table);
     176           3 :     agent_->set_sg_table(sg_table);
     177           3 :     sg_table->set_agent(agent_);
     178             : 
     179             :     TagTable *tag_table;
     180           3 :     tag_table = static_cast<TagTable *>(db->CreateTable("db.tag.0"));
     181           3 :     assert(tag_table);
     182           3 :     agent_->set_tag_table(tag_table);
     183           3 :     tag_table->set_agent(agent_);
     184             : 
     185             :     VnTable *vn_table;
     186           3 :     vn_table = static_cast<VnTable *>(db->CreateTable("db.vn.0"));
     187           3 :     assert(vn_table);
     188           3 :     agent_->set_vn_table(vn_table);
     189           3 :     vn_table->set_agent(agent_);
     190             : 
     191             :     MplsTable *mpls_table;
     192           3 :     mpls_table = static_cast<MplsTable *>(db->CreateTable("db.mpls.0"));
     193           3 :     assert(mpls_table);
     194           3 :     agent_->set_mpls_table(mpls_table);
     195           3 :     mpls_table->set_agent(agent_);
     196           3 :     mpls_table->ReserveLabel(0, MplsTable::kStartLabel - 1);
     197             : 
     198             :     AclTable *acl_table;
     199           3 :     acl_table = static_cast<AclTable *>(db->CreateTable("db.acl.0"));
     200           3 :     assert(acl_table);
     201           3 :     agent_->set_acl_table(acl_table);
     202           3 :     acl_table->set_agent(agent_);
     203             : 
     204             :     MirrorTable *mirror_table;
     205             :     mirror_table = static_cast<MirrorTable *>
     206           3 :                    (db->CreateTable("db.mirror_table.0"));
     207           3 :     assert(mirror_table);
     208           3 :     agent_->set_mirror_table(mirror_table);
     209           3 :     mirror_table->set_agent(agent_);
     210           3 :     mirror_table->Initialize();
     211             : 
     212             :     VrfAssignTable *vassign_table = static_cast<VrfAssignTable *>
     213           3 :                    (db->CreateTable("db.vrf_assign.0"));
     214           3 :     assert(vassign_table);
     215           3 :     agent_->set_vrf_assign_table(vassign_table);
     216           3 :     vassign_table->set_agent(agent_);
     217             : 
     218             :     PolicySetTable *policy_set =
     219           3 :         static_cast<PolicySetTable *>(db->CreateTable("db.policy_set.0"));
     220           3 :     assert(policy_set);
     221           3 :     agent_->set_policy_set_table(policy_set);
     222           3 :     policy_set->set_agent(agent_);
     223             : 
     224           3 :     domain_config_.reset(new DomainConfig(agent_));
     225             : 
     226             :     VxLanTable *vxlan_table;
     227           3 :     vxlan_table = static_cast<VxLanTable *>(db->CreateTable("db.vxlan.0"));
     228           3 :     assert(vxlan_table);
     229           3 :     agent_->set_vxlan_table(vxlan_table);
     230           3 :     vxlan_table->set_agent(agent_);
     231           3 :     vxlan_table->Initialize();
     232             : 
     233             :     QosQueueTable *qos_queue_table;
     234             :     qos_queue_table =
     235           3 :         static_cast<QosQueueTable *>(db->CreateTable("db.qos_queue.0"));
     236           3 :     agent_->set_qos_queue_table(qos_queue_table);
     237             : 
     238             :     ForwardingClassTable *forwarding_class_table;
     239             :     forwarding_class_table = static_cast<ForwardingClassTable *>(
     240           3 :                                  db->CreateTable("db.forwardingclass.0"));
     241           3 :     agent_->set_forwarding_class_table(forwarding_class_table);
     242             : 
     243             :     SecurityLoggingObjectTable *slo_table;
     244             :     slo_table = static_cast<SecurityLoggingObjectTable *>(
     245           3 :                                  db->CreateTable("db.security_logging_object.0"));
     246           3 :     agent_->set_slo_table(slo_table);
     247             : 
     248             :     AgentQosConfigTable *qos_config_table;
     249             :     qos_config_table =
     250           3 :         static_cast<AgentQosConfigTable *>(db->CreateTable("db.qos_config.0"));
     251           3 :     agent_->set_qos_config_table(qos_config_table);
     252             : 
     253             :     BridgeDomainTable *bd_table;
     254             :     bd_table =
     255           3 :         static_cast<BridgeDomainTable *>(db->CreateTable("db.bridge_domain.0"));
     256           3 :     assert(bd_table);
     257           3 :     agent_->set_bridge_domain_table(bd_table);
     258             : 
     259             :     MulticastPolicyTable *mp_table;
     260             :     mp_table = static_cast<MulticastPolicyTable *>(
     261           3 :                                 db->CreateTable("db.multicast_policy.0"));
     262           3 :     assert(mp_table);
     263           3 :     agent_->set_mp_table(mp_table);
     264           3 :     mp_table->set_agent(agent_);
     265             : 
     266           3 :     acl_table->ListenerInit();
     267             : 
     268             :     route_walk_manager_ =
     269           3 :         std::unique_ptr<AgentRouteWalkerManager>(new AgentRouteWalkerManager(agent_));
     270           3 :     multicast_ = std::unique_ptr<MulticastHandler>(new MulticastHandler(agent_));
     271           3 :     global_vrouter_ = std::unique_ptr<GlobalVrouter> (new GlobalVrouter(agent_));
     272             :     route_preference_module_ =
     273           3 :         std::unique_ptr<PathPreferenceModule>(new PathPreferenceModule(agent_));
     274           3 :     route_preference_module_->Init();
     275             : 
     276             :     ServiceInstanceTable *si_table =
     277             :         static_cast<ServiceInstanceTable *>(
     278           3 :             db->CreateTable("db.service-instance.0"));
     279           3 :     agent_->set_service_instance_table(si_table);
     280           3 :     si_table->Initialize(agent_->cfg()->cfg_graph(), dependency_manager_.get());
     281           3 :     si_table->set_agent(agent_);
     282             : 
     283             :     PhysicalDeviceTable *dev_table =
     284           3 :         DBTableCreate<PhysicalDeviceTable>(db, agent_, this,
     285             :                                            "db.physical_devices.0");
     286           3 :     agent_->set_physical_device_table(dev_table);
     287             : 
     288             :     PhysicalDeviceVnTable *dev_vn_table =
     289           3 :         DBTableCreate<PhysicalDeviceVnTable>(db, agent_, this,
     290             :                                              "db.physical_device_vn.0");
     291           3 :     agent_->set_physical_device_vn_table(dev_vn_table);
     292           3 :     profile_.reset(new AgentProfile(agent_, true));
     293             : 
     294           3 :     bgp_as_a_service_ = std::unique_ptr<BgpAsAService>(new BgpAsAService(agent_));
     295             :     bgp_router_config_ =
     296           3 :         std::unique_ptr<BgpRouterConfig> (new BgpRouterConfig(agent_));
     297             : 
     298           3 :     vrouter_ = std::unique_ptr<VRouter> (new VRouter(agent_));
     299             :     global_qos_config_ =
     300           3 :         std::unique_ptr<GlobalQosConfig>(new GlobalQosConfig(agent_));
     301             :     global_system_config_ =
     302           3 :         std::unique_ptr<GlobalSystemConfig>(new GlobalSystemConfig(agent_));
     303           6 :     network_ipam_ = std::unique_ptr<OperNetworkIpam>
     304           6 :         (new OperNetworkIpam(agent_, domain_config_.get()));
     305           6 :     virtual_dns_ = std::unique_ptr<OperVirtualDns>
     306           6 :         (new OperVirtualDns(agent_, domain_config_.get()));
     307           3 :     tsn_elector_ = std::unique_ptr<TsnElector>(new TsnElector(agent_));
     308           6 :     vxlan_routing_manager_= std::unique_ptr<VxlanRoutingManager>
     309           6 :         (new VxlanRoutingManager(agent_));
     310           6 :     hbf_handler_= std::unique_ptr<HBFHandler>
     311           6 :         (new HBFHandler(agent_));
     312           3 : }
     313             : 
     314           3 : void OperDB::Init() {
     315           3 :     dependency_manager_->Initialize(agent());
     316             : 
     317             :     // Unit tests may not initialize the agent configuration parameters.
     318           3 :     std::string netns_cmd;
     319           3 :     std::string docker_cmd;
     320           3 :     int netns_workers = -1;
     321           3 :     int netns_timeout = -1;
     322           3 :     if (agent_->params()) {
     323           3 :         netns_cmd = agent_->params()->si_netns_command();
     324           3 :         docker_cmd = agent_->params()->si_docker_command();
     325           3 :         netns_workers = agent_->params()->si_netns_workers();
     326           3 :         netns_timeout = agent_->params()->si_netns_timeout();
     327             :     }
     328           3 :     instance_manager_->Initialize(agent_->db(), netns_cmd,
     329             :                     docker_cmd, netns_workers, netns_timeout);
     330           3 :     if (nexthop_manager_.get()) {
     331           0 :         nexthop_manager_->Initialize(agent_->db());
     332             :     }
     333             : 
     334           3 :     if (agent_sandesh_manager_.get()) {
     335           3 :         agent_sandesh_manager_->Init();
     336             :     }
     337             : 
     338           3 :     agent_->config_manager()->Init();
     339           3 :     domain_config_->Init();
     340           3 : }
     341             : 
     342           3 : void OperDB::InitDone() {
     343           3 :     profile_->InitDone();
     344           3 : }
     345             : 
     346           3 : void OperDB::RegisterDBClients() {
     347           3 :     IFMapDependencyManager *mgr = agent_->oper_db()->dependency_manager();
     348           3 :     agent_->physical_device_table()->RegisterDBClients(mgr);
     349           3 :     agent_->interface_table()->RegisterDBClients(mgr);
     350             : 
     351           3 :     multicast_.get()->Register();
     352           3 :     global_vrouter_.get()->CreateDBClients();
     353           3 :     route_leak_manager_.reset(new RouteLeakManager(agent_));
     354           3 :     tsn_elector_.get()->Register();
     355           3 :     vxlan_routing_manager_.get()->Register();
     356           3 :     hbf_handler_.get()->Register();
     357           3 : }
     358             : 
     359           3 : OperDB::OperDB(Agent *agent)
     360           3 :         : agent_(agent),
     361           3 :           dependency_manager_(
     362             :               AgentStaticObjectFactory::Create<IFMapDependencyManager>(
     363             :                   agent->db(), agent->cfg()->cfg_graph())),
     364           3 :           instance_manager_(
     365           6 :                   AgentStaticObjectFactory::Create<InstanceManager>(agent)) {
     366           6 :     if (agent_->params() &&
     367           6 :         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           3 :     agent_sandesh_manager_.reset(new AgentSandeshManager(agent));
     373           3 : }
     374             : 
     375           6 : OperDB::~OperDB() {
     376           6 : }
     377             : 
     378           3 : void OperDB::Shutdown() {
     379           3 :     agent_->mpls_table()->FreeReserveLabel(0, MplsTable::kStartLabel - 1);
     380           3 :     instance_manager_->Terminate();
     381           3 :     if (nexthop_manager_.get()) {
     382           0 :         nexthop_manager_->Terminate();
     383             :     }
     384           3 :     dependency_manager_->Terminate();
     385           3 :     global_vrouter_.reset();
     386             : 
     387           3 :     bgp_router_config_.reset();
     388             : 
     389           3 :     global_qos_config_.reset();
     390           3 :     global_system_config_.reset();
     391             : 
     392           3 :     route_preference_module_->Shutdown();
     393           3 :     multicast_->Shutdown();
     394           3 :     multicast_->Terminate();
     395           3 :     route_walk_manager_->Shutdown();
     396           3 :     tsn_elector_->Shutdown();
     397           3 :     vxlan_routing_manager_->Shutdown();
     398           3 :     hbf_handler_->Terminate();
     399             : 
     400           3 :     if (agent_sandesh_manager_.get()) {
     401           3 :         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           3 :     route_preference_module_->Shutdown();
     420           3 :     domain_config_->Terminate();
     421           3 :     if (vrouter_.get()) {
     422           3 :         vrouter_->Shutdown();
     423           3 :         vrouter_.reset();
     424             :     }
     425           3 :     if (agent()->mirror_table()) {
     426           3 :         agent()->mirror_table()->Shutdown();
     427             :     }
     428             : 
     429           3 :     if (agent()->vxlan_table()) {
     430           3 :         agent()->vxlan_table()->Shutdown();
     431             :     }
     432             : 
     433             :     //route_walk_manager_.reset();
     434           3 :     profile_.reset();
     435           3 :     route_leak_manager_.reset();
     436           3 :     vxlan_routing_manager_.reset();
     437           3 :     hbf_handler_.reset();
     438           3 : }
     439             : 
     440           3 : void OperDB::DeleteRoutes() {
     441           3 :     agent_->vrf_table()->DeleteRoutes();
     442           3 : }