engineyard-visualvm 0.5.0

data/cookbooks/server/recipes/default.rb

@@ -0,0 +1,9 @@
+template "#{ENV['HOME']}/server.sh" do
+  source "server.sh.erb"
+  mode "0755"
+end
+
+execute "start server" do
+  cwd ENV['HOME']
+  command "./server.sh"
+end

data/cookbooks/server/templates/default/server.sh.erb

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+export PATH=/usr/local/bin:$PATH
+export JAVA_OPTS=$(jruby -S ey-visualvm jvmargs)
+
+start() {
+  /sbin/start-stop-daemon --start --verbose --background --make-pidfile \
+    --pidfile server.pid --exec /usr/local/bin/jruby --chdir $PWD \
+    -- -e sleep
+}
+
+stop() {
+  /sbin/start-stop-daemon --stop --quiet --pidfile server.pid
+}
+
+case $1 in
+  start)
+    start
+  ;;
+  stop)
+    stop
+  ;;
+  *)
+    start
+  ;;
+esac
+

data/cookbooks/vagrant_main/recipes/default.rb

@@ -0,0 +1,4 @@
+require_recipe 'apt'
+require_recipe 'jruby'
+require_recipe 'gems'
+require_recipe 'server'

data/engineyard-visualvm.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "engineyard-visualvm/version"
+
+Gem::Specification.new do |s|
+  s.name        = "engineyard-visualvm"
+  s.version     = EngineYard::VisualVM::VERSION
+  s.authors     = ["Nick Sieger"]
+  s.email       = ["nick@nicksieger.com"]
+  s.homepage    = "https://github.com/engineyard/engineyard-visualvm"
+  s.summary     = %q{Client and server helpers for using JMX and VisualVM with EY Cloud.}
+  s.description = %q{This provides a Java agent and command-line utility to enable
+    JMX in any Java process such that it can be accessed through a firewall,
+    and a VisualVM launcher aid to connect to that process through ssh.}
+
+  s.rubyforge_project = "jruby-extras"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "childprocess"
+  s.add_runtime_dependency "engineyard"
+  s.add_runtime_dependency "jruby-openssl" # engineyard gem uses ssl
+  s.add_runtime_dependency "ffi-ncurses" # for highline gem, dep of engineyard
+  s.add_development_dependency "rspec"
+end

data/ext/org/jruby/ext/jmx/Agent.java

@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2011 Engine Yard, Inc.
+ * See the file LICENSE.txt included with the distribution for
+ * software license details.
+ *
+ * Based on CustomAgent.java found at the following URLs:
+ * https://blogs.oracle.com/jmxetc/entry/connecting_through_firewall_using_jmx
+ * https://blogs.oracle.com/jmxetc/entry/more_on_premain_and_jmx
+ */
+/*
+ * CustomAgent.java
+ *
+ * Copyright 2007, 2011 Sun Microsystems, Inc.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *   - 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.
+ *
+ *   - Neither the name of Sun Microsystems nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR
+ * CONTRIBUTORS 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.
+ *
+ * Created on Jul 25, 2007, 11:42:49 AM
+ *
+ */
+
+package org.jruby.ext.jmx;
+
+import java.io.IOException;
+import java.lang.management.ManagementFactory;
+import java.rmi.Remote;
+import java.rmi.registry.LocateRegistry;
+import java.rmi.server.RMIServerSocketFactory;
+import java.rmi.server.UnicastRemoteObject;
+import java.util.HashMap;
+import javax.management.MBeanServer;
+import javax.management.remote.JMXConnectorServer;
+import javax.management.remote.JMXConnectorServerFactory;
+import javax.management.remote.JMXServiceURL;
+import javax.management.remote.rmi.RMIConnectorServer;
+
+import sun.jvmstat.monitor.remote.RemoteHost;
+import sun.tools.jstatd.RemoteHostImpl;
+import java.rmi.Naming;
+
+public class Agent {
+
+    private static Thread cleaner;
+
+    private Agent() { }
+
+    public static void premain(String agentArgs) throws IOException {
+
+        // Ensure cryptographically strong random number generator used
+        // to choose the object number - see java.rmi.server.ObjID
+        //
+        System.setProperty("java.rmi.server.randomIDs", "true");
+
+        // Ensure JRuby JMX beans are available in all runtimes
+        System.setProperty("jruby.management.enabled", "true");
+
+        final int port = Integer.parseInt(System.getProperty("org.jruby.jmx.agent.port", "5900"));
+        final String hostname = System.getProperty("org.jruby.jmx.agent.hostname", "localhost");
+
+        // Make sure our RMI server knows which host we're binding to
+        System.setProperty("java.rmi.server.hostname", hostname);
+        System.setProperty("java.rmi.server.disableHttp", "true");
+
+        final RMIServerSocketFactory factory = new RMIServerSocketFactoryImpl(hostname);
+
+        LocateRegistry.createRegistry(port, null, factory);
+        MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
+        HashMap<String,Object> env = new HashMap<String,Object>();
+        env.put(RMIConnectorServer.RMI_SERVER_SOCKET_FACTORY_ATTRIBUTE, factory);
+
+        // Create an RMI connector server.
+        //
+        // As specified in the JMXServiceURL the RMIServer stub will be
+        // registered in the RMI registry running in the local host with the
+        // name "jmxrmi". This is the same name the out-of-the-box
+        // management agent uses to register the RMIServer stub too.
+        //
+        // The port specified in "service:jmx:rmi://"+hostname+":"+port
+        // is the second port, where RMI connection objects will be exported.
+        // Here we use the same port as that we choose for the RMI registry.
+        // The port for the RMI registry is specified in the second part
+        // of the URL, in "rmi://"+hostname+":"+port
+        //
+        JMXConnectorServer cs = new RMIConnectorServer(makeJMXServiceURL(hostname, port), env, mbs);
+
+        try {
+            // Create and register Jstatd remote host
+            Remote remoteHost = (Remote) Class.forName("sun.tools.jstatd.RemoteHostImpl").newInstance();
+            UnicastRemoteObject.exportObject(remoteHost, port, null, factory);
+            Naming.rebind("//"+hostname+":"+port+"/JStatRemoteHost", remoteHost);
+        } catch (Throwable e) {
+            System.err.println("Unable to start jstatd monitor: " + e.toString());
+        }
+
+        cs.start();
+        cleaner = new CleanThread(cs);
+        cleaner.start();
+    }
+
+    public static JMXServiceURL makeJMXServiceURL(String hostname, int port) throws IOException {
+        return new JMXServiceURL("service:jmx:rmi://"+hostname+
+                                 ":"+port+"/jndi/rmi://"+hostname+":"+port+"/jmxrmi");
+    }
+
+    public static class CleanThread extends Thread {
+        private final JMXConnectorServer cs;
+        public CleanThread(JMXConnectorServer cs) {
+            super("JMX Agent Cleaner");
+            this.cs = cs;
+            setDaemon(true);
+        }
+        public void run() {
+            boolean loop = true;
+            try {
+                while (loop) {
+                    final Thread[] all = new Thread[Thread.activeCount()+100];
+                    final int count = Thread.enumerate(all);
+                    loop = false;
+                    for (int i=0;i<count;i++) {
+                        final Thread t = all[i];
+                        // daemon: skip it.
+                        if (t.isDaemon()) continue;
+                        // RMI Reaper: skip it.
+                        if (t.getName().startsWith("RMI Reaper")) continue;
+                        if (t.getName().startsWith("DestroyJavaVM")) continue;
+                        // Non daemon, non RMI Reaper: join it, break the for
+                        // loop, continue in the while loop (loop=true)
+                        loop = true;
+                        try {
+                            t.join();
+                        } catch (Exception ex) {
+                        }
+                        break;
+                    }
+                }
+            } catch (Exception ex) {
+            } finally {
+                try {
+                    cs.stop();
+                } catch (Exception ex) {
+                }
+            }
+        }
+    }
+}

data/ext/org/jruby/ext/jmx/JavaHome.java

@@ -0,0 +1,7 @@
+package org.jruby.ext.jmx.agent;
+
+public class JavaHome {
+    public static void main(String[] args) {
+        System.out.println(System.getProperty("java.home"));
+    }
+}

data/ext/org/jruby/ext/jmx/RMIServerSocketFactoryImpl.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2011 Engine Yard, Inc.
+ * See the file LICENSE.txt included with the distribution for
+ * software license details.
+ *
+ *
+ * Cribbed from http://vafer.org/blog/20061010091658/
+ */
+
+package org.jruby.ext.jmx;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.UnknownHostException;
+import java.rmi.server.RMIServerSocketFactory;
+import javax.net.ServerSocketFactory;
+
+public class RMIServerSocketFactoryImpl implements RMIServerSocketFactory {
+    private final InetAddress localAddress;
+
+    public RMIServerSocketFactoryImpl(final String address) throws UnknownHostException {
+        localAddress = InetAddress.getByName(address);
+    }
+
+    public ServerSocket createServerSocket(final int port) throws IOException  {
+        return ServerSocketFactory.getDefault().createServerSocket(port, 0, localAddress);
+    }
+
+    public boolean equals(Object obj) {
+        return obj != null && obj.getClass().equals(getClass());
+    }
+
+    public int hashCode() {
+        return RMIServerSocketFactoryImpl.class.hashCode();
+    }
+}

data/lib/engineyard-visualvm.rb

@@ -0,0 +1,8 @@
+#--
+# Copyright (c) 2011 Engine Yard, Inc.
+# See the file LICENSE.txt included with the distribution for
+# software license details.
+#++
+
+require 'engineyard-visualvm/version'
+require 'engineyard-visualvm/cli'

data/lib/engineyard-visualvm/cli.rb

@@ -0,0 +1,205 @@
+#--
+# Copyright (c) 2011 Engine Yard, Inc.
+# See the file LICENSE.txt included with the distribution for
+# software license details.
+#++
+
+require "thor"
+require "childprocess"
+require "socket"
+require "engineyard"
+require "engineyard/cli"
+require "engineyard/thor"
+
+module EngineYard
+  module VisualVM
+    module Helpers
+      def self.port_available?(port)
+        begin
+          tcps = TCPServer.new("127.0.0.1", port)
+          true
+        rescue Errno::EADDRINUSE
+          false
+        ensure
+          tcps.close if tcps
+        end
+      end
+
+      STARTING_PORT = 5900
+
+      def self.next_free_port(start = STARTING_PORT)
+        (start...start+100).each do |i|
+          return i if port_available?(i)
+        end
+      end
+
+      def environment
+        @environment ||= begin
+                           fetch_environment(options[:environment], options[:account]).tap {|env|
+                             @user = env.username
+                             @host = fetch_public_ip(env)
+                           }
+                         rescue EY::Error
+                           raise if options[:environment]
+                           nil
+                         end
+      end
+
+      def user
+        @user
+      end
+
+      def ssh?
+        environment || (host && user) || options[:ssh] || options[:socks]
+      end
+
+      def socks_proxy?
+        options[:socks]
+      end
+
+      def ssh_host
+        user ? "#{user}@#{host}" : host
+      end
+
+      def host
+        @host ||= begin
+                    match = /(.*)?@(.*)/.match options[:host]
+                    if match
+                      @user = match[1]
+                      match[2]
+                    else
+                      @user = nil
+                      options[:host]
+                    end
+                  end
+      end
+
+      def next_free_port
+        Helpers.next_free_port(port)
+      end
+
+      def port
+        @port ||= Numeric === options[:port] && options[:port] || STARTING_PORT
+      end
+
+      def jvm_arguments
+        tools_jar = find_tools_jar
+        args = "-Dorg.jruby.jmx.agent.port=#{next_free_port} -javaagent:#{agent_jar_path}"
+        args = "-Dorg.jruby.jmx.agent.hostname=#{host} #{args}" if host != "localhost"
+        args = "-Xbootclasspath/a:#{tools_jar} #{args}" if tools_jar
+        args
+      end
+
+      def jmx_service_url
+        "service:jmx:rmi://#{host}:#{port}/jndi/rmi://#{host}:#{port}/jmxrmi"
+      end
+
+      def find_executable?(exe)
+        ENV['PATH'].split(File::PATH_SEPARATOR).detect do |path|
+          File.exist?(File.join(path, exe))
+        end
+      end
+
+      def agent_jar_path
+        File.expand_path('../agent.jar', __FILE__)
+      end
+
+      def find_tools_jar
+        java_home = `java -classpath #{agent_jar_path} org.jruby.ext.jmx.agent.JavaHome`
+        [File.expand_path('./lib/tools.jar', java_home),
+         File.expand_path('../lib/tools.jar', java_home)].detect do |path|
+          File.readable?(path)
+        end
+      end
+
+      # Return the public IP assigned to an environment (which may or
+      # may not be a booted cluster of instances) Displays error and
+      # exits if no public IP assigned to the environment
+      def fetch_public_ip(environment)
+        unless environment.load_balancer_ip_address
+          warn "#{environment.account.name}/#{environment.name} has no assigned public IP address."
+        end
+
+        environment.load_balancer_ip_address
+      end
+    end
+
+    class CLI < Thor
+      include EY::UtilityMethods
+      include Helpers
+
+      class_option :host, :aliases => ["-H"], :default => "localhost",
+        :desc => "Host or IP where the JMX agent runs"
+      class_option :port, :aliases => ["-p"], :type => :numeric, :default => STARTING_PORT.to_s,
+        :desc => "Port where the JMX agent runs"
+
+      desc "jvmargs", "Print the arguments to be passed to the server JVM"
+      def jvmargs
+        puts jvm_arguments
+      end
+
+      desc "url", "Print the connection URL for the JMX server process"
+      def url
+        puts jmx_service_url
+      end
+
+      desc "version", "Show version"
+      def version
+        puts "ey-visualvm version #{EngineYard::VisualVM::VERSION}"
+      end
+
+      desc "start", "Launch VisualVM to connect to the server.\nUse either the environment/account or host/port options."
+      method_option :ssh,   :type => :boolean, :desc => "Force VisualVM to connect through an ssh tunnel"
+      method_option :socks, :type => :boolean, :desc => "Force VisualVM to connect through a SOCKS proxy"
+      method_option :environment, :aliases => ["-e"], :desc => "Environment containing the IP to which to resolve", :type => :string
+      method_option :account,     :aliases => ["-c"], :desc => "Name of the account where the environment is found"
+      def start
+        unless find_executable?("jvisualvm")
+          warn "Could not find \`jvisualvm\'; do you need to install the JDK?"
+          exit 1
+        end
+
+        visualvm_args = []
+
+        if ssh?
+          ssh_dest = ssh_host
+
+          if socks_proxy?
+            proxy_port = next_free_port
+            visualvm_args += ["-J-Dnetbeans.system_socks_proxy=localhost:#{proxy_port}", "-J-Djava.net.useSystemProxies=true"]
+            @ssh_process = ChildProcess.build("ssh", "-ND", proxy_port.to_s, ssh_dest)
+          else
+            server_host, server_port = host, port
+            @host, @port = "localhost", next_free_port
+            @ssh_process = ChildProcess.build("ssh", "-NL", "#{@port}:#{@host}:#{server_port}", "#{ssh_dest}")
+          end
+
+          @ssh_process.start
+        end
+
+        visualvm_args += ["--openjmx", jmx_service_url.to_s]
+        visualvm = ChildProcess.build("jvisualvm", *visualvm_args)
+        visualvm.start
+
+        loop do
+          visualvm.exited? && break
+          sleep 1
+        end
+
+        @ssh_process.stop if @ssh_process
+      rescue EY::Error => e
+        warn e.message
+        exit 2
+      end
+
+      def help(task = nil, *args)
+        unless task
+          puts "usage: ey-visualvm <task> [options|arguments]"
+          puts "Make JMX and VisualVM more accessible to your server-side JVM."
+          puts
+        end
+        super
+      end
+    end
+  end
+end