Author: bpoussin Date: 2008-09-01 08:38:03 +0000 (Mon, 01 Sep 2008) New Revision: 1326 Added: trunk/isis-fish/src/java/fr/ifremer/isisfish/IsisConfig.java Log: - je ne comprend pas bien pourquoi il a ete supprime :( Added: trunk/isis-fish/src/java/fr/ifremer/isisfish/IsisConfig.java =================================================================== --- trunk/isis-fish/src/java/fr/ifremer/isisfish/IsisConfig.java (rev 0) +++ trunk/isis-fish/src/java/fr/ifremer/isisfish/IsisConfig.java 2008-09-01 08:38:03 UTC (rev 1326) @@ -0,0 +1,684 @@ +/* *##% + * Copyright (C) 2002-2008 Code Lutin, Benjamin Poussin + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + *##%*/ + +package fr.ifremer.isisfish; + +import static org.codelutin.i18n.I18nf._; + +import fr.ifremer.isisfish.actions.ExportAction; +import fr.ifremer.isisfish.actions.OtherAction; +import fr.ifremer.isisfish.actions.ImportAction; +import fr.ifremer.isisfish.actions.SimulationAction; +import fr.ifremer.isisfish.actions.VCSAction; +import fr.ifremer.isisfish.simulator.SimulationContext; +import fr.ifremer.isisfish.simulator.launcher.InProcessSimulatorLauncher; +import fr.ifremer.isisfish.simulator.launcher.SimulationService; +import fr.ifremer.isisfish.vcs.VCS; +import java.io.File; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLClassLoader; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import org.apache.commons.beanutils.ConvertUtils; +import org.apache.commons.lang.time.DurationFormatUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.codelutin.util.ApplicationConfig; +import org.codelutin.util.ArgumentsParserException; +import org.codelutin.util.StringUtil; +import org.codelutin.util.VersionNumber; + +/** + * + * @author poussin + * @version $Revision: 1310 $ + * + * Last update: $Date: 2008-08-23 00:46:00 +0200 (Sat, 23 Aug 2008) $ + * by : $Author: bpoussin $ + */ +public class IsisConfig extends ApplicationConfig { + + /** to use log facility, just put in your code: log.info(\"...\"); */ + static private Log log = LogFactory.getLog(IsisConfig.class); + + /** la version du logiciel constitue de l.d.a.r + * <li>l: le numero de version du logiciel + * <li>d: le numero de version du schema de la base de donnees + * <li>a: le numero de version de l'api des scripts + * <li>r: le numero de version de de l'interface graphique ou autre modif mineur + * <p> + * lors de l'increment de l, d, a et r sont remis a 0 + * lors de l'increment de d, a et r sont remis a 0 + * lors de l'increment de a, r est remis a 0 + * <p> + * Un changement d'UI ne modifie jamais le numero de version de database + * Un changement de schema de base pour lequel on ne peut pas faire de + * migration de donnees demande automatiquement un changement de version + * d'application. + */ + protected final static VersionNumber version = new VersionNumber(3, 2, 0, 0); + protected final static VersionNumber databaseVersion = new VersionNumber( + version.getNumber(0), version.getNumber(1)); + protected final static VersionNumber apiVersion = new VersionNumber( + version.getNumber(0), version.getNumber(1), version.getNumber(2)); + + public static VersionNumber getVersionNumber() { + return version; + } + + /** + * le nombre global ex: 3.2.0.0 + * @return + */ + static public String getVersion() { + String result = version.toString(); + return result; + } + + /** + * La version de la base ex: 3.2 + * @return + */ + public static VersionNumber getDatabaseVersion() { + return databaseVersion; + } + + /** + * La version de l'api de programmation ex: 3.2.0 + * @return + */ + public static VersionNumber getApiVersion() { + return apiVersion; + } + + static final public String COPYRIGHT_TEXT = "Version " + getVersion() + " IFREMER-MAERHA © 2000-2008"; + static final public String CONFIG_FILENAME = "isis-config-" + version.getNumber(0); + + /** separateur de liste */ + static final public String SEP = ","; + static final public String REPORT_EMAIL = "isis-fish-bugreport at lists.labs.libre-entreprise.org"; + + protected transient File backupSessionDirectory = null; + protected long startingTime = System.nanoTime(); + + public IsisConfig() { + + for (Option o : Option.values()) { + setDefaultOption(o.key, o.defaultValue); + } + + for (Action a : Action.values()) { + for (String alias : a.aliases) { + addActionAlias(alias, a.action); + } + } + + } + + ////////////////////////////////////////////////// + // Methode d'acces aux options + ////////////////////////////////////////////////// + + /** + * Retourne le repertoire racine de toutes les donnees (script, simulation + * region, ...) + * @return + */ + public File getDatabaseDirectory() { + File result = getOptionAsFile(Option.DATABASE_DIRECTORY.key); + return result; + } + + /** + * retourne le repertoire ou sont stockes les scripts compiles + * @return + */ + public File getCompileDirectory() { + File result = getOptionAsFile(Option.COMPILATION_DIRECTORY.key); + if (!result.exists()) { + result.mkdirs(); + } + return result; + } + + /** + * Retourne l'objet Local a utilise pour la langue + * @return + */ + public Locale getLocale() { + String value = getOption(Option.LOCALE.key); + Locale result = (Locale)ConvertUtils.convert(value, Locale.class); + return result; + } + + /** + * Retourne l'encoding a utiliser pour les fichiers textes + * @return + */ + public String getEncoding() { + String result = getOption(Option.ENCODING.key); + return result; + } + + /** + * Retourne le serveur SMTP a utiliser pour l'envoie de mail + * @return + */ + public String getSmtpServer() { + String result = getOption(Option.SMTP_SERVER.key); + return result; + } + + /** + * Retourne le nom usuel de l'utilisateur + * @return + */ + public String getUserName() { + String result = getOption(Option.USER_NAME.key); + return result; + } + + /** + * Retourne l'email de l'utilisateur + * @return + */ + public String getUserMail() { + String result = getOption(Option.USER_MAIL.key); + return result; + } + + /** + * Retourne l'url du serveur de simulation + * @return + */ + public String getSimulatorServer() { + String result = getOption(Option.SIMULATOR_SERVER.key); + return result; + } + + /** + * Retourne le login pour acceder au serveur de simulation + * @return + */ + public String getSimulatorUsername() { + String result = getOption(Option.SIMULATOR_USER_NAME.key); + return result; + } + + /** + * Retourne le mot de passe pour acceder au serveur de simulation + * @return + */ + public String getSimulatorPassword() { + String result = getOption(Option.SIMULATOR_PASSWORD.key); + return result; + } + + public String getSimulatorClassfile() { + String result = getOption(Option.SIMULATOR_CLASSFILE.key); + return result; + } + + public void setSimulatorClassfile(String value) { + setOption(Option.SIMULATOR_CLASSFILE.key, value); + } + + /** + * Le type de simulation par defaut a utiliser (local, remote, ...) + * @return + */ + public boolean isSimulatorLocal() { + String value = getOption(Option.SIMULATOR_LAUNCHER.key); + boolean result = "local".equalsIgnoreCase(value); + return result; + } + +// public boolean isUseVCS() { +// String value = getOption(Option.VCS_TYPE.key); +// boolean result = !VCSNone.TYPE_NONE.equals(value); +// return result; +// } + + public boolean isLaunchUI() { + boolean result = getOptionAsBoolean(Option.LAUNCH_UI.key); + return result; + } + + public void setSimulatorLauncher(String value) { + setOption(Option.SIMULATOR_LAUNCHER.key, value); + } + +// public boolean isSimulationShowOnlyQueue() { +// Boolean result = getOptionAsBoolean(Option.SIMULATION_SHOW_ONLY_QUEUE.key); +// return result; +// } + + public boolean isSimulationShowOnlyError() { + Boolean result = getOptionAsBoolean(Option.SIMULATION_SHOW_ONLY_ERROR.key); + return result; + } + + public File getDefaultExportDirectory() { + File result = getOptionAsFile(Option.DEFAULT_EXPORT_DIRECTORY.key); + if (!result.exists()) { + result.mkdirs(); + } + return result; + } + + public void setDefaultExportDirectory(String value) { + setOption(Option.DEFAULT_EXPORT_DIRECTORY.key, value); + } + + public String getDefaultExportNames() { + String result = getOption(Option.DEFAULT_EXPORT_NAMES.key); + return result; + } + + public void setDefaultExportNames(List<String> exportNames) { + StringBuilder sb = new StringBuilder(); + for (String exportName : exportNames) { + sb.append(SEP).append(exportName); + } + String value = sb.toString().substring(1); + setOption(Option.DEFAULT_EXPORT_NAMES.key, value); + saveForUser(); + } + + /** + * @return la liste des noms d'exports par defaut sous forme de liste, + * a partir de la propriete {@link Option#DEFAULT_EXPORT_NAMES} + * ou null si ils n'ont jamais ete sauves par l'utilisateur. + * by user. + * @see Option#DEFAULT_EXPORT_NAMES + */ + public List<String> getDefaultExportNamesAsList() { + List<String> result = null; + String exportNamesList = getDefaultExportNames(); + if (exportNamesList != null) { + result = new ArrayList<String>(); + String[] exportNames = StringUtil.split(exportNamesList, ","); + result.addAll(Arrays.asList(exportNames)); + } + return result; + } + + public String getDefaultMapFilename() { + String result = getOption(Option.DEFAULT_MAP_FILENAME.key); + return result; + } + + public String getDefaultResultNames() { + String result = getOption(Option.DEFAULT_RESULT_NAMES.key); + return result; + } + + public void setDefaultResultNames(List<String> resultNames) { + StringBuilder sb = new StringBuilder(); + for (String resultName : resultNames) { + sb.append(SEP).append(resultName); + } + String value = sb.toString().substring(1); + setOption(Option.DEFAULT_RESULT_NAMES.key, value); + saveForUser(); + } + + /** + * @return les resultats par defaut d'une simulation sous forme de liste + * a partir de la propriete {@link Option#DEFAULT_RESULT_NAMES} + * @see Option#DEFAULT_RESULT_NAMES + */ + public List<String> getDefaultResultNamesAsList() { + List<String> result = null; + String resultNamesList = getDefaultResultNames(); + if (resultNamesList != null) { + result = new ArrayList<String>(); + String[] resultNames = StringUtil.split(resultNamesList, ","); + result.addAll(Arrays.asList(resultNames)); + } + return result; + } + + public String getDefaultTagValue() { + String result = getOption(Option.DEFAULT_TAG_VALUE.key); + return result; + } + + public void setDefaultTagValues(Map<String, String> tagValues) { + StringBuilder sb = new StringBuilder(); + for (Map.Entry<String, String> entry : tagValues.entrySet()) { + sb.append(SEP).append('"').append(entry.getKey()).append("\":\"").append(entry.getValue()).append('"'); + } + String value = sb.toString().substring(1); + setOption(Option.DEFAULT_TAG_VALUE.key, value); + saveForUser(); + } + + + + /** + * @return le dictionnaire des tags par defaut d'une simulation a partir + * de la propriete {@link Option#DEFAULT_TAG_VALUE} + * @see Option#DEFAULT_TAG_VALUE_PROPERTY_KEY + */ + public Map<String, String> getDefaultTagValueAsMap() { + Map<String, String> result = new HashMap<String, String>(); + String tagValuesList = getDefaultTagValue(); + if (tagValuesList != null) { + String[] tagValues = StringUtil.split(tagValuesList, ","); + for (String tagValue : tagValues) { + String[] tagAndValue = StringUtil.split(tagValue, ":"); + + String tag = tagAndValue[0].trim(); + tag = tag.substring(1, tag.length() - 1); // remove "..." + + String value = tagAndValue[1].trim(); + value = value.substring(1, value.length() - 1); // remove "..." + + result.put(tag, value); + } + } + return result; + } + + public String getJavadocURL() { + String result = getOption(Option.JAVADOC_URL.key); + return result; + } + + public File getBackupDirectory() { + File result = getOptionAsFile(Option.BACKUP_DIRECTORY.key); + return result; + } + + public long getStartingTime() { + return startingTime; + } + + public String getElapsedTimeAsString() { + long diff = System.nanoTime() - getStartingTime(); + String result = DurationFormatUtils.formatDuration(diff / 1000000, "s'.'S"); + return result; + } + + public File getBackupSessionDirectory() { + if (backupSessionDirectory == null) { + // le timestamp est en nano (on le veut en ms) + long time = getStartingTime() / 1000; + // creation de l'unique répertoire de backup pour la session + String path = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss").format(new java.util.Date(time)); + backupSessionDirectory = new File(getBackupDirectory(), path); + if (!backupSessionDirectory.exists()) { + backupSessionDirectory.mkdirs(); + } + } + return backupSessionDirectory; + } + + /** + * Retourne un class loader contenant le repertoire de compilation + * Il permet alors de charger des classes qui viennent d'etre compilees + * dans isis + * If current thread is in simulation then return specific simulation + * compilation directory, else default compilation directory + * + * @return the class loader adequate + */ + public ClassLoader getScriptClassLoader() { + SimulationContext simContext = SimulationContext.get(); + ClassLoader result = simContext.getClassLoader(); + if (result == null) { + // on est pas dans une simulation, il faut retourner un nouveau + // a chaque fois. on force la creation d'un nouveau classloader + // a chaque fois pour + // que l'ancienne class compiler et charg<E9> ne soit pas presente + File f = getCompileDirectory(); + try { + URL[] cp = new URL[]{f.toURI().toURL()}; + // il faut prendre le ClassLoader du thread courant comme parent + // car pour les simulations il a ete modifi<E9>, et il faut + // que les classes de script soit recherch<E9> dedans avant + // la recherche dans le getCompileDirectory(). + // ce qui est le cas avec les URLClassLoader + ClassLoader parent = Thread.currentThread().getContextClassLoader(); + result = new URLClassLoader(cp, parent); + } catch (MalformedURLException eee) { + throw new IsisFishRuntimeException(_("isisfish.error.load.classloader", f, eee.getMessage()), eee); + } + } + return result; + } + + /** + * Surcharge pour la migration des options de config qui ont change de nom + * <p> + * TODO: lors du passage en version 4.0 on pourrait supprimer cette methode + * + * @param args + * @throws org.codelutin.util.ArgumentsParserException + */ + @Override + public void parse(String[] args) throws ArgumentsParserException { + super.parse(args); + // dans la version precedente (3.1) seul le fichier user existe, il est + // donc le seul a devoir etre modifie + boolean mustSave = false; + String[] keys = new String[]{ + "compileDirectory", Option.COMPILATION_DIRECTORY.key, + "defaultBackupDirectory", Option.BACKUP_DIRECTORY.key, + "defaultExportDirectory", Option.DEFAULT_EXPORT_DIRECTORY.key, + "defaultExportNames", Option.DEFAULT_EXPORT_NAMES.key, + "defaultMapFile", Option.DEFAULT_MAP_FILENAME.key, + "defaultResultNames", Option.DEFAULT_RESULT_NAMES.key, + "defaultSimulator", Option.SIMULATOR_CLASSFILE.key, + "defaultTagValue", Option.DEFAULT_TAG_VALUE.key, + "javadocURL", Option.JAVADOC_URL.key, + "locale", Option.LOCALE.key, + "login", Option.SIMULATOR_USER_NAME.key, + "password", Option.SIMULATOR_PASSWORD.key, + "simulationServer", Option.SIMULATOR_SERVER.key, + "simulationShowOnlyError", Option.SIMULATION_SHOW_ONLY_ERROR.key, + "simulationShowOnlyQueue", null, // Option.SIMULATION_SHOW_ONLY_QUEUE.key, + "smtpServer", Option.SMTP_SERVER.key, + "userMail", Option.USER_MAIL.key, + "userName", Option.USER_NAME.key, + "vcs.keyFile", Option.VCS_SSH_KEY_FILE.key, + "vcs.localDatabasePath", Option.DATABASE_DIRECTORY.key, + // on supprime car non compatible, les valeurs par defaut sont tres bien + "localSimulator", null, + "vcs.databaseVersion", null, + "vcs.hostName", null, + "vcs.noPassPhrase", null, + "vcs.remoteDatabase", null, + "vcs.remotePath", null, + "vcs.type", null, + "vcs.typeRepo", null, + "vcs.useSshConnexion", null, + "vcs.userName", null, + "version", null, + "projectName", null, + "simulationReportMail", null, + + }; + + log.info("Check configuration change"); + for(int i=0; i<keys.length;) { + String oldKey = keys[i++]; + String newKey = keys[i++]; + if (!oldKey.equals(newKey)) { + String value = getOption(oldKey); + if (value != null) { + mustSave = true; + // quoi qu'il arrive on enleve l'ancienne cle + homefile.remove(oldKey); + if (newKey != null) { + setOption(newKey, value); + } + } + } + } + if (mustSave) { + saveForUser(); + log.info("Config file migration done"); + } + if (log.isDebugEnabled()) { + printConfig(); + } + } + + ////////////////////////////////////////////////// + // Toutes les options disponibles + ////////////////////////////////////////////////// + + static public enum Option { + + COMPILATION_DIRECTORY("compilation.directory", _("isisfish.config.main.compileDirectory.description"), getUserHome() + File.separator + "isis-build"), + CONFIG_FILE(CONFIG_FILE_NAME, _("isisfish.config.main.configFileName.description"), CONFIG_FILENAME), + BACKUP_DIRECTORY("backup.directory", _("isisfish.config.main.defaultBackupDirectory.description"), getUserHome() + File.separator + "isis-backup"), + + DEFAULT_EXPORT_DIRECTORY("default.export.directory", _("isisfish.config.main.defaultExportDirectory.description"), getUserHome() + File.separator + "isis-export"), + DEFAULT_EXPORT_NAMES("default.export.names", _("isisfish.config.main.defaultExportNames.description"), ""), + DEFAULT_RESULT_NAMES("default.result.names", _("isisfish.config.main.defaultResultNames.description"), ""), + DEFAULT_MAP_FILENAME("default.map.filename", _("isisfish.config.main.defaultMapFile.description"), "maps/vmap_area_thin"), + DEFAULT_TAG_VALUE("default.tagvalue", _("isisfish.config.main.defaultTagValue.description"), ""), + ENCODING("encoding", _("isisfish.config.main.encoding.description"), "UTF-8"), + JAVADOC_URL("javadoc.url", _("isisfish.config.main.javadocURL.description"), "http://isis-fish.labs.libre-entreprise.org/apidocs/"), + + SIMULATOR_CLASSFILE("simulator.classfile", _("isisfish.config.main.defaultSimulator.description"), "DefaultSimulator.java"), + /** prevu pour l'architecture de lancement en plugin: local, isis-server, caparmor, ... */ + SIMULATOR_LAUNCHER(SimulationService.SIMULATION_LAUNCHER + ".localDefault", _("isisfish.config.main.localSimulator.description"), InProcessSimulatorLauncher.class.getName()), + + SIMULATOR_SERVER("simulation.server", _("isisfish.config.main.simulationServer.description"), "http://simulateur.ifremer.fr:9090"), + /** le login a utiliser pour les launcher distant, le type du launcher est ajouter a la cle (car 1 login par launcher) */ + SIMULATOR_USER_NAME("simulator.username", _("isisfish.config.main.login.description"), "anonymous"), + SIMULATOR_PASSWORD("simulator.password", _("isisfish.config.main.password.description"), "guest"), + + LOCALE("locale", _("isisfish.config.main.locale.description"), "fr_FR"), +// REGION_MAP("regionMap", _("isisfish.config.main.regionMap.description"), "maps"), +// RESULT_EXPORT("resultExport", String.class, 15, n_("isisfish.config.main.resultExport.description"), "resultExports"), + SIMULATION_SHOW_ONLY_ERROR("simulationShowOnlyError", _("isisfish.config.main.simulationShowOnlyError.description"), "false"), +// SIMULATION_SHOW_ONLY_QUEUE("simulationShowOnlyQueue", _("isisfish.config.main.simulationShowOnlyQueue.description"), "true"), + + // if false no graphical interface + LAUNCH_UI("launch.ui", _("isisfish.config.main.launchUI.description"), "true"), + + DATABASE_DIRECTORY("database.directory", _("isisfish.config.vcs.localDatabasePath.description"), getUserHome() + File.separator + "isis-database-3"), + + SSH_KEY_FILE("ssh.key.file", _("isisfish.config.vcs.keyFile.description"), getUserHome() + File.separator + ".ssh" + File.separator + "isis_rsa"), + SSH_PASSPHRASE_ENABLED("ssh.passphrase.enabled", _("isisfish.config.vcs.noPassPhrase.description"), "false"), + SSH_PASSPHRASE("ssh.passphrase", _("isisfish.config.vcs.passphrase.description"), ""), + + // can be None, CVS or SVN. only None or SVN work + VCS_TYPE(VCS.VCS_TYPE, _("isisfish.config.vcs.type.description"), VCS.TYPE_SVN), + // depend of VCS_TYPE, for SVN can be svn, svn+ssh, http or file + VCS_PROTOCOLE(VCS.VCS_PROTOCOLE, _("isisfish.config.vcs.useSshConnexion.description"), "svn"), + VCS_SSH_KEY_FILE(VCS.VCS_SSH_KEY_FILE, _("isisfish.config.vcs.keyFile.description"), getUserHome() + File.separator + ".ssh" + File.separator + "isis_rsa"), + // user login to access vcs + VCS_USER_NAME(VCS.VCS_USER_NAME, _("isisfish.config.vcs.userName.description"), ""), + VCS_USER_PASSWORD(VCS.VCS_USER_PASSWORD, _("isisfish.config.vcs.userPassword.description"), ""), + VCS_HOST_NAME(VCS.VCS_HOST_NAME, _("isisfish.config.vcs.hostName.description"), "labs.libre-entreprise.org"), + VCS_PATH(VCS.VCS_PATH, _("isisfish.config.vcs.remotePath.description"), "/svnroot/isis-fish-data"), +// VCS_TAG(VCS.VCS_TAG, _("isisfish.config.vcs.remoteDatabase.description"), "/trunk"), +// TYPE_REPO_PROPERTY_KEY = newConfigPropertyKey("typeRepo", VCSTypeRepo.class, 9, n_("isisfish.config.vcs.typeRepo.description"), "TAG"), +// PROJECT_NAME_PROPERTY_KEY = newConfigPropertyKey("projectName", String.class, 11, n_("isisfish.config.main.projectName.description"), "Isis-Fish"), + + USER_NAME("user.name", _("isisfish.config.main.userName.description"), System.getProperty("user.name")), + SMTP_SERVER("smtpServer", _("isisfish.config.main.smtpServer.description"), "smtp"), + USER_MAIL("userMail", _("isisfish.config.main.userMail.description"), USER_NAME.key + "@" + VCS_HOST_NAME.key), + + ; + + public final String key; + public final String description; + public final String defaultValue; + + private Option(String key, String description, String defaultValue) { + this.key = key; + this.description = description; + this.defaultValue = defaultValue; + } + } + + ////////////////////////////////////////////////// + // Toutes les actions disponibles + ////////////////////////////////////////////////// + + static public enum Step { + AfterInit, AfterInitVCS, AfterUI, BeforeExit + } + + static public enum Action { + HELP(_("Show help"), OtherAction.class.getName() + "#help", "-h", "--help"), + + IMPORT_ANALYSE_PLAN(_(""), ImportAction.class.getName() + "#importAnalysePlan", "--importAnalysePlan"), + IMPORT_EXPORT(_(""), ImportAction.class.getName() + "#importExport", "--importExport"), + IMPORT_RULE(_(""), ImportAction.class.getName() + "#importRule", "--importRule"), + IMPORT_SCRIPT(_("Import one java file script source"), ImportAction.class.getName() + "#importScript", "--importScript"), + IMPORT_SIMULATOR(_(""), ImportAction.class.getName() + "#importSimulator", "--importSimulator"), + IMPORT_FORMULA(_(""), ImportAction.class.getName() + "#importFormula", "--importFormula"), + IMPORT_REGION(_(""), ImportAction.class.getName() + "#importRegion", "--importRegion"), + IMPORT_REGION_AND_RENAME(_(""), ImportAction.class.getName() + "#importRegionAndRename", "--importRegionAndRename"), + IMPORT_SIMULATION(_(""), ImportAction.class.getName() + "#importSimulation", "--importSimulation"), + IMPORT_SCRIPT_MODULE(_("Import zipped file containing all scripts directory structure"), ImportAction.class.getName() + "#importScriptModule", "--importScriptModule"), + + LIST_ANALYSE_PLAN(_(""), ExportAction.class.getName() + "#listAnalysePlan", "--listAnalysePlan"), + LIST_EXPORT(_(""), ExportAction.class.getName() + "#listExport", "--listExport"), + LIST_RULE(_(""), ExportAction.class.getName() + "#listRule", "--listRule"), + LIST_SCRIPT(_(""), ExportAction.class.getName() + "#listScript", "--listScript"), + LIST_SIMULATOR(_(""), ExportAction.class.getName() + "#listSimulator", "--listSimulator"), + LIST_FORMULA(_(""), ExportAction.class.getName() + "#listFormula", "--listFormula"), + LIST_REGION(_(""), ExportAction.class.getName() + "#listRegion", "--listRegion"), + LIST_SIMULATION(_(""), ExportAction.class.getName() + "#listSimulation", "--listSimulation"), + + EXPORT_ANALYSE_PLAN(_(""), ExportAction.class.getName() + "#exportAnalysePlan", "--exportAnalysePlan"), + EXPORT_EXPORT(_(""), ExportAction.class.getName() + "#exportExport", "--exportExport"), + EXPORT_RULE(_(""), ExportAction.class.getName() + "#exportRule", "--exportRule"), + EXPORT_SCRIPT(_(""), ExportAction.class.getName() + "#exportScript", "--exportScript"), + EXPORT_SIMULATOR(_(""), ExportAction.class.getName() + "#exportSimulator", "--exportSimulator"), + EXPORT_FORMULA(_(""), ExportAction.class.getName() + "#exportFormula", "--exportFormula"), + EXPORT_REGION(_(""), ExportAction.class.getName() + "#exportRegion", "--exportRegion"), + EXPORT_SIMULATION(_(""), ExportAction.class.getName() + "#exportSimulation", "--exportSimulation"), + + VCS_SSH_CREATE_KEY(_(""), VCSAction.class.getName() + "#sshCreateKey", "--sshCreateKey"), + VCS_UPDATE(_(""), VCSAction.class.getName() + "#vcsUpdate", "--vcsUpdate"), + VCS_ADD(_(""), VCSAction.class.getName() + "#vcsAdd", "--vcsAdd"), + VCS_REMOVE(_(""), VCSAction.class.getName() + "#vcsRemove", "--vcsRemove"), + VCS_COMMIT(_(""), VCSAction.class.getName() + "#vcsCommit", "--vcsCommit"), + + SIMULATE_WITH_REGION(_(""), SimulationAction.class.getName() + "#simulateWithRegion", "--simulateWithRegion"), + SIMULATE_WITH_SIMULATION(_(""), SimulationAction.class.getName() + "#simulateWithSimulation", "--simulateWithSimulation"), + ; + + public String description; + public String action; + public String[] aliases; + + private Action(String description, String action, String ... aliases) { + this.description = description; + this.action = action; + this.aliases = aliases; + } + } +}