jmx 0.1 → 0.2

data/Manifest.txt

@@ -9,5 +9,6 @@ lib/jmx/version.rb
 lib/jmx.rb
 lib/rmi.rb
 samples/memory.rb
+test/jmx_attribute_test.rb
 test/jmx_client_test.rb
 test/jmx_server_test.rb

data/lib/jmx.rb

@@ -135,7 +135,7 @@ module JMX
 
     # Set MBean attribute specified by name to value
     def []=(name, value) 
-      @server.setAttribute @object_name, Attribute.new(name.to_s, value)
+      @server.setAttribute @object_name, javax.management.Attribute.new(name.to_s, value)
     end
 
     def add_notification_listener(filter=nil, handback=nil, &listener)

data/lib/jmx/dynamic_mbean.rb

@@ -1,21 +1,31 @@
 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 = {
-      :int => 'java.lang.Integer',
-      :list => 'java.util.List',
-      :long => 'java.lang.Long',
-      :map => 'java.util.Map',
-      :set => 'java.util.Set',
-      :string => 'java.lang.String',
-      :void => 'java.lang.Void'
+      :int => ['java.lang.Integer', lambda {|param| param.to_i}],
+      :list => ['java.util.List', lambda {|param| param.to_a}],
+      :long => ['java.lang.Long', lambda {|param| param.to_i}],
+      :float => ['java.lang.Float', lambda {|param| param.to_f}],
+      :map => ['java.util.Map', lambda {|param| param}],
+      :set => ['java.util.Set', 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] || 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
 
@@ -44,29 +54,138 @@ module 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
 end
 
+#  The Ruby-Java JMX utilities work throught the DynamicMBean concept.  Creators of Ruby based MBeans must inherit this
+# class (<tt>RubyDynamicMBean</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 RubyDynamicMBean
   import javax.management.MBeanOperationInfo
+  import javax.management.MBeanAttributeInfo
+  include JMX::JavaTypeAware
   
   # TODO: preserve any original method_added?
   # TODO: Error handling here when it all goes wrong?
-  def self.method_added(name)
+  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
+  def self.attributes #:nodoc:
     Thread.current[:attrs] ||= []
   end
   
-  def self.operations
+  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"
+  #--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)
+    #QUESTION: Is this here to ensure that our type implements the interface?
+    include DynamicMBean
+    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)
+      eval "@#{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)
+    include DynamicMBean        
+    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)
+    include DynamicMBean        
+    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 argument the description for the operation
+  #     operation "Used to start the service"
+  #     def start
+  #     end
+  #--
   # Last operation wins if more than one
+  #++
   def self.operation(description)
     include DynamicMBean
 
@@ -74,27 +193,59 @@ class RubyDynamicMBean
     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.
+  #     operation "Used to update the name of a service"
+  #     parameter :string, "name", "Set the new name of the service"
+  #     def start
+  #     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 set_name
+  #     end
   def self.returns(type)
     Thread.current[:op].return_type = type
   end
   
+  # when creating a dynamic MBean we need to provide it with a 
+  # name and a description.
   def initialize(name, description)
     operations = self.class.operations.to_java(MBeanOperationInfo)
-    @info = MBeanInfo.new name, description, nil, nil, operations, nil
+    attributes = self.class.attributes.to_java(MBeanAttributeInfo)
+    @info = MBeanInfo.new name, description, attributes, nil, operations, nil
   end
 
-  def getAttribute(attribute); $stderr.puts "getAttribute"; end
-  def getAttributes(attributes); $stderr.puts "getAttributes"; end
+  # Retrieve the value of the requested attribute (where attribute is a javax.management.Attribute class)
+  def getAttribute(attribute)
+    send("jmx_get_"+attribute.downcase)
+  end
+  
+  def getAttributes(attributes)
+    attrs = javax.management.AttributeList.new
+    attributes.each { |attribute| attrs.add(getAttribute(attribute)) } 
+    attrs
+  end
+  
   def getMBeanInfo; @info; end
+  
   def invoke(actionName, params=nil, signature=nil)
     send(actionName, *params)
   end
-  def setAttribute(attribute); $stderr.puts "setAttribute"; end
-  def setAttributes(attributes); $stderr.puts "setAttributes";  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

data/lib/jmx/server.rb

@@ -1,5 +1,11 @@
 module JMX
+  # The MBeanServer represents a connection to an MBean server
+  # rather than an actual MBean server.  Depending upon how 
+  # this object is constructed you can either talk to the 
+  # PlatformMBeanServer or any "remote" MBean server.
+  #--
   # Represents both MBeanServer and MBeanServerConnection
+  #++ 
   class MBeanServer
     import javax.management.Attribute
     import javax.management.MBeanServerFactory
@@ -9,6 +15,10 @@ module JMX
     attr_accessor :server
     @@classes = {}
 
+    # when creatinga  new MBeanServer you can optionally specify a location, username, and password
+    # if specify these values (or at least the location) the MBeanServer instance will connect to 
+    # an existing (and remote ) MBean server and register the mbeans there.
+    # otherwise the server will connect to to the local Platform MBean Server.
     def initialize(location=nil, username=nil, password=nil)
       if (location)
         env = username ? 

data/lib/jmx/version.rb

@@ -1,3 +1,3 @@
 module JMX
-  VERSION = "0.1"
+  VERSION = "0.2"
 end

data/test/jmx_attribute_test.rb

@@ -0,0 +1,156 @@
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'rmi'
+require 'jmx'
+
+
+class MyAttributeDynamicBean < RubyDynamicMBean
+  rw_attribute :name1, :string, "My sample attribute"
+  r_attribute :number1, :int, "My sample integer based attribute that is read only"
+  w_attribute :number2, :int, "My sample integer based attribute that is write only"
+
+  def intialize(type, text)
+    super(type,text)
+  end
+  def set_number1(val)
+    @number1 = val
+  end
+  
+  def fetch_number2
+    @number2
+  end
+end
+
+class JMXAttributeTest < Test::Unit::TestCase
+  
+  def setup
+    @madb = MyAttributeDynamicBean.new("test.MyTestBean","Mwahahahahahah")    
+  end
+  
+  #make sure we didn't break anything from a ruby perspective
+  def test_can_create_bean_and_access_accessor_type_methods
+    @madb.set_number1 4
+    assert_nil(@madb.name1)
+    @madb.name1 = "Name"
+    assert_equal("Name", @madb.name1)
+    assert_equal(4, @madb.number1)
+    @madb.number2 = 4
+    assert_equal(4, @madb.fetch_number2)    
+    assert_raise(NoMethodError) { @madb.number2 }    
+  end
+
+  def test_get_attributes_via_dynamicmbeaninterface
+    @madb.set_number1 4
+    @madb.name1 = "Name"
+
+    assert_equal(@madb.name1, @madb.getAttribute("name1").get_value.to_s)
+    assert_equal(@madb.number1, @madb.getAttribute("number1").get_value)    
+    atts = ["name1", "number1"]
+    retrieved = @madb.getAttributes(atts)
+    assert_equal(2, retrieved.length)
+    #TODO: assertion comparing the types in teh array to java types
+  end
+  
+  def test_set_attributes_via_dynamicbeaninterface
+    @madb.name1 = "blue"
+    red = java.lang.String.new("red")
+    attribute = javax.management.Attribute.new("name1", red)
+    @madb.setAttribute(attribute)
+
+    assert_equal("String", @madb.name1.class.to_s )
+    assert_equal("red", @madb.name1)
+  end
+  
+  def test_set_multiple_attributes_via_dynamicbeaninterface
+    @madb.name1 = "blue"
+    three = java.lang.Integer.new(3)
+    red = java.lang.String.new("red")
+    attribute1 = javax.management.Attribute.new("name1", red)
+    attribute2 = javax.management.Attribute.new("number2", three)
+    
+    @madb.setAttributes([attribute1, attribute2])    
+    assert_equal("red", @madb.name1)
+    assert_equal(3, @madb.fetch_number2)
+  end
+  
+end
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'rmi'
+require 'jmx'
+
+
+class MyAttributeDynamicBean < RubyDynamicMBean
+  rw_attribute :name1, :string, "My sample attribute"
+  r_attribute :number1, :int, "My sample integer based attribute that is read only"
+  w_attribute :number2, :int, "My sample integer based attribute that is write only"
+
+  def intialize(type, text)
+    super(type,text)
+  end
+  def set_number1(val)
+    @number1 = val
+  end
+  
+  def fetch_number2
+    @number2
+  end
+end
+
+class JMXAttributeTest < Test::Unit::TestCase
+  
+  def setup
+    @madb = MyAttributeDynamicBean.new("test.MyTestBean","Mwahahahahahah")    
+  end
+  
+  #make sure we didn't break anything from a ruby perspective
+  def test_can_create_bean_and_access_accessor_type_methods
+    @madb.set_number1 4
+    assert_nil(@madb.name1)
+    @madb.name1 = "Name"
+    assert_equal("Name", @madb.name1)
+    assert_equal(4, @madb.number1)
+    @madb.number2 = 4
+    assert_equal(4, @madb.fetch_number2)    
+    assert_raise(NoMethodError) { @madb.number2 }    
+  end
+
+  def test_get_attributes_via_dynamicmbeaninterface
+    @madb.set_number1 4
+    @madb.name1 = "Name"
+
+    assert_equal(@madb.name1, @madb.getAttribute("name1").get_value.to_s)
+    assert_equal(@madb.number1, @madb.getAttribute("number1").get_value)    
+    atts = ["name1", "number1"]
+    retrieved = @madb.getAttributes(atts)
+    assert_equal(2, retrieved.length)
+    #TODO: assertion comparing the types in teh array to java types
+  end
+  
+  def test_set_attributes_via_dynamicbeaninterface
+    @madb.name1 = "blue"
+    red = java.lang.String.new("red")
+    attribute = javax.management.Attribute.new("name1", red)
+    @madb.setAttribute(attribute)
+
+    assert_equal("String", @madb.name1.class.to_s )
+    assert_equal("red", @madb.name1)
+  end
+  
+  def test_set_multiple_attributes_via_dynamicbeaninterface
+    @madb.name1 = "blue"
+    three = java.lang.Integer.new(3)
+    red = java.lang.String.new("red")
+    attribute1 = javax.management.Attribute.new("name1", red)
+    attribute2 = javax.management.Attribute.new("number2", three)
+    
+    @madb.setAttributes([attribute1, attribute2])    
+    assert_equal("red", @madb.name1)
+    assert_equal(3, @madb.fetch_number2)
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jmx
 version: !ruby/object:Gem::Version 
-  version: "0.1"
+  version: "0.2"
 platform: ruby
 authors: 
 - Thomas Enebo
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-06 00:00:00 -05:00
+date: 2008-07-28 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
@@ -35,6 +35,7 @@ files:
 - lib/jmx.rb
 - lib/rmi.rb
 - samples/memory.rb
+- test/jmx_attribute_test.rb
 - test/jmx_client_test.rb
 - test/jmx_server_test.rb
 has_rdoc: true