Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2016 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #ifndef vnsw_agent_resource_sandesh_map_hpp
       6             : #define vnsw_agent_resource_sandesh_map_hpp
       7             : #include "resource_manager/resource_manager_types.h"
       8             : 
       9             : class Timer;
      10             : class ResourceManager;
      11             : class ResourceBackupManager;
      12             : // Backup Resource Table maintains all the Sandesh data to
      13             : // resource index in a map. Timer is maintained per Backup Resource table.
      14             : // will be used to trigger Write to file based on idle time out logic.
      15             : // Trigger will be intiated Only when we don't see any frequent Changes
      16             : // in the Data modifications with in the idle time out period otherwise
      17             : // Write to file will happens upon fallback.
      18             : class BackUpResourceTable {
      19             : public:
      20             :     static const uint8_t  kFallBackCount = 6;
      21             :     BackUpResourceTable(ResourceBackupManager *manager,
      22             :                         const std::string &name,
      23             :                         const std::string& file_name);
      24             :     virtual ~BackUpResourceTable();
      25             : 
      26             :     virtual bool WriteToFile() = 0;
      27             :     virtual void ReadFromFile() = 0;
      28             :     virtual void RestoreResource() = 0;
      29             :     bool TimerExpiry();
      30             :     void StartTimer();
      31           0 :     ResourceBackupManager *backup_manager() {
      32           0 :         return backup_manager_;
      33             :     }
      34             :     Agent *agent() {return agent_;}
      35             :     void TriggerBackup();
      36             :     bool UpdateRequired();
      37             :     void EnqueueRestore(ResourceManager::KeyPtr key,
      38             :                         ResourceManager:: DataPtr data);
      39           0 :     const std::string & backup_dir() {return backup_dir_;}
      40             :     static const std::string FindFile(const std::string &root,
      41             :                                       const std::string & file_ext);
      42             :     static bool CalculateHashSum(const std::string &file_name,
      43             :                                  uint32_t *hashsum);
      44           0 :     const std::string& file_name_str() {return file_name_str_;}
      45           0 :     const std::string& file_name_prefix() {return file_name_prefix_;}
      46             : protected:
      47             :     template <typename T1, typename T2>
      48             :     bool WriteMapToFile(T1* sandesh_data, const T2& index_map);
      49             :     template <typename T>
      50             :     void ReadMapFromFile(T* sandesh_data, const std::string &root);
      51             :     std::string backup_dir_;
      52             : 
      53             : private:
      54             :     ResourceBackupManager *backup_manager_;
      55             :     Agent *agent_;
      56             :     std::string name_;
      57             :     Timer *timer_;
      58             :     uint32_t backup_idle_timeout_;
      59             :     uint64_t last_modified_time_;
      60             :     uint8_t fall_back_count_;
      61             :     std::string file_name_str_;
      62             :     std::string file_name_prefix_;
      63             :     DISALLOW_COPY_AND_ASSIGN(BackUpResourceTable);
      64             : };
      65             : 
      66             : // Vrf backup resource table to maintains Sandesh encoded data VrfMpls info
      67             : class VrfMplsBackUpResourceTable : public BackUpResourceTable {
      68             : public:
      69             :     typedef std::map<uint32_t, VrfMplsResource> Map;
      70             :     typedef Map::iterator MapIter;
      71             :     VrfMplsBackUpResourceTable(ResourceBackupManager *manager);
      72             :     virtual ~VrfMplsBackUpResourceTable();
      73             : 
      74             :     bool WriteToFile();
      75             :     void ReadFromFile();
      76             :     void RestoreResource();
      77           0 :     Map& map() {return map_;}
      78             : private:
      79             :     Map map_;
      80             : };
      81             : 
      82             : // Vlan backup resource table to maintains Sandesh encoded data VlanMpls info
      83             : class VlanMplsBackUpResourceTable : public BackUpResourceTable {
      84             : public:
      85             :     typedef std::map<uint32_t, VlanMplsResource> Map;
      86             :     typedef Map::iterator MapIter;
      87             :     VlanMplsBackUpResourceTable(ResourceBackupManager *manager);
      88             :     virtual ~VlanMplsBackUpResourceTable();
      89             : 
      90             :     bool WriteToFile();
      91             :     void ReadFromFile();
      92             :     void RestoreResource();
      93           0 :     Map& map() {return map_;}
      94             : private:
      95             :     Map map_;
      96             : };
      97             : 
      98             : // Interface backup resource table to maintains sandesh encode data for
      99             : // interfaceMpls info
     100             : class InterfaceMplsBackUpResourceTable : public BackUpResourceTable {
     101             : public:
     102             :     typedef std::map<uint32_t, InterfaceIndexResource> Map;
     103             :     typedef Map::iterator MapIter;
     104             :     InterfaceMplsBackUpResourceTable(ResourceBackupManager *manager);
     105             :     virtual ~InterfaceMplsBackUpResourceTable();
     106             : 
     107             :     bool WriteToFile();
     108             :     void ReadFromFile();
     109             :     void RestoreResource();
     110           0 :     Map& map() {return map_;}
     111             : private:
     112             :     Map map_;
     113             : };
     114             : 
     115             : // Route backup resource table to maintains sandesh encoded data for route info
     116             : class RouteMplsBackUpResourceTable : public BackUpResourceTable {
     117             : public:
     118             :     typedef std::map<uint32_t, RouteMplsResource> Map;
     119             :     typedef Map::iterator MapIter;
     120             :     RouteMplsBackUpResourceTable(ResourceBackupManager *manager);
     121             :     virtual ~RouteMplsBackUpResourceTable();
     122             : 
     123             :     bool WriteToFile();
     124             :     void ReadFromFile();
     125             :     void RestoreResource();
     126           0 :     Map& map() {return map_;}
     127             : private:
     128             :     Map map_;
     129             : };
     130             : 
     131             : // interface backup resource table to maintains sandesh encoded data for route info
     132             : class VmInterfaceBackUpResourceTable : public BackUpResourceTable {
     133             : public:
     134             :     typedef std::map<uint32_t, VmInterfaceIndexResource> Map;
     135             :     typedef Map::iterator MapIter;
     136             :     VmInterfaceBackUpResourceTable(ResourceBackupManager *manager);
     137             :     virtual ~VmInterfaceBackUpResourceTable();
     138             : 
     139             :     bool WriteToFile();
     140             :     void ReadFromFile();
     141             :     void RestoreResource();
     142           0 :     Map& map() {return map_;}
     143             : private:
     144             :     Map map_;
     145             : };
     146             : 
     147             : // vrf backup resource table to maintains sandesh encoded data for vrf info
     148             : class VrfBackUpResourceTable : public BackUpResourceTable {
     149             : public:
     150             :     typedef std::map<uint32_t, VrfIndexResource> Map;
     151             :     typedef Map::iterator MapIter;
     152             :     VrfBackUpResourceTable(ResourceBackupManager *manager);
     153             :     virtual ~VrfBackUpResourceTable();
     154             : 
     155             :     bool WriteToFile();
     156             :     void ReadFromFile();
     157             :     void RestoreResource();
     158           0 :     Map& map() {return map_;}
     159             : private:
     160             :     Map map_;
     161             : };
     162             : 
     163             : // Qos backup resource table to maintains sandesh encoded data for qos info
     164             : class QosBackUpResourceTable : public BackUpResourceTable {
     165             : public:
     166             :     typedef std::map<uint32_t, QosIndexResource> Map;
     167             :     typedef Map::iterator MapIter;
     168             :     QosBackUpResourceTable(ResourceBackupManager *manager);
     169             :     virtual ~QosBackUpResourceTable();
     170             : 
     171             :     bool WriteToFile();
     172             :     void ReadFromFile();
     173             :     void RestoreResource();
     174           0 :     Map& map() {return map_;}
     175             : private:
     176             :     Map map_;
     177             : };
     178             : 
     179             : // bgp as a service backup resource table to maintains
     180             : // sandesh encoded data for bgp info
     181             : class BgpAsServiceBackUpResourceTable : public BackUpResourceTable {
     182             : public:
     183             :     typedef std::map<uint32_t, BgpAsServiceIndexResource> Map;
     184             :     typedef Map::iterator MapIter;
     185             :     BgpAsServiceBackUpResourceTable(ResourceBackupManager *manager);
     186             :     virtual ~BgpAsServiceBackUpResourceTable();
     187             : 
     188             :     bool WriteToFile();
     189             :     void ReadFromFile();
     190             :     void RestoreResource();
     191           0 :     Map& map() {return map_;}
     192             : private:
     193             :     Map map_;
     194             : };
     195             : 
     196             : // mirro backup resource table to maintains sandesh encoded data for mirro info
     197             : class MirrorBackUpResourceTable : public BackUpResourceTable {
     198             : public:
     199             :     typedef std::map<uint32_t, MirrorIndexResource> Map;
     200             :     typedef Map::iterator MapIter;
     201             :     MirrorBackUpResourceTable(ResourceBackupManager *manager);
     202             :     virtual ~MirrorBackUpResourceTable();
     203             : 
     204             :     bool WriteToFile();
     205             :     void ReadFromFile();
     206             :     void RestoreResource();
     207           0 :     Map& map() {return map_;}
     208             : private:
     209             :     Map map_;
     210             : };
     211             : 
     212             : // Maintians all the Sandesh encoded structures
     213             : class ResourceSandeshMaps {
     214             : public:
     215             :     typedef pair<uint32_t, VrfMplsResource> VrfMplsResourcePair;
     216             :     typedef pair<uint32_t, VlanMplsResource> VlanMplsResourcePair;
     217             :     typedef pair<uint32_t, InterfaceIndexResource>
     218             :         InterfaceMplsResourcePair;
     219             :     typedef pair<uint32_t, RouteMplsResource> RouteMplsResourcePair;
     220             :     typedef pair<uint32_t, VmInterfaceIndexResource>
     221             :         VmInterfaceIndexResourcePair;
     222             :     typedef pair<uint32_t, VrfIndexResource> VrfIndexResourcePair;
     223             :     typedef pair<uint32_t, QosIndexResource> QosIndexResourcePair;
     224             :     typedef pair<uint32_t, BgpAsServiceIndexResource>
     225             :         BgpAsServiceIndexResourcePair;
     226             :     typedef pair<uint32_t, MirrorIndexResource> MirrorIndexResourcePair;
     227             :     ResourceSandeshMaps(ResourceBackupManager *manager);
     228             :     virtual ~ResourceSandeshMaps();
     229             :     void ReadFromFile();
     230             :     void RestoreResource();
     231             :     void EndOfBackup();
     232             :     void AddInterfaceMplsResourceEntry(uint32_t index,
     233             :                                        InterfaceIndexResource data );
     234             :     void DeleteInterfaceMplsResourceEntry(uint32_t index);
     235             :     void AddVrfMplsResourceEntry(uint32_t index,
     236             :                                  VrfMplsResource data);
     237             :     void DeleteVrfMplsResourceEntry(uint32_t index);
     238             :     void AddVlanMplsResourceEntry(uint32_t index,
     239             :                                  VlanMplsResource data);
     240             :     void DeleteVlanMplsResourceEntry(uint32_t index);
     241             :     void AddRouteMplsResourceEntry(uint32_t index,
     242             :                                    RouteMplsResource data);
     243             :     void DeleteRouteMplsResourceEntry(uint32_t index);
     244             : 
     245             :     void AddVmInterfaceResourceEntry(uint32_t index,
     246             :                                     VmInterfaceIndexResource data);
     247             :     void DeleteVmInterfaceResourceEntry(uint32_t index);
     248             : 
     249             :     void AddVrfResourceEntry(uint32_t index,
     250             :                              VrfIndexResource data);
     251             :     void DeleteVrfResourceEntry(uint32_t index);
     252             : 
     253             :     void AddQosResourceEntry(uint32_t index,
     254             :                              QosIndexResource data);
     255             :     void DeleteQosResourceEntry(uint32_t index);
     256             : 
     257             :     void AddBgpAsServiceResourceEntry(uint32_t index,
     258             :                                       BgpAsServiceIndexResource data);
     259             :     void DeleteBgpAsServiceResourceEntry(uint32_t index);
     260             : 
     261             :     void AddMirrorResourceEntry(uint32_t index,
     262             :                                 MirrorIndexResource data);
     263             :     void DeleteMirrorResourceEntry(uint32_t index);
     264             : 
     265           0 :     InterfaceMplsBackUpResourceTable& interface_mpls_index_table() {
     266           0 :        return interface_mpls_index_table_;
     267             :     }
     268             : 
     269           0 :     VrfMplsBackUpResourceTable& vrf_mpls_index_table() {
     270           0 :         return vrf_mpls_index_table_;
     271             :     }
     272             : 
     273           0 :     VlanMplsBackUpResourceTable& vlan_mpls_index_table() {
     274           0 :         return vlan_mpls_index_table_;
     275             :     }
     276             : 
     277           0 :     RouteMplsBackUpResourceTable& route_mpls_index_table() {
     278           0 :         return route_mpls_index_table_;
     279             :     }
     280             : 
     281           0 :     VmInterfaceBackUpResourceTable& vm_interface_index_table() {
     282           0 :         return vm_interface_index_table_;
     283             :     }
     284             : 
     285           0 :     VrfBackUpResourceTable& vrf_index_table() {
     286           0 :         return vrf_index_table_;
     287             :     }
     288             : 
     289           0 :     QosBackUpResourceTable& qos_index_table() {
     290           0 :         return qos_index_table_;
     291             :     }
     292             : 
     293           0 :     BgpAsServiceBackUpResourceTable& bgp_as_service_index_table() {
     294           0 :         return bgp_as_service_index_table_;
     295             :     }
     296             : 
     297           0 :     MirrorBackUpResourceTable& mirror_index_table() {
     298           0 :         return mirror_index_table_;
     299             :     }
     300             : 
     301             : private:
     302             :     ResourceBackupManager *backup_manager_;
     303             :     Agent *agent_;
     304             :     InterfaceMplsBackUpResourceTable interface_mpls_index_table_;
     305             :     VrfMplsBackUpResourceTable vrf_mpls_index_table_;
     306             :     VlanMplsBackUpResourceTable vlan_mpls_index_table_;
     307             :     RouteMplsBackUpResourceTable route_mpls_index_table_;
     308             :     VmInterfaceBackUpResourceTable vm_interface_index_table_;
     309             :     VrfBackUpResourceTable vrf_index_table_;
     310             :     QosBackUpResourceTable qos_index_table_;
     311             :     BgpAsServiceBackUpResourceTable bgp_as_service_index_table_;
     312             :     MirrorBackUpResourceTable mirror_index_table_;
     313             :     DISALLOW_COPY_AND_ASSIGN(ResourceSandeshMaps);
     314             : };
     315             : #endif