torquebox-cache 2.0.0.beta1-java

data/lib/cache_listener.rb

@@ -0,0 +1,46 @@
+# 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.
+
+module TorqueBox
+  module Infinispan
+    class CacheListener
+
+      def event_fired( event )
+        event_type = event.get_type.to_s.downcase
+        if respond_to? event_type
+          self.send( event_type, event )
+        else
+          puts "#{self.class.name}##{event_type} not implemented."
+        end
+      end
+
+      add_class_annotation( { org.infinispan.notifications.Listener => { } } )
+      add_method_signature( "event_fired", [java.lang.Void::TYPE, org.infinispan.notifications.cachelistener.event.Event] )
+      add_method_annotation( "event_fired", 
+                            { org.infinispan.notifications.cachelistener.annotation.CacheEntryCreated    => {},
+                              org.infinispan.notifications.cachelistener.annotation.CacheEntryRemoved    => {},
+                              org.infinispan.notifications.cachelistener.annotation.CacheEntryModified   => {},
+                              org.infinispan.notifications.cachelistener.annotation.CacheEntryEvicted    => {},
+                              org.infinispan.notifications.cachelistener.annotation.CacheEntryActivated  => {},
+                              org.infinispan.notifications.cachelistener.annotation.CacheEntryEvicted    => {},
+                              org.infinispan.notifications.cachelistener.annotation.CacheEntryVisited    => {}})
+      become_java!
+    end
+  end
+end
+
+

data/lib/datamapper/dm-infinispan-adapter.rb

@@ -0,0 +1,128 @@
+#
+# Copyright 2011 Red Hat, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+require "digest/sha1"
+require 'dm-core'
+require 'cache'
+require 'json'
+require 'torquebox-cache' # is this needed?
+require 'datamapper/model'
+require 'datamapper/search'
+
+
+module DataMapper::Adapters
+
+  class InfinispanAdapter < AbstractAdapter
+
+    include TorqueBox::Infinispan
+
+    DataMapper::Model.append_inclusions( Infinispan::Model )
+
+    def initialize( name, options )
+      super
+      @options            = options.dup
+      @metadata           = @options.dup
+      @options[:name]     = name.to_s
+      @options[:index]    = true
+      @metadata[:name]    = name.to_s + "/metadata"
+      @cache              = Cache.new( @options )
+      @metadata_cache     = Cache.new( @metadata )
+      @search             = Infinispan::Search.new(cache, lambda{ |v| self.deserialize(v) })
+    end
+
+
+    def create( resources )
+      cache.transaction do
+        resources.each do |resource|
+          initialize_serial( resource, @metadata_cache.increment( index_for( resource ) ) )
+          cache.put( key( resource ), serialize( resource ) ) 
+        end
+      end
+    end
+
+    def read( query )
+      records = []
+      query.filter_records(@search.search( query ))
+    end
+
+    def update( attributes, collection )
+      attributes = attributes_as_fields(attributes)
+      cache.transaction do
+        collection.each do |resource|
+          resource.attributes(:field).merge(attributes)
+          cache.put( key(resource), serialize(resource) )
+        end
+      end
+    end
+
+    def delete( collection )
+      cache.transaction do
+        collection.each do |resource|
+          cache.remove( key(resource) )
+        end
+      end
+    end
+
+    def stop
+      cache.stop
+    end
+
+    def serialize(resource)
+      resource.is_a?(DataMapper::Resource) ? resource : resource.to_json
+    end
+
+    def deserialize(value)
+      value.is_a?(String) ? JSON.parse(value) : value
+    end
+
+    def search_manager
+      @search.search_manager
+    end
+
+    private
+    def cache
+      @cache
+    end
+
+    def metadata_cache
+      @metadata_cache
+    end
+
+    def next_id(resource)
+      Digest::SHA1.hexdigest(Time.now.to_i + rand(1000000000).to_s)[1..length].to_i
+    end
+
+    def key( resource )
+      model = resource.model
+      key = resource.key.nil? ? '' : resource.key.join('/')
+      "#{model}/#{key}/#{resource.id}"
+    end      
+    
+    def index_for( resource )
+      resource.model.name + ".index"
+    end
+
+    def all_records
+      records = []
+      cache.keys.each do |key|
+        value = cache.get(key)
+        records << deserialize(value) if value
+      end
+      records
+    end
+
+  end
+end
+

data/lib/datamapper/model.rb

@@ -0,0 +1,185 @@
+#
+# Copyright 2011 Red Hat, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+require 'dm-serializer'
+require 'jruby/core_ext'
+require 'json'
+
+
+module Infinispan
+  JVoid   = java.lang.Void::TYPE
+  
+  module Model
+
+    # TODO enhance TYPEs list
+    TYPES = {
+      ::String                         => java.lang.String,
+      ::Integer                        => java.lang.Integer,
+      ::Float                          => java.lang.Double,
+      ::BigDecimal                     => java.math.BigDecimal,
+      ::Date                           => java.util.Date,
+      ::DateTime                       => java.util.Date,
+      ::Time                           => java.util.Date,
+      ::TrueClass                      => java.lang.Boolean
+    }
+
+    def self.included(model)
+      model.extend(ClassMethods)
+      include java.io.Serializable
+
+      unless model.mapped? model.name
+        [:auto_migrate!, :auto_upgrade!, :create, :all, :copy, :first, :first_or_create, :first_or_new, :get, :last, :load].each do |method|
+          model.before_class_method(method, :configure_index)
+        end
+
+        [:save, :update, :destroy, :update_attributes].each do |method|
+          model.before(method) { model.configure_index }
+        end
+      end
+    end
+
+    def deserialize_to
+      self.class.name
+    end
+
+    def is_a_with_hack?( thing )
+      thing == java.lang.Object || is_a_without_hack?( thing )
+    end
+
+    alias_method :is_a_without_hack?, :is_a?
+    alias_method :is_a?, :is_a_with_hack?
+
+    module ClassMethods
+
+      @@mapped = {}
+
+      def auto_upgrade!
+        configure_index
+      end
+
+      def auto_migrate!
+        destroy
+        configure_index
+      end
+
+      def to_java_type(type)
+        TYPES[type] || self.to_java_type(type.primitive)
+      end
+
+      def mapped?( type )
+        @@mapped[type]
+      end
+
+      def configure_index
+        unless mapped?( name )
+          configure_index!
+        end
+      end
+
+      def configure_index!
+        TorqueBox::Infinispan::Cache.log( "Configuring dm-infinispan-adapter model #{name}" )
+        properties().each do |prop|
+          TorqueBox::Infinispan::Cache.log( "Adding property #{prop.inspect}" )
+          add_java_property(prop) 
+          TorqueBox::Infinispan::Cache.log( "Added property #{prop.inspect}" )
+        end
+
+        annotation = {
+          org.hibernate.search.annotations.Indexed => {},
+          org.hibernate.search.annotations.ProvidedId => {},
+          org.infinispan.marshall.SerializeWith => { "value" => org.torquebox.cache.marshalling.JsonExternalizer.java_class }
+        }
+
+        add_class_annotation( annotation )
+
+        # Wonder twin powers... ACTIVATE!
+        java_class = become_java!(false)
+
+        @@mapped[name] = true
+      end
+
+      def add_java_property(prop)
+        name = prop.name
+        type = prop.class
+
+        column_name = prop.field
+        annotation = {}
+
+        annotation[org.hibernate.search.annotations.Field] = {}
+
+        get_name = "get#{name.to_s.capitalize}"
+        set_name = "set#{name.to_s.capitalize}"
+
+        # TODO Time, Discriminator, EmbededValue
+        # to consider: in mu opinion those methods should set from/get to java objects...
+        if (type == DataMapper::Property::Date)
+          class_eval <<-EOT
+            def  #{set_name.intern} (d)
+              attribute_set(:#{name} , d.nil? ? nil : Date.civil(d.year + 1900, d.month + 1, d.date))
+            end
+          EOT
+          class_eval <<-EOT
+            def  #{get_name.intern}
+              d = attribute_get(:#{name} )
+              java.util.Date.new( (Time.mktime(d.year, d.month, d.day).to_i * 1000) ) if d
+            end
+          EOT
+        elsif (type == DataMapper::Property::DateTime)
+          class_eval <<-EOT
+            def  #{set_name.intern} (d)
+              attribute_set(:#{name} , d.nil? ? nil : DateTime.civil(d.year + 1900, d.month + 1, d.date, d.hours, d.minutes, d.seconds))
+            end
+          EOT
+          class_eval <<-EOT
+            def  #{get_name.intern}
+              d = attribute_get(:#{name} )
+              java.util.Date.new( (Time.mktime(d.year, d.month, d.day, d.hour, d.min, d.sec, 0).to_i * 1000) ) if d
+            end
+          EOT
+        elsif (type.to_s == BigDecimal || type == DataMapper::Property::Decimal)
+          class_eval <<-EOT
+            def  #{set_name.intern} (d)
+              attribute_set(:#{name} , d.nil? ? nil :#{type}.new(d.to_s))
+            end
+          EOT
+          class_eval <<-EOT
+            def  #{get_name.intern}
+              d = attribute_get(:#{name} )
+              java.math.BigDecimal.new(d.to_i) if d
+            end
+          EOT
+        else
+          class_eval <<-EOT
+            def  #{set_name.intern} (d)
+              attribute_set(:#{name} , d)
+            end
+          EOT
+          class_eval <<-EOT
+            def  #{get_name.intern}
+              d = attribute_get(:#{name} )
+              d
+            end
+          EOT
+        end
+
+        mapped_type = to_java_type(type)
+        add_method_signature get_name, [mapped_type]
+        add_method_annotation get_name, annotation
+        add_method_signature set_name, [JVoid, mapped_type]
+      end
+    end
+
+  end
+end

data/lib/datamapper/search.rb

@@ -0,0 +1,145 @@
+#
+# Copyright 2011 Red Hat, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Infinispan
+
+  class Search
+
+    def initialize(cache, deserializer)
+      @cache          = cache
+      @deserializer   = deserializer
+      begin
+        @search_manager = cache.search_manager
+      rescue Exception => e
+        cache.log( "Infinispan SearchManager not available for cache: #{cache.name}", 'ERROR' )
+        cache.log( e.message, 'ERROR' )
+      end
+    end
+
+    def search( query )
+      if @search_manager
+        cache_query = search_manager.get_query( build_query( query ), query.model.java_class )
+        cache_query.list.collect { |record| deserialize(record) }
+      else
+        cache.all.select do |r| 
+          record = deserialize(r) 
+          record.class == query.model
+        end
+      end
+    end
+
+    def search_manager
+      @search_manager
+    end
+
+    private
+    def build_query( query )
+      builder = search_manager.build_query_builder_for_class( query.model.java_class ).get
+      query = query.conditions.nil? ? builder.all.create_query : handle_condition( builder, query.conditions.first ) 
+      #puts "LUCENE QUERY: #{query.to_s}"
+      query
+    end
+
+    def handle_condition( builder, condition )
+      #puts "CONDITION: #{condition.inspect} <<<>>> #{condition}"
+      #puts "CONDITION CLASS: #{condition.class}"
+      #puts "CONDITION OPERANDS: #{condition.operands.inspect}" if condition.respond_to? :operands
+      #puts "CONDITION VALUE: #{condition.value}"
+      #puts "CONDITION SUBJECT: #{condition.subject.inspect}"
+      if condition.class == DataMapper::Query::Conditions::OrOperation
+        terms = condition.operands.each do |op|
+          builder.bool.should( handle_condition( builder, op ) )
+        end
+        builder.all.create_query
+      elsif condition.class == DataMapper::Query::Conditions::NotOperation
+        handle_not_operation( builder, condition )
+      elsif condition.class == DataMapper::Query::Conditions::EqualToComparison
+        handle_equal_to( builder, condition ) 
+      elsif condition.class == DataMapper::Query::Conditions::InclusionComparison
+        handle_inclusion( builder, condition )
+      elsif condition.class == DataMapper::Query::Conditions::RegexpComparison
+        handle_regex( builder, condition )
+      else
+        builder.all.create_query
+      end
+    end
+
+    def handle_regex( builder, condition )
+      field = condition.subject.name
+      # TODO Figure out how hibernate search/lucene deal with regexp
+      value = condition.value.nil? ? "?*" : "*" + condition.value.source.gsub('/','') + "*"
+      builder.keyword.wildcard.on_field(field).matching(value).create_query
+    end
+
+    def handle_inclusion( builder, condition )
+      #puts "RANGE: #{condition.value.class} #{condition.value}"
+      if condition.value.is_a? Range
+        # TODO: Deal with Time
+        if ((condition.subject.class == DataMapper::Property::DateTime) || 
+           (condition.subject.class == DataMapper::Property::Date))
+          rng = builder.range.on_field(condition.subject.name).from(convert_date(condition.value.begin)).to(convert_date(condition.value.end))
+        else
+          rng = builder.range.on_field(condition.subject.name).from(condition.value.begin).to(condition.value.end)
+        end
+        condition.value.exclude_end? ? rng.exclude_limit.create_query : rng.create_query 
+      else # an Array
+        match = condition.value.collect { |v| v }.join(' ')
+        if match.empty?
+          # we should find nothing
+          builder.bool.must( builder.all.create_query ).not.create_query
+        else
+          builder.keyword.on_field( condition.subject.name ).matching( match ).create_query 
+        end
+      end
+    end
+
+    def convert_date(date)
+      java.util.Date.new(Time.mktime(date.year, date.month, date.day, date.hour, date.min, date.sec, 0).to_i*1000) if date
+    end
+
+    def handle_equal_to( builder, condition )
+      field = condition.subject.name
+      value = condition.value.nil? ? "?*" : condition.value.to_s
+      if !value.nil? && (value.include?( '?' ) || value.include?( '*' ))
+        builder.keyword.wildcard.on_field(field).matching(value).create_query
+      else
+        builder.keyword.on_field(field).matching(value).create_query
+      end
+    end
+
+    def handle_not_operation( builder, operation )
+      condition = operation.operands.first
+      if (condition.class == DataMapper::Query::Conditions::EqualToComparison && condition.value.nil?) 
+        # not nil means everything
+        everything = DataMapper::Query::Conditions::EqualToComparison.new( condition.subject, '*' )
+        handle_condition( builder, everything )
+      else
+        builder.bool.must( handle_condition( builder, condition ) ).not.create_query
+      end
+    end
+
+    def cache
+      @cache
+    end
+
+    def deserialize(value)
+      @deserializer.call(value)
+    end
+
+  end
+end
+
+