weblogic-jmx4r 0.1.9

data/examples/runtime_sysprops.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env jruby
+require 'rubygems'
+require 'jmx4r'
+
+# This example shows how to iterate on TabularData
+
+runtime = JMX::MBean.find_by_name "java.lang:type=Runtime"
+
+# The system_properties attribute of the Runtime MBean is an instance of
+#   TabularDataSupport
+sysprops = runtime.system_properties
+sysprops.each do | sysprop|
+  puts "#{sysprop["key"]} = #{sysprop["value"]}"
+end

data/examples/weblogic.rb

@@ -0,0 +1,127 @@
+require 'rubygems'
+require 'jmx4r'
+require 'java'
+
+
+
+
+def get_weblogic_metrics(jmx_connection)
+
+  array_of_hashes = []
+
+  service_object_name = JMX::MBean::ObjectName.new("com.bea:Name=DomainRuntimeService,Type=weblogic.management.mbeanservers.domainruntime.DomainRuntimeServiceMBean")
+  servers =  jmx_connection.getAttribute(service_object_name, "ServerRuntimes")
+
+  for server in servers
+    server_state =  jmx_connection.getAttribute(server, "State");
+    server_name =  jmx_connection.getAttribute(server, "Name");
+    server_health_state = jmx_connection.getAttribute(server, "HealthState");
+
+    jvm_runtime = jmx_connection.getAttribute(server, "JVMRuntime");
+    heap_free = jmx_connection.getAttribute(jvm_runtime, "HeapFreeCurrent");
+
+    thread_pool_runtime =  jmx_connection.getAttribute(server, "ThreadPoolRuntime");
+    thread_idle = jmx_connection.getAttribute(thread_pool_runtime, "ExecuteThreadIdleCount");
+
+    array_of_hashes << {'server_name' => server_name, 'server_state' => server_state, 'heap_free' => heap_free, 'thread_idle' => thread_idle}
+
+
+    domain_runtime_object_name = jmx_connection.getAttribute(service_object_name, "DomainRuntime");
+    apps = jmx_connection.getAttribute(domain_runtime_object_name, "AppRuntimeStateRuntime");
+    app_ids = jmx_connection.getAttribute(apps, "ApplicationIds");
+    app_runtimes = jmx_connection.getAttribute(server, "ApplicationRuntimes");
+
+    states = Hash.new
+    for app_id in app_ids
+      app_name = (app_id.split("#"))[0];
+      state = jmx_connection.invoke(apps, "getCurrentState", Array.new(app_id, server_name), Array.new( "java.lang.String", "java.lang.String")  )
+      states[app_name] = state
+    end
+
+
+    for app_runtime in app_runtimes
+      appli_name =  jmx_connection.getAttribute(app_runtime, "Name");
+      component_runtimes_object_name_list = jmx_connection.getAttribute(app_runtime, "ComponentRuntimes");
+
+      for component_runtimes_object_name in component_runtimes_object_name_list
+        app_name =  jmx_connection.getAttribute(app_runtime, "Name");
+        component_type = jmx_connection.getAttribute(component_runtimes_object_name, "Type");
+        if component_type.to_s == "WebAppComponentRuntime"
+          open_sessions = jmx_connection.getAttribute(component_runtimes_object_name,"OpenSessionsCurrentCount");
+          state = states[appli_name]
+
+          array_of_hashes << {'app_name' => app_name, 'state' => state, 'open_sessions' => open_sessions, 'server_name' => server_name}
+        end
+      end
+
+
+      jdbc_runtime_object_name = jmx_connection.getAttribute(server, "JDBCServiceRuntime");
+      datastores_object_name_list = jmx_connection.getAttribute(jdbc_runtime_object_name, "JDBCDataSourceRuntimeMBeans");
+
+      for datastores_object_name in datastores_object_name_list
+        datastore_name = jmx_connection.getAttribute(datastores_object_name, "Name");
+        datastore_state = jmx_connection.getAttribute(datastores_object_name, "State");
+        datastore_connection_total_count = jmx_connection.getAttribute(datastores_object_name, "ConnectionsTotalCount");
+        datastore_active_connections_current_count = jmx_connection.getAttribute(datastores_object_name, "ActiveConnectionsCurrentCount");
+        datastore_active_connections_high_count = jmx_connection.getAttribute(datastores_object_name, "ActiveConnectionsHighCount");
+
+        array_of_hashes << {'server_name' => server_name, 'datastore_name' => datastore_name, 'datastore_name' => datastore_name,
+                            'datastore_state' => datastore_state, 'datastore_connection_total_count' => datastore_connection_total_count,
+                            'datastore_active_connections_current_count' => datastore_active_connections_current_count, 'datastore_active_connections_high_count' => datastore_active_connections_high_count}
+      end
+
+      jms_runtime = jmx_connection.getAttribute(server, "JMSRuntime");
+      jms_servers_object_name_list = jmx_connection.getAttribute(jms_runtime, "JMSServers");
+
+      for jms_servers_object_name in jms_servers_object_name_list
+        destinations_object_name_list =  jmx_connection.getAttribute(jms_servers_object_name, "Destinations");
+
+        for destinations_object_name in destinations_object_name_list
+          jms_pending_messages = jmx_connection.getAttribute(destinations_object_name, "MessagesPendingCount");
+          jms_name = jmx_connection.getAttribute(destinations_object_name, "Name");
+
+          array_of_hashes << {'server_name' => server_name, 'jms_pending_messages' => jms_pending_messages, 'jms_name' => jms_name}
+
+        end
+
+      end
+
+
+    end
+
+
+
+
+  end
+  return array_of_hashes
+end
+
+jmx_connection = JMX::MBean.establish_connection :url => "service:jmx:t3://localhost:7001/jndi/weblogic.management.mbeanservers.domainruntime", :provider_package => "weblogic.management.remote", :username => "weblogic", :password => "Gildarex1"
+
+#jmx_object_name_s = JMX::MBean.find_all_by_name "com.bea:Name=DomainRuntimeService,Type=weblogic.management.mbeanservers.domainruntime.DomainRuntimeServiceMBean", :connection => jmx_connection
+
+
+#service = JMX::MBean::ObjectName.new("com.bea:Name=DomainRuntimeService,Type=weblogic.management.mbeanservers.domainruntime.DomainRuntimeServiceMBean")
+
+
+#servers =  jmx_connection.getAttribute(service, "ServerRuntimes")
+#
+
+
+# for server in servers
+#    serverState =  jmx_connection.getAttribute(server, "State");
+#    serverName =  jmx_connection.getAttribute(server, "Name");
+#    serverHealthState = jmx_connection.getAttribute(server, "HealthState");
+#    puts "Server state  #{serverState} #{serverName} #{serverState} #{serverHealthState}"
+#
+#    jvmRuntime = jmx_connection.getAttribute(server, "JVMRuntime");
+#    heap_free = jmx_connection.getAttribute(jvmRuntime, "HeapFreeCurrent");
+#
+#    threadPoolRuntime =  jmx_connection.getAttribute(server, "ThreadPoolRuntime");
+#    threadIdle = jmx_connection.getAttribute(threadPoolRuntime, "ExecuteThreadIdleCount");
+#
+#    puts "Server state  #{heap_free} #{threadIdle} "
+# end
+#
+array_of_hashes = get_weblogic_metrics(jmx_connection)
+puts array_of_hashes.to_json

data/lib/dynamic_mbean.rb

@@ -0,0 +1,277 @@
+# Copyright (c) 2008 Thomas E Enebo <enebo@acm.org>
+#--
+# taken from the 'jmx' gems in jruby-extras
+
+module JMX
+  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
+    # 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
+    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 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:
+      self.mbean_attributes[:attrs] ||= []
+    end
+
+    def self.operations #:nodoc:
+      self.mbean_attributes[: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 = java_type.new(instance_variable_get("@#{name.to_s}".to_sym))
+        rescue
+          #otherwise turn it into a java Object type for now.
+          value = Java.ruby_to_java(instance_variable_get("@#{name.to_s}".to_sym))
+        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 = java_type.new(instance_variable_get("@#{name.to_s}".to_sym))
+        rescue
+          #otherwise turn it into a java Object type for now.
+          value = Java.ruby_to_java(instance_variable_get("@#{name.to_s}".to_sym))
+        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|
+        blk = to_ruby(type)
+        instance_variable_set("@#{name.to_s}".to_sym, blk.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
+      self.mbean_attributes[: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)
+      self.mbean_attributes[: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)
+      self.mbean_attributes[: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| attrs.add 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

@@ -0,0 +1,75 @@
+# JConsole module is used by jmx4r unit tests.
+#
+# {jconsole}[http://java.sun.com/j2se/1.5.0/docs/guide/management/jconsole.html]
+# is used as the target remote Java application manageable by JMX
+# (we do not used it for its JMX capability, just because it is a ready to
+# use Java application available with every JDK).
+#
+# Copyright 2007 Jeff Mesnil (http://jmesnil.net)
+module JConsole
+
+  # Start a new instance of jconsole which is accessible on port 3000.
+  # 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.
+  #                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
+  #
+  # The file path corresponding to :pwd_file must have <b>600 permission</b>
+  # (<tt>chmod 600 jmxremote.password</tt>).
+  #
+  # Both <tt>:pwd_file</tt> and <tt>:access_file+</tt> must be specified to run a secure
+  # jconsole (see {JMX password & access files}[http://java.sun.com/j2se/1.5.0/docs/guide/management/agent.html#PasswordAccessFiles])
+  def JConsole.start(args={})
+    port = args[:port] || 3000
+    pwd_file = args[:pwd_file]
+    access_file = args[:access_file]
+
+    cmd =<<-EOCMD.split("\n").join(" ")
+    jconsole
+    -J-Dcom.sun.management.jmxremote
+    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
+  end
+
+  # Stop an instance of JConsole (by killing its process)
+  #
+  # 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)
+    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
+end
+
+if ARGV.length == 1
+  case ARGV[0]
+  when "start"
+    JConsole::start
+    puts "started jconsole"
+  when "stop"
+    JConsole::stop
+    puts "stopped jconsole"
+  end
+end