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

 import org.openconcerto.erp.modules.ModuleTableModel.ModuleRow;
 import org.openconcerto.sql.Configuration;
 import org.openconcerto.sql.TM;
 import org.openconcerto.sql.element.SQLElement;
 import org.openconcerto.sql.element.SQLElementDirectory;
+import org.openconcerto.sql.element.SQLElementNamesFromXML;
 import org.openconcerto.sql.model.AliasedTable;
 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.view.list.IListeAction;
 import org.openconcerto.ui.SwingThreadUtils;
 import org.openconcerto.utils.CollectionMap2.Mode;
 import org.openconcerto.utils.CollectionUtils;
 import org.openconcerto.utils.ExceptionHandler;
+import org.openconcerto.utils.ExceptionUtils;
 import org.openconcerto.utils.FileUtils;
 import org.openconcerto.utils.SetMap;
 import org.openconcerto.utils.StringUtils;
 import org.openconcerto.utils.ThreadFactory;
 import org.openconcerto.utils.Tuple2;
 import java.io.FileFilter;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
     @GuardedBy("ModuleManager.class")
     private static ExecutorService exec = null;
     private static synchronized final Executor getExec() {
         if (exec == null)
-            exec = new ThreadPoolExecutor(0, 2, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(),
+            exec = new ThreadPoolExecutor(0, 2, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(), new ThreadFactory(ModuleManager.class.getSimpleName()
-                    new ThreadFactory(ModuleManager.class.getSimpleName()
-                            // not daemon since install() is not atomic
+                    // not daemon since install() is not atomic
-                            + " executor thread ", false));
+                    + " executor thread ", false));
         return exec;
+    }
     private static final String NEEDED_MODULE_COLNAME = "ID_MODULE_NEEDED";
     private static final String fileMutex = new String("modules");
     private static final Integer TO_INSTALL_VERSION = 1;
-    @GuardedBy("ModuleManager.class")
-    private static ModuleManager instance = null;
+    private static final String OLD_BACKUP_DIR_SUFFIX = ".backup";
-    public static synchronized ModuleManager getInstance() {
+    private static final String OLD_FAILED_DIR_SUFFIX = ".failed";
-        if (instance == null)
-            instance = new ModuleManager();
-        return instance;
-    }
-    static synchronized void resetInstance() {
+    private static final String BACKUP_DIR = "Install backup";
-        if (instance != null) {
-            for (final String id : instance.getRunningModules().keySet()) {
+    private static final String FAILED_DIR = "Install failed";
-                instance.stopModuleRecursively(id);
-            }
-            instance = null;
-        }
-    }
     // return true if the MainFrame is not displayable (or if there's none)
     static private boolean noDisplayableFrame() {
         final MainFrame mf = MainFrame.getInstance();
         if (mf == null)
         ModuleState toInstallTargetState = ModuleState.NOT_CREATED;
         if (toInstallFile.exists()) {
             if (!toInstallFile.canRead() || !toInstallFile.isFile()) {
                 L.warning("Couldn't read " + toInstallFile);
             } else {
-                final XMLDecoder dec = new XMLDecoder(new FileInputStream(toInstallFile));
+                try (final XMLDecoder dec = new XMLDecoder(new FileInputStream(toInstallFile))) {
-                try {
                     final Number version = (Number) dec.readObject();
                     if (version.intValue() != TO_INSTALL_VERSION.intValue())
                         throw new Exception("Version mismatch, expected " + TO_INSTALL_VERSION + " found " + version);
                     final Date fileDate = (Date) dec.readObject();
                     @SuppressWarnings("unchecked")
                     final File errorFile = FileUtils.addSuffix(toInstallFile, ".error");
                     errorFile.delete();
                     final boolean renamed = toInstallFile.renameTo(errorFile);
                     throw new Exception("Couldn't parse " + toInstallFile + " ; renamed : " + renamed, e);
                 } finally {
+                    // Either the installation will succeed and we don't want to execute it again,
+                    // or the installation will fail and we don't want to be caught in an endless
+                    // loop (since there's no API to remove this file).
-                    dec.close();
+                    if (toInstallFile.exists() && !toInstallFile.delete())
+                        throw new IOException("Couldn't delete " + toInstallFile);
+                }
+            }
+        }
         // handle upgrades : the old version was not uninstalled and thus still in
         // dbRequiredModules, and the new version is in toInstall, so the DepSolver will error out
             } else {
                 // NO_CHANGE since they were just installed above
                 this.createModules(userReferencesToInstall, NoChoicePredicate.NO_CHANGE, ModuleState.STARTED, persistent);
+            }
+        }
-        if (toInstallFile.exists() && !toInstallFile.delete())
-            throw new IOException("Couldn't delete " + toInstallFile);
         this.inited = true;
+    }
     // whether module removal can exit the VM
     final void setExitAllowed(boolean exitAllowed) {
     private final Preferences getRequiredIDsPrefs() {
         return getDBPrefs().node("required");
+    }
     protected final boolean isModuleInstalledLocally(String id) {
+        final File versionFile = getLocalVersionFile(id);
-        return getLocalVersionFile(id).exists();
+        return versionFile != null && versionFile.exists();
+    }
     protected final ModuleVersion getModuleVersionInstalledLocally(String id) {
         synchronized (fileMutex) {
             final File versionFile = getLocalVersionFile(id);
-            if (versionFile.exists()) {
+            if (versionFile != null && versionFile.exists()) {
                 try {
                     return new ModuleVersion(Long.valueOf(FileUtils.read(versionFile)));
                 } catch (IOException e) {
                     throw new IllegalStateException("Couldn't get installed version of " + id, e);
+                }
     private SQLElementDirectory getDirectory() {
         return getConf().getDirectory();
+    }
-    final File getLocalDirectory() {
+    public final File getLocalDirectory() {
         return new File(this.getConf().getConfDir(getRoot()), "modules");
+    }
+    public final Set<String> migrateOldTransientDirs() {
+        Set<String> res = Collections.emptySet();
+        final File[] listFiles = this.getLocalDirectory().listFiles();
+        if (listFiles != null) {
+            for (final File f : listFiles) {
+                if (f.isDirectory()) {
+                    res = migrateOldDir(res, f, OLD_BACKUP_DIR_SUFFIX);
+                    res = migrateOldDir(res, f, OLD_FAILED_DIR_SUFFIX);
+                }
+            }
+        }
+        return res;
+    }
+    private final String getOldID(final File f, final String oldSuffix) {
+        if (f.getName().endsWith(oldSuffix)) {
+            final String id = f.getName().substring(0, f.getName().length() - oldSuffix.length());
+            return ModuleReference.checkID(id, false);
+        }
+        return null;
+    }
+    private final Set<String> migrateOldDir(Set<String> res, final File f, final String oldSuffix) {
+        final String id = getOldID(f, oldSuffix);
+        if (id != null) {
+            final Path localFailedDir = getLocalFailedDirectory(id);
+            try {
+                if (Files.exists(localFailedDir)) {
+                    // newer already exists, remove old one
+                    FileUtils.rm_R(f);
+                } else {
+                    Files.createDirectories(localFailedDir.getParent());
+                    Files.move(f.toPath(), localFailedDir);
+                }
+            } catch (IOException e) {
+                L.log(Level.CONFIG, "Couldn't migrate " + f, e);
+                if (res.isEmpty())
+                    res = new HashSet<>();
+                res.add(id);
+            }
+        }
+        return res;
+    }
     // file specifying which module (and only those, dependencies won't be installed automatically)
     // to install during the next application launch.
     private final File getToInstallFile() {
         return new File(getLocalDirectory(), "toInstall");
+    }
+    private final File getLocalDataSubDir(final File f) {
+        // TODO return "Local Data" and a migration method
+        return f;
+    }
+    // => create "internal state" and "local data" folders inside getLocalDirectory() (i.e.
+    // module.id/local data and not local data/module.id so that we can easily copy to
+    // getLocalBackupDirectory() or uninstall a module)
+    private final Path getInternalStateSubDir(final Path f) {
+        // TODO return "Internal State" and a migration method
+        return f;
+    }
-    protected final File getLocalDirectory(final String id) {
+    protected final File getLocalDataDirectory(final String id) {
+        return getLocalDataSubDir(this.getLocalDirectory(id));
+    }
+    private final Path getInternalStateDirectory(final String id) {
+        final File l = this.getLocalDirectory(id);
+        return l == null ? null : getInternalStateSubDir(l.toPath());
+    }
+    private final File getLocalDirectory(final String id) {
+        if (ModuleReference.checkID(id, false) == null)
+            return null;
         return new File(this.getLocalDirectory(), id);
+    }
+    // contains a copy of local module data during install
+    protected final Path getLocalBackupDirectory(final String id) {
-    // TODO module might remove it since it's in getLocalDirectory()
+        // will be ignored by getModulesVersionInstalledLocally()
+        assert ModuleReference.checkID(BACKUP_DIR, false) == null;
+        return this.getLocalDirectory().toPath().resolve(BACKUP_DIR).resolve(id);
+    }
+    // contains local module data of the last failed install
+    protected final Path getLocalFailedDirectory(final String id) {
+        // will be ignored by getModulesVersionInstalledLocally()
+        assert ModuleReference.checkID(FAILED_DIR, false) == null;
+        return this.getLocalDirectory().toPath().resolve(FAILED_DIR).resolve(id);
+    }
     private final File getLocalVersionFile(final String id) {
+        final Path dir = this.getInternalStateDirectory(id);
+        if (dir == null)
+            return null;
-        return new File(this.getLocalDirectory(id), "version");
+        return new File(dir.toFile(), "version");
+    }
     public final ModuleVersion getDBInstalledModuleVersion(final String id) throws SQLException {
         return getDBInstalledModules(id).get(id);
+    }
             // 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;
+            final Path backupDir;
             // check if we need a backup
             if (localDir.exists()) {
-                backupDir = FileUtils.addSuffix(localDir, ".backup");
+                backupDir = getLocalBackupDirectory(factory.getID());
-                FileUtils.rm_R(backupDir);
+                FileUtils.rm_R(backupDir, false);
-                FileUtils.copyDirectory(localDir, backupDir);
+                Files.createDirectories(backupDir.getParent());
+                FileUtils.copyDirectory(localDir.toPath(), backupDir, false, StandardCopyOption.COPY_ATTRIBUTES);
             } else {
                 backupDir = null;
                 FileUtils.mkdir_p(localDir);
+            }
             assert localDir.exists();
             try {
                 SQLUtils.executeAtomic(getDS(), new ConnectionHandlerNoSetup<Object, IOException>() {
                     @Override
                     public Object handle(SQLDataSource ds) throws SQLException, IOException {
                         final Tuple2<Set<String>, Set<SQLName>> alreadyCreatedItems = getCreatedItems(factory.getID());
-                        final DBContext ctxt = new DBContext(localDir, localVersion, getRoot(), lastInstalledVersion, alreadyCreatedItems.get0(), alreadyCreatedItems.get1(), getDirectory());
+                        final DBContext ctxt = new DBContext(getLocalDataSubDir(localDir), localVersion, getRoot(), lastInstalledVersion, alreadyCreatedItems.get0(), alreadyCreatedItems.get1(),
+                                getDirectory());
                         // install local (i.e. ctxt stores the actions to carry on the DB)
                         // TODO pass a data source with no rights to modify the data definition (or
                         // even no rights to modify the data if DB version is up to date)
                         module.install(ctxt);
                         if (!localDir.exists())
             } 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");
+                final Path failed = getLocalFailedDirectory(factory.getID());
+                boolean moved = false;
+                try {
-                if (failed.exists() && !FileUtils.rmR(failed))
+                    FileUtils.rm_R(failed, false);
-                    L.warning("Couldn't remove " + failed);
+                    Files.createDirectories(failed.getParent());
-                if (!localDir.renameTo(failed)) {
+                    Files.move(localDir.toPath(), failed);
-                    L.warning("Couldn't move " + localDir + " to " + failed);
+                    final String errorMsg = "Couldn't install " + module + " :\n" + ExceptionUtils.getStackTrace(e);
+                    // TODO as in getLocalVersionFile(), separate internal state (i.e. version and
+                    // error) from module local data
+                    Files.write(getInternalStateSubDir(failed).resolve("Install error.txt"), errorMsg.getBytes(StandardCharsets.UTF_8));
-                } else {
+                    moved = true;
-                    assert !localDir.exists();
+                } catch (Exception e1) {
+                    L.log(Level.WARNING, "Couldn't move " + localDir + " to " + failed, e1);
+                }
-                    // restore if needed
+                // restore if needed
+                if (moved && backupDir != null) {
+                    assert !localDir.exists();
+                    try {
-                    if (backupDir != null && !backupDir.renameTo(localDir))
+                        Files.move(backupDir, localDir.toPath());
+                    } catch (Exception e1) {
-                        L.warning("Couldn't restore " + backupDir + " to " + localDir);
+                        L.log(Level.WARNING, "Couldn't restore " + backupDir + " to " + localDir, e1);
+                    }
+                }
                 throw e;
+            }
             // DB transaction was committed, remove backup files
             assert localDir.exists();
     private void registerSQLElements(final AbstractModule module, Map<SQLTable, SQLElement> beforeElements) throws IOException {
         final ModuleReference id = module.getFactory().getReference();
         synchronized (this.modulesElements) {
             // perhaps check that no other version of the module has been registered
             if (!this.modulesElements.containsKey(id)) {
-                final String mdVariant = getMDVariant(module.getFactory());
-                // load now so that it's available to ModuleElement in setupElements()
-                final Set<SQLTable> tablesWithMD = loadTranslations(getConf().getTranslator(), module, mdVariant);
                 final SQLElementDirectory dir = getDirectory();
                 module.setupElements(dir);
                 final IdentityHashMap<SQLElement, SQLElement> elements = new IdentityHashMap<SQLElement, SQLElement>();
                 // use IdentitySet so as not to call equals() since it triggers initFF()
                 final IdentitySet<SQLElement> beforeElementsSet = new IdentityHashSet<SQLElement>(beforeElements.values());
                             elements.put(elem, null);
+                        }
+                    }
+                }
+                // Load translations after registering elements since SQLFieldTranslator needs them.
+                // If setupElements() needs translations then perhaps we should store translations
+                // with the element code, without needing the element.
+                final String mdVariant = getMDVariant(module.getFactory());
+                final Set<SQLTable> tablesWithMD = loadTranslations(getConf().getTranslator(), module, mdVariant);
                 // insert just loaded labels into the search path
                 for (final SQLTable tableWithDoc : tablesWithMD) {
                     final SQLElement sqlElem = this.getDirectory().getElement(tableWithDoc);
                     if (sqlElem == null)
                         throw new IllegalStateException("Missing element for table with metadata : " + tableWithDoc);
+        }
         // call it before stopping/uninstalling
         final boolean exit = this.isExitAllowed() && this.needExit(change);
+        final DepSolverGraph graph = change.getGraph();
         final Set<ModuleReference> toRemove = change.getReferencesToRemove();
         final Set<ModuleReference> removed;
         if (toRemove.size() > 0) {
             final Set<String> idsToInstall = change.getIDsToInstall();
-            // limit the number of requests
-            final Map<String, ModuleVersion> dbVersions = this.getDBInstalledModules();
             removed = new HashSet<ModuleReference>();
             for (final ModuleReference ref : toRemove) {
                 // don't uninstall modules to upgrade but since this loop might uninstall modules
                 // needed by ref, at least stop it like uninstallUnsafe() does
                 if (idsToInstall.contains(ref.getID()))
                     this.stopModule(ref.getID(), false);
-                else if (this.uninstallUnsafe(ref, !change.forceRemove(), dbVersions))
+                else if (this.uninstallUnsafe(ref, !change.forceRemove(), change.getInstallState()))
                     removed.add(ref);
+            }
         } else {
             removed = Collections.emptySet();
+        }
             // don't use only getReferencesToInstall() as even if no modules need installing, their
             // state might need to change (e.g. start)
             if (toInstall.size() > 0 || (targetState.compareTo(ModuleState.INSTALLED) > 0 && change.getUserReferencesToInstall().size() > 0)) {
                 // record current time and actions
                 final File f = getToInstallFile();
-                final XMLEncoder xmlEncoder = new XMLEncoder(new FileOutputStream(f));
+                try (final XMLEncoder xmlEncoder = new XMLEncoder(new FileOutputStream(f))) {
-                try {
                     xmlEncoder.setExceptionListener(XMLCodecUtils.EXCEPTION_LISTENER);
                     xmlEncoder.setPersistenceDelegate(ModuleVersion.class, ModuleVersion.PERSIST_DELEGATE);
                     xmlEncoder.setPersistenceDelegate(ModuleReference.class, ModuleReference.PERSIST_DELEGATE);
                     xmlEncoder.writeObject(TO_INSTALL_VERSION);
                     xmlEncoder.writeObject(new Date());
                     xmlEncoder.writeObject(toInstall);
                     xmlEncoder.writeObject(change.getUserReferencesToInstall());
                     xmlEncoder.writeObject(targetState);
                     xmlEncoder.writeObject(startPersistent);
-                    xmlEncoder.close();
                 } catch (Exception e) {
                     // try to delete invalid file before throwing exception
-                    try {
-                        xmlEncoder.close();
-                    } catch (Exception e1) {
+                    // "any catch or finally block is run after the resources have been closed."
-                        e1.printStackTrace();
-                    }
                     f.delete();
                     throw e;
+                }
+            }
-            return ModulesStateChangeResult.onlyRemoved(removed);
+            return new ModulesStateChangeResult(removed, change.getReferencesToInstall(), graph, Collections.emptyMap());
+        }
         // don't use getReferencesToInstall() as even if no modules need installing, their state
         // might need to change (e.g. start)
         if (targetState.compareTo(ModuleState.CREATED) < 0)
             return ModulesStateChangeResult.onlyRemoved(removed);
-        final DepSolverGraph graph = change.getGraph();
         if (graph == null)
-            throw new IllegalArgumentException("target state is " + targetState + " but no graph was provided");
+            throw new IllegalArgumentException("target state is " + targetState + " but no graph was provided by " + change);
         // modules created by this method
         final Map<ModuleReference, AbstractModule> modules = new LinkedHashMap<ModuleReference, AbstractModule>(graph.getFactories().size());
         // MAYBE try to continue even if some modules couldn't be created
         final Set<ModuleReference> cannotCreate = Collections.emptySet();
                 for (final Entry<Object, ModuleFactory> e : dependenciesFactory.entrySet()) {
                     final AbstractModule module = this.createdModules.get(e.getValue());
                     assert module != null;
                     dependenciesModule.put(e.getKey(), module);
+                }
-                final AbstractModule createdModule = useableFactory.createModule(this.getLocalDirectory(id), Collections.unmodifiableMap(dependenciesModule));
+                final AbstractModule createdModule = useableFactory.createModule(this.getLocalDataDirectory(id), Collections.unmodifiableMap(dependenciesModule));
                 modules.put(useableFactory.getReference(), createdModule);
                 this.createdModules.put(useableFactory, createdModule);
                 // update graph
                 final boolean added = this.dependencyGraph.addVertex(useableFactory);
             final List<Locale> langs = cntrl.getCandidateLocales(baseName, targetLocale);
             // SQLFieldTranslator overwrite, so we need to load from general to specific
             final ListIterator<Locale> listIterator = CollectionUtils.getListIterator(langs, true);
             while (listIterator.hasNext()) {
                 final Locale lang = listIterator.next();
+                final SQLElementNamesFromXML elemNames = new SQLElementNamesFromXML(lang);
+                final String bundleName = cntrl.toBundleName(baseName, lang);
-                final String resourceName = cntrl.toResourceName(cntrl.toBundleName(baseName, lang), "xml");
+                final String resourceName = cntrl.toResourceName(bundleName, "xml");
                 final InputStream ins = module.getClass().getResourceAsStream(resourceName);
                 // do not force to have one mapping for each locale
                 if (ins != null) {
                     L.config("module " + module.getName() + " loading translation from " + resourceName);
                     final Set<SQLTable> loadedTables;
                     try {
-                        loadedTables = trns.load(getRoot(), mdVariant, ins).get0();
+                        loadedTables = trns.load(getRoot(), mdVariant, ins, elemNames).get0();
                     } finally {
                         ins.close();
+                    }
                     if (loadedTables.size() > 0) {
                         res.addAll(loadedTables);
                         found |= true;
+                    }
+                    // As in PropsConfiguration.loadTranslations(), perhaps load the class at
+                    // module.getClass().getPackage().getName() + '.' + bundleName
+                    // to allow more flexibility. Perhaps pass a ModuleSQLFieldTranslator to
+                    // restrict what a module can do (and have SQLElementNamesFromXML, mdVariant).
+                }
+            }
+        }
         return res;
+    }
             res.add(f.getReference());
+        }
         return res;
+    }
+    public final Set<ModuleReference> stopAllModules() {
+        // this method is not synchronized, so don't just return getRunningModules()
+        final Set<ModuleReference> res = new HashSet<>();
+        for (final String id : this.getRunningModules().keySet()) {
+            res.addAll(this.stopModuleRecursively(id));
+        }
+        return res;
+    }
-    public synchronized final void stopModuleRecursively(final String id) {
+    public synchronized final List<ModuleReference> stopModuleRecursively(final String id) {
-        for (final ModuleReference ref : getRunningDependentModulesRecursively(id)) {
+        final List<ModuleReference> res = getRunningDependentModulesRecursively(id);
+        for (final ModuleReference ref : res) {
             this.stopModule(ref.getID());
+        }
+        return res;
+    }
-    public final void stopModule(final String id) {
+    public final boolean stopModule(final String id) {
-        this.stopModule(id, true);
+        return this.stopModule(id, true);
+    }
     // TODO pass ModuleReference instead of ID (need to change this.runningModules)
-    public synchronized final void stopModule(final String id, final boolean persistent) {
+    public synchronized final boolean stopModule(final String id, final boolean persistent) {
         if (!this.isModuleRunning(id))
-            return;
+            return false;
         final ModuleFactory f = this.runningModules.get(id).getFactory();
         if (this.isAdminRequired(f.getReference()) && !currentUserIsAdmin())
             throw new IllegalStateException("Not allowed to stop a module required by the administrator " + f);
         final Set<DepLink> deps = this.dependencyGraph.incomingEdgesOf(f);
         // we can't undo what the module has done, so just start from the base menu and re-apply all
         // modifications
         final MenuAndActions menuAndActions = MenuManager.getInstance().createBaseMenuAndActions();
         final ArrayList<AbstractModule> modules = new ArrayList<AbstractModule>(this.runningModules.values());
         SwingThreadUtils.invoke(new Runnable() {
             @Override
             public void run() {
                 for (final AbstractModule m : modules) {
                     setupMenu(m, menuAndActions);
+                }
                 MenuManager.getInstance().setMenuAndActions(menuAndActions);
+            }
         });
         if (persistent)
             getRunningIDsPrefs().remove(m.getFactory().getID());
         assert !this.isModuleRunning(id);
+        return true;
+    }
     private final void stopModule(final AbstractModule m) {
         // this must not attempt to lock this monitor, see uninstallUnsafe()
         assert SwingUtilities.isEventDispatchThread();
             @Override
             public DepSolverGraph getGraph() {
                 return null;
+            }
+            @Override
+            public String toString() {
+                return "Uninstall solution for " + this.getReferencesToRemove();
+            }
         };
+    }
     public final void uninstall(final ModuleReference ref) throws Exception {
         this.uninstall(ref, false);
     public synchronized final Set<ModuleReference> uninstall(final ModuleReference id, final boolean recurse, final boolean force) throws Exception {
         return this.uninstall(Collections.singleton(id), recurse, force);
+    }
-    // return vers if it matches ref
+    // return the version in installed that matches ref
-    private final ModuleVersion filter(final ModuleVersion vers, final ModuleReference ref) {
+    private final ModuleReference filter(final Set<ModuleReference> installed, final ModuleReference ref) {
+        for (final ModuleReference installedRef : installed) {
-        return ref.getVersion() == null || vers != null && vers.equals(ref.getVersion()) ? vers : null;
+            if (installedRef.getID().equals(ref.getID()) && (ref.getVersion() == null || installedRef.getVersion().equals(ref.getVersion())))
+                return installedRef;
+        }
+        return null;
+    }
     // unsafe because this method doesn't check dependents
     // dbVersions parameter to avoid requests to the DB
     // return true if the mref was actually uninstalled (i.e. it was installed locally or remotely)
-    private boolean uninstallUnsafe(final ModuleReference mref, final boolean requireModule, Map<String, ModuleVersion> dbVersions) throws SQLException, Exception {
+    private boolean uninstallUnsafe(final ModuleReference mref, final boolean requireModule, final InstallationState installState) throws SQLException, Exception {
         assert Thread.holdsLock(this);
         final String id = mref.getID();
-        if (dbVersions == null)
-            dbVersions = this.getDBInstalledModules();
         // versions to uninstall
-        final ModuleVersion localVersion = filter(this.getModuleVersionInstalledLocally(id), mref);
+        final ModuleReference localRef = filter(installState.getLocal(), mref);
-        final ModuleVersion dbVersion = filter(dbVersions.get(id), mref);
+        final ModuleReference dbRef = filter(installState.getRemote(), mref);
+        final ModuleVersion dbVersion = dbRef == null ? null : dbRef.getVersion();
         // otherwise it will get re-installed the next launch
         getRunningIDsPrefs().remove(id);
         final Set<ModuleReference> refs = new HashSet<ModuleReference>(2);
-        if (localVersion != null)
+        if (localRef != null)
-            refs.add(new ModuleReference(id, localVersion));
+            refs.add(localRef);
-        if (dbVersion != null)
+        if (dbRef != null)
-            refs.add(new ModuleReference(id, dbVersion));
+            refs.add(dbRef);
         setAdminRequiredModules(refs, false);
         // only return after having cleared required, so that we don't need to install just to
         // not require
-        if (localVersion == null && dbVersion == null)
+        if (localRef == null && dbRef == null)
             return false;
-        if (dbVersion != null && !currentUserIsAdmin())
+        if (dbRef != null && !currentUserIsAdmin())
             throw new IllegalStateException("Not allowed to uninstall " + id + " from the database");
         // DB module
         final AbstractModule module;
         if (!this.isModuleRunning(id)) {
-            if (dbVersion == null) {
+            if (dbRef == null) {
-                assert localVersion != null;
+                assert localRef != null;
                 // only installed locally
                 module = null;
             } else {
                 final SortedMap<ModuleVersion, ModuleFactory> available = this.factories.getVersions(id);
                 final ModuleReference ref;
                 if (available.containsKey(dbVersion)) {
-                    ref = new ModuleReference(id, dbVersion);
+                    ref = dbRef;
                 } else {
                     // perhaps modules should specify which versions they can uninstall
                     final SortedMap<ModuleVersion, ModuleFactory> moreRecent = available.headMap(dbVersion);
                     if (moreRecent.size() == 0) {
                         ref = null;
                     assert ref.getVersion().compareTo(dbVersion) >= 0;
                     final ModuleFactory f = available.get(ref.getVersion());
                     assert f != null;
                     // only call expensive method if necessary
                     if (!this.createdModules.containsKey(f)) {
-                        // don't use the result, instead use this.createdModules since the module
+                        // * Don't use the result, instead use this.createdModules since the module
-                        // might have been created before
+                        // might have been created before.
+                        // * Cannot call directly applyChange(), we need DepSolver to create modules
+                        // that ref depends on, as they might be required by
+                        // AbstractModule.uninstall().
+                        // * Cannot pass NoChoicePredicate.NO_CHANGE as ref won't be created if not
+                        // already installed both locally and remotely. No installation will occur
+                        // since we pass ModuleState.CREATED.
-                        this.createModules(Collections.singleton(ref), NoChoicePredicate.NO_CHANGE, ModuleState.CREATED);
+                        this.createModules(Collections.singleton(ref), NoChoicePredicate.ONLY_INSTALL, ModuleState.CREATED);
+                    }
                     module = this.createdModules.get(f);
                 } else {
                     module = null;
+                }
+                    }
                     throw new IllegalStateException("Couldn't get module " + id + " : " + reason);
+                }
+            }
         } else {
+            final ModuleVersion localVersion = localRef.getVersion();
             if (!localVersion.equals(dbVersion))
                 L.warning("Someone else has changed the database version while we were running :" + localVersion + " != " + dbVersion);
             module = this.runningModules.get(id);
             assert localVersion.equals(module.getFactory().getVersion());
             this.stopModule(id, false);
             // ATTN we hold this monitor, so stop() should never try to acquire it in the EDT
             if (!SwingUtilities.isEventDispatchThread()) {
                 SwingUtilities.invokeAndWait(EMPTY_RUNNABLE);
+            }
+        }
-        assert (module == null) == (!requireModule || dbVersion == null);
+        assert (module == null) == (!requireModule || dbRef == null);
         SQLUtils.executeAtomic(getDS(), new SQLFactory<Object>() {
             @Override
             public Object create() throws SQLException {
                 final DBRoot root = getRoot();
                 if (module != null) {
                     module.uninstall(root);
                     unregisterSQLElements(module);
+                }
-                if (localVersion != null)
+                if (localRef != null)
-                    setModuleInstalledLocally(new ModuleReference(id, localVersion), false);
+                    setModuleInstalledLocally(localRef, false);
                 // uninstall from DB
-                if (dbVersion != null) {
+                if (dbRef != null) {
                     final Tuple2<Set<String>, Set<SQLName>> createdItems = getCreatedItems(id);
                     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);
                             root.getDBSystemRoot().getDataSource().execute(s);
                         root.getSchema().updateVersion();
                         root.refetch();
+                    }
-                    removeModuleFields(new ModuleReference(id, dbVersion));
+                    removeModuleFields(dbRef);
+                }
                 return null;
+            }
         });
         return true;

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 151 → 156