tibems 0.0.2-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dd6d3099d869e484d150441df309c585b7dcd6e8
+  data.tar.gz: b5fd1c0569158c8b4ae0ddb5671d56b2c4cdc61d
+SHA512:
+  metadata.gz: 88c224d9aa6a18ebdd37e569014fa46e67440f09f44af04cc9d5938dc24fb400e082ddeac9d4a987487bbd268113b8730b1ebf3b41485647da4a228ad8c2c4d6
+  data.tar.gz: 4f37ea6a8b4c740b4d77c2087872dd1749fadfd1388dc7a656fcaeaf6bf5181ee4666d914652cc50b79ab9865852e967425acc641726ff6e7e82cf3d42c2fdcb

data/ext/tibems/Admin.java

@@ -0,0 +1,179 @@
+package org.jalonsoa.tibems;
+
+import java.lang.Long;
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyHash;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+import com.tibco.tibjms.admin.ConsumerInfo;
+import com.tibco.tibjms.admin.DestinationInfo;
+import com.tibco.tibjms.admin.QueueInfo;
+import com.tibco.tibjms.admin.TopicInfo;
+import com.tibco.tibjms.admin.ServerInfo;
+import com.tibco.tibjms.admin.StatData;
+import com.tibco.tibjms.admin.TibjmsAdmin;
+import com.tibco.tibjms.admin.TibjmsAdminException;
+
+import java.util.Collection;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+// The Java class that backs the Ruby class Faye::WebSocketMask. Its methods
+// annotated with @JRubyMethod become exposed as instance methods on the Ruby
+// class through the call to defineAnnotatedMethods() above.
+@JRubyClass(name="TibEMS::Admin")
+public class Admin extends RubyObject {
+  public static final int DESTINATION_TYPE_TOPIC = 0;
+  public static final int DESTINATION_TYPE_QUEUE = 1;
+
+  protected static TibjmsAdmin admin = null;
+
+  private static IRubyObject Qnil;
+
+  public Admin(final Ruby runtime, RubyClass rubyClass) {
+    super(runtime, rubyClass);
+
+    Qnil = runtime.getNil();
+  }
+
+  @JRubyMethod(name = "create")
+  protected static IRubyObject create(ThreadContext context, IRubyObject self, RubyString url, RubyString user, RubyString pass) {
+    try {
+      admin = new TibjmsAdmin(url.asJavaString(),user.asJavaString(),pass.asJavaString());
+    } catch (TibjmsAdminException exp) {
+    }
+
+    return self;
+  }
+
+  @JRubyMethod(name = "close")
+  public IRubyObject close(ThreadContext context) {
+    try {
+      admin.close();
+      admin = null;
+    } catch (TibjmsAdminException exp) {
+    }
+    return Qnil;
+  }
+
+  private RubyArray destinationsHash( Ruby runtime, DestinationInfo[] destInfos, int type ) {
+    RubyArray info = RubyArray.newArray( runtime, destInfos.length );
+
+    for (DestinationInfo destInfo : destInfos) {
+      RubyHash dest = RubyHash.newHash( runtime );
+      RubyHash inbound = RubyHash.newHash( runtime );
+      RubyHash outbound = RubyHash.newHash( runtime );
+
+      dest.put("name",destInfo.getName());
+      dest.put("consumerCount", destInfo.getConsumerCount());
+      dest.put("flowControlMaxBytes", destInfo.getFlowControlMaxBytes());
+      dest.put("pendingMessageCount", destInfo.getPendingMessageCount());
+      dest.put("pendingMessageSize", destInfo.getPendingMessageSize());
+
+      if (type == DESTINATION_TYPE_TOPIC) {
+        TopicInfo topicInfo = (TopicInfo)destInfo;
+        dest.put("subscriberCount", topicInfo.getSubscriberCount());
+        dest.put("durableCount", topicInfo.getDurableCount());
+        dest.put("activeDurableCount", topicInfo.getActiveDurableCount());
+      } else {
+        QueueInfo queueInfo = (QueueInfo)destInfo;
+        dest.put("receiverCount", queueInfo.getReceiverCount());
+        dest.put("deliveredMessageCount", queueInfo.getDeliveredMessageCount());
+        dest.put("inTransitMessageCount", queueInfo.getInTransitMessageCount());
+        dest.put("maxRedelivery", queueInfo.getMaxRedelivery());
+      }
+
+      StatData inboundStats = destInfo.getInboundStatistics();
+      inbound.put("totalMessages", inboundStats.getTotalMessages());
+      inbound.put("messageRate", inboundStats.getMessageRate());
+      inbound.put("totalBytes", inboundStats.getTotalBytes());
+      inbound.put("byteRate", inboundStats.getByteRate());
+
+      dest.put("inbound", inbound);
+
+      StatData outboundStats = destInfo.getInboundStatistics();
+      outbound.put("totalMessages", outboundStats.getTotalMessages());
+      outbound.put("messageRate", outboundStats.getMessageRate());
+      outbound.put("totalBytes", outboundStats.getTotalBytes());
+      outbound.put("byteRate", outboundStats.getByteRate());
+
+      dest.put("outbound", outbound);
+
+      info.add(dest);
+    }
+
+    return info;
+  }
+
+  @JRubyMethod(name = "get_info")
+  public IRubyObject get_info(ThreadContext context) {
+    Ruby runtime = context.runtime;
+    RubyHash info = RubyHash.newHash( runtime );
+
+    try {
+      ServerInfo serverInfo = admin.getInfo();
+
+      info.put("diskReadRate", serverInfo.getDiskReadRate());
+      info.put("diskWriteRate", serverInfo.getDiskWriteRate());
+      info.put("syncDBSize", serverInfo.getSyncDBSize());
+      info.put("asyncDBSize", serverInfo.getAsyncDBSize());
+      info.put("msgMem", serverInfo.getMsgMem());
+      info.put("msgMemPooled", serverInfo.getMsgMemPooled());
+      info.put("maxMsgMemory", serverInfo.getMaxMsgMemory());
+      info.put("msgMem", serverInfo.getMsgMem());
+      info.put("connectionCount", serverInfo.getConnectionCount());
+      info.put("maxConnections", serverInfo.getMaxConnections());
+      info.put("sessionCount", serverInfo.getSessionCount());
+      info.put("producerCount", serverInfo.getProducerCount());
+      info.put("consumerCount", serverInfo.getConsumerCount());
+      info.put("durableCount", serverInfo.getDurableCount());
+      info.put("topicCount", serverInfo.getTopicCount());
+      info.put("queueCount", serverInfo.getQueueCount());
+      info.put("pendingMessageCount", serverInfo.getPendingMessageCount());
+      info.put("pendingMessageSize", serverInfo.getPendingMessageSize());
+      info.put("inboundMessageCount", serverInfo.getInboundMessageCount());
+      info.put("inboundMessageRate", serverInfo.getInboundMessageRate());
+      info.put("inboundBytesRate", serverInfo.getInboundBytesRate());
+      info.put("outboundMessageCount", serverInfo.getOutboundMessageCount());
+      info.put("outboundMessageRate", serverInfo.getOutboundMessageRate());
+      info.put("outboundBytesRate", serverInfo.getOutboundBytesRate());
+      info.put("logFileMaxSize", serverInfo.getLogFileMaxSize());
+      info.put("logFileSize", serverInfo.getLogFileSize());
+
+      // TODO: pass pattern
+      QueueInfo[] queueInfos = admin.getQueuesStatistics();
+
+      if (queueInfos.length > 0) {
+        RubyArray queues = destinationsHash( runtime, queueInfos, DESTINATION_TYPE_QUEUE );
+
+        info.put("queues", queues);
+      }
+
+      // TODO: pass pattern
+      TopicInfo[] topicInfos = admin.getTopicsStatistics();
+
+      if (topicInfos.length > 0) {
+        RubyArray topics = destinationsHash( runtime, topicInfos, DESTINATION_TYPE_TOPIC );
+
+        info.put("topics", topics);
+      }
+
+    } catch (TibjmsAdminException exp) {
+    }
+
+    return info;
+  }
+}

data/ext/tibems/TibEMSService.java

@@ -0,0 +1,43 @@
+package org.jalonsoa.tibems;
+
+import java.lang.Long;
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+import org.jalonsoa.tibems.Admin;
+
+public class TibEMSService implements BasicLibraryService {
+  private Ruby runtime;
+
+  // Initial setup function. Takes a reference to the current JRuby runtime and
+  // sets up our modules. For JRuby, we will define mask() as an instance method
+  // on a specially created class, Faye::WebSocketMask.
+  public boolean basicLoad(Ruby runtime) throws IOException {
+    this.runtime = runtime;
+    RubyModule tibems = runtime.defineModule("TibEMS");
+
+    // Create the WebSocketMask class. defineClassUnder() takes a name, a
+    // reference to the superclass -- runtime.getObject() gets you the Object
+    // class for the current runtime -- and an allocator function that says
+    // which Java object to constuct when you call new() on the class.
+    RubyClass admin = tibems.defineClassUnder("Admin", runtime.getObject(), new ObjectAllocator() {
+      public IRubyObject allocate(Ruby runtime, RubyClass rubyClass) {
+        return new Admin(runtime, rubyClass);
+      }
+    });
+
+    admin.defineAnnotatedMethods(Admin.class);
+    return true;
+  }
+}

data/ext/tibems/extconf.rb

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+require 'mkmf'
+require 'English'
+
+# 2.0-only
+have_header('ruby/thread.h') && have_func('rb_thread_call_without_gvl', 'ruby/thread.h')
+
+# 1.9-only
+have_func('rb_thread_blocking_region')
+have_func('rb_hash_dup')
+have_func('rb_intern3')
+
+# If the user has provided a --with-tibems-dir argument, we must respect it or fail.
+inc, lib = dir_config('tibems')
+if inc && lib
+  # TODO: Remove when 2.0.0 is the minimum supported version
+  # Ruby versions not incorporating the mkmf fix at
+  # https://bugs.ruby-lang.org/projects/ruby-trunk/repository/revisions/39717
+  # do not properly search for lib directories, and must be corrected
+  unless lib && lib[-3, 3] == 'lib'
+    @libdir_basename = 'lib'
+    inc, lib = dir_config('tibems')
+  end
+
+  if RUBY_PLATFORM =~ /x86_64/
+    # Add dir with /64 in libraries
+    libs64 = lib.split(File::PATH_SEPARATOR).map! { |l| "#{l}/64" }
+    lib = libs64.join(File::PATH_SEPARATOR) + File::PATH_SEPARATOR + lib
+  end
+
+  abort "-----\nCannot find include dir(s) #{inc}\n-----" unless inc && inc.split(File::PATH_SEPARATOR).any? { |dir| File.directory?(dir) }
+  abort "-----\nCannot find library dir(s) #{lib}\n-----" unless lib && lib.split(File::PATH_SEPARATOR).any? { |dir| File.directory?(dir) }
+  warn "-----\nUsing --with-tibems-dir=#{File.dirname inc}\n-----"
+  rpath_dir = lib
+end
+
+if have_header('tibems.h')
+  prefix = nil
+elsif have_header('tibems/tibems.h')
+  prefix = 'tibems'
+else
+  asplode 'tibems.h'
+end
+
+%w(emsadmin.h emserr.h admtypes.h qinfo.h status.h).each do |h|
+  header = [prefix, h].compact.join '/'
+  asplode h unless have_header header
+end
+
+if RUBY_PLATFORM =~ /x86_64/
+  have_library("tibems64");
+  have_library("tibemslookup64");
+  have_library("tibemsufo64");
+  have_library("tibemsadmin64");
+else
+  have_library("tibems");
+  have_library("tibemslookup");
+  have_library("tibemsufo");
+  have_library("tibemsadmin");
+end
+
+have_library("ssl");
+
+create_makefile('tibems')

data/lib/tibems.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+require 'date'
+require 'bigdecimal'
+
+require 'tibems/version' unless defined? TibEMS::VERSION
+require 'tibems/error'
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+  require 'jruby'
+  begin
+    require 'tibems_jars'
+  rescue LoadError
+  end
+  require 'tibems/tibems.jar'
+  org.jalonsoa.tibems.TibEMSService.new.basicLoad(JRuby.runtime)
+else
+  require 'tibems/tibems'
+end
+require 'tibems/admin'
+
+
+# = TibEMS
+#
+# A modern, simple binding to TibEMS libraries
+module TibEMS
+end
+
+# For holding utility methods
+module TibEMS
+  module Util
+    #
+    # Rekey a string-keyed hash with equivalent symbols.
+    #
+    def self.key_hash_as_symbols(hash)
+      return nil unless hash
+      Hash[hash.map { |k, v| [k.to_sym, v] }]
+    end
+
+    #
+    # Thread#handle_interrupt is used to prevent Timeout#timeout
+    # from interrupting query execution.
+    #
+    # Timeout::ExitException was removed in Ruby 2.3.0, 2.2.3, and 2.1.8,
+    # but is present in earlier 2.1.x and 2.2.x, so we provide a shim.
+    #
+    if Thread.respond_to?(:handle_interrupt)
+      require 'timeout'
+      # rubocop:disable Style/ConstantName
+      TimeoutError = if defined?(::Timeout::ExitException)
+        ::Timeout::ExitException
+      else
+        ::Timeout::Error
+      end
+    end
+  end
+end

data/lib/tibems/admin.rb

@@ -0,0 +1,25 @@
+module TibEMS
+  class Admin
+    def initialize(opts = {})
+      opts = TibEMS::Util.key_hash_as_symbols(opts)
+
+      if RUBY_PLATFORM !~ /java/
+        initialize_ext
+      end
+
+      ##ssl_options = opts.values_at(:sslkey, :sslcert, :sslca, :sslcapath, :sslcipher)
+      ##ssl_set(*ssl_options) if ssl_options.any?
+
+      url      = opts[:url] || opts[:host]
+      user     = opts[:username] || opts[:user]
+      pass     = opts[:password] || opts[:pass]
+
+      # Correct the data types before passing these values down to the C level
+      url  = url.to_s unless url.nil?
+      user = user.to_s unless user.nil?
+      pass = pass.to_s unless pass.nil?
+
+      create url, user, pass
+    end
+  end
+end

data/lib/tibems/error.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+module TibEMS
+  class Error < StandardError
+    ENCODE_OPTS = {
+      :undef => :replace,
+      :invalid => :replace,
+      :replace => '?'.freeze,
+    }.freeze
+
+    attr_reader :error_number, :error_message
+
+    def initialize(msg)
+      @server_version ||= nil
+
+      super(clean_message(msg))
+    end
+
+    def self.new_with_args(msg, server_version, error_number, error_message)
+      err = allocate
+      err.instance_variable_set('@server_version', server_version)
+      err.instance_variable_set('@error_number', error_number)
+      err.instance_variable_set('@error_state', error_message.respond_to?(:encode) ? error_message.encode(ENCODE_OPTS) : error_message)
+      err.send(:initialize, msg)
+      err
+    end
+
+    private
+
+    def clean_message(message)
+      return message unless message.respond_to?(:encode)
+
+      message.encode(ENCODE_OPTS)
+      ##message.encode(Encoding::UTF_8, ENCODE_OPTS)
+    end
+  end
+end

data/lib/tibems/version.rb

@@ -0,0 +1,3 @@
+module TibEMS
+  VERSION = "0.0.2"
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: tibems
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: java
+authors:
+- Justo Alonso
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2016-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: jar-dependencies
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rake-compiler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: TibEMS bindings for Ruby
+email:
+- justo.alonso@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ext/tibems/Admin.java
+- ext/tibems/TibEMSService.java
+- ext/tibems/extconf.rb
+- lib/tibems.rb
+- lib/tibems/admin.rb
+- lib/tibems/error.rb
+- lib/tibems/tibems.jar
+- lib/tibems/version.rb
+homepage: https://github.com/jalonsoa/ruby-tibems
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- jar 'javax.jms:javax.jms-api', '2.0'
+- jar 'com.tibco:tibjms', '>= 7.0'
+- jar 'com.tibco:tibjms-admin', '>= 7.0'
+rubyforge_project:
+rubygems_version: 2.4.8
+signing_key:
+specification_version: 4
+summary: TibEMS bindings for Ruby
+test_files: []