norikra 0.0.1-java → 0.0.3-java

data/bin/norikra

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
 
 require 'pathname'
-lib = Pathname.new(__FILE__).dirname.join('..', 'lib').expand_path
-$LOAD_PATH.unshift lib.to_s
+libs = ['lib', 'esper'].map{|p| Pathname.new(__FILE__).dirname.join('..', p).expand_path}
+$LOAD_PATH.unshift(*libs.map(&:to_s))
 
 require 'norikra/cli'
 Norikra::CLI.start

data/lib/norikra/engine.rb

@@ -51,8 +51,8 @@ module Norikra
     end
 
     def register(query)
-      unless @targets.include?(query.target)
-        open(query.target) # open as lazy defined target
+      unless @targets.include?(query.targets.first)
+        open(query.targets.first) # open as lazy defined target
       end
       register_query(query)
     end
@@ -146,9 +146,10 @@ module Norikra
     end
 
     def register_query(query)
-      target = query.target
+      #TODO: support JOINs
+      target = query.targets.first
       @mutex.synchronize do
-        if @typedef_manager.lazy?(target) || @typedef_manager.fields_defined?(target, query.fields)
+        if @typedef_manager.lazy?(target) || !@typedef_manager.fields_defined?(target, query.fields)
           @waiting_queries[target] ||= []
           @waiting_queries[target].push(query)
         else
@@ -156,6 +157,14 @@ module Norikra
           @typedef_manager.bind_fieldset(target, :query, query_fieldset)
           register_fieldset_actually(target, query_fieldset, :query)
           register_query_actually(target, query_fieldset.event_type_name, query)
+
+          # replace registered data fieldsets with new fieldset inherits this query fieldset
+          @typedef_manager.supersets(target, query_fieldset).each do |set|
+            rebound = set.rebind
+            register_fieldset_actually(target, rebound, :data, true) # replacing
+            @typedef_manager.replace_fieldset(target, set, rebound)
+            remove_fieldset_actually(target, set, :data)
+          end
         end
         @queries.push(query)
       end
@@ -201,8 +210,8 @@ module Norikra
     end
 
     # this method should be protected with @mutex lock
-    def register_fieldset_actually(target, fieldset, level)
-      return if @registered_fieldsets[target][level][fieldset.summary]
+    def register_fieldset_actually(target, fieldset, level, replace=false)
+      return if level == :data && @registered_fieldsets[target][level][fieldset.summary] && !replace
 
       # Map Supertype (target) and Subtype (typedef name, like TARGET_TypeDefName)
       # http://esper.codehaus.org/esper-4.9.0/doc/reference/en-US/html/event_representation.html#eventrep-map-supertype
@@ -223,9 +232,20 @@ module Norikra
         @config.addEventType(fieldset.event_type_name, fieldset.definition, subset_names.to_java(:string))
         #TODO: debug log
         #p "addEventType target:#{target}, level:data, eventType:#{fieldset.event_type_name}, inherit:#{subset_names.join(',')}"
+
+        @registered_fieldsets[target][level][fieldset.summary] = fieldset
       end
-      @registered_fieldsets[target][level][fieldset.summary] = fieldset
       nil
     end
+
+    # this method should be protected with @mutex lock as same as register
+    def remove_fieldset_actually(target, fieldset, level)
+      return if level == :base || level == :query
+
+      # DON'T check @registered_fieldsets[target][level][fieldset.summary]
+      # removed fieldset should be already replaced with register_fieldset_actually w/ replace flag
+      #TODO: debug log
+      @config.removeEventType(fieldset.event_type_name, true)
+    end
   end
 end

data/lib/norikra/query.rb

@@ -12,7 +12,7 @@ module Norikra
       @name = param[:name]
       @expression = param[:expression]
       @ast = nil
-      @target = nil
+      @targets = nil
       @fields = nil
     end
 
@@ -21,29 +21,30 @@ module Norikra
     end
 
     def dup_with_stream_name(actual_name)
-      target = self.target
+      first_target = self.targets.first
       query = self.dup
-      query.expression = self.expression.gsub(/(\s[Ff][Rr][Oo][Mm]\s+)#{target}(\.|\s)/, '\1' + actual_name + '\2')
-      if query.target != actual_name
+      query.expression = self.expression.gsub(/(\s[Ff][Rr][Oo][Mm]\s+)#{first_target}(\.|\s)/, '\1' + actual_name + '\2')
+      if query.targets.first != actual_name
         raise RuntimeError, 'failed to replace query target into stream name:' + self.expression
       end
       query
     end
 
     def to_hash
-      {'name' => @name, 'expression' => @expression, 'target' => self.target}
+      {'name' => @name, 'expression' => @expression, 'targets' => self.targets}
     end
 
-    def target
-      return @target if @target
-      #TODO: this code doesn't care JOINs.
-      @target = self.ast.find('STREAM_EXPR').find('EVENT_FILTER_EXPR').children.first.name
-      @target
+    def targets
+      return @targets if @targets
+      #TODO: test with JOINs.
+      @targets = self.ast.find('STREAM_EXPR').find('EVENT_FILTER_EXPR').children.map(&:name)
+      @targets
     end
 
     def fields
       return @fields if @fields
       #TODO: this code doesn't care JOINs.
+      ### fields -> {'target_name' => fields} ?
 
       # Norikra::Query.new(
       #   :name => 'hoge',

data/lib/norikra/typedef.rb

@@ -144,10 +144,14 @@ module Norikra
                when :query then 'q_'
                else 'e_'
                end
-      @event_type_name = prefix + Digest::MD5.hexdigest(target + "\t" + level.to_s + "\t" + @summary)
+      @event_type_name = prefix + Digest::MD5.hexdigest([target, level.to_s, self.object_id.to_s, @summary].join("\t"))
       self
     end
 
+    def rebind
+      self.dup.bind(@target, @level)
+    end
+
     def self.simple_guess(data, optional=true)
       mapping = Hash[
         data.map{|key,value|
@@ -279,6 +283,24 @@ module Norikra
       true
     end
 
+    def replace(level, old_fieldset, fieldset)
+      unless self.consistent?(fieldset)
+        raise ArgumentError, "inconsistent field set for this typedef"
+      end
+      if level != :data
+        raise ArgumentError, "invalid argument, fieldset replace should be called for :data"
+      end
+      if old_fieldset.field_names_key != fieldset.field_names_key
+        raise ArgumentError, "try to replace different field name sets"
+      end
+      @mutex.synchronize do
+        @datafieldsets.push(fieldset)
+        @set_map[fieldset.field_names_key] = fieldset
+        @datafieldsets.delete(old_fieldset)
+      end
+      true
+    end
+
     def refer(data)
       field_names_key = data.keys.sort.join(',')
       return @set_map[field_names_key] if @set_map.has_key?(field_names_key)

data/lib/norikra/typedef_manager.rb

@@ -45,6 +45,10 @@ module Norikra
       @typedefs[target].push(level, fieldset)
     end
 
+    def replace_fieldset(target, old_fieldset, new_fieldset)
+      @typedefs[target].replace(:data, old_fieldset, new_fieldset)
+    end
+
     def generate_base_fieldset(target, event)
       guessed = Norikra::FieldSet.simple_guess(event, false) # all fields are non-optional
       guessed.update(@typedefs[target].fields, false)
@@ -80,6 +84,16 @@ module Norikra
       sets
     end
 
+    def supersets(target, fieldset) # for query fieldset
+      sets = []
+      @mutex.synchronize do
+        @typedefs[target].datafieldsets.each do |set|
+          sets.push(set) if fieldset.subset?(set)
+        end
+      end
+      sets
+    end
+
     def refer(target, event)
       @typedefs[target].refer(event)
     end

data/lib/norikra/version.rb

@@ -1,3 +1,3 @@
 module Norikra
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/norikra.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "rack"
   spec.add_runtime_dependency "msgpack-rpc-over-http-jruby", ">= 0.0.5.jruby1"
   spec.add_runtime_dependency "thor"
-  spec.add_runtime_dependency "norikra-client-jruby"
+  spec.add_runtime_dependency "norikra-client-jruby", ">= 0.0.3"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"

data/spec/fieldset_spec.rb

@@ -155,7 +155,23 @@ describe Norikra::FieldSet do
         expect(x.bind('TargetExample', :query)).to eql(x)
 
         expect(x.instance_eval{ @event_type_name }).not_to be_nil
-        expect(x.instance_eval{ @event_type_name }).to eql('q_' + Digest::MD5.hexdigest("TargetExample\tquery\t" + x.summary))
+        expect(x.instance_eval{ @event_type_name }).to match(/q_[0-9a-f]{32}/) # MD5 hexdump
+      end
+    end
+
+    describe '#rebind' do
+      it 'returns duplicated object, but these event_type_name are same' do
+        x = set.dup
+        x.bind('TargetExample', :data)
+
+        y = x.rebind
+        expect(y.summary).to eql(x.summary)
+        expect(y.fields.values.map(&:to_hash)).to eql(x.fields.values.map(&:to_hash))
+        expect(y.target).to eql(x.target)
+        expect(y.level).to eql(x.level)
+        expect(y.field_names_key).to eql(x.field_names_key)
+
+        expect(y.event_type_name).not_to eql(x.event_type_name)
       end
     end
 

data/spec/query_spec.rb

@@ -12,7 +12,7 @@ describe Norikra::Query do
         ) }
         its(:name){ should == 'TestTable query1' }
         its(:expression){ should == expression }
-        its(:target){ should == 'TestTable' }
+        its(:targets){ should == ['TestTable'] }
         its(:fields){ should == ['param', 'path', 'size'] }
       end
       context 'with query including Static lib call'
@@ -22,7 +22,7 @@ describe Norikra::Query do
         ) }
         its(:name){ should == 'TestTable query1' }
         its(:expression){ should == expression }
-        its(:target){ should == 'TestTable' }
+        its(:targets){ should == ['TestTable'] }
         its(:fields){ should == ['path', 'size'] }
     end
     describe '#dup_with_stream_name' do

data/spec/typedef_manager_spec.rb

@@ -117,6 +117,24 @@ describe Norikra::TypedefManager do
       end
     end
 
+    describe '#supersets' do
+      it 'returns list of data fieldset, superset of specified fieldset, owned by manager for specified target' do
+        base = {'a'=>'string','b'=>'string','c'=>'double'}
+        set_x = Norikra::FieldSet.new(base.merge({'one'=>'int','two'=>'string','three'=>'double'}))
+        manager.bind_fieldset('sample', :data, set_x)
+        set_y = Norikra::FieldSet.new(base.merge({'one'=>'int','two'=>'string'}))
+        manager.bind_fieldset('sample', :data, set_y)
+        set_z = Norikra::FieldSet.new(base.merge({'one'=>'int','two'=>'string','three'=>'double','four'=>'boolean'}))
+        manager.bind_fieldset('sample', :data, set_z)
+
+        list = manager.supersets('sample', Norikra::FieldSet.new({'one'=>'int','three'=>'double'}))
+        expect(list.size).to eql(2) # set_x, set_z
+        expect(list.include?(set_x)).to be_true
+        expect(list.include?(set_y)).to be_false
+        expect(list.include?(set_z)).to be_true
+      end
+    end
+
     describe '#generate_query_fieldset' do
       it 'returns fieldset instance with all required(non-optional) fields of target, and fields of query requires' do
         r = manager.generate_query_fieldset('sample', ['a', 'b','f'])

data/spec/typedef_spec.rb

@@ -182,6 +182,30 @@ describe Norikra::Typedef do
       end
     end
 
+    describe '#replace' do
+      it 'raises error for different field name sets' do
+        t = Norikra::Typedef.new({'a'=>'string'})
+        set1 = Norikra::FieldSet.new({'a'=>'string','b'=>'int'})
+        set2 = Norikra::FieldSet.new({'a'=>'string','c'=>'int'})
+        t.push(:data, set1)
+        expect { t.replace(:data, set1, set2) }.to raise_error(ArgumentError)
+      end
+
+      it 'replaces typedef internal fieldset object for specified field_names_key' do
+        t = Norikra::Typedef.new({'a'=>'string'})
+        set1 = Norikra::FieldSet.new({'a'=>'string','b'=>'int'}).bind('x', :data)
+        t.push(:data, set1)
+        expect(t.instance_eval{ @set_map['a,b'].event_type_name }).to eql(set1.event_type_name)
+        expect(t.instance_eval{ @datafieldsets.size }).to eql(1)
+
+        set2 = set1.rebind
+        t.replace(:data, set1, set2)
+        expect(t.instance_eval{ @datafieldsets.size }).to eql(1)
+        expect(t.instance_eval{ @set_map['a,b'].event_type_name }).not_to eql(set1.event_type_name)
+        expect(t.instance_eval{ @set_map['a,b'].event_type_name }).to eql(set2.event_type_name)
+      end
+    end
+
     describe '#refer' do
       context 'for event defined by data-fieldset already known' do
         it 'returns fieldset that already known itself' do

metadata

@@ -2,14 +2,14 @@
 name: norikra
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.0.1
+  version: 0.0.3
 platform: java
 authors:
 - TAGOMORI Satoshi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-05-21 00:00:00.000000000 Z
+date: 2013-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mizuno
@@ -85,15 +85,13 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
+        version: 0.0.3
     none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
+        version: 0.0.3
     none: false
   prerelease: false
   type: :runtime