jmx4r 0.0.8 → 0.1.0

data/README.rdoc

@@ -29,6 +29,11 @@ jmx4r helps to manage Java applications using JMX in a simple and powerful way:
   # trigger a Garbage Collection
   memory.gc
 
+  # For local processes not publishing jmxrmi ports, instead:
+
+  # connect to the local JConsole process
+  JMX::MBean.establish_connection :command => /jconsole/i
+
 == Help
 
 * Wiki[http://jmesnil.net/wiki/Jmx4r]

data/Rakefile

@@ -6,7 +6,7 @@ require "rubygems"
 
 dir     = File.dirname(__FILE__)
 lib     = File.join(dir, "lib", "jmx4r.rb")
-version = "0.0.8"
+version = "0.1.0"
 
 task :default => [:test]
 

data/lib/dynamic_mbean.rb

@@ -3,10 +3,10 @@
 # taken from the 'jmx' gems in jruby-extras
 
 module JMX
-  import javax.management.MBeanParameterInfo
-  import javax.management.MBeanOperationInfo
-  import javax.management.MBeanAttributeInfo
-  import javax.management.MBeanInfo
+  java_import javax.management.MBeanParameterInfo
+  java_import javax.management.MBeanOperationInfo
+  java_import javax.management.MBeanAttributeInfo
+  java_import javax.management.MBeanInfo
 
   # Module that is used to bridge java to ruby and ruby to java types.
   module JavaTypeAware
@@ -99,32 +99,36 @@ module JMX
   # like: user_name= and username.  So in your ruby code you can treat the attributes
   # as "regular" ruby accessors
   class DynamicMBean
-    import javax.management.MBeanOperationInfo
-    import javax.management.MBeanAttributeInfo
-    import javax.management.DynamicMBean
-    import javax.management.MBeanInfo
+    java_import javax.management.MBeanOperationInfo
+    java_import javax.management.MBeanAttributeInfo
+    java_import javax.management.DynamicMBean
+    java_import javax.management.MBeanInfo
     include JMX::JavaTypeAware
   
     #NOTE this will not be needed when JRuby-3164 is fixed.
     def self.inherited(cls)
       cls.send(:include, DynamicMBean)
     end
+    
+    def self.mbean_attributes
+      @mbean_attributes ||= {}
+    end
   
     # TODO: preserve any original method_added?
     # TODO: Error handling here when it all goes wrong?
     def self.method_added(name) #:nodoc:
-      return if Thread.current[:op].nil?
-      Thread.current[:op].name = name
-      operations << Thread.current[:op].to_jmx
-      Thread.current[:op] = nil
+      return if self.mbean_attributes[:op].nil?
+      self.mbean_attributes[:op].name = name
+      operations << self.mbean_attributes[:op].to_jmx
+      self.mbean_attributes[:op] = nil
     end
   
     def self.attributes #:nodoc:
-      Thread.current[:attrs] ||= []
+      self.mbean_attributes[:attrs] ||= []
     end
   
     def self.operations #:nodoc:
-      Thread.current[:ops] ||= []
+      self.mbean_attributes[:ops] ||= []
     end
   
     # the <tt>rw_attribute</tt> method is used to declare a JMX read write attribute.
@@ -207,7 +211,7 @@ module JMX
     #++
     def self.operation(description=nil)
       # Wait to error check until method_added so we can know method name
-      Thread.current[:op] = JMX::Operation.new description
+      self.mbean_attributes[:op] = JMX::Operation.new description
     end
   
     # Used to declare a parameter (you can declare more than one in succession) that
@@ -220,7 +224,7 @@ module JMX
     #        ...
     #     end
     def self.parameter(type, name=nil, description=nil)
-      Thread.current[:op].parameters << JMX::Parameter.new(type, name, description)
+      self.mbean_attributes[:op].parameters << JMX::Parameter.new(type, name, description)
     end
   
     # Used to declare the return type of the operation
@@ -231,7 +235,7 @@ module JMX
     #        ...
     #     end
     def self.returns(type)
-      Thread.current[:op].return_type = type
+      self.mbean_attributes[:op].return_type = type
     end
   
     def initialize(description="")
@@ -272,4 +276,3 @@ module JMX
   end
   
 end
-  

data/lib/jconsole.rb

@@ -12,7 +12,8 @@ module JConsole
   # By default, no authentication is required to connect to it.
   #
   # The args hash accepts 3 keys:
-  # [:port]        the port which will be listens to JMX connections
+  # [:port]        the port which will be listens to JMX connections.
+  #                if the port is 0, jmxrmi port is not published
   # [:pwd_file]    the path to the file containing the authentication credentials
   # [:access_file] the path to the file containing the authorization credentials
   #
@@ -29,13 +30,19 @@ module JConsole
     cmd =<<-EOCMD.split("\n").join(" ")
     jconsole
     -J-Dcom.sun.management.jmxremote 
-    -J-Dcom.sun.management.jmxremote.port=#{port} 
-    -J-Dcom.sun.management.jmxremote.ssl=false 
-    -J-Dcom.sun.management.jmxremote.authenticate=#{!pwd_file.nil?}
-EOCMD
-    if pwd_file and access_file
-      cmd << " -J-Dcom.sun.management.jmxremote.password.file=#{pwd_file}" 
-      cmd << " -J-Dcom.sun.management.jmxremote.access.file=#{access_file}"
+    EOCMD
+
+    if port != 0
+      cmd << <<-EOCMD.split("\n").join(" ")
+      -J-Dcom.sun.management.jmxremote.port=#{port}
+      -J-Dcom.sun.management.jmxremote.ssl=false
+      -J-Dcom.sun.management.jmxremote.authenticate=#{!pwd_file.nil?}
+      EOCMD
+
+      if pwd_file and access_file
+        cmd << " -J-Dcom.sun.management.jmxremote.password.file=#{pwd_file}"
+        cmd << " -J-Dcom.sun.management.jmxremote.access.file=#{access_file}"
+      end
     end
     Thread.start { system cmd }
     sleep 3
@@ -46,7 +53,11 @@ EOCMD
   # By default, it will kill the process corresponding to an instance JConsole with 
   # a port on 3000. Another port can be specified in parameter.
   def JConsole.stop(port=3000)
-    jconsole_pid = `ps a -w -o pid,command | grep -w jconsole | grep port=#{port} | grep -v grep | grep -v ruby | cut -c -5`
+    ps  = "ps a -w -o pid,command | grep -w jconsole"
+    ps << " | grep port=#{port}" if port != 0
+    ps << " | grep -v grep | grep -v ruby | cut -c -5"
+
+    jconsole_pid = `#{ps}`
     `kill #{jconsole_pid}` if jconsole_pid != ""
     sleep 1
   end

data/lib/jdk/jdk4.rb

@@ -0,0 +1,16 @@
+
+module JMX
+  module JDKHelper
+    module JDK4
+
+      class << self
+        def method_missing(method, *args, &block)
+          raise "JDK (>= 5.0) implementation is not available - \
+            maybe only JREs or older JDKs are installed properly."
+        end
+      end
+
+    end
+  end
+end
+

data/lib/jdk/jdk5.rb

@@ -0,0 +1,34 @@
+
+module JMX
+  module JDKHelper
+    module JDK5
+      include_class 'sun.jvmstat.monitor.HostIdentifier'
+      include_class 'sun.jvmstat.monitor.MonitoredHost'
+      include_class 'sun.jvmstat.monitor.MonitoredVmUtil'
+      include_class 'sun.jvmstat.monitor.VmIdentifier'
+      include_class 'sun.management.ConnectorAddressLink'
+
+      class << self
+
+        def find_local_url(command_pattern)
+          host_id = HostIdentifier.new(nil)
+          host = MonitoredHost.get_monitored_host(host_id)
+
+          host.active_vms.each do |vmid_int|
+            vmid = VmIdentifier.new(vmid_int.to_s)
+            vm = host.get_monitored_vm(vmid)
+            command = MonitoredVmUtil.command_line(vm)
+            if command_pattern === command
+              return ConnectorAddressLink.import_from(vmid_int)
+            end
+          end
+
+          nil
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/jdk/jdk6.rb

@@ -0,0 +1,69 @@
+
+module JMX
+  module JDKHelper
+    module JDK6
+      include_class 'com.sun.tools.attach.VirtualMachine'
+
+      class << self
+        def find_local_url(command_pattern)
+          target_vmd = VirtualMachine.list.find do |vmd|
+            command_pattern === vmd.display_name
+          end
+
+          if target_vmd
+            local_connector_address(target_vmd)
+          end
+        end
+
+      private
+
+        def local_connector_address(vm_descriptor)
+          vm = VirtualMachine.attach(vm_descriptor)
+
+          address = nil
+          agent_loaded = false
+
+          lambda {
+            address = vm.get_agent_properties.get(
+              "com.sun.management.jmxremote.localConnectorAddress")
+
+            unless address || agent_loaded
+              load_management_agent(vm)
+              agent_loaded = true
+              redo
+            end
+          }.call
+
+          vm.detach
+
+          address
+        end
+
+        def load_management_agent(vm)
+          home =
+            vm.get_system_properties.get_property 'java.home'
+
+          try_load_management_agent(vm, [home, 'jre', 'lib']) or
+            try_load_management_agent(vm, [home, 'lib']) or
+              raise "management agent not found"
+        end
+
+        def try_load_management_agent(vm, path)
+          sep = vm.get_system_properties.get_property 'file.separator'
+
+          path = path.dup
+          path << 'management-agent.jar'
+
+          file = Java::java.io.File.new(path.join(sep))
+          if file.exists
+            vm.load_agent(file.get_canonical_path,
+                          "com.sun.management.jmxremote")
+            true
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/lib/jdk_helper.rb

@@ -0,0 +1,69 @@
+
+module JMX
+  module JDKHelper
+    include_class 'java.lang.System'
+
+    class << self
+
+      def method_missing(method, *args, &block)
+        init unless @jdk
+        @jdk.send method, *args, &block
+      end
+
+    private
+
+      def init
+        @jdk =
+          case
+          when has_java_class?("com.sun.tools.attach.VirtualMachine")
+            require "jdk/jdk6"
+            JDK6
+          when has_java_class?('sun.jvmstat.monitor.MonitoredHost')
+            require "jdk/jdk5"
+            JDK5
+          else
+            require "jdk/jdk4"
+            JDK4
+          end
+      end
+
+      def has_java_class?(name)
+        begin
+          include_class name
+          true
+        rescue
+          retry if load_tools_jar
+          false
+        end
+      end
+
+      def load_tools_jar
+        unless @tools_loaded
+          home = System.get_property 'java.home'
+          paths = [
+            [home, '..', 'lib'],
+            [home, 'lib'],
+          ]
+          try_load_jar('tools.jar', paths)
+          @tools_loaded = true
+          true
+        end
+      end
+
+      def try_load_jar(jar_file, paths)
+        sep = System.get_property 'file.separator'
+        paths = paths.dup
+        begin
+          path = paths.shift
+          require path.join(sep) + sep + jar_file
+          true
+        rescue LoadError
+          retry unless paths.empty?
+          false
+        end
+      end
+    end
+
+  end
+end
+

data/lib/jmx4r.rb

@@ -18,6 +18,7 @@ module JMX
   require 'dynamic_mbean'
   require 'open_data_helper'
   require 'objectname_helper'
+  require 'jdk_helper'
   require 'jruby'
 
   class MBeanServerConnectionProxy
@@ -57,6 +58,13 @@ module JMX
 
     attr_reader :object_name, :operations, :attributes, :connection
 
+    def metaclass; class << self; self; end; end
+    def meta_def name, &blk
+      metaclass.instance_eval do
+          define_method name, &blk
+      end
+    end
+
     # Creates a new MBean.
     #
     # object_name:: a string corresponding to a valid ObjectName
@@ -70,19 +78,6 @@ module JMX
       @attributes = Hash.new
       info.attributes.each do | mbean_attr |
         @attributes[mbean_attr.name.snake_case] = mbean_attr.name
-        self.class.instance_eval do 
-          define_method mbean_attr.name.snake_case do
-            @connection.getAttribute @object_name, "#{mbean_attr.name}"
-          end
-        end
-        if mbean_attr.isWritable
-          self.class.instance_eval do
-            define_method "#{mbean_attr.name.snake_case}=" do |value| 
-              attr = Attribute.new mbean_attr.name, value
-              @connection.setAttribute @object_name, attr
-            end
-          end
-        end
       end
       @operations = Hash.new
       info.operations.each do |mbean_op|
@@ -92,12 +87,14 @@ module JMX
     end
 
     def method_missing(method, *args, &block) #:nodoc:
-      if @operations.keys.include?(method.to_s)
-        op_name, param_types = @operations[method.to_s]
+      method_in_snake_case = method.to_s.snake_case # this way Java/JRuby styles are compatible
+
+      if @operations.keys.include?(method_in_snake_case)
+        op_name, param_types = @operations[method_in_snake_case]
         @connection.invoke @object_name,
-        op_name,
-        args.to_java(:Object),
-        param_types.to_java(:String)
+                           op_name,
+                           args.to_java(:Object),
+                           param_types.to_java(:String)
       else
         super
       end
@@ -115,6 +112,7 @@ module JMX
     # 
     #   JMX::MBean.establish_connection :port => "node23", :port => 1090
     #   JMX::MBean.establish_connection :port => "node23", :username => "jeff", :password => "secret"
+    #   JMX::MBean.establish_connection :command => /jconsole/i
     def self.establish_connection(args={})
       @@connection ||= create_connection args
     end
@@ -147,6 +145,16 @@ module JMX
     #                     if the url is specified, the host & port parameters are
     #                     not taken into account
     #
+    # [:command]          the pattern matches the command line of the local
+    #                     JVM process including the MBean server.
+    #                     (command lines are listed on the connection dialog
+    #                      in JConsole).
+    #                     No default.
+    #                     this feature needs a JDK (>=5) installed on the local
+    #                     system.
+    #                     if the command is specified, the host & port or the url
+    #                     parameters are not taken into account
+    #
     # [:username]         the name of the user (if the MBean server requires authentication).
     #                     No default
     #
@@ -168,9 +176,14 @@ module JMX
       credentials = args[:credentials]
       provider_package = args[:provider_package]
       
-      # host & port are not taken into account if url is set (see issue #7)
-      standard_url = "service:jmx:rmi:///jndi/rmi://#{host}:#{port}/jmxrmi"
-      url = args[:url] || standard_url
+      if args[:command]
+        url = JDKHelper.find_local_url(args[:command]) or
+          raise "no locally attacheable VMs"
+      else
+        # host & port are not taken into account if url is set (see issue #7)
+        standard_url = "service:jmx:rmi:///jndi/rmi://#{host}:#{port}/jmxrmi"
+        url = args[:url] || standard_url
+      end
       
       unless credentials
         if !username.nil? and username.length > 0
@@ -219,7 +232,7 @@ module JMX
       object_name = ObjectName.new(name)
       connection = args[:connection] || MBean.connection(args)
       object_names = connection.queryNames(object_name, nil)
-      object_names.map { |on| MBean.new(on, connection) }
+      object_names.map { |on| create_mbean on, connection }
     end
 
     # Same as #find_all_by_name but the ObjectName passed in parameter
@@ -227,7 +240,25 @@ module JMX
     # Only one single MBean is returned.
     def self.find_by_name(name, args={})
       connection = args[:connection] || MBean.connection(args)
-      MBean.new ObjectName.new(name), connection
+      create_mbean ObjectName.new(name), connection
+    end
+
+    def self.create_mbean(object_name, connection)
+      info = connection.getMBeanInfo object_name
+      mbean = MBean.new object_name, connection
+      # define attribute accessor methods for the mbean
+      info.attributes.each do |mbean_attr|
+        mbean.meta_def mbean_attr.name.snake_case do
+          connection.getAttribute object_name, mbean_attr.name
+        end
+        if mbean_attr.isWritable
+          mbean.meta_def "#{mbean_attr.name.snake_case}=" do |value|
+            attribute = Attribute.new mbean_attr.name, value
+            connection.setAttribute object_name, attribute
+          end
+        end
+      end
+      mbean
     end
 
     def self.pretty_print (object_name, args={})

data/test/tc_attributes.rb

@@ -34,4 +34,11 @@ class TestAttribute < Test::Unit::TestCase
   def test_non_writable_attribute
     assert_raise(NoMethodError) { @memory.object_pending_finalization_count = -1 }
   end
+
+  def test_non_overlapping_attributes
+    assert_raise(NoMethodError) { @memory.logger_names }
+    logging = JMX::MBean.find_by_name "java.util.logging:type=Logging", :connection => ManagementFactory.platform_mbean_server
+    assert_raise(NoMethodError) { logging.verbose }
+    assert_raise(NoMethodError) { @memory.logger_names }
+  end
 end

data/test/tc_connection.rb

@@ -77,4 +77,15 @@ class TestConnection < Test::Unit::TestCase
     end
   end
 
+  def test_establish_connection_local
+    begin
+      JConsole::start :port => 0
+      connection = JMX::MBean.establish_connection \
+        :command => /jconsole/i
+      assert(connection.getMBeanCount > 0)
+    ensure
+      JConsole::stop 0
+    end
+  end
+
 end

data/test/tc_dynamic_mbean.rb

@@ -76,4 +76,53 @@ class TestDynamicMBean < Test::Unit::TestCase
     mbean = JMX::MBean.find_by_name "jmx4r:name=OperationInvocationMBean", :connection => mbeanServer
     assert_equal("oof", mbean.reverse("foo"))
   end
+
+  class Foo < JMX::DynamicMBean
+    rw_attribute :foo_attr, :string
+
+    operation
+    parameter :string
+    returns :string
+    def foo(arg)
+       "foo #{arg}"
+    end
+  end
+
+  class Bar < JMX::DynamicMBean
+    rw_attribute :bar_attr, :string
+
+    operation
+    parameter :string
+    returns :string
+    def bar(arg)
+       "bar #{arg}"
+    end
+  end
+
+  def test_separate_dynamic_beans_have_separate_operations_and_attributes
+     mbean_server = ManagementFactory.platform_mbean_server
+     mbean_server.register_mbean Foo.new, ObjectName.new("jmx4r:name=foo")
+     mbean_server.register_mbean Bar.new, ObjectName.new("jmx4r:name=bar")
+
+     foo_mbean = JMX::MBean.find_by_name "jmx4r:name=foo", :connection => mbean_server
+     assert_equal "foo test", foo_mbean.foo("test")
+     assert_raise(NoMethodError){
+        foo_mbean.bar("test")
+     }
+     foo_mbean.foo_attr = "test"
+     assert_equal "test", foo_mbean.foo_attr
+     assert_raise(NoMethodError){
+        foo_mbean.bar_attr = "test"
+     }
+     bar_mbean = JMX::MBean.find_by_name "jmx4r:name=bar", :connection => mbean_server
+     assert_equal "bar test", bar_mbean.bar("test")
+     assert_raise(NoMethodError) {
+        bar_mbean.foo("test")
+     }
+     bar_mbean.bar_attr = "test"
+     assert_equal "test", bar_mbean.bar_attr
+     assert_raise(NoMethodError){
+        bar_mbean.foo_attr = "test"
+     }
+  end
 end

data/test/tc_methods.rb

@@ -0,0 +1,30 @@
+# Copyright 2007 Jeff Mesnil (http://jmesnil.net)
+
+require "test/unit"
+
+require "jmx4r"
+require "jconsole"
+
+class TestMethods < Test::Unit::TestCase
+  java_import java.lang.management.ManagementFactory
+
+  def setup
+    @logging = JMX::MBean.find_by_name "java.util.logging:type=Logging", :connection => ManagementFactory.platform_mbean_server
+  end
+
+  def teardown
+    JMX::MBean.remove_connection
+  end
+
+  def test_invoke_operation
+    @logging.set_logger_level "global", "FINEST"
+    assert_equal "FINEST", @logging.get_logger_level("global")
+  end
+
+  # make sure we can also use Java name convention
+  def test_invoke_CamelCaseOperation
+    @logging.setLoggerLevel "global", "FINE"
+    assert_equal "FINE", @logging.getLoggerLevel("global")
+  end
+
+end

data/test/ts_all.rb

@@ -6,6 +6,7 @@ require "tc_connection"
 require "tc_auth"
 require "tc_multiple_connections"
 require "tc_attributes"
+require "tc_methods"
 require "tc_composite_data"
 require "tc_dynamic_mbean"
 

metadata

@@ -42,14 +42,19 @@ files:
 - examples/runtime_sysprops.rb
 - lib/dynamic_mbean.rb
 - lib/jconsole.rb
+- lib/jdk_helper.rb
 - lib/jmx4r.rb
 - lib/objectname_helper.rb
 - lib/open_data_helper.rb
+- lib/jdk/jdk4.rb
+- lib/jdk/jdk5.rb
+- lib/jdk/jdk6.rb
 - test/tc_attributes.rb
 - test/tc_auth.rb
 - test/tc_composite_data.rb
 - test/tc_connection.rb
 - test/tc_dynamic_mbean.rb
+- test/tc_methods.rb
 - test/tc_multiple_connections.rb
 - test/ts_all.rb
 - Rakefile
@@ -68,12 +73,12 @@ requirements: []
 
 authors: 
 - Jeff Mesnil
-date: 2009-06-14 22:00:00 +00:00
+date: 2009-10-21 22:00:00 +00:00
 platform: ruby
 test_files: 
 - test/ts_all.rb
 version: !ruby/object:Gem::Version 
-  version: 0.0.8
+  version: 0.1.0
 require_paths: 
 - lib
 dependencies: []