Attachment #49619 for bug #116891

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 116891
Collapse All | Expand All

Lines 688-694 Link Here

(-)core/startup/src/org/netbeans/core/startup/AutomaticDependencies.java (-2 / +2 lines)
688		688
689	private static final class Parser implements ContentHandler, ErrorHandler, EntityResolver {	689	private static final class Parser implements ContentHandler, ErrorHandler, EntityResolver {
690		690
691	private java.lang.StringBuffer buffer;	691	private StringBuilder buffer;
692		692
693	private Handler handler;	693	private Handler handler;
694		694
Lines 696-702 Link Here
696		696
697	public Parser(final Handler handler) {	697	public Parser(final Handler handler) {
698	this.handler = handler;	698	this.handler = handler;
699	buffer = new StringBuffer(111);	699	buffer = new StringBuilder(111);
700	context = new java.util.Stack<Object[]>();	700	context = new java.util.Stack<Object[]>();
701	}	701	}
702		702




import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.CharArrayWriter;

import java.io.FileNotFoundException;
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.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeMap;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import org.netbeans.DuplicateException;
import org.netbeans.Events;

import org.openide.modules.InstalledFileLocator;
import org.openide.modules.ModuleInstall;
import org.openide.modules.SpecificationVersion;
import org.openide.util.Exceptions;
import org.openide.util.RequestProcessor;
import org.openide.util.Utilities;
import org.openide.util.WeakSet;

    private boolean triggered = false;
    /** listener for changes in modules, etc.; see comment on class Listener */
    private final Listener listener = new Listener();
    
    /** Read some stuff from a stream and skip over it.
     * Newline conventions are normalized to Unix \n.
     * @return true upon success, false if stream contained something else
     */
    private boolean expect(InputStream is, byte[] stuff) throws IOException {
        int len = stuff.length;
        boolean inNewline = false;
        for (int i = 0; i < len; ) {
            int c = is.read();
            if (c == 10 || c == 13) {
                // Normalize: s/[\r\n]+/\n/g
                if (inNewline) {
                    continue;
                } else {
                    inNewline = true;
                    c = 10;
                }
            } else {
                inNewline = false;
            }
            if (c != stuff[i++]) {
                return false;
            }
        }
        if (stuff[len - 1] == 10) {
            // Expecting something ending in a \n - so we have to
            // read any further \r or \n and discard.
            if (!is.markSupported()) throw new IOException("Mark not supported"); // NOI18N
            is.mark(1);
            int c = is.read();
            if (c != -1 && c != 10 && c != 13) {
                // Got some non-newline character, push it back!
                is.reset();
            }
        }
        return true;
    }
    /** 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));
    private static final String CACHE_FILE_NAME = "modules.cache";
    /** Create the list manager.
     * @param mgr the module manager which will actually control the modules at runtime
     * @param folder the Modules/ folder on the system file system to scan/write

        Util.err.fine("ModuleList created, storage in " + folder);
    }
    
    private boolean errorsLoadingModules = false;
    private FileObject getCacheFile(boolean create) {
        FileObject result = folder.getFileObject(CACHE_FILE_NAME);
        if (result == null && create) {
            try {
                result = folder.createData(CACHE_FILE_NAME);
            } catch (IOException ex) {
                throw new IllegalStateException (ex);
            }
        }
        return result;
    }
    
    private boolean isCacheUpToDate() {
        FileObject cacheFile = getCacheFile(false);
        if (cacheFile == null) {
            return false;
        }
        long date = cacheFile.lastModified().getTime();
        boolean result = true;
        for (FileObject fo : folder.getChildren()) {
            result &= (fo.lastModified().getTime() <= date);
            if (!result) {
                break;
            }
        }
        return result;
    }

    public void deleteCacheFile() {
        FileObject ob = getCacheFile(false);
        if (ob != null) {
            try {
                System.err.println("Deleting module xml cache");
                ob.delete();
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }
    
    private void writeCacheFile(Collection <Map <String, Object>> data) throws IOException {
        if (errorsLoadingModules) {
            //If some module failed to load, we do not want to write a cache
            //containing partial data!  Otherwise it will silently never be
            //loaded for eternity.
            deleteCacheFile();
            return;
        }
        FileObject ob = getCacheFile(true);
        
        FileLock lock = ob.lock();
        ObjectOutputStream str = new ObjectOutputStream (new BufferedOutputStream(ob.getOutputStream(lock)));
        try {
            str.writeObject(data);
        } finally {
            str.close();
            lock.releaseLock();
        }
    }
    
    private Collection <Map <String, Object>> loadCacheData() {
        FileObject obj = getCacheFile(false);
        if (obj != null) {
            try {
                ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(obj.getInputStream()));
                return (Collection<Map <String, Object>>) in.readObject();
            } catch (Exception ex) {
                Exceptions.printStackTrace(ex);
                return null;
            }
        }
        return null;
    }
    
    /** Read an initial list of modules from disk according to their stored settings.
     * Just reads the XML files in the Modules/ directory, and adds those to
     * the manager's list of modules. Errors are handled internally.

     * enable as needed. All discovered modules are returned.
     * Write mutex only.
     */
    public Set <Module> readInitial() {
        ev.log(Events.START_READ);
        if (isCacheUpToDate()) {
            return readFromCache();
        } else {
            return readFromXml();
        }
    }

    private Set<Module> readFromCache() {
         Set<Module> read = new HashSet<Module>();
         Collection <Map<String, Object>> data = loadCacheData();
         final boolean[] en = new boolean[1];
         ev.log( Events.MODULES_FILE_SCANNED, data.size() );
outer:   for (Map <String, Object> props : data) {
             for (Map.Entry <String, Object> e : props.entrySet()) {
                String name = (String) props.get("name");
                String nameDashes = name.replace ('.', '-');
                FileObject file = folder.getFileObject (nameDashes + ".xml");
                assert file != null;
                Module m = null;
                try {
                    m = buildModule (props, name, nameDashes, file, en);
                } catch (Exception ex) {
                    Exceptions.printStackTrace(ex);
                    //Cache data probably bad
                    errorsLoadingModules = true;
                    deleteCacheFile();
                    continue outer;
                }
                if (m == null) {
                    continue outer;
                }
                boolean enabled = en[0];

                read.add(m);
                DiskStatus status = new DiskStatus();
                status.module = m;
                status.file = file;
                //status.lastApprovedChange = children[i].lastModified().getTime();
                status.pendingInstall = enabled;
                // Will only really be flushed if mgr props != disk props, i.e
                // if version changed or could not be enabled.
                //status.pendingFlush = true;
                status.diskProps = props;
                statuses.put(name, status);
                ev.log( Events.MODULES_FILE_PROCESSED, file );
             }
        }
        // Handle changes in the Modules/ folder on disk by parsing & applying them.
        folder.addFileChangeListener(FileUtil.weakFileChangeListener (listener, 
                folder));
        ev.log(Events.FINISH_READ, read);
        return read;
    }
    
    private Set<Module> readFromXml() {
        final Set<Module> read = new HashSet<Module>();
        try {
            folder.getFileSystem().runAtomicAction(new FileSystem.AtomicAction() {

        ev.log( Events.MODULES_FILE_SCANNED, children.length );

	XMLReader reader = null;
        List <Map <String, Object>> toCache = new ArrayList <Map <String, Object>> (children.length);
	final boolean[] en = new boolean[1];
        for (int i = 0; i < children.length; i++) {
            if (children[i].hasExt("ser")) { // NOI18N
                // Fine, skip over.

                // Assume this is one of ours. Note fixed naming scheme.
                try {
                    String nameDashes = children[i].getName(); // NOI18N
                    char[] chars = nameDashes.toCharArray();
                    for (int j=0; j < chars.length; j++) {
                        switch (chars[j]) {
                            case '.':
                            case '/' :
                            case '>' :
                            case '=' :
                                throw new IllegalArgumentException("Bad " +
                                        "name: " + nameDashes); // NOI18N
                            case '-' :
                                chars[j] = '.';
                            default:
                                continue;
                        }
                    }
                    String name = new String(chars).intern();
                    // Now name is the code name base of the module we expect to find.
                    // Check its format (throws IllegalArgumentException if bad):
                    Dependency.create(Dependency.TYPE_MODULE, name);

                    } finally {
                        is.close();
                    }
                    toCache.add (props);
                    if (! name.equals(props.get("name"))) throw new IOException("Code name mismatch: " /* #25011 */ + name + " vs. " + props.get("name")); // NOI18N
                    Module m = buildModule (props, name, nameDashes, children[i], en);
                    if (m == null) {
                        continue;
                    }
                    boolean enabled = en[0];
                    read.add(m);
                    DiskStatus status = new DiskStatus();
                    status.module = m;
                    status.file = children[i];
                    //status.lastApprovedChange = children[i].lastModified().getTime();
                    status.pendingInstall = enabled;
                    // Will only really be flushed if mgr props != disk props, i.e
                    // if version changed or could not be enabled.
                    //status.pendingFlush = true;
                    status.diskProps = props;
                    statuses.put(name, status);
                } catch (Exception e) {
                    Util.err.log(Level.WARNING, "Error encountered while reading " + children[i], e);
                    errorsLoadingModules = true;
                }
            } else {
                Util.err.fine("Strange file encountered in modules folder: " + children[i]);
            }
            ev.log( Events.MODULES_FILE_PROCESSED, children[i] );
        }
        try {
            writeCacheFile(toCache);
        } catch (Exception e) {
            Exceptions.printStackTrace(e);
        }
        if (Util.err.isLoggable(Level.FINE)) {
            Util.err.fine("read initial XML files: statuses=" + statuses);
        }
        ev.log(Events.FINISH_READ, read);
                }});
        } catch (IOException ioe) {
            Util.err.log(Level.WARNING, null, ioe);
        }
        return read;
    }
    
    private Module buildModule (Map <String, Object> props, String name, String nameDashes, FileObject fob, boolean[] en) throws IOException, DuplicateException {
            Module m = mgr.get(name);
            if (m != null) {
                return m;
            }
                    String jar = (String)props.get("jar"); // NOI18N
                    File jarFile;
                    try {

                        //Util.err.fine("Cannot find: " + fnfe.getMessage());
                        ev.log(Events.MISSING_JAR_FILE, new File(fnfe.getMessage()));
                        try {
                    fob.delete();
                        } catch (IOException ioe) {
                            Util.err.log(Level.WARNING, null, ioe);
                        }
                return null;
                    }

                    ModuleHistory history = new ModuleHistory(jar); // NOI18N

                    boolean reloadable = (reloadableB != null ? reloadableB.booleanValue() : false);
                    Boolean enabledB = (Boolean)props.get("enabled"); // NOI18N
                    boolean enabled = (enabledB != null ? enabledB.booleanValue() : false);
            en[0] = enabled;
                    Boolean autoloadB = (Boolean)props.get("autoload"); // NOI18N
                    boolean autoload = (autoloadB != null ? autoloadB.booleanValue() : false);
                    Boolean eagerB = (Boolean)props.get("eager"); // NOI18N

                        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); // NOI18N
                        // Hope the stored state is not >Integer.MAX_INT! :-)
                        byte[] buf = new byte[(int)installerSer.getSize()];
                        InputStream is2 = installerSer.getInputStream();

                        // Quasi-prop which is stored separately.
                        props.put("installerState", buf); // NOI18N
                    }
            if (m == null) {
                m = mgr.create(jarFile, history, reloadable, autoload, eager);
                    DiskStatus status = new DiskStatus();
                    status.module = m;
                    status.file = children[i];
                    //status.lastApprovedChange = children[i].lastModified().getTime();
                    status.pendingInstall = enabled;
                    // Will only really be flushed if mgr props != disk props, i.e
                    // if version changed or could not be enabled.
                    //status.pendingFlush = true;
                    status.diskProps = props;
                    statuses.put(name, status);
                } catch (Exception e) {
                    Util.err.log(Level.WARNING, "Error encountered while reading " + children[i], e);
                }
            return m;
                Util.err.fine("Strange file encountered in modules folder: " + children[i]);
            }
            ev.log( Events.MODULES_FILE_PROCESSED, children[i] );
        }
        if (Util.err.isLoggable(Level.FINE)) {
            Util.err.fine("read initial XML files: statuses=" + statuses);
        }
        ev.log(Events.FINISH_READ, read);
        // Handle changes in the Modules/ folder on disk by parsing & applying them.
        folder.addFileChangeListener(FileUtil.weakFileChangeListener (listener, folder));
                }});
        } catch (IOException ioe) {
            Util.err.log(Level.WARNING, null, ioe);
        }
        return read;
    }
    
    /**
     * Try to find a module JAR by an XML-supplied name.

        }
        try {
            mgr.enable(modules);
            /*
            //dangerous but potential perf improvement on multi-core machines.
            //Certainly unhelpful on single cpu, but worth thinking about
            //To make this work we really need to walk the dep tree to preserve
            //ordering and build sets that can be enabled separately
            int threadCount = 2;
            final ExecutorService service = Executors.newFixedThreadPool(threadCount);
            final Object lock = new Object();
            final int[] count = new int[] { threadCount };
            class R implements Callable <Void> {
                private final Set <Module> myModules;
                private final R next;
                R (R next, Set <Module> myModules) {
                    this.myModules = myModules;
                    this.next = next;
                }
                
                public Void call() throws Exception {
                    System.err.println("Enabling " + myModules + " on " + Thread.currentThread());
                    mgr.enable(myModules);
                    synchronized (lock) {
                        count[0]--;
                        if (count[0] == 0) {
                            lock.notifyAll();
                        }
                    }
                    return null;
                }
                
                public void start() throws InvalidException {
                    if (next == null) {
                        try {
                            call();
                        } catch (Exception e) {
                            if (e instanceof InvalidException) {
                                throw (InvalidException) e;
                            } else {
                                Exceptions.printStackTrace(e);
                                //XXX hard to debug
                                throw new InvalidException ("");
                            }
                        }
                    } else {
                        service.submit(this);
                        next.start();
                    }
                }
            }
            R prev = null;
            int ix = 0;
            int modulesPerThread = modules.size() / threadCount;
            Set <Module> curr = new HashSet <Module> (modulesPerThread);
            for (Iterator <Module> iter = modules.iterator(); iter.hasNext(); ix++) {
                curr.add (iter.next());
                if ((ix % modulesPerThread) == 0 || !it.hasNext()) {
                    prev = new R (prev, curr);
                    curr = new HashSet <Module> (modulesPerThread);
                }
            }
            if (prev != null) {
                //Will cascade and run the last one in this thread
                prev.start();
            }
            synchronized (lock) {
                while (count[0] > 0) {
                    lock.wait();
                }
            }
        } catch (InterruptedException ex) {
            Exceptions.printStackTrace(ex);
             */
        } catch (InvalidException ie) {
            Util.err.log(Level.WARNING, null, ie);
            Module bad = ie.getModule();

        DefaultHandler handler = new DefaultHandler() {
            private String modName;
            private String paramName;
            private StringBuilder data = new StringBuilder();
	    
            public void startElement(String uri,
                                     String localname,

        sanityCheckStatus(m);
        return m;
    }
    
    /** Read some stuff from a stream and skip over it.
     * Newline conventions are normalized to Unix \n.
     * @return true upon success, false if stream contained something else
     */
    private boolean expect(InputStream is, byte[] stuff) throws IOException {
        int len = stuff.length;
        boolean inNewline = false;
        for (int i = 0; i < len; ) {
            int c = is.read();
            if (c == 10 || c == 13) {
                // Normalize: s/[\r\n]+/\n/g
                if (inNewline) {
                    continue;
                } else {
                    inNewline = true;
                    c = 10;
                }
            } else {
                inNewline = false;
            }
            if (c != stuff[i++]) {
                return false;
            }
        }
        if (stuff[len - 1] == 10) {
            // Expecting something ending in a \n - so we have to
            // read any further \r or \n and discard.
            if (!is.markSupported()) throw new IOException("Mark not supported"); // NOI18N
            is.mark(1);
            int c = is.read();
            if (c != -1 && c != 10 && c != 13) {
                // Got some non-newline character, push it back!
                is.reset();
            }
        }
        return true;
    }
    /** Read a maximal string until delim is encountered (which will be removed from stream).
     * This impl reads only ASCII, for speed.
     * Newline conventions are normalized to Unix \n.




            Module m = (Module)args[0];
            // ignore args[1]: InvalidException
            {
                StringBuilder buf = new StringBuilder(NbBundle.getMessage(NbEvents.class, "MSG_failed_install_new_unexpected", m.getDisplayName()));
                NbProblemDisplayer.problemMessagesForModules(buf, Collections.singleton(m), false);
                logger.log(Level.INFO, buf.toString());
            }

            {
                StringBuilder buf = new StringBuilder(NbBundle.getMessage(NbEvents.class, "MSG_failed_install_new_unexpected", m.getDisplayName()));
                NbProblemDisplayer.problemMessagesForModules(buf, Collections.singleton(m), true);
                notify(buf.toString(), true);
            }

            if (! Boolean.getBoolean("netbeans.moduleitem.dontverifyclassloader") && Util.err.isLoggable(Level.WARNING)) { // NOI18N
                Class clazz = (Class)args[1];
                // Message for developers, no need for I18N.
                StringBuilder b = new StringBuilder();
                b.append("The module " + ((Module)args[0]).getDisplayName() + " loaded the class " + clazz.getName() + "\n"); // NOI18N
                b.append("from the wrong classloader. The expected classloader was " + args[2] + "\n"); // NOI18N
                b.append("whereas it was actually loaded from " + clazz.getClassLoader() + "\n"); // NOI18N




        for (String[] cpjar : CLASSPATH_JARS) {
            if (kosher != null && name.startsWith(cpjar[0])) {
                // Restricted JAR.
                StringBuilder entry = null; // will be set if there are any packages
                for (int k = 1; k < cpjar.length; k++) {
                    String pkg = cpjar[k];
                    if (kosher.contains(pkg)) {
                        // Module is permitted to use this package.
                        if (entry == null) {
                            entry = new StringBuilder(100);
                            entry.append(cpEntry.getAbsolutePath());
                            entry.append('['); // NOI18N
                        } else {

                return;
            }
            // Only certain packages are exported, so list them explicitly.
            StringBuilder b = new StringBuilder(100);
            b.append('['); // NOI18N
            for (int i = 0; i < exports.length; i++) {
                if (i > 0) {

Lines 123-133 Link Here

(-)core/startup/src/org/netbeans/core/startup/Splash.java (-2 / +2 lines)
123	int height = Integer.parseInt(NbBundle.getMessage(Splash.class, "SPLASH_HEIGHT"));	123	int height = Integer.parseInt(NbBundle.getMessage(Splash.class, "SPLASH_HEIGHT"));
124	frame.setPreferredSize(new Dimension(width, height));	124	frame.setPreferredSize(new Dimension(width, height));
125		125
126	SwingUtilities.invokeLater (new SplashRunner(frame, true));	126	EventQueue.invokeLater (new SplashRunner(frame, true));
127	}	127	}
128	}	128	}
129	else {	129	else {
130	SwingUtilities.invokeLater (new SplashRunner(frame, false));	130	EventQueue.invokeLater (new SplashRunner(frame, false));
131	}	131	}
132	}	132	}
133		133




    private static String createBootClassPath() {
        // boot
        String boot = System.getProperty("sun.boot.class.path"); // NOI18N
        StringBuilder sb = (boot != null ? new StringBuilder(boot) : new StringBuilder());
        
        // std extensions
        findBootJars(System.getProperty("java.ext.dirs"), sb);

     * @param extensions null or path list
     * @param sb buffer to put results to
     */
    private static void findBootJars(final String extensions, final StringBuilder sb) {
        if (extensions != null) {
            for (StringTokenizer st = new StringTokenizer(extensions, File.pathSeparator); st.hasMoreTokens();) {
                File dir = new File(st.nextToken());

     */
    private static final class LgStream extends PrintStream implements Runnable {
        private Logger log;
        private StringBuilder sb = new StringBuilder();
        private static RequestProcessor RP = new RequestProcessor("StdErr Flush");
        private RequestProcessor.Task flush = RP.create(this, true);


Return to bug 116891

Lines 1047-1059 Link Here

(-)core/startup/src/org/netbeans/core/startup/NbInstaller.java (-3 / +3 lines)
1047	for (String[] cpjar : CLASSPATH_JARS) {	1047	for (String[] cpjar : CLASSPATH_JARS) {
1048	if (kosher != null && name.startsWith(cpjar[0])) {	1048	if (kosher != null && name.startsWith(cpjar[0])) {
1049	// Restricted JAR.	1049	// Restricted JAR.
1050	StringBuffer entry = null; // will be set if there are any packages	1050	StringBuilder entry = null; // will be set if there are any packages
1051	for (int k = 1; k < cpjar.length; k++) {	1051	for (int k = 1; k < cpjar.length; k++) {
1052	String pkg = cpjar[k];	1052	String pkg = cpjar[k];
1053	if (kosher.contains(pkg)) {	1053	if (kosher.contains(pkg)) {
1054	// Module is permitted to use this package.	1054	// Module is permitted to use this package.
1055	if (entry == null) {	1055	if (entry == null) {
1056	entry = new StringBuffer(100);	1056	entry = new StringBuilder(100);
1057	entry.append(cpEntry.getAbsolutePath());	1057	entry.append(cpEntry.getAbsolutePath());
1058	entry.append('['); // NOI18N	1058	entry.append('['); // NOI18N
1059	} else {	1059	} else {
Lines 1112-1118 Link Here
1112	return;	1112	return;
1113	}	1113	}
1114	// Only certain packages are exported, so list them explicitly.	1114	// Only certain packages are exported, so list them explicitly.
1115	StringBuffer b = new StringBuffer(100);	1115	StringBuilder b = new StringBuilder(100);
1116	b.append('['); // NOI18N	1116	b.append('['); // NOI18N
1117	for (int i = 0; i < exports.length; i++) {	1117	for (int i = 0; i < exports.length; i++) {
1118	if (i > 0) {	1118	if (i > 0) {

Lines 216-222 Link Here

(-)core/startup/src/org/netbeans/core/startup/TopLogging.java (-3 / +3 lines)
216	private static String createBootClassPath() {	216	private static String createBootClassPath() {
217	// boot	217	// boot
218	String boot = System.getProperty("sun.boot.class.path"); // NOI18N	218	String boot = System.getProperty("sun.boot.class.path"); // NOI18N
219	StringBuffer sb = (boot != null ? new StringBuffer(boot) : new StringBuffer());	219	StringBuilder sb = (boot != null ? new StringBuilder(boot) : new StringBuilder());
220		220
221	// std extensions	221	// std extensions
222	findBootJars(System.getProperty("java.ext.dirs"), sb);	222	findBootJars(System.getProperty("java.ext.dirs"), sb);
Lines 228-234 Link Here
228	* @param extensions null or path list	228	* @param extensions null or path list
229	* @param sb buffer to put results to	229	* @param sb buffer to put results to
230	*/	230	*/
231	private static void findBootJars(final String extensions, final StringBuffer sb) {	231	private static void findBootJars(final String extensions, final StringBuilder sb) {
232	if (extensions != null) {	232	if (extensions != null) {
233	for (StringTokenizer st = new StringTokenizer(extensions, File.pathSeparator); st.hasMoreTokens();) {	233	for (StringTokenizer st = new StringTokenizer(extensions, File.pathSeparator); st.hasMoreTokens();) {
234	File dir = new File(st.nextToken());	234	File dir = new File(st.nextToken());
Lines 605-611 Link Here
605	*/	605	*/
606	private static final class LgStream extends PrintStream implements Runnable {	606	private static final class LgStream extends PrintStream implements Runnable {
607	private Logger log;	607	private Logger log;
608	private StringBuffer sb = new StringBuffer();	608	private StringBuilder sb = new StringBuilder();
609	private static RequestProcessor RP = new RequestProcessor("StdErr Flush");	609	private static RequestProcessor RP = new RequestProcessor("StdErr Flush");
610	private RequestProcessor.Task flush = RP.create(this, true);	610	private RequestProcessor.Task flush = RP.create(this, true);
611		611

Lines 138-150 Link Here

(-)core/startup/src/org/netbeans/core/startup/NbEvents.java (-3 / +3 lines)
138	Module m = (Module)args[0];	138	Module m = (Module)args[0];
139	// ignore args[1]: InvalidException	139	// ignore args[1]: InvalidException
140	{	140	{
141	StringBuffer buf = new StringBuffer(NbBundle.getMessage(NbEvents.class, "MSG_failed_install_new_unexpected", m.getDisplayName()));	141	StringBuilder buf = new StringBuilder(NbBundle.getMessage(NbEvents.class, "MSG_failed_install_new_unexpected", m.getDisplayName()));
142	NbProblemDisplayer.problemMessagesForModules(buf, Collections.singleton(m), false);	142	NbProblemDisplayer.problemMessagesForModules(buf, Collections.singleton(m), false);
143	logger.log(Level.INFO, buf.toString());	143	logger.log(Level.INFO, buf.toString());
144	}	144	}
145		145
146	{	146	{
147	StringBuffer buf = new StringBuffer(NbBundle.getMessage(NbEvents.class, "MSG_failed_install_new_unexpected", m.getDisplayName()));	147	StringBuilder buf = new StringBuilder(NbBundle.getMessage(NbEvents.class, "MSG_failed_install_new_unexpected", m.getDisplayName()));
148	NbProblemDisplayer.problemMessagesForModules(buf, Collections.singleton(m), true);	148	NbProblemDisplayer.problemMessagesForModules(buf, Collections.singleton(m), true);
149	notify(buf.toString(), true);	149	notify(buf.toString(), true);
150	}	150	}
Lines 201-207 Link Here
201	if (! Boolean.getBoolean("netbeans.moduleitem.dontverifyclassloader") && Util.err.isLoggable(Level.WARNING)) { // NOI18N	201	if (! Boolean.getBoolean("netbeans.moduleitem.dontverifyclassloader") && Util.err.isLoggable(Level.WARNING)) { // NOI18N
202	Class clazz = (Class)args[1];	202	Class clazz = (Class)args[1];
203	// Message for developers, no need for I18N.	203	// Message for developers, no need for I18N.
204	StringBuffer b = new StringBuffer();	204	StringBuilder b = new StringBuilder();
205	b.append("The module " + ((Module)args[0]).getDisplayName() + " loaded the class " + clazz.getName() + "\n"); // NOI18N	205	b.append("The module " + ((Module)args[0]).getDisplayName() + " loaded the class " + clazz.getName() + "\n"); // NOI18N
206	b.append("from the wrong classloader. The expected classloader was " + args[2] + "\n"); // NOI18N	206	b.append("from the wrong classloader. The expected classloader was " + args[2] + "\n"); // NOI18N
207	b.append("whereas it was actually loaded from " + clazz.getClassLoader() + "\n"); // NOI18N	207	b.append("whereas it was actually loaded from " + clazz.getClassLoader() + "\n"); // NOI18N