Attachment #92834 for bug #113341

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 113341
Collapse All | Expand All

Lines 368-373 Link Here

(-)a/autoupdate.services/src/org/netbeans/modules/autoupdate/services/InstallManager.java (+2 lines)
368	}	368	}
369		369
370	}	370	}
		371
		372	// XXX also need locateAll
371		373
372	/** Search all top dirs for a file. */	374	/** Search all top dirs for a file. */
373	private static File locateExactPath(String prefix, String name) {	375	private static File locateExactPath(String prefix, String name) {

Lines 173-178 Link Here

(-)a/core.startup/src/org/netbeans/core/startup/InstalledFileLocatorImpl.java (+2 lines)
173	}	173	}
174	}	174	}
175		175
		176	// XXX also need locateAll
		177
176	/** Search all top dirs for a file. */	178	/** Search all top dirs for a file. */
177	private static File locateExactPath(String prefix, String name) {	179	private static File locateExactPath(String prefix, String name) {
178	assert Thread.holdsLock(InstalledFileLocatorImpl.class);	180	assert Thread.holdsLock(InstalledFileLocatorImpl.class);




// and ModuleInfo-related things). Should be possible to use without
// the rest of core.

import org.openide.modules.SpecificationVersion;

/** Representation of the history of the module.
 * This includes information such as: whether the module
 * has been installed before and now just needs to be restored
 * (or in fact where it was installed); the previous version
 * of the module, in case it needs to be upgraded.
 * Used for communication
 * between the module lister and the module installer.
 * @author Jesse Glick
 */
// XXX no longer useful, could probably delete, and deprecate Module.history
public final class ModuleHistory {
    
    private final String jar;
    private int oldMajorVers;
    private SpecificationVersion oldSpecVers;
    private boolean upgraded;
    private byte[] installerState;
    private boolean installerStateChanged = false;
    
    /** Create a module history with essential information.
     * You also need to specify a relative or absolute JAR name.

    public ModuleHistory(String jar) {
        assert jar != null;
        this.jar = jar;
        upgraded = false;
        oldMajorVers = -1;
        oldSpecVers = null;
        installerState = null;
    }
    
    /**

        return jar;
    }
    
    /** True if this module has been installed before. */
    boolean isPreviouslyInstalled() {
        return upgraded;
    }
    
    /** The old major version of the module,
     * before an upgrade.
     * -1 if unspecified, or it has never been installed before.
     */
    int getOldMajorVersion() {
        return oldMajorVers;
    }
    
    /** The old specification version of the module,
     * before an upgrade.
     * null if unspecified, or it has never been installed before.
     */
    SpecificationVersion getOldSpecificationVersion() {
        return oldSpecVers;
    }
    
    /** Signal that a module has been previously installed,
     * marking it as a possible candidate for upgrade.
     */
    void upgrade(int oldMajorVersion, SpecificationVersion oldSpecificationVersion) {
        upgraded = true;
        oldMajorVers = oldMajorVersion;
        oldSpecVers = oldSpecificationVersion;
    }
    
    /** Get the stored state of the ModuleInstall, if any.
     * Currently this would be a serialized bytestream.
     * null if unknown or there was no stored state.
     */
    byte[] getInstallerState() {
        return installerState;
    }
    
    /** Set the stored state of the ModuleInstall.
     * This may be null to indicate that no state
     * needs to be stored. Otherwise it would currently
     * be a serialized bytestream.
     */
    void setInstallerState(byte[] state) {
        if (installerState != null && state != null) {
            installerStateChanged = true;
        }
        installerState = state;
    }
    
    /** True if the state of the installer has changed dynamically. */
    boolean getInstallerStateChanged() {
        return installerStateChanged;
    }
    
    /** Reset history after an uninstall. */
    void resetHistory() {
        upgraded = false;
        installerState = null;
        installerStateChanged = false;
    }
    
}




import java.beans.PropertyChangeListener;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.CharArrayWriter;
import java.io.DataOutputStream;
import java.io.File;

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PushbackInputStream;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.jar.JarFile;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.netbeans.DuplicateException;

import org.openide.filesystems.FileUtil;
import org.openide.modules.Dependency;
import org.openide.modules.InstalledFileLocator;
import org.openide.modules.ModuleInstall;
import org.openide.modules.SpecificationVersion;
import org.openide.util.Parameters;
import org.openide.util.RequestProcessor;
import org.openide.util.Utilities;
import org.openide.util.WeakSet;
import org.openide.util.io.NbObjectInputStream;
import org.openide.util.io.NbObjectOutputStream;
import org.openide.xml.EntityCatalog;
import org.openide.xml.XMLUtil;
import org.xml.sax.Attributes;

    private boolean triggered = false;
    /** listener for changes in modules, etc.; see comment on class Listener */
    private final Listener listener = new Listener();
    /** any module install sers from externalizedModules.ser, from class name to data */
    private final Map<String,byte[]> compatibilitySers = new HashMap<String,byte[]>(100);
    /** atomic actions I have used to change Modules/*.xml */
    private final Set<FileSystem.AtomicAction> myAtomicActions = Collections.<FileSystem.AtomicAction>synchronizedSet(new WeakSet<FileSystem.AtomicAction>(100));
    

            if (!f.isFile()) throw new FileNotFoundException(f.getAbsolutePath());
            return f;
        } else {
            Set<File> jars = InstalledFileLocator.getDefault().locateAll(jar, name, false);
            if (jars.isEmpty()) {
                throw new FileNotFoundException(jar);
            } else if (jars.size() == 1) {
                return jars.iterator().next();
            } else {
                // Pick the newest one available.
                int major = -1;
                SpecificationVersion spec = null;
                File newest = null;
                for (File candidate : jars) {
                    int candidateMajor = -1;
                    SpecificationVersion candidateSpec = null;
                    JarFile jf = new JarFile(candidate);
                    try {
                        java.util.jar.Attributes attr = jf.getManifest().getMainAttributes();
                        String codename = attr.getValue("OpenIDE-Module");
                        if (codename != null) {
                            int slash = codename.lastIndexOf('/');
                            if (slash != -1) {
                                candidateMajor = Integer.parseInt(codename.substring(slash + 1));
                            }
                        }
                        String sv = attr.getValue("OpenIDE-Module-Specification-Version");
                        if (sv != null) {
                            candidateSpec = new SpecificationVersion(sv);
                        }
                    } finally {
                        jf.close();
                    }
                    if (newest == null || candidateMajor > major || (spec != null && candidateSpec != null && candidateSpec.compareTo(spec) > 0)) {
                        newest = candidate;
                        major = candidateMajor;
                        spec = candidateSpec;
                    }
                }
                return newest;
            }
        }
    }

        ev.log(Events.PERF_END, "ModuleList.installNew"); // NOI18N
    }
    
    /** Record initial condition of a module installer.
     * First, if any stored state of the installer was found on disk,
     * that is if it is kept in the ModuleHistory, then deserialize
     * it (to the found installer). If there are deserialization errors,
     * this step is simply skipped. Or, if there was no prerecorded state,
     * and the ModuleInstall class overrides writeExternal or a similar
     * serialization-related method, thus indicating that it wishes to
     * serialize state, then this initial object is serialized to the
     * history's state for comparison with the later value. If there are
     * problems with this serialization, the history receives a dummy state
     * (empty bytestream) to indicate that something should be saved later.
     * If there is no prerecorded state and no writeExternal method, it is
     * assumed that serialization is irrelevant to this installer and so the
     * state is left null and nothing will be done here or in the postpare method.
     * If this installer was mentioned in externalizedModules.ser, also try to
     * handle the situation (determine if the state was useful or not etc.).
     * Access from NbInstaller.
     */
    void installPrepare(Module m, ModuleInstall inst) {
        if (! (m.getHistory() instanceof ModuleHistory)) {
            LOG.fine(m + " had strange history " + m.getHistory() + ", ignoring...");
            return;
        }
        ModuleHistory hist = (ModuleHistory)m.getHistory();
        // We might have loaded something from externalizedModules.ser before.
        byte[] compatSer = compatibilitySers.get(inst.getClass().getName());
        if (compatSer != null) {
            LOG.fine("Had some old-style state for " + m);
            if (isReallyExternalizable(inst.getClass())) {
                // OK, maybe it was not useless, let's see...
                // Compare virgin state to what we had; if different, load
                // the old state and record that we want to track state.
                try {
                    ByteArrayOutputStream baos = new ByteArrayOutputStream(1000);
                    new NbObjectOutputStream(baos).writeObject(inst);
                    baos.close();
                    if (Utilities.compareObjects(compatSer, baos.toByteArray())) {
                        LOG.fine("Old-style state for " + m + " was gratuitous");
                        // leave hist.installerState null
                    } else {
                        LOG.fine("Old-style state for " + m + " was useful, loading it...");
                        // Make sure it is recorded as "changed" in history by writing something
                        // fake now. In installPostpare, we will load the new installer state
                        // and call setInstallerState again, so the result will be written to disk.
                        hist.setInstallerState(new byte[0]);
                        // And also load it into the actual installer.
                        InputStream is = new ByteArrayInputStream(compatSer);
                        Object o = new NbObjectInputStream(is).readObject();
                        if (o != inst) throw new ClassCastException("Stored " + o + " but expecting " + inst); // NOI18N
                    }
                } catch (Exception e) {
                    LOG.log(Level.WARNING, null, e);
                    // Try later to continue.
                    hist.setInstallerState(new byte[0]);
                } catch (LinkageError le) {
                    LOG.log(Level.WARNING, null, le);
                    // Try later to continue.
                    hist.setInstallerState(new byte[0]);
                }
            } else {
                LOG.fine(m + " did not want to store install state");
                // leave hist.installerState null
            }
        } else if (hist.getInstallerState() != null) {
            // We already have some state, load it now.
            LOG.fine("Loading install state for " + m);
            try {
                InputStream is = new ByteArrayInputStream(hist.getInstallerState());
                // Note: NBOOS requires the system class loader to be in order.
                // Technically we have not yet fired any changes in it. However,
                // assuming that we are not in the first block of modules to be
                // loaded (that is, core = bootstraps) this will work because the
                // available systemClassLoader is just appended to. Better would
                // probably be to use a special ObjectInputStream resolving
                // specifically to the module's classloader, as this is far more
                // direct and possibly more reliable.
                Object o = new NbObjectInputStream(is).readObject();
                // The joys of SharedClassObject. The deserialization itself actually
                // is assumed to overwrite the state of the install singleton. We
                // can only confirm that we actually deserialized the same thing we
                // were expecting too (it is too late to revert anything of course).
                if (o != inst) throw new ClassCastException("Stored " + o + " but expecting " + inst); // NOI18N
            } catch (Exception e) {
                // IOException, ClassNotFoundException, and maybe unchecked stuff
                LOG.log(Level.WARNING, null, e);
                // Nothing else to do, hope that the install object was not corrupted
                // by the failed deserialization! If it was, it cannot be saved now.
            } catch (LinkageError le) {
                LOG.log(Level.WARNING, null, le);
            }
        } else {
            // Virgin installer. First we check if it really cares about serialization
            // at all, because it not we do not want to waste time forcing it.
            if (isReallyExternalizable(inst.getClass())) {
                LOG.fine("Checking pre-install state of " + m);
                LOG.warning("Warning: use of writeExternal (or writeReplace) in " + inst.getClass().getName() + " is deprecated; use normal settings instead");
                try {
                    ByteArrayOutputStream baos = new ByteArrayOutputStream(1000);
                    new NbObjectOutputStream(baos).writeObject(inst);
                    baos.close();
                    // Keep track of the installer's state before we installed it.
                    // This will be compared to its state afterwards so we can
                    // avoid writing anything if nothing changed, thus avoid
                    // polluting the disk.
                    hist.setInstallerState(baos.toByteArray());
                } catch (Exception e) {
                    LOG.log(Level.WARNING, null, e);
                    // Remember that it is *supposed* to be serializable to something.
                    hist.setInstallerState(new byte[0]);
                } catch (LinkageError le) {
                    LOG.log(Level.WARNING, null, le);
                    hist.setInstallerState(new byte[0]);
                }
            } else {
                // It does not want to store anything. Leave the installer state null
                // and continue.
                LOG.fine(m + " did not want to store install state");
            }
        }
    }
    /** Check if a class (extends ModuleInstall) is truly externalizable,
     * e.g. overrides writeExternal.
     */
    private static boolean isReallyExternalizable(Class clazz) {
        Class<?> c;
        for (c = clazz; c != ModuleInstall.class && c != Object.class; c = c.getSuperclass()) {
            try {
                c.getDeclaredMethod("writeExternal", ObjectOutput.class); // NOI18N
                // [PENDING] check that m is public, nonstatic, returns Void.TYPE and includes at most
                // IOException and unchecked exceptions in its clauses, else die
                // OK, it does something nontrivial.
                return true;
            } catch (NoSuchMethodException nsme) {
                // Didn't find it at this level, continue.
            }
            try {
                c.getDeclaredMethod("writeReplace"); // NOI18N
                // [PENDING] check that m is nonstatic, returns Object, throws ObjectStreamException
                // Designates a serializable replacer, this is special.
                return true;
            } catch (NoSuchMethodException nsme) {
                // Again keep on looking.
            }
        }
        // Hit a superclass.
        if (c == Object.class) throw new IllegalArgumentException("Class " + clazz + " was not a ModuleInstall"); // NOI18N
        // Hit ModuleInstall. Did not find anything. Assumed to not do anything during externalization.
        return false;
    }
    
    /** Acknowledge later conditions of a module installer.
     * If the module history indicates a nonnull installer state, then we
     * try to serialize the current state to a temporary buffer and compare
     * to the previous state. If the serialization succeeds, and they differ,
     * then the new state is recorded in the history and will later be written to disk.
     * Access from NbInstaller.
     */
    void installPostpare(Module m, ModuleInstall inst) {
        if (! (m.getHistory() instanceof ModuleHistory)) {
            LOG.fine(m + " had strange history " + m.getHistory() + ", ignoring...");
            return;
        }
        ModuleHistory hist = (ModuleHistory)m.getHistory();
        if (hist.getInstallerState() != null) {
            try {
                ByteArrayOutputStream baos = new ByteArrayOutputStream(1000);
                new NbObjectOutputStream(baos).writeObject(inst);
                baos.close();
                byte[] old = hist.getInstallerState();
                byte[] nue = baos.toByteArray();
                if (Utilities.compareObjects(old, nue)) {
                    // State has not changed.
                    LOG.fine(m + " did not change installer state (" + old.length + " bytes), not writing anything");
                } else {
                    // It did change. Store new version.
                    LOG.fine(m + " changed installer state after loading");
                    hist.setInstallerState(nue);
                }
            } catch (Exception e) {
                LOG.log(Level.WARNING, null, e);
                // We could not compare, so don't bother writing out any old state.
                //hist.setInstallerState(null);
            } catch (LinkageError le) {
                LOG.log(Level.WARNING, null, le);
            }
        } else {
            // Nothing stored (does not writeExternal), do nothing.
            LOG.fine(m + " has no saved state");
        }
    }
    
    /** Read an XML file using an XMLReader and parse into a map of properties.
     * One distinguished property 'name' is the code name base
     * and is taken from the root element. Others are taken

     * @return some parsed value suitable for the status map
     */
    private Object processStatusParam(String k, String v) throws NumberFormatException {
        if (k == "enabled" // NOI18N
            return Integer.parseInt(v);
        } else if (k == "enabled" // NOI18N
                   || k == "autoload" // NOI18N
                   || k == "eager" // NOI18N
                   || k == "reloadable" // NOI18N
                   ) {
            return Boolean.valueOf(v);
        } else if (k == "specversion") { // NOI18N
            return new SpecificationVersion(v);
        } else {
            // Other properties are of type String.
            // Intern the smaller ones which are likely to be repeated somewhere.

            && ((Boolean)m.get("eager")).booleanValue() // NOI18N
            && m.get("enabled") != null) // NOI18N
            throw new IOException("Eager modules cannot specify enablement"); // NOI18N
        // Compatibility:
        String origin = (String)m.remove("origin"); // NOI18N
        if (origin != null) {
            String jar = (String)m.get("jar"); // NOI18N
            String newjar;
            if (origin.equals("user") || origin.equals("installation")) { // NOI18N
                newjar = "modules/" + jar; // NOI18N
            } else if (origin.equals("user/autoload") || origin.equals("installation/autoload")) { // NOI18N
                newjar = "modules/autoload/" + jar; // NOI18N
            } else if (origin.equals("user/eager") || origin.equals("installation/eager")) { // NOI18N
                newjar = "modules/eager/" + jar; // NOI18N
            } else if (origin.equals("adhoc")) { // NOI18N
                newjar = jar;
            } else {
                throw new IOException("Unrecognized origin " + origin + " for " + jar); // NOI18N
            }
            LOG.warning("Upgrading 'jar' param from " + jar + " to " + newjar + " and removing 'origin' " + origin);
            m.put("jar", newjar); // NOI18N
        }
    }

    // Encoding irrelevant for these getBytes() calls: all are ASCII...

        for (Map.Entry<String, Object> entry: new TreeMap<String, Object>(m).entrySet()) {
            String name = entry.getKey();
            if (
                name.equals("name") || // NOI18N
                name.equals("deps") // NOI18N
            ) {
                // Skip this one, it is a pseudo-param.

                    lock.releaseLock();
                }
                //nue.lastApprovedChange = nue.file.lastModified().getTime();
                // Now check up on the installer ser.
                byte[] data = (byte[])nue.diskProps.get("installerState"); // NOI18N
                if (data != null) {
                    String installerName = (String)nue.diskProps.get("installer"); // NOI18N
                    FileObject ser = folder.getFileObject(installerName);
                    if (ser == null) {
                        // Need to make it.
                        int idx = installerName.lastIndexOf('.'); // NOI18N
                        ser = folder.createData(installerName.substring(0, idx), installerName.substring(idx + 1));
                    }
                    // Now write it.
                    lock = ser.lock();
                    try {
                        OutputStream os = ser.getOutputStream(lock);
                        try {
                            os.write(data);
                        } finally {
                            os.close();
                        }
                    } finally {
                        lock.releaseLock();
                    }
                } else {
                    /* Probably not right:
                    // Delete any existing one.
                    if (ser != null) {
                        ser.delete();
                    }
                     */
                }
            }
        };
        myAtomicActions.add(aa);

    
    /** Compute what properties we would want to store in XML
     * for this module. I.e. 'name', 'reloadable', etc.
     * The special property 'installerState' may be set (only
     * if the normal property 'installer' is also set) and
     * will be a byte[] rather than a string, which means that
     * the indicated installer state should be written out.
     */
    private Map<String,Object> computeProperties(Module m) {
        if (m.isFixed() || ! m.isValid()) throw new IllegalArgumentException("fixed or invalid: " + m); // NOI18N
        Map<String,Object> p = new HashMap<String,Object>();
        p.put("name", m.getCodeNameBase()); // NOI18N
        int rel = m.getCodeNameRelease();
        if (rel >= 0) {
            p.put("release", rel); // NOI18N
        }
        SpecificationVersion spec = m.getSpecificationVersion();
        if (spec != null) {
            p.put("specversion", spec); // NOI18N
        }
        if (!m.isAutoload() && !m.isEager()) {
            p.put("enabled", m.isEnabled()); // NOI18N
        }

        if (m.getHistory() instanceof ModuleHistory) {
            ModuleHistory hist = (ModuleHistory) m.getHistory();
            p.put("jar", hist.getJar()); // NOI18N
            if (hist.getInstallerStateChanged()) {
                p.put("installer", m.getCodeNameBase().replace('.', '-') + ".ser"); // NOI18N
                p.put("installerState", hist.getInstallerState()); // NOI18N
            }
        }
        return p;
    }

        }
        private void stepCheckMisc(Map<String,Map<String,Object>> dirtyprops) {
            LOG.fine("ModuleList: stepCheckMisc");
            String[] toCheck = {"jar", "autoload", "eager"}; // NOI18N
            for (Map.Entry<String,Map<String,Object>> entry : dirtyprops.entrySet()) {
                String cnb = entry.getKey();
                Map<String,Object> props = entry.getValue();

                        continue;
                    }
                    ModuleHistory history = new ModuleHistory(jar); // NOI18N
                    Integer prevReleaseI = (Integer) props.get("release"); // NOI18N
                    int prevRelease = prevReleaseI == null ? -1 : prevReleaseI.intValue();
                    SpecificationVersion prevSpec = (SpecificationVersion) props.get("specversion"); // NOI18N
                    history.upgrade(prevRelease, prevSpec);
                    Boolean reloadableB = (Boolean) props.get("reloadable"); // NOI18N
                    boolean reloadable = reloadableB != null ? reloadableB.booleanValue() : false;
                    boolean enabled = enabledB != null ? enabledB.booleanValue() : false;

                    boolean autoload = autoloadB != null ? autoloadB.booleanValue() : false;
                    Boolean eagerB = (Boolean) props.get("eager"); // NOI18N
                    boolean eager = eagerB != null ? eagerB.booleanValue() : false;
                    String installer = (String) props.get("installer"); // NOI18N
                    if (installer != null) {
                        String nameDashes = name.replace('.', '-');
                        if (!installer.equals(nameDashes + ".ser")) {
                            throw new IOException("Incorrect installer ser name: " + installer); // NOI18N
                        }
                        // Load from disk in mentioned file.
                        FileObject installerSer = folder.getFileObject(nameDashes, "ser"); // NOI18N
                        if (installerSer == null) {
                            throw new IOException("No such install ser: " + installer + "; I see only: " + Arrays.asList(folder.getChildren())); // NOI18N
                        }
                        // Hope the stored state is not >Integer.MAX_INT! :-)
                        byte[] buf = new byte[(int) installerSer.getSize()];
                        InputStream is2 = installerSer.getInputStream();
                        try {
                            is2.read(buf);
                        } finally {
                            is2.close();
                        }
                        history.setInstallerState(buf);
                        // Quasi-prop which is stored separately.
                        props.put("installerState", buf); // NOI18N
                    }
                    NbInstaller.register(name, props.get("deps")); // NOI18N
                    Module m = mgr.create(jarFile, history, reloadable, autoload, eager);
                    NbInstaller.register(null, null);




        if (instClazz != null) {
            ModuleInstall inst = SharedClassObject.findObject(instClazz, true);
            if (load) {
                ev.log(Events.RESTORE, m);
                inst.restored();
                }
                // restore, install, or upgrade as appropriate
                Object history = m.getHistory();
                if (history instanceof ModuleHistory) {
                    ModuleHistory h = (ModuleHistory)history;
                    if (h.isPreviouslyInstalled()) {
                        // Check whether we have changed versions.
                        SpecificationVersion oldSpec = h.getOldSpecificationVersion();
                        SpecificationVersion nueSpec = m.getSpecificationVersion();
                        if (m.getCodeNameRelease() != h.getOldMajorVersion() ||
                                (oldSpec == null ^ nueSpec == null) ||
                                (oldSpec != null && nueSpec != null && oldSpec.compareTo(nueSpec) != 0)) {
                            // Yes, different version; upgrade from the old one.
                            ev.log(Events.UPDATE, m);
                            inst.updated(h.getOldMajorVersion(), oldSpec == null ? null : oldSpec.toString());
                        } else {
                            // Same version as before.
                            ev.log(Events.RESTORE, m);
                            inst.restored();
                        }
                    } else {
                        // First time.
                        ev.log(Events.INSTALL, m);
                        inst.installed();
                    }
                } else {
                    // Probably fixed module. Just restore.
                    ev.log(Events.RESTORE, m);
                    inst.restored();
                }
                if (moduleList != null) {
                    moduleList.installPostpare(m, inst);
                }
            } else {
                ev.log(Events.UNINSTALL, m);
                inst.uninstalled();
                if (m.getHistory() instanceof ModuleHistory) {
                    ((ModuleHistory)m.getHistory()).resetHistory();
                }
            }
        }
    }




import java.util.jar.*;
import java.io.*;
import java.util.zip.ZipEntry;
import org.apache.tools.ant.types.Mapper;

/** Create XML files corresponding to the set of known modules
 * without actually running the IDE.

                }
                int idx = codename.lastIndexOf('/');
                String codenamebase;
                int rel;
                if (idx == -1) {
                    codenamebase = codename;
                    rel = -1;
                } else {
                    codenamebase = codename.substring(0, idx);
                    try {
                        rel = Integer.parseInt(codename.substring(idx + 1));
                    } catch (NumberFormatException e) {
                        throw new BuildException("Invalid OpenIDE-Module '" + codename + "' in " + module, getLocation());
                    }
                }
                File xml = new File(xmldir, codenamebase.replace('.', '-') + ".xml");
                if (xml.exists()) {

                    displayname = codename;
                }
                names.add(displayname);
                String spec = attr.getValue("OpenIDE-Module-Specification-Version");
                if (isHidden) {
                    File h = new File(xml.getParentFile(), xml.getName() + "_hidden");
                    h.createNewFile();

                            pw.println("    <param name=\"enabled\">" + isEnabled + "</param>");
                        }
                        pw.println("    <param name=\"jar\">" + kid.replace(File.separatorChar, '/') + "</param>");
                        if (rel != -1) {
                            pw.println("    <param name=\"release\">" + rel + "</param>");
                        }
                        pw.println("    <param name=\"reloadable\">false</param>");
                        if (spec != null) {
                            pw.println("    <param name=\"specversion\">" + spec + "</param>");
                        }
                        pw.println("</module>");
                        pw.flush();
                        pw.close();

Lines 43-48 Link Here

(-)a/openide.modules/src/org/openide/modules/InstalledFileLocator.java (-3 / +34 lines)
43		43
44	import java.io.File;	44	import java.io.File;
45	import java.util.Collection;	45	import java.util.Collection;
		46	import java.util.Collections;
		47	import java.util.LinkedHashSet;
		48	import java.util.Set;
46	import org.openide.util.Lookup;	49	import org.openide.util.Lookup;
47	import org.openide.util.LookupEvent;	50	import org.openide.util.LookupEvent;
48	import org.openide.util.LookupListener;	51	import org.openide.util.LookupListener;
Lines 70-75 Link Here
70		73
71	return null;	74	return null;
72	}	75	}
		76	public @Override Set<File> locateAll(String relativePath, String codeNameBase, boolean localized) {
		77	Set<File> result = null;
		78	for (InstalledFileLocator ifl : getInstances()) {
		79	Set<File> added = ifl.locateAll(relativePath, codeNameBase, localized);
		80	// avoid allocating extra lists, under the assumption there is only one result:
		81	if (!added.isEmpty()) {
		82	if (result == null) {
		83	result = added;
		84	} else {
		85	result = new LinkedHashSet<File>(result);
		86	result.addAll(added);
		87	}
		88	}
		89	}
		90	return result != null ? result : Collections.<File>emptySet();
		91	}
73	};	92	};
74		93
75	private static InstalledFileLocator[] instances = null;	94	private static InstalledFileLocator[] instances = null;
Lines 108-116 Link Here
108	* useful where a directory can contain many items that may be merged between e.g.	127	* useful where a directory can contain many items that may be merged between e.g.
109	* the installation and user directories. For example, the <samp>docs</samp> folder	128	* the installation and user directories. For example, the <samp>docs</samp> folder
110	* (used e.g. for Javadoc) might contain several ZIP files in both the installation and	129	* (used e.g. for Javadoc) might contain several ZIP files in both the installation and
111	* user areas. There is currently no supported way to enumerate all such files. Therefore	130	* user areas. Use {@link #locateAll} if you need all results. The module may assume
112	* searching for a directory should be attempted only when there is just one module which
113	* is expected to provide that directory and all of its contents. The module may assume
114	* that all contained files are in the same relative structure in the directory as in	131	* that all contained files are in the same relative structure in the directory as in
115	* the normal NBM-based installation; unusual locator implementations may need to create	132	* the normal NBM-based installation; unusual locator implementations may need to create
116	* temporary directories with matching structures to return from this method, in case the	133	* temporary directories with matching structures to return from this method, in case the
Lines 182-187 Link Here
182	* @return the requested <code>File</code>, if it can be found, else <code>null</code>	199	* @return the requested <code>File</code>, if it can be found, else <code>null</code>
183	*/	200	*/
184	public abstract File locate(String relativePath, String codeNameBase, boolean localized);	201	public abstract File locate(String relativePath, String codeNameBase, boolean localized);
		202
		203	/**
		204	* Similar to {@link #locate} but can return multiple results.
		205	* The default implementation returns a list with zero or one elements according to {@link #locate}.
		206	* @param relativePath a path from install root
		207	* @param codeNameBase name of the supplying module or null
		208	* @param localized true to perform a localized/branded search
		209	* @return a (possibly empty) set of files
		210	* @since XXX
		211	*/
		212	public Set<File> locateAll(String relativePath, String codeNameBase, boolean localized) {
		213	File f = locate(relativePath, codeNameBase, localized);
		214	return f != null ? Collections.singleton(f) : Collections.<File>emptySet();
		215	}
185		216
186	/**	217	/**
187	* Get a master locator.	218	* Get a master locator.

Return to bug 113341

Lines 417-463 Link Here

(-)a/core.startup/src/org/netbeans/core/startup/NbInstaller.java (-38 / +2 lines)
417	if (instClazz != null) {	417	if (instClazz != null) {
418	ModuleInstall inst = SharedClassObject.findObject(instClazz, true);	418	ModuleInstall inst = SharedClassObject.findObject(instClazz, true);
419	if (load) {	419	if (load) {
420	if (moduleList != null) {	420	ev.log(Events.RESTORE, m);
421	moduleList.installPrepare(m, inst);	421	inst.restored();
422	}
423	// restore, install, or upgrade as appropriate
424	Object history = m.getHistory();
425	if (history instanceof ModuleHistory) {
426	ModuleHistory h = (ModuleHistory)history;
427	if (h.isPreviouslyInstalled()) {
428	// Check whether we have changed versions.
429	SpecificationVersion oldSpec = h.getOldSpecificationVersion();
430	SpecificationVersion nueSpec = m.getSpecificationVersion();
431	if (m.getCodeNameRelease() != h.getOldMajorVersion() \|\|
432	(oldSpec == null ^ nueSpec == null) \|\|
433	(oldSpec != null && nueSpec != null && oldSpec.compareTo(nueSpec) != 0)) {
434	// Yes, different version; upgrade from the old one.
435	ev.log(Events.UPDATE, m);
436	inst.updated(h.getOldMajorVersion(), oldSpec == null ? null : oldSpec.toString());
437	} else {
438	// Same version as before.
439	ev.log(Events.RESTORE, m);
440	inst.restored();
441	}
442	} else {
443	// First time.
444	ev.log(Events.INSTALL, m);
445	inst.installed();
446	}
447	} else {
448	// Probably fixed module. Just restore.
449	ev.log(Events.RESTORE, m);
450	inst.restored();
451	}
452	if (moduleList != null) {
453	moduleList.installPostpare(m, inst);
454	}
455	} else {	422	} else {
456	ev.log(Events.UNINSTALL, m);	423	ev.log(Events.UNINSTALL, m);
457	inst.uninstalled();	424	inst.uninstalled();
458	if (m.getHistory() instanceof ModuleHistory) {
459	((ModuleHistory)m.getHistory()).resetHistory();
460	}
461	}	425	}
462	}	426	}
463	}	427	}

Lines 47-72 Link Here

(-)a/core.startup/src/org/netbeans/core/startup/ModuleHistory.java (-80 / +1 lines)
47	// and ModuleInfo-related things). Should be possible to use without	47	// and ModuleInfo-related things). Should be possible to use without
48	// the rest of core.	48	// the rest of core.
49		49
50	import org.openide.modules.SpecificationVersion;
51
52	/** Representation of the history of the module.	50	/** Representation of the history of the module.
53	* This includes information such as: whether the module
54	* has been installed before and now just needs to be restored
55	* (or in fact where it was installed); the previous version
56	* of the module, in case it needs to be upgraded.
57	* Used for communication
58	* between the module lister and the module installer.
59	* @author Jesse Glick	51	* @author Jesse Glick
60	*/	52	*/
61		53	// XXX no longer useful, could probably delete, and deprecate Module.history
62	public final class ModuleHistory {	54	public final class ModuleHistory {
63		55
64	private final String jar;	56	private final String jar;
65	private int oldMajorVers;
66	private SpecificationVersion oldSpecVers;
67	private boolean upgraded;
68	private byte[] installerState;
69	private boolean installerStateChanged = false;
70		57
71	/** Create a module history with essential information.	58	/** Create a module history with essential information.
72	* You also need to specify a relative or absolute JAR name.	59	* You also need to specify a relative or absolute JAR name.
Lines 74-83 Link Here
74	public ModuleHistory(String jar) {	61	public ModuleHistory(String jar) {
75	assert jar != null;	62	assert jar != null;
76	this.jar = jar;	63	this.jar = jar;
77	upgraded = false;
78	oldMajorVers = -1;
79	oldSpecVers = null;
80	installerState = null;
81	}	64	}
82		65
83	/**	66	/**
Lines 88-153 Link Here
88	return jar;	71	return jar;
89	}	72	}
90		73
91	/** True if this module has been installed before. */
92	boolean isPreviouslyInstalled() {
93	return upgraded;
94	}
95
96	/** The old major version of the module,
97	* before an upgrade.
98	* -1 if unspecified, or it has never been installed before.
99	*/
100	int getOldMajorVersion() {
101	return oldMajorVers;
102	}
103
104	/** The old specification version of the module,
105	* before an upgrade.
106	* null if unspecified, or it has never been installed before.
107	*/
108	SpecificationVersion getOldSpecificationVersion() {
109	return oldSpecVers;
110	}
111
112	/** Signal that a module has been previously installed,
113	* marking it as a possible candidate for upgrade.
114	*/
115	void upgrade(int oldMajorVersion, SpecificationVersion oldSpecificationVersion) {
116	upgraded = true;
117	oldMajorVers = oldMajorVersion;
118	oldSpecVers = oldSpecificationVersion;
119	}
120
121	/** Get the stored state of the ModuleInstall, if any.
122	* Currently this would be a serialized bytestream.
123	* null if unknown or there was no stored state.
124	*/
125	byte[] getInstallerState() {
126	return installerState;
127	}
128
129	/** Set the stored state of the ModuleInstall.
130	* This may be null to indicate that no state
131	* needs to be stored. Otherwise it would currently
132	* be a serialized bytestream.
133	*/
134	void setInstallerState(byte[] state) {
135	if (installerState != null && state != null) {
136	installerStateChanged = true;
137	}
138	installerState = state;
139	}
140
141	/** True if the state of the installer has changed dynamically. */
142	boolean getInstallerStateChanged() {
143	return installerStateChanged;
144	}
145
146	/** Reset history after an uninstall. */
147	void resetHistory() {
148	upgraded = false;
149	installerState = null;
150	installerStateChanged = false;
151	}
152
153	}	74	}

Lines 47-53 Link Here

(-)a/nbbuild/antsrc/org/netbeans/nbbuild/CreateModuleXML.java (-15 lines)
47	import java.util.jar.*;	47	import java.util.jar.*;
48	import java.io.*;	48	import java.io.*;
49	import java.util.zip.ZipEntry;	49	import java.util.zip.ZipEntry;
50	import org.apache.tools.ant.types.Mapper;
51		50
52	/** Create XML files corresponding to the set of known modules	51	/** Create XML files corresponding to the set of known modules
53	* without actually running the IDE.	52	* without actually running the IDE.
Lines 206-222 Link Here
206	}	205	}
207	int idx = codename.lastIndexOf('/');	206	int idx = codename.lastIndexOf('/');
208	String codenamebase;	207	String codenamebase;
209	int rel;
210	if (idx == -1) {	208	if (idx == -1) {
211	codenamebase = codename;	209	codenamebase = codename;
212	rel = -1;
213	} else {	210	} else {
214	codenamebase = codename.substring(0, idx);	211	codenamebase = codename.substring(0, idx);
215	try {
216	rel = Integer.parseInt(codename.substring(idx + 1));
217	} catch (NumberFormatException e) {
218	throw new BuildException("Invalid OpenIDE-Module '" + codename + "' in " + module, getLocation());
219	}
220	}	212	}
221	File xml = new File(xmldir, codenamebase.replace('.', '-') + ".xml");	213	File xml = new File(xmldir, codenamebase.replace('.', '-') + ".xml");
222	if (xml.exists()) {	214	if (xml.exists()) {
Lines 262-268 Link Here
262	displayname = codename;	254	displayname = codename;
263	}	255	}
264	names.add(displayname);	256	names.add(displayname);
265	String spec = attr.getValue("OpenIDE-Module-Specification-Version");
266	if (isHidden) {	257	if (isHidden) {
267	File h = new File(xml.getParentFile(), xml.getName() + "_hidden");	258	File h = new File(xml.getParentFile(), xml.getName() + "_hidden");
268	h.createNewFile();	259	h.createNewFile();
Lines 282-294 Link Here
282	pw.println(" <param name=\"enabled\">" + isEnabled + "</param>");	273	pw.println(" <param name=\"enabled\">" + isEnabled + "</param>");
283	}	274	}
284	pw.println(" <param name=\"jar\">" + kid.replace(File.separatorChar, '/') + "</param>");	275	pw.println(" <param name=\"jar\">" + kid.replace(File.separatorChar, '/') + "</param>");
285	if (rel != -1) {
286	pw.println(" <param name=\"release\">" + rel + "</param>");
287	}
288	pw.println(" <param name=\"reloadable\">false</param>");	276	pw.println(" <param name=\"reloadable\">false</param>");
289	if (spec != null) {
290	pw.println(" <param name=\"specversion\">" + spec + "</param>");
291	}
292	pw.println("</module>");	277	pw.println("</module>");
293	pw.flush();	278	pw.flush();
294	pw.close();	279	pw.close();