aboutsummaryrefslogtreecommitdiff
path: root/pdf-as-lib/src
diff options
context:
space:
mode:
Diffstat (limited to 'pdf-as-lib/src')
-rw-r--r--pdf-as-lib/src/main/java/at/gv/egiz/pdfas/lib/settings/Settings.java468
1 files changed, 468 insertions, 0 deletions
diff --git a/pdf-as-lib/src/main/java/at/gv/egiz/pdfas/lib/settings/Settings.java b/pdf-as-lib/src/main/java/at/gv/egiz/pdfas/lib/settings/Settings.java
new file mode 100644
index 00000000..0dc36fd2
--- /dev/null
+++ b/pdf-as-lib/src/main/java/at/gv/egiz/pdfas/lib/settings/Settings.java
@@ -0,0 +1,468 @@
+/*******************************************************************************
+ * <copyright> Copyright 2014 by E-Government Innovation Center EGIZ, Graz, Austria </copyright>
+ * PDF-AS has been contracted by the E-Government Innovation Center EGIZ, a
+ * joint initiative of the Federal Chancellery Austria and Graz University of
+ * Technology.
+ * <p>
+ * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by
+ * the European Commission - subsequent versions of the EUPL (the "Licence");
+ * You may not use this work except in compliance with the Licence.
+ * You may obtain a copy of the Licence at:
+ * http://www.osor.eu/eupl/
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the Licence is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the Licence for the specific language governing permissions and
+ * limitations under the Licence.
+ * <p>
+ * This product combines work with different licenses. See the "NOTICE" text
+ * file for details on the various modules and licenses.
+ * The "NOTICE" text file is part of the distribution. Any derivative works
+ * that you distribute must include a readable copy of the "NOTICE" text file.
+ ******************************************************************************/
+package at.gv.egiz.pdfas.common.settings;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Properties;
+import java.util.Vector;
+
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.IOCase;
+import org.apache.commons.io.filefilter.WildcardFileFilter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import at.gv.egiz.pdfas.common.exceptions.PdfAsSettingsException;
+
+public class Settings implements ISettings, IProfileConstants {
+
+ private static final Logger logger = LoggerFactory
+ .getLogger(Settings.class);
+
+ protected Properties properties = new Properties();
+
+ protected File workDirectory;
+
+ public Settings(File workDirectory) {
+ try {
+ this.workDirectory = workDirectory;
+ loadSettings(workDirectory);
+ } catch (PdfAsSettingsException e) {
+ logger.error(e.getMessage(), e);
+ }
+ }
+
+ private void loadSettingsRecursive(File workDirectory, File file)
+ throws PdfAsSettingsException {
+ try {
+ String configDir = workDirectory.getAbsolutePath() + File.separator
+ + CFG_DIR;
+ Properties tmpProps = new Properties();
+ logger.debug("Loading: " + file.getName());
+ tmpProps.load(new FileInputStream(file));
+
+ properties.putAll(tmpProps);
+
+ Map<String, String> includes = this.getValuesPrefix(INCLUDE,
+ tmpProps);
+ File contextFolder = new File(configDir);
+ if (includes != null) {
+ Iterator<String> includeIterator = includes.values().iterator();
+ while (includeIterator.hasNext()) {
+ contextFolder = new File(configDir);
+ String includeFileName = includeIterator.next();
+
+ File includeInstruction = new File(contextFolder,
+ includeFileName);
+ contextFolder = includeInstruction.getParentFile();
+ String includeName = includeInstruction.getName();
+
+ WildcardFileFilter fileFilter = new WildcardFileFilter(
+ includeName, IOCase.SENSITIVE);
+ Collection<File> includeFiles = null;
+
+ if (contextFolder != null && contextFolder.exists()
+ && contextFolder.isDirectory()) {
+ includeFiles = FileUtils.listFiles(contextFolder,
+ fileFilter, null);
+ }
+ if (includeFiles != null && !includeFiles.isEmpty()) {
+ logger.debug("Including '" + includeFileName + "'.");
+ for (File includeFile : includeFiles) {
+ loadSettingsRecursive(workDirectory, includeFile);
+ }
+ }
+ }
+ }
+
+ } catch (IOException e) {
+ throw new PdfAsSettingsException("Failed to read settings!", e);
+ }
+ }
+
+ private void showAugments(Profiles profiles) {
+ if (!profiles.getAugments().isEmpty()) {
+ logger.debug("\tAugments for {}", profiles.getName());
+ for (int i = 0; i < profiles.getAugments().size(); i++) {
+ logger.debug("\t\t{}", profiles.getAugments().get(i).getName());
+ }
+ }
+ }
+
+ private boolean isAugmentsReady(Profiles profiles) {
+ Iterator<Profiles> augmentingProfiles = profiles.getAugments().iterator();
+ boolean allInitialized = true;
+ while (augmentingProfiles.hasNext()) {
+ if (!augmentingProfiles.next().isInitialized()) {
+ allInitialized = false;
+ }
+ }
+ return allInitialized;
+ }
+
+ private boolean isParentReady(Profiles profiles) {
+ if (profiles.getParent() != null) {
+ return profiles.getParent().isInitialized();
+ } else {
+ return false;
+ }
+ }
+
+ private void performAugmentConfiguration(Profiles profiles) {
+ Iterator<Profiles> augmentingProfiles = profiles.getAugments().iterator();
+
+ String childBase = "sig_obj."
+ + profiles.getName();
+
+ while (augmentingProfiles.hasNext()) {
+ Profiles augmentingProfile = augmentingProfiles.next();
+ String augmentingBase = "sig_obj." + augmentingProfile.getName();
+
+ Iterator<String> augmentingKeyIt = this.getKeys(
+ augmentingBase + ".").iterator();
+
+ while (augmentingKeyIt.hasNext()) {
+ String key = augmentingKeyIt.next();
+ String keyToCopy = key.substring(augmentingBase
+ .length());
+ //logger.debug("Profile: {} => {}",
+ // key, childBase+keyToCopy);
+ String sourceKey = augmentingBase + keyToCopy;
+ String targetKey = childBase + keyToCopy;
+
+ if (!this.hasValue(targetKey)) {
+ properties.setProperty(targetKey,
+ this.getValue(sourceKey));
+ //logger.debug("Replaced: {} with Value from {}",
+ // childBase+keyToCopy, parentBase+keyToCopy);
+ } else {
+ //logger.debug("NOT Replaced: {} with Value from {}",
+ // childBase+keyToCopy, parentBase+keyToCopy);
+ }
+ }
+ }
+ }
+
+ private void performParentConfiguration(Profiles profiles) {
+ if (profiles.getParent() != null) {
+ // If Parent is initialized Copy Properties from Parent
+ // to this profile
+ String parentBase = "sig_obj." + profiles.getParent().getName();
+ String childBase = "sig_obj."
+ + profiles.getName();
+
+ Iterator<String> parentKeyIt = this.getKeys(
+ parentBase + ".").iterator();
+ while (parentKeyIt.hasNext()) {
+ String key = parentKeyIt.next();
+ String keyToCopy = key.substring(parentBase
+ .length());
+ //logger.debug("Profile: {} => {}",
+ // key, childBase+keyToCopy);
+ String sourceKey = parentBase + keyToCopy;
+ String targetKey = childBase + keyToCopy;
+
+ if (!this.hasValue(targetKey)) {
+ properties.setProperty(targetKey,
+ this.getValue(sourceKey));
+ //logger.debug("Replaced: {} with Value from {}",
+ // childBase+keyToCopy, parentBase+keyToCopy);
+ } else {
+ //logger.debug("NOT Replaced: {} with Value from {}",
+ // childBase+keyToCopy, parentBase+keyToCopy);
+ }
+ }
+ }
+ }
+
+ private void buildProfiles() {
+ Map<String, Profiles> profiles = new HashMap<String, Profiles>();
+
+ Iterator<String> itKeys = this.getFirstLevelKeys("sig_obj.types.")
+ .iterator();
+ while (itKeys.hasNext()) {
+ String key = itKeys.next();
+ String profile = key.substring("sig_obj.types.".length());
+ //System.out.println("[" + profile + "]: " + this.getValue(key));
+ if (this.getValue(key).equals("on")) {
+ Profiles prof = new Profiles(profile);
+ profiles.put(profile, prof);
+ }
+ }
+
+ // Initialize Parent Structure ...
+ Iterator<Entry<String, Profiles>> profileIterator = profiles.entrySet()
+ .iterator();
+ while (profileIterator.hasNext()) {
+ Entry<String, Profiles> entry = profileIterator.next();
+ entry.getValue().findParent(properties, profiles);
+ }
+
+ // Debug Output
+ Iterator<Entry<String, Profiles>> profileIteratorDbg = profiles.entrySet()
+ .iterator();
+ while (profileIteratorDbg.hasNext()) {
+ Entry<String, Profiles> entry = profileIteratorDbg.next();
+ if (entry.getValue().getParent() == null) {
+ logger.debug("Got Profile: [{}] : {}", entry.getKey(), entry.getValue().getName());
+ showAugments(entry.getValue());
+ } else {
+ logger.debug("Got Profile: [{}] : {} (Parent {})", entry.getKey(),
+ entry.getValue().getName(), entry.getValue().getParent().getName());
+ showAugments(entry.getValue());
+ }
+ }
+
+ logger.debug("Configured Settings: {}",
+ properties.size());
+
+ // Resolve Parent Structures ...
+ while (!profiles.isEmpty()) {
+ List<String> removes = new ArrayList<String>();
+ Iterator<Entry<String, Profiles>> profileIt = profiles.entrySet()
+ .iterator();
+ while (profileIt.hasNext()) {
+ Entry<String, Profiles> entry = profileIt.next();
+
+ // Remove all base Profiles ...
+ if (entry.getValue().getParent() == null && entry.getValue().getAugments().isEmpty()) {
+ // Has neither parent or augmenting profiles
+
+ entry.getValue().setInitialized(true);
+ removes.add(entry.getKey());
+ } else if (entry.getValue().getParent() == null) {
+ // Has augmenting profiles but no parent
+
+ // check if all augmenting profiles are initialized if so
+ // add them
+
+ Profiles profile = entry.getValue();
+ if (this.isAugmentsReady(profile)) {
+ this.performAugmentConfiguration(profile);
+ // Copy done
+ entry.getValue().setInitialized(true);
+ removes.add(entry.getKey());
+ } else {
+ logger.debug("Not all augmenting profiles are ready yet for {}", entry.getValue().getName());
+ }
+ } else if (entry.getValue().getAugments().isEmpty()) {
+
+ // Has parent but no augmenting profiles
+ Profiles profile = entry.getValue();
+
+ if (this.isParentReady(profile)) {
+ this.performParentConfiguration(profile);
+ // Copy done
+ entry.getValue().setInitialized(true);
+ removes.add(entry.getKey());
+ }
+ } else {
+
+ // Has parent and augmenting profiles
+
+ Profiles profile = entry.getValue();
+ if (this.isAugmentsReady(profile) && this.isParentReady(profile)) {
+ // order is curcial, augments preceed over parent configuration
+ this.performAugmentConfiguration(profile);
+ this.performParentConfiguration(profile);
+
+ // Copy done
+ entry.getValue().setInitialized(true);
+ removes.add(entry.getKey());
+ }
+ }
+ }
+
+ // Remove all Profiles from Remove List
+
+ if (removes.isEmpty() && !profiles.isEmpty()) {
+ logger.error("Failed to build inheritant Profiles, running in infinite loop! (aborting ...)");
+ logger.error("Profiles that cannot be resolved completly:");
+ Iterator<Entry<String, Profiles>> failedProfiles = profiles.entrySet().iterator();
+ while (failedProfiles.hasNext()) {
+ Entry<String, Profiles> entry = failedProfiles.next();
+ logger.error("Problem Profile: [{}] : {}", entry.getKey(), entry.getValue().getName());
+ }
+ return;
+ }
+
+ Iterator<String> removeIt = removes.iterator();
+ while (removeIt.hasNext()) {
+ profiles.remove(removeIt.next());
+ }
+ }
+
+ logger.debug("Derived Settings: {}",
+ properties.size());
+
+ }
+
+ public void debugDumpProfileSettings(String profileName) {
+ Iterator<String> keysIterator = this.getKeys("sig_obj." + profileName + ".").iterator();
+
+ logger.debug("Configuration for {}", profileName);
+ while(keysIterator.hasNext()) {
+ String key = keysIterator.next();
+ logger.debug(" {}: {}", key, this.getValue(key));
+ }
+ }
+
+ public void loadSettings(File workDirectory) throws PdfAsSettingsException {
+ // try {
+ String configDir = workDirectory.getAbsolutePath() + File.separator
+ + CFG_DIR;
+ String configFile = configDir + File.separator + CFG_FILE;
+ loadSettingsRecursive(workDirectory, new File(configFile));
+ buildProfiles();
+ /*
+ * logger.debug("Loading cfg file: " + configFile);
+ *
+ *
+ * properties.load(new FileInputStream(configFile));
+ *
+ * Map<String, String> includes = this.getValuesPrefix(INCLUDE); File
+ * contextFolder = new File(configDir); if (includes != null) {
+ * Iterator<String> includeIterator = includes.values().iterator();
+ * while (includeIterator.hasNext()) { String includeFileName =
+ * includeIterator.next(); if (includeFileName.contains("*")) {
+ * WildcardFileFilter fileFilter = new WildcardFileFilter(
+ * includeFileName, IOCase.SENSITIVE); Collection<File> includeFiles =
+ * null;
+ *
+ * if (contextFolder != null && contextFolder.exists() &&
+ * contextFolder.isDirectory()) { includeFiles =
+ * FileUtils.listFiles(contextFolder, fileFilter, null); } if
+ * (includeFiles != null && !includeFiles.isEmpty()) {
+ * logger.info("Including '" + includeFileName + "'."); for (File
+ * includeFile : includeFiles) { properties .load(new
+ * FileInputStream(includeFile)); } } } else { String includeFile =
+ * configDir + File.separator + includeFileName;
+ * logger.debug("Loading included cfg file: " + includeFile); try {
+ * properties.load(new FileInputStream(includeFile)); } catch (Throwable
+ * e) { logger.error("Failed to load cfg file " + includeFile, e); } } }
+ * }
+ */
+ // logger.debug("Configured Properties:");
+ /*
+ * if(logger.isDebugEnabled()) { properties.list(System.out); }
+ */
+
+ // } catch (IOException e) {
+ // throw new PdfAsSettingsException("Failed to read settings!", e);
+ // }
+ }
+
+ public String getValue(String key) {
+ return properties.getProperty(key);
+ }
+
+ public boolean hasValue(String key) {
+ return properties.containsKey(key);
+ }
+
+ private Map<String, String> getValuesPrefix(String prefix, Properties props) {
+ Iterator<Object> keyIterator = props.keySet().iterator();
+ Map<String, String> valueMap = new HashMap<String, String>();
+ while (keyIterator.hasNext()) {
+ String key = keyIterator.next().toString();
+
+ if (key.startsWith(prefix)) {
+ valueMap.put(key, props.getProperty(key));
+ }
+ }
+
+ if (valueMap.isEmpty()) {
+ return null;
+ }
+
+ return valueMap;
+ }
+
+ public Map<String, String> getValuesPrefix(String prefix) {
+ return getValuesPrefix(prefix, properties);
+ }
+
+ public Vector<String> getKeys(String prefix) {
+ Iterator<Object> keyIterator = properties.keySet().iterator();
+ Vector<String> valueMap = new Vector<String>();
+ while (keyIterator.hasNext()) {
+ String key = keyIterator.next().toString();
+
+ if (key.startsWith(prefix)) {
+ valueMap.add(key);
+ }
+ }
+ return valueMap;
+ }
+
+ public Vector<String> getFirstLevelKeys(String prefix) {
+ String mPrefix = prefix.endsWith(".") ? prefix : prefix + ".";
+ Iterator<Object> keyIterator = properties.keySet().iterator();
+ Vector<String> valueMap = new Vector<String>();
+ while (keyIterator.hasNext()) {
+ String key = keyIterator.next().toString();
+
+ if (key.startsWith(prefix)) {
+ int keyIdx = key.indexOf('.', mPrefix.length()) > 0 ? key
+ .indexOf('.', mPrefix.length()) : key.length();
+ String firstLevels = key.substring(0, keyIdx);
+ if (!valueMap.contains(firstLevels)) {
+ valueMap.add(firstLevels);
+ }
+ }
+ }
+
+ if (valueMap.isEmpty()) {
+ return null;
+ }
+
+ return valueMap;
+ }
+
+ public boolean hasPrefix(String prefix) {
+ Iterator<Object> keyIterator = properties.keySet().iterator();
+ while (keyIterator.hasNext()) {
+ String key = keyIterator.next().toString();
+
+ if (key.startsWith(prefix)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public String getWorkingDirectory() {
+ return this.workDirectory.getAbsolutePath();
+ }
+
+}