Line data    Source code

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