org.nuiton.util.ApplicationConfig Maven / Gradle / Ivy

* Returned Properties is {@link RecursiveProperties}. * * @param key the option's key * @return Properties object loaded with value pointed by file * @throws IOException if exception occured on read file */ public Properties getOptionAsProperties(String key) throws IOException { File file = getOptionAsFile(key); Properties prop = new RecursiveProperties(); FileReader reader = new FileReader(file); try { prop.load(reader); } finally { reader.close(); } return prop; } /** * Get option value as {@link URL}. * * @param key the option's key * @return value as URL */ public URL getOptionAsURL(String key) { URL result = getOption(URL.class, key); return result; } /** * Get option value as {@link Class}. * * @param key the option's key * @return value as Class */ public Class getOptionAsClass(String key) { Class result = getOption(Class.class, key); return result; } /** * Get option value as {@link Date}. * * @param key the option's key * @return value as Date */ public Date getOptionAsDate(String key) { Date result = getOption(Date.class, key); return result; } /** * Get option value as {@link Time}. * * @param key the option's key * @return value as Time */ public Time getOptionAsTime(String key) { Time result = getOption(Time.class, key); return result; } /** * Get option value as {@link Timestamp}. * * @param key the option's key * @return value as Timestamp */ public Timestamp getOptionAsTimestamp(String key) { Timestamp result = getOption(Timestamp.class, key); return result; } /** * Get option value as {@code int}. * * @param key the option's key * @return value as {@code int} */ public int getOptionAsInt(String key) { Integer result = getOption(Integer.class, key); if (result == null) { // primitive value can not be null result = 0; } return result; } /** * Get option value as {@code long}. * * @param key the option's key * @return value as {@code long} */ public long getOptionAsLong(String key) { Long result = getOption(Long.class, key); if (result == null) { // primitive value can not be null result = 0L; } return result; } /** * Get option value as {@code float}. * * @param key the option's key * @return value as {@code float} * @since 2.2 */ public float getOptionAsFloat(String key) { Float result = getOption(Float.class, key); if (result == null) { // primitive value can not be null result = 0f; } return result; } /** * Get option value as {@code double}. * * @param key the option's key * @return value as {@code double} */ public double getOptionAsDouble(String key) { Double result = getOption(Double.class, key); if (result == null) { // primitive value can not be null result = 0d; } return result; } /** * Get option value as {@code boolean}. * * @param key the option's key * @return value as {@code boolean}. */ public boolean getOptionAsBoolean(String key) { Boolean result = getOption(Boolean.class, key); if (result == null) { // primitive value can not be null result = false; } return result; } /** * Get option value as {@link Locale}. * * @param key the option's key * @return value as {@link Locale}. * @since 2.0 */ public Locale getOptionAsLocale(String key) { Locale result = getOption(Locale.class, key); return result; } /** * Get option value as {@link Version}. * * @param key the option's key * @return value as {@link Version}. * @since 2.0 */ public Version getOptionAsVersion(String key) { Version result = getOption(Version.class, key); return result; } /** * Get option value as {@link KeyStroke}. * * @param key the option's key * @return value as {@link KeyStroke}. * @since 2.5.1 */ public KeyStroke getOptionAsKeyStroke(String key) { KeyStroke result = getOption(KeyStroke.class, key); return result; } /** * Get all options from configuration. * * @return Properties which contains all options */ public Properties getOptions() { return options; } /** * Set manually options when you don't want to use parse method to check * properties file configured by {@link #setConfigFileName(String)}. * * @param options Properties which contains all options to set */ public void setOptions(Properties options) { this.options = options; } /** * Get all options as flat {@link Properties} object (replace inner options). * * @return flat Properties object * @since 1.2.2 */ public Properties getFlatOptions() { return getFlatOptions(true); } /** * Get all options as flat {@link Properties} object. * * @param replaceInner if {@code true} replace imbricated options by theirs values * @return flat Properties object * @since 1.2.2 */ public Properties getFlatOptions(boolean replaceInner) { Properties props = new Properties(); for (String propertyKey : options.stringPropertyNames()) { String propertyValue; if (replaceInner) { // replace ${xxx} option propertyValue = getOption(propertyKey); } else { // do not replace ${xxx} option propertyValue = options.getProperty(propertyKey); } props.setProperty(propertyKey, propertyValue); } return props; } /** * Install the {@link #saveUserAction} on givne {@code properties}. * * @param properties properties on which insalls the saveUserAction */ protected void installSaveUserAction(String... properties) { // pass in adjusting state setAdjusting(true); try { // ajout de tous les listeners pour sauver la configuration // lors de la modification des options de la configuration for (String propertyKey : properties) { // add a listener if (log.isDebugEnabled()) { log.debug("register saveUserAction on property [" + propertyKey + ']'); } addPropertyChangeListener(propertyKey, saveUserAction); } } finally { // ok back to normal adjusting state setAdjusting(false); } } /** * Get all set method on this object or super object. * * @return map with method name without set and in lower case as key, and * method as value */ protected Map getMethods() { // looking for all methods set on ApplicationConfig Method[] allMethods = getClass().getMethods(); Map methods = new HashMap(); for (Method m : allMethods) { String methodName = m.getName(); if (methodName.startsWith("set")) { methodName = methodName.substring(3).toLowerCase(); methods.put(methodName, m); } } return methods; } /** * Take required argument for method in args. Argument used is removed from * args. If method has varArgs, we take all argument to next '--' * * @param m the method to call * @param args iterator with many argument (equals or more than necessary * @return the arguments found for the given method */ protected String[] getParams(Method m, ListIterator args) { List result = new ArrayList(); if (m.isVarArgs()) { while (args.hasNext()) { String p = args.next(); if (p.startsWith("--")) { // stop search args.previous(); break; } else { result.add(p); args.remove(); } } } else { int paramLenght = m.getParameterTypes().length; for (int i = 0; i < paramLenght; i++) { String p = args.next(); args.remove(); // remove this arg because is used now result.add(p); } } return result.toArray(new String[result.size()]); } /** * Create action from string, string must be [package.][class][#][method] * if package, class or method missing, default is used * * @param name name of the action * @param args arguments for action invocation * @return the created action * @throws ArgumentsParserException if parsing failed * @throws IllegalAccessException if could not create action * @throws IllegalArgumentException if could not create action * @throws InstantiationException if could not create action * @throws InvocationTargetException if could not create action */ protected Action createAction(String name, ListIterator args) throws ArgumentsParserException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { Action result = null; List methods = ObjectUtil.getMethod(name, true); Class clazz = null; Method method = null; if (methods.size() > 0) { if (methods.size() > 1) { log.warn(String.format( "More than one method found, used the first: %s", methods)); } method = methods.get(0); clazz = method.getDeclaringClass(); } if (method != null) { // remove option from command line, because is used now args.remove(); // creation de l'object sur lequel on fera l'appel Object o = cacheAction.get(clazz); if (o == null && !Modifier.isStatic(method.getModifiers())) { try { o = ConstructorUtils.invokeConstructor(clazz, this); } catch (NoSuchMethodException eee) { log.debug(String.format( "Use default constructor, because no constructor" + " with Config parameter on class %s", clazz.getName())); o = clazz.newInstance(); } cacheAction.put(clazz, o); } // recherche du step de l'action int step = 0; Action.Step annotation = method.getAnnotation(Action.Step.class); if (annotation != null) { step = annotation.value(); } String[] params = getParams(method, args); result = new Action(step, o, method, params); } return result; } /** * Parse option and call set necessary method, read jvm, env variable, * Load configuration file and prepare Action. * * @param args argument as main(String[] args) * @return ApplicationConfig instance * @throws ArgumentsParserException if parsing failed */ public ApplicationConfig parse(String... args) throws ArgumentsParserException { if (args == null) { args = ArrayUtils.EMPTY_STRING_ARRAY; } try { Map methods = getMethods(); List arguments = new ArrayList(args.length); for (String arg : args) { if (aliases.containsKey(arg)) { arguments.addAll(aliases.get(arg)); } else { arguments.add(arg); } } // first parse option inParseOptionPhase = true; for (ListIterator i = arguments.listIterator(); i.hasNext(); ) { String arg = i.next(); if (arg.equals("--")) { // stop parsing break; } if (arg.startsWith("--")) { String optionName = arg.substring(2); if (methods.containsKey(optionName)) { i.remove(); // remove this arg because is used now Method m = methods.get(optionName); String[] params = getParams(m, i); if (log.isDebugEnabled()) { log.debug(String.format( "Set option '%s' with method '%s %s'", optionName, m, Arrays.toString(params))); } ObjectUtil.call(this, m, params); } } } inParseOptionPhase = false; // // second load options from all sources // // JVM jvm.putAll(System.getProperties()); // ENV env.putAll(System.getenv()); // classpath String filename = getConfigFileName(); Enumeration enumInClasspath = ClassLoader.getSystemClassLoader().getResources(filename); Set urlsInClasspath = new HashSet(EnumerationUtils.toList(enumInClasspath)); enumInClasspath = ApplicationConfig.class.getClassLoader().getResources(filename); urlsInClasspath.addAll(EnumerationUtils.toList(enumInClasspath)); if (log.isDebugEnabled() && urlsInClasspath.isEmpty()) { log.debug("No configuration file found in classpath : /" + filename); } /* TODO EC20100515 not sure if it's usefull :( if (urlsInClasspath.isEmpty()) { URL inClasspath = ApplicationConfig.class.getResource("/" + filename); if (inClasspath != null) { urlsInClasspath.add(inClasspath); } }*/ for (URL inClasspath : urlsInClasspath) { if (log.isInfoEnabled()) { log.info("Loading configuration file (classpath) : " + inClasspath); } loadResource(inClasspath.toURI(), classpath); } // system directory File etcConfig = getSystemConfigFile(); // File etcConfig = new File(getConfigPath(), filename); if (etcConfig.exists()) { if (log.isInfoEnabled()) { log.info("Loading configuration file (etc) : " + etcConfig); } loadResource(etcConfig.toURI(), etcfile); } else { if (log.isDebugEnabled()) { log.debug("No configuration file found in system : " + etcConfig.getAbsolutePath()); } } // user home directory File homeConfig = getUserConfigFile(); // File homeConfig = new File(getUserPath(), filename); if (log.isDebugEnabled()) { log.debug("User configuration file : " + homeConfig); } // don't use new File(String, String) File oldHomeConfig = new File(userPath + filename); // migration, if homeConfig doesn't exists and oldHomeConfig does if (!homeConfig.exists() && oldHomeConfig.exists()) { migrateUserConfigurationFile(oldHomeConfig, homeConfig); } // end of migration if (homeConfig.exists()) { if (log.isInfoEnabled()) { log.info("Loading configuration file (home) : " + homeConfig); } loadResource(homeConfig.toURI(), homefile); } else { if (log.isDebugEnabled()) { log.debug("No configuration file found in user home : " + homeConfig.getAbsolutePath()); } } // file $CURDIR/filename File config = new File(filename); if (config.exists()) { if (log.isInfoEnabled()) { log.info("Loading configuration file (curr) : " + config); } loadResource(config.toURI(), curfile); } else { if (log.isDebugEnabled()) { log.debug("No configuration file found in current" + " directory : " + config.getAbsolutePath()); } } // // third parse action and do action // for (ListIterator i = arguments.listIterator(); i.hasNext(); ) { String arg = i.next(); if (arg.equals("--")) { // stop parsing break; } if (arg.startsWith("--")) { String optionName = arg.substring(2); Action action = createAction(optionName, i); addAction(action); } } // // not used args added to unparsed // arguments.remove("--"); unparsed.addAll(arguments); } catch (Exception eee) { if (log.isErrorEnabled()) { log.error(eee); } throw new ArgumentsParserException("Can't parse argument", eee); } return this; } /** * Move old user configuration file {@code oldHomeConfig} to {@code * homeConfig}. * * @param oldHomeConfig old configuration file path * @param homeConfig new configuration file path * @throws IOException if could not move configuration file */ protected void migrateUserConfigurationFile(File oldHomeConfig, File homeConfig) throws IOException { if (log.isInfoEnabled()) { log.info(_("nuitonutil.config.moving.conf", oldHomeConfig.getPath(), homeConfig.getPath())); } boolean b = oldHomeConfig.renameTo(homeConfig); if (!b) { // could not move... String message = String.format( "could not move old configuration file %s to %s", oldHomeConfig, homeConfig ); throw new IOException(message); } } /** * Load a resources given by his {@code uri} to the given * {@code properties} argument. * * @param uri the uri to load * @param properties the properties file to load * @throws IOException if something occurs bad while loading resource * @see Properties#load(Reader) * @since 2.3 */ protected void loadResource(URI uri, Properties properties) throws IOException { InputStreamReader reader = new InputStreamReader(uri.toURL().openStream(), getEncoding()); try { properties.load(reader); } finally { reader.close(); } } /** * Save the given {@code properties} into the given {@code file} with * the given {@code comment}. * * @param file the location where to store the properties * @param properties the properties file to save * @param comment the comment to add in the saved file * @throws IOException if something occurs bad while saving resource * @see Properties#store(Writer, String) * @since 2.3 */ protected void saveResource(File file, Properties properties, String comment) throws IOException { Writer reader = new OutputStreamWriter(new FileOutputStream(file), getEncoding()); try { properties.store(reader, comment); } finally { reader.close(); } } /** For debugging. */ public void printConfig() { System.out.println("-------------------Value-------------------------"); printConfig(System.out); System.out.println("-------------------------------------------------"); } /** * Print out current configuration in specified output. * * @param output output to write config to * @since 1.1.4 */ public void printConfig(PrintStream output) { output.println("defaults " + defaults); output.println("classpath " + classpath); output.println("etcfile " + etcfile); output.println("homefile " + homefile); output.println("curfile " + curfile); output.println("env " + env); output.println("jvm " + jvm); output.println("line " + line); output.println("options " + options); } /** * Return all configuration used with value, that respect includePattern * * @param includePattern null for all value, or config key pattern (ex: "wikitty.*") * @param padding for better presentation, you can use padding to align '=' sign * @return string that represent config * @since 1.5.2 */ public String getPrintableConfig(String includePattern, int padding) { String msg = "Configuration:\n"; for (String key : getFlatOptions().stringPropertyNames()) { if (includePattern == null || "".equals(includePattern) || key.matches(includePattern)) { String value = getOption(key); msg += String.format("\t%" + padding + "s = %s\n", key, value); } } return msg; } protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) { pcs.firePropertyChange(propertyName, oldValue, newValue); } public void addPropertyChangeListener(PropertyChangeListener listener) { pcs.addPropertyChangeListener(listener); } public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) { pcs.addPropertyChangeListener(propertyName, listener); } public void removePropertyChangeListener(PropertyChangeListener listener) { pcs.removePropertyChangeListener(listener); } public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) { pcs.removePropertyChangeListener(propertyName, listener); } public boolean hasListeners(String propertyName) { return pcs.hasListeners(propertyName); } public PropertyChangeListener[] getPropertyChangeListeners( String propertyName) { return pcs.getPropertyChangeListeners(propertyName); } public PropertyChangeListener[] getPropertyChangeListeners() { return pcs.getPropertyChangeListeners(); } /////////////////////////////////////////////////////////////////////////// // // C L A S S E S D E C L A R A T I O N // /////////////////////////////////////////////////////////////////////////// /** * Action to save user configuration. *

* Add it as a listener of the configuration for a given property. *

* Note: Will not save if {@link #isAdjusting()} is {@code true}. * * @since 1.3 */ private final PropertyChangeListener saveUserAction = new PropertyChangeListener() { @Override public void propertyChange(PropertyChangeEvent evt) { if (isAdjusting()) { if (log.isDebugEnabled()) { log.debug("Skip save while adjusting"); } return; } if (log.isDebugEnabled()) { log.debug("Saving configuration fired by property [" + evt.getPropertyName() + "] at " + new Date()); } saveForUser(); } }; /** * Permet de masquer un prefix. Il est possible d'avoir des valeurs par * defaut. Par exemple: *

     * monOption=toto
     * monPrefix.monOption=titi
     * 

*