package de.micromata.borgbutler;
|
|
import de.micromata.borgbutler.config.BorgRepoConfig;
|
import de.micromata.borgbutler.data.Archive;
|
import de.micromata.borgbutler.data.Repository;
|
import de.micromata.borgbutler.demo.DemoRepos;
|
import de.micromata.borgbutler.jobs.JobResult;
|
import de.micromata.borgbutler.json.JsonUtils;
|
import de.micromata.borgbutler.json.borg.*;
|
import de.micromata.borgbutler.utils.DateUtils;
|
import de.micromata.borgbutler.utils.ReplaceUtils;
|
import org.apache.commons.collections4.CollectionUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.commons.lang3.Validate;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.io.File;
|
import java.io.IOException;
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
/**
|
* Creates and executes borg commands by calling system's borg application (Borg must be installed).
|
*/
|
public class BorgCommands {
|
private static Logger log = LoggerFactory.getLogger(BorgCommands.class);
|
|
/**
|
* Executes borg --version
|
*
|
* @return version string.
|
*/
|
public static String version() {
|
BorgCommand command = new BorgCommand()
|
.setParams("--version")
|
.setDescription("Getting borg version.");
|
|
BorgJob<String> job = new BorgJob<>(command);
|
JobResult<String> jobResult = job.execute();
|
if (jobResult == null || jobResult.getStatus() != JobResult.Status.OK) {
|
return null;
|
}
|
String origVersion = jobResult.getResultObject();
|
String version = origVersion;
|
String[] strs = StringUtils.split(origVersion);
|
if (strs != null) {
|
if (!StringUtils.containsIgnoreCase(origVersion, "borg")) {
|
version = "";
|
} else {
|
version = strs[strs.length - 1]; // Work arround: borg returns "borg-macosx64 1.1.8" as version string (command is included).
|
}
|
}
|
if (version.length() == 0 || !Character.isDigit(version.charAt(0))) {
|
log.error("Version string returned by '" + job.getCommandLineAsString() + "' not as expected (not borg?): " + origVersion);
|
return null;
|
}
|
log.info("Borg version: " + version);
|
return version;
|
}
|
|
/**
|
* Executes borg init repository.
|
*
|
* @param repoConfig The configuration of the repo config (only repo is required).
|
* @param encryption The encryption value (repokey, repokey-blake2, none, ...).
|
* @return true, if no errors occured, otherwise false.
|
*/
|
public static boolean init(BorgRepoConfig repoConfig, String encryption) {
|
BorgCommand command = new BorgCommand()
|
.setRepoConfig(repoConfig)
|
.setCommand("init")
|
//.setParams("--json") // --progress has no effect.
|
.setDescription("Init new repo '" + repoConfig.getDisplayName() + "'.");
|
JobResult<String> jobResult = getResult(command);
|
String result = jobResult != null ? jobResult.getResultObject() : null;
|
// If everything is ok, now String will be returned, result must be blank:
|
if (jobResult == null || jobResult.getStatus() != JobResult.Status.OK || StringUtils.isNotBlank(result)) {
|
log.error("Error while trying to intialize repo '" + repoConfig.getRepo() + "': " + result);
|
return false;
|
}
|
log.error("Error while trying to intialize repo '" + repoConfig.getRepo() + "': " + result);
|
return false;
|
}
|
|
|
/**
|
* Executes borg info repository.
|
*
|
* @param repoConfig
|
* @return Parsed repo config returned by Borg command (without archives).
|
*/
|
public static BorgCommandResult<Repository> info(BorgRepoConfig repoConfig) {
|
BorgCommand command = new BorgCommand()
|
.setRepoConfig(repoConfig)
|
.setCommand("info")
|
.setParams("--json") // --progress has no effect.
|
.setDescription("Loading info of repo '" + repoConfig.getDisplayName() + "'.");
|
BorgCommandResult<Repository> result = new BorgCommandResult<>();
|
getResult(result, command);
|
if (result.getStatus() != JobResult.Status.OK) {
|
return result;
|
}
|
String resultJson = result.getJobResult().getResultObject();
|
BorgRepoInfo repoInfo = JsonUtils.fromJson(BorgRepoInfo.class, resultJson);
|
BorgRepository borgRepository = repoInfo.getRepository();
|
Repository repository = new Repository();
|
repository.setId(borgRepository.getId());
|
repository.setName(repoConfig.getRepo());
|
repository.setDisplayName(repoConfig.getDisplayName());
|
repository.setLastModified(DateUtils.format(borgRepository.getLastModified()));
|
repository.setLocation(borgRepository.getLocation());
|
repository.setCache(repoInfo.getCache());
|
repository.setEncryption(repoInfo.getEncryption());
|
repository.setSecurityDir(repoInfo.getSecurityDir());
|
repository.setLastCacheRefresh(DateUtils.format(LocalDateTime.now()));
|
DemoRepos.repoWasRead(repoConfig, repository);
|
return result.setObject(repository);
|
}
|
|
/**
|
* Executes borg list repository.
|
* The given repository will be used and archives will be added.
|
*
|
* @param repoConfig The repo config associated to the masterRepository. Needed for the borg call.
|
* @param repository Repository without archives, archives will be loaded.
|
*/
|
public static void list(BorgRepoConfig repoConfig, Repository repository) {
|
BorgCommand command = new BorgCommand()
|
.setRepoConfig(repoConfig)
|
.setCommand("list")
|
.setParams("--json") // --progress has no effect.
|
.setDescription("Loading list of archives of repo '" + repoConfig.getDisplayName() + "'.");
|
JobResult<String> jobResult = getResult(command);
|
if (jobResult == null || jobResult.getStatus() != JobResult.Status.OK) {
|
log.error("Can't load archives from repo '" + repository.getName() + "'.");
|
return;
|
}
|
String result = jobResult.getResultObject();
|
BorgRepoList repoList = JsonUtils.fromJson(BorgRepoList.class, result);
|
if (repoList == null || CollectionUtils.isEmpty(repoList.getArchives())) {
|
log.error("Can't load archives from repo '" + repository.getName() + "'.");
|
return;
|
}
|
repository.setLastModified(DateUtils.format(repoList.getRepository().getLastModified()));
|
repository.setLastCacheRefresh(DateUtils.format(LocalDateTime.now()));
|
for (BorgArchive borgArchive : repoList.getArchives()) {
|
Archive archive = new Archive()
|
.setName(borgArchive.getArchive())
|
.setId(borgArchive.getId())
|
.setStart(DateUtils.format(borgArchive.getStart()))
|
.setTime(DateUtils.format(borgArchive.getTime()))
|
.setRepoId(repository.getId())
|
.setRepoName(repository.getName())
|
.setRepoDisplayName(repoConfig.getDisplayName());
|
repository.add(archive);
|
}
|
}
|
|
/**
|
* Executes borg info repository::archive.
|
* The given repository will be modified.
|
* The field {@link Repository#getLastModified()} of masterRepository will be updated.
|
*
|
* @param repoConfig The repo config associated to the repository. Needed for the borg call.
|
* @param archive The archive to update.
|
* @param repository Repository without archives.
|
*/
|
public static void info(BorgRepoConfig repoConfig, Archive archive, Repository repository) {
|
BorgCommand command = new BorgCommand()
|
.setRepoConfig(repoConfig)
|
.setCommand("info")
|
.setArchive(archive.getName())
|
.setParams("--json", "--log-json", "--progress")
|
.setDescription("Loading info of archive '" + archive.getName() + "' of repo '" + repoConfig.getDisplayName() + "'.");
|
JobResult<String> jobResult = getResult(command);
|
if (jobResult == null || jobResult.getStatus() != JobResult.Status.OK) {
|
return;
|
}
|
String result = jobResult.getResultObject();
|
BorgArchiveInfo archiveInfo = JsonUtils.fromJson(BorgArchiveInfo.class, result);
|
if (archiveInfo == null) {
|
log.error("Archive '" + command.getRepoArchive() + "' not found.");
|
return;
|
}
|
repository.setLastModified(DateUtils.format(archiveInfo.getRepository().getLastModified()));
|
repository.setLastCacheRefresh(DateUtils.format(LocalDateTime.now()));
|
archive.setCache(archiveInfo.getCache())
|
.setEncryption(archiveInfo.getEncryption());
|
if (CollectionUtils.isEmpty(archiveInfo.getArchives())) {
|
log.error("The returned borg archive contains no archive infos: " + command.getAbbreviatedResponse());
|
return;
|
}
|
if (archiveInfo.getArchives().size() > 1) {
|
log.warn("Archive '" + command.getRepoArchive() + "' contains more than one archives!? (Using only first.)");
|
}
|
BorgArchive2 borgArchive = archiveInfo.getArchives().get(0);
|
archive.setStart(DateUtils.format(borgArchive.getStart()))
|
.setChunkerParams(borgArchive.getChunkerParams())
|
.setCommandLine(borgArchive.getCommandLine())
|
.setComment(borgArchive.getComment())
|
.setStats(borgArchive.getStats())
|
.setLimits(borgArchive.getLimits())
|
.setHostname(borgArchive.getHostname())
|
.setUsername(borgArchive.getUsername())
|
.setEnd(DateUtils.format(borgArchive.getEnd()))
|
.setDuration(borgArchive.getDuration());
|
}
|
|
public static List<BorgFilesystemItem> listArchiveContent(BorgRepoConfig repoConfig, Archive archive) {
|
BorgCommand command = new BorgCommand()
|
.setRepoConfig(repoConfig)
|
.setCommand("list")
|
.setArchive(archive.getName())
|
.setParams("--json-lines")
|
.setDescription("Loading list of files of archive '" + archive.getName() + "' of repo '" + repoConfig.getDisplayName() + "'.");
|
// The returned job might be an already queued or running one!
|
final ProgressInfo progressInfo = new ProgressInfo()
|
.setMessage("Getting file list...")
|
.setCurrent(0);
|
if (archive.getStats() != null) // Occurs only for demo repos.
|
progressInfo.setTotal(archive.getStats().getNfiles());
|
BorgJob<List<BorgFilesystemItem>> job = BorgQueueExecutor.getInstance().execute(new BorgJob<List<BorgFilesystemItem>>(command) {
|
@Override
|
public void processStdOutLine(String line, int level) {
|
BorgFilesystemItem item = JsonUtils.fromJson(BorgFilesystemItem.class, line);
|
item.setMtime(DateUtils.format(item.getMtime()));
|
payload.add(item);
|
if ("-".equals(item.getType())) {
|
// Only increment for files, because number of files is the total.
|
setProgressInfo(progressInfo.incrementCurrent());
|
}
|
}
|
});
|
job.payload = new ArrayList<>();
|
JobResult<String> jobResult = job.getResult();
|
if (jobResult == null || jobResult.getStatus() != JobResult.Status.OK) {
|
return null;
|
}
|
List<BorgFilesystemItem> items = job.payload;
|
job.cleanUp(); // payload will be released.
|
return items;
|
}
|
|
/**
|
* Stores the file in a subdirectory named with the repos display name.
|
*
|
* @param restoreHomeDir
|
* @param repoConfig
|
* @param archive
|
* @param path
|
* @return Used sub directory with the restored content.
|
* @throws IOException
|
*/
|
public static File extractFiles(File restoreHomeDir, BorgRepoConfig repoConfig, Archive archive, String path) throws IOException {
|
File restoreDir = new File(restoreHomeDir, ReplaceUtils.encodeFilename(repoConfig.getDisplayName(), true));
|
if (!restoreDir.exists()) {
|
restoreDir.mkdirs();
|
}
|
BorgCommand command = new BorgCommand()
|
.setWorkingDir(restoreDir)
|
.setRepoConfig(repoConfig)
|
.setCommand("extract")
|
.setParams("--log-json", "--progress")
|
.setArchive(archive.getName())
|
.setArgs(path)
|
.setDescription("Extract content of archive '" + archive.getName()
|
+ "' of repo '" + repoConfig.getDisplayName() + "': "
|
+ path);
|
JobResult<String> jobResult = getResult(command);
|
return restoreDir;
|
}
|
|
private static void getResult(BorgCommandResult<?> result, BorgCommand command) {
|
BorgJob<Void> job = execute(command);
|
JobResult<String> jobResult = job.getResult();
|
result.setJobResult(jobResult);
|
if (jobResult == null || jobResult.getStatus() == JobResult.Status.ERROR) {
|
jobResult.setErrorString(job.getErrorString(2000));
|
}
|
job.cleanUp();
|
}
|
|
private static JobResult<String> getResult(BorgCommand command) {
|
BorgJob<Void> job = execute(command);
|
JobResult<String> jobResult = job.getResult();
|
job.cleanUp();
|
return jobResult;
|
}
|
|
private static BorgJob<Void> execute(BorgCommand command) {
|
Validate.notNull(command);
|
return BorgQueueExecutor.getInstance().execute(command);
|
}
|
}
|
