项目日记 -云备份 -客户端

最新推荐文章于 2025-04-02 17:12:37 发布

夜泉_ly

最新推荐文章于 2025-04-02 17:12:37 发布

阅读量892

点赞数 25

分类专栏：项目日记 # 云备份文章标签： linux 网络 c++

本文链接：https://blog.youkuaiyun.com/2401_86587256/article/details/146799668

版权

项目日记同时被 2 个专栏收录

6 篇文章

订阅专栏

云备份

6 篇文章

订阅专栏

博客主页：【夜泉_ly】
本文专栏：【项目日记-云备份】
欢迎点赞👍收藏⭐关注❤️

在这里插入图片描述
代码已上传 gitee

文件工具类

客户端也涉及到文件操作，
可以直接CV服务端的文件工具类。

下面我简单说两个改动点，
首先，需要加一条宏定义

#define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING

这个宏是在Visual Studio中引入的，
用于在编译时忽略<experimental/filesystem>库的弃用警告。
然后，Windows下路径分隔符为\，提取名字时需要注意一下：

std::string getFileName() const
{
    size_t pos = _filePath.find_last_of("\\");
    if (pos == std::string::npos) {
        return _filePath;
    }
    return _filePath.substr(pos + 1);
}

数据管理类

大致思路与服务端相同，
不过这里简化了很多步骤：
用全局变量取代单例模式（客户端是单线程）、
用简单的最后修改时间+文件名代替FileInfo结构体、
用 \n 和 \n\n 代替 jsoncpp 的序列化。

#pragma once
#include "utils.hpp"
#include <unordered_map>

namespace Cloud
{
const char* const backupFile = "cloud.dat";
class DataManager
{
public:
	DataManager()
		:_backupFile(backupFile)
	{
		checkFile();
		init();
	}
	void checkFile()
	{
		if (FileUtils(_backupFile).exists() == false)
			FileUtils(_backupFile).setContent("");
	}

	void init()
	{
		std::ifstream ifs(_backupFile, std::ios::binary);
		std::string filePath;
		while (std::getline(ifs, filePath))
		{
			std::string fileInfo;
			std::getline(ifs, fileInfo);
			_hash[filePath] = fileInfo;
			std::getline(ifs, fileInfo);
		}
	}
	bool storage()
	{
		std::stringstream ss;
		for (const auto& e : _hash)
			ss << e.first << "\n" << e.second << "\n\n";
		std::ofstream ofs(_backupFile, std::ios::binary);
		if (!ofs)
		{
			std::cerr << "DataManager::storage: open file error\n";
			return false;
		}
		ofs << ss.str();
		return true;
	}

	bool insert(const std::string& filePath, const std::string& fileInfo)
	{
		_hash[filePath] = fileInfo;
		return storage();
	}

	bool update(const std::string& filePath, const std::string& fileInfo)
	{
		_hash[filePath] = fileInfo;
		return storage();
	}

	bool getInfoFromHash(const std::string& filePath, std::string* fileInfo)
	{
		if (_hash.count(filePath))
		{
			*fileInfo = _hash[filePath];
			return true;
		}
		return false;
	}
	bool getInfoFromDir(const std::string& filePath, std::string* fileInfo)
	{
		FileUtils tmp(filePath);
		if (tmp.exists())
		{
			*fileInfo += std::to_string(tmp.getMTime());
			*fileInfo += "***";
			*fileInfo += tmp.getFileName();
			return true;
		}
		return false;
	}
private:
	std::unordered_map<std::string, std::string> _hash;
	std::string _backupFile;
};
static DataManager dataManager;
} // namespace Cloud

文件备份模块

#pragma once
#include "datamanager.hpp"
#include "httplib.h"
#include <windows.h>

std::string GbkToUtf8(const char* src_str)
{
	int len = MultiByteToWideChar(CP_ACP, 0, src_str, -1, NULL, 0);
	wchar_t* wstr = new wchar_t[len + 1];
	memset(wstr, 0, len + 1);
	MultiByteToWideChar(CP_ACP, 0, src_str, -1, wstr, len);
	len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
	char* str = new char[len + 1];
	memset(str, 0, len + 1);
	WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, len, NULL, NULL);
	std::string strTemp = str;
	if (wstr) delete[] wstr;
	if (str) delete[] str;
	return strTemp;
}

namespace Cloud
{
const char* const serverIp = "113.44.51.126";
const int serverPort = 8899;
class Backup
{
public:
	Backup(const std::string& backupDir)
		: _backupDir(backupDir)
	{
		FileUtils(backupDir).createDirectory();
	}

	bool upload(const std::string& filePath)
	{
		httplib::Client client(serverIp, serverPort);
		std::string fileName = GbkToUtf8(FileUtils(filePath).getFileName().c_str());
		std::string content;
		FileUtils(filePath).getContent(&content);
		
		httplib::MultipartFormDataItems items = 
		{
			{"uploadFile", content, fileName, "application/octet-stream"}
		};

		auto res = client.Post("/upload", items);

		if (res && res->status == 200 || res->status == 302) 
		{
			std::cout << "upload successful: " << fileName << std::endl;
			return true;
		}
		else 
		{
			std::cout << "upload failed: " << fileName << std::endl;
			return false;
		}
	}

	
	bool needUpload(const std::string& filePath)
	{
		std::string fileInfo;
		if (dataManager.getInfoFromHash(filePath, &fileInfo))
		{   // 能在哈希表中找到文件信息，说明已备份，
			// 只需检查是否修改
			std::string curFileInfo;
			dataManager.getInfoFromDir(filePath, &curFileInfo);
			return fileInfo != curFileInfo;
		}
		// 没备份，则需检查最后修改时间，避免大文件拷贝到一半就post了
		time_t mtime = FileUtils(filePath).getMTime();
		return time(nullptr) - mtime > 5;
	}

	bool run()
	{
		FileUtils backupDir(_backupDir);
		while (1)
		{
			std::vector<std::string> pathes;
			backupDir.scanDirectory(&pathes);
			for (const auto& filePath : pathes)
			{
				if (needUpload(filePath))
				{
					std::cout << filePath << " need upload\n";
					std::string fileInfo;
					dataManager.getInfoFromDir(filePath, &fileInfo);
					std::cout << "fileInfo : " << fileInfo << '\n';
					dataManager.insert(filePath, fileInfo);
					upload(filePath);
				}
			}
			Sleep(1);
		}
	}

private:
	std::string _backupDir;
};
} // namespace Cloud

这里存文件名时必须 GbkToUtf8 ，不然会乱码。

client

#define  _CRT_SECURE_NO_WARNINGS

#include "utils.hpp"
#include "backup.hpp"

const char* backupDir = "backupdir";

int main()
{
	Cloud::Backup(backupDir).run();
	return 0;
}