Attachment #12377 for bug #32054

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




#                 Sun Public License Notice
# 
# The contents of this file are subject to the Sun Public License
# Version 1.0 (the "License"). You may not use this file except in
# compliance with the License. A copy of the License is available at
# http://www.sun.com/
# 
# The Original Code is NetBeans. The Initial Developer of the Original
# Code is Sun Microsystems, Inc. Portions Copyright 1997-2003 Sun
# Microsystems, Inc. All Rights Reserved.

#Question to show user to find out whether start second instance of NetBeans  or not
MSG_AlreadyRunning=Another version of the program seems to be running. Continue anyway?
MSG_AlreadyRunningTitle=Warning




/*
 *                 Sun Public License Notice
 *
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 *
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2003 Sun
 * Microsystems, Inc. All Rights Reserved.
 */

package org.netbeans;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URL;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;

/**
 * Command Line Interface and User Directory Locker support class.
 * Subclasses may be registered into the system to handle special command-line options.
 * To be registered, use <samp>META-INF/services/org.netbeans.CLIHandler</code>
 * in a JAR file in the startup or dynamic class path (e.g. <samp>lib/ext/</samp>
 * or <samp>lib/</samp>).
 * @author Jaroslav Tulach
 * @since org.netbeans.core/1 1.18
 * @see "#32054"
 * @see <a href="http://openide.netbeans.org/proposals/arch/cli.html">Specification</a>
 */
public abstract class CLIHandler extends Object {
    /** lenght of the key used for connecting */
    private static final int KEY_LENGTH = 10;
    /** ok reply */
    private static final int REPLY_OK = 1;
    /** sends exit code */
    private static final int REPLY_EXIT = 2;
    /** fail reply */
    private static final int REPLY_FAIL = 0;
    
    /** request to read from input stream */
    private static final int REPLY_READ = 10;
    /** request to write */
    private static final int REPLY_WRITE = 11;
    /** request to find out how much data is available */
    private static final int REPLY_AVAILABLE = 12;
    
    /**
     * Used during bootstrap sequence. Should only be used by core, not modules.
     */
    public static final int WHEN_BOOT = 1;
    /**
     * Used during later initialization or while NetBeans is up and running.
     */
    public static final int WHEN_INIT = 2;
    
    private int when;
    
    /**
     * Create a CLI handler and indicate its preferred timing.
     * @param when when to run the handler: {@link #WHEN_BOOT} or {@link #WHEN_INIT}
     */
    protected CLIHandler(int when) {
        this.when = when;
    }
    
    /**
     * Process some set of command-line arguments.
     * Unrecognized or null arguments should be ignored.
     * Recognized arguments should be nulled out.
     * @param args arguments
     * @return error value or 0 if everything is all right
     */
    protected abstract int cli(Args args);
    
    private static void showHelp(PrintWriter w, List handlers) {
        w.println("-?");
        w.println("-help");
        w.println("  Show this help information.");
        Iterator it = handlers.iterator();
        while (it.hasNext()) {
            ((CLIHandler)it.next()).usage(w);
        }
    }
    
    /**
     * Print usage information for this handler.
     * @param w a writer to print to
     */
    protected abstract void usage(PrintWriter w);
    
    /** For testing purposes we can block the
     * algorithm in any place in the initialize method.
     */
    private static void enterState(int state, Integer block) {
        if (block == null) return;
        
        // for easier debugging of CLIHandlerTest
        //System.err.println("state: " + state + " block: " + block + " thread: " + Thread.currentThread());
        
        synchronized (block) {
            if (state == block.intValue()) {
                block.notifyAll();
                try {
                    block.wait();
                } catch (InterruptedException ex) {
                    throw new IllegalStateException();
                }
            }
        }
    }
    
    /** Notification of available handlers.
     * @return non-zero if one of the handlers fails
     */
    private static int notifyHandlers(Args args, List handlers, int when, boolean failOnUnknownOptions, boolean consume) {
        try {
            //System.err.println("notifyHandlers: handlers=" + handlers + " when=" + when + " args=" + Arrays.asList(args.getArguments()));
            if (failOnUnknownOptions) {
                String[] argv = args.getArguments();
                for (int i = 0; i < argv.length; i++) {
                    if (argv[i].equals("-?") || argv[i].equals("-help")) { // NOI18N
                        PrintWriter w = new PrintWriter(args.getOutputStream());
                        showHelp(w, handlers);
                        w.flush();
                        return 2;
                    }
                }
            }
            int r = 0;
            Iterator it = handlers.iterator();
            while (it.hasNext()) {
                CLIHandler h = (CLIHandler)it.next();
                if (h.when != when) continue;

                r = h.cli(args);
                //System.err.println("notifyHandlers: exit code " + r + " from " + h);
                if (r != 0) {
                    return r;
                }
            }
            if (failOnUnknownOptions) {
                String[] argv = args.getArguments();
                for (int i = 0; i < argv.length; i++) {
                    if (argv[i] != null) {
                        // Unhandled option.
                        PrintWriter w = new PrintWriter(args.getOutputStream());
                        w.println("Unknown option: " + argv[i]); // NOI18N
                        showHelp(w, handlers);
                        w.flush();
                        return 2;
                    }
                }
            }
            return 0;
        } finally {
            args.reset(consume);
        }
    }
    
    /**
     * Represents result of initialization.
     * @see #initialize(String[], ClassLoader)
     * @see #initialize(Args, Integer, List)
     */
    static final class Status {
        public static final int CANNOT_CONNECT = -255;
        
        private final File lockFile;
        private final int port;
        private final int exitCode;
        /**
         * General failure.
         */
        Status() {
            this(0);
        }
        /**
         * Failure due to a parse problem.
         * @param c bad status code (not 0)
         * @see #cli(Args)
         */
        Status(int c) {
            this(null, 0, c);
        }
        /**
         * Some measure of success.
         * @param l the lock file (not null)
         * @param p the server port (not 0)
         * @param c a status code (0 or not)
         */
        Status(File l, int p, int c) {
            lockFile = l;
            port = p;
            exitCode = c;
        }
        /**
         * Get the lock file, if available.
         * @return the lock file, or null if there is none
         */
        public File getLockFile() {
            return lockFile;
        }
        /**
         * Get the server port, if available.
         * @return a port number for the server, or 0 if there is no port open
         */
        public int getServerPort() {
            return port;
        }
        /**
         * Get the CLI parse status.
         * @return 0 for success, some other value for error conditions
         */
        public int getExitCode() {
            return exitCode;
        }
    }
    
    
    /** Initializes the system by creating lock file.
     *
     * @param args the command line arguments to recognize
     * @param classloader to find command CLIHandlers in
     * @param doAllInit if true, run all WHEN_INIT handlers now; else wait for {@link #finishInitialization}
     * @param failOnUnknownOptions if true, fail (status 2) if some options are not recognized (also checks for -? and -help)
     * @param cleanLockFile removes lock file if it appears to be dead
     * @return the file to be used as lock file or null parsing of args failed
     */
    static Status initialize(String[] args, ClassLoader loader, boolean doAllInit, boolean failOnUnknownOptions, boolean cleanLockFile) {
        return initialize(new Args(args, System.in, System.err, System.getProperty ("user.dir")), (Integer)null, allCLIs(loader), doAllInit, failOnUnknownOptions, cleanLockFile);
    }
    
    /**
     * What to do later when {@link #finishInitialization} is called.
     * May remain null.
     */
    private static Runnable doLater = null;
    
    /** Initializes the system by creating lock file.
     *
     * @param args the command line arguments to recognize
     * @param block the state we want to block in
     * @param handlers all handlers to use
     * @param doAllInit if true, run all WHEN_INIT handlers now; else wait for {@link #finishInitialization}
     * @param failOnUnknownOptions if true, fail (status 2) if some options are not recognized (also checks for -? and -help)
     * @param cleanLockFile removes lock file if it appears to be dead
     * @return a status summary
     */
    static Status initialize(final Args args, Integer block, final List handlers, boolean doAllInit, final boolean failOnUnknownOptions, boolean cleanLockFile) {
        // initial parsing of args
        {
            int r = notifyHandlers(args, handlers, WHEN_BOOT, false, failOnUnknownOptions);
            if (r != 0) {
                return new Status(r);
            }
        }
        
        // get the value
        String home = System.getProperty("netbeans.user"); // NOI18N
        if (home == null) {
            home = System.getProperty("user.home"); // NOI18N
        }
        File lockFile = new File(home, "lock"); // NOI18N
        
        for (int i = 0; i < 5; i++) {
            // try few times to succeed
            try {
                if (lockFile.exists()) {
                    enterState(5, block);
                    throw new IOException("EXISTS"); // NOI18N
                }
                lockFile.getParentFile().mkdirs();
                lockFile.createNewFile();
                lockFile.deleteOnExit();
                try {
                    // try to make it only user-readable (on Unix)
                    // since people are likely to leave a+r on their userdir
                    File chmod = new File("/bin/chmod"); // NOI18N
                    if (!chmod.isFile()) {
                        // Linux uses /bin, Solaris /usr/bin, others hopefully one of those
                        chmod = new File("/usr/bin/chmod"); // NOI18N
                    }
                    if (chmod.isFile()) {
                        int chmoded = Runtime.getRuntime().exec(new String[] {
                            chmod.getAbsolutePath(),
                            "go-rwx", // NOI18N
                            lockFile.getAbsolutePath()
                        }).waitFor();
                        if (chmoded != 0) {
                            throw new IOException("could not run " + chmod + " go-rwx " + lockFile); // NOI18N
                        }
                    }
                } catch (InterruptedException e) {
                    throw (IOException)new IOException(e.toString()).initCause(e);
                }
                
                enterState(10, block);
                
                byte[] arr = new byte[KEY_LENGTH];
                try {
                    SecureRandom.getInstance("SHA1PRNG").nextBytes(arr); // NOI18N
                } catch (NoSuchAlgorithmException e) {
                    // #36966: IBM JDK doesn't have it.
                    try {
                        SecureRandom.getInstance("IBMSecureRandom").nextBytes(arr); // NOI18N
                    } catch (NoSuchAlgorithmException e2) {
                        // OK, disable server...
                        System.err.println("WARNING: remote IDE automation features cannot be cryptographically secured, so disabling; please reopen http://www.netbeans.org/issues/show_bug.cgi?id=36966"); // NOI18N
                        e.printStackTrace();
                        return new Status();
                    }
                }
                
                Server server = new Server(arr, block, handlers, failOnUnknownOptions);
                
                DataOutputStream os = new DataOutputStream(new FileOutputStream(lockFile));
                int p = server.getLocalPort();
                os.writeInt(p);
                
                enterState(20, block);
                
                os.write(arr);
                os.close();
                
                int exitCode;
                if (doAllInit) {
                    exitCode = notifyHandlers(args, handlers, WHEN_INIT, failOnUnknownOptions, failOnUnknownOptions);
                } else {
                    doLater = new Runnable() {
                        public void run() {
                            int r = notifyHandlers(args, handlers, WHEN_INIT, failOnUnknownOptions, failOnUnknownOptions);
                            if (r != 0) {
                                // Not much to do about it.
                                System.err.println("Post-initialization command-line options could not be run."); // NOI18N
                                //System.err.println("r=" + r + " args=" + java.util.Arrays.asList(args.getArguments()));
                            }
                        }
                    };
                    exitCode = 0;
                }
                
                enterState(0, block);
                return new Status(lockFile, server.getLocalPort(), exitCode);
                
            } catch (IOException ex) {
                if (!"EXISTS".equals(ex.getMessage())) { // NOI18N
                    ex.printStackTrace();
                }
                // already exists, try to read
                byte[] key = null;
                int port = -1;
                try {
                    DataInputStream is = new DataInputStream(new FileInputStream(lockFile));
                    port = is.readInt();
                    key = new byte[KEY_LENGTH];
                    is.readFully(key);
                    is.close();
                } catch (IOException ex2) {
                    // ok, try to read it once more
                }
                
                if (key != null && port != -1) {
                    try {
                        // ok, try to connect
                        enterState(28, block);
                        Socket socket = new Socket(InetAddress.getLocalHost(), port);
                        // wait max of 1s for reply
                        socket.setSoTimeout(5000);
                        DataOutputStream os = new DataOutputStream(socket.getOutputStream());
                        os.write(key);
                        os.flush();
                        
                        enterState(30, block);
                        
                        DataInputStream replyStream = new DataInputStream(socket.getInputStream());
                        COMMUNICATION: for (;;) {
                            enterState(32, block);
                            int reply = replyStream.read();
                            //System.err.println("reply=" + reply);
                            enterState(34, block);
                            
                            switch (reply) {
                                case REPLY_FAIL:
                                    enterState(36, block);
                                    break COMMUNICATION;
                                case REPLY_OK:
                                    enterState(38, block);
                                    // write the arguments
                                    String[] arr = args.getArguments();
                                    os.writeInt(arr.length);
                                    for (int a = 0; a < arr.length; a++) {
                                        os.writeUTF(arr[a]);
                                    }
                                    os.writeUTF (args.getCurrentDirectory().toString()); 
                                    os.flush();
                                    break;
                                case REPLY_EXIT:
                                    int exitCode = replyStream.readInt();
                                    if (exitCode == 0) {
                                        // to signal end of the world
                                        exitCode = -1;
                                    }
                                    
                                    os.close();
                                    replyStream.close();
                                    
                                    enterState(0, block);
                                    return new Status(lockFile, port, exitCode);
                                case REPLY_READ: {
                                    enterState(42, block);
                                    int howMuch = replyStream.readInt();
                                    byte[] byteArr = new byte[howMuch];
                                    args.getInputStream().read(byteArr);
                                    os.write(byteArr);
                                    os.flush();
                                    break;
                                }
                                case REPLY_WRITE: {
                                    enterState(44, block);
                                    int howMuch = replyStream.readInt();
                                    byte[] byteArr = new byte[howMuch];
                                    replyStream.read(byteArr);
                                    args.getOutputStream().write(byteArr);
                                    break;
                                }
                                case REPLY_AVAILABLE:
                                    enterState(46, block);
                                    os.writeInt(args.getInputStream().available());
                                    os.flush();
                                    break;
                                case -1:
                                    // EOF. Why does this happen?
                                    break;
                                default:
                                    throw new IllegalStateException ("Reply: " + reply); // NOI18N
                            }
                        }
                        
                        // connection ok, but secret key not recognized
                        // delete the lock file
                    } catch (java.net.SocketTimeoutException ex2) {
                        // connection failed, the port is dead
                        enterState(33, block);
                    } catch (IOException ex2) {
                        // some strange exception
                        ex2.printStackTrace();
                        enterState(33, block);
                    }
                    if (cleanLockFile) {
                        // remove the file and try once more
                        lockFile.delete();
                    } else {
                        return new Status (Status.CANNOT_CONNECT);
                    }
                }
            }
            
            try {
                enterState(83, block);
                Thread.sleep((int)(Math.random() * 1000.00));
                enterState(85, block);
            } catch (InterruptedException ex) {
                // means nothing
            }
        }
        
        // failure
        return new Status();
    }

    /**
     * Run any {@link #WHEN_INIT} handlers that were passed to the original command line.
     * Should be called when the system is up and ready.
     * Cancels any existing actions, in case it is called twice.
     */
    static void finishInitialization() {
        if (doLater != null) {
            doLater.run();
            doLater = null;
        }
    }
    
    /** For a given classloader finds all registered CLIHandlers.
     */
    private static List allCLIs(ClassLoader loader) {
        /* should be, but we cannot use it yet, as openide is not separated:
        return new ArrayList(Lookups.metaInfServices(loader).lookup(new Lookup.Template(CLIHandler.class)).allInstances());
         */
        List res = new ArrayList();
        Enumeration en;
        try {
            en = loader.getResources("META-INF/services/org.netbeans.CLIHandler"); // NOI18N
        } catch (IOException ex) {
            ex.printStackTrace();
            return Collections.EMPTY_LIST;
        }
        while (en.hasMoreElements()) {
            URL url = (URL)en.nextElement();
            try {
                InputStream is = url.openStream();
                try {
                    BufferedReader reader = new BufferedReader(new InputStreamReader(is, "UTF-8")); // NOI18N
                    while (true) {
                        String line = reader.readLine();
                        if (line == null) break;
                        
                        // Ignore blank lines and comments.
                        line = line.trim();
                        if (line.length() == 0) continue;
                        
                        boolean remove = false;
                        if (line.charAt(0) == '#') {
                            if (line.length() == 1 || line.charAt(1) != '-') {
                                continue;
                            }
                            
                            // line starting with #- is a sign to remove that class from lookup
                            remove = true;
                            line = line.substring(2);
                        }
                        Class inst = Class.forName(line, false, loader);
                        
                        Object obj = inst.newInstance();
                        res.add((CLIHandler)obj);
                    }
                } finally {
                    is.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        return res;
    }
    
    /** Class that represents available arguments to the CLI
     * handlers.
     */
    public static final class Args extends Object {
        private String[] args;
        private final String[] argsBackup;
        private InputStream is;
        private OutputStream os;
        private File currentDir;
        
        Args(String[] args, InputStream is, OutputStream os, String currentDir) {
            argsBackup = args;
            reset(false);
            this.is = is;
            this.os = os;
            this.currentDir = new File (currentDir);
        }
        
        /**
         * Restore the arguments list to a clean state.
         * If not consuming arguments, it is just set to the original list.
         * If consuming arguments, any nulled-out arguments are removed from the list.
         */
        void reset(boolean consume) {
            if (consume) {
                String[] a = args;
                if (a == null) {
                    a = argsBackup;
                }
                List l = new ArrayList(Arrays.asList(a));
                l.removeAll(Collections.singleton(null));
                args = (String[])l.toArray(new String[l.size()]);
            } else {
                args = (String[])argsBackup.clone();
            }
        }
        
        /**
         * Get the command-line arguments.
         * You may not modify the returned array except to set some elements
         * to null as you recognize them.
         * @return array of string arguments, may contain nulls
         */
        public String[] getArguments() {
            return args;
        }
        
        /**
         * Get an output stream to which data may be sent.
         * @return stream to write to
         */
        public OutputStream getOutputStream() {
            return os;
        }
        
        public File getCurrentDirectory () {
            return currentDir;
        }
        
        /**
         * Get an input stream that may supply additional data.
         * @return stream to read from
         */
        public InputStream getInputStream() {
            return is;
        }
    } // end of Args
    
    /** Server that creates local socket and communicates with it.
     */
    private static final class Server extends Thread {
        private byte[] key;
        private ServerSocket socket;
        private Integer block;
        private List handlers;
        private Socket work;
        private static volatile int counter;
        private final boolean failOnUnknownOptions;
        
        public Server(byte[] key, Integer block, List handlers, boolean failOnUnknownOptions) throws IOException {
            super("CLI Requests Server"); // NOI18N
            this.key = key;
            this.setDaemon(true);
            this.block = block;
            this.handlers = handlers;
            this.failOnUnknownOptions = failOnUnknownOptions;
            
            socket = new ServerSocket(0);
            
            start();
        }
        
        public Server(Socket request, byte[] key, Integer block, List handlers, boolean failOnUnknownOptions) throws IOException {
            super("CLI Handler Thread Handler: " + ++counter); // NOI18N
            this.key = key;
            this.setDaemon(true);
            this.block = block;
            this.handlers = handlers;
            this.work = request;
            this.failOnUnknownOptions = failOnUnknownOptions;
            
            start();
        }
        
        public int getLocalPort() {
            return socket.getLocalPort();
        }
        
        public void run() {
            if (work != null) {
                // I am a worker not listener server
                try {
                    handleConnect(work);
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
                return;
            }
            
            
            while (true) {
                try {
                    enterState(65, block);
                    Socket s = socket.accept();
                    
                    // spans new request handler
                    new Server(s, key, block, handlers, failOnUnknownOptions);
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }
        
        
        private void handleConnect(Socket s) throws IOException {
            
            byte[] check = new byte[key.length];
            DataInputStream is = new DataInputStream(s.getInputStream());
            
            enterState(70, block);
            
            is.readFully(check);
            
            enterState(90, block);
            
            DataOutputStream os = new DataOutputStream(s.getOutputStream());
            
            if (Arrays.equals(check, key)) {
                enterState(93, block);
                os.write(REPLY_OK);
                os.flush();
                
                // continue with arguments
                int numberOfArguments = is.readInt();
                String[] args = new String[numberOfArguments];
                for (int i = 0; i < args.length; i++) {
                    args[i] = is.readUTF();
                }
                String currentDir = is.readUTF ();
                
                Args arguments = new Args(args, new IS(is, os), new OS(is, os), currentDir);
                int res = notifyHandlers(arguments, handlers, WHEN_INIT, failOnUnknownOptions, false);
                
                if (res == 0) {
                    enterState(98, block);
                } else {
                    enterState(99, block);
                }
                
                os.write(REPLY_EXIT);
                os.writeInt(res);
            } else {
                enterState(103, block);
                os.write(REPLY_FAIL);
            }
            
            
            enterState(120, block);
            
            os.close();
            is.close();
        }
        
        private static final class IS extends InputStream {
            private DataInputStream is;
            private DataOutputStream os;
            
            public IS(DataInputStream is, DataOutputStream os) {
                this.is = is;
                this.os = os;
            }
            
            public int read() throws IOException {
                byte[] arr = new byte[1];
                if (read(arr) == 1) {
                    return arr[0];
                } else {
                    return -1;
                }
            }
            
            public void close() throws IOException {
                super.close();
            }
            
            public int available() throws IOException {
                // ask for data
                os.write(REPLY_AVAILABLE);
                os.flush();
                // read provided data
                return is.readInt();
            }
            
            public int read(byte[] b) throws IOException {
                return read(b, 0, b.length);
            }
            
            public int read(byte[] b, int off, int len) throws IOException {
                // ask for data
                os.write(REPLY_READ);
                os.writeInt(len);
                os.flush();
                // read provided data
                return is.read(b, off, len);
            }
            
        } // end of IS
        
        private static final class OS extends OutputStream {
            private DataOutputStream os;
            
            public OS(DataInputStream is, DataOutputStream os) {
                this.os = os;
            }
            
            public void write(int b) throws IOException {
                byte[] arr = { (byte)b };
                write(arr);
            }
            
            public void write(byte[] b) throws IOException {
                write(b, 0, b.length);
            }
            
            public void close() throws IOException {
                super.close();
            }
            
            public void flush() throws IOException {
                os.flush();
            }
            
            public void write(byte[] b, int off, int len) throws IOException {
                os.write(REPLY_WRITE);
                os.writeInt(len);
                os.write(b, off, len);
            }
            
        } // end of OS
        
    } // end of Server
    
    
}




import java.io.File;
import java.util.*;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.jar.JarFile;
import java.security.*;
import java.net.*;

/** Bootstrap main class.
 * @author Jaroslav Tulach, Jesse Glick
 */
public class Main extends Object {
    
    /** Starts the IDE.
     * @param args the command line arguments
     * @throws Exception for lots of reasons
     */
    public static void main (String args[]) throws Exception {
        ArrayList list = new ArrayList ();


        // Note that ModuleManager.updateContextClassLoaders will later change
        // the loader on this and other threads to be MM.SystemClassLoader anyway.
        Thread.currentThread().setContextClassLoader (loader);
        
        
        //
        // Evaluate command line interfaces and lock the user directory
        //

        CLIHandler.Status result;
        result = CLIHandler.initialize(args, loader, false, true, false);
        if (result.getExitCode () == CLIHandler.Status.CANNOT_CONNECT) {
            int value = javax.swing.JOptionPane.showConfirmDialog (
                null,
                java.util.ResourceBundle.getBundle("org/netbeans/Bundle").getString("MSG_AlreadyRunning"),
                java.util.ResourceBundle.getBundle("org/netbeans/Bundle").getString("MSG_AlreadyRunningTitle"),
                javax.swing.JOptionPane.OK_CANCEL_OPTION,
                javax.swing.JOptionPane.WARNING_MESSAGE
            );
            if (value == javax.swing.JOptionPane.OK_OPTION) {
                result = CLIHandler.initialize(args, loader, false, true, true);
            }
        }

        int res = result.getExitCode();
        if (res == -1) {
            // Connected to another running NB instance and succeeded in making a call.
            System.exit(0);
        } else if (res != 0) {
            // Some CLIHandler refused the invocation
            System.exit(res);
        }

        m.invoke (null, new Object[] { args });
    }
    
    /**
     * Call when the system is up and running, to complete handling of
     * delayed command-line options like -open FILE.
     */
    public static void finishInitialization() {
        CLIHandler.finishInitialization();
    }
    
    private static final class BootClassLoader extends JarClassLoader {

Added Link Here

(-)src/META-INF/services/org.netbeans.CLIHandler (+1 lines)
1	org.netbeans.core.CLIOptions

Lines 171-177 Link Here

(-)src/org/netbeans/core/Bundle.properties (-1 lines)
171	ERR_UIError=An error occured when setting the specified UI, using default UI ...	171	ERR_UIError=An error occured when setting the specified UI, using default UI ...
172	ERR_FontSizeExpected=Font size expected, using default font size...	172	ERR_FontSizeExpected=Font size expected, using default font size...
173	ERR_BadFontSize=Bad format of the font size, using default font size...	173	ERR_BadFontSize=Bad format of the font size, using default font size...
174	ERR_UnknownOption=Unknown option
175		174
176	# Notify system	175	# Notify system
177	# {0} - class name of exception	176	# {0} - class name of exception




/*
 *                 Sun Public License Notice
 *
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 *
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2003 Sun
 * Microsystems, Inc. All Rights Reserved.
 */

package org.netbeans.core;

import java.awt.*;
import java.awt.event.*;
import java.beans.*;
import java.io.*;
import java.security.*;
import java.util.Locale;
import javax.swing.*;
import javax.swing.border.*;

import org.netbeans.CLIHandler;

import org.netbeans.core.perftool.StartLog;
import org.openide.util.NbBundle;

/**
 * Handler for core options.
 * @author Jaroslav Tulach
 */
public class CLIOptions extends CLIHandler {
    
    private static boolean specifiedBranding = false;

    /**
     * Create a default handler.
     */
    public CLIOptions() {
        super(WHEN_BOOT);
    }
    
    protected int cli(Args arguments) {
        return cli(arguments.getArguments());
    }
    
    final int cli(String[] args) {
        // let's go through the command line
        for (int i = 0; i < args.length; i++) {
            if (args[i] == null) {
                continue;
            }
            boolean used = true;
            if (args[i].equalsIgnoreCase("-nogui")) { // NOI18N
                System.getProperties().put("org.openide.TopManager", "org.netbeans.core.NonGui"); // NOI18N
            } else if (args[i].equalsIgnoreCase("-nosplash")) { // NOI18N
                NonGui.noSplash = true;
            } else if (args[i].equalsIgnoreCase("-noinfo")) { // NOI18N
                // obsolete switch, ignore
            } else if (args[i].equalsIgnoreCase("-nologging")) { // NOI18N
                NonGui.noLogging = true;
            } else if (args[i].equalsIgnoreCase("-ui")) { // NOI18N
                args[i] = null;
                try {
                    NonGui.uiClass = Class.forName(args[++i]);
                } catch(ArrayIndexOutOfBoundsException e) {
                    System.err.println(NonGui.getString("ERR_UIExpected"));
                    return 2;
                } catch (ClassNotFoundException e2) {
                    System.err.println(NonGui.getString("ERR_UINotFound"));
                    return 1;
                }
            } else if (args[i].equalsIgnoreCase("-fontsize")) { // NOI18N
                args[i] = null;
                try {
                    NonGui.uiFontSize = Integer.parseInt(args[++i]);
                } catch(ArrayIndexOutOfBoundsException e) {
                    System.err.println(NonGui.getString("ERR_FontSizeExpected"));
                    return 2;
                } catch (NumberFormatException e2) {
                    System.err.println(NonGui.getString("ERR_BadFontSize"));
                    return 1;
                }
            } else if (args[i].equalsIgnoreCase("-locale")) { // NOI18N
                args[i] = null;
                String localeParam = args[++i];
                String language;
                String country = ""; // NOI18N
                String variant = ""; // NOI18N
                int index1 = localeParam.indexOf(":"); // NOI18N
                if (index1 == -1)
                    language = localeParam;
                else {
                    language = localeParam.substring(0, index1);
                    int index2 = localeParam.indexOf(":", index1+1); // NOI18N
                    if (index2 != -1) {
                        country = localeParam.substring(index1+1, index2);
                        variant = localeParam.substring(index2+1);
                    }
                    else
                        country = localeParam.substring(index1+1);
                }
                Locale.setDefault(new Locale(language, country, variant));
            } else if (args[i].equalsIgnoreCase("-branding")) { // NOI18N
                args[i] = null;
                String branding = args[++i];
                if (branding.equals("-")) branding = null; // NOI18N
                try {
                    NbBundle.setBranding(branding);
                } catch (IllegalArgumentException iae) {
                    iae.printStackTrace();
                    return 1;
                }
                specifiedBranding = true;
            } else {
                used = false;
            }
            args[i] = null;
        }
        
        return 0;
    }
    
    /** Initializes logging etc.
     */
    public static void initialize() {
        if (! specifiedBranding) {
            // Read default branding from file "lib/branding" in installation.
            File branding = new File(new File(NonGui.getHomeDir(), "lib"), "branding"); // NOI18N
            if (branding.exists()) {
                try {
                    InputStream is = new FileInputStream(branding);
                    try {
                        BufferedReader rd = new BufferedReader(new InputStreamReader(is));
                        String line = rd.readLine();
                        if (line == null || line.equals("")) // NOI18N
                            throw new IOException("empty branding file"); // NOI18N
                        if (rd.readLine() != null)
                            throw new IOException("branding file more than one line"); // NOI18N
                        line = line.trim();
                        if (line.equals("-")) line = null; // NOI18N
                        try {
                            org.openide.util.NbBundle.setBranding(line);
                        } catch (IllegalArgumentException iae) {
                            iae.printStackTrace();
                        }
                    } finally {
                        is.close();
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        }
        
        if (!NonGui.noLogging) {
            try {
                NonGui.logger = new TopLogging(NonGui.getSystemDir());
            } catch (IOException e) {
                System.err.println("Cannot create log file. Logging disabled."); // NOI18N
                e.printStackTrace();
            }
        }
        StartLog.logProgress("TopLogging initialized"); // NOI18N
    }
    
    protected void usage(PrintWriter w) {
        w.println(NonGui.getString("TEXT_help"));
    }
    
}

Lines 414-420 Link Here

(-)src/org/netbeans/core/Main.java (-1 / +1 lines)
414	// the loger	414	// the loger
415	// org.netbeans.lib.logger.TraceLogger lgr = org.netbeans.lib.logger.TraceLogger.getTraceLogger();	415	// org.netbeans.lib.logger.TraceLogger lgr = org.netbeans.lib.logger.TraceLogger.getTraceLogger();
416		416
417	NonGui.parseCommandLine (args);	417	CLIOptions.initialize();
418	StartLog.logProgress ("Command line parsed"); // NOI18N	418	StartLog.logProgress ("Command line parsed"); // NOI18N
419		419
420	checkDoubleBuffering();	420	checkDoubleBuffering();




import javax.swing.*;
import javax.swing.border.*;
import java.lang.reflect.Method;
import java.net.*;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.openide.loaders.*;
import org.openide.actions.*;
import org.openide.filesystems.*;
import org.openide.filesystems.FileSystem;
import org.openide.windows.*;
import org.openide.explorer.*;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;
import org.openide.util.SharedClassObject;
import org.openide.util.Utilities;
import org.openide.util.io.*;
import org.openide.util.Utilities;
import org.openide.nodes.*;

import org.netbeans.TopSecurityManager;


    /** The flag whether to create the log - can be set via -nologging
    * command line option */
    protected static boolean noLogging = false;

    /** The flag whether to show the Splash screen on the startup */
    protected static boolean noSplash = false;

    /** The Class that logs the IDE events to a log file */
    protected static TopLogging logger;

    /** Getter for home directory. */
    protected static String getHomeDir () {

        java.net.Authenticator.setDefault (new NbAuthenticator ());
        StartLog.logProgress ("Security managers installed"); // NOI18N
        Main.incrementSplashProgressBar();
        
        org.netbeans.Main.finishInitialization();
        StartLog.logProgress("Ran any delayed command-line options"); // NOI18N
    }



Lines 93-99 Link Here

(-)src/org/netbeans/core/NonGuiMain.java (-4 / +6 lines)
93		93
94	/** Prints help to the System.out. */	94	/** Prints help to the System.out. */
95	public static void showHelp2() {	95	public static void showHelp2() {
96	showHelp();	96	// XXX how to implement? CLIOptions.showHelp();
97	System.out.println(getStringX("CTL_INPUT_option")); // NOI18N	97	System.out.println(getStringX("CTL_INPUT_option")); // NOI18N
98	System.out.println(getStringX("CTL_OUTPUT_option"));	98	System.out.println(getStringX("CTL_OUTPUT_option"));
99	System.out.println(getStringX("CTL_INFO_option"));	99	System.out.println(getStringX("CTL_INFO_option"));
Lines 338-347 Link Here
338	// if we are starting the GUI (e.g. for running Jemmy tests),	338	// if we are starting the GUI (e.g. for running Jemmy tests),
339	// pass the args to Main.main, rather than NonGui.main.	339	// pass the args to Main.main, rather than NonGui.main.
340	//	340	//
341	if (startGui)	341	if (startGui) {
342	startGui(tmpArgs);	342	startGui(tmpArgs);
343	else	343	} else {
344	NonGui.parseCommandLine(tmpArgs);	344	new CLIOptions().cli(tmpArgs);
		345	CLIOptions.initialize();
		346	}
345		347
346	if (showInfo) {	348	if (showInfo) {
347	info();	349	info();




/*
 *                 Sun Public License Notice
 *
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 *
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2003 Sun
 * Microsystems, Inc. All Rights Reserved.
 */

package org.netbeans;

import java.io.*;
import junit.textui.TestRunner;
import org.netbeans.junit.*;
import java.util.*;
import org.openide.util.RequestProcessor;

/**
 * Test the command-line-interface handler.
 * @author Jaroslav Tulach
 */
public class CLIHandlerTest extends NbTestCase {
    
    private static ByteArrayInputStream nullInput = new ByteArrayInputStream(new byte[0]);
    private static ByteArrayOutputStream nullOutput = new ByteArrayOutputStream();
    
    public CLIHandlerTest(String name) {
        super(name);
    }
    
    public static void main(String[] args) {
        TestRunner.run(new NbTestSuite(CLIHandlerTest.class));
    }
    
    protected void setUp() throws Exception {
        super.setUp();
        
        // setups a temporary file
        String tmp = System.getProperty("java.io.tmpdir");
        assertNotNull(tmp);
        System.getProperties().put("netbeans.user", tmp);
        
        File f = new File(tmp, "lock");
        if (f.exists()) {
            assertTrue("Clean up previous mess", f.delete());
            assertTrue(!f.exists());
        }
    }
    
    public void testFileExistsButItCannotBeRead() throws Exception {
        // just creates the file and blocks
        InitializeRunner runner = new InitializeRunner(10);
        
        // blocks when operation fails
        InitializeRunner second = new InitializeRunner(85);
        
        for (int i = 0; i < 3; i++) {
            second.next();
        }
        
        // finishes the code
        runner.next();
        
        assertNotNull("Runner succeeded to allocate the file", runner.resultFile());
        
        // let the second code go on as well
        second.next();
        
        assertEquals("The same file has been allocated", runner.resultFile(), second.resultFile());
    }
    
    public void testFileExistsButTheServerCannotBeContacted() throws Exception {
        // start the server and block
        InitializeRunner runner = new InitializeRunner(65);
        
        assertNotNull("File created", runner.resultFile());
        assertTrue("Port allocated", runner.resultPort() != 0);
        
        // blocks when operation fails
        InitializeRunner second = new InitializeRunner(85);
        // second try should be ok
        second.next();
        
        assertNotNull("Previous file deleted and new one created", second.resultFile());
        assertTrue("Another port allocated", second.resultPort() != runner.resultPort());
        
        
    }
    
    public void testFileExistsButTheServerCannotBeContactedAndWeDoNotWantToCleanTheFile() throws Exception {
        // start the server and block
        InitializeRunner runner = new InitializeRunner(65);
        
        assertNotNull("File created", runner.resultFile());
        assertTrue("Port allocated", runner.resultPort() != 0);
        
        CLIHandler.Status res = CLIHandler.initialize(
            new CLIHandler.Args(new String[0], nullInput, nullOutput, ""), 
            null, Collections.EMPTY_LIST, true, false, false
        );
        
        assertEquals ("Cannot connect", CLIHandler.Status.CANNOT_CONNECT, res.getExitCode());
    }
    
    public void testFileExistsButTheKeyIsNotRecognized() throws Exception {
        // start the server be notified when it accepts connection
        InitializeRunner runner = new InitializeRunner(65);
        
        assertNotNull("File created", runner.resultFile());
        assertTrue("Port allocated", runner.resultPort() != 0);
        
        int s = (int)runner.resultFile().length();
        byte[] copy = new byte[s];
        FileInputStream is = new FileInputStream(runner.resultFile());
        assertEquals("Read fully", s, is.read(copy));
        is.close();
        
        // change the key
        copy[s - 1]++;
        
        FileOutputStream os = new FileOutputStream(runner.resultFile());
        os.write(copy);
        os.close();
        
        // try to connect to previous server be notified as soon as it
        // sends request
        InitializeRunner second = new InitializeRunner(30);
        
        // handle the request, say NO
        runner.next();
        
        // read the reply and allocate new port
        second.next();
        
        assertNotNull("Previous file deleted and new one created", second.resultFile());
        assertTrue("Another port allocated", second.resultPort() != runner.resultPort());
    }
    
    public void testCLIHandlersCanChangeLocationOfLockFile() throws Exception {
        File f = File.createTempFile("suffix", "tmp").getParentFile();
        final File dir = new File(f, "subdir");
        dir.delete();
        assertTrue(dir.exists() || dir.mkdir());
        
        class UserDir extends CLIHandler {
            private int cnt;
            
            public UserDir() {
                super(WHEN_BOOT);
            }
            
            protected int cli(Args args) {
                cnt++;
                System.setProperty("netbeans.user", dir.toString());
                return 0;
            }
            
            protected void usage(PrintWriter w) {}
        }
        UserDir ud = new UserDir();
        
        CLIHandler.Status res = cliInitialize(new String[0], ud, nullInput, nullOutput, null);
        
        assertEquals("Our command line handler is called once", 1, ud.cnt);
        assertEquals("Lock file is created in dir", dir, res.getLockFile().getParentFile());
        
        dir.delete();
    }
    
    public void testCLIHandlerCanStopEvaluation() throws Exception {
        class H extends CLIHandler {
            private int cnt;
            
            public H() {
                super(WHEN_INIT);
            }
            
            protected int cli(Args args) {
                cnt++;
                return 1;
            }
            
            protected void usage(PrintWriter w) {}
        }
        H h1 = new H();
        H h2 = new H();
        
        
        CLIHandler.Status res = cliInitialize(new String[0], new H[] {
            h1, h2
        }, nullInput, nullOutput);
        
        assertEquals("CLI evaluation failed with return code of h1", 1, res.getExitCode());
        assertEquals("First one executed", 1, h1.cnt);
        assertEquals("Not the second one", 0, h2.cnt);
    }
    
    public void testWhenInvokedTwiceParamsGoToTheFirstHandler() throws Exception {
        final String[] template = { "Ahoj", "Hello" };
        final String currentDir = "MyDir";
        
        class H extends CLIHandler {
            private int cnt;
            
            public H() {
                super(WHEN_INIT);
            }
            
            protected int cli(Args args) {
                String[] a = args.getArguments();
                String[] t = template;
                
                assertEquals("Same length", t.length, a.length);
                assertEquals("First is same", t[0], a[0]);
                assertEquals("Second is same", t[1], a[1]);
                assertEquals("Current dir is fine", currentDir, args.getCurrentDirectory().toString());
                return ++cnt;
            }
            
            protected void usage(PrintWriter w) {}
        }
        H h1 = new H();
        
        
        CLIHandler.Status res = cliInitialize(template, h1, nullInput, nullOutput, null, currentDir);
        
        assertEquals("First one executed", 1, h1.cnt);
        assertEquals("CLI evaluation failed with return code of h1", 1, res.getExitCode());
        
        res = cliInitialize(template, java.util.Collections.EMPTY_LIST, nullInput, nullOutput, null, currentDir);
        assertEquals("But again executed h1", 2, h1.cnt);
        assertEquals("Now the result is 2 as cnt++ was increased", 2, res.getExitCode());
        
    }
    
    public void testServerIsNotBlockedByLongRequests() throws Exception {
        class H extends CLIHandler {
            private int cnt = -1;
            public int toReturn;
            
            public H() {
                super(CLIHandler.WHEN_INIT);
            }
            
            protected synchronized int cli(Args args) {
                notifyAll();
                cnt++;
                return toReturn;
            }
            
            protected void usage(PrintWriter w) {}
        }
        H h = new H();
        
        h.toReturn = 7;
        final Integer blockOn = new Integer(99);
        CLIHandler.Status res = cliInitialize(new String[0], h, nullInput, nullOutput, blockOn);
        assertEquals("Called once, increased -1 to 0", 0, h.cnt);
        assertEquals("Result is provided by H", 7, res.getExitCode());
        
        // blocks after connection established, before returning the result
        class R implements Runnable {
            CLIHandler.Status res;
            public void run() {
                res = cliInitialize(new String[0], Collections.EMPTY_LIST, nullInput, nullOutput, blockOn);
            }
        }
        R r = new R();
        RequestProcessor.Task task;
        synchronized (h) {
            h.toReturn = 5;
            task = new org.openide.util.RequestProcessor("Blocking request").post(r);
            h.wait();
            assertEquals("Connects to the h", 1, h.cnt);
            assertEquals("But is not finished", null, r.res);
        }
        
        // while R is blocked, run another task
        h.toReturn = 0;
        res = cliInitialize(new String[0], Collections.EMPTY_LIST, nullInput, nullOutput, null);
        assertEquals("Called once, increased to 2", 2, h.cnt);
        assertEquals("Result is provided by H, H gives 0, changes into -1 right now", -1, res.getExitCode());
        
        synchronized (blockOn) {
            // let the R task go on
            blockOn.notifyAll();
        }
        task.waitFinished();
        assertNotNull("Now it is finished", r.res);
        assertEquals("Result is -1, if this fails: this usually means that the server is blocked by some work and the task R started new server to handle its request",
            5, r.res.getExitCode());
        assertEquals("H called three times (but counting from -1)", 2, h.cnt);
    }
    
    public void testReadingOfInputWorksInHandler() throws Exception {
        final byte[] template = { 1, 2, 3, 4 };
        
        class H extends CLIHandler {
            private byte[] arr;
            
            public H() {
                super(WHEN_INIT);
            }
            
            protected int cli(Args args) {
                try {
                    InputStream is = args.getInputStream();
                    arr = new byte[is.available() / 2];
                    if (arr.length > 0) {
                        assertEquals("Read amount is the same", arr.length, is.read(arr));
                    }
                    is.close();
                } catch (IOException ex) {
                    fail("There is an exception: " + ex);
                }
                return 0;
            }
            
            protected void usage(PrintWriter w) {}
        }
        H h1 = new H();
        H h2 = new H();
        
        // why twice? first attempt is direct, second thru the socket server
        for (int i = 0; i < 2; i++) {
            CLIHandler.Status res = cliInitialize(
                new String[0], new H[] { h1, h2 }, new ByteArrayInputStream(template), nullOutput);
            
            assertNotNull("Attempt " + i + ": " + "Can be read", h1.arr);
            assertEquals("Attempt " + i + ": " + "Read two bytes", 2, h1.arr.length);
            assertEquals("Attempt " + i + ": " + "First is same", template[0], h1.arr[0]);
            assertEquals("Attempt " + i + ": " + "Second is same", template[1], h1.arr[1]);
            
            assertNotNull("Attempt " + i + ": " + "Can read as well", h2.arr);
            assertEquals("Attempt " + i + ": " + "Just one char", 1, h2.arr.length);
            assertEquals("Attempt " + i + ": " + "And is the right one", template[2], h2.arr[0]);
            
            h1.arr = null;
            h2.arr = null;
        }
    }
    
    public void testWritingToOutputIsFine() throws Exception {
        final byte[] template = { 1, 2, 3, 4 };
        
        class H extends CLIHandler {
            public H() {
                super(WHEN_INIT);
            }
            
            protected int cli(Args args) {
                try {
                    OutputStream os = args.getOutputStream();
                    os.write(template);
                    os.close();
                } catch (IOException ex) {
                    fail("There is an exception: " + ex);
                }
                return 0;
            }
            
            protected void usage(PrintWriter w) {}
        }
        H h1 = new H();
        H h2 = new H();
        
        // why twice? first attempt is direct, second thru the socket server
        for (int i = 0; i < 2; i++) {
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            
            CLIHandler.Status res = cliInitialize(
                new String[0], new H[] { h1, h2 }, nullInput, os);
            
            byte[] arr = os.toByteArray();
            assertEquals("Double size of template", template.length * 2, arr.length);
            
            for (int pos = 0; pos < arr.length; pos++) {
                assertEquals(pos + ". is the same", template[pos % template.length], arr[pos]);
            }
        }
    }
    
    //
    // Utility methods
    //
    
    private static CLIHandler.Status cliInitialize(String[] args, CLIHandler handler, InputStream is, OutputStream os, Integer lock) {
        return cliInitialize(args, handler, is, os, lock, System.getProperty ("user.dir"));
    }
    private static CLIHandler.Status cliInitialize(String[] args, CLIHandler handler, InputStream is, OutputStream os, Integer lock, String currentDir) {
        return cliInitialize(args, Collections.nCopies(1, handler), is, os, lock, currentDir);
    }
    private static CLIHandler.Status cliInitialize(String[] args, CLIHandler[] arr, InputStream is, OutputStream os) {
        return cliInitialize(args, Arrays.asList(arr), is, os, null);
    }
    private static CLIHandler.Status cliInitialize(String[] args, List coll, InputStream is, OutputStream os, Integer lock) {
        return cliInitialize (args, coll, is, os, lock, System.getProperty ("user.dir"));
    }
    private static CLIHandler.Status cliInitialize(String[] args, List coll, InputStream is, OutputStream os, Integer lock, String currentDir) {
        return CLIHandler.initialize(new CLIHandler.Args(args, is, os, currentDir), lock, coll, true, false, true);
    }
    
    
    private static final class InitializeRunner extends Object implements Runnable {
        private Integer block;
        private String[] args;
        private CLIHandler handler;
        private CLIHandler.Status result;
        
        public InitializeRunner(int till) throws InterruptedException {
            this(new String[0], null, till);
        }
        
        public InitializeRunner(String[] args, CLIHandler h, int till) throws InterruptedException {
            this(args, h, new Integer(till));
        }
        public InitializeRunner(String[] args, CLIHandler h, Integer till) throws InterruptedException {
            this.args = args;
            this.block = till;
            this.handler = h;
            
            synchronized (block) {
                RequestProcessor.getDefault().post(this);
                block.wait();
            }
        }
        
        public void run() {
            synchronized (block) {
                result = CLIHandler.initialize(
                    new CLIHandler.Args(args, nullInput, nullOutput, ""),
                    block,
                    handler == null ? java.util.Collections.EMPTY_LIST : java.util.Collections.nCopies(1, handler),
                    true,
                    false,
                    true);
                // we are finished, wake up guys in next() if any
                block.notifyAll();
            }
        }
        
        /** Executes the code to next invocation */
        public void next() throws InterruptedException {
            synchronized (block) {
                block.notify();
                block.wait();
            }
        }
        
        /** Has already the resutl?
         */
        public boolean hasResult() {
            return result != null;
        }
        
        /** Gets the resultFile, if there is some,
         */
        public File resultFile() {
            if (result == null) {
                fail("No result produced");
            }
            return result.getLockFile();
        }
        
        /** Gets the port, if there is some,
         */
        public int resultPort() {
            if (result == null) {
                fail("No result produced");
            }
            return result.getServerPort();
        }
    } // end of InitializeRunner
    
}

Return to bug 32054

Added Link Here

(-)bootstrap/src/org/netbeans/Bundle.properties (+14 lines)
1	# Sun Public License Notice
2	#
3	# The contents of this file are subject to the Sun Public License
4	# Version 1.0 (the "License"). You may not use this file except in
5	# compliance with the License. A copy of the License is available at
6	# http://www.sun.com/
7	#
8	# The Original Code is NetBeans. The Initial Developer of the Original
9	# Code is Sun Microsystems, Inc. Portions Copyright 1997-2003 Sun
10	# Microsystems, Inc. All Rights Reserved.
11
12	#Question to show user to find out whether start second instance of NetBeans or not
13	MSG_AlreadyRunning=Another version of the program seems to be running. Continue anyway?
14	MSG_AlreadyRunningTitle=Warning

Lines 16-33 Link Here

(-)bootstrap/src/org/netbeans/Main.java (-4 / +42 lines)
16	import java.io.File;	16	import java.io.File;
17	import java.util.*;	17	import java.util.*;
18	import java.lang.reflect.Method;	18	import java.lang.reflect.Method;
19	import java.net.MalformedURLException;
20	import java.net.URL;
21	import java.util.jar.JarFile;	19	import java.util.jar.JarFile;
22	import java.security.*;	20	import java.security.*;
		21	import java.net.*;
23		22
24	/** Bootstrap main class.	23	/** Bootstrap main class.
25	* @author Jaroslav Tulach, Jesse Glick	24	* @author Jaroslav Tulach, Jesse Glick
26	*/	25	*/
27	public class Main extends Object {	26	public class Main extends Object {
		27
28	/** Starts the IDE.	28	/** Starts the IDE.
29	* @param args the command line arguments	29	* @param args the command line arguments
30	*/	30	* @throws Exception for lots of reasons
		31	*/
31	public static void main (String args[]) throws Exception {	32	public static void main (String args[]) throws Exception {
32	ArrayList list = new ArrayList ();	33	ArrayList list = new ArrayList ();
33		34
Lines 92-99 Link Here
92	// Note that ModuleManager.updateContextClassLoaders will later change	93	// Note that ModuleManager.updateContextClassLoaders will later change
93	// the loader on this and other threads to be MM.SystemClassLoader anyway.	94	// the loader on this and other threads to be MM.SystemClassLoader anyway.
94	Thread.currentThread().setContextClassLoader (loader);	95	Thread.currentThread().setContextClassLoader (loader);
		96
		97
		98	//
		99	// Evaluate command line interfaces and lock the user directory
		100	//
		101
		102	CLIHandler.Status result;
		103	result = CLIHandler.initialize(args, loader, false, true, false);
		104	if (result.getExitCode () == CLIHandler.Status.CANNOT_CONNECT) {
		105	int value = javax.swing.JOptionPane.showConfirmDialog (
		106	null,
		107	java.util.ResourceBundle.getBundle("org/netbeans/Bundle").getString("MSG_AlreadyRunning"),
		108	java.util.ResourceBundle.getBundle("org/netbeans/Bundle").getString("MSG_AlreadyRunningTitle"),
		109	javax.swing.JOptionPane.OK_CANCEL_OPTION,
		110	javax.swing.JOptionPane.WARNING_MESSAGE
		111	);
		112	if (value == javax.swing.JOptionPane.OK_OPTION) {
		113	result = CLIHandler.initialize(args, loader, false, true, true);
		114	}
		115	}
		116
		117	int res = result.getExitCode();
		118	if (res == -1) {
		119	// Connected to another running NB instance and succeeded in making a call.
		120	System.exit(0);
		121	} else if (res != 0) {
		122	// Some CLIHandler refused the invocation
		123	System.exit(res);
		124	}
95		125
96	m.invoke (null, new Object[] { args });	126	m.invoke (null, new Object[] { args });
		127	}
		128
		129	/**
		130	* Call when the system is up and running, to complete handling of
		131	* delayed command-line options like -open FILE.
		132	*/
		133	public static void finishInitialization() {
		134	CLIHandler.finishInitialization();
97	}	135	}
98		136
99	private static final class BootClassLoader extends JarClassLoader {	137	private static final class BootClassLoader extends JarClassLoader {

Added Link Here

(-)src/org/netbeans/core/CLIOptions.java (+173 lines)
1	/*
2	* Sun Public License Notice
3	*
4	* The contents of this file are subject to the Sun Public License
5	* Version 1.0 (the "License"). You may not use this file except in
6	* compliance with the License. A copy of the License is available at
7	* http://www.sun.com/
8	*
9	* The Original Code is NetBeans. The Initial Developer of the Original
10	* Code is Sun Microsystems, Inc. Portions Copyright 1997-2003 Sun
11	* Microsystems, Inc. All Rights Reserved.
12	*/
13
14	package org.netbeans.core;
15
16	import java.awt.*;
17	import java.awt.event.*;
18	import java.beans.*;
19	import java.io.*;
20	import java.security.*;
21	import java.util.Locale;
22	import javax.swing.*;
23	import javax.swing.border.*;
24
25	import org.netbeans.CLIHandler;
26
27	import org.netbeans.core.perftool.StartLog;
28	import org.openide.util.NbBundle;
29
30	/**
31	* Handler for core options.
32	* @author Jaroslav Tulach
33	*/
34	public class CLIOptions extends CLIHandler {
35
36	private static boolean specifiedBranding = false;
37
38	/**
39	* Create a default handler.
40	*/
41	public CLIOptions() {
42	super(WHEN_BOOT);
43	}
44
45	protected int cli(Args arguments) {
46	return cli(arguments.getArguments());
47	}
48
49	final int cli(String[] args) {
50	// let's go through the command line
51	for (int i = 0; i < args.length; i++) {
52	if (args[i] == null) {
53	continue;
54	}
55	boolean used = true;
56	if (args[i].equalsIgnoreCase("-nogui")) { // NOI18N
57	System.getProperties().put("org.openide.TopManager", "org.netbeans.core.NonGui"); // NOI18N
58	} else if (args[i].equalsIgnoreCase("-nosplash")) { // NOI18N
59	NonGui.noSplash = true;
60	} else if (args[i].equalsIgnoreCase("-noinfo")) { // NOI18N
61	// obsolete switch, ignore
62	} else if (args[i].equalsIgnoreCase("-nologging")) { // NOI18N
63	NonGui.noLogging = true;
64	} else if (args[i].equalsIgnoreCase("-ui")) { // NOI18N
65	args[i] = null;
66	try {
67	NonGui.uiClass = Class.forName(args[++i]);
68	} catch(ArrayIndexOutOfBoundsException e) {
69	System.err.println(NonGui.getString("ERR_UIExpected"));
70	return 2;
71	} catch (ClassNotFoundException e2) {
72	System.err.println(NonGui.getString("ERR_UINotFound"));
73	return 1;
74	}
75	} else if (args[i].equalsIgnoreCase("-fontsize")) { // NOI18N
76	args[i] = null;
77	try {
78	NonGui.uiFontSize = Integer.parseInt(args[++i]);
79	} catch(ArrayIndexOutOfBoundsException e) {
80	System.err.println(NonGui.getString("ERR_FontSizeExpected"));
81	return 2;
82	} catch (NumberFormatException e2) {
83	System.err.println(NonGui.getString("ERR_BadFontSize"));
84	return 1;
85	}
86	} else if (args[i].equalsIgnoreCase("-locale")) { // NOI18N
87	args[i] = null;
88	String localeParam = args[++i];
89	String language;
90	String country = ""; // NOI18N
91	String variant = ""; // NOI18N
92	int index1 = localeParam.indexOf(":"); // NOI18N
93	if (index1 == -1)
94	language = localeParam;
95	else {
96	language = localeParam.substring(0, index1);
97	int index2 = localeParam.indexOf(":", index1+1); // NOI18N
98	if (index2 != -1) {
99	country = localeParam.substring(index1+1, index2);
100	variant = localeParam.substring(index2+1);
101	}
102	else
103	country = localeParam.substring(index1+1);
104	}
105	Locale.setDefault(new Locale(language, country, variant));
106	} else if (args[i].equalsIgnoreCase("-branding")) { // NOI18N
107	args[i] = null;
108	String branding = args[++i];
109	if (branding.equals("-")) branding = null; // NOI18N
110	try {
111	NbBundle.setBranding(branding);
112	} catch (IllegalArgumentException iae) {
113	iae.printStackTrace();
114	return 1;
115	}
116	specifiedBranding = true;
117	} else {
118	used = false;
119	}
120	args[i] = null;
121	}
122
123	return 0;
124	}
125
126	/** Initializes logging etc.
127	*/
128	public static void initialize() {
129	if (! specifiedBranding) {
130	// Read default branding from file "lib/branding" in installation.
131	File branding = new File(new File(NonGui.getHomeDir(), "lib"), "branding"); // NOI18N
132	if (branding.exists()) {
133	try {
134	InputStream is = new FileInputStream(branding);
135	try {
136	BufferedReader rd = new BufferedReader(new InputStreamReader(is));
137	String line = rd.readLine();
138	if (line == null \|\| line.equals("")) // NOI18N
139	throw new IOException("empty branding file"); // NOI18N
140	if (rd.readLine() != null)
141	throw new IOException("branding file more than one line"); // NOI18N
142	line = line.trim();
143	if (line.equals("-")) line = null; // NOI18N
144	try {
145	org.openide.util.NbBundle.setBranding(line);
146	} catch (IllegalArgumentException iae) {
147	iae.printStackTrace();
148	}
149	} finally {
150	is.close();
151	}
152	} catch (IOException ioe) {
153	ioe.printStackTrace();
154	}
155	}
156	}
157
158	if (!NonGui.noLogging) {
159	try {
160	NonGui.logger = new TopLogging(NonGui.getSystemDir());
161	} catch (IOException e) {
162	System.err.println("Cannot create log file. Logging disabled."); // NOI18N
163	e.printStackTrace();
164	}
165	}
166	StartLog.logProgress("TopLogging initialized"); // NOI18N
167	}
168
169	protected void usage(PrintWriter w) {
170	w.println(NonGui.getString("TEXT_help"));
171	}
172
173	}

Lines 23-30 Link Here

(-)src/org/netbeans/core/NonGui.java (-7 / +8 lines)
23	import javax.swing.*;	23	import javax.swing.*;
24	import javax.swing.border.*;	24	import javax.swing.border.*;
25	import java.lang.reflect.Method;	25	import java.lang.reflect.Method;
26	import java.net.MalformedURLException;	26	import java.net.*;
27	import java.net.URLClassLoader;
28	import java.util.ArrayList;	27	import java.util.ArrayList;
29	import java.util.Iterator;	28	import java.util.Iterator;
30	import java.util.List;	29	import java.util.List;
Lines 35-48 Link Here
35	import org.openide.loaders.*;	34	import org.openide.loaders.*;
36	import org.openide.actions.*;	35	import org.openide.actions.*;
37	import org.openide.filesystems.*;	36	import org.openide.filesystems.*;
38	import org.openide.filesystems.FileSystem;
39	import org.openide.windows.*;	37	import org.openide.windows.*;
40	import org.openide.explorer.*;	38	import org.openide.explorer.*;
41	import org.openide.util.Lookup;	39	import org.openide.util.Lookup;
42	import org.openide.util.NbBundle;	40	import org.openide.util.NbBundle;
43	import org.openide.util.SharedClassObject;	41	import org.openide.util.SharedClassObject;
44	import org.openide.util.Utilities;
45	import org.openide.util.io.*;	42	import org.openide.util.io.*;
		43	import org.openide.util.Utilities;
46	import org.openide.nodes.*;	44	import org.openide.nodes.*;
47		45
48	import org.netbeans.TopSecurityManager;	46	import org.netbeans.TopSecurityManager;
Lines 97-109 Link Here
97		95
98	/** The flag whether to create the log - can be set via -nologging	96	/** The flag whether to create the log - can be set via -nologging
99	* command line option */	97	* command line option */
100	private static boolean noLogging = false;	98	protected static boolean noLogging = false;
101		99
102	/** The flag whether to show the Splash screen on the startup */	100	/** The flag whether to show the Splash screen on the startup */
103	protected static boolean noSplash = false;	101	protected static boolean noSplash = false;
104		102
105	/** The Class that logs the IDE events to a log file */	103	/** The Class that logs the IDE events to a log file */
106	private static TopLogging logger;	104	protected static TopLogging logger;
107		105
108	/** Getter for home directory. */	106	/** Getter for home directory. */
109	protected static String getHomeDir () {	107	protected static String getHomeDir () {
Lines 564-569 Link Here
564	java.net.Authenticator.setDefault (new NbAuthenticator ());	562	java.net.Authenticator.setDefault (new NbAuthenticator ());
565	StartLog.logProgress ("Security managers installed"); // NOI18N	563	StartLog.logProgress ("Security managers installed"); // NOI18N
566	Main.incrementSplashProgressBar();	564	Main.incrementSplashProgressBar();
		565
		566	org.netbeans.Main.finishInitialization();
		567	StartLog.logProgress("Ran any delayed command-line options"); // NOI18N
567	}	568	}
568		569
569		570

Added Link Here

(-)test/unit/src/org/netbeans/CLIHandlerTest.java (+479 lines)
1	/*
2	* Sun Public License Notice
3	*
4	* The contents of this file are subject to the Sun Public License
5	* Version 1.0 (the "License"). You may not use this file except in
6	* compliance with the License. A copy of the License is available at
7	* http://www.sun.com/
8	*
9	* The Original Code is NetBeans. The Initial Developer of the Original
10	* Code is Sun Microsystems, Inc. Portions Copyright 1997-2003 Sun
11	* Microsystems, Inc. All Rights Reserved.
12	*/
13
14	package org.netbeans;
15
16	import java.io.*;
17	import junit.textui.TestRunner;
18	import org.netbeans.junit.*;
19	import java.util.*;
20	import org.openide.util.RequestProcessor;
21
22	/**
23	* Test the command-line-interface handler.
24	* @author Jaroslav Tulach
25	*/
26	public class CLIHandlerTest extends NbTestCase {
27
28	private static ByteArrayInputStream nullInput = new ByteArrayInputStream(new byte[0]);
29	private static ByteArrayOutputStream nullOutput = new ByteArrayOutputStream();
30
31	public CLIHandlerTest(String name) {
32	super(name);
33	}
34
35	public static void main(String[] args) {
36	TestRunner.run(new NbTestSuite(CLIHandlerTest.class));
37	}
38
39	protected void setUp() throws Exception {
40	super.setUp();
41
42	// setups a temporary file
43	String tmp = System.getProperty("java.io.tmpdir");
44	assertNotNull(tmp);
45	System.getProperties().put("netbeans.user", tmp);
46
47	File f = new File(tmp, "lock");
48	if (f.exists()) {
49	assertTrue("Clean up previous mess", f.delete());
50	assertTrue(!f.exists());
51	}
52	}
53
54	public void testFileExistsButItCannotBeRead() throws Exception {
55	// just creates the file and blocks
56	InitializeRunner runner = new InitializeRunner(10);
57
58	// blocks when operation fails
59	InitializeRunner second = new InitializeRunner(85);
60
61	for (int i = 0; i < 3; i++) {
62	second.next();
63	}
64
65	// finishes the code
66	runner.next();
67
68	assertNotNull("Runner succeeded to allocate the file", runner.resultFile());
69
70	// let the second code go on as well
71	second.next();
72
73	assertEquals("The same file has been allocated", runner.resultFile(), second.resultFile());
74	}
75
76	public void testFileExistsButTheServerCannotBeContacted() throws Exception {
77	// start the server and block
78	InitializeRunner runner = new InitializeRunner(65);
79
80	assertNotNull("File created", runner.resultFile());
81	assertTrue("Port allocated", runner.resultPort() != 0);
82
83	// blocks when operation fails
84	InitializeRunner second = new InitializeRunner(85);
85	// second try should be ok
86	second.next();
87
88	assertNotNull("Previous file deleted and new one created", second.resultFile());
89	assertTrue("Another port allocated", second.resultPort() != runner.resultPort());
90
91
92	}
93
94	public void testFileExistsButTheServerCannotBeContactedAndWeDoNotWantToCleanTheFile() throws Exception {
95	// start the server and block
96	InitializeRunner runner = new InitializeRunner(65);
97
98	assertNotNull("File created", runner.resultFile());
99	assertTrue("Port allocated", runner.resultPort() != 0);
100
101	CLIHandler.Status res = CLIHandler.initialize(
102	new CLIHandler.Args(new String[0], nullInput, nullOutput, ""),
103	null, Collections.EMPTY_LIST, true, false, false
104	);
105
106	assertEquals ("Cannot connect", CLIHandler.Status.CANNOT_CONNECT, res.getExitCode());
107	}
108
109	public void testFileExistsButTheKeyIsNotRecognized() throws Exception {
110	// start the server be notified when it accepts connection
111	InitializeRunner runner = new InitializeRunner(65);
112
113	assertNotNull("File created", runner.resultFile());
114	assertTrue("Port allocated", runner.resultPort() != 0);
115
116	int s = (int)runner.resultFile().length();
117	byte[] copy = new byte[s];
118	FileInputStream is = new FileInputStream(runner.resultFile());
119	assertEquals("Read fully", s, is.read(copy));
120	is.close();
121
122	// change the key
123	copy[s - 1]++;
124
125	FileOutputStream os = new FileOutputStream(runner.resultFile());
126	os.write(copy);
127	os.close();
128
129	// try to connect to previous server be notified as soon as it
130	// sends request
131	InitializeRunner second = new InitializeRunner(30);
132
133	// handle the request, say NO
134	runner.next();
135
136	// read the reply and allocate new port
137	second.next();
138
139	assertNotNull("Previous file deleted and new one created", second.resultFile());
140	assertTrue("Another port allocated", second.resultPort() != runner.resultPort());
141	}
142
143	public void testCLIHandlersCanChangeLocationOfLockFile() throws Exception {
144	File f = File.createTempFile("suffix", "tmp").getParentFile();
145	final File dir = new File(f, "subdir");
146	dir.delete();
147	assertTrue(dir.exists() \|\| dir.mkdir());
148
149	class UserDir extends CLIHandler {
150	private int cnt;
151
152	public UserDir() {
153	super(WHEN_BOOT);
154	}
155
156	protected int cli(Args args) {
157	cnt++;
158	System.setProperty("netbeans.user", dir.toString());
159	return 0;
160	}
161
162	protected void usage(PrintWriter w) {}
163	}
164	UserDir ud = new UserDir();
165
166	CLIHandler.Status res = cliInitialize(new String[0], ud, nullInput, nullOutput, null);
167
168	assertEquals("Our command line handler is called once", 1, ud.cnt);
169	assertEquals("Lock file is created in dir", dir, res.getLockFile().getParentFile());
170
171	dir.delete();
172	}
173
174	public void testCLIHandlerCanStopEvaluation() throws Exception {
175	class H extends CLIHandler {
176	private int cnt;
177
178	public H() {
179	super(WHEN_INIT);
180	}
181
182	protected int cli(Args args) {
183	cnt++;
184	return 1;
185	}
186
187	protected void usage(PrintWriter w) {}
188	}
189	H h1 = new H();
190	H h2 = new H();
191
192
193	CLIHandler.Status res = cliInitialize(new String[0], new H[] {
194	h1, h2
195	}, nullInput, nullOutput);
196
197	assertEquals("CLI evaluation failed with return code of h1", 1, res.getExitCode());
198	assertEquals("First one executed", 1, h1.cnt);
199	assertEquals("Not the second one", 0, h2.cnt);
200	}
201
202	public void testWhenInvokedTwiceParamsGoToTheFirstHandler() throws Exception {
203	final String[] template = { "Ahoj", "Hello" };
204	final String currentDir = "MyDir";
205
206	class H extends CLIHandler {
207	private int cnt;
208
209	public H() {
210	super(WHEN_INIT);
211	}
212
213	protected int cli(Args args) {
214	String[] a = args.getArguments();
215	String[] t = template;
216
217	assertEquals("Same length", t.length, a.length);
218	assertEquals("First is same", t[0], a[0]);
219	assertEquals("Second is same", t[1], a[1]);
220	assertEquals("Current dir is fine", currentDir, args.getCurrentDirectory().toString());
221	return ++cnt;
222	}
223
224	protected void usage(PrintWriter w) {}
225	}
226	H h1 = new H();
227
228
229	CLIHandler.Status res = cliInitialize(template, h1, nullInput, nullOutput, null, currentDir);
230
231	assertEquals("First one executed", 1, h1.cnt);
232	assertEquals("CLI evaluation failed with return code of h1", 1, res.getExitCode());
233
234	res = cliInitialize(template, java.util.Collections.EMPTY_LIST, nullInput, nullOutput, null, currentDir);
235	assertEquals("But again executed h1", 2, h1.cnt);
236	assertEquals("Now the result is 2 as cnt++ was increased", 2, res.getExitCode());
237
238	}
239
240	public void testServerIsNotBlockedByLongRequests() throws Exception {
241	class H extends CLIHandler {
242	private int cnt = -1;
243	public int toReturn;
244
245	public H() {
246	super(CLIHandler.WHEN_INIT);
247	}
248
249	protected synchronized int cli(Args args) {
250	notifyAll();
251	cnt++;
252	return toReturn;
253	}
254
255	protected void usage(PrintWriter w) {}
256	}
257	H h = new H();
258
259	h.toReturn = 7;
260	final Integer blockOn = new Integer(99);
261	CLIHandler.Status res = cliInitialize(new String[0], h, nullInput, nullOutput, blockOn);
262	assertEquals("Called once, increased -1 to 0", 0, h.cnt);
263	assertEquals("Result is provided by H", 7, res.getExitCode());
264
265	// blocks after connection established, before returning the result
266	class R implements Runnable {
267	CLIHandler.Status res;
268	public void run() {
269	res = cliInitialize(new String[0], Collections.EMPTY_LIST, nullInput, nullOutput, blockOn);
270	}
271	}
272	R r = new R();
273	RequestProcessor.Task task;
274	synchronized (h) {
275	h.toReturn = 5;
276	task = new org.openide.util.RequestProcessor("Blocking request").post(r);
277	h.wait();
278	assertEquals("Connects to the h", 1, h.cnt);
279	assertEquals("But is not finished", null, r.res);
280	}
281
282	// while R is blocked, run another task
283	h.toReturn = 0;
284	res = cliInitialize(new String[0], Collections.EMPTY_LIST, nullInput, nullOutput, null);
285	assertEquals("Called once, increased to 2", 2, h.cnt);
286	assertEquals("Result is provided by H, H gives 0, changes into -1 right now", -1, res.getExitCode());
287
288	synchronized (blockOn) {
289	// let the R task go on
290	blockOn.notifyAll();
291	}
292	task.waitFinished();
293	assertNotNull("Now it is finished", r.res);
294	assertEquals("Result is -1, if this fails: this usually means that the server is blocked by some work and the task R started new server to handle its request",
295	5, r.res.getExitCode());
296	assertEquals("H called three times (but counting from -1)", 2, h.cnt);
297	}
298
299	public void testReadingOfInputWorksInHandler() throws Exception {
300	final byte[] template = { 1, 2, 3, 4 };
301
302	class H extends CLIHandler {
303	private byte[] arr;
304
305	public H() {
306	super(WHEN_INIT);
307	}
308
309	protected int cli(Args args) {
310	try {
311	InputStream is = args.getInputStream();
312	arr = new byte[is.available() / 2];
313	if (arr.length > 0) {
314	assertEquals("Read amount is the same", arr.length, is.read(arr));
315	}
316	is.close();
317	} catch (IOException ex) {
318	fail("There is an exception: " + ex);
319	}
320	return 0;
321	}
322
323	protected void usage(PrintWriter w) {}
324	}
325	H h1 = new H();
326	H h2 = new H();
327
328	// why twice? first attempt is direct, second thru the socket server
329	for (int i = 0; i < 2; i++) {
330	CLIHandler.Status res = cliInitialize(
331	new String[0], new H[] { h1, h2 }, new ByteArrayInputStream(template), nullOutput);
332
333	assertNotNull("Attempt " + i + ": " + "Can be read", h1.arr);
334	assertEquals("Attempt " + i + ": " + "Read two bytes", 2, h1.arr.length);
335	assertEquals("Attempt " + i + ": " + "First is same", template[0], h1.arr[0]);
336	assertEquals("Attempt " + i + ": " + "Second is same", template[1], h1.arr[1]);
337
338	assertNotNull("Attempt " + i + ": " + "Can read as well", h2.arr);
339	assertEquals("Attempt " + i + ": " + "Just one char", 1, h2.arr.length);
340	assertEquals("Attempt " + i + ": " + "And is the right one", template[2], h2.arr[0]);
341
342	h1.arr = null;
343	h2.arr = null;
344	}
345	}
346
347	public void testWritingToOutputIsFine() throws Exception {
348	final byte[] template = { 1, 2, 3, 4 };
349
350	class H extends CLIHandler {
351	public H() {
352	super(WHEN_INIT);
353	}
354
355	protected int cli(Args args) {
356	try {
357	OutputStream os = args.getOutputStream();
358	os.write(template);
359	os.close();
360	} catch (IOException ex) {
361	fail("There is an exception: " + ex);
362	}
363	return 0;
364	}
365
366	protected void usage(PrintWriter w) {}
367	}
368	H h1 = new H();
369	H h2 = new H();
370
371	// why twice? first attempt is direct, second thru the socket server
372	for (int i = 0; i < 2; i++) {
373	ByteArrayOutputStream os = new ByteArrayOutputStream();
374
375	CLIHandler.Status res = cliInitialize(
376	new String[0], new H[] { h1, h2 }, nullInput, os);
377
378	byte[] arr = os.toByteArray();
379	assertEquals("Double size of template", template.length * 2, arr.length);
380
381	for (int pos = 0; pos < arr.length; pos++) {
382	assertEquals(pos + ". is the same", template[pos % template.length], arr[pos]);
383	}
384	}
385	}
386
387	//
388	// Utility methods
389	//
390
391	private static CLIHandler.Status cliInitialize(String[] args, CLIHandler handler, InputStream is, OutputStream os, Integer lock) {
392	return cliInitialize(args, handler, is, os, lock, System.getProperty ("user.dir"));
393	}
394	private static CLIHandler.Status cliInitialize(String[] args, CLIHandler handler, InputStream is, OutputStream os, Integer lock, String currentDir) {
395	return cliInitialize(args, Collections.nCopies(1, handler), is, os, lock, currentDir);
396	}
397	private static CLIHandler.Status cliInitialize(String[] args, CLIHandler[] arr, InputStream is, OutputStream os) {
398	return cliInitialize(args, Arrays.asList(arr), is, os, null);
399	}
400	private static CLIHandler.Status cliInitialize(String[] args, List coll, InputStream is, OutputStream os, Integer lock) {
401	return cliInitialize (args, coll, is, os, lock, System.getProperty ("user.dir"));
402	}
403	private static CLIHandler.Status cliInitialize(String[] args, List coll, InputStream is, OutputStream os, Integer lock, String currentDir) {
404	return CLIHandler.initialize(new CLIHandler.Args(args, is, os, currentDir), lock, coll, true, false, true);
405	}
406
407
408	private static final class InitializeRunner extends Object implements Runnable {
409	private Integer block;
410	private String[] args;
411	private CLIHandler handler;
412	private CLIHandler.Status result;
413
414	public InitializeRunner(int till) throws InterruptedException {
415	this(new String[0], null, till);
416	}
417
418	public InitializeRunner(String[] args, CLIHandler h, int till) throws InterruptedException {
419	this(args, h, new Integer(till));
420	}
421	public InitializeRunner(String[] args, CLIHandler h, Integer till) throws InterruptedException {
422	this.args = args;
423	this.block = till;
424	this.handler = h;
425
426	synchronized (block) {
427	RequestProcessor.getDefault().post(this);
428	block.wait();
429	}
430	}
431
432	public void run() {
433	synchronized (block) {
434	result = CLIHandler.initialize(
435	new CLIHandler.Args(args, nullInput, nullOutput, ""),
436	block,
437	handler == null ? java.util.Collections.EMPTY_LIST : java.util.Collections.nCopies(1, handler),
438	true,
439	false,
440	true);
441	// we are finished, wake up guys in next() if any
442	block.notifyAll();
443	}
444	}
445
446	/** Executes the code to next invocation */
447	public void next() throws InterruptedException {
448	synchronized (block) {
449	block.notify();
450	block.wait();
451	}
452	}
453
454	/** Has already the resutl?
455	*/
456	public boolean hasResult() {
457	return result != null;
458	}
459
460	/** Gets the resultFile, if there is some,
461	*/
462	public File resultFile() {
463	if (result == null) {
464	fail("No result produced");
465	}
466	return result.getLockFile();
467	}
468
469	/** Gets the port, if there is some,
470	*/
471	public int resultPort() {
472	if (result == null) {
473	fail("No result produced");
474	}
475	return result.getServerPort();
476	}
477	} // end of InitializeRunner
478
479	}