jruby-launcher 0.9.9-java

data/resources/jruby.rc

@@ -0,0 +1,25 @@
+id ICON "jruby.ico"
+
+1 VERSIONINFO
+ FILEVERSION    1,0,0,0
+ PRODUCTVERSION 1,0,0,0
+BEGIN
+ BLOCK "StringFileInfo"
+ BEGIN
+  BLOCK "000004b0"
+  BEGIN
+   VALUE "CompanyName",      "http://www.jruby.org/\0"
+   VALUE "FileDescription",  "Windows JRuby Launcher\0"
+   VALUE "FileVersion",      "1.0\0"
+   VALUE "InternalName",     "jruby.exe\0"
+   VALUE "LegalCopyright",   "Copyright (C) The JRuby Team\0"
+   VALUE "OriginalFilename", "jruby.exe\0"
+   VALUE "ProductName",      "JRuby\0"
+   VALUE "ProductVersion",   "1.0\0"
+  END
+ END
+ BLOCK "VarFileInfo"
+ BEGIN
+  VALUE "Translation", 0x0, 0x4b0
+ END
+END

data/spec/launcher_spec.rb

@@ -0,0 +1,134 @@
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe "JRuby native launcher" do
+  it "should run org.jruby.Main" do
+    jruby_launcher_args("").last.should == "org/jruby/Main"
+  end
+
+  it "should pass unrecognized arguments to JRuby" do
+    jruby_launcher_args("-J-Dsome.option -v --help")[-3..-1].should == ["org/jruby/Main", "-v", "--help"]
+  end
+
+  it "should print help message" do
+    jruby_launcher("-Xhelp 2>&1").should =~ /JRuby Launcher usage/
+  end
+
+  it "should use $JAVA_HOME/bin/java when JAVA_HOME is specified" do
+    with_environment "JAVA_HOME" => File.join("some", "java", "home") do
+      if windows?
+        jruby_launcher_args("-v 2>&1").join.should =~ %r{some/java/home}
+      else
+        jruby_launcher_args("-v").first.should == File.join("some", "java", "home", "bin", "java")
+      end
+    end
+  end
+
+  it "should use -Xjdkhome argument above JAVA_HOME" do
+    with_environment "JAVA_HOME" => File.join("env", "java", "home") do
+      if windows?
+        jruby_launcher_args("-Xjdkhome some/java/home 2>&1").join.should =~ %r{some/java/home}
+      else
+        jruby_launcher_args("-Xjdkhome some/java/home").first.should == File.join("some", "java", "home", "bin", "java")
+      end
+    end
+  end
+
+  it "should complain about a missing log argument" do
+    jruby_launcher("-Xtrace 2>&1").should =~ /Argument is missing for "-Xtrace"/
+    jruby_launcher("-Xtrace -- 2>&1").should =~ /Argument is missing for "-Xtrace"/
+  end
+
+  it "should complain about a missing jdkhome argument" do
+    jruby_launcher("-Xjdkhome 2>&1").should =~ /Argument is missing/
+    jruby_launcher("-Xjdkhome -- 2>&1").should =~ /Argument is missing/
+  end
+
+  it "should complain about a missing classpath append argument" do
+    jruby_launcher("-Xcp:a 2>&1").should =~ /Argument is missing/
+    jruby_launcher("-Xcp:a -- 2>&1").should =~ /Argument is missing/
+  end
+
+  it "should run nailgun server with --ng-server option" do
+    jruby_launcher_args("--ng-server").last.should == "com/martiansoftware/nailgun/NGServer"
+  end
+
+  it "should run nailgun client with --ng option" do
+    jruby_launcher_args('--ng -e "puts 1"').should == ["org.jruby.util.NailMain", "-e", "puts 1"]
+  end
+
+  it "should handle -J JVM options" do
+    jruby_launcher_args("-J-Darg1=value1 -J-Darg2=value2").should include("-Darg1=value1", "-Darg2=value2")
+  end
+
+  it "should default to 500m max heap" do
+    jruby_launcher_args("").should include("-Xmx500m", "-Djruby.memory.max=500m")
+  end
+
+  it "should allow max heap to be overridden" do
+    jruby_launcher_args("-J-Xmx256m").should include("-Xmx256m", "-Djruby.memory.max=256m")
+  end
+
+  it "should default to 1024k max stack" do
+    jruby_launcher_args("").should include("-Xss1024k", "-Djruby.stack.max=1024k")
+  end
+
+  it "should allow max stack to be overridden" do
+    jruby_launcher_args("-J-Xss512k").should include("-Xss512k", "-Djruby.stack.max=512k")
+  end
+
+  it "should add the contents of the CLASSPATH environment variable" do
+    with_environment "CLASSPATH" => "some.jar" do
+      classpath_arg = jruby_launcher_args("").detect{|a| a =~ /java\.class\.path/}
+      classpath_arg.should =~ /-Djava.class.path=.*some.jar/
+    end
+  end
+
+  it "should add the classpath elements in proper order" do
+    s = File::PATH_SEPARATOR
+    with_environment "CLASSPATH" => "some-env.jar" do
+      classpath_arg = jruby_launcher_args("-Xcp:a some-other.jar -Xcp:p some.jar").detect{|a| a =~ /java\.class\.path/}
+      classpath_arg.should =~ /-Djava.class.path=some.jar.*#{s}some-env.jar#{s}some-other.jar/
+    end
+  end
+
+  it "should use the --server compiler" do
+    jruby_launcher_args("--server").should include("-server")
+  end
+
+  it "should use the --client compiler" do
+    jruby_launcher_args("--client").should include("-client")
+  end
+
+  it "should set the JMX settings when --manage is present" do
+    jruby_launcher_args("--manage").should include("-Dcom.sun.management.jmxremote", "-Djruby.management.enabled=true")
+  end
+
+  it "should set the headless flag when --headless is present" do
+    jruby_launcher_args("--headless").should include("-Djava.awt.headless=true")
+  end
+
+  it "should pass -Xprof when --sample is present" do
+    jruby_launcher_args("--sample").should include("-Xprof")
+  end
+
+  it "should stop argument processing when a -- is seen" do
+    jruby_launcher_args("-- -Xhelp -Xtrace --headless").should include("-Xhelp", "-Xtrace", "--headless")
+  end
+
+  # JRUBY-4151
+  it "should properly handle single quotes" do
+    jruby_launcher_args("-e 'ABC DEF'").should include("ABC DEF")
+  end
+
+  # JRUBY-4581
+  it "should prepend JRUBY_OPTS to the start of the argument list to process" do
+    with_environment "JRUBY_OPTS" => "--server -J-Dsome.key=val -rubygems" do
+      jruby_launcher_args("-e 'ABC DEF'").should include("-server", "-Dsome.key=val", "-rubygems", "-e", "ABC DEF")
+    end
+  end
+
+  # JRUBY-4611
+  it "stops argument processing on first non-option argument" do
+    jruby_launcher_args("foo.rb --profile")[-2..-1].should == ["foo.rb", "--profile"]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,61 @@
+require 'spec'
+require 'rbconfig'
+
+if defined?(JRUBY_VERSION)
+  require 'jruby'
+  JRuby.runtime.instance_config.run_ruby_in_process = false
+end
+
+module JRubyLauncherHelper
+  JRUBY_EXE = File.expand_path("../../jruby", __FILE__) + Config::CONFIG['EXEEXT']
+  WINDOWS = Config::CONFIG['target_os'] =~ /mswin/
+
+  def self.check_executable_built
+    unless File.executable?(JRUBY_EXE)
+      raise "Error: launcher executable not built; type `make' before continuing."
+    end
+  end
+
+  def jruby_launcher(args)
+    `#{JRUBY_EXE} #{args}`
+  end
+
+  def jruby_launcher_args(args)
+    jruby_launcher("-Xcommand #{args}").split("\n")
+  end
+
+  def last_exit_code
+    $?.exitstatus
+  end
+
+  def windows?
+    WINDOWS
+  end
+
+  def with_environment(pairs = {})
+    prev_env = {}
+    pairs.each_pair do |k,v|
+      prev_env[k] = ENV[k] if ENV.has_key?(k)
+      ENV[k] = v
+    end
+    begin
+      yield
+    ensure
+      pairs.keys.each {|k| ENV.delete(k)}
+      ENV.update(prev_env)
+    end
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.before(:all) do
+    JRubyLauncherHelper.check_executable_built
+    # clear environment for better control
+    ENV.delete("JAVA_HOME")
+    ENV.delete("JRUBY_HOME")
+    ENV.delete("JAVA_OPTS")
+    ENV.delete("JRUBY_OPTS")
+    ENV.delete("CLASSPATH")
+  end
+  config.include(JRubyLauncherHelper)
+end

data/strlcpy.c

@@ -0,0 +1,69 @@
+/*	$OpenBSD: strlcpy.c,v 1.5 2001/05/13 15:40:16 deraadt Exp $	*/
+
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char *rcsid = "$OpenBSD: strlcpy.c,v 1.5 2001/05/13 15:40:16 deraadt Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/types.h>
+#include <string.h>
+
+/*
+ * Copy src to string dst of size siz.  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz == 0).
+ * Returns strlen(src); if retval >= siz, truncation occurred.
+ */
+size_t
+strlcpy(dst, src, siz)
+	char *dst;
+	const char *src;
+	size_t siz;
+{
+	register char *d = dst;
+	register const char *s = src;
+	register size_t n = siz;
+
+	/* Copy as many bytes as will fit */
+	if (n != 0 && --n != 0) {
+		do {
+			if ((*d++ = *s++) == 0)
+				break;
+		} while (--n != 0);
+	}
+
+	/* Not enough room in dst, add NUL and traverse rest of src */
+	if (n == 0) {
+		if (siz != 0)
+			*d = '\0';		/* NUL-terminate dst */
+		while (*s++)
+			;
+	}
+
+	return(s - src - 1);	/* count does not include NUL */
+}

data/unixlauncher.cpp

@@ -0,0 +1,81 @@
+#include <stdlib.h>
+#include "unixlauncher.h"
+#include "utilsfuncs.h"
+
+using namespace std;
+
+extern "C" int nailgunClientMain(int argc, char *argv[], char *env[]);
+
+UnixLauncher::UnixLauncher()
+    : ArgParser()
+{
+}
+
+UnixLauncher::UnixLauncher(const UnixLauncher& orig)
+    : ArgParser(orig)
+{
+}
+
+UnixLauncher::~UnixLauncher() {
+}
+
+int UnixLauncher::run(int argc, char* argv[], char* envp[]) {
+    platformDir = argv[0];
+    if (!initPlatformDir() || !parseArgs(argc - 1, argv + 1)) {
+        return 255;
+    }
+
+    if (nailgunClient) {
+        progArgs.push_front("org.jruby.util.NailMain");
+        char ** nailArgv = convertToArgvArray(progArgs);
+        if (printCommandLine) {
+            return printArgvToConsole(nailArgv);
+        }
+        return nailgunClientMain(progArgs.size(), (char**)nailArgv, envp);
+    }
+
+    prepareOptions();
+
+    string java("");
+
+    if (!jdkhome.empty()) {
+        java = jdkhome + "/bin/java";
+    } else if (getenv("JAVA_HOME") != NULL) {
+        java = string(getenv("JAVA_HOME")) + "/bin/java";
+    } else {
+        java = findOnPath("java");
+    }
+
+    if (java.empty()) {
+        printToConsole("No `java' executable found on PATH.");
+        return 255;
+    }
+
+    list<string> commandLine;
+    commandLine.push_back(java);
+    addOptionsToCommandLine(commandLine);
+
+    logMsg("Command line:");
+    for (list<string>::iterator it = commandLine.begin(); it != commandLine.end(); ++it) {
+        logMsg(it->c_str());
+    }
+
+    char** newArgv = convertToArgvArray(commandLine);
+
+    if (printCommandLine) {
+        return printArgvToConsole(newArgv);
+    }
+
+
+    if (!fileExists(java.c_str())) {
+        string msg = "No `java' exists at " + java + ", please double-check JAVA_HOME.\n";
+        printToConsole(msg.c_str());
+        return 255;
+    }
+
+    execv(java.c_str(), newArgv);
+
+    // shouldn't get here unless something bad happened with execv
+    logErr(true, true, "execv failed:");
+    return 255;
+}

data/unixlauncher.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2009-2010 JRuby Team (www.jruby.org).
+ */
+
+
+#ifndef _UNIXLAUNCHER_H_
+#define _UNIXLAUNCHER_H_
+
+#include "argparser.h"
+
+class UnixLauncher : public ArgParser {
+public:
+    UnixLauncher();
+    virtual ~UnixLauncher();
+
+    int run(int argc, char* argv[], char* envp[]);
+
+private:
+    UnixLauncher(const UnixLauncher& orig);
+};
+
+#endif // ! _UNIXLAUNCHER_H_

data/utilsfuncs.cpp

@@ -0,0 +1,269 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright 2009-2010 JRuby Team (www.jruby.org).
+ * Copyright 1997-2008 Sun Microsystems, Inc. All rights reserved.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common
+ * Development and Distribution License("CDDL") (collectively, the
+ * "License"). You may not use this file except in compliance with the
+ * License. You can obtain a copy of the License at
+ * http://www.netbeans.org/cddl-gplv2.html
+ * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
+ * specific language governing permissions and limitations under the
+ * License.  When distributing the software, include this License Header
+ * Notice in each file and include the License file at
+ * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the GPL Version 2 section of the License file that
+ * accompanied this code. If applicable, add the following below the
+ * License Header, with the fields enclosed by brackets [] replaced by
+ * your own identifying information:
+ * "Portions Copyrighted [year] [name of copyright owner]"
+ *
+ * Contributor(s):
+ *
+ * The Original Software is NetBeans. The Initial Developer of the Original
+ * Software is Sun Microsystems, Inc. Portions Copyright 1997-2008 Sun
+ * Microsystems, Inc. All Rights Reserved.
+ *
+ * If you wish your version of this file to be governed by only the CDDL
+ * or only the GPL Version 2, indicate your decision by adding
+ * "[Contributor] elects to include this software in this distribution
+ * under the [CDDL or GPL Version 2] license." If you do not indicate a
+ * single choice of license, a recipient has the option to distribute
+ * your version of this file under either the CDDL, the GPL Version 2 or
+ * to extend the choice of license to its licensees as provided above.
+ * However, if you add GPL Version 2 code and therefore, elected the GPL
+ * Version 2 license, then the option applies only if the new code is
+ * made subject to such option by the copyright holder.
+ *
+ * Author: Tomas Holy
+ */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <cstring>
+#include <cstdlib>
+#include <memory>
+#include "utilsfuncs.h"
+#include "argnames.h"
+
+#ifndef WIN32
+#include <sys/stat.h>
+#include <errno.h>
+#include <string.h>
+#endif
+
+#ifdef __SUNOS__
+#include <sys/varargs.h>
+#endif
+
+using namespace std;
+
+bool checkExists(const char* path, unsigned int flags) {
+#ifdef WIN32
+    WIN32_FIND_DATA fd = {0};
+    HANDLE hFind = 0;
+    hFind = FindFirstFile(path, &fd);
+    if (hFind == INVALID_HANDLE_VALUE) {
+        return false;
+    }
+    FindClose(hFind);
+    if (flags == 0) {
+	return true;
+    }
+    return (fd.dwFileAttributes & flags) != 0;
+#else
+    struct stat dir;
+    if (stat(path, &dir) != 0) {
+	return false;
+    }
+    if (flags == 0) {
+	return true;
+    }
+    return dir.st_mode & flags;
+#endif
+}
+
+bool checkDirectory(const char* path) {
+#ifdef WIN32
+    unsigned int flags = FILE_ATTRIBUTE_DIRECTORY;
+#else
+    unsigned int flags = S_IFDIR;
+#endif
+    return checkExists(path, flags);
+}
+
+bool dirExists(const char *path) {
+    if (!checkDirectory(path)) {
+        logMsg("Dir \"%s\" does not exist", path);
+        return false;
+    }
+    logMsg("Dir \"%s\" exists", path);
+    return true;
+}
+
+bool fileExists(const char *path) {
+    if (!checkExists(path, 0)) {
+        logMsg("File \"%s\" does not exist", path);
+        return false;
+    }
+    logMsg("File \"%s\" exists", path);
+    return true;
+}
+
+char* findOnPath(const char* name) {
+    string path(getenv("PATH"));
+    size_t start = 0;
+    size_t sep;
+    char * found;
+
+    while (start < path.length()) {
+	sep = path.find(PATH_SEP, start);
+	if (sep == string::npos) {
+	    sep = path.length();
+	}
+
+	string elem(path.substr(start, sep - start));
+	if (elem[elem.length() - 1] != FILE_SEP) {
+	    elem += FILE_SEP;
+	}
+	elem += name;
+
+	if (checkExists(elem.c_str(), 0)) {
+	    found = (char*) malloc(elem.length());
+	    strncpy(found, elem.c_str(), elem.length() + 1);
+	    return found;
+	}
+
+	start = sep + 1;
+    }
+    return NULL;
+}
+
+const char* getSysError(char *str, int strSize) {
+#ifdef WIN32
+    int err = GetLastError();
+    LPTSTR lpMsgBuf;
+    FormatMessage(
+            FORMAT_MESSAGE_ALLOCATE_BUFFER |
+            FORMAT_MESSAGE_FROM_SYSTEM |
+            FORMAT_MESSAGE_IGNORE_INSERTS,
+            NULL,
+            err,
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+            (LPTSTR) & lpMsgBuf,
+            0,
+            NULL
+            );
+    LPTSTR tmp = strchr(lpMsgBuf, '\r');
+    if (tmp != NULL) {
+        *tmp = '\0';
+    }
+
+    _snprintf(str, strSize, " %s (%u)", lpMsgBuf, err);
+    LocalFree(lpMsgBuf);
+#else
+    const char* error = strerror(errno);
+    snprintf(str, strSize, " %s (%u)", error, errno);
+#endif
+    return str;
+}
+
+string gLogFileName;
+
+void logV(bool appendSysError, bool showMsgBox, const char *format, va_list args) {
+    char msg[4096] = "";
+    vsnprintf(msg, 4096, format, args);
+
+    if (appendSysError) {
+        char sysErr[512] = "";
+        getSysError(sysErr, 512);
+        strncat(msg, sysErr, 4096 - strlen(msg));
+    }
+
+    if (!gLogFileName.empty()) {
+        FILE *file = fopen(gLogFileName.c_str(), "a");
+        if (file) {
+            fprintf(file, "%s\n", msg);
+            fclose(file);
+        }
+    }
+
+    if (showMsgBox) {
+#ifdef WIN32
+        // Pop-up the message box only if there is no console
+        if (!isConsoleAttached()) {
+            ::MessageBox(NULL, msg, "JRuby Error", MB_OK | MB_ICONSTOP);
+        }
+#endif
+        fprintf(stderr, "%s\n", msg);
+    }
+}
+
+void logErr(bool appendSysError, bool showMsgBox, const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    logV(appendSysError, showMsgBox, format, args);
+}
+
+void logMsg(const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    logV(false, false, format, args);
+}
+
+bool checkLoggingArg(int argc, char *argv[], bool delFile) {
+    for (int i = 0; i < argc; i++) {
+        if (strcmp("--", argv[i]) == 0) {
+            break;
+        }
+        if (strcmp(ARG_NAME_LAUNCHER_LOG, argv[i]) == 0) {
+            if (i+1 == argc || *argv[i+1] == '-') {
+                return false;
+            }
+            gLogFileName = argv[++i];
+            if (delFile) {
+#ifdef WIN32
+                DeleteFile(gLogFileName.c_str());
+#else
+		unlink(gLogFileName.c_str());
+#endif
+            }
+            break;
+        }
+    }
+    return true;
+}
+
+bool printToConsole(const char *msg) {
+    fprintf(stderr, "%s", msg);
+    return false;
+}
+
+char** convertToArgvArray(list<string> args) {
+    char ** argv = (char**) malloc(sizeof (char*) * args.size() + 1);
+    int i = 0;
+    for (list<string>::iterator it = args.begin(); it != args.end(); ++it, ++i) {
+        argv[i] = (char*) malloc(sizeof(char) * it->length() + 1);
+        strncpy(argv[i], it->c_str(), it->length() + 1);
+    }
+    argv[i] = NULL;
+    return argv;
+}
+
+void addToArgList(list<string> & args, int argc, char ** argv) {
+    for (int i = 0; i < argc; i++) {
+	args.push_back(argv[i]);
+    }
+}
+
+int printArgvToConsole(char** argv) {
+    while (*argv) {
+	printf("%s\n", *argv);
+	argv++;
+    }
+    return 0;
+}