package db.backup.internal;
|
|
import java.io.FileNotFoundException;
|
import java.text.DateFormat;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.Map;
|
|
import org.apache.logging.log4j.Level;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import db.Constants;
|
import db.DBBackup;
|
import db.DBBackupBeanHandler;
|
import db.DBBackupRecord;
|
import db.DBBackupRecordService;
|
import db.DBOperatorEvent;
|
import db.OpertProcessListener;
|
import db.support.DBBackupRecordServiceImpl;
|
import db.util.FileUtil;
|
import db.util.PathUtil;
|
import db.util.UUIDGenerator;
|
import kernel.util.DateUtils;
|
import kernel.util.StringUtils;
|
|
|
public abstract class AbstractBackupImpl implements DBBackup, DBBackupBeanHandler {
|
/**
|
* logger
|
*/
|
private final Logger logger = LoggerFactory.getLogger(this.getClass());
|
|
/**
|
* 默认备份路径
|
*/
|
protected final static String DEFAULT_BACKUP_PATH = PathUtil.getDbBackupPath();
|
|
/**
|
* 事件通知
|
*/
|
protected DBOperatorEvent operatorEvent;
|
|
/**
|
* 数据库备份记录信息管理接口
|
*/
|
protected DBBackupRecordService backupRecordService = new DBBackupRecordServiceImpl();
|
|
@Override
|
public boolean backup(Map<String, Object> params, OpertProcessListener processListener) {
|
if (params == null) {
|
params = new HashMap<String, Object>();
|
}
|
params = parserMapParams(params); // 解析参数
|
|
// operatorEvent.beforeBackup(params); // 备份前事件通知
|
|
boolean result = false;
|
DBBackupRecord record = null;
|
backupRecordService = new DBBackupRecordServiceImpl();
|
try {
|
if (doEnvironmentCheck(params, processListener)) {
|
Date backupTime = new Date(); // 备份时间
|
params.put("backupTime", backupTime);
|
|
String backupName = (String) params.get("backupName"); // 备份名称
|
if (backupName == null) {
|
String databaseName = (String) params.get("databaseName");
|
DateFormat sdf = DateUtils.createDateFormat(Constants.DB_BACKUP_TIME_FORMAT);
|
backupName = databaseName + "_" + sdf.format(backupTime);
|
params.put("backupName", backupName);
|
}
|
|
result = doBackup(params, processListener); // 执行备份操作
|
|
record = createNewBackupRecord(params); // 新建备份记录
|
backupRecordService.add(record); // 保存备份文件信息
|
}
|
} catch (Throwable e) {
|
result = false;
|
logger.error("backup database error", e);
|
// throw new FastFailException(e);
|
throw new RuntimeException(e);
|
} finally {
|
String msg = "Finished - " + (result ? "Successfully" : "Failed");
|
try {
|
onOutputAndLog(processListener, msg, Level.INFO);
|
} catch (InterruptedException e) {
|
// ignore
|
}
|
|
if (processListener != null) {
|
processListener.onExit();
|
}
|
|
clearAfterBackup(params); // 备份后清理
|
}
|
|
params.put("result", result); // 结果
|
// operatorEvent.afterBackup(record, params); // 备份后事件通知
|
return result;
|
}
|
|
/**
|
* <p>Description: 备份清理工作（清除临时目录、不完整备份文件等操作） </p>
|
* <p>Create Time: 2013-2-20 </p>
|
* @author weiminghua
|
* @param params 参数
|
*/
|
protected void clearAfterBackup(Map<String, Object> params) {
|
// default do nothing
|
}
|
|
/**
|
* 备份文件后缀
|
* @return 备份文件后缀名
|
*/
|
protected abstract String getBackupFileSuffix();
|
|
/**
|
* 解析参数
|
*
|
* @param params 参数
|
* @return 参数
|
*/
|
protected abstract Map<String, Object> parserMapParams(Map<String, Object> params);
|
|
/**
|
* 运行环境检测
|
* @param params 参数
|
* @param processListener 监听器
|
* @return 结果
|
*/
|
protected abstract boolean doEnvironmentCheck(Map<String, Object> params, OpertProcessListener processListener);
|
|
/**
|
* 执行备份
|
* @param params 参数
|
* @param processListener 监听器
|
* @return 结果
|
* @throws InterruptedException 中断异常
|
*/
|
protected abstract boolean doBackup(Map<String, Object> params, OpertProcessListener processListener)
|
throws InterruptedException;
|
|
/**
|
* @param operatorEvent The operatorEvent to set.
|
*/
|
public void setOperatorEvent(DBOperatorEvent operatorEvent) {
|
this.operatorEvent = operatorEvent;
|
}
|
|
/**
|
* @param backupRecordService The backupRecordService to set.
|
*/
|
public void setBackupRecordService(DBBackupRecordService backupRecordService) {
|
this.backupRecordService = backupRecordService;
|
}
|
|
/**
|
* 生成备份记录
|
* @param params 参数
|
* @return 备份记录
|
*/
|
protected DBBackupRecord createNewBackupRecord(Map<String, Object> params) {
|
DBBackupRecord record = new DBBackupRecord();
|
record.setUuid(UUIDGenerator.getUUID());
|
String backupName = (String) params.get("backupName");
|
record.setName(backupName);
|
record.setBackupTime((Date) params.get("backupTime")); // 备份时间
|
String description = (String) params.get("description"); // 备份描述
|
record.setDescription(description);
|
|
String backupPath = (String) params.get("backupPath"); // 备份存储路径
|
String filePath = backupPath + "/" + backupName + getBackupFileSuffix(); // 备份文件路径
|
record.setFilePath(filePath);
|
try {
|
record.setFileSize(FileUtil.getFileSize(filePath));
|
} catch (FileNotFoundException e) {
|
logger.error("get backup file[" + filePath + "] size error");
|
throw new RuntimeException(e);
|
}
|
return record;
|
}
|
|
/**
|
* 输出监听，同时添加日志信息
|
* @param processListener 过程监听
|
* @param msg 日志信息
|
* @param log4jLevel 日志级别
|
* @throws InterruptedException 备份中断异常
|
*/
|
protected void onOutputAndLog(OpertProcessListener processListener, String msg, Level log4jLevel)
|
throws InterruptedException {
|
if (StringUtils.isNullOrEmpty(msg)) {
|
return;
|
}
|
|
if (processListener != null) {
|
if (processListener.isFinish()) {
|
throw new InterruptedException("interrupt databse backup"); // 备份中断
|
}
|
|
if (processListener.getOutputListener() != null) {
|
processListener.getOutputListener().onOutput(msg);
|
}
|
}
|
|
if (log4jLevel == null) {
|
try {
|
Thread.sleep(200); // 延迟加载信息
|
} catch (InterruptedException e) {
|
// ignore
|
}
|
return;
|
}
|
|
// 输出日志信息
|
if (Level.ERROR.equals(log4jLevel)) {
|
logger.error(msg);
|
}
|
else if (Level.WARN.equals(log4jLevel)) {
|
logger.warn(msg);
|
}
|
else if (Level.INFO.equals(log4jLevel)) {
|
logger.info(msg);
|
}
|
else if (Level.DEBUG.equals(log4jLevel)) {
|
logger.debug(msg);
|
}
|
}
|
|
}
|
