1571 lines
48 KiB
C++
Executable File
1571 lines
48 KiB
C++
Executable File
#include "utils.h"
|
||
#include <QByteArray>
|
||
#include <QDateTime>
|
||
#include <QFile>
|
||
#include <QTextStream>
|
||
#include <QDir>
|
||
#include <QRegularExpression>
|
||
#include <QThread>
|
||
#include <QUuid>
|
||
#include <iostream>
|
||
#include <unistd.h>
|
||
#include <fcntl.h>
|
||
#include <sys/file.h>
|
||
#include <sys/stat.h>
|
||
#include <sys/types.h>
|
||
#include <memory>
|
||
#include <functional>
|
||
#include <QRegularExpression>
|
||
#include <QProcess>
|
||
#include <QSettings>
|
||
#include <QTextCodec>
|
||
#include <QEventLoop>
|
||
#include <QTimer>
|
||
#include <QStorageInfo>
|
||
#include "../backup-daemon/parsebackuplist.h"
|
||
|
||
#include "mylittleparse.h"
|
||
#include "mydefine.h"
|
||
|
||
QString SystemInfo::m_os;
|
||
QString SystemInfo::m_arch;
|
||
QString SystemInfo::m_archDetect;
|
||
|
||
QString Utils::m_sysRootPath = "/";
|
||
QString Utils::m_logPath = "";
|
||
|
||
/**
|
||
* @brief initSysRootPath, 根据应用程序路径推断系统根目录
|
||
* @note
|
||
* 本方法依赖于根分区挂载目录
|
||
* 1. grub引导中根目录为/root（现在grub菜单的系统备份还原改为了initrd阶段用shell脚本实现，不会再用此应用程序）
|
||
* 2. 试安装的小系统中根目录约定为/target（试安装小系统中进行系统还原的功能暂未提供）
|
||
* 3. 正常使用中根目录为/
|
||
* 此接口是为试安装的小系统中进行系统还原预留
|
||
*/
|
||
void Utils::initSysRootPath()
|
||
{
|
||
QString sysRootPath = "/";
|
||
if (Utils::isCasper())
|
||
sysRootPath = CASPER_ROOT_PATH;
|
||
|
||
m_sysRootPath = sysRootPath;
|
||
}
|
||
|
||
/**
|
||
* @brief /proc/cmdline中包含boot=casper则说明是运行的试安装的小系统
|
||
* @return true-是试安装模式中；false-不是
|
||
*/
|
||
bool Utils::isCasper()
|
||
{
|
||
QString cmdline = Utils::processCmd("cat /proc/cmdline");
|
||
if (cmdline.contains("boot=casper"))
|
||
return true;
|
||
else
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* @brief customMessageHandler，日志重定向句柄
|
||
* @param type 日志类型，debug等
|
||
* @param context 上下文
|
||
* @param msg 日志信息
|
||
*/
|
||
void Utils::customMessageHandler(QtMsgType type, const QMessageLogContext& context, const QString& msg)
|
||
{
|
||
QByteArray localMsg = msg.toLocal8Bit();
|
||
QString strMsg("");
|
||
switch (type) {
|
||
case QtDebugMsg:
|
||
strMsg = QString("[Debug]");
|
||
break;
|
||
case QtWarningMsg:
|
||
strMsg = QString("[Warning]");
|
||
break;
|
||
case QtCriticalMsg:
|
||
strMsg = QString("[Critical]");
|
||
break;
|
||
case QtFatalMsg:
|
||
strMsg = QString("[Fatal]");
|
||
break;
|
||
default:
|
||
strMsg = QString("[Debug]");
|
||
break;
|
||
}
|
||
|
||
// 设置输出信息格式
|
||
QString strDateTime = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss ddd");
|
||
QString strMessage = strMsg + QString("DateTime:%1 ThreadId:%2 Message:%3 File:%4(%5)")
|
||
.arg(strDateTime).arg(QString::number(quintptr(QThread::currentThreadId()))).arg(localMsg.constData()).arg(context.file).arg(context.line);
|
||
|
||
std::cout << strMessage.toUtf8().data() << std::endl;
|
||
|
||
// 输出信息至文件中（读写、追加形式）
|
||
QString fileName = m_sysRootPath + PROC_LOG;
|
||
if (!m_logPath.isEmpty()) {
|
||
fileName = m_logPath;
|
||
}
|
||
fileName.replace("//", "/");
|
||
QFile file(fileName);
|
||
file.open(QIODevice::ReadWrite | QIODevice::Append);
|
||
QTextStream stream(&file);
|
||
stream << strMessage << END_LINE;
|
||
stream.flush();
|
||
file.close();
|
||
}
|
||
|
||
/**
|
||
* @brief 文件锁，锁定应用程序
|
||
* @param frontUid，锁定程序的用户id
|
||
* @return 锁文件的文件描述符
|
||
* @note 使用方式类似于QLockFile，后面时间充足时也可以自行封装一个独立类来处理文件锁
|
||
* 这个文件锁的作用是，在关机时关机模块会自行校验/tmp/lock路径下的锁文件，如果存在则提醒用户xx程序在运行不允许关机等
|
||
*/
|
||
int Utils::lockProgram(int frontUid)
|
||
{
|
||
QDir dir(LOCK_FILE_PATH);
|
||
if (!dir.exists()) {
|
||
dir.mkdir(LOCK_FILE_PATH);
|
||
chmod(LOCK_FILE_PATH, S_IRWXU | S_IRWXG | S_IRWXO);
|
||
}
|
||
|
||
int lock_file_fd = ::open(LOCK_FILE, O_CREAT | O_RDWR, 0666);
|
||
if (0 > lock_file_fd) {
|
||
return -2;
|
||
}
|
||
fchmod(lock_file_fd, S_IRWXU | S_IRWXG | S_IRWXO);
|
||
|
||
int lock_ret = flock(lock_file_fd, LOCK_EX | LOCK_NB);
|
||
if (0 > lock_ret) {
|
||
return -11;
|
||
}
|
||
|
||
ftruncate(lock_file_fd, 0);
|
||
|
||
char write_string[PID_STRING_LEN] = { 0 };
|
||
snprintf(write_string, PID_STRING_LEN, "%d\n%s\n", frontUid, BACKUP_CLI_NAME);
|
||
write(lock_file_fd, write_string, strlen(write_string));
|
||
fdatasync(lock_file_fd);
|
||
return lock_file_fd;
|
||
}
|
||
|
||
/**
|
||
* @brief 解除应用程序文件锁
|
||
* @param lock_file_fd 锁文件的文件描述符
|
||
* @return 0，解除成功；1，解除失败
|
||
*/
|
||
int Utils::unLockProgram(int lock_file_fd)
|
||
{
|
||
int lock_ret = flock(lock_file_fd, LOCK_UN);
|
||
if (lock_ret < 0) {
|
||
qCritical("unlock fail!");
|
||
return 1;
|
||
}
|
||
qDebug("unlock success!");
|
||
rmLockFile();
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* @brief 删除锁文件
|
||
* @return bool
|
||
*/
|
||
bool Utils::rmLockFile()
|
||
{
|
||
bool res = QFile::remove(LOCK_FILE);
|
||
if (!res)
|
||
qCritical() << QString("remove %s fail").arg(LOCK_FILE);
|
||
return res;
|
||
}
|
||
|
||
/**
|
||
* @brief 检查/etc/.bootinfo是否存在并可读，里面存放备份分区的UUID等信息
|
||
* @return bool
|
||
*/
|
||
bool Utils::checkBootInfoExists()
|
||
{
|
||
QString bootinfoPath = Utils::m_sysRootPath + BOOTINFO_PATH;
|
||
bootinfoPath.replace("//", "/");
|
||
QFile bootinfoFile(bootinfoPath);
|
||
if (!bootinfoFile.exists()) {
|
||
qCritical("%s is not exists!", qUtf8Printable(bootinfoPath));
|
||
return false;
|
||
}
|
||
if (!bootinfoFile.open(QIODevice::ReadOnly)) {
|
||
qCritical("%s file can't open!", qUtf8Printable(bootinfoPath));
|
||
return false;
|
||
}
|
||
bootinfoFile.close();
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @brief 是否有平板模式
|
||
* @return bool
|
||
*/
|
||
bool Utils::isTablet()
|
||
{
|
||
QString otaPath = Utils::m_sysRootPath + "/etc/apt/ota_version";
|
||
otaPath.replace("//", "/");
|
||
|
||
return QFile::exists(otaPath);
|
||
}
|
||
|
||
/**
|
||
* @brief 获取备份分区的UUID
|
||
* @return 备份分区的UUID
|
||
*/
|
||
QString Utils::getBackupPartitionUuid()
|
||
{
|
||
QString bootinfoPath = Utils::m_sysRootPath + BOOTINFO_PATH;
|
||
bootinfoPath.replace("//", "/");
|
||
|
||
MyLittleParse parse(bootinfoPath);
|
||
QString restoreUuid;
|
||
parse.find("RECOVERY_DEV_UUID", restoreUuid);
|
||
|
||
if (restoreUuid.isEmpty()) {
|
||
QString fstab = Utils::m_sysRootPath + FSTAB_PATH;
|
||
fstab.replace("//", "/");
|
||
QFile file(fstab);
|
||
if (file.exists()) {
|
||
if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
||
QTextStream in(&file);
|
||
QString preLine;
|
||
while (!in.atEnd()) {
|
||
QString line = in.readLine();
|
||
if (line.isEmpty())
|
||
continue;
|
||
if (line.startsWith("#")) {
|
||
preLine = line;
|
||
continue;
|
||
}
|
||
if (line.startsWith("UUID=") && line.contains("/backup")) {
|
||
// like:
|
||
// # /dev/add4 LABEL=KYLIN-BACKUP
|
||
// UUID=40be1cac-cd92-49db-8a98-68ee21ddbc49 /backup ext4 noauto 0 0
|
||
int indexOfSpace = line.indexOf(QRegularExpression("[ \t]+"), 0);
|
||
QString uuid = line.mid(0, indexOfSpace);
|
||
uuid.replace("UUID=", "");
|
||
restoreUuid = uuid.trimmed();
|
||
|
||
parse.Add("RECOVERY_DEV_UUID", restoreUuid);
|
||
|
||
break ;
|
||
} else if (line.startsWith("/dev/") && line.contains("/backup")) {
|
||
// like:
|
||
// # UUID=40be1cac-cd92-49db-8a98-68ee21ddbc49 LABEL=KYLIN-BACKUP
|
||
// /dev/add4 /backup ext4 noauto 0 0
|
||
if (preLine.startsWith("#") && preLine.contains("UUID=")) {
|
||
preLine.replace("# ", "");
|
||
preLine.replace("#", "");
|
||
|
||
int indexOfSpace = preLine.indexOf(QRegularExpression("[ \t]+"), 0);
|
||
QString uuid = preLine.mid(0, indexOfSpace);
|
||
uuid.replace("UUID=", "");
|
||
restoreUuid = uuid.trimmed();
|
||
|
||
parse.Add("RECOVERY_DEV_UUID", restoreUuid);
|
||
|
||
break ;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return restoreUuid;
|
||
}
|
||
|
||
/**
|
||
* @brief 获取分区对应的UUID映射关系
|
||
* @param fstab文件路径
|
||
* @return “分区挂载目录-分区UUID”键值对
|
||
*/
|
||
QHash<QString, QString> Utils::getPartUuidMap(const QString &fstab)
|
||
{
|
||
QHash<QString, QString> result;
|
||
QFile file(fstab);
|
||
if (file.exists()) {
|
||
if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
||
QTextStream in(&file);
|
||
QString preLine;
|
||
while (!in.atEnd()) {
|
||
QString line = in.readLine();
|
||
if (line.isEmpty())
|
||
continue;
|
||
if (line.startsWith("#")) {
|
||
preLine = line;
|
||
continue;
|
||
}
|
||
|
||
// 配置文件/etc/fstab每行6个域: <file system> <mount point> <type> <options> <dump> <pass>, 形如:
|
||
// UUID=232f5fb4-53e0-46b9-ba9b-22bfec64f2a2 /boot ext4 rw,relatime 0 0
|
||
QStringList list = line.split(QRegularExpression("[ \t]+"));
|
||
QStringList fields;
|
||
for (int i = 0; i < list.size(); ++i) {
|
||
QString field = list.at(i);
|
||
field = field.trimmed();
|
||
if (field.isEmpty())
|
||
continue;
|
||
fields << field;
|
||
}
|
||
QString mountPonit = fields.at(1);
|
||
|
||
if (line.startsWith("UUID=")) {
|
||
// like:
|
||
// # /dev/add4 LABEL=KYLIN-BACKUP
|
||
// UUID=40be1cac-cd92-49db-8a98-68ee21ddbc49 /backup ext4 noauto 0 0
|
||
int indexOfSpace = line.indexOf(QRegularExpression("[ \t]+"), 0);
|
||
QString uuid = line.mid(0, indexOfSpace);
|
||
uuid.replace("UUID=", "");
|
||
uuid = uuid.trimmed();
|
||
|
||
result.insert(mountPonit, uuid);
|
||
} else if (line.startsWith("/dev/")) {
|
||
// like:
|
||
// # UUID=40be1cac-cd92-49db-8a98-68ee21ddbc49 LABEL=KYLIN-BACKUP
|
||
// /dev/add4 /backup ext4 noauto 0 0
|
||
if (preLine.startsWith("#") && preLine.contains("UUID=")) {
|
||
preLine.replace("# ", "");
|
||
preLine.replace("#", "");
|
||
|
||
int indexOfSpace = preLine.indexOf(QRegularExpression("[ \t]+"), 0);
|
||
QString uuid = preLine.mid(0, indexOfSpace);
|
||
uuid.replace("UUID=", "");
|
||
uuid = uuid.trimmed();
|
||
|
||
result.insert(mountPonit, uuid);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* @brief swapKeyValue
|
||
* @param hash
|
||
* @return
|
||
*/
|
||
QHash<QString, QString> Utils::swapKeyValue(const QHash<QString, QString>& hash)
|
||
{
|
||
QHash<QString, QString> result;
|
||
for (QHash<QString, QString>::const_iterator it = hash.constBegin(); it != hash.constEnd(); ++it) {
|
||
result.insert(it.value(), it.key());
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* @brief /etc/fstab中的绑定映射关系
|
||
* @return src-dest键值对map
|
||
*/
|
||
QHash<QString, QString> Utils::getFstabBindInfo()
|
||
{
|
||
QHash<QString, QString> result;
|
||
QString fstabPath = Utils::m_sysRootPath + FSTAB_PATH;
|
||
fstabPath.replace("//", "/");
|
||
|
||
QFile file(fstabPath);
|
||
if (!file.open(QIODevice::ReadOnly))
|
||
return result;
|
||
QTextStream in(&file);
|
||
while (!in.atEnd()) {
|
||
const QString &line = in.readLine();
|
||
if (line.startsWith("#"))
|
||
continue ;
|
||
if (line.startsWith("UUID="))
|
||
continue ;
|
||
if (line.startsWith("/dev/"))
|
||
continue ;
|
||
if (line.isEmpty())
|
||
continue ;
|
||
if (!line.contains("bind"))
|
||
continue ;
|
||
|
||
// 配置文件/etc/fstab每行6个域: <file system> <mount point> <type> <options> <dump> <pass>, 形如:
|
||
// UUID=232f5fb4-53e0-46b9-ba9b-22bfec64f2a2 /boot ext4 rw,relatime 0 0
|
||
QStringList list = line.split(QRegularExpression("[ \t]+"));
|
||
QStringList fields;
|
||
for (int i = 0; i < list.size(); ++i) {
|
||
QString field = list.at(i);
|
||
field = field.trimmed();
|
||
if (field.isEmpty())
|
||
continue;
|
||
fields << field;
|
||
}
|
||
// 配置文件/etc/fstab每行6个域，第二个域为挂载路径, 为统一路径使用挂接点，排除第一个域
|
||
if (6 == fields.size())
|
||
result.insert(fields.at(0), fields.at(1));
|
||
}
|
||
|
||
file.close();
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* @brief 路径不存在则创建，不支持递归创建
|
||
* @param path
|
||
*/
|
||
void Utils::mkdir(const QString& path)
|
||
{
|
||
QDir dir(path);
|
||
if (!dir.exists())
|
||
dir.mkdir(path);
|
||
}
|
||
|
||
/**
|
||
* @brief 创建路径，支持递归创建
|
||
* @param path
|
||
* @return bool
|
||
*/
|
||
bool Utils::mkpath(const QString& path)
|
||
{
|
||
QDir dir(path);
|
||
if (!dir.exists()) {
|
||
return dir.mkpath(path);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @brief 备份还原时，需要排除绑定挂载的路径，因为数据不是存放在挂载路径内
|
||
* @param excludes，存放需要排除的绑定路径
|
||
*/
|
||
void Utils::excludeFstabBindPath(QStringList &excludes)
|
||
{
|
||
QString fstabPath = Utils::m_sysRootPath + FSTAB_PATH;
|
||
fstabPath.replace("//", "/");
|
||
|
||
QFile file(fstabPath);
|
||
if (!file.open(QIODevice::ReadOnly))
|
||
return;
|
||
QTextStream in(&file);
|
||
while (!in.atEnd()) {
|
||
const QString &line = in.readLine();
|
||
if (line.startsWith("#"))
|
||
continue ;
|
||
if (line.startsWith("UUID="))
|
||
continue ;
|
||
if (line.startsWith("/dev/"))
|
||
continue ;
|
||
if (line.isEmpty())
|
||
continue ;
|
||
if (!line.contains("bind"))
|
||
continue ;
|
||
|
||
// 配置文件/etc/fstab每行6个域: <file system> <mount point> <type> <options> <dump> <pass>, 形如:
|
||
// UUID=232f5fb4-53e0-46b9-ba9b-22bfec64f2a2 /boot ext4 rw,relatime 0 0
|
||
QStringList list = line.split(QRegularExpression("[ \t]+"));
|
||
QStringList fields;
|
||
for (int i = 0; i < list.size(); ++i) {
|
||
QString field = list.at(i);
|
||
field = field.trimmed();
|
||
if (field.isEmpty())
|
||
continue;
|
||
fields << field;
|
||
}
|
||
// 配置文件/etc/fstab每行6个域，第二个域为挂载路径, 为统一路径使用挂接点，排除第一个域
|
||
if (6 == fields.size())
|
||
excludes << fields.at(0);
|
||
}
|
||
|
||
file.close();
|
||
}
|
||
|
||
/**
|
||
* @brief 备份还原时，需要一些用户家目录下的路径，因为这些路径备份还原程序无权操作
|
||
* @param excludes，存放需要排除的路径
|
||
*/
|
||
void Utils::excludeSomeHomePath(QStringList &excludes)
|
||
{
|
||
QSet<QString> homeSet;
|
||
// 获取/home下的用户家目录
|
||
QString homePath = Utils::m_sysRootPath + "/home";
|
||
homePath.replace("//", "/");
|
||
QDir dir(homePath);
|
||
QStringList list = dir.entryList(QDir::NoDotAndDotDot | QDir::Dirs);
|
||
for (const QString& item : list) {
|
||
// /home/oem跳过
|
||
if (item == "oem")
|
||
continue ;
|
||
|
||
QString home("/home/");
|
||
home += item;
|
||
excludes << home + "/.box";
|
||
excludes << home + "/.log";
|
||
QString dataHome("/data/home/");
|
||
dataHome += item;
|
||
excludes << dataHome + "/.box";
|
||
excludes << dataHome + "/.log";
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 排除自定义备份路径
|
||
* @param excludes，存放需要排除的路径
|
||
*/
|
||
void Utils::excludeCustomizePath(QStringList &excludes)
|
||
{
|
||
// 本地xml文件中的信息
|
||
QString xmlPath = Utils::getSysRootPath() + BACKUP_XML_PATH;
|
||
xmlPath.replace("//", "/");
|
||
ParseBackupList parse(xmlPath);
|
||
parse.getCustomizePaths(excludes);
|
||
}
|
||
|
||
/**
|
||
* @brief 生成rsync --exclude-from排除路径规则文件
|
||
* @return
|
||
*/
|
||
bool Utils::generateExcludePathsFile()
|
||
{
|
||
QString excludeFile = Utils::m_sysRootPath + EXCLUDE_FILE_PATH;
|
||
excludeFile.replace("//", "/");
|
||
|
||
QFile excludePathFile(excludeFile);
|
||
// 暂时改为每次都重写文件内容，以便能随版本更新排除路径
|
||
if (!excludePathFile.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
|
||
qCritical("%s create failed", qUtf8Printable(excludeFile));
|
||
return false;
|
||
}
|
||
|
||
QTextStream in(&excludePathFile);
|
||
in << "/backup" << END_LINE; //分区
|
||
// in << "/boot/efi" << END_LINE;
|
||
in << "/cdrom" << END_LINE;
|
||
in << "/dev" << END_LINE;
|
||
// efi原始目录在/boot/efi，备份到目标目录为/efi下，再还原时已经单独处理了，批量还原时应该屏蔽此目录
|
||
in << "/efi" << END_LINE;
|
||
// 安全模块会将文件/usr/share/kysec-utils/data/readonly_list中的文件列表限制只读，无法修改、备份（包含扩展属性时）、删除等
|
||
// 现在里面仅有/etc/uid_list，先暂时排除掉；等后续安全模块有其它保护方案后再进一步修改
|
||
in << "/etc/uid_list" << END_LINE;
|
||
in << "/data/ghost" << END_LINE; //ghost镜像文件
|
||
in << "/ghost" << END_LINE; //ghost镜像文件
|
||
in << "/lost+found" << END_LINE;
|
||
in << "/media" << END_LINE;
|
||
in << "/mnt" << END_LINE;
|
||
in << "/proc" << END_LINE;
|
||
in << "/run" << END_LINE;
|
||
in << "/swap_file" << END_LINE;
|
||
in << "/sys" << END_LINE; //添加*(/sys/*)，表示如果/sys目录不存在，则会拷贝/sys，但不会拷贝/sys下的内容
|
||
in << "/tmp" << END_LINE;
|
||
in << "/var/lib/docker/overlay2" << END_LINE;
|
||
// 安卓兼容的这个里面很多文件都是设置了特殊扩展文件属性，lsetxattr无法设置成功，听取安卓兼容模块同事的意见不用管这个文件夹，其实是从home下挂载的
|
||
in << "/var/lib/kmre/data" << END_LINE;
|
||
in << "/var/lib/kmre/kmre-*-*/data/media/0/0-麒麟*" << END_LINE;
|
||
in << "/var/lib/udisks2" << END_LINE;
|
||
in << "/var/log" << END_LINE;
|
||
in << "*/backup/snapshots" << END_LINE;
|
||
// 跟wps的研发沟通了，安全目录的使用场景，主要是两个场景：
|
||
// 1、在用户浏览信创加密文档时，解密出来的临时明文文件会放在安全目录，关闭文档后，临时文件被删除。
|
||
// 2、用户离线授权的某个加密文档的解密私钥也会放在安全目录中。因此跟他讨论，从安全角度来看，最好不要备份还原这个目录。
|
||
in << "/data/security-dir" << END_LINE;
|
||
|
||
// 系统安装后有的会将/data/home /data/root挂载到的/home /root上，实际文件是存放在/data/home /data/root下面，为了统一标准保留/home /root排除/data/home /data/root
|
||
QStringList excludes;
|
||
Utils::excludeFstabBindPath(excludes);
|
||
// ~/.box目录后来安全给予赋权，故此去掉
|
||
// Utils::excludeSomeHomePath(excludes);
|
||
Utils::excludeCustomizePath(excludes);
|
||
for (const QString& item : excludes) {
|
||
in << item << END_LINE;
|
||
}
|
||
in.flush();
|
||
|
||
excludePathFile.close();
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @brief 判断目录是否存在
|
||
* @param 目录路径
|
||
* @return true,存在；false,不存在
|
||
*/
|
||
bool Utils::isDirExist(const QString& fullDirName)
|
||
{
|
||
QDir dir(fullDirName);
|
||
if (dir.exists())
|
||
return true;
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* @brief 获取系统备份还原排除路径列表, rsync --exclude-from排除路径规则文件中读取
|
||
* @return 系统备份还原排除路径列表
|
||
*/
|
||
QStringList Utils::getFromExcludePathsFile()
|
||
{
|
||
QStringList list;
|
||
list << "/backup";
|
||
// list << "/boot/efi";
|
||
list << "/cdrom";
|
||
list << "/dev";
|
||
list << "/efi";
|
||
list << "/etc/uid_list";
|
||
list << "/data/ghost";
|
||
list << "/ghost";
|
||
list << "/lost+found";
|
||
list << "/media";
|
||
list << "/mnt";
|
||
list << "/proc";
|
||
list << "/run";
|
||
list << "/swap_file";
|
||
list << "/sys";
|
||
list << "/tmp";
|
||
list << "/var/lib/docker/overlay2";
|
||
list << "/var/lib/kmre/data";
|
||
list << "/var/lib/kmre/kmre-*-*/data/media/0/0-麒麟*";
|
||
list << "/var/lib/udisks2";
|
||
list << "/var/log";
|
||
list << "*/backup/snapshots";
|
||
// 跟wps的研发沟通了，安全目录的使用场景，主要是两个场景：
|
||
// 1、在用户浏览信创加密文档时，解密出来的临时明文文件会放在安全目录，关闭文档后，临时文件被删除。
|
||
// 2、用户离线授权的某个加密文档的解密私钥也会放在安全目录中。因此跟他讨论，从安全角度来看，最好不要备份还原这个目录。
|
||
list << "/data/security-dir";
|
||
|
||
// 系统安装后有的会将/data/home /data/root挂载到的/home /root上，实际文件是存放在/data/home /data/root下面
|
||
QStringList excludes;
|
||
Utils::excludeFstabBindPath(excludes);
|
||
// Utils::excludeSomeHomePath(excludes);
|
||
Utils::excludeCustomizePath(excludes);
|
||
for (const QString& item : excludes) {
|
||
list << item;
|
||
}
|
||
|
||
return list;
|
||
}
|
||
|
||
/**
|
||
* @brief 生成Uuid
|
||
* @return UUID
|
||
*/
|
||
QString Utils::createUuid()
|
||
{
|
||
QString uuid;
|
||
do {
|
||
uuid = QUuid::createUuid().toString();
|
||
} while (uuid == AUTO_BACKUP_UUID || uuid == FACTORY_BACKUP_UUID);
|
||
return uuid;
|
||
}
|
||
|
||
/**
|
||
* @brief 将列表中内容写入指定文件中
|
||
* @param fileName，文件全路径
|
||
* @param lines，内容列表
|
||
* @return true，成功写入；false，写入失败
|
||
*/
|
||
bool Utils::writeFileByLines(const QString& fileName, const QStringList& lines)
|
||
{
|
||
QFile file(fileName);
|
||
if (!file.open(QIODevice::ReadWrite | QIODevice::Truncate)) {
|
||
return false;
|
||
}
|
||
|
||
QTextStream out(&file);
|
||
for (const QString& line : lines) {
|
||
out << line << END_LINE;
|
||
}
|
||
out.flush();
|
||
file.close();
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @brief 判断文件是否存在
|
||
* @param fileName 文件明
|
||
* @return bool，true-存在；false-不存在
|
||
* @author zhaominyong
|
||
* @since 2021/05/29
|
||
*/
|
||
bool Utils::fileExists(const QString &fileName)
|
||
{
|
||
struct stat buffer;
|
||
return (stat(fileName.toStdString().data(), &buffer) == 0);
|
||
}
|
||
|
||
/**
|
||
* @brief 判断目录是否为空
|
||
* @param fullDirName 目录路径
|
||
* @return true-目录不存在或为空目录; false-非空目录
|
||
*/
|
||
bool Utils::isDirEmpty(const QString& fullDirName)
|
||
{
|
||
QDir dir(fullDirName);
|
||
if (!dir.exists())
|
||
return true;
|
||
|
||
if (dir.isEmpty())
|
||
return true;
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* @brief 记录备份日志
|
||
* @param line，日志内容
|
||
* @return bool, true-成功；false-失败
|
||
* @author zhaominyong
|
||
* @since 2021/05/29
|
||
* @note
|
||
* 因为系统恢复成功后马上需要reboot，但是此时的文件缓存可能还未能落盘，故此增加此函数，其中调用了系统函数fdatasync确保缓存落盘
|
||
*/
|
||
bool Utils::writeBackupLog(QString line)
|
||
{
|
||
line = line + "\n";
|
||
QString logFile = Utils::getSysRootPath() + BACKUP_LOG_TEXT_PATH;
|
||
logFile.replace("//", "/");
|
||
std::string fileName(logFile.toStdString());
|
||
// 判断文件是否存在
|
||
bool exists = fileExists(logFile);
|
||
|
||
std::unique_ptr<std::FILE, int (*)(std::FILE*)> fp(std::fopen(fileName.data(), "a+"), std::fclose);
|
||
|
||
if (!fp) {
|
||
std::perror("file opening failed!");
|
||
return false;
|
||
}
|
||
|
||
if (!exists) {
|
||
std::fputs("#This file must not be deleted and it is for the backup tool.\n", fp.get());
|
||
std::fputs("#0:new system backup\n", fp.get());
|
||
std::fputs("#1:update system backup\n", fp.get());
|
||
std::fputs("#2:new data backup\n", fp.get());
|
||
std::fputs("#3:update data backup\n", fp.get());
|
||
std::fputs("#4:restore system\n", fp.get());
|
||
std::fputs("#5:retaining user data\n", fp.get());
|
||
std::fputs("#6:restore data\n", fp.get());
|
||
std::fputs("#8:delete backup\n", fp.get());
|
||
std::fputs("#for example: 17-04-25 10:43:56,{uuidxxxxx},0,this is a note,21.19KB,userid-1000,备份名称\n", fp.get());
|
||
}
|
||
std::fputs(line.toStdString().data(), fp.get());
|
||
std::fflush(fp.get());
|
||
fdatasync(fileno(fp.get()));
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @brief 立即写文件
|
||
* @param fileName 文件名，包含路径
|
||
* @param content 文件内容
|
||
* @return bool
|
||
*/
|
||
bool Utils::syncWriteFile(const QString &fileName, const QString& content)
|
||
{
|
||
qDebug() << fileName << content;
|
||
std::unique_ptr<std::FILE, int (*)(std::FILE*)> fp(std::fopen(fileName.toStdString().data(), "w"), std::fclose);
|
||
|
||
if (!fp) {
|
||
std::perror("file opening failed!");
|
||
return false;
|
||
}
|
||
|
||
QStringList lines = content.split("\n");
|
||
for (const QString& line : lines) {
|
||
std::fputs(line.toStdString().data(), fp.get());
|
||
}
|
||
std::fflush(fp.get());
|
||
fdatasync(fileno(fp.get()));
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @brief 将字节大小转换为GB等表示的字符串
|
||
* @param size，qint64，空间大小，单位字节
|
||
* @return GB/MB/KB等表示的字符串型大小
|
||
*/
|
||
QString Utils::StringBySize(qint64 size)
|
||
{
|
||
#define GB (1024 * 1024 * 1024)
|
||
#define MB (1024 * 1024)
|
||
#define KB (1024)
|
||
|
||
float fcount = size * 1.0;
|
||
|
||
if (size > GB)
|
||
return QString(QString::number(fcount / GB, 10, 2) + "GB");
|
||
else if (size > MB)
|
||
return QString(QString::number(fcount / MB, 10, 2) + "MB");
|
||
else
|
||
return QString(QString::number(fcount / KB, 10, 2) + "KB");
|
||
}
|
||
|
||
/**
|
||
* @brief 获取挂接的移动设备列表
|
||
* @return MOUNTPOINT,PATH键值对列表
|
||
* @author zhaominyong
|
||
* @since 2021/06/07
|
||
* @note
|
||
* for bug 59636 【cpm】【HUAWEI】【KOS】【L0】【V3试制】备份时选择移动设备，会出现一个dev/sdc的路径(一般+必现+不常用功能)
|
||
* QStorageInfo::mountedVolumes获取的磁盘列表区分不出来是否移动设备
|
||
*/
|
||
QHash<QString, QString> Utils::getRemovableStorages()
|
||
{
|
||
QHash<QString, QString> removalbeStorages;
|
||
|
||
QProcess process_lsblk;
|
||
process_lsblk.start("lsblk -P -o PATH,RM,TYPE,MOUNTPOINT,TRAN");
|
||
if (!process_lsblk.waitForStarted(-1)) {
|
||
return removalbeStorages;
|
||
}
|
||
if (!process_lsblk.waitForFinished(-1)) {
|
||
return removalbeStorages;
|
||
}
|
||
QString result = process_lsblk.readAllStandardOutput();
|
||
/*
|
||
result like bellow :
|
||
PATH="/dev/sda" RM="0" TYPE="disk" MOUNTPOINT="" TRAN="sata"
|
||
PATH="/dev/sda1" RM="0" TYPE="part" MOUNTPOINT="/media/zhaominyong/DATA1" TRAN=""
|
||
PATH="/dev/sdb" RM="1" TYPE="disk" MOUNTPOINT="" TRAN="usb"
|
||
PATH="/dev/sdb4" RM="1" TYPE="part" MOUNTPOINT="/media/zhaominyong/31 GB" TRAN=""
|
||
PATH="/dev/sr0" RM="1" TYPE="rom" MOUNTPOINT="/media/zhaominyong/Kylin-Desktop-V10-SP1" TRAN=""
|
||
*/
|
||
QStringList items = result.split("\n");
|
||
QStringList usbDevs;
|
||
for (QStringList::const_iterator it = items.constBegin(); it != items.constEnd(); ++it) {
|
||
const QString &line = (*it);
|
||
if (line.contains(" TRAN=\"usb\"")) {
|
||
QStringList storageAttrs = line.split("\" ");
|
||
if (5 != storageAttrs.size())
|
||
continue ;
|
||
QString path = storageAttrs.at(0);
|
||
path = path.replace("PATH=\"", "");
|
||
usbDevs.append(path);
|
||
}
|
||
if (line.contains(" RM=\"1\" ") || line.contains(" MOUNTPOINT=\"/media/")) {
|
||
if (line.contains(" TYPE=\"rom\" "))
|
||
continue;
|
||
if (line.contains(" MOUNTPOINT=\"\""))
|
||
continue;
|
||
|
||
// "PATH RM TYPE MOUNTPOINT TRAN" for each row, split by "\" "
|
||
QStringList storageAttrs = line.split("\" ");
|
||
if (5 != storageAttrs.size())
|
||
continue ;
|
||
QString path = storageAttrs.at(0);
|
||
path = path.replace("PATH=\"", "");
|
||
bool isSubPart = false;
|
||
for (const QString& usbDev : usbDevs) {
|
||
if (path.contains(usbDev)) {
|
||
isSubPart = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!isSubPart)
|
||
continue;
|
||
QString mount_point = storageAttrs.at(3);
|
||
mount_point = mount_point.replace("MOUNTPOINT=\"", "");
|
||
removalbeStorages.insert(path, mount_point);
|
||
}
|
||
}
|
||
|
||
return removalbeStorages;
|
||
}
|
||
|
||
/**
|
||
* @brief 获取分区信息
|
||
* @return “LABEL-分区信息”键值对
|
||
*/
|
||
QHash<QString, PartitionInfo> Utils::getPartitions()
|
||
{
|
||
QString blkidResult = Utils::processCmd("blkid");
|
||
QStringList lines = blkidResult.split("\n");
|
||
/*
|
||
blkid命令结果形如：
|
||
/dev/sda3: LABEL="SYSROOT" UUID="0336d6bf-4ce5-4dcf-8976-4f51be65e0ea" TYPE="ext4" PARTLABEL="SYSROOT" PARTUUID="d255022a-597e-471a-8407-bf8f82c66f8c"
|
||
/dev/sda1: LABEL_FATBOOT="ESP" LABEL="ESP" UUID="A995-1AE9" TYPE="vfat" PARTLABEL="EFI" PARTUUID="98282378-7d21-4ee8-96f2-abbe9903b6db"
|
||
/dev/sda2: LABEL="SYSBOOT" UUID="939dc93e-6c81-4f50-8de8-abd8e5ad2058" TYPE="ext4" PARTLABEL="boot" PARTUUID="b3638559-0ebd-4df1-96ef-49058e703a7f"
|
||
/dev/sda4: LABEL="KYLIN-BACKUP" UUID="5f98378a-56fc-4ba5-a751-2bc51c59a0a4" TYPE="ext4" PARTLABEL="backup" PARTUUID="31a2e37b-2868-4959-8402-23e135ddd9aa"
|
||
/dev/sda5: LABEL="DATA" UUID="f363d368-ef4e-4a19-a997-be4c3bfaaca5" TYPE="ext4" PARTLABEL="data" PARTUUID="c24d9d39-9cb1-4eb2-9b88-e807decbb8e5"
|
||
/dev/sda6: LABEL="SWAP" UUID="577b58ad-78a4-4a68-84b6-07095d562614" TYPE="swap" PARTLABEL="logical" PARTUUID="acba62b4-0747-44d9-9d87-82013762af31"
|
||
*/
|
||
|
||
QHash<QString, PartitionInfo> result;
|
||
for (const QString& line : lines) {
|
||
QStringList fields = line.split(QRegularExpression(":[ \t]+"));
|
||
if (fields.size() != 2)
|
||
continue;
|
||
QString device = fields.at(0);
|
||
QString desc = fields.at(1);
|
||
PartitionInfo partitionInfo;
|
||
partitionInfo.m_device = device;
|
||
QStringList attrs = desc.split(QRegularExpression("[ \t]+"));
|
||
for (const QString& attr : attrs) {
|
||
if (attr.startsWith("LABEL=")) {
|
||
QStringList pairs = attr.split("=");
|
||
if (pairs.size() != 2)
|
||
continue;
|
||
QString label = pairs.at(1);
|
||
label.replace("\"", "");
|
||
partitionInfo.m_label = label;
|
||
} else if (attr.startsWith("UUID=")) {
|
||
QStringList pairs = attr.split("=");
|
||
if (pairs.size() != 2)
|
||
continue;
|
||
QString uuid = pairs.at(1);
|
||
uuid.replace("\"", "");
|
||
partitionInfo.m_uuid = uuid;
|
||
} else if (attr.startsWith("TYPE=")) {
|
||
QStringList pairs = attr.split("=");
|
||
if (pairs.size() != 2)
|
||
continue;
|
||
QString type = pairs.at(1);
|
||
type.replace("\"", "");
|
||
partitionInfo.m_type = type;
|
||
}
|
||
|
||
if (!partitionInfo.m_label.isEmpty() && !partitionInfo.m_uuid.isEmpty() && !partitionInfo.m_type.isEmpty()) {
|
||
result.insert(partitionInfo.m_label, partitionInfo);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* @brief 获取挂接的计算机内部磁盘
|
||
* @return 内部磁盘挂接路径列表
|
||
*/
|
||
QList<QString> Utils::getLocalDisks()
|
||
{
|
||
QList<QString> localDisks;
|
||
|
||
QProcess process_lsblk;
|
||
process_lsblk.start("lsblk -P -o PATH,RM,TYPE,MOUNTPOINT,TRAN");
|
||
if (!process_lsblk.waitForStarted(-1)) {
|
||
return localDisks;
|
||
}
|
||
if (!process_lsblk.waitForFinished(-1)) {
|
||
return localDisks;
|
||
}
|
||
QString result = process_lsblk.readAllStandardOutput();
|
||
|
||
QString userName = qgetenv("USER");
|
||
QString mountPointPre("/media/");
|
||
mountPointPre += userName;
|
||
/*
|
||
result like bellow :
|
||
PATH="/dev/sda" RM="0" TYPE="disk" MOUNTPOINT="" TRAN="sata"
|
||
PATH="/dev/sda1" RM="0" TYPE="part" MOUNTPOINT="/media/zhaominyong/DATA1" TRAN=""
|
||
PATH="/dev/sdb" RM="1" TYPE="disk" MOUNTPOINT="" TRAN="usb"
|
||
PATH="/dev/sdb4" RM="1" TYPE="part" MOUNTPOINT="/media/zhaominyong/31 GB" TRAN=""
|
||
PATH="/dev/sr0" RM="1" TYPE="rom" MOUNTPOINT="/media/zhaominyong/Kylin-Desktop-V10-SP1" TRAN=""
|
||
*/
|
||
QStringList items = result.split("\n");
|
||
QStringList usbDevs;
|
||
for (QStringList::const_iterator it = items.constBegin(); it != items.constEnd(); ++it) {
|
||
const QString &line = (*it);
|
||
if (line.contains(QRegularExpression(" TRAN=\".+\"")) && !line.contains(" TRAN=\"usb\"")) {
|
||
QStringList storageAttrs = line.split("\" ");
|
||
if (5 != storageAttrs.size())
|
||
continue ;
|
||
QString path = storageAttrs.at(0);
|
||
path = path.replace("PATH=\"", "");
|
||
usbDevs.append(path);
|
||
continue;
|
||
}
|
||
if (line.contains(" TYPE=\"part\" ") && line.contains(mountPointPre)) {
|
||
if (line.contains(" MOUNTPOINT=\"\""))
|
||
continue;
|
||
|
||
// "PATH RM TYPE MOUNTPOINT TRAN" for each row, split by "\" "
|
||
QStringList storageAttrs = line.split("\" ");
|
||
if (5 != storageAttrs.size())
|
||
continue ;
|
||
QString path = storageAttrs.at(0);
|
||
path = path.replace("PATH=\"", "");
|
||
bool isSubPart = false;
|
||
for (const QString& usbDev : usbDevs) {
|
||
if (path.contains(usbDev)) {
|
||
isSubPart = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!isSubPart)
|
||
continue;
|
||
|
||
// 默认挂载的内部磁盘不太可能使用中文字符等，暂不考虑挂载路径被转义的场景
|
||
QString mount_point = storageAttrs.at(3);
|
||
mount_point = mount_point.replace("MOUNTPOINT=\"", "");
|
||
localDisks << mount_point;
|
||
}
|
||
}
|
||
|
||
return localDisks;
|
||
}
|
||
|
||
/**
|
||
* @brief 设置安全状态
|
||
* @param enable——true，开启保护；false，关闭保护
|
||
*/
|
||
void Utils::setKysecStatus(bool enable)
|
||
{
|
||
QFile file("/usr/bin/setstatus");
|
||
if (!file.exists()) {
|
||
file.setFileName("/usr/sbin/setstatus");
|
||
if (!file.exists())
|
||
return ;
|
||
}
|
||
|
||
if (enable) {
|
||
QProcess::execute("setstatus enable");
|
||
} else {
|
||
QProcess::execute("setstatus softmode");
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 启动或关闭kysec-sync-daemon服务
|
||
* @param enable——true，开启；false，关闭
|
||
*/
|
||
void Utils::setKysecDaemon(bool enable){
|
||
if(enable){
|
||
QProcess::execute("systemctl start kysec-sync-daemon");
|
||
}else{
|
||
QProcess::execute("systemctl stop kysec-sync-daemon");
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 判断程序是否已开启
|
||
* @param processName
|
||
* @return bool
|
||
*/
|
||
bool Utils::isRunning(const QString &processName)
|
||
{
|
||
bool bRet = false;
|
||
|
||
QProcess ps;
|
||
QProcess grep;
|
||
ps.setStandardOutputProcess(&grep);
|
||
|
||
ps.start("ps", QStringList() << "-ef");
|
||
grep.start("grep", QStringList() << processName);
|
||
|
||
if (grep.waitForFinished()) {
|
||
QString result(grep.readAll());
|
||
qDebug() << result;
|
||
QStringList lines = result.split("\n");
|
||
for (const QString& line : lines) {
|
||
if (line.contains("grep"))
|
||
continue;
|
||
if (line.contains(processName)){
|
||
bRet = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
grep.close();
|
||
ps.close();
|
||
|
||
return bRet;
|
||
}
|
||
|
||
/**
|
||
* @brief 判断是否990或9006C、PANGU处理器
|
||
* @return bool
|
||
*/
|
||
bool Utils::isHuawei990()
|
||
{
|
||
QString result;
|
||
Utils::executeCMD("cat /proc/cpuinfo | grep -i \"kirin.*9.0\"", result);
|
||
if (result.isEmpty()) {
|
||
Utils::executeCMD("cat /proc/cpuinfo | grep -i \"PANGU\"", result);
|
||
if (result.isEmpty())
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @brief 在终端中执行简单命令
|
||
* @param cmd
|
||
* @return 返回终端输出结果
|
||
*/
|
||
QString Utils::processCmd(const QString& cmd)
|
||
{
|
||
QString result;
|
||
|
||
QStringList args;
|
||
args << "-c";
|
||
args << cmd;
|
||
QProcess process;
|
||
process.start("bash", args);
|
||
if (process.waitForFinished()) {
|
||
result = QString(process.readAll());
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* @brief popen()函数通过创建一个管道，调用fork()产生一个子进程，执行一个shell以运行命令来开启一个进程。
|
||
* @param cmd，是一个指向以 NULL 结束的 shell 命令字符串的指针。这行命令将被传到 bin/sh 并使用 -c 标志，shell 将执行这个命令
|
||
* @param result 输出结果
|
||
* @note
|
||
*/
|
||
void Utils::executeCMD(const char* cmd, QString &result)
|
||
{
|
||
char buf_ps[1024] = { 0 };
|
||
FILE* ptr = nullptr;
|
||
// 只能是读或者写中的一种，得到的返回值（标准 I/O 流）也具有和 type 相应的只读或只写类型。
|
||
// 如果 type 是 “r” 则文件指针连接到 command 的标准输出；如果 type 是 “w” 则文件指针连接到 command 的标准输入。
|
||
qDebug() << cmd;
|
||
if ((ptr = popen(cmd, "r")) != nullptr) {
|
||
while (fgets(buf_ps, 1024, ptr) != nullptr) {
|
||
result += buf_ps;
|
||
memset(buf_ps, 0, 1024);
|
||
}
|
||
pclose(ptr);
|
||
ptr = nullptr;
|
||
} else {
|
||
qCritical("popen %s error", cmd);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief Utils::executeCmd
|
||
* @param cmd
|
||
* @param args
|
||
* @return
|
||
*/
|
||
QString Utils::executeCmd(const QString &cmd, const QStringList &args)
|
||
{
|
||
QString cmdLine(cmd);
|
||
for (const QString &arg : args) {
|
||
cmdLine += " ";
|
||
cmdLine += arg;
|
||
}
|
||
qDebug() << cmdLine;
|
||
|
||
QString result;
|
||
char buf_ps[1024] = { 0 };
|
||
FILE* ptr = nullptr;
|
||
// 只能是读或者写中的一种，得到的返回值（标准 I/O 流）也具有和 type 相应的只读或只写类型。
|
||
// 如果 type 是 “r” 则文件指针连接到 command 的标准输出；如果 type 是 “w” 则文件指针连接到 command 的标准输入。
|
||
if ((ptr = popen(cmdLine.toStdString().data(), "r")) != nullptr) {
|
||
while (fgets(buf_ps, 1024, ptr) != nullptr) {
|
||
result += buf_ps;
|
||
memset(buf_ps, 0, 1024);
|
||
}
|
||
pclose(ptr);
|
||
ptr = nullptr;
|
||
} else {
|
||
qCritical("popen %s error", cmdLine.toStdString().data());
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* @brief 获取备份日志列表
|
||
* @return
|
||
*/
|
||
QList<BackupWrapper> Utils::getBackupLogList()
|
||
{
|
||
// 为兼容以前的老备份数据，在此处先获取uuid-name键值对
|
||
QMap<QString, QString> uuid_name = Utils::getBackupUuidNameMap();
|
||
|
||
QString logFile = Utils::getSysRootPath() + BACKUP_LOG_TEXT_PATH;
|
||
logFile.replace("//", "/");
|
||
QFile file(logFile);
|
||
QList<BackupWrapper> list;
|
||
if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
||
QTextStream in(&file);
|
||
while (!in.atEnd()) {
|
||
QString line = in.readLine();
|
||
if (line.startsWith("#") || line.isEmpty())
|
||
continue;
|
||
QStringList fields = line.split(",");
|
||
BackupWrapper record;
|
||
int index = 0;
|
||
for (const QString &field : fields) {
|
||
switch (index) {
|
||
case 0: // 备份时间
|
||
record.m_time = field;
|
||
break;
|
||
case 1: // uuid
|
||
record.m_uuid = field;
|
||
break;
|
||
case 2: // 操作类型
|
||
record.m_type = field.toInt();
|
||
break;
|
||
case 3: // 备注
|
||
record.m_note = field;
|
||
break;
|
||
case 4: // 备份大小
|
||
record.m_size = field;
|
||
break;
|
||
case 5: // 备份用户id
|
||
if (field.isEmpty())
|
||
record.m_frontUid = -1;
|
||
else
|
||
record.m_frontUid = field.toInt();
|
||
break;
|
||
case 6: // 备份名称
|
||
record.m_backupName = field;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
++index;
|
||
}
|
||
|
||
if (record.m_backupName.isEmpty()) {
|
||
if (FACTORY_BACKUP_UUID == record.m_uuid) {
|
||
record.m_backupName = QObject::tr("Factory Backup");
|
||
}
|
||
// else if (AUTO_BACKUP_UUID == record.m_uuid) {
|
||
// record.m_backupName = QObject::tr("Auto Backup");
|
||
// }
|
||
else if (uuid_name.contains(record.m_uuid)) {
|
||
record.m_backupName = uuid_name.value(record.m_uuid);
|
||
}
|
||
else {
|
||
record.m_backupName = record.m_time;
|
||
}
|
||
} else if (FACTORY_BACKUP_UUID == record.m_uuid) {
|
||
record.m_backupName = QObject::tr("Factory Backup");
|
||
}
|
||
|
||
list << record;
|
||
}
|
||
}
|
||
|
||
return list;
|
||
}
|
||
|
||
/**
|
||
* @brief 初始化系统信息
|
||
*/
|
||
void Utils::initSystemInfo()
|
||
{
|
||
SystemInfo::m_os = Utils::getOs();
|
||
SystemInfo::m_arch = Utils::getArch();
|
||
SystemInfo::m_archDetect = Utils::getArchDetect();
|
||
}
|
||
|
||
/**
|
||
* @brief getOs
|
||
* @return 操作系统名字, 如：
|
||
* Kylin-Desktop V10-SP1
|
||
* Build 20210407
|
||
*/
|
||
QString Utils::getOs()
|
||
{
|
||
QString path = Utils::getSysRootPath() + "/etc/kylin-build";
|
||
path.replace("//", "/");
|
||
QFile file(path);
|
||
/* 文件内容形如：
|
||
Kylin-Desktop V10-SP1
|
||
Build 20210407
|
||
*/
|
||
QString os;
|
||
if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
||
QTextStream in(&file);
|
||
if (!in.atEnd()) {
|
||
os = in.readLine();
|
||
}
|
||
}
|
||
|
||
return os;
|
||
}
|
||
|
||
/**
|
||
* @brief getArch
|
||
* @return 架构，arch命令的结果，如：x86_64
|
||
*/
|
||
QString Utils::getArch()
|
||
{
|
||
QString arch = Utils::executeCmd("arch");
|
||
return arch.replace("\n", "");
|
||
}
|
||
|
||
/**
|
||
* @brief getArchDetect
|
||
* @return archdetect命令的结果，如：amd64/efi
|
||
*/
|
||
QString Utils::getArchDetect()
|
||
{
|
||
QString arch = Utils::executeCmd("archdetect");
|
||
return arch.replace("\n", "");
|
||
}
|
||
|
||
/**
|
||
* @brief 获取分区剩余大小
|
||
* @return
|
||
*/
|
||
QHash<QString, QString> Utils::getLeftSizeOfPartitions()
|
||
{
|
||
QString root = Utils::getSysRootPath();
|
||
QString backup = Utils::getSysRootPath() + BACKUP_PATH;
|
||
backup.replace("//", "/");
|
||
QString data = Utils::getSysRootPath() + DATA_PATH;
|
||
data.replace("//", "/");
|
||
|
||
QStringList args;
|
||
args << "-h";
|
||
args << backup;
|
||
args << data;
|
||
args << root;
|
||
|
||
QHash<QString, QString> hash;
|
||
|
||
QProcess df;
|
||
df.start("df", args);
|
||
if (df.waitForFinished()) {
|
||
QString result(df.readAll());
|
||
QStringList lines = result.split("\n");
|
||
/*
|
||
文件系统 容量 已用 可用 已用% 挂载点
|
||
/dev/nvme0n1p4 26G 45M 25G 1% /backup
|
||
/dev/nvme0n1p3 98G 54G 40G 58% /
|
||
/dev/nvme0n1p5 90G 8.6G 77G 11% /data
|
||
*/
|
||
// 排除第一行标题
|
||
for (int i = 1; i < lines.size(); ++i) {
|
||
QString line = lines.at(i);
|
||
line = line.trimmed();
|
||
if (line.isEmpty())
|
||
continue;
|
||
|
||
QStringList fields = line.split(QRegularExpression("[ \t]+"));
|
||
if (fields.size() != 6)
|
||
continue;
|
||
QString path = fields.at(5);
|
||
QString left = fields.at(3);
|
||
hash.insert(path, left);
|
||
}
|
||
}
|
||
return hash;
|
||
}
|
||
|
||
/**
|
||
* @brief 获取分区可用大小，主要是/和/data分区
|
||
* @return 路径和大小（单位：字节）键值对
|
||
*/
|
||
QHash<QString, qint64> Utils::getAvailableSizeOfPartitions()
|
||
{
|
||
QHash<QString, qint64> hash;
|
||
|
||
QString root = Utils::getSysRootPath();
|
||
QStorageInfo rootInfo(root);
|
||
hash.insert(root, rootInfo.bytesAvailable());
|
||
|
||
QString data = Utils::getSysRootPath() + DATA_PATH;
|
||
data.replace("//", "/");
|
||
QStorageInfo dataInfo(data);
|
||
hash.insert(data, dataInfo.bytesAvailable());
|
||
|
||
return hash;
|
||
}
|
||
|
||
/**
|
||
* @brief 获取文件夹或文件的大小
|
||
* @param path 路径
|
||
* @return 大小
|
||
*/
|
||
qint64 Utils::getDirOrFileSize(const QString &path)
|
||
{
|
||
char cmd[1024] = { 0 };
|
||
sprintf(cmd, "du -sb '%s' 2>/dev/null | awk '{print $1}'", path.toLocal8Bit().data()); //s:total k:1024 bytes b:1 byte
|
||
|
||
QString qsSize;
|
||
Utils::executeCMD(cmd, qsSize);
|
||
qsSize.replace("\n", "");
|
||
qsSize = qsSize.trimmed();
|
||
return qsSize.toLongLong();
|
||
}
|
||
|
||
/**
|
||
* @brief 记录下备份点uuid及其名称
|
||
* @param uuid 备份点识别码
|
||
* @param backupName 备份点名称
|
||
*/
|
||
void Utils::update_backup_unique_settings(const QString &uuid, const QString &backupName)
|
||
{
|
||
// 由于历史原因（原来只校验U盘备份的唯一性）,文件名暂不改变
|
||
QString backupUniqueSetting = Utils::getSysRootPath() + UDISK_UNIQUE_SETTINGS;
|
||
backupUniqueSetting.replace("//", "/");
|
||
QSettings udisk_unique_settings(backupUniqueSetting, QSettings::IniFormat);
|
||
udisk_unique_settings.setIniCodec(QTextCodec::codecForName("utf-8"));
|
||
udisk_unique_settings.beginGroup(backupName);
|
||
udisk_unique_settings.setValue("uuid", uuid);
|
||
udisk_unique_settings.endGroup();
|
||
}
|
||
|
||
/**
|
||
* @brief 根据备份点名称，删除备份点uuid记录
|
||
* @param backupName 备份点名称
|
||
*/
|
||
void Utils::deleteBackupUniqueRecord(const QString& backupName)
|
||
{
|
||
QString backupUniqueSetting = Utils::getSysRootPath() + UDISK_UNIQUE_SETTINGS;
|
||
backupUniqueSetting.replace("//", "/");
|
||
QSettings udisk_unique_settings(backupUniqueSetting, QSettings::IniFormat);
|
||
udisk_unique_settings.setIniCodec(QTextCodec::codecForName("utf-8"));
|
||
udisk_unique_settings.remove(backupName);
|
||
}
|
||
|
||
/**
|
||
* @brief 获取备份点Uuid-BackupName键值对
|
||
* @return Uuid-BackupName键值对
|
||
*/
|
||
QMap<QString, QString> Utils::getBackupUuidNameMap()
|
||
{
|
||
// 1、udisk_unique_file文件中的信息
|
||
QString backupUniqueSetting = Utils::getSysRootPath() + UDISK_UNIQUE_SETTINGS;
|
||
backupUniqueSetting.replace("//", "/");
|
||
QSettings udisk_unique_settings(backupUniqueSetting, QSettings::IniFormat);
|
||
QStringList groups = udisk_unique_settings.childGroups();
|
||
|
||
QMap<QString, QString> result;
|
||
for (const QString& group : groups) {
|
||
udisk_unique_settings.beginGroup(group);
|
||
QString uuid = udisk_unique_settings.value("uuid").toString();
|
||
udisk_unique_settings.endGroup();
|
||
result.insert(uuid, group);
|
||
}
|
||
|
||
// 2、本地xml文件中的信息
|
||
QString xmlPath = Utils::getSysRootPath() + BACKUP_XML_PATH;
|
||
xmlPath.replace("//", "/");
|
||
ParseBackupList parse(xmlPath);
|
||
parse.getXmlUuidNameMap(result);
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* @brief 前后两次调用，然后取文件修改时间用于判断缓存数据是否落盘
|
||
* @return
|
||
*/
|
||
bool Utils::updateSyncFile()
|
||
{
|
||
QString fileIfSync = Utils::getSysRootPath() + FILE_IF_SYNC;
|
||
fileIfSync.replace("//", "/");
|
||
QFile file(fileIfSync);
|
||
if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
|
||
return false;
|
||
}
|
||
|
||
QTextStream out(&file);
|
||
out << "sync" << END_LINE;
|
||
out.flush();
|
||
file.flush();
|
||
file.close();
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @brief 用事件循环替换sleep，以便事件尽量得到处理
|
||
* @param sec，等待时间，单位秒
|
||
* @author zhaominyong
|
||
* @since 2021/05/29
|
||
*/
|
||
void Utils::wait(uint sec)
|
||
{
|
||
QEventLoop loop;
|
||
QTimer::singleShot(1000 * sec, &loop, SLOT(quit()));
|
||
loop.exec();
|
||
}
|
||
|
||
/**
|
||
* @brief 判断某目录是否某些目录的子目录
|
||
* @param paths
|
||
* @param path
|
||
* @return
|
||
*/
|
||
bool Utils::isSubPath(const QStringList & paths, const QString& path)
|
||
{
|
||
for (QString item : paths) {
|
||
if (item.isEmpty() || item == Utils::getSysRootPath())
|
||
continue;
|
||
|
||
if (!item.endsWith("/"))
|
||
item.append("/");
|
||
|
||
if (path.startsWith(item))
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* @brief 获取备份还原版本号
|
||
* @return
|
||
*/
|
||
QString Utils::getBackupVersion()
|
||
{
|
||
QString version;
|
||
Utils::executeCMD("dpkg -l yhkylin-backup-tools | grep yhkylin-backup-tools", version);
|
||
// "ii yhkylin-backup-tools 4.0.13-kylin72 amd64 YHkylin backup tools\n"
|
||
QStringList fields = version.split(QRegularExpression("[ \t]+"));
|
||
if (fields.size() >= 3)
|
||
version = fields.at(2);
|
||
else
|
||
version = "none";
|
||
|
||
return version;
|
||
}
|
||
|
||
|
||
/**
|
||
* @brief 重新rw读写挂载efi分区
|
||
*/
|
||
void Utils::remountEfi()
|
||
{
|
||
QString mountPath = Utils::getSysRootPath() + "/boot/efi";
|
||
mountPath.replace("//", "/");
|
||
QStringList args;
|
||
args << "-o"
|
||
<< "rw,remount"
|
||
<< mountPath;
|
||
Utils::executeCmd("mount", args);
|
||
}
|
||
|
||
/**
|
||
* @brief 重新rw读写挂载boot分区
|
||
*/
|
||
void Utils::remountBoot()
|
||
{
|
||
QString mountPath = Utils::getSysRootPath() + "/boot";
|
||
mountPath.replace("//", "/");
|
||
QStringList args;
|
||
args << "-o"
|
||
<< "rw,remount"
|
||
<< mountPath;
|
||
Utils::executeCmd("mount", args);
|
||
}
|
||
|
||
|
||
/**
|
||
* @brief 停掉安全初始化服务
|
||
*/
|
||
void Utils::stopKysecInit()
|
||
{
|
||
Utils::executeCmd("systemctl stop kysec-init.service");
|
||
}
|
||
|
||
/**
|
||
* @brief 停掉网络服务
|
||
*/
|
||
void Utils::stopNetwork()
|
||
{
|
||
Utils::executeCmd("service network-manager stop");
|
||
}
|
||
|