项目总结
- 整体回顾
- 逐步实现
- utill.hpp
- config.hpp
- data.hpp
- hot.hpp
- service.hpp
- 代码
整体回顾
服务端的目标是：
- 对客户端的请求进行处理
- 管理客户端上传的文件
于客户端进行数据交换，我们需要引入网络，所以我们引入第三方库----httplib.h库，搭建服务端。在进行网络通讯时，数据需要被系列化和反序列化，否则有数据丢失的风险，还需引入json库
在管理文件时，需要进行热点管理，把非热点文件进行压缩也需要引入第三方库 ----bundle.h,对文件进行压缩。
因此我们可以给服务端的各种功能实现划分模块，逐步实现服务端的整体功能。
要对上传的文件的文件进行管理，我们需要---- 文件管理模块，
同时，在将文件管理后，我们需要对其进行更一步的热带管理模块，热点管理的实现是在文件管理模块的实现之上的。
在本地测试好了上述两个模块后，我们可以进行网络通讯了。
需要一个网络通讯模块，通过其搭建我们的服务端，
能进行网络通讯后，还需要一个业务处理模块，处理客户端发送过来的请求，并予以响应。
逐步实现
先创建一个库，util.hpp工具库文件
里面有我们自己实现的几个util工具类。
工欲善其事，必先利其器。
utill.hpp
class FileUtil{}
创建一个FileUtil 类，文件工具类，对系统的文件接口进行封装，便于我们对文件快捷操作，提供对文件的增删查改
class FileUtil{
private:
std::string _name;
public:
FileUtil(const std::string &name);
size_t FileSize();// 文件大小
time_t LastATime(); // 最后一次查看文件时间
time_t LastMTime(); // 最后一次修改文件的时间
std::string FileName(); //文件名字
bool GetPosLen(std::string *content, size_t pos, size_t len); //获取文件流pos 后len个长度的数据
bool GetContent(std::string *content); //获取文件内容
bool SetContent(std::strint *content); //写入文件
bool Compress(const std::string &packname); //压缩文件
bool UnCompress(const std::string &filename); //解压文件
bool Exists(); //判断文件是否存在
bool CreateDirectory(); //创建一个目录
bool ScanDirectory(std::vector<std::string> *arry); //查看目录下的文件内容
}
- FileUtile 工具提供了对文件的增删查改的功能，
- 也提供了对目录的查看功能，和创建目录的功能
其中，对文件压缩解压缩时，我们需要借用bundle.h库的函数，如何使用bundle库里的函数，在GitHub上有完整的教程。
同时，我们在查看目录时，需要借助filesystem库的使用，但是只有在c++17以上的版本才支持filesystem：
注意：
- 在Windows下，我们要选择了vs2017以上的版本
- 在Linux下，我们需要将gcc进行升级，7.3版本
class jsonutil
jsonutil类为网络通讯时的数据提供系列化和反序列化的功能，当然需要引入json库
至此，我们的基础工具已经完善，可以以此为基础，更一步完善服务端的功能。
config.hpp
项目配置信息的管理，启动项目时，会自动从 .conf文件加载项目的配置信息。需要修改部分内容时，不需要在代码上修改，只需要修改配置文件，然后重启服务器即可。
采用json 格式将配置信息存放在Cloud.conf中，当启动服务器时，由服务器从.conf文件中读取关键数据。
Cloud.conf 文件
{
“hot_time” : 30,
“server_port” : 9090,
“server_ip” : “1.1.1.1”,
“url_prefix” : “/download/”,
“arc_suffix” : “.lz”,
“pack_dir” : “./packdir/”,
“back_dir” : “./backdir/”,
“manager_file” : “./back.dat”
}
#define CONFIG_FILE "./cloud.conf"
class Config{
private:
time_t _hot_time;
int _server_port;
std::string _server_ip;
std::string _url_prefix;
std::string _arc_suffix;
std::string _pack_dir;
std::string _back_dir;
std::string _manager_file;//备份信息的配置管理
private:
static std::mutex _mutex;
static Config *_instance;
Config();
public:
bool ReadConfig(const std::string &filename);
int GetHotTime();
int GetServerPort();
std::string GetServerIp();
std::string GetURLPrefix();
std::string GetArcSuffix();
std::string GetPackDir();
std::string GetBackDir();
std::string GetManagerFile();
public:
static Config *GetInstance();
};
且，在实现配置信息类时，我们采取单例模式。
data.hpp
data.hpp是数据管理模块的主要部分。
要管理文件数据，就得先对文件的信息进行组织。
struct BackupInfo{}
typedef struct BackupInfo
{
bool pack_flag; // 文件是否被压缩的标识
time_t atime; // 最后一次查看时间
time_t mtime; // 最后一次修改时间
size_t fsize; //文件大小
std::string real_path; // 文件在服务器上的真实存储路径
std::string url; // 客户端访问文件时的请求url
std::string packpath; // 压缩包存储路径
bool FillBackupInfo(const std::string &realpath){}
}BackupInfo;
有了这些数据后，我们能准确的描述一个文件，并可以很好的进行管理。
上传的文件信息都以BackuoInfo的模式，以json的格式存储在backup_file中，当程序启动时，需要去文件加载数据到内存。同时，在新上传文件后，我们也需要将文件数据永久化存储到backup_file中。也需要支持对已经被管理的文件信息的增删查改（我们暂时不支持对信息的删除，现在只涉及最基础的功能实现，更多功能在已经构建好整个框架后会进一步实现）。
整个数据管理模块，也为让上层迅速查找文件的备份信息
class DateManager{}
class DataManager{
private:
FileUtil _backup_file;
pthread_rwlock_t _rwlock; // 读写锁
std::unordered_map<std::string, BackupInfo> _table;
public:
DataManager();
bool InitLoad();//初始化程序运行时从文件读取数据
bool Storage(); //每次有信息改变则需要持久化存储一次
bool Insert(const std::string &key, const BackupInfo &val);
bool Update(const std::string &key, const BackupInfo &val);
bool GetOneByURL(const std::string &key, BackupInfo *info);
bool GetOneByRealPath(const std::string &key, BackupInfo *info);
bool GetAll(std::vector<BackupInfo> *arry);
};
其具体实现内容在项目日志时已经说过，在此不再重复。
注意：
我们是对 _table 加上了rwlock 读写锁，因为这里的并发访问场景更多的是读读，读写场景，能提高服务器运行速度。
同时，加锁的原因是：
在httplib库中，使用了线程池的技术，当服务端accept一个客户端后，会另起一个线程在服务端处理请求，所以， _table属于临界资源，需要加锁保护。
我们的Storage()是覆盖式存储，是将 内存中 _table里的所有数据进行反序列，将 backup_file里的内容进行覆盖。
hot.hpp
热点管理模块就压要简单一点，很大一部分工作在数据管理模块已经完成。
循环遍历目录下的所有文件，然后通过文件最后一次修改时间来判断该文件是否为热点文件，然后压缩至指定目录即可。
extern cloud::DataManager *_data;
class HotManager{
private:
std::string _back_dir;
std::string _pack_dir;
std::string _pack_suffix;
time_t _hot_time;
public:
HotManager();
bool HotJudge(const std::string &file);
bool RunModule();
};
因为数据管理是要在多个模块中访问的，因此将其作为全局数据定义。
service.hpp
云备份项目中 ，业务处理模块是针对客户端的业务请求进行处理，并最终给与响应。而整个过程中包含以下要实现
的功能：
- 借助网络通信模块httplib库搭建http服务器与客户端进行网络通信
- 针对收到的请求进行对应的业务处理并进行响应（文件上传，列表查看，文件下载（包含断点续传））
响应给客户端的 rsp在之前的项目日志里也有描述。
class Service{
private:
int _server_port;
std::string _server_ip;
std::string _url_prefix;
httplib::Server _srv;
private:
static void Upload(const httplib::Request &req, httplib::Response &rsp);
static void List(const httplib::Request &req, httplib::Response &rsp);
static void Download(const httplib::Request &req,httplib::Response &rsp);
public:
Service();
bool RunModule();
}
注意：
业务处理的回调函数没有传入参数的地方（大概是因为，回调函数的模板被固定化了），因此无法直接访问外部的数据管理模块数据，因此将数据管理模块的对象定义为全局数据,在这里声明一下，就可以在任意位置访问了,且回调函数必须为静态函数，（类内函数成员变量会隐藏一个this指针）。
文件上传函数和文件列表查看函数都按照思路来写。
文件下载函数有部分事项需要注意：
1 . 服务端要判断是否需要进行断点重传，判断条件：
有If-Range字段且，这个字段的值与请求文件的最新etag一致则符合断点续传
也就是说需要在客户端请求里有If-Range字段，且在这段时间内，文件的数据内容没有被修改过。
这是Download 函数正常的响应rsp：
HTTP/1.1 200 OK
Content-Length: 100000
ETags: "filename-size-mtime一个能够唯一标识文件的数据"
Accept-Ranges: bytes
Accept-Ranges报头：
服务器使用 HTTP 响应头 Accept-Ranges 标识自身支持范围请求 (partial
requests)。字段的具体值用于定义范围请求的单位。
当浏览器发现Accept-Ranges头时，可以尝试继续中断了的下载，而不是重新开始。
这是Download执行断点续传的rsp：
HTTP/1.1 206 Partial Content
Content-Length:
Content-Range: bytes 89-999/100000
Content-Type: application/octet-stream
ETag: "inode-size-mtime一个能够唯一标识文件的数据"
Accept-Ranges: bytes
httplib内部实现了对于区间请求也就是断点续传请求的处理
只需要我们用户将文件所有数据读取到rsp.body中，它内部会自动根据请求
区间，从body中取出指定区间数据进行响应，并且会自动填充rsp内容。
代码
代码里边会有博主的一些思考和理解，各位大佬见笑了😅
util.hpp
#pragma once
#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <memory>
#include <experimental/filesystem>
#include "bundle.h"
#include <jsoncpp/json/json.h>
namespace Cloud
{
namespace fs = std::experimental::filesystem;
class FileUtil
{
private:
std::string _Filename;
public:
FileUtil(std::string fname) : _Filename(fname)
{
}
int64_t Filesize() // 提取文件大小
{
struct stat st;
if (stat(_Filename.c_str(), &st) < 0)
{
std::cerr << "get Filesize fail"
<< std::endl;
return -1;
}
return st.st_size;
}
std::string Filename() // 提取文件名
{
// /a/b/文件名
size_t pos = _Filename.find_last_of("/");
if (pos == std::string::npos)
{
return _Filename;
}
return _Filename.substr(pos + 1);
}
time_t LastMtime() // 提取文件最后一次的修改时间（文件内容）
{
struct stat st;
if (stat(_Filename.c_str(), &st) < 0)
{
std::cerr << "get File LastMtime fail\n"
<< std::endl;
return -1;
}
return st.st_mtime;
}
time_t LastAtime() // 提取文件最后一次的访问时间
{
struct stat st;
if (stat(_Filename.c_str(), &st) < 0)
{
std::cerr << "get File LastAtime fail\n"
<< std::endl;
return -1;
}
return st.st_atime;
}
time_t LastCtime() // 提取文件最后一次的修改时间（文件内容 || 文件属性）
{
struct stat st;
if (stat(_Filename.c_str(), &st) < 0)
{
std::cerr << "get File LastCtime fail\n"
<< std::endl;
return -1;
}
return st.st_ctime;
}
bool Remove()
{
remove(_Filename.c_str());
return true;
}
bool GetPosLen(std::string &body, size_t pos, size_t len)
{
size_t fsize = this->Filesize();
if (pos + len > fsize)
{
std::cout << "get file len is error\n";
return false;
}
std::ifstream ifs;
ifs.open(_Filename, std::ios::binary);
if (ifs.is_open() == false)
{
std::cout << "read open file failed!\n";
return false;
}
ifs.seekg(pos, std::ios::beg);
body.resize(len);
ifs.read(&body[0], len);
if (ifs.good() == false)
{
std::cout << "get file content failed\n";
ifs.close();
return false;
}
ifs.close();
return true;
}
bool GetContent(std::string &body)
{
size_t fsize = this->Filesize();
return GetPosLen(body, 0, fsize);
}
bool SetContent(const std::string &body)
{
std::ofstream ofs;
ofs.open(_Filename, std::ios::binary);
if (ofs.is_open() == false)
{
std::cout << "write open file failed!\n";
return false;
}
ofs.write(&body[0], body.size());
if (ofs.good() == false)
{
std::cout << "write file content failed!\n";
ofs.close();
return false;
}
ofs.close();
return true;
}
bool Compress(const std::string &packname)
{
// 1. 获取源文件数据
std::string body;
if (this->GetContent(body) == false)
{
std::cout << "compress get file content failed!\n";
return false;
}
// 2. 对数据进行压缩
std::string packed = bundle::pack(bundle::LZIP, body);
// 3. 将压缩的数据存储到压缩包文件中
FileUtil fu(packname);
if (fu.SetContent(packed) == false)
{
std::cout << "compress write packed data failed!\n";
return false;
}
return true;
}
bool UnCompress(const std::string &filename)
{
// 将当前压缩包数据读取出来
std::string body;
if (this->GetContent(body) == false)
{
std::cout << "uncompress get file content failed!\n";
return false;
}
// 对压缩的数据进行解压缩
std::string unpacked = bundle::unpack(body);
// 将解压缩的数据写入到新文件
FileUtil fu(filename);
if (fu.SetContent(unpacked) == false)
{
std::cout << "uncompress write packed data failed!\n";
return false;
}
return true;
}
bool Exists()
{
return fs::exists(_Filename);
}
bool CreateDirectory()
{
if (this->Exists())
return true;
return fs::create_directories(_Filename);
}
bool ScanDirectory(std::vector<std::string> &arry)
{
CreateDirectory();
for (auto &p : fs::directory_iterator(_Filename))
{
if (fs::is_directory(p) == true)
{
continue;
}
// relative_path 带有路径的文件名
arry.push_back(fs::path(p).relative_path().string());
}
return true;
}
};
class jsonutil
{
public:
static bool Serialize(const Json::Value &root, std::string &str) // 序列化
{
Json::StreamWriterBuilder swb;
std::unique_ptr<Json::StreamWriter> sw(swb.newStreamWriter());
std::stringstream ss;
if (sw->write(root, &ss) != 0)
{
std::cout << "json write failed!\n";
return false;
}
str = ss.str();
return true;
}
static bool UnSerialize(const std::string &str, Json::Value &root) // 反序列化
{
Json::CharReaderBuilder crb;
std::unique_ptr<Json::CharReader> cr(crb.newCharReader());
std::string err;
bool ret = cr->parse(str.c_str(), str.c_str() + str.size(), &root, &err);
if (ret == false)
{
std::cout << "parse error: " << err << std::endl;
return false;
}
return true;
}
};
}
data.hpp
#pragma once
#include <unordered_map>
#include <pthread.h>
#include <iostream>
#include "util.hpp"
#include "config.hpp"
#include <string>
#include <stdio.h>
// 服务端要管理文件数据，需要 先描述，在组织， 构建一个文件属性结构体，通过这个结构体来管理所有的文件
namespace Cloud
{
typedef struct BackupInfo
{
bool pack_flag; // 文件是否被压缩的标识
time_t atime; // 最后一次查看时间
time_t mtime; // 最后一次修改时间
size_t fsize;
std::string real_path; // 文件在服务器上的真实存储路径
std::string url; // 客户端访问文件时的请求url
std::string packpath; // 压缩包存储路径
bool FillBackupInfo(const std::string &realpath)
{
FileUtil ft(realpath);
if (ft.Exists() == false)
{
std::cerr << "fill backupinfo:file not exists" << std::endl;
return false;
}
Config *cf = Config::Getinstance();
pack_flag = false;
atime = ft.LastAtime();
mtime = ft.LastMtime();
fsize = ft.Filesize();
real_path = realpath;
// ./backdir/a.txt -> /download/a.txt
url = cf->GetDownloadPrefix() + ft.Filename();
// ./packdir/a.txt -> ./packdir/a.txt.lz
packpath = cf->GetPackDir() + ft.Filename() + cf->GetPackFileSuffix();
return true;
}
} BackupInfo;
class DateManager
{
private:
std::string _backup_file; // 文件的信息都会以json的格式存放在 一个backup文件里
pthread_rwlock_t _rwlock; // 对backup文件会存在并发访问的问题 ------->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ????????????????? 不懂为什么有锁
std::unordered_map<std::string, BackupInfo> _table; // 以hash结构，url 为key ，BackupInfo 为val ，查找迅速
public:
// 从文件中读取数据进行初始化 对文件增删查改 对文件的永久化储存
DateManager()
{
// printf("准备Datemanager初始化\n");
_backup_file = Config::Getinstance()->GetBackupFile();
pthread_rwlock_init(&_rwlock, nullptr);
initload();
// std::cout<<"初始化成功"<<std::endl;
}
bool insert(const BackupInfo &bf)
{
// ? 我自己的思路 --------- 传入一个 filename ，然后在insert函数中，自己填充BackupInfo数据 ，在插入进_table中 ----》 可以减少上层的工作量 （我觉得）
pthread_rwlock_wrlock(&_rwlock);
std::string url = bf.url;
_table[url] = bf;
pthread_rwlock_unlock(&_rwlock);
Storage();
return true;
}
bool update(const BackupInfo &bf)
{
// ？ 问题同 insert函数
pthread_rwlock_wrlock(&_rwlock);
std::string url = bf.url;
_table[url] = bf;
pthread_rwlock_unlock(&_rwlock);
Storage();
return true;
}
bool GetOneByURL(const std::string &url, BackupInfo *info)
{
pthread_rwlock_rdlock(&_rwlock);
auto it = _table.find(url);
if (it != _table.end())
{
*info = it->second;
}
else
{
pthread_rwlock_unlock(&_rwlock);
return false;
}
pthread_rwlock_unlock(&_rwlock);
return true;
}
bool GetOneByRealpath(const std::string &realpath, BackupInfo *info)
{
// std::cout<<"准备拿锁"<<std::endl;
pthread_rwlock_rdlock(&_rwlock);
// std::cout<<"拿到锁了"<<std::endl;
std::unordered_map<std::string, BackupInfo>::iterator it = _table.begin();
// std::cout<<"找到初始位置了"<<std::endl;
for (; it != _table.end(); ++it)
{
if (it->second.real_path == realpath)
{
*info = it->second;
pthread_rwlock_unlock(&_rwlock);
return true;
}
}
pthread_rwlock_unlock(&_rwlock);
return false;
}
void GetAll(std::vector<BackupInfo> *arry)
{
pthread_rwlock_wrlock(&_rwlock);
for (auto it = _table.begin(); it != _table.end(); ++it)
{
arry->push_back(it->second);
}
pthread_rwlock_unlock(&_rwlock);
}
bool Storage() // 每次有信息改变则需要持久化存储一次
{
// 1. 获取所有数据
std::vector<BackupInfo> arry;
this->GetAll(&arry);
// 2. 添加到Json::Value
Json::Value root;
for (int i = 0; i < arry.size(); i++)
{
Json::Value item;
item["pack_flag"] = arry[i].pack_flag;
item["fsize"] = (Json::Int64)arry[i].fsize;
item["atime"] = (Json::Int64)arry[i].atime;
item["mtime"] = (Json::Int64)arry[i].mtime;
item["real_path"] = arry[i].real_path;
item["packpath"] = arry[i].packpath;
item["url"] = arry[i].url;
root.append(item); // 添加数组元素
}
// 3. 对Json::Value序列化
std::string body;
jsonutil::Serialize(root, body);
// 4. 写文件
FileUtil fu(_backup_file);
fu.SetContent(body);
return true;
}
bool initload() 初始化程序运行时从文件读取数据 -------> 为什么不从备份目录中提取数据？ --- 备份目录下的文件会被压缩至压缩目录
{
// 1. 从文件中读取数据
// printf("准备读数据\n");
FileUtil ft(_backup_file);
// printf("读数据成功\n");
if (ft.Exists() == false) // 如果文件不存在，说明还没有数据存入数据文件，也就是还没有创建数据文件
{
// printf("文件不存在\n");
return true;
}
std::string str;
// printf("准备获得文\n");
ft.GetContent(str);
// printf("获得文成功\n");
// 2. 将数据反序列化
// printf("准备序列化\n");
Json::Value root;
jsonutil::UnSerialize(str, root);
// printf("反序列化成功\n");
// 3. 将数据插入_table
// printf("准备插入数据:%d\n",root.size());
for (int i = 0; i < root.size(); i++)
{
// std::cout<<"开始插入数据"<<std::endl;
BackupInfo info;
info.pack_flag = root[i]["pack_flag"].asBool();
info.fsize = root[i]["fsize"].asInt64();
info.atime = root[i]["atime"].asInt64();
info.mtime = root[i]["mtime"].asInt64();
info.packpath = root[i]["packpath"].asString();
info.real_path = root[i]["real_path"].asString();
info.url = root[i]["url"].asString();
// std::cout<<"插入:"<<info.url<<std::endl;
insert(info);
}
return true;
}
~DateManager()
{
pthread_rwlock_destroy(&_rwlock);
}
};
}
hot.hpp
#pragma once
#include <unistd.h>
#include "data.hpp"
#include <iostream>
extern Cloud::DateManager *_data;
namespace Cloud
{
class HotManager
{
private:
std::string _back_dir;
std::string _pack_dir;
std::string _pack_suffix;
int _hot_time;
public:
HotManager()
{
Config *cng = Config::Getinstance();
_back_dir = cng->GetBackDir();
_pack_dir = cng->GetPackDir();
_pack_suffix = cng->GetPackFileSuffix();
_hot_time = cng->GetHotTime();
FileUtil tmp1(_back_dir);
FileUtil tmp2(_pack_dir);
tmp1.CreateDirectory();
tmp2.CreateDirectory();
}
bool HotJudge(const std::string &filename) // 返回true 说明为非热点文件
{
FileUtil fu(filename);
time_t curtime = time(NULL);
if (curtime - fu.LastAtime() > _hot_time)
return true;
return false;
}
void RunModel() // 不断循环检测 back_dir 目录下的文件 ，进行热点管理
{
while (true)
{
// 1. 遍历备份目录，获取所有文件名
FileUtil fu(_back_dir);
std::vector<std::string> arry;
fu.ScanDirectory(arry);
// std::cout<<"准备判断是否为热点文件"<<std::endl;//,没什么问题
// 2. 判断文件是否为热点文件
// std::cout<<arry.size()<<std::endl;
for (const auto &it : arry)
{
// std::cout<<"开始遍历判断是否为热点文件"<<std::endl;
// std::cout<<it<<std::endl;
if (HotJudge(it) == false)
{
// std::cout<<"不是热点文件"<<std::endl;
continue;
}
// 获取文件的备份信息
BackupInfo info;
// std::cout<<"准备执行HOT里的GetonebyRealpath"<<std::endl;
if (_data->GetOneByRealpath(it, &info) == false)
{
// std::cout<<"准备执行fillBackupInfo"<<std::endl;
info.FillBackupInfo(it);
}
// 3. 对非热点文件进行压缩
FileUtil tmp(it);
tmp.Compress(info.packpath);
// 4. 删除源文件，修改备份信息
tmp.Remove();
info.pack_flag = true;
_data->update(info);
}
// std::cout<<"准备进入睡眠"<<std::endl;
usleep(1000);
}
}
};
}
service.hpp
#pragma once
#include <errno.h>
#include <string>
#include "data.hpp"
#include "hot.hpp"
#include "httplib.h"
// 服务端构建服务器， 为客户端提供 上传文件（upload） 下载文件(get) 文件列表查看()三个req
// 并对客户端 进行响应 响应上传成功 响应下载的文件数据 响应一个展示文件备份列表的前端页面
extern Cloud::DateManager *_data;
namespace Cloud
{
std::string totimestring(const time_t &tm)
{
struct tm *tmp = localtime(&tm);
char buffer[1024];
snprintf(buffer, sizeof(buffer), "%d-%d-%d %d:%d:%d", tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_yday,
tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
return buffer;
}
class Service
{
private:
std::string _server_ip;
uint16_t _server_port;
std::string _download_prefix; // 我自己粗略认为这是充当客户端请求下载文件时url中的前一部分
httplib::Server _server;
public:
Service()
{
printf("Service 开始初始化\n");
Config *config = Config::Getinstance();
_server_ip = config->GetServerIp();
_server_port = config->GetServerPort();
_download_prefix = config->GetDownloadPrefix();
printf("ser 初始化成功\n");
}
void RunModule()
{
printf("Server RunModulem 开始\n");
_server.Post("/Upload", Upload);
_server.Get("/", Showlist);
_server.Get("/Showlist", Showlist);
// 下载文件需要匹配具体的文件名，需要借用正则表达式
_server.Get(_download_prefix + ".*", Download);
printf("server 开始listen\n");
std::cout << _server_ip << "::" << _server_port << std::endl;
if (_server.listen(_server_ip.c_str(), _server_port) == false)
{
std::cout << "listen error" << errno << std::strerror(errno) << std::endl;
}
}
private:
static void Upload(const httplib::Request &req, httplib::Response &rsp) // 上传文件数据
{
// 1. 对req进行反序列化(httplib已经帮我们做过了) ，提取数据
printf("收到一个upload请求\n");
auto ret = req.has_file("file"); // 判断req请求中是否包含 上传的文件字段
if (ret == false)
{
rsp.status = 400;
return;
}
// 2. 拿到文件名，拿到文件数据
const auto &file = req.get_file_value("file");
std::string filename = file.filename;
std::string filecontent = file.content;
// 3. 将其保存至 backdir目录下 ,
std::string backdir = Config::Getinstance()->GetBackDir();
std::cout << "backfilename:" << backdir + filename << std::endl;
FileUtil fu(backdir + filename);
fu.SetContent(filecontent);
// 修该组织文件备份的管理信息
BackupInfo info;
info.FillBackupInfo(backdir + filename);
_data->insert(info);
// 4. 同时填充rsp
rsp.status = 200;
printf("upload 完成\n");
return;
}
// 唯一标识符 filename-filesize-lastmtime
static std::string GetETag(const BackupInfo &info)
{
FileUtil fu(info.real_path);
std::string etag = fu.Filename();
etag += "-";
etag += std::to_string(info.fsize);
etag += "-";
etag += std::to_string(info.mtime);
return etag;
}
// static void Download(const httplib::Request &req, httplib::Response &rsp)
// {
// printf("收到一个Download请求\n");
// // 1. 从req中提取url，通过url找到 获取文件备份信息
// BackupInfo info;
// _data->GetOneByURL(req.path, &info);
// std::cout << req.path << std::endl;
// std::cout << info.packpath << ":" << info.real_path << std::endl;
// std::cout << info.pack_flag << std::endl;
// printf("提取到info信息\n");
// // 3. 判断是否被压缩
// if (info.pack_flag == true)
// {
// printf("在解压缩文件\n");
// // 4. 如果被压缩，需要进行解压缩，同时修改备份信息
// FileUtil fu(info.packpath);
// fu.UnCompress(info.real_path);
// fu.Remove();
// info.pack_flag = false;
// _data->update(info);
// printf("解压缩完成\n");
// }
// bool retrans = false;
// std::string old_etag;
// if (req.has_header("If-Range") == true)
// {
// old_etag = req.get_header_value("If-Range");
// // 有If-Range字段且，这个字段的值与请求文件的最新etag一致则符合断点续传
// if (old_etag == GetETag(info))
// {
// retrans = true;
// }
// }
// printf("retrans:%d\n", retrans);
// // 5. 填充rsp 设置响应头部字段： ETag， Accept-Ranges: bytes
// printf("填充rsp中\n");
// FileUtil fu(info.real_path);
// if (retrans == false)
// {
// fu.GetContent(rsp.body);
// rsp.set_header("Accept-Ranges", "bytes"); // 告诉客户端支持断点重传功能
// rsp.set_header("ETag", GetETag(info)); // etag 是一个标识文件的数据
// rsp.set_header("Content-Type", "application/octet-stream"); // 告诉客户实际返回的内容的内容类型
// rsp.status = 200;
// }
// else
// {
// // 需要进行断点续传
// // httplib内部实现了对于区间请求也就是断点续传请求的处理
// // 只需要我们用户将文件所有数据读取到rsp.body中，它内部会自动根据请求
// // 区间，从body中取出指定区间数据进行响应
// // 也就是说，下边的代码可以省略，但是我们需要知道httplib 库给我做了什么工作
// fu.GetContent(rsp.body);
// rsp.set_header("Accept-Ranges", "bytes");
// rsp.set_header("ETag", GetETag(info));
// rsp.set_header("Content-Type", "application/octet-stream");
// // rsp.set_header("Content-Range", "bytes start-end/fsize");
// rsp.status = 206;
// }
// printf("Download 请求完毕\n");
// return;
// }
static void Download(const httplib::Request &req, httplib::Response &rsp)
{
// 1. 获取客户端请求的资源路径path req.path
// 2. 根据资源路径，获取文件备份信息
printf("收到一个Download请求\n");
BackupInfo info;
_data->GetOneByURL(req.path, &info);
// 3. 判断文件是否被压缩，如果被压缩，要先解压缩,
if (info.pack_flag == true)
{
FileUtil fu(info.packpath);
fu.UnCompress(info.real_path); // 将文件解压到备份目录下
// 4. 删除压缩包，修改备份信息（已经没有被压缩）
fu.Remove();
info.pack_flag = false;
_data->update(info);
}
bool retrans = false;
std::string old_etag;
if (req.has_header("If-Range"))
{
old_etag = req.get_header_value("If-Range");
// 有If-Range字段且，这个字段的值与请求文件的最新etag一致则符合断点续传
if (old_etag == GetETag(info))
{
retrans = true;
}
}
printf("retrans:%d\n", retrans);
// 4. 读取文件数据，放入rsp.body中
FileUtil fu(info.real_path);
if (retrans == false)
{
fu.GetContent(rsp.body);
// 5. 设置响应头部字段： ETag， Accept-Ranges: bytes
rsp.set_header("Accept-Ranges", "bytes");
rsp.set_header("ETag", GetETag(info));
rsp.set_header("Content-Type", "application/octet-stream");
rsp.status = 200;
}
else
{
// httplib内部实现了对于区间请求也就是断点续传请求的处理
// 只需要我们用户将文件所有数据读取到rsp.body中，它内部会自动根据请求
// 区间，从body中取出指定区间数据进行响应
// std::string range = req.get_header_val("Range"); bytes=start-end
fu.GetContent(rsp.body);
rsp.set_header("Accept-Ranges", "bytes");
rsp.set_header("ETag", GetETag(info));
rsp.set_header("Content-Type", "application/octet-stream");
// rsp.set_header("Content-Range", "bytes start-end/fsize");
rsp.status = 206; // 区间请求响应的是206*****
}
printf("Download 请求结束\n");
}
static void Showlist(const httplib::Request &req, httplib::Response &rsp)
{
// 1. 获取所有的文件备份信息
printf("收到一个showlist请求\n");
std::vector<BackupInfo> arry;
_data->GetAll(&arry);
//std::cout << "文件信息准备完毕，size:" << arry.size() << std::endl;
// 2. 根据这些文件备份信息组织html页面
std::stringstream ss;
ss << "<html><head><title>Download</title></head>";
ss << "<body><h1>Download</h1><table>";
for (auto &a : arry)
{
ss << "<tr>";
std::string filename = FileUtil(a.real_path).Filename();
ss << "<td><a href='" << a.url << "'>" << filename << "</a></td>";
ss << "<td align='right'>" << totimestring(a.atime) << "</td>";
ss << "<td align='right'>" << a.fsize / 1024 << "k"
<< "</td>";
ss << "</tr>";
}
ss << "</table></body></html>";
//std::cout << "文件信息填充完毕，开始填写rsq" << std::endl;
// 3. 填充rsp响应
rsp.body = ss.str();
rsp.status = 200;
rsp.set_header("Content-Type", "text/html");
printf("showlist请求完毕\n");
return;
}
};
}
