• 云备份——数据信息管理模块

    一，数据信息管理模块设计

    该模块主要用于服务端对备份的文件进行数据信息管理，以便于业务处理模块或者热点管理模随用随取，以及在网页上迅速的显示备份文件列表，因此该模块需要管理的信息也是根据后续业务处理模块以及热点管理模块确定的

    根据后续需要我们要管理的信息大概有以下几种

    1. 文件的实际存储路径：当用户发出下载请求时，会从该路径读取文件进行响应

    2. 文件的压缩包存放路径名：当用户要下载的文件为非热点文件时，需要到该路径下找到目标文件压缩包进行解压，再响应

    3. 文件是否压缩标志位：判断文件是否已经被压缩

    4. 文件大小

    5. 文件最后一次修改时间

    6. 文件最后一次访问时间

    7. 文件访问中URL的资源路径：/download/a.txt

    那么我们如何进行数据管理呢？

    1.首先对于数据的访问，最常用的就是查找，如当插入时需要查找资源是否存在，要获取某个备份文件时需要查找资源是否存在，当要更新备份文件时也需要迅速找到目标文件位置；因此我们选择用hash表在内存中管理数据，以URL的下载路径作为key值，对应的信息结构体作为value

    2. 持久化存储管理：当服务器关闭或者重启时，我们的文件信息也需要保存到文件中，当服务器再次开始，信息管理模块直接从文件中读取信息即可，因此我们选择用Json序列化将信息保存起来，取出时反序列化即可

    数据管理类提供的主要接口如下所示：

    1. #ifndef _MY_MANAGER_
    2. #define _MY_MANAGER_
    3.  
    4. #include "util.hpp"
    5. #include "config.hpp"
    6. #include 
    7.  
    8. namespace mjw_cloud
    9. {
    10.     struct BackupInfo
    11.     {
    12.         BackupInfo(const std::string real_path);
    13.         BackupInfo& operator=(const BackupInfo& data);//DataManager中的接口需要
    14.         bool _pack_flag;        // 判断文件是否压缩
    15.         size_t _fsize;          // 文件大小
    16.         time_t _atime;          // 文件最后一次访问时间
    17.         time_t _mtime;          // 文件最后一次修改时间
    18.         std::string _real_path; // 文件真实存储路径 ./packdir/
    19.         std::string _pack_path; // 文件压缩包存储路径 ./backdir/
    20.         std::string _url_path;  // 文件访问中url的资源路径 /download/文件名
    21.     };
    22.  
    23.     class DataManager
    24.     {
    25.     public:
    26.         DataManager();
    27.         ~DataManager();
    28.         // 存储
    29.         bool Storage();
    30.         // 从文件中读取文件信息管理表
    31.         bool InitTable();
    32.         // 表中插入数据
    33.         bool Insert(const BackupInfo &data);
    34.         // 修改更新表中数据
    35.         bool Updata(const BackupInfo &data);
    36.         // 根据url获取对应文件信息,用户根据url请求下载文件时需要
    37.         bool GetoneByURL(const std::string &url_path, BackupInfo *data);
    38.         // 根据文件存放路径获取文件信息，服务端检测备份文件时要用
    39.         bool GetoneByRp(const std::string &real_path, BackupInfo *data);
    40.         // 获取所有的文件信息，向用户提供一个备份文件表时需要
    41.         bool GetAll(std::vector *arry);
    42.  
    43.     private:
    44.         std::unordered_map _table; // 文件信息管理表
    45.         std::string _backup_file;                           // 持久化存储文件信息管理表
    46.         pthread_rwlock_t _rwlock;                           // 读写锁，读共享，写互斥
    47.     };
    48. }
    49.  
    50. #endif

    二，代码实现

    代码:

    1. #ifndef _MY_MANAGER_
    2. #define _MY_MANAGER_
    3.  
    4. #include "util.hpp"
    5. #include "config.hpp"
    6. #include 
    7. #include 
    8.  
    9. namespace mjw_cloud
    10. {
    11.     struct BackupInfo
    12.     {
    13.         // 后面数据管理类的InitTable需要用
    14.         BackupInfo() {}
    15.  
    16.         BackupInfo(const std::string real_path)
    17.         {
    18.             FileUtil fu(real_path);
    19.             if (fu.Exists() == false)
    20.             {
    21.                 std::cout << "文件不存在" << std::endl;
    22.                 return;
    23.             }
    24.             _pack_flag = 0;
    25.             _fsize = fu.FileSize();
    26.             _atime = fu.LastATime();
    27.             _mtime = fu.LastMTime();
    28.             _real_path = real_path;
    29.             //"./packdir/a.out" -> "./backdir/a.out.lz"
    30.             _pack_path = Config::GetInstance().GetPackDir() + fu.FileName() + Config::GetInstance().GetLzPrefix();
    31.             _url_path = Config::GetInstance().GetUrlPrefix() + fu.FileName();
    32.         }
    33.         BackupInfo &operator=(const BackupInfo &data) // DataManager中的接口需要
    34.         {
    35.             _pack_flag = data._pack_flag;
    36.             _fsize = data._fsize;
    37.             _atime = data._atime;
    38.             _mtime = data._mtime;
    39.             _real_path = data._real_path;
    40.             _pack_path = data._pack_path;
    41.             _url_path = data._url_path;
    42.  
    43.             return *this;
    44.         }
    45.         bool _pack_flag;        // 判断文件是否压缩
    46.         size_t _fsize;          // 文件大小
    47.         time_t _atime;          // 文件最后一次访问时间
    48.         time_t _mtime;          // 文件最后一次修改时间
    49.         std::string _real_path; // 文件真实存储路径名称 ./packdir/a.out
    50.         std::string _pack_path; // 文件压缩包存储路径名称 ./backdir/a.out.lz
    51.         std::string _url_path;  // 文件访问中url的资源路径 /download/文件名
    52.     };
    53.  
    54.     class DataManager
    55.     {
    56.     public:
    57.         DataManager()
    58.         {
    59.             pthread_rwlock_init(&_rwlock, nullptr);
    60.             _backup_file = Config::GetInstance().GetManagerFile();
    61.             // 初始化_table
    62.             InitTable();
    63.         }
    64.         ~DataManager()
    65.         {
    66.             pthread_rwlock_destroy(&_rwlock);
    67.         }
    68.         // 存储
    69.         bool Storage()
    70.         {
    71.             // 1. 将table Json序列化
    72.             Json::Value root;
    73.             for (auto t : _table)
    74.             {
    75.                 Json::Value val;
    76.                 val["_pack_flag"] = t.second._pack_flag;
    77.                 // Json支持内置类型，因此size_t和time_t都需强转
    78.                 val["_fsize"] = (Json::Int64)t.second._fsize;
    79.                 val["_atime"] = (Json::Int64)t.second._atime;
    80.                 val["_mtime"] = (Json::Int64)t.second._mtime;
    81.                 val["_real_path"] = t.second._real_path;
    82.                 val["_pack_path"] = t.second._pack_path;
    83.                 val["_url_path"] = t.second._url_path;
    84.  
    85.                 root.append(val);
    86.             }
    87.             std::string str;
    88.             JsonUtil::Serialize(root, &str);
    89.             // 2. 写入存储文件
    90.             FileUtil fu(_backup_file);
    91.             if (fu.SetContent(str) == false)
    92.             {
    93.                 std::cout << "storage failed" << std::endl;
    94.                 return false;
    95.             }
    96.  
    97.             return true;
    98.         }
    99.         // 从文件中读取文件信息管理表
    100.         bool InitTable()
    101.         {
    102.             // 读取信息
    103.             FileUtil fu(_backup_file);
    104.             if (fu.Exists() == false)
    105.                 return true;
    106.             std::string str;
    107.             if (fu.GetContent(&str) == false)
    108.             {
    109.                 std::cout << "InitTable failed" << std::endl;
    110.                 return false;
    111.             }
    112.             // 反序列化
    113.             Json::Value root;
    114.             JsonUtil::UnSerialize(str, &root);
    115.             for (int i = 0; i < root.size(); i++)
    116.             {
    117.                 BackupInfo info;
    118.                 info._atime = root[i]["_atime"].asInt();
    119.                 info._mtime = root[i]["_mtime"].asInt();
    120.                 info._fsize = root[i]["_fsize"].asInt();
    121.                 info._pack_flag = root[i]["_pack_flag"].asBool();
    122.                 info._pack_path = root[i]["_pack_path"].asString();
    123.                 info._real_path = root[i]["_real_path"].asString();
    124.                 info._url_path = root[i]["_url_path"].asString();
    125.                 Insert(info);
    126.             }
    127.  
    128.             return true;
    129.         }
    130.         // 表中插入数据
    131.         bool Insert(const BackupInfo &data)
    132.         {
    133.             pthread_rwlock_wrlock(&_rwlock);
    134.             _table[data._url_path] = data;
    135.             pthread_rwlock_unlock(&_rwlock);
    136.             //更新数据，持久化存储
    137.             Storage();
    138.             return true;
    139.         }
    140.         // 修改更新表中数据
    141.         bool Updata(const BackupInfo &data)
    142.         {
    143.             pthread_rwlock_wrlock(&_rwlock);
    144.             _table[data._url_path] = data;
    145.             pthread_rwlock_unlock(&_rwlock);
    146.             Storage();
    147.             return true;
    148.         }
    149.         // 根据url获取对应文件信息,用户根据url请求下载文件时需要
    150.         bool GetoneByURL(const std::string &url_path, BackupInfo *data)
    151.         {
    152.             pthread_rwlock_rdlock(&_rwlock);
    153.             auto it = _table.find(url_path);
    154.             if (it == _table.end())
    155.             {
    156.                 std::cout << "file unexist" << std::endl;
    157.                 pthread_rwlock_unlock(&_rwlock);
    158.                 return false;
    159.             }
    160.             *data = _table[url_path];
    161.             pthread_rwlock_unlock(&_rwlock);
    162.             return true;
    163.         }
    164.         // 根据文件存放路径获取文件信息，服务端检测备份文件时要用
    165.         bool GetoneByRp(const std::string &real_path, BackupInfo *data)
    166.         {
    167.             // 遍历_table，一一比对
    168.             pthread_rwlock_rdlock(&_rwlock);
    169.             for (auto t : _table)
    170.             {
    171.                 if (t.second._real_path == real_path)
    172.                 {
    173.                     *data = t.second;
    174.                     pthread_rwlock_unlock(&_rwlock);
    175.                     return true;
    176.                 }
    177.             }
    178.             pthread_rwlock_unlock(&_rwlock);
    179.             return false;
    180.         }
    181.         // 获取所有的文件信息，向用户提供一个备份文件表时需要
    182.         bool GetAll(std::vector *arry)
    183.         {
    184.             // 遍历_table，全部插入arry
    185.             pthread_rwlock_rdlock(&_rwlock);
    186.             for (auto t : _table)
    187.             {
    188.                 arry->push_back(t.second);
    189.             }
    190.             pthread_rwlock_unlock(&_rwlock);
    191.             return true;
    192.         }
    193.  
    194.     private:
    195.         std::unordered_map _table; // 文件信息管理表
    196.         std::string _backup_file;                           // 持久化存储文件信息管理表
    197.         pthread_rwlock_t _rwlock;                           // 读写锁，读共享，写互斥
    198.     };
    199. }
    200.  
    201. #endif

    测试：

    在测试之前我们先将bundle.cpp文件打包成库，因为每次联合编译都很慢，打包成库后编译速度会加快不少。

    1. g++ -c bundle.cpp -o bundle.o
    2. ar -cr libbundle.a bundle.o
    3. mkdir lib//创建lib库
    4. mv libbundle.a lib//将libbnudle.a移动到lib中
    5. //makefile编译指令
    6. g++ -o $@ $^ -L./lib -std=c++11 -lpthread -ljsoncpp -lbundle

    测试代码如下

    1. void Managertest(const std::string &real_path)
    2. {
    3.     std::cout << "-------------BackupInfo test----------------" << std::endl;
    4.     mjw_cloud::BackupInfo info(real_path);
    5.     std::cout << info._pack_flag << std::endl;
    6.     std::cout << info._fsize << std::endl;
    7.     std::cout << info._atime << std::endl;
    8.     std::cout << info._mtime << std::endl;
    9.     std::cout << info._pack_path << std::endl;
    10.     std::cout << info._real_path << std::endl;
    11.     std::cout << info._url_path << std::endl;
    12.     std::cout << std::endl;
    13.  
    14.     std::cout << "-------------DataManager test---------------" << std::endl;
    15.     mjw_cloud::DataManager dm;
    16.     dm.Insert(info);
    17.     mjw_cloud::BackupInfo ex1;
    18.     dm.GetoneByURL(info._url_path, &ex1);
    19.     std::cout << ex1._pack_flag << std::endl;
    20.     std::cout << ex1._fsize << std::endl;
    21.     std::cout << ex1._atime << std::endl;
    22.     std::cout << ex1._mtime << std::endl;
    23.     std::cout << ex1._pack_path << std::endl;
    24.     std::cout << ex1._real_path << std::endl;
    25.     std::cout << ex1._url_path << std::endl;
    26.     std::cout << std::endl;
    27.  
    28.     mjw_cloud::BackupInfo ex2;
    29.     dm.GetoneByRp(info._real_path, &ex2);
    30.     std::cout << ex2._pack_flag << std::endl;
    31.     std::cout << ex2._fsize << std::endl;
    32.     std::cout << ex2._atime << std::endl;
    33.     std::cout << ex2._mtime << std::endl;
    34.     std::cout << ex2._pack_path << std::endl;
    35.     std::cout << ex2._real_path << std::endl;
    36.     std::cout << ex2._url_path << std::endl;
    37.     std::cout << std::endl;
    38.  
    39.     std::vector arry;
    40.     dm.GetAll(&arry);
    41.     for (auto a : arry)
    42.     {
    43.         std::cout << a._pack_flag << std::endl;
    44.         std::cout << a._fsize << std::endl;
    45.         std::cout << a._atime << std::endl;
    46.         std::cout << a._mtime << std::endl;
    47.         std::cout << a._pack_path << std::endl;
    48.         std::cout << a._real_path << std::endl;
    49.         std::cout << a._url_path << std::endl;
    50.         std::cout << std::endl;
    51.     }
    52. }

    结果如下

  • 相关阅读:
    基于JAVA学校运动会信息管理系统计算机毕业设计源码+系统+mysql数据库+lw文档+部署
    Node学习笔记之path模块
    Qt设置horizontal line 和vertical line的颜色
    ArcGIS中如何再画一个已经存在的相同属性地类图斑
    【HTML专栏2】VSCode的使用（新建HTML文件）
    win系统下pytorch深度学习环境安装
    OpenCV的应用——快递二维码识别
    基于 SpringBoot + Redis 实现分布式锁
    Javascript 编写一个简单的聊天机器人
    Redis系列：使用Redis实现缓存及相关问题
  • 原文地址：https://blog.csdn.net/zcxmjw/article/details/132675581