Line data    Source code

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