WebSVN - OpenConcerto - Diff - Rev 20 and 25 - /trunk/OpenConcerto/src/org/openconcerto/erp/modules/ModuleManager.java

 import org.openconcerto.erp.config.MainFrame;
 import org.openconcerto.sql.Configuration;
 import org.openconcerto.sql.element.SQLElement;
 import org.openconcerto.sql.element.SQLElementDirectory;
+import org.openconcerto.sql.model.ConnectionHandlerNoSetup;
 import org.openconcerto.sql.model.DBFileCache;
 import org.openconcerto.sql.model.DBItemFileCache;
 import org.openconcerto.sql.model.DBRoot;
+import org.openconcerto.sql.model.SQLDataSource;
 import org.openconcerto.sql.model.SQLField;
 import org.openconcerto.sql.model.SQLName;
 import org.openconcerto.sql.model.SQLRow;
 import org.openconcerto.sql.model.SQLRowListRSH;
 import org.openconcerto.sql.model.SQLRowValues;
 import org.openconcerto.sql.model.SQLSelect;
 import org.openconcerto.sql.model.SQLSyntax;
+import org.openconcerto.sql.model.SQLSystem;
 import org.openconcerto.sql.model.SQLTable;
 import org.openconcerto.sql.model.Where;
 import org.openconcerto.sql.model.graph.DirectedEdge;
 import org.openconcerto.sql.utils.AlterTable;
 import org.openconcerto.sql.utils.ChangeTable;
 import org.openconcerto.sql.utils.DropTable;
 import org.openconcerto.sql.utils.SQLCreateTable;
 import org.openconcerto.sql.utils.SQLUtils;
 import org.openconcerto.sql.utils.SQLUtils.SQLFactory;
 import org.openconcerto.sql.view.list.RowAction;
-import org.openconcerto.task.config.ComptaBasePropsConfiguration;
 import org.openconcerto.utils.CollectionUtils;
 import org.openconcerto.utils.ExceptionHandler;
+import org.openconcerto.utils.FileUtils;
 import org.openconcerto.utils.StringUtils;
 import org.openconcerto.utils.Tuple2;
 import org.openconcerto.utils.cc.IClosure;
 import org.openconcerto.utils.cc.IdentityHashSet;
+import org.openconcerto.utils.cc.IdentitySet;
 import java.io.File;
 import java.io.FileFilter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 import java.util.Map.Entry;
+import java.util.Set;
 import java.util.logging.Logger;
-import java.util.prefs.BackingStoreException;
 import java.util.prefs.Preferences;
 import javax.swing.JMenuItem;
 import javax.swing.SwingUtilities;
 public class ModuleManager {
     private static final Logger L = Logger.getLogger(ModuleManager.class.getPackage().getName());
     private static final int MIN_VERSION = 0;
-    private static final int NO_VERSION = MIN_VERSION - 1;
     private static final String MODULE_COLNAME = "MODULE_NAME";
     private static final String MODULE_VERSION_COLNAME = "MODULE_VERSION";
     private static final String TABLE_COLNAME = "TABLE";
     private static final String FIELD_COLNAME = "FIELD";
     private static final String ISKEY_COLNAME = "KEY";
     private final Map<String, AbstractModule> runningModules;
     private final Map<String, Collection<SQLElement>> modulesElements;
     private final Map<String, ComponentsContext> modulesComponents;
     private final DirectedGraph<ModuleFactory, DirectedEdge<ModuleFactory>> dependencyGraph;
+    private DBRoot root;
+    private Configuration conf;
     public ModuleManager() {
         this.factories = new HashMap<String, ModuleFactory>();
         this.runningModules = new HashMap<String, AbstractModule>();
         this.dependencyGraph = new SimpleDirectedGraph<ModuleFactory, DirectedEdge<ModuleFactory>>(new EdgeFactory<ModuleFactory, DirectedEdge<ModuleFactory>>() {
             @Override
                 return new DirectedEdge<ModuleFactory>(sourceVertex, targetVertex);
+            }
         });
         this.modulesElements = new HashMap<String, Collection<SQLElement>>();
         this.modulesComponents = new HashMap<String, ComponentsContext>();
+        this.root = null;
+        this.conf = null;
+    }
     // *** factories (thread-safe)
     public final int addFactories(final File dir) {
         if (!dir.exists()) {
-            System.err.println("Warning: module factory directory not found: " + dir.getAbsolutePath());
+            L.warning("Module factory directory not found: " + dir.getAbsolutePath());
             return 0;
+        }
         final File[] jars = dir.listFiles(new FileFilter() {
             @Override
             public boolean accept(File f) {
             for (final File jar : jars) {
                 try {
                     this.addFactory(new JarModuleFactory(jar));
                     i++;
                 } catch (Exception e) {
-                    System.err.println("Couldn't add " + jar);
+                    L.warning("Couldn't add " + jar);
                     e.printStackTrace();
+                }
+            }
+        }
         return i;
         return this.addFactory(f, true, persistent);
+    }
     private final String addFactory(final ModuleFactory f, final boolean start, final boolean persistent) {
         synchronized (this.factories) {
-            this.factories.put(f.getID(), f);
+            final ModuleFactory prev = this.factories.put(f.getID(), f);
+            if (prev != null)
+                L.info("Changing the factory for " + f.getID() + "\nfrom\t" + prev + "\nto\t" + f);
+        }
         if (start)
             this.invoke(new IClosure<ModuleManager>() {
                 @Override
                 public void executeChecked(ModuleManager input) {
             });
         return f.getID();
+    }
     public final Map<String, ModuleFactory> getFactories() {
+        synchronized (this.factories) {
-        return Collections.unmodifiableMap(this.factories);
+            return new HashMap<String, ModuleFactory>(this.factories);
+        }
+    }
     private ModuleFactory getFactory(final String id) {
+        final ModuleFactory res;
+        synchronized (this.factories) {
-        final ModuleFactory res = this.factories.get(id);
+            res = this.factories.get(id);
+        }
         if (res == null)
             throw new IllegalArgumentException("No factory for " + id);
         return res;
+    }
+    }
     // *** modules (in EDT)
     /**
-     * Call the passed closure at a time when modules can be started. In particular the
+     * Call the passed closure at a time when modules can be started. In particular this manager has
-     * {@link MainFrame#getInstance() main frame} has been created.
+     * been set up and the {@link MainFrame#getInstance() main frame} has been created.
+     *
+     * @param c the closure to execute.
      */
     public void invoke(final IClosure<ModuleManager> c) {
         MainFrame.invoke(new Runnable() {
             @Override
             public void run() {
     // call registerSQLElements() for any installed modules that might need it
     // (e.g. if a module created a child table, as long as the table is in the database it needs to
     // be archived along its parent)
     private void registerRequiredModules() throws Exception {
-        assert SwingUtilities.isEventDispatchThread();
         final List<String> modulesToStart = new ArrayList<String>();
         try {
+            final Map<String, ModuleFactory> factories = this.getFactories();
             for (final Entry<String, ModuleVersion> e : this.getDBInstalledModules().entrySet()) {
                 final String moduleID = e.getKey();
                 // modules that just add non-key fields are not required
                 if (this.areElementsNeeded(moduleID)) {
-                    final ModuleFactory moduleFactory = this.getFactories().get(moduleID);
+                    final ModuleFactory moduleFactory = factories.get(moduleID);
                     final String error;
                     if (moduleFactory == null)
                         error = "Module '" + moduleID + "' non disponible.";
                     else if (!moduleFactory.getVersion().equals(e.getValue()))
                         error = "Mauvaise version pour '" + moduleID + "'. La version " + moduleFactory.getVersion() + " est disponible mais " + e.getValue() + " est requise.";
                     // check canCreate() after since it's more efficient
                     else
                         error = null;
                     if (error != null) {
                         // TODO open GUI to resolve the issue
-                        ExceptionHandler.handle(error);
+                        throw new Exception(error);
-                        return;
                     } else {
                         modulesToStart.add(moduleID);
+                    }
+                }
+            }
         } catch (Exception e) {
-            ExceptionHandler.die("Impossible de déterminer les modules requis", e);
+            throw new Exception("Impossible de déterminer les modules requis", e);
-            return;
+        }
-        final Tuple2<Map<String, AbstractModule>, Set<String>> modules = this.createModules(modulesToStart, false);
+        final Tuple2<Map<String, AbstractModule>, Set<String>> modules = this.createModules(modulesToStart, false, true);
         if (modules.get1().size() > 0)
-            ExceptionHandler.die("Impossible de créer les modules " + modules.get1());
+            throw new Exception("Impossible de créer les modules " + modules.get1());
         for (final AbstractModule m : modules.get0().values())
             this.registerSQLElements(m);
+    }
     /**
-     * Initialize the module manager.
+     * Initialise the module manager.
+     *
+     * @param root the root where the modules install.
-     * @return the exception, if any, thrown when starting previously running modules.
+     * @param conf the configuration the modules change.
      * @throws Exception if required modules couldn't be registered.
      */
+    public synchronized final void setup(final DBRoot root, final Configuration conf) throws Exception {
+        if (root == null || conf == null)
-    public final Exception setup() throws Exception {
+            throw new NullPointerException();
+        if (this.root != null || getConf() != null)
+            throw new IllegalStateException("Already setup");
+        // modulesElements can be non empty, if a previous setup() failed
+        assert this.runningModules.isEmpty() && this.modulesComponents.isEmpty() : "Modules cannot start without root & conf";
-        this.registerRequiredModules();
+        this.root = root;
+        this.conf = conf;
         try {
-            this.startPreviouslyRunningModules();
+            this.registerRequiredModules();
-            return null;
         } catch (Exception e) {
+            // allow setup() to be called again
+            this.root = null;
+            this.conf = null;
-            return e;
+            throw e;
+        }
+        assert this.runningModules.isEmpty() && this.modulesComponents.isEmpty() : "registerRequiredModules() should not start modules";
+    }
     private Preferences getPrefs() {
         // modules are installed per business entity (perhaps we could add a per user option, i.e.
         // for all businesses of all databases)
         final StringBuilder path = new StringBuilder(32);
-        for (final String item : DBFileCache.getJDBCAncestorNames(Configuration.getInstance().getRoot(), true)) {
+        for (final String item : DBFileCache.getJDBCAncestorNames(getRoot(), true)) {
             path.append(StringUtils.getBoundedLengthString(DBItemFileCache.encode(item), Preferences.MAX_NAME_LENGTH));
             path.append('/');
+        }
         // path must not end with '/'
         path.setLength(path.length() - 1);
     private Preferences getRunningIDsPrefs() {
         return getPrefs().node("toRun");
+    }
-    private Preferences getInstalledPrefs() {
-        return getPrefs().node("installed");
-    }
     protected final boolean isModuleInstalledLocally(String id) {
-        return getInstalledPrefs().getLong(id, NO_VERSION) != NO_VERSION;
+        return getLocalVersionFile(id).exists();
+    }
     protected final ModuleVersion getModuleVersionInstalledLocally(String id) {
-        final long v = getInstalledPrefs().getLong(id, NO_VERSION);
+        final File versionFile = getLocalVersionFile(id);
+        if (versionFile.exists()) {
+            try {
-        return v == NO_VERSION ? null : new ModuleVersion(v);
+                return new ModuleVersion(Long.valueOf(FileUtils.read(versionFile)));
+            } catch (IOException e) {
+                throw new IllegalStateException("Couldn't get installed version of " + id, e);
+            }
+        } else {
+            return null;
+        }
+    }
     public final Collection<String> getModulesInstalledLocally() {
-        try {
-            return Arrays.asList(getInstalledPrefs().keys());
+        return getModulesVersionInstalledLocally().keySet();
-        } catch (BackingStoreException e) {
-            throw new IllegalStateException("Couldn't fetch installed preferences", e);
-        }
+    }
     public final Map<String, ModuleVersion> getModulesVersionInstalledLocally() {
-        final Preferences prefs = getInstalledPrefs();
         final Map<String, ModuleVersion> res = new HashMap<String, ModuleVersion>();
-        try {
+        final File dir = getLocalDirectory();
+        for (final File d : dir.listFiles()) {
-            for (final String key : prefs.keys())
+            final String id = d.getName();
-                res.put(key, new ModuleVersion(prefs.getLong(key, NO_VERSION)));
+            final ModuleVersion version = getModuleVersionInstalledLocally(id);
-        } catch (BackingStoreException e) {
+            if (version != null)
-            throw new IllegalStateException("Couldn't fetch installed preferences", e);
+                res.put(id, version);
+        }
         return res;
+    }
     private void setModuleInstalledLocally(ModuleFactory f, boolean b) {
+        try {
-        if (b) {
+            if (b) {
-            final ModuleVersion vers = f.getVersion();
+                final ModuleVersion vers = f.getVersion();
-            if (vers.getMerged() < MIN_VERSION)
+                if (vers.getMerged() < MIN_VERSION)
-                throw new IllegalStateException("Invalid version : " + vers);
+                    throw new IllegalStateException("Invalid version : " + vers);
+                final File versionFile = getLocalVersionFile(f.getID());
+                FileUtils.mkdir_p(versionFile.getParentFile());
-            getInstalledPrefs().putLong(f.getID(), vers.getMerged());
+                FileUtils.write(String.valueOf(vers.getMerged()), versionFile);
-        } else {
+            } else {
+                // perhaps add a parameter to only remove the versionFile
-            getInstalledPrefs().remove(f.getID());
+                FileUtils.rm_R(getLocalDirectory(f.getID()));
+            }
+        } catch (IOException e) {
+            throw new IllegalStateException("Couldn't change installed status of " + f, e);
+        }
+    }
     private SQLTable getInstalledTable(final DBRoot r) throws SQLException {
         if (!r.contains(FWK_MODULE_TABLENAME)) {
             createTable.addColumn(ISKEY_COLNAME, "boolean NULL");
             createTable.addColumn(MODULE_VERSION_COLNAME, "bigint NOT NULL");
             createTable.addUniqueConstraint("uniqModule", Arrays.asList(MODULE_COLNAME, TABLE_COLNAME, FIELD_COLNAME));
-            SQLUtils.executeAtomic(Configuration.getInstance().getSystemRoot().getDataSource(), new SQLFactory<Object>() {
+            SQLUtils.executeAtomic(getDS(), new SQLFactory<Object>() {
                 @Override
                 public Object create() throws SQLException {
                     r.getDBSystemRoot().getDataSource().execute(createTable.asString());
                     r.getSchema().updateVersion();
                     SQLTable.setUndefID(r.getSchema(), createTable.getName(), null);
             r.refetch();
+        }
         return r.getTable(FWK_MODULE_TABLENAME);
+    }
-    private DBRoot getRoot() {
+    protected final DBRoot getRoot() {
+        return this.root;
+    }
+    private SQLDataSource getDS() {
+        return getRoot().getDBSystemRoot().getDataSource();
+    }
+    protected final Configuration getConf() {
+        return this.conf;
+    }
+    private SQLElementDirectory getDirectory() {
+        return getConf().getDirectory();
+    }
+    private final File getLocalDirectory() {
-        return ((ComptaBasePropsConfiguration) Configuration.getInstance()).getRootSociete();
+        return new File(this.getConf().getConfDir(getRoot()), "modules");
+    }
+    protected final File getLocalDirectory(final String id) {
+        return new File(this.getLocalDirectory(), id);
+    }
+    private final File getLocalVersionFile(final String id) {
+        return new File(this.getLocalDirectory(id), "version");
+    }
     public final ModuleVersion getDBInstalledModuleVersion(final String id) throws SQLException {
         return getDBInstalledModules(id).get(id);
+    }
         final Where keyCreated = Where.isNotNull(installedTable.getField(FIELD_COLNAME)).and(new Where(installedTable.getField(ISKEY_COLNAME), "=", Boolean.TRUE));
         sel.setWhere(idW.and(tableCreated.or(keyCreated)));
         return (Boolean) installedTable.getDBSystemRoot().getDataSource().executeScalar(sel.asString());
+    }
-    private void install(final AbstractModule module) throws SQLException {
+    private void install(final AbstractModule module) throws Exception {
         final ModuleFactory factory = module.getFactory();
-        if (!isModuleInstalledLocally(factory.getID())) {
+        final ModuleVersion localVersion = getModuleVersionInstalledLocally(factory.getID());
-            final ModuleVersion lastInstalledVersion = getDBInstalledModuleVersion(factory.getID());
+        final ModuleVersion lastInstalledVersion = getDBInstalledModuleVersion(factory.getID());
+        final ModuleVersion moduleVersion = module.getFactory().getVersion();
-            if (lastInstalledVersion != null && module.getFactory().getVersion().compareTo(lastInstalledVersion) < 0)
+        if (lastInstalledVersion != null && moduleVersion.compareTo(lastInstalledVersion) < 0)
-                throw new IllegalArgumentException("Module older than the one installed in the DB : " + module.getFactory().getVersion() + " < " + lastInstalledVersion);
+            throw new IllegalArgumentException("Module older than the one installed in the DB : " + moduleVersion + " < " + lastInstalledVersion);
+        if (localVersion != null && moduleVersion.compareTo(localVersion) < 0)
+            throw new IllegalArgumentException("Module older than the one installed locally : " + moduleVersion + " < " + localVersion);
+        if (!moduleVersion.equals(localVersion) || !moduleVersion.equals(lastInstalledVersion)) {
+            // local
+            final File localDir = getLocalDirectory(factory.getID());
+            // There are 2 choices to handle the update of files :
+            // 1. copy dir to a new one and pass it to DBContext, then either rename it to dir or
+            // rename it failed
+            // 2. copy dir to a backup, pass dir to DBContext, then either remove backup or rename
+            // it to dir
+            // Choice 2 is simpler since the module deals with the same directory in both install()
+            // and start()
+            final File backupDir;
+            // check if we need a backup
+            if (localDir.exists()) {
+                backupDir = FileUtils.addSuffix(localDir, ".backup");
+                FileUtils.rm_R(backupDir);
+                FileUtils.copyDirectory(localDir, backupDir);
+            } else {
+                backupDir = null;
+                FileUtils.mkdir_p(localDir);
+            }
+            assert localDir.exists();
+            try {
-            SQLUtils.executeAtomic(Configuration.getInstance().getSystemRoot().getDataSource(), new SQLFactory<Object>() {
+                SQLUtils.executeAtomic(getDS(), new ConnectionHandlerNoSetup<Object, IOException>() {
-                @Override
+                    @Override
-                public Object create() throws SQLException {
+                    public Object handle(SQLDataSource ds) throws SQLException, IOException {
-                    final Tuple2<Set<String>, Set<SQLName>> alreadyCreatedItems = getCreatedItems(factory.getID());
+                        final Tuple2<Set<String>, Set<SQLName>> alreadyCreatedItems = getCreatedItems(factory.getID());
-                    final DBContext ctxt = new DBContext(lastInstalledVersion, getRoot(), alreadyCreatedItems.get0(), alreadyCreatedItems.get1());
+                        final DBContext ctxt = new DBContext(localDir, localVersion, getRoot(), lastInstalledVersion, alreadyCreatedItems.get0(), alreadyCreatedItems.get1());
-                    module.install(ctxt);
-                    // install local
+                        // install local
-                    setModuleInstalledLocally(factory, true);
+                        module.install(ctxt);
+                        if (!localDir.exists())
+                            throw new IOException("Modules shouldn't remove their directory");
-                    // install in DB
+                        // install in DB
-                    ctxt.execute();
+                        ctxt.execute();
-                    updateModuleFields(factory, ctxt);
+                        updateModuleFields(factory, ctxt);
-                    return null;
+                        return null;
+                    }
-            });
+                });
+            } catch (Exception e) {
+                // install did not complete successfully
+                if (getRoot().getServer().getSQLSystem() == SQLSystem.MYSQL)
+                    L.warning("MySQL cannot rollback DDL statements");
+                // keep failed install files and restore previous files
+                final File failed = FileUtils.addSuffix(localDir, ".failed");
+                if (failed.exists() && !FileUtils.rmR(failed))
+                    L.warning("Couldn't remove " + failed);
+                if (!localDir.renameTo(failed)) {
+                    L.warning("Couldn't move " + localDir + " to " + failed);
+                } else {
+                    assert !localDir.exists();
+                    // restore if needed
+                    if (backupDir != null && !backupDir.renameTo(localDir))
+                        L.warning("Couldn't restore " + backupDir + " to " + localDir);
+                }
+                throw e;
+            }
+            // DB transaction was committed, remove backup files
+            assert localDir.exists();
+            if (backupDir != null)
+                FileUtils.rm_R(backupDir);
+            setModuleInstalledLocally(factory, true);
+        }
+        assert moduleVersion.equals(getModuleVersionInstalledLocally(factory.getID())) && moduleVersion.equals(getDBInstalledModuleVersion(factory.getID()));
+    }
     private void registerSQLElements(final AbstractModule module) {
         final String id = module.getFactory().getID();
+        synchronized (this.modulesElements) {
-        if (!this.modulesElements.containsKey(id)) {
+            if (!this.modulesElements.containsKey(id)) {
-            final SQLElementDirectory dir = Configuration.getInstance().getDirectory();
+                final SQLElementDirectory dir = getDirectory();
-            final Map<SQLTable, SQLElement> beforeElements = new HashMap<SQLTable, SQLElement>(dir.getElementsMap());
+                final Map<SQLTable, SQLElement> beforeElements = new HashMap<SQLTable, SQLElement>(dir.getElementsMap());
-            module.setupElements(dir);
+                module.setupElements(dir);
-            final Collection<SQLElement> elements = new ArrayList<SQLElement>();
+                final Collection<SQLElement> elements = new ArrayList<SQLElement>();
+                // use IdentitySet so as not to call equals() since it triggers initFF()
-            final Collection<SQLElement> newElements = CollectionUtils.substract(new IdentityHashSet<SQLElement>(dir.getElements()), new IdentityHashSet<SQLElement>(beforeElements.values()));
+                final IdentitySet<SQLElement> beforeElementsSet = new IdentityHashSet<SQLElement>(beforeElements.values());
-            for (final SQLElement elem : newElements) {
+                for (final SQLElement elem : dir.getElements()) {
+                    if (!beforeElementsSet.contains(elem)) {
-                // don't let elements be replaced (it's tricky to restore in unregister())
+                        // don't let elements be replaced (it's tricky to restore in unregister())
-                if (beforeElements.containsKey(elem.getTable())) {
+                        if (beforeElements.containsKey(elem.getTable())) {
-                    L.warning("Trying to replace element for " + elem.getTable() + " with " + elem);
+                            L.warning("Trying to replace element for " + elem.getTable() + " with " + elem);
-                    dir.addSQLElement(beforeElements.get(elem.getTable()));
+                            dir.addSQLElement(beforeElements.get(elem.getTable()));
-                } else {
+                        } else {
-                    elements.add(elem);
+                            elements.add(elem);
+                        }
+                    }
+                }
-            this.modulesElements.put(id, elements);
+                this.modulesElements.put(id, elements);
+            }
+        }
+    }
     private void setupComponents(final AbstractModule module) throws SQLException {
         final String id = module.getFactory().getID();
         if (!this.modulesComponents.containsKey(id)) {
-            final SQLElementDirectory dir = Configuration.getInstance().getDirectory();
+            final SQLElementDirectory dir = getDirectory();
             final Tuple2<Set<String>, Set<SQLName>> alreadyCreatedItems = getCreatedItems(id);
             final ComponentsContext ctxt = new ComponentsContext(dir, getRoot(), alreadyCreatedItems.get0(), alreadyCreatedItems.get1());
             module.setupComponents(ctxt);
             this.modulesComponents.put(id, ctxt);
+        }
+    }
-    protected final void startPreviouslyRunningModules() throws Exception {
+    public final void startPreviouslyRunningModules() throws Exception {
         final List<String> ids = Arrays.asList(getRunningIDsPrefs().keys());
         startModules(ids);
+    }
     public final boolean startModule(final String id) throws Exception {
+        }
         return res;
+    }
     private final Set<String> startModules(final Collection<String> ids) throws Exception {
-        return this.createModules(ids, true).get1();
+        return this.createModules(ids, true, false).get1();
+    }
     // modules created, and the ones that couldn't
     // i.e. if a module was already created it's in neither
-    private final Tuple2<Map<String, AbstractModule>, Set<String>> createModules(final Collection<String> ids, final boolean start) throws Exception {
+    private final Tuple2<Map<String, AbstractModule>, Set<String>> createModules(final Collection<String> ids, final boolean start, final boolean inSetup) throws Exception {
+        // in setup we're not in the EDT, but it's OK since by definition no modules are started
-        assert SwingUtilities.isEventDispatchThread();
+        assert SwingUtilities.isEventDispatchThread() || inSetup && this.runningModules.isEmpty();
         // add currently running modules so that ModuleFactory can use them
-        final Map<String, AbstractModule> modules = new LinkedHashMap<String, AbstractModule>(this.runningModules);
+        final Map<String, AbstractModule> modules = inSetup ? new LinkedHashMap<String, AbstractModule>(ids.size() * 2) : new LinkedHashMap<String, AbstractModule>(this.runningModules);
         final Set<String> cannotCreate = new HashSet<String>();
         final LinkedHashMap<ModuleFactory, Boolean> map = new LinkedHashMap<ModuleFactory, Boolean>();
         synchronized (this.factories) {
             for (final String id : ids) {
                 final ModuleFactory f = getFactory(id);
                     cannotCreate.add(id);
+                }
+            }
+        }
         // only keep modules created by this method
+        if (!inSetup)
-        modules.keySet().removeAll(this.runningModules.keySet());
+            modules.keySet().removeAll(this.runningModules.keySet());
         if (start) {
             for (final AbstractModule module : modules.values())
                 startModule(module);
+            }
             try {
                 final InputStream labels = module.getClass().getResourceAsStream("labels.xml");
                 if (labels != null) {
                     try {
-                        Configuration.getInstance().getTranslator().load(getRoot(), labels);
+                        getConf().getTranslator().load(getRoot(), labels);
                     } finally {
                         labels.close();
+                    }
+                }
                 this.registerSQLElements(module);
         assert !this.isModuleRunning(id);
+    }
     private void unregisterSQLElements(final AbstractModule module) {
         final String id = module.getFactory().getID();
+        synchronized (this.modulesElements) {
-        if (this.modulesElements.containsKey(id)) {
+            if (this.modulesElements.containsKey(id)) {
-            final Collection<SQLElement> elements = this.modulesElements.remove(id);
+                final Collection<SQLElement> elements = this.modulesElements.remove(id);
-            final SQLElementDirectory dir = Configuration.getInstance().getDirectory();
+                final SQLElementDirectory dir = getDirectory();
-            for (final SQLElement elem : elements)
+                for (final SQLElement elem : elements)
-                dir.removeSQLElement(elem);
+                    dir.removeSQLElement(elem);
+            }
+        }
+    }
     private void tearDownComponents(final AbstractModule module) {
         final String id = module.getFactory().getID();
         if (this.modulesComponents.containsKey(id)) {
             final ComponentsContext ctxt = this.modulesComponents.remove(id);
         if (dbVersion != null && !moduleFactory.getVersion().equals(dbVersion))
             throw new IllegalStateException("DB version not equal : " + dbVersion);
         final AbstractModule module;
         if (!this.isModuleRunning(id)) {
-            module = this.createModules(Collections.singleton(id), false).get0().get(id);
+            module = this.createModules(Collections.singleton(id), false, false).get0().get(id);
         } else {
             module = this.runningModules.get(id);
             this.stopModule(id, true);
+        }
-        SQLUtils.executeAtomic(Configuration.getInstance().getSystemRoot().getDataSource(), new SQLFactory<Object>() {
+        SQLUtils.executeAtomic(getDS(), new SQLFactory<Object>() {
             @Override
             public Object create() throws SQLException {
+                final DBRoot root = getRoot();
-                module.uninstall();
+                module.uninstall(root);
                 unregisterSQLElements(module);
                 setModuleInstalledLocally(module.getFactory(), false);
                 // uninstall from DB
                 final Tuple2<Set<String>, Set<SQLName>> createdItems = getCreatedItems(id);
-                final DBRoot root = getRoot();
                 final List<ChangeTable<?>> l = new ArrayList<ChangeTable<?>>();
                 final Set<String> tableNames = createdItems.get0();
                 for (final SQLName field : createdItems.get1()) {
                     final SQLField f = root.getDesc(field, SQLField.class);
                     // dropped by DROP TABLE

Dépôt officiel du code source de l'ERP OpenConcerto

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/erp/modules/ModuleManager.java - Rev 20 → 25