norikra 0.0.1-java

data/lib/norikra/typedef_manager.rb

@@ -0,0 +1,91 @@
+require 'digest'
+
+require 'norikra/typedef'
+
+module Norikra
+  class TypedefManager
+    attr_reader :typedefs
+
+    def initialize(opts={})
+      @typedefs = {} # {target => Typedef}
+      @mutex = Mutex.new
+    end
+
+    def field_list(target)
+      @typedefs[target].fields.values.sort{|a,b| a.name <=> b.name}.map(&:to_hash)
+    end
+
+    def add_target(target, fields)
+      # fields nil => lazy
+      # fields {'fieldname' => 'type'}
+      @mutex.synchronize do
+        raise RuntimeError, "target #{target} already exists" if @typedefs[target]
+        @typedefs[target] = Typedef.new(fields)
+      end
+    end
+
+    def lazy?(target)
+      @typedefs[target].lazy?
+    end
+
+    def activate(target, fieldset)
+      @typedefs[target].activate(fieldset)
+    end
+
+    def reserve(target, field, type)
+      @typedefs[target].reserve(field, type)
+    end
+
+    def fields_defined?(target, field_name_list)
+      @typedefs[target].field_defined?(field_name_list)
+    end
+
+    def bind_fieldset(target, level, fieldset)
+      fieldset.bind(target, level)
+      @typedefs[target].push(level, 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)
+      guessed
+    end
+
+    def generate_query_fieldset(target, field_name_list)
+      # all fields of field_name_list should exists in definitions of typedef fields
+      # for this premise, call 'bind_fieldset' for data fieldset before this method.
+      required_fields = {}
+      @mutex.synchronize do
+        @typedefs[target].fields.each do |fieldname, field|
+          if field_name_list.include?(fieldname) || !(field.optional?)
+            required_fields[fieldname] = {:type => field.type, :optional => field.optional}
+          end
+        end
+      end
+      Norikra::FieldSet.new(required_fields)
+    end
+
+    def base_fieldset(target)
+      @typedefs[target].baseset
+    end
+
+    def subsets(target, fieldset) # for data fieldset
+      sets = []
+      @mutex.synchronize do
+        @typedefs[target].queryfieldsets.each do |set|
+          sets.push(set) if set.subset?(fieldset)
+        end
+        sets.push(@typedefs[target].baseset)
+      end
+      sets
+    end
+
+    def refer(target, event)
+      @typedefs[target].refer(event)
+    end
+
+    def format(target, event)
+      @typedefs[target].format(event)
+    end
+  end
+end

data/lib/norikra/version.rb

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

data/norikra.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'norikra/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "norikra"
+  spec.version       = Norikra::VERSION
+  spec.authors       = ["TAGOMORI Satoshi"]
+  spec.email         = ["tagomoris@gmail.com"]
+  spec.summary       = %q{CEP engine/server with Esper and JRuby}
+  spec.description   = %q{CEP: Complex Event Processor with Esper EPL qeury language, messagepack rpc for inbound event data}
+  spec.homepage      = "https://github.com/tagomoris/norikra"
+  spec.license       = "GPLv2"
+  spec.platform      = "java"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib", "esper"]
+
+  spec.add_runtime_dependency "mizuno", "~> 0.6"
+  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_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.0"
+  spec.add_development_dependency "spork"
+  spec.add_development_dependency "pry"
+end

data/script/spec_server_pry

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'drb'
+require 'pry'
+
+begin
+  begin
+    DRb.start_service("druby://localhost:0")
+  rescue SocketError, Errno::EADDRNOTAVAIL
+    DRb.start_service("druby://:0")
+  end
+  $spec_server = DRbObject.new_with_uri("druby://127.0.0.1:8989")
+rescue DRb::DRbConnError
+  err.puts "No DRb server is running. Running in local process instead ..."
+end
+
+def rspec(file=nil)
+  if file
+    $spec_server.run(["--color", "--format", "s", file], STDERR, STDOUT)
+  else
+    $spec_server.run(["--color", 'spec'], STDERR, STDOUT)
+  end
+end
+
+puts <<DESC
+
+Example:
+  > rspec 'spec/xxx_spec.rb'
+  or (for all tests)
+  > rspec
+
+DESC
+
+$LOAD_PATH.push './lib'
+$LOAD_PATH.push './esper'
+
+require 'norikra'
+
+require 'java'
+require 'esper-4.9.0.jar'
+require 'esper/lib/commons-logging-1.1.1.jar'
+require 'esper/lib/antlr-runtime-3.2.jar'
+require 'esper/lib/cglib-nodep-2.2.jar'
+
+Pry.start

data/spec/field_spec.rb

@@ -0,0 +1,141 @@
+require_relative './spec_helper'
+
+require 'norikra/typedef'
+
+require 'json'
+require 'digest'
+
+describe Norikra::Field do
+  describe '.valid_type?' do
+    it 'returns normalized type strings' do
+      expect(Norikra::Field.valid_type?('String')).to eql('string')
+      expect(Norikra::Field.valid_type?('STRING')).to eql('string')
+      expect(Norikra::Field.valid_type?(:string)).to eql('string')
+      expect(Norikra::Field.valid_type?('string')).to eql('string')
+
+      expect(Norikra::Field.valid_type?('boolean')).to eql('boolean')
+      expect(Norikra::Field.valid_type?('BOOLEAN')).to eql('boolean')
+      expect(Norikra::Field.valid_type?('Int')).to eql('int')
+      expect(Norikra::Field.valid_type?('lonG')).to eql('long')
+      expect(Norikra::Field.valid_type?('FLOAT')).to eql('float')
+      expect(Norikra::Field.valid_type?('Double')).to eql('double')
+    end
+
+    it 'raises ArgumentError for unknown type string' do
+      expect { Norikra::Field.valid_type?('foo') }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'when initialized' do
+    it 'value of field name is normalized to string' do
+      expect(Norikra::Field.new('foo', 'string').name).to be_instance_of String
+      expect(Norikra::Field.new(:foo, 'string').name).to be_instance_of String
+    end
+
+    it 'value of type is normalized with .valid_type?' do
+      expect(Norikra::Field.new('foo', 'String').type).to eql(Norikra::Field.valid_type?('String'))
+    end
+
+    it 'default value of optional is nil' do
+      expect(Norikra::Field.new(:foo, 'String').optional).to be_nil
+    end
+  end
+
+  context 'has non-nil value for optional' do
+    describe '#dup' do
+      context 'without values' do
+        it 'saves original boolean value' do
+          f = Norikra::Field.new('foo', 'string', false)
+          expect(f.dup.optional).to eql(false)
+
+          f = Norikra::Field.new('foo', 'int', true)
+          expect(f.dup.optional).to eql(true)
+        end
+      end
+
+      context 'with value' do
+        it 'will be overwritten with specified value' do
+          f = Norikra::Field.new('bar', 'float', false)
+          expect(f.dup(true).optional).to eql(true)
+
+          f = Norikra::Field.new('bar', 'double', true)
+          expect(f.dup(false).optional).to eql(false)
+        end
+      end
+    end
+  end
+
+  context 'defined as string field' do
+    describe '#format' do
+      it 'converts specified value as string' do
+        f = Norikra::Field.new('x', 'string')
+        expect(f.format('foo bar')).to eql('foo bar')
+        expect(f.format('foo bar'.to_sym)).to eql('foo bar')
+        expect(f.format(500)).to eql('500')
+        expect(f.format(' ')).to eql(' ')
+        expect(f.format(true)).to eql('true')
+        expect(f.format(false)).to eql('false')
+        expect(f.format(nil)).to eql('')
+        expect(f.format({})).to eql('{}')
+        expect(f.format([])).to eql('[]')
+      end
+    end
+  end
+
+  context 'defined as boolean' do
+    describe '#format' do
+      it 'converts specified value as boolean' do
+        f = Norikra::Field.new('x', 'boolean')
+        expect(f.format(true)).to eql(true)
+        expect(f.format(false)).to eql(false)
+        expect(f.format(nil)).to eql(false)
+        expect(f.format('')).to eql(true)
+
+        expect(f.format('true')).to eql(true)
+        expect(f.format('false')).to eql(false)
+      end
+    end
+  end
+
+  context 'defined as numeric value (int/long/float/double)' do
+    describe '#format' do
+      it 'convertes specified value as numeric' do
+        f = Norikra::Field.new('x', 'int')
+        expect(f.format('1')).to eql(1)
+        expect(f.format('1.0')).to eql(1)
+        expect(f.format('0.1')).to eql(0)
+        expect(f.format('.1')).to eql(0)
+        expect(f.format('')).to eql(0)
+        expect(f.format(' ')).to eql(0)
+        expect(f.format(nil)).to eql(0)
+
+        f = Norikra::Field.new('x', 'long')
+        expect(f.format('1')).to eql(1)
+        expect(f.format('1.0')).to eql(1)
+        expect(f.format('0.1')).to eql(0)
+        expect(f.format('.1')).to eql(0)
+        expect(f.format('')).to eql(0)
+        expect(f.format(' ')).to eql(0)
+        expect(f.format(nil)).to eql(0)
+
+        f = Norikra::Field.new('x', 'float')
+        expect(f.format('1')).to eql(1.0)
+        expect(f.format('1.0')).to eql(1.0)
+        expect(f.format('0.1')).to eql(0.1)
+        expect(f.format('.1')).to eql(0.1)
+        expect(f.format('')).to eql(0.0)
+        expect(f.format(' ')).to eql(0.0)
+        expect(f.format(nil)).to eql(0.0)
+
+        f = Norikra::Field.new('x', 'double')
+        expect(f.format('1')).to eql(1.0)
+        expect(f.format('1.0')).to eql(1.0)
+        expect(f.format('0.1')).to eql(0.1)
+        expect(f.format('.1')).to eql(0.1)
+        expect(f.format('')).to eql(0.0)
+        expect(f.format(' ')).to eql(0.0)
+        expect(f.format(nil)).to eql(0.0)
+      end
+    end
+  end
+end

data/spec/fieldset_spec.rb

@@ -0,0 +1,172 @@
+require_relative './spec_helper'
+
+require 'norikra/typedef'
+
+require 'json'
+require 'digest'
+
+describe Norikra::FieldSet do
+  describe '.simple_guess' do
+    it 'can guess field definitions with class of values' do
+      t = Norikra::FieldSet.simple_guess({'key1' => true, 'key2' => false, 'key3' => 10, 'key4' => 3.1415, 'key5' => 'foobar'})
+      r = t.definition
+      expect(r['key1']).to eql('boolean')
+      expect(r['key2']).to eql('boolean')
+      expect(r['key3']).to eql('long')
+      expect(r['key4']).to eql('double')
+      expect(r['key5']).to eql('string')
+    end
+
+    it 'does not guess with content of string values' do
+      t = Norikra::FieldSet.simple_guess({'key1' => 'TRUE', 'key2' => 'false', 'key3' => "10", 'key4' => '3.1415', 'key5' => {:a => 1}})
+      r = t.definition
+      expect(r['key1']).to eql('string')
+      expect(r['key2']).to eql('string')
+      expect(r['key3']).to eql('string')
+      expect(r['key4']).to eql('string')
+      expect(r['key5']).to eql('string')
+    end
+  end
+
+  describe 'can be initialized with both of Hash parameter and String' do
+    it 'accepts String as type' do
+      set = Norikra::FieldSet.new({'x' => 'string', 'y' => 'long'})
+      expect(set.fields['x'].type).to eql('string')
+      expect(set.fields['y'].type).to eql('long')
+    end
+
+    it 'sets optional specification nil as defaults' do
+      set = Norikra::FieldSet.new({'x' => 'string', 'y' => 'long'})
+      expect(set.fields['x'].optional).to be_nil
+      expect(set.fields['y'].optional).to be_nil
+    end
+
+    it 'accepts second argument as optional specification' do
+      set = Norikra::FieldSet.new({'x' => 'string', 'y' => 'long'}, false)
+      expect(set.fields['x'].optional?).to be_false
+      expect(set.fields['y'].optional?).to be_false
+
+      set = Norikra::FieldSet.new({'x' => 'string', 'y' => 'long'}, true)
+      expect(set.fields['x'].optional?).to be_true
+      expect(set.fields['y'].optional?).to be_true
+    end
+
+    it 'sets summary as comma-separated labeled field-type string with sorted field order' do
+      set = Norikra::FieldSet.new({'x' => 'string', 'y' => 'long'})
+      expect(set.summary).to eql('x:string,y:long')
+
+      set = Norikra::FieldSet.new({'x' => 'string', 'y' => 'long', 'a' => 'Boolean'})
+      expect(set.summary).to eql('a:boolean,x:string,y:long')
+    end
+  end
+
+  context 'initialized with some fields' do
+    set = Norikra::FieldSet.new({'x' => 'string', 'y' => 'long', 'a' => 'Boolean'})
+
+    describe '#dup' do
+      it 'make duplicated object with different internal instance' do
+        x = set.dup
+        expect(x.fields.object_id).not_to eql(set.fields.object_id)
+        expect(x.fields).to eq(set.fields)
+      end
+    end
+
+    describe '#field_names_key' do
+      it 'returns comman-separeted sorted field names' do
+        expect(set.field_names_key).to eql('a,x,y')
+      end
+    end
+
+    describe '#udpate_summary' do
+      it 'changes summary with current @fields' do
+        x = set.dup
+        x.fields = set.fields.dup
+
+        oldsummary = x.summary
+
+        x.fields['x'] = Norikra::Field.new('x', 'int')
+
+        expect(x.summary).to eql(oldsummary)
+
+        x.update_summary
+
+        expect(x.summary).not_to eql(oldsummary)
+        expect(x.summary).to eql('a:boolean,x:int,y:long')
+      end
+    end
+
+    describe '#update' do
+      it 'changes field definition of this instance' do
+        x = set.dup
+        expect(x.fields['a'].type).to eql('boolean')
+        expect(x.fields['x'].type).to eql('string')
+
+        expect(x.fields['y'].type).to eql('long')
+        expect(x.fields['y'].optional).to be_nil
+
+        x.update([Norikra::Field.new('y', 'int'), Norikra::Field.new('a','string')], false)
+
+        expect(x.fields['y'].type).to eql('int')
+        expect(x.fields['y'].optional).to eql(false)
+
+        expect(x.fields['x'].type).to eql('string')
+        expect(x.fields['a'].type).to eql('string')
+      end
+
+      it 'adds field definition' do
+        x = set.dup
+        expect(x.fields.size).to eql(3)
+        x.update([Norikra::Field.new('z', 'string')], true)
+        expect(x.fields.size).to eql(4)
+        expect(x.summary).to eql('a:boolean,x:string,y:long,z:string')
+      end
+    end
+
+    describe '#definition' do
+      it 'returns hash instance of fieldname => esper type' do
+        d = set.definition
+        expect(d).to be_instance_of(Hash)
+        expect(d.size).to eql(3)
+        expect(d['a']).to eql('boolean')
+        expect(d['x']).to eql('string')
+        expect(d['y']).to eql('long')
+      end
+    end
+
+    describe '#subset?' do
+      it 'returns true when other instance has all fields of self' do
+        other = Norikra::FieldSet.new({'a' => 'boolean', 'x' => 'string'})
+        expect(set.subset?(other)).to be_false
+
+        other.update([Norikra::Field.new('y', 'long')], false)
+        expect(set.subset?(other)).to be_true
+
+        other.update([Norikra::Field.new('z', 'double')], false)
+        expect(set.subset?(other)).to be_true
+      end
+    end
+
+    describe '#bind' do
+      it 'sets event_type_name internally, and returns self' do
+        x = set.dup
+
+        expect(x.instance_eval{ @event_type_name }).to be_nil
+
+        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))
+      end
+    end
+
+    describe '#event_type_name' do
+      it 'returns duplicated string of @event_type_name' do
+        x = set.dup
+        x.bind('TargetExample', :query)
+        internal = x.instance_eval{ @event_type_name }
+        expect(x.event_type_name.object_id).not_to eql(internal.object_id)
+        expect(x.event_type_name).to eql(internal)
+      end
+    end
+  end
+end