项目总结
- 整体回顾
- util.hpp
- data.hpp
- cloud.hpp
- 代码
客户端的代码与服务端的代码实现有很多相似之处，我们也只编写一个简单的客户端代码。
整体回顾
客户端要实现的功能是：对指定文件夹中的文件自动进行备份上传。但是并不是所有的文件每次都需要上传，我们需要能够判断，哪些文件需要上传，哪些不需要，因此需要将备份的文件信息给管理起来，作为下一次文件是否需要备份的判断。因此需要被管理的信息包含以下：
- 文件路径名称
- 文件唯一标识：由文件名，最后一次修改时间，文件大小组成的一串信息
所以也需要对文件进行操作的fileutil工具，这个其实与服务端的文件实用工具类颇为相似，直接复制过来即可。
同时也需要对文件进行管理，需要datamanager模块。
在之后就是对文件进行上传的文件备份backup模块
util.hpp
与服务端类似。
namespace fs = std::experimental::filesystem;
class FileUtil {
private:
std::string _name;
public:
FileUtil(const std::string &name) :_name(name) {}
size_t FileSize();
time_t LastATime();
time_t LastMTime();
std::string FileName();
bool GetPosLen(std::string *content, size_t pos, size_t len);
bool GetContent(std::string *content);
bool SetContent(const std::string &content);
bool Exists();
bool CreateDirectory();
bool ScanDirectory(std::vector<std::string> *arry);
};
data.hpp
与服务端的差别是在_table 中的val 存储的值的类型不同，其余的也几乎都相同，都是对文件数据的增查改，对文件数据进行永久化储存，程序运行时的初始化。
class DataManager{
private:
std::unordered_map<std::string, std::string> _table;
std::string _back_file;
public:
DataManager(const std::string back_file);
bool InitLoad();//程序运行时加载以前的数据
bool Storage();//持久化存储
bool Insert(const std::string &key, const std::string &val);
bool Update(const std::string &key, const std::string &val);
bool GetOneByKey(const std::string &key, std::string *val);
};
cloud.hpp
搭建客户端，然后循环检测被管理目录下的文件是否需要被备份。
#define SRV_IP "1.1.1.1"
#define SRV_PORT 9000
class BackUp {
private:
DataManager *_data;
std::string _back_dir;
std::string _back_file;
bool Upload(const std::string &filename)；
bool IsCanBeUpload(const std::string &filename);
std::string GetFileIdentifier(const std::string &filename);
public:
BackUp(const std::string &back_dir, const std::string &back_file)
: _back_dir(back_dir)
, _back_file(back_file){}
bool RunModule();
};
需要注意的部分是，在判断文件是否需要被备份时的条件，具体会在代码部分指出。
整个客户端大致就是如此了。
代码
util.hpp
#pragma once
#define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING
#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <sys/types.h>
#include <sys/stat.h>
#include <memory>
#include <experimental/filesystem>
// FileUtile 工具提供了对文件的增删查改的功能，
// 也提供了对目录的查看功能，和创建目录的功能
namespace Cloud
{
namespace fs = std::experimental::filesystem;
class FileUtil
{
private:
std::string _Filename;
public:
FileUtil(std::string fname) : _Filename(fname)
{
// std::cout << fname << std::endl;
}
size_t Filesize() // 提取文件大小
{
struct stat st;
if (stat(_Filename.c_str(), &st) < 0)
{
std::cout << "get Filesize fail"
<< std::endl;
return 0;
}
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::cout << "get File LastMtime fail"
<< std::endl;
return -1;
}
return st.st_mtime;
}
time_t LastAtime() // 提取文件最后一次的访问时间
{
struct stat st;
if (stat(_Filename.c_str(), &st) < 0)
{
std::cout << "get File LastAtime fail"
<< std::endl;
return -1;
}
return st.st_atime;
}
time_t LastCtime() // 提取文件最后一次的修改时间（文件内容 || 文件属性）
{
struct stat st;
if (stat(_Filename.c_str(), &st) < 0)
{
std::cout << "get File LastCtime fail"
<< std::endl;
return -1;
}
return st.st_ctime;
}
bool Remove()
{
if (this->Exists() == false) {
return true;
}
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 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;
}
};
data.hpp
#pragma once
#include "util.hpp"
#include<unordered_map>
#include<sstream>
namespace Cloud
{
#define SEP " "
class DataManager {
private:
std::string _backup_file; // 存储文件信息的文件
std::unordered_map<std::string, std::string> _table;
int Split(std::string& str, std::string sep, std::vector<std::string>* arry)
{
int count = 0;
size_t pos = 0, idx = 0;
while (true)
{
pos = str.find(sep, idx);
if (pos == idx)
{
idx += sep.size();
continue;
}
if (pos == std::string::npos)
{
break;
}
arry->push_back(str.substr(idx, pos - idx));
idx = pos + sep.size();
count++;
}
if (idx < str.size())
{
arry->push_back(str.substr(idx));
count++;
}
return count;
}
public:
DataManager(const std::string& backup_file):_backup_file(backup_file)
{
InitLoad();
}
bool Storage() { // 将_table里的文件信息写入 back_file
// 1、获取_table的信息
std::stringstream ss;
for (const auto& a : _table)
{
//2. 将所有信息进行有格式化的组织
ss << a.first << SEP << a.second << std::endl;
}
//3. 写入到 back_file 文件
FileUtil fu(_backup_file);
fu.SetContent(ss.str());
return true;
}
bool InitLoad() { // 在DataManager 实列化对象时，将_backup_file 里的文件信息提取到 _table中
// 1. 从 file中提取数据
std::string body;
FileUtil fu(_backup_file);
fu.GetContent(body);
// 2. 将数据进行分割，然后放入 _table中。
std::vector<std::string> arry;
Split(body, "\n", &arry);
for (auto& a : arry)
{
std::vector<std::string> tmp;
Split(a, SEP, &tmp);
if (tmp.size() != 2)
{
continue;
}
_table[tmp[0]] = tmp[1];
}
return true;
}
bool Insert(const std::string& key, const std::string& val) {
_table[key] = val;
Storage();
return true;
}
bool Update(const std::string& key, const std::string& val) {
_table[key] = val;
Storage();
return true;
}
bool GetOneByKey(const std::string key, std::string* val) {
auto it = _table.find(key);
if (it == _table.end())
{
return false;
}
*val = it->second;
return true;
}
};
}
cloud.hpp
#pragma once
#include"httplib.h"
#include"util.hpp"
#include"data.hpp"
namespace Cloud {
#define SERVER_IP "60.204.140.244"
#define SERVER_PORT 9090
class Backup{
private:
std::string _back_dir; //需要管理的目录
DataManager* _data;
bool IsNeedUpload(const std::string& filename)
{
// 1. 如果文件未被备份过，则需要进行备份 2. 如果文件被修改过，则需要重新备份
FileUtil fu(filename);
std::string old_id;
if (_data->GetOneByKey(filename, &old_id)) // 查看文件是否被备份
{
//std::cout << old_id << std::endl;
std::string new_id = GetFileIdentifier(filename);
if (old_id == new_id)
{
return false;
}
//一个文件比较大,正在徐徐的拷贝到这个目录下，拷贝需要一个过程，
//如果每次遍历则都会判断标识不一致需要上传一个几十G的文件会上传上百次
//因此应该判断一个文件一段时间都没有被修改过了，则才能上传
// 合理的判断方式应该是判断该文件是否被其他线程占用，是否处于被使用的状态 ，我们采取简单一点的时间判断
else
{
if (time(NULL) - fu.LastMtime() < 10)
return false;
}
}
//std::cout << old_id << std::endl;
return true;
}
bool Upload(const std::string& file)
{
// 1. 获取数据
FileUtil fu(file);
std::string body;
fu.GetContent(body);
//std::cout << fu.Filename() <<": " << fu.Filesize() << std::endl;
// 2. 搭建客户端,填充客户端信息
httplib::Client client(SERVER_IP, SERVER_PORT);
httplib::MultipartFormData item;
item.content = body;
item.filename = fu.Filename();
item.content_type = "application/octet-stream"; // 表示上传的数据类型为任一数据类型，以二进制形式上传
item.name = "file";
httplib::MultipartFormDataItems items;
items.push_back(item);
// 3. 上传文件
auto res = client.Post("/Upload", items);
if (!res || res->status != 200)
{
return false;
}
return true;
}
std::string GetFileIdentifier(const std::string& filename) {
// a.txt-fsize-mtime
FileUtil fu(filename);
std::stringstream ss;
ss << fu.Filename() << "-" << fu.Filesize() << "-" << fu.LastMtime();
return ss.str();
}
public:
Backup(const std::string& back_dir, const std::string back_file):_back_dir(back_dir)
{
_data = new DataManager(back_file);
}
bool RunModel()
{
while (true)
{
//1. 遍历文件列表，获取信息
FileUtil fu(_back_dir);
std::vector<std::string> arry;
fu.ScanDirectory(arry);
//std::cout << arry.size() << std::endl;
for (auto& a : arry)
{
//std::cout << a << std::endl;
// 获取唯一标识符 ，判断是否需要备份
if (IsNeedUpload(a)==true)
{
std::cout << "文件需要上传\n";
if (Upload(a) == true)
{
std::cout <<GetFileIdentifier(a) << "文件上传成功\n";
_data->Insert(a, GetFileIdentifier(a));
}
}
}
Sleep(1000);
}
return true;
}
};
}
