ConfigService.java
package ui.entities.config.service;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.persistence.EntityManager;
import jakarta.persistence.Persistence;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Root;
import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.JAXBException;
import jakarta.xml.bind.Marshaller;
import jakarta.xml.bind.Unmarshaller;
import libsidutils.IOUtils;
import ui.entities.DatabaseType;
import ui.entities.PersistenceProperties;
import ui.entities.config.Configuration;
import java.io.File;
import java.io.IOException;
import java.util.Optional;
import static libsidplay.config.IConfig.REQUIRED_CONFIG_VERSION;
/**
* Service of the configuration database.
*
* @author ken
*
*/
public class ConfigService {
/**
* Configuration types offered by JSIDPlay2
*
* @author ken
*
*/
public enum ConfigurationType {
/**
* Use JSON configuration files
*/
JSON(".json"),
/**
* Use XML configuration files
*/
XML(".xml"),
/**
* Use binary database files
*/
DATABASE("");
private final String fileExt;
ConfigurationType(String fileExt) {
this.fileExt = fileExt;
}
}
/**
* Filename of the jsidplay2 configuration file.
*/
public static final String CONFIG_FILE = "jsidplay2";
private EntityManager em;
private final ConfigurationType configurationType;
public ConfigService(ConfigurationType configurationType) {
this.configurationType = configurationType;
}
public Configuration load() {
final File configPath = getConfigPath();
switch (configurationType) {
case DATABASE:
em = Persistence
.createEntityManagerFactory(PersistenceProperties.CONFIG_DS,
new PersistenceProperties(DatabaseType.HSQL_FILE, "", "", configPath.getAbsolutePath()))
.createEntityManager();
return get(configPath);
case JSON:
em = Persistence
.createEntityManagerFactory(PersistenceProperties.CONFIG_DS,
new PersistenceProperties(DatabaseType.HSQL_MEM, "", "", CONFIG_FILE))
.createEntityManager();
return importJson(configPath);
case XML:
default:
em = Persistence
.createEntityManagerFactory(PersistenceProperties.CONFIG_DS,
new PersistenceProperties(DatabaseType.HSQL_MEM, "", "", CONFIG_FILE))
.createEntityManager();
return importXml(configPath);
}
}
public void save(Configuration configuration) {
save(configuration, getConfigPath());
}
private void save(Configuration configuration, final File configPath) {
switch (configurationType) {
case DATABASE:
persist(configuration);
break;
case JSON:
exportJson(configuration, configPath);
break;
case XML:
default:
exportXml(configuration, configPath);
break;
}
}
/**
* Get configuration database.
* <p>
* If absent or invalid, create a new one.
*
* @return configuration
*/
private Configuration get(File configPath) {
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Integer> q = cb.createQuery(Integer.class);
Root<Configuration> h = q.from(Configuration.class);
// Read only the version: old entities may have an incompatible schema.
q.select(h.get("sidplay2Section").get("version"));
Optional<Integer> version = em.createQuery(q).getResultList().stream().findFirst();
if (version.isPresent() && version.get() == REQUIRED_CONFIG_VERSION) {
return em.createQuery("from Configuration", Configuration.class).setMaxResults(1).getSingleResult();
}
em.clear();
var schema = em.getEntityManagerFactory().getSchemaManager();
schema.drop(false);
schema.create(false);
return create();
}
/**
* Create a new configuration and persist into the database.
*
* @return newly created configuration
*/
private Configuration create() {
Configuration configuration = new Configuration();
configuration.getSidplay2Section().setVersion(REQUIRED_CONFIG_VERSION);
persist(configuration);
return configuration;
}
/**
* Persist configuration database.
*
* @param config configuration to persist
*/
private void persist(Configuration config) {
try {
em.getTransaction().begin();
em.persist(config);
em.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
if (em.getTransaction().isActive()) {
em.getTransaction().rollback();
}
}
}
/**
* Close configuration database.
*/
public void close() {
em.close();
}
/**
* Import configuration database from an XML file.
* <p>
* If absent or invalid, create a new one.
*
* @param file XML file to import
* @return imported configuration
*/
private Configuration importXml(File file) {
if (file.exists()) {
try {
JAXBContext jaxbContext = JAXBContext.newInstance(Configuration.class);
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
Object obj = unmarshaller.unmarshal(file);
if (obj instanceof Configuration) {
Configuration detachedConfig = (Configuration) obj;
// configuration version check
if (detachedConfig.getSidplay2Section().getVersion() == REQUIRED_CONFIG_VERSION) {
Configuration mergedConfig = em.merge(detachedConfig);
persist(mergedConfig);
return mergedConfig;
}
createBackup(detachedConfig, file);
}
} catch (JAXBException e) {
System.err.println(e.getMessage());
}
}
return create();
}
/**
* Import configuration database from an JSON file.
* <p>
* If absent or invalid, create a new one.
*
* @param file JSON file to import
* @return imported configuration
*/
private Configuration importJson(final File file) {
if (file.exists()) {
try {
final ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
Configuration detachedConfig = objectMapper.readValue(file, Configuration.class);
// configuration version check
if (detachedConfig.getSidplay2Section().getVersion() == REQUIRED_CONFIG_VERSION) {
Configuration mergedConfig = em.merge(detachedConfig);
persist(mergedConfig);
return mergedConfig;
}
createBackup(detachedConfig, file);
} catch (IOException e) {
System.err.println(e.getMessage());
}
} else {
// migration XML to JSON
File fileAsXml = new File(IOUtils.getFilenameWithoutSuffix(file.getAbsolutePath()) + ".xml");
if (fileAsXml.exists()) {
return importXml(fileAsXml);
}
}
return create();
}
/**
* Export configuration database into an XML file.
*
* @param configuration configuration to export
* @param file target file of the export
*/
private void exportXml(Configuration configuration, File file) {
try {
JAXBContext jaxbContext = JAXBContext.newInstance(Configuration.class);
Marshaller marshaller = jaxbContext.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
marshaller.marshal(configuration, file);
} catch (JAXBException e) {
e.printStackTrace();
}
}
/**
* Export configuration database into an JSON file.
*
* @param configuration configuration to export
* @param file target file of the export
*/
private void exportJson(Configuration configuration, File file) {
try {
new ObjectMapper().writerWithDefaultPrettyPrinter().writeValue(file, configuration);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* Search for the configuration. Search in CWD and in the HOME folder.
*
* @return XML configuration file
*/
private File getConfigPath() {
for (final String s : new String[]{System.getProperty("user.dir"), System.getProperty("user.home"),}) {
File configPlace = new File(s, CONFIG_FILE + configurationType.fileExt);
if (configPlace.exists()) {
return configPlace;
}
}
// default directory
return new File(System.getProperty("user.home"), CONFIG_FILE + configurationType.fileExt);
}
/**
* Create a backup of the current configuration.
*
* @param configuration configuration to backup
* @param configPath backup filename without .bak
*/
private void createBackup(Configuration configuration, File configPath) {
File bakFile = new File(configPath.getParentFile(), configPath.getName() + ".bak");
save(configuration, bakFile);
int currentVersion = configuration.getSidplay2Section().getVersion();
System.out.println("Configuration file version=" + currentVersion + " is older than expected version="
+ REQUIRED_CONFIG_VERSION + ", a backup has been created: " + bakFile);
}
}