jmx4r 0.0.7 → 0.0.8

data/Rakefile

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

data/examples/ruby_mbean.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env jruby
+
+# Run with:
+# jruby -J-Dcom.sun.management.jmxremote  -Ilib examples/ruby_mbean.rb
+#
+# and open jconsole to manage the MBean
+
+require 'rubygems'
+require 'jmx4r'
+
+import java.lang.management.ManagementFactory
+import javax.management.ObjectName
+
+class ExampleMBean < DynamicMBean
+  rw_attribute :string_attr, :string, "a String attribute"
+  rw_attribute :int_attr, :int, "a Integer attribute"
+  rw_attribute :long_attr, :long, "a Long attribute"
+  rw_attribute :float_attr, :float, "a Float attribute"
+  rw_attribute :double_attr, :double, "a Double attribute"
+  rw_attribute :boolean_attr, :boolean, "a Boolean attribute"
+
+  operation "reverse the string passed in parameter"
+  parameter :string, "arg", "a String to reverse"
+  returns :string
+  def reverse(arg)
+    arg.reverse
+  end
+end
+
+mbean = ExampleMBean.new
+object_name = ObjectName.new("jmx4r:name=ExampleMBean")
+
+mbeanServer = ManagementFactory.platform_mbean_server
+mbeanServer.register_mbean mbean, object_name
+puts "Open jconsole to manage the MBean #{object_name}"
+puts "When you have finished, type <ENTER> to exit"
+gets
+
+mbeanServer.unregister_mbean object_name
+puts "unregistered #{object_name}"
+

data/lib/dynamic_mbean.rb

@@ -0,0 +1,275 @@
+# Copyright (c) 2008 Thomas E Enebo <enebo@acm.org>
+#--
+# 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
+
+  # Module that is used to bridge java to ruby and ruby to java types.
+  module JavaTypeAware
+    # Current list of types we understand  If it's not in this list we are
+    # assuming that we are going to convert to a java.object
+    SIMPLE_TYPES = {
+      :boolean => ['java.lang.Boolean', lambda {|param| param}],
+      :byte => ['java.lang.Byte', lambda {|param| param.to_i}],
+      :int => ['java.lang.Integer', lambda {|param| param.to_i}],
+      :long => ['java.lang.Long', lambda {|param| param.to_i}],
+      :float => ['java.lang.Float', lambda {|param| param.to_f}],
+      :double => ['java.lang.Double', lambda {|param| param.to_f}],
+      :list => ['java.util.ArrayList', lambda {|param| param.to_a}],
+      :map => ['java.util.HashMap', lambda {|param| param}],
+      :set => ['java.util.HashSet', lambda {|param| param}],
+      :string => ['java.lang.String', lambda {|param| param.to_s}],
+      :void => ['java.lang.Void', lambda {|param| nil}]
+    }
+
+    def to_java_type(type_name)
+      SIMPLE_TYPES[type_name][0] || type_name
+    end
+    #TODO: I'm not sure this is strictly needed, but funky things can happen if you
+    # are expecting your attributes (from the ruby side) to be ruby types and they are java types.
+    def to_ruby(type_name)
+      SIMPLE_TYPES[type_name][1] || lambda {|param| param}
+    end
+  end
+
+  class Parameter
+    include JavaTypeAware
+
+    def initialize(type, name, description)
+      @type, @name, @description = type, name, description
+    end
+
+    def to_jmx
+      MBeanParameterInfo.new @name.to_s, to_java_type(@type), @description
+    end
+  end
+
+  class Operation < Struct.new(:description, :parameters, :return_type, :name, :impact)
+    include JavaTypeAware
+
+    def initialize(description)
+      super
+      self.parameters, self.impact, self.description = [], MBeanOperationInfo::UNKNOWN, description
+    end
+
+    def to_jmx
+      java_parameters = parameters.map { |parameter| parameter.to_jmx }
+      MBeanOperationInfo.new name.to_s, description, java_parameters.to_java(javax.management.MBeanParameterInfo), to_java_type(return_type), impact
+    end
+  end
+
+  class Attribute < Struct.new(:name, :type, :description, :is_reader, :is_writer, :is_iser)
+    include JavaTypeAware
+
+    def initialize(name, type, description, is_rdr, is_wrtr)
+      super
+      self.description, self.type, self.name = description, type, name
+      self.is_reader,self.is_writer, self.is_iser = is_rdr, is_wrtr, false
+    end
+
+    def to_jmx
+      MBeanAttributeInfo.new(name.to_s, to_java_type(type), description, is_reader, is_writer, is_iser)
+    end
+  end
+
+  # Creators of Ruby based MBeans must inherit this
+  # class (<tt>DynamicMBean</tt>) in their own bean classes and then register them with a JMX mbean server.
+  #  Here is an example:
+  #       class MyMBean < DynamicMBean
+  #         rw_attribute :status, :string, "Status information for this process"
+  #
+  #         operation "Shutdown this process"
+  #         parameter :string, "user_name", "Name of user requesting shutdown"
+  #         returns :string
+  #         def shutdown(user_name)
+  #            "shutdown requests more time"
+  #         end
+  #       end
+  # Once you have defined your bean class you can start declaring attributes and operations.
+  # Attributes come in three flavors: read, write, and read write.  Simmilar to the <tt>attr*</tt>
+  # helpers, there are helpers that are used to create management attributes. Use +r_attribute+,
+  # +w_attribute+, and +rw_attribute+ to declare attributes, and the +operation+, +returns+,
+  # and +parameter+ helpers to define a management operation.
+  # Creating attributes with the *_attribute convention ALSO creates ruby accessors
+  # (it invokes the attr_accessor/attr_reader/attr_writer ruby helpers) to create ruby methods
+  # 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
+    include JMX::JavaTypeAware
+  
+    #NOTE this will not be needed when JRuby-3164 is fixed.
+    def self.inherited(cls)
+      cls.send(:include, DynamicMBean)
+    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
+    end
+  
+    def self.attributes #:nodoc:
+      Thread.current[:attrs] ||= []
+    end
+  
+    def self.operations #:nodoc:
+      Thread.current[:ops] ||= []
+    end
+  
+    # the <tt>rw_attribute</tt> method is used to declare a JMX read write attribute.
+    # see the +JavaSimpleTypes+ module for more information about acceptable types
+    # usage:
+    # rw_attribute :attribute_name, :string, "Description displayed in a JMX console"
+    #
+    # The name and type parameters are mandatory
+    # The description parameter is optional (defaults to the same value than the env: ruby: No such file or directory
+    # name parameter in that case)
+    # --
+    # methods used to create an attribute.  They are modeled on the attrib_accessor
+    # patterns of creating getters and setters in ruby
+    #++
+    def self.rw_attribute(name, type, description=nil)
+      description ||= name.to_s
+      attributes << JMX::Attribute.new(name, type, description, true, true).to_jmx
+      attr_accessor name
+      #create a "java" oriented accessor method
+      define_method("jmx_get_#{name.to_s.downcase}") do
+        begin
+          #attempt conversion
+          java_type = to_java_type(type)
+          value = eval "#{java_type}.new(@#{name.to_s})"
+        rescue
+          #otherwise turn it into a java Object type for now.
+          value = eval "Java.ruby_to_java(@#{name.to_s})"
+        end
+        attribute = javax.management.Attribute.new(name.to_s, value)
+      end
+  
+      define_method("jmx_set_#{name.to_s.downcase}") do |value|
+        blck = to_ruby(type)
+        send "#{name.to_s}=", blck.call(value)
+      end
+    end
+  
+    # the <tt>r_attribute</tt> method is used to declare a JMX read only attribute.
+    # see the +JavaSimpleTypes+ module for more information about acceptable types
+    # usage:
+    #  r_attribute :attribute_name, :string, "Description displayed in a JMX console"
+    def self.r_attribute(name, type, description)
+      attributes << JMX::Attribute.new(name, type, description, true, false).to_jmx
+      attr_reader name
+      #create a "java" oriented accessor method
+      define_method("jmx_get_#{name.to_s.downcase}") do
+        begin
+          #attempt conversion
+          java_type = to_java_type(type)
+          value = eval "#{java_type}.new(@#{name.to_s})"
+        rescue
+          #otherwise turn it into a java Object type for now.
+          value = eval "Java.ruby_to_java(@#{name.to_s})"
+        end
+        attribute = javax.management.Attribute.new(name.to_s, value)
+      end
+    end
+  
+    # the <tt>w_attribute</tt> method is used to declare a JMX write only attribute.
+    # see the +JavaSimpleTypes+ module for more information about acceptable types
+    # usage:
+    #  w_attribute :attribute_name, :string, "Description displayed in a JMX console"
+    def self.w_attribute(name, type, description)
+      attributes << JMX::Attribute.new(name, type, description, false, true).to_jmx
+      attr_writer name
+      define_method("jmx_set_#{name.to_s.downcase}") do |value|
+        blck = to_ruby(type)
+        eval "@#{name.to_s} = #{blck.call(value)}"
+      end
+    end
+  
+    # Use the operation method to declare the start of an operation
+    # It takes as an optional argument the description for the operation
+    # Example:
+    #     operation "Used to start the service"
+    #     def start
+    #     end
+    #--
+    # Last operation wins if more than one
+    #++
+    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
+    end
+  
+    # Used to declare a parameter (you can declare more than one in succession) that
+    # is associated with the currently declared operation.
+    # The type is mandatory, the name and description are optional.
+    # Example:
+    #     operation "Used to update the name of a service"
+    #     parameter :string, "name", "Set the new name of the service"
+    #     def start(name)
+    #        ...
+    #     end
+    def self.parameter(type, name=nil, description=nil)
+      Thread.current[:op].parameters << JMX::Parameter.new(type, name, description)
+    end
+  
+    # Used to declare the return type of the operation
+    #     operation "Used to update the name of a service"
+    #     parameter :string, "name", "Set the new name of the service"
+    #     returns :void
+    #     def do_stuff
+    #        ...
+    #     end
+    def self.returns(type)
+      Thread.current[:op].return_type = type
+    end
+  
+    def initialize(description="")
+      name = self.class.to_s
+      operations = self.class.operations.to_java(MBeanOperationInfo)
+      attributes = self.class.attributes.to_java(MBeanAttributeInfo)
+      @info = MBeanInfo.new name, description, attributes, nil, operations, nil
+    end
+  
+    # Retrieve the value of the requested attribute
+    def getAttribute(attribute)
+      send("jmx_get_"+attribute.downcase).value
+    end
+  
+    def getAttributes(attributes)
+      attrs = javax.management.AttributeList.new
+      attributes.each { |attribute| send("jmx_get_"+attribute.downcase) }
+      attrs
+    end
+  
+    def getMBeanInfo; @info; end
+  
+    def invoke(actionName, params=nil, signature=nil)
+      send(actionName, *params)
+    end
+  
+    def setAttribute(attribute)
+      send("jmx_set_#{attribute.name.downcase}", attribute.value)
+    end
+  
+    def setAttributes(attributes)
+      attributes.each { |attribute| setAttribute attribute}
+    end
+  
+    def to_s; toString; end
+    def inspect; toString; end
+    def toString; "#@info.class_name: #@info.description"; end
+  end
+  
+end
+  

data/lib/jconsole.rb

@@ -38,7 +38,7 @@ EOCMD
       cmd << " -J-Dcom.sun.management.jmxremote.access.file=#{access_file}"
     end
     Thread.start { system cmd }
-    sleep 1
+    sleep 3
   end
 
   # Stop an instance of JConsole (by killing its process)

data/lib/jmx4r.rb

@@ -15,6 +15,7 @@ class String
 end
 
 module JMX
+  require 'dynamic_mbean'
   require 'open_data_helper'
   require 'objectname_helper'
   require 'jruby'
@@ -135,23 +136,29 @@ module JMX
 
     # Create a connection to a remote MBean server.
     # 
-    # The args accepts 4 keys:
+    # The args accepts the following keys:
     #
-    # [:host]        the host of the MBean server (defaults to "localhost")
-    # [:port]        the port of the MBean server (defaults to 3000)
-    # [:url]         the url of the MBean server.
-    #                No default.
-    #                if the url is specified, the host & port parameters are
-    #                not taken into account
-    # [:username]    the name of the user (if the MBean server requires authentication).
-    #                No default
-    # [:password]    the password of the user (if the MBean server requires authentication).
-    #                No default
-    # [:credentials] custom credentials (if the MBean server requires authentication).
-    #                No default. It has precedence over :username and :password (i.e. if
-    #                :credentials is specified, :username & :password are ignored)   
-    # [:provider_package] use to fill the JMXConnectorFactory::PROTOCOL_PROVIDER_PACKAGES
-    #                No default
+    # [:host]             the host of the MBean server (defaults to "localhost")
+    #
+    # [:port]             the port of the MBean server (defaults to 3000)
+    #
+    # [:url]              the url of the MBean server.
+    #                     No default.
+    #                     if the url is specified, the host & port parameters are
+    #                     not taken into account
+    #
+    # [:username]         the name of the user (if the MBean server requires authentication).
+    #                     No default
+    #
+    # [:password]         the password of the user (if the MBean server requires authentication).
+    #                     No default
+    #
+    # [:credentials]      custom credentials (if the MBean server requires authentication).
+    #                     No default. It has precedence over :username and :password (i.e. if
+    #                     :credentials is specified, :username & :password are ignored)   
+    #
+    # [:provider_package] use to fill the JMXConnectorFactory::PROTOCOL_PROVIDER_PACKAGES.
+    #                     No default
     #
     def self.create_connection(args={})
       host= args[:host] || "localhost"

data/test/tc_attributes.rb

@@ -6,14 +6,14 @@ require "jmx4r"
 require "jconsole"
 
 class TestAttribute < Test::Unit::TestCase
+  import java.lang.management.ManagementFactory
+
   def setup
-    JConsole::start
-    @memory = JMX::MBean.find_by_name "java.lang:type=Memory"
+    @memory = JMX::MBean.find_by_name "java.lang:type=Memory", :connection => ManagementFactory.platform_mbean_server
   end
 
   def teardown
     JMX::MBean.remove_connection
-    JConsole::stop
   end
 
   def test_unknwown_attribute
@@ -28,6 +28,7 @@ class TestAttribute < Test::Unit::TestCase
     assert_equal false, @memory.verbose
     @memory.verbose = true
     assert_equal true, @memory.verbose
+    @memory.verbose = false
   end
 
   def test_non_writable_attribute

data/test/tc_composite_data.rb

@@ -6,9 +6,10 @@ require "jmx4r"
 require "jconsole"
 
 class TestCompositeData < Test::Unit::TestCase
+  import java.lang.management.ManagementFactory
+
   def setup
-    JConsole::start
-    memory = JMX::MBean.find_by_name "java.lang:type=Memory"
+    memory = JMX::MBean.find_by_name "java.lang:type=Memory", :connection => ManagementFactory.platform_mbean_server
     # heap_memory_usage is a CompositeData
     @heap = memory.heap_memory_usage
   end
@@ -16,7 +17,6 @@ class TestCompositeData < Test::Unit::TestCase
   def teardown
     @heap = nil
     JMX::MBean.remove_connection
-    JConsole::stop
   end
   
   # use #map to check that CompositeData includes Enumerable

data/test/tc_dynamic_mbean.rb

@@ -0,0 +1,79 @@
+# Copyright 2008 Jeff Mesnil (http://jmesnil.net)
+
+require "test/unit"
+require "jmx4r"
+
+
+class TestDynamicMBean < Test::Unit::TestCase
+
+  import java.lang.management.ManagementFactory
+  import javax.management.ObjectName
+
+  class AttributeTypesMBean < JMX::DynamicMBean
+    rw_attribute :string_attr, :string, "a String attribute"
+    rw_attribute :byte_attr, :byte, "a Byte attribute"
+    rw_attribute :int_attr, :int, "a Integer attribute"
+    rw_attribute :long_attr, :long, "a Long attribute"
+    rw_attribute :float_attr, :float, "a Float attribute"
+    rw_attribute :double_attr, :double, "a Double attribute"
+    rw_attribute :list_attr, :list, "a List attribute"
+    rw_attribute :map_attr, :map, "a Map attribute"
+    rw_attribute :set_attr, :set, "a Set attribute"
+    rw_attribute :boolean_attr, :boolean, "a Boolean attribute"
+  end
+
+  def test_attribute_types
+    mbean = AttributeTypesMBean.new
+    mbeanServer = ManagementFactory.platform_mbean_server
+    mbeanServer.register_mbean mbean, ObjectName.new("jmx4r:name=AttributeTypesMBean")
+
+    mbean = JMX::MBean.find_by_name "jmx4r:name=AttributeTypesMBean", :connection => mbeanServer
+    mbean.string_attr = "test"
+    assert_equal("test", mbean.string_attr)
+
+    mbean.byte_attr = 9
+    assert_equal(9, mbean.byte_attr)
+
+    mbean.int_attr = 23
+    assert_equal(23, mbean.int_attr)
+
+    mbean.long_attr = 33
+    assert_equal(33, mbean.long_attr)
+
+    mbean.float_attr = 91.0
+    assert_equal(91.0, mbean.float_attr)
+
+    mbean.float_attr = 7.0
+    assert_equal(7.0, mbean.float_attr)
+
+    mbean.list_attr = [1, 2, 3]
+    assert_equal([1, 2, 3], mbean.list_attr.to_a)
+
+    mbean.set_attr = [1, 2, 3]
+    assert_equal([1, 2, 3].sort, mbean.list_attr.to_a.sort)
+
+    mbean.map_attr = { "a" => 1, "b" => 2}
+    assert_equal({ "a" => 1, "b" => 2}.to_a.sort, mbean.map_attr.to_a.sort)
+
+    mbean.boolean_attr = true
+    assert_equal(true, mbean.boolean_attr)
+  end
+
+  class OperationInvocationMBean < JMX::DynamicMBean
+    operation "reverse the string passed in parameter"
+    parameter :string, "arg", "a String to reverse"
+    returns :string
+    def reverse(arg)
+      arg.reverse
+    end
+  end
+
+  def test_operation_invocation
+    mbean = OperationInvocationMBean.new
+    mbeanServer = ManagementFactory.platform_mbean_server
+    mbeanServer.register_mbean mbean, ObjectName.new("jmx4r:name=OperationInvocationMBean")
+
+    mbean = JMX::MBean.find_by_name "jmx4r:name=OperationInvocationMBean", :connection => mbeanServer
+    assert_equal("oof", mbean.reverse("foo"))
+  end
+end

data/test/ts_all.rb

@@ -7,3 +7,5 @@ require "tc_auth"
 require "tc_multiple_connections"
 require "tc_attributes"
 require "tc_composite_data"
+require "tc_dynamic_mbean"
+

metadata

@@ -1,13 +1,36 @@
 --- !ruby/object:Gem::Specification 
-extensions: []
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - '>='
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+email: jmesnil@gmail.com
+cert_chain: []
 
+summary: jmx4r is a JMX library for JRuby
+post_install_message: 
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE.txt
 homepage: http://jmesnil.net/wiki/Jmx4r
+signing_key: 
+name: jmx4r
+rdoc_options: 
+- --title
+- jmx4r Documentation
+- --main
+- README.rdoc
+rubyforge_project: jmx4r
+autorequire: 
+licenses: []
+
 executables: []
 
-version: !ruby/object:Gem::Version 
-  version: 0.0.7
-post_install_message: 
-date: 2009-02-11 23:00:00 +00:00
+description: |
+  jmx4r is a JMX library for JRuby
+specification_version: 3
+default_executable: 
 files: 
 - examples/class_loading.rb
 - examples/jvm_mngmt.rb
@@ -15,7 +38,9 @@ files:
 - examples/memory.rb
 - examples/memory_on_many_nodes.rb
 - examples/memory_types.rb
+- examples/ruby_mbean.rb
 - examples/runtime_sysprops.rb
+- lib/dynamic_mbean.rb
 - lib/jconsole.rb
 - lib/jmx4r.rb
 - lib/objectname_helper.rb
@@ -24,53 +49,34 @@ files:
 - test/tc_auth.rb
 - test/tc_composite_data.rb
 - test/tc_connection.rb
+- test/tc_dynamic_mbean.rb
 - test/tc_multiple_connections.rb
 - test/ts_all.rb
 - Rakefile
 - README.rdoc
 - LICENSE.txt
-rubygems_version: 1.3.1
-rdoc_options: 
-- --title
-- jmx4r Documentation
-- --main
-- README.rdoc
-signing_key: 
-cert_chain: []
-
-name: jmx4r
-has_rdoc: true
-platform: ruby
-summary: jmx4r is a JMX library for JRuby
-default_executable: 
-bindir: bin
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  version: 
   requirements: 
   - - '>='
     - !ruby/object:Gem::Version 
       version: "0"
-required_ruby_version: !ruby/object:Gem::Requirement 
   version: 
-  requirements: 
-  - - '>='
-    - !ruby/object:Gem::Version 
-      version: "0"
-require_paths: 
-- lib
-specification_version: 2
-test_files: 
-- test/ts_all.rb
-dependencies: []
+extensions: []
+
+rubygems_version: 1.3.3
+requirements: []
 
-description: jmx4r is a JMX library for JRuby
-email: jmesnil@gmail.com
 authors: 
 - Jeff Mesnil
-extra_rdoc_files: 
-- README.rdoc
-- LICENSE.txt
-requirements: []
+date: 2009-06-14 22:00:00 +00:00
+platform: ruby
+test_files: 
+- test/ts_all.rb
+version: !ruby/object:Gem::Version 
+  version: 0.0.8
+require_paths: 
+- lib
+dependencies: []
 
-rubyforge_project: jmx4r
-autorequire: 
+bindir: bin
+has_rdoc: true