torquebox-configure 2.0.0.beta1-java

data/lib/gem_hook.rb

@@ -0,0 +1,19 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+# 
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+require 'torquebox/configure'
+require 'torquebox/configuration/global'

data/lib/torquebox/configuration/global.rb

@@ -0,0 +1,209 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+#
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+require 'torquebox/configure'
+require 'torquebox/configuration'
+
+module TorqueBox
+  module Configuration
+    class GlobalConfiguration < TorqueBox::Configuration::Configuration
+      def self.load_configuration(file)
+        config = new
+        TorqueBox::Configuration.load_configuration( file, config, ENTRY_MAP )
+        config.to_metadata_hash
+      end
+
+      ENTRY_MAP = lambda do
+        destination_entry =
+          ThingWithOptionsEntry.with_settings(:validate => {
+                                                :optional => [
+                                                              { :create => [true, false] },
+                                                              { :durable => [true, false] },
+                                                              :processor,
+                                                              :remote_host
+                                                             ]
+                                              })
+        {
+          :authentication => ThingWithOptionsEntry.with_settings( :validate => {
+                                                                    :required => [:domain],
+                                                                    :optional => [:credential]
+                                                                  }),
+          :credential  => ThingsEntry.with_settings(:require_parent => [:authentication],
+                                                   :discrete => true),
+          :environment => OptionsEntry,
+          :job         => ThingWithOptionsEntry.with_settings(:discrete => true,
+                                                              :validate => {
+                                                                :required => [:cron],
+                                                                :optional => [
+                                                                              :config,
+                                                                              :name,
+                                                                              { :singleton => [true, false] }
+                                                                             ]
+                                                              }),
+          :options_for => ThingWithOptionsEntry.with_settings(:validate => {
+                                                                :optional => [
+                                                                              :concurrency,
+                                                                              { :disabled => [true, false] },
+                                                                              :default_message_encoding
+                                                                             ]
+                                                              }),
+          :pool        => ThingWithOptionsEntry.with_settings(:validate => {
+                                                                :required => [{ :type => [:bounded, :shared] }],
+                                                                :optional => [:min, :max]
+                                                              }),
+          :processor   => ThingWithOptionsEntry.with_settings(:require_parent => [:queue, :topic],
+                                                              :discrete => true,
+                                                              :validate => {
+                                                                :optional => [
+                                                                              :concurrency,
+                                                                              { :singleton => [true, false] },
+                                                                              :config,
+                                                                              :filter,
+                                                                              :name
+                                                                             ]
+                                                              }),
+          :queue       => destination_entry,
+          :ruby        => OptionsEntry.with_settings(:validate => {
+                                                       :optional => [{ :version => ['1.8', '1.9'] },
+                                                                     { :compile_mode => [:force, :jit, :off,
+                                                                                         'force', 'jit', 'off'] },
+                                                                     { :debug => [true, false] },
+                                                                     { :interactive => [true, false] }
+                                                                    ]
+                                                     }),
+          :service     => ThingWithOptionsEntry.with_settings(:discrete => true,
+                                                              :validate => {
+                                                                :optional => [
+                                                                              :config,
+                                                                              :name,
+                                                                              { :singleton => [true, false] }
+                                                                             ]
+                                                              }),
+          :stomp       => OptionsEntry.with_settings(:validate => { :required => [:host] } ),
+          :stomplet    => ThingWithOptionsEntry.with_settings( :discrete => true,
+                                                               :validate => {
+                                                                 :required => [ :route ],
+                                                                 :optional => [ :config, :name ] } ),
+          
+          :topic       => destination_entry,
+          :web         => OptionsEntry.with_settings(:validate => {
+                                                       :optional => [:context, :host, :rackup, :static, :'session-timeout' ]
+                                                     })
+        }
+      end.call
+
+
+      def to_metadata_hash
+        metadata = Hash.new { |hash, key| hash[key] = Hash.new { |hash, key| hash[key] = { } } }
+
+        self[TorqueBox::CONFIGURATION_ROOT].each do |entry_name, entry_data|
+          case entry_name
+          when 'authentication' # => auth:
+            entry_data.each do |name, data|
+              (data.delete('credential') || []).each do |user, password|
+                data['credentials'] ||= {}
+                data['credentials'][user] = password
+              end
+              metadata['auth'][name] = data
+            end
+
+          when 'job' # => jobs:
+            entry_data.each do |klass, data|
+              name = data.delete( :name ) || unique_name( klass.to_s, metadata['jobs'].keys )
+              job = metadata['jobs'][name]
+              job['job'] = klass.to_s
+              job.merge!( data )
+            end
+
+          when 'options_for' # => tasks:, messaging:\n  default_message_encoding:
+            if (messaging_opts = entry_data.delete( 'messaging' )) &&
+                (default_encoding = messaging_opts.delete( :default_message_encoding ))
+              metadata['messaging']['default_message_encoding'] = default_encoding.to_s
+            end
+
+            entry_data.each do |name, data|
+              data[:concurrency] = 0 if data.delete( :disabled )
+              data[:concurrency] &&= data[:concurrency].to_java(java.lang.Integer)
+              metadata['tasks'][name] = data
+            end
+
+          when 'pool' # => pooling:
+            entry_data.each do |name, data|
+              pool_type = data.delete( :type )
+              if pool_type.to_s == 'shared'
+                metadata['pooling'][name] = 'shared'
+              else
+                metadata['pooling'][name] = data
+              end
+            end
+
+          when 'queue', 'topic' # => queues:/topics: & messaging:
+            entry_data.each do |name, data|
+              metadata[entry_name + 's'][name] = data unless data.delete( :create ) === false
+              (data.delete( 'processor' ) || []).each do |processor|
+                processor_class, processor_options = processor
+                processor_options[:concurrency] &&= processor_options[:concurrency].to_java(java.lang.Integer)
+                metadata['messaging'][name][processor_class] = processor_options
+              end
+            end
+
+          when 'service' # => services:
+            entry_data.each do |klass, data|
+              name = data.delete( :name )
+              if name
+                data[:service] = klass.to_s
+              else
+                name = klass.to_s
+              end
+              metadata['services'][name] = data
+            end
+
+          when 'stomplet' 
+            entry_data.each do |klass, data|
+              name = data.delete( :name ) || unique_name( klass.to_s, metadata['stomp']['stomplets'].keys )
+              stomplet = metadata['stomp']['stomplets'][name] = {}
+              stomplet['class'] = klass.to_s
+              stomplet.merge!( data )
+            end
+
+          else # => <entry_name>: (handles environment, ruby, stomp, web)
+            metadata[entry_name].merge!( entry_data )
+          end
+        end
+
+        hash_to_hashmap( metadata )
+      end
+
+      def hash_to_hashmap(hash)
+        hashmap = java.util.HashMap.new
+        hash.each do |key, value|
+          value = hash_to_hashmap( value ) if value.is_a?( Hash )
+          hashmap[key.to_s] = value
+        end
+        hashmap
+      end
+
+      protected
+      def unique_name(name, set, suffix = nil)
+        name = "#{name}-#{suffix}" if suffix
+        name = unique_name( name, set, suffix.to_i + 1 ) if set.include?( name )
+        name
+      end
+    end
+  end
+end
+

data/lib/torquebox/configuration/validator.rb

@@ -0,0 +1,91 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+#
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+require 'torquebox/configuration'
+
+module TorqueBox
+  module Configuration
+    class Validator
+      
+      def initialize(ruleset, entry, options_to_validate)
+        @required = ruleset[:required] || []
+        @allowed = @required + (ruleset[:optional] || [])
+        @entry = entry
+        @options_to_validate = options_to_validate
+        validate
+      end
+
+
+      def valid?
+        !message
+      end
+
+      def message
+        case messages.size
+        when 0
+          nil
+        when 1
+          messages.first
+        else
+          result = "There are multiple messages for this entry:"
+          messages.each { |message| result << "\n  " << message }
+          result
+        end
+      end
+      
+      protected
+      def messages
+        @messages ||= []
+      end
+      
+      def validate
+        validate_required
+        validate_allowed
+        validate_values
+      end
+
+      def validate_required
+        keys_for( @required ).each do |required|
+          messages << "Required option :#{required} is missing on '#{@entry}'" unless @options_to_validate.keys.map(&:to_s).include?( required )
+        end
+      end
+
+      def validate_allowed
+        @options_to_validate.keys.map(&:to_s).each do |option|
+          messages << "Option :#{option} is not allowed on '#{@entry}'" unless keys_for( @allowed ).include?( option )
+        end
+      end
+
+      def validate_values
+        @allowed.each do |allowed|
+          if allowed.is_a?( Hash )
+            key = allowed.keys.first
+            if @options_to_validate.has_key?( key ) && !allowed[key].include?( @options_to_validate[key] )
+              messages << "#{@options_to_validate[key].inspect} is not a valid value for #{key.inspect} on '#{@entry}'. Valid values are #{allowed[key].inspect}"
+            end
+          end
+        end
+      end
+      
+      def keys_for(ary)
+        ary.collect do |value|
+          (value.is_a?( Hash ) ? value.keys.first : value).to_s
+        end
+      end
+    end
+  end
+end

data/lib/torquebox/configuration.rb

@@ -0,0 +1,190 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+#
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+require 'blankslate'
+require 'torquebox/configuration/validator'
+
+module TorqueBox
+  module Configuration
+
+    def self.load_configuration(file, config, entry_map)
+      Thread.current[:torquebox_config] = config
+      Thread.current[:torquebox_config_entry_map] = entry_map
+      eval( File.read( file ) )
+      config
+    end
+
+    def self.const_missing(name)
+      FakeConstant.new( name )
+    end
+
+    class Entry < BlankSlate
+      def initialize(name, config, entry_map, options = { })
+        @name = name
+        @config = config
+        @entry_map = entry_map
+        @parents = options.delete( :parents ) || []
+        @options = options
+        @line_number = find_line_number
+        @entry_options = { }
+        
+        if options[:require_parent] && ([options[:require_parent]].flatten & @parents).empty?
+          raise ConfigurationError.new( "#{@name} only allowed inside #{options[:require_parent]}", @line_number )
+        end
+      end
+
+      def find_line_number
+        caller.each do |line|
+          return $1 if line =~ /\(eval\):(\d+):/
+        end
+        nil
+      end
+      
+      def process(*args, &block)
+        process_args( args )
+        eval_block( &block ) if block_given?
+        validate_options
+        finalize_options
+        local_config
+      end
+
+      def process_args(unused)
+        # no op
+        @config
+      end
+
+      def validate_options
+        if @options[:validate]
+          validator = Validator.new( @options[:validate], @name, @entry_options )
+          raise ConfigurationError.new( validator.message, @line_number ) unless validator.valid?
+        end
+      end
+
+      def eval_block(&block)
+        block.arity < 1 ? self.instance_eval( &block ) : block.call( self )
+      end
+
+      def self.const_missing(name)
+        FakeConstant.new( name )
+      end
+
+      def self.with_settings(options)
+        klass = self
+        proxy = Object.new
+        (class << proxy; self; end).__send__( :define_method, :new ) do |*args|
+          if args.last.is_a?( Hash )
+            args.last.merge!( options )
+          else
+            args << options
+          end
+          klass.new( *args )
+        end
+        proxy
+      end
+
+      alias_method :send, :__send__
+
+      def method_missing(method, *args, &block)
+        klass = @entry_map[method]
+        if klass
+          entry = klass.new( method, @entry_options, @entry_map, :parents => @parents + [@name] )
+          entry.process( *args, &block )
+        else
+          add_options( method.to_sym => args.first )
+        end
+      end
+
+      def add_options( option )
+        @entry_options.merge!( option )
+      end
+
+      def finalize_options
+        if @options[:discrete]
+          local_config << @entry_options
+        else
+          @entry_options = local_config.merge!( @entry_options )
+        end
+        local_config
+      end
+      
+      def local_config
+        @config[@name.to_s] = [] if @options[:discrete] && !@config[@name.to_s].is_a?(Array)
+        @config[@name.to_s] ||= {}  
+      end
+
+      def local_config=(value)
+        @config[@name.to_s] = value
+      end
+    end
+
+    class OptionsEntry < Entry
+      def process_args(args)
+        hash = args.first || { }
+        raise ConfigurationError.new( "'#{@name}' takes a hash (and only a hash)", @line_number ) if !hash.is_a?(Hash) || args.length > 1
+        add_options( hash )
+      end
+    end
+
+    class ThingWithOptionsEntry < Entry
+      def process_args(args)
+        @thing, hash = args
+        add_options( hash || {} )
+      end
+
+      def finalize_options
+        if @options[:discrete]
+          local_config << [@thing.to_s, @entry_options]
+        else
+          local_config[@thing.to_s] = { } unless local_config[@thing.to_s]
+          @entry_options = local_config[@thing.to_s].merge!( @entry_options )
+        end
+      end
+    end
+
+    class ThingsEntry < Entry
+      def process_args(args)
+        @entry_options = args.map(&:to_s)
+        local_config
+      end
+    end
+    
+ 
+    class Configuration < Hash
+      def initialize
+        super { |hash, key| hash[key] = { } }
+      end
+    end
+
+    class FakeConstant
+      def initialize(name)
+        @name = name.to_s
+      end
+
+      def to_s
+        @name
+      end
+    end
+
+    class ConfigurationError < RuntimeError
+      def initialize(message, line_number = nil)
+        message += " (line #{line_number})" if line_number
+        super(message)
+      end
+    end
+
+  end
+end

data/lib/torquebox/configure.rb

@@ -0,0 +1,31 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+#
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+require 'torquebox/configuration'
+
+module TorqueBox
+  CONFIGURATION_ROOT = '<root>'
+  
+  def self.configure(&block)
+    config = Thread.current[:torquebox_config]
+    entry_map = Thread.current[:torquebox_config_entry_map]
+    Configuration::Entry.new( CONFIGURATION_ROOT, config, entry_map, :allow_block => true ).
+      process( nil, &block )
+    config
+  end
+     
+end

data/lib/torquebox-configure.rb

@@ -0,0 +1,13 @@
+module TorqueboxConfigure
+  VERSION = '2.0.0.beta1'
+  MAVEN_VERSION = '2.0.0.beta1'
+end
+begin
+  require 'java'
+  require File.dirname(__FILE__) + '/torquebox-configure.jar'
+rescue LoadError
+  puts 'JAR-based gems require JRuby to load. Please visit www.jruby.org.'
+  raise
+end
+
+load File.dirname(__FILE__) + '/gem_hook.rb' if File.exists?( File.dirname(__FILE__) + '/gem_hook.rb')