jmx 0.3 → 0.5

data/Manifest.txt

@@ -11,6 +11,4 @@ lib/jmx/version.rb
 samples/memory.rb
 test/jmx_attribute_test.rb
 test/jmx_client_test.rb
-test/jmx_notification_test.rb
 test/jmx_server_test.rb
-test/object_name_test.rb

data/Rakefile

@@ -12,9 +12,9 @@ begin
   require 'hoe'
   Hoe.new("jmx", JMX::VERSION) do |p|
     p.rubyforge_name = "jruby-extras"
-    p.url = "http://jruby-extras.rubyforge.org/jmx"
-    p.author = "Thomas Enebo"
-    p.email = "enebo@acm.org"
+    p.url = "http://github.com/enebo/jmxjr"
+    p.author = "Thomas Enebo & Jay McGaffigan"
+    p.email = "tom.enebo@gmail.com"
     p.summary = "Package for interacting/creating Java Management Extensions"
     p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
     p.description = "Install this gem and require 'jmx' to load the library."

data/lib/jmx.rb

@@ -4,13 +4,13 @@ require 'rmi'
 require 'jmx/dynamic_mbean'
 require 'jmx/server'
 
-import java.util.ArrayList
-import javax.management.Attribute
-import javax.management.MBeanInfo
-import javax.management.DynamicMBean
+java_import java.util.ArrayList
+java_import javax.management.Attribute
+java_import javax.management.MBeanInfo
+java_import javax.management.DynamicMBean
 
 module JMX
-  import javax.management.ObjectName
+  java_import javax.management.ObjectName
   class ObjectName
     def [](key)
       get_key_property(key.to_s)
@@ -130,9 +130,12 @@ module JMX
       @operations ||= @info.operations.inject([]) { |s,op| s << op.name }
     end
 
-    # Get MBean attribute specified by name
+    # Get MBean attribute specified by name.  If it is just a plain attribute then
+    # unwrap the attribute and just return the value.
     def [](name)
-      @server.getAttribute @object_name, name.to_s
+      attribute = @server.getAttribute(@object_name, name.to_s)
+      return attribute.value if attribute.kind_of? javax.management.Attribute
+      attribute
     end
 
     # Set MBean attribute specified by name to value
@@ -169,8 +172,8 @@ module JMX
     def define_operations
       @info.operations.each do |op| 
         self.class.__send__(:define_method, op.name) do |*args|
-          jargs = java_args(op.signature, args)
-          @server.invoke @object_name, op.name, jargs, java_types(jargs)
+          jargs, jtypes = java_args(op.signature, args)
+          @server.invoke @object_name, op.name, jargs, jtypes
         end
       end
     end
@@ -180,29 +183,33 @@ module JMX
     def java_args(signature, params)
       return nil if params.nil?
 
-      i = 0
-      params.map do |param|
-        required_type = JavaClass.for_name(signature[i].get_type)
-        java_arg = Java.ruby_to_java(param)
+      jtypes = []
+      jargs = []
+      params.each_with_index do |param, i|
+        type = signature[i].get_type
+        jtypes << type
+        required_type = JavaClass.for_name(type)
+        
+        java_arg = param.to_java(:object)
 
         if (param.kind_of? Array)
           java_arg = param.inject(ArrayList.new) {|l, element| l << element }
         end
+        
+        jargs << java_arg
 
         arg_type = java_arg.java_class
         
         raise TypeError.new("parameter #{signature[i].name} expected to be #{required_type}, but was #{arg_type}") if !required_type.assignable_from? arg_type
-        i = i + 1
-        
-        java_arg
-      end.to_java(:object)
+      end
+      [jargs.to_java, jtypes.to_java(:string)]
     end
 
     # Convert a collection of java objects to their Java class name equivalents
     def java_types(params)
       return nil if params.nil?
 
-      params.map {|e| params.java_class.name }.to_java(:string)
+      params.map {|e| e.class.java_class.name }.to_java(:string)
     end
 
     def underscore(string)

data/lib/jmx/dynamic_mbean.rb

@@ -1,8 +1,8 @@
 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
@@ -15,18 +15,21 @@ module JMX
       :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}'"}],
+      :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
+
+    module_function :to_java_type, :to_ruby
   end
 
   class Parameter
@@ -93,95 +96,80 @@ end
 # 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
-  import javax.management.DynamicMBean
-  import javax.management.MBeanInfo
+  java_import javax.management.AttributeList
+  java_import javax.management.MBeanOperationInfo
+  java_import javax.management.MBeanAttributeInfo
+  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)
+    cls.send(:include, javax.management.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
+    return if local_hash[:op].nil?
+    local_hash[:op].name = name
+    operations << local_hash[:op].to_jmx
+    local_hash[:op] = nil
   end
 
   def self.attributes #:nodoc:
-    Thread.current[:attrs] ||= []
+    local_hash[:attrs] ||= []
   end
   
   def self.operations #:nodoc:
-    Thread.current[:ops] ||= []
+    local_hash[: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)
-    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)
+  def self.define_getter(name, type)
+    # FIXME: Our to_java_type needs to do something saner
+    java_type = begin; to_java_type(type); rescue; nil; end
+    value_proc = java_type ? proc { |value| java_type.new value } : proc { |value| Java.ruby_to_java value }
+
+    define_method("jmx_get_#{name.downcase}") do
+      javax.management.Attribute.new name, value_proc.call(instance_variable_get('@' + name))
     end
+  end
 
-    define_method("jmx_set_#{name.to_s.downcase}") do |value| 
-      blck = to_ruby(type)
-      eval "@#{name.to_s} = #{blck.call(value)}"
+  def self.define_setter(name, type)
+    value_converter = JMX::JavaTypeAware.to_ruby(type)
+
+    define_method("jmx_set_#{name.downcase}") do |value| 
+      instance_variable_set '@' + name, value_converter.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"
+  # 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"
+  def self.rw_attribute(name, type, description)
+    name = name.to_s
+    attributes << JMX::Attribute.new(name, type, description, true, true).to_jmx
+    attr_accessor name
+    define_getter name, type
+    define_setter name, type
+  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)
+    name = name.to_s
     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
+    define_getter name, type
   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"
+  # 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)
+    name = name.to_s
     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
+    define_setter name, type
   end
 
   # Use the operation method to declare the start of an operation
@@ -193,9 +181,8 @@ class RubyDynamicMBean
   # Last operation wins if more than one
   #++
   def self.operation(description)
-
     # Wait to error check until method_added so we can know method name
-    Thread.current[:op] = JMX::Operation.new description
+    local_hash[:op] = JMX::Operation.new description
   end
 
   # Used to declare a parameter (you can declare more than one in succession) that
@@ -205,7 +192,7 @@ class RubyDynamicMBean
   #     def start
   #     end
   def self.parameter(type, name=nil, description=nil)
-    Thread.current[:op].parameters << JMX::Parameter.new(type, name, description)
+    local_hash[:op].parameters << JMX::Parameter.new(type, name, description)
   end
 
   # Used to declare the return type of the operation
@@ -215,44 +202,49 @@ class RubyDynamicMBean
   #     def set_name
   #     end
   def self.returns(type)
-    Thread.current[:op].return_type = type
+    local_hash[:op].return_type = type
   end
   
-  # when creating a dynamic MBean we need to provide it with a 
-  # name and a description.
+  # Thread local storage for the derived bean
+  def self.local_hash
+    Thread.current[self.name] ||= {}
+  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)
-    attributes = self.class.attributes.to_java(MBeanAttributeInfo)
+    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 (where attribute is a 
-  # javax.management.Attribute class)
+  # Retrieve the value of the requested attribute (where attribute is a javax.management.Attribute class)
   def getAttribute(attribute)
-    send("jmx_get_"+attribute.downcase)
+    __send__("jmx_get_" + attribute.downcase)
   end
   
   def getAttributes(attributes)
-    attrs = javax.management.AttributeList.new
-    attributes.each { |attribute| attrs.add(getAttribute(attribute)) } 
-    attrs
+    attributes.inject(AttributeList.new) { |attrs, attribute| attrs.add(getAttribute(attribute)); attrs } 
   end
   
-  def getMBeanInfo; @info; end
+  def getMBeanInfo
+    @info
+  end
   
   def invoke(actionName, params=nil, signature=nil)
-    send(actionName, *params)
+    __send__(actionName, *params)
   end
 
   def setAttribute(attribute)
-    send("jmx_set_#{attribute.name.downcase}", attribute.value)   
+    __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
+  def toString
+    "#@info.class_name: #@info.description"
+  end
+  alias_method :to_s, :toString
+  alias_method :inspect, :toString
 end

data/lib/jmx/server.rb

@@ -7,10 +7,10 @@ module JMX
   # Represents both MBeanServer and MBeanServerConnection
   #++ 
   class MBeanServer
-    import javax.management.Attribute
-    import javax.management.MBeanServerFactory
-    import javax.management.remote.JMXConnectorFactory
-    import javax.management.remote.JMXServiceURL
+    java_import javax.management.Attribute
+    java_import javax.management.MBeanServerFactory
+    java_import javax.management.remote.JMXConnectorFactory
+    java_import javax.management.remote.JMXServiceURL
 
     attr_accessor :server
     @@classes = {}
@@ -101,8 +101,8 @@ module JMX
   end
 
   class MBeanServerConnector
-    import javax.management.remote.JMXServiceURL
-    import javax.management.remote.JMXConnectorServerFactory
+    java_import javax.management.remote.JMXServiceURL
+    java_import javax.management.remote.JMXConnectorServerFactory
 
     def initialize(location, server)
       @url = JMXServiceURL.new location

data/lib/jmx/version.rb

@@ -1,3 +1,3 @@
 module JMX
-  VERSION = "0.3"
+  VERSION = "0.5"
 end

data/lib/rmi.rb

@@ -1,8 +1,8 @@
 include Java
 
-import java.rmi.registry.LocateRegistry
-import java.rmi.registry.Registry
-import java.rmi.server.UnicastRemoteObject
+java_import java.rmi.registry.LocateRegistry
+java_import java.rmi.registry.Registry
+java_import java.rmi.server.UnicastRemoteObject
 
 class RMIRegistry
   def initialize(port = Registry::REGISTRY_PORT)

data/test/jmx_attribute_test.rb

@@ -3,20 +3,22 @@ $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 require 'test/unit'
 require 'jmx'
 
+# These tests are for verifying that at a Ruby-level (on server-side) it is still possible 
+# to interact with dynamic mbeans as you expect.  *_attributes are backed by ordinary
+# Ruby instance variables of the same name.
+
 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"
+  rw_attribute :name, :string, "My sample attribute"
+  r_attribute :number_read_only, :int, "My sample integer based attribute that is read only"
+  w_attribute :number_write_only, :int, "My sample integer based attribute that is write only"
 
-  def intialize(type, text)
-    super(type,text)
-  end
-  def set_number1(val)
-    @number1 = val
+  # Give us a way to change the attribute for testing
+  def set_number_read_only(value)
+    @number_read_only = value
   end
   
-  def fetch_number2
-    @number2
+  def fetch_number_write_only
+    @number_write_only
   end
 end
 
@@ -29,48 +31,48 @@ class JMXAttributeTest < Test::Unit::TestCase
   
   #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 }    
+    @madb.set_number_read_only 4
+    assert_nil(@madb.name)
+    @madb.name = "Name"
+    assert_equal("Name", @madb.name)
+    assert_equal(4, @madb.number_read_only)
+    @madb.number_write_only = 4
+    assert_equal(4, @madb.fetch_number_write_only)    
+    assert_raise(NoMethodError) { @madb.number_write_only }    
   end
 
   def test_get_attributes_via_dynamicmbeaninterface
-    @madb.set_number1 4
-    @madb.name1 = "Name"
+    @madb.set_number_read_only 4
+    @madb.name = "Name"
 
-    assert_equal(@madb.name1, @madb.getAttribute("name1").get_value.to_s)
-    assert_equal(@madb.number1, @madb.getAttribute("number1").get_value)    
-    atts = ["name1", "number1"]
+    assert_equal(@madb.name, @madb.getAttribute("name").get_value.to_s)
+    assert_equal(@madb.number_read_only, @madb.getAttribute("number_read_only").get_value)    
+    atts = ["name", "number_read_only"]
     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"
+    @madb.name = "blue"
     red = java.lang.String.new("red")
-    attribute = javax.management.Attribute.new("name1", red)
+    attribute = javax.management.Attribute.new("name", red)
     @madb.setAttribute(attribute)
 
-    assert_equal("String", @madb.name1.class.to_s )
-    assert_equal("red", @madb.name1)
+    assert_equal("String", @madb.name.class.to_s )
+    assert_equal("red", @madb.name)
   end
   
   def test_set_multiple_attributes_via_dynamicbeaninterface
-    @madb.name1 = "blue"
+    @madb.name = "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)
+    attribute1 = javax.management.Attribute.new("name", red)
+    attribute2 = javax.management.Attribute.new("number_write_only", three)
     
     @madb.setAttributes([attribute1, attribute2])    
-    assert_equal("red", @madb.name1)
-    assert_equal(3, @madb.fetch_number2)
+    assert_equal("red", @madb.name)
+    assert_equal(3, @madb.fetch_number_write_only)
   end
   
 end

data/test/jmx_server_test.rb

@@ -10,6 +10,8 @@ require 'rmi'
 require 'jmx'
 
 class MyDynamicMBean < RubyDynamicMBean
+  rw_attribute :name, :string, "My sample attribute"
+
   operation "Doubles a value"
   parameter :int, "a", "Value to double"
   returns :int
@@ -67,7 +69,12 @@ class JMXServerTest < Test::Unit::TestCase
     assert_raise(TypeError) { puts bean.double("HEH") }
     assert_equal("hehheh", bean.string_double("heh"))
     assert_equal("123", bean.concat([1,2,3]))
+
+    assert_nil(bean.name)
+    bean.name = "Name"
+    assert_equal("Name", bean.name)
   end
+
   def test_ruby_mbean_twice
     dyna = MyDynamicMBean.new("domain.MySuperBean", "Heh")
     domain = @server.default_domain

metadata

@@ -1,71 +1,72 @@
 --- !ruby/object:Gem::Specification 
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - '>='
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-email: enebo@acm.org
-cert_chain: []
-
-summary: Package for interacting/creating Java Management Extensions
-post_install_message: 
-extra_rdoc_files: 
-- Manifest.txt
-- README.txt
-- LICENSE.txt
-homepage: http://jruby-extras.rubyforge.org/jmx
-signing_key: 
 name: jmx
-rdoc_options: 
-- --main
-- README.txt
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: "0.5"
+platform: ruby
+authors: 
+  - Thomas Enebo & Jay McGaffigan
 autorequire: 
-rubyforge_project: jruby-extras
-executables: []
+bindir: bin
+cert_chain: []
 
-description: Install this gem and require 'jmx' to load the library.
-specification_version: 2
+date: 2011-03-18 00:00:00 -05:00
 default_executable: 
+dependencies: []
+
+description: Install this gem and require 'jmx' to load the library.
+email: tom.enebo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+  - Manifest.txt
+  - README.txt
+  - LICENSE.txt
 files: 
-- Manifest.txt
-- Rakefile
-- README.txt
-- LICENSE.txt
-- lib/jmx
-- lib/jmx.rb
-- lib/rmi.rb
-- lib/jmx/dynamic_mbean.rb
-- lib/jmx/server.rb
-- lib/jmx/version.rb
-- samples/memory.rb
-- test/jmx_attribute_test.rb
-- test/jmx_client_test.rb
-- test/jmx_notification_test.rb
-- test/jmx_server_test.rb
-- test/object_name_test.rb
+  - Manifest.txt
+  - Rakefile
+  - README.txt
+  - LICENSE.txt
+  - lib/jmx.rb
+  - lib/rmi.rb
+  - lib/jmx/dynamic_mbean.rb
+  - lib/jmx/server.rb
+  - lib/jmx/version.rb
+  - samples/memory.rb
+  - test/jmx_attribute_test.rb
+  - test/jmx_client_test.rb
+  - test/jmx_server_test.rb
+  - .gemtest
+has_rdoc: true
+homepage: http://github.com/enebo/jmxjr
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+  - --main
+  - README.txt
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
-  - - '>='
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-extensions: []
-
-rubygems_version: 1.3.1
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
 requirements: []
 
-authors: 
-- Thomas Enebo
-date: 2008-11-21 05:00:00 +00:00
-platform: ruby
+rubyforge_project: jruby-extras
+rubygems_version: 1.5.1
+signing_key: 
+specification_version: 3
+summary: Package for interacting/creating Java Management Extensions
 test_files: []
 
-version: !ruby/object:Gem::Version 
-  version: "0.3"
-require_paths: 
-- lib
-dependencies: []
-
-bindir: bin
-has_rdoc: true

data/test/jmx_notification_test.rb

@@ -1,29 +0,0 @@
-$:.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
-
-
-
-#interface NotificationEmitter
-#v addNotificationListener listener, filter, handback
-#MBEanNotificationInfo getNotificationInfo
-#v removeNotificationListener listener, filter, handback

data/test/object_name_test.rb

@@ -1,12 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
-require "test/unit"
-
-require "jmx"
-
-class TestObjectName < Test::Unit::TestCase
-  def test_create_object_name
-    MObjectName.ancestors.each {|method| p method}
-    x = MObjectName.new "foo:d=bar"
-    assert_not_nil(x)
-  end
-end