// Never try to cache reloadable JARs.

import java.io.File;

import java.io.IOException;

import java.util.jar.JarFile;

import java.util.jar.Manifest;

    }

    /** Scan a disabled module JAR file for its manifest contents.

     * Subclasses may implement this efficiently, e.g. to use a special cache.

     * <p>The default implementation simply opens the JAR and gets its manifest

     * using the standard JRE calls.

     * <p>Never called for reloadable JARs.

     * @param jar a module JAR to open

     * @return its manifest

     * @throws IOException if the JAR cannot be opened or does not have a manifest at all

     * @since org.netbeans.core/1 1.5

     * @see #26786

     */

    public Manifest loadManifest(File jar) throws IOException {

        JarFile jarFile = new JarFile(jar, false);

        try {

            Manifest m = jarFile.getManifest();

            if (m == null) throw new IOException("No manifest found in " + jar); // NOI18N

            return m;

        } finally {

            jarFile.close();

        }

    // Again, access from Module to ModuleInstaller:

    Manifest loadManifest(File jar) throws IOException {

        return installer.loadManifest(jar);

    }

import java.util.jar.Manifest;

        maybeSaveManifestCache();

        }

    }

    // Manifest caching: #26786.

    /** The actual file where the manifest cache is stored,

     * or null if it will not be used.

     * Binary format:

     * Sequence of records, one per cached manifest; no particular order.

     * Record:

     * 1. Absolute JAR path, UTF-8.

     * 2. Null byte.

     * 3. Last modification time of JAR, System.currentTimeMillis format, big-endian (8-byte long).

     * 4. The manifest body.

     * 5. Null byte.

     */

    private File manifestCacheFile;

    /** While true, try to use the manifest cache.

     * So (non-reloadable) JARs scanned during startup will have their manifests cached.

     * After the primary set of modules has been scanned, this will be set to false.

     * Initially true, unless -J-Dnetbeans.cache.manifests=false is specified,

     * or there is no available cache directory.

     */

    private boolean usingManifestCache;

    {

        usingManifestCache = Boolean.valueOf(System.getProperty("netbeans.cache.manifests", "true")).booleanValue();

        if (usingManifestCache) {

            String userdir = System.getProperty("netbeans.user");

            if (userdir != null) {

                manifestCacheFile = new File(new File(new File(userdir), "cache"), "all-manifests.dat"); // NOI18N

                Util.err.log("Using manifest cache in " + manifestCacheFile);

            } else {

                // Some special startup mode, e.g. with Plain.

                usingManifestCache = false;

                Util.err.log("Not using any manifest cache; no user directory");

            }

        } else {

            Util.err.log("Manifest cache disabled");

        }

    }

    /** Cache of known JAR manifests.

     * Initially null. If the cache is read, it may be used to quickly serve JAR manifests.

     * Each JAR file is mapped to a two-element array consisting of

     * its modification date when last read; and the manifest itself.

     */

    private Map manifestCache = null; // Map<File,[Date,Manifest]>

    /** If true, at least one manifest has had to be read explicitly.

     * This might be because the cache did not initially exist;

     * or the JAR was not present in the cache;

     * or the JAR was present but did not match the cache timestamp.

     */

    private boolean manifestCacheDirty = false;

    // XXX consider logging using Events

    /** Overrides superclass method to keep a cache of module manifests,

     * so that their JARs do not have to be opened twice during startup.

     */

    public Manifest loadManifest(File jar) throws IOException {

        if (!usingManifestCache) {

            return super.loadManifest(jar);

        }

        if (manifestCache == null) {

            manifestCache = loadManifestCache(manifestCacheFile);

        }

        Object[] entry = (Object[])manifestCache.get(jar);

        if (entry != null) {

            if (((Date)entry[0]).getTime() == jar.lastModified()) {

                // Cache hit.

                Util.err.log("Found manifest for " + jar + " in cache");

                return (Manifest)entry[1];

            } else {

                Util.err.log("Wrong timestamp for " + jar + " in manifest cache");

            }

        } else {

            Util.err.log("No entry for " + jar + " in manifest cache");

        }

        // Cache miss.

        Manifest m = super.loadManifest(jar);

        // (If that threw IOException, we leave it out of the cache.)

        manifestCache.put(jar, new Object[] {new Date(jar.lastModified()), m});

        manifestCacheDirty = true;

        return m;

    }

    /** If the manifest cache had been in use, and is now dirty, write it to disk.

     */

    private void maybeSaveManifestCache() {

        if (usingManifestCache && manifestCacheDirty) {

            try {

                saveManifestCache(manifestCache, manifestCacheFile);

            } catch (IOException ioe) {

                Util.err.notify(ErrorManager.WARNING, ioe);

            }

            usingManifestCache = false;

            manifestCacheDirty = false;

            manifestCache = null;

            manifestCacheFile = null;

        }

    }

    /** Really save the cache.

     * @see #manifestCacheFile

     */

    private void saveManifestCache(Map manifestCache, File manifestCacheFile) throws IOException {

        Util.err.log("Saving manifest cache");

        manifestCacheFile.getParentFile().mkdirs();

        OutputStream os = new FileOutputStream(manifestCacheFile);

        try {

            try {

                os = new BufferedOutputStream(os);

                Iterator it = manifestCache.entrySet().iterator();

                while (it.hasNext()) {

                    Map.Entry e = (Map.Entry)it.next();

                    File jar = (File)e.getKey();

                    Object[] v = (Object[])e.getValue();

                    long time = ((Date)v[0]).getTime();

                    Manifest m = (Manifest)v[1];

                    os.write(jar.getAbsolutePath().getBytes("UTF-8")); // NOI18N

                    os.write(0);

                    for (int i = 7; i >= 0; i--) {

                        os.write((int)((time >> (i * 8)) & 0xFF));

                    }

                    m.write(os);

                    os.write(0);

                }

            } finally {

                os.close();

            }

        } catch (IOException ioe) {

            // Do not leave behind a bogus half-written file.

            manifestCacheFile.delete();

            throw ioe;

        }

    }

    /** Load the cache if present.

     * If not present, or there are problems with it,

     * just create an empty cache.

     * @see #manifestCacheFile

     */

    private Map loadManifestCache(File manifestCacheFile) {

        if (!manifestCacheFile.canRead()) {

            Util.err.log("No manifest cache found at " + manifestCacheFile);

            return new HashMap(200);

        }

        ev.log(Events.PERF_START, "NbInstaller - loadManifestCache"); // NOI18N

        try {

            InputStream is = new FileInputStream(manifestCacheFile);

            try {

                BufferedInputStream bis = new BufferedInputStream(is);

                Map m = new HashMap(200);

                while (true) {

                    bis.mark(1);

                    if (bis.read() == -1) {

                        break;

                    }

                    bis.reset();

                    readManifestCacheEntry(bis, m);

                }

                tmpbuf = null;

                return m;

            } finally {

                is.close();

                ev.log(Events.PERF_END, "NbInstaller - loadManifestCache"); // NOI18N

            }

        } catch (IOException ioe) {

            Util.err.annotate(ioe, ErrorManager.UNKNOWN, "While reading: " + manifestCacheFile, null, null, null); // NOI18N

            Util.err.notify(ErrorManager.WARNING, ioe);

            return new HashMap(200);

        }

    }

    /** buf to be filled, starting at beginning of array */

    private byte[] tmpbuf;

    /** bytes successfully read into buf */

    private int pos;

    private void readUpTillNullByte(InputStream is) throws IOException {

        if (tmpbuf == null) {

            tmpbuf = new byte[4096];

        }

        final int size = tmpbuf.length;

        pos = 0;

        while (true) {

            final int toread = size - pos;

            is.mark(toread);

            int read = is.read(tmpbuf, pos, toread);

            if (read == -1) throw new IOException("EOF"); // NOI18N

            int end = pos + read;

            for (int i = pos; i < end; i++) {

                if (tmpbuf[i] == 0) {

                    // It fit into the 4k buffer (as it usually will, I hope).

                    pos = i;

                    is.reset();

                    while (true) {

                        int toskip = i + 1;

                        long s = is.skip(toskip);

                        if (s == 0 || s > toskip) throw new IOException("Cannot skip"); // NOI18N

                        toskip -= s;

                        if (toskip == 0) break;

                    }

                    return;

                }

            }

            // Did not read the null byte.

            if (read < toread) {

                // Neither filled the buffer nor got to the null byte.

                pos = end;

            } else {

                // Did not fit, try again.

                byte[] tmpbuf2 = new byte[size * 2];

                System.arraycopy(tmpbuf, 0, tmpbuf2, 0, size);

                pos = size;

                tmpbuf = tmpbuf2;

            }

            // continue reading

        }

    }

    private void readManifestCacheEntry(InputStream is, Map m) throws IOException {

        readUpTillNullByte(is);

        File jar = new File(new String(tmpbuf, 0, pos, "UTF-8")); // NOI18N

        long time = 0L;

        for (int i = 7; i >= 0; i--) {

            time |= (((long)is.read()) << (i * 8));

        }

        readUpTillNullByte(is);

        Manifest mani = new Manifest(new ByteArrayInputStream(tmpbuf, 0, pos));

        m.put(jar, new Object[] {new Date(time), mani});

        if (Util.err.isLoggable(ErrorManager.INFORMATIONAL)) {

            Util.err.log("Manifest cache entry: jar=" + jar + " date=" + new Date(time) + " codename=" + mani.getMainAttributes().getValue("OpenIDE-Module"));