Docker...

Kai Reinhard

14.20.2021 5e39c0040ddde260831a5b9f73c0bbfec3738f94

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
package de.micromata.borgbutler.config;
 
import de.micromata.borgbutler.json.JsonUtils;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
 
public class ConfigurationHandler {
    private static Logger log = LoggerFactory.getLogger(ConfigurationHandler.class);
    private static ConfigurationHandler instance;
    private static final String BUTLER_HOME_DIR = ".borgbutler";
    private static final String CONFIG_FILENAME = "borgbutler-config.json";
    private static final String CONFIG_BACKUP_DIR = "backup";
    private File configFile;
    private File configBackupDir;
    private File workingDir;
    private File butlerHomeDir;
    private Configuration configuration;
    private static Class<? extends Configuration> configClazz = Configuration.class;
 
    public static void init(String butlerHomeDir) {
        if (instance != null) {
            throw new RuntimeException("ConfigurationHandler already initialized");
        }
        instance = new ConfigurationHandler(butlerHomeDir);
    }
 
    public static ConfigurationHandler getInstance() {
        if (instance == null) instance = new ConfigurationHandler();
        return instance;
    }
 
    public static Configuration getConfiguration() {
        return getInstance().configuration;
    }
 
    public static void setConfigClazz(Class<? extends Configuration> configClazz) {
        ConfigurationHandler.configClazz = configClazz;
    }
 
    private void read() {
        log.info("Reading config file '" + configFile.getAbsolutePath() + "'");
        try {
            String json = "{}";
            if (configFile.exists()) {
                json = FileUtils.readFileToString(configFile, Definitions.STD_CHARSET);
                // Migrate from first version:
                if (json.contains("repo-configs")) {
                    json = json.replace("repo-configs", "repoConfigs");
                    json = json.replace("display_name", "displayName");
                }
            }
            this.configuration = JsonUtils.fromJson(configClazz, json);
            if (this.configuration == null) {
                try {
                    this.configuration = configClazz.getDeclaredConstructor().newInstance();
                } catch (Exception ex) {
                    log.error("Internal error: Can't instantiate object of type '" + configClazz + "': " + ex.getMessage(), ex);
                    return;
                }
            }
            if (this.configuration.getRepoConfigs() != null) {
                for (BorgRepoConfig repoConfig : this.configuration.getRepoConfigs()) {
                    if (StringUtils.isBlank(repoConfig.getDisplayName())) {
                        repoConfig.setDisplayName(repoConfig.getRepo());
                    }
                }
            }
            this.configuration.setWorkingDir(workingDir);
        } catch (IOException ex) {
            log.error("Error while trying to read from config file: " + configFile.getAbsolutePath() + ": " + ex.getMessage(), ex);
            return;
        }
    }
 
    public void save() {
        if (this.configuration.getRepoConfigs() != null) {
            for (BorgRepoConfig repoConfig : this.configuration.getRepoConfigs()) {
                if (StringUtils.isNotBlank(repoConfig.getPassphrase())) {
                    log.info("Removing password command from config because password command is given: " + repoConfig.getPasswordCommand());
                    repoConfig.setPassphrase(null); // Don't use password (anymore) if password command is available.
                }
            }
        }
        String json = JsonUtils.toJson(configuration, true);
        try {
            if (configFile.exists()) {
                // Create backup-file first:
                SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd_HH-mm-ss'-'");
                File configBackupFile = new File(configBackupDir, formatter.format(new Date()) + CONFIG_FILENAME);
                log.info("Creating backup file first: '" + configBackupFile.getAbsolutePath() + "'");
                FileUtils.copyFile(configFile, configBackupFile);
            }
            log.info("Writing config file '" + configFile.getAbsolutePath() + "'");
            FileUtils.write(configFile, json, Definitions.STD_CHARSET);
        } catch (IOException ex) {
            log.error("Error while trying to write config file: " + configFile.getAbsolutePath() + ": " + ex.getMessage(), ex);
        }
    }
 
    private ConfigurationHandler() {
        this(null);
    }
 
    private ConfigurationHandler(String butlerHomeDir) {
        if (butlerHomeDir != null) {
            workingDir = new File(butlerHomeDir);
        } else {
            workingDir = new File(System.getProperty("user.home"), BUTLER_HOME_DIR);
        }
        log.info("Using directory '" + workingDir.getAbsolutePath() + "' as BorgButler's home directory.");
        if (!workingDir.exists()) {
            log.info("Creating borg-butlers working directory: " + workingDir.getAbsolutePath());
            workingDir.mkdirs();
        }
        configFile = new File(workingDir, CONFIG_FILENAME);
        configBackupDir = new File(workingDir, CONFIG_BACKUP_DIR);
        if (!configBackupDir.exists()) {
            log.info("Creating borg-butlers backup directory: " + configBackupDir.getAbsolutePath());
            configBackupDir.mkdirs();
        }
        read();
    }
 
    public File getConfigFile() {
        return this.configFile;
    }
 
    public File getWorkingDir() {
        return this.workingDir;
    }
}